From 6184c2a9c04c97644405620dee8b97bf84b4a261 Mon Sep 17 00:00:00 2001 From: PASCALE NOYRET Date: Fri, 8 Dec 2023 11:58:44 +0100 Subject: [PATCH] on continue le nettoyae --- Accas/A_ASSD.py | 14 +- Accas/A_AU_MOINS_UN.py | 1 + Accas/A_AU_PLUS_UN.py | 5 +- Accas/A_AVANT.py | 1 + Accas/A_A_CLASSER.py | 5 +- Accas/A_BLOC.py | 1 + Accas/A_ENSEMBLE.py | 1 + Accas/A_EVAL.py | 2 + Accas/A_EXCLUS.py | 1 + Accas/A_FACT.py | 2 + Accas/A_FICHIER.py | 2 + Accas/A_FORM.py | 2 +- Accas/A_FORM_ETAPE.py | 7 +- Accas/A_JDC.py | 3 +- Accas/A_JDC_CATA.py | 3 +- Accas/A_JDC_CATA_SINGLETON.py | 9 +- Accas/A_MACRO.py | 2 +- Accas/A_MACRO_ETAPE.py | 11 +- Accas/A_MCBLOC.py | 12 +- Accas/A_MCFACT.py | 12 +- Accas/A_MCLIST.py | 2 +- Accas/A_MCSIMP.py | 7 +- Accas/A_MEME_NOMBRE.py | 2 +- Accas/A_OPER.py | 1 - Accas/A_PRESENT_ABSENT.py | 9 +- Accas/A_PRESENT_PRESENT.py | 8 +- Accas/A_PROC.py | 1 + Accas/A_PROC_ETAPE.py | 8 +- Accas/A_SALOME_ENTRY.py | 11 +- Accas/A_SENSIBILITE.py | 9 +- Accas/A_SIMP.py | 3 +- Accas/A_TUPLE.py | 3 +- Accas/A_UN_PARMI.py | 1 + Codes/ReacteurNumerique/cata_RN.py | 1034 ++++++ Codes/ReacteurNumerique/cata_RN_UQ.py | 76 + Codes/ReacteurNumerique/cata_UQ.py | 1555 +++++++++ Codes/ReacteurNumerique/lanceEficas.py | 40 + Codes/ReacteurNumerique/prefs.py | 22 + .../prefs_ReacteurNumerique.py | 53 + Efi2Xsd/ReadMe.txt | 7 - Extensions/CMakeLists.txt | 2 +- Noyau/CMakeLists.txt | 2 +- Noyau/N_ASSD.py | 139 +- Noyau/N_BLOC.py | 166 +- Noyau/N_CO.py | 15 +- Noyau/N_CONVERT.py | 77 +- Noyau/N_CR.py | 161 +- Noyau/N_ENTITE.py | 381 +- Noyau/N_ETAPE.py | 257 +- Noyau/N_Exception.py | 8 +- Noyau/N_FACT.py | 237 +- Noyau/N_FONCTION.py | 61 +- Noyau/N_FORM.py | 10 +- Noyau/N_FORM_ETAPE.py | 10 +- Noyau/N_GEOM.py | 28 +- Noyau/N_JDC.py | 375 +- Noyau/N_JDC_CATA.py | 159 +- Noyau/N_LASSD.py | 9 +- Noyau/N_MACRO.py | 138 +- Noyau/N_MACRO_ETAPE.py | 384 +- Noyau/N_MCBLOC.py | 67 +- Noyau/N_MCCOMPO.py | 382 +- Noyau/N_MCFACT.py | 68 +- Noyau/N_MCLIST.py | 115 +- Noyau/N_MCSIMP.py | 454 ++- Noyau/N_OBJECT.py | 173 +- Noyau/N_OPER.py | 128 +- Noyau/N_OPS.py | 10 +- Noyau/N_PROC.py | 133 +- Noyau/N_PROC_ETAPE.py | 60 +- Noyau/N_REGLE.py | 40 +- Noyau/N_SENSIBILITE.py | 122 +- Noyau/N_SIMP.py | 279 +- Noyau/N_TUPLE.py | 132 +- Noyau/N_UserASSD.py | 174 +- Noyau/N_UserASSDMultiple.py | 110 +- Noyau/N_VALIDATOR.py | 782 +++-- Noyau/N__F.py | 31 +- Noyau/N_types.py | 19 +- Noyau/N_utils.py | 100 +- Noyau/__init__.py | 25 +- Noyau/context.py | 25 +- Noyau/nommage.py | 75 +- Noyau/strfunc.py | 68 +- Traducteur/CMakeLists.txt | 2 +- Traducteur/__init__.py | 2 +- Traducteur/calcG.py | 2 +- Traducteur/changeValeur.py | 536 +-- Traducteur/dictErreurs.py | 157 +- Traducteur/inseremocle.py | 499 +-- Traducteur/load.py | 187 +- Traducteur/log.py | 28 +- Traducteur/mocles.py | 250 +- Traducteur/movemocle.py | 544 +-- Traducteur/parseur.py | 322 +- Traducteur/regles.py | 361 +- Traducteur/removemocle.py | 382 +- Traducteur/renamemocle.py | 361 +- Traducteur/traduitV10V11.py | 3091 ++++++++++++----- Traducteur/traduitV11V12.py | 1260 ++++--- Traducteur/traduitV7V8.py | 1275 +++++-- Traducteur/traduitV8V9.py | 857 +++-- Traducteur/traduitV9V10.py | 1826 ++++++---- Traducteur/utils.py | 20 +- Traducteur/visiteur.py | 78 +- Validation/CMakeLists.txt | 2 +- Validation/V_AU_MOINS_UN.py | 28 +- Validation/V_AU_PLUS_UN.py | 31 +- Validation/V_A_CLASSER.py | 63 +- Validation/V_ENSEMBLE.py | 35 +- Validation/V_ETAPE.py | 155 +- Validation/V_EXCLUS.py | 24 +- Validation/V_JDC.py | 35 +- Validation/V_MACRO_ETAPE.py | 100 +- Validation/V_MCBLOC.py | 33 +- Validation/V_MCCOMPO.py | 63 +- Validation/V_MCFACT.py | 45 +- Validation/V_MCLIST.py | 78 +- Validation/V_MCSIMP.py | 115 +- Validation/V_MEME_NOMBRE.py | 24 +- Validation/V_PRESENT_ABSENT.py | 41 +- Validation/V_PRESENT_PRESENT.py | 40 +- Validation/V_PROC_ETAPE.py | 38 +- Validation/V_UN_PARMI.py | 28 +- generator/CMakeLists.txt | 2 +- generator/Formatage.py | 410 ++- generator/__init__.py | 5 +- generator/generator_5CRequeteSelection.py | 110 + generator/generator_GroupMA.py | 70 +- generator/generator_TELEMAC.py | 562 +-- generator/generator_UQ.py | 1092 ++++++ generator/generator_XML.py | 126 +- generator/generator_aplat.py | 326 +- generator/generator_dico.py | 179 +- generator/generator_dicoImbrique.py | 175 +- generator/generator_modification.py | 56 +- generator/generator_python.py | 733 ++-- generator/incertainty_tools.py | 70 + generator/post_csv_rn.py | 167 + generator/textePersalys.py | 449 +++ 140 files changed, 18106 insertions(+), 8583 deletions(-) create mode 100755 Codes/ReacteurNumerique/cata_RN.py create mode 100755 Codes/ReacteurNumerique/cata_RN_UQ.py create mode 100755 Codes/ReacteurNumerique/cata_UQ.py create mode 100644 Codes/ReacteurNumerique/lanceEficas.py create mode 100755 Codes/ReacteurNumerique/prefs.py create mode 100755 Codes/ReacteurNumerique/prefs_ReacteurNumerique.py delete mode 100644 Efi2Xsd/ReadMe.txt create mode 100644 generator/generator_5CRequeteSelection.py create mode 100755 generator/generator_UQ.py create mode 100755 generator/incertainty_tools.py create mode 100755 generator/post_csv_rn.py create mode 100755 generator/textePersalys.py diff --git a/Accas/A_ASSD.py b/Accas/A_ASSD.py index 441e2043..5ef8595c 100644 --- a/Accas/A_ASSD.py +++ b/Accas/A_ASSD.py @@ -37,45 +37,57 @@ from Noyau import N_UserASSDMultiple class ASSD(I_ASSD.ASSD, N_ASSD.ASSD): pass + # class LASSD(I_LASSD.LASSD,N_LASSD.LASSD):pass class LASSD(I_LASSD.LASSD): pass + class UserASSD(N_UserASSD.UserASSD, ASSD): pass + class UserASSDMultiple(N_UserASSDMultiple.UserASSDMultiple, UserASSD): pass + class assd(N_ASSD.assd, I_ASSD.assd, ASSD): pass + class FONCTION(N_FONCTION.FONCTION, I_FONCTION.FONCTION, ASSD): def __init__(self, etape=None, sd=None, reg="oui"): N_FONCTION.FONCTION.__init__(self, etape=etape, sd=sd, reg=reg) I_FONCTION.FONCTION.__init__(self, etape=etape, sd=sd, reg=reg) + class formule(I_FONCTION.formule, N_FONCTION.formule, ASSD): def __init__(self, etape=None, sd=None, reg="oui"): N_FONCTION.formule.__init__(self, etape=etape, sd=sd, reg=reg) I_FONCTION.formule.__init__(self, etape=etape, sd=sd, reg=reg) + class formule_c(formule): pass + # On conserve fonction (ceinture et bretelles) # fonction n'existe plus dans N_FONCTION on le remplace par formule class fonction(N_FONCTION.formule, I_FONCTION.fonction, ASSD): - """ obsolete class : use formule instead""" + """obsolete class : use formule instead""" + def __init__(self, etape=None, sd=None, reg="oui"): N_FONCTION.formule.__init__(self, etape=etape, sd=sd, reg=reg) I_FONCTION.fonction.__init__(self, etape=etape, sd=sd, reg=reg) + class GEOM(N_GEOM.GEOM, I_ASSD.GEOM, ASSD): pass + class geom(N_GEOM.geom, I_ASSD.geom, ASSD): pass + class CO(N_CO.CO, I_ASSD.CO, ASSD): pass diff --git a/Accas/A_AU_MOINS_UN.py b/Accas/A_AU_MOINS_UN.py index e68be303..32c4df6c 100644 --- a/Accas/A_AU_MOINS_UN.py +++ b/Accas/A_AU_MOINS_UN.py @@ -27,4 +27,5 @@ class AU_MOINS_UN(V_AU_MOINS_UN.AU_MOINS_UN, I_REGLE.REGLE, N_REGLE.REGLE): Accas class for catalog rule AU_MOINS_UN __init__ is in N_REGLE.REGLE """ + pass diff --git a/Accas/A_AU_PLUS_UN.py b/Accas/A_AU_PLUS_UN.py index 70295f74..d22b559d 100644 --- a/Accas/A_AU_PLUS_UN.py +++ b/Accas/A_AU_PLUS_UN.py @@ -24,7 +24,8 @@ from Ihm import I_REGLE class AU_PLUS_UN(V_AU_PLUS_UN.AU_PLUS_UN, I_REGLE.REGLE, N_REGLE.REGLE): """ - Accas class for catalog rule AU_PLUS_UN - class instantiation automatically invokes REGLE.__init__() + Accas class for catalog rule AU_PLUS_UN + class instantiation automatically invokes REGLE.__init__() """ + pass diff --git a/Accas/A_AVANT.py b/Accas/A_AVANT.py index 9c1525c4..6f60223f 100644 --- a/Accas/A_AVANT.py +++ b/Accas/A_AVANT.py @@ -26,4 +26,5 @@ class AVANT(I_AVANT.I_AVANT, I_REGLE.REGLE, N_REGLE.REGLE): Accas class for catalog rule AVANT class instantiation automatically invokes REGLE.__init__() """ + pass diff --git a/Accas/A_A_CLASSER.py b/Accas/A_A_CLASSER.py index c8c82960..a19e28e6 100644 --- a/Accas/A_A_CLASSER.py +++ b/Accas/A_A_CLASSER.py @@ -24,10 +24,11 @@ from Ihm import I_A_CLASSER class A_CLASSER(V_A_CLASSER.A_CLASSER, N_REGLE.REGLE, I_A_CLASSER.A_CLASSER): """ - Accas class for catalog rule A_CLASSER + Accas class for catalog rule A_CLASSER It is absolutely necessary that V_A_CLASSER be first in the inheritance """ - # to do --> prevoir un X_A_CLASSER pour la projection XSD + + # to do --> prevoir un X_A_CLASSER pour la projection XSD # Est-ce possible en 1ere passe ou faut-il modifier pendant une 2nd passe ? # ajouter une methode dump a tous les objets ? pass diff --git a/Accas/A_BLOC.py b/Accas/A_BLOC.py index 13cbbaa6..39946ca9 100644 --- a/Accas/A_BLOC.py +++ b/Accas/A_BLOC.py @@ -27,6 +27,7 @@ class BLOC(N_BLOC.BLOC, X_BLOC, I_ENTITE.ENTITE): """ Accas class for catalog definition keyword BLOC """ + class_instance = A_MCBLOC.MCBLOC def __init__(self, *tup, **args): diff --git a/Accas/A_ENSEMBLE.py b/Accas/A_ENSEMBLE.py index c0a66c28..995b10eb 100644 --- a/Accas/A_ENSEMBLE.py +++ b/Accas/A_ENSEMBLE.py @@ -27,4 +27,5 @@ class ENSEMBLE(I_REGLE.REGLE, V_ENSEMBLE.ENSEMBLE, N_REGLE.REGLE): Accas class for catalog rule ENSEMBLE class instantiation automatically invokes REGLE.__init__() """ + pass diff --git a/Accas/A_EVAL.py b/Accas/A_EVAL.py index 428c467f..1769285e 100644 --- a/Accas/A_EVAL.py +++ b/Accas/A_EVAL.py @@ -19,9 +19,11 @@ # from Ihm import I_EVAL + class EVAL(I_EVAL.EVAL): """ class used to evaluate parameter """ + def __init__(self, str): I_EVAL.EVAL.__init__(self, str) diff --git a/Accas/A_EXCLUS.py b/Accas/A_EXCLUS.py index a144986f..e5d56ee9 100644 --- a/Accas/A_EXCLUS.py +++ b/Accas/A_EXCLUS.py @@ -27,4 +27,5 @@ class EXCLUS(I_EXCLUS.EXCLUS, V_EXCLUS.EXCLUS, N_REGLE.REGLE): Accas class for catalog rule EXCLUS class instantiation automatically invokes REGLE.__init__() """ + pass diff --git a/Accas/A_FACT.py b/Accas/A_FACT.py index b865eac3..8a18cfd4 100644 --- a/Accas/A_FACT.py +++ b/Accas/A_FACT.py @@ -28,6 +28,7 @@ class FACT(N_FACT.FACT, X_FACT, I_ENTITE.ENTITE): """ Accas class for catalog definition keyword FACT """ + class_instance = A_MCFACT.MCFACT list_instance = A_MCLIST.MCList @@ -39,6 +40,7 @@ class FACT(N_FACT.FACT, X_FACT, I_ENTITE.ENTITE): from Noyau import N_OBJECT from Ihm import I_OBJECT + class ErrorObj(I_OBJECT.ErrorObj, N_OBJECT.ErrorObj): pass diff --git a/Accas/A_FICHIER.py b/Accas/A_FICHIER.py index e17f496d..cd889c11 100644 --- a/Accas/A_FICHIER.py +++ b/Accas/A_FICHIER.py @@ -26,6 +26,8 @@ class Fichier(I_FICHIER.Fichier): (defined in Salome EFICAS module) when Eficas is launched in Salome context. It handles the objects that can be selected from Salome object browser. """ + def __init__(self, *tup, **args): I_FICHIER.FICHIER.__init__(self, *tup, **args) + # To do --> a travailler pour ajouter tous les types de fichier (existant ou non, avec un chemin relatif pour etre vraiment utilise hors salome diff --git a/Accas/A_FORM.py b/Accas/A_FORM.py index fd8d3807..dbe86717 100644 --- a/Accas/A_FORM.py +++ b/Accas/A_FORM.py @@ -17,7 +17,6 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_FORM from Ihm import I_ENTITE from Accas import A_FORM_ETAPE @@ -27,4 +26,5 @@ class FORM(N_FORM.FORM, I_ENTITE.ENTITE): """ Accas class for catalog definition keyword FORMULE """ + class_instance = A_FORM_ETAPE.FORM_ETAPE diff --git a/Accas/A_FORM_ETAPE.py b/Accas/A_FORM_ETAPE.py index 1aeef15a..8d0fd94c 100644 --- a/Accas/A_FORM_ETAPE.py +++ b/Accas/A_FORM_ETAPE.py @@ -23,11 +23,14 @@ from Validation import V_MACRO_ETAPE from Ihm import I_FORM_ETAPE -class FORM_ETAPE( I_FORM_ETAPE.FORM_ETAPE, V_MACRO_ETAPE.MACRO_ETAPE, N_FORM_ETAPE.FORM_ETAPE): +class FORM_ETAPE( + I_FORM_ETAPE.FORM_ETAPE, V_MACRO_ETAPE.MACRO_ETAPE, N_FORM_ETAPE.FORM_ETAPE +): """ - specific class for Aster FORM_ETAPE + specific class for Aster FORM_ETAPE most likely as MACRO """ + def __init__(self, oper=None, reuse=None, args={}): N_FORM_ETAPE.FORM_ETAPE.__init__(self, oper, reuse, args) V_MACRO_ETAPE.MACRO_ETAPE.__init__(self) diff --git a/Accas/A_JDC.py b/Accas/A_JDC.py index de6f1ede..ac697e40 100644 --- a/Accas/A_JDC.py +++ b/Accas/A_JDC.py @@ -26,8 +26,9 @@ from Efi2Xsd.MCAccasXML import X_JDC class JDC(jdc.JDC, I_JDC.JDC, X_JDC, V_JDC.JDC, N_JDC.JDC): """ - parent class for dataset object (JDC) + parent class for dataset object (JDC) """ + from .A_ASSD import CO, assd def __init__(self, *pos, **args): diff --git a/Accas/A_JDC_CATA.py b/Accas/A_JDC_CATA.py index 384a3550..33db81ae 100644 --- a/Accas/A_JDC_CATA.py +++ b/Accas/A_JDC_CATA.py @@ -25,9 +25,10 @@ from Efi2Xsd.AccasXsd import X_JDC_CATA class JDC_CATA(I_JDC_CATA.JDC_CATA, N_JDC_CATA.JDC_CATA, X_JDC_CATA): """ - Accas class that defines a catalog object that is object which will be used + Accas class that defines a catalog object that is object which will be used to control conformity of the dataset with its definition """ + class_instance = A_JDC.JDC def __init__(self, *pos, **kw): diff --git a/Accas/A_JDC_CATA_SINGLETON.py b/Accas/A_JDC_CATA_SINGLETON.py index 5a69ffc4..3d2acc8d 100644 --- a/Accas/A_JDC_CATA_SINGLETON.py +++ b/Accas/A_JDC_CATA_SINGLETON.py @@ -21,17 +21,20 @@ from Noyau.N_utils import Singleton from Accas import JDC_CATA + class JDC_CATA_SINGLETON(Singleton, JDC_CATA): """ class used for defining catalogs which can be either standalone either imported by another catalog the steps are recorded in the correct JDC_CATA """ + def __init__(self, *pos, **kw): if hasattr(self, "initialised"): return self.initialised = True JDC_CATA.__init__(self, *pos, **kw) - # to do : reflechir pour les imports des drivers a utiliser le nom du code - # de maniere a pour pourvoir utiliser n importe lequel des driver pour lire - # le XML + + # to do : reflechir pour les imports des drivers a utiliser le nom du code + # de maniere a pour pourvoir utiliser n importe lequel des driver pour lire + # le XML diff --git a/Accas/A_MACRO.py b/Accas/A_MACRO.py index 7b63bfea..aad70717 100644 --- a/Accas/A_MACRO.py +++ b/Accas/A_MACRO.py @@ -17,7 +17,6 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_MACRO from Ihm import I_ENTITE from . import A_MACRO_ETAPE @@ -28,6 +27,7 @@ class MACRO(N_MACRO.MACRO, I_ENTITE.ENTITE): parent class of MACRO definition unused class that could/should be reactivated """ + class_instance = A_MACRO_ETAPE.MACRO_ETAPE def __init__(self, *tup, **args): diff --git a/Accas/A_MACRO_ETAPE.py b/Accas/A_MACRO_ETAPE.py index b6610b91..7db99b8b 100644 --- a/Accas/A_MACRO_ETAPE.py +++ b/Accas/A_MACRO_ETAPE.py @@ -24,14 +24,19 @@ from Accas.A_ASSD import CO from Efi2Xsd.MCAccasXML import X_MCCOMPO -class MACRO_ETAPE( I_MACRO_ETAPE.MACRO_ETAPE, X_MCCOMPO, - V_MACRO_ETAPE.MACRO_ETAPE, N_MACRO_ETAPE.MACRO_ETAPE,): +class MACRO_ETAPE( + I_MACRO_ETAPE.MACRO_ETAPE, + X_MCCOMPO, + V_MACRO_ETAPE.MACRO_ETAPE, + N_MACRO_ETAPE.MACRO_ETAPE, +): """ parent class of MACRO objects unused class that could/should be reactivated - a macro is a set of command + a macro is a set of command differs from step (PROC or OPER) for supervision """ + typeCO = CO def __init__(self, oper=None, reuse=None, args={}): diff --git a/Accas/A_MCBLOC.py b/Accas/A_MCBLOC.py index 0de4377d..8085eed7 100644 --- a/Accas/A_MCBLOC.py +++ b/Accas/A_MCBLOC.py @@ -17,7 +17,6 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_MCBLOC from Validation import V_MCBLOC from Ihm import I_MCBLOC @@ -28,7 +27,14 @@ class MCBLOC(I_MCBLOC.MCBLOC, N_MCBLOC.MCBLOC, X_MCBLOC, V_MCBLOC.MCBLOC): """ class of BLOC objet """ + def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction=None): - N_MCBLOC.MCBLOC.__init__(self, val, definition, nom, - parent, dicoPyxbDeConstruction=dicoPyxbDeConstruction) + N_MCBLOC.MCBLOC.__init__( + self, + val, + definition, + nom, + parent, + dicoPyxbDeConstruction=dicoPyxbDeConstruction, + ) V_MCBLOC.MCBLOC.__init__(self) diff --git a/Accas/A_MCFACT.py b/Accas/A_MCFACT.py index 6cd1988f..fdccb588 100644 --- a/Accas/A_MCFACT.py +++ b/Accas/A_MCFACT.py @@ -17,7 +17,6 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_MCFACT from Validation import V_MCFACT from Ihm import I_MCFACT @@ -28,7 +27,14 @@ class MCFACT(I_MCFACT.MCFACT, N_MCFACT.MCFACT, X_MCFACT, V_MCFACT.MCFACT): """ class of FACT object (MCFACT = mot clef FACTEUR) """ + def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction=None): - N_MCFACT.MCFACT.__init__(self, val, definition, nom, - parent, dicoPyxbDeConstruction=dicoPyxbDeConstruction) + N_MCFACT.MCFACT.__init__( + self, + val, + definition, + nom, + parent, + dicoPyxbDeConstruction=dicoPyxbDeConstruction, + ) V_MCFACT.MCFACT.__init__(self) diff --git a/Accas/A_MCLIST.py b/Accas/A_MCLIST.py index 810f37ba..bb12a927 100644 --- a/Accas/A_MCLIST.py +++ b/Accas/A_MCLIST.py @@ -17,7 +17,6 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # ====================================================================== -from __future__ import absolute_import from Noyau import N_MCLIST from Validation import V_MCLIST from Ihm import I_MCLIST @@ -29,5 +28,6 @@ class MCList(I_MCLIST.MCList, N_MCLIST.MCList, X_MCLIST, V_MCLIST.MCList): class of keywords which are also lists overload the python list class """ + def __init__(self): N_MCLIST.MCList.__init__(self) diff --git a/Accas/A_MCSIMP.py b/Accas/A_MCSIMP.py index b0618e42..c4059f58 100644 --- a/Accas/A_MCSIMP.py +++ b/Accas/A_MCSIMP.py @@ -27,8 +27,11 @@ class MCSIMP(I_MCSIMP.MCSIMP, N_MCSIMP.MCSIMP, X_MCSIMP, V_MCSIMP.MCSIMP): """ class for SIMP object (MCSIMP = mot clef simp) """ + def __init__(self, val, definition, nom, parent, objPyxbDeConstruction=None): - # le defaut de objPyxbDeConstruction permet de lire les comm + # le defaut de objPyxbDeConstruction permet de lire les comm # avec des modeles sans equivalent XSD - N_MCSIMP.MCSIMP.__init__(self,val,definition,nom,parent,objPyxbDeConstruction) + N_MCSIMP.MCSIMP.__init__( + self, val, definition, nom, parent, objPyxbDeConstruction + ) V_MCSIMP.MCSIMP.__init__(self) diff --git a/Accas/A_MEME_NOMBRE.py b/Accas/A_MEME_NOMBRE.py index 07f0b9ba..a52445c9 100644 --- a/Accas/A_MEME_NOMBRE.py +++ b/Accas/A_MEME_NOMBRE.py @@ -17,7 +17,6 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_REGLE from Validation import V_MEME_NOMBRE from Ihm import I_REGLE @@ -27,4 +26,5 @@ class MEME_NOMBRE(V_MEME_NOMBRE.MEME_NOMBRE, I_REGLE.REGLE, N_REGLE.REGLE): """ Accas class for catalog rule MEME_NOMBRE """ + pass diff --git a/Accas/A_OPER.py b/Accas/A_OPER.py index 201a1c5f..6da8133f 100644 --- a/Accas/A_OPER.py +++ b/Accas/A_OPER.py @@ -17,7 +17,6 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_OPER from Ihm import I_ENTITE from Accas import A_ETAPE diff --git a/Accas/A_PRESENT_ABSENT.py b/Accas/A_PRESENT_ABSENT.py index 5a6df329..1130b062 100644 --- a/Accas/A_PRESENT_ABSENT.py +++ b/Accas/A_PRESENT_ABSENT.py @@ -17,17 +17,16 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_REGLE from Validation import V_PRESENT_ABSENT from Ihm import I_PRESENT_ABSENT -class PRESENT_ABSENT( I_PRESENT_ABSENT.PRESENT_ABSENT, - V_PRESENT_ABSENT.PRESENT_ABSENT, - N_REGLE.REGLE - ): +class PRESENT_ABSENT( + I_PRESENT_ABSENT.PRESENT_ABSENT, V_PRESENT_ABSENT.PRESENT_ABSENT, N_REGLE.REGLE +): """ Accas class for catalog rule PRESENT_ABSENT """ + pass diff --git a/Accas/A_PRESENT_PRESENT.py b/Accas/A_PRESENT_PRESENT.py index 1cb636df..02e0d82a 100644 --- a/Accas/A_PRESENT_PRESENT.py +++ b/Accas/A_PRESENT_PRESENT.py @@ -17,16 +17,16 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from __future__ import absolute_import from Noyau import N_REGLE from Validation import V_PRESENT_PRESENT from Ihm import I_PRESENT_PRESENT -class PRESENT_PRESENT(I_PRESENT_PRESENT.PRESENT_PRESENT, - V_PRESENT_PRESENT.PRESENT_PRESENT, - N_REGLE.REGLE): +class PRESENT_PRESENT( + I_PRESENT_PRESENT.PRESENT_PRESENT, V_PRESENT_PRESENT.PRESENT_PRESENT, N_REGLE.REGLE +): """ Accas class for catalog rule PRESENT_PRESENT """ + pass diff --git a/Accas/A_PROC.py b/Accas/A_PROC.py index 283f59ea..15190574 100644 --- a/Accas/A_PROC.py +++ b/Accas/A_PROC.py @@ -27,6 +27,7 @@ class PROC(N_PROC.PROC, X_PROC, I_ENTITE.ENTITE): """ Accas class for catalog definition keyword PROC """ + class_instance = A_PROC_ETAPE.PROC_ETAPE def __init__(self, *tup, **args): diff --git a/Accas/A_PROC_ETAPE.py b/Accas/A_PROC_ETAPE.py index dcdd3062..c317f5af 100644 --- a/Accas/A_PROC_ETAPE.py +++ b/Accas/A_PROC_ETAPE.py @@ -23,13 +23,13 @@ from Ihm import I_PROC_ETAPE from Efi2Xsd.MCAccasXML import X_MCCOMPO -class PROC_ETAPE(I_PROC_ETAPE.PROC_ETAPE, - V_PROC_ETAPE.PROC_ETAPE, - X_MCCOMPO, - N_PROC_ETAPE.PROC_ETAPE): +class PROC_ETAPE( + I_PROC_ETAPE.PROC_ETAPE, V_PROC_ETAPE.PROC_ETAPE, X_MCCOMPO, N_PROC_ETAPE.PROC_ETAPE +): """ Accas class for dataset object PROC_ETAPE """ + def __init__(self, oper=None, args={}): N_PROC_ETAPE.PROC_ETAPE.__init__(self, oper=oper, args=args) V_PROC_ETAPE.PROC_ETAPE.__init__(self) diff --git a/Accas/A_SALOME_ENTRY.py b/Accas/A_SALOME_ENTRY.py index cfe688e0..8e8fd29b 100644 --- a/Accas/A_SALOME_ENTRY.py +++ b/Accas/A_SALOME_ENTRY.py @@ -21,10 +21,11 @@ class SalomeEntry: """ - This empty class is replaced by the class eficas.SalomeEntry - (defined in Salome EFICAS module) when Eficas is launched in Salome context. - It handles the objects that can be selected from Salome object browser. - from builtins import object - class SalomeEntry(object): + This empty class is replaced by the class eficas.SalomeEntry + (defined in Salome EFICAS module) when Eficas is launched in Salome context. + It handles the objects that can be selected from Salome object browser. + from builtins import object + class SalomeEntry(object): """ + pass diff --git a/Accas/A_SENSIBILITE.py b/Accas/A_SENSIBILITE.py index f41eaa75..958e9dd8 100644 --- a/Accas/A_SENSIBILITE.py +++ b/Accas/A_SENSIBILITE.py @@ -23,21 +23,24 @@ from Noyau import N_SENSIBILITE class REUSE_SENSIBLE(I_REGLE.REGLE, N_SENSIBILITE.REUSE_SENSIBLE): - """ + """ obsolete class which was used by the supervisor """ + pass class CONCEPT_SENSIBLE(I_REGLE.REGLE, N_SENSIBILITE.CONCEPT_SENSIBLE): - """ + """ obsolete class which was used by the supervisor """ + pass class DERIVABLE(I_REGLE.REGLE, N_SENSIBILITE.DERIVABLE): - """ + """ obsolete class which was used by the supervisor """ + pass diff --git a/Accas/A_SIMP.py b/Accas/A_SIMP.py index 6ec8d9d3..34906bfa 100644 --- a/Accas/A_SIMP.py +++ b/Accas/A_SIMP.py @@ -24,9 +24,10 @@ from Efi2Xsd.AccasXsd import X_SIMP class SIMP(N_SIMP.SIMP, X_SIMP, I_ENTITE.ENTITE): - """ + """ Accas class for catalog definition keyword SIMP """ + class_instance = A_MCSIMP.MCSIMP def __init__(self, *tup, **args): diff --git a/Accas/A_TUPLE.py b/Accas/A_TUPLE.py index 8b2a1a4b..dde1a926 100644 --- a/Accas/A_TUPLE.py +++ b/Accas/A_TUPLE.py @@ -26,6 +26,7 @@ class Tuple(N_TUPLE.N_Tuple): """ Accas class for catalog definition keyword Tuple """ + pass @@ -33,5 +34,5 @@ class Matrice(I_TUPLE.I_Matrice, N_TUPLE.N_Matrice): """ Accas class for catalog definition keyword Matrice """ - pass + pass diff --git a/Accas/A_UN_PARMI.py b/Accas/A_UN_PARMI.py index 03bf197c..d777d61f 100644 --- a/Accas/A_UN_PARMI.py +++ b/Accas/A_UN_PARMI.py @@ -26,4 +26,5 @@ class UN_PARMI(I_UN_PARMI.UN_PARMI, V_UN_PARMI.UN_PARMI, N_REGLE.REGLE): """ Accas class for catalog rule UN_PARMI """ + pass diff --git a/Codes/ReacteurNumerique/cata_RN.py b/Codes/ReacteurNumerique/cata_RN.py new file mode 100755 index 00000000..f507f79a --- /dev/null +++ b/Codes/ReacteurNumerique/cata_RN.py @@ -0,0 +1,1034 @@ +# -*- coding: utf-8 -*- + +"""Definition of the data model used by the integration bench. + +Warnings +-------- +EFICAS will import this file as Python module with the ``__import__`` special +function so, this module must not use relative import. +""" +# TODO: Create a main object that point on the different subobjects and force its name + +# EFICAS +from Accas import OPER, BLOC, FACT, SIMP, ASSD, JDC_CATA, VerifTypeTuple, Matrice # pylint: disable=import-error +from Accas import Tuple as _Tuple # pylint: disable=import-error +from Extensions.i18n import tr # pylint: disable=import-error + +# Warning: The names of these variables are defined by EFICAS +JdC = JDC_CATA(code="IB") +VERSION_CATALOGUE = "V_0" + +# Define the minimum and the maximum number of elements (reflectors and fuel +# assemblies) on the core's side +NMIN_CORE_FUEL_ELTS = 1 +NMAX_CORE_FUEL_ELTS = 18 + +# Available absorbing material type in the rod clusters +ROD_COMPOSITIONS = ( + "Black", # Full AIC rods + "Grey", # Mix between AIC and steel rods + "B4C", # Full B4C rods +) + +# Available options for the core elements rotation +ASSEMBLY_ROTATIONS = ( + ".", # identity + "R1", # 90° counter-clock + "R2", # 180° + "R3", # 270° counter-clock + "UD", # up-down + "LR", # left-right + "TR", # transpose x/y + "RT", # transpose x/-y +) + +class Tuple(_Tuple): + """Organize the data into a fixed size tuple. + + Warnings + -------- + This class respect the EFICAS conventions. + """ + + def __convert__(self, valeur): + if len(valeur) != self.ntuple: + return None + return valeur + + +class VerifPostTreatment(VerifTypeTuple): + """Validate the data comming from ``Scenario_data.post_processing``. + + Warnings + -------- + This class respect the EFICAS conventions. + """ + # pylint: disable=invalid-name + # pylint: disable=missing-function-docstring + # pylint: disable=no-self-use + + PHYSICS = ("Neutronics", "Thermalhydraulics", "System") + FORMATS = ("MED", "SUM", "MIN", "MAX", "MEAN", "VALUE") + + def __init__(self): + super().__init__(("TXM", "TXM", "TXM")) + self.cata_info = "" + + def info(self): + return tr(": vérifie les \ntypes dans un tuple") + + def infoErreurListe(self): + return tr("Les types entres ne sont pas permis") + + def default(self, valeur): + return valeur + + def isList(self): + return 1 + + def convertItem(self, valeur): + if len(valeur) != len(self.typeDesTuples): + raise ValueError( + tr("%s devrait être de type %s ") % (valeur, self.typeDesTuples)) + ok = self.verifType(valeur) + if ok == 0: + raise ValueError( + tr("%s devrait être de type %s (%d)") % (valeur, self.typeDesTuples, ok)) + if ok == -1: + raise ValueError( + tr("%s devrait être dans %s ") % (valeur[1], self.PHYSICS)) + if ok == -2: + raise ValueError( + tr("%s devrait être dans %s ") % (valeur[2], self.FORMATS)) + return valeur + + def verifItem(self, valeur): + try: + if len(valeur) != len(self.typeDesTuples): + return 0 + ok = self.verifType(valeur) + if ok != 1: + return 0 + except: + return 0 + return 1 + + def verifType(self, valeur): + ok = 0 + for v in valeur: + if isinstance(v, (bytes, str)): + ok += 1 + if ok == len(self.typeDesTuples): + if valeur[1] not in self.PHYSICS: + return -1 + if valeur[2] not in self.FORMATS: + return -2 + return 1 + return 0 + + def verif(self, valeur): + if type(valeur) in (list, tuple): + liste = list(valeur) + for val in liste: + if self.verifItem(val) != 1: + return 0 + return 1 + return 0 + + +class _Assembly(ASSD): + pass + + +class _TechnoData(ASSD): + pass + + +class _RodBank(ASSD): + pass + + +class _ModelData(ASSD): + pass + + +class _ScenarioData(ASSD): + pass + + +class _IandCFunction(ASSD): + pass + + +class _Program(ASSD): + pass + + +Assembly = OPER( + nom="Assembly", + sd_prod=_Assembly, + fr="Description d'un élément du cœur", + ang="Core element description", + assembly_type=SIMP( + fr="Type d'élément cœur (assemblage combustible ou réflecteur", + ang="Type of the core element (fuel assembly or reflector", + statut="o", + typ="TXM", + into=("UOX", "MOX", "REF")), + description=BLOC( + condition="assembly_type != 'REF'", + fr="Description d'un assemblage combustible", + ang="Fuel assembly description", + assembly_width=SIMP( + fr="Pas inter-assemblage dans le cœur", + ang="Fuel assembly pitch in the core", + unite="m", + statut="o", + typ="R"), + fuel_density=SIMP( + fr=("Ratio entre masse volumique nominale et la masse volumique " + "théorique des pastilles combustible"), + ang=("Ratio between the nominal density and the theoretical " + "density of the fuel pellets"), + unite="g/cm3", + statut="o", + typ="R", + defaut=0.95), + radial_description=FACT( + fr="Description radiale de l'assemblage combustible", + ang="Fuel assembly radial description", + statut="o", + clad_outer_radius=SIMP( + fr="Rayon externe de la gaine des crayons combustible", + ang="Clad external radius of the fuel pins", + unite="m", + statut="o", + typ="R"), + guide_tube_outer_radius=SIMP( + fr="Rayon externe des tubes guides", + ang="Clad external radius of the guide tubes", + unite="m", + statut="o", + typ="R"), + fuel_rod_pitch=SIMP( + fr="Pas inter-crayon dans l'assemblage", + ang="Fuel pin pitch in the assembly", + unite="m", + statut="o", + typ="R"), + nfuel_rods=SIMP( + fr="Nombre de crayons combustibles dans l'assemblage", + ang="Number of fuel pins in the assembly", + statut="o", + typ="I")), + axial_description=FACT( + fr="Description axiale de l'assemblage combustible", + ang="Fuel assembly axial description", + statut="o", + active_length_start=SIMP( + fr="Altitude basse de la partie active", + ang="Lower altitude of the active part", + unite="m", + statut="o", + typ="R"), + active_length_end=SIMP( + fr="Altitude haute de la partie active", + ang="Upper altitude of the active part", + unite="m", + statut="o", + typ="R")), + grids=FACT( + fr="Description des grilles", + ang="Grids description", + statut="o", + mixing=FACT( + fr="Description des grilles de mélange", + ang="Mixing grids description", + statut="o", + positions=SIMP( + fr="Altitude basse de la grille", + ang="Grid lower altitude", + unite="m", + statut="f", + typ="R", + max="**"), + size=SIMP( + fr="Hauteur de la grille", + ang="Grid height", + unite="m", + statut="o", + typ="R")), + non_mixing=FACT( + fr="Description des grilles de maintien", + ang="Holding grids description", + statut="o", + positions=SIMP( + fr="Altitude basse de la grille", + ang="Grid lower altitude", + unite="m", + statut="f", + typ="R", + max="**"), + size=SIMP( + fr="Hauteur de la grille", + ang="Grid height", + unite="m", + statut="o", + typ="R"))))) + + +# TODO: Define the names of the possible compositions (Black, Grey, B4C, Hafnium and Pyrex) +RodBank = OPER( + nom="RodBank", + sd_prod=_RodBank, + fr="Description d'un groupe de grappes absorbantes", + ang="Rod bank description", + rod_type=SIMP( + fr="Type de grappes absorbantes", + ang="Type of rod clusters", + statut="o", + typ="TXM", + into=("homogeneous", "heterogeneous")), + description_HOM=BLOC( + condition="rod_type == 'homogeneous'", + fr="Description d'un groupe de grappes absorbantes homogènes axialement", + ang="Axially homogeneous rod bank description", + rod_composition=SIMP( + fr=("Type de matériau absorbant des grappes absorbantes (Types " + "autorisés : {})").format( + ", ".join(ROD_COMPOSITIONS)), + ang=("Absorbing material type of the rod clusters (Authorized " + "types: {})").format( + ", ".join(ROD_COMPOSITIONS)), + statut="o", + typ="TXM", + into=ROD_COMPOSITIONS)), + description_HET=BLOC( + condition="rod_type == 'heterogeneous'", + fr="Description d'un groupe de grappes absorbantes hétérogène axialement", + ang="Axially heterogeneous rod bank description", + bottom_composition=SIMP( + fr=("Type de matériau absorbant dans la partie basse des grappes " + "absorantes (Types autorisés : {})").format( + ", ".join(ROD_COMPOSITIONS)), + ang=("Absorbing material type in the lower part of the rod " + "clusters (Authorized types: {})").format( + ", ".join(ROD_COMPOSITIONS)), + statut="o", + typ="TXM", + into=ROD_COMPOSITIONS), + splitting_heigh=SIMP( + fr=("Altitude de séparation entre la partie haute et la partie " + "basse des grappes absorbantes"), + ang=("Splitting height between the upper part and the lower part " + "of the rod clusters"), + unite="m", + statut="o", + typ="R"), + upper_composition=SIMP( + fr=("Type de matériau absorbant dans la partie haute des grappes " + "absorantes (Types autorisés : {})").format( + ", ".join(ROD_COMPOSITIONS)), + ang=("Absorbing material type in the upper part of the rod " + "clusters (Authorized types: {})").format( + ", ".join(ROD_COMPOSITIONS)), + statut="o", + typ="TXM", + into=ROD_COMPOSITIONS)), + step_height=SIMP( + fr="Hauteur d'un pas", + ang="Step height", + unite="m", + statut="o", + typ="R"), + nsteps=SIMP( + fr="Nombre de pas du groupe de grappes", + ang="Rod bank steps number", + statut="o", + typ="I")) + + +def gen_assembly_maps(): + """Generate all the possible maps (one for each possible core size) for the + data cointained in ``Techno_data.radial_description.assembly_map``.""" + # Build the default axes names + xsym_list = list("ABCDEFGHJKLNPRSTUVWXYZ") + xsym_list.reverse() + ysym_list = ["%02d" % i for i in range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS + 1)] + ysym_list.reverse() + def_xaxis = {} + def_yaxis = {} + for i in range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS + 1): + def_xaxis[i] = ["RW"] + xsym_list[-i:] + ["RE"] + def_yaxis[i] = ["RS"] + ysym_list[-i:] + ["RN"] + + dico = {} + for i in range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS): + dico["assembly_map_%d" % i] = BLOC( + condition="nb_assembly == %d" % i, + fr="Description radiale du cœur", + ang="Core radial description", + xaxis=SIMP( + fr="Nom des repères radiaux du cœur suivant l'axe ouest-est", + ang="Name of core radial marks following the west-east axis", + statut="o", + typ="TXM", + min=i + 2, + max=i + 2, + defaut=def_xaxis[i]), + yaxis=SIMP( + fr="Nom des repères radiaux du cœur suivant l'axe nord-sud", + ang="Name of core radial marks following the north-south axis", + statut="o", + typ="TXM", + min=i + 2, + max=i + 2, + defaut=def_yaxis[i]), + assembly_map=SIMP( + fr=("Répartition radiale des assemblages combustibles et des " + "réflecteurs dans le cœur"), + ang=("Radial repartition of the fuel assemblies and the " + "reflectors in the core"), + statut="o", + typ=Matrice( + nbLigs=i + 2, + nbCols=i + 2, + typElt=_Assembly, + listeHeaders=( + ("RW","S","R","P","N","L","K","J","H","G","F","E","D","C","B","A","RE",), + ("RS","15","14","13","12","11","10","09","08","07","06","05","04","03","02","01","RN",)), # pylint: disable=line-too-long + defaut=(i + 2) * [(i + 2) * ["."]], + coloree=True)), + rotation_map=SIMP( + fr="Rotation des éléments du cœur. Valeur possibles : {}".format( + ", ".join([repr(elt) for elt in ASSEMBLY_ROTATIONS])), + ang="Core elements rotation. Possible values : {}".format( + ", ".join([repr(elt) for elt in ASSEMBLY_ROTATIONS])), + statut="o", + typ=Matrice( + nbLigs=i + 2, + nbCols=i + 2, + typElt="TXM", + typEltInto=ASSEMBLY_ROTATIONS, + coloree=True), + defaut=(i + 2) * [(i + 2) * ["."]]), + rod_map=SIMP( + fr="Répartition radiale des groupes de grappes dans le cœur", + ang="Rod banks radial repartition in the core", + statut="o", + typ=Matrice( + nbLigs=i + 2, + nbCols=i + 2, + valSup=1, + valMin=-1, + typElt="TXM", + listeHeaders=None, + coloree=True), + defaut=(i + 2) * [(i + 2) * ["."]]), + BU_map=SIMP( + fr="Taux de combustion moyen des assemblages combustibles en GW.j/t", + ang="Average burnup of the fuel assemblies in GW.d/t", + statut="o", + typ=Matrice( + nbLigs=i + 2, + nbCols=i + 2, + valSup=90000., + valMin=0., + typElt="R", + listeHeaders=None, + coloree=True), + defaut=(i + 2) * [(i + 2) * ["."]])) + return dico + + +Techno_data = OPER( + nom="Techno_data", + sd_prod=_TechnoData, + fr="Description technologique du cœur", + ang="Core technological description", + technology=SIMP( + statut="o", + typ="TXM", + into=("DPY", "Other")), + assembly_list=SIMP( + fr="Sélection des assemblages combustible", + ang="Fuel assemblies selection", + statut="o", + typ=_Assembly, + min=1, + max="**"), + rodbank_list=SIMP( + fr="Sélection des groupes de grappes", + ang="Rod banks selection", + statut="o", + typ=_RodBank, + min=0, + max="**"), + radial_description=FACT( + fr="Description radiale du cœur", + ang="Radial description of the core", + statut="o", + nb_assembly=SIMP( + fr="Nombre d'éléments combustible sur la tranche du cœur", + ang="Number of fuel elements on one side of the core", + statut="o", + typ="I", + into=list(range(NMIN_CORE_FUEL_ELTS, NMAX_CORE_FUEL_ELTS))), + **(gen_assembly_maps())), + axial_description=FACT( + fr="Description axiale du cœur", + ang="Axial description of the core", + statut="o", + lower_refl_size=SIMP( + fr="Hauteur du réflecteur axial bas", + ang="Height of bottom axial reflector", + unite="m", + statut="o", + typ="R"), + upper_refl_size=SIMP( + fr="Hauteur du réflecteur axial haut", + ang="Height of top axial reflector", + unite="m", + statut="o", + typ="R")), + nominal_power=SIMP( + fr="Puissance thermique nominale du cœur", + ang="Nominal thermal power of the core", + unite="W", + statut="o", + typ="R"), + Fuel_power_fraction=SIMP( + fr="Fraction de la puissance dissipée dans le combustible", + ang="Power fraction dissipated in the fuel", + statut="o", + typ="R", + defaut=0.974), + by_pass=SIMP( + fr="Fraction du débit de bypass cœur", + ang="Bypass core flow fraction", + statut="o", + typ="R", + defaut=0.07), + core_volumic_flowrate=SIMP( + fr="Débit volumique cœur", + ang="Core volume flowrate", + unite="m3/h", + statut="o", + typ="R")) + + +class _AssemblyDKLibFile(ASSD): + """Manage informations about a fuel assembly DKLib file.""" + + +class _ReflectorDKLibFile(ASSD): + """Manage informations about a reflector DKLib file.""" + + +AssemblyDKLibFile = OPER( + nom="AssemblyDKLibFile", + sd_prod=_AssemblyDKLibFile, + fr="Description d'un fichier DKLib assemblage combustible", + ang="Description of a fuel assembly DKLib file", + filename=SIMP( + fr="Nom du fichier DKLib", + ang="DKLib filename", + statut="o", + typ=("Fichier", "DKLib Files (.dklib);;DKZip Files (.dkzip);;All Files ()", "Sauvegarde")), + pattern=SIMP( + fr="Nom du pattern à utiliser dans le fichier DKLib", + ang="Name of the pattern to use in the DKLib file", + statut="o", + typ="TXM"), + rod_bank_names=SIMP( + fr=("Nom de la configuration de grappe dans la DKLib pour chaque type " + "de matériaux absorbants disponibles dans le modèle sous la forme " + "({{{}}}, nom dans la DKLib)").format(", ".join(ROD_COMPOSITIONS)), + ang=("Name of the rod cluster configuration in the DKLib file for any " + "type of absorbing materials available in the model under the form " + "({{{}}}, name in the DKLib)").format(", ".join(ROD_COMPOSITIONS)), + statut="o", + typ=Tuple(2), + # TODO: Check if the first string is ROD_COMPOSITIONS + validators=VerifTypeTuple(("TXM", "TXM")), + max="**")) + + +ReflectorDKLibFile = OPER( + nom="ReflectorDKLibFile", + sd_prod=_ReflectorDKLibFile, + fr="Description d'un fichier DKLib réflecteur", + ang="Description of a reflector DKLib file", + filename=SIMP( + fr="Nom du fichier DKLib", + ang="DKLib filename", + statut="o", + typ=("Fichier", "DKLib Files (.dklib);;DKZip Files (.dkzip);;All Files ()","Sauvegarde")), + radial_pattern=SIMP( + fr="Nom du pattern contenant les données du réflecteur radial", + ang="Name of the pattern containing the radial reflector data", + statut="o", + typ="TXM"), + lower_pattern=SIMP( + fr="Nom du pattern contenant les données du réflecteur axial bas", + ang="Name of the pattern containing the lower reflector data", + statut="o", + typ="TXM"), + upper_pattern=SIMP( + fr="Nom du pattern contenant les données du réflecteur axial haut", + ang="Name of the pattern containing the upper reflector data", + statut="o", + typ="TXM")) + + +IandCFunction = OPER( + nom="IandCFunction", + sd_prod=_IandCFunction, + fr="Description d'une fonction de régulation", + ang="IandC function description", + parameter=SIMP( + fr="Paramètre cible de la regulation", + ang="Instrumentation and control function target parameter", + statut="o", + typ="TXM", + into=("Core", "Pressurizer level", "Pressurizer pressure")), + b_core=BLOC( + condition="parameter == 'Core'", + steering_mode=SIMP( + statut="o", + typ="TXM", + into=("A", "G", "T"), + fr="Mode de pilotage", + ang="Steering mode"), + b_steer_g=BLOC( + condition="steering_mode == 'G'", + r_group=SIMP( + statut="o", + typ=_RodBank, + max="**", + fr="Définition du groupe R", + ang="R group definition"), + g1_group=SIMP( + statut="o", + typ=_RodBank, + max="**", + fr="Définition du groupe G1", + ang="G1 group definition"), + g2_group=SIMP( + statut="o", + typ=_RodBank, + max="**", + fr="Définition du groupe G2", + ang="G2 group definition"), + n1_group=SIMP( + statut="o", + typ=_RodBank, + max="**", + fr="Définition du groupe N1", + ang="N1 group definition"), + n2_group=SIMP( + statut="o", + typ=_RodBank, + max="**", + fr="Définition du groupe N2", + ang="N2 group definition"), + limit_insertion=SIMP( + statut="o", + typ="I", + defaut=190, + unite="extracted steps"), + fr="paramètres mode G", + ang="G steering mode parameters"), + fr="Paramètres de la régulation coeur", + ang="Core iandc functions parameters")) + + +Program = OPER( + nom="Program", + sd_prod=_Program, + labels=SIMP( + statut="o", + typ="TXM", + min=1, + max="**"), + values=SIMP( + statut="o", + typ=Tuple(2), + validators=VerifTypeTuple(("R", "R")), + max="**", + fr="Loi de variation du paramètre sous la forme (temps, value)", + ang="Parameter variation law in the form (time, value)")) + + +# TODO: Split this class in two: neutronic and thermalhydraulic) +# TODO: Or split this class in N classes (one for each code) +Model_data = OPER( + nom="Model_data", + sd_prod=_ModelData, + fr="Description de la modélisation physique", + ang="Physical modeling description", + physics=SIMP( + fr="Sélection de la physique du modèle", + ang="Physic model selection", + statut="o", + typ="TXM", + into=("Neutronics", "Thermalhydraulics", "IandC")), + scale=SIMP( + fr="Sélection de l'échelle du modèle", + ang="Scale model selection", + statut="o", + typ="TXM", + into=("system", "component", "local")), + b_iandc=BLOC( + condition="physics == 'IandC'", + functions=SIMP( + statut="o", + typ=_IandCFunction, + min=1, + max="**"), + fr="Description de la modélisation des fonctions de régulation", + ang="Instrumentation and control modeling description"), + b_neutro_compo=BLOC( + condition="physics == 'Neutronics' and scale == 'component'", + fr="Description de la modélisation neutronique à l'échelle du composant", + ang="Neutronic modeling description at the component scale", + code=SIMP( + fr="Sélection du code de neutronique cœur", + ang="Core neutronic code selection", + statut="o", + typ="TXM", + into=("COCAGNE", "APOLLO3")), + cocagne_bloc=BLOC( + condition="code == 'COCAGNE'", + cocagne_options=FACT( + fr="Options de modélisations spécifiques au code COCAGNE.", + ang="COCAGNE specific modeling options", + statut="o", + n_threads=SIMP( + fr="Nombre de threads alloués aux solveurs", + ang="Number of threads allocated to the solvers", + statut="f", + typ="I", + val_min=1), + core_elements_vs_dklib=SIMP( + fr=("Association des éléments du cœur aux bibliothèques neutroniques " + "sous la forme (assemblage combustible, DKLib)"), + ang=("Association between the core elements and the neutronic libraries " + "in the form (fuel assembly, DKLib)"), + statut="o", + typ=Tuple(2), + # TODO: Check if the attribute assembly_type of the + # Assembly object is 'REF' then the type of the + # DKLibFile must be ReflectorDKLibFile and, if not, + # the type of the DKLibFile must be AssemblyDKLibFile + validators=VerifTypeTuple( + (_Assembly, (_AssemblyDKLibFile, _ReflectorDKLibFile))), + max="**"))), + # TODO: Implement the *4x4* mesh + radial_meshing=FACT( + fr="Maillage radial du cœur", + ang="Core radial meshing", + statut="o", + flux_solver=SIMP( + fr="Type de maillage radial du solveur de flux", + ang="Radial mesh type for the flux solver", + statut="o", + typ="TXM", + into=("subdivision", "pin-by-pin")), + b_flux_subdivision=BLOC( + condition="flux_solver == 'subdivision'", + fr=("Paramètres pour les maillages radiaux de type subdivisé " + "pour le solveur de flux"), + ang=("Parameters for the subdivided radial meshes types for the " + "flux solver"), + flux_subdivision=SIMP( + fr=("Nombre de sous-divisions à appliquer à chaque maille " + "radiale pour le solveur de flux"), + ang=("Subdivision number to apply to all radial meshes for " + "the flux solver"), + statut="o", + typ="I")), + feedback_solver=SIMP( + fr="Type de maillage radial du solveur de contre-réaction", + ang="Radial mesh type for the feedback solver", + statut="o", + typ="TXM", + into=("subdivision", "pin-by-pin")), + b_feedback_subdivision=BLOC( + condition="feedback_solver == 'subdivision'", + fr=("Paramètres pour les maillages radiaux de type subdivisé " + "pour le solveur de contre-réaction"), + ang=("Parameters for the subdivided radial meshes types for the " + "feedback solver"), + feedback_subdivision=SIMP( + fr=("Nombre de sous-divisions à appliquer à chaque maille " + "radiale pour le solveur de contre-réaction"), + ang=("Subdivision number to apply to all radial meshes for " + "the feedback solver"), + statut="o", + typ="I")))), + b_thermo_compo=BLOC( + condition="physics == 'Thermalhydraulics' and scale == 'component'", + fr="Description de la modélisation thermohydraulique à l'échelle du composant", + ang="Thermalhydraulic modeling description at the component scale", + code=SIMP( + fr="Sélection du code de thermohydraulique cœur", + ang="Core thermalhydraulic code selection", + statut="o", + typ="TXM", + into=("THYC", "CATHARE3", "FLICA4", "THEDI")), + thyc_bloc=BLOC( + condition="code == 'THYC'", + thyc_options=FACT( + fr="Options de modélisations spécifiques au code THYC.", + ang="THYC specific modeling options", + statut="o", + n_threads=SIMP( + fr="Nombre de threads alloués aux solveurs", + ang="Number of threads allocated to the solvers", + statut="f", + typ="I", + val_min=1))), + radial_meshing=FACT( + fr="Description du maillage radial thermohydraulique à l'échelle du composant", + ang="Thermalhydraulic radial meshing description at the component scale", + statut="o", + fluid=SIMP( + fr="Méthode de maillage radial", + ang="Radial meshing method", + statut="o", + typ="TXM", + into=("subdivision", "subchannel")), + b_fluid_subdivision=BLOC( + condition="fluid == 'subdivision'", + fr="Données spécifiques au maillage radial par subdivision", + ang="Specific data for the radial meshing by subdivision", + fluid_subdivision=SIMP( + fr="Nombre de mailles radiales dans les assemblages combustibles", + ang="Radial mesh number in the fuel assemblies", + statut="o", + typ="I")), + pellet=SIMP( + fr="Nombre de mailles radiales dans la pastille combustible", + ang="Radial mesh number in the fuel pellet", + statut="o", + typ="I"), + clad=SIMP( + fr="Nombre de mailles radiales dans la gaine des crayons combustibles", + ang="Radial mesh number in the clad of the fuel pins", + statut="o", + typ="I"))), + b_thermo_sys=BLOC( + condition="physics == 'Thermalhydraulics' and scale == 'system'", + code_sys=SIMP( + statut="o", + typ="TXM", + into=("CATHARE3",), + defaut="CATHARE3", + fr="Sélection du code de thermohydraulique système", + ang="System thermalhydraulic code selection"), + b_cathare3_sys=BLOC( + condition="code_sys == 'CATHARE3'", + input_type=SIMP( + statut="o", + typ="TXM", + into=("file", "model_data"), + fr="Sélection de la mise en donnée CATHARE3", + ang="CATHARE3 input data selection"), + b_c3_input_file=BLOC( + condition="input_type == 'file'", + input_file=SIMP( + statut='o', + typ=("Fichier", "CATHARE3 Input Deck (.dat);;All Files ()", "Sauvegarde"), + fr='Chemin vers le jeu de données CATHARE3', + ang='Path to CATHARE3 input deck')), + meshing=FACT( + statut='o', + nb_vessel_sectors=SIMP( + statut="o", + typ="I", + defaut=1, + fr="Nombre de secteurs pour la cuve", + ang="Number of vessel sectors"), + nb_core_sectors=SIMP( + statut="o", + typ="I", + defaut=1, + fr="Nombre de secteurs pour le coeur", + ang="Number of core sectors"))), + fr="Description de la modélisation thermohydraulique à l'échelle système", + ang="Thermalhydraulic modeling description at system level"), + b_scale_compo=BLOC( + condition="scale == 'component'", + fr="Description de la modélisation à l'échelle du composant", + ang="Modeling description at the component scale", + axial_meshing=FACT( + fr="Maillage axial du cœur", + ang="Core axial meshing", + statut="o", + lower_refl=SIMP( + fr="Nombre de mailles axiales dans le réflecteur bas", + ang="Axial mesh number in the lower reflector", + statut="o", + typ="I"), + fuel=SIMP( + fr="Nombre de mailles axiales dans la partie active de l'assemblage combustible", + ang="Axial mesh number in the active part of the fuel assembly", + statut="o", + typ="I"), + upper_refl=SIMP( + fr="Nombre de mailles axiales dans le réflecteur haut", + ang="Axial mesh number in the upper reflector", + statut="o", + typ="I"))), + b_scale_local=BLOC( + condition="scale == 'local'", + fr="Description de la modélisation à l'échelle du locale", + ang="Modeling description at the local scale", + mesh_file=SIMP( + fr="Nom du fichier décrivant le maillage", + ang="Name of the file describing the mesh", + statut="o", + typ="Fichier"))) + + +Scenario_data = OPER( + nom="Scenario_data", + sd_prod=_ScenarioData, + fr="Description du transitoire", + ang="Transient description", + toto = FACT(max='**', + titi = FACT( + max=2, + initial_power=SIMP( + fr="Puissance thermique initiale du cœur", + ang="Initial thermal power of the core", + statut="o", + typ="R", + val_min=0., + defaut=100.), + ), + ), + initial_power_unit=SIMP( + fr="Unité de la puissance thermique initiale du cœur", + ang="Unit of the initial thermal power of the core", + statut="o", + typ="TXM", + into=("% Nominal power", "W"), + defaut="% Nominal power"), + initial_core_inlet_temperature=SIMP( + fr="Température initiale de l'eau à l'entrée du cœur", + ang="Initial water temperature at the inlet of the core", + unite="°C", + statut="o", + typ="R", + val_min=0., + defaut=280.), + initial_boron_concentration=SIMP( + fr="Concentration en bore initiale", + ang="Initial boron concentration", + unite="ppm", + statut="o", + typ="R", + val_min=0., + defaut=1300.), + initial_inlet_pressure=SIMP( + fr="Pression initiale de l'eau à l'entrée du cœur", + ang="Initial water pressure at the inlet of the core", + unite="bar", + statut="o", + typ="R", + val_min=0., + defaut=160.2), + initial_outlet_pressure=SIMP( + fr="Pression initiale de l'eau à la sortie du cœur", + ang="Initial water pressure at the outlet of the core", + unite="bar", + statut="o", + typ="R", + val_min=0., + defaut=157.2), + initial_rod_positions=SIMP( + fr=("Position initiale des groupes de grappes et des grappes dans le " + "cœur sous la forme (type@nom, position) " + "(ex. (Rodbank@RB, 62) pour le groupe de grappe RB positionné à 62 " + "pas extraits et (Rodcluster@H08, 0) pour la grappe H08 " + "complètement insérée)"), + ang=("Initial position of the rod banks and the rod clusters in the " + "core in the form (type@name, position) " + "(e.g. (Rodbank@RB, 62) for the RB rod bank placed at 62 " + "extracted steps and (Rodcluster@H08, 0) for the rod cluster H08 " + "completely inserted)"), + unite="extracted steps", + statut="o", + typ=Tuple(2), # TODO: Use a triplet (type, name, position) instead of a doublet + validators=VerifTypeTuple(("TXM", "I")), + max="**"), + scenario_type=SIMP( + fr="Type de transitoire à modéliser", + ang="Type of transient to model", + statut="o", + typ="TXM", + into=("RIA", "HLO")), + b_ria=BLOC( + condition="scenario_type == 'RIA'", + fr="Données du transitoire 'accident de réactivité'", + ang="Data of the 'Reactivity-initiated Accident' transient", + ejected_rod=SIMP( + fr="Nom de la grappe éjectée", + ang="Name of the ejected rod cluster", + statut="o", + typ="TXM"), + rod_position_program=SIMP( + fr="Loi d'éjection à appliquer à la grappe sous la forme (temps, position)", + ang="Ejection law to apply to the ejected rod cluster in the form (time, position)", + unite="s, extracted steps", + statut="o", + typ=Tuple(2), + validators=VerifTypeTuple(("R", "I")), + max="**"), + SCRAM=SIMP( + fr="Activation/désactivation de l'arrêt automatique du réacteur", + ang="Activation/deactivation of automatic reactor shutdown", + statut="o", + typ="TXM", + into=("YES", "NO")), + SCRAM_option=BLOC( + condition="SCRAM == 'YES'", + fr="Options relatives à l'arrêt automatique du réacteur", + ang="Options relative to the automatic reactor shutdown", + SCRAM_power=SIMP( + fr=("Puissance thermique du cœur déclenchant un arrêt " + "automatique du réacteur"), + ang="Core thermal power triggering an automatic reactor shutdown", + unite="MW", + statut="o", + typ="R"), + complete_SCRAM_time=SIMP( + fr="Temps de chute des grappes", + ang="Rod cluster fall time", + unite="s", + statut="o", + typ="R"))), + b_hlo=BLOC( + condition="scenario_type == 'HLO'", + programs=SIMP( + statut="f", + max="**", + typ=_Program), + fr="Données du transitoire 'ilotage'", + ang="Data of the 'house-load operation' transient"), + post_processing=SIMP( + # TODO: Give all the possible parameters depending of the physics + fr=("Données de sortie du calcul sous la forme (paramètre, physique, format). " + "'physique' peut valoir {physics!r} et 'format' peut valoir {formats!r}".format( + physics=VerifPostTreatment.PHYSICS, + formats=VerifPostTreatment.FORMATS)), + ang=("Output computed data in function of time in the form (parameter, physic, format). " + "'physic' can be {physics!r} and 'format' can be {formats!r})".format( + physics=VerifPostTreatment.PHYSICS, + formats=VerifPostTreatment.FORMATS)), + statut="f", + typ=Tuple(3), + validators=VerifPostTreatment(), + max="**")) diff --git a/Codes/ReacteurNumerique/cata_RN_UQ.py b/Codes/ReacteurNumerique/cata_RN_UQ.py new file mode 100755 index 00000000..39ddb625 --- /dev/null +++ b/Codes/ReacteurNumerique/cata_RN_UQ.py @@ -0,0 +1,76 @@ +import os, sys +repInitial = os.path.dirname(os.path.abspath(__file__)) +repEficas = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if os.path.dirname(repInitial) not in sys.path : sys.path.insert(0,repInitial) +if os.path.dirname(repEficas) not in sys.path : sys.path.insert(0,repEficas) +import types + +from Noyau.N_VALIDATOR import Valid +from cata_RN import * + +# sert a activer les options d incertitude dans eficas +# et a changer le convert en convertUQ + +def supprimeExpressionIncertitude(obj): + if not (hasattr(obj, 'oldValue')) : + obj.oldValue=obj.valeur + return + if obj.oldValue==obj.valeur : return + obj.oldValue=obj.valeur + jdc=obj.getJdcRoot() + etapesUQ=obj.jdc.getEtapesByName('ExpressionIncertitude') + for e in etapesUQ : # a priori une seule + jdc.suppEntite(e) + +def maFonctionDeModif(cata) : + scenario_type=cata.Scenario_data.entites['scenario_type'] + scenario_type.changeSiValide(supprimeExpressionIncertitude) + +avecIncertitude=True +modifieCatalogueDeterministe=maFonctionDeModif + +def scenarioEgal(valeursPossibles, obj ): + listeEtapeScenario=obj.jdc.getEtapesByName('Scenario_data') + if len(listeEtapeScenario) !=1 : return False + else : etapeScenario=listeEtapeScenario[0] + scenario_type=etapeScenario.getChildOrChildInBloc('scenario_type') + if scenario_type.valeur == None : return False + if scenario_type.valeur in valeursPossibles : return True + return False + +dictUQConditions = {'initial_power' : (scenarioEgal, {'valeursPossibles':('HLO', 'RIA')}), + 'initial_core_inlet_temperature' : (scenarioEgal, {'valeursPossibles':('RIA','HLO')}), + 'initial_boron_concentration' : (scenarioEgal, {'valeursPossibles':('RIA')}), + 'initial_inlet_pressure' : (scenarioEgal, {'valeursPossibles':('RIA')}), + 'initial_outlet_pressure' : (scenarioEgal, {'valeursPossibles':('RIA')}), + 'assembly_width' : (scenarioEgal, {'valeursPossibles':('RIA')}), + } + +# Creation des lois : +# clef : variable deterministe +# valeur : dico des lois possibles ou le dictionnaire contient les parametres de creation de la loi +# il faudra eventuellement revoir ce mecanisme si on decide d affiner par scenario ces parametres +# cela pourrait se faire soit avec des blocs lors de la creation des lois +# ou par activation de fonctions de changement dynamique des SIMP ( comme changeIntoSelonValeurs) +dictUQ = {'initial_power' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}, {'UserDefined' :{}}), + 'initial_core_inlet_temperature' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}), + 'initial_boron_concentration' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}), + 'initial_inlet_pressure' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}), + 'initial_outlet_pressure' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}), + 'assembly_width' : ({'Uniform' : {}}, {'TruncatedNormal' : {}}), + # modifier la partie Accas pour garder une reference a l objet nomme + } + +listeDesSortiesNeutro = ("Boron concentration", "Kinetic reactivity", "Neutronic power",) +listeDesSortiesThermo = ("Average mass flux", "Boiling power fraction", "Enthalpy", "Fuel temperature",\ + "Liquid power", "Mass flux", "Mass fraction", "Mass title", "Mixture density", \ + "Mixture specific enthalpy", "Mixture temperature", "Outlet pressure", "Pollutant concentration", \ + "Pressure ", "Rowlands fuel effective temp", "Thermal power", "Water density", "Water temperature", ) + +scriptPosttraitement = os.path.join(repEficas,"generator","post_csv_rn.py") +scriptDeLancement = os.path.join(repInitial,"ib_test.sh") +dicoDesSortiesPossibles = {'Neutronics':listeDesSortiesNeutro,'Thermalhydraulics':listeDesSortiesThermo} + +from cata_UQ import creeOperExpressionIncertitude +ExpressionIncertitude = creeOperExpressionIncertitude(dictUQ, dicoDesSortiesPossibles, scriptPosttraitement, scriptDeLancement) + diff --git a/Codes/ReacteurNumerique/cata_UQ.py b/Codes/ReacteurNumerique/cata_UQ.py new file mode 100755 index 00000000..14f541e0 --- /dev/null +++ b/Codes/ReacteurNumerique/cata_UQ.py @@ -0,0 +1,1555 @@ +import os, sys +repInitial = os.path.dirname(os.path.abspath(__file__)) +repEficas = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if os.path.dirname(repInitial) not in sys.path : + sys.path.insert(0,repInitial) +if os.path.dirname(repEficas) not in sys.path : + sys.path.insert(0,repEficas) +import types + +from Accas import OPER, BLOC, FACT, SIMP, ASSD, JDC_CATA, VerifTypeTuple, Matrice, Tuple, AU_MOINS_UN, A_VALIDATOR, PROC +from Noyau.N_VALIDATOR import Valid + +#TODO --> si UserDefined et Uranie alors UserDefined + + +class CataError(Exception): + pass + + +class compareAutreMC(Valid) : +#---------------------------- + def __init__(self,frere=None): + Valid.__init__(self, frere=frere) + self.nomFrere=frere + + def set_MCSimp (self, MCSimp): + self.MCSimp=MCSimp + +class supValeurProbabiliste(compareAutreMC): +#------------------------------------------- + def convert(self, valeur): + try : VP=self.MCSimp.parent.parent.parent.variableDeterministe.valeur + except : return valeur + if VP == None : return valeur + if VP > valeur : + raise CataError('la valeur de la variable Probabiliste est superieure a la valeur entree ') + return valeur + + def verifItem(self, valeur): + try : VP=self.MCSimp.parent.parent.parent.variableDeterministe.valeur + except : return valeur + if VP == None : return valeur + if VP > valeur : + raise CataError(' la valeur de la variable Probabiliste est superieure a la valeur entree et doit etre inferieure') + return 0 + return valeur + + def infoErreurItem(self, valeur): + return 'la valeur de la variable Probabiliste est superieure a la valeur entree et doit etre inferieure' + + +class infValeurProbabiliste(compareAutreMC): +#------------------------------------------- + def convert(self, valeur): + valeur=valeur + try : VP=self.MCSimp.parent.parent.parent.variableDeterministe.valeur + except : return valeur + VP=self.MCSimp.parent.parent.parent.variableDeterministe.valeur + if VP < valeur : + raise CataError('la valeur de la variable Probabiliste est inferieure a la valeur entree ') + return valeur + + def verifItem(self, valeur): + try : VP=self.MCSimp.parent.parent.parent.variableDeterministe.valeur + except : return valeur + if VP == None : return valeur + if VP < valeur : + raise CataError(' la valeur de la variable Probabiliste est inferieure a la valeur entree et doit etre superieure') + return 0 + return valeur + + def infoErreurItem(self, valeur): + return 'la valeur de la variable Probabiliste est inferieure a la valeur entree et doit etre superieure' + +class infFrereMC(compareAutreMC): +#------------------------------- + def convert(self, valeur): + # on sort de cardProto on a une liste + valeur=valeur[0] + try: MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere) + except : return valeur + if not MCFrere : return valeur + if MCFrere== None : return valeur + if MCFrere.valeur == None : return valeur + if MCFrere.valeur < valeur : + raise CataError('la valeur de '+self.nomFrere + ' est inferieure a la valeur entree ') + return valeur + + def verifItem(self, valeur): + try: MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere) + except : return valeur + if not MCFrere : return valeur + if MCFrere== None : return valeur + if MCFrere.valeur == None : return valeur + if MCFrere.valeur < valeur : + raise CataError('la valeur de '+self.nomFrere + ' est inferieure a la valeur entree et doit etre superieure') + return 0 + return 1 + + def infoErreurItem(self, valeur): + return 'la valeur de '+self.nomFrere + ' est inferieure a la valeur entree et doit etre superieure' + + def info(self): + return 'la valeur de '+self.nomFrere + ' est inferieure a la valeur entree et doit etre superieure' + +class supFrereMC(compareAutreMC): +#-------------------------------- + def convert(self, valeur): + # on sort de cardProto on a une liste + valeur=valeur[0] + MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere) + if not MCFrere : return valeur + if MCFrere== None : return valeur + if MCFrere.valeur > valeur : + raise CataError('la valeur de '+self.nomFrere + ' est superieure a la valeur entree et doit etre inferieure') + return valeur + + def verifItem(self, valeur): + MCFrere=self.MCSimp.parent.getChildOrChildInBloc(self.nomFrere) + if not MCFrere : return 1 + if MCFrere== None : return 1 + if MCFrere.valeur > valeur : + raise CataError('la valeur de '+self.nomFrere + ' est superieure a la valeur entree et doit etre inferieure') + return 0 + return 1 + + def infoErreurItem(self, valeur): + return 'la valeur de '+self.nomFrere + ' est superieure a la valeur entree et doit etre inferieure' + + def info(self): + return 'la valeur de '+self.nomFrere + ' est superieure a la valeur entree ' +# +#listeLoiDistribution= ( #"Beta", #"Exponential", #"Gamma", #"Geometric", #"Gumbel", #"Histogram", #"Laplace", #"Logistic", #"LogNormal", #"MultiNomial", + #"NonCentralStudent", #"Normal", #"Poisson", #"Rayleigh", #"Student", #"Triangular", "TruncatedNormal", "Uniform", "UserDefined", + #"Weibull",), + +##==== +## Definition des parametres selon le type de la loi +##==== + +def creeBeta ( MuMax=1 ): + MuSimp = SIMP( statut = "o", typ = "R", max = 1, val_max=MuMax, + fr = "Moyenne de la loi", + ang = "Mean value", + ) + BETA = BLOC( condition = "Distribution == 'Beta'", + Settings = SIMP( statut = "o", typ = "TXM", max = 1, + into = ( "RT", "MuSigma" ), + defaut = "RT", + fr = "Parametrage de la loi beta", + ang = "Beta distribution parameter set", + ), + + RT_Parameters = BLOC( condition = " Settings in ( 'RT', ) ", + R = SIMP( statut = "o", typ = "R", max = 1, val_min = 0., + fr = "Parametre R de la loi | R > 0", + ang = "R parameter | R > 0", + ), + + # T > R + T = SIMP( statut = "o", typ = "R", max = 1, val_min = 0., + fr = "Parametre T de la loi | T > R", + ang = "T parameter | T > R", + ), + ), # Fin BLOC RT_Parameters + + MuSigma_Parameters = BLOC( condition = " Settings in ( 'MuSigma', ) ", + Mu=MuSimp, + Sigma = SIMP( statut = "o", typ = "R", max = 1, val_min = 0., + fr = "Ecart type de la loi", + ang = "Standard deviation", + ), + ), # Fin BLOC MuSigma_Parameters + + A = SIMP( statut = "o", typ = "R", max = 1, + fr = "Borne inferieure du support de la loi", + ang = "Support lower bound", + ), + + # B > A + B = SIMP( statut = "o", typ = "R", max = 1, + fr = "Borne superieure du support de la loi", + ang = "Support upper bound", + ), + + ) # Fin BLOC BETA + return BETA + +def creeExponential (): + EXPONENTIAL = BLOC( condition = " Distribution in ( 'Exponential', ) ", + + Lambda = SIMP( statut = "o", typ = "R", max = 1, val_min = 0., + fr = "Parametre Lambda | Lambda > 0", + ang = "Lambda parameter | Lambda > 0", + ), + + Gamma = SIMP( statut = "o", typ = "R", max = 1, + fr = "Borne inferieure du support de la loi", + ang = "Support lower bound", + ), + ) # Fin BLOC EXPONENTIAL + return EXPONENTIAL + +#def creeGamma (): +# GAMMA = BLOC( condition = " Distribution in ( 'Gamma', ) ", +# +# Settings = SIMP( statut = "o", typ = "TXM", max = 1, into = ( "KLambda", "MuSigma" ), defaut = "KLambda", +# fr = "Parametrage de la loi gamma", +# ang = "Gamma distribution parameter set", +# ), +# +# KLambda_Parameters = BLOC( condition = " Settings in ( 'KLambda', ) ", +# +# K = SIMP( statut = "o", typ = "R", max = 1, val_min = 0., +# fr = "Parametre K de la loi | K > 0", +# ang = "K parameter | K > 0", +# ), +# +# Lambda = SIMP( statut = "o", typ = "R", max = 1, val_min = 0., +# fr = "Parametre Lambda de la loi | Lambda > 0", +# ang = "Lambda parameter | Lambda > 0", +# ), +# +# ), # Fin BLOC KLambda_Parameters +# +# +# MuSigma_Parameters = BLOC( condition = " Settings in ( 'MuSigma', ) ", +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne de la loi", +# ang = "Mean value", +# ), +# +# Sigma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Ecart type de la loi", +# ang = "Standard deviation", +# ), +# +# ), # Fin BLOC MuSigma_Parameters +# +# Gamma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne inferieure du supoport de la loi", +# ang = "Support lower bound", +# ), +# +# +# ) # Fin BLOC GAMMA + +# +# +# GEOMETRIC = BLOC( condition = " Distribution in ( 'Geometric', ) ", +# +# P = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# val_max = 1., +# fr = "Parametre P | 0 < P < 1", +# ang = "P parameter | 0 < P < 1", +# ), +# +# ), # Fin BLOC GEOMETRIC +# +# +# +# GUMBEL = BLOC( condition = " Distribution in ( 'Gumbel', ) ", +# +# Settings = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# into = ( "AlphaBeta", "MuSigma" ), +# defaut = "AlphaBeta", +# fr = "Parametrage de la loi gumbel", +# ang = "Gumbel distribution parameter set", +# ), +# +# AlphaBeta_Parameters = BLOC( condition = " Settings in ( 'AlphaBeta', ) ", +# +# Alpha = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Parametre Alpha de la loi | Alpha > 0", +# ang = "Alpha parameter | Alpha > 0", +# ), +# +# Beta = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Parametre Beta de la loi", +# ang = "Beta parameter", +# ), +# +# ), # Fin BLOC AlphaBeta_Parameters +# +# +# MuSigma_Parameters = BLOC( condition = " Settings in ( 'MuSigma', ) ", +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne de la loi", +# ang = "Mean value", +# ), +# +# Sigma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Ecart type de la loi", +# ang = "Standard deviation", +# ), +# +# ), # Fin BLOC MuSigma_Parameters +# +# ), # Fin BLOC GUMBEL +# +# +# +# HISTOGRAM = BLOC( condition = " Distribution in ( 'Histogram', ) ", +# +# First = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne inferieure du supoport de la loi", +# ang = "Support lower bound", +# ), +# +# # Il faut definir une collection de couples ( x,p ) +# Values = SIMP( statut = 'o', +# typ = Tuple(2), +# max = '**', +# fr = "Liste de couples : largeur de classe, hauteur de classe", +# ang = "Class bandwidth, class height couple list", +# validators=VerifTypeTuple(('R','R')), +# ), +# +# ), # Fin BLOC HISTOGRAM +# +# +# +# LAPLACE = BLOC( condition = " Distribution in ( 'Laplace', ) ", +# +# Lambda = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Parametre Lambda | Lambda > 0", +# ang = "Lambda parameter | Lambda > 0", +# ), +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne de la loi", +# ang = "Mean value", +# ), +# +# ), # Fin BLOC LAPLACE +# +# LOGNORMAL = BLOC( condition = " Distribution in ( 'LogNormal', ) ", +# +# Settings = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ), +# defaut = "MuSigmaLog", +# fr = "Parametrage de la loi lognormale", +# ang = "Lognormal distribution parameter set", +# ), +# +# MuSigma_Parameters = BLOC( condition = " Settings in ( 'MuSigma', ) ", +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne de la loi", +# ang = "Mean value", +# ), +# +# Sigma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Ecart type de la loi", +# ang = "Standard deviation", +# ), +# +# ), # Fin BLOC MuSigma_Parameters +# +# MuSigmaOverMu_Parameters = BLOC( condition = " Settings in ( 'MuSigmaOverMu', ) ", +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne de la loi", +# ang = "Mean value", +# ), +# +# SigmaOverMu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Rapport ecart type / moyenne de la loi", +# ang = "Standard deviation / mean value ratio", +# ), +# +# ), # Fin BLOC MuSigmaOverMu_Parameters +# +# MuSigmaLog_Parameters = BLOC( condition = " Settings in ( 'MuSigmaLog', ) ", +# +# MuLog = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne du log", +# ang = "Log mean value", +# ), +# +# SigmaLog = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Ecart type du log", +# ang = "Log standard deviation", +# ), +# +# ), # Fin BLOC MuSigmaLog_Parameters +# +# Gamma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne inferieure du support de la loi", +# ang = "Support lower bound", +# ), +# +# ), # Fin BLOC LOGNORMAL +# +# +# +# LOGISTIC = BLOC( condition = " Distribution in ( 'Logistic', ) ", +# +# Alpha = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne inferieure du supoport de la loi", +# ang = "Support lower bound", +# ), +# +# Beta = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Parametre Beta de la loi | Beta > 0", +# ang = "Beta parameter | Beta > 0", +# ), +# +# ), # Fin BLOC LOGISTIC +# +# +# +# MULTINOMIAL = BLOC( condition = " Distribution in ( 'MultiNomial', ) ", +# +# N = SIMP( statut = "o", +# typ = "I", +# max = 1, +# fr = "Parametre N de la loi | N > 0", +# ang = "N parameter | N > 0", +# ), +# +# # Il faut definir une collection de couples ( x,p ) +# Values = SIMP( statut = 'o', +# typ = "R", +# max = '**', +# fr = "Liste de probabilités", +# ang = "Probability list", +# validators=VerifTypeTuple(('R','R')), +# ), +# +# ), # Fin BLOC MULTINOMIAL +# +# +# NONCENTRALSTUDENT = BLOC( condition = " Distribution in ( 'NonCentralStudent', ) ", +# +# Nu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Parametre Nu de la loi | Nu > 0", +# ang = "Nu parameter | Nu > 0", +# ), +# +# Delta = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Parametre Delta de la loi | Delta > 0", +# ang = "Delta parameter | Delta > 0", +# ), +# +# Gamma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Parametre Gamma de centrage de la loi", +# ang = "Gamma parameter", +# ), +# +# ), # Fin BLOC NONCENTRALSTUDENT +# +# +# NORMAL = BLOC( condition = " Distribution in ( 'Normal', ) ", +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne de la loi", +# ang = "Mean value", +# ), +# +# Sigma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Ecart type de la loi", +# ang = "Standard deviation", +# ), +# +# ) # Fin BLOC NORMAL +# +# +# +# POISSON = BLOC( condition = " Distribution in ( 'Poisson', ) ", +# +# Lambda = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Parametre Lambda de la loi | Lambda > 0", +# ang = "Lambda parameter | Lambda > 0", +# ), +# +# ), # Fin BLOC POISSON +# +# +# +# RAYLEIGH = BLOC( condition = " Distribution in ( 'Rayleigh', ) ", +# +# Sigma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Parametre Sigma de la loi | Sigma > 0", +# ang = "Sigma parameter | Sigma > 0", +# ), +# +# Gamma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne inferieure du support de la loi", +# ang = "Support lower bound", +# ), +# ), # Fin BLOC RAYLEIGH +# +# +# STUDENT = BLOC( condition = " Distribution in ( 'Student', ) ", +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Parametre Mu de la loi", +# ang = "Mu parameter", +# ), +# +# Nu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 2., +# fr = "Parametre Nu de la loi | Nu > 2", +# ang = "Nu parameter | Nu > 2", +# ), +# +# Sigma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Parametre Sigma de la loi", +# ang = "Sigma parameter", +# ), +# +# ), # Fin BLOC STUDENT +# +# +# +# TRIANGULAR = BLOC( condition = " Distribution in ( 'Triangular', ) ", +# +# A = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne inferieure du support de la loi | A < M < B", +# ang = "Support lower bound | A < M < B", +# ), +# +# M = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Mode de la loi | A < M < B", +# ang = "Mode | A < M < B", +# ), +# +# B = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne superieure du support de la loi | A < M < B", +# ang = "Support upper bound | A < M < B", +# ), +# +# ), # Fin BLOC TRIANGULAR +# +# +# +def creeTruncatedNormal(): + TRUNCATEDNORMAL = BLOC( condition = " Distribution in ( 'TruncatedNormal', ) ", + + MuN = SIMP( statut = "o", + typ = "R", + max = 1, + fr = "Moyenne de la loi Normale non tronquée", + ang = "Mean value of the associated non truncated normal distribution", + ), + + SigmaN = SIMP( statut = "o", + typ = "R", + max = 1, + val_min = 0., + fr = "Ecart-type de la loi Normale non tronquée", + ang = "Standard deviation of the associated non truncated normal distribution", + ), + + A = SIMP( statut = "o", + typ = "R", + max = 1, + #fr = "Borne inferieure de la loi | A < B", + #ang = "Lower bound | A < B", + ), + + B = SIMP( statut = "o", + typ = "R", + max = 1, + #fr = "Borne superieure de la loi | A < B", + #ang = "Upper bound | A < B", + ), + + ) # Fin BLOC TRUNCATEDNORMAL + return TRUNCATEDNORMAL + + +def verifieBorneInUniforme(self): + if self.valeur < self.parent.getChild('A').valeur : return ( "il faut A < B") + +def creeUniform(): + UNIFORM = BLOC( condition = " Distribution in ( 'Uniform', ) ", + + A = SIMP( statut = "o", + typ = "R", + max = 1, + #fr = "Borne inferieure du support de la loi | A < B", + #ang = "Support lower bound | A < B", + validators=[infFrereMC(frere='B'),infValeurProbabiliste()], + #validators=infFrereMC(frere='B') + ), + + B = SIMP( statut = "o", + typ = "R", + max = 1, + #fr = "Borne superieure du support de la loi | A < B", + #ang = "Support upper bound | A < B", + validators=[supFrereMC(frere='A'),supValeurProbabiliste()], + ), + ) # Fin BLOC UNIFORM + return UNIFORM + +# +# +def creeUserDefined (): + USERDEFINED = BLOC( condition = " Distribution in ( 'UserDefined', ) ", + + # Il faut definir une collection de couples ( x,p ) + Values = SIMP( statut = 'o', + typ = 'R', + max = '**', + ), + + ) # Fin BLOC USERDEFINED + return USERDEFINED +# +# +# WEIBULL = BLOC( condition = " Distribution in ( 'Weibull', ) ", +# +# Settings = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# into = ( "AlphaBeta", "MuSigma" ), +# defaut = "AlphaBeta", +# fr = "Parametrage de la loi weibull", +# ang = "Weibull distribution parameter set", +# ), +# +# AlphaBeta_Parameters = BLOC( condition = " Settings in ( 'AlphaBeta', ) ", +# +# Alpha = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Parametre Alpha de la loi | Alpha > 0", +# ang = "Alpha parameter | Alpha > 0", +# ), +# +# Beta = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Parametre Beta de la loi | Beta > 0", +# ang = "Beta parameter | Beta > 0", +# ), +# +# ), # Fin BLOC AlphaBeta_Parameters +# +# +# MuSigma_Parameters = BLOC( condition = " Settings in ( 'MuSigma', ) ", +# +# Mu = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Moyenne de la loi", +# ang = "Mean value", +# ), +# +# Sigma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# val_min = 0., +# fr = "Ecart type de la loi", +# ang = "Standard deviation", +# ), +# +# ), # Fin BLOC MuSigma_Parameters +# +# Gamma = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Borne inferieure du support de la loi", +# ang = "Support lower bound", +# ), +# +# ), # Fin BLOC WEIBULL +# +#) # Fin OPER DISTRIBUTION +# +# +# +#Correlation = PROC ( nom = 'Correlation', +# op = None, +# docu = "", +# fr = "Correlation entre variables", +# ang = "Variable correlation", +# UIinfo={"groupes":("UQ",)}, +# +# Copula = SIMP( statut = "o", +# typ = 'TXM', +# into = ( "Independent", "Normal" ), +# defaut = "Independent", +# fr = "Type de la copule", +# ang = "Copula kind", +# ), +# +# Matrix = BLOC( condition = "Copula in ( 'Normal', )", +# +# CorrelationMatrix = SIMP( statut = "o", +# typ = Matrice(nbLigs=None, +# nbCols=None, +# methodeCalculTaille='NbDeVariables', +# valSup=1, +# valMin=-1,), +# #structure="symetrique"), +# fr = "Matrice de correlation entre les variables d'entree", +# ang = "Correlation matrix for input variables", +# ), +# ), # Fin BLOC Matrix +# +# +#) # Fin PROC CORRELATION +# +# +# +# +# +# +# ThresholdExceedence = BLOC( condition = " Type in ( 'Threshold Exceedence', ) ", +# +# Event = FACT ( statut = "o", +# min = 1, +# max = 1, +# +# Threshold = SIMP( statut = "o", +# typ = "R", +# max = 1, +# fr = "Le seuil de defaillance", +# ang = "Failure threshold", +# ), +# +# ComparisonOperator = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ), +# fr = "Que faut-il ne pas depasser : un maximum ou un minimum", +# ang = "What is the failure threshold : maximum or minimum", +# ), +# ), # Fin FACT Event +# +# +# Method = SIMP( statut = "o", +# typ = "TXM", +# into = ( "Simulation", "FORM_SORM" ), +# fr = "Methode", +# ang = "Method", +# ), +# +# SimulationSettings = BLOC( condition = " Method in ( 'Simulation', ) ", +# +# Algorithm = SIMP( statut = "o", +# typ = "TXM", +# into = ( "MonteCarlo", "LHS", "ImportanceSampling" ), +# fr = "Algorithme de simulation", +# ang = "Simulation algorithm", +# ), +# +# +# RandomGenerator = FACT ( statut = "o", +# min = 1, +# max = 1, +# +# SeedToBeSet = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'no', +# max = 1, +# fr = "La racine du generateur aleatoire doit-elle etre positionnee ?", +# ang = "Does the random generator seed need to be set ?", +# ), +# +# SeedSettings = BLOC( condition = " SeedToBeSet in ( 'yes', ) ", +# +# RandomGeneratorSeed = SIMP( statut = "o", +# typ = "I", +# max = 1, +# fr = "Racine du generateur aleatoire", +# ang = "Random generator seed", +# ), +# +# ), # Fin BLOC SeedSettings +# +# ), # Fin FACT RandomGenerator +# +# +# BlockSize = SIMP( statut = "o", +# typ = "I", +# max = 1, +# val_min = 1, +# defaut = 1, +# fr = "Nombre de calculs realises en bloc", +# ang = "Number of computations as a block", +# ), +# +# MaximumOuterSampling = SIMP( statut = "o", +# typ = "I", +# max = 1, +# val_min = 1, +# fr = "Maximum d'iterations externes", +# ang = "Maximum outer Sampling value", +# ), +# +# MaximumCoefficientOfVariation = SIMP( statut = "o", +# typ = "R", +# max = 1, +# defaut = 0.1, +# val_min = 0.0, +# val_max = 1.0, +# fr = "Coefficient de variation maximum", +# ang = "Maximum coefficient of variation" +# ), +# +# ImportanceSamplingSettings = BLOC( condition = " Algorithm in ( 'ImportanceSampling', ) ", +# +# MeanVector = SIMP( statut = "o", +# typ = "R", +# max = "**", +# fr = "Moyenne", +# ang = "Mean vector", +# ), +# +# +# ), # Fin BLOC ImportanceSamplingSettings +# +# Result = FACT ( statut = "o", +# min = 1, +# max = "**", +# +# Probability = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', ), +# defaut = 'yes', +# max = 1, +# fr = "Probabiblite", +# ang = "Probability", +# ), +# +# StandardDeviation = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', ), +# defaut = 'yes', +# max = 1, +# fr = "Ecart type", +# ang = "Standard deviation", +# ), +# +# ConfidenceInterval = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Intervale de confiance", +# ang = "Confidence interval", +# ), +# +# ConfidenceIntervalSettings = BLOC( condition = " ConfidenceInterval in ( 'yes', ) ", +# +# Level = SIMP( statut = "o", +# typ = 'R', +# defaut = 0.9, +# max = 1, +# val_min = 0.0, +# val_max = 1.0, +# fr = "Niveau de confiance", +# ang = "Confidence level", +# ), +# +# ), # Fin BLOC ConfidenceIntervalSettings +# +# VariationCoefficient = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Coefficient de variation", +# ang = "Coefficient of variation", +# ), +# +# SimulationsNumber = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Nombre d'iterations", +# ang = "Iteration number", +# ), +# +# ConvergenceGraph = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Graphe de convergence", +# ang = "Convergence graph", +# ), +# +# ConvergenceGraphSettings = BLOC( condition = " ConvergenceGraph in ( 'yes', ) ", +# +# ConvergenceDrawingFilename = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# fr = "Nom du fichier graphique de la convergence", +# ang = "Convergence Drawing Filename", +# ), +# +# +# ), # Fin BLOC ConvergenceGraphSettings +# +# ), # Fin FACT Result +# +# +# +# ), # Fin BLOC SimulationSettings +# +# +# +# FORM_SORMSettings = BLOC( condition = " Method in ( 'FORM_SORM', ) ", +# +# Approximation = SIMP( statut = "o", +# typ = "TXM", +# defaut = "FirstOrder", +# into = ( "FirstOrder", "SecondOrder" ), +# max = 1, +# fr = "Approximation", +# ang = "Approximation", +# ), +# +# OptimizationAlgorithm = SIMP( statut = "o", +# typ = "TXM", +# defaut = "Cobyla", +# into = ( "Cobyla", "AbdoRackwitz" ), +# max = 1, +# fr = "Methode d'optimisation", +# ang = "Optimization method", +# ), +# +# +# PhysicalStartingPoint = SIMP( statut = "f", +# typ = "R", +# max = "**", +# fr = "Point de demarrage de l'algorithme iteratif", +# ang = "Initial point for iterative process", +# ), +# +# MaximumIterationsNumber = SIMP( statut = "f", +# typ = "I", +# max = 1, +# val_min = 1, +# fr = "Nombre maximum d'iterations", +# ang = "Maximum number of iterations", +# ), +# +# +# MaximumAbsoluteError = SIMP( statut = "o", +# typ = "R", +# max = 1, +# defaut = 1E-4, +# val_min = 0.0, +# fr = "Distance maximum absolue entre 2 iterations successives", +# ang = "Absolute maximum distance between 2 successive iterates", +# ), +# +# MaximumRelativeError = SIMP( statut = "o", +# typ = "R", +# max = 1, +# defaut = 1E-4, +# val_min = 0.0, +# fr = "Distance maximum relative entre 2 iterations successives", +# ang = "Relative maximum distance between 2 successive iterates", +# ), +# +# MaximumConstraintError = SIMP( statut = "o", +# typ = "R", +# max = 1, +# defaut = 1E-4, +# val_min = 0.0, +# fr = "Valeur maximum absolue de la fonction moins la valeur du niveau", +# ang = "Maximum absolute value of the constraint function minus the level value", +# ), +# +# ImportanceSampling = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'no', +# max = 1, +# fr = "Tirage d'importance au point de conception", +# ang = "Importance sampling at design point", +# ), +# +# FORMResult = BLOC( condition = " Approximation in ( 'FirstOrder', ) ", +# +# Probability = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', ), +# defaut = 'yes', +# max = 1, +# fr = "Probabiblite", +# ang = "Probability", +# ), +# +# DesignPoint = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Point de conception", +# ang = "Design point", +# ), +# +# HasoferReliabilityIndex = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Indice de fiabilite", +# ang = "Reliability index", +# ), +# +# ImportanceFactor = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Facteur d'importance pour variable de sortie scalaire", +# ang = "Importance factor", +# ), +# +# ImportanceFactorSettings = BLOC( condition = " ImportanceFactor in ( 'yes', ) ", +# +# ImportanceFactorDrawingFilename = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# fr = "Nom du fichier graphique des facteurs d'importance", +# ang = "Importance Factor Drawing Filename", +# ), +# +# +# ), # Fin BLOC ImportanceFactorSettings +# +# SensitivityAnalysis = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Analyse de sensibilite", +# ang = "Sensitivity analysis", +# ), +# +# SensitivityAnalysisSettings = BLOC( condition = " SensitivityAnalysis in ( 'yes', ) ", +# +# FORMEventProbabilitySensitivity = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Indice de fiabilite de Hasofer", +# ang = "Hasofer reliability index", +# ), +# +# FORMEventProbabilitySensitivitySettings = BLOC( condition = " FORMEventProbabilitySensitivity in ( 'yes', ) ", +# +# FORMEventProbabilitySensitivityDrawingFilename = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# fr = "Nom du fichier graphique des sensibilites", +# ang = "Sensitivity Drawing Filename", +# ), +# +# +# ), # Fin BLOC FORMEventProbabilitySensitivitySettings +# +# HasoferReliabilityIndexSensitivity = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Indice de fiabilite de Hasofer", +# ang = "Hasofer reliability index", +# ), +# +# HasoferReliabilityIndexSensitivitySettings = BLOC( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ", +# +# HasoferReliabilityIndexSensitivityDrawingFilename = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# fr = "Nom du fichier graphique des sensibilites", +# ang = "Sensitivity Drawing Filename", +# ), +# +# +# ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings +# +# ), # Fin BLOC SensitivityAnalysisSettings +# +# FunctionCallsNumber = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Nombre d'appels a la fonction", +# ang = "Function calls number", +# ), +# +# +# ), # Fin BLOC FORMResult +# +# +# SORMResult = BLOC( condition = " Approximation in ( 'SecondOrder', ) ", +# +# +# TvedtApproximation = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Approximation de Tvedt", +# ang = "Tvedt approximation", +# ), +# +# HohenBichlerApproximation = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Approximation de HohenBichler", +# ang = "HohenBichler approximation", +# ), +# +# BreitungApproximation = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Approximation de Breitung", +# ang = "Breitung approximation", +# ), +# +# DesignPoint = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Point de conception", +# ang = "Design point", +# ), +# +# ImportanceFactor = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Facteur d'importance pour variable de sortie scalaire", +# ang = "Importance factor", +# ), +# +# ImportanceFactorSettings = BLOC( condition = " ImportanceFactor in ( 'yes', ) ", +# +# ImportanceFactorDrawingFilename = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# fr = "Nom du fichier graphique des facteurs d'importance", +# ang = "Importance Factor Drawing Filename", +# ), +# +# +# ), # Fin BLOC ImportanceFactorSettings +# +# SensitivityAnalysis = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Analyse de sensibilite", +# ang = "Sensitivity analysis", +# ), +# +# SensitivityAnalysisSettings = BLOC( condition = " SensitivityAnalysis in ( 'yes', ) ", +# +# HasoferReliabilityIndexSensitivity = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Indice de fiabilite de Hasofer", +# ang = "Hasofer reliability index", +# ), +# +# HasoferReliabilityIndexSensitivitySettings = BLOC( condition = " HasoferReliabilityIndexSensitivity in ( 'yes', ) ", +# +# HasoferReliabilityIndexSensitivityDrawingFilename = SIMP( statut = "o", +# typ = "TXM", +# max = 1, +# fr = "Nom du fichier graphique des sensibilites", +# ang = "Sensitivity Drawing Filename", +# ), +# +# +# ), # Fin BLOC FHasoferReliabilityIndexSensitivitySettings +# +# ), # Fin BLOC SensitivityAnalysisSettings +# +# FunctionCallsNumber = SIMP( statut = "o", +# typ = 'TXM', +# into = ( 'yes', 'no' ), +# defaut = 'yes', +# max = 1, +# fr = "Nombre d'appels a la fonction", +# ang = "Function calls number", +# ), +# +# +# ), # Fin BLOC SecondOrder +# +# +# +# ), # Fin BLOC FORM_SORMSettings +# +# +# +# ), # Fin BLOC ThresholdExceedence +#) # Fin PROC CRITERIA +# +# + +def affineDistribution(monDicoVarDeter,var,loi): + nomLoi=list(monDicoVarDeter[var].keys())[0] + argsLoi=loi[nomLoi] + nomFonction='cree'+nomLoi + maFonction=globals()[nomFonction] + bloc=maFonction(**argsLoi) + + +def creeDistributionsSelonVariable(monDicoVarDeter): + lesBlocs={} + for var in monDicoVarDeter : + listeLoisComplete=monDicoVarDeter[var] + listeChoix=[] + for loi in listeLoisComplete: + nomLoi=list(loi.keys())[0] + listeChoix.append(nomLoi) + nomBlocVar = 'b_Model_Variable_' + var + laCondition ="ModelVariable == '" + var + "'" + distribution = SIMP(statut='o', typ='TXM', into=listeChoix) + dicoDistribution={} + for loi in listeLoisComplete: + nomLoi = list(loi.keys())[0] + argsLoi = loi[nomLoi] + nomFonction = 'cree'+nomLoi + maFonction = globals()[nomFonction] + bloc = maFonction(**argsLoi) + nomBloc = 'b_Model_Variable_' + var+'_'+nomLoi + dicoDistribution[nomBloc]=bloc + lesBlocs[nomBlocVar]= BLOC(condition=laCondition, Distribution = distribution, **dicoDistribution) + return lesBlocs + + +def definitIntoOuput(objExpression, contexte): + # protege par un gros try -) + debug=0 + if debug : print ('dans definitIntoOutput', objExpression) + jdc=objExpression.jdc + if not jdc : return + if debug : print (jdc) + monScenario=jdc.getEtapesByName('Scenario_data')[0] + if debug : print (monScenario) + mesPostPro=monScenario.getChildOrChildInBloc('post_processing') + if debug : print (mesPostPro) + if not mesPostPro : return + mesPostPro.definition.changeSiValide(changeIntoOuput) + changeIntoOuput(mesPostPro) + + +def changeIntoOuput(objPostPro): + mesPostProVal=objPostPro.valeur + contexte=objPostPro.etape.parent.g_context + # on essaye d assurer la compatibilite du catalogue UQ pour les 2 versions du catalogue RN_EDG + if len(mesPostProVal[0]) == 2 : + for (variable,fonct) in mesPostProVal : + if fonct == 'MED' : continue + nomVar=variable.split('@')[0] + phys=variable.split('@')[1] + nomAProposer= variable+'@'+fonct + nomBloc = 'b_physique_' + phys + nomBlocVar = ('b_var_'+nomVar).replace( ' ','__') + maDef=contexte['ExpressionIncertitude'].entites['Output'].entites['VariableDeSortie'].entites[nomBloc].entites[nomBlocVar].entites['VariablePosttraiteeAssociee'] + maDef.addInto(nomAProposer) + if len(mesPostProVal[0]) == 3 : + for (nomVar,phys,fonct) in mesPostProVal : + if '@' in nomVar : continue # Les noms des grandeurs et les associations à leurs définitions doivent être revues dans une nvlle version du cata_RN.py + if fonct == 'MED' : continue + nomAProposer= nomVar+'@'+phys+'@'+fonct + nomBloc = 'b_physique_' + phys + nomBlocVar = ('b_var_'+nomVar).replace( ' ','__') + # Les variables ne sont pas dans le catalogue catalog_uq.py donc pas proposees + try : + maDef=contexte['ExpressionIncertitude'].entites['Output'].entites['VariableDeSortie'].entites[nomBloc].entites[nomBlocVar].entites['VariablePosttraiteeAssociee'] + maDef.addInto(nomAProposer) + except : pass + +def creeOutput(monDicoVarSortie,scriptPosttraitement): + intoVariable=list(monDicoVarSortie.keys()) + lesBlocs={} + Physique = SIMP (statut = "o", typ = "TXM",into = intoVariable,defaut=intoVariable[0]) + for phys in intoVariable : + laCondition = "Physique == '" + phys + "'" + VariablePhysique = SIMP(statut = "o", typ = "TXM", into = monDicoVarSortie[phys], ) + Unit = SIMP ( statut = "f", typ = "TXM", fr = "Unite", ang = "Unit",) + Format = SIMP ( statut = "f", typ = "TXM", fr = "Format de sortie", ang = "format", into =['med', 'csv']) + lesBlocsVar={} + for v in monDicoVarSortie[phys] : + VariablePosttraiteeAssociee = SIMP ( statut = "o", typ = "TXM", into=[]) + Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut="la Variable Post Traitée associée doit être présente dans la variable post_processing de Scenario_Data") + laConditionVar ="VariablePhysique == '" + v + "'" + nomBlocVar=('b_var_'+v).replace( ' ','__') + lesBlocsVar[nomBlocVar]= BLOC (condition=laConditionVar, VariablePosttraiteeAssociee=VariablePosttraiteeAssociee, Consigne=Consigne) + nomBloc = 'b_physique_' + phys + lesBlocs[nomBloc] = BLOC (condition=laCondition, VariablePhysique = VariablePhysique, **lesBlocsVar) + FonctionDAggregation = SIMP(statut = 'o', typ= 'TXM', into = ('valeur à t=O', 'valeur à mi-temps', 'valeur à t final', 'valeur moyenne', 'valeur cumulée', 'valeur minimale', 'valeur maximale' ), + defaut=('Max'), max='**', homo='SansOrdreNiDoublon', avecBlancs=True) + ScriptPosttraitement=SIMP( + fr="Nom du fichier Script de Postraitement", + ang="Postprocessing Script File", + statut="o", + typ=("FichierNoAbs", "All Files ()"), defaut=scriptPosttraitement) + VariableDeSortie = FACT ( max='**', statut ='o', Physique=Physique, **lesBlocs, FonctionDAggregation=FonctionDAggregation, Unit=Unit,Format=Format) + output = FACT (max=1, statut ='o', VariableDeSortie=VariableDeSortie, ScriptPosttraitement=ScriptPosttraitement) + return output + +def creeOperExpressionIncertitude(monDicoVarDeter, monDicoVarSortie,scriptPosttraitement, scriptDeLancement ): + listeDesVariablesPossibles = list(monDicoVarDeter.keys()) + #monOutput = creeOutput(monDicoVarSortie) + objectName = SIMP ( statut = "f", typ = 'TXM', into=[], fenetreIhm='menuDeroulant', homo='constant' ) # on ne met pas [] pour la projection XSD, intoXML=? + modelVariable = SIMP ( statut = "o", + typ = ( 'TXM'), + fr = "Variable d'entrée du modèle", + ang = "Input variable of the model", + into = listeDesVariablesPossibles, + fenetreIhm='menuDeroulant', + homo='constant', + ) + Consigne = SIMP(statut="o", homo="information", typ="TXM", defaut=' ') + MCPath = SIMP(statut='d', typ='TXM', defaut=(), max='**', min=0, avecBlancs = True) + blocs=creeDistributionsSelonVariable(monDicoVarDeter) + # Attention + # l ordre des motclefs en 3.7 a l air de dépendre de l ordre de creation des objets + # et non d un dict ordonné. on retombe toujours sur ce pb + return PROC ( nom = "ExpressionIncertitude", UIinfo={"groupes":("CACHE",)}, op_init=definitIntoOuput, + UncertaintyTool = SIMP ( statut = "o", typ = "TXM", into = ['Uranie', 'OpenTurns'], defaut='OpenTurns',position='global'), + Input = FACT( max=1, statut ='o', + VariableProbabiliste = FACT ( max='**', statut ='cache', + fr = "Variable probabiliste", + ang = "Probabilistic variable", + ObjectName = objectName, + ModelVariable = modelVariable, + Consigne = Consigne, + MCPath = MCPath, + **blocs + ), + ), + Propagation = FACT( max=1, statut ='o', + #UncertaintyTool = SIMP ( statut = "o", typ = "TXM", into = ['Uranie', 'OpenTurns'], defaut='Uranie',position='global'), + Propagation_OT = BLOC( condition = "UncertaintyTool == 'OpenTurns'", + Methode = SIMP( statut = "o", typ = "TXM", max=1, into = ('Taylor', 'MonteCarlo'), defaut='Taylor'), + BlocMonteCarlo1 = BLOC ( condition = "Methode == 'MonteCarlo'", + CritereArret = FACT ( statut = "o", max = 1, + regles = (AU_MOINS_UN('SimulationsNumber','MaximumElapsedTime'),), + # TODO : regles = (AU_MOINS_UN('Accuracy', 'SimulationsNumber','MaximumElapsedTime'),), + Accuracy = SIMP ( statut = "o", typ = "R", #TODO: statut = "f" + val_min = 0.0, val_max = 1.0, sug = 0.01, #TODO: val_min > 0 + fr = "Coefficient de variation maximum à atteindre pour la moyenne", + ang = "Accuracy - the maximum coefficient of variation (CV) for the mean",), + SimulationsNumber = SIMP ( statut = "o", typ = "I", + val_min = 1, defaut =10000, + fr = "Nombre maximum de réalisations", + ang = "maximum sampling size ",), + MaximumElapsedTime = SIMP ( statut = "o", typ = "I", # Incohérence Doc Persalys : 60s par défaut + val_min = 1, defaut = 3600, #TODO: statut = "f" + unite = "secondes", + fr = "Temps elapse maximum pour l'exécution globale", + ang = "Maximum elapse time for the whole simulation",), + ), # FIN FACT CritereArret + EvaluationParameter = FACT ( statut = "o", max = 1, #TODO: BlockSize < SimulationsNumber + BlockSize = SIMP ( statut = "o", typ = "I", val_min = 1, defaut = 1, + fr = "Nombre d'évaluations en parallèle", + ang = "The number of runs launched simultaneously",), + ), # FIN FACT EvaluationParameter + AdvancedParameter = FACT ( statut = "f", max = 1, #TODO: BlockSize < SimulationsNumber + ComputeConfidenceIntervalAt = SIMP ( statut = "o", typ = "R", + val_min = 0, val_max = 0.9999, defaut = 0.95, + #TODO: avec statut = "f" && defaut = 0.95, + fr = "Demande le calcul de l'interval de confiance au niveau donné", + ang = "Require the computation of the confidence interval at a given level",), + Seed = SIMP ( statut = "o", typ = "I", val_min = 0, defaut = 0, + fr = "La graine d'initialisation du générateur aléatoire", + ang = "The seed of the random generator ",), + ), # FIN FACT AdvancedParameter + ), + BlocTaylor = BLOC( condition = "Methode == 'Taylor'", + Result = FACT( statut = "o", min = 1, + MeanFirstOrder = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Moyenne au premier ordre", + ang = "MeanFirstOrder",), + StandardDeviationFirstOrder = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Ecart-type au premier ordre", + ang = "StandardDeviationFirstOrder",), + MeanSecondOrder = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'no', + fr = "Moyenne au second ordre", + ang = "MeanSecondOrder",), + ),# fin Result + ), # fin BlocTaylor + BlocMonteCarlo2 = BLOC ( condition = "Methode == 'MonteCarlo'", + Result = FACT( statut = "o", min = 1, + EmpiricalMean = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Moyenne empirique", + ang = "Empirical mean",), + EmpiricalStandardDeviation = SIMP ( statut = "o", typ = 'TXM', into = ( 'yes', 'no' ), defaut = 'yes', + fr = "Ecart-type empirique", + ang = "Empirical standard deviation",), + EmpiricalQuantile = SIMP ( statut = "o", typ = 'TXM', into = ( 'no', ), defaut = 'no', #into = ( 'yes', 'no' ), + fr = "Quantile empirique (Non encore implémenté)", + ang = "Empirical quantile (Not Yet Implemented)",), + BlocEmpiricalQuantileSettings = BLOC ( condition = " EmpiricalQuantile in ( 'yes', ) ", + EmpiricalQuantile_Order = SIMP ( statut = "o", typ = 'R', defaut = 0.95, + val_min = 0.0, val_max = 1.0, + fr = "Ordre du quantile empirique", + ang = "Empirical quantile order",), + ), # Fin BlocEmpiricalQuantileSettings + ),# fin Result + ),# fin BlocMonteCarlo2 + ),# fin BlocOTPropagation + Propagation_Uranie = BLOC( condition = "UncertaintyTool == 'Uranie'", + Methode = SIMP( statut = "o", typ = "TXM", max=1, into = ('SRS', 'Sobol'), defaut='Sobol'), + ), # fin UraniePropagation + ), # fin Propagation + Output=creeOutput(monDicoVarSortie,scriptPosttraitement), + Execution = FACT (max=1, statut ='o', + bloc_OT = BLOC (condition = 'UncertaintyTool == "OpenTurns"', + ExecutionMode = SIMP ( statut = "o", typ = "TXM", into = ['desktop', 'cluster']), + NbDeBranches = SIMP ( statut = "o", typ = "I", val_min = 0, fr='nb d evaluations Persalys simultanees'), + bloc_OT_local = BLOC (condition = 'ExecutionMode == "desktop"', + JobName = SIMP ( statut = 'o', typ ="TXM", defaut='idefix_rn_job'), + ResourceName = SIMP ( statut = 'o', typ ="TXM", defaut ='localhost'), + Login = SIMP ( statut = 'o', typ ="TXM", defaut = os.getlogin() ), +# WorkDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/tmp/'+os.getlogin()+'_workingdir_uncertainty'), #TODO: Login + NonExistent + WorkDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/tmp/'+os.getlogin()+'_workingdir_uncertainty'), #TODO: NonExistent +# ResultDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/tmp/idefix_rn_job'), #TODO: JobName + ResultDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/tmp/idefix_rn_job'), #TODO: JobName + UncertaintyScript=SIMP( statut="o", typ=('Fichier' ,'py Files (*.py);;All Files (*)'), defaut=scriptDeLancement, + fr="Nom du fichier script de lancement", ang="script File to launch",), + ), + bloc_OT_cluster = BLOC (condition = 'ExecutionMode == "cluster"', + MultiJobStudy = SIMP ( statut = "o", typ = bool, defaut=False,fr='Si True, un job est soumis pour chaque évaluation de branche'), + NbOfProcs = SIMP ( statut = 'o', typ ="I" , defaut = 1, val_min = 1, fr='Equivaut au nombre de tasks SLURM affectées à chaque job'), + JobName = SIMP ( statut = 'o', typ ="TXM", defaut='idefix_rn_job'), + ResourceName = SIMP ( statut = 'o', typ ="TXM", defaut ='gaia'), + Login = SIMP( statut = 'o', typ ="TXM", defaut = os.getlogin()), + WorkDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/scratch/'+os.getlogin()+'/workingdir/persalys_light'), #TODO: Login +# WorkDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/scratch/'+os.getlogin()+'/workingdir/persalys_light'), #TODO: Login + ResultDirectory = SIMP ( statut = 'o', typ='TXM' , defaut='/tmp/idefix_rn_job'), #TODO: JobName +# ResultDirectory = SIMP ( statut = 'o', typ='Repertoire' , defaut='/tmp/idefix_rn_job'), #TODO: JobName + Consigne = SIMP(statut="o", homo="information", typ="TXM", + defaut="Le chemin d'accès au script de lancement est celui utilisé par les machines du cluster."), + UncertaintyScript = SIMP( statut="o", typ=("Fichier", "All Files ()"), defaut=scriptDeLancement, + fr="Nom du fichier script de lancement", ang="script File to launch",), + ), + ), + bloc_Uranie = BLOC (condition = 'UncertaintyTool == "Uranie"', + DOEDimensions = SIMP ( statut = "o", typ = "I"), + NbDeBranches = SIMP ( statut = "o", typ = "I", val_min = 0, fr='nb d evaluations simultanees'), + ), + ), + ) + return ExpressionIncertitude + diff --git a/Codes/ReacteurNumerique/lanceEficas.py b/Codes/ReacteurNumerique/lanceEficas.py new file mode 100644 index 00000000..04831f8d --- /dev/null +++ b/Codes/ReacteurNumerique/lanceEficas.py @@ -0,0 +1,40 @@ +# Copyright (C) 2007-2012 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +import sys, os +from pathlib import Path + +code="ReacteurNumerique" + +try : + eficasPath=os.environ['EFICAS_ROOT_DIR'] +except : + print ('Please, set EFICAS_ROOT_DIR') + exit(1) +sys.path.append(os.path.join(os.path.abspath(eficasPath))) + +name='prefs_' + code +prefFile = Path(name + ".py") +if (prefFile .is_file(): + try : + __import__(name) + except : + print ('Unable to import {}').format(prefFile) + exit(1) +from InterfaceQT4 import eficas_go +eficas_go.lanceEficas(code=prefs.code,GUI='QT5') diff --git a/Codes/ReacteurNumerique/prefs.py b/Codes/ReacteurNumerique/prefs.py new file mode 100755 index 00000000..e4ed9a42 --- /dev/null +++ b/Codes/ReacteurNumerique/prefs.py @@ -0,0 +1,22 @@ +# Copyright (C) 2007-2012 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +code="ReacteurNumerique" +import sys, os +if os.path.dirname(os.path.abspath(__file__)) not in sys.path : + sys.path.insert(0,os.path.dirname(os.path.abspath(__file__))) diff --git a/Codes/ReacteurNumerique/prefs_ReacteurNumerique.py b/Codes/ReacteurNumerique/prefs_ReacteurNumerique.py new file mode 100755 index 00000000..ae35e063 --- /dev/null +++ b/Codes/ReacteurNumerique/prefs_ReacteurNumerique.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# maConfiguration MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# +# +# ====================================================================== + +import traceback +traceback.print_stack() +import os,sys +# repIni sert a localiser le fichier editeur.ini +# Obligatoire +repIni=os.path.dirname(os.path.abspath(__file__)) +INSTALLDIR=os.path.join(repIni,'..') +sys.path[:0]=[INSTALLDIR] + + +# lang indique la langue utilisee pour les chaines d'aide : fr ou ang +lang='fr' + +# Codage des strings qui accepte les accents (en remplacement de 'ascii') +encoding='iso-8859-1' + +# +#typeDeCata='XML' +catalogues=( + ('ReacteurNumerique','Version Beta',os.path.join(repIni,'cata_RN_UQ.py'),'python','python'), + #('ReacteurNumerique','Version UQ',os.path.join(repIni,'cata_RN_EDG_Fake.py'),'python','python'), +) +#nombreDeBoutonParLigne=4 +simpleClic=True +#closeFrameRechercheCommande=True +boutonDsMenuBar=False +#closeArbre=True +afficheListesPliees=False +#withXSD=True +afficheCommandesPliees = False +#dumpXSD=True +#afficheIhm=False diff --git a/Efi2Xsd/ReadMe.txt b/Efi2Xsd/ReadMe.txt deleted file mode 100644 index 4c1dd01d..00000000 --- a/Efi2Xsd/ReadMe.txt +++ /dev/null @@ -1,7 +0,0 @@ -Pyxb --> accas -si simp on ne passe rien -sinon un dictPyxb avec valeur dict des objets clef=nom -et un objpyxb dans objpyxb - -il faut mettre à jour la liste en cohérence avec l ordered content -Attention aux blocs diff --git a/Extensions/CMakeLists.txt b/Extensions/CMakeLists.txt index e3ce0580..c8c84624 100644 --- a/Extensions/CMakeLists.txt +++ b/Extensions/CMakeLists.txt @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR diff --git a/Noyau/CMakeLists.txt b/Noyau/CMakeLists.txt index e3ce0580..c8c84624 100644 --- a/Noyau/CMakeLists.txt +++ b/Noyau/CMakeLists.txt @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR diff --git a/Noyau/N_ASSD.py b/Noyau/N_ASSD.py index 5f3dea15..a68be72d 100644 --- a/Noyau/N_ASSD.py +++ b/Noyau/N_ASSD.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,28 +20,24 @@ """ """ +from builtins import object -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import object -except : pass - class ASSD(object): """ - Classe de base pour definir des types de structures de donnees ASTER - equivalent d un concept ASTER - Doit_on garder tout ce qui concerne jeveux ? les concepts ? + Classe de base pour definir des types de structures de donnees ASTER + equivalent d un concept ASTER + Doit_on garder tout ce qui concerne jeveux ? les concepts ? """ + idracine = "SD" - def __init__(self, etape=None, sd=None, reg='oui'): + def __init__(self, etape=None, sd=None, reg="oui"): """ - reg est un parametre qui vaut oui ou non : - - si oui (défaut) : on enregistre la SD aupres du JDC - - si non : on ne l'enregistre pas + reg est un parametre qui vaut oui ou non : + - si oui (défaut) : on enregistre la SD aupres du JDC + - si non : on ne l'enregistre pas """ self.etape = etape self.sd = sd @@ -57,7 +53,7 @@ class ASSD(object): if not self.parent: self.id = None - elif reg == 'oui': + elif reg == "oui": self.id = self.parent.regSD(self) else: self.id = self.parent.o_register(self) @@ -78,9 +74,11 @@ class ASSD(object): def _getSdj(self): """Retourne le catalogue de SD associé au concept.""" if self.ptr_sdj is None: - cata_sdj = getattr(self, 'cata_sdj', None) - assert cata_sdj, "The attribute 'cata_sdj' must be defined in the class %s" \ + cata_sdj = getattr(self, "cata_sdj", None) + assert cata_sdj, ( + "The attribute 'cata_sdj' must be defined in the class %s" % self.__class__.__name__ + ) assert self.nom, "The attribute 'nom' has not been filled!" if self.ptr_class_sdj is None: self.ptr_class_sdj = importObject(cata_sdj) @@ -99,12 +97,12 @@ class ASSD(object): def __getitem__(self, key): text_error = "ASSD.__getitem__ est déprécié car la référence a l'objet ETAPE parent sera supprimée." from warnings import warn + warn(text_error, DeprecationWarning, stacklevel=2) return self.etape[key] def setName(self, nom): - """Positionne le nom de self - """ + """Positionne le nom de self""" self.nom = nom def isTypCO(self): @@ -119,12 +117,12 @@ class ASSD(object): def changeType(self, new_type): """Type connu a posteriori (type CO).""" self.__class__ = new_type - assert self._as_co != 0, 'it should only be called on CO object.' + assert self._as_co != 0, "it should only be called on CO object." self._as_co = 2 def getName(self): """ - Retourne le nom de self, éventuellement en le demandant au JDC + Retourne le nom de self, éventuellement en le demandant au JDC """ if not self.nom: try: @@ -132,7 +130,7 @@ class ASSD(object): except: self.nom = "" - if self.nom=='sansnom' or self.nom == '': + if self.nom == "sansnom" or self.nom == "": self.nom = self.id return self.nom @@ -153,52 +151,51 @@ class ASSD(object): # 'del self.sdj' appellerait la méthode '_getSdj()'... self._del_sdj() - def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitASSD(self) def __getstate__(self): """ - Cette methode permet de pickler les objets ASSD - Ceci est possible car on coupe les liens avec les objets - parent, etape et jdc qui conduiraient a pickler de nombreux - objets inutiles ou non picklables. - En sortie, l'objet n'est plus tout a fait le même ! + Cette methode permet de pickler les objets ASSD + Ceci est possible car on coupe les liens avec les objets + parent, etape et jdc qui conduiraient a pickler de nombreux + objets inutiles ou non picklables. + En sortie, l'objet n'est plus tout a fait le même ! """ d = self.__dict__.copy() - for key in ('parent', 'etape', 'jdc'): - if key in d : + for key in ("parent", "etape", "jdc"): + if key in d: del d[key] for key in list(d.keys()): - if key in ('_as_co', ): + if key in ("_as_co",): continue - if key[0] == '_': + if key[0] == "_": del d[key] return d def accessible(self): - """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD. - """ + """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD.""" if CONTEXT.debug: - print(('| accessible ?', self.nom)) + print(("| accessible ?", self.nom)) is_accessible = CONTEXT.getCurrentStep().sdAccessible() if CONTEXT.debug: - print((' `- is_accessible =', repr(is_accessible))) + print((" `- is_accessible =", repr(is_accessible))) return is_accessible def filter_context(self, context): """Filtre le contexte fourni pour retirer (en gros) ce qui vient du catalogue.""" from .N_ENTITE import ENTITE import types + ctxt = {} for key, value in list(context.items()): if type(value) is type: continue - if type(value) is types.ModuleType and value.__name__.startswith('Accas'): + if type(value) is types.ModuleType and value.__name__.startswith("Accas"): continue if issubclass(type(value), type): continue @@ -210,58 +207,62 @@ class ASSD(object): def parLot(self): """Conserver uniquement pour la compatibilite avec le catalogue v9 dans eficas.""" # XXX eficas - if not hasattr(self, 'jdc') or self.jdc == None: + if not hasattr(self, "jdc") or self.jdc == None: val = None else: val = self.jdc.parLot - return val == 'OUI' - + return val == "OUI" def getEficasAttribut(self, attribut): - #print ('getEficasAttribut : ', self, attribut) - valeur=self.etape.getMocle(attribut) - try : - valeur=self.etape.getMocle(attribut) - except : + # print ('getEficasAttribut : ', self, attribut) + valeur = self.etape.getMocle(attribut) + try: + valeur = self.etape.getMocle(attribut) + except: valeur = None - #print (valeur) + # print (valeur) return valeur - def getEficasListOfAttributs(self,listeAttributs): + def getEficasListOfAttributs(self, listeAttributs): from .N_MCLIST import MCList - #print ('getEficasListOfAttributs pour', self,listeAttributs) - aTraiter=(self.etape,) - while len(listeAttributs) > 0 : - attribut=listeAttributs.pop(0) - nvListe=[] - for mc in aTraiter : - try : - resultat=mc.getMocle(attribut) - if isinstance(resultat,MCList): - for rmc in resultat : nvListe.append(rmc) - else : nvListe.append(resultat) - except : pass - aTraiter=nvListe - #print ('fin getEficasListOfAttributs ', nvListe) + + # print ('getEficasListOfAttributs pour', self,listeAttributs) + aTraiter = (self.etape,) + while len(listeAttributs) > 0: + attribut = listeAttributs.pop(0) + nvListe = [] + for mc in aTraiter: + try: + resultat = mc.getMocle(attribut) + if isinstance(resultat, MCList): + for rmc in resultat: + nvListe.append(rmc) + else: + nvListe.append(resultat) + except: + pass + aTraiter = nvListe + # print ('fin getEficasListOfAttributs ', nvListe) return nvListe - def ajouteUnPere(self,pere): + def ajouteUnPere(self, pere): # ne fait rien mais est appeler pour tous les types de ASSD pass -class assd(ASSD): +class assd(ASSD): def __convert__(cls, valeur): - # On accepte les vraies ASSD et les objets 'entier' et 'reel' - # qui font tout pour se faire passer pour de vrais entiers/réels. + # On accepte les vraies ASSD et les objets 'entier' et 'reel' + # qui font tout pour se faire passer pour de vrais entiers/réels. if isinstance(valeur, ASSD) or type(valeur) in (int, float): return valeur - raise ValueError(_(u"On attend un objet concept.")) + raise ValueError(_("On attend un objet concept.")) + __convert__ = classmethod(__convert__) class not_checked(ASSD): - def __convert__(cls, valeur): return valeur + __convert__ = classmethod(__convert__) diff --git a/Noyau/N_BLOC.py b/Noyau/N_BLOC.py index aa565492..cb5f17dc 100644 --- a/Noyau/N_BLOC.py +++ b/Noyau/N_BLOC.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -16,15 +16,12 @@ # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com - - """ Ce module contient la classe de definition BLOC qui permet de spécifier les caractéristiques des blocs de mots clés """ -from __future__ import absolute_import -from __future__ import print_function + import types import sys import traceback @@ -35,43 +32,55 @@ from .N_Exception import AsException from .N_types import forceList - class BLOC(N_ENTITE.ENTITE): """ - Classe pour definir un bloc de mots-cles + Classe pour definir un bloc de mots-cles - Cette classe a deux attributs de classe : + Cette classe a deux attributs de classe : - - class_instance qui indique la classe qui devra etre utilisée - pour créer l'objet qui servira à controler la conformité d'un - bloc de mots-clés avec sa définition - - label qui indique la nature de l'objet de définition (ici, BLOC) + - class_instance qui indique la classe qui devra etre utilisée + pour créer l'objet qui servira à controler la conformité d'un + bloc de mots-clés avec sa définition + - label qui indique la nature de l'objet de définition (ici, BLOC) """ - class_instance = N_MCBLOC.MCBLOC - label = 'BLOC' - def __init__(self, fr="", docu="", regles=(), statut='f', condition=None,ang="", nomXML=None, - **args): + class_instance = N_MCBLOC.MCBLOC + label = "BLOC" + + def __init__( + self, + fr="", + docu="", + regles=(), + statut="f", + condition=None, + ang="", + nomXML=None, + exclusif=False, + **args + ): """ - Un bloc est caractérisé par les attributs suivants : - - - fr : chaine de caractere commentaire pour aide en ligne (en francais) - - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets - - statut : obligatoire ('o') ou facultatif ('f') - - condition : chaine de caractère evaluable par l'interpreteur Python - - entites : dictionnaire contenant les sous-objets de self (mots-clés). - La clé du dictionnaire est le nom du mot-clé et la valeur l'objet de - définition correspondant. Cet attribut est initialisé avec l'argument - args de la méthode __init__ + Un bloc est caractérisé par les attributs suivants : + + - fr : chaine de caractere commentaire pour aide en ligne (en francais) + - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets + - statut : obligatoire ('o') ou facultatif ('f') + - condition : chaine de caractère evaluable par l'interpreteur Python + - exclusif : ne s active pas en meme temps que ses blocs freres + - entites : dictionnaire contenant les sous-objets de self (mots-clés). + La clé du dictionnaire est le nom du mot-clé et la valeur l'objet de + définition correspondant. Cet attribut est initialisé avec l'argument + args de la méthode __init__ """ # Initialisation des attributs self.fr = fr self.ang = ang self.docu = docu - self.fenetreIhm=None + self.fenetreIhm = None + self.exclusif = exclusif if type(regles) == tuple: self.regles = regles else: @@ -81,86 +90,113 @@ class BLOC(N_ENTITE.ENTITE): self.nomXML = nomXML self.entites = args self.affecter_parente() - self.txtNomComplet = '' + self.txtNomComplet = "" + self.possedeDejaUnMCFactorise = False def __call__(self, val, nom, parent=None, dicoPyxbDeConstruction=None): """ - Construit un objet MCBLOC a partir de sa definition (self) - de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent) + Construit un objet MCBLOC a partir de sa definition (self) + de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent) """ - return self.class_instance(nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction) + return self.class_instance( + nom=nom, + definition=self, + val=val, + parent=parent, + dicoPyxbDeConstruction=dicoPyxbDeConstruction, + ) def verifCata(self): """ - Cette méthode vérifie si les attributs de définition sont valides. - Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr). + Cette méthode vérifie si les attributs de définition sont valides. + Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr). """ self.checkFr() self.checkDocu() self.checkRegles() - self.checkStatut(into=('f', 'o')) + self.checkStatut(into=("f", "o")) self.checkCondition() self.verifCataRegles() - def verifPresence(self, dict, globs): """ - Cette méthode vérifie si le dictionnaire passé en argument (dict) - est susceptible de contenir un bloc de mots-clés conforme à la - définition qu'il porte. - Si la réponse est oui, la méthode retourne 1 - Si la réponse est non, la méthode retourne 0 - - Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs - les valeurs des mots-clés + Cette méthode vérifie si le dictionnaire passé en argument (dict) + est susceptible de contenir un bloc de mots-clés conforme à la + définition qu'il porte. + Si la réponse est oui, la méthode retourne 1 + Si la réponse est non, la méthode retourne 0 + + Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs + les valeurs des mots-clés """ # On recopie le dictionnaire pour protéger l'original dico = blocUtils() dico.update(dict) if self.condition != None: try: - #if 1 : + # if 1 : test = eval(self.condition, globs, dico) return test - #try: + # try: # 1 except NameError: # erreur 'normale' : un mot-clé n'est pas présent et on veut # l'évaluer dans la condition if CONTEXT.debug: l = traceback.format_exception( - sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]) - print(("WARNING : Erreur a l'evaluation de la condition " + ''.join(l))) + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) + print( + ( + "WARNING : Erreur a l'evaluation de la condition " + + "".join(l) + ) + ) return 0 except SyntaxError: # le texte de la condition n'est pas du Python correct --> # faute de catalogue l = traceback.format_exception( - sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]) + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) raise AsException( - "Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom, - '\n', "Erreur dans la condition : ", self.condition, ''.join(l)) + "Catalogue entite : ", + self.nom, + ", de pere : ", + self.pere.nom, + "\n", + "Erreur dans la condition : ", + self.condition, + "".join(l), + ) except: l = traceback.format_exception( - sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]) + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) raise AsException( - "Catalogue entite : ", self.nom, ", de pere : ", self.pere.nom, - '\n', "Erreur dans la condition : ", self.condition, ''.join(l)) + "Catalogue entite : ", + self.nom, + ", de pere : ", + self.pere.nom, + "\n", + "Erreur dans la condition : ", + self.condition, + "".join(l), + ) else: return 0 - - - def longueurDsArbre(self): - longueur=0 - for mc in self.mcListe : + longueur = 0 + for mc in self.mcListe: longueur = longueur + mc.longueurDsArbre() return longueur + def blocUtils(): """Définit un ensemble de fonctions utilisables pour écrire les conditions de BLOC.""" + def au_moins_un(mcsimp, valeurs): """Valide si la (ou une) valeur de 'mcsimp' est au moins une fois dans la ou les 'valeurs'. Similaire à la règle AU_MOINS_UN, 'mcsimp' peut @@ -173,12 +209,14 @@ def blocUtils(): """Valide si aucune des valeurs de 'mcsimp' n'est dans 'valeurs'.""" return not au_moins_un(mcsimp, valeurs) - def getEficasAttribut( nomUserASSD, nomAttr): - if nomUserASSD == None : return None - return ( nomUserASSD.getEficasAttribut(nomAttr)) + def getEficasAttribut(nomUserASSD, nomAttr): + if nomUserASSD == None: + return None + return nomUserASSD.getEficasAttribut(nomAttr) - def getEficasListOfAttributs( nomASSD, listeAttributs): - if nomASSD == None : return () - return ( nomASSD.getEficasListOfAttributs(listeAttributs)) + def getEficasListOfAttributs(nomASSD, listeAttributs): + if nomASSD == None: + return () + return nomASSD.getEficasListOfAttributs(listeAttributs) return locals() diff --git a/Noyau/N_CO.py b/Noyau/N_CO.py index 4f189595..ec524bd8 100644 --- a/Noyau/N_CO.py +++ b/Noyau/N_CO.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -18,20 +18,15 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -from __future__ import absolute_import from .N_ASSD import ASSD from .N_Exception import AsException from .N_VALIDATOR import ValError from . import N_utils -#from asojb import AsBase - - -#class CO(ASSD, AsBase): -class CO(ASSD) : +class CO(ASSD): def __init__(self, nom): - ASSD.__init__(self, etape=None, sd=None, reg='oui') + ASSD.__init__(self, etape=None, sd=None, reg="oui") self._as_co = 1 # # On demande le nommage du concept @@ -42,7 +37,8 @@ class CO(ASSD) : except AsException as e: appel = N_utils.calleeWhere(niveau=2) raise AsException( - "Concept CO, fichier: ", appel[1], " ligne : ", appel[0], '\n', e) + "Concept CO, fichier: ", appel[1], " ligne : ", appel[0], "\n", e + ) else: self.nom = nom @@ -50,4 +46,5 @@ class CO(ASSD) : if valeur.isTypCO(): return valeur raise ValError("Pas un concept CO") + __convert__ = classmethod(__convert__) diff --git a/Noyau/N_CONVERT.py b/Noyau/N_CONVERT.py index 426caa46..7f606a59 100644 --- a/Noyau/N_CONVERT.py +++ b/Noyau/N_CONVERT.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,33 +20,25 @@ """ Module de conversion des valeurs saisies par l'utilisateur après vérification. """ - -from __future__ import absolute_import -try: - from builtins import object -except : pass - +from builtins import object from .N_types import isInt, isFloat, isSequence def hasIntValue(real): - """Est-ce que 'real' a une valeur entière ? - """ - return abs(int(real) - real) < 1.e-12 + """Est-ce que 'real' a une valeur entière ?""" + return abs(int(real) - real) < 1.0e-12 class Conversion(object): - """Conversion de type. - """ + """Conversion de type.""" def __init__(self, name, typeACreer): self.name = name self.typeACreer = typeACreer def convert(self, obj): - """Filtre liste - """ + """Filtre liste""" in_as_seq = isSequence(obj) if not in_as_seq: obj = (obj,) @@ -63,25 +55,23 @@ class Conversion(object): return tuple(result) def function(self, o): - raise NotImplementedError('cette classe doit être dérivée') + raise NotImplementedError("cette classe doit être dérivée") class TypeConversion(Conversion): - """Conversion de typeACreer - """ + """Conversion de typeACreer""" def __init__(self, typeACreer): - Conversion.__init__(self, 'type', typeACreer) + Conversion.__init__(self, "type", typeACreer) class IntConversion(TypeConversion): - """Conversion en entier - """ + """Conversion en entier""" def __init__(self): - TypeConversion.__init__(self, 'I') + TypeConversion.__init__(self, "I") def function(self, o): if isFloat(o) and hasIntValue(o): @@ -91,11 +81,10 @@ class IntConversion(TypeConversion): class FloatConversion(TypeConversion): - """Conversion de type - """ + """Conversion de type""" def __init__(self): - TypeConversion.__init__(self, 'R') + TypeConversion.__init__(self, "R") def function(self, o): if isFloat(o): @@ -108,35 +97,41 @@ class UserASSDConversion(TypeConversion): TypeConversion.__init__(self, classUser) def function(self, o): - #print ('je convertis : ', o, 'en ', self.typeACreer ) - #import traceback - #traceback.print_stack() - if o == None : return None - #print ('je cree UserASSDConversion', o, ' ', self.typeACreer) - nouvelObj=self.typeACreer(o) + # print ('je convertis : ', o, 'en ', self.typeACreer ) + # import traceback + # traceback.print_stack() + if o == None: + return None + # print ('je cree UserASSDConversion', o, ' ', self.typeACreer) + nouvelObj = self.typeACreer(o) return nouvelObj + class UserASSDMultipleConversion(TypeConversion): def __init__(self, classUser): TypeConversion.__init__(self, classUser) def function(self, o): - if o == None : return None - #print ('je cree dans UserASSDMultipleConversion', o, ' ', self.typeACreer) - nouvelObj=self.typeACreer(o) + if o == None: + return None + # print ('je cree dans UserASSDMultipleConversion', o, ' ', self.typeACreer) + nouvelObj = self.typeACreer(o) return nouvelObj + _convertI = IntConversion() _convertR = FloatConversion() def ConversionFactory(name, typ): - if name == 'type': - if 'I' in typ : return _convertI - elif 'R' in typ : return _convertR - if name == 'UserASSD': - #print(typ) - return (UserASSDConversion(typ)) - if name == 'UserASSDMultiple': - return (UserASSDMultipleConversion(typ)) + if name == "type": + if "I" in typ: + return _convertI + elif "R" in typ: + return _convertR + if name == "UserASSD": + # print(typ) + return UserASSDConversion(typ) + if name == "UserASSDMultiple": + return UserASSDMultipleConversion(typ) return None diff --git a/Noyau/N_CR.py b/Noyau/N_CR.py index 4ce27e7d..074cc977 100644 --- a/Noyau/N_CR.py +++ b/Noyau/N_CR.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,29 +20,23 @@ """ Ce module contient la classe compte-rendu de validation """ - -from __future__ import absolute_import -try : - from builtins import str - from builtins import object -except : - pass -import six +from builtins import str +from builtins import object class CR(object): """ - Classe servant a la construction et a l'affichage des objets Comptes-rendus + Classe servant a la construction et a l'affichage des objets Comptes-rendus """ - def __init__(self, verbeux='non', debut='', fin='', dec=' '): + def __init__(self, verbeux="non", debut="", fin="", dec=" "): """ - Attributs - - verbeux - - debut - - fin - - dec + Attributs + - verbeux + - debut + - fin + - dec """ self.verbeux = verbeux self.debut = debut @@ -55,30 +49,30 @@ class CR(object): self.subcr = [] def ok(self, comment): - """ Ajoute un commentaire OK a la liste crok""" + """Ajoute un commentaire OK a la liste crok""" self.crok.append(comment) def warn(self, comment): - """ Ajoute un commentaire Warning a la liste crwarn""" + """Ajoute un commentaire Warning a la liste crwarn""" self.crwarn.append(comment) def fatal(self, comment, *args): """Ajoute un commentaire Erreur Fatale a la liste crfatal a formater""" self.crfatal.append(comment) - self.crfatal.append(str( *args)) + self.crfatal.append(str(*args)) def exception(self, comment): - """ Ajoute un commentaire Exception a la liste crexception""" + """Ajoute un commentaire Exception a la liste crexception""" self.crexception.append(comment) def add(self, cr): - """ Ajoute un objet CR a la liste subcr :il s'agit de l'objet CR d'un fils de self """ + """Ajoute un objet CR a la liste subcr :il s'agit de l'objet CR d'un fils de self""" self.subcr.append(cr) def estvide(self): """ - Retourne 1 si self ne contient aucun message grave (fatal ou exception) - et aucun CR qui en contienne, 0 sinon + Retourne 1 si self ne contient aucun message grave (fatal ou exception) + et aucun CR qui en contienne, 0 sinon """ if self.crexception: return 0 @@ -91,11 +85,11 @@ class CR(object): def purge(self): """ - Purge complètement le CR sauf les exceptions + Purge complètement le CR sauf les exceptions """ - self.debut = '' - self.fin = '' - self.dec = ' ' + self.debut = "" + self.fin = "" + self.dec = " " self.crok = [] self.crwarn = [] self.crfatal = [] @@ -103,53 +97,53 @@ class CR(object): def beautifieMessages(self): """ - Beautifie les messages stockés dans crok,crfatal,crexception et crwarn + Beautifie les messages stockés dans crok,crfatal,crexception et crwarn """ l = [] for mess in self.crok: - l.append(mess + '\n') + l.append(mess + "\n") self.crok_belle = l l = [] for mess in self.crwarn: - l.append(encadreMessage(mess, '*')) + l.append(encadreMessage(mess, "*")) self.crwarn_belle = l l = [] for mess in self.crfatal: - l.append(encadreMessage(mess, '!')) + l.append(encadreMessage(mess, "!")) self.crfatal_belle = l l = [] for mess in self.crexception: - l.append(encadreMessage(mess, '!')) + l.append(encadreMessage(mess, "!")) self.crexception_belle = l def indent(self, s): """ - Insère en tete de chaque ligne du texte s la chaine self.dec + Insère en tete de chaque ligne du texte s la chaine self.dec """ - l = s.split( '\n') - a='\n' + self.dec + l = s.split("\n") + a = "\n" + self.dec return self.dec + a.join(l)[:-3] def __unicode__(self): """ - Retourne une chaine de caractères décorée et représentative de self + Retourne une chaine de caractères décorée et représentative de self """ - s = '' + s = "" self.beautifieMessages() - s = s + ''.join(self.crok_belle) - s = s + ''.join(self.crwarn_belle) - s = s + ''.join(self.crfatal_belle) - s = s + ''.join(self.crexception_belle) + s = s + "".join(self.crok_belle) + s = s + "".join(self.crwarn_belle) + s = s + "".join(self.crfatal_belle) + s = s + "".join(self.crexception_belle) for subcr in self.subcr: - if self.verbeux == 'oui': - s = s + six.text_type(subcr) + '\n' + if self.verbeux == "oui": + s = s + six.text_type(subcr) + "\n" else: if not subcr.estvide(): s = s + six.text_type(subcr) - if s != '': - s = self.debut + '\n' + self.indent(s) + self.fin + '\n' + if s != "": + s = self.debut + "\n" + self.indent(s) + self.fin + "\n" else: - s = self.debut + '\n' + self.fin + '\n' + s = self.debut + "\n" + self.fin + "\n" return s def __str__(self): @@ -159,35 +153,42 @@ class CR(object): def report(self, decalage=2): """ - Retourne une chaine de caractères non encadrée mais représentative de self + Retourne une chaine de caractères non encadrée mais représentative de self """ - s = '' + s = "" # on stocke dans s les messages de premier niveau for mess in self.crok: - s = s + decalage * self.dec + mess + self.dec + '\n' + s = s + decalage * self.dec + mess + self.dec + "\n" for mess in self.crwarn: - s = s + decalage * self.dec + mess + self.dec + '\n' + s = s + decalage * self.dec + mess + self.dec + "\n" for mess in self.crfatal: - s = s + decalage * self.dec + mess + self.dec + '\n' + s = s + decalage * self.dec + mess + self.dec + "\n" for mess in self.crexception: - s = s + decalage * self.dec + mess + self.dec + '\n' + s = s + decalage * self.dec + mess + self.dec + "\n" # on récupère les messages des sous comptes-rendus ... for subcr in self.subcr: if not subcr.estvide(): s = s + subcr.report(decalage=decalage + 1) # on rajoute les flags de début et de fin ... (si self n'est pas vide) if not self.estvide(): - s = (decalage - 1) * self.dec + self.debut + '\n' + s + \ - (decalage - 1) * self.dec + self.fin + '\n' + s = ( + (decalage - 1) * self.dec + + self.debut + + "\n" + + s + + (decalage - 1) * self.dec + + self.fin + + "\n" + ) return s def getMessFatal(self): """ - Retourne une chaine de caractères contenant les messages de - la liste crfatal (du dernier au premier) + Retourne une chaine de caractères contenant les messages de + la liste crfatal (du dernier au premier) """ self.crfatal.reverse() - s = '' + s = "" for elem in self.crfatal: s = s + elem self.crfatal.reverse() @@ -195,18 +196,18 @@ class CR(object): def getMessException(self): """ - Retourne une chaine de caractères contenant les messages - de la liste crexception (du dernier au premier) + Retourne une chaine de caractères contenant les messages + de la liste crexception (du dernier au premier) """ self.crexception.reverse() - s = '' + s = "" for elem in self.crexception: s = s + elem self.crexception.reverse() return s -separateurs = (' ', ',', '/') +separateurs = (" ", ",", "/") def split(ligne, cesure): @@ -225,36 +226,46 @@ def split(ligne, cesure): if coupure == len(ligne) - 1: return ligne else: - return ligne[:coupure + 1] + '\n' + split(ligne[coupure + 1:], cesure) + return ligne[: coupure + 1] + "\n" + split(ligne[coupure + 1 :], cesure) -def justifyText(texte='', cesure=50): - if not isinstance (texte,str) : texte = ''.join(texte) +def justifyText(texte="", cesure=50): + if not isinstance(texte, str): + texte = "".join(texte) texte = texte.strip() - liste_lignes = texte.split('\n') + liste_lignes = texte.split("\n") l = [split(l, cesure) for l in liste_lignes] - texte_justifie = '\n'.join(l) + texte_justifie = "\n".join(l) return texte_justifie def encadreMessage(texte, motif): """ - Retourne la chaine de caractères texte entourée d'un cadre formés - d'éléments 'motif' + Retourne la chaine de caractères texte entourée d'un cadre formés + d'éléments 'motif' """ texte = justifyText(texte, cesure=80) - if texte.strip() == "" : return '' - lignes = texte.split( '\n') + if texte.strip() == "": + return "" + lignes = texte.split("\n") longueur = 0 for ligne in lignes: ligne = ligne.rstrip() if len(ligne) > longueur: longueur = len(ligne) longueur = longueur + 4 - txt = motif * longueur + '\n' + txt = motif * longueur + "\n" for ligne in lignes: - if ligne == '' : continue - txt = txt + motif + ' ' + ligne + ' ' * \ - (longueur - len(motif + ligne) - 2) + motif + '\n' - txt = txt + motif * longueur + '\n' + if ligne == "": + continue + txt = ( + txt + + motif + + " " + + ligne + + " " * (longueur - len(motif + ligne) - 2) + + motif + + "\n" + ) + txt = txt + motif * longueur + "\n" return txt diff --git a/Noyau/N_ENTITE.py b/Noyau/N_ENTITE.py index bdb25350..5821da85 100644 --- a/Noyau/N_ENTITE.py +++ b/Noyau/N_ENTITE.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2021 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,100 +17,100 @@ # # # ====================================================================== - - """ Ce module contient la classe ENTITE qui est la classe de base de toutes les classes de definition d'EFICAS. """ - -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import str - from builtins import object -except : - pass -import re +from builtins import str +from builtins import object from . import N_CR from . import N_OPS from . import N_VALIDATOR import six + stringTypes = (str, six.text_type) class ENTITE(object): """ - Classe de base pour tous les objets de definition : mots cles et commandes - Cette classe ne contient que des methodes utilitaires - Elle ne peut être instanciee et doit d abord être specialisee + Classe de base pour tous les objets de definition : mots cles et commandes + Cette classe ne contient que des methodes utilitaires + Elle ne peut être instanciee et doit d abord être specialisee """ + CR = N_CR.CR - factories = {'validator': N_VALIDATOR.validatorFactory} + factories = {"validator": N_VALIDATOR.validatorFactory} def __init__(self, validators=None): """ - Initialise les deux attributs regles et entites d'une classe dérivée - à : pas de règles et pas de sous-entités. + Initialise les deux attributs regles et entites d'une classe dérivée + à : pas de règles et pas de sous-entités. - L'attribut regles doit contenir la liste des regles qui s'appliquent - sur ses sous-entités + L'attribut regles doit contenir la liste des regles qui s'appliquent + sur ses sous-entités - L'attribut entités doit contenir le dictionnaires des sous-entités - (clé = nom, valeur=objet) + L'attribut entités doit contenir le dictionnaires des sous-entités + (clé = nom, valeur=objet) + Les attributs utiles pour la projection xsd sont aussi initialises + init non appele pour bloc """ self.regles = () self.entites = {} if validators: - self.validators = self.factories['validator'](validators) + self.validators = self.factories["validator"](validators) else: self.validators = validators - #self.doitSenregistrerComme = None - self.txtNomComplet='' - self.redefinit=False - self.dejaPrepareDump=False + # self.doitSenregistrerComme = None + self.txtNomComplet = "" + self.redefinit = False + self.dejaPrepareDump = False + self.possedeDejaUnMCFactorise = False def affecter_parente(self): """ - Cette methode a pour fonction de donner un nom et un pere aux - sous entités qui n'ont aucun moyen pour atteindre leur parent - directement - Il s'agit principalement des mots cles + Cette methode a pour fonction de donner un nom et un pere aux + sous entités qui n'ont aucun moyen pour atteindre leur parent + directement + Il s'agit principalement des mots cles """ for k, v in list(self.entites.items()): - #print( k,v) + # print( k,v) v.pere = self v.nom = k def verifCata(self): """ - Cette methode sert à valider les attributs de l'objet de définition + Cette methode sert à valider les attributs de l'objet de définition """ - raise NotImplementedError("La méthode verifCata de la classe %s doit être implémentée" - % self.__class__.__name__) + raise NotImplementedError( + "La méthode verifCata de la classe %s doit être implémentée" + % self.__class__.__name__ + ) def __call__(self): """ - Cette methode doit retourner un objet dérivé de la classe OBJECT + Cette methode doit retourner un objet dérivé de la classe OBJECT """ - raise NotImplementedError("La méthode __call__ de la classe %s doit être implémentée" - % self.__class__.__name__) + raise NotImplementedError( + "La méthode __call__ de la classe %s doit être implémentée" + % self.__class__.__name__ + ) def report(self): """ - Cette méthode construit pour tous les objets dérivés de ENTITE un - rapport de validation de la définition portée par cet objet + Cette méthode construit pour tous les objets dérivés de ENTITE un + rapport de validation de la définition portée par cet objet """ self.cr = self.CR() self.verifCata() for k, v in list(self.entites.items()): try: cr = v.report() - cr.debut = u"Début " + v.__class__.__name__ + ' : ' + k - cr.fin = u"Fin " + v.__class__.__name__ + ' : ' + k + cr.debut = "Début " + v.__class__.__name__ + " : " + k + cr.fin = "Fin " + v.__class__.__name__ + " : " + k self.cr.add(cr) except: self.cr.fatal("Impossible d'obtenir le rapport de %s %s" % (k, repr(v))) @@ -120,223 +120,324 @@ class ENTITE(object): def verifCataRegles(self): """ - Cette méthode vérifie pour tous les objets dérivés de ENTITE que - les objets REGLES associés ne portent que sur des sous-entités - existantes + Cette méthode vérifie pour tous les objets dérivés de ENTITE que + les objets REGLES associés ne portent que sur des sous-entités + existantes """ for regle in self.regles: l = [] for mc in regle.mcs: - if not mc in self.entites : + if not mc in self.entites: l.append(mc) if l != []: txt = str(regle) self.cr.fatal( - _(u"Argument(s) non permis : %r pour la règle : %s"), l, txt) + _("Argument(s) non permis : %r pour la règle : %s"), l, txt + ) def checkDefinition(self, parent): """Verifie la definition d'un objet composite (commande, fact, bloc).""" args = self.entites.copy() mcs = set() for nom, val in list(args.items()): - if val.label == 'SIMP': + if val.label == "SIMP": mcs.add(nom) # XXX # if val.max != 1 and val.type == 'TXM': - # print "#CMD", parent, nom - elif val.label == 'FACT': + # print "#CMD", parent, nom + elif val.label == "FACT": val.checkDefinition(parent) # CALC_SPEC ! # assert self.label != 'FACT', \ - #'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \ - #% parent + #'Commande %s : Mot-clef facteur present sous un mot-clef facteur : interdit !' \ + # % parent else: continue del args[nom] # seuls les blocs peuvent entrer en conflit avec les mcs du plus haut # niveau for nom, val in list(args.items()): - if val.label == 'BLOC': + if val.label == "BLOC": mcbloc = val.checkDefinition(parent) # XXX - # print "#BLOC", parent, re.sub('\s+', ' ', val.condition) - assert mcs.isdisjoint(mcbloc), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" \ - % (parent, tuple(mcs.intersection(mcbloc))) + assert mcs.isdisjoint( + mcbloc + ), "Commande %s : Mot(s)-clef(s) vu(s) plusieurs fois : %s" % ( + parent, + tuple(mcs.intersection(mcbloc)), + ) return mcs def checkOp(self, valmin=-9999, valmax=9999): """Vérifie l'attribut op.""" - if self.op is not None and \ - (type(self.op) is not int or self.op < valmin or self.op > valmax): - self.cr.fatal(_(u"L'attribut 'op' doit être un entier " - u"compris entre %d et %d : %r"), valmin, valmax, self.op) + if self.op is not None and ( + type(self.op) is not int or self.op < valmin or self.op > valmax + ): + self.cr.fatal( + _("L'attribut 'op' doit être un entier " "compris entre %d et %d : %r"), + valmin, + valmax, + self.op, + ) def checkProc(self): """Vérifie l'attribut proc.""" if self.proc is not None and not isinstance(self.proc, N_OPS.OPS): self.cr.fatal( - _(u"L'attribut op doit être une instance d'OPS : %r"), self.proc) + _("L'attribut op doit être une instance d'OPS : %r"), self.proc + ) def checkRegles(self): """Vérifie l'attribut regles.""" if type(self.regles) is not tuple: - self.cr.fatal(_(u"L'attribut 'regles' doit être un tuple : %r"), - self.regles) + self.cr.fatal(_("L'attribut 'regles' doit être un tuple : %r"), self.regles) def checkFr(self): """Vérifie l'attribut fr.""" if type(self.fr) not in stringTypes: self.cr.fatal( - _(u"L'attribut 'fr' doit être une chaine de caractères : %r"), - self.fr) + _("L'attribut 'fr' doit être une chaine de caractères : %r"), self.fr + ) def checkDocu(self): """Vérifie l'attribut docu.""" if type(self.docu) not in stringTypes: self.cr.fatal( - _(u"L'attribut 'docu' doit être une chaine de caractères : %r"), - self.docu) + _("L'attribut 'docu' doit être une chaine de caractères : %r"), + self.docu, + ) def checkNom(self): """Vérifie l'attribut proc.""" if type(self.nom) is not str: self.cr.fatal( - _(u"L'attribut 'nom' doit être une chaine de caractères : %r"), - self.nom) + _("L'attribut 'nom' doit être une chaine de caractères : %r"), self.nom + ) def checkReentrant(self): """Vérifie l'attribut reentrant.""" - if self.reentrant not in ('o', 'n', 'f'): + if self.reentrant not in ("o", "n", "f"): self.cr.fatal( - _(u"L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"), - self.reentrant) + _("L'attribut 'reentrant' doit valoir 'o','n' ou 'f' : %r"), + self.reentrant, + ) - def checkStatut(self, into=('o', 'f', 'c', 'd')): + def checkStatut(self, into=("o", "f", "c", "d")): """Vérifie l'attribut statut.""" if self.statut not in into: - self.cr.fatal(_(u"L'attribut 'statut' doit être parmi %s : %r"), - into, self.statut) + self.cr.fatal( + _("L'attribut 'statut' doit être parmi %s : %r"), into, self.statut + ) def checkCondition(self): """Vérifie l'attribut condition.""" if self.condition != None: if type(self.condition) is not str: self.cr.fatal( - _(u"L'attribut 'condition' doit être une chaine de caractères : %r"), - self.condition) + _("L'attribut 'condition' doit être une chaine de caractères : %r"), + self.condition, + ) else: - self.cr.fatal(_(u"La condition ne doit pas valoir None !")) + self.cr.fatal(_("La condition ne doit pas valoir None !")) def checkMinMax(self): """Vérifie les attributs min/max.""" if type(self.min) != int: - if self.min != '**'and self.min != float('-inf'): - self.cr.fatal( - _(u"L'attribut 'min' doit être un entier : %r"), self.min) + if self.min != "**" and self.min != float("-inf"): + self.cr.fatal(_("L'attribut 'min' doit être un entier : %r"), self.min) if type(self.max) != int: - if self.max != '**' and self.max != float('inf'): - self.cr.fatal( - _(u"L'attribut 'max' doit être un entier : %r"), self.max) + if self.max != "**" and self.max != float("inf"): + self.cr.fatal(_("L'attribut 'max' doit être un entier : %r"), self.max) if self.min > self.max: self.cr.fatal( - _(u"Nombres d'occurrence min et max invalides : %r %r"), - self.min, self.max) + _("Nombres d'occurrence min et max invalides : %r %r"), + self.min, + self.max, + ) def checkValidators(self): """Vérifie les validateurs supplémentaires""" if self.validators and not self.validators.verifCata(): - self.cr.fatal(_(u"Un des validateurs est incorrect. Raison : %s"), - self.validators.cata_info) + self.cr.fatal( + _("Un des validateurs est incorrect. Raison : %s"), + self.validators.cata_info, + ) def checkHomo(self): """Vérifie l'attribut homo.""" if self.homo != 0 and self.homo != 1: - self.cr.fatal( - _(u"L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo) + self.cr.fatal(_("L'attribut 'homo' doit valoir 0 ou 1 : %r"), self.homo) def checkInto(self): """Vérifie l'attribut into.""" if self.into != None: - if (type(self.into) not in (list, tuple)) and (type(self.into) != types.FunctionType) : - self.cr.fatal( - _(u"L'attribut 'into' doit être un tuple : %r"), self.into) + if (type(self.into) not in (list, tuple)) and ( + type(self.into) != types.FunctionType + ): + self.cr.fatal(_("L'attribut 'into' doit être un tuple : %r"), self.into) def checkPosition(self): """Vérifie l'attribut position.""" - if self.position not in ('local', 'global', 'global_jdc', 'inGetAttribut', 'reCalculeEtape'): - self.cr.fatal(_(u"L'attribut 'position' doit valoir 'local', 'global' ,'global_jdc', 'inGetAttribut', 'reCalculeEtape' " - u"ou 'global_jdc' : %r"), self.position) + if self.position not in ( + "local", + "global", + "global_jdc", + "inGetAttribut", + "reCalculeEtape", + ): + self.cr.fatal( + _( + "L'attribut 'position' doit valoir 'local', 'global' ,'global_jdc', 'inGetAttribut', 'reCalculeEtape' " + "ou 'global_jdc' : %r" + ), + self.position, + ) def nomComplet(self): - if self.txtNomComplet != '' : return self.txtNomComplet - qui=self - while hasattr(qui, 'pere' ): - self.txtNomComplet+='_'+qui.nom - qui=qui.pere - self.txtNomComplet+='_'+qui.nom + if self.txtNomComplet != "": + return self.txtNomComplet + qui = self + while hasattr(qui, "pere"): + self.txtNomComplet += "_" + qui.nom + qui = qui.pere + self.txtNomComplet += "_" + qui.nom return self.txtNomComplet def geneaCompleteSousFormeDeListe(self): - geneaCompleteSousFormeDeListe=[] - qui=self - while hasattr(qui, 'pere' ): + geneaCompleteSousFormeDeListe = [] + qui = self + while hasattr(qui, "pere"): geneaCompleteSousFormeDeListe.append(qui) - qui=qui.pere + qui = qui.pere geneaCompleteSousFormeDeListe.append(qui) return geneaCompleteSousFormeDeListe - def addDefinitionMC(self,listeMCAvant,**args): - ouChercher=self + def addDefinitionMC(self, listeMCAvant, **args): + ouChercher = self for mot in listeMCAvant: - try : - ouChercher=ouChercher.entites[mot] - except : - print ('impossible de trouver : ',mot,' ',listeMCAvant) - (nomMC,defMC)=args.items()[0] + try: + ouChercher = ouChercher.entites[mot] + except: + print("impossible de trouver : ", mot, " ", listeMCAvant) + (nomMC, defMC) = args.items()[0] defMC.pere = ouChercher defMC.pere.propageRedefinit() defMC.nom = nomMC cata = CONTEXT.getCurrentCata() - #print (cata) - ouChercher.entites[nomMC]=defMC + # print (cata) + ouChercher.entites[nomMC] = defMC - def changeDefinitionMC(self,listeMCAvant,**args): - ouChercher=self + def changeDefinitionMC(self, listeMCAvant, **args): + ouChercher = self for mot in listeMCAvant: - try : - ouChercher=ouChercher.entites[mot] - except : - print ('impossible de trouver : ',mot,' ',listeMCAvant) - monSIMP=ouChercher - for (nomAttributDef,valeurAttributDef) in args.items(): - if hasattr(monSIMP, nomAttributDef) : + try: + ouChercher = ouChercher.entites[mot] + except: + print("impossible de trouver : ", mot, " ", listeMCAvant) + monSIMP = ouChercher + for nomAttributDef, valeurAttributDef in args.items(): + if hasattr(monSIMP, nomAttributDef): setattr(monSIMP, nomAttributDef, valeurAttributDef) - else : - print ('pb avec ', nomAttributdef,valeurAttributMC) + else: + print("pb avec ", nomAttributdef, valeurAttributMC) monSIMP.propageRedefinit() def propageRedefinit(self): - # a reflechir - self.redefinit=True + # a reflechir + self.redefinit = True # PNPN il faut remonter a l etape - - - def makeObjetPourVerifSignature(self,*args,**kwargs): + def makeObjetPourVerifSignature(self, *args, **kwargs): etape = self.class_instance(oper=self, args=kwargs) etape.MCBuild() return etape + def dumpStringDataBase(self, dPrimaryKey, dElementsRecursifs, dictKey, inBloc): + # ne fonctionne que + # on admet que si un FACT a une primaryKey, elle existe dans celui-ci + # ou que il s agit d un motclef frere/oncle place avant + # derivee pour N_SIMP et N_FACT + debug = True + if debug: + print("****** traitement de ", self.nom) + if debug: + print( + "dElementsRecursifs", + dElementsRecursifs, + ) + if debug: + print( + "dPrimaryKey", + dPrimaryKey, + ) + texte = "" + texteDesFactTables = "" + if debug: + print("dictKey", dictKey) + if (self.label == "OPER") or (self.label == "PROC"): + for mc in dPrimaryKey.values(): + dictKey[mc] = None + texte = "CREATE TABLE IF NOT EXISTS {} (\n".format(self.nom) + for mc in self.entites.values(): + if mc.label == "SIMP": + texteMC = mc.dumpStringDataBase(inBloc) + texte += texteMC + if mc.nom in dictKey: + dictKey[mc.nom] = (texteMC, self.nom) + elif mc.label == "FACT": + if mc.nom in dElementsRecursifs: + texte += mc.dumpStringDataBase( + dPrimaryKey, dElementsRecursifs, dictKey, inBloc + ) + else: + texteDesFactTables += mc.dumpStringDataBase( + dPrimaryKey, dElementsRecursifs, dictKey, inBloc + ) + else: + texte += mc.dumpStringDataBase( + dPrimaryKey, dElementsRecursifs, dictKey, inBloc + ) + if self.label == "BLOC": + for mc in self.entites.values(): + texte += m.dumpStringDataBase( + dPrimaryKey, dElementsRecursifs, inBloc, dictKey + ) + # on enleve la derniere ',' + texte = texte[0:-3] + texte += "\n" + if (self.label == "OPER") or (self.label == "PROC"): + if self.nom in dPrimaryKey: + texte += "\tPRIMARY KEY ({}), \n".format(dPrimaryKey[self.nom]) + texte += ");\n" + texte += texteDesFactTables + return texte + + def dumpGitStringFormat(self): + texte = "" + if self.label == "SIMP": + texte += "".format(self.nom) + texte += "%{}".format(self.fr) + texte += "".format(self.nom) + else: + if self.label == "FACT": + texte += "".format(self.nom) + for c in self.entites.values(): + texte += c.dumpGitStringFormat() + if self.label == "FACT": + texte += "".format(self.nom) + return texte - def dumpStructure(self,decal=0): - if self.label == 'SIMP': - texte = decal * ' ' + self.nom + ' \n' + def dumpStructure(self, decal=0): + if self.label == "SIMP": + texte = decal * " " + self.nom + " \n" return texte - texte = decal * ' ' + self.nom - if self.label == 'BLOC' : texte+= " " + self.condition - if self.label == 'OPER' : texte+ " " + str(self.sd_prod) + "\n" - texte+=' \n' + texte = decal * " " + self.nom + if self.label == "BLOC": + texte += " " + self.condition + if self.label == "OPER": + texte + " " + str(self.sd_prod) + "\n" + texte += " \n" for c in self.entites.values(): - texte+=c.dumpStructure(decal+1) - texte += decal * ' ' + 'fin pour ' + self.nom + ' \n' + texte += c.dumpStructure(decal + 1) + texte += decal * " " + "fin pour " + self.nom + " \n" return texte diff --git a/Noyau/N_ETAPE.py b/Noyau/N_ETAPE.py index 1523bd4a..8a34ae5b 100644 --- a/Noyau/N_ETAPE.py +++ b/Noyau/N_ETAPE.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -16,19 +16,17 @@ # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com - - """ Ce module contient la classe ETAPE qui sert a verifier et a executer une commande """ # Modules Python -from __future__ import absolute_import -from __future__ import print_function -try : + + +try: from builtins import str -except : +except: pass import types import sys @@ -48,9 +46,10 @@ from .N_ASSD import ASSD class ETAPE(N_MCCOMPO.MCCOMPO): """ - Cette classe herite de MCCOMPO car ETAPE est un OBJECT composite + Cette classe herite de MCCOMPO car ETAPE est un OBJECT composite """ + nature = "OPERATEUR" # L'attribut de classe codex est utilise pour rattacher le module de calcul eventuel (voir Build) @@ -70,12 +69,12 @@ class ETAPE(N_MCCOMPO.MCCOMPO): """ # faut il le faire ds MC_Build ? # traitement de Pyxb si Pyxb - self.dicoPyxbDeConstruction = args.get('dicoPyxbDeConstruction', None) - if self.dicoPyxbDeConstruction : - del args['dicoPyxbDeConstruction'] - self.objPyxbDeConstruction=self.dicoPyxbDeConstruction['objEnPyxb'] - else : - self.objPyxbDeConstruction=None + self.dicoPyxbDeConstruction = args.get("dicoPyxbDeConstruction", None) + if self.dicoPyxbDeConstruction: + del args["dicoPyxbDeConstruction"] + self.objPyxbDeConstruction = self.dicoPyxbDeConstruction["objEnPyxb"] + else: + self.objPyxbDeConstruction = None self.definition = oper self.reuse = reuse self.valeur = args @@ -91,7 +90,7 @@ class ETAPE(N_MCCOMPO.MCCOMPO): self.actif = 1 self.makeRegister() self.icmd = None - self.userASSDCrees=[] + self.userASSDCrees = [] def makeRegister(self): """ @@ -99,7 +98,7 @@ class ETAPE(N_MCCOMPO.MCCOMPO): enregistrements necessaires surcharge dans Ihm """ - #print ('makeRegister de ETAPE') + # print ('makeRegister de ETAPE') if self.parent: self.jdc = self.parent.getJdcRoot() self.id = self.parent.register(self) @@ -111,8 +110,8 @@ class ETAPE(N_MCCOMPO.MCCOMPO): def nettoiargs(self): """ - Cette methode a pour fonction de retirer tous les arguments egaux a None - de la liste des arguments. Ils sont supposes non presents et donc retires. + Cette methode a pour fonction de retirer tous les arguments egaux a None + de la liste des arguments. Ils sont supposes non presents et donc retires. """ for k in list(self.valeur.keys()): if self.valeur[k] == None: @@ -120,21 +119,21 @@ class ETAPE(N_MCCOMPO.MCCOMPO): def MCBuild(self): """ - Demande la construction des sous-objets et les stocke dans l'attribut - mcListe. + Demande la construction des sous-objets et les stocke dans l'attribut + mcListe. """ self.mcListe = self.buildMc() def buildSd(self, nom): """ - Construit le concept produit de l'operateur. Deux cas - peuvent se presenter : + Construit le concept produit de l'operateur. Deux cas + peuvent se presenter : - - le parent n'est pas defini. Dans ce cas, l'etape prend en charge la creation - et le nommage du concept. + - le parent n'est pas defini. Dans ce cas, l'etape prend en charge la creation + et le nommage du concept. - - le parent est defini. Dans ce cas, l'etape demande au parent la creation et - le nommage du concept. + - le parent est defini. Dans ce cas, l'etape demande au parent la creation et + le nommage du concept. """ self.sdnom = nom @@ -142,8 +141,7 @@ class ETAPE(N_MCCOMPO.MCCOMPO): if self.parent: sd = self.parent.createSdprod(self, nom) if type(self.definition.op_init) == types.FunctionType: - self.definition.op_init(*( - self, self.parent.g_context)) + self.definition.op_init(*(self, self.parent.g_context)) else: sd = self.getSdProd() # On n'utilise pas self.definition.op_init car self.parent @@ -153,40 +151,54 @@ class ETAPE(N_MCCOMPO.MCCOMPO): # d un concept sd.setName(nom) except AsException as e: - raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0], - 'fichier : ', self.appel[1], e) + raise AsException( + "Etape ", + self.nom, + "ligne : ", + self.appel[0], + "fichier : ", + self.appel[1], + e, + ) except EOFError: raise except: l = traceback.format_exception( - sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]) - raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0], - 'fichier : ', self.appel[1] + '\n', - ''.join(l)) + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) + raise AsException( + "Etape ", + self.nom, + "ligne : ", + self.appel[0], + "fichier : ", + self.appel[1] + "\n", + "".join(l), + ) self.Execute() return sd def Execute(self): """ - Cette methode est un point d'entree prevu pour realiser une execution immediatement - apres avoir construit les mots cles et le concept produit. - Par defaut, elle ne fait rien. Elle doit etre surchargee dans une autre partie du programme. + Cette methode est un point d'entree prevu pour realiser une execution immediatement + apres avoir construit les mots cles et le concept produit. + Par defaut, elle ne fait rien. Elle doit etre surchargee dans une autre partie du programme. """ return def getSdProd(self): """ - Retourne le concept resultat de l'etape - Deux cas : - - cas 1 : sd_prod de oper n'est pas une fonction - il s'agit d'une sous classe de ASSD - on construit le sd a partir de cette classe - et on le retourne - - cas 2 : il s'agit d'une fonction - on l'evalue avec les mots-cles de l'etape (mcListe) - on construit le sd a partir de la classe obtenue - et on le retourne + Retourne le concept resultat de l'etape + Deux cas : + - cas 1 : sd_prod de oper n'est pas une fonction + il s'agit d'une sous classe de ASSD + on construit le sd a partir de cette classe + et on le retourne + - cas 2 : il s'agit d'une fonction + on l'evalue avec les mots-cles de l'etape (mcListe) + on construit le sd a partir de la classe obtenue + et on le retourne """ if type(self.definition.sd_prod) == types.FunctionType: d = self.creeDictValeurs(self.mcListe) @@ -197,12 +209,13 @@ class ETAPE(N_MCCOMPO.MCCOMPO): except Exception as exc: if CONTEXT.debug: traceback.print_exc() - raise AsException("impossible d affecter un type au resultat:", - str(exc)) + raise AsException( + "impossible d affecter un type au resultat:", str(exc) + ) else: sd_prod = self.definition.sd_prod # on teste maintenant si la SD est reutilisee ou s'il faut la creer - if self.definition.reentrant != 'n' and self.reuse: + if self.definition.reentrant != "n" and self.reuse: # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale. # Elle sera traitee ulterieurement. self.sd = self.reuse @@ -212,12 +225,14 @@ class ETAPE(N_MCCOMPO.MCCOMPO): # On ne fait rien ici. L'erreur sera traiter par la suite. # precaution if self.sd is not None and not isinstance(self.sd, ASSD): - raise AsException(""" + raise AsException( + """ Impossible de typer le resultat ! Causes possibles : Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte, soit il y a une "," a la fin d'une commande precedente. - Developpeur : La fonction "sd_prod" retourne un type invalide.""") + Developpeur : La fonction "sd_prod" retourne un type invalide.""" + ) return self.sd def getType_produit(self): @@ -228,14 +243,14 @@ Causes possibles : def getType_produit_brut(self): """ - Retourne le type du concept resultat de l'etape - Deux cas : - - cas 1 : sd_prod de oper n'est pas une fonction - il s'agit d'une sous classe de ASSD - on retourne le nom de la classe - - cas 2 : il s'agit d'une fonction - on l'evalue avec les mots-cles de l'etape (mcListe) - et on retourne son resultat + Retourne le type du concept resultat de l'etape + Deux cas : + - cas 1 : sd_prod de oper n'est pas une fonction + il s'agit d'une sous classe de ASSD + on retourne le nom de la classe + - cas 2 : il s'agit d'une fonction + on l'evalue avec les mots-cles de l'etape (mcListe) + et on retourne son resultat """ if type(self.definition.sd_prod) == types.FunctionType: d = self.creeDictValeurs(self.mcListe) @@ -246,22 +261,22 @@ Causes possibles : def getEtape(self): """ - Retourne l'etape a laquelle appartient self - Un objet de la categorie etape doit retourner self pour indiquer que - l'etape a ete trouvee + Retourne l'etape a laquelle appartient self + Un objet de la categorie etape doit retourner self pour indiquer que + l'etape a ete trouvee """ return self def supprime(self): """ - Methode qui supprime toutes les references arrières afin que l'objet puisse - etre correctement detruit par le garbage collector + Methode qui supprime toutes les references arrières afin que l'objet puisse + etre correctement detruit par le garbage collector """ N_MCCOMPO.MCCOMPO.supprime(self) self.jdc = None self.appel = None for name in dir(self): - if name.startswith('_cache_'): + if name.startswith("_cache_"): setattr(self, name, None) if self.sd: self.sd.supprime() @@ -274,55 +289,64 @@ Causes possibles : Si reuse est present, `self.sd` a ete creee avant, donc n'est pas dans cette liste.""" if not self.reuse and self.sd: - return [self.sd, ] + return [ + self.sd, + ] return [] def isActif(self): """ - Indique si l'etape est active (1) ou inactive (0) + Indique si l'etape est active (1) ou inactive (0) """ return self.actif def setCurrentStep(self): """ - Methode utilisee pour que l etape self se declare etape - courante. Utilise par les macros + Methode utilisee pour que l etape self se declare etape + courante. Utilise par les macros """ cs = CONTEXT.getCurrentStep() if self.parent != cs: - raise AsException("L'etape courante", cs.nom, cs, - "devrait etre le parent de", self.nom, self) + raise AsException( + "L'etape courante", + cs.nom, + cs, + "devrait etre le parent de", + self.nom, + self, + ) else: CONTEXT.unsetCurrentStep() CONTEXT.setCurrentStep(self) def resetCurrentStep(self): """ - Methode utilisee par l'etape self qui remet son etape parent comme - etape courante + Methode utilisee par l'etape self qui remet son etape parent comme + etape courante """ cs = CONTEXT.getCurrentStep() if self != cs: - raise AsException("L'etape courante", cs.nom, cs, - "devrait etre", self.nom, self) + raise AsException( + "L'etape courante", cs.nom, cs, "devrait etre", self.nom, self + ) else: CONTEXT.unsetCurrentStep() CONTEXT.setCurrentStep(self.parent) def issubstep(self, etape): """ - Cette methode retourne un entier indiquant si etape est une - sous etape de self ou non - 1 = oui - 0 = non - Une etape simple n'a pas de sous etape + Cette methode retourne un entier indiquant si etape est une + sous etape de self ou non + 1 = oui + 0 = non + Une etape simple n'a pas de sous etape """ return 0 - def getFile(self, unite=None, fic_origine='', fname=None): + def getFile(self, unite=None, fic_origine="", fname=None): """ - Retourne le nom du fichier correspondant a un numero d'unite - logique (entier) ainsi que le source contenu dans le fichier + Retourne le nom du fichier correspondant a un numero d'unite + logique (entier) ainsi que le source contenu dans le fichier """ if self.jdc: return self.jdc.getFile(unite=unite, fic_origine=fic_origine, fname=fname) @@ -331,28 +355,30 @@ Causes possibles : if os.path.exists("fort." + str(unite)): fname = "fort." + str(unite) if fname == None: - raise AsException("Impossible de trouver le fichier correspondant" - " a l unite %s" % unite) + raise AsException( + "Impossible de trouver le fichier correspondant" + " a l unite %s" % unite + ) if not os.path.exists(fname): raise AsException("%s n'est pas un fichier existant" % unite) - fproc = open(fname, 'r') + fproc = open(fname, "r") text = fproc.read() fproc.close() - text = text.replace('\r\n', '\n') - linecache.cache[fname] = 0, 0, text.split('\n'), fname + text = text.replace("\r\n", "\n") + linecache.cache[fname] = 0, 0, text.split("\n"), fname return fname, text def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitETAPE(self) def updateContext(self, d): """ - Cette methode doit updater le contexte fournit par - l'appelant en argument (d) en fonction de sa definition + Cette methode doit updater le contexte fournit par + l'appelant en argument (d) en fonction de sa definition """ if type(self.definition.op_init) == types.FunctionType: self.definition.op_init(*(self, d)) @@ -360,12 +386,12 @@ Causes possibles : d[self.sd.nom] = self.sd def copy(self): - """ Methode qui retourne une copie de self non enregistree auprès du JDC - et sans sd + """Methode qui retourne une copie de self non enregistree auprès du JDC + et sans sd """ etape = copy(self) etape.sd = None - etape.state = 'modified' + etape.state = "modified" etape.reuse = None etape.sdnom = None etape.etape = etape @@ -377,20 +403,18 @@ Causes possibles : return etape def copyReuse(self, old_etape): - """ Methode qui copie le reuse d'une autre etape. - """ + """Methode qui copie le reuse d'une autre etape.""" if hasattr(old_etape, "reuse"): self.reuse = old_etape.reuse def copySdnom(self, old_etape): - """ Methode qui copie le sdnom d'une autre etape. - """ + """Methode qui copie le sdnom d'une autre etape.""" if hasattr(old_etape, "sdnom"): self.sdnom = old_etape.sdnom def reparent(self, parent): """ - Cette methode sert a reinitialiser la parente de l'objet + Cette methode sert a reinitialiser la parente de l'objet """ self.parent = parent self.jdc = parent.getJdcRoot() @@ -402,26 +426,26 @@ Causes possibles : def getCmd(self, nomcmd): """ - Methode pour recuperer la definition d'une commande - donnee par son nom dans les catalogues declares - au niveau du jdc - Appele par un ops d'une macro en Python + Methode pour recuperer la definition d'une commande + donnee par son nom dans les catalogues declares + au niveau du jdc + Appele par un ops d'une macro en Python """ return self.jdc.getCmd(nomcmd) def copyIntern(self, etape): """ - Methode permettant lors du processus de recopie de copier - les elements internes d'une etape dans une autre + Methode permettant lors du processus de recopie de copier + les elements internes d'une etape dans une autre """ return def fullCopy(self, parent=None): """ - Methode permettant d'effectuer une copie complète - d'une etape (y compris concept produit, elements internes) - Si l'argument parent est fourni, la nouvelle etape - aura cet objet comme parent. + Methode permettant d'effectuer une copie complète + d'une etape (y compris concept produit, elements internes) + Si l'argument parent est fourni, la nouvelle etape + aura cet objet comme parent. """ new_etape = self.copy() new_etape.copyReuse(self) @@ -440,7 +464,7 @@ Causes possibles : def resetJdc(self, new_jdc): """ - Reinitialise le nommage du concept de l'etape lors d'un changement de jdc + Reinitialise le nommage du concept de l'etape lors d'un changement de jdc """ if self.sd and self.reuse == None: self.parent.nommerSDProd(self.sd, self.sd.nom) @@ -449,18 +473,17 @@ Causes possibles : """Permet savoir si on a affaire a la commande INCLUDE car le comportement de ces macros est particulier. """ - return self.nom.startswith('INCLUDE') + return self.nom.startswith("INCLUDE") def sdAccessible(self): - """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape. - """ + """Dit si on peut acceder aux "valeurs" (jeveux) de l'ASSD produite par l'etape.""" if CONTEXT.debug: - print(('`- ETAPE sdAccessible :', self.nom)) + print(("`- ETAPE sdAccessible :", self.nom)) return self.parent.sdAccessible() def getConcept(self, nomsd): """ - Methode pour recuperer un concept a partir de son nom + Methode pour recuperer un concept a partir de son nom """ # pourrait etre appelee par une commande fortran faisant appel a des fonctions python # on passe la main au parent diff --git a/Noyau/N_Exception.py b/Noyau/N_Exception.py index 5ff4b37a..540d255b 100644 --- a/Noyau/N_Exception.py +++ b/Noyau/N_Exception.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2021 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21,21 +21,19 @@ """ Ce module contient la classe AsException """ - # Modules EFICAS -from __future__ import absolute_import + from .strfunc import getEncoding, toUnicode import six class AsException(Exception): - def __unicode__(self): args = [] for x in self.args: ustr = toUnicode(x) if type(ustr) is not six.text_type: - ustr = six.text_type( repr(x) ) + ustr = six.text_type(repr(x)) args.append(ustr) return " ".join(args) diff --git a/Noyau/N_FACT.py b/Noyau/N_FACT.py index c5737a07..eb67c35e 100644 --- a/Noyau/N_FACT.py +++ b/Noyau/N_FACT.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -21,9 +21,6 @@ """ Ce module contient la classe de definition FACT qui permet de spécifier les caractéristiques des mots clés facteurs """ - -from __future__ import absolute_import -from __future__ import print_function import types from . import N_ENTITE @@ -38,41 +35,55 @@ from . import N_OBJECT class FACT(N_ENTITE.ENTITE): """ - Classe pour definir un mot cle facteur + Classe pour definir un mot cle facteur - Cette classe a trois attributs de classe + Cette classe a trois attributs de classe - - class_instance qui indique la classe qui devra etre utilisée - pour créer l'objet qui servira à controler la conformité d'un - mot-clé facteur avec sa définition + - class_instance qui indique la classe qui devra etre utilisée + pour créer l'objet qui servira à controler la conformité d'un + mot-clé facteur avec sa définition - - list_instance + - list_instance - - label qui indique la nature de l'objet de définition (ici, FACT) + - label qui indique la nature de l'objet de définition (ici, FACT) """ + class_instance = N_MCFACT.MCFACT list_instance = N_MCLIST.MCList - label = 'FACT' + label = "FACT" - def __init__(self, fr="", docu="", regles=(), statut='f', defaut=None,ang="",fenetreIhm=None, - min=0, max=1, validators=None, **args): + def __init__( + self, + fr="", + docu="", + regles=(), + statut="f", + defaut=None, + ang="", + fenetreIhm=None, + min=0, + max=1, + validators=None, + nomXML=None, + **args + ): """ - Un mot-clé facteur est caractérisé par les attributs suivants : - - - fr : - - statut : - - defaut : - - regles - - min - - max - - position - - docu - - fenetreIhm + Un mot-clé facteur est caractérisé par les attributs suivants : + + - fr : + - statut : + - defaut : + - regles + - min + - max + - position + - docu + - fenetreIhm """ N_ENTITE.ENTITE.__init__(self, validators) # Initialisation des attributs self.fr = fr - self.ang=ang + self.ang = ang self.docu = docu if type(regles) == tuple: self.regles = regles @@ -82,87 +93,110 @@ class FACT(N_ENTITE.ENTITE): self.defaut = defaut self.min = min self.max = max - if self.max == "**" : self.max=float('inf') - if self.min == "**" : self.min=float('-inf') + if self.max == "**": + self.max = float("inf") + if self.min == "**": + self.min = float("-inf") self.entites = args self.position = None self.affecter_parente() self.fenetreIhm = fenetreIhm + self.nomXML = nomXML - def __call__(self, val, nom, parent, dicoPyxbDeConstruction = None): + def __call__(self, val, nom, parent, dicoPyxbDeConstruction=None): """ - Construit la structure de donnee pour un mot cle facteur a partir - de sa definition (self) de sa valeur (val), de son nom (nom) et de - son parent dans l arboresence (parent) - - Suivant le type de la valeur on retournera soit un objet de type - MCFACT soit une liste de type MCLIST. - - La creation d un mot cle facteur depend de son statut - - Si statut ='o' il est obligatoire - - Si statut == 'd' il est facultatif mais ses sous mots cles avec - defaut sont visibles - - Si statut == 'f' il est facultatif et ses sous mots avec defaut ne - sont pas visibles - - Si statut == 'c' il est cache ??? - - Si defaut != None, on utilise cette valeur pour calculer la valeur - par defaut du mot cle facteur + Construit la structure de donnee pour un mot cle facteur a partir + de sa definition (self) de sa valeur (val), de son nom (nom) et de + son parent dans l arboresence (parent) + + Suivant le type de la valeur on retournera soit un objet de type + MCFACT soit une liste de type MCLIST. + + La creation d un mot cle facteur depend de son statut + - Si statut ='o' il est obligatoire + - Si statut == 'd' il est facultatif mais ses sous mots cles avec + defaut sont visibles + - Si statut == 'f' il est facultatif et ses sous mots avec defaut ne + sont pas visibles + - Si statut == 'c' il est cache ??? + - Si defaut != None, on utilise cette valeur pour calculer la valeur + par defaut du mot cle facteur """ if val is None: if self.defaut == None: val = {} elif type(self.defaut) == tuple: val = self.defaut - # Est ce utile ? Le défaut pourrait etre uniquement un dict + # Est ce utile ? Le défaut pourrait etre uniquement un dict elif type(self.defaut) == dict or isinstance(self.defaut, _F): val = self.defaut else: # On ne devrait jamais passer par la - print ("On ne devrait jamais passer par la") + print("On ne devrait jamais passer par la") return None - elif isSequence(val) and len(val) == 0 and self.statut == 'o': - # On est dans le cas où le mcfact est présent mais est une liste/tuple - # vide. Il est obligatoire donc on l'initialise. Les règles, mots-clés - # obligatoires diront si un mcfact vide est accepté. + elif isSequence(val) and len(val) == 0 and self.statut == "o": + # On est dans le cas où le mcfact est présent mais est une liste/tuple + # vide. Il est obligatoire donc on l'initialise. Les règles, mots-clés + # obligatoires diront si un mcfact vide est accepté. val = {} # On cree toujours une liste de mcfact l = self.list_instance() l.init(nom=nom, parent=parent) if type(val) in (tuple, list, self.list_instance): - indice=0 + indice = 0 for v in val: if type(v) == dict or isinstance(v, _F): - if dicoPyxbDeConstruction : + if dicoPyxbDeConstruction: objet = self.class_instance( - nom=nom, definition=self, val=v, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction[indice]) - else : + nom=nom, + definition=self, + val=v, + parent=parent, + dicoPyxbDeConstruction=dicoPyxbDeConstruction[indice], + ) + else: objet = self.class_instance( - nom=nom, definition=self, val=v, parent=parent,dicoPyxbDeConstruction=None) - indice=indice+1 + nom=nom, + definition=self, + val=v, + parent=parent, + dicoPyxbDeConstruction=None, + ) + indice = indice + 1 l.append(objet) elif isinstance(v, self.class_instance): -# if faut gerer ici --> on passe la avec une liste de concept ? -# PNPN --> si pyxb + # if faut gerer ici --> on passe la avec une liste de concept ? + # PNPN --> si pyxb l.append(v) else: l.append(N_OBJECT.ErrorObj(self, v, parent, nom)) elif type(val) == dict or isinstance(val, _F): - if dicoPyxbDeConstruction : + if dicoPyxbDeConstruction: objet = self.class_instance( - nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=dicoPyxbDeConstruction) - else : + nom=nom, + definition=self, + val=val, + parent=parent, + dicoPyxbDeConstruction=dicoPyxbDeConstruction, + ) + else: objet = self.class_instance( - nom=nom, definition=self, val=val, parent=parent,dicoPyxbDeConstruction=None) + nom=nom, + definition=self, + val=val, + parent=parent, + dicoPyxbDeConstruction=None, + ) l.append(objet) elif isinstance(val, self.class_instance): -# idem --> quand passe t on la + # idem --> quand passe t on la l.append(val) else: l.append(N_OBJECT.ErrorObj(self, val, parent, nom)) # pour tenir compte du validateFonction - if l.jdc : - l.cata=l.jdc.cata + if l.jdc: + l.cata = l.jdc.cata l.buildObjPyxb(l) return l @@ -174,3 +208,74 @@ class FACT(N_ENTITE.ENTITE): self.checkDocu() self.checkValidators() self.verifCataRegles() + + def dumpStringDataBase(self, dPrimaryKey, dElementsRecursifs, dictKey, inBloc): + # ne fonctionne que + # on admet que si un FACT a une primaryKey, elle existe dans celui-ci + # ou que il s agit d un motclef frere/oncle place avant + debug = True + if debug: + print("****** traitement de FACT ", self.nom) + if debug: + print( + "dElementsRecursifs", + dElementsRecursifs, + ) + if debug: + print( + "dPrimaryKey", + dPrimaryKey, + ) + if debug: + print("dictKey", dictKey) + texte = "CREATE TABLE IF NOT EXISTS {} (\n".format(self.nom) + texteForeignKey = "" + textePrimaryKey = "" + texteDesFactTables = "" + if self.nom in dElementsRecursifs: + return "\t{} XML ,\n".format(self.nom) + if self.nom in dPrimaryKey: + if debug: + print("FACT ", self.nom, " attend une primary key") + if dPrimaryKey[self.nom] not in self.entites.values(): + if dictKey[dPrimaryKey[self.nom]] == None: + texte += "PB SUR LA PRIMARY KEY DE {}\n".format(self.nom) + elif dPrimaryKey[self.nom] not in dictKey: + texte += "PB SUR LA PRIMARY KEY DE {}\n".format(self.nom) + else: + texte += dictKey[dPrimaryKey[self.nom]][0] + textePrimaryKey = "\tPRIMARY KEY ({}), \n".format( + dPrimaryKey[self.nom] + ) + texteForeignKey = ( + "\tFOREIGN KEY ({}) REFERENCES {} ({}), \n".format( + dPrimaryKey[self.nom], + dictKey[dPrimaryKey[self.nom]][1], + dPrimaryKey[self.nom], + ) + ) + for mc in self.entites.values(): + if mc.label == "SIMP": + texteMC = mc.dumpStringDataBase(inBloc) + texte += texteMC + if mc.nom in dictKey: + dictKey[mc.nom] = (texteMC, self.nom) + elif mc.label == "FACT": + if mc.nom in dElementsRecursifs: + texte += mc.dumpStringDataBase( + dPrimaryKey, dElementsRecursifs, dictKey, inBloc + ) + else: + texteDesFactTables += mc.dumpStringDataBase( + dPrimaryKey, dElementsRecursifs, dictKey, inBloc + ) + else: + texte += mc.dumpStringDataBase( + dPrimaryKey, dElementsRecursifs, dictKey, inBloc + ) + texte += textePrimaryKey + texte += texteForeignKey + texte = texte[0:-3] + texte += "\n);\n" + texte += texteDesFactTables + return texte diff --git a/Noyau/N_FONCTION.py b/Noyau/N_FONCTION.py index 537959f5..e7eaacbc 100644 --- a/Noyau/N_FONCTION.py +++ b/Noyau/N_FONCTION.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,49 +20,41 @@ # Attention : cet import permet d'avoir, en Python, le comportement # de la division réelle pour les entiers, et non la division entière # 1/2=0.5 (et non 0). Comportement par défaut dans Python 3.0. -from __future__ import division -from __future__ import absolute_import -try : - from builtins import zip - from builtins import str -except : - pass + +from builtins import zip +from builtins import str from math import sin, cos, tan, asin, acos, atan2, atan, sinh, cosh, tanh from math import pi, exp, log, log10, sqrt - from .N_ASSD import ASSD -from six.moves import zip - class FONCTION(ASSD): pass - class formule(ASSD): - def __init__(self, *args, **kwargs): ASSD.__init__(self, *args, **kwargs) self.nompar = None self.expression = None ctxt = {} - ctxt.update(getattr(self.parent, 'const_context', {})) - ctxt.update(getattr(self.parent, 'macro_const_context', {})) + ctxt.update(getattr(self.parent, "const_context", {})) + ctxt.update(getattr(self.parent, "macro_const_context", {})) self.parent_context = self.filter_context(ctxt) def __call__(self, *val): """Evaluation de la formule""" # en POURSUITE, self.parent_context is None, on essaie de reprendre # const_context - context = getattr(self, 'parent_context') or getattr( - self.parent, 'const_context', {}) + context = getattr(self, "parent_context") or getattr( + self.parent, "const_context", {} + ) for param, value in zip(self.nompar, val): context[param] = value try: # globals() pour math.* res = eval(self.code, context, globals()) except Exception as exc: - mes = "ERREUR LORS DE L EVALUATION DE LA FORMULE %s" %self.nom - print (mes) + mes = "ERREUR LORS DE L EVALUATION DE LA FORMULE %s" % self.nom + print(mes) raise return res @@ -73,22 +65,22 @@ class formule(ASSD): self.nompar = nom_para self.expression = texte try: - self.code = compile(texte, texte, 'eval') + self.code = compile(texte, texte, "eval") except SyntaxError as exc: - mes = "ERREUR LORS DE LA CREATION DE LA FORMULE %s" %self.nom - print (mes) + mes = "ERREUR LORS DE LA CREATION DE LA FORMULE %s" % self.nom + print(mes) raise def __setstate__(self, state): """Cette methode sert a restaurer l'attribut code lors d'un unpickle.""" - self.__dict__.update(state) # update attributes + self.__dict__.update(state) # update attributes self.setFormule(self.nompar, self.expression) # restore code attribute def __getstate__(self): """Pour les formules, il faut enlever l'attribut code qui n'est pas picklable.""" d = ASSD.__getstate__(self) - del d['code'] + del d["code"] return d def supprime(self, force=False): @@ -107,7 +99,7 @@ class formule(ASSD): conservé. """ if force: - for ctxt in ('parent_context', 'g_context'): + for ctxt in ("parent_context", "g_context"): if hasattr(self, ctxt): setattr(self, ctxt, None) ASSD.supprime(self, force) @@ -118,24 +110,23 @@ class formule(ASSD): """ from SD.sd_fonction import sd_formule from Utilitai.Utmess import UTMESS + if self.accessible(): - TypeProl = { - 'E': 'EXCLU', 'L': 'LINEAIRE', 'C': 'CONSTANT', 'I': 'INTERPRE'} + TypeProl = {"E": "EXCLU", "L": "LINEAIRE", "C": "CONSTANT", "I": "INTERPRE"} sd = sd_formule(self.getName()) prol = sd.PROL.get() nova = sd.NOVA.get() if prol is None or nova is None: - UTMESS('F', 'SDVERI_2', valk=[objev]) + UTMESS("F", "SDVERI_2", valk=[objev]) dico = { - 'INTERPOL': ['LIN', 'LIN'], - 'NOM_PARA': [s.strip() for s in nova], - 'NOM_RESU': prol[3][0:16].strip(), - 'PROL_DROITE': TypeProl['E'], - 'PROL_GAUCHE': TypeProl['E'], + "INTERPOL": ["LIN", "LIN"], + "NOM_PARA": [s.strip() for s in nova], + "NOM_RESU": prol[3][0:16].strip(), + "PROL_DROITE": TypeProl["E"], + "PROL_GAUCHE": TypeProl["E"], } else: - raise Accas.AsException( - "Erreur dans fonction.Parametres en PAR_LOT='OUI'") + raise Accas.AsException("Erreur dans fonction.Parametres en PAR_LOT='OUI'") return dico diff --git a/Noyau/N_FORM.py b/Noyau/N_FORM.py index 9ec437dc..e69bfd63 100644 --- a/Noyau/N_FORM.py +++ b/Noyau/N_FORM.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -18,7 +18,6 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -from __future__ import absolute_import from . import N_MACRO from . import N_FORM_ETAPE @@ -26,8 +25,9 @@ from . import N_FORM_ETAPE class FORM(N_MACRO.MACRO): """ - Cette classe sert à définir dans le catalogue des objets de type - FORMULE pour ASTER. - Elle surcharge la classe MACRO + Cette classe sert à définir dans le catalogue des objets de type + FORMULE pour ASTER. + Elle surcharge la classe MACRO """ + class_instance = N_FORM_ETAPE.FORM_ETAPE diff --git a/Noyau/N_FORM_ETAPE.py b/Noyau/N_FORM_ETAPE.py index ec62c461..0dc466d4 100644 --- a/Noyau/N_FORM_ETAPE.py +++ b/Noyau/N_FORM_ETAPE.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -17,15 +17,13 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com - -from __future__ import absolute_import from . import N_MACRO_ETAPE class FORM_ETAPE(N_MACRO_ETAPE.MACRO_ETAPE): """ - Cette classe sert à construire l'objet ACCAS correspondant à une - FORMULE Aster. - Il s'agit d'un objet MACRO_ETAPE légèrement modifié + Cette classe sert à construire l'objet ACCAS correspondant à une + FORMULE Aster. + Il s'agit d'un objet MACRO_ETAPE légèrement modifié """ diff --git a/Noyau/N_GEOM.py b/Noyau/N_GEOM.py index 5f0cec66..290443a6 100644 --- a/Noyau/N_GEOM.py +++ b/Noyau/N_GEOM.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -16,29 +16,23 @@ # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com - - """ - """ -from __future__ import absolute_import -from .N_ASSD import ASSD -try:basestring -except NameError: basestring = str +from .N_ASSD import ASSD class GEOM(ASSD): """ - Cette classe sert à définir les types de concepts - géométriques comme GROUP_NO, GROUP_MA,NOEUD et MAILLE + Cette classe sert à définir les types de concepts + géométriques comme GROUP_NO, GROUP_MA,NOEUD et MAILLE + inusitée """ - def __init__(self, nom, etape=None, sd=None, reg='oui'): - """ - """ + def __init__(self, nom, etape=None, sd=None, reg="oui"): + """ """ self.etape = etape self.sd = sd if etape: @@ -52,7 +46,7 @@ class GEOM(ASSD): if not self.parent: self.id = None - elif reg == 'oui': + elif reg == "oui": self.id = self.parent.regSD(self) self.nom = nom @@ -60,10 +54,10 @@ class GEOM(ASSD): return self.nom def __convert__(cls, valeur): - if isinstance(valeur, basestring) and len(valeur.strip()) <= 8: + if isinstance(valeur, str) and len(valeur.strip()) <= 8: return valeur.strip() - raise ValueError( - _(u'On attend une chaine de caractères (de longueur <= 8).')) + raise ValueError(_("On attend une chaine de caractères (de longueur <= 8).")) + __convert__ = classmethod(__convert__) diff --git a/Noyau/N_JDC.py b/Noyau/N_JDC.py index 910c4797..db024c0f 100644 --- a/Noyau/N_JDC.py +++ b/Noyau/N_JDC.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -21,14 +21,8 @@ """ Ce module contient la classe JDC qui sert a interpreter un jeu de commandes """ - -# Modules Python -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import str - from builtins import range -except : pass +from builtins import str +from builtins import range import os import traceback import types @@ -43,37 +37,18 @@ from .N_ASSD import ASSD from .strfunc import getEncoding -MemoryErrorMsg = """MemoryError : - -En general, cette erreur se produit car la memoire utilisee hors du fortran -(jeveux) est importante. - -Causes possibles : - - le calcul produit de gros objets Python dans une macro-commande ou - dans le jeu de commande lui-meme, - - le calcul appelle un solveur (MUMPS par exemple) ou un outil externe - qui a besoin de memoire hors jeveux, - - utilisation de jeveux dynamique, - - ... - -Solution : - - distinguer la memoire limite du calcul (case "Memoire totale" de astk) - de la memoire reservee a jeveux (case "dont Aster"), le reste etant - disponible pour les allocations dynamiques. -""" - - class JDC(N_OBJECT.OBJECT): """ - Cette classe interprete un jeu de commandes fourni sous - la forme d'une chaine de caractères + Cette classe interprete un jeu de commandes fourni sous + la forme d'une chaine de caractères - Attributs de classe : + Attributs de classe : - Attributs d'instance : + Attributs d'instance : """ + nature = "JDC" CR = N_CR.CR exec_init = """ @@ -85,9 +60,18 @@ NONE = None from .N_utils import SEP - def __init__(self, definition=None, procedure=None, cata=None, - cata_ord_dico=None, parent=None, - nom='SansNom', appliEficas=None, context_ini=None, **args): + def __init__( + self, + definition=None, + procedure=None, + cata=None, + cata_ord_dico=None, + parent=None, + nom="SansNom", + appliEficas=None, + context_ini=None, + **args + ): self.procedure = procedure self.definition = definition self.cata = cata @@ -108,7 +92,7 @@ NONE = None self.args.update(args) self.nstep = 0 self.nsd = 0 - self.parLot = 'OUI' + self.parLot = "OUI" self.parLot_user = None if definition: self.regles = definition.regles @@ -119,11 +103,12 @@ NONE = None # # Creation de l objet compte rendu pour collecte des erreurs # - self.cr = self.CR(debut="CR phase d'initialisation", - fin="fin CR phase d'initialisation") + self.cr = self.CR( + debut="CR phase d'initialisation", fin="fin CR phase d'initialisation" + ) # on met le jdc lui-meme dans le context global pour l'avoir sous # l'etiquette "jdc" dans le fichier de commandes - self.g_context = {'jdc': self} + self.g_context = {"jdc": self} CONTEXT.unsetCurrentJdC() CONTEXT.setCurrentJdC(self) # Dictionnaire pour stocker tous les concepts du JDC (acces rapide par @@ -142,24 +127,21 @@ NONE = None def compile(self): """ - Cette methode compile la chaine procedure - Si des erreurs se produisent, elles sont consignees dans le - compte-rendu self.cr + Cette methode compile la chaine procedure + Si des erreurs se produisent, elles sont consignees dans le + compte-rendu self.cr """ try: # Python 2.7 compile function does not accept unicode filename, so we encode it # with the current locale encoding in order to have a correct # traceback encoded_filename = self.nom.encode(getEncoding()) - self.proc_compile = compile( - self.procedure, encoded_filename, 'exec') + self.proc_compile = compile(self.procedure, encoded_filename, "exec") except SyntaxError as e: if CONTEXT.debug: traceback.print_exc() l = traceback.format_exception_only(SyntaxError, e) - self.cr.exception("Compilation impossible : " + ''.join(l)) - except MemoryError as e: - self.cr.exception(MemoryErrorMsg) + self.cr.exception("Compilation impossible : " + "".join(l)) except SystemError as e: erreurs_connues = """ Causes possibles : @@ -169,7 +151,7 @@ Causes possibles : """ l = traceback.format_exception_only(SystemError, e) l.append(erreurs_connues) - self.cr.exception("Compilation impossible : " + ''.join(l)) + self.cr.exception("Compilation impossible : " + "".join(l)) return def setCurrentContext(self): @@ -180,8 +162,8 @@ Causes possibles : def execCompile(self): """ - Cette methode execute le jeu de commandes compile dans le contexte - self.g_context de l'objet JDC + Cette methode execute le jeu de commandes compile dans le contexte + self.g_context de l'objet JDC """ CONTEXT.setCurrentStep(self) @@ -191,18 +173,19 @@ Causes possibles : # Dans le cas d'une chaine de caractères il faut acceder # aux commandes qui sont dans la chaine import linecache - linecache.cache[self.nom] = 0, 0, self.procedure.split('\n'), self.nom + + linecache.cache[self.nom] = 0, 0, self.procedure.split("\n"), self.nom try: exec(self.exec_init, self.g_context) for obj_cata in (self.cata,): if type(obj_cata) == types.ModuleType: init2 = "from " + obj_cata.__name__ + " import *" exec(init2, self.g_context) - else : + else: # ici on a un catalogue en grammaire Eficas XML # il faut ajouter ce qu on a construit au contexte - for (k,v) in obj_cata.contexteXML.items() : - self.g_context[k]=v + for k, v in obj_cata.contexteXML.items(): + self.g_context[k] = v # Initialisation du contexte global pour l'evaluation des conditions de BLOC # On utilise une copie de l'initialisation du contexte du jdc self.condition_context = self.g_context.copy() @@ -217,7 +200,7 @@ Causes possibles : if isinstance(sd, ASSD): self.sdsDict[sdnom] = sd - #if self.appliEficas != None: + # if self.appliEficas != None: # self.appliEficas.afficheInfos( # 'Interpretation du fichier de commandes en cours ...') @@ -242,7 +225,7 @@ Causes possibles : # erreur CONTEXT.unsetCurrentStep() self.afficheFinExec() - self.traiterFinExec('commande') + self.traiterFinExec("commande") except AsException as e: # une erreur a ete identifiee @@ -251,26 +234,24 @@ Causes possibles : # l'exception a ete recuperee avant (ou, comment ?), # donc on cherche dans le texte txt = str(e) - if txt.find('MemoryError') >= 0: - txt = MemoryErrorMsg self.cr.exception(txt) CONTEXT.unsetCurrentStep() except NameError as e: etype, value, tb = sys.exc_info() l = traceback.extract_tb(tb) - s = traceback.format_exception_only(NameError,e) + s = traceback.format_exception_only(NameError, e) msg = "erreur de syntaxe, %s ligne %d" % (s, l[-1][1]) if CONTEXT.debug: traceback.print_exc() self.cr.exception(msg) CONTEXT.unsetCurrentStep() - # except self.UserError as exc_val: - # self.traiterUserException(exc_val) - # CONTEXT.unsetCurrentStep() - # self.afficheFinExec() - # self.traiterFinExec('commande') + # except self.UserError as exc_val: + # self.traiterUserException(exc_val) + # CONTEXT.unsetCurrentStep() + # self.afficheFinExec() + # self.traiterFinExec('commande') except: # erreur inattendue @@ -284,43 +265,46 @@ Causes possibles : exc_typ, exc_val, exc_fr = sys.exc_info() l = traceback.format_exception(exc_typ, exc_val, exc_fr) self.cr.exception( - "erreur non prevue et non traitee prevenir la maintenance " + '\n' + ''.join(l)) + "erreur non prevue et non traitee prevenir la maintenance " + + "\n" + + "".join(l) + ) del exc_typ, exc_val, exc_fr CONTEXT.unsetCurrentStep() - idx=0 + idx = 0 for e in self.etapes: - self.enregistreEtapePyxb(e,idx) - idx=idx+1 + self.enregistreEtapePyxb(e, idx) + idx = idx + 1 def afficheFinExec(self): """ - Cette methode realise l'affichage final des statistiques de temps - apres l'execution de toutes - les commandes en mode commande par commande ou par lot - Elle doit etre surchargee pour en introduire un + Cette methode realise l'affichage final des statistiques de temps + apres l'execution de toutes + les commandes en mode commande par commande ou par lot + Elle doit etre surchargee pour en introduire un """ return def traiterFinExec(self, mode, etape=None): """ - Cette methode realise un traitement final apres l'execution de toutes - les commandes en mode commande par commande ou par lot - Par defaut il n'y a pas de traitement. Elle doit etre surchargee - pour en introduire un + Cette methode realise un traitement final apres l'execution de toutes + les commandes en mode commande par commande ou par lot + Par defaut il n'y a pas de traitement. Elle doit etre surchargee + pour en introduire un """ - print ( "FIN D'EXECUTION %s %s" %s( mode, etape)) + print("FIN D'EXECUTION %s %s" % s(mode, etape)) def traiterUserException(self, exc_val): """Cette methode realise un traitement sur les exceptions utilisateur - Par defaut il n'y a pas de traitement. La methode doit etre - surchargee pour en introduire un. + Par defaut il n'y a pas de traitement. La methode doit etre + surchargee pour en introduire un. """ return def register(self, etape): """ - Cette methode ajoute etape dans la liste des etapes : self.etapes - et retourne un numero d'enregistrement + Cette methode ajoute etape dans la liste des etapes : self.etapes + et retourne un numero d'enregistrement """ self.etapes.append(etape) self.index_etapes[etape] = len(self.etapes) - 1 @@ -328,7 +312,7 @@ Causes possibles : def o_register(self, sd): """ - Retourne un identificateur pour concept + Retourne un identificateur pour concept """ self.nsd = self.nsd + 1 nom = sd.idracine + self.SEP + repr(self.nsd) @@ -336,7 +320,7 @@ Causes possibles : def gRegister(self, etape): """ - Retourne un identificateur pour etape + Retourne un identificateur pour etape """ self.nstep = self.nstep + 1 idetape = etape.idracine + self.SEP + repr(self.nstep) @@ -344,45 +328,46 @@ Causes possibles : def createSdprod(self, etape, nomsd): """ - Cette methode doit fabriquer le concept produit retourne - par l'etape etape et le nommer. + Cette methode doit fabriquer le concept produit retourne + par l'etape etape et le nommer. - Elle est appelee a l'initiative de l'etape - pendant le processus de construction de cette etape : - methode __call__ de la classe CMD (OPER ou MACRO) + Elle est appelee a l'initiative de l'etape + pendant le processus de construction de cette etape : + methode __call__ de la classe CMD (OPER ou MACRO) - Ce travail est realise par le contexte superieur - (etape.parent) car dans certains cas, le concept ne doit - pas etre fabrique mais l'etape doit simplement utiliser - un concept preexistant. + Ce travail est realise par le contexte superieur + (etape.parent) car dans certains cas, le concept ne doit + pas etre fabrique mais l'etape doit simplement utiliser + un concept preexistant. - Deux cas possibles : - - Cas 1 : etape.reuse != None : le concept est reutilise - - Cas 2 : l'etape appartient a une macro qui a declare un - concept de sortie qui doit etre produit par cette - etape. - Dans le cas du JDC, le deuxième cas ne peut pas se produire. + Deux cas possibles : + - Cas 1 : etape.reuse != None : le concept est reutilise + - Cas 2 : l'etape appartient a une macro qui a declare un + concept de sortie qui doit etre produit par cette + etape. + Dans le cas du JDC, le deuxième cas ne peut pas se produire. """ sd = etape.getSdProd() - if sd != None and (etape.definition.reentrant == 'n' or etape.reuse is None): + if sd != None and (etape.definition.reentrant == "n" or etape.reuse is None): # ATTENTION : On ne nomme la SD que dans le cas de non reutilisation # d un concept. Commande non reentrante ou reuse absent. self.nommerSDProd(sd, nomsd) return sd - def nommerSDProd(self, sd, sdnom, restrict='non'): + def nommerSDProd(self, sd, sdnom, restrict="non"): """ - Nomme la SD apres avoir verifie que le nommage est possible : nom - non utilise - Si le nom est deja utilise, leve une exception - Met le concept cree dans le concept global g_context + Nomme la SD apres avoir verifie que le nommage est possible : nom + non utilise + Si le nom est deja utilise, leve une exception + Met le concept cree dans le concept global g_context """ o = self.sdsDict.get(sdnom, None) if isinstance(o, ASSD): raise AsException("Nom de concept deja defini : %s" % sdnom) if sdnom in self._reserved_kw: raise AsException( - "Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom) + "Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom + ) # Ajoute a la creation (appel de regSD). self.sdsDict[sdnom] = sd @@ -390,28 +375,27 @@ Causes possibles : # En plus si restrict vaut 'non', on insere le concept dans le contexte # du JDC - if restrict == 'non': + if restrict == "non": self.g_context[sdnom] = sd - def regUserSD(self,sd): - # utilisee pour creer les references - # se contente d appeler la methode equivalente sur le jdc - id=self.regSD(sd) - self.nommerSDProd(sd,sd.nom) + def regUserSD(self, sd): + # utilisee pour creer les references + # se contente d appeler la methode equivalente sur le jdc + id = self.regSD(sd) + self.nommerSDProd(sd, sd.nom) return id - def regSD(self, sd): """ - Methode appelee dans l __init__ d un ASSD lors de sa creation - pour s enregistrer + Methode appelee dans l __init__ d un ASSD lors de sa creation + pour s enregistrer """ return self.o_register(sd) def deleteConceptAfterEtape(self, etape, sd): """ - Met a jour les etapes du JDC qui sont après etape suite a - la disparition du concept sd + Met a jour les etapes du JDC qui sont après etape suite a + la disparition du concept sd """ # Cette methode est definie dans le noyau mais ne sert que pendant # la phase de creation des etapes et des concepts. Il n'y a aucun @@ -437,28 +421,28 @@ Causes possibles : e.jdc = jdc del self.index_etapes[e] - def getFile(self, unite=None, fic_origine='', fname=None): + def getFile(self, unite=None, fic_origine="", fname=None): """ - Retourne le nom du fichier correspondant a un numero d'unite - logique (entier) ainsi que le source contenu dans le fichier + Retourne le nom du fichier correspondant a un numero d'unite + logique (entier) ainsi que le source contenu dans le fichier """ - #if self.appliEficas: - # Si le JDC est relie a une appliEficascation maitre, on delègue la - # recherche + # if self.appliEficas: + # Si le JDC est relie a une appliEficascation maitre, on delègue la + # recherche # return self.appliEficas.getFile(unite, fic_origine) - #else: + # else: # if unite != None: # if os.path.exists("fort." + str(unite)): # fname = "fort." + str(unite) if fname == None: raise AsException("Impossible de trouver le fichier correspondant") if not os.path.exists(fname): - raise AsException(fname + " n'est pas un fichier existant" ) - fproc = open(fname, 'r') + raise AsException(fname + " n'est pas un fichier existant") + fproc = open(fname, "r") text = fproc.read() fproc.close() - text = text.replace('\r\n', '\n') - linecache.cache[fname] = 0, 0, text.split('\n'), fname + text = text.replace("\r\n", "\n") + linecache.cache[fname] = 0, 0, text.split("\n"), fname return fname, text def set_parLot(self, parLot, user_value=False): @@ -480,19 +464,19 @@ Causes possibles : self.parLot = parLot else: # Avec appliEficascation maitre - self.parLot = 'OUI' + self.parLot = "OUI" def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitJDC(self) def interact(self): """ - Cette methode a pour fonction d'ouvrir un interpreteur - pour que l'utilisateur entre des commandes interactivement + Cette methode a pour fonction d'ouvrir un interpreteur + pour que l'utilisateur entre des commandes interactivement """ CONTEXT.setCurrentStep(self) try: @@ -503,12 +487,15 @@ Causes possibles : # aux commandes qui sont dans le buffer de la console import linecache import code - console = code.InteractiveConsole( - self.g_context, filename="") + + console = code.InteractiveConsole(self.g_context, filename="") linecache.cache[""] = 0, 0, console.buffer, "" - banner = """*********************************************** + banner = ( + """*********************************************** * Interpreteur interactif %s -***********************************************""" % self.code +***********************************************""" + % self.code + ) console.interact(banner) finally: console = None @@ -516,10 +503,10 @@ Causes possibles : def getContexteAvant(self, etape): """ - Retourne le dictionnaire des concepts connus avant etape - On tient compte des commandes qui modifient le contexte - comme DETRUIRE ou les macros - Si etape == None, on retourne le contexte en fin de JDC + Retourne le dictionnaire des concepts connus avant etape + On tient compte des commandes qui modifient le contexte + comme DETRUIRE ou les macros + Si etape == None, on retourne le contexte en fin de JDC """ # L'etape courante pour laquelle le contexte a ete calcule est # memorisee dans self.index_etape_courante @@ -529,11 +516,11 @@ Causes possibles : # Si on insère des commandes (par ex, dans EFICAS), il faut prealablement # remettre ce pointeur a 0 # self.currentContext.items() if isinstance(v, ASSD)]) - #if self.parLot_user == 'NON': + # if self.parLot_user == 'NON': # d = self.currentContext = self.g_context.copy() # if etape is None: # return d - # retirer les sd produites par 'etape' + # retirer les sd produites par 'etape' # sd_names = [sd.nom for sd in etape.getCreated_sd()] # for nom in sd_names: # try: @@ -554,7 +541,7 @@ Causes possibles : d = self.currentContext if self.index_etape_courante == 0 and self.context_ini: d.update(self.context_ini) - liste_etapes = self.etapes[self.index_etape_courante:index_etape] + liste_etapes = self.etapes[self.index_etape_courante : index_etape] else: d = self.currentContext = {} if self.context_ini: @@ -582,8 +569,8 @@ Causes possibles : def getContexteCourant(self, etape_courante=None): """ - Retourne le contexte tel qu'il est (ou 'sera' si on est en phase - de construction) au moment de l'execution de l'etape courante. + Retourne le contexte tel qu'il est (ou 'sera' si on est en phase + de construction) au moment de l'execution de l'etape courante. """ if etape_courante is None: etape_courante = CONTEXT.getCurrentStep() @@ -591,7 +578,7 @@ Causes possibles : def getConcept(self, nomsd): """ - Methode pour recuperer un concept a partir de son nom + Methode pour recuperer un concept a partir de son nom """ co = self.getContexteCourant().get(nomsd.strip(), None) if not isinstance(co, ASSD): @@ -600,8 +587,8 @@ Causes possibles : def getConceptByType(self, nomsd, typesd, etape): """ - Methode pour recuperer un concept a partir de son nom et de son type. - Il aura comme père 'etape'. + Methode pour recuperer un concept a partir de son nom et de son type. + Il aura comme père 'etape'. """ assert issubclass(typesd, ASSD), typesd co = typesd(etape=etape) @@ -611,8 +598,8 @@ Causes possibles : def delConcept(self, nomsd): """ - Methode pour supprimer la reference d'un concept dans le sdsDict. - Ne detruire pas le concept (different de supprime). + Methode pour supprimer la reference d'un concept dans le sdsDict. + Ne detruire pas le concept (different de supprime). """ try: del self.sdsDict[nomsd.strip()] @@ -621,9 +608,9 @@ Causes possibles : def getCmd(self, nomcmd): """ - Methode pour recuperer la definition d'une commande - donnee par son nom dans les catalogues declares - au niveau du jdc + Methode pour recuperer la definition d'une commande + donnee par son nom dans les catalogues declares + au niveau du jdc """ for cata in (self.cata,): if hasattr(cata, nomcmd): @@ -631,8 +618,8 @@ Causes possibles : def append_reset(self, etape): """ - Ajoute une etape provenant d'un autre jdc a la liste des etapes - et remet a jour la parente de l'etape et des concepts + Ajoute une etape provenant d'un autre jdc a la liste des etapes + et remet a jour la parente de l'etape et des concepts """ self.etapes.append(etape) self.index_etapes[etape] = len(self.etapes) - 1 @@ -640,33 +627,71 @@ Causes possibles : etape.resetJdc(self) def sdAccessible(self): - """On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON". - """ + """On peut acceder aux "valeurs" (jeveux) des ASSD si le JDC est en PAR_LOT="NON".""" if CONTEXT.debug: - print((' `- JDC sdAccessible : PAR_LOT =', self.parLot)) - return self.parLot == 'NON' + print((" `- JDC sdAccessible : PAR_LOT =", self.parLot)) + return self.parLot == "NON" - def getEtapesByName(self,name): - listeDEtapes=[] - for e in self.etapes : - if e.nom == name : listeDEtapes.append(e) + def getEtapesByName(self, name): + listeDEtapes = [] + for e in self.etapes: + if e.nom == name: + listeDEtapes.append(e) return listeDEtapes - def getEtapeByConceptName(self,conceptName): - for e in self.etapes : - if hasattr(e,'sdnom') and e.sdnom == conceptName : return e - + def getEtapeByConceptName(self, conceptName): + for e in self.etapes: + if hasattr(e, "sdnom") and e.sdnom == conceptName: + return e def _build_reserved_kw_list(self): """Construit la liste des mots-cles reserves (interdits pour le nommage des concepts).""" self._reserved_kw = set() - #for cat in self.cata: - cat=self.cata + # for cat in self.cata: + cat = self.cata self._reserved_kw.update( - #PN 14 2020 [kw for kw in dir(cat) if len(kw) <= 8 and kw == kw.upper()]) - [kw for kw in dir(cat) ]) + # PN 14 2020 [kw for kw in dir(cat) if len(kw) <= 8 and kw == kw.upper()]) + [kw for kw in dir(cat)] + ) self._reserved_kw.difference_update( - ['OPER', 'MACRO', 'BLOC', 'SIMP', 'FACT', 'FORM', - 'GEOM', 'MCSIMP', 'MCFACT']) - + [ + "OPER", + "MACRO", + "BLOC", + "SIMP", + "FACT", + "FORM", + "GEOM", + "MCSIMP", + "MCFACT", + ] + ) + + def prepareInsertInDB(self): + debug = 1 + if debug: + print("prepareInsertInDB traitement de ", self.nom) + if hasattr(self, "dPrimaryKey"): + dPrimaryKey = self.dPrimaryKey + else: + dPrimaryKey = {} + if hasattr(self, "dElementsRecursifs"): + dElementsRecursifs = self.dElementsRecursifs + else: + dElementsRecursifs = {} + dictKey = {} + if debug: + print("dElementsRecursifs", dElementsRecursifs) + if debug: + print( + "dPrimaryKey", + dPrimaryKey, + ) + for mc in dPrimaryKey.values(): + dictKey[mc] = None + texte = "" + for e in self.etapes: + tc, tv, ta = e.prepareInsertInDB(dictKey, dElementsRecursifs, dPrimaryKey) + texte += tc + tv + ta + return texte diff --git a/Noyau/N_JDC_CATA.py b/Noyau/N_JDC_CATA.py index 3f6fcafa..7f54a25b 100644 --- a/Noyau/N_JDC_CATA.py +++ b/Noyau/N_JDC_CATA.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,7 +23,6 @@ qui permet de spécifier les caractéristiques d'un JDC """ -from __future__ import absolute_import import types import traceback @@ -34,24 +33,35 @@ from . import N_JDC class JDC_CATA(N_ENTITE.ENTITE): """ - Classe pour definir un jeu de commandes + Classe pour definir un jeu de commandes - Attributs de classe : + Attributs de classe : - - class_instance qui indique la classe qui devra etre utilisée - pour créer l'objet qui servira à controler la conformité - du jeu de commandes avec sa définition + - class_instance qui indique la classe qui devra etre utilisée + pour créer l'objet qui servira à controler la conformité + du jeu de commandes avec sa définition - - label qui indique la nature de l'objet de définition (ici, JDC) + - label qui indique la nature de l'objet de définition (ici, JDC) """ - class_instance = N_JDC.JDC - label = 'JDC' - def __init__(self, code='', execmodul=None, regles=(), niveaux=(),fichierSource=None, fr='', ang ='', **args): + class_instance = N_JDC.JDC + label = "JDC" + + def __init__( + self, + code="", + execmodul=None, + regles=(), + niveaux=(), + fichierSource=None, + fr="", + ang="", + **args + ): """ on se laisse la possibilite d initier fichierSource avec autre chose que le nom du fichier - au cas ou ... pour pouvoir changer le nom du 'sous code' implementer (cf readercata) + au cas ou ... pour pouvoir changer le nom du 'sous code' implemente (cf readercata) """ self.code = code self.fr = fr @@ -65,7 +75,7 @@ class JDC_CATA(N_ENTITE.ENTITE): # et seront passés au JDC pour initialiser ses paramètres propres self.args = args self.d_niveaux = {} - self.l_niveaux = niveaux + self.lNiveaux = niveaux self.commandes = [] self.fichierSource = fichierSource for niveau in niveaux: @@ -74,86 +84,129 @@ class JDC_CATA(N_ENTITE.ENTITE): # courant à None CONTEXT.unsetCurrentCata() CONTEXT.setCurrentCata(self) - self.fenetreIhm=None + self.fenetreIhm = None self.definitUserASSD = False self.definitUserASSDMultiple = False - self.dictTypesXSD={} - self.dictTypesXSDJumeaux={} - self.dictTypesASSDorUserASSDCrees={} - self.dictTypesASSDorUserASSDUtilises={} - self.listeUserASSDDumpes=set() - self.listeTypeTXMAvecBlancs=set() - - - def __call__(self, procedure=None, cata=None, cata_ord_dico=None, - nom='SansNom', parent=None, **args): - """ - Construit l'objet JDC a partir de sa definition (self), - """ - return self.class_instance(definition=self, procedure=procedure, - cata=cata, cata_ord_dico=cata_ord_dico, - nom=nom, - parent=parent, - **args - ) + self.dictTypesXSD = {} + self.dictTypesXSDJumeaux = {} + self.dictTypesASSDorUserASSDCrees = {} + self.dictTypesASSDorUserASSDUtilises = {} + self.listeUserASSDDumpes = set() + self.listeTypeTXMAvecBlancs = set() + + def __call__( + self, + procedure=None, + cata=None, + cata_ord_dico=None, + nom="SansNom", + parent=None, + **args + ): + """ + Construit l'objet JDC a partir de sa definition (self), + """ + return self.class_instance( + definition=self, + procedure=procedure, + cata=cata, + cata_ord_dico=cata_ord_dico, + nom=nom, + parent=parent, + **args + ) def enregistre(self, commande): """ - Methode qui permet aux definitions de commandes de s'enregistrer aupres - d'un JDC_CATA + Methode qui permet aux definitions de commandes de s'enregistrer aupres + d'un JDC_CATA """ self.commandes.append(commande) def verifCata(self): """ - Méthode de vérification des attributs de définition + Méthode de vérification des attributs de définition """ self.checkRegles() self.verifCataRegles() def verifCataRegles(self): """ - Cette méthode vérifie pour tous les objets stockés dans la liste entités - respectent les REGLES associés à self + Cette méthode vérifie pour tous les objets stockés dans la liste entités + respectent les REGLES associés à self """ # A FAIRE def report(self): """ - Methode pour produire un compte-rendu de validation d'un catalogue de commandes + Methode pour produire un compte-rendu de validation d'un catalogue de commandes """ self.cr = self.CR( - debut=u"Compte-rendu de validation du catalogue " + self.code, - fin=u"Fin Compte-rendu de validation du catalogue " + self.code) + debut="Compte-rendu de validation du catalogue " + self.code, + fin="Fin Compte-rendu de validation du catalogue " + self.code, + ) self.verifCata() for commande in self.commandes: cr = commande.report() - cr.debut = u"Début Commande :" + commande.nom - cr.fin = u"Fin commande :" + commande.nom + cr.debut = "Début Commande :" + commande.nom + cr.fin = "Fin commande :" + commande.nom self.cr.add(cr) return self.cr def supprime(self): """ - Méthode pour supprimer les références arrières susceptibles de provoquer - des cycles de références + Méthode pour supprimer les références arrières susceptibles de provoquer + des cycles de références """ for commande in self.commandes: commande.supprime() def getNiveau(self, nom_niveau): """ - Retourne l'objet de type NIVEAU de nom nom_niveau - ou None s'il n'existe pas + Retourne l'objet de type NIVEAU de nom nom_niveau + ou None s'il n'existe pas """ return self.d_niveaux.get(nom_niveau, None) - def dumpStructure(self): - texte="" + texte = "" + for c in self.commandes: + if not (c.label != "OPER") and not (c.label != "PROC"): + continue + if c.label == "OPER": + texte += c.nom + " " + str(c.sd_prod) + "\n" + if c.label == "PROC": + texte += c.nom + " \n" + texte += c.dumpStructure() + return texte + + def dumpStringDataBase(self, nomDataBaseACreer): + texte = "create database {}; \n".format(nomDataBaseACreer) + texte += "create user admin{}; \n".format(nomDataBaseACreer) + texte += "grant all privileges on database {} to admin{}; \n".format( + nomDataBaseACreer, nomDataBaseACreer + ) + texte += "********* fin de creation de la database ********* \n" + dictPrimaryKey = {} + dictRecursif = {} + if hasattr(self.cata, "dPrimaryKey"): + dPrimaryKey = self.cata.dPrimaryKey + if hasattr(self.cata, "dElementsRecursifs"): + dElementsRecursifs = self.cata.dElementsRecursifs + for c in self.commandes: + if not (c.label != "OPER") and not (c.label != "PROC"): + continue # une macro ? + texte += c.dumpStringDataBase(dPrimaryKey, dElementsRecursifs, {}, False) + # print (texte) + return texte + + def dumpGitStringFormat(self): + texte = "git log --pretty=format:'" for c in self.commandes: - if not(c.label != "OPER") and not(c.label != 'PROC') : continue - if c.label == "OPER" : texte+=c.nom + " "+ str(c.sd_prod) + "\n" - if c.label == "PROC" : texte+=c.nom + " \n" - texte+=c.dumpStructure() + if not (c.label != "OPER") and not (c.label != "PROC"): + continue + texte += "".format(c.nom) + texte += c.dumpGitStringFormat() + texte += "".format(c.nom) + texte += "'" return texte diff --git a/Noyau/N_LASSD.py b/Noyau/N_LASSD.py index a4840a51..b3e754ad 100644 --- a/Noyau/N_LASSD.py +++ b/Noyau/N_LASSD.py @@ -1,5 +1,5 @@ # -*- coding: iso-8859-1 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -16,6 +16,9 @@ # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -from __future__ import absolute_import + from .N_ASSD import ASSD -class LASSD(ASSD,list):pass + + +class LASSD(ASSD, list): + pass diff --git a/Noyau/N_MACRO.py b/Noyau/N_MACRO.py index c15a70e6..b9981deb 100644 --- a/Noyau/N_MACRO.py +++ b/Noyau/N_MACRO.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -16,14 +16,12 @@ # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com - - """ Ce module contient la classe de definition MACRO qui permet de spécifier les caractéristiques d'une macro-commande """ -from __future__ import absolute_import + import types import traceback @@ -35,63 +33,67 @@ from . import nommage class MACRO(N_ENTITE.ENTITE): """ - Classe pour definir une macro-commande - - Cette classe a trois attributs de classe - - - class_instance qui indique la classe qui devra etre utilisée - pour créer l'objet qui servira à controler la conformité d'un - macro-commande avec sa définition - - - label qui indique la nature de l'objet de définition (ici, MACRO) - - - nommage qui est un module Python qui fournit la fonctionnalité de nommage - - et les attributs d'instance suivants : - - - nom : son nom - - - op : le numéro d'opérateur - - - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne - une classe - - - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur - réentrant peut modifier un concept d'entrée et le produire comme concept de sortie - - - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur - non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort - de l'objet gérant le contexte d'exécution de vérifier cette contrainte. - - - fr : commentaire associé en francais - - - docu : clé de documentation associée - - - regles : liste des règles associées - - - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette - fonction est exécutée lors des phases d'initialisation de l'étape associée. - - - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre - rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement. - Si niveau vaut None, l'opérateur est rangé au niveau global. - - - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit - des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut - est initialisé avec args, c'est à dire les arguments d'appel restants. - + Classe pour definir une macro-commande + + Cette classe a trois attributs de classe + + - class_instance qui indique la classe qui devra etre utilisée + pour créer l'objet qui servira à controler la conformité d'un + macro-commande avec sa définition + + - label qui indique la nature de l'objet de définition (ici, MACRO) + + - nommage qui est un module Python qui fournit la fonctionnalité de nommage + + et les attributs d'instance suivants : + - nom : son nom + - op : le numéro d'opérateur + - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne + une classe + - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur + réentrant peut modifier un concept d'entrée et le produire comme concept de sortie + - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur + non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort + de l'objet gérant le contexte d'exécution de vérifier cette contrainte. + - fr : commentaire associé en francais + - docu : clé de documentation associée + - regles : liste des règles associées + - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette + fonction est exécutée lors des phases d'initialisation de l'étape associée. + - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre + rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement. + Si niveau vaut None, l'opérateur est rangé au niveau global. + - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit + des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut + est initialisé avec args, c'est à dire les arguments d'appel restants. """ + class_instance = N_MACRO_ETAPE.MACRO_ETAPE - label = 'MACRO' + label = "MACRO" nommage = nommage def __init__( - self, nom, op=None, sd_prod=None, reentrant='n', repetable='o', fr="",ang="",fenetreIhm=None, - docu="", regles=(), op_init=None, niveau = None, fichier_ini=0, UIinfo=None, **args): + self, + nom, + op=None, + sd_prod=None, + reentrant="n", + repetable="o", + fr="", + ang="", + fenetreIhm=None, + docu="", + regles=(), + op_init=None, + niveau=None, + fichier_ini=0, + UIinfo=None, + **args + ): """ - Méthode d'initialisation de l'objet MACRO. Les arguments sont utilisés pour initialiser - les attributs de meme nom + Méthode d'initialisation de l'objet MACRO. Les arguments sont utilisés pour initialiser + les attributs de meme nom """ # XXX fichier_ini n'est pas utilisé pour l'instant self.nom = nom @@ -110,10 +112,10 @@ class MACRO(N_ENTITE.ENTITE): self.sd_prod = sd_prod self.reentrant = reentrant self.fr = fr - self.ang=ang + self.ang = ang self.repetable = repetable self.docu = docu - self.fenetreIhm=fenetreIhm + self.fenetreIhm = fenetreIhm if type(regles) == tuple: self.regles = regles else: @@ -136,30 +138,30 @@ class MACRO(N_ENTITE.ENTITE): def __call__(self, reuse=None, **args): """ - Construit l'objet MACRO_ETAPE a partir de sa definition (self), - puis demande la construction de ses sous-objets et du concept produit. + Construit l'objet MACRO_ETAPE a partir de sa definition (self), + puis demande la construction de ses sous-objets et du concept produit. """ nomsd = self.nommage.getNomConceptResultat(self.nom) etape = self.class_instance(oper=self, reuse=reuse, args=args) etape.MCBuild() return etape.buildSd(nomsd) - def make_objet(self, mc_list='oui'): + def make_objet(self, mc_list="oui"): """ - Cette méthode crée l'objet MACRO_ETAPE dont la définition est self sans - créer sa sdprod. - Normalement l'étape est enregistrée auprès de son parent. - Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction - des objets MCxxx. + Cette méthode crée l'objet MACRO_ETAPE dont la définition est self sans + créer sa sdprod. + Normalement l'étape est enregistrée auprès de son parent. + Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction + des objets MCxxx. """ etape = self.class_instance(oper=self, reuse=None, args={}) - if mc_list == 'oui': + if mc_list == "oui": etape.MCBuild() return etape def verifCata(self): """ - Méthode de vérification des attributs de définition + Méthode de vérification des attributs de définition """ self.checkOp(valmax=0) self.checkProc() @@ -172,7 +174,7 @@ class MACRO(N_ENTITE.ENTITE): def supprime(self): """ - Méthode pour supprimer les références arrières susceptibles de provoquer - des cycles de références + Méthode pour supprimer les références arrières susceptibles de provoquer + des cycles de références """ self.niveau = None diff --git a/Noyau/N_MACRO_ETAPE.py b/Noyau/N_MACRO_ETAPE.py index 4da07525..56365aea 100644 --- a/Noyau/N_MACRO_ETAPE.py +++ b/Noyau/N_MACRO_ETAPE.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -24,11 +24,7 @@ """ # Modules Python -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import str -except : pass +from builtins import str import types import sys import traceback @@ -46,9 +42,8 @@ from .N_ASSD import ASSD class MACRO_ETAPE(N_ETAPE.ETAPE): - """ + """ """ - """ nature = "COMMANDE" typeCO = CO @@ -94,14 +89,14 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): def buildSd(self, nom): """ - Construit le concept produit de l'operateur. Deux cas - peuvent se presenter : + Construit le concept produit de l'operateur. Deux cas + peuvent se presenter : - - le parent n'est pas defini. Dans ce cas, l'etape prend en charge - la creation et le nommage du concept. + - le parent n'est pas defini. Dans ce cas, l'etape prend en charge + la creation et le nommage du concept. - - le parent est defini. Dans ce cas, l'etape demande au parent la - creation et le nommage du concept. + - le parent est defini. Dans ce cas, l'etape demande au parent la + creation et le nommage du concept. """ self.sdnom = nom @@ -113,8 +108,7 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): if self.parent: sd = self.parent.createSdprod(self, nom) if type(self.definition.op_init) == types.FunctionType: - self.definition.op_init(*( - self, self.parent.g_context)) + self.definition.op_init(*(self, self.parent.g_context)) else: sd = self.getSdProd() if sd != None and self.reuse == None: @@ -124,10 +118,17 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): self.resetCurrentStep() except AsException as e: self.resetCurrentStep() - raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0], - 'fichier : ', self.appel[1], e) - #except (EOFError, self.UserError): - except (EOFError): + raise AsException( + "Etape ", + self.nom, + "ligne : ", + self.appel[0], + "fichier : ", + self.appel[1], + e, + ) + # except (EOFError, self.UserError): + except EOFError: # Le retablissement du step courant n'est pas strictement # necessaire. On le fait pour des raisons de coherence self.resetCurrentStep() @@ -135,31 +136,38 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): except: self.resetCurrentStep() l = traceback.format_exception( - sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]) - raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0], - 'fichier : ', self.appel[1] + '\n', - ''.join(l)) + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) + raise AsException( + "Etape ", + self.nom, + "ligne : ", + self.appel[0], + "fichier : ", + self.appel[1] + "\n", + "".join(l), + ) self.Execute() return sd def getSdProd(self): """ - Retourne le concept resultat d'une macro etape - La difference avec une etape ou une proc-etape tient a ce que - le concept produit peut exister ou pas + Retourne le concept resultat d'une macro etape + La difference avec une etape ou une proc-etape tient a ce que + le concept produit peut exister ou pas - Si sd_prod == None le concept produit n existe pas on retourne None + Si sd_prod == None le concept produit n existe pas on retourne None - Deux cas : - - cas 1 : sd_prod n'est pas une fonction - il s'agit d'une sous classe de ASSD - on construit le sd a partir de cette classe - et on le retourne - - cas 2 : sd_prod est une fonction - on l'evalue avec les mots-cles de l'etape (mcListe) - on construit le sd a partir de la classe obtenue - et on le retourne + Deux cas : + - cas 1 : sd_prod n'est pas une fonction + il s'agit d'une sous classe de ASSD + on construit le sd a partir de cette classe + et on le retourne + - cas 2 : sd_prod est une fonction + on l'evalue avec les mots-cles de l'etape (mcListe) + on construit le sd a partir de la classe obtenue + et on le retourne """ sd_prod = self.definition.sd_prod self.typret = None @@ -173,17 +181,18 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): # zero avant de l'appeler self.sdprods = [] sd_prod = sd_prod(*(self,), **d) - #except (EOFError, self.UserError): - except (EOFError): + # except (EOFError, self.UserError): + except EOFError: raise except Exception as exc: if CONTEXT.debug: traceback.print_exc() - raise AsException("impossible d affecter un type au resultat:", - str(exc)) + raise AsException( + "impossible d affecter un type au resultat:", str(exc) + ) # on teste maintenant si la SD est reutilisee ou s'il faut la creer - if self.definition.reentrant != 'n' and self.reuse: + if self.definition.reentrant != "n" and self.reuse: # Le concept produit est specifie reutilise (reuse=xxx). C'est une erreur mais non fatale. # Elle sera traitee ulterieurement. self.sd = self.reuse @@ -197,12 +206,14 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): # On ne fait rien ici. L'erreur sera traitee par la suite. # precaution if self.sd is not None and not isinstance(self.sd, ASSD): - raise AsException(""" + raise AsException( + """ Impossible de typer le resultat ! Causes possibles : Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte, soit il y a une "," a la fin d'une commande precedente. - Developpeur : La fonction "sd_prod" retourne un type invalide.""") + Developpeur : La fonction "sd_prod" retourne un type invalide.""" + ) return self.sd def getType_produit(self, force=0): @@ -214,18 +225,18 @@ Causes possibles : def getType_produit_brut(self, force=0): """ - Retourne le type du concept resultat de l'etape et eventuellement type - les concepts produits "a droite" du signe egal (en entree) + Retourne le type du concept resultat de l'etape et eventuellement type + les concepts produits "a droite" du signe egal (en entree) - Deux cas : - - cas 1 : sd_prod de oper n'est pas une fonction - il s'agit d'une sous classe de ASSD - on retourne le nom de la classe - - cas 2 : il s'agit d'une fonction - on l'evalue avec les mots-cles de l'etape (mcListe) - et on retourne son resultat + Deux cas : + - cas 1 : sd_prod de oper n'est pas une fonction + il s'agit d'une sous classe de ASSD + on retourne le nom de la classe + - cas 2 : il s'agit d'une fonction + on l'evalue avec les mots-cles de l'etape (mcListe) + et on retourne son resultat """ - if not force and hasattr(self, 'typret'): + if not force and hasattr(self, "typret"): return self.typret if type(self.definition.sd_prod) == types.FunctionType: @@ -240,10 +251,10 @@ Causes possibles : def getContexteAvant(self, etape): """ - Retourne le dictionnaire des concepts connus avant etape - pour les commandes internes a la macro - On tient compte des commandes qui modifient le contexte - comme DETRUIRE ou les macros + Retourne le dictionnaire des concepts connus avant etape + pour les commandes internes a la macro + On tient compte des commandes qui modifient le contexte + comme DETRUIRE ou les macros """ # L'etape courante pour laquelle le contexte a ete calcule est # memorisee dans self.index_etape_courante @@ -263,13 +274,13 @@ Causes possibles : # elles ne sont donc pas dans le contexte de la macro appelante. # from warnings import warn # warn("concept '%s' absent du contexte de %s" % (nom, self.nom), - # RuntimeWarning, stacklevel=2) + # RuntimeWarning, stacklevel=2) return d def supprime(self): """ - Methode qui supprime toutes les references arrières afin que - l'objet puisse etre correctement detruit par le garbage collector + Methode qui supprime toutes les references arrières afin que + l'objet puisse etre correctement detruit par le garbage collector """ N_MCCOMPO.MCCOMPO.supprime(self) self.jdc = None @@ -296,15 +307,15 @@ Causes possibles : def typeSDProd(self, co, t): """ - Cette methode a pour fonction de typer le concept co avec le type t - dans les conditions suivantes : - 1. co est un concept produit de self - 2. co est un concept libre : on le type et on l attribue a self + Cette methode a pour fonction de typer le concept co avec le type t + dans les conditions suivantes : + 1. co est un concept produit de self + 2. co est un concept libre : on le type et on l attribue a self - Elle enregistre egalement les concepts produits (on fait l hypothese - que la liste sdprods a ete correctement initialisee, vide probablement) + Elle enregistre egalement les concepts produits (on fait l hypothese + que la liste sdprods a ete correctement initialisee, vide probablement) """ - if not hasattr(co, 'etape'): + if not hasattr(co, "etape"): # Le concept vaut None probablement. On ignore l'appel return # @@ -330,12 +341,18 @@ Causes possibles : # Recherche du mot cle simple associe au concept mcs = self.getMcsWithCo(co) if len(mcs) != 1: - raise AsException("""Erreur interne. -Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co) + raise AsException( + """Erreur interne. +Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" + % co + ) mcs = mcs[0] if not self.typeCO in mcs.definition.type: - raise AsException("""Erreur interne. -Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" % (co, mcs.definition.type)) + raise AsException( + """Erreur interne. +Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" + % (co, mcs.definition.type) + ) co.etape = self # affectation du bon type du concept co.changeType(t) @@ -356,8 +373,11 @@ Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pa # Le type du concept doit etre coherent avec le type demande # (seulement derive) if not isinstance(co, t): - raise AsException("""Erreur interne. -Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, co.__class__)) + raise AsException( + """Erreur interne. +Le type demande (%s) et le type du concept (%s) devraient etre derives""" + % (t, co.__class__) + ) self.sdprods.append(co) @@ -370,17 +390,26 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, # Cette règle est normalement coherente avec les règles de # verification des mots-cles if not isinstance(co, t): - raise AsException(""" + raise AsException( + """ Impossible de changer le type du concept produit (%s) en (%s). -Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)""" % (co, t, co.__class__, t)) +Le type actuel (%s) devrait etre une classe derivee du nouveau type (%s)""" + % (co, t, co.__class__, t) + ) mcs = self.getMcsWithCo(co) if len(mcs) != 1: - raise AsException("""Erreur interne. -Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" % co) + raise AsException( + """Erreur interne. +Il ne devrait y avoir qu'un seul mot cle porteur du concept CO (%s)""" + % co + ) mcs = mcs[0] if not self.typeCO in mcs.definition.type: - raise AsException("""Erreur interne. -Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" % (co, mcs.definition.type)) + raise AsException( + """Erreur interne. +Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pas CO mais seulement (%s)""" + % (co, mcs.definition.type) + ) co.etape = self # On ne change pas le type car il respecte la condition isinstance(co,t) # co.__class__ = t @@ -394,8 +423,11 @@ Impossible de changer le type du concept (%s). Le mot cle associe ne supporte pa # Il n'y a aucune raison pour que la condition ne soit pas # verifiee. if not isinstance(co, t): - raise AsException("""Erreur interne. -Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, co.__class__)) + raise AsException( + """Erreur interne. +Le type demande (%s) et le type du concept (%s) devraient etre derives""" + % (t, co.__class__) + ) self.sdprods.append(co) else: @@ -405,10 +437,10 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def issubstep(self, etape): """ - Cette methode retourne un entier indiquant si etape est une - sous etape de la macro self ou non - 1 = oui - 0 = non + Cette methode retourne un entier indiquant si etape est une + sous etape de la macro self ou non + 1 = oui + 0 = non """ if etape in self.etapes: return 1 @@ -419,8 +451,8 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def register(self, etape): """ - Enregistrement de etape dans le contexte de la macro : liste etapes - et demande d enregistrement global aupres du JDC + Enregistrement de etape dans le contexte de la macro : liste etapes + et demande d enregistrement global aupres du JDC """ self.etapes.append(etape) self.index_etapes[etape] = len(self.etapes) - 1 @@ -429,25 +461,25 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def regSD(self, sd): """ - Methode appelee dans l __init__ d un ASSD a sa creation pour - s enregistrer (reserve aux ASSD crees au sein d'une MACRO) + Methode appelee dans l __init__ d un ASSD a sa creation pour + s enregistrer (reserve aux ASSD crees au sein d'une MACRO) """ return self.jdc.o_register(sd) def createSdprod(self, etape, nomsd): """ - Cette methode doit fabriquer le concept produit retourne - par l'etape etape et le nommer. + Cette methode doit fabriquer le concept produit retourne + par l'etape etape et le nommer. - Elle est appelee a l'initiative de l'etape - pendant le processus de construction de cette etape : methode __call__ - de la classe CMD (OPER ou MACRO) - Ce travail est realise par le contexte superieur (etape.parent) - car dans certains cas, le concept ne doit pas etre fabrique mais - l'etape doit simplement utiliser un concept preexistant. - - Cas 1 : etape.reuse != None : le concept est reutilise - - Cas 2 : l'etape appartient a une macro qui a declare un concept - de sortie qui doit etre produit par cette etape. + Elle est appelee a l'initiative de l'etape + pendant le processus de construction de cette etape : methode __call__ + de la classe CMD (OPER ou MACRO) + Ce travail est realise par le contexte superieur (etape.parent) + car dans certains cas, le concept ne doit pas etre fabrique mais + l'etape doit simplement utiliser un concept preexistant. + - Cas 1 : etape.reuse != None : le concept est reutilise + - Cas 2 : l'etape appartient a une macro qui a declare un concept + de sortie qui doit etre produit par cette etape. """ if nomsd in self.Outputs: # Il s'agit d'un concept de sortie de la macro. Il ne faut pas le creer @@ -461,16 +493,23 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, # verification des mots-cles if not issubclass(sdprod, sd.__class__): raise AsException( - "Le type du concept produit %s devrait etre une sur classe de %s" % (sd.__class__, sdprod)) + "Le type du concept produit %s devrait etre une sur classe de %s" + % (sd.__class__, sdprod) + ) # La propriete du concept est transferee a l'etape avec le type # attendu par l'etape etape.sd = sd sd.etape = etape - if self.reuse == sd and etape.reuse != sd \ - and getattr(sd, "executed", 0) == 1: # n'a pas ete pas detruit - raise AsException("Le concept '%s' est reentrant dans la macro-commande %s. " - "Il devrait donc l'etre dans %s (produit sous le nom '%s')." - % (sd.nom, self.nom, etape.nom, nomsd)) + if ( + self.reuse == sd + and etape.reuse != sd + and getattr(sd, "executed", 0) == 1 + ): # n'a pas ete pas detruit + raise AsException( + "Le concept '%s' est reentrant dans la macro-commande %s. " + "Il devrait donc l'etre dans %s (produit sous le nom '%s')." + % (sd.nom, self.nom, etape.nom, nomsd) + ) # On donne au concept le type produit par la sous commande. # Le principe est le suivant : apres avoir verifie que le type deduit par la sous commande # est bien coherent avec celui initialement affecte par la macro (voir ci dessus) @@ -482,7 +521,7 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, etape.sdnom = sd.nom # pour l'ajouter au contexte de la macro self.g_context[sd.nom] = sd - elif etape.definition.reentrant != 'n' and etape.reuse != None: + elif etape.definition.reentrant != "n" and etape.reuse != None: # On est dans le cas d'une commande avec reutilisation d'un concept existant # getSdProd fait le necessaire : verifications, associations, etc. mais ne cree # pas un nouveau concept. Il retourne le concept reutilise @@ -495,7 +534,7 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, # la variable a gauche du signe = est le meme que celui du concept reutilise. # Lorsqu'une telle commande apparait dans une macro, on supprime # cette verification. - if (etape.sdnom == '' or etape.sdnom[0] == '_'): + if etape.sdnom == "" or etape.sdnom[0] == "_": etape.sdnom = sd.nom else: # On est dans le cas de la creation d'un nouveau concept @@ -504,39 +543,39 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, self.nommerSDProd(sd, nomsd) return sd - def nommerSDProd(self, sd, sdnom, restrict='non'): + def nommerSDProd(self, sd, sdnom, restrict="non"): """ - Cette methode est appelee par les etapes internes de la macro. - La macro appelle le JDC pour valider le nommage. - On considère que l'espace de nom est unique et gere par le JDC. - Si le nom est deja utilise, l'appel lève une exception. - Si restrict=='non', on insère le concept dans le contexte du parent de la macro. - Si restrict=='oui', on insère le concept uniquement dans le contexte de la macro. + Cette methode est appelee par les etapes internes de la macro. + La macro appelle le JDC pour valider le nommage. + On considère que l'espace de nom est unique et gere par le JDC. + Si le nom est deja utilise, l'appel lève une exception. + Si restrict=='non', on insère le concept dans le contexte du parent de la macro. + Si restrict=='oui', on insère le concept uniquement dans le contexte de la macro. """ # Normalement, lorsqu'on appelle cette methode, on ne veut nommer que des concepts nouvellement crees. # Le filtrage sur les concepts a creer ou a ne pas creer est fait dans la methode # createSdprod. La seule chose a verifier apres conversion eventuelle du nom # est de verifier que le nom n'est pas deja attribue. Ceci est fait en delegant # au JDC par l'intermediaire du parent. - if sdnom in self.Outputs : - # Il s'agit d'un concept de sortie de la macro produit par une - # sous commande + if sdnom in self.Outputs: + # Il s'agit d'un concept de sortie de la macro produit par une + # sous commande sdnom = self.Outputs[sdnom].nom elif len(sdnom) > 0: - if sdnom[0] in ('_', '.') and sdnom[1:].isdigit(): + if sdnom[0] in ("_", ".") and sdnom[1:].isdigit(): # il est deja de la forme _9000012 ou .9000017 pass - elif sdnom[0] == '_': + elif sdnom[0] == "_": # Si le nom du concept commence par le caractère '_', on lui attribue # un identificateur JEVEUX construit par gcncon. # nom commençant par __ : il s'agit de concepts qui seront detruits # nom commençant par _ : il s'agit de concepts intermediaires # qui seront gardes - if len(sdnom) > 1 and sdnom[1] == '_': - sdnom = self.gcncon('.') + if len(sdnom) > 1 and sdnom[1] == "_": + sdnom = self.gcncon(".") else: - sdnom = self.gcncon('_') - elif self.nom in ('INCLUDE', 'MACR_RECAL'): + sdnom = self.gcncon("_") + elif self.nom in ("INCLUDE", "MACR_RECAL"): # dans le cas d'INCLUDE, on passe # MACR_RECAL fonctionne comme INCLUDE pass @@ -545,24 +584,25 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, # XXX a voir, creation de CO() dans CALC_ESSAI (sdls139a) if not sd.isTypCO(): raise AsException( - "Resultat non declare par la macro %s : %s" % (self.nom, sdnom)) + "Resultat non declare par la macro %s : %s" % (self.nom, sdnom) + ) self.last = sdnom - if restrict == 'non': + if restrict == "non": # On demande le nommage au parent mais sans ajout du concept dans le contexte du parent # car on va l'ajouter dans le contexte de la macro - self.parent.nommerSDProd(sd, sdnom, restrict='oui') + self.parent.nommerSDProd(sd, sdnom, restrict="oui") # On ajoute dans le contexte de la macro les concepts nommes # Ceci est indispensable pour les CO (macro) dans un INCLUDE self.g_context[sdnom] = sd else: # La demande de nommage vient probablement d'une macro qui a mis # le concept dans son contexte. On ne traite plus que le nommage (restrict="oui") - self.parent.nommerSDProd(sd, sdnom, restrict='oui') + self.parent.nommerSDProd(sd, sdnom, restrict="oui") def deleteConceptAfterEtape(self, etape, sd): """ - Met a jour les etapes de la MACRO qui sont après etape suite a - la disparition du concept sd + Met a jour les etapes de la MACRO qui sont après etape suite a + la disparition du concept sd """ # Cette methode est definie dans le noyau mais ne sert que pendant la phase de creation # des etapes et des concepts. Il n'y a aucun traitement particulier a realiser @@ -586,16 +626,16 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitMACRO_ETAPE(self) def updateContext(self, d): """ - Met a jour le contexte contenu dans le dictionnaire d - Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte - Une fonction enregistree dans op_init peut egalement modifier le contexte + Met a jour le contexte contenu dans le dictionnaire d + Une MACRO_ETAPE peut ajouter plusieurs concepts dans le contexte + Une fonction enregistree dans op_init peut egalement modifier le contexte """ if type(self.definition.op_init) == types.FunctionType: self.definition.op_init(*(self, d)) @@ -607,9 +647,12 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def makeInclude(self, unite=None, fname=None): """Inclut un fichier dont l'unite logique est `unite` ou de nom `fname`""" if unite is not None: - warn("'unite' is deprecated, please use 'fname' instead", - DeprecationWarning, stacklevel=2) - fname = 'fort.%s' % unite + warn( + "'unite' is deprecated, please use 'fname' instead", + DeprecationWarning, + stacklevel=2, + ) + fname = "fort.%s" % unite if not fname: return f, text = self.getFile(fic_origine=self.parent.nom, fname=fname) @@ -620,19 +663,19 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def makePoursuite(self): """Inclut un fichier poursuite""" - raise NotImplementedError('this method must be derivated (in Eficas)') + raise NotImplementedError("this method must be derivated (in Eficas)") def makeContexte(self, f, text): """ - Interprete le texte fourni (text) issu du fichier f - dans le contexte du parent. - Cette methode est utile pour le fonctionnement des - INCLUDE + Interprete le texte fourni (text) issu du fichier f + dans le contexte du parent. + Cette methode est utile pour le fonctionnement des + INCLUDE """ # on execute le texte fourni dans le contexte forme par # le contexte de l etape pere (global au sens Python) # et le contexte de l etape (local au sens Python) - code = compile(text, f, 'exec') + code = compile(text, f, "exec") d = self.g_context = self.macro_const_context globs = self.getGlobalContexte() d.update(globs) @@ -642,9 +685,9 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def getGlobalContexte(self): """ - Cette methode retourne le contexte global fourni - par le parent(self) a une etape fille (l'appelant) pour - realiser des evaluations de texte Python (INCLUDE,...) + Cette methode retourne le contexte global fourni + par le parent(self) a une etape fille (l'appelant) pour + realiser des evaluations de texte Python (INCLUDE,...) """ # Le contexte global est forme par concatenation du contexte # du parent de self et de celui de l'etape elle meme (self) @@ -654,14 +697,19 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, # ce qui y est deja. d = self.parent.getGlobalContexte() d.update(self.g_context) - d.update([(k, v) for k, v in list(self.parent.getContexteAvant(self).items()) - if d.get(k) is None]) + d.update( + [ + (k, v) + for k, v in list(self.parent.getContexteAvant(self).items()) + if d.get(k) is None + ] + ) return d def getContexteCourant(self, etape_fille_du_jdc=None): """ - Retourne le contexte tel qu'il est au moment de l'execution de - l'etape courante. + Retourne le contexte tel qu'il est au moment de l'execution de + l'etape courante. """ ctx = {} # update car par ricochet on modifierait jdc.currentContext @@ -672,8 +720,8 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def getConcept(self, nomsd): """ - Methode pour recuperer un concept a partir de son nom - dans le contexte du jdc connu avant l'execution de la macro courante. + Methode pour recuperer un concept a partir de son nom + dans le contexte du jdc connu avant l'execution de la macro courante. """ # chercher dans self.getContexteAvant, puis si non trouve # self.parent.getConcept est peut-etre plus performant @@ -684,25 +732,25 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def getConceptByType(self, nomsd, typesd, etape=None): """ - Methode pour recuperer un concept a partir de son nom et de son type. - Il aura comme père 'etape' (ou la macro courante si etape est absente). + Methode pour recuperer un concept a partir de son nom et de son type. + Il aura comme père 'etape' (ou la macro courante si etape est absente). """ return self.parent.getConceptByType(nomsd, typesd, etape=etape or self) def copy(self): - """ Methode qui retourne une copie de self non enregistree auprès du JDC - et sans sd - On surcharge la methode de ETAPE pour exprimer que les concepts crees - par la MACRO d'origine ne sont pas crees par la copie mais eventuellement - seulement utilises + """Methode qui retourne une copie de self non enregistree auprès du JDC + et sans sd + On surcharge la methode de ETAPE pour exprimer que les concepts crees + par la MACRO d'origine ne sont pas crees par la copie mais eventuellement + seulement utilises """ etape = N_ETAPE.ETAPE.copy(self) etape.sdprods = [] return etape def copyIntern(self, etape): - """ Cette methode effectue la recopie des etapes internes d'une macro - passee en argument (etape) + """Cette methode effectue la recopie des etapes internes d'une macro + passee en argument (etape) """ self.etapes = [] self.index_etapes = {} @@ -724,7 +772,7 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def resetJdc(self, new_jdc): """ - Reinitialise l'etape avec un nouveau jdc parent new_jdc + Reinitialise l'etape avec un nouveau jdc parent new_jdc """ if self.sd and self.reuse == None: self.parent.nommerSDProd(self.sd, self.sd.nom) @@ -733,7 +781,7 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def reparent(self, parent): """ - Cette methode sert a reinitialiser la parente de l'objet + Cette methode sert a reinitialiser la parente de l'objet """ N_ETAPE.ETAPE.reparent(self, parent) # on ne change pas la parente des concepts. On s'assure uniquement que @@ -745,8 +793,8 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, def updateConstContext(self, d): """ - Met a jour le contexte des constantes pour l'evaluation de - formules dans la macro. + Met a jour le contexte des constantes pour l'evaluation de + formules dans la macro. """ # Dans le jdc, const_context est mis a jour par execCompile # Dans la macro, on n'a pas le code a compiler pour recupèrer les @@ -760,5 +808,5 @@ Le type demande (%s) et le type du concept (%s) devraient etre derives""" % (t, sauf pour INCLUDE. """ if CONTEXT.debug: - print((' `- MACRO sdAccessible :', self.nom)) + print((" `- MACRO sdAccessible :", self.nom)) return self.parent.sdAccessible() or not self.isInclude() diff --git a/Noyau/N_MCBLOC.py b/Noyau/N_MCBLOC.py index 212d7e26..1bf9b11f 100644 --- a/Noyau/N_MCBLOC.py +++ b/Noyau/N_MCBLOC.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -24,7 +24,7 @@ de type ENTITE """ -from __future__ import absolute_import + import types from . import N_MCCOMPO @@ -33,38 +33,33 @@ from . import N_MCCOMPO class MCBLOC(N_MCCOMPO.MCCOMPO): """ - Classe support d'un bloc de mots-clés. + Classe support d'un bloc de mots-clés. """ nature = "MCBLOC" - def __init__(self, val, definition, nom, parent,dicoPyxbDeConstruction=None): + def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction=None): """ - Attributs : - - - val : valeur du bloc (dictionnaire dont les clés sont des noms de mots-clés et les valeurs - les valeurs des mots-clés) - - - definition : objet de définition de type BLOC associé au bloc (porte les attributs de définition) - - - nom : nom du bloc. Ce nom lui est donné par celui qui crée le bloc de mot-clé - - - parent : le créateur du bloc. Ce peut etre un mot-clé facteur ou un autre objet composite de type - OBJECT. Si parent vaut None, le bloc ne possède pas de contexte englobant. - - - mcListe : liste des sous-objets du bloc construite par appel à la méthode buildMc - + Attributs : + + - val : valeur du bloc (dictionnaire dont les clés sont des noms de mots-clés et les valeurs + les valeurs des mots-clés) + - definition : objet de définition de type BLOC associé au bloc (porte les attributs de définition) + - nom : nom du bloc. Ce nom lui est donné par celui qui crée le bloc de mot-clé + - parent : le créateur du bloc. Ce peut etre un mot-clé facteur ou un autre objet composite de type + OBJECT. Si parent vaut None, le bloc ne possède pas de contexte englobant. + - mcListe : liste des sous-objets du bloc construite par appel à la méthode buildMc """ - #print ('MCBLOC' , val, definition, nom, parent) + # print ('MCBLOC' , val, definition, nom, parent) self.definition = definition self.nom = nom self.val = val self.parent = parent self.valeur = val - self.objPyxbDeConstruction=None - self.dicoPyxbDeConstruction=dicoPyxbDeConstruction - self.estIdentifiePar=None + self.objPyxbDeConstruction = None + self.dicoPyxbDeConstruction = dicoPyxbDeConstruction + self.estIdentifiePar = None if parent: self.jdc = self.parent.jdc self.niveau = self.parent.niveau @@ -78,14 +73,14 @@ class MCBLOC(N_MCCOMPO.MCCOMPO): def getValeur(self): """ - Retourne la "valeur" de l'objet bloc. Il s'agit d'un dictionnaire dont - les clés seront les noms des objets de self.mcListe et les valeurs - les valeurs des objets de self.mcListe obtenues par application de - la méthode getValeur. + Retourne la "valeur" de l'objet bloc. Il s'agit d'un dictionnaire dont + les clés seront les noms des objets de self.mcListe et les valeurs + les valeurs des objets de self.mcListe obtenues par application de + la méthode getValeur. - Dans le cas particulier d'un objet bloc les éléments du dictionnaire - obtenu par appel de la méthode getValeur sont intégrés au niveau - supérieur. + Dans le cas particulier d'un objet bloc les éléments du dictionnaire + obtenu par appel de la méthode getValeur sont intégrés au niveau + supérieur. """ dico = {} @@ -106,11 +101,11 @@ class MCBLOC(N_MCCOMPO.MCCOMPO): # une condition. for k, v in list(self.definition.entites.items()): if not k in dico: - if v.label == 'SIMP': + if v.label == "SIMP": # Mot clé simple dico[k] = v.defaut - elif v.label == 'FACT': - if v.statut in ('c', 'd'): + elif v.label == "FACT": + if v.statut in ("c", "d"): # Mot clé facteur avec défaut ou caché provisoire dico[k] = v(val=None, nom=k, parent=self) # On demande la suppression des pointeurs arrieres @@ -123,16 +118,16 @@ class MCBLOC(N_MCCOMPO.MCCOMPO): def isBLOC(self): """ - Indique si l'objet est un BLOC + Indique si l'objet est un BLOC """ return 1 def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitMCBLOC(self) def makeobjet(self): - return self.definition(val=None, nom=self.nom, parent=self.parent) + return self.definition(val=None, nom=self.nom, parent=self.parent) diff --git a/Noyau/N_MCCOMPO.py b/Noyau/N_MCCOMPO.py index 934ba636..06d69fd5 100644 --- a/Noyau/N_MCCOMPO.py +++ b/Noyau/N_MCCOMPO.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,28 +23,25 @@ des OBJECT composites """ -from __future__ import absolute_import -from __future__ import print_function from copy import copy from . import N_OBJECT class MCCOMPO(N_OBJECT.OBJECT): - """ - Classe support d'un OBJECT composite + Classe support d'un OBJECT composite """ def buildMc(self): """ - Construit la liste des sous-entites du MCCOMPO - à partir du dictionnaire des arguments (valeur) + Construit la liste des sous-entites du MCCOMPO + à partir du dictionnaire des arguments (valeur) """ - #import traceback - #traceback.print_stack() - #print(("MCCOMPO.buildMc _____________________________________", self.nom)) + # import traceback + # traceback.print_stack() + # print(("MCCOMPO.buildMc _____________________________________", self.nom)) if CONTEXT.debug: print(("MCCOMPO.buildMc ", self.nom)) # Dans la phase de reconstruction args peut contenir des mots-clés @@ -53,11 +50,11 @@ class MCCOMPO(N_OBJECT.OBJECT): # mais qui sont malgré tout des descendants de l'objet courant # (petits-fils, ...) args = self.valeur - #print ('MCCOMPO___________________', self.valeur) - if args == None: args = {} + # print ('MCCOMPO___________________', self.valeur) + if args == None: + args = {} mcListe = [] - # On recopie le dictionnaire des arguments pour protéger l'original des # delete (del args[k]) args = args.copy() @@ -68,33 +65,39 @@ class MCCOMPO(N_OBJECT.OBJECT): # 2- les entités non présentes dans les arguments, présentes dans la définition avec un défaut # Phase 1.1 : on traite d'abord les SIMP pour enregistrer les mots cles # globaux - if not hasattr(self, 'dicoPyxbDeConstruction') : self.dicoPyxbDeConstruction = {} + if not hasattr(self, "dicoPyxbDeConstruction"): + self.dicoPyxbDeConstruction = {} for k, v in list(self.definition.entites.items()): - if v.label != 'SIMP': + if v.label != "SIMP": continue - if k in args or v.statut == 'o': + if k in args or v.statut in ("o", "d"): # # Creation par appel de la methode __call__ de la definition de la sous entite k de self # si une valeur existe dans args ou est obligatoire (generique si toutes les # entites ont l attribut statut ) # - if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction : - objPyxbDeConstruction=self.dicoPyxbDeConstruction[k] + if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction: + objPyxbDeConstruction = self.dicoPyxbDeConstruction[k] del self.dicoPyxbDeConstruction[k] - else : - objPyxbDeConstruction=None - #print (args.get(k, None)) - objet = v(val=args.get(k, None), nom=k, parent=self,objPyxbDeConstruction=objPyxbDeConstruction) + else: + objPyxbDeConstruction = None + # print (args.get(k, None)) + objet = v( + val=args.get(k, None), + nom=k, + parent=self, + objPyxbDeConstruction=objPyxbDeConstruction, + ) mcListe.append(objet) # Si l'objet a une position globale on l'ajoute aux listes # correspondantes - if hasattr(objet.definition, 'position'): - if objet.definition.position == 'global': + if hasattr(objet.definition, "position"): + if objet.definition.position == "global": self.append_mc_global(objet) - if objet.definition.position == 'reCalculeEtape': - #print ('-------------------------- rencontre reCalculeEtape: ', objet.nom) + if objet.definition.position == "reCalculeEtape": + # print ('-------------------------- rencontre reCalculeEtape: ', objet.nom) self.append_mc_global_avecRecalcule(objet) - elif objet.definition.position == 'global_jdc': + elif objet.definition.position == "global_jdc": self.append_mc_global_jdc(objet) if k in args: del args[k] @@ -102,20 +105,26 @@ class MCCOMPO(N_OBJECT.OBJECT): # Phase 1.2 : on traite les autres entites que SIMP # FACT ou listeDeFAct en fait car un BLOC ne peut etre present dans les args for k, v in list(self.definition.entites.items()): - if v.label == 'SIMP': continue - if k in args or v.statut == 'o': - #print ('construit', k) + if v.label == "SIMP": + continue + if k in args or v.statut == "o": + # print ('construit', k) # # Creation par appel de la methode __call__ de la definition de la sous entite k de self # si une valeur existe dans args ou est obligatoire (generique si toutes les # entites ont l attribut statut ) # - if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction : - dicoPyxbDeConstruction=self.dicoPyxbDeConstruction[k] + if self.dicoPyxbDeConstruction and k in self.dicoPyxbDeConstruction: + dicoPyxbDeConstruction = self.dicoPyxbDeConstruction[k] del self.dicoPyxbDeConstruction[k] - else : - dicoPyxbDeConstruction=None - objet = v(val=args.get(k, None), nom=k, parent=self,dicoPyxbDeConstruction=dicoPyxbDeConstruction) + else: + dicoPyxbDeConstruction = None + objet = v( + val=args.get(k, None), + nom=k, + parent=self, + dicoPyxbDeConstruction=dicoPyxbDeConstruction, + ) mcListe.append(objet) if k in args: del args[k] @@ -126,23 +135,29 @@ class MCCOMPO(N_OBJECT.OBJECT): # args ne contient plus que des mots-clés qui n'ont pas été attribués car ils sont # à attribuer à des blocs du niveau inférieur ou bien sont des mots-clés erronés for k, v in list(self.definition.entites.items()): - if v.label != 'BLOC': continue - #PNPN on recalcule dico_valeurs dans le for + if v.label != "BLOC": + continue + # PNPN on recalcule dico_valeurs dans le for # pour les globaux imbriques (exple Telemac Advection) # avant le calcul etait avant le for dico_valeurs = self.creeDictCondition(mcListe, condition=1) globs = self.jdc and self.jdc.condition_context or {} if v.verifPresence(dico_valeurs, globs): - #print ('appel construit bloc', k, 'avec', args, 'a partir de', self.nom ) - # Si le bloc existe : - # 1- on le construit - # 2- on l'ajoute à mcListe - # 3- on récupère les arguments restant - # 4- on reconstruit le dictionnaire équivalent à mcListe - bloc = v(nom=k, val=args, parent=self,dicoPyxbDeConstruction=self.dicoPyxbDeConstruction) + # print ('appel construit bloc', k, 'avec', args, 'a partir de', self.nom ) + # Si le bloc existe : + # 1- on le construit + # 2- on l'ajoute à mcListe + # 3- on récupère les arguments restant + # 4- on reconstruit le dictionnaire équivalent à mcListe + bloc = v( + nom=k, + val=args, + parent=self, + dicoPyxbDeConstruction=self.dicoPyxbDeConstruction, + ) mcListe.append(bloc) args = bloc.reste_val - #print ('les args deviennent ', args) + # print ('les args deviennent ', args) # On ne recalcule pas le contexte car on ne tient pas compte des blocs # pour évaluer les conditions de présence des blocs # dico_valeurs = self.creeDictValeurs(mcListe) @@ -153,103 +168,114 @@ class MCCOMPO(N_OBJECT.OBJECT): # et le reste_val n est pas remis a jour # est-ce un pb ? a priori non self.reste_val = args - #print ('self.reste_val de ', self.nom, self.reste_val) + # print ('self.reste_val de ', self.nom, self.reste_val) # On ordonne la liste ainsi créée suivant l'ordre du catalogue # (utile seulement pour IHM graphique) mcListe = self.ordonneListe(mcListe) # on retourne la liste ainsi construite - if self.jdc : self.cata=self.jdc.cata - else : self.cata = None + if self.jdc: + self.cata = self.jdc.cata + else: + self.cata = None self.buildObjPyxb(mcListe) - #print ('______________________________________ fin ', self.nom) + # print ('______________________________________ fin ', self.nom) return mcListe def buildMcApresGlobalEnSuppression(self): - blocsDejaLa=[] - for mc in self.mcListe : - if mc.nature == 'MCBLOC' : blocsDejaLa.append(mc) - for mc in blocsDejaLa : + blocsDejaLa = [] + for mc in self.mcListe: + if mc.nature == "MCBLOC": + blocsDejaLa.append(mc) + for mc in blocsDejaLa: dico_valeurs = self.creeDictCondition(self.mcListe, condition=1) globs = self.jdc and self.jdc.condition_context or {} defBloc = mc.definition if not (defBloc.verifPresence(dico_valeurs, globs)): self.suppEntite(mc) - def reConstruitResteVal(self): - # normal que apres buildMcApresGlobalEnCreation les reste_val ne soient pas corrects - for mc in self.mcListe : - if mc.nom in self.reste_val : + # normal que apres buildMcApresGlobalEnCreation les reste_val ne soient pas corrects + for mc in self.mcListe: + if mc.nom in self.reste_val: del self.reste_val[mc.nom] - if mc.nature == 'MCBLOC' : - ancetre=mc.parent - for mcFDuMc in mc.mcListe : - while ancetre.nature == 'MCBLOC' : - ancetre=ancetre.parent - if mcFDuMc.nom in ancetre.reste_val : del ancetre.reste_val[mcFDuMc.nom] - if mc.nature == 'MCSIMP' : continue - if mc.nature == 'MCList' : - for mcObj in mc.data : + if mc.nature == "MCBLOC": + ancetre = mc.parent + for mcFDuMc in mc.mcListe: + while ancetre.nature == "MCBLOC": + ancetre = ancetre.parent + if mcFDuMc.nom in ancetre.reste_val: + del ancetre.reste_val[mcFDuMc.nom] + if mc.nature == "MCSIMP": + continue + if mc.nature == "MCList": + for mcObj in mc.data: mcObj.reConstruitResteVal() - else : + else: mc.reConstruitResteVal() - def buildMcApresGlobalEnCreation(self): nouveau_args = self.reste_val - blocsDejaLa=[] - for mc in self.mcListe : - if mc.nature == 'MCBLOC' : blocsDejaLa.append(mc.nom) + blocsDejaLa = [] + for mc in self.mcListe: + if mc.nature == "MCBLOC": + blocsDejaLa.append(mc.nom) for k, v in list(self.definition.entites.items()): - if v.label != 'BLOC': continue - if k in blocsDejaLa : continue + if v.label != "BLOC": + continue + if k in blocsDejaLa: + continue dico_valeurs = self.creeDictCondition(self.mcListe, condition=1) globs = self.jdc and self.jdc.condition_context or {} if v.verifPresence(dico_valeurs, globs): - bloc = v(nom=k, val=nouveau_args, parent=self,dicoPyxbDeConstruction=self.dicoPyxbDeConstruction) - if bloc : + bloc = v( + nom=k, + val=nouveau_args, + parent=self, + dicoPyxbDeConstruction=self.dicoPyxbDeConstruction, + ) + if bloc: self.mcListe.append(bloc) bloc.addObjPyxb(self.chercheIndiceDsLeContenu(bloc)) nouveau_args = self.reste_val self.reste_val = bloc.reste_val - def ordonneListe(self, mcListe): """ - Ordonne la liste suivant l'ordre du catalogue. - Seulement pour IHM graphique + Ordonne la liste suivant l'ordre du catalogue. + Seulement pour IHM graphique """ if self.jdc and self.jdc.cata_ordonne_dico != None: liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute( - self.getGenealogie(), self.jdc.cata_ordonne_dico) + self.getGenealogie(), self.jdc.cata_ordonne_dico + ) return self.ordonneListeMc(mcListe, liste_noms_mc_ordonnee) else: return mcListe def creeDictValeurs(self, liste=[], condition=0): """ - Cette méthode crée un contexte (sous la forme d'un dictionnaire) - à partir des valeurs des mots clés contenus dans l'argument liste. - L'opération consiste à parcourir la liste (d'OBJECT) et à la - transformer en un dictionnaire dont les clés sont les noms des - mots clés et les valeurs dépendent du type d'OBJECT. - Ce dictionnaire servira de liste d'arguments d'appel pour les - fonctions sd_prod de commandes et ops de macros ou de contexte - d'évaluation des conditions de présence de BLOC. + Cette méthode crée un contexte (sous la forme d'un dictionnaire) + à partir des valeurs des mots clés contenus dans l'argument liste. + L'opération consiste à parcourir la liste (d'OBJECT) et à la + transformer en un dictionnaire dont les clés sont les noms des + mots clés et les valeurs dépendent du type d'OBJECT. + Ce dictionnaire servira de liste d'arguments d'appel pour les + fonctions sd_prod de commandes et ops de macros ou de contexte + d'évaluation des conditions de présence de BLOC. - Si l'argument condition de la méthode vaut 1, on ne - remonte pas les valeurs des mots clés contenus dans des blocs - pour eviter les bouclages. + Si l'argument condition de la méthode vaut 1, on ne + remonte pas les valeurs des mots clés contenus dans des blocs + pour eviter les bouclages. - Cette méthode réalise les opérations suivantes en plus de transformer - la liste en dictionnaire : + Cette méthode réalise les opérations suivantes en plus de transformer + la liste en dictionnaire : - - ajouter tous les mots-clés non présents avec la valeur None - - ajouter tous les mots-clés globaux (attribut position = 'global' - et 'global_jdc') + - ajouter tous les mots-clés non présents avec la valeur None + - ajouter tous les mots-clés globaux (attribut position = 'global' + et 'global_jdc') - L'argument liste est, en général, une mcListe en cours de - construction, contenant les mots-clés locaux et les blocs déjà créés. + L'argument liste est, en général, une mcListe en cours de + construction, contenant les mots-clés locaux et les blocs déjà créés. """ dico = {} @@ -276,12 +302,12 @@ class MCCOMPO(N_OBJECT.OBJECT): # XXX remplacer le not has_key par un dico différent et faire dico2.update(dico) # ce n'est qu'un pb de perf for k, v in list(self.definition.entites.items()): - if not k in dico : - if v.label == 'SIMP': - # Mot clé simple + if not k in dico: + if v.label == "SIMP": + # Mot clé simple dico[k] = v.defaut - elif v.label == 'FACT': - if v.statut in ('c', 'd'): + elif v.label == "FACT": + if v.statut in ("c", "d"): # Mot clé facteur avec défaut ou caché provisoire dico[k] = v(val=None, nom=k, parent=self) # On demande la suppression des pointeurs arrieres @@ -308,22 +334,22 @@ class MCCOMPO(N_OBJECT.OBJECT): def creeDictCondition(self, liste=[], condition=0): """ - Methode pour construire un contexte qui servira dans l'évaluation - des conditions de présence de blocs. Si une commande a un concept - produit réutilisé, on ajoute la clé 'reuse' + Methode pour construire un contexte qui servira dans l'évaluation + des conditions de présence de blocs. Si une commande a un concept + produit réutilisé, on ajoute la clé 'reuse' """ dico = self.creeDictValeurs(liste, condition=1) # On ajoute la cle "reuse" pour les MCCOMPO qui ont un attribut reuse. A destination # uniquement des commandes. Ne devrait pas etre dans cette classe mais # dans une classe dérivée - if not 'reuse' in dico and hasattr(self, 'reuse'): - dico['reuse'] = self.reuse + if not "reuse" in dico and hasattr(self, "reuse"): + dico["reuse"] = self.reuse return dico def rechercheMcGlobaux(self): """ - Retourne la liste des mots-clés globaux de l'étape à laquelle appartient self - et des mots-clés globaux du jdc + Retourne la liste des mots-clés globaux de l'étape à laquelle appartient self + et des mots-clés globaux du jdc """ etape = self.getEtape() if etape: @@ -339,30 +365,35 @@ class MCCOMPO(N_OBJECT.OBJECT): def rechercheMcGlobauxFacultatifs(self): """ - Cette méthode interroge la définition de self et retourne la liste des mots-clés fils - directs de self de type 'global'. - position='global' n'est donc possible (et n'a de sens) qu'au plus haut niveau. - du coup ici on ajoute les globaux de l etape qui sont dans mc_recalculeEtape + Cette méthode interroge la définition de self et retourne la liste des mots-clés fils + directs de self de type 'global'. + position='global' n'est donc possible (et n'a de sens) qu'au plus haut niveau. + du coup ici on ajoute les globaux de l etape qui sont dans mc_recalculeEtape """ - #print ('je passe par ici', self.nom) + # print ('je passe par ici', self.nom) dico = {} etape = self.getEtape() if not etape: return {} for k, v in list(etape.definition.entites.items()): - if v.label != 'SIMP': continue - if v.position == 'local': continue - if v.position == 'inGetAttribut': continue - if v.position == 'reCalculeEtape': continue - if v.statut == 'o': continue + if v.label != "SIMP": + continue + if v.position == "local": + continue + if v.position == "inGetAttribut": + continue + if v.position == "reCalculeEtape": + continue + if v.statut == "o": + continue obj = v(val=None, nom=k, parent=etape) dico[k] = obj.getValeur() return dico def supprime(self): """ - Méthode qui supprime toutes les références arrières afin que l'objet puisse - etre correctement détruit par le garbage collector + Méthode qui supprime toutes les références arrières afin que l'objet puisse + etre correctement détruit par le garbage collector """ N_OBJECT.OBJECT.supprime(self) for child in self.mcListe: @@ -370,15 +401,15 @@ class MCCOMPO(N_OBJECT.OBJECT): def __getitem__(self, key): """ - Cette méthode retourne la valeur d'un sous mot-clé (key) + Cette méthode retourne la valeur d'un sous mot-clé (key) """ return self.getMocle(key) def getMocle(self, key): """ - Retourne la valeur du sous mot-clé key - Ce sous mot-clé peut exister, avoir une valeur par defaut ou etre - dans un BLOC fils de self + Retourne la valeur du sous mot-clé key + Ce sous mot-clé peut exister, avoir une valeur par defaut ou etre + dans un BLOC fils de self """ # on cherche dans les mots cles presents, le mot cle de nom key # s'il est là on retourne sa valeur (méthode getVal) @@ -390,14 +421,14 @@ class MCCOMPO(N_OBJECT.OBJECT): # a ce niveau try: d = self.definition.entites[key] - if d.label == 'SIMP': + if d.label == "SIMP": return d.defaut - elif d.label == 'FACT': + elif d.label == "FACT": # il faut construire les objets necessaires pour # evaluer les conditions des blocs eventuels (a faire) - if d.statut == 'o': + if d.statut == "o": return None - if d.statut != 'c' and d.statut != 'd': + if d.statut != "c" and d.statut != "d": return None else: return d(val=None, nom=key, parent=self) @@ -419,58 +450,63 @@ class MCCOMPO(N_OBJECT.OBJECT): # On leve une exception raise IndexError("Le mot cle %s n existe pas dans %s" % (key, self)) - def getChild(self, name, restreint='non'): + def getChild(self, name, restreint="non"): """ - Retourne le fils de self de nom name ou None s'il n'existe pas - Si restreint vaut oui : ne regarde que dans la mcListe - Si restreint vaut non : regarde aussi dans les entites possibles - avec defaut (Ce dernier cas n'est utilisé que dans le catalogue) + Retourne le fils de self de nom name ou None s'il n'existe pas + Si restreint vaut oui : ne regarde que dans la mcListe + Si restreint vaut non : regarde aussi dans les entites possibles + avec defaut (Ce dernier cas n'est utilisé que dans le catalogue) """ for v in self.mcListe: if v.nom == name: return v - if restreint == 'non': + if restreint == "non": try: entite = self.definition.entites[name] - if entite.label == 'SIMP' or (entite.label == 'FACT' and entite.statut in ('c', 'd')): + if entite.label == "SIMP" or ( + entite.label == "FACT" and entite.statut in ("c", "d") + ): return entite(None, name, None) except: pass return None - def getChildOrChildInBloc(self, name, restreint='non'): - # cherche dans les fils et les fils des blocs - # tout est base sur le fait que deux freres ne peuvent pas avoir le meme nom - # dans des blocs non exclusifs, sinon le .comm n est pas du python valide + def getChildOrChildInBloc(self, name, restreint="non"): + # cherche dans les fils et les fils des blocs + # tout est base sur le fait que deux freres ne peuvent pas avoir le meme nom + # dans des blocs non exclusifs, sinon le .comm n est pas du python valide for v in self.mcListe: - if v.nom == name: return v - if restreint == 'non': + if v.nom == name: + return v + if restreint == "non": try: entite = self.definition.entites[name] - if entite.label == 'SIMP' or (entite.label == 'FACT' and entite.statut in ('c', 'd')): + if entite.label == "SIMP" or ( + entite.label == "FACT" and entite.statut in ("c", "d") + ): return entite(None, name, None) except: pass for v in self.mcListe: - if v.nature == 'MCBLOC' : - petitFils=v.getChildOrChildInBloc(name, restreint) - if petitFils !=None : return petitFils + if v.nature == "MCBLOC": + petitFils = v.getChildOrChildInBloc(name, restreint) + if petitFils != None: + return petitFils return None def append_mc_global_avecRecalcule(self, mc): etape = self.getEtape() if etape: nom = mc.nom - if not(nom in etape.mc_globaux) : + if not (nom in etape.mc_globaux): etape.doitEtreRecalculee = True etape.mc_globaux[nom] = mc - #print ('ajout de nom', mc.nom, 'ds les mc_globaux de', etape.nom) - + # print ('ajout de nom', mc.nom, 'ds les mc_globaux de', etape.nom) def append_mc_global(self, mc): """ - Ajoute le mot-clé mc à la liste des mots-clés globaux de l'étape + Ajoute le mot-clé mc à la liste des mots-clés globaux de l'étape """ etape = self.getEtape() if etape: @@ -479,13 +515,13 @@ class MCCOMPO(N_OBJECT.OBJECT): def append_mc_global_jdc(self, mc): """ - Ajoute le mot-clé mc à la liste des mots-clés globaux du jdc + Ajoute le mot-clé mc à la liste des mots-clés globaux du jdc """ nom = mc.nom self.jdc.mc_globaux[nom] = mc def copy(self): - """ Retourne une copie de self """ + """Retourne une copie de self""" objet = self.makeobjet() # attention !!! avec makeobjet, objet a le meme parent que self # ce qui n'est pas du tout bon dans le cas d'une copie !!!!!!! @@ -503,7 +539,7 @@ class MCCOMPO(N_OBJECT.OBJECT): def reparent(self, parent): """ - Cette methode sert a reinitialiser la parente de l'objet + Cette methode sert a reinitialiser la parente de l'objet """ self.parent = parent self.jdc = parent.getJdcRoot() @@ -513,29 +549,29 @@ class MCCOMPO(N_OBJECT.OBJECT): def getSd_utilisees(self): """ - Retourne la liste des concepts qui sont utilisés à l'intérieur de self - ( comme valorisation d'un MCS) + Retourne la liste des concepts qui sont utilisés à l'intérieur de self + ( comme valorisation d'un MCS) """ l = [] for child in self.mcListe: l.extend(child.getSd_utilisees()) return l - def getSd_mcs_utilisees(self): + def getSdMCSUtilisees(self): """ - Retourne la ou les SD utilisée par self sous forme d'un dictionnaire : - - Si aucune sd n'est utilisée, le dictionnaire est vide. - - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on - trouve des sd ; la valeur est la liste des sd attenante. - Exemple :: + Retourne la ou les SD utilisée par self sous forme d'un dictionnaire : + - Si aucune sd n'est utilisée, le dictionnaire est vide. + - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on + trouve des sd ; la valeur est la liste des sd attenante. + Exemple :: - { 'VALE_F': [ , - ], - 'MODELE': [] } + { 'VALE_F': [ , + ], + 'MODELE': [] } """ dico = {} for child in self.mcListe: - daux = child.getSd_mcs_utilisees() + daux = child.getSdMCSUtilisees() for cle in daux: dico[cle] = dico.get(cle, []) dico[cle].extend(daux[cle]) @@ -543,10 +579,10 @@ class MCCOMPO(N_OBJECT.OBJECT): def getMcsWithCo(self, co): """ - Cette methode retourne l'objet MCSIMP fils de self - qui a le concept co comme valeur. - En principe, elle ne doit etre utilisee que pour les concepts - instances de la classe CO + Cette methode retourne l'objet MCSIMP fils de self + qui a le concept co comme valeur. + En principe, elle ne doit etre utilisee que pour les concepts + instances de la classe CO """ l = [] for child in self.mcListe: @@ -555,15 +591,14 @@ class MCCOMPO(N_OBJECT.OBJECT): def getAllCo(self): """ - Cette methode retourne tous les concepts instances de CO + Cette methode retourne tous les concepts instances de CO """ l = [] for child in self.mcListe: l.extend(child.getAllCo()) return l - - #def getSdCreeParObjetAvecFiltre(self,objetAssdMultiple): + # def getSdCreeParObjetAvecFiltre(self,objetAssdMultiple): # est-ce que si on est bloc, il faut passer à parent ? # ou prevoir une autre fonction qui tienne compte de cela # ou prevoir un xpath @@ -578,7 +613,6 @@ class MCCOMPO(N_OBJECT.OBJECT): # return l - def intersection_vide(dict1, dict2): """Verification qu'il n'y a pas de clé commune entre 'dict1' et 'dict2'.""" sk1 = set(dict1) @@ -586,5 +620,5 @@ def intersection_vide(dict1, dict2): inter = sk1.intersection(sk2) ok = len(inter) == 0 if not ok: - print(('ERREUR: Mot(s)-clef(s) vu(s) plusieurs fois :', tuple(inter))) + print(("ERREUR: Mot(s)-clef(s) vu(s) plusieurs fois :", tuple(inter))) return ok diff --git a/Noyau/N_MCFACT.py b/Noyau/N_MCFACT.py index a1fc0c72..8d010bb5 100644 --- a/Noyau/N_MCFACT.py +++ b/Noyau/N_MCFACT.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,39 +23,34 @@ d'un mot-clé facteur par rapport à sa définition portée par un objet de type ENTITE """ - -from __future__ import absolute_import from . import N_MCCOMPO class MCFACT(N_MCCOMPO.MCCOMPO): - - """ - """ nature = "MCFACT" - def __init__(self, val, definition, nom, parent,dicoPyxbDeConstruction): + def __init__(self, val, definition, nom, parent, dicoPyxbDeConstruction): """ - Attributs : - - val : valeur du mot clé simple - - definition - - nom - - parent + Attributs : + - val : valeur du mot clé simple + - definition + - nom + - parent """ - #print ('MCFACT', self, val, definition, nom, parent, dicoPyxbDeConstruction) - #import traceback - #traceback.print_stack() - self.dicoPyxbDeConstruction=dicoPyxbDeConstruction - if self.dicoPyxbDeConstruction : - self.objPyxbDeConstruction=self.dicoPyxbDeConstruction['objEnPyxb'] - del self.dicoPyxbDeConstruction['objEnPyxb'] - else : - self.objPyxbDeConstruction=None + # print ('MCFACT', self, val, definition, nom, parent, dicoPyxbDeConstruction) + # import traceback + # traceback.print_stack() + self.dicoPyxbDeConstruction = dicoPyxbDeConstruction + if self.dicoPyxbDeConstruction: + self.objPyxbDeConstruction = self.dicoPyxbDeConstruction["objEnPyxb"] + del self.dicoPyxbDeConstruction["objEnPyxb"] + else: + self.objPyxbDeConstruction = None self.definition = definition self.nom = nom self.val = val self.parent = parent - self.estIdentifiePar=None + self.estIdentifiePar = None self.valeur = self.getValeurEffective(self.val) if parent: self.jdc = self.parent.jdc @@ -70,33 +65,33 @@ class MCFACT(N_MCCOMPO.MCCOMPO): def getValeurEffective(self, val): """ - Retourne la valeur effective du mot-clé en fonction - de la valeur donnée. Defaut si val == None + Retourne la valeur effective du mot-clé en fonction + de la valeur donnée. Defaut si val == None """ - if (val is None and hasattr(self.definition, 'defaut')): + if val is None and hasattr(self.definition, "defaut"): return self.definition.defaut else: return val def getValeur(self): """ - Retourne la "valeur" d'un mot-clé facteur qui est l'objet lui-meme. - Cette valeur est utilisée lors de la création d'un contexte - d'évaluation d'expressions à l'aide d'un interpréteur Python + Retourne la "valeur" d'un mot-clé facteur qui est l'objet lui-meme. + Cette valeur est utilisée lors de la création d'un contexte + d'évaluation d'expressions à l'aide d'un interpréteur Python """ return self def getVal(self): """ - Une autre méthode qui retourne une "autre" valeur du mot clé facteur. - Elle est utilisée par la méthode getMocle + Une autre méthode qui retourne une "autre" valeur du mot clé facteur. + Elle est utilisée par la méthode getMocle """ return [self] def __getitem__(self, key): """ - Dans le cas d un mot cle facteur unique on simule une liste de - longueur 1 + Dans le cas d un mot cle facteur unique on simule une liste de + longueur 1 """ if key == 0: return self @@ -104,11 +99,12 @@ class MCFACT(N_MCCOMPO.MCCOMPO): def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitMCFACT(self) def makeobjet(self): - return self.definition.class_instance(val=None, nom=self.nom, - definition=self.definition, parent=self.parent) + return self.definition.class_instance( + val=None, nom=self.nom, definition=self.definition, parent=self.parent + ) diff --git a/Noyau/N_MCLIST.py b/Noyau/N_MCLIST.py index 45b096df..0590a423 100644 --- a/Noyau/N_MCLIST.py +++ b/Noyau/N_MCLIST.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,34 +23,22 @@ d'une liste de mots-clés facteur par rapport à sa définition portée par un objet de type ENTITE """ - -from __future__ import absolute_import -try : - from future import standard_library - standard_library.install_aliases() -except : - pass from copy import copy import types - -try: - from UserList import UserList -except ImportError: - from collections import UserList - - +from collections import UserList class MCList(UserList): - """ Liste semblable a la liste Python - mais avec quelques methodes en plus - = liste de MCFACT + """Liste semblable a la liste Python + mais avec quelques methodes en plus + = liste de MCFACT """ - nature = 'MCList' + + nature = "MCList" def init(self, nom, parent): - self.objPyxbDeConstruction=None + self.objPyxbDeConstruction = None self.definition = None self.nom = nom self.parent = parent @@ -66,23 +54,23 @@ class MCList(UserList): def getValeur(self): """ - Retourne la "valeur" d'un objet MCList. Sert à construire - un contexte d'évaluation pour une expression Python. - On retourne l'objet lui-meme. + Retourne la "valeur" d'un objet MCList. Sert à construire + un contexte d'évaluation pour une expression Python. + On retourne l'objet lui-meme. """ return self def getVal(self): """ - Une autre méthode qui retourne une "autre" valeur d'une MCList - Elle est utilisée par la méthode getMocle + Une autre méthode qui retourne une "autre" valeur d'une MCList + Elle est utilisée par la méthode getMocle """ return self def supprime(self): """ - Méthode qui supprime toutes les références arrières afin que l'objet puisse - etre correctement détruit par le garbage collector + Méthode qui supprime toutes les références arrières afin que l'objet puisse + etre correctement détruit par le garbage collector """ self.parent = None self.etape = None @@ -91,10 +79,10 @@ class MCList(UserList): for child in self.data: child.supprime() - def getChild(self, name,restreint='non'): + def getChild(self, name, restreint="non"): """ - Retourne le fils de nom name s'il est contenu dans self - Par défaut retourne le fils du premier de la liste + Retourne le fils de nom name s'il est contenu dans self + Par défaut retourne le fils du premier de la liste """ obj = self.data[0] # Phase 1 : on cherche dans les fils directs de obj @@ -118,53 +106,52 @@ class MCList(UserList): return None def getAllChild(self, name): - # A utiliser uniquement dans un filtre - maListeRetour= MCList() + # A utiliser uniquement dans un filtre + maListeRetour = MCList() for obj in self.data: - for objFils in obj.getChild(name) : + for objFils in obj.getChild(name): maListeRetour.append(objFils) return maListeRetour - def isBLOC(self): """ - Indique si l'objet est de type BLOC + Indique si l'objet est de type BLOC """ return 0 def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitMCList(self) def getSd_utilisees(self): """ - Retourne la liste des concepts qui sont utilisés à l'intérieur de self - ( comme valorisation d'un MCS) + Retourne la liste des concepts qui sont utilisés à l'intérieur de self + ( comme valorisation d'un MCS) """ l = [] for child in self.data: l.extend(child.getSd_utilisees()) return l - def getSd_mcs_utilisees(self): + def getSdMCSUtilisees(self): """ - Retourne la ou les SD utilisée par self sous forme d'un dictionnaire : - - Si aucune sd n'est utilisée, le dictionnaire est vide. - - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on - trouve des sd ; la valeur est la liste des sd attenante. + Retourne la ou les SD utilisée par self sous forme d'un dictionnaire : + - Si aucune sd n'est utilisée, le dictionnaire est vide. + - Sinon, les clés du dictionnaire sont les mots-clés derrière lesquels on + trouve des sd ; la valeur est la liste des sd attenante. - Exemple :: + Exemple :: - { 'VALE_F': [ , - ], - 'MODELE': [] } + { 'VALE_F': [ , + ], + 'MODELE': [] } """ dico = {} for child in self.data: - daux = child.getSd_mcs_utilisees() + daux = child.getSdMCSUtilisees() for cle in daux: dico[cle] = dico.get(cle, []) dico[cle].extend(daux[cle]) @@ -172,10 +159,10 @@ class MCList(UserList): def getMcsWithCo(self, co): """ - Cette methode retourne l'objet MCSIMP fils de self - qui a le concept co comme valeur. - En principe, elle ne doit etre utilisee que pour les concepts - instances de la classe CO + Cette methode retourne l'objet MCSIMP fils de self + qui a le concept co comme valeur. + En principe, elle ne doit etre utilisee que pour les concepts + instances de la classe CO """ l = [] for child in self.data: @@ -184,7 +171,7 @@ class MCList(UserList): def getAllCo(self): """ - Cette methode retourne tous les concepts instances de CO + Cette methode retourne tous les concepts instances de CO """ l = [] for child in self.data: @@ -193,7 +180,7 @@ class MCList(UserList): def copy(self): """ - Réalise la copie d'une MCList + Réalise la copie d'une MCList """ liste = self.data[0].definition.list_instance() # FR -->Il faut spécifier un parent pour la méthode init qui attend 2 @@ -210,7 +197,7 @@ class MCList(UserList): def reparent(self, parent): """ - Cette methode sert a reinitialiser la parente de l'objet + Cette methode sert a reinitialiser la parente de l'objet """ self.parent = parent self.jdc = parent.jdc @@ -220,10 +207,10 @@ class MCList(UserList): def getEtape(self): """ - Retourne l'étape à laquelle appartient self - Un objet de la catégorie etape doit retourner self pour indiquer que - l'étape a été trouvée - XXX double emploi avec self.etape ??? + Retourne l'étape à laquelle appartient self + Un objet de la catégorie etape doit retourner self pour indiquer que + l'étape a été trouvée + XXX double emploi avec self.etape ??? """ if self.parent == None: return None @@ -231,7 +218,7 @@ class MCList(UserList): def __getitem__(self, key): """ - Dans le cas d un mot cle facteur de longueur 1 on simule un scalaire + Dans le cas d un mot cle facteur de longueur 1 on simule un scalaire """ if type(key) != int and len(self) == 1: return self.data[0].getMocle(key) @@ -240,8 +227,8 @@ class MCList(UserList): def List_F(self): """ - Retourne une liste de dictionnaires (eventuellement singleton) qui peut etre - passe directement derriere un mot-cle facteur (pour les macros). + Retourne une liste de dictionnaires (eventuellement singleton) qui peut etre + passe directement derriere un mot-cle facteur (pour les macros). """ dresu = [] for mcf in self: @@ -253,5 +240,5 @@ class MCList(UserList): return dresu def longueurDsArbre(self): - # pour Pyxb : longueur dans le orderedcontent de pyxb + # pour Pyxb : longueur dans le orderedcontent de pyxb return len(self) diff --git a/Noyau/N_MCSIMP.py b/Noyau/N_MCSIMP.py index bda0b21e..cd57f6b6 100644 --- a/Noyau/N_MCSIMP.py +++ b/Noyau/N_MCSIMP.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -24,9 +24,7 @@ de type ENTITE """ -from __future__ import absolute_import from copy import copy - from Noyau.N_ASSD import ASSD from Noyau.N_UserASSDMultiple import UserASSDMultiple from Noyau.N_CO import CO @@ -37,25 +35,25 @@ from .N_types import forceList, isSequence class MCSIMP(N_OBJECT.OBJECT): - """ - """ - nature = 'MCSIMP' + """ """ + + nature = "MCSIMP" - def __init__(self, val, definition, nom, parent,objPyxbDeConstruction): + def __init__(self, val, definition, nom, parent, objPyxbDeConstruction): """ - Attributs : + Attributs : - - val : valeur du mot clé simple - - definition - - nom - - parent + - val : valeur du mot clé simple + - definition + - nom + - parent - Autres attributs : + Autres attributs : - - valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut + - valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut """ - #print (self, val, definition, nom, parent) + # print (self, val, definition, nom, parent) self.definition = definition self.nom = nom self.val = val @@ -63,143 +61,193 @@ class MCSIMP(N_OBJECT.OBJECT): self.objPyxbDeConstruction = objPyxbDeConstruction if parent: self.jdc = self.parent.jdc - if self.jdc : self.cata = self.jdc.cata - else : self.cata = None + if self.jdc: + self.cata = self.jdc.cata + else: + self.cata = None self.niveau = self.parent.niveau - self.etape = self.parent.etape + self.etape = self.parent.etape else: # Le mot cle simple a été créé sans parent # est-ce possible ? - print ('je suis dans le else sans parent du build') - self.jdc = None - self.cata = None + print("je suis dans le else sans parent du build") + self.jdc = None + self.cata = None self.niveau = None - self.etape = None - if self.definition.creeDesObjets : - if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) : - self.convProto = ConversionFactory('UserASSDMultiple', self.definition.creeDesObjetsDeType) - else : - self.convProto = ConversionFactory('UserASSD', self.definition.creeDesObjetsDeType) - else : - self.convProto = ConversionFactory('type', typ=self.definition.type) + self.etape = None + if self.definition.creeDesObjets: + if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple): + self.convProto = ConversionFactory( + "UserASSDMultiple", self.definition.creeDesObjetsDeType + ) + else: + self.convProto = ConversionFactory( + "UserASSD", self.definition.creeDesObjetsDeType + ) + else: + self.convProto = ConversionFactory("type", typ=self.definition.type) self.valeur = self.getValeurEffective(self.val) - if self.definition.utiliseUneReference : + if self.definition.utiliseUneReference: if self.valeur != None: - if not type(self.valeur) in (list, tuple): self.valeur.ajoutUtilisePar(self) - else : - #PNPN --> chgt pour Vimmp - for v in self.valeur : - #print (v, type(v)) + if not type(self.valeur) in (list, tuple): + self.valeur.ajoutUtilisePar(self) + else: + # PNPN --> chgt pour Vimmp + for v in self.valeur: + # print (v, type(v)) v.ajoutUtilisePar(self) - #try : v.ajoutUtilisePar(self) - #except : print ('il y a un souci ici', self.nom, self.valeur) + # try : v.ajoutUtilisePar(self) + # except : print ('il y a un souci ici', self.nom, self.valeur) self.buildObjPyxb() self.listeNomsObjsCrees = [] def getValeurEffective(self, val): """ - Retourne la valeur effective du mot-clé en fonction - de la valeur donnée. Defaut si val == None - Attention aux UserASSD et aux into (exple Wall gp de maille et 'Wall') + Retourne la valeur effective du mot-clé en fonction + de la valeur donnée. Defaut si val == None + Attention aux UserASSD et aux into (exple Wall gp de maille et 'Wall') """ - #print ('getValeurEffective ________________', val) - if (val is None and hasattr(self.definition, 'defaut')): val = self.definition.defaut - if self.definition.type[0] == 'TXM' and isinstance(val,str) : return val - if self.definition.creeDesObjets : + # print ('getValeurEffective ________________', val) + if val is None and hasattr(self.definition, "defaut"): + val = self.definition.defaut + if self.definition.type[0] == "TXM" and isinstance(val, str): + return val + if self.definition.creeDesObjets: # isinstance(val, self.definition.creeDesObjetsDeType) ne fonctionne pas car il y a un avec cata devant et l autre non - if val == None : return val - if not isinstance(val,(list,tuple)) : valATraiter=[val,] - else : valATraiter=val - listeRetour=[] + if val == None: + return val + if not isinstance(val, (list, tuple)): + valATraiter = [ + val, + ] + else: + valATraiter = val + listeRetour = [] for v in valATraiter: - #print (v.__class__.__name__, self.definition.creeDesObjetsDeType.__name__) - if (not(v.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__)) : - if self.jdc != None and v in list(self.jdc.sdsDict.keys()): v=self.jdc.sdsDict[v] - else : v=self.convProto.convert(v) - if v.parent== None : v.initialiseParent(self) - if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) : + # print (v.__class__.__name__, self.definition.creeDesObjetsDeType.__name__) + if not ( + v.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__ + ): + if self.jdc != None and v in list(self.jdc.sdsDict.keys()): + v = self.jdc.sdsDict[v] + else: + v = self.convProto.convert(v) + if v.parent == None: + v.initialiseParent(self) + if issubclass( + self.definition.creeDesObjetsDeType, UserASSDMultiple + ): v.ajouteUnPere(self) - else : - if v.nom=='sansNom' : - for leNom,laVariable in self.jdc.g_context.items(): - #print (leNom,laVariable) - if id(laVariable) == id(v) and (leNom != 'sansNom'): + else: + if v.nom == "sansNom": + for leNom, laVariable in self.jdc.g_context.items(): + # print (leNom,laVariable) + if id(laVariable) == id(v) and (leNom != "sansNom"): v.initialiseNom(leNom) - if v.parent== None : v.initialiseParent(self) - if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) : + if v.parent == None: + v.initialiseParent(self) + if issubclass( + self.definition.creeDesObjetsDeType, UserASSDMultiple + ): v.ajouteUnPere(self) listeRetour.append(v) - if isinstance(val,(list,tuple)) :newVal=listeRetour - else : newVal=listeRetour[0] + if isinstance(val, (list, tuple)): + newVal = listeRetour + else: + newVal = listeRetour[0] return newVal if self.convProto: val = self.convProto.convert(val) return val def creeUserASSDetSetValeur(self, val): - self.state='changed' - nomVal=val + self.state = "changed" + nomVal = val if nomVal in self.jdc.sdsDict.keys(): - if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType): - if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) : - p=self.parent - while p in self.parent : - if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal]) - else : p.listeDesReferencesCrees=[self.jdc.sdsDict[nomVal],] - p=p.parent + if isinstance( + self.jdc.sdsDict[nomVal], self.definition.creeDesObjetsDeType + ): + if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple): + p = self.parent + while p in self.parent: + if hasattr(p, "listeDesReferencesCrees"): + p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal]) + else: + p.listeDesReferencesCrees = [ + self.jdc.sdsDict[nomVal], + ] + p = p.parent self.jdc.sdsDict[nomVal].ajouteUnPere(self) - #return (1, 'reference ajoutee') - else : - return (0, 'concept non multiple deja reference') - else : return (0, 'concept d un autre type existe deja') + # return (1, 'reference ajoutee') + else: + return (0, "concept non multiple deja reference") + else: + return (0, "concept d un autre type existe deja") if self.convProto: objVal = self.convProto.convert(nomVal) objVal.initialiseNom(nomVal) - if objVal.parent== None : objVal.initialiseParent(self) + if objVal.parent == None: + objVal.initialiseParent(self) objVal.ajouteUnPere(self) - p=self.parent - while p in self.parent : - #print ('mise a jour de ',p) - if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objVal) - else : p.listeDesReferencesCrees=[objVal,] - p=p.parent - return (self.setValeur(objVal), 'reference creee') + p = self.parent + while p in self.parent: + # print ('mise a jour de ',p) + if hasattr(p, "listeDesReferencesCrees"): + p.listeDesReferencesCrees.append(objVal) + else: + p.listeDesReferencesCrees = [ + objVal, + ] + p = p.parent + return (self.setValeur(objVal), "reference creee") def creeUserASSD(self, val): - self.state='changed' - nomVal=val + self.state = "changed" + nomVal = val if nomVal in self.jdc.sdsDict.keys(): - if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType): - if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple) : - p=self.parent - while p in self.parent : - if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal]) - else : p.listeDesReferencesCrees=[self.jdc.sdsDict[nomVal],] - p=p.parent + if isinstance( + self.jdc.sdsDict[nomVal], self.definition.creeDesObjetsDeType + ): + if issubclass(self.definition.creeDesObjetsDeType, UserASSDMultiple): + p = self.parent + while p in self.parent: + if hasattr(p, "listeDesReferencesCrees"): + p.listeDesReferencesCrees.append(self.jdc.sdsDict[nomVal]) + else: + p.listeDesReferencesCrees = [ + self.jdc.sdsDict[nomVal], + ] + p = p.parent self.jdc.sdsDict[nomVal].ajouteUnPere(self) - return (1,self.jdc.sdsDict[nomVal], 'reference ajoutee') - else : return (0, None, 'concept d un autre type existe deja') - else : return (0, None, 'concept d un autre type existe deja') + return (1, self.jdc.sdsDict[nomVal], "reference ajoutee") + else: + return (0, None, "concept d un autre type existe deja") + else: + return (0, None, "concept d un autre type existe deja") if self.convProto: objVal = self.convProto.convert(nomVal) objVal.initialiseNom(nomVal) objVal.ajouteUnPere(self) - return (1, objVal, 'reference creee') + return (1, objVal, "reference creee") def rattacheUserASSD(self, objASSD): - if objASSD.parent== None : objASSD.initialiseParent(self) - p=self.parent - while p in self.parent : - if hasattr(p, 'listeDesReferencesCrees') : p.listeDesReferencesCrees.append(objASSD) - else : p.listeDesReferencesCrees=[objASSD,] - p=p.parent - + if objASSD.parent == None: + objASSD.initialiseParent(self) + p = self.parent + while p in self.parent: + if hasattr(p, "listeDesReferencesCrees"): + p.listeDesReferencesCrees.append(objASSD) + else: + p.listeDesReferencesCrees = [ + objASSD, + ] + p = p.parent def getValeur(self): """ - Retourne la "valeur" d'un mot-clé simple. - Cette valeur est utilisée lors de la création d'un contexte - d'évaluation d'expressions à l'aide d'un interpréteur Python + Retourne la "valeur" d'un mot-clé simple. + Cette valeur est utilisée lors de la création d'un contexte + d'évaluation d'expressions à l'aide d'un interpréteur Python """ v = self.valeur # Si singleton et max=1, on retourne la valeur. @@ -212,28 +260,33 @@ class MCSIMP(N_OBJECT.OBJECT): elif isSequence(v) and len(v) == 1 and self.definition.max == 1: v = v[0] elif not isSequence(v) and self.definition.max != 1: - v = (v, ) + v = (v,) # traitement particulier pour les complexes ('RI', r, i) - if 'C' in self.definition.type and self.definition.max != 1 and v != None and v[0] in ('RI', 'MP'): - v = (v, ) + if ( + "C" in self.definition.type + and self.definition.max != 1 + and v != None + and v[0] in ("RI", "MP") + ): + v = (v,) return v def getVal(self): """ - Une autre méthode qui retourne une "autre" valeur du mot clé simple. - Elle est utilisée par la méthode getMocle + Une autre méthode qui retourne une "autre" valeur du mot clé simple. + Elle est utilisée par la méthode getMocle """ return self.valeur def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitMCSIMP(self) def copy(self): - """ Retourne une copie de self """ + """Retourne une copie de self""" objet = self.makeobjet() # il faut copier les listes et les tuples mais pas les autres valeurs # possibles (réel,SD,...) @@ -249,7 +302,7 @@ class MCSIMP(N_OBJECT.OBJECT): def reparent(self, parent): """ - Cette methode sert a reinitialiser la parente de l'objet + Cette methode sert a reinitialiser la parente de l'objet """ self.parent = parent self.jdc = parent.jdc @@ -257,8 +310,8 @@ class MCSIMP(N_OBJECT.OBJECT): def getSd_utilisees(self): """ - Retourne une liste qui contient la ou les SD utilisée par self si c'est le cas - ou alors une liste vide + Retourne une liste qui contient la ou les SD utilisée par self si c'est le cas + ou alors une liste vide """ l = [] if isinstance(self.valeur, ASSD): @@ -269,16 +322,16 @@ class MCSIMP(N_OBJECT.OBJECT): l.append(val) return l - def getSd_mcs_utilisees(self): + def getSdMCSUtilisees(self): """ - Retourne la ou les SD utilisée par self sous forme d'un dictionnaire : - - Si aucune sd n'est utilisée, le dictionnaire est vide. - - Sinon, la clé du dictionnaire est le mot-clé simple ; la valeur est - la liste des sd attenante. - - Exemple :: - { 'VALE_F': [ , - ] } + Retourne la ou les SD utilisée par self sous forme d'un dictionnaire : + - Si aucune sd n'est utilisée, le dictionnaire est vide. + - Sinon, la clé du dictionnaire est le mot-clé simple ; la valeur est + la liste des sd attenante. + + Exemple :: + { 'VALE_F': [ , + ] } """ l = self.getSd_utilisees() dico = {} @@ -286,83 +339,112 @@ class MCSIMP(N_OBJECT.OBJECT): dico[self.nom] = l return dico - def getMcsWithCo(self, co): """ - Cette methode retourne l'objet MCSIMP self s'il a le concept co - comme valeur. + Cette methode retourne l'objet MCSIMP self s'il a le concept co + comme valeur. """ if co in forceList(self.valeur): - return [self, ] + return [ + self, + ] return [] def getAllCo(self): """ - Cette methode retourne la liste de tous les concepts co - associés au mot cle simple + Cette methode retourne la liste de tous les concepts co + associés au mot cle simple """ - return [co for co in forceList(self.valeur) - if isinstance(co, CO) and co.isTypCO()] + return [ + co for co in forceList(self.valeur) if isinstance(co, CO) and co.isTypCO() + ] def supprime(self): - if not type(self.valeur) in (list, tuple): lesValeurs=(self.valeur,) - else : lesValeurs=self.valeur - if self.valeur == None or self.valeur == [] : lesValeurs=[] + if not type(self.valeur) in (list, tuple): + lesValeurs = (self.valeur,) + else: + lesValeurs = self.valeur + if self.valeur == None or self.valeur == []: + lesValeurs = [] for val in lesValeurs: - if self.definition.creeDesObjets : val.deleteReference(self) - else : - if (hasattr (val, 'enleveUtilisePar')) : val.enleveUtilisePar(self) + if self.definition.creeDesObjets: + val.deleteReference(self) + else: + if hasattr(val, "enleveUtilisePar"): + val.enleveUtilisePar(self) N_OBJECT.OBJECT.supprime(self) def getUserAssdPossible(self): - debug=False - if self.nom == 'ApplyOn' : debug = True - if debug : print ('____________', self, self.nom) + debug = False + if self.nom == "ApplyOn": + debug = True + if debug: + print("____________", self, self.nom) classeAChercher = self.definition.type - if debug : print ('____________', classeAChercher) - l=[] - dicoValeurs={} - d={} - if debug : print ('____________', self.definition.filtreVariables) - if self.definition.filtreVariables != None : - for (nomMC, Xpath) in self.definition.filtreVariables : - if debug : print (nomMC, Xpath) - if Xpath == None : dicoValeurs[nomMC] = getattr(self,nomMC) - else : - try: #if 1 : - pereMC=eval(Xpath) - if debug : print ('pereMC :',pereMC) - if pereMC : - exp=Xpath+'.getChild("'+nomMC+'")' - leMotCle=eval(exp) - else : leMotCle=None - if debug : print ('leMotCle', leMotCle) - if leMotCle : - if leMotCle.val : dicoValeurs[nomMC]=leMotCle.val - elif leMotCle.definition.max != 1 : dicoValeurs[nomMC] = [] - else : dicoValeurs[nomMC] = None - if debug : print ('dicoValeurs', dicoValeurs) - else : - #PN PN est-ce sur ? sinon quoi None ou [] - # je pense que les 2 valeurs doivent être renseignees si le filtre depend de 2 valeurs + if debug: + print("____________", classeAChercher) + l = [] + dicoValeurs = {} + d = {} + if debug: + print("____________", self.definition.filtreVariables) + if self.definition.filtreVariables != None: + for nomMC, Xpath in self.definition.filtreVariables: + if debug: + print(nomMC, Xpath) + if Xpath == None: + dicoValeurs[nomMC] = getattr(self, nomMC) + else: + try: # if 1 : + pereMC = eval(Xpath) + if debug: + print("pereMC :", pereMC) + if pereMC: + exp = Xpath + '.getChild("' + nomMC + '")' + leMotCle = eval(exp) + else: + leMotCle = None + if debug: + print("leMotCle", leMotCle) + if leMotCle: + if leMotCle.val: + dicoValeurs[nomMC] = leMotCle.val + elif leMotCle.definition.max != 1: + dicoValeurs[nomMC] = [] + else: + dicoValeurs[nomMC] = None + if debug: + print("dicoValeurs", dicoValeurs) + else: + # PN PN est-ce sur ? sinon quoi None ou [] + # je pense que les 2 valeurs doivent être renseignees si le filtre depend de 2 valeurs return l except: return l - - for k,v in self.parent.jdc.sdsDict.items(): - if (isinstance(v, classeAChercher)) : - if debug : print ('je traite', v) - if self.definition.filtreExpression : - if debug : print ('expression', self.definition.filtreExpression) - if debug : - print (v.executeExpression(self.definition.filtreExpression ,dicoValeurs) ) - try : - if v.executeExpression(self.definition.filtreExpression ,dicoValeurs) : l.append(v) - except : - print ('il faut comprendre except pour', self.nom) - #print (self.nom) - #print (self.parent.nom) - #print (k,v) - else : l.append(v) + for k, v in self.parent.jdc.sdsDict.items(): + if isinstance(v, classeAChercher): + if debug: + print("je traite", v) + if self.definition.filtreExpression: + if debug: + print("expression", self.definition.filtreExpression) + if debug: + print( + v.executeExpression( + self.definition.filtreExpression, dicoValeurs + ) + ) + try: + if v.executeExpression( + self.definition.filtreExpression, dicoValeurs + ): + l.append(v) + except: + print("il faut comprendre except pour", self.nom) + # print (self.nom) + # print (self.parent.nom) + # print (k,v) + else: + l.append(v) return l diff --git a/Noyau/N_OBJECT.py b/Noyau/N_OBJECT.py index 80f31056..2fa70c59 100644 --- a/Noyau/N_OBJECT.py +++ b/Noyau/N_OBJECT.py @@ -1,5 +1,5 @@ ## coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,32 +22,28 @@ Ce module contient la classe OBJECT classe mère de tous les objets servant à controler les valeurs par rapport aux définitions """ -from __future__ import absolute_import -try : - from builtins import object -except : - pass +from builtins import object from .N_CR import CR class OBJECT(object): """ - Classe OBJECT : cette classe est virtuelle et sert de classe mère - aux classes de type ETAPE et MOCLES. - Elle ne peut etre instanciée. - Une sous classe doit obligatoirement implémenter les méthodes : + Classe OBJECT : cette classe est virtuelle et sert de classe mère + aux classes de type ETAPE et MOCLES. + Elle ne peut etre instanciée. + Une sous classe doit obligatoirement implémenter les méthodes : - - __init__ + - __init__ """ def getEtape(self): """ - Retourne l'étape à laquelle appartient self - Un objet de la catégorie etape doit retourner self pour indiquer que - l'étape a été trouvée - XXX double emploi avec self.etape ??? + Retourne l'étape à laquelle appartient self + Un objet de la catégorie etape doit retourner self pour indiquer que + l'étape a été trouvée + XXX double emploi avec self.etape ??? """ if self.parent == None: return None @@ -55,29 +51,27 @@ class OBJECT(object): def supprime(self): """ - Méthode qui supprime les références arrières suffisantes pour - que l'objet puisse etre correctement détruit par le - garbage collector + Méthode qui supprime les références arrières suffisantes pour + que l'objet puisse etre correctement détruit par le + garbage collector """ self.parent = None self.etape = None self.jdc = None self.niveau = None - def getVal(self): """ - Retourne la valeur de l'objet. Cette méthode fournit - une valeur par defaut. Elle doit etre dérivée pour chaque - type d'objet + Retourne la valeur de l'objet. Cette méthode fournit + une valeur par defaut. Elle doit etre dérivée pour chaque + type d'objet """ return self - def getJdcRoot(self): """ - Cette méthode doit retourner l'objet racine c'est à dire celui qui - n'a pas de parent + Cette méthode doit retourner l'objet racine c'est à dire celui qui + n'a pas de parent """ if self.parent: return self.parent.getJdcRoot() @@ -86,39 +80,81 @@ class OBJECT(object): def getValeurEffective(self, val): """ - Retourne la valeur effective du mot-clé en fonction - de la valeur donnée. Defaut si val == None + Retourne la valeur effective du mot-clé en fonction + de la valeur donnée. Defaut si val == None """ - if (val is None and hasattr(self.definition, 'defaut')): + if val is None and hasattr(self.definition, "defaut"): return self.definition.defaut else: return val def reparent(self, parent): """ - Cette methode sert a reinitialiser la parente de l'objet + Cette methode sert a reinitialiser la parente de l'objet """ self.parent = parent self.jdc = parent.jdc def isBLOC(self): """ - Indique si l'objet est un BLOC - surcharge dans MCBLOC + Indique si l'objet est un BLOC + surcharge dans MCBLOC """ return 0 def longueurDsArbre(self): - if self.nom == "Consigne" : return 0 - if self.nom == "blocConsigne" : return 0 + if self.nom == "Consigne": + return 0 + if self.nom == "blocConsigne": + return 0 return 1 + def prepareInsertInDB(self, dictKey, dElementsRecursifs, dPrimaryKey): + # Comme c est recursif doit etre dans Objet + # derive pour MCSIMP et MCLIST + debug = 1 + if debug: + print("prepareInsertInDB traitement de ", self.nom) + if self.nature in ("OPERATEUR", "PROCEDURE"): + texteColonnes = "INSERT INTO {} (".format(self.nom) + texteValeurs = " VALUES(" + elif self.nom in dPrimaryKey: + texteColonnes = "INSERT INTO {} (".format(self.nom) + texteValeurs = " VALUES(" + texteColonnes += dPrimaryKey[self.nom] + texteValeurs += dictKey[dPrimaryKey[self.nom]] + else: + texteColonnes = "" + texteValeurs = "" + texteAutresTables = "" + for mc in self.mcListe: + if debug: + print("prepareInsertInDB appel pour", mc.nom, dictKey) + if mc.nom in dElementsRecursifs: + print("Mot Clef Recursifs", mc.nom) + if mc.nature == "MCSIMP": + col, val = mc.prepareInsertInDB() + if mc.nom in dictKey: + dictKey[mc.nom] = val + texteValeurs += val + " ," + texteColonnes += col + " ," + else: + tc, tv, ta = mc.prepareInsertInDB( + dictKey, dElementsRecursifs, dPrimaryKey + ) + texteValeurs += val + " ," + texteColonnes += col + " ," + texteAutresTables += ta + + if self.nature in ("OPERATEUR", "PROCEDURE") or self.nom in dPrimaryKey: + texteColonnes = texteColonnes[0:-1] + ") " + texteValeurs = texteValeurs[0:-1] + ");\n" + return (texteColonnes, texteValeurs, texteAutresTables) class ErrorObj(OBJECT): - """Classe pour objets errones : emule le comportement d'un objet tel mcsimp ou mcfact - """ + """Classe pour objets errones : emule le comportement d'un objet tel mcsimp ou mcfact""" def __init__(self, definition, valeur, parent, nom="err"): self.nom = nom @@ -136,42 +172,57 @@ class ErrorObj(OBJECT): # self.niveau = None # self.etape = None - def isValid(self, cr='non'): + def isValid(self, cr="non"): return 0 def report(self): - """ génère le rapport de validation de self """ + """génère le rapport de validation de self""" self.cr = CR() - self.cr.debut = u"Mot-clé invalide : " + self.nom - self.cr.fin = u"Fin Mot-clé invalide : " + self.nom - self.cr.fatal(_(u"Type non autorisé pour le mot-clé %s : '%s'"), - self.nom, self.valeur) + self.cr.debut = "Mot-clé invalide : " + self.nom + self.cr.fin = "Fin Mot-clé invalide : " + self.nom + self.cr.fatal( + _("Type non autorisé pour le mot-clé %s : '%s'"), self.nom, self.valeur + ) return self.cr -def newGetattr(self,name): - try : - fils=self.getChildOrChildInBloc(name,restreint='non') - if fils : - if fils.nature == 'MCSIMP' : return fils.valeur - if fils.nature == 'MCList' : - if fils[0].definition.max == 1 : return fils[0] - return fils - except : - raise AttributeError("%r object has no attribute %r" % (self.__class__.__name__, name)) - raise AttributeError("%r object has no attribute %r" % (self.__class__.__name__, name)) - -def newGetattrForEtape(self,name): - try : - lesFils=self.getEtapesByName(name) - if lesFils != [] : return lesFils - except : - raise AttributeError("%r object has no attribute %r" % (self.__class__.__name__, name)) - raise AttributeError("%r object has no attribute %r" % (self.__class__.__name__, name)) +def newGetattr(self, name): + try: + fils = self.getChildOrChildInBloc(name, restreint="non") + if fils: + if fils.nature == "MCSIMP": + return fils.valeur + if fils.nature == "MCList": + if fils[0].definition.max == 1: + return fils[0] + return fils + except: + raise AttributeError( + "%r object has no attribute %r" % (self.__class__.__name__, name) + ) + raise AttributeError( + "%r object has no attribute %r" % (self.__class__.__name__, name) + ) + + +def newGetattrForEtape(self, name): + try: + lesFils = self.getEtapesByName(name) + if lesFils != []: + return lesFils + except: + raise AttributeError( + "%r object has no attribute %r" % (self.__class__.__name__, name) + ) + raise AttributeError( + "%r object has no attribute %r" % (self.__class__.__name__, name) + ) + def activeSurcharge(): from .N_MCCOMPO import MCCOMPO + MCCOMPO.__getattr__ = newGetattr from .N_JDC import JDC + JDC.__getattr__ = newGetattrForEtape - diff --git a/Noyau/N_OPER.py b/Noyau/N_OPER.py index 0c13833a..785af480 100644 --- a/Noyau/N_OPER.py +++ b/Noyau/N_OPER.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,7 +23,7 @@ qui permet de spécifier les caractéristiques d'un opérateur """ -from __future__ import absolute_import + import types import traceback @@ -35,62 +35,78 @@ from . import nommage class OPER(N_ENTITE.ENTITE): """ - Classe pour definir un opérateur + Classe pour definir un opérateur - Cette classe a trois attributs de classe + Cette classe a trois attributs de classe - - class_instance qui indique la classe qui devra etre utilisée - pour créer l'objet qui servira à controler la conformité d'un - opérateur avec sa définition + - class_instance qui indique la classe qui devra etre utilisée + pour créer l'objet qui servira à controler la conformité d'un + opérateur avec sa définition - - label qui indique la nature de l'objet de définition (ici, OPER) + - label qui indique la nature de l'objet de définition (ici, OPER) - - nommage qui est un module Python qui fournit la fonctionnalité de nommage + - nommage qui est un module Python qui fournit la fonctionnalité de nommage - et les attributs d'instance suivants : + et les attributs d'instance suivants : - - nom : son nom + - nom : son nom - - op : le numéro d'opérateur + - op : le numéro d'opérateur - - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne - une classe + - sd_prod : le type de concept produit. C'est une classe ou une fonction qui retourne + une classe - - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur - réentrant peut modifier un concept d'entrée et le produire comme concept de sortie + - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur + réentrant peut modifier un concept d'entrée et le produire comme concept de sortie - - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur - non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort - de l'objet gérant le contexte d'exécution de vérifier cette contrainte. + - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur + non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort + de l'objet gérant le contexte d'exécution de vérifier cette contrainte. - - fr : commentaire associé en francais + - fr : commentaire associé en francais - - docu : clé de documentation associée + - docu : clé de documentation associée - - regles : liste des règles associées + - regles : liste des règles associées - - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette - fonction est exécutée lors des phases d'initialisation de l'étape associée. + - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette + fonction est exécutée lors des phases d'initialisation de l'étape associée. - - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre - rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement. - Si niveau vaut None, l'opérateur est rangé au niveau global. + - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre + rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement. + Si niveau vaut None, l'opérateur est rangé au niveau global. - - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit - des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut - est initialisé avec args, c'est à dire les arguments d'appel restants. + - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit + des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut + est initialisé avec args, c'est à dire les arguments d'appel restants. """ + class_instance = N_ETAPE.ETAPE - label = 'OPER' + label = "OPER" nommage = nommage - def __init__(self, nom, op=None, sd_prod=None, reentrant='n', repetable='o', fr="",ang="",fenetreIhm=None, - docu="", regles=(), op_init=None, niveau = None, UIinfo=None, **args): + def __init__( + self, + nom, + op=None, + sd_prod=None, + reentrant="n", + repetable="o", + fr="", + ang="", + fenetreIhm=None, + docu="", + regles=(), + op_init=None, + niveau=None, + UIinfo=None, + **args + ): """ - Méthode d'initialisation de l'objet OPER. Les arguments sont utilisés pour initialiser - les attributs de meme nom + Méthode d'initialisation de l'objet OPER. Les arguments sont utilisés pour initialiser + les attributs de meme nom """ self.nom = nom self.op = op @@ -100,7 +116,7 @@ class OPER(N_ENTITE.ENTITE): self.ang = ang self.repetable = repetable self.docu = docu - self.fenetreIhm= fenetreIhm + self.fenetreIhm = fenetreIhm if type(regles) == tuple: self.regles = regles else: @@ -119,43 +135,45 @@ class OPER(N_ENTITE.ENTITE): self.UIinfo = UIinfo self.affecter_parente() self.checkDefinition(self.nom) - self.txtNomComplet="" - self.dejaPrepareDump=False + self.txtNomComplet = "" + self.dejaPrepareDump = False - def __call__(self, reuse=None, nomXML=None,**args): + def __call__(self, reuse=None, nomXML=None, **args): """ - Construit l'objet ETAPE a partir de sa definition (self), - puis demande la construction de ses sous-objets et du concept produit. + Construit l'objet ETAPE a partir de sa definition (self), + puis demande la construction de ses sous-objets et du concept produit. """ - if nomXML == None : nomsd = self.nommage.getNomConceptResultat(self.nom) - else : nomsd = nomXML + if nomXML == None: + nomsd = self.nommage.getNomConceptResultat(self.nom) + else: + nomsd = nomXML etape = self.class_instance(oper=self, reuse=reuse, args=args) etape.MCBuild() - while etape.doitEtreRecalculee == True : + while etape.doitEtreRecalculee == True: etape.doitEtreRecalculee = False etape.deepUpdateConditionBlocApresCreation() etape.reConstruitResteVal() - etape.state='modified' - #print ('on recalcule la validite depuis N_OPER') + etape.state = "modified" + # print ('on recalcule la validite depuis N_OPER') # etape.isValid(cr='oui') etape.metAJourNomASSD(nomsd) return etape.buildSd(nomsd) - def make_objet(self, mc_list='oui'): + def make_objet(self, mc_list="oui"): """ - Cette méthode crée l'objet ETAPE dont la définition est self sans - l'enregistrer ni créer sa sdprod. - Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction - des objets MCxxx. + Cette méthode crée l'objet ETAPE dont la définition est self sans + l'enregistrer ni créer sa sdprod. + Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction + des objets MCxxx. """ etape = self.class_instance(oper=self, reuse=None, args={}) - if mc_list == 'oui': + if mc_list == "oui": etape.MCBuild() return etape def verifCata(self): """ - Méthode de vérification des attributs de définition + Méthode de vérification des attributs de définition """ self.checkRegles() self.checkFr() @@ -167,7 +185,7 @@ class OPER(N_ENTITE.ENTITE): def supprime(self): """ - Méthode pour supprimer les références arrières susceptibles de provoquer - des cycles de références + Méthode pour supprimer les références arrières susceptibles de provoquer + des cycles de références """ self.niveau = None diff --git a/Noyau/N_OPS.py b/Noyau/N_OPS.py index d861fd87..463ae63b 100644 --- a/Noyau/N_OPS.py +++ b/Noyau/N_OPS.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -17,11 +17,8 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -from __future__ import absolute_import -try : - from builtins import object -except : - pass + +from builtins import object from .N_utils import importObject @@ -49,4 +46,5 @@ class NOTHING(OPS): macro.set_icmd(1) return 0 + EMPTY_OPS = NOTHING(None) diff --git a/Noyau/N_PROC.py b/Noyau/N_PROC.py index f12d13f6..e1aae298 100644 --- a/Noyau/N_PROC.py +++ b/Noyau/N_PROC.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,7 +23,7 @@ qui permet de spécifier les caractéristiques d'une procédure """ -from __future__ import absolute_import + import types import traceback @@ -34,78 +34,93 @@ from . import N_PROC_ETAPE class PROC(N_ENTITE.ENTITE): """ - Classe pour definir un opérateur + Classe pour definir un opérateur - Cette classe a deux attributs de classe + Cette classe a deux attributs de classe - - class_instance qui indique la classe qui devra etre utilisée - pour créer l'objet qui servira à controler la conformité d'un - opérateur avec sa définition + - class_instance qui indique la classe qui devra etre utilisée + pour créer l'objet qui servira à controler la conformité d'un + opérateur avec sa définition - - label qui indique la nature de l'objet de définition (ici, PROC) + - label qui indique la nature de l'objet de définition (ici, PROC) - et les attributs d'instance suivants : + et les attributs d'instance suivants : - - nom : son nom + - nom : son nom - - op : le numéro d'opérateur + - op : le numéro d'opérateur - - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur - réentrant peut modifier un concept d'entrée et le produire comme concept de sortie + - reentrant : vaut 'n' ou 'o'. Indique si l'opérateur est réentrant ou pas. Un opérateur + réentrant peut modifier un concept d'entrée et le produire comme concept de sortie - - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur - non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort - de l'objet gérant le contexte d'exécution de vérifier cette contrainte. + - repetable : vaut 'n' ou 'o'. Indique si l'opérateur est répetable ou pas. Un opérateur + non répétable ne doit apparaitre qu'une fois dans une exécution. C'est du ressort + de l'objet gérant le contexte d'exécution de vérifier cette contrainte. - - fr : commentaire associé en francais + - fr : commentaire associé en francais - - docu : clé de documentation associée + - docu : clé de documentation associée - - regles : liste des règles associées + - regles : liste des règles associées - - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette - fonction est exécutée lors des phases d'initialisation de l'étape associée. + - op_init : cet attribut vaut None ou une fonction. Si cet attribut ne vaut pas None, cette + fonction est exécutée lors des phases d'initialisation de l'étape associée. - - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre - rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement. - Si niveau vaut None, l'opérateur est rangé au niveau global. + - niveau : indique le niveau dans lequel est rangé l'opérateur. Les opérateurs peuvent etre + rangés par niveau. Ils apparaissent alors exclusivement dans leur niveau de rangement. + Si niveau vaut None, l'opérateur est rangé au niveau global. - - fenetreIhm : specification de la fenetre + - fenetreIhm : specification de la fenetre - - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit - des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut - est initialisé avec args, c'est à dire les arguments d'appel restants. + - entites : dictionnaire dans lequel sont stockés les sous entités de l'opérateur. Il s'agit + des entités de définition pour les mots-clés : FACT, BLOC, SIMP. Cet attribut + est initialisé avec args, c'est à dire les arguments d'appel restants. """ - class_instance = N_PROC_ETAPE.PROC_ETAPE - label = 'PROC' - def __init__(self, nom, op=None, reentrant='n', repetable='o', fr="",ang="", fenetreIhm=None, - docu="", regles=(), op_init=None, niveau = None, UIinfo=None, **args): + class_instance = N_PROC_ETAPE.PROC_ETAPE + label = "PROC" + + def __init__( + self, + nom, + op=None, + reentrant="n", + repetable="o", + fr="", + ang="", + fenetreIhm=None, + docu="", + regles=(), + op_init=None, + niveau=None, + UIinfo=None, + **args + ): """ - Méthode d'initialisation de l'objet PROC. Les arguments sont utilisés pour initialiser - les attributs de meme nom + Méthode d'initialisation de l'objet PROC. Les arguments sont utilisés pour initialiser + les attributs de meme nom """ - self.nom = nom - self.op = op - self.reentrant = reentrant - self.repetable = repetable + self.nom = nom + self.op = op + self.reentrant = reentrant + self.repetable = repetable self.fenetreIhm = fenetreIhm - self.fr = fr - #self.ang="" - self.ang = ang - self.docu = docu + self.fr = fr + # self.ang="" + self.ang = ang + self.docu = docu if type(regles) == tuple: self.regles = regles else: self.regles = (regles,) # Attribut op_init : Fonction a appeler a la construction de l # operateur sauf si == None - self.op_init = op_init - self.entites = args - current_cata = CONTEXT.getCurrentCata() + self.op_init = op_init + self.entites = args + current_cata = CONTEXT.getCurrentCata() if niveau == None: self.niveau = None current_cata.enregistre(self) @@ -115,37 +130,37 @@ class PROC(N_ENTITE.ENTITE): self.UIinfo = UIinfo self.affecter_parente() self.checkDefinition(self.nom) - self.dejaPrepareDump=False - self.txtNomComplet='' + self.dejaPrepareDump = False + self.txtNomComplet = "" def __call__(self, **args): """ - Construit l'objet PROC_ETAPE a partir de sa definition (self), - puis demande la construction de ses sous-objets et du concept produit. + Construit l'objet PROC_ETAPE a partir de sa definition (self), + puis demande la construction de ses sous-objets et du concept produit. """ etape = self.class_instance(oper=self, args=args) etape.MCBuild() - while etape.doitEtreRecalculee == True : + while etape.doitEtreRecalculee == True: etape.doitEtreRecalculee = False etape.deepUpdateConditionBlocApresCreation() etape.reConstruitResteVal() return etape.buildSd() - def make_objet(self, mc_list='oui'): + def make_objet(self, mc_list="oui"): """ - Cette méthode crée l'objet PROC_ETAPE dont la définition est self sans - l'enregistrer ni créer sa sdprod. - Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction - des objets MCxxx. + Cette méthode crée l'objet PROC_ETAPE dont la définition est self sans + l'enregistrer ni créer sa sdprod. + Si l'argument mc_list vaut 'oui', elle déclenche en plus la construction + des objets MCxxx. """ etape = self.class_instance(oper=self, args={}) - if mc_list == 'oui': + if mc_list == "oui": etape.MCBuild() return etape def verifCata(self): """ - Méthode de vérification des attributs de définition + Méthode de vérification des attributs de définition """ self.checkRegles() self.checkFr() @@ -157,7 +172,7 @@ class PROC(N_ENTITE.ENTITE): def supprime(self): """ - Méthode pour supprimer les références arrières susceptibles de provoquer - des cycles de références + Méthode pour supprimer les références arrières susceptibles de provoquer + des cycles de références """ self.niveau = None diff --git a/Noyau/N_PROC_ETAPE.py b/Noyau/N_PROC_ETAPE.py index fde2ac79..b693d52f 100644 --- a/Noyau/N_PROC_ETAPE.py +++ b/Noyau/N_PROC_ETAPE.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -24,7 +24,7 @@ """ # Modules Python -from __future__ import absolute_import + import types import sys import traceback @@ -39,10 +39,11 @@ from . import N_utils class PROC_ETAPE(N_ETAPE.ETAPE): """ - Cette classe hérite de ETAPE. La seule différence porte sur le fait - qu'une procédure n'a pas de concept produit + Cette classe hérite de ETAPE. La seule différence porte sur le fait + qu'une procédure n'a pas de concept produit """ + nature = "PROCEDURE" def __init__(self, oper=None, reuse=None, args={}): @@ -58,39 +59,52 @@ class PROC_ETAPE(N_ETAPE.ETAPE): def buildSd(self): """ - Cette methode applique la fonction op_init au contexte du parent - et lance l'exécution en cas de traitement commande par commande - Elle doit retourner le concept produit qui pour une PROC est toujours None - En cas d'erreur, elle leve une exception : AsException ou EOFError + Cette methode applique la fonction op_init au contexte du parent + et lance l'exécution en cas de traitement commande par commande + Elle doit retourner le concept produit qui pour une PROC est toujours None + En cas d'erreur, elle leve une exception : AsException ou EOFError """ if not self.isActif(): return try: if self.parent: if type(self.definition.op_init) == types.FunctionType: - self.definition.op_init(*( - self, self.parent.g_context)) + self.definition.op_init(*(self, self.parent.g_context)) else: pass except AsException as e: - raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0], - 'fichier : ', self.appel[1], e) + raise AsException( + "Etape ", + self.nom, + "ligne : ", + self.appel[0], + "fichier : ", + self.appel[1], + e, + ) except EOFError: raise except: l = traceback.format_exception( - sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]) - raise AsException("Etape ", self.nom, 'ligne : ', self.appel[0], - 'fichier : ', self.appel[1] + '\n', - ''.join(l)) + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) + raise AsException( + "Etape ", + self.nom, + "ligne : ", + self.appel[0], + "fichier : ", + self.appel[1] + "\n", + "".join(l), + ) self.Execute() return None def supprime(self): """ - Méthode qui supprime toutes les références arrières afin que l'objet puisse - etre correctement détruit par le garbage collector + Méthode qui supprime toutes les références arrières afin que l'objet puisse + etre correctement détruit par le garbage collector """ N_MCCOMPO.MCCOMPO.supprime(self) self.jdc = None @@ -98,16 +112,16 @@ class PROC_ETAPE(N_ETAPE.ETAPE): def accept(self, visitor): """ - Cette methode permet de parcourir l'arborescence des objets - en utilisant le pattern VISITEUR + Cette methode permet de parcourir l'arborescence des objets + en utilisant le pattern VISITEUR """ visitor.visitPROC_ETAPE(self) def updateContext(self, d): """ - Met à jour le contexte de l'appelant passé en argument (d) - Une PROC_ETAPE n ajoute pas directement de concept dans le contexte - Seule une fonction enregistree dans op_init pourrait le faire + Met à jour le contexte de l'appelant passé en argument (d) + Une PROC_ETAPE n ajoute pas directement de concept dans le contexte + Seule une fonction enregistree dans op_init pourrait le faire """ if type(self.definition.op_init) == types.FunctionType: self.definition.op_init(*(self, d)) diff --git a/Noyau/N_REGLE.py b/Noyau/N_REGLE.py index 062230c8..685e5f81 100644 --- a/Noyau/N_REGLE.py +++ b/Noyau/N_REGLE.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -37,44 +37,39 @@ r.verif({"INFO":v1,"AFFE":v2) """ -from __future__ import absolute_import -try : - from builtins import object -except : - pass +from builtins import object import types class REGLE(object): - def __init__(self, *args): """ - Les classes dérivées peuvent utiliser cet initialiseur par défaut ou - le surcharger + Les classes dérivées peuvent utiliser cet initialiseur par défaut ou + le surcharger """ self.mcs = args def verif(self, args): """ - Les classes dérivées doivent implémenter cette méthode - qui doit retourner une paire dont le premier élément est une chaine de caractère - et le deuxième un entier. + Les classes dérivées doivent implémenter cette méthode + qui doit retourner une paire dont le premier élément est une chaine de caractère + et le deuxième un entier. - L'entier peut valoir 0 ou 1. -- s'il vaut 1, la règle est vérifiée - s'il vaut 0, la règle n'est pas vérifiée et le texte joint contient - un commentaire de la non validité. + L'entier peut valoir 0 ou 1. -- s'il vaut 1, la règle est vérifiée + s'il vaut 0, la règle n'est pas vérifiée et le texte joint contient + un commentaire de la non validité. """ - raise NotImplementedError('class REGLE should be derived') + raise NotImplementedError("class REGLE should be derived") def listeToDico(self, args): """ - Cette méthode est utilitaire pour les seuls besoins - des classes dérivées. + Cette méthode est utilitaire pour les seuls besoins + des classes dérivées. - Elle transforme une liste de noms de mots clés en un - dictionnaire équivalent dont les clés sont les noms des mts-clés + Elle transforme une liste de noms de mots clés en un + dictionnaire équivalent dont les clés sont les noms des mts-clés - Ceci permet d'avoir un traitement identique pour les listes et les dictionnaires + Ceci permet d'avoir un traitement identique pour les listes et les dictionnaires """ if type(args) == dict: return args @@ -84,5 +79,4 @@ class REGLE(object): dico[arg] = 0 return dico else: - raise Exception( - "Erreur ce n'est ni un dictionnaire ni une liste %s" % args) + raise Exception("Erreur ce n'est ni un dictionnaire ni une liste %s" % args) diff --git a/Noyau/N_SENSIBILITE.py b/Noyau/N_SENSIBILITE.py index 89e9ed68..ee0dc24a 100644 --- a/Noyau/N_SENSIBILITE.py +++ b/Noyau/N_SENSIBILITE.py @@ -1,5 +1,5 @@ # -*- coding: iso-8859-1 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,33 +23,33 @@ sur présence de la sensibilité. """ -from __future__ import absolute_import from .N_REGLE import REGLE + # ----------------------------------------------------------------------------- class CONCEPT_SENSIBLE(REGLE): """Règle permettant de renseigner au niveau du catalogue comment sera rempli le concept (valeur nominale ou dérivée(s) ou les deux...). """ - def __init__(self, mode, mocle='SENSIBILITE'): + + def __init__(self, mode, mocle="SENSIBILITE"): """Constructeur. - mode : manière dont la commande rempli le concept - - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe - - 'SEPARE' : concept nominal OU dérivée (une ou plusieurs) + mode : manière dont la commande rempli le concept + - 'ENSEMBLE' : concept nominal ET dérivées en une seule passe + - 'SEPARE' : concept nominal OU dérivée (une ou plusieurs) - mocle : mot-clé contenant les paramètres sensibles. + mocle : mot-clé contenant les paramètres sensibles. """ REGLE.__init__(self) self.mocle = mocle - self._modes = { 'ENSEMBLE' : 0, 'SEPARE' : 1 } - self.mode = self._modes.get(mode, self._modes['ENSEMBLE']) + self._modes = {"ENSEMBLE": 0, "SEPARE": 1} + self.mode = self._modes.get(mode, self._modes["ENSEMBLE"]) def getText(self): - """Pour EFICAS - """ - return '' + """Pour EFICAS""" + return "" def verif(self, args): """Retourne texte + 1 si ok, 0 si nook. @@ -59,27 +59,29 @@ class CONCEPT_SENSIBLE(REGLE): """ obj = args["self"] etape = obj.etape - id_etape = '%s_%s' % (etape.id, id(etape)) + id_etape = "%s_%s" % (etape.id, id(etape)) if etape.sd == None: - return '',1 - if not hasattr(etape.sd,"sensi"): + return "", 1 + if not hasattr(etape.sd, "sensi"): etape.sd.sensi = {} # si ENSEMBLE, la sd nominale est forcément produite - if self.mode == self._modes['ENSEMBLE'] and not 'nominal' in etape.sd.sensi : - etape.sd.sensi['nominal'] = id_etape + if self.mode == self._modes["ENSEMBLE"] and not "nominal" in etape.sd.sensi: + etape.sd.sensi["nominal"] = id_etape # liste des paramètres sensibles valeur = obj[self.mocle] if valeur == None: # pas de sensibilité, la sd nominale est produite - if not 'nominal' in etape.sd.sensi: - etape.sd.sensi['nominal'] = id_etape - return '', 1 + if not "nominal" in etape.sd.sensi: + etape.sd.sensi["nominal"] = id_etape + return "", 1 if not type(valeur) in (list, tuple): - valeur = [valeur,] + valeur = [ + valeur, + ] for v in valeur: if not v.getName() in etape.sd.sensi: etape.sd.sensi[v.getName()] = id_etape - return '', 1 + return "", 1 # ----------------------------------------------------------------------------- @@ -90,44 +92,55 @@ class REUSE_SENSIBLE(REGLE): - sd nominale calculée et SENSIBILITE absent - PS1 dans SENSIBILITE et sd dérivée par rapport à PS1 calculée """ - def __init__(self, mocle='SENSIBILITE'): + + def __init__(self, mocle="SENSIBILITE"): """Constructeur. - mocle : mot-clé SENSIBILITE. + mocle : mot-clé SENSIBILITE. """ REGLE.__init__(self) self.mocle = mocle def getText(self): - """Pour EFICAS - """ - return '' + """Pour EFICAS""" + return "" - def verif(self,args): + def verif(self, args): """Retourne texte + 1 si ok, 0 si nook = reuse interdit. Comme CONCEPT_SENSIBLE est appelé avant (et à chaque validation), on regarde si sd.sensi[ps] a été renseigné par une étape précédente. """ obj = args["self"] etape = obj.etape - id_etape = '%s_%s' % (etape.id, id(etape)) + id_etape = "%s_%s" % (etape.id, id(etape)) sd = etape.sd # si la commande n'est pas réentrante, rien à faire if etape.reuse is not None: valeur = obj[self.mocle] if valeur is None: - if not hasattr(sd, 'sensi') or sd.sensi.get('nominal', id_etape) != id_etape: + if ( + not hasattr(sd, "sensi") + or sd.sensi.get("nominal", id_etape) != id_etape + ): # pas de sensibilite et concept nominal déjà calculé : reuse interdit text = "Commande non réentrante en l'absence de sensibilité." return text, 0 else: if not type(valeur) in (list, tuple): - valeur = [valeur,] + valeur = [ + valeur, + ] for ps in valeur: - if hasattr(sd, 'sensi') and sd.sensi.get(ps.nom, id_etape) != id_etape: + if ( + hasattr(sd, "sensi") + and sd.sensi.get(ps.nom, id_etape) != id_etape + ): # concept dérivé par rapport à ps déjà calculé : reuse interdit - text = "Commande non réentrante : dérivée par rapport à %s déjà calculée" % ps.nom + text = ( + "Commande non réentrante : dérivée par rapport à %s déjà calculée" + % ps.nom + ) return text, 0 - return '', 1 + return "", 1 # ----------------------------------------------------------------------------- @@ -137,28 +150,29 @@ class DERIVABLE(REGLE): '.sensi' soit cohérent avec le contenu du mot-clé SENSIBILITE (ou l'absence de celui-ci). """ + def __init__(self, mocle): """Constructeur. - mocle : mot-clé dérivable. + mocle : mot-clé dérivable. """ REGLE.__init__(self) self.mocle = mocle def getText(self): - """Pour EFICAS - """ - return '' + """Pour EFICAS""" + return "" - def verif(self,args): - """ - """ + def verif(self, args): + """ """ obj = args["self"] try: concept = obj[self.mocle] except IndexError: - return '', 1 + return "", 1 if not type(concept) in (list, tuple): - concept = [concept,] + concept = [ + concept, + ] l_ps = obj["SENSIBILITE"] for co in concept: if co is None: @@ -166,17 +180,23 @@ class DERIVABLE(REGLE): return text, 0 if not l_ps: # pas de sensibilité - if hasattr(co,"sensi") and not co.sensi.get('nominal'): - text = "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE" %\ - co.nom + if hasattr(co, "sensi") and not co.sensi.get("nominal"): + text = ( + "%s ne contient que des valeurs dérivées, utilisez le mot cle SENSIBILITE" + % co.nom + ) return text, 0 else: # sensibilité spécifiée if not type(l_ps) in (list, tuple): - l_ps = [l_ps,] + l_ps = [ + l_ps, + ] for ps in l_ps: - if not hasattr(co,"sensi") or not co.sensi.get(ps.nom): - text = "La dérivée de %s par rapport à %s n'est pas disponible." %\ - (co.nom, ps.nom) + if not hasattr(co, "sensi") or not co.sensi.get(ps.nom): + text = ( + "La dérivée de %s par rapport à %s n'est pas disponible." + % (co.nom, ps.nom) + ) return text, 0 - return '', 1 + return "", 1 diff --git a/Noyau/N_SIMP.py b/Noyau/N_SIMP.py index e8bc1222..5dac00b6 100644 --- a/Noyau/N_SIMP.py +++ b/Noyau/N_SIMP.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,63 +22,100 @@ qui permet de spécifier les caractéristiques des mots clés simples """ -from __future__ import absolute_import + import types import Accas from Noyau import N_ENTITE from Noyau import N_MCSIMP +dictPourSql = { + "I": "BIGINT", + "R": "FLOAT8", + "BOOL": "BOOL", + "TXM": "TEXT", + "date": "DATE", +} + class SIMP(N_ENTITE.ENTITE): """ - Classe pour definir un mot cle simple + Classe pour definir un mot cle simple - Cette classe a deux attributs de classe + Cette classe a deux attributs de classe - - class_instance qui indique la classe qui devra etre utilisée - pour créer l'objet qui servira à controler la conformité d'un - mot-clé simple avec sa définition + - class_instance qui indique la classe qui devra etre utilisée + pour créer l'objet qui servira à controler la conformité d'un + mot-clé simple avec sa définition - - label qui indique la nature de l'objet de définition (ici, SIMP) + - label qui indique la nature de l'objet de définition (ici, SIMP) """ + class_instance = N_MCSIMP.MCSIMP - label = 'SIMP' + label = "SIMP" - def __init__(self, typ,ang="", fr="", statut='f', into=None, intoSug = None,siValide = None, defaut=None, - min=1, max=1, homo=1, position='local',filtre=None, - val_min=float('-inf'), val_max=float('inf'), docu="", validators=None, nomXML=None, - sug=None,fenetreIhm=None, attribut=False, sortie='n', intoXML=None, metAJour=None, - avecBlancs=False, unite=None): + def __init__( + self, + typ, + ang="", + fr="", + statut="f", + into=None, + intoSug=None, + siValide=None, + defaut=None, + min=1, + max=1, + homo=1, + position="local", + filtre=None, + val_min=float("-inf"), + val_max=float("inf"), + docu="", + validators=None, + nomXML=None, + sug=None, + fenetreIhm=None, + attribut=False, + sortie="n", + intoXML=None, + metAJour=None, + avecBlancs=False, + unite=None, + typeXSD=None, + formatGit=None, + affichage=None, + ): """ - Un mot-clé simple est caractérisé par les attributs suivants : - - type : cet attribut est obligatoire et indique le type de valeur attendue - - fr : chaîne documentaire en français - - statut : obligatoire ou facultatif ou caché - - into : valeurs autorisées - - intoSug : valeurs possibles mais des valeurs autres du bon type peuvent etre entrees par l utilsateur - - defaut : valeur par défaut - - min : nombre minimal de valeurs - - max : nombre maximal de valeurs - - homo : un certatin nb de choses qui il faut redispacher ailleurs (information, constant) - - ang : doc - - position : si global, le mot-clé peut-être lu n'importe où dans la commande - - val_min : valeur minimale autorisée - - val_max : valeur maximale autorisée - - docu : clef sur de la documentation utilisateur - - sug : valeur suggere - - fenetreIhm : si widget particulier - - attribut : si projection XSD sur attribut - - creeDesObjetsDeType : type des UserASSD si siValide en cree - - nomXML : se projette en XSD avec un autre nom pour accepter les tirets - - sortie : force l ecriture dans le fichier de sortie (utile pour Telemac) + Un mot-clé simple est caractérisé par les attributs suivants : + - type : cet attribut est obligatoire et indique le type de valeur attendue + - fr : chaîne documentaire en français + - statut : obligatoire ou facultatif ou caché ou cache avec defaut (d) + - into : valeurs autorisées + - intoSug : valeurs possibles mais des valeurs autres du bon type peuvent etre entrees par l utilsateur + - defaut : valeur par défaut + - min : nombre minimal de valeurs + - max : nombre maximal de valeurs + - homo : un certatin nb de choses qui il faut redispacher ailleurs (information, constant) + - ang : doc + - position : si global, le mot-clé peut-être lu n'importe où dans la commande + - val_min : valeur minimale autorisée + - val_max : valeur maximale autorisée + - docu : clef sur de la documentation utilisateur + - sug : valeur suggere + - fenetreIhm : si widget particulier + - attribut : si projection XSD sur attribut + - creeDesObjetsDeType : type des UserASSD si siValide en cree + - nomXML : se projette en XSD avec un autre nom pour accepter les tirets + - sortie : force l ecriture dans le fichier de sortie (utile pour Telemac) + - affichage : Tuple contenant un nom de gridLayout, puis ligne et colonne pour l affichage """ - #print (self) - #import traceback - #traceback.print_stack() - #print (self) + # print (self) + # import traceback + # traceback.print_stack() + # print (self) N_ENTITE.ENTITE.__init__(self, validators) # Initialisation des attributs self.creeDesObjets = False @@ -89,73 +126,113 @@ class SIMP(N_ENTITE.ENTITE): self.type = typ else: self.type = (typ,) - for t in (self.type) : - try : - if issubclass(t,Accas.UserASSDMultiple) : + for t in self.type: + try: + if issubclass(t, Accas.UserASSDMultiple): creeDesObjetsDeType = t self.utiliseUneReference = True - elif issubclass(t,Accas.UserASSD) : + elif issubclass(t, Accas.UserASSD): creeDesObjetsDeType = t self.utiliseUneReference = True - except : pass - if t == 'createObject' : self.creeDesObjets=True - if self.utiliseUneReference : - if self.creeDesObjets : + except: + pass + if t == "createObject": + self.creeDesObjets = True + if self.utiliseUneReference: + if self.creeDesObjets: self.utiliseUneReference = False self.creeDesObjetsDeType = creeDesObjetsDeType - else : self.utiliseDesObjetsDeType = creeDesObjetsDeType - self.fr = fr - self.statut = statut - self.into = into - self.intoSug = intoSug + else: + self.utiliseDesObjetsDeType = creeDesObjetsDeType + self.fr = fr + self.statut = statut + self.into = into + self.intoSug = intoSug self.siValide = siValide - self.defaut = defaut - self.min = min - self.max = max - self.homo = homo + self.defaut = defaut + self.min = min + self.max = max + self.homo = homo self.position = position - self.val_min = val_min - self.val_max = val_max - self.docu = docu - self.sug = sug - self.ang = ang - if self.max == '**' : self.max = float('inf') - if self.val_max == '**' : self.val_max = float('inf') - if self.min == '**' : self.min = float('-inf') - if self.val_min == '**' : self.val_min = float('-inf') + self.val_min = val_min + self.val_max = val_max + self.docu = docu + self.sug = sug + self.ang = ang + if self.max == "**": + self.max = float("inf") + if self.val_max == "**": + self.val_max = float("inf") + if self.min == "**": + self.min = float("-inf") + if self.val_min == "**": + self.val_min = float("-inf") self.fenetreIhm = fenetreIhm - self.attribut = attribut - self.nomXML = nomXML - self.intoXML = intoXML - self.sortie = sortie - self.filtre = filtre + self.attribut = attribut + self.nomXML = nomXML + self.intoXML = intoXML + self.sortie = sortie + self.filtre = filtre self.avecBlancs = avecBlancs - self.unite = unite - if not(self.avecBlancs) and self.max > 1 and 'TXM' in self.type and self.into != None : - for val in self.into : - if val.find(' ') > -1: - self.avecBlancs = True - break - if not(self.avecBlancs) and self.max > 1 and 'TXM' in self.type and self.intoXML != None : - for val in self.intoXML : - if val.find(' ') > -1: - self.avecBlancs = True - break - if self.avecBlancs and not ('TXM' in self.type) : - print ('definition incoherente avecBlanc et non texte pour ', self) + self.unite = unite + self.formatGit = formatGit + self.affichage = affichage + if typeXSD: + self.typeXSD = typeXSD + if ( + not (self.avecBlancs) + and self.max > 1 + and "TXM" in self.type + and self.into != None + ): + for val in self.into: + if val.find(" ") > -1: + self.avecBlancs = True + break + if ( + not (self.avecBlancs) + and self.max > 1 + and "TXM" in self.type + and self.intoXML != None + ): + for val in self.intoXML: + if val.find(" ") > -1: + self.avecBlancs = True + break + if self.avecBlancs and not ("TXM" in self.type): + print("definition incoherente avecBlanc et non texte pour ", self) exit() - if self.filtre : + if self.filtre: self.filtreExpression = self.filtre[0] self.filtreVariables = self.filtre[1] - else : + else: self.filtreExpression = [] self.filtreVariables = [] - self.metAJour=metAJour + self.metAJour = metAJour + + def changeInto(self, listeDesIntos): + self.into = listeDesIntos + + def changeIntoSelonValeurs(self, mcRecepteur): + mcRecepteur.changeInto(self.valeurs) + + def addInto(self, nvlInto): + if self.into == None: + self.into = [] + if nvlInto in self.into: + return + self.into.append(nvlInto) + + def changeStatut(self, nvlStatut): + self.statut = nvlStatut + + def changeSiValide(self, nvlFonction): + self.siValide = nvlFonction def verifCata(self): """ - Cette methode sert à valider les attributs de l'objet de définition - de la classe SIMP + Cette methode sert à valider les attributs de l'objet de définition + de la classe SIMP """ self.checkMinMax() self.checkFr() @@ -165,10 +242,28 @@ class SIMP(N_ENTITE.ENTITE): self.checkPosition() self.checkValidators() + def dumpStringDataBase(self, inBloc): + if self.type[0] in dictPourSql: + leTypeSql = dictPourSql[self.type[0]] + else: + leTypeSql = "texte" + # est-ce toujours vrai ? est ce que cela ne depend pas un peu des tables + if self.statut == "o" and not inBloc: + contraintes = "NOT NULL" + else: + contraintes = "" + texte = "\t{} {} {} ,\n".format(self.nom, leTypeSql, contraintes) + return texte - def __call__(self, val, nom, parent=None, objPyxbDeConstruction = None): + def __call__(self, val, nom, parent=None, objPyxbDeConstruction=None): """ - Construit un objet mot cle simple (MCSIMP) a partir de sa definition (self) - de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent) + Construit un objet mot cle simple (MCSIMP) a partir de sa definition (self) + de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent) """ - return self.class_instance(nom=nom, definition=self, val=val, parent=parent, objPyxbDeConstruction=objPyxbDeConstruction) + return self.class_instance( + nom=nom, + definition=self, + val=val, + parent=parent, + objPyxbDeConstruction=objPyxbDeConstruction, + ) diff --git a/Noyau/N_TUPLE.py b/Noyau/N_TUPLE.py index a5b656cf..dc78ad45 100644 --- a/Noyau/N_TUPLE.py +++ b/Noyau/N_TUPLE.py @@ -1,27 +1,43 @@ import types import Accas import inspect + + class N_Tuple: - def __init__(self,ntuple): - self.ntuple=ntuple + def __init__(self, ntuple): + self.ntuple = ntuple - def __convert__(self,valeur): + def __convert__(self, valeur): try: - if isinstance(valeur, basestring) : return None + if isinstance(valeur, basestring): + return None except NameError: - if isinstance(valeur, str): return None - if len(valeur) != self.ntuple: return None + if isinstance(valeur, str): + return None + if len(valeur) != self.ntuple: + return None return valeur def info(self): return "Tuple de %s elements" % self.ntuple + class N_Matrice: - def __init__(self, nbLigs=None, nbCols=None, - methodeCalculTaille=None, formatSortie="ligne", - valSup=None, valMin=None, structure=None, typElt='R', - typEltInto=None, listeHeaders=None, coloree=False, - defaut=None): + def __init__( + self, + nbLigs=None, + nbCols=None, + methodeCalculTaille=None, + formatSortie="ligne", + valSup=None, + valMin=None, + structure=None, + typElt="R", + typEltInto=None, + listeHeaders=None, + coloree=False, + defaut=None, + ): self.nbLigs = nbLigs self.nbCols = nbCols self.methodeCalculTaille = methodeCalculTaille @@ -32,10 +48,11 @@ class N_Matrice: self.typElt = typElt self.listeHeaders = listeHeaders self.typEltInto = typEltInto - self.jdc=None - self.coloree=coloree - self.defaut=defaut - if self.coloree : self.activeCouleur() + self.jdc = None + self.coloree = coloree + self.defaut = defaut + if self.coloree: + self.activeCouleur() def __convert__(self, valeur): # Attention ne verifie pas grand chose @@ -43,43 +60,55 @@ class N_Matrice: return None return valeur - def verifItem(self,texte,mc): - val='' - if self.typElt == 'R' : - try : val=float(str(texte)); ok=True - except : return (False,"Entrer un float SVP") - if self.typElt == 'I' : - try : val=int(str(texte)); ok=True - except : return (False,"Entrer un float SVP") - if self.typElt in ('R', 'I') and self.valSup != None : - if val > self.valSup : - return (False, "Entrer un nombre inferieur a " + repr(self.valSup)) - if self.typElt in ('R', 'I') and self.valMin != None : - if val < self.valMin : - return (False, "Entrer un nombre superieur a " + repr(self.valMin)) - if val=='' : val = texte - if self.typEltInto != None and val not in self.typEltInto : - return ( "Entrer une valeur contenue dans " + str(self.typEltInto)) - try : - if issubclass (self.typElt, Accas.ASSD): - if not self.jdc : self.jdc = CONTEXT.getCurrentJdC() - if not(val in self.jdc.sdsDict.keys()) : return (False, 'Concept inexistant') - if not (isinstance(self.jdc.sdsDict[val],self.typElt)) : return (False, 'Concept d un autre type') - a=self.jdc.getSdAvantDuBonType(mc.etape,(self.typElt,)) - if texte not in self.jdc.getSdAvantDuBonType(mc.etape,(self.typElt,)) : - return (False, 'Le concept doit etre defini avant') - except : - pass - return ( True, "") - - def convertItem(self,texte): - if self.typElt == 'R' : val=float(str(texte)) - if self.typElt == 'I' : val=int(str(texte)) - try : - if issubclass (self.typElt, Accas.ASSD): return self.jdc.sdsDict[texte] - except : - pass + def verifItem(self, texte, mc): + val = "" + if self.typElt == "R": + try: + val = float(str(texte)) + ok = True + except: + return (False, "Entrer un float SVP") + if self.typElt == "I": + try: + val = int(str(texte)) + ok = True + except: + return (False, "Entrer un float SVP") + if self.typElt in ("R", "I") and self.valSup != None: + if val > self.valSup: + return (False, "Entrer un nombre inferieur a " + repr(self.valSup)) + if self.typElt in ("R", "I") and self.valMin != None: + if val < self.valMin: + return (False, "Entrer un nombre superieur a " + repr(self.valMin)) + if val == "": + val = texte + if self.typEltInto != None and val not in self.typEltInto: + return "Entrer une valeur contenue dans " + str(self.typEltInto) + try: + if issubclass(self.typElt, Accas.ASSD): + if not self.jdc: + self.jdc = CONTEXT.getCurrentJdC() + if not (val in self.jdc.sdsDict.keys()): + return (False, "Concept inexistant") + if not (isinstance(self.jdc.sdsDict[val], self.typElt)): + return (False, "Concept d un autre type") + a = self.jdc.getSdAvantDuBonType(mc.etape, (self.typElt,)) + if texte not in self.jdc.getSdAvantDuBonType(mc.etape, (self.typElt,)): + return (False, "Le concept doit etre defini avant") + except: + pass + return (True, "") + def convertItem(self, texte): + if self.typElt == "R": + val = float(str(texte)) + if self.typElt == "I": + val = int(str(texte)) + try: + if issubclass(self.typElt, Accas.ASSD): + return self.jdc.sdsDict[texte] + except: + pass def info(self): return "Matrice %s x %s" % (self.nbLigs, self.nbCols) @@ -87,5 +116,6 @@ class N_Matrice: __repr__ = info __str__ = info + class N_Matrice_Correlation(N_Matrice): pass diff --git a/Noyau/N_UserASSD.py b/Noyau/N_UserASSD.py index 7f8a0f2f..b0bea231 100644 --- a/Noyau/N_UserASSD.py +++ b/Noyau/N_UserASSD.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -21,144 +21,155 @@ """ -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import object -except : pass + +from builtins import object import traceback import sys from .N_ASSD import ASSD from Ihm import CONNECTOR + class UserASSD(ASSD): """ - Classe de base pour definir des types de structures de donnees definie par - l utilisateur - equivalent d un concept ASSD pour un SIMP ou un FACT - Attention : le parent est a None au debut et non le MC createur que l on ne connait pas - Lorsqu on ecrit le jdc, n ecrit nom=UserASSD() - le parent est le SIMP qui cree l objet - a la lecture si la classe commence par un majuscule on fait le boulot dans MCSIMP, sinon dans - l init de parametre car le parsing considere qu on a un parametre + Classe de base pour definir des types de structures de donnees definie par + l utilisateur + equivalent d un concept ASSD pour un SIMP ou un FACT + Attention : le parent est a None au debut et non le MC createur que l on ne connait pas + Lorsqu on ecrit le jdc, n ecrit nom=UserASSD() + le parent est le SIMP qui cree l objet + a la lecture si la classe commence par un majuscule on fait le boulot dans MCSIMP, sinon dans + l init de parametre car le parsing considere qu on a un parametre """ - def __init__(self,nom='sansNom'): - #print ('dans init de UserASSD pour ', nom, type(nom)) + def __init__(self, nom="sansNom"): + # print ('dans init de UserASSD pour ', nom, type(nom)) self.nom = nom self.jdc = CONTEXT.getCurrentJdC() self.parent = None self.initialiseValeur() self.utilisePar = set() - if self.nom != 'sansNom' : self.id = self.jdc.regSD(self) - if self.nom != 'sansNom' : self.initialiseNom(nom) - else : self.id = None - self.ptr_sdj = None - + if self.nom != "sansNom": + self.id = self.jdc.regSD(self) + if self.nom != "sansNom": + self.initialiseNom(nom) + else: + self.id = None + self.ptr_sdj = None def initialiseParent(self, parent): - # attention parent.parent peut être un bloc - #print ('je passe initialiseParent pour : ', self, parent.nom) + # attention parent.parent peut être un bloc + # print ('je passe initialiseParent pour : ', self, parent.nom) self.parent = parent self.etape = self.parent.getEtape() self.etape.userASSDCrees.append(self) - if self.parent.parent != self.etape : - if self.parent.parent.estIdentifiePar != None : - print ('il y a un souci dans l initialisation de l identifiant pour', self.parent.parent.nom) - print (self.parent.nom) - print (self.nom) + if self.parent.parent != self.etape: + if self.parent.parent.estIdentifiePar != None: + print( + "il y a un souci dans l initialisation de l identifiant pour", + self.parent.parent.nom, + ) + print(self.parent.nom) + print(self.nom) self.parent.parent.estIdentifiePar = self - def initialiseNom(self,nom): - #print ('je passe initialiseNom pour : ', self, nom, type(nom)) - for (i,j) in list(self.jdc.sdsDict.items()) : - if j == self : - del(self.jdc.sdsDict[i]) - self.jdc.sdsDict[nom]=self - self.nom=nom - if self.nom != 'sansNom' and self.id ==None : self.id = self.jdc.regSD(self) + def initialiseNom(self, nom): + # print ('je passe initialiseNom pour : ', self, nom, type(nom)) + for i, j in list(self.jdc.sdsDict.items()): + if j == self: + del self.jdc.sdsDict[i] + self.jdc.sdsDict[nom] = self + self.nom = nom + if self.nom != "sansNom" and self.id == None: + self.id = self.jdc.regSD(self) - def initialiseValeur(self,valeur=None): - self.valeur=valeur + def initialiseValeur(self, valeur=None): + self.valeur = valeur - def ajoutUtilisePar(self,mc): - #print ('je passe ajoutUtilisePar pour : ', self.nom) + def ajoutUtilisePar(self, mc): + # print ('je passe ajoutUtilisePar pour : ', self.nom) self.utilisePar.add(mc) - def enleveUtilisePar(self,mc): - try : self.utilisePar.remove(mc) - except : pass + def enleveUtilisePar(self, mc): + try: + self.utilisePar.remove(mc) + except: + pass - def renomme(self,nouveauNom): - print ('je passe dans renomme') + def renomme(self, nouveauNom): + print("je passe dans renomme") self.jdc.delConcept(self.nom) self.jdc.sdsDict[nouveauNom] = self self.setName(nouveauNom) - #print ('je suis dans renomme',nouveauNom, self.nom) - #print (self.utilisePar) - for mc in (self.utilisePar): + # print ('je suis dans renomme',nouveauNom, self.nom) + # print (self.utilisePar) + for mc in self.utilisePar: mc.demandeRedessine() - def transfere (self,obj): - # uniquement utise pour les lectures XML - self.utilisePar=obj.utilisePar - self.id=obj.id - for mc in self.utilisePar: mc.valeur=self + def transfere(self, obj): + # uniquement utise pour les lectures XML + self.utilisePar = obj.utilisePar + self.id = obj.id + for mc in self.utilisePar: + mc.valeur = self def deleteReference(self, mcCreateur=None): - print ('je passe dans supprime de N_UserASSDMultiple') - # meme signature que UserASSDMultiple - for MC in self.utilisePar : + print("je passe dans supprime de N_UserASSDMultiple") + # meme signature que UserASSDMultiple + for MC in self.utilisePar: # le delete est appele en cascade par toute la hierachie # du mcsimp (au cas ou on detruise le fact ou le proc) # du coup pas beau - try : - if type(MC.valeur) in (list,tuple): - MC.valeur=list(MC.valeur) - while self in MC.valeur: MC.valeur.remove(self) - if MC.valeur == [] : MC.Valeur = None - else : MC.valeur=None - MC.state='changed' + try: + if type(MC.valeur) in (list, tuple): + MC.valeur = list(MC.valeur) + while self in MC.valeur: + MC.valeur.remove(self) + if MC.valeur == []: + MC.Valeur = None + else: + MC.valeur = None + MC.state = "changed" MC.isValid() - CONNECTOR.Emit(MC,"valid") - except : pass + CONNECTOR.Emit(MC, "valid") + except: + pass # on peut avoir des listes qui contiennent plusieurs fois la meme valeur self.jdc.delConcept(self.nom) - def executeExpression(self, condition, dico) : - #if self.nom == 'shape1' : print ('je suis dans executeExpression ', self.nom, ' ', condition) + def executeExpression(self, condition, dico): + # if self.nom == 'shape1' : print ('je suis dans executeExpression ', self.nom, ' ', condition) dict = locals() dict.update(dico) - #if self.nom == 'shape1' or self.nom == 'G1' : print (dict) - #if self.nom == 'shape1' : + # if self.nom == 'shape1' or self.nom == 'G1' : print (dict) + # if self.nom == 'shape1' : # print (self.getParentsWithId().getListeUserASSD("systemGeometryId")) # print (self.getParentsWithId().getListeUserASSD("SystemGeometryId")) # test = eval(condition, globals(), dict) # print ('-------------------------------------------------------------------------') - try : + try: test = eval(condition, globals(), dict) - except : - print ('executeExpression ', self.nom, ' ', condition , 'exception') + except: + print("executeExpression ", self.nom, " ", condition, "exception") test = 0 return test def getEficasAttribut(self, attribut): - #print ('je suis dans getEficasAttr', attribut) - if self.parent == None : return None - #print ('apres if') + # print ('je suis dans getEficasAttr', attribut) + if self.parent == None: + return None + # print ('apres if') # parent est le SIMP donc c est bien parent.parent - try : + try: valeur = self.parent.parent.getMocle(attribut) - except : + except: valeur = None - #print (valeur) + # print (valeur) return valeur - def supprime(self, mcCreateur=None): - # mcCreateur utile pour N_UserASSDMultiple - print ('je passe dans supprime de N_UserASSDMultiple') + # mcCreateur utile pour N_UserASSDMultiple + print("je passe dans supprime de N_UserASSDMultiple") self.deleteReference(mcCreateur) def __repr__(self): @@ -166,4 +177,3 @@ class UserASSD(ASSD): def __str__(self): return self.getName() or "" - diff --git a/Noyau/N_UserASSDMultiple.py b/Noyau/N_UserASSDMultiple.py index d2dc5603..615e9309 100644 --- a/Noyau/N_UserASSDMultiple.py +++ b/Noyau/N_UserASSDMultiple.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -18,14 +18,9 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com """ - """ -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import object -except : pass +from builtins import object import traceback import sys @@ -33,92 +28,99 @@ from .N_UserASSD import UserASSD from .N_ASSD import ASSD from collections import UserList + + class UserASSDMultiple(UserASSD): """ - Classe de base pour definir des types de structures de donnees definie par - l utilisateur - equivalent d un concept ASSD pour un SIMP ou un FACT - mais pouvant referencer 2 objets par exemple les groupes de mailles qui peuvent porter - le meme nom dans 2 maillages differents + Classe de base pour definir des types de structures de donnees definie par + l utilisateur + equivalent d un concept ASSD pour un SIMP ou un FACT + mais pouvant referencer 2 objets par exemple les groupes de mailles qui peuvent porter + le meme nom dans 2 maillages differents """ - def __init__(self,nom='sansNom'): - #print ('dans init de UserASSDMultiple ',nom) - UserASSD.__init__(self,nom) - self.peres=[] - - def ajouteUnPere(self,pere): - #print ('dans ajouteUnPere', self.peres, self.nom, pere) - if pere not in self.peres : self.peres.append(pere) + + def __init__(self, nom="sansNom"): + # print ('dans init de UserASSDMultiple ',nom) + UserASSD.__init__(self, nom) + self.peres = [] + + def ajouteUnPere(self, pere): + # print ('dans ajouteUnPere', self.peres, self.nom, pere) + if pere not in self.peres: + self.peres.append(pere) etape = pere.getEtape() - if self not in etape.userASSDCrees : etape.userASSDCrees.append(self) + if self not in etape.userASSDCrees: + etape.userASSDCrees.append(self) - def renomme(self,nouveauNom): - print ('je passe dans renomme') - #import traceback - #traceback.print_stack() + def renomme(self, nouveauNom): + print("je passe dans renomme") + # import traceback + # traceback.print_stack() self.jdc.delConcept(self.nom) self.jdc.sdsDict[nouveauNom] = self self.setName(nouveauNom) - for mc in (self.utilisePar): + for mc in self.utilisePar: mc.demandeRedessine() - def initialiseParent(self, pere): # surcharge N_UserASSD parent ici n a pas de sens pass - def deleteReference(self,mcCreateur): - print ('je passe dans deleteReference', mcCreateur.nom) - if not(mcCreateur in self.peres) : return + def deleteReference(self, mcCreateur): + print("je passe dans deleteReference", mcCreateur.nom) + if not (mcCreateur in self.peres): + return self.peres.pop(self.peres.index(mcCreateur)) - if len(self.peres)==0 : + if len(self.peres) == 0: UserASSD.deleteReference(self) - def getParentsWithId(self): - #print ('je suis dans getParentsWithId ') - listeRetour= listUserASSD() - for pere in self.peres : + # print ('je suis dans getParentsWithId ') + listeRetour = listUserASSD() + for pere in self.peres: pereWithId = pere.parent monEtape = pere.getEtape() - while (pereWithId) : - if pereWithId==monEtape : + while pereWithId: + if pereWithId == monEtape: listeRetour.append(pereWithId) break - if pereWithId.estIdentifiePar != None : + if pereWithId.estIdentifiePar != None: listeRetour.append(pereWithId) break - pereWithId=pereWithId.parent + pereWithId = pereWithId.parent return listeRetour def getEtapes(self): - listeRetour= listUserASSD() - for pere in self.peres : - if pere.etape not in listeRetour : listeRetour.append(pere.etape) + listeRetour = listUserASSD() + for pere in self.peres: + if pere.etape not in listeRetour: + listeRetour.append(pere.etape) return listeRetour class listUserASSD(UserList): - - def getListeMotsCles(self,nomMc): - if self.data == None : return [] - listeRetour=[] + def getListeMotsCles(self, nomMc): + if self.data == None: + return [] + listeRetour = [] for concept in self.data: listeRetour.append(concept.getChild(nomMc).val) return listeRetour - def getListeNomsUserASSD(self,nomMc): - if self.data == None : return [] - listeRetour=[] + def getListeNomsUserASSD(self, nomMc): + if self.data == None: + return [] + listeRetour = [] for concept in self.data: listeRetour.append(concept.getChild(nomMc).val.nom) return listeRetour - def getListeUserASSD(self,nomMc): - if self.data == None : return [] - listeRetour=[] + def getListeUserASSD(self, nomMc): + if self.data == None: + return [] + listeRetour = [] for concept in self.data: - if concept.getChild(nomMc) : - if concept.getChild(nomMc).val : + if concept.getChild(nomMc): + if concept.getChild(nomMc).val: listeRetour.append(concept.getChild(nomMc).val) return listeRetour diff --git a/Noyau/N_VALIDATOR.py b/Noyau/N_VALIDATOR.py index 6eb770ea..4f3260d4 100644 --- a/Noyau/N_VALIDATOR.py +++ b/Noyau/N_VALIDATOR.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -24,12 +24,9 @@ Ce module contient toutes les classes necessaires pour implanter le concept de validateur dans Accas """ -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import str - from builtins import object -except : pass + + +from builtins import object import types import traceback @@ -40,7 +37,6 @@ from Accas import A_TUPLE from Extensions.i18n import tr - class ValError(Exception): pass @@ -55,19 +51,18 @@ def cls_mro(cls): class Protocol(object): - def __init__(self, name): self.registry = {} self.name = name self.args = {} def register(self, T, A): - print ('register Protocol',T,A) + print("register Protocol", T, A) self.registry[T] = A def adapt(self, obj): # (a) verifier si l'objet peut s'adapter au protocole - adapt = getattr(obj, '__adapt__', None) + adapt = getattr(obj, "__adapt__", None) if adapt is not None: # on demande à l'objet obj de réaliser lui-meme l'adaptation return adapt(self) @@ -82,13 +77,13 @@ class Protocol(object): return self.default(obj, **self.args) def default(self, obj, **args): - raise TypeError("Can't adapt %s to %s" % - (obj.__class__.__name__, self.name)) + raise TypeError("Can't adapt %s to %s" % (obj.__class__.__name__, self.name)) class PProtocol(Protocol): """Verificateur de protocole paramétré (classe de base)""" + # Protocole paramétré. Le registre est unique pour toutes les instances. # La methode register est une methode de classe registry = {} @@ -99,6 +94,7 @@ class PProtocol(Protocol): def register(cls, T, A): cls.registry[T] = A + register = classmethod(register) @@ -108,7 +104,7 @@ class ListProtocol(Protocol): def default(self, obj): if type(obj) is tuple: - if len(obj) > 0 and obj[0] in ('RI', 'MP'): + if len(obj) > 0 and obj[0] in ("RI", "MP"): # il s'agit d'un complexe ancienne mode. La cardinalite vaut 1 return (obj,) else: @@ -130,12 +126,14 @@ class ListProtocol(Protocol): # sinon elle vaut 1 return (obj,) + listProto = ListProtocol("list") class TypeProtocol(PProtocol): """Verificateur de type parmi une liste de types possibles""" + # pas de registre par instance. Registre unique pour toutes les instances # de TypeProtocol registry = {} @@ -147,80 +145,106 @@ class TypeProtocol(PProtocol): def default(self, obj, typ): err = "" for type_permis in typ: - if type_permis == 'createObject': continue - if type_permis == 'R': + if type_permis == "createObject": + continue + if type_permis == "R": if isFloat_or_int(obj): return obj - elif type_permis == 'I': + elif type_permis == "I": if isInt(obj): return obj - elif type_permis == 'C': + elif type_permis == "C": if self.isComplexe(obj): return obj - elif type_permis == 'TXM': + elif type_permis == "TXM": if isStr(obj): return obj - elif type_permis == 'shell': + elif type_permis == "date": + from datetime import datetime + + try: + d = datetime.strptime(obj, "%Y-%m-%d") + return obj + except: + raise ValError("%s n'est pas une date valide" % repr(obj)) + elif type_permis == "shell": if isStr(obj): return obj - elif type_permis == 'Fichier': + elif type_permis == "Fichier": import os - try : + + try: if (len(typ) > 2 and typ[2] == "Sauvegarde") or os.path.isfile(obj): return obj else: - raise ValError( "%s n'est pas un fichier valide" % repr(obj)) - except : - raise ValError( "%s n'est pas un fichier valide" % repr(obj)) + raise ValError("%s n'est pas un fichier valide" % repr(obj)) + except: + raise ValError("%s n'est pas un fichier valide" % repr(obj)) - elif type_permis == 'FichierNoAbs': + elif type_permis == "FichierNoAbs": import os - if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance(obj, type("")): + + if (len(typ) > 2 and typ[2] == "Sauvegarde") or isinstance( + obj, type("") + ): return obj else: - raise ValError( "%s n'est pas un fichier valide" % repr(obj)) + raise ValError("%s n'est pas un fichier valide" % repr(obj)) - elif type_permis == 'Repertoire': + elif type_permis == "Repertoire": import os - try : - if os.path.isdir(obj): return obj - else: raise ValError( "%s n'est pas un repertoire valide" % repr(obj)) - except : - raise ValError( "%s n'est pas un repertoire valide" % repr(obj)) - elif type_permis == 'FichierOuRepertoire': + + try: + if os.path.isdir(obj): + return obj + else: + raise ValError("%s n'est pas un repertoire valide" % repr(obj)) + except: + raise ValError("%s n'est pas un repertoire valide" % repr(obj)) + elif type_permis == "FichierOuRepertoire": import os - try : - if os.path.isdir(obj) or os.path.isfile(obj): return obj - else: raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj)) - except : - raise ValError( "%s n'est pas un fichier ou un repertoire valide" % repr(obj)) + + try: + if os.path.isdir(obj) or os.path.isfile(obj): + return obj + else: + raise ValError( + "%s n'est pas un fichier ou un repertoire valide" + % repr(obj) + ) + except: + raise ValError( + "%s n'est pas un fichier ou un repertoire valide" % repr(obj) + ) elif type(type_permis) == type or isinstance(type_permis, type): try: if self.isObjectFrom(obj, type_permis): return obj except Exception as err: pass - elif isinstance(type_permis, A_TUPLE.Tuple): + elif isinstance(type_permis, A_TUPLE.Tuple): try: if type_permis.__convert__(obj): return obj except Exception as err: pass - elif isinstance(type_permis, object): + elif isinstance(type_permis, object): try: if type_permis.__convert__(obj): return obj except Exception as err: pass else: - print(("Type non encore gere %s" %type_permis)) + print(("Type non encore gere %s" % type_permis)) raise ValError( - tr("%s (de type %s) n'est pas d'un type autorise: %s ") % (repr(obj), type(obj), typ)) - #import traceback; traceback.print_stack() - #print (object, type_permis,) + tr("%s (de type %s) n'est pas d'un type autorise: %s ") + % (repr(obj), type(obj), typ) + ) + # import traceback; traceback.print_stack() + # print (object, type_permis,) def isComplexe(self, valeur): - """ Retourne 1 si valeur est un complexe, 0 sinon """ + """Retourne 1 si valeur est un complexe, 0 sinon""" if isNumber(valeur): # Pour permettre l'utilisation de complexes Python (accepte les # entiers et réels) @@ -233,7 +257,7 @@ class TypeProtocol(PProtocol): else: # Un complexe doit etre un tuple de longueur 3 avec 'RI' ou 'MP' comme premiere # valeur suivie de 2 reels. - if valeur[0].strip() in ('RI', 'MP'): + if valeur[0].strip() in ("RI", "MP"): try: v1 = reelProto.adapt(valeur[1]), reelProto.adapt(valeur[2]) return 1 @@ -244,9 +268,9 @@ class TypeProtocol(PProtocol): def isObjectFrom(self, objet, classe): """ - Retourne 1 si objet est une instance de la classe classe, 0 sinon + Retourne 1 si objet est une instance de la classe classe, 0 sinon """ - convert = getattr(classe, '__convert__', None) + convert = getattr(classe, "__convert__", None) if convert is not None: # classe verifie les valeurs try: @@ -259,12 +283,14 @@ class TypeProtocol(PProtocol): # On accepte les instances de la classe et des classes derivees return isinstance(objet, classe) -reelProto = TypeProtocol("reel", typ=('R',)) + +reelProto = TypeProtocol("reel", typ=("R",)) class CardProtocol(PProtocol): - """Verificateur de cardinalité """ + """Verificateur de cardinalité""" + # pas de registre par instance. Registre unique pour toutes les instances registry = {} @@ -273,44 +299,51 @@ class CardProtocol(PProtocol): def default(self, obj, min, max): length = len(obj) - if (length < min) or( length > max): + if (length < min) or (length > max): raise ValError( - "Nombre d'arguments de %s incorrect (min = %s, max = %s)" % (repr(obj), min, max)) + "Nombre d'arguments de %s incorrect (min = %s, max = %s)" + % (repr(obj), min, max) + ) return obj class IntoProtocol(PProtocol): """Verificateur de choix possibles : liste discrète ou intervalle""" + # pas de registre par instance. Registre unique pour toutes les instances registry = {} - def __init__(self, name, into=None, val_min=float('-inf'), val_max=float('inf')): - - PProtocol.__init__( - self, name, into=into, val_min=val_min, val_max=val_max) + def __init__(self, name, into=None, val_min=float("-inf"), val_max=float("inf")): + PProtocol.__init__(self, name, into=into, val_min=val_min, val_max=val_max) self.val_min = val_min self.val_max = val_max def default(self, obj, into, val_min, val_max): - if type(into) ==types.FunctionType : - maListeDeValeur=into() - into=maListeDeValeur + if type(into) == types.FunctionType: + maListeDeValeur = into() + into = maListeDeValeur if into: if obj not in into: raise ValError( - tr("La valeur : %s ne fait pas partie des choix possibles %s") % (repr(obj), into)) + tr("La valeur : %s ne fait pas partie des choix possibles %s") + % (repr(obj), into) + ) else: # on est dans le cas d'un ensemble continu de valeurs possibles # (intervalle) if isFloat_or_int(obj): - if val_min == '**': + if val_min == "**": val_min = obj - 1 - if val_max == '**': + if val_max == "**": val_max = obj + 1 if obj < val_min or obj > val_max: raise ValError( - tr("La valeur : %s est en dehors du domaine de validite [ %s , %s ]") %(repr(obj), self.val_min, self.val_max)) + tr( + "La valeur : %s est en dehors du domaine de validite [ %s , %s ]" + ) + % (repr(obj), self.val_min, self.val_max) + ) return obj @@ -324,9 +357,12 @@ class MinStr(object): self.max = max def __convert__(self, valeur): - if isStr(valeur) and self.min <= len(valeur) <= self.max: return valeur + if isStr(valeur) and self.min <= len(valeur) <= self.max: + return valeur raise ValError( - "%s n'est pas une chaine de longueur comprise entre %s et %s" % (valeur, self.min, self.max)) + "%s n'est pas une chaine de longueur comprise entre %s et %s" + % (valeur, self.min, self.max) + ) def __repr__(self): return tr("TXM de longueur entre %s et %s" % (self.min, self.max)) @@ -335,14 +371,15 @@ class MinStr(object): class Valid(PProtocol): """ - Cette classe est la classe mere des validateurs Accas - Elle doit etre derivee - Elle presente la signature des methodes indispensables pour son bon - fonctionnement et dans certains cas leur comportement par défaut. + Cette classe est la classe mere des validateurs Accas + Elle doit etre derivee + Elle presente la signature des methodes indispensables pour son bon + fonctionnement et dans certains cas leur comportement par défaut. - @ivar cata_info: raison de la validite ou de l'invalidite du validateur meme - @type cata_info: C{} + @ivar cata_info: raison de la validite ou de l'invalidite du validateur meme + @type cata_info: C{} """ + registry = {} def __init__(self, **args): @@ -350,130 +387,130 @@ class Valid(PProtocol): def info(self): """ - Cette methode retourne une chaine de caractères informative sur - la validation demandée par le validateur. Elle est utilisée - pour produire le compte-rendu de validité du mot clé associé. + Cette methode retourne une chaine de caractères informative sur + la validation demandée par le validateur. Elle est utilisée + pour produire le compte-rendu de validité du mot clé associé. """ return "valeur valide" def aide(self): """ - Cette methode retourne une chaine de caractère qui permet - de construire un message d'aide en ligne. - En général, le message retourné est le meme que celui retourné par la - méthode info. + Cette methode retourne une chaine de caractère qui permet + de construire un message d'aide en ligne. + En général, le message retourné est le meme que celui retourné par la + méthode info. """ return self.info() def infoErreurItem(self): """ - Cette méthode permet d'avoir un message d'erreur pour un item - dans une liste dans le cas ou le validateur fait des vérifications - sur les items d'une liste. Si le validateur fait seulement des - vérifications sur la liste elle meme et non sur ses items, la méthode - doit retourner une chaine vide. + Cette méthode permet d'avoir un message d'erreur pour un item + dans une liste dans le cas ou le validateur fait des vérifications + sur les items d'une liste. Si le validateur fait seulement des + vérifications sur la liste elle meme et non sur ses items, la méthode + doit retourner une chaine vide. """ return " " def infoErreurListe(self): """ - Cette méthode a un comportement complémentaire de celui de - infoErreurItem. Elle retourne un message d'erreur lié uniquement - aux vérifications sur la liste elle meme et pas sur ses items. - Dans le cas où le validateur ne fait pas de vérification sur des - listes, elle retourne une chaine vide + Cette méthode a un comportement complémentaire de celui de + infoErreurItem. Elle retourne un message d'erreur lié uniquement + aux vérifications sur la liste elle meme et pas sur ses items. + Dans le cas où le validateur ne fait pas de vérification sur des + listes, elle retourne une chaine vide """ return " " def verif(self, valeur): """ - Cette methode sert a verifier si la valeur passee en argument est consideree - comme valide ou non par le validateur. Dans le premier cas le validateur retourne 1 - (valide) sinon 0 (invalide). - - @type valeur: tout type python - @param valeur: valeur du mot cle a valider - @rtype: C{boolean} - @return: indicateur de validite 1 (valide) ou 0 (invalide) + Cette methode sert a verifier si la valeur passee en argument est consideree + comme valide ou non par le validateur. Dans le premier cas le validateur retourne 1 + (valide) sinon 0 (invalide). + + @type valeur: tout type python + @param valeur: valeur du mot cle a valider + @rtype: C{boolean} + @return: indicateur de validite 1 (valide) ou 0 (invalide) """ raise NotImplementedError("Must be implemented") def verifItem(self, valeur): """ - La methode verif du validateur effectue une validation complete de - la valeur. valeur peut etre un scalaire ou une liste. Le validateur - doit traiter les 2 aspects s'il accepte des listes (dans ce cas la - methode isList doit retourner 1). - La methode valid_item sert pour effectuer des validations partielles - de liste. Elle doit uniquement verifier la validite d'un item de - liste mais pas les caracteristiques de la liste. + La methode verif du validateur effectue une validation complete de + la valeur. valeur peut etre un scalaire ou une liste. Le validateur + doit traiter les 2 aspects s'il accepte des listes (dans ce cas la + methode isList doit retourner 1). + La methode valid_item sert pour effectuer des validations partielles + de liste. Elle doit uniquement verifier la validite d'un item de + liste mais pas les caracteristiques de la liste. """ return 0 def valideListePartielle(self, liste_courante): """ - Cette methode retourne un entier qui indique si liste_courante est partiellement valide (valeur 1) - ou invalide (valeur 0). La validation partielle concerne les listes en cours de construction : on - veut savoir si la liste en construction peut etre complétée ou si elle peut déjà etre considérée - comme invalide. - En général un validateur effectue la meme validation pour les listes partielles et les - listes complètes. + Cette methode retourne un entier qui indique si liste_courante est partiellement valide (valeur 1) + ou invalide (valeur 0). La validation partielle concerne les listes en cours de construction : on + veut savoir si la liste en construction peut etre complétée ou si elle peut déjà etre considérée + comme invalide. + En général un validateur effectue la meme validation pour les listes partielles et les + listes complètes. """ return self.verif(liste_courante) def verifCata(self): """ - Cette methode sert a realiser des verifications du validateur lui meme. - Elle est facultative et retourne 1 (valide) par defaut. - Elle retourne 0 si le validateur est lui meme invalide si par exemple ses - parametres de definition ne sont pas corrects. - La raison de l'invalidite est stockee dans l'attribut cata_info. - - @rtype: C{boolean} - @return: indicateur de validite 1 (valide) ou 0 (invalide) + Cette methode sert a realiser des verifications du validateur lui meme. + Elle est facultative et retourne 1 (valide) par defaut. + Elle retourne 0 si le validateur est lui meme invalide si par exemple ses + parametres de definition ne sont pas corrects. + La raison de l'invalidite est stockee dans l'attribut cata_info. + + @rtype: C{boolean} + @return: indicateur de validite 1 (valide) ou 0 (invalide) """ return 1 def isList(self): """ - Cette méthode retourne un entier qui indique si le validateur - permet les listes (valeur 1) ou ne les permet pas (valeur 0). - Par défaut, un validateur n'autorise que des scalaires. + Cette méthode retourne un entier qui indique si le validateur + permet les listes (valeur 1) ou ne les permet pas (valeur 0). + Par défaut, un validateur n'autorise que des scalaires. """ return 0 def hasInto(self): """ - Cette méthode retourne un entier qui indique si le validateur - propose une liste de choix (valeur 1) ou n'en propose pas. - Par défaut, un validateur n'en propose pas. + Cette méthode retourne un entier qui indique si le validateur + propose une liste de choix (valeur 1) ou n'en propose pas. + Par défaut, un validateur n'en propose pas. """ return 0 def getInto(self, liste_courante=None, into_courant=None): """ - Cette méthode retourne la liste de choix proposée par le validateur. - Si le validateur ne propose pas de liste de choix, la méthode - retourne None. - L'argument d'entrée liste_courante, s'il est différent de None, donne - la liste des choix déjà effectués par l'utilisateur. Dans ce cas, la - méthode getInto doit calculer la liste des choix en en tenant - compte. Par exemple, si le validateur n'autorise pas les répétitions, - la liste des choix retournée ne doit pas contenir les choix déjà - contenus dans liste_courante. - L'argument d'entrée into_courant, s'il est différent de None, donne - la liste des choix proposés par d'autres validateurs. Dans ce cas, - la méthode getInto doit calculer la liste des choix à retourner - en se limitant à cette liste initiale. Par exemple, si into_courant - vaut (1,2,3) et que le validateur propose la liste de choix (3,4,5), - la méthode ne doit retourner que (3,). - - La méthode getInto peut retourner une liste vide [], ce qui veut - dire qu'il n'y a pas (ou plus) de choix possible. Cette situation - peut etre normale : l''utilisateur a utilisé tous les choix, ou - résulter d'une incohérence des validateurs : - choix parmi (1,2,3) ET choix parmi (4,5,6). Il est impossible de - faire la différence entre ces deux situations. + Cette méthode retourne la liste de choix proposée par le validateur. + Si le validateur ne propose pas de liste de choix, la méthode + retourne None. + L'argument d'entrée liste_courante, s'il est différent de None, donne + la liste des choix déjà effectués par l'utilisateur. Dans ce cas, la + méthode getInto doit calculer la liste des choix en en tenant + compte. Par exemple, si le validateur n'autorise pas les répétitions, + la liste des choix retournée ne doit pas contenir les choix déjà + contenus dans liste_courante. + L'argument d'entrée into_courant, s'il est différent de None, donne + la liste des choix proposés par d'autres validateurs. Dans ce cas, + la méthode getInto doit calculer la liste des choix à retourner + en se limitant à cette liste initiale. Par exemple, si into_courant + vaut (1,2,3) et que le validateur propose la liste de choix (3,4,5), + la méthode ne doit retourner que (3,). + + La méthode getInto peut retourner une liste vide [], ce qui veut + dire qu'il n'y a pas (ou plus) de choix possible. Cette situation + peut etre normale : l''utilisateur a utilisé tous les choix, ou + résulter d'une incohérence des validateurs : + choix parmi (1,2,3) ET choix parmi (4,5,6). Il est impossible de + faire la différence entre ces deux situations. """ return into_courant @@ -481,8 +518,8 @@ class Valid(PProtocol): class ListVal(Valid): """ - Cette classe sert de classe mère pour tous les validateurs qui acceptent - des listes. + Cette classe sert de classe mère pour tous les validateurs qui acceptent + des listes. """ def isList(self): @@ -490,9 +527,9 @@ class ListVal(Valid): def getInto(self, liste_courante=None, into_courant=None): """ - Cette méthode getInto effectue un traitement général qui consiste - a filtrer la liste de choix into_courant, si elle existe, en ne - conservant que les valeurs valides (appel de la méthode valid). + Cette méthode getInto effectue un traitement général qui consiste + a filtrer la liste de choix into_courant, si elle existe, en ne + conservant que les valeurs valides (appel de la méthode valid). """ if into_courant is None: return None @@ -505,9 +542,9 @@ class ListVal(Valid): def convert(self, valeur): """ - Méthode convert pour les validateurs de listes. Cette méthode - fait appel à la méthode convertItem sur chaque élément de la - liste. + Méthode convert pour les validateurs de listes. Cette méthode + fait appel à la méthode convertItem sur chaque élément de la + liste. """ if isSequence(valeur): for val in valeur: @@ -518,10 +555,10 @@ class ListVal(Valid): def verif(self, valeur): """ - Méthode verif pour les validateurs de listes. Cette méthode - fait appel à la méthode verifItem sur chaque élément de la - liste. Si valeur est un paramètre, on utilise sa valeur effective - valeur.valeur. + Méthode verif pour les validateurs de listes. Cette méthode + fait appel à la méthode verifItem sur chaque élément de la + liste. Si valeur est un paramètre, on utilise sa valeur effective + valeur.valeur. """ if isSequence(valeur): for val in valeur: @@ -534,9 +571,10 @@ class ListVal(Valid): class Compulsory(ListVal): """ - Validateur operationnel - Verification de la présence obligatoire d'un élément dans une liste + Validateur operationnel + Verification de la présence obligatoire d'un élément dans une liste """ + registry = {} def __init__(self, elem=()): @@ -547,7 +585,7 @@ class Compulsory(ListVal): self.cata_info = "" def info(self): - return (tr(u"valeur %s obligatoire") % self.elem) + return tr("valeur %s obligatoire") % self.elem def default(self, valeur, elem): return valeur @@ -563,7 +601,9 @@ class Compulsory(ListVal): elem.remove(v) if elem: raise ValError( - tr("%s ne contient pas les elements obligatoires : %s ") % (valeur, elem)) + tr("%s ne contient pas les elements obligatoires : %s ") + % (valeur, elem) + ) return valeur def hasInto(self): @@ -585,9 +625,10 @@ class Compulsory(ListVal): class Together(ListVal): """ - Validateur operationnel - si un des éléments est présent les autres doivent aussi l'être + Validateur operationnel + si un des éléments est présent les autres doivent aussi l'être """ + registry = {} def __init__(self, elem=()): @@ -598,7 +639,7 @@ class Together(ListVal): self.cata_info = "" def info(self): - return (tr("%s present ensemble") % self.elem) + return tr("%s present ensemble") % self.elem def default(self, valeur, elem): return valeur @@ -610,10 +651,15 @@ class Together(ListVal): elem = list(self.elem) for val in valeur: v = self.adapt(val) - if v in elem: elem.remove(v) - if ( len(elem) == 0 ): return valeur - if len(elem) != len(list(self.elem)) : - raise ValError(tr("%s ne contient pas les elements devant etre presents ensemble: %s ") %( valeur, elem)) + if v in elem: + elem.remove(v) + if len(elem) == 0: + return valeur + if len(elem) != len(list(self.elem)): + raise ValError( + tr("%s ne contient pas les elements devant etre presents ensemble: %s ") + % (valeur, elem) + ) return valeur def hasInto(self): @@ -626,9 +672,12 @@ class Together(ListVal): liste = valeur compte = 0 for val in self.elem: - if val in liste: compte += 1 - if ( compte == 0 ): return 1 - if ( compte != len( list(self.elem) ) ): return 0 + if val in liste: + compte += 1 + if compte == 0: + return 1 + if compte != len(list(self.elem)): + return 0 return 1 def infoErreurItem(self): @@ -637,9 +686,10 @@ class Together(ListVal): class Absent(ListVal): """ - Validateur operationnel - si un des éléments est présent non valide + Validateur operationnel + si un des éléments est présent non valide """ + registry = {} def __init__(self, elem=()): @@ -650,7 +700,7 @@ class Absent(ListVal): self.cata_info = "" def info(self): - return (tr("%s absent") % self.elem) + return tr("%s absent") % self.elem def default(self, valeur, elem): return valeur @@ -663,7 +713,7 @@ class Absent(ListVal): for val in valeur: v = self.adapt(val) if v in elem: - raise ValError(tr("%s n'est pas autorise : %s ")% (v, elem)) + raise ValError(tr("%s n'est pas autorise : %s ") % (v, elem)) return valeur def hasInto(self): @@ -675,7 +725,8 @@ class Absent(ListVal): else: liste = valeur for val in self.elem: - if val in liste: return 0 + if val in liste: + return 0 return 1 def infoErreurItem(self): @@ -684,9 +735,10 @@ class Absent(ListVal): class NoRepeat(ListVal): """ - Validateur operationnel - Verification d'absence de doublons dans la liste. + Validateur operationnel + Verification d'absence de doublons dans la liste. """ + def __init__(self): Valid.__init__(self) self.cata_info = "" @@ -699,7 +751,7 @@ class NoRepeat(ListVal): def default(self, valeur): if valeur in self.liste: - raise ValError( tr("%s est un doublon") % valeur) + raise ValError(tr("%s est un doublon") % valeur) return valeur def convert(self, valeur): @@ -744,8 +796,8 @@ class NoRepeat(ListVal): class LongStr(ListVal): """ - Validateur operationnel - Verification de la longueur d une chaine + Validateur operationnel + Verification de la longueur d une chaine """ def __init__(self, low, high): @@ -755,7 +807,7 @@ class LongStr(ListVal): self.cata_info = "" def info(self): - return (tr("longueur de la chaine entre %s et %s") %( self.low, self.high)) + return tr("longueur de la chaine entre %s et %s") % (self.low, self.high) def infoErreurItem(self): return tr("Longueur de la chaine incorrecte") @@ -774,21 +826,20 @@ class LongStr(ListVal): def default(self, valeur, low, high): if not isStr(valeur): - raise ValError ("%s n'est pas une chaine" % repr(valeur)) + raise ValError("%s n'est pas une chaine" % repr(valeur)) if valeur[0] == "'" and valeur[-1] == "'": low = low + 2 high = high + 2 if len(valeur) < low or len(valeur) > high: - raise ValError( - "%s n'est pas de la bonne longueur" % repr(valeur)) + raise ValError("%s n'est pas de la bonne longueur" % repr(valeur)) return valeur class OnlyStr(ListVal): """ - Validateur operationnel - Valide que c'est une chaine + Validateur operationnel + Valide que c'est une chaine """ def __init__(self): @@ -815,15 +866,15 @@ class OnlyStr(ListVal): def default(self, valeur): if not isStr(valeur): - raise ValError (tr("%s n'est pas une chaine") % repr(valeur)) + raise ValError(tr("%s n'est pas une chaine") % repr(valeur)) return valeur class OrdList(ListVal): """ - Validateur operationnel - Verification qu'une liste est croissante ou decroissante + Validateur operationnel + Verification qu'une liste est croissante ou decroissante """ def __init__(self, ord): @@ -832,10 +883,10 @@ class OrdList(ListVal): self.cata_info = "" def info(self): - return ("liste %s" % self.ord) + return "liste %s" % self.ord def infoErreurListe(self): - return (tr("La liste doit etre en ordre %s") % self.ord) + return tr("La liste doit etre en ordre %s") % self.ord def convert(self, valeur): self.val = None @@ -845,14 +896,16 @@ class OrdList(ListVal): return valeur def default(self, valeur, ord): - if self.ord == 'croissant': + if self.ord == "croissant": if self.val is not None and valeur < self.val: raise ValError( - (tr("%s n'est pas par valeurs croissantes") % repr(self.liste))) - elif self.ord == 'decroissant': + (tr("%s n'est pas par valeurs croissantes") % repr(self.liste)) + ) + elif self.ord == "decroissant": if self.val is not None and valeur > self.val: raise ValError( - (tr("%s n'est pas par valeurs decroissantes") % repr(self.liste))) + (tr("%s n'est pas par valeurs decroissantes") % repr(self.liste)) + ) self.val = valeur return valeur @@ -874,9 +927,9 @@ class OrdList(ListVal): liste_choix = [] last_val = liste_choix[-1] for e in into_courant: - if self.ord == 'croissant' and e <= last_val: + if self.ord == "croissant" and e <= last_val: continue - if self.ord == 'decroissant' and e >= last_val: + if self.ord == "decroissant" and e >= last_val: continue liste_choix.append(e) return liste_choix @@ -885,9 +938,9 @@ class OrdList(ListVal): class OrVal(Valid): """ - Validateur operationnel - Cette classe est un validateur qui controle une liste de validateurs - Elle verifie qu'au moins un des validateurs de la liste valide la valeur + Validateur operationnel + Cette classe est un validateur qui controle une liste de validateurs + Elle verifie qu'au moins un des validateurs de la liste valide la valeur """ def __init__(self, validators=()): @@ -910,7 +963,7 @@ class OrVal(Valid): return validator.convert(valeur) except: pass - raise ValError(tr("%s n'est pas du bon type")% repr(valeur)) + raise ValError(tr("%s n'est pas du bon type") % repr(valeur)) def infoErreurItem(self): l = [] @@ -932,9 +985,9 @@ class OrVal(Valid): def isList(self): """ - Si plusieurs validateurs sont reliés par un OU - il suffit qu'un seul des validateurs attende une liste - pour qu'on considère que leur union attend une liste. + Si plusieurs validateurs sont reliés par un OU + il suffit qu'un seul des validateurs attende une liste + pour qu'on considère que leur union attend une liste. """ for validator in self.validators: v = validator.isList() @@ -1002,9 +1055,9 @@ class OrVal(Valid): def valideListePartielle(self, liste_courante=None): """ - Méthode de validation de liste partielle pour le validateur Or. - Si un des validateurs gérés par le validateur Or considère la - liste comme valide, le validateur Or la considère comme valide. + Méthode de validation de liste partielle pour le validateur Or. + Si un des validateurs gérés par le validateur Or considère la + liste comme valide, le validateur Or la considère comme valide. """ for validator in self.validators: v = validator.valideListePartielle(liste_courante) @@ -1016,9 +1069,9 @@ class OrVal(Valid): class AndVal(Valid): """ - Validateur operationnel - Cette classe est un validateur qui controle une liste de validateurs - Elle verifie que tous les validateurs de la liste valident la valeur + Validateur operationnel + Cette classe est un validateur qui controle une liste de validateurs + Elle verifie que tous les validateurs de la liste valident la valeur """ def __init__(self, validators=()): @@ -1030,12 +1083,17 @@ class AndVal(Valid): self.validators.append(FunctionVal(validator)) else: self.validators.append(validator) - if hasattr(validator, 'fonctions'): + if hasattr(validator, "fonctions"): for fonction in validator.fonctions: f = getattr(validator, fonction) setattr(self, fonction, f) self.cata_info = "" + def set_MCSimp(self, MCSimp): + for validator in self.validators: + if hasattr(validator, "set_MCSimp"): + validator.set_MCSimp(MCSimp) + def info(self): return "\n et ".join([v.info() for v in self.validators]) @@ -1057,7 +1115,7 @@ class AndVal(Valid): return chaine def infoErreurListe(self): - chaine="" + chaine = "" a = 1 for v in self.validators: if v.infoErreurListe() != " ": @@ -1099,10 +1157,10 @@ class AndVal(Valid): def valideListePartielle(self, liste_courante=None): """ - Méthode de validation de liste partielle pour le validateur And. - Tous les validateurs gérés par le validateur And doivent considérer - la liste comme valide, pour que le validateur And la considère - comme valide. + Méthode de validation de liste partielle pour le validateur And. + Tous les validateurs gérés par le validateur And doivent considérer + la liste comme valide, pour que le validateur And la considère + comme valide. """ for validator in self.validators: v = validator.valideListePartielle(liste_courante) @@ -1157,8 +1215,8 @@ class AndVal(Valid): def do_liste(validators): """ - Convertit une arborescence de validateurs en OrVal ou AndVal - validators est une liste de validateurs ou de listes ou de tuples + Convertit une arborescence de validateurs en OrVal ou AndVal + validators est une liste de validateurs ou de listes ou de tuples """ valids = [] for validator in validators: @@ -1183,39 +1241,46 @@ def validatorFactory(validator): else: return validator + # Ci-dessous : exemples de validateur (peu testés) class RangeVal(ListVal): """ - Exemple de classe validateur : verification qu'une valeur - est dans un intervalle. - Pour une liste on verifie que tous les elements sont - dans l'intervalle - Susceptible de remplacer les attributs "vale_min" "vale_max" - dans les catalogues + Exemple de classe validateur : verification qu'une valeur + est dans un intervalle. + Pour une liste on verifie que tous les elements sont + dans l'intervalle + Susceptible de remplacer les attributs "vale_min" "vale_max" + dans les catalogues """ def __init__(self, low, high): self.low = low self.high = high - self.cata_info = (tr("%s doit etre inferieur a %s") % (low, high)) + self.cata_info = tr("%s doit etre inferieur a %s") % (low, high) def info(self): - return (tr("valeur dans l'intervalle %s , %s") %( self.low, self.high)) + return tr("valeur dans l'intervalle %s , %s") % (self.low, self.high) def convertItem(self, valeur): if valeur > self.low and valeur < self.high: return valeur - raise ValError(tr("%s devrait etre comprise entre %s et %s") % (valeur, self.low, self.high)) + raise ValError( + tr("%s devrait etre comprise entre %s et %s") + % (valeur, self.low, self.high) + ) def verifItem(self, valeur): return valeur > self.low and valeur < self.high def infoErreurItem(self): - return (tr("la valeur %s doit etre comprise entre %s et %s") % (valeur, self.low, self.high)) - + return tr("la valeur %s doit etre comprise entre %s et %s") % ( + valeur, + self.low, + self.high, + ) def verifCata(self): if self.low > self.high: @@ -1226,33 +1291,36 @@ class RangeVal(ListVal): class CardVal(Valid): """ - Exemple de classe validateur : verification qu'une liste est - d'une longueur superieur a un minimum (min) et inferieure - a un maximum (max). - Susceptible de remplacer les attributs "min" "max" dans les - catalogues + Exemple de classe validateur : verification qu'une liste est + d'une longueur superieur a un minimum (min) et inferieure + a un maximum (max). + Susceptible de remplacer les attributs "min" "max" dans les + catalogues """ - def __init__(self, min=float('-inf'), max=float('inf')): + def __init__(self, min=float("-inf"), max=float("inf")): self.min = min self.max = max - self.cata_info = (tr("%s doit etre inferieur a %s") %(min, max)) + self.cata_info = tr("%s doit etre inferieur a %s") % (min, max) def info(self): - return (tr("longueur de liste comprise entre %s et %s") %(self.min, self.max)) + return tr("longueur de liste comprise entre %s et %s") % (self.min, self.max) def infoErreurListe(self): - return (tr("Le cardinal de la liste doit etre compris entre %s et %s") % (self.min, self.max)) + return tr("Le cardinal de la liste doit etre compris entre %s et %s") % ( + self.min, + self.max, + ) def isList(self): - return self.max == '**' or self.max > 1 + return self.max == "**" or self.max > 1 def getInto(self, liste_courante=None, into_courant=None): if into_courant is None: return None elif liste_courante is None: return into_courant - elif self.max == '**': + elif self.max == "**": return into_courant elif len(liste_courante) < self.max: return into_courant @@ -1266,12 +1334,14 @@ class CardVal(Valid): l = 0 else: l = 1 - if self.max != '**' and l > self.max: + if self.max != "**" and l > self.max: raise ValError( - tr("%s devrait etre de longueur inferieure a %s") % (valeur, self.max)) - if self.min != '**' and l < self.min: + tr("%s devrait etre de longueur inferieure a %s") % (valeur, self.max) + ) + if self.min != "**" and l < self.min: raise ValError( - tr("%s devrait etre de longueur superieure a %s") % (valeur, self.min)) + tr("%s devrait etre de longueur superieure a %s") % (valeur, self.min) + ) return valeur def verifItem(self, valeur): @@ -1279,20 +1349,20 @@ class CardVal(Valid): def verif(self, valeur): if isSequence(valeur): - if self.max != '**' and len(valeur) > self.max: + if self.max != "**" and len(valeur) > self.max: return 0 - if self.min != '**' and len(valeur) < self.min: + if self.min != "**" and len(valeur) < self.min: return 0 return 1 else: - if self.max != '**' and 1 > self.max: + if self.max != "**" and 1 > self.max: return 0 - if self.min != '**' and 1 < self.min: + if self.min != "**" and 1 < self.min: return 0 return 1 def verifCata(self): - if self.min != '**' and self.max != '**' and self.min > self.max: + if self.min != "**" and self.max != "**" and self.min > self.max: return 0 return 1 @@ -1307,10 +1377,10 @@ class CardVal(Valid): class PairVal(ListVal): """ - Exemple de classe validateur : verification qu'une valeur - est paire. - Pour une liste on verifie que tous les elements sont - pairs + Exemple de classe validateur : verification qu'une valeur + est paire. + Pour une liste on verifie que tous les elements sont + pairs """ def __init__(self): @@ -1318,7 +1388,7 @@ class PairVal(ListVal): self.cata_info = "" def info(self): - return _(u"valeur paire") + return _("valeur paire") def infoErreurItem(self): return tr("La valeur saisie doit etre paire") @@ -1327,8 +1397,7 @@ class PairVal(ListVal): for val in valeur: v = self.adapt(val) if v % 2 != 0: - raise ValError( - tr("%s contient des valeurs non paires") % repr(valeur)) + raise ValError(tr("%s contient des valeurs non paires") % repr(valeur)) return valeur def default(self, valeur): @@ -1354,9 +1423,9 @@ class PairVal(ListVal): class EnumVal(ListVal): """ - Exemple de classe validateur : verification qu'une valeur - est prise dans une liste de valeurs. - Susceptible de remplacer l attribut "into" dans les catalogues + Exemple de classe validateur : verification qu'une valeur + est prise dans une liste de valeurs. + Susceptible de remplacer l attribut "into" dans les catalogues """ def __init__(self, into=()): @@ -1366,13 +1435,15 @@ class EnumVal(ListVal): self.cata_info = "" def info(self): - return ("valeur dans %s" % self.into) + return "valeur dans %s" % self.into def convertItem(self, valeur): if valeur in self.into: return valeur raise ValError( - tr("%s contient des valeurs hors des choix possibles: %s ") % (valeur, self.into)) + tr("%s contient des valeurs hors des choix possibles: %s ") + % (valeur, self.into) + ) def verifItem(self, valeur): if valeur not in self.into: @@ -1398,9 +1469,9 @@ class EnumVal(ListVal): def ImpairVal(valeur): """ - Exemple de validateur - Cette fonction est un validateur. Elle verifie que la valeur passee - est bien un nombre impair. + Exemple de validateur + Cette fonction est un validateur. Elle verifie que la valeur passee + est bien un nombre impair. """ if isSequence(valeur): for val in valeur: @@ -1412,16 +1483,17 @@ def ImpairVal(valeur): return 0 return 1 + ImpairVal.info = "valeur impaire" class F1Val(Valid): """ - Exemple de validateur - Cette classe est un validateur de dictionnaire (mot cle facteur ?). Elle verifie - que la somme des cles A et B vaut une valeur donnee - en parametre du validateur + Exemple de validateur + Cette classe est un validateur de dictionnaire (mot cle facteur ?). Elle verifie + que la somme des cles A et B vaut une valeur donnee + en parametre du validateur """ def __init__(self, somme=10): @@ -1429,7 +1501,7 @@ class F1Val(Valid): self.cata_info = "" def info(self): - return (tr("valeur %s pour la somme des cles A et B ") % self.somme) + return tr("valeur %s pour la somme des cles A et B ") % self.somme def verif(self, valeur): if isSequence(valeur): @@ -1454,8 +1526,8 @@ class F1Val(Valid): class FunctionVal(Valid): """ - Exemple de validateur - Cette classe est un validateur qui est initialise avec une fonction + Exemple de validateur + Cette classe est un validateur qui est initialise avec une fonction """ def __init__(self, function): @@ -1476,25 +1548,25 @@ class FunctionVal(Valid): def convert(self, valeur): return valeur + # MC ca ne devrait plus servir ! # PN : commenter le 22.11.19 -#CoercableFuncs = {int: int, +# CoercableFuncs = {int: int, # int: int, # float: float, # complex: complex, # str: six.text_type} - class TypeVal(ListVal): """ - Exemple de validateur - Cette classe est un validateur qui controle qu'une valeur - est bien du type Python attendu. - Pour une liste on verifie que tous les elements sont du bon type. - Semblable a InstanceVal mais ici on fait le test par tentative de conversion - alors qu'avec InstanceVal on ne teste que si isinstance est vrai. + Exemple de validateur + Cette classe est un validateur qui controle qu'une valeur + est bien du type Python attendu. + Pour une liste on verifie que tous les elements sont du bon type. + Semblable a InstanceVal mais ici on fait le test par tentative de conversion + alors qu'avec InstanceVal on ne teste que si isinstance est vrai. """ def __init__(self, aType): @@ -1509,7 +1581,7 @@ class TypeVal(ListVal): self.coerce = self.identity def info(self): - return (tr("valeur de %s") % self.aType) + return tr("valeur de %s") % self.aType def identity(self, value): if type(value) == self.aType: @@ -1530,17 +1602,17 @@ class TypeVal(ListVal): class InstanceVal(ListVal): """ - Exemple de validateur - Cette classe est un validateur qui controle qu'une valeur est - bien une instance (au sens Python) d'une classe - Pour une liste on verifie chaque element de la liste + Exemple de validateur + Cette classe est un validateur qui controle qu'une valeur est + bien une instance (au sens Python) d'une classe + Pour une liste on verifie chaque element de la liste """ def __init__(self, aClass): # Si aClass est une classe on la memorise dans self.aClass # sinon c'est une instance dont on memorise la classe - #if type(aClass) == types.InstanceType: - if type(aClass) == object : + # if type(aClass) == types.InstanceType: + if type(aClass) == object: # instance ancienne mode aClass = aClass.__class__ elif type(aClass) == type: @@ -1558,7 +1630,7 @@ class InstanceVal(ListVal): self.aClass = aClass def info(self): - return (tr("valeur d'instance de %s") % self.aClass.__name__) + return tr("valeur d'instance de %s") % self.aClass.__name__ def verifItem(self, valeur): if not isinstance(valeur, self.aClass): @@ -1567,7 +1639,6 @@ class InstanceVal(ListVal): class VerifTypeTuple(ListVal): - def __init__(self, typeDesTuples): self.typeDesTuples = typeDesTuples Valid.__init__(self) @@ -1588,12 +1659,14 @@ class VerifTypeTuple(ListVal): def convertItem(self, valeur): if len(valeur) != len(self.typeDesTuples): raise ValError( - tr("%s devrait etre de type %s ") %( valeur, self.typeDesTuples)) + tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples) + ) for i in range(len(valeur)): ok = self.verifType(valeur[i], self.typeDesTuples[i]) if ok != 1: raise ValError( - tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples)) + tr("%s devrait etre de type %s ") % (valeur, self.typeDesTuples) + ) return valeur def verifItem(self, valeur): @@ -1609,16 +1682,16 @@ class VerifTypeTuple(ListVal): return 1 def verifType(self, valeur, type_permis): - if type_permis == 'R': + if type_permis == "R": if type(valeur) in (int, float, int): return 1 - elif type_permis == 'I': + elif type_permis == "I": if type(valeur) in (int, int): return 1 - elif type_permis == 'C': + elif type_permis == "C": if self.isComplexe(valeur): return 1 - elif type_permis == 'TXM': + elif type_permis == "TXM": if type(valeur) == bytes or type(valeur) == str: return 1 elif isinstance(valeur, type_permis): @@ -1637,16 +1710,16 @@ class VerifTypeTuple(ListVal): class VerifExiste(ListVal): """ - fonctionne avec into - Met une liste à jour selon les mot clefs existant - exemple si into = ("A","B","C") - si au niveau N du JDC les objets "A" et "C" existe - alors la liste des into deviendra ( "A","C") - - niveauVerif est le niveau du JDC dans lequel va s effectuer la verification - niveauVerif est defini par rapport au Noeud : - exemple niveauVerif = 1 : on verifie les freres - niveauVerif = 2 : on verifie les oncles.. + fonctionne avec into + Met une liste à jour selon les mot clefs existant + exemple si into = ("A","B","C") + si au niveau N du JDC les objets "A" et "C" existe + alors la liste des into deviendra ( "A","C") + + niveauVerif est le niveau du JDC dans lequel va s effectuer la verification + niveauVerif est defini par rapport au Noeud : + exemple niveauVerif = 1 : on verifie les freres + niveauVerif = 2 : on verifie les oncles.. """ def __init__(self, niveauVerif): @@ -1654,7 +1727,7 @@ class VerifExiste(ListVal): self.niveauVerif = niveauVerif self.MCSimp = None self.listeDesFreres = () - self.fonctions = ('verifieListe', 'set_MCSimp') + self.fonctions = ("verifieListe", "set_MCSimp") def isList(self): return 1 @@ -1662,7 +1735,7 @@ class VerifExiste(ListVal): def verifieListe(self, liste): self.set_MCSimp(self.MCSimp) for item in liste: - if not(item in self.listeDesFreres): + if not (item in self.listeDesFreres): return 0 return 1 @@ -1676,7 +1749,7 @@ class VerifExiste(ListVal): self.MCSimp = MCSimp k = self.niveauVerif mc = MCSimp - while (k != 0): + while k != 0: parent = mc.parent mc = parent k = k - 1 @@ -1687,8 +1760,7 @@ class VerifExiste(ListVal): def convertItem(self, valeur): if valeur in self.listeDesFreres: return valeur - raise ValError( - tr("%s n'est pas dans %s") % (valeur, self.listeDesFreres)) + raise ValError(tr("%s n'est pas dans %s") % (valeur, self.listeDesFreres)) class RegExpVal(ListVal): @@ -1704,10 +1776,18 @@ class RegExpVal(ListVal): self.compiled_regexp = re.compile(pattern) def info(self): - return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue") + return ( + tr("Une chaîne correspondant au motif ") + + str(self.pattern) + + tr(" est attendue") + ) def infoErreurItem(self): - return tr('Une chaîne correspondant au motif ') + str(self.pattern) + tr(" est attendue") + return ( + tr("Une chaîne correspondant au motif ") + + str(self.pattern) + + tr(" est attendue") + ) def verifItem(self, valeur): if self.compiled_regexp.match(valeur): @@ -1719,8 +1799,7 @@ class RegExpVal(ListVal): if self.compiled_regexp.match(valeur): return valeur else: - raise ValError(self.errormsg % - {"value": valeur, "pattern": self.pattern}) + raise ValError(self.errormsg % {"value": valeur, "pattern": self.pattern}) class FileExtVal(RegExpVal): @@ -1732,56 +1811,61 @@ class FileExtVal(RegExpVal): def __init__(self, ext): self.ext = ext self.errormsg = '"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % { - "ext": ext} - #PNPN Modif pour Adao + "ext": ext + } + # PNPN Modif pour Adao RegExpVal.__init__(self, "^\S+\.%s$" % self.ext) - def info(self): - return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext) + return 'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext def infoErreurItem(self): - return ('Un nom de fichier se terminant par ".%s" est attendu.' % self.ext) + return 'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext + class CreeMotClef(object): - def __init__(self,MotClef ): - self.MotClef=MotClef - self.MCSimp=None + def __init__(self, MotClef): + self.MotClef = MotClef + self.MCSimp = None def convert(self, lval): - try : valeur=lval[0] - except : return lval - - parent= self.MCSimp.parent - if hasattr(parent, 'inhibeValidator') and parent.inhibeValidator: return lval - - - if parent.getChild(self.MotClef) == None : longueur=0 - else : longueur=len(parent.getChild(self.MotClef)) + try: + valeur = lval[0] + except: + return lval - pos=parent.getIndexChild(self.MCSimp.nom)+1 - while longueur < valeur : - parent.inhibeValidator=1 - parent.addEntite(self.MotClef,pos) - pos=pos+1 - parent.inhibeValidator=0 - longueur=len(parent.getChild(self.MotClef)) + parent = self.MCSimp.parent + if hasattr(parent, "inhibeValidator") and parent.inhibeValidator: + return lval - if longueur > valeur : - parent.inhibeValide=1 - parentObj=parent.getChild(self.MotClef) - obj=parent.getChild(self.MotClef)[-1] + if parent.getChild(self.MotClef) == None: + longueur = 0 + else: + longueur = len(parent.getChild(self.MotClef)) + + pos = parent.getIndexChild(self.MCSimp.nom) + 1 + while longueur < valeur: + parent.inhibeValidator = 1 + parent.addEntite(self.MotClef, pos) + pos = pos + 1 + parent.inhibeValidator = 0 + longueur = len(parent.getChild(self.MotClef)) + + if longueur > valeur: + parent.inhibeValide = 1 + parentObj = parent.getChild(self.MotClef) + obj = parent.getChild(self.MotClef)[-1] parentObj.suppEntite(obj) - longueur=len(parent.getChild(self.MotClef)) - parent.inhibeValide=0 + longueur = len(parent.getChild(self.MotClef)) + parent.inhibeValide = 0 return lval def info(self): - return "Cree le bon nombre de Mot %s" % self.MotClef + return "Cree le bon nombre de Mot %s" % self.MotClef def verifItem(self, valeur): return 1 def set_MCSimp(self, MCSimp): - #print "dans set_MCSimp" - self.MCSimp=MCSimp + # print "dans set_MCSimp" + self.MCSimp = MCSimp diff --git a/Noyau/N__F.py b/Noyau/N__F.py index 07a405d9..b44c164e 100644 --- a/Noyau/N__F.py +++ b/Noyau/N__F.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -17,37 +17,33 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com - -from __future__ import absolute_import -try : - from past.builtins import cmp -except : - pass -try: - from UserDict import UserDict -except ImportError: - from collections import UserDict +from collections import UserDict class _F(UserDict): """ - Cette classe a un comportement semblable à un - dictionnaire Python et permet de donner - la valeur d'un mot-clé facteur avec pour les sous - mots-clés la syntaxe motcle=valeur + Cette classe a un comportement semblable à un + dictionnaire Python et permet de donner + la valeur d'un mot-clé facteur avec pour les sous + mots-clés la syntaxe motcle=valeur """ def __init__(self, *pos, **args): if len(pos) != 0: - raise SyntaxError("Valeur invalide pour '_F('. " - "On attend cette syntaxe : _F(MOTCLE=valeur, ...)") + raise SyntaxError( + "Valeur invalide pour '_F('. " + "On attend cette syntaxe : _F(MOTCLE=valeur, ...)" + ) self.data = args def supprime(self): self.data = {} def __cmp__(self, dict): + print("je passe ici ________________________ Attention cmp deprecated") + from past.builtins import cmp + if type(dict) == type(self.data): return cmp(self.data, dict) elif hasattr(dict, "data"): @@ -60,6 +56,7 @@ class _F(UserDict): def copy(self): import copy + c = copy.copy(self) c.data = self.data.copy() return c diff --git a/Noyau/N_types.py b/Noyau/N_types.py index d6e889e3..065e7e57 100644 --- a/Noyau/N_types.py +++ b/Noyau/N_types.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,10 +22,11 @@ """ # eficas sentinel -from __future__ import absolute_import -import six + + try: import numpy as NP + _np_arr = NP.ndarray except ImportError: _np_arr = None @@ -45,6 +46,7 @@ def isFloat(obj): def isComplex(obj): return isinstance(obj, complex) + from decimal import Decimal @@ -57,6 +59,8 @@ def isNumber(obj): def isStr(obj): + import six + return isinstance(obj, (str, six.text_type)) @@ -80,6 +84,7 @@ def isSequence(obj): def isASSD(obj): from .N_ASSD import ASSD + return isinstance(obj, ASSD) @@ -88,7 +93,9 @@ def forceList(obj): sinon retourne [obj,] (en tant que list). """ if not isSequence(obj): - obj = [obj, ] + obj = [ + obj, + ] return list(obj) @@ -96,12 +103,12 @@ def forceTuple(obj): """Return `obj` as a tuple.""" return tuple(forceList(obj)) + # backward compatibility from warnings import warn def isEnum(obj): """same as isSequence""" - warn("'isEnum' is deprecated, use 'isSequence'", - DeprecationWarning, stacklevel=2) + warn("'isEnum' is deprecated, use 'isSequence'", DeprecationWarning, stacklevel=2) return isSequence(obj) diff --git a/Noyau/N_utils.py b/Noyau/N_utils.py index 5e1ba24a..7fe2371c 100644 --- a/Noyau/N_utils.py +++ b/Noyau/N_utils.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,14 +23,10 @@ """ # Modules Python -from __future__ import absolute_import -from __future__ import print_function -from __future__ import division -try : - from builtins import str - from builtins import object -except : - pass + + +from builtins import str +from builtins import object import sys # Modules EFICAS @@ -38,16 +34,17 @@ from .N_Exception import AsException from .N_types import isInt, isFloat, isComplex, isStr, isSequence, isASSD from .strfunc import getEncoding -SEP = '_' +SEP = "_" -try : +try: cur_frame = sys._getframe -except : - print ('pb avec la version de python pour cur_frame = sys._getframe') +except: + print("pb avec la version de python pour cur_frame = sys._getframe") + def calleeWhere(niveau=4): """ - recupere la position de l appel + recupere la position de l appel """ frame = sys._getframe(niveau) if frame == None: @@ -57,6 +54,7 @@ def calleeWhere(niveau=4): # with the current locale encoding in order to have a correct traceback. # Here, we convert it back to unicode. import six + filename = six.text_type(frame.f_code.co_filename, getEncoding()) return frame.fLineNo, filename, frame.f_code.co_firstlineno, frame.f_locals except: @@ -65,8 +63,8 @@ def calleeWhere(niveau=4): def AsType(a): """ - Retourne le type d'un concept (a) à partir - des caractéristiques de l'objet Python + Retourne le type d'un concept (a) à partir + des caractéristiques de l'objet Python """ if isSequence(a): return AsType(a[0]) @@ -91,70 +89,70 @@ def prbanner(s): def repr_float(valeur): """ - Cette fonction représente le réel valeur comme une chaine de caractères - sous forme mantisse exposant si nécessaire cad si le nombre contient plus de - 5 caractères - NB : valeur est un réel au format Python ou une chaine de caractères représentant un réel + Cette fonction représente le réel valeur comme une chaine de caractères + sous forme mantisse exposant si nécessaire cad si le nombre contient plus de + 5 caractères + NB : valeur est un réel au format Python ou une chaine de caractères représentant un réel """ if type(valeur) == str: valeur = eval(valeur) - if valeur == 0.: - return '0.0' - if abs(valeur) > 1.: - if abs(valeur) < 10000.: + if valeur == 0.0: + return "0.0" + if abs(valeur) > 1.0: + if abs(valeur) < 10000.0: return repr(valeur) else: if abs(valeur) > 0.01: return repr(valeur) t = repr(valeur) - if t.find('e') != -1 or t.find('E') != -1: + if t.find("e") != -1 or t.find("E") != -1: # le réel est déjà sous forme mantisse exposant ! # --> on remplace e par E - t = t.replace('e', 'E') + t = t.replace("e", "E") # --> on doit encore vérifier que la mantisse contient bien un '.' - if t.find('.') != -1: + if t.find(".") != -1: return t else: # -->il faut rajouter le point avant le E - t = t.replace('E', '.E') + t = t.replace("E", ".E") return t - s = '' + s = "" neg = 0 - if t[0] == '-': + if t[0] == "-": s = s + t[0] t = t[1:] cpt = 0 - if t[0].atof() == 0.: + if t[0].atof() == 0.0: # réel plus petit que 1 neg = 1 t = t[2:] cpt = 1 - while t[0].atof() == 0.: + while t[0].atof() == 0.0: cpt = cpt + 1 t = t[1:] - s = s + t[0] + '.' + s = s + t[0] + "." for c in t[1:]: s = s + c else: # réel plus grand que 1 - s = s + t[0] + '.' - if t[1:].atof() == 0.: - l = t[1:].split('.') + s = s + t[0] + "." + if t[1:].atof() == 0.0: + l = t[1:].split(".") cpt = len(l[0]) else: r = 0 pt = 0 for c in t[1:]: r = r + 1 - if c != '.': + if c != ".": if pt != 1: cpt = cpt + 1 s = s + c else: pt = 1 - if r + 1 == len(t) or t[r + 1:].atof() == 0.: + if r + 1 == len(t) or t[r + 1 :].atof() == 0.0: break - s = s + 'E' + neg * '-' + repr(cpt) + s = s + "E" + neg * "-" + repr(cpt) return s @@ -164,35 +162,37 @@ def importObject(uri): that "mainpkg.subpkg.module" is imported and "object" is the object to return. """ - path = uri.split('.') - modname = '.'.join(path[:-1]) + path = uri.split(".") + modname = ".".join(path[:-1]) if len(modname) == 0: - raise ImportError(u"invalid uri: %s" % uri) - mod = object = '?' + raise ImportError("invalid uri: %s" % uri) + mod = object = "?" objname = path[-1] try: __import__(modname) mod = sys.modules[modname] except ImportError as err: - raise ImportError( - "can not import module : %s (%s)" % (modname, str(err))) + raise ImportError("can not import module : %s (%s)" % (modname, str(err))) try: object = getattr(mod, objname) except AttributeError as err: - raise AttributeError("object (%s) not found in module '%s'. " - "Module content is: %s" % (objname, modname, tuple(dir(mod)))) + raise AttributeError( + "object (%s) not found in module '%s'. " + "Module content is: %s" % (objname, modname, tuple(dir(mod))) + ) return object class Singleton(object): """Singleton implementation in python.""" + # add _singleton_id attribute to the class to be independant of import # path used __inst = {} def __new__(cls, *args, **kargs): - cls_id = getattr(cls, '_singleton_id', cls) + cls_id = getattr(cls, "_singleton_id", cls) if Singleton.__inst.get(cls_id) is None: Singleton.__inst[cls_id] = object.__new__(cls) return Singleton.__inst[cls_id] @@ -210,8 +210,8 @@ class Enum(object): """Constructor""" self._dict_keys = {} for inum, key in enumerate(keys): - setattr(self, key, 2 ** inum) - self._dict_keys[2 ** inum] = key + setattr(self, key, 2**inum) + self._dict_keys[2**inum] = key def exists(self, value): """Tell if value is in the enumeration""" diff --git a/Noyau/__init__.py b/Noyau/__init__.py index fbbfde0d..f62757b7 100644 --- a/Noyau/__init__.py +++ b/Noyau/__init__.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2021 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,8 +17,6 @@ # # # ====================================================================== - - """ Ce package fournit les classes de base d'EFICAS. Ces classes permettent d'effectuer quelques operations basiques : @@ -31,26 +29,17 @@ # sous le nom CONTEXT afin d'avoir acces aux fonctions # getCurrentStep, setCurrentStep et unsetCurrentStep de n'importe ou -from __future__ import absolute_import -from . import context - -try : - import __builtin__ - __builtin__.CONTEXT = context -except : - import builtins - builtins.CONTEXT = context +from . import context -# Classes de base -#from .N_SIMP import SIMP -#from .N_FACT import FACT +import builtins +builtins.CONTEXT = context # Only the first MAXSIZE objects will be checked # This is used for the number of MCFACT, the number of MCSIMP and the number of # values in a MCSIMP. -MAXSIZE = 500 -MAXSIZE_MSGCHK = ' Only the first {0} occurrences (total: {1}) have been checked.' -MAXSIZE_MSGKEEP = ' Only the first {0} occurrences (total: {1}) have been printed.' +MAXSIZE = 500 +MAXSIZE_MSGCHK = " Only the first {0} occurrences (total: {1}) have been checked." +MAXSIZE_MSGKEEP = " Only the first {0} occurrences (total: {1}) have been printed." diff --git a/Noyau/context.py b/Noyau/context.py index 602800fe..4e9b9172 100644 --- a/Noyau/context.py +++ b/Noyau/context.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2021 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -18,10 +18,9 @@ # # ====================================================================== -from __future__ import absolute_import _root = None _cata = None -_jdc = None +_jdc = None debug = 0 # Le "current step" est l'etape courante. @@ -33,7 +32,7 @@ debug = 0 def setCurrentStep(step): """ - Fonction qui permet de changer la valeur de l'etape courante + Fonction qui permet de changer la valeur de l'etape courante """ global _root if _root: @@ -43,14 +42,14 @@ def setCurrentStep(step): def getCurrentStep(): """ - Fonction qui permet d'obtenir la valeur de l'etape courante + Fonction qui permet d'obtenir la valeur de l'etape courante """ return _root def unsetCurrentStep(): """ - Fonction qui permet de remettre a None l'etape courante + Fonction qui permet de remettre a None l'etape courante """ global _root _root = None @@ -58,7 +57,7 @@ def unsetCurrentStep(): def setCurrentCata(cata): """ - Fonction qui permet de changer l'objet catalogue courant + Fonction qui permet de changer l'objet catalogue courant """ global _cata if _cata: @@ -68,14 +67,14 @@ def setCurrentCata(cata): def getCurrentCata(): """ - Fonction qui retourne l'objet catalogue courant + Fonction qui retourne l'objet catalogue courant """ return _cata def unsetCurrentCata(): """ - Fonction qui permet de remettre a None le catalogue courant + Fonction qui permet de remettre a None le catalogue courant """ global _cata _cata = None @@ -83,22 +82,24 @@ def unsetCurrentCata(): def getCurrentJdC(): """ - Fonction qui retourne l'objet JDC courant + Fonction qui retourne l'objet JDC courant """ return _jdc + def setCurrentJdC(jdc): """ - Fonction qui permet de changer l'objet JDC courant + Fonction qui permet de changer l'objet JDC courant """ global _jdc if _jdc: raise Exception("Impossible d'affecter _jdc. Il devrait valoir None") _jdc = jdc + def unsetCurrentJdC(): """ - Fonction qui permet de remettre a None le JDC courant + Fonction qui permet de remettre a None le JDC courant """ global _jdc _jdc = None diff --git a/Noyau/nommage.py b/Noyau/nommage.py index 93c8db06..0a95c1f6 100644 --- a/Noyau/nommage.py +++ b/Noyau/nommage.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -34,11 +34,7 @@ """ # Modules Python -from __future__ import absolute_import -try : - from builtins import str -except : - pass +from builtins import str import re import linecache import sys @@ -48,7 +44,7 @@ from functools import partial from . import N_utils from .strfunc import getEncoding -regex1 = '=?\s*%s\s*\(' +regex1 = "=?\s*%s\s*\(" # commentaire standard precede d'un nombre quelconque de blancs (pas # multiligne) pattern_comment = re.compile(r"^\s*#.*") @@ -56,29 +52,30 @@ pattern_comment = re.compile(r"^\s*#.*") def _getNomConceptResultat(ope, level=2): """ - Cette fonction recherche dans la pile des appels, l'appel à la commande - qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)). - On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne - dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename). - A partir de là, on récupère la ligne de source avec linecache.getline - et on vérifie que cette ligne correspond véritablement à l'appel. + Cette fonction recherche dans la pile des appels, l'appel à la commande + qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)). + On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne + dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename). + A partir de là, on récupère la ligne de source avec linecache.getline + et on vérifie que cette ligne correspond véritablement à l'appel. - En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve - la dernière ligne. Il faut donc remonter dans le source jusqu'à la première - ligne. + En effet, lorsque les commandes tiennent sur plusieurs lignes, on retrouve + la dernière ligne. Il faut donc remonter dans le source jusqu'à la première + ligne. - Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un - élément d'une liste, par exemple. + Enfin la fonction evalnom forme un nom acceptable lorsque le concept est un + élément d'une liste, par exemple. """ f = N_utils.cur_frame(level) - lineno = f.f_lineno # XXX Too bad if -O is used + lineno = f.f_lineno # XXX Too bad if -O is used # lineno = f_lineno(f) # Ne marche pas toujours co = f.f_code - if sys.version_info >= (3,0) : + if sys.version_info >= (3, 0): filename = co.co_filename - else : + else: import six + filename = six.text_type(co.co_filename, getEncoding()) name = co.co_name # pattern pour identifier le debut de la commande @@ -101,37 +98,37 @@ def _getNomConceptResultat(ope, level=2): if m != []: return m[-1] else: - return '' + return "" # print "appel inconnu" return "" def evalnom(text, d): """ - Retourne un nom pour le concept resultat identifie par text - Pour obtenir ce nom il y a plusieurs possibilites : - 1. text est un identificateur python c'est le nom du concept - 2. text est un element d'une liste on construit le nom en - evaluant la partie indice dans le contexte de l'appelant d + Retourne un nom pour le concept resultat identifie par text + Pour obtenir ce nom il y a plusieurs possibilites : + 1. text est un identificateur python c'est le nom du concept + 2. text est un element d'une liste on construit le nom en + evaluant la partie indice dans le contexte de l'appelant d """ - l = re.split('([\[\]]+)', text) - if l[-1] == '': + l = re.split("([\[\]]+)", text) + if l[-1] == "": l = l[:-1] lll = [] i = 0 while i < len(l): s = l[i] - ll = re.split('[ ,]+', s) - if ll[0] == '': + ll = re.split("[ ,]+", s) + if ll[0] == "": ll = ll[1:] if len(ll) == 1: id0 = ll[0] else: lll = lll + ll[0:-1] id0 = ll[-1] - if i + 1 < len(l) and l[i + 1] == '[': # le nom est suivi d un subscript + if i + 1 < len(l) and l[i + 1] == "[": # le nom est suivi d un subscript sub = l[i + 2] - nom = id0 + '_' + str(eval(sub, d)) + nom = id0 + "_" + str(eval(sub, d)) i = i + 4 else: nom = id0 @@ -142,12 +139,12 @@ def evalnom(text, d): def f_lineno(f): """ - Calcule le numero de ligne courant - Devrait marcher meme avec -O - Semble ne pas marcher en présence de tuples longs + Calcule le numero de ligne courant + Devrait marcher meme avec -O + Semble ne pas marcher en présence de tuples longs """ c = f.f_code - if not hasattr(c, 'co_lnotab'): + if not hasattr(c, "co_lnotab"): return f.f_lineno tab = c.co_lnotab line = c.co_firstlineno @@ -164,7 +161,8 @@ def f_lineno(f): class NamingSystem(N_utils.Singleton): """Cette classe définit un système de nommage dynamique des concepts.""" - _singleton_id = 'nommage.NamingSystem' + + _singleton_id = "nommage.NamingSystem" def __init__(self): """Initialisation""" @@ -183,4 +181,5 @@ class NamingSystem(N_utils.Singleton): """Appel à la fonction de nommage.""" return self.naming_func(*args) + getNomConceptResultat = NamingSystem() diff --git a/Noyau/strfunc.py b/Noyau/strfunc.py index 4bb51c42..bf6e89e8 100644 --- a/Noyau/strfunc.py +++ b/Noyau/strfunc.py @@ -1,5 +1,5 @@ # coding=utf-8 -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,10 +22,11 @@ de chaines de caractères """ # module identique à Execution/strfunc.py pour usage dans Eficas -from __future__ import absolute_import -try : + +try: from builtins import str -except : pass +except: + pass import locale import six @@ -34,14 +35,13 @@ _encoding = None def getEncoding(): - """Return local encoding - """ + """Return local encoding""" global _encoding if _encoding is None: try: - _encoding = locale.getpreferredencoding() or 'ascii' + _encoding = locale.getpreferredencoding() or "ascii" except locale.Error: - _encoding = 'ascii' + _encoding = "ascii" return _encoding @@ -60,57 +60,11 @@ def toUnicode(string): return tuple(toUnicode(list(string))) elif type(string) is not str: return string - assert type(string) is str, u"unsupported object: %s" % string - for encoding in ('utf-8', 'iso-8859-15', 'cp1252'): + assert type(string) is str, "unsupported object: %s" % string + for encoding in ("utf-8", "iso-8859-15", "cp1252"): try: s = six.text_type(string, encoding) return s except UnicodeDecodeError: pass - return six.text_type(string, 'utf-8', 'replace') - - -#def fromUnicode(ustring, encoding, errors='replace'): -# """Try to encode a unicode string using encoding.""" -# try: -# return ustring.encode(encoding) -# except UnicodeError: -# pass -# return ustring.encode(encoding, errors) -# -# -#def convert(content, encoding=None, errors='replace'): -# """Convert content using encoding or default encoding if None.""" -# if type(content) not in (str, six.text_type): -# content = six.text_type(content) -# if type(content) == str: -# content = toUnicode(content) -# return fromUnicode(content, encoding or getEncoding(), errors) -# -# -#def ufmt(uformat, *args): -# """Helper function to format a string by converting all its arguments to unicode""" -# if type(uformat) is not six.text_type: -# uformat = toUnicode(uformat) -# if len(args) == 1 and type(args[0]) is dict: -# arguments = toUnicode(args[0]) -# else: -# nargs = [] -# for arg in args: -# if type(arg) in (str, six.text_type, list, tuple, dict): -# nargs.append(toUnicode(arg)) -# elif type(arg) not in (int, int, float): -# nargs.append(toUnicode(str(arg))) -# else: -# nargs.append(arg) -# arguments = tuple(nargs) -# formatted_string="" -# try: -# formatted_string = uformat % arguments -# #except UnicodeDecodeError: -# # print type(uformat), uformat -# # print type(arguments), arguments -# #raise -# except : -# pass -# return formatted_string + return six.text_type(string, "utf-8", "replace") diff --git a/Traducteur/CMakeLists.txt b/Traducteur/CMakeLists.txt index d1c51c80..59b150cd 100644 --- a/Traducteur/CMakeLists.txt +++ b/Traducteur/CMakeLists.txt @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR diff --git a/Traducteur/__init__.py b/Traducteur/__init__.py index 5b4f0e3b..be5cb0a1 100644 --- a/Traducteur/__init__.py +++ b/Traducteur/__init__.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public diff --git a/Traducteur/calcG.py b/Traducteur/calcG.py index c8879f13..b41f84eb 100644 --- a/Traducteur/calcG.py +++ b/Traducteur/calcG.py @@ -1,5 +1,5 @@ #### -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public diff --git a/Traducteur/changeValeur.py b/Traducteur/changeValeur.py index 50b0c9c9..a677a18f 100644 --- a/Traducteur/changeValeur.py +++ b/Traducteur/changeValeur.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -26,292 +26,374 @@ from Traducteur.removemocle import removeMotCleInFact from Traducteur import regles -#-------------------------------------------------------------------------- -def changementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0): -#-------------------------------------------------------------------------- - if command not in jdcSet : return - boolChange=0 +# -------------------------------------------------------------------------- +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 + if c.name != command: + continue + trouveUnMC = 0 for mc in c.childNodes: - if mc.name != motcle : continue - trouveUnMC=1 - TexteMC=mc.getText(jdc) - liste_ligne_MC=TexteMC.splitlines() - indexLigneGlob=mc.lineno-1 - indexTexteMC=0 - while indexLigneGlob < mc.endline : - if indexTexteMC > len(liste_ligne_MC)-1 : break - MaLigneGlob=jdc.getLines()[indexLigneGlob] - MaLigneTexte=liste_ligne_MC[indexTexteMC] - for Valeur in DictNouvVal : - MaLigneTexteDict=lineToDict(MaLigneTexte) - trouvecol=MaLigneTexte.find(Valeur) + if mc.name != motcle: + continue + trouveUnMC = 1 + TexteMC = mc.getText(jdc) + liste_ligne_MC = TexteMC.splitlines() + indexLigneGlob = mc.lineno - 1 + indexTexteMC = 0 + while indexLigneGlob < mc.endline: + if indexTexteMC > len(liste_ligne_MC) - 1: + break + MaLigneGlob = jdc.getLines()[indexLigneGlob] + MaLigneTexte = liste_ligne_MC[indexTexteMC] + for Valeur in DictNouvVal: + MaLigneTexteDict = lineToDict(MaLigneTexte) + trouvecol = MaLigneTexte.find(Valeur) if trouvecol > -1: - trouve=(Valeur==MaLigneTexteDict[trouvecol]) + trouve = Valeur == MaLigneTexteDict[trouvecol] else: - trouve=False + trouve = False if trouve: - debut=MaLigneGlob.find(motcle) - if debut==-1 : debut=0 - Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur]) - Nouveau=MaLigneGlob[0:debut]+Nouveau - jdc.getLines()[indexLigneGlob]=Nouveau - MaLigneTexte=Nouveau # raccourci honteux mais ... - MaLigneGlob=Nouveau - if Valeur in liste : - 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) - if boolChange : jdc.reset(jdc.getSource()) + debut = MaLigneGlob.find(motcle) + if debut == -1: + debut = 0 + Nouveau = MaLigneGlob[debut:].replace( + Valeur, DictNouvVal[Valeur] + ) + Nouveau = MaLigneGlob[0:debut] + Nouveau + jdc.getLines()[indexLigneGlob] = Nouveau + MaLigneTexte = Nouveau # raccourci honteux mais ... + MaLigneGlob = Nouveau + if Valeur in liste: + 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) + if boolChange: + jdc.reset(jdc.getSource()) -#-------------------------------------------------------------------------------- -def changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),ensemble=regles.SansRegle,defaut=0): -#-------------------------------------------------------------------------------- - if command not in jdcSet : return - boolChange=0 +# -------------------------------------------------------------------------------- +def changementValeurDsMCF( + jdc, + command, + fact, + motcle, + DictNouvVal, + liste=(), + ensemble=regles.SansRegle, + defaut=0, +): + # -------------------------------------------------------------------------------- + + if command not in jdcSet: + return + boolChange = 0 for c in jdc.root.childNodes: - if c.name != command : continue + if c.name != command: + continue for mcF in c.childNodes: - if mcF.name != fact : continue - l=mcF.childNodes[:] + if mcF.name != fact: + continue + l = mcF.childNodes[:] l.reverse() for ll in l: - trouveUnMC=0 + trouveUnMC = 0 for mc in ll.childNodes: - if mc.name != motcle:continue - if ensemble.verif(c) == 0 : continue - trouveUnMC=1 - TexteMC=mc.getText(jdc) - liste_ligne_MC=TexteMC.splitlines() - indexLigneGlob=mc.lineno-1 - indexTexteMC=0 - while indexLigneGlob < mc.endline : - if indexTexteMC > len(liste_ligne_MC)-1 : break - MaLigneGlob=jdc.getLines()[indexLigneGlob] - MaLigneTexte=liste_ligne_MC[indexTexteMC] - for Valeur in DictNouvVal : - MaLigneTexteDict=lineToDict(MaLigneTexte) - trouvecol=MaLigneTexte.find(Valeur) + if mc.name != motcle: + continue + if ensemble.verif(c) == 0: + continue + trouveUnMC = 1 + TexteMC = mc.getText(jdc) + liste_ligne_MC = TexteMC.splitlines() + indexLigneGlob = mc.lineno - 1 + indexTexteMC = 0 + while indexLigneGlob < mc.endline: + if indexTexteMC > len(liste_ligne_MC) - 1: + break + MaLigneGlob = jdc.getLines()[indexLigneGlob] + MaLigneTexte = liste_ligne_MC[indexTexteMC] + for Valeur in DictNouvVal: + MaLigneTexteDict = lineToDict(MaLigneTexte) + trouvecol = MaLigneTexte.find(Valeur) if trouvecol > -1: - trouve=(Valeur==MaLigneTexteDict[trouvecol]) + trouve = Valeur == MaLigneTexteDict[trouvecol] else: - trouve=False + trouve = False if trouve: - debut=MaLigneGlob.find(motcle) - if debut==-1 : debut=0 - Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur]) - Nouveau=MaLigneGlob[0:debut]+Nouveau - jdc.getLines()[indexLigneGlob]=Nouveau - MaLigneTexte=Nouveau # raccourci honteux mais ... - MaLigneGlob=Nouveau - if Valeur in liste : - 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.warning("OPTION (defaut) de CALCG a verifier ligne %s" ,c.lineno ) - ecritErreur((command,fact,motcle,"DEFAUT"),c.lineno) - if boolChange : jdc.reset(jdc.getSource()) + debut = MaLigneGlob.find(motcle) + if debut == -1: + debut = 0 + Nouveau = MaLigneGlob[debut:].replace( + Valeur, DictNouvVal[Valeur] + ) + Nouveau = MaLigneGlob[0:debut] + Nouveau + jdc.getLines()[indexLigneGlob] = Nouveau + MaLigneTexte = Nouveau # raccourci honteux mais ... + MaLigneGlob = Nouveau + if Valeur in liste: + 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.warning( + "OPTION (defaut) de CALCG a verifier ligne %s", c.lineno + ) + ecritErreur((command, fact, motcle, "DEFAUT"), c.lineno) + if boolChange: + jdc.reset(jdc.getSource()) + + +# -------------------------------------------------------------------------------- +def changementValeurDsMCFSiRegle( + jdc, command, fact, motcle, DictNouvVal, liste_regles, defaut=0 +): + # -------------------------------------------------------------------------------- + if command not in jdcSet: + return + mesRegles = regles.ensembleRegles(liste_regles) + liste = () + changementValeurDsMCF( + jdc, command, fact, motcle, DictNouvVal, liste, mesRegles, defaut + ) + + +# --------------------------------------------------------------------------------------- +def changementValeurDsMCFAvecAvertissement( + jdc, command, fact, motcle, DictNouvVal, liste +): + # --------------------------------------------------------------------------------------- + if command not in jdcSet: + return + defaut = 0 + if liste[-1] == "defaut": + defaut = 1 + changementValeurDsMCF(jdc, command, fact, motcle, DictNouvVal, liste, defaut) -#-------------------------------------------------------------------------------- -def changementValeurDsMCFSiRegle(jdc,command,fact,motcle,DictNouvVal,liste_regles,defaut=0): -#-------------------------------------------------------------------------------- - if command not in jdcSet : return - mesRegles=regles.ensembleRegles(liste_regles) - liste=() - changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,mesRegles,defaut) -#--------------------------------------------------------------------------------------- -def changementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal,liste): -#--------------------------------------------------------------------------------------- - if command not in jdcSet : return - defaut=0 - if liste[-1] == "defaut" : - defaut=1 - changementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,defaut) +# -------------------------------------------------------------------------- +def changementValeurAvecAvertissement(jdc, command, motcle, DictNouvVal, liste): + # -------------------------------------------------------------------------- + if command not in jdcSet: + return + defaut = 0 + if liste[-1] == "defaut": + defaut = 1 + changementValeur(jdc, command, motcle, DictNouvVal, liste, defaut) -#-------------------------------------------------------------------------- -def changementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste): -#-------------------------------------------------------------------------- - if command not in jdcSet : return - defaut=0 - if liste[-1] == "defaut" : - defaut=1 - changementValeur(jdc,command,motcle,DictNouvVal,liste,defaut) -#-------------------------------------------------------------------------- -def suppressionValeurs(jdc, command,motcle,liste): -#-------------------------------------------------------------------------- +# -------------------------------------------------------------------------- +def suppressionValeurs(jdc, command, motcle, liste): + # -------------------------------------------------------------------------- - if command not in jdcSet : return - boolChange=0 + if command not in jdcSet: + return + boolChange = 0 for c in jdc.root.childNodes: - if c.name != command : continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != motcle : continue - indexLigneGlob=mc.lineno-1 - while indexLigneGlob < mc.endline-1 : + if mc.name != motcle: + continue + indexLigneGlob = mc.lineno - 1 + while indexLigneGlob < mc.endline - 1: MaLigneTexte = jdc.getLines()[indexLigneGlob] - MaLigne=MaLigneTexte - for Valeur in liste : - debutMC =MaLigne.find(motcle) - if debutMC ==-1 : debutMC=0 - debut1=MaLigne[0:debutMC] - chercheLigne=MaLigne[debutMC:] - trouve=chercheLigne.find(Valeur) - premier=0 - if trouve > 1 : #on a au moins une quote - debut=debut1 + chercheLigne[0:trouve-1] + MaLigne = MaLigneTexte + for Valeur in liste: + debutMC = MaLigne.find(motcle) + if debutMC == -1: + debutMC = 0 + debut1 = MaLigne[0:debutMC] + chercheLigne = MaLigne[debutMC:] + trouve = chercheLigne.find(Valeur) + premier = 0 + if trouve > 1: # on a au moins une quote + debut = debut1 + chercheLigne[0 : trouve - 1] index = -1 - while (-1 * index) < len(debut) : - if (debut[index] == "(") : + while (-1 * index) < len(debut): + if debut[index] == "(": premier = 1 - if index == -1 : - index=len(debut) - else : - index=index+1 + if index == -1: + index = len(debut) + else: + index = index + 1 break - if (debut[index] == "," ) : + if debut[index] == ",": break - if (debut[index] != " " ) : - assert(0) - index = index -1 + if debut[index] != " ": + assert 0 + index = index - 1 debLigne = debut[0:index] - fin=trouve+len(Valeur)+1 - if premier == 1 and chercheLigne[fin] == ',': fin = fin + 1 # on supprime la , + fin = trouve + len(Valeur) + 1 + if premier == 1 and chercheLigne[fin] == ",": + fin = fin + 1 # on supprime la , finLigne = chercheLigne[fin:] - MaLigne_tmp=debLigne+finLigne + MaLigne_tmp = debLigne + finLigne # traitement ligne commancant par , - if len(MaLigne_tmp.strip()) > 0 : - if MaLigne_tmp.strip()[0]==',' : - MaLigne=MaLigne_tmp.strip()[1:] - else : - MaLigne=MaLigne_tmp[0:] - else : - MaLigne=MaLigne_tmp[0:] - boolChange=1 - jdc.getLines()[indexLigneGlob]=MaLigne - indexLigneGlob=indexLigneGlob+1 - if boolChange : jdc.reset(jdc.getSource()) + if len(MaLigne_tmp.strip()) > 0: + if MaLigne_tmp.strip()[0] == ",": + MaLigne = MaLigne_tmp.strip()[1:] + else: + MaLigne = MaLigne_tmp[0:] + else: + MaLigne = MaLigne_tmp[0:] + boolChange = 1 + jdc.getLines()[indexLigneGlob] = MaLigne + indexLigneGlob = indexLigneGlob + 1 + if boolChange: + jdc.reset(jdc.getSource()) + -#---------------------------------------------- -def appelleMacroSelonValeurConcept(jdc,macro,genea): -#---------------------------------------------- - if macro not in jdcSet : return - boolChange=0 - fact=genea[0] - motcle=genea[1] - chaine="CO" +# ---------------------------------------------- +def appelleMacroSelonValeurConcept(jdc, macro, genea): + # ---------------------------------------------- + if macro not in jdcSet: + return + boolChange = 0 + fact = genea[0] + motcle = genea[1] + chaine = "CO" for c in jdc.root.childNodes: - if c.name != macro : continue + if c.name != macro: + continue for mcF in c.childNodes: - if mcF.name != fact : continue - l=mcF.childNodes[:] + if mcF.name != fact: + continue + l = mcF.childNodes[:] l.reverse() for ll in l: - trouveValeur=0 + trouveValeur = 0 for mc in ll.childNodes: - if mc.name != motcle:continue - TexteMC=mc.getText(jdc) - liste_ligne_MC=TexteMC.splitlines() - indexLigneGlob=mc.lineno-2 - trouveTexteMC=0 - trouveegal=0 - trouvechaine=0 - trouveparent=0 - trouvequote=0 - while indexLigneGlob < mc.endline : - indexLigneGlob=indexLigneGlob+1 - MaLigneTexte=jdc.getLines()[indexLigneGlob] + if mc.name != motcle: + continue + TexteMC = mc.getText(jdc) + liste_ligne_MC = TexteMC.splitlines() + indexLigneGlob = mc.lineno - 2 + trouveTexteMC = 0 + trouveegal = 0 + trouvechaine = 0 + trouveparent = 0 + trouvequote = 0 + while indexLigneGlob < mc.endline: + indexLigneGlob = indexLigneGlob + 1 + MaLigneTexte = jdc.getLines()[indexLigneGlob] # on commence par chercher TABLE par exemple # si on ne trouve pas on passe a la ligne suivante - if ( trouveTexteMC == 0 ) : - indice=MaLigneTexte.find(motcle) - if indice < 0 : continue - trouveTexteMC=1 - else : - indice=0 + if trouveTexteMC == 0: + indice = MaLigneTexte.find(motcle) + if indice < 0: + continue + trouveTexteMC = 1 + else: + indice = 0 # on cherche = - aChercher=MaLigneTexte[indice:] - if (trouveegal == 0 ): - indice=aChercher.find("=") - if indice < 0 : continue + aChercher = MaLigneTexte[indice:] + if trouveegal == 0: + indice = aChercher.find("=") + if indice < 0: + continue trouveegal = 1 - else : + else: indice = 0 # on cherche CO - aChercher2=aChercher[indice:] - if (trouvechaine == 0 ): - indice=aChercher2.find(chaine) - if indice < 0 : continue + aChercher2 = aChercher[indice:] + if trouvechaine == 0: + indice = aChercher2.find(chaine) + if indice < 0: + continue trouvechaine = 1 - else : + else: indice = 0 - #on cherche ( - aChercher3=aChercher2[indice:] - if (trouveparent == 0 ): - indice=aChercher3.find('(') - if indice < 0 : continue + # on cherche ( + aChercher3 = aChercher2[indice:] + if trouveparent == 0: + indice = aChercher3.find("(") + if indice < 0: + continue trouveparent = 1 - else : + else: indice = 0 - #on cherche la ' - aChercher4=aChercher3[indice:] - if (trouvequote == 0 ): - indice=aChercher4.find("'") - indice2=aChercher4.find('"') - if (indice < 0) and (indice2 < 0): continue - if (indice < 0) : indice=indice2 + # on cherche la ' + aChercher4 = aChercher3[indice:] + if trouvequote == 0: + indice = aChercher4.find("'") + indice2 = aChercher4.find('"') + if (indice < 0) and (indice2 < 0): + continue + if indice < 0: + indice = indice2 trouvequote = 1 - else : + else: indice = 0 - trouveValeur=1 - aChercher5=aChercher4[indice+1:] - indice=aChercher5.find("'") - if indice < 0 : indice=aChercher5.find('"') - valeur=aChercher5[:indice] + trouveValeur = 1 + aChercher5 = aChercher4[indice + 1 :] + indice = aChercher5.find("'") + if indice < 0: + indice = aChercher5.find('"') + valeur = aChercher5[:indice] break - if trouveValeur==0 : - logging.error("Pb de traduction pour MACR_LIGNE_COUPE : Pas de nom de Concept identifiable") + if trouveValeur == 0: + logging.error( + "Pb de traduction pour MACR_LIGNE_COUPE : Pas de nom de Concept identifiable" + ) return - if boolChange : + if boolChange: jdc.reset(jdc.getSource()) - logging.error("Pb du traduction pour MACR_LIGNE_COUPE : Deux noms de Concept possibles") + logging.error( + "Pb du traduction pour MACR_LIGNE_COUPE : Deux noms de Concept possibles" + ) return - boolChange=1 - ligneaTraiter=jdc.getLines()[c.lineno-1] - debut=ligneaTraiter[0:c.colno] - suite=valeur+"=" - fin=ligneaTraiter[c.colno:] - ligne=debut+suite+fin - jdc.getLines()[c.lineno-1]=ligne - nbBlanc=len(valeur)+1 + boolChange = 1 + ligneaTraiter = jdc.getLines()[c.lineno - 1] + debut = ligneaTraiter[0 : c.colno] + suite = valeur + "=" + fin = ligneaTraiter[c.colno :] + ligne = debut + suite + fin + jdc.getLines()[c.lineno - 1] = ligne + nbBlanc = len(valeur) + 1 if c.lineno < c.endline: - decaleLignesdeNBlancs(jdc,c.lineno,c.endline-1,nbBlanc) - if boolChange : jdc.reset(jdc.getSource()) + decaleLignesdeNBlancs(jdc, c.lineno, c.endline - 1, nbBlanc) + if boolChange: + jdc.reset(jdc.getSource()) + -#---------------------------------------------- -def changeTouteValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0): -#---------------------------------------------- - if macro not in jdcSet : return - boolChange=0 +# ---------------------------------------------- +def changeTouteValeur(jdc, command, motcle, DictNouvVal, liste=(), defaut=0): + # ---------------------------------------------- + if macro not in jdcSet: + return + boolChange = 0 diff --git a/Traducteur/dictErreurs.py b/Traducteur/dictErreurs.py index 82fc058f..c8bdc78a 100644 --- a/Traducteur/dictErreurs.py +++ b/Traducteur/dictErreurs.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,89 +22,128 @@ import logging from Traducteur.load import jdcSet -def ecritErreur(listeGena,ligne=None) : +def ecritErreur(listeGena, ligne=None): from sys import dict_erreurs - maCle="" - for Mot in listeGena : - maCle=maCle+"_"+Mot - #try : - if ( 1 == 1) : - maClef=maCle[1:] - if maClef in dict_erreurs : - if ligne != None : - logging.warning("ligne %d : %s ",ligne,dict_erreurs[maClef]) - else : - logging.warning("%s",dict_erreurs[maClef]) - else : - maCle="" - for Mot in listeGena[:-1] : - maCle=maCle+"_"+Mot - maClef=maCle[1:] - maClef=maCle+"_"+"VALEUR" - if maClef in dict_erreurs : - if ligne != None : - logging.warning("ligne %d : %s ",ligne,dict_erreurs[maClef]) - else : - logging.warning("%s",dict_erreurs[maClef]) - #except : + + maCle = "" + for Mot in listeGena: + maCle = maCle + "_" + Mot + # try : + if 1 == 1: + maClef = maCle[1:] + if maClef in dict_erreurs: + if ligne != None: + logging.warning("ligne %d : %s ", ligne, dict_erreurs[maClef]) + else: + logging.warning("%s", dict_erreurs[maClef]) + else: + maCle = "" + for Mot in listeGena[:-1]: + maCle = maCle + "_" + Mot + maClef = maCle[1:] + maClef = maCle + "_" + "VALEUR" + if maClef in dict_erreurs: + if ligne != None: + logging.warning("ligne %d : %s ", ligne, dict_erreurs[maClef]) + else: + logging.warning("%s", dict_erreurs[maClef]) + # except : # pass -def genereErreurPourCommande(jdc,listeCommande) : - commands= jdc.root.childNodes[:] + +def genereErreurPourCommande(jdc, listeCommande): + commands = jdc.root.childNodes[:] commands.reverse() for c in commands: - if type(listeCommande)==list: - for Mot in listeCommande : - if c.name != Mot :continue - ecritErreur((Mot,),c.lineno) + if type(listeCommande) == list: + for Mot in listeCommande: + if c.name != Mot: + continue + ecritErreur((Mot,), c.lineno) else: - if c.name != listeCommande :continue - ecritErreur((listeCommande,),c.lineno) + if c.name != listeCommande: + continue + ecritErreur((listeCommande,), c.lineno) -def genereErreurMotCleInFact(jdc,command,fact,mocle): + +def genereErreurMotCleInFact(jdc, command, fact, mocle): for c in jdc.root.childNodes: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != fact:continue - l=mc.childNodes[:] + if mc.name != fact: + continue + l = mc.childNodes[:] for ll in l: for n in ll.childNodes: if n.name != mocle: continue - else : - ecritErreur((command,fact,mocle,),c.lineno) + else: + ecritErreur( + ( + command, + fact, + mocle, + ), + c.lineno, + ) + -def genereErreurMCF(jdc,command,fact): +def genereErreurMCF(jdc, command, fact): for c in jdc.root.childNodes: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: if mc.name != fact: continue - else : - ecritErreur((command,fact,),c.lineno) + else: + ecritErreur( + ( + command, + fact, + ), + c.lineno, + ) -def genereErreurValeur(jdc,command,fact,list_valeur): + +def genereErreurValeur(jdc, command, fact, list_valeur): for c in jdc.root.childNodes: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != fact:continue - texte=mc.getText(jdc) + 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) + 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): +def genereErreurValeurDsMCF(jdc, command, fact, mocle, list_valeur): for c in jdc.root.childNodes: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != fact:continue - l=mc.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) + 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) + 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 19dc1ceb..b7f51a05 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,50 +22,59 @@ from Traducteur.parseur import FactNode from Traducteur.load import jdcSet from Traducteur.dictErreurs import ecritErreur from Traducteur import regles -debug=0 +debug = 0 -#----------------------------------- -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) +# ----------------------------------- +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) return -#-------------------------------------------- -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 : - jdc.splitLine(command.lineno,numcol) +# -------------------------------------------- +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: + jdc.splitLine(command.lineno, numcol) indice = -1 while texte[indice] == " " or texte[indice] == "\n": - indice = indice -1 - if texte[indice] != "," : texte=texte+"," - texteinfo=texte - texte=texte+'\n' - jdc.addLine(texte,command.lineno) - logging.info("Insertion de : %s ligne %d", texteinfo,command.lineno) - if numcol > 0 : # Les mots clefs etaient sur la meme ligne + indice = indice - 1 + if texte[indice] != ",": + texte = texte + "," + texteinfo = texte + texte = texte + "\n" + jdc.addLine(texte, command.lineno) + logging.info("Insertion de : %s ligne %d", texteinfo, command.lineno) + if numcol > 0: # Les mots clefs etaient sur la meme ligne jdc.joinLineandNext(command.lineno) -#------------------------------------------------------------- -def insereMotCleDansFacteur(jdc,facteur,texte,plusieursFois=True): -#---------------------------------------------------------------- - if debug : print ("insereMotCle ", texte , " dans ", facteur.name) - if texte[-1] == "\n" : texte=texte[0:-1] - ancien=jdc.getLine(facteur.lineno) +# ------------------------------------------------------------- +def insereMotCleDansFacteur(jdc, facteur, texte, plusieursFois=True): + # ---------------------------------------------------------------- + if debug: + print("insereMotCle ", texte, " dans ", facteur.name) + + if texte[-1] == "\n": + texte = texte[0:-1] + ancien = jdc.getLine(facteur.lineno) # On va chercher la derniere ) pour ajouter avant # on va verifier s il il y a un , avant @@ -73,217 +82,269 @@ def insereMotCleDansFacteur(jdc,facteur,texte,plusieursFois=True): # on en met une indice = -1 - while texte[indice] == " " : - indice = indice -1 - if texte[indice] != "," : - texte=texte+"," - if (texte.find("#") > -1) and (texte.find("#") < texte.find(",")) : - texte=texte+"\n," - - texteinfo=texte - texte=texte+"\n" - - ligneaCouper=facteur.lineno - while ligneaCouper < facteur.endline + 1 : - trouve=0 - trouveF=0 - trouveP=0 - indiceDeCoupe=0 - while ancien.find("_F") > 0 : - longueur=len(ancien) - indice=ancien.find("_F") - indiceParcours=0 + while texte[indice] == " ": + indice = indice - 1 + if texte[indice] != ",": + texte = texte + "," + if (texte.find("#") > -1) and (texte.find("#") < texte.find(",")): + texte = texte + "\n," + + texteinfo = texte + texte = texte + "\n" + + ligneaCouper = facteur.lineno + while ligneaCouper < facteur.endline + 1: + trouve = 0 + trouveF = 0 + trouveP = 0 + indiceDeCoupe = 0 + while ancien.find("_F") > 0: + longueur = len(ancien) + indice = ancien.find("_F") + indiceParcours = 0 # pour ne pas tenir compte des autres noms # Attention si 2 MCF sur la meme ligne (la 1ere) - if trouveF == 0 : - if ((ligneaCouper!=facteur.lineno) or ((ancien.find(facteur.name) < indice ) or (ancien.find(facteur.name) < 0))) : - trouveF=1 - indiceParcours=indice + 2 - # attention pour regler DEFI_FONCTION .. - else : - indiceDeCoupe=indiceDeCoupe+indice+2 - ancien=ancien[indice +2:] + if trouveF == 0: + if (ligneaCouper != facteur.lineno) or ( + (ancien.find(facteur.name) < indice) + or (ancien.find(facteur.name) < 0) + ): + trouveF = 1 + indiceParcours = indice + 2 + # attention pour regler DEFI_FONCTION .. + else: + indiceDeCoupe = indiceDeCoupe + indice + 2 + ancien = ancien[indice + 2 :] continue - if trouveF == 1 : - indiceDeCoupe=indiceDeCoupe+indice - # print "indice de Parcours" ,indiceParcours - # print ancien[indiceParcours] - # print ancien[indiceParcours+1] - # print ancien[indiceParcours+2] - while indiceParcours < longueur : - if ancien[indiceParcours] == "(" : - trouveP=1 - # print ("trouve". + if trouveF == 1: + indiceDeCoupe = indiceDeCoupe + indice + # print "indice de Parcours" ,indiceParcours + # print ancien[indiceParcours] + # print ancien[indiceParcours+1] + # print ancien[indiceParcours+2] + while indiceParcours < longueur: + if ancien[indiceParcours] == "(": + trouveP = 1 + # print ("trouve". break - if ancien[indiceParcours] != " " : - trouveP=0 - # print ("mouv") + if ancien[indiceParcours] != " ": + trouveP = 0 + # print ("mouv") break - indiceParcours = indiceParcours+1 + indiceParcours = indiceParcours + 1 trouve = trouveP * trouveF - if trouve : break - ancien=ancien[indice+1:] - if trouve : - debut=indiceDeCoupe + 3 - if(jdc.getLine(ligneaCouper)[debut:]!="\n"): - jdc.splitLine(ligneaCouper,debut) - jdc.addLine(texte,ligneaCouper) + if trouve: + break + ancien = ancien[indice + 1 :] + if trouve: + debut = indiceDeCoupe + 3 + if jdc.getLine(ligneaCouper)[debut:] != "\n": + jdc.splitLine(ligneaCouper, debut) + jdc.addLine(texte, ligneaCouper) jdc.joinLineandNext(ligneaCouper) - logging.info("Insertion de %s ligne %d", texteinfo,ligneaCouper) + logging.info("Insertion de %s ligne %d", texteinfo, ligneaCouper) # Gestion du cas particulier du mot clef facteur vide if facteur.childNodes == []: jdc.joinLineandNext(facteur.lineno) - ligneaCouper=ligneaCouper+1 - ancien=jdc.getLine(ligneaCouper) - if not plusieursFois and trouve : break - - -#----------------------------------- -def chercheDebut1Mot(jdc,command): -#----------------------------------- -# Retourne le numero de colonne si le 1er mot clef est -# sur la meme ligne que le mot clef facteur -# -1 sinon - assert (command.childNodes != []) - debut=-1 - node1=command.childNodes[0] - if hasattr(node1,"lineno"): - if node1.lineno == command.lineno : - debut=node1.colno + ligneaCouper = ligneaCouper + 1 + ancien = jdc.getLine(ligneaCouper) + if not plusieursFois and trouve: + break + + +# ----------------------------------- +def chercheDebut1Mot(jdc, command): + # ----------------------------------- + # Retourne le numero de colonne si le 1er mot clef est + # sur la meme ligne que le mot clef facteur + # -1 sinon + assert command.childNodes != [] + debut = -1 + node1 = command.childNodes[0] + if hasattr(node1, "lineno"): + if node1.lineno == command.lineno: + debut = node1.colno else: - debut=chercheDebutFacteur(jdc,command) - if debut == -1 and debug : print ("attention!!! pb pour trouver le debut dans ", command) + debut = chercheDebutFacteur(jdc, command) + if debut == -1 and debug: + print("attention!!! pb pour trouver le debut dans ", command) return debut -#----------------------------------- -def chercheDebutFacteur(jdc,facteur): -#----------------------------------- - debut=-1 - ligne=jdc.getLines()[facteur.lineno] - debut=ligne.find("_F") - if debut > -1 : debut=debut + 3 + +# ----------------------------------- +def chercheDebutFacteur(jdc, facteur): + # ----------------------------------- + debut = -1 + ligne = jdc.getLines()[facteur.lineno] + debut = ligne.find("_F") + if debut > -1: + debut = debut + 3 return debut -#----------------------------------- -def chercheAlignement(jdc,command): -#----------------------------------- -# Retourne le nb de blanc -# pour aligner sur le 1er mot clef fils - assert (command.childNodes != []) - node1=command.childNodes[0] - nbBlanc=node1.colno - return " "*nbBlanc - -#--------------------------------------------------------------------------------------------------------- -def chercheOperInsereFacteur(jdc,nomcommande,nouveau,ensemble=regles.SansRegle, estunFacteur=1, erreur=0): -#-------------------------------------------------------------------------------------------------------- -# Cherche l oper -# cree le texte -# appelle insereMotCle pour ajouter le texte -# - boolChange=0 - if estunFacteur : - texte=nouveau+"=_F()," - else : - texte=nouveau - if nomcommande not in jdcSet : return - commands= jdc.root.childNodes[:] +# ----------------------------------- +def chercheAlignement(jdc, command): + # ----------------------------------- + # Retourne le nb de blanc + # pour aligner sur le 1er mot clef fils + assert command.childNodes != [] + node1 = command.childNodes[0] + nbBlanc = node1.colno + return " " * nbBlanc + + +# --------------------------------------------------------------------------------------------------------- +def chercheOperInsereFacteur( + jdc, nomcommande, nouveau, ensemble=regles.SansRegle, estunFacteur=1, erreur=0 +): + # -------------------------------------------------------------------------------------------------------- + # Cherche l oper + # cree le texte + # appelle insereMotCle pour ajouter le texte + # + boolChange = 0 + if estunFacteur: + texte = nouveau + "=_F()," + else: + texte = nouveau + 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 - if erreur : ecritErreur((nomcommande,nouveau),c.lineno) - boolChange=1 - insereMotCle(jdc,c,texte) - if boolChange : jdc.reset(jdc.getSource()) - -#---------------------------------------------------------------------------------------- -def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles, estunFacteur=1): -#---------------------------------------------------------------------------------------- -# Cherche l oper -# 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,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): -#--------------------------------------------------------------------------------------------------------- - if nomcommande not in jdcSet : return - mesRegles=regles.ensembleRegles(liste_regles) - chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur,erreur=1) - -#------------------------------------------------------------------------------------------------- -def ajouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle, estunFacteur=0): -#------------------------------------------------------------------------------------------------- -# Cherche la commande -# Cherche le MCF -# 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[:] + if c.name != nomcommande: + continue + if ensemble.verif(c) == 0: + continue + if erreur: + ecritErreur((nomcommande, nouveau), c.lineno) + boolChange = 1 + insereMotCle(jdc, c, texte) + if boolChange: + jdc.reset(jdc.getSource()) + + +# ---------------------------------------------------------------------------------------- +def chercheOperInsereFacteurSiRegle( + jdc, nomcommande, nouveau, liste_regles, estunFacteur=1 +): + # ---------------------------------------------------------------------------------------- + # Cherche l oper + # 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, 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 +): + # --------------------------------------------------------------------------------------------------------- + if nomcommande not in jdcSet: + return + mesRegles = regles.ensembleRegles(liste_regles) + chercheOperInsereFacteur( + jdc, nomcommande, nouveau, mesRegles, estunFacteur, erreur=1 + ) + + +# ------------------------------------------------------------------------------------------------- +def ajouteMotClefDansFacteur( + jdc, commande, fact, nouveau, ensemble=regles.SansRegle, estunFacteur=0 +): + # ------------------------------------------------------------------------------------------------- + # Cherche la commande + # Cherche le MCF + # 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 + boolChange = 0 for c in commands: - if c.name != commande : continue + if c.name != commande: + continue for mcF in c.childNodes: - if mcF.name != fact : continue - if ensemble.verif(c) == 0 : continue - boolChange=1 - insereMotCleDansFacteur(jdc,mcF,texte) - 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) + if mcF.name != fact: + continue + if ensemble.verif(c) == 0: + continue + boolChange = 1 + insereMotCleDansFacteur(jdc, mcF, texte) + if boolChange: + jdc.reset(jdc.getSource()) -#------------------------------------------------------------------------------------------- -def ajouteMotClefDansFacteurCourantSiRegle(jdc,commande,fact,nouveau,liste_regles): -#------------------------------------------------------------------------------------------- -# - if commande not in jdcSet : return - ensemble=regles.ensembleRegles(liste_regles) - commands= jdc.root.childNodes[:] + +# ------------------------------------------------------------------------------------------- +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) + + +# ------------------------------------------------------------------------------------------- +def ajouteMotClefDansFacteurCourantSiRegle(jdc, commande, fact, nouveau, liste_regles): + # ------------------------------------------------------------------------------------------- + # + if commande not in jdcSet: + return + ensemble = regles.ensembleRegles(liste_regles) + commands = jdc.root.childNodes[:] commands.reverse() - boolChange=0 + boolChange = 0 for c in commands: - if c.name != commande : continue + if c.name != commande: + continue for mcF in c.childNodes: - if mcF.name != fact : continue - l=mcF.childNodes[:] + if mcF.name != fact: + continue + l = mcF.childNodes[:] l.reverse() for ll in l: - if ensemble.verif(ll) == 0 : continue - boolChange=1 - n=ll.childNodes[0] - ligneaCouper=n.lineno-1 - numcol=n.colno - jdc.splitLine(ligneaCouper+1,numcol) - texte=nouveau+",\n" - jdc.addLine(texte,ligneaCouper+1) - logging.info("Insertion de %s dans %s : ligne %d", nouveau,c.name,ligneaCouper+1) - if numcol > 0 : - jdc.joinLineandNext(ligneaCouper+1) - if boolChange : jdc.reset(jdc.getSource()) + if ensemble.verif(ll) == 0: + continue + boolChange = 1 + n = ll.childNodes[0] + ligneaCouper = n.lineno - 1 + numcol = n.colno + jdc.splitLine(ligneaCouper + 1, numcol) + texte = nouveau + ",\n" + jdc.addLine(texte, ligneaCouper + 1) + logging.info( + "Insertion de %s dans %s : ligne %d", + nouveau, + c.name, + ligneaCouper + 1, + ) + if numcol > 0: + jdc.joinLineandNext(ligneaCouper + 1) + if boolChange: + jdc.reset(jdc.getSource()) diff --git a/Traducteur/load.py b/Traducteur/load.py index f5aa5b52..3f2d8b96 100644 --- a/Traducteur/load.py +++ b/Traducteur/load.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,124 +23,129 @@ import re from Traducteur import parseur from Traducteur.mocles import parseKeywords -jdcSet=set() +jdcSet = set() class JDCTrad: """Cet objet conserve toutes les informations relatives a un fichier de commandes .comm""" - def __init__(self,src,atraiter): - #---------------------------------------- - self.atraiter=atraiter - self.init(src,atraiter) - commands= self.root.childNodes[:] + def __init__(self, src, atraiter): + # ---------------------------------------- + self.atraiter = atraiter + self.init(src, atraiter) + commands = self.root.childNodes[:] commands.reverse() for c in commands: jdcSet.add(c.name) - def init(self,src,atraiter): - #--------------------------- - # construction de self.lines - self.root=parseur.parser(src,atraiter) - self.lines=src.splitlines(1) + def init(self, src, atraiter): + # --------------------------- + # construction de self.lines + self.root = parseur.parser(src, atraiter) + self.lines = src.splitlines(1) def parseKeywords(self): - #----------------------- - # construction de fils (cf mocles.py) + # ----------------------- + # construction de fils (cf mocles.py) parseKeywords(self.root) - def reset(self,src): - #----------------------- - # reconstruction - self.init(src,self.atraiter) + def reset(self, src): + # ----------------------- + # reconstruction + self.init(src, self.atraiter) self.parseKeywords() def getSource(self): - #----------------------- - # retourne la concatenation de - # toutes les lignes - return "".join(self.getLines()) + # ----------------------- + # retourne la concatenation de + # toutes les lignes + return "".join(self.getLines()) - def getLine(self,linenum): - #----------------------- - # retourne la linenumieme ligne - return self.getLines()[linenum-1] + def getLine(self, linenum): + # ----------------------- + # retourne la linenumieme ligne + return self.getLines()[linenum - 1] def getLines(self): - #---------------------------- - # retourne toutes les lignes + # ---------------------------- + # retourne toutes les lignes return self.lines - def addLine(self,ligne,numero) : - #---------------------------- - # insere le texte contenu dans ligne - # dans la liste self.lines au rang numero - Ldebut=self.lines[0:numero] - Lmilieu=[ligne,] - Lfin=self.lines[numero:] - self.lines=Ldebut+Lmilieu+Lfin - - - def splitLine(self,numeroLigne,numeroColonne) : - #---------------------------------------------- - # coupe la ligne numeroLigne en 2 a numeroColonne - # ajoute des blancs en debut de 2nde Ligne pour - # aligner - numeroLigne = numeroLigne -1 - Ldebut=self.lines[0:numeroLigne] - if len(self.lines) > numeroLigne : - Lfin=self.lines[numeroLigne+1:] - else : - Lfin=[] - Lsplit=self.lines[numeroLigne] - LigneSplitDebut=Lsplit[0:numeroColonne]+"\n" - LigneSplitFin=" "*numeroColonne+Lsplit[numeroColonne:] - Lmilieu=[LigneSplitDebut,LigneSplitFin] - - self.lines=Ldebut+Lmilieu+Lfin - - def joinLineandNext(self,numeroLigne) : - #-------------------------------------- - # concatene les lignes numeroLigne et numeroLigne +1 - # enleve les blancs de debut de la ligne (numeroLigne +1) - Ldebut=self.lines[0:numeroLigne-1] - if len(self.lines) > numeroLigne : - Lfin=self.lines[numeroLigne+1:] - else : - Lfin=[] - - ligneMilieuDeb=self.lines[numeroLigne - 1 ] - ligneMilieuDeb=ligneMilieuDeb[0:-1] - ligneMilieuFin=self.lines[numeroLigne] + def addLine(self, ligne, numero): + # ---------------------------- + # insere le texte contenu dans ligne + # dans la liste self.lines au rang numero + Ldebut = self.lines[0:numero] + Lmilieu = [ + ligne, + ] + Lfin = self.lines[numero:] + self.lines = Ldebut + Lmilieu + Lfin + + def splitLine(self, numeroLigne, numeroColonne): + # ---------------------------------------------- + # coupe la ligne numeroLigne en 2 a numeroColonne + # ajoute des blancs en debut de 2nde Ligne pour + # aligner + numeroLigne = numeroLigne - 1 + Ldebut = self.lines[0:numeroLigne] + if len(self.lines) > numeroLigne: + Lfin = self.lines[numeroLigne + 1 :] + else: + Lfin = [] + Lsplit = self.lines[numeroLigne] + LigneSplitDebut = Lsplit[0:numeroColonne] + "\n" + LigneSplitFin = " " * numeroColonne + Lsplit[numeroColonne:] + Lmilieu = [LigneSplitDebut, LigneSplitFin] + + self.lines = Ldebut + Lmilieu + Lfin + + def joinLineandNext(self, numeroLigne): + # -------------------------------------- + # concatene les lignes numeroLigne et numeroLigne +1 + # enleve les blancs de debut de la ligne (numeroLigne +1) + Ldebut = self.lines[0 : numeroLigne - 1] + if len(self.lines) > numeroLigne: + Lfin = self.lines[numeroLigne + 1 :] + else: + Lfin = [] + + ligneMilieuDeb = self.lines[numeroLigne - 1] + ligneMilieuDeb = ligneMilieuDeb[0:-1] + ligneMilieuFin = self.lines[numeroLigne] for i in range(len(ligneMilieuFin)): - if ligneMilieuFin[i] != " " : - ligneMilieuFin=ligneMilieuFin[i:] + if ligneMilieuFin[i] != " ": + ligneMilieuFin = ligneMilieuFin[i:] break - Lmilieu=[ligneMilieuDeb+ligneMilieuFin,] + Lmilieu = [ + ligneMilieuDeb + ligneMilieuFin, + ] - self.lines=Ldebut+Lmilieu+Lfin + self.lines = Ldebut + Lmilieu + Lfin - def supLignes(self,debut,fin): - #------------------------ - Ldebut=self.lines[0:debut-1] - Lfin=self.lines[fin:] - self.lines=Ldebut+Lfin + def supLignes(self, debut, fin): + # ------------------------ + Ldebut = self.lines[0 : debut - 1] + Lfin = self.lines[fin:] + self.lines = Ldebut + Lfin - def remplaceLine(self,numeroLigne,nouveauTexte) : - #------------------------------------------------ - self.lines[numeroLigne]=nouveauTexte + def remplaceLine(self, numeroLigne, nouveauTexte): + # ------------------------------------------------ + self.lines[numeroLigne] = nouveauTexte -def getJDC(filename,atraiter): -#---------------------------- -# lit le JDC - f=open(filename) - src=f.read() + +def getJDC(filename, atraiter): + # ---------------------------- + # lit le JDC + f = open(filename) + src = f.read() f.close() - jdc=JDCTrad(src,atraiter) + jdc = JDCTrad(src, atraiter) return jdc -def getJDCFromTexte(texte,atraiter): -#----------------------------------- -# lit le JDC - jdc=JDCTrad(texte,atraiter) + +def getJDCFromTexte(texte, atraiter): + # ----------------------------------- + # lit le JDC + jdc = JDCTrad(texte, atraiter) return jdc diff --git a/Traducteur/log.py b/Traducteur/log.py index 9eb0e480..3e2833cf 100644 --- a/Traducteur/log.py +++ b/Traducteur/log.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,28 +20,30 @@ import logging import os -logger=logging.getLogger() + +logger = logging.getLogger() + def initialise(flog=None): - if flog == None : - MaDir=os.path.join(os.path.expanduser("~"),"Eficas_install") - try : + if flog == None: + MaDir = os.path.join(os.path.expanduser("~"), "Eficas_install") + try: os.mkdir(MaDir) - except : + except: pass - try : + try: os.listdir(MaDir) - flog=MaDir+"/convert.log" - except : - flog='/tmp/convert.log' + flog = MaDir + "/convert.log" + except: + flog = "/tmp/convert.log" - hdlr=logging.FileHandler(flog,'w') - formatter = logging.Formatter('%(levelname)s: %(message)s') + hdlr = logging.FileHandler(flog, "w") + formatter = logging.Formatter("%(levelname)s: %(message)s") hdlr.setFormatter(formatter) logger.addHandler(hdlr) logger.setLevel(logging.INFO) return hdlr -def ferme (hdlr) : +def ferme(hdlr): logger.removeHandler(hdlr) diff --git a/Traducteur/mocles.py b/Traducteur/mocles.py index 553c9526..29dedfa7 100644 --- a/Traducteur/mocles.py +++ b/Traducteur/mocles.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -18,150 +18,192 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -#import compiler +# import compiler import ast import types -from Traducteur.parseur import Keyword, FactNode, lastParen, lastParen2,maskStringsAndComments +from Traducteur.parseur import ( + Keyword, + FactNode, + lastParen, + lastParen2, + maskStringsAndComments, +) from Traducteur.visiteur import KeywordFinder, NodeVisitor from Traducteur.utils import indexToCoordinates, lineToDict, dictToLine -debug=0 +debug = 0 -#------------------------ -def parseFact(match,c,kw): -#------------------------ - submatch=match[2] - lastpar=match[0]+lastParen(c.src[match[0]:]) - #if type(submatch[0][0]) ==types.IntType: - if isinstance(submatch[0][0], int) : - #mot cle facteur isole - no=FactNode() + +# ------------------------ +def parseFact(match, c, kw): + # ------------------------ + submatch = match[2] + lastpar = match[0] + lastParen(c.src[match[0] :]) + # if type(submatch[0][0]) ==types.IntType: + if isinstance(submatch[0][0], int): + # mot cle facteur isole + no = FactNode() kw.addChild(no) - for ii in range(len(submatch)-1): - e=submatch[ii] - x,y=indexToCoordinates(c.src,e[0]) - lineno=y+c.lineno - colno=x - x,y=indexToCoordinates(c.src,submatch[ii+1][0]) - endline=y+c.lineno - endcol=x - no.addChild(Keyword(e[1],lineno,colno,endline,endcol)) - #last one - e=submatch[-1] - x,y=indexToCoordinates(c.src,e[0]) - lineno=y+c.lineno - colno=x - x,y=indexToCoordinates(c.src,lastpar-1) - endline=y+c.lineno - endcol=x - no.addChild(Keyword(e[1],lineno,colno,endline,endcol)) + for ii in range(len(submatch) - 1): + e = submatch[ii] + x, y = indexToCoordinates(c.src, e[0]) + lineno = y + c.lineno + colno = x + x, y = indexToCoordinates(c.src, submatch[ii + 1][0]) + endline = y + c.lineno + endcol = x + no.addChild(Keyword(e[1], lineno, colno, endline, endcol)) + # last one + e = submatch[-1] + x, y = indexToCoordinates(c.src, e[0]) + lineno = y + c.lineno + colno = x + x, y = indexToCoordinates(c.src, lastpar - 1) + endline = y + c.lineno + endcol = x + no.addChild(Keyword(e[1], lineno, colno, endline, endcol)) else: - #mot cle facteur multiple - ii=0 + # mot cle facteur multiple + ii = 0 for l in submatch: - lastpar=l[0][0]+lastParen2(c.src[l[0][0]:]) - ii=ii+1 - no=FactNode() + lastpar = l[0][0] + lastParen2(c.src[l[0][0] :]) + ii = ii + 1 + no = FactNode() kw.addChild(no) - for j in range(len(l)-1): - e=l[j] - x,y=indexToCoordinates(c.src,e[0]) - lineno=y+c.lineno - colno=x - x,y=indexToCoordinates(c.src,l[j+1][0]) - endline=y+c.lineno - endcol=x - no.addChild(Keyword(e[1],lineno,colno,endline,endcol)) - #last one - e=l[-1] - x,y=indexToCoordinates(c.src,e[0]) - lineno=y+c.lineno - colno=x - x,y=indexToCoordinates(c.src,lastpar-1) - endline=y+c.lineno - endcol=x - no.addChild(Keyword(e[1],lineno,colno,endline,endcol)) + for j in range(len(l) - 1): + e = l[j] + x, y = indexToCoordinates(c.src, e[0]) + lineno = y + c.lineno + colno = x + x, y = indexToCoordinates(c.src, l[j + 1][0]) + endline = y + c.lineno + endcol = x + no.addChild(Keyword(e[1], lineno, colno, endline, endcol)) + # last one + e = l[-1] + x, y = indexToCoordinates(c.src, e[0]) + lineno = y + c.lineno + colno = x + x, y = indexToCoordinates(c.src, lastpar - 1) + endline = y + c.lineno + endcol = x + no.addChild(Keyword(e[1], lineno, colno, endline, endcol)) -#----------------------- +# ----------------------- def parseKeywords(root): -#----------------------- + # ----------------------- """A partir d'un arbre contenant des commandes, ajoute les noeuds - fils correspondant aux mocles de la commande + fils correspondant aux mocles de la commande """ - #traceback.print_stack(limit=5) + # traceback.print_stack(limit=5) - matchFinder=KeywordFinder() + matchFinder = KeywordFinder() for c in root.childNodes: - if debug : print ('parse -------------- ', c.name) - maskedsrc=maskStringsAndComments(c.src) - #on supprime seulement les blancs du debut pour pouvoir compiler - #meme si la commande est sur plusieurs lignes seul le debut compte - #ast=compiler.parse(c.src.lstrip()) - #print ast - monAst=ast.parse(c.src.lstrip()) - if debug : print (ast.dump(monAst)) - #Ne pas supprimer les blancs du debut pour avoir les bons numeros de colonne + if debug: + print("parse -------------- ", c.name) + maskedsrc = maskStringsAndComments(c.src) + # on supprime seulement les blancs du debut pour pouvoir compiler + # meme si la commande est sur plusieurs lignes seul le debut compte + # ast=compiler.parse(c.src.lstrip()) + # print ast + monAst = ast.parse(c.src.lstrip()) + if debug: + print(ast.dump(monAst)) + # Ne pas supprimer les blancs du debut pour avoir les bons numeros de colonne matchFinder.reset(maskedsrc) matchFinder.visit(monAst) - if debug : print ("matchFinder.matches", matchFinder.matches) + if debug: + print("matchFinder.matches", matchFinder.matches) if len(matchFinder.matches) > 1: # plusieurs mocles trouves : # un mocle commence au debut du keyword (matchFinder.matches[i][0]) # et finit juste avant le keyword suivant # (matchFinder.matches[i+1][0]]) - for i in range(len(matchFinder.matches)-1): - if debug:print ("texte:",c.src[matchFinder.matches[i][0]:matchFinder.matches[i+1][0]]) - x,y=indexToCoordinates(c.src,matchFinder.matches[i][0]) - lineno=y+c.lineno - colno=x - x,y=indexToCoordinates(c.src,matchFinder.matches[i+1][0]) - endline=y+c.lineno - endcol=x - if debug:print (matchFinder.matches[i][0],matchFinder.matches[i][1],lineno,colno,endline,endcol) - kw=Keyword(matchFinder.matches[i][1],lineno,colno,endline,endcol) + for i in range(len(matchFinder.matches) - 1): + if debug: + print( + "texte:", + c.src[ + matchFinder.matches[i][0] : matchFinder.matches[i + 1][0] + ], + ) + x, y = indexToCoordinates(c.src, matchFinder.matches[i][0]) + lineno = y + c.lineno + colno = x + x, y = indexToCoordinates(c.src, matchFinder.matches[i + 1][0]) + endline = y + c.lineno + endcol = x + if debug: + print( + matchFinder.matches[i][0], + matchFinder.matches[i][1], + lineno, + colno, + endline, + endcol, + ) + kw = Keyword(matchFinder.matches[i][1], lineno, colno, endline, endcol) c.addChild(kw) - submatch= matchFinder.matches[i][2] + submatch = matchFinder.matches[i][2] if submatch: - parseFact(matchFinder.matches[i],c,kw) + parseFact(matchFinder.matches[i], c, kw) # dernier mocle : # il commence au debut du dernier keyword # (matchFinder.matches[i+1][0]) et # finit avant la parenthese fermante de la commande (c.lastParen) - if debug:print ("texte:",c.src[matchFinder.matches[i+1][0]:c.lastParen]) - x,y=indexToCoordinates(c.src,matchFinder.matches[i+1][0]) - lineno=y+c.lineno - colno=x - x,y=indexToCoordinates(c.src,c.lastParen) - endline=y+c.lineno - endcol=x - if debug:print (matchFinder.matches[i+1][0],matchFinder.matches[i+1][1],lineno,colno,endline,endcol) - kw=Keyword(matchFinder.matches[i+1][1],lineno,colno,endline,endcol) + if debug: + print("texte:", c.src[matchFinder.matches[i + 1][0] : c.lastParen]) + x, y = indexToCoordinates(c.src, matchFinder.matches[i + 1][0]) + lineno = y + c.lineno + colno = x + x, y = indexToCoordinates(c.src, c.lastParen) + endline = y + c.lineno + endcol = x + if debug: + print( + matchFinder.matches[i + 1][0], + matchFinder.matches[i + 1][1], + lineno, + colno, + endline, + endcol, + ) + kw = Keyword(matchFinder.matches[i + 1][1], lineno, colno, endline, endcol) c.addChild(kw) - submatch= matchFinder.matches[i+1][2] + submatch = matchFinder.matches[i + 1][2] if submatch: - parseFact(matchFinder.matches[i+1],c,kw) + parseFact(matchFinder.matches[i + 1], c, kw) elif len(matchFinder.matches) == 1: - #un seul mocle trouve : + # un seul mocle trouve : # il commence au debut du keyword (matchFinder.matches[0][0]) et # finit juste avant la parenthese fermante de la # commande (c.lastParen) - if debug:print ("texte:",c.src[matchFinder.matches[0][0]:c.lastParen]) - x,y=indexToCoordinates(c.src,matchFinder.matches[0][0]) - lineno=y+c.lineno - colno=x - x,y=indexToCoordinates(c.src,c.lastParen) - endline=y+c.lineno - endcol=x - if debug:print ( matchFinder.matches[0][0],matchFinder.matches[0][1],lineno,colno,endline,endcol) - kw=Keyword(matchFinder.matches[0][1],lineno,colno,endline,endcol) + if debug: + print("texte:", c.src[matchFinder.matches[0][0] : c.lastParen]) + x, y = indexToCoordinates(c.src, matchFinder.matches[0][0]) + lineno = y + c.lineno + colno = x + x, y = indexToCoordinates(c.src, c.lastParen) + endline = y + c.lineno + endcol = x + if debug: + print( + matchFinder.matches[0][0], + matchFinder.matches[0][1], + lineno, + colno, + endline, + endcol, + ) + kw = Keyword(matchFinder.matches[0][1], lineno, colno, endline, endcol) c.addChild(kw) - submatch= matchFinder.matches[0][2] + submatch = matchFinder.matches[0][2] if submatch: - parseFact(matchFinder.matches[0],c,kw) + parseFact(matchFinder.matches[0], c, kw) else: pass diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py index 4a43752f..1e4116c0 100644 --- a/Traducteur/movemocle.py +++ b/Traducteur/movemocle.py @@ -1,5 +1,5 @@ # -*- coding: iso-8859-1 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,324 +23,424 @@ from Traducteur import removemocle from Traducteur import inseremocle from Traducteur.parseur import lastParen from Traducteur.load import jdcSet -debug=0 -#----------------------------------------------------- -def moveMotCleFromFactToFather(jdc,command,fact,mocle): -#----------------------------------------------------- -# exemple type : IMPR_GENE +debug = 0 - if command not in jdcSet : return - boolChange=0 - commands= jdc.root.childNodes[:] + +# ----------------------------------------------------- +def moveMotCleFromFactToFather(jdc, command, fact, mocle): + # ----------------------------------------------------- + # exemple type : IMPR_GENE + + if command not in jdcSet: + return + boolChange = 0 + commands = jdc.root.childNodes[:] commands.reverse() for c in commands: - if c.name != command:continue - boolchange_c=0 + if c.name != command: + continue + boolchange_c = 0 for mc in c.childNodes: - if mc.name != fact:continue - l=mc.childNodes[:] + if mc.name != fact: + continue + l = mc.childNodes[:] for ll in l: for n in ll.childNodes: - if n.name != mocle:continue + 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_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) + if boolChange: + jdc.reset(jdc.getSource()) + removemocle.removeMotCleInFact(jdc, command, fact, mocle) -#---------------------------------------------------------------------------- -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) - removemocle.removeMotCleInFact(jdc,oper,factsource,mocle) +# ---------------------------------------------------------------------------- +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) + 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[:] +# ---------------------------------------------------------------------------- +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: - if c.name != oper : continue - cible=None + if c.name != oper: + continue + cible = None for mc in c.childNodes: - if mc.name != factcible : + if mc.name != factcible: continue - else : - cible=mc + else: + cible = mc break - if cible==None : - if debug : print ("Pas de changement pour ", oper, " ", factsource, " ",mocle, "cible non trouvée") + if cible == None: + if debug: + print( + "Pas de changement pour ", + oper, + " ", + factsource, + " ", + mocle, + "cible non trouvée", + ) continue for mc in c.childNodes: - source=None + source = None if mc.name != factsource: continue - else : - source=mc + else: + source = mc break - if source==None : - if debug : print ("Pas de changement pour ", oper, " ", factsource, " ",mocle, "source non trouvée") + if source == None: + if debug: + print( + "Pas de changement pour ", + oper, + " ", + factsource, + " ", + mocle, + "source non trouvée", + ) continue - if debug : print ("Changement pour ", oper, " ", factsource, " ",mocle, "cible et source trouvées") - l=source.childNodes[:] + if debug: + print( + "Changement pour ", + oper, + " ", + factsource, + " ", + mocle, + "cible et source trouvées", + ) + l = source.childNodes[:] for ll in l: for n in ll.childNodes: - if n.name != mocle:continue - MonTexte=n.getText(jdc); - inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte) - boolChange=1 - logging.info("Changement de place %s ligne %s vers %s",n.name, n.lineno, cible.name) - if boolChange : jdc.reset(jdc.getSource()) - removemocle.removeMotCleInFact(jdc,oper,factsource,mocle) - - + if n.name != mocle: + continue + MonTexte = n.getText(jdc) + inseremocle.insereMotCleDansFacteur(jdc, cible, MonTexte) + boolChange = 1 + logging.info( + "Changement de place %s ligne %s vers %s", + n.name, + n.lineno, + cible.name, + ) + if boolChange: + jdc.reset(jdc.getSource()) + removemocle.removeMotCleInFact(jdc, oper, factsource, mocle) -#----------------------------------------------------------------------- -def moveMotClefInOperToFact(jdc,oper,mocle,factcible,plusieursFois=True): -#----------------------------------------------------------------------- -# Attention le cas type est THETA_OLD dans calc_G +# ----------------------------------------------------------------------- +def moveMotClefInOperToFact(jdc, oper, mocle, factcible, plusieursFois=True): + # ----------------------------------------------------------------------- + # 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[:] + 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 + if c.name != oper: + continue + cible = None for mc in c.childNodes: - if mc.name != factcible : + if mc.name != factcible: continue - else : - cible=mc + else: + cible = mc break - if cible==None : - if debug : print ("Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée") + if cible == None: + if debug: + print( + "Pas de changement pour ", + oper, + " ", + factcible, + " ", + "cible non trouvée", + ) continue - source=None + source = None for mc in c.childNodes: if mc.name != mocle: continue - else : - source=mc + else: + source = mc break - if source==None : - if debug : print ("Pas de changement pour ", oper, " ", mocle, " source non trouvée") + 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,plusieursFois) - if boolChange : jdc.reset(jdc.getSource()) - removemocle.removeMotCle(jdc,oper,mocle) + MonTexte = source.getText(jdc) + boolChange = 1 + inseremocle.insereMotCleDansFacteur(jdc, cible, MonTexte, plusieursFois) + if boolChange: + jdc.reset(jdc.getSource()) + removemocle.removeMotCle(jdc, oper, mocle) + -#------------------------------------------------------ -def copyMotClefInOperToFact(jdc,oper,mocle,factcible): -#------------------------------------------------------ +# ------------------------------------------------------ +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[:] + 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 + if c.name != oper: + continue + cible = None for mc in c.childNodes: - if mc.name != factcible : + if mc.name != factcible: continue - else : - cible=mc + else: + cible = mc break - if cible==None : - if debug : print ("Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée") + if cible == None: + if debug: + print( + "Pas de changement pour ", + oper, + " ", + factcible, + " ", + "cible non trouvée", + ) continue - source=None + source = None for mc in c.childNodes: if mc.name != mocle: continue - else : - source=mc + else: + source = mc break - if source==None : - if debug : print ("Pas de changement pour ", oper, " ", mocle, " source non trouvée") + 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()) + 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[:] + +# ---------------------------------------------------------------------- +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 + 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 : + 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 fusionMotCleToFact(jdc,command,listeMc,factcible,defaut=0): -#----------------------------------------------------- - if command not in jdcSet : return - boolChange=0 - commands= jdc.root.childNodes[:] + +# ----------------------------------------------------- +def fusionMotCleToFact(jdc, command, listeMc, factcible, defaut=0): + # ----------------------------------------------------- + if command not in jdcSet: + return + boolChange = 0 + commands = jdc.root.childNodes[:] commands.reverse() for c in commands: - if c.name != command : continue - list_val=[] - trouveUnMC=0 + if c.name != command: + continue + list_val = [] + trouveUnMC = 0 for mc in c.childNodes: - if mc.name not in listeMc : continue - val=mc.getText(jdc).split("=")[1].split(",")[0] + if mc.name not in listeMc: + continue + val = mc.getText(jdc).split("=")[1].split(",")[0] list_val.append(val) - trouveUnMC=1 - if trouveUnMC : - TexteMC=factcible+"=(" - for val in list_val : TexteMC=TexteMC+val+"," - TexteMC=TexteMC[:-1]+")," - inseremocle.insereMotCle(jdc,c,TexteMC) + trouveUnMC = 1 + if trouveUnMC: + TexteMC = factcible + "=(" + for val in list_val: + TexteMC = TexteMC + val + "," + TexteMC = TexteMC[:-1] + ")," + inseremocle.insereMotCle(jdc, c, TexteMC) jdc.reset(jdc.getSource()) - boolChange=1 - if boolChange : + boolChange = 1 + if boolChange: jdc.reset(jdc.getSource()) - for mc in listeMc : - removemocle.removeMotCle(jdc,command,mc) + for mc in listeMc: + removemocle.removeMotCle(jdc, command, mc) jdc.reset(jdc.getSource()) -#----------------------------------------------------- -def fusionMotCleInFact(jdc,command,fact,listeMc,new_name,defaut=0): -#----------------------------------------------------- - if command not in jdcSet : return - boolChange=0 - commands= jdc.root.childNodes[:] + +# ----------------------------------------------------- +def fusionMotCleInFact(jdc, command, fact, listeMc, new_name, defaut=0): + # ----------------------------------------------------- + if command not in jdcSet: + return + boolChange = 0 + commands = jdc.root.childNodes[:] commands.reverse() for c in commands: - if c.name != command : continue - list_val=[] - trouveUnMC=0 + if c.name != command: + continue + list_val = [] + trouveUnMC = 0 for mcF in c.childNodes: - if mcF.name != fact: continue + if mcF.name != fact: + continue for ll in mcF.childNodes[:]: for mc in ll.childNodes: - if mc.name not in listeMc : continue - val=mc.getText(jdc).split("=")[1].split(",")[0] + if mc.name not in listeMc: + continue + val = mc.getText(jdc).split("=")[1].split(",")[0] list_val.append(val) - trouveUnMC=1 - if trouveUnMC : - TexteMC=new_name+"=("+",".join(list_val)+")," - inseremocle.insereMotCleDansFacteur(jdc,mcF,TexteMC) + trouveUnMC = 1 + if trouveUnMC: + TexteMC = new_name + "=(" + ",".join(list_val) + ")," + inseremocle.insereMotCleDansFacteur(jdc, mcF, TexteMC) jdc.reset(jdc.getSource()) - boolChange=1 - if boolChange : + boolChange = 1 + if boolChange: jdc.reset(jdc.getSource()) - for mc in listeMc : - removemocle.removeMotCleInFact(jdc,command,fact,mc) + for mc in listeMc: + removemocle.removeMotCleInFact(jdc, command, fact, mc) jdc.reset(jdc.getSource()) -#----------------------------------------------------- -def fusionMCFToMCF(jdc,command,listeMcF,factcible,defaut=0): -#----------------------------------------------------- - if command not in jdcSet : return - boolChange=0 - commands= jdc.root.childNodes[:] + +# ----------------------------------------------------- +def fusionMCFToMCF(jdc, command, listeMcF, factcible, defaut=0): + # ----------------------------------------------------- + if command not in jdcSet: + return + boolChange = 0 + commands = jdc.root.childNodes[:] commands.reverse() for c in commands: - if c.name != command : continue - list_val=[] - trouveUnMC=0 - TexteMC=factcible+'=(' - esp1=' '*len(TexteMC) - pp=0 + if c.name != command: + continue + list_val = [] + trouveUnMC = 0 + TexteMC = factcible + "=(" + esp1 = " " * len(TexteMC) + pp = 0 for mcF in c.childNodes: - if mcF.name not in listeMcF : continue - trouveUnMC=1 - val=mcF.getText(jdc) + if mcF.name not in listeMcF: + continue + trouveUnMC = 1 + val = mcF.getText(jdc) # esp=esp1+(inseremocle.chercheDebutFacteur(jdc,mcF)-len(mcF.name))*' ' - esp=esp1+inseremocle.chercheAlignement(jdc,c) + esp = esp1 + inseremocle.chercheAlignement(jdc, c) # print len(esp) for ll in mcF.childNodes[:]: # if(pp>0): TexteMC+=esp - TexteMC+='_F(' + TexteMC += "_F(" for mc in ll.childNodes: - val=mc.getText(jdc) - TexteMC+=val+'\n '+esp + val = mc.getText(jdc) + TexteMC += val + "\n " + esp # if('#' in val.split('\n')[-1]): TexteMC+='\n'+esp+' ' - lastkey = ''.join(val.split('=')[-1].split(' ')) - if((len(lastkey.split('(')) - len(lastkey.split(')'))) >= 0): - TexteMC += '),\n'+esp + lastkey = "".join(val.split("=")[-1].split(" ")) + if (len(lastkey.split("(")) - len(lastkey.split(")"))) >= 0: + TexteMC += "),\n" + esp # TexteMC+='),' - TexteMC+='),' + TexteMC += ")," # print TexteMC - if(trouveUnMC): - inseremocle.insereMotCle(jdc,c,TexteMC) + if trouveUnMC: + inseremocle.insereMotCle(jdc, c, TexteMC) jdc.reset(jdc.getSource()) - boolChange=1 - if boolChange : + boolChange = 1 + if boolChange: jdc.reset(jdc.getSource()) - for mcF in listeMcF : - removemocle.removeMotCle(jdc,command,mcF) + for mcF in listeMcF: + removemocle.removeMotCle(jdc, command, mcF) jdc.reset(jdc.getSource()) - -#-------------------------------------------------------------------- -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 +# -------------------------------------------------------------------- +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 + 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()) + 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/parseur.py b/Traducteur/parseur.py index 2635b9ab..c985fef4 100644 --- a/Traducteur/parseur.py +++ b/Traducteur/parseur.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -17,182 +17,211 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -import re,string +import re, string -debug=0 +debug = 0 escapedQuotesRE = re.compile(r"(\\\\|\\\"|\\\')") -stringsAndCommentsRE = \ - re.compile("(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|\'[^\']*\'|#.*?\n)", re.DOTALL) +stringsAndCommentsRE = re.compile( + "(\"\"\".*?\"\"\"|'''.*?'''|\"[^\"]*\"|'[^']*'|#.*?\n)", re.DOTALL +) import six -if six.PY2 : - allchars = string.maketrans(u"", "") - allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:] - allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline)) -else : - allchars=bytes.maketrans(b"",b"") - allcharsExceptNewline = allchars[: allchars.index(b'\n')]+allchars[allchars.index(b'\n')+1:] - allcharsExceptNewlineTranstable = bytes.maketrans(allcharsExceptNewline, b'*'*len(allcharsExceptNewline)) - -#------------------------------ +if six.PY2: + allchars = string.maketrans("", "") + allcharsExceptNewline = ( + allchars[: allchars.index("\n")] + allchars[allchars.index("\n") + 1 :] + ) + allcharsExceptNewlineTranstable = string.maketrans( + allcharsExceptNewline, "*" * len(allcharsExceptNewline) + ) +else: + allchars = bytes.maketrans(b"", b"") + allcharsExceptNewline = ( + allchars[: allchars.index(b"\n")] + allchars[allchars.index(b"\n") + 1 :] + ) + allcharsExceptNewlineTranstable = bytes.maketrans( + allcharsExceptNewline, b"*" * len(allcharsExceptNewline) + ) + + +# ------------------------------ def maskStringsAndComments(src): -#------------------------------ - """Remplace tous les caracteres dans commentaires et strings par des * """ + # ------------------------------ + """Remplace tous les caracteres dans commentaires et strings par des *""" src = escapedQuotesRE.sub("**", src) allstrings = stringsAndCommentsRE.split(src) # every odd element is a string or comment for i in range(1, len(allstrings), 2): - if allstrings[i].startswith("'''")or allstrings[i].startswith('"""'): - allstrings[i] = allstrings[i][:3]+ \ - allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable)+ \ - allstrings[i][-3:] + if allstrings[i].startswith("'''") or allstrings[i].startswith('"""'): + allstrings[i] = ( + allstrings[i][:3] + + allstrings[i][3:-3].translate(allcharsExceptNewlineTranstable) + + allstrings[i][-3:] + ) else: - allstrings[i] = allstrings[i][0]+ \ - allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable)+ \ - allstrings[i][-1] + allstrings[i] = ( + allstrings[i][0] + + allstrings[i][1:-1].translate(allcharsExceptNewlineTranstable) + + allstrings[i][-1] + ) return "".join(allstrings) -#un nombre queconque de blancs,un nom,des blancs -pattern_oper = re.compile(r"^\s*(.*?=\s*)?([a-zA-Z_]\w*)(\s*)(\()(.*)",re.DOTALL) -pattern_proc = re.compile(r"^\s*([a-zA-Z_]\w*)(\s*)(\()(.*)",re.DOTALL) -implicitContinuationChars = (('(', ')'), ('[', ']'), ('{', '}')) +# un nombre queconque de blancs,un nom,des blancs +pattern_oper = re.compile(r"^\s*(.*?=\s*)?([a-zA-Z_]\w*)(\s*)(\()(.*)", re.DOTALL) +pattern_proc = re.compile(r"^\s*([a-zA-Z_]\w*)(\s*)(\()(.*)", re.DOTALL) + +implicitContinuationChars = (("(", ")"), ("[", "]"), ("{", "}")) linecontinueRE = re.compile(r"\\\s*(#.*)?$") -emptyHangingBraces = [0,0,0,0,0] +emptyHangingBraces = [0, 0, 0, 0, 0] + + +# -------------------------------------- +class UnbalancedBracesException: + pass + + +# -------------------------------------- -#-------------------------------------- -class UnbalancedBracesException: pass -#-------------------------------------- -#----------- +# ----------- class Node: -#----------- + # ----------- def __init__(self): - self.childNodes=[] + self.childNodes = [] - def addChild(self,node): + def addChild(self, node): self.childNodes.append(node) -#------------------- +# ------------------- class FactNode(Node): -#------------------- + # ------------------- pass -#------------------- +# ------------------- class JDCNode(Node): -#------------------- - def __init__(self,src): + # ------------------- + def __init__(self, src): Node.__init__(self) - self.src=src + self.src = src -#------------------- + +# ------------------- class Command(Node): -#------------------- - def __init__(self,name,lineno,colno,firstparen): + # ------------------- + def __init__(self, name, lineno, colno, firstparen): Node.__init__(self) - self.name=name - self.lineno=lineno - self.colno=colno - self.firstparen=firstparen + self.name = name + self.lineno = lineno + self.colno = colno + self.firstparen = firstparen + -#------------------- +# ------------------- class Keyword(Node): -#------------------- - def __init__(self,name,lineno,colno,endline,endcol): + # ------------------- + def __init__(self, name, lineno, colno, endline, endcol): Node.__init__(self) - self.name=name - self.lineno=lineno - self.colno=colno - self.endline=endline - self.endcol=endcol + self.name = name + self.lineno = lineno + self.colno = colno + self.endline = endline + self.endcol = endcol - def getText(self,jdc): + def getText(self, jdc): if self.endline > self.lineno: - debut=jdc.getLines()[self.lineno-1][self.colno:] - fin = jdc.getLines()[self.endline-1][:self.endcol] - texte=debut - lignecourante=self.lineno - while lignecourante < self.endline -1 : + debut = jdc.getLines()[self.lineno - 1][self.colno :] + fin = jdc.getLines()[self.endline - 1][: self.endcol] + texte = debut + lignecourante = self.lineno + while lignecourante < self.endline - 1: texte = texte + jdc.getLines()[lignecourante] lignecourante = lignecourante + 1 - if chaineBlanche(fin) == 0 : - texte=texte + fin - if texte[-1] == "\n" : - texte=texte[0:-1] + if chaineBlanche(fin) == 0: + texte = texte + fin + if texte[-1] == "\n": + texte = texte[0:-1] else: - texte = jdc.getLines()[self.lineno-1][self.colno:self.endcol] + texte = jdc.getLines()[self.lineno - 1][self.colno : self.endcol] return texte -#------------------------- -def chaineBlanche(texte) : -#------------------------- -# retourne 1 si la chaine est composee de " " -# retourne 0 sinon - bool = 1 ; - for i in range(len(texte)) : - if texte[i] != " " : bool = 0 + +# ------------------------- +def chaineBlanche(texte): + # ------------------------- + # retourne 1 si la chaine est composee de " " + # retourne 0 sinon + bool = 1 + for i in range(len(texte)): + if texte[i] != " ": + bool = 0 return bool -#------------------- + +# ------------------- def printNode(node): -#------------------- - if hasattr(node,'name'): - print (node.name) + # ------------------- + if hasattr(node, "name"): + print(node.name) else: - print ("pas de nom pour:",node) + print("pas de nom pour:", node) for c in node.childNodes: printNode(c) -#------------------------ -def parser(src,atraiter): -#------------------------ + +# ------------------------ +def parser(src, atraiter): + # ------------------------ """Parse le texte src et retourne un arbre syntaxique (root). - Cet arbre syntaxique a comme noeuds (childNodes) les commandes a traiter (liste atraiter) + Cet arbre syntaxique a comme noeuds (childNodes) les commandes a traiter (liste atraiter) """ - lines=src.splitlines(1) - maskedSrc=maskStringsAndComments(src) - maskedLines=maskedSrc.splitlines(1) + lines = src.splitlines(1) + maskedSrc = maskStringsAndComments(src) + maskedLines = maskedSrc.splitlines(1) - root=JDCNode(src) + root = JDCNode(src) # (a) dans un premier temps on extrait les commandes et on les insere # dans un arbre (root) les noeuds fils sont stockes dans # root.childNodes (liste) - lineno=0 + lineno = 0 for line in maskedLines: - lineno=lineno+1 - if debug:print ("line",lineno,":",line) - m=pattern_proc.match(line) + lineno = lineno + 1 + if debug: + print("line", lineno, ":", line) + m = pattern_proc.match(line) if m and (m.group(1) in atraiter): - if debug:print (m.start(3),m.end(3),m.start(4)) - root.addChild(Command(m.group(1),lineno,m.start(1),m.end(3))) + if debug: + print(m.start(3), m.end(3), m.start(4)) + root.addChild(Command(m.group(1), lineno, m.start(1), m.end(3))) else: - m=pattern_oper.match(line) + m = pattern_oper.match(line) if m and (m.group(2) in atraiter): - root.addChild(Command(m.group(2),lineno,m.start(2),m.end(4))) + root.addChild(Command(m.group(2), lineno, m.start(2), m.end(4))) - #(b) dans un deuxieme temps , on recupere le texte complet de la commande + # (b) dans un deuxieme temps , on recupere le texte complet de la commande # jusqu'a la derniere parenthese fermante # iterateur sur les lignes physiques masquees - iterlines=iter(maskedLines) + iterlines = iter(maskedLines) - linenum=0 + linenum = 0 for c in root.childNodes: - lineno=c.lineno - colno=c.colno # debut de la commande + lineno = c.lineno + colno = c.colno # debut de la commande while linenum < lineno: - line=iterlines.__next__() - linenum=linenum+1 + line = iterlines.__next__() + linenum = linenum + 1 if linenum != lineno: - if debug:print ("line %s:"%linenum, line) + if debug: + print("line %s:" % linenum, line) tmp = [] hangingBraces = list(emptyHangingBraces) hangingComments = 0 @@ -202,8 +231,9 @@ def parser(src,atraiter): contchar = implicitContinuationChars[i] numHanging = hangingBraces[i] - hangingBraces[i] = numHanging+line.count(contchar[0]) - \ - line.count(contchar[1]) + hangingBraces[i] = ( + numHanging + line.count(contchar[0]) - line.count(contchar[1]) + ) hangingComments ^= line.count('"""') % 2 hangingComments ^= line.count("'''") % 2 @@ -212,69 +242,71 @@ def parser(src,atraiter): raise UnbalancedBracesException() if linecontinueRE.search(line): - tmp.append(lines[linenum-1]) + tmp.append(lines[linenum - 1]) elif hangingBraces != emptyHangingBraces: - tmp.append(lines[linenum-1]) + tmp.append(lines[linenum - 1]) elif hangingComments: - tmp.append(lines[linenum-1]) + tmp.append(lines[linenum - 1]) else: - tmp.append(lines[linenum-1]) - src="".join(tmp) - c.src=src - c.endline=linenum - decal=len(line)-line.rindex(')') - c.lastParen=len(src)-decal - if debug:print ("logical line %s %s:" % (c.lineno,c.endline),src) + tmp.append(lines[linenum - 1]) + src = "".join(tmp) + c.src = src + c.endline = linenum + decal = len(line) - line.rindex(")") + c.lastParen = len(src) - decal + if debug: + print("logical line %s %s:" % (c.lineno, c.endline), src) break - line=iterlines.__next__() - linenum=linenum+1 + line = iterlines.__next__() + linenum = linenum + 1 return root -#----------------- +# ----------------- def lastParen(src): -#----------------- + # ----------------- """Retourne la position de la derniere parenthese fermante dans src a partir du debut de la string - La string doit contenir la premiere parenthese ouvrante + La string doit contenir la premiere parenthese ouvrante """ - src=maskStringsAndComments(src) - level=0 - i,n=0,len(src) + src = maskStringsAndComments(src) + level = 0 + i, n = 0, len(src) while i < n: - ch=src[i] - i=i+1 - if ch in ('(','['): - level=level+1 - if ch in (')',']'): + ch = src[i] + i = i + 1 + if ch in ("(", "["): + level = level + 1 + if ch in (")", "]"): if level == 0: raise UnbalancedBracesException() - level=level-1 + level = level - 1 if level == 0: - #derniere parenthese fermante + # derniere parenthese fermante return i -#------------------- + +# ------------------- def lastParen2(src): -#------------------- + # ------------------- """Retourne la position de la derniere parenthese fermante dans src a partir du debut de la string - La string ne contient pas la premiere parenthese ouvrante + La string ne contient pas la premiere parenthese ouvrante """ - src=maskStringsAndComments(src) - level=1 - i,n=0,len(src) + src = maskStringsAndComments(src) + level = 1 + i, n = 0, len(src) while i < n: - ch=src[i] - i=i+1 - if ch in ('(','['): - level=level+1 - if ch in (')',']'): + ch = src[i] + i = i + 1 + if ch in ("(", "["): + level = level + 1 + if ch in (")", "]"): if level == 0: raise UnbalancedBracesException() - level=level-1 + level = level - 1 if level == 0: - #derniere parenthese fermante + # derniere parenthese fermante return i diff --git a/Traducteur/regles.py b/Traducteur/regles.py index a8f78215..af94c7d1 100644 --- a/Traducteur/regles.py +++ b/Traducteur/regles.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,51 +23,56 @@ Définition des règles debug = 0 -#-------------------- -class ensembleRegles : -#-------------------- + +# -------------------- +class ensembleRegles: + # -------------------- """ Ensemble des règles """ + def __init__(self, liste_regles): self.liste = [] - for item in liste_regles : + for item in liste_regles: args, clefRegle = item r = regle(clefRegle, args) self.liste.append(r) - def verif(self, commande) : + def verif(self, commande): """ Vérification """ bool = 1 - for regle in self.liste : + for regle in self.liste: result = regle.verif(commande) - bool = bool*result + bool = bool * result return bool -#-------------------------------- + +# -------------------------------- class pasDeRegle(ensembleRegles): -#-------------------------------- + # -------------------------------- """ Pas de règle """ - def __init__(self) : + + def __init__(self): pass - def verif (self, commande) : + def verif(self, commande): """ Vérification """ return 1 -#------------ -class regle : -#------------ +# ------------ +class regle: + # ------------ """ Règle """ + def __init__(self, clef_regle, args): self.fonction = dictionnaire_regle[clef_regle] self.list_args = args @@ -80,49 +85,56 @@ class regle : f = self.fonction(self.list_args) return f.verif(commande) -#--------------------- -class existeMCFParmi : -#--------------------- + +# --------------------- +class existeMCFParmi: + # --------------------- """ Existence du mot-clé facteur parmi la liste """ + def __init__(self, list_arg): self.listeMCF = list_arg - def verif(self, commande) : + def verif(self, commande): """ Vérification """ bool = 0 - for c in commande.childNodes : - if c.name in self.listeMCF : + for c in commande.childNodes: + if c.name in self.listeMCF: bool = 1 break return bool -#--------------------- -class nexistepasMCFParmi(existeMCFParmi) : -#--------------------- + +# --------------------- +class nexistepasMCFParmi(existeMCFParmi): + # --------------------- """ Existence du mot-clé facteur parmi la liste """ + def __init__(self, list_arg): self.listeMCF = list_arg - def verif(self, commande) : + def verif(self, commande): """ Vérification """ bool = existeMCFParmi.verif(self, commande) - if bool : return 0 + if bool: + return 0 return 1 -#---------------------- -class existeMCsousMCF : -#---------------------- + +# ---------------------- +class existeMCsousMCF: + # ---------------------- """ Existence du mot-clé simple sous le mot-clé facteur """ + def __init__(self, list_arg): self.liste = list_arg self.MCF = self.liste[0] @@ -133,22 +145,26 @@ class existeMCsousMCF : Vérification """ bool = 0 - for mcf in commande.childNodes : - if mcf.name != self.MCF : continue + 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 + if mc.name != self.MC: + continue bool = 1 return bool -#---------------------- -class existeMCsousMCFcourant : -#---------------------- + +# ---------------------- +class existeMCsousMCFcourant: + # ---------------------- """ Existence du mot-clé simple sous le mot-clé facteur courant """ + def __init__(self, list_arg): self.liste = list_arg self.MC = self.liste[0] @@ -161,52 +177,59 @@ class existeMCsousMCFcourant : l = mcf.childNodes[:] l.reverse() for mc in l: - if mc.name != self.MC : continue + if mc.name != self.MC: + continue bool = 1 return bool -#----------------------------------------- + +# ----------------------------------------- class nexistepasMCsousMCF(existeMCsousMCF): -#----------------------------------------- + # ----------------------------------------- """ Absence du mot-clé simple sous le mot-clé facteur """ + def __init__(self, list_arg): existeMCsousMCF.__init__(self, list_arg) - def verif(self, commande): """ Vérification """ bool = existeMCsousMCF.verif(self, commande) - if bool : return 0 + if bool: + return 0 return 1 -#----------------------------------------- + +# ----------------------------------------- class nexistepasMCsousMCFcourant(existeMCsousMCFcourant): -#----------------------------------------- + # ----------------------------------------- """ Absence du mot-clé simple sous le mot-clé facteur courant """ + def __init__(self, list_arg): existeMCsousMCFcourant.__init__(self, list_arg) - def verif(self, commande): """ Vérification """ bool = existeMCsousMCFcourant.verif(self, commande) - if bool : return 0 + if bool: + return 0 return 1 -#------------- -class existe : -#-------------- + +# ------------- +class existe: + # -------------- """ Existence du mot-clé simple """ + def __init__(self, list_arg): self.genea = list_arg @@ -214,12 +237,14 @@ class existe : """ Recherche du mot """ - if commande == None : return 0 - if niveau == len(self.genea) : return 1 + if commande == None: + return 0 + if niveau == len(self.genea): + return 1 texte = self.genea[niveau] - for c in commande.childNodes : - if c.name == texte : - niveau = niveau+1 + for c in commande.childNodes: + if c.name == texte: + niveau = niveau + 1 return self.chercheMot(niveau, c) return None @@ -228,15 +253,18 @@ class existe : Vérification """ bool = self.chercheMot(0, commande) - if bool == None : bool = 0 + if bool == None: + bool = 0 return bool -#------------- -class nexistepas : -#-------------- + +# ------------- +class nexistepas: + # -------------- """ Absence du mot-clé simple """ + def __init__(self, list_arg): self.genea = list_arg @@ -244,12 +272,14 @@ class nexistepas : """ Recherche du mot """ - if commande == None : return 0 - if niveau == len(self.genea) : return 1 + if commande == None: + return 0 + if niveau == len(self.genea): + return 1 texte = self.genea[niveau] - for c in commande.childNodes : - if c.name == texte : - niveau = niveau+1 + for c in commande.childNodes: + if c.name == texte: + niveau = niveau + 1 return self.chercheMot(niveau, c) return None @@ -258,17 +288,20 @@ class nexistepas : Vérification """ bool = self.chercheMot(0, commande) - if bool : return 0 + if bool: + return 0 return 1 -#------------------------------- -class MCsousMCFaPourValeur : -#------------------------------ + +# ------------------------------- +class MCsousMCFaPourValeur: + # ------------------------------ """ Égalité du mot-clé simple à une valeur sous le mot-clé facteur """ + def __init__(self, list_arg): - assert (len(list_arg)==4) + assert len(list_arg) == 4 self.genea = list_arg[0:-2] self.MCF = list_arg[0] self.MC = list_arg[1] @@ -280,26 +313,31 @@ class MCsousMCFaPourValeur : Vérification """ bool = 0 - for mcf in commande.childNodes : - if mcf.name != self.MCF : continue + 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 + if mc.name != self.MC: + continue TexteMC = mc.getText(self.Jdc) - if (TexteMC.find(self.Val) < 0 ): continue + if TexteMC.find(self.Val) < 0: + continue bool = 1 return bool -#------------------------------- -class MCsousMCFcourantaPourValeur : -#------------------------------ + +# ------------------------------- +class MCsousMCFcourantaPourValeur: + # ------------------------------ """ Égalité du mot-clé simple à une valeur sous le mot-clé facteur courant """ + def __init__(self, list_arg): - assert (len(list_arg)==3) + assert len(list_arg) == 3 self.genea = list_arg[0:-1] self.MC = list_arg[0] self.Val = list_arg[1] @@ -313,22 +351,25 @@ class MCsousMCFcourantaPourValeur : l = mcf.childNodes[:] l.reverse() for mc in l: - if mc.name != self.MC : continue + if mc.name != self.MC: + continue TexteMC = mc.getText(self.Jdc) - if (TexteMC.find(self.Val) < 0 ): continue + if TexteMC.find(self.Val) < 0: + continue bool = 1 return bool -#----------------------------- -class MCsousMCFaPourValeurDansListe : -#---------------------------- +# ----------------------------- +class MCsousMCFaPourValeurDansListe: + # ---------------------------- """ Égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ + def __init__(self, list_arg): - assert (len(list_arg)==4) + assert len(list_arg) == 4 self.genea = list_arg[0:-2] self.MCF = list_arg[0] self.MC = list_arg[1] @@ -340,28 +381,33 @@ class MCsousMCFaPourValeurDansListe : Vérification """ bool = 0 - for mcf in commande.childNodes : - if mcf.name != self.MCF : continue + 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 + if mc.name != self.MC: + continue TexteMC = mc.getText(self.Jdc) for Val in self.LVal: - if (TexteMC.find(Val) < 0 ): continue + if TexteMC.find(Val) < 0: + continue bool = 1 return bool -#----------------------------- -class MCsousMCFcourantaPourValeurDansListe : -#---------------------------- + +# ----------------------------- +class MCsousMCFcourantaPourValeurDansListe: + # ---------------------------- """ Égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ + def __init__(self, list_arg): - assert (len(list_arg)==3) + assert len(list_arg) == 3 self.genea = list_arg[0:-1] self.MC = list_arg[0] self.LVal = list_arg[1] @@ -375,53 +421,61 @@ class MCsousMCFcourantaPourValeurDansListe : l = mcf.childNodes[:] l.reverse() for mc in l: - if mc.name != self.MC : continue + if mc.name != self.MC: + continue TexteMC = mc.getText(self.Jdc) for Val in self.LVal: - if (TexteMC.find(Val) < 0 ): continue + if TexteMC.find(Val) < 0: + continue bool = 1 return bool -#----------------------------------------- -class MCsousMCFcourantnaPasPourValeurDansListe(MCsousMCFcourantaPourValeurDansListe) : -#----------------------------------------- + +# ----------------------------------------- +class MCsousMCFcourantnaPasPourValeurDansListe(MCsousMCFcourantaPourValeurDansListe): + # ----------------------------------------- """ Non égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ + def __init__(self, list_arg): MCsousMCFcourantaPourValeurDansListe.__init__(self, list_arg) - def verif(self, commande): bool = MCsousMCFcourantaPourValeurDansListe.verif(self, commande) - if bool : return 0 + if bool: + return 0 return 1 -#----------------------------------------- -class MCsousMCFnaPasPourValeurDansListe(MCsousMCFaPourValeurDansListe) : -#----------------------------------------- + +# ----------------------------------------- +class MCsousMCFnaPasPourValeurDansListe(MCsousMCFaPourValeurDansListe): + # ----------------------------------------- """ Non égalité du mot-clé simple à une valeur dans une liste sous le mot-clé facteur """ + def __init__(self, list_arg): MCsousMCFaPourValeurDansListe.__init__(self, list_arg) - def verif(self, commande): bool = MCsousMCFaPourValeurDansListe.verif(self, commande) - if bool : return 0 + if bool: + return 0 return 1 -#------------------------------ -class MCaPourValeur : -#------------------------------ + +# ------------------------------ +class MCaPourValeur: + # ------------------------------ """ Égalité du mot-clé à une valeur """ + def __init__(self, list_arg): - assert (len(list_arg)==3) + assert len(list_arg) == 3 self.MC = list_arg[0] self.Val = list_arg[1] self.Jdc = list_arg[2] @@ -431,19 +485,23 @@ class MCaPourValeur : Vérification """ bool = 0 - for mc in commande.childNodes : - if mc.name != self.MC : continue + for mc in commande.childNodes: + if mc.name != self.MC: + continue TexteMC = mc.getText(self.Jdc) - if (TexteMC.find(self.Val) < 0 ): continue + if TexteMC.find(self.Val) < 0: + continue bool = 1 return bool -#----------------------------------------- -class MCnaPasPourValeur(MCaPourValeur) : -#----------------------------------------- + +# ----------------------------------------- +class MCnaPasPourValeur(MCaPourValeur): + # ----------------------------------------- """ - Non égalité du mot-clé à une valeur + Non égalité du mot-clé à une valeur """ + def __init__(self, list_arg): MCaPourValeur.__init__(self, list_arg) @@ -452,17 +510,20 @@ class MCnaPasPourValeur(MCaPourValeur) : Vérification """ bool = MCaPourValeur.verif(self, commande) - if bool : return 0 + if bool: + return 0 return 1 -#------------------------------ -class MCaPourValeurDansListe : -#------------------------------ + +# ------------------------------ +class MCaPourValeurDansListe: + # ------------------------------ """ Égalité du mot-clé à une valeur dans une liste """ + def __init__(self, list_arg): - assert (len(list_arg)==3) + assert len(list_arg) == 3 self.MC = list_arg[0] self.LVal = list_arg[1] self.Jdc = list_arg[2] @@ -472,24 +533,28 @@ class MCaPourValeurDansListe : Vérification """ bool = 0 - for mc in commande.childNodes : - if mc.name != self.MC : continue + for mc in commande.childNodes: + if mc.name != self.MC: + continue TexteMC = mc.getText(self.Jdc) - #print "TexteMC=",type(TexteMC),TexteMC - #print "LVal=",type(self.LVal),self.LVal + # print "TexteMC=",type(TexteMC),TexteMC + # print "LVal=",type(self.LVal),self.LVal for Val in self.LVal: - #print "Val=",type(Val),Val - #print "Find",TexteMC.find(Val) - if (TexteMC.find(Val) < 0 ): continue + # print "Val=",type(Val),Val + # print "Find",TexteMC.find(Val) + if TexteMC.find(Val) < 0: + continue bool = 1 return bool -#----------------------------------------- -class MCnaPasPourValeurDansListe(MCaPourValeurDansListe) : -#----------------------------------------- + +# ----------------------------------------- +class MCnaPasPourValeurDansListe(MCaPourValeurDansListe): + # ----------------------------------------- """ - Non égalité du mot-clé à une valeur dans une liste + Non égalité du mot-clé à une valeur dans une liste """ + def __init__(self, list_arg): MCaPourValeurDansListe.__init__(self, list_arg) @@ -498,27 +563,31 @@ class MCnaPasPourValeurDansListe(MCaPourValeurDansListe) : Vérification """ bool = MCaPourValeurDansListe.verif(self, commande) - if bool : return 0 + if bool: + return 0 return 1 -dictionnaire_regle = {"existe":existe, - "nexistepas":nexistepas, - "existeMCFParmi":existeMCFParmi, - "nexistepasMCFParmi":nexistepasMCFParmi, - "existeMCsousMCF":existeMCsousMCF, - "nexistepasMCsousMCF":nexistepasMCsousMCF, - "MCsousMCFaPourValeur":MCsousMCFaPourValeur, - "MCsousMCFaPourValeurDansListe":MCsousMCFaPourValeurDansListe, - "MCaPourValeur":MCaPourValeur, - "MCnaPasPourValeur":MCnaPasPourValeur, - "existeMCsousMCFcourant":existeMCsousMCFcourant, - "nexistepasMCsousMCFcourant":nexistepasMCsousMCFcourant, - "MCsousMCFcourantaPourValeur":MCsousMCFcourantaPourValeur, - "MCsousMCFcourantaPourValeurDansListe":MCsousMCFcourantaPourValeurDansListe, - "MCsousMCFcourantnaPasPourValeurDansListe":MCsousMCFcourantnaPasPourValeurDansListe, - "MCsousMCFnaPasPourValeurDansListe":MCsousMCFnaPasPourValeurDansListe, - "MCaPourValeurDansListe":MCaPourValeurDansListe, - "MCnaPasPourValeurDansListe":MCnaPasPourValeurDansListe} + +dictionnaire_regle = { + "existe": existe, + "nexistepas": nexistepas, + "existeMCFParmi": existeMCFParmi, + "nexistepasMCFParmi": nexistepasMCFParmi, + "existeMCsousMCF": existeMCsousMCF, + "nexistepasMCsousMCF": nexistepasMCsousMCF, + "MCsousMCFaPourValeur": MCsousMCFaPourValeur, + "MCsousMCFaPourValeurDansListe": MCsousMCFaPourValeurDansListe, + "MCaPourValeur": MCaPourValeur, + "MCnaPasPourValeur": MCnaPasPourValeur, + "existeMCsousMCFcourant": existeMCsousMCFcourant, + "nexistepasMCsousMCFcourant": nexistepasMCsousMCFcourant, + "MCsousMCFcourantaPourValeur": MCsousMCFcourantaPourValeur, + "MCsousMCFcourantaPourValeurDansListe": MCsousMCFcourantaPourValeurDansListe, + "MCsousMCFcourantnaPasPourValeurDansListe": MCsousMCFcourantnaPasPourValeurDansListe, + "MCsousMCFnaPasPourValeurDansListe": MCsousMCFnaPasPourValeurDansListe, + "MCaPourValeurDansListe": MCaPourValeurDansListe, + "MCnaPasPourValeurDansListe": MCnaPasPourValeurDansListe, +} SansRegle = pasDeRegle() diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index ee1eab7a..d356b621 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,193 +23,253 @@ from Traducteur.parseur import FactNode from Traducteur.dictErreurs import ecritErreur from Traducteur.load import jdcSet -debug=0 -#debug=1 -#on n'a qu'un mocle par commande. On peut donc supprimer le mocle sans trop de precautions (a part iterer a l'envers sur les commandes) -#avant de supprimer un autre mocle, on remet a jour l'arbre syntaxique (lineno,colno,etc.) +debug = 0 +# debug=1 +# on n'a qu'un mocle par commande. On peut donc supprimer le mocle sans trop de precautions (a part iterer a l'envers sur les commandes) +# avant de supprimer un autre mocle, on remet a jour l'arbre syntaxique (lineno,colno,etc.) -#----------------------------------------------------------------------- -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[:] +# ----------------------------------------------------------------------- +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: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != mocle:continue - if ensemble.verif(c) == 0 : continue - if erreur : ecritErreur((command,mocle),c.lineno) - boolChange=1 - removeMC(jdc,c,mc) - - 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[:] + if mc.name != mocle: + continue + if ensemble.verif(c) == 0: + continue + if erreur: + ecritErreur((command, mocle), c.lineno) + boolChange = 1 + removeMC(jdc, c, mc) + + 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.warning("Suppression de %s ligne %s",c.name,c.lineno) - if boolChange : jdc.reset(jdc.getSource()) - -#------------------------------------------------------------- -def removeCommandeSiRegle(jdc,command,liste_regles): -#------------------------------------------------------------- - if command not in jdcSet : return - mesRegles=regles.ensembleRegles(liste_regles) - removeCommande(jdc,command,mesRegles,0) - -#------------------------------------------------------------- -def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles): -#------------------------------------------------------------- - if command not in jdcSet : return - mesRegles=regles.ensembleRegles(liste_regles) - removeCommande(jdc,command,mesRegles,1) - -#--------------------------------- -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 dans %s ligne %d",mc.name,c.name,mc.lineno) + 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.warning("Suppression de %s ligne %s", c.name, c.lineno) + if boolChange: + jdc.reset(jdc.getSource()) + + +# ------------------------------------------------------------- +def removeCommandeSiRegle(jdc, command, liste_regles): + # ------------------------------------------------------------- + if command not in jdcSet: + return + mesRegles = regles.ensembleRegles(liste_regles) + removeCommande(jdc, command, mesRegles, 0) + + +# ------------------------------------------------------------- +def removeCommandeSiRegleAvecErreur(jdc, command, liste_regles): + # ------------------------------------------------------------- + if command not in jdcSet: + return + mesRegles = regles.ensembleRegles(liste_regles) + removeCommande(jdc, command, mesRegles, 1) + + +# --------------------------------- +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 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:]) - jdc.getLines()[mc.lineno-1]=jdc.getLines()[mc.lineno-1][:mc.colno] - jdc.getLines()[mc.endline-1]=jdc.getLines()[mc.endline-1][mc.endcol:] + if debug: + print( + "mocle sur plusieurs lignes--%s--" + % jdc.getLines()[mc.lineno - 1][mc.colno :] + ) + jdc.getLines()[mc.lineno - 1] = jdc.getLines()[mc.lineno - 1][: mc.colno] + jdc.getLines()[mc.endline - 1] = jdc.getLines()[mc.endline - 1][mc.endcol :] - #attention : supprimer les lignes a la fin - jdc.getLines()[mc.lineno:mc.endline-1]=[] + # attention : supprimer les lignes a la fin + jdc.getLines()[mc.lineno : mc.endline - 1] = [] else: - if debug: print( "mocle sur une ligne--%s--" % jdc.getLines()[mc.lineno-1][mc.colno:mc.endcol]) - s=jdc.getLines()[mc.lineno-1] - jdc.getLines()[mc.lineno-1]=s[:mc.colno]+s[mc.endcol:] - fusionne(jdc,mc.lineno-1) - -#--------------------------------------------------------------------------------- -def removeMotCleInFact(jdc,command,fact,mocle,ensemble=regles.SansRegle,erreur=0): -#---------------------------------------------------------------------------------- + if debug: + print( + "mocle sur une ligne--%s--" + % jdc.getLines()[mc.lineno - 1][mc.colno : mc.endcol] + ) + s = jdc.getLines()[mc.lineno - 1] + jdc.getLines()[mc.lineno - 1] = s[: mc.colno] + s[mc.endcol :] + fusionne(jdc, mc.lineno - 1) + + +# --------------------------------------------------------------------------------- +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[:] + if command not in jdcSet: + return + commands = jdc.root.childNodes[:] commands.reverse() - boolChange=0 + boolChange = 0 for c in commands: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != fact:continue - l=mc.childNodes[:] + if mc.name != fact: + continue + l = mc.childNodes[:] l.reverse() for ll in l: for n in ll.childNodes: - if n.name != mocle:continue - if ensemble.verif(c) == 0 : continue - if erreur : ecritErreur((command,fact,mocle),c.lineno) - boolChange=1 - removeMC(jdc,c,n) - - 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) - -#---------------------------------------------------------------------- -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) - - -#---------------------------------------------------------------------- -def removeMotCleInFactCourantSiRegle(jdc,command,fact,mocle,liste_regles,erreur=0): -#---------------------------------------------------------------------- - if command not in jdcSet : return - ensemble=regles.ensembleRegles(liste_regles) - commands= jdc.root.childNodes[:] + 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) + + 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) + + +# ---------------------------------------------------------------------- +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) + + +# ---------------------------------------------------------------------- +def removeMotCleInFactCourantSiRegle(jdc, command, fact, mocle, liste_regles, erreur=0): + # ---------------------------------------------------------------------- + if command not in jdcSet: + return + ensemble = regles.ensembleRegles(liste_regles) + commands = jdc.root.childNodes[:] commands.reverse() - boolChange=0 + boolChange = 0 for c in commands: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != fact:continue - l=mc.childNodes[:] + if mc.name != fact: + continue + l = mc.childNodes[:] l.reverse() for ll in l: - if ensemble.verif(ll) == 0 : continue + if ensemble.verif(ll) == 0: + continue for n in ll.childNodes: - if n.name != mocle:continue - if erreur : ecritErreur((command,fact,mocle),c.lineno) - boolChange=1 - removeMC(jdc,c,n) - - if boolChange : jdc.reset(jdc.getSource()) - -#------------------------------------------ -def fusionne(jdc,numLigne): -#------------------------------------------ -# fusionne la ligne numLigne et numLigne+1 -# si la ligne numLigne+1 ne contient que des parentheses -# fermantes -# et si la ligne numLigne ne contient pas par un "#" -# Attention a la difference de numerotation -# jdc.getLines()[numLigne] donne la ligne numLigne + 1 -# alors que joinLineandNext(numLigne) travaille sur le tableau - index=0 - texte=jdc.getLines()[numLigne] - fusion=1 - while (index < len(texte)) : - if texte[index] not in (" ",",",")",";","\n") : - fusion=0 + if n.name != mocle: + continue + if erreur: + ecritErreur((command, fact, mocle), c.lineno) + boolChange = 1 + removeMC(jdc, c, n) + + if boolChange: + jdc.reset(jdc.getSource()) + + +# ------------------------------------------ +def fusionne(jdc, numLigne): + # ------------------------------------------ + # fusionne la ligne numLigne et numLigne+1 + # si la ligne numLigne+1 ne contient que des parentheses + # fermantes + # et si la ligne numLigne ne contient pas par un "#" + # Attention a la difference de numerotation + # jdc.getLines()[numLigne] donne la ligne numLigne + 1 + # alors que joinLineandNext(numLigne) travaille sur le tableau + index = 0 + texte = jdc.getLines()[numLigne] + fusion = 1 + while index < len(texte): + if texte[index] not in (" ", ",", ")", ";", "\n"): + fusion = 0 break - index=index+1 + index = index + 1 - if fusion == 0 : return; + if fusion == 0: + return - texte=jdc.getLines()[numLigne -1] - if texte.find("#") < 0 : - fusion=1 - else : - fusion=0 + texte = jdc.getLines()[numLigne - 1] + if texte.find("#") < 0: + fusion = 1 + else: + fusion = 0 - if fusion : + if fusion: jdc.joinLineandNext(numLigne) diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py index e246abf2..5daedebe 100644 --- a/Traducteur/renamemocle.py +++ b/Traducteur/renamemocle.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -23,166 +23,239 @@ from Traducteur.parseur import FactNode from Traducteur.load import jdcSet from Traducteur import regles from Traducteur.dictErreurs import ecritErreur -#debug=1 -debug=0 -#on n'a qu'un mocle par commande. -#en fin de traitement, on remet a jour l'arbre syntaxique (lineno,colno,etc.) +# debug=1 +debug = 0 -#-------------------------------------------------------------------------------- -def renameMotCle(jdc,command,mocle,new_name, erreur=0,ensemble=regles.SansRegle): -#-------------------------------------------------------------------------------- - if command not in jdcSet : return - boolChange=0 +# on n'a qu'un mocle par commande. +# en fin de traitement, on remet a jour l'arbre syntaxique (lineno,colno,etc.) + + +# -------------------------------------------------------------------------------- +def renameMotCle(jdc, command, mocle, new_name, erreur=0, ensemble=regles.SansRegle): + # -------------------------------------------------------------------------------- + if command not in jdcSet: + return + boolChange = 0 for c in jdc.root.childNodes: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != mocle:continue - if ensemble.verif(c) == 0 : continue - boolChange=1 - if debug: print ("Renommage de:",c.name,mc.name,mc.lineno,mc.colno) - if erreur : - ecritErreur((command,mocle),c.lineno) - else : - logging.info("Renommage de: %s %s ligne %d en %s",c.name,mc.name,mc.lineno,new_name) - s=jdc.getLines()[mc.lineno-1] - jdc.getLines()[mc.lineno-1]=s[:mc.colno]+new_name+s[mc.colno+len(mocle):] - diff=len(new_name) - len(mocle) - decaleLignesdeNBlancs(jdc,mc.lineno,mc.endline-1,diff) - - 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,regles.SansRegle) - -#-------------------------------------------------------------------------- -def renameMotCleSiRegle(jdc,command,mocle,new_name,liste_regles, erreur=0): -#-------------------------------------------------------------------------- - if command not in jdcSet : return - mesRegles=regles.ensembleRegles(liste_regles) - renameMotCle(jdc,command,mocle,new_name, erreur,mesRegles) - -#------------------------------------------- -def renameOper(jdc,command,new_name): -#------------------------------------------- - if command not in jdcSet : return + if mc.name != mocle: + continue + if ensemble.verif(c) == 0: + continue + boolChange = 1 + if debug: + print("Renommage de:", c.name, mc.name, mc.lineno, mc.colno) + if erreur: + ecritErreur((command, mocle), c.lineno) + else: + logging.info( + "Renommage de: %s %s ligne %d en %s", + c.name, + mc.name, + mc.lineno, + new_name, + ) + s = jdc.getLines()[mc.lineno - 1] + jdc.getLines()[mc.lineno - 1] = ( + s[: mc.colno] + new_name + s[mc.colno + len(mocle) :] + ) + diff = len(new_name) - len(mocle) + decaleLignesdeNBlancs(jdc, mc.lineno, mc.endline - 1, diff) + + 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, regles.SansRegle) + + +# -------------------------------------------------------------------------- +def renameMotCleSiRegle(jdc, command, mocle, new_name, liste_regles, erreur=0): + # -------------------------------------------------------------------------- + if command not in jdcSet: + return + mesRegles = regles.ensembleRegles(liste_regles) + renameMotCle(jdc, command, mocle, new_name, erreur, mesRegles) + + +# ------------------------------------------- +def renameOper(jdc, command, new_name): + # ------------------------------------------- + if command not in jdcSet: + return jdcSet.add(new_name) - boolChange=0 + 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 ligne %d en %s",c.name,c.lineno,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) - if boolChange : jdc.reset(jdc.getSource()) - -#---------------------------------------------------------- -def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc): -#---------------------------------------------------------- + if c.name != command: + continue + if debug: + print("Renommage de:", c.name, c.lineno, c.colno) + logging.info("Renommage de: %s ligne %d en %s", c.name, c.lineno, 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) + if boolChange: + jdc.reset(jdc.getSource()) + + +# ---------------------------------------------------------- +def decaleLignesdeNBlancs(jdc, premiere, derniere, nbBlanc): + # ---------------------------------------------------------- ligne = premiere + 1 - while ligne < derniere : - s=jdc.getLines()[ligne] - if nbBlanc > 0 : - jdc.getLines()[ligne] = nbBlanc*" " + s - else : - toutblancs=-1*nbBlanc*" " - if jdc.getLines()[ligne][0:-1*nbBlanc] == toutblancs: - jdc.getLines()[ligne] = s[-1*nbBlanc:] - ligne=ligne+1 - -#--------------------------------------------------------------------------------------------- -def renameMotCleInFact(jdc,command,fact,mocle,new_name, ensemble=regles.SansRegle, erreur=0): -#--------------------------------------------------------------------------------------------- - if command not in jdcSet : return - boolChange=0 + while ligne < derniere: + s = jdc.getLines()[ligne] + if nbBlanc > 0: + jdc.getLines()[ligne] = nbBlanc * " " + s + else: + toutblancs = -1 * nbBlanc * " " + if jdc.getLines()[ligne][0 : -1 * nbBlanc] == toutblancs: + jdc.getLines()[ligne] = s[-1 * nbBlanc :] + ligne = ligne + 1 + + +# --------------------------------------------------------------------------------------------- +def renameMotCleInFact( + jdc, command, fact, mocle, new_name, ensemble=regles.SansRegle, erreur=0 +): + # --------------------------------------------------------------------------------------------- + if command not in jdcSet: + return + boolChange = 0 for c in jdc.root.childNodes: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != fact:continue - l=mc.childNodes[:] - #on itere a l'envers + if mc.name != fact: + continue + l = mc.childNodes[:] + # on itere a l'envers l.reverse() for ll in l: for n in ll.childNodes: - if n.name != mocle:continue - if ensemble.verif(c) == 0 : continue - s=jdc.getLines()[n.lineno-1] - jdc.getLines()[n.lineno-1]=s[:n.colno]+new_name+s[n.colno+len(mocle):] - boolChange=1 - if erreur : - ecritErreur((command,fact,mocle),c.lineno) - else : - logging.info("Renommage de: %s, ligne %s, en %s",n.name,n.lineno,new_name) - - if boolChange : jdc.reset(jdc.getSource()) - -#-------------------------------------------------------------------------- -def renameMotCleInFactSiRegle(jdc,command,fact,mocle,new_name,liste_regles): -#-------------------------------------------------------------------------- - if command not in jdcSet : return - mesRegles=regles.ensembleRegles(liste_regles) - renameMotCleInFact(jdc,command,fact,mocle,new_name,mesRegles) - -def renameMotCleInFactCourantSiRegle(jdc,command,fact,mocle,new_name,liste_regles,erreur=0): -#-------------------------------------------------------------------------- - if command not in jdcSet : return - ensemble=regles.ensembleRegles(liste_regles) - boolChange=0 + if n.name != mocle: + continue + if ensemble.verif(c) == 0: + continue + s = jdc.getLines()[n.lineno - 1] + jdc.getLines()[n.lineno - 1] = ( + s[: n.colno] + new_name + s[n.colno + len(mocle) :] + ) + boolChange = 1 + if erreur: + ecritErreur((command, fact, mocle), c.lineno) + else: + logging.info( + "Renommage de: %s, ligne %s, en %s", + n.name, + n.lineno, + new_name, + ) + + if boolChange: + jdc.reset(jdc.getSource()) + + +# -------------------------------------------------------------------------- +def renameMotCleInFactSiRegle(jdc, command, fact, mocle, new_name, liste_regles): + # -------------------------------------------------------------------------- + if command not in jdcSet: + return + mesRegles = regles.ensembleRegles(liste_regles) + renameMotCleInFact(jdc, command, fact, mocle, new_name, mesRegles) + + +def renameMotCleInFactCourantSiRegle( + jdc, command, fact, mocle, new_name, liste_regles, erreur=0 +): + # -------------------------------------------------------------------------- + if command not in jdcSet: + return + ensemble = regles.ensembleRegles(liste_regles) + boolChange = 0 for c in jdc.root.childNodes: - if c.name != command:continue + if c.name != command: + continue for mc in c.childNodes: - if mc.name != fact:continue - l=mc.childNodes[:] - #on itere a l'envers + if mc.name != fact: + continue + l = mc.childNodes[:] + # on itere a l'envers l.reverse() for ll in l: - if ensemble.verif(ll) == 0 : continue + if ensemble.verif(ll) == 0: + continue for n in ll.childNodes: - 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 - if erreur : - ecritErreur((command,fact,mocle),c.lineno) - else : - logging.info("Renommage de: %s, ligne %s, en %s",n.name,n.lineno,new_name) - - 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 + 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 + if erreur: + ecritErreur((command, fact, mocle), c.lineno) + else: + logging.info( + "Renommage de: %s, ligne %s, en %s", + n.name, + n.lineno, + new_name, + ) + + 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) - else : + boolChange = 0 + if debug: + if ensemble != regles.SansRegle: + logging.info( + "traitement de %s renomme en %s sous conditions", command, new_name + ) + else: logging.info("traitement de %s renomme en %s ", command, new_name) for c in jdc.root.childNodes: - if c.name != command:continue - if ensemble.verif(c) == 0 : continue - boolChange=1 - if debug: print ("Renommage de:",c.name,new_name ,c.lineno,c.colno) - logging.info("Renommage de: %s ligne %d en %s",c.name,c.lineno,new_name) - s=jdc.getLines()[c.lineno-1] - jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):] - - 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) + 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 ligne %d en %s", c.name, c.lineno, new_name) + s = jdc.getLines()[c.lineno - 1] + jdc.getLines()[c.lineno - 1] = ( + s[: c.colno] + new_name + s[c.colno + len(command) :] + ) + + 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) diff --git a/Traducteur/traduitV10V11.py b/Traducteur/traduitV10V11.py index 5f638c2c..d8eba434 100755 --- a/Traducteur/traduitV10V11.py +++ b/Traducteur/traduitV10V11.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,7 +20,7 @@ # """ """ -usage="""usage: %prog [options] +usage = """usage: %prog [options] Typical use is: python traduitV10V11.py --infile=xxxx --outfile=yyyy """ @@ -29,301 +29,311 @@ import log import optparse import sys -from Traducteur.load import getJDC +from Traducteur.load import getJDC from Traducteur.mocles import parseKeywords -from Traducteur.removemocle import * -from Traducteur.renamemocle import * -from Traducteur.renamemocle import * -from Traducteur.inseremocle import * +from Traducteur.removemocle import * +from Traducteur.renamemocle import * +from Traducteur.renamemocle import * +from Traducteur.inseremocle import * from Traducteur.changeValeur import * -from Traducteur.movemocle import * -from Traducteur.dictErreurs import * +from Traducteur.movemocle import * +from Traducteur.dictErreurs import * from Traducteur.regles import pasDeRegle -atraiter=( - "AFFE_CARA_ELEM", - "AFFE_CHAR_MECA", - "AFFE_CHAR_MECA_F", - "AFFE_CHAR_OPS011", - "AFFE_CHAR_THER", - "AFFE_CHAR_THER_F", - "AFFE_MATERIAU", - "AFFE_MODELE", - "ASSE_ELEM_SSD", - "ASSEMBLAGE", - "CALC_CHAM_ELEM", - "CALC_CHAMP", - "CALC_ECREVISSE", - "CALC_ELEM", - "CALC_ERREUR", - "CALC_ESSAI", - "CALC_EUROPLEXUS", - "CALC_FATIGUE", - "CALC_FERRAILLAGE", - "CALC_FONC_INTERP", - "CALC_FONCTION", - "CALC_FORC_AJOU", - "CALC_G", - "CALC_IFS_DNL", - "CALC_INTE_SPEC", - "CALC_MAC3COEUR", - "CALC_MATR_AJOU", - "CALC_MATR_ELEM", - "CALC_META", - "CALC_MISS", - "CALC_MODAL", - "CALC_MODE_ROTATION", - "CALC_NO", - "CALC_POINT_MAT", - "CALC_PRECONT", - "CALC_SENSI", - "CALC_SPEC", - "CALC_TABLE", - "CALC_THETA", - "COMB_FOURIER", - "COMB_SISM_MODAL", - "COPIER", - "CREA_CHAMP", - "CREA_ELEM_SSD", - "CREA_MAILLAGE", - "CREA_RESU", - "CREA_TABLE", - "DEBUT", - "DEFI_BASE_MODALE", - "DEFI_CABLE_BP", - "DEFI_COMPOR", - "DEFI_CONTACT", - "DEFI_COQU_MULT", - "DEFI_FICHIER", - "DEFI_FISS_XFEM", - "DEFI_FONC_ELEC", - "DEFI_FOND_FISS", - "DEFI_GLRC", - "DEFI_GROUP", - "DEFI_INTE_SPEC", - "DEFI_LIST_INST", - "DEFI_MATER_GC", - "DEFI_MATERIAU", - "DEFI_NAPPE", - "DEFI_PARA_SENSI", - "DEFI_PART_FETI", - "DEFI_SOL_MISS", - "DEFI_SPEC_TURB", - "DETRUIRE", - "DYNA_ALEA_MODAL", - "DYNA_ISS_VARI", - "DYNA_LINE_HARM", - "DYNA_LINE_TRAN", - "DYNA_NON_LINE", - "DYNA_SPEC_MODAL", - "DYNA_TRAN_MODAL", - "DYNA_VIBRA", - "EXEC_LOGICIEL", - "EXTR_RESU", - "EXTR_TABLE", - "FACTORISER", - "FORMULE", - "GENE_ACCE_SEISME", - "GENE_FONC_ALEA", - "GENE_VARI_ALEA", - "IMPR_CO", - "IMPR_DIAG_CAMPBELL", - "IMPR_FONCTION", - "IMPR_GENE", - "IMPR_OAR", - "IMPR_RESU", - "IMPR_STURM", - "IMPR_TABLE", - "INCLUDE", - "INCLUDE_MATERIAU", - "INFO_EXEC_ASTER", - "INFO_FONCTION", - "INFO_MODE", - "LIRE_CHAMP", - "LIRE_FONCTION", - "LIRE_IMPE_MISS", - "LIRE_INTE_SPEC", - "LIRE_MAILLAGE", - "LIRE_RESU", - "LIRE_TABLE", - "MACR_ADAP_MAIL", - "MACR_ASCOUF_CALC", - "MACR_ASCOUF_MAIL", - "MACR_ASPIC_CALC", - "MACR_ASPIC_MAIL", - "MACR_CARA_POUTRE", - "MACR_ECLA_PG", - "MACR_ECRE_CALC", - "MACR_ECREVISSE", - "MACR_ELEM_DYNA", - "MACR_FIABILITE", - "MACR_FIAB_IMPR", - "MACR_INFO_MAIL", - "MACR_LIGN_COUPE", - "MACRO_ELAS_MULT", - "MACRO_EXPANS", - "MACRO_MATR_AJOU", - "MACRO_MATR_ASSE", - "MACRO_MISS_3D", - "MACRO_MODE_MECA", - "MACRO_PROJ_BASE", - "MACR_RECAL", - "MACR_SPECTRE", - "MECA_STATIQUE", - "MODE_ITER_INV", - "MODE_ITER_SIMULT", - "MODE_STATIQUE", - "MODI_MODELE_XFEM", - "MODI_REPERE", - "NORM_MODE", - "NUME_DDL", - "NUME_DDL_GENE", - "OBSERVATION", - "POST_BORDET", - "POST_CHAMP", - "POST_CHAM_XFEM", - "POST_COQUE", - "POST_DECOLLEMENT", - "POST_DYNA_ALEA", - "POST_ELEM", - "POST_ENDO_FISS", - "POST_FATIGUE", - "POST_GP", - "POST_K1_K2_K3", - "POST_K_TRANS", - "POST_MAC3COEUR", - "POST_MAIL_XFEM", - "POST_RCCM", - "POST_RELEVE_T", - "POST_RUPTURE", - "POST_USURE", - "POURSUITE", - "PROJ_BASE", - "PROJ_CHAMP", - "PROJ_RESU_BASE", - "PROJ_SPEC_BASE", - "PROPA_FISS", - "PROPA_XFEM", - "RAFF_XFEM", - "RECU_FONCTION", - "RECU_GENE", - "RESOUDRE", - "REST_SPEC_PHYS", - "SIMU_POINT_MAT", - "STANLEY", - "STAT_NON_LINE", - "TEST_COMPOR", - "TEST_FICHIER", - "TEST_FONCTION", - "TEST_RESU", - "TEST_TABLE", - "TEST_TEMPS", - "THER_LINEAIRE", - "THER_NON_LINE", - "THER_NON_LINE_MO", - - "CALC_CHAMPNO", - "CALC_METANO", - "CALC_ERREURNO", - - ) - -dict_erreurs={ - - "CALC_G_THETA_DTAN_ORIG":"La valeur de DTAN_ORIG est maintenant calculée automatiquement", - "CALC_G_THETA_DTAN_EXTR":"La valeur de DTAN_EXTR est maintenant calculée automatiquement", - "AFFE_CHAR_MECA_CONTACT":"Attention, modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", - "DEFI_COMPOR_MONOCRISTAL_FAMI_SYST_GLIS":"Famille de système de glissement supprimée : choisir une autre famille", - "DEFI_COMPOR_MULTIFIBRE_DEFORMATION":"Il faut maintenant renseigner le mot-clé DEFORMATION dans STAT_NON_LINE ou DYNA_NON_LINE.", - "DEFI_MATERIAU_ECRO_FLEJOU":"Le comportement ECRO_FLEJOU a été supprimé. Il faut maintenant utiliser un modèle de poutre multifibres avec une loi d'écrouissage'.", - "DEFI_MATERIAU_VMIS_POUTRE":"Le comportement VMIS_POUTRE a été supprimé. Il faut maintenant utiliser un modèle de poutre multifibres avec une loi plastique.", - "DEFI_MATERIAU_VMIS_POUTRE_FO":"Le comportement VMIS_POUTRE_FO a été supprimé. Il faut maintenant utiliser un modèle de poutre multifibres avec une loi plastique.", - "DEFI_MATERIAU_LEMAITRE_IRRA_GRAN_A":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_LEMAITRE_IRRA_GRAN_B":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_LEMAITRE_IRRA_GRAN_S":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_LMARC_IRRA_GRAN_A":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_LMARC_IRRA_GRAN_B":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_LMARC_IRRA_GRAN_S":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_GRAN_IRRA_LOG_GRAN_A":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_GRAN_IRRA_LOG_GRAN_B":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_GRAN_IRRA_LOG_GRAN_S":"Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", - "DEFI_MATERIAU_ENDO_SCALAIRE":"Les paramètres définissant la loi ENDO_SCALAIRE ont changé. Il faut renseigner les nouveaux paramètres.", - "DEFI_MATERIAU_MAZARS":"Le paramètres BETA définissant la loi MAZARS a été supprimé. Il faut renseigner le nouveau paramètre K.", - "DEFI_MATERIAU_MONO_VISC3":"Le comportement MONO_VISC3 a été supprimé.", - "DEFI_MATERIAU_MONO_DD_CC":"Le comportement MONO_DD_CC a été supprimé.", - "DYNA_LINE_TRAN_INCREMENT_FONC_INST":"Le mot-clé FONC_INST a été supprimé. Il faut maintenant utiliser ", - "LIRE_RESU_TYPE_RESU":"Il n'est plus possible de lire un résultat de type HARM_GENE. Il faut choisir un autre type.", - "MACRO_ELAS_MULT_CAS_CHARGE_OPTION":"Seule l'option SIEF_ELGA est permise pour MACRO_ELAS_MULT. Il faut calculer les autres options avec CALC_CHAMP.", - "MODI_MODELE_XFEM_CONTACT":"La formulation du contact aux arêtes P1P1A a été supprimée. Il faut choisir une autre formulation.", - "POST_GP":"La commande POST_GP a été supprimée. Il faut maintenant utiliser la commande CALC_GP.", - "AFFE_CARA_ELEM_COQUE_EPAIS_F":"Il n'est plus possible de faire d'analyse de sensibilité.", - "AFFE_CARA_ELEM_DISCRET_VALE_F":"Il n'est plus possible de faire d'analyse de sensibilité.", - "AFFE_CARA_ELEM_DISCRET_2D_VALE_F":"Il n'est plus possible de faire d'analyse de sensibilité.", - "CALC_CHAMP_REPE_COQUE":"Pour les éléments de structures, les résultats sont calculés sur tous les sous-points. Pour extraire un champ sur un seul sous-point, il faut utiliser POST_CHAMP.", - "CALC_THETA_THETA_BANDE":"L'option THETA_BANDE n'existe plus, il faut choisir entre THETA_2D ou THETA_3D." - } - -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 +atraiter = ( + "AFFE_CARA_ELEM", + "AFFE_CHAR_MECA", + "AFFE_CHAR_MECA_F", + "AFFE_CHAR_OPS011", + "AFFE_CHAR_THER", + "AFFE_CHAR_THER_F", + "AFFE_MATERIAU", + "AFFE_MODELE", + "ASSE_ELEM_SSD", + "ASSEMBLAGE", + "CALC_CHAM_ELEM", + "CALC_CHAMP", + "CALC_ECREVISSE", + "CALC_ELEM", + "CALC_ERREUR", + "CALC_ESSAI", + "CALC_EUROPLEXUS", + "CALC_FATIGUE", + "CALC_FERRAILLAGE", + "CALC_FONC_INTERP", + "CALC_FONCTION", + "CALC_FORC_AJOU", + "CALC_G", + "CALC_IFS_DNL", + "CALC_INTE_SPEC", + "CALC_MAC3COEUR", + "CALC_MATR_AJOU", + "CALC_MATR_ELEM", + "CALC_META", + "CALC_MISS", + "CALC_MODAL", + "CALC_MODE_ROTATION", + "CALC_NO", + "CALC_POINT_MAT", + "CALC_PRECONT", + "CALC_SENSI", + "CALC_SPEC", + "CALC_TABLE", + "CALC_THETA", + "COMB_FOURIER", + "COMB_SISM_MODAL", + "COPIER", + "CREA_CHAMP", + "CREA_ELEM_SSD", + "CREA_MAILLAGE", + "CREA_RESU", + "CREA_TABLE", + "DEBUT", + "DEFI_BASE_MODALE", + "DEFI_CABLE_BP", + "DEFI_COMPOR", + "DEFI_CONTACT", + "DEFI_COQU_MULT", + "DEFI_FICHIER", + "DEFI_FISS_XFEM", + "DEFI_FONC_ELEC", + "DEFI_FOND_FISS", + "DEFI_GLRC", + "DEFI_GROUP", + "DEFI_INTE_SPEC", + "DEFI_LIST_INST", + "DEFI_MATER_GC", + "DEFI_MATERIAU", + "DEFI_NAPPE", + "DEFI_PARA_SENSI", + "DEFI_PART_FETI", + "DEFI_SOL_MISS", + "DEFI_SPEC_TURB", + "DETRUIRE", + "DYNA_ALEA_MODAL", + "DYNA_ISS_VARI", + "DYNA_LINE_HARM", + "DYNA_LINE_TRAN", + "DYNA_NON_LINE", + "DYNA_SPEC_MODAL", + "DYNA_TRAN_MODAL", + "DYNA_VIBRA", + "EXEC_LOGICIEL", + "EXTR_RESU", + "EXTR_TABLE", + "FACTORISER", + "FORMULE", + "GENE_ACCE_SEISME", + "GENE_FONC_ALEA", + "GENE_VARI_ALEA", + "IMPR_CO", + "IMPR_DIAG_CAMPBELL", + "IMPR_FONCTION", + "IMPR_GENE", + "IMPR_OAR", + "IMPR_RESU", + "IMPR_STURM", + "IMPR_TABLE", + "INCLUDE", + "INCLUDE_MATERIAU", + "INFO_EXEC_ASTER", + "INFO_FONCTION", + "INFO_MODE", + "LIRE_CHAMP", + "LIRE_FONCTION", + "LIRE_IMPE_MISS", + "LIRE_INTE_SPEC", + "LIRE_MAILLAGE", + "LIRE_RESU", + "LIRE_TABLE", + "MACR_ADAP_MAIL", + "MACR_ASCOUF_CALC", + "MACR_ASCOUF_MAIL", + "MACR_ASPIC_CALC", + "MACR_ASPIC_MAIL", + "MACR_CARA_POUTRE", + "MACR_ECLA_PG", + "MACR_ECRE_CALC", + "MACR_ECREVISSE", + "MACR_ELEM_DYNA", + "MACR_FIABILITE", + "MACR_FIAB_IMPR", + "MACR_INFO_MAIL", + "MACR_LIGN_COUPE", + "MACRO_ELAS_MULT", + "MACRO_EXPANS", + "MACRO_MATR_AJOU", + "MACRO_MATR_ASSE", + "MACRO_MISS_3D", + "MACRO_MODE_MECA", + "MACRO_PROJ_BASE", + "MACR_RECAL", + "MACR_SPECTRE", + "MECA_STATIQUE", + "MODE_ITER_INV", + "MODE_ITER_SIMULT", + "MODE_STATIQUE", + "MODI_MODELE_XFEM", + "MODI_REPERE", + "NORM_MODE", + "NUME_DDL", + "NUME_DDL_GENE", + "OBSERVATION", + "POST_BORDET", + "POST_CHAMP", + "POST_CHAM_XFEM", + "POST_COQUE", + "POST_DECOLLEMENT", + "POST_DYNA_ALEA", + "POST_ELEM", + "POST_ENDO_FISS", + "POST_FATIGUE", + "POST_GP", + "POST_K1_K2_K3", + "POST_K_TRANS", + "POST_MAC3COEUR", + "POST_MAIL_XFEM", + "POST_RCCM", + "POST_RELEVE_T", + "POST_RUPTURE", + "POST_USURE", + "POURSUITE", + "PROJ_BASE", + "PROJ_CHAMP", + "PROJ_RESU_BASE", + "PROJ_SPEC_BASE", + "PROPA_FISS", + "PROPA_XFEM", + "RAFF_XFEM", + "RECU_FONCTION", + "RECU_GENE", + "RESOUDRE", + "REST_SPEC_PHYS", + "SIMU_POINT_MAT", + "STANLEY", + "STAT_NON_LINE", + "TEST_COMPOR", + "TEST_FICHIER", + "TEST_FONCTION", + "TEST_RESU", + "TEST_TABLE", + "TEST_TEMPS", + "THER_LINEAIRE", + "THER_NON_LINE", + "THER_NON_LINE_MO", + "CALC_CHAMPNO", + "CALC_METANO", + "CALC_ERREURNO", +) + +dict_erreurs = { + "CALC_G_THETA_DTAN_ORIG": "La valeur de DTAN_ORIG est maintenant calculée automatiquement", + "CALC_G_THETA_DTAN_EXTR": "La valeur de DTAN_EXTR est maintenant calculée automatiquement", + "AFFE_CHAR_MECA_CONTACT": "Attention, modification de la définition du CONTACT : nommer DEFI_CONTACT,verifier les paramètres globaux et le mettre dans le calcul", + "DEFI_COMPOR_MONOCRISTAL_FAMI_SYST_GLIS": "Famille de système de glissement supprimée : choisir une autre famille", + "DEFI_COMPOR_MULTIFIBRE_DEFORMATION": "Il faut maintenant renseigner le mot-clé DEFORMATION dans STAT_NON_LINE ou DYNA_NON_LINE.", + "DEFI_MATERIAU_ECRO_FLEJOU": "Le comportement ECRO_FLEJOU a été supprimé. Il faut maintenant utiliser un modèle de poutre multifibres avec une loi d'écrouissage'.", + "DEFI_MATERIAU_VMIS_POUTRE": "Le comportement VMIS_POUTRE a été supprimé. Il faut maintenant utiliser un modèle de poutre multifibres avec une loi plastique.", + "DEFI_MATERIAU_VMIS_POUTRE_FO": "Le comportement VMIS_POUTRE_FO a été supprimé. Il faut maintenant utiliser un modèle de poutre multifibres avec une loi plastique.", + "DEFI_MATERIAU_LEMAITRE_IRRA_GRAN_A": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_LEMAITRE_IRRA_GRAN_B": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_LEMAITRE_IRRA_GRAN_S": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_LMARC_IRRA_GRAN_A": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_LMARC_IRRA_GRAN_B": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_LMARC_IRRA_GRAN_S": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_GRAN_IRRA_LOG_GRAN_A": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_GRAN_IRRA_LOG_GRAN_B": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_GRAN_IRRA_LOG_GRAN_S": "Les paramètres de la loi de grandissement se définissent maintenant par une fonction avec GRAN_FO.", + "DEFI_MATERIAU_ENDO_SCALAIRE": "Les paramètres définissant la loi ENDO_SCALAIRE ont changé. Il faut renseigner les nouveaux paramètres.", + "DEFI_MATERIAU_MAZARS": "Le paramètres BETA définissant la loi MAZARS a été supprimé. Il faut renseigner le nouveau paramètre K.", + "DEFI_MATERIAU_MONO_VISC3": "Le comportement MONO_VISC3 a été supprimé.", + "DEFI_MATERIAU_MONO_DD_CC": "Le comportement MONO_DD_CC a été supprimé.", + "DYNA_LINE_TRAN_INCREMENT_FONC_INST": "Le mot-clé FONC_INST a été supprimé. Il faut maintenant utiliser ", + "LIRE_RESU_TYPE_RESU": "Il n'est plus possible de lire un résultat de type HARM_GENE. Il faut choisir un autre type.", + "MACRO_ELAS_MULT_CAS_CHARGE_OPTION": "Seule l'option SIEF_ELGA est permise pour MACRO_ELAS_MULT. Il faut calculer les autres options avec CALC_CHAMP.", + "MODI_MODELE_XFEM_CONTACT": "La formulation du contact aux arêtes P1P1A a été supprimée. Il faut choisir une autre formulation.", + "POST_GP": "La commande POST_GP a été supprimée. Il faut maintenant utiliser la commande CALC_GP.", + "AFFE_CARA_ELEM_COQUE_EPAIS_F": "Il n'est plus possible de faire d'analyse de sensibilité.", + "AFFE_CARA_ELEM_DISCRET_VALE_F": "Il n'est plus possible de faire d'analyse de sensibilité.", + "AFFE_CARA_ELEM_DISCRET_2D_VALE_F": "Il n'est plus possible de faire d'analyse de sensibilité.", + "CALC_CHAMP_REPE_COQUE": "Pour les éléments de structures, les résultats sont calculés sur tous les sous-points. Pour extraire un champ sur un seul sous-point, il faut utiliser POST_CHAMP.", + "CALC_THETA_THETA_BANDE": "L'option THETA_BANDE n'existe plus, il faut choisir entre THETA_2D ou THETA_3D.", +} + +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) - genereErreurPourCommande(jdc,("CALC_SENSI",)) - + genereErreurPourCommande(jdc, ("CALC_SENSI",)) #### traitement des cas particuliers ############################## # On ne traite pas les commandes TEST* - removeCommande(jdc,"TEST_COMPOR") - removeCommande(jdc,"TEST_FICHIER") - removeCommande(jdc,"TEST_FONCTION") - removeCommande(jdc,"TEST_RESU") - removeCommande(jdc,"TEST_TABLE") - removeCommande(jdc,"TEST_TEMPS") + removeCommande(jdc, "TEST_COMPOR") + removeCommande(jdc, "TEST_FICHIER") + removeCommande(jdc, "TEST_FONCTION") + removeCommande(jdc, "TEST_RESU") + removeCommande(jdc, "TEST_TABLE") + removeCommande(jdc, "TEST_TEMPS") #### traitement de AFFE_CARA_ELEM ############################## # Déplacement de PREC_AIRE et PREC_INERTIE dans MULTIFIBRE - moveMotCleFromFactToFact(jdc,"AFFE_CARA_ELEM","POUTRE","PREC_AIRE","MULTIFIBRE") - removeMotCleInFact(jdc,"AFFE_CARA_ELEM","POUTRE","PREC_AIRE",pasDeRegle(),0) - moveMotCleFromFactToFact(jdc,"AFFE_CARA_ELEM","POUTRE","PREC_INERTIE","MULTIFIBRE") - removeMotCleInFact(jdc,"AFFE_CARA_ELEM","POUTRE","PREC_INERTIE",pasDeRegle(),0) + moveMotCleFromFactToFact(jdc, "AFFE_CARA_ELEM", "POUTRE", "PREC_AIRE", "MULTIFIBRE") + removeMotCleInFact(jdc, "AFFE_CARA_ELEM", "POUTRE", "PREC_AIRE", pasDeRegle(), 0) + moveMotCleFromFactToFact( + jdc, "AFFE_CARA_ELEM", "POUTRE", "PREC_INERTIE", "MULTIFIBRE" + ) + removeMotCleInFact(jdc, "AFFE_CARA_ELEM", "POUTRE", "PREC_INERTIE", pasDeRegle(), 0) # Résorption de la sensibilité - genereErreurMotCleInFact(jdc,"AFFE_CARA_ELEM","COQUE","EPAIS_F") - genereErreurMotCleInFact(jdc,"AFFE_CARA_ELEM","DISCRET","VALE_F") - genereErreurMotCleInFact(jdc,"AFFE_CARA_ELEM","DISCRET_2D","VALE_F") + genereErreurMotCleInFact(jdc, "AFFE_CARA_ELEM", "COQUE", "EPAIS_F") + genereErreurMotCleInFact(jdc, "AFFE_CARA_ELEM", "DISCRET", "VALE_F") + genereErreurMotCleInFact(jdc, "AFFE_CARA_ELEM", "DISCRET_2D", "VALE_F") # Suppression de GRILLE_NCOU - removeMotCleInFact(jdc,"AFFE_CARA_ELEM","GRILLE","GRILLE_NCOU",pasDeRegle(),0) + removeMotCleInFact(jdc, "AFFE_CARA_ELEM", "GRILLE", "GRILLE_NCOU", pasDeRegle(), 0) # Suppression de ORIG_AXE - removeMotCleInFact(jdc,"AFFE_CARA_ELEM","GRILLE","ORIG_AXE",pasDeRegle(),0) + removeMotCleInFact(jdc, "AFFE_CARA_ELEM", "GRILLE", "ORIG_AXE", pasDeRegle(), 0) #### traitement de AFFE_CHAR_MECA/_F ############################## - renameMotCle(jdc,"AFFE_CHAR_MECA","SIGM_INTERNE","PRE_SIGM") - renameMotCle(jdc,"AFFE_CHAR_MECA","EPSI_INIT","PRE_EPSI") - renameMotCle(jdc,"AFFE_CHAR_MECA_F","SIGM_INTERNE","PRE_SIGM") - renameMotCle(jdc,"AFFE_CHAR_MECA_F","EPSI_INIT","PRE_EPSI") + renameMotCle(jdc, "AFFE_CHAR_MECA", "SIGM_INTERNE", "PRE_SIGM") + renameMotCle(jdc, "AFFE_CHAR_MECA", "EPSI_INIT", "PRE_EPSI") + renameMotCle(jdc, "AFFE_CHAR_MECA_F", "SIGM_INTERNE", "PRE_SIGM") + renameMotCle(jdc, "AFFE_CHAR_MECA_F", "EPSI_INIT", "PRE_EPSI") #### traitement de AFFE_CHAR_OPS011 ############################## - genereErreurPourCommande(jdc,("AFFE_CHAR_OPS011",)) + genereErreurPourCommande(jdc, ("AFFE_CHAR_OPS011",)) #### traitement de AFFE_CHAR_THER/_F ############################## - renameMotCle(jdc,"AFFE_CHAR_THER","GRAD_TEMP_INIT","PRE_GRAD_TEMP") - renameMotCle(jdc,"AFFE_CHAR_THER_F","GRAD_TEMP_INIT","PRE_GRAD_TEMP") + renameMotCle(jdc, "AFFE_CHAR_THER", "GRAD_TEMP_INIT", "PRE_GRAD_TEMP") + renameMotCle(jdc, "AFFE_CHAR_THER_F", "GRAD_TEMP_INIT", "PRE_GRAD_TEMP") #### traitement de AFFE_MATERIAU ############################## # VALE_REF obligatoire si NOM_VARC in ('TEMP', 'SECH') - lNOMVARC=["CORR","IRRA","HYDR","EPSA","M_ACIER","M_ZIRC","NEUT1","NEUT2"] - removeMotCleInFactSiRegle(jdc,"AFFE_MATERIAU","AFFE_VARC","VALE_REF",((("NOM_VARC",lNOMVARC,jdc),"MCsousMCFcourantaPourValeurDansListe"),)) + lNOMVARC = ["CORR", "IRRA", "HYDR", "EPSA", "M_ACIER", "M_ZIRC", "NEUT1", "NEUT2"] + removeMotCleInFactSiRegle( + jdc, + "AFFE_MATERIAU", + "AFFE_VARC", + "VALE_REF", + ((("NOM_VARC", lNOMVARC, jdc), "MCsousMCFcourantaPourValeurDansListe"),), + ) # renommage CHAMP_GD en CHAM_GD - renameMotCleInFact(jdc,"AFFE_MATERIAU","AFFE_VARC","CHAMP_GD","CHAM_GD",pasDeRegle(),0) + renameMotCleInFact( + jdc, "AFFE_MATERIAU", "AFFE_VARC", "CHAMP_GD", "CHAM_GD", pasDeRegle(), 0 + ) #### traitement de AFFE_MODELE ############################## - dXFEMCONT={"3D_XFEM_CONT":"3D","C_PLAN_XFEM_CONT":"C_PLAN","D_PLAN_XFEM_CONT":"D_PLAN"} - changementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",dXFEMCONT) + dXFEMCONT = { + "3D_XFEM_CONT": "3D", + "C_PLAN_XFEM_CONT": "C_PLAN", + "D_PLAN_XFEM_CONT": "D_PLAN", + } + changementValeurDsMCF(jdc, "AFFE_MODELE", "AFFE", "MODELISATION", dXFEMCONT) #### traitement de ASSE_ELEM_SSD ############################## # Rien à faire @@ -333,41 +343,91 @@ def traduc(infile,outfile,flog=None): #### traitement de C_COMP_INCR ############################## # Suppression de ALGO_C_PLAN et ALGO_1D - lCOMMANDE=["CALC_FORC_NONL","CALC_IFS_DNL","CALC_POINT_MAT", - "CALC_PRECONT","CALCUL","DYNA_NON_LINE","LIRE_RESU", - "MACR_ECREVISSE","SIMU_POINT_MAT","STAT_NON_LINE", - "TEST_COMPOR",] - for com in lCOMMANDE : - removeMotCleInFact(jdc,com,"COMP_INCR","ALGO_C_PLAN",pasDeRegle(),0) - removeMotCleInFact(jdc,com,"COMP_INCR","ALGO_1D",pasDeRegle(),0) - renameMotCleInFact(jdc,com,"COMP_INCR","RESI_DEBO_MAXI","RESI_CPLAN_MAXI",pasDeRegle(),0) - renameMotCleInFact(jdc,com,"COMP_INCR","RESI_DEBO_RELA","RESI_CPLAN_RELA",pasDeRegle(),0) - renameMotCleInFact(jdc,com,"COMP_INCR","ITER_MAXI_DEBORST","ITER_CPLAN_MAXI",pasDeRegle(),0) + lCOMMANDE = [ + "CALC_FORC_NONL", + "CALC_IFS_DNL", + "CALC_POINT_MAT", + "CALC_PRECONT", + "CALCUL", + "DYNA_NON_LINE", + "LIRE_RESU", + "MACR_ECREVISSE", + "SIMU_POINT_MAT", + "STAT_NON_LINE", + "TEST_COMPOR", + ] + for com in lCOMMANDE: + removeMotCleInFact(jdc, com, "COMP_INCR", "ALGO_C_PLAN", pasDeRegle(), 0) + removeMotCleInFact(jdc, com, "COMP_INCR", "ALGO_1D", pasDeRegle(), 0) + renameMotCleInFact( + jdc, com, "COMP_INCR", "RESI_DEBO_MAXI", "RESI_CPLAN_MAXI", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, com, "COMP_INCR", "RESI_DEBO_RELA", "RESI_CPLAN_RELA", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, + com, + "COMP_INCR", + "ITER_MAXI_DEBORST", + "ITER_CPLAN_MAXI", + pasDeRegle(), + 0, + ) #### traitement de C_NEWTON ############################## # Renommage de EXTRAPOL en EXTRAPOLE - lCOMMANDE=["CALC_IFS_DNL","CALC_POINT_MAT","CALC_PRECONT", - "DYNA_NON_LINE","MACR_ASCOUF_CALC","MACR_ASPIC_CALC", - "SIMU_POINT_MAT","STAT_NON_LINE","TEST_COMPOR",] - dPRED={"EXTRAPOL":"EXTRAPOLE"} - for com in lCOMMANDE : - changementValeurDsMCF(jdc,com,"NEWTON","PREDICTION",dPRED) + lCOMMANDE = [ + "CALC_IFS_DNL", + "CALC_POINT_MAT", + "CALC_PRECONT", + "DYNA_NON_LINE", + "MACR_ASCOUF_CALC", + "MACR_ASPIC_CALC", + "SIMU_POINT_MAT", + "STAT_NON_LINE", + "TEST_COMPOR", + ] + dPRED = {"EXTRAPOL": "EXTRAPOLE"} + for com in lCOMMANDE: + changementValeurDsMCF(jdc, com, "NEWTON", "PREDICTION", dPRED) #### traitement de C_SOLVEUR ############################## # Renommage de EXTRAPOL en EXTRAPOLE - lCOMMANDE=["CALC_ELEM","CALC_FORC_AJOU","CALC_IFS_DNL", - "CALC_MATR_AJOU","CALC_PRECONT","CREA_ELEM_SSD", - "DEFI_BASE_MODALE","DYNA_LINE_HARM","DYNA_LINE_HARM", - "DYNA_LINE_TRAN","DYNA_NON_LINE","DYNA_TRAN_MODAL", - "IMPR_STURM","MACR_ASCOUF_CALC","MACR_ASPIC_CALC", - "MACRO_ELAS_MULT","MACRO_MATR_AJOU","MACRO_MATR_ASSE", - "MECA_STATIQUE","MODE_ITER_INV","MODE_ITER_INV", - "MODE_ITER_SIMULT","MODE_ITER_SIMULT","MODE_STATIQUE", - "STAT_NON_LINE","THER_LINEAIRE","THER_NON_LINE","THER_NON_LINE_MO",] - dPRED={"EXTRAPOL":"EXTRAPOLE"} - for com in lCOMMANDE : - removeMotCleInFact(jdc,com,"SOLVEUR","OUT_OF_CORE",pasDeRegle(),0) - removeMotCleInFact(jdc,com,"SOLVEUR","LIBERE_MEMOIRE",pasDeRegle(),0) + lCOMMANDE = [ + "CALC_ELEM", + "CALC_FORC_AJOU", + "CALC_IFS_DNL", + "CALC_MATR_AJOU", + "CALC_PRECONT", + "CREA_ELEM_SSD", + "DEFI_BASE_MODALE", + "DYNA_LINE_HARM", + "DYNA_LINE_HARM", + "DYNA_LINE_TRAN", + "DYNA_NON_LINE", + "DYNA_TRAN_MODAL", + "IMPR_STURM", + "MACR_ASCOUF_CALC", + "MACR_ASPIC_CALC", + "MACRO_ELAS_MULT", + "MACRO_MATR_AJOU", + "MACRO_MATR_ASSE", + "MECA_STATIQUE", + "MODE_ITER_INV", + "MODE_ITER_INV", + "MODE_ITER_SIMULT", + "MODE_ITER_SIMULT", + "MODE_STATIQUE", + "STAT_NON_LINE", + "THER_LINEAIRE", + "THER_NON_LINE", + "THER_NON_LINE_MO", + ] + dPRED = {"EXTRAPOL": "EXTRAPOLE"} + for com in lCOMMANDE: + removeMotCleInFact(jdc, com, "SOLVEUR", "OUT_OF_CORE", pasDeRegle(), 0) + removeMotCleInFact(jdc, com, "SOLVEUR", "LIBERE_MEMOIRE", pasDeRegle(), 0) #### traitement de CALC_CHAMP ############################## # Rien à faire, n'existe pas en 10 @@ -377,162 +437,440 @@ def traduc(infile,outfile,flog=None): #### traitement de CALC_ELEM ############################## # renommage de la commande - renameCommande(jdc,"CALC_ELEM","CALC_CHAMP", ) + renameCommande( + jdc, + "CALC_ELEM", + "CALC_CHAMP", + ) # Suppression des types de charges - removeMotCleInFact(jdc,"CALC_CHAMP","EXCIT","TYPE_CHARGE",pasDeRegle(),0) + removeMotCleInFact(jdc, "CALC_CHAMP", "EXCIT", "TYPE_CHARGE", pasDeRegle(), 0) # Suppression des types d'option' - removeMotCle(jdc,"CALC_CHAMP","TYPE_OPTION",pasDeRegle(),0) + removeMotCle(jdc, "CALC_CHAMP", "TYPE_OPTION", pasDeRegle(), 0) # Redistribution des options de calcul ## dictionnaire contenant les options - lTOUT=["SIEF_ELNO","SIGM_ELNO","SIEF_ELGA", - "SIPO_ELNO","EFGE_ELNO","EFCA_ELNO","SICA_ELNO", - "SIRO_ELEM","SIPM_ELNO","SIRO_ELEM", - "EFCA_ELNO","SIPO_ELNO","SIPM_ELNO", - "EPTU_ELNO","SITU_ELNO","SICO_ELNO", - "EPSI_ELNO","EPSI_ELGA","EPSG_ELNO","EPSG_ELGA", - "EPME_ELNO","EPME_ELGA","EPMG_ELNO","EPMG_ELGA", - "DEGE_ELNO","EPTU_ELNO", - "EPSP_ELNO","EPSP_ELGA", - "EPFD_ELNO","EPFD_ELGA","EPVC_ELNO","EPVC_ELGA", - "EPFP_ELNO","EPFP_ELGA", - "EPOT_ELEM","ECIN_ELEM","ENEL_ELGA","ENEL_ELNO", - "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","DISS_ELGA","DISS_ELNO", - "SIEQ_ELNO","SIEQ_ELGA","CRIT_ELNO","EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA", - "ENDO_ELGA","ENDO_ELNO","SITQ_ELNO","EPTQ_ELNO","INDL_ELGA","DERA_ELNO","DERA_ELGA", - "SITQ_ELNO","EPTQ_ELNO", - "VARI_ELNO","VATU_ELNO","VACO_ELNO","VARC_ELGA", - "VAEX_ELGA","VAEX_ELNO", - "FLHN_ELGA", - "FLUX_ELGA","FLUX_ELNO","SOUR_ELGA", - "INTE_ELNO","PRAC_ELNO", - "SIZ1_NOEU","ERZ1_ELEM","SIZ2_NOEU","ERZ2_ELEM", - "ERME_ELEM","ERME_ELNO","ERTH_ELEM","ERTH_ELNO", - "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM", - "SING_ELEM","SING_ELNO", - "DURT_ELNO"] - lCONTRAINTE=["SIEF_ELNO","SIGM_ELNO","SIEF_ELGA", - "SIPO_ELNO","EFGE_ELNO","EFCA_ELNO","SICA_ELNO", - "SIRO_ELEM","SIPM_ELNO","SIRO_ELEM", - "EFCA_ELNO","SIPO_ELNO","SIPM_ELNO", - "EPTU_ELNO","SITU_ELNO","SICO_ELNO",] - lDEFORMATION=["EPSI_ELNO","EPSI_ELGA","EPSG_ELNO","EPSG_ELGA", - "EPME_ELNO","EPME_ELGA","EPMG_ELNO","EPMG_ELGA", - "DEGE_ELNO","EPTU_ELNO", - "EPSP_ELNO","EPSP_ELGA", - "EPFD_ELNO","EPFD_ELGA","EPVC_ELNO","EPVC_ELGA", - "EPFP_ELNO","EPFP_ELGA",] - lENERGIE=["EPOT_ELEM","ECIN_ELEM","ENEL_ELGA","ENEL_ELNO", - "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","DISS_ELGA","DISS_ELNO",] - lCRITERES=["SIEQ_ELNO","SIEQ_ELGA","CRIT_ELNO","EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA", - "ENDO_ELGA","ENDO_ELNO","SITQ_ELNO","EPTQ_ELNO","INDL_ELGA","DERA_ELNO","DERA_ELGA", - "SITQ_ELNO","EPTQ_ELNO"] - lVARI_INTERNE=["VARI_ELNO","VATU_ELNO","VACO_ELNO","VARC_ELGA", - "VAEX_ELGA","VAEX_ELNO",] - lHYDRAULIQUE=["FLHN_ELGA",] - lTHERMIQUE=["FLUX_ELGA","FLUX_ELNO","SOUR_ELGA",] - lACOUSTIQUE=["INTE_ELNO","PRAC_ELNO"] - lERREUR=["SIZ1_NOEU","ERZ1_ELEM","SIZ2_NOEU","ERZ2_ELEM", - "ERME_ELEM","ERME_ELNO","ERTH_ELEM","ERTH_ELNO", - "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM", - "SING_ELEM","SING_ELNO",] - lMETA=["DURT_ELNO"] - #SPMX_ELGA / NOM_CHAM / NOM_CMP + lTOUT = [ + "SIEF_ELNO", + "SIGM_ELNO", + "SIEF_ELGA", + "SIPO_ELNO", + "EFGE_ELNO", + "EFCA_ELNO", + "SICA_ELNO", + "SIRO_ELEM", + "SIPM_ELNO", + "SIRO_ELEM", + "EFCA_ELNO", + "SIPO_ELNO", + "SIPM_ELNO", + "EPTU_ELNO", + "SITU_ELNO", + "SICO_ELNO", + "EPSI_ELNO", + "EPSI_ELGA", + "EPSG_ELNO", + "EPSG_ELGA", + "EPME_ELNO", + "EPME_ELGA", + "EPMG_ELNO", + "EPMG_ELGA", + "DEGE_ELNO", + "EPTU_ELNO", + "EPSP_ELNO", + "EPSP_ELGA", + "EPFD_ELNO", + "EPFD_ELGA", + "EPVC_ELNO", + "EPVC_ELGA", + "EPFP_ELNO", + "EPFP_ELGA", + "EPOT_ELEM", + "ECIN_ELEM", + "ENEL_ELGA", + "ENEL_ELNO", + "ETOT_ELGA", + "ETOT_ELNO", + "ETOT_ELEM", + "DISS_ELGA", + "DISS_ELNO", + "SIEQ_ELNO", + "SIEQ_ELGA", + "CRIT_ELNO", + "EPEQ_ELNO", + "EPEQ_ELGA", + "EPMQ_ELNO", + "EPMQ_ELGA", + "ENDO_ELGA", + "ENDO_ELNO", + "SITQ_ELNO", + "EPTQ_ELNO", + "INDL_ELGA", + "DERA_ELNO", + "DERA_ELGA", + "SITQ_ELNO", + "EPTQ_ELNO", + "VARI_ELNO", + "VATU_ELNO", + "VACO_ELNO", + "VARC_ELGA", + "VAEX_ELGA", + "VAEX_ELNO", + "FLHN_ELGA", + "FLUX_ELGA", + "FLUX_ELNO", + "SOUR_ELGA", + "INTE_ELNO", + "PRAC_ELNO", + "SIZ1_NOEU", + "ERZ1_ELEM", + "SIZ2_NOEU", + "ERZ2_ELEM", + "ERME_ELEM", + "ERME_ELNO", + "ERTH_ELEM", + "ERTH_ELNO", + "QIRE_ELEM", + "QIRE_ELNO", + "QIZ1_ELEM", + "QIZ2_ELEM", + "SING_ELEM", + "SING_ELNO", + "DURT_ELNO", + ] + lCONTRAINTE = [ + "SIEF_ELNO", + "SIGM_ELNO", + "SIEF_ELGA", + "SIPO_ELNO", + "EFGE_ELNO", + "EFCA_ELNO", + "SICA_ELNO", + "SIRO_ELEM", + "SIPM_ELNO", + "SIRO_ELEM", + "EFCA_ELNO", + "SIPO_ELNO", + "SIPM_ELNO", + "EPTU_ELNO", + "SITU_ELNO", + "SICO_ELNO", + ] + lDEFORMATION = [ + "EPSI_ELNO", + "EPSI_ELGA", + "EPSG_ELNO", + "EPSG_ELGA", + "EPME_ELNO", + "EPME_ELGA", + "EPMG_ELNO", + "EPMG_ELGA", + "DEGE_ELNO", + "EPTU_ELNO", + "EPSP_ELNO", + "EPSP_ELGA", + "EPFD_ELNO", + "EPFD_ELGA", + "EPVC_ELNO", + "EPVC_ELGA", + "EPFP_ELNO", + "EPFP_ELGA", + ] + lENERGIE = [ + "EPOT_ELEM", + "ECIN_ELEM", + "ENEL_ELGA", + "ENEL_ELNO", + "ETOT_ELGA", + "ETOT_ELNO", + "ETOT_ELEM", + "DISS_ELGA", + "DISS_ELNO", + ] + lCRITERES = [ + "SIEQ_ELNO", + "SIEQ_ELGA", + "CRIT_ELNO", + "EPEQ_ELNO", + "EPEQ_ELGA", + "EPMQ_ELNO", + "EPMQ_ELGA", + "ENDO_ELGA", + "ENDO_ELNO", + "SITQ_ELNO", + "EPTQ_ELNO", + "INDL_ELGA", + "DERA_ELNO", + "DERA_ELGA", + "SITQ_ELNO", + "EPTQ_ELNO", + ] + lVARI_INTERNE = [ + "VARI_ELNO", + "VATU_ELNO", + "VACO_ELNO", + "VARC_ELGA", + "VAEX_ELGA", + "VAEX_ELNO", + ] + lHYDRAULIQUE = [ + "FLHN_ELGA", + ] + lTHERMIQUE = [ + "FLUX_ELGA", + "FLUX_ELNO", + "SOUR_ELGA", + ] + lACOUSTIQUE = ["INTE_ELNO", "PRAC_ELNO"] + lERREUR = [ + "SIZ1_NOEU", + "ERZ1_ELEM", + "SIZ2_NOEU", + "ERZ2_ELEM", + "ERME_ELEM", + "ERME_ELNO", + "ERTH_ELEM", + "ERTH_ELNO", + "QIRE_ELEM", + "QIRE_ELNO", + "QIZ1_ELEM", + "QIZ2_ELEM", + "SING_ELEM", + "SING_ELNO", + ] + lMETA = ["DURT_ELNO"] + # SPMX_ELGA / NOM_CHAM / NOM_CMP ## Erreur pour les options supprimées - genereErreurValeur(jdc,"CALC_ELEM","OPTION",("'SICA_ELNO'","'EFCA_ELNO'","'PMPB_ELNO'","'PMPB_ELGA'",)) - lCHANOPT={"SICO_ELNO":"SIGM_ELNO","EPTU_ELNO":"EPSI_ELNO","SITU_ELNO":"SIGM_ELNO","SITQ_ELNO":"SIGM_ELNO","EPTQ_ELNO":"EPSI_ELNO"} - changementValeur(jdc,"CALC_ELEM","OPTION",lCHANOPT) + genereErreurValeur( + jdc, + "CALC_ELEM", + "OPTION", + ( + "'SICA_ELNO'", + "'EFCA_ELNO'", + "'PMPB_ELNO'", + "'PMPB_ELGA'", + ), + ) + lCHANOPT = { + "SICO_ELNO": "SIGM_ELNO", + "EPTU_ELNO": "EPSI_ELNO", + "SITU_ELNO": "SIGM_ELNO", + "SITQ_ELNO": "SIGM_ELNO", + "EPTQ_ELNO": "EPSI_ELNO", + } + changementValeur(jdc, "CALC_ELEM", "OPTION", lCHANOPT) ## copie de OPTION dans MCF TEMPORAIRE pour chaque type - chercheOperInsereFacteur(jdc,"CALC_CHAMP","TEMPORAIRE") - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","CONTRAINTE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","DEFORMATION",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","ENERGIE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","CRITERES",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","VARI_INTERNE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","HYDRAULIQUE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","THERMIQUE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","ACOUSTIQUE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","ERREUR",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMP","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMP","TEMPORAIRE","OPTION","META",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMP","OPTION",pasDeRegle(),0) + chercheOperInsereFacteur(jdc, "CALC_CHAMP", "TEMPORAIRE") + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "CONTRAINTE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "DEFORMATION", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "ENERGIE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "CRITERES", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "VARI_INTERNE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "HYDRAULIQUE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "THERMIQUE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "ACOUSTIQUE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "ERREUR", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMP", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMP", "TEMPORAIRE", "OPTION", "META", pasDeRegle(), 0 + ) + removeMotCle(jdc, "CALC_CHAMP", "OPTION", pasDeRegle(), 0) ## déplacement au premier niveau de mot-clés - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","CONTRAINTE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","DEFORMATION") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","ENERGIE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","CRITERES") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","VARI_INTERNE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","HYDRAULIQUE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","THERMIQUE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","ACOUSTIQUE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","ERREUR") - moveMotCleFromFactToFather(jdc,"CALC_CHAMP","TEMPORAIRE","META") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "CONTRAINTE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "DEFORMATION") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "ENERGIE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "CRITERES") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "VARI_INTERNE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "HYDRAULIQUE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "THERMIQUE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "ACOUSTIQUE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "ERREUR") + moveMotCleFromFactToFather(jdc, "CALC_CHAMP", "TEMPORAIRE", "META") ## suppression des mot-clés s'ils ne contiennent pas d'options à traiter - removeMotCleSiRegle(jdc,"CALC_CHAMP","CONTRAINTE",((("CONTRAINTE",lCONTRAINTE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","DEFORMATION",((("DEFORMATION",lDEFORMATION,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","ENERGIE",((("ENERGIE",lENERGIE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","CRITERES",((("CRITERES",lCRITERES,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","VARI_INTERNE",((("VARI_INTERNE",lVARI_INTERNE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","HYDRAULIQUE",((("HYDRAULIQUE",lHYDRAULIQUE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","THERMIQUE",((("THERMIQUE",lTHERMIQUE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","ACOUSTIQUE",((("ACOUSTIQUE",lACOUSTIQUE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","ERREUR",((("ERREUR",lERREUR,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMP","META",((("META",lMETA,jdc),"MCnaPasPourValeurDansListe"),)) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "CONTRAINTE", + ((("CONTRAINTE", lCONTRAINTE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "DEFORMATION", + ((("DEFORMATION", lDEFORMATION, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "ENERGIE", + ((("ENERGIE", lENERGIE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "CRITERES", + ((("CRITERES", lCRITERES, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "VARI_INTERNE", + ((("VARI_INTERNE", lVARI_INTERNE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "HYDRAULIQUE", + ((("HYDRAULIQUE", lHYDRAULIQUE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "THERMIQUE", + ((("THERMIQUE", lTHERMIQUE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "ACOUSTIQUE", + ((("ACOUSTIQUE", lACOUSTIQUE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "ERREUR", + ((("ERREUR", lERREUR, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMP", + "META", + ((("META", lMETA, jdc), "MCnaPasPourValeurDansListe"),), + ) ## suppression des valeurs non-licites - suppressionValeurs(jdc,"CALC_CHAMP","CONTRAINTE",list(set(lTOUT)-set(lCONTRAINTE))) - suppressionValeurs(jdc,"CALC_CHAMP","DEFORMATION",list(set(lTOUT)-set(lDEFORMATION))) - suppressionValeurs(jdc,"CALC_CHAMP","ENERGIE",list(set(lTOUT)-set(lENERGIE))) - suppressionValeurs(jdc,"CALC_CHAMP","CRITERES",list(set(lTOUT)-set(lCRITERES))) - suppressionValeurs(jdc,"CALC_CHAMP","VARI_INTERNE",list(set(lTOUT)-set(lVARI_INTERNE))) - suppressionValeurs(jdc,"CALC_CHAMP","HYDRAULIQUE",list(set(lTOUT)-set(lHYDRAULIQUE))) - suppressionValeurs(jdc,"CALC_CHAMP","THERMIQUE",list(set(lTOUT)-set(lTHERMIQUE))) - suppressionValeurs(jdc,"CALC_CHAMP","ACOUSTIQUE",list(set(lTOUT)-set(lACOUSTIQUE))) - suppressionValeurs(jdc,"CALC_CHAMP","ERREUR",list(set(lTOUT)-set(lERREUR))) - suppressionValeurs(jdc,"CALC_CHAMP","META",list(set(lTOUT)-set(lMETA))) + suppressionValeurs( + jdc, "CALC_CHAMP", "CONTRAINTE", list(set(lTOUT) - set(lCONTRAINTE)) + ) + suppressionValeurs( + jdc, "CALC_CHAMP", "DEFORMATION", list(set(lTOUT) - set(lDEFORMATION)) + ) + suppressionValeurs(jdc, "CALC_CHAMP", "ENERGIE", list(set(lTOUT) - set(lENERGIE))) + suppressionValeurs(jdc, "CALC_CHAMP", "CRITERES", list(set(lTOUT) - set(lCRITERES))) + suppressionValeurs( + jdc, "CALC_CHAMP", "VARI_INTERNE", list(set(lTOUT) - set(lVARI_INTERNE)) + ) + suppressionValeurs( + jdc, "CALC_CHAMP", "HYDRAULIQUE", list(set(lTOUT) - set(lHYDRAULIQUE)) + ) + suppressionValeurs( + jdc, "CALC_CHAMP", "THERMIQUE", list(set(lTOUT) - set(lTHERMIQUE)) + ) + suppressionValeurs( + jdc, "CALC_CHAMP", "ACOUSTIQUE", list(set(lTOUT) - set(lACOUSTIQUE)) + ) + suppressionValeurs(jdc, "CALC_CHAMP", "ERREUR", list(set(lTOUT) - set(lERREUR))) + suppressionValeurs(jdc, "CALC_CHAMP", "META", list(set(lTOUT) - set(lMETA))) ## ajout CALC_META ou CALC_ERREUR - lMOTCLE=[] - lMOTCLE=["reuse","RESULTAT","TOUT_ORDRE","NUME_ORDRE","NUME_MODE","NOEUD_CMP","NOM_CAS", - "INST","FREQ","LIST_INST","LIST_FREQ","LIST_ORDRE","CRITERE","PRECISION","EXCIT"] + lMOTCLE = [] + lMOTCLE = [ + "reuse", + "RESULTAT", + "TOUT_ORDRE", + "NUME_ORDRE", + "NUME_MODE", + "NOEUD_CMP", + "NOM_CAS", + "INST", + "FREQ", + "LIST_INST", + "LIST_FREQ", + "LIST_ORDRE", + "CRITERE", + "PRECISION", + "EXCIT", + ] ### traitement métallurgie - llistMETA=[] - llistMETA=list(lMOTCLE) - llistMETA.extend(["META",]) - for mc in llistMETA : - copyMotClefInOperToFact(jdc,"CALC_CHAMP",mc,"TEMPORAIRE") - moveMCFToCommand(jdc,"CALC_CHAMP","TEMPORAIRE","CALC_META","TEMPORAIRE") - for mc in llistMETA : - moveMotCleFromFactToFather(jdc,"CALC_META","TEMPORAIRE",mc) - removeCommandeSiRegle(jdc,"CALC_META",((("META","COMP_INCR","ETAT_INIT"),"nexistepasMCFParmi"),)) - renameMotCle(jdc,"CALC_META","META","OPTION") - removeMotCle(jdc,"CALC_META","TEMPORAIRE",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMP","TEMPORAIRE",pasDeRegle(),0) + llistMETA = [] + llistMETA = list(lMOTCLE) + llistMETA.extend( + [ + "META", + ] + ) + for mc in llistMETA: + copyMotClefInOperToFact(jdc, "CALC_CHAMP", mc, "TEMPORAIRE") + moveMCFToCommand(jdc, "CALC_CHAMP", "TEMPORAIRE", "CALC_META", "TEMPORAIRE") + for mc in llistMETA: + moveMotCleFromFactToFather(jdc, "CALC_META", "TEMPORAIRE", mc) + removeCommandeSiRegle( + jdc, "CALC_META", ((("META", "COMP_INCR", "ETAT_INIT"), "nexistepasMCFParmi"),) + ) + renameMotCle(jdc, "CALC_META", "META", "OPTION") + removeMotCle(jdc, "CALC_META", "TEMPORAIRE", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_CHAMP", "TEMPORAIRE", pasDeRegle(), 0) ### traitement calcul d'erreur - llistERREUR=[] - llistERREUR=list(lMOTCLE) - llistERREUR.extend(["ERREUR","SOLVEUR","RESU_DUAL","PREC_ESTI","TYPE_ESTI"]) - for mc in llistERREUR : - copyMotClefInOperToFact(jdc,"CALC_CHAMP",mc,"TEMPORAIRE") - moveMCFToCommand(jdc,"CALC_CHAMP","TEMPORAIRE","CALC_ERREUR","TEMPORAIRE") - for mc in llistERREUR : - moveMotCleFromFactToFather(jdc,"CALC_ERREUR","TEMPORAIRE",mc) - removeCommandeSiRegle(jdc,"CALC_ERREUR",((("ERREUR"),"nexistepasMCFParmi"),)) - renameMotCle(jdc,"CALC_ERREUR","ERREUR","OPTION") - removeMotCle(jdc,"CALC_ERREUR","TEMPORAIRE",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMP","TEMPORAIRE",pasDeRegle(),0) + llistERREUR = [] + llistERREUR = list(lMOTCLE) + llistERREUR.extend(["ERREUR", "SOLVEUR", "RESU_DUAL", "PREC_ESTI", "TYPE_ESTI"]) + for mc in llistERREUR: + copyMotClefInOperToFact(jdc, "CALC_CHAMP", mc, "TEMPORAIRE") + moveMCFToCommand(jdc, "CALC_CHAMP", "TEMPORAIRE", "CALC_ERREUR", "TEMPORAIRE") + for mc in llistERREUR: + moveMotCleFromFactToFather(jdc, "CALC_ERREUR", "TEMPORAIRE", mc) + removeCommandeSiRegle(jdc, "CALC_ERREUR", ((("ERREUR"), "nexistepasMCFParmi"),)) + renameMotCle(jdc, "CALC_ERREUR", "ERREUR", "OPTION") + removeMotCle(jdc, "CALC_ERREUR", "TEMPORAIRE", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_CHAMP", "TEMPORAIRE", pasDeRegle(), 0) ### traitement de REPE_COQUE - removeMotCle(jdc,"CALC_CHAMP","REPE_COQUE",pasDeRegle(),1) + removeMotCle(jdc, "CALC_CHAMP", "REPE_COQUE", pasDeRegle(), 1) ## ménage final - removeCommandeSiRegle(jdc,"CALC_CHAMP",((("CONTRAINTE","DEFORMATION","ENERGIE","CRITERES","VARI_INTERNE","HYDRAULIQUE","THERMIQUE","ACOUSTIQUE"),"nexistepasMCFParmi"),)) - removeMotCle(jdc,"CALC_CHAMP","META",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMP","ERREUR",pasDeRegle(),0) + removeCommandeSiRegle( + jdc, + "CALC_CHAMP", + ( + ( + ( + "CONTRAINTE", + "DEFORMATION", + "ENERGIE", + "CRITERES", + "VARI_INTERNE", + "HYDRAULIQUE", + "THERMIQUE", + "ACOUSTIQUE", + ), + "nexistepasMCFParmi", + ), + ), + ) + removeMotCle(jdc, "CALC_CHAMP", "META", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_CHAMP", "ERREUR", pasDeRegle(), 0) #### traitement de CALC_ERREUR ############################## # Rien à faire, n'existe pas en 10 @@ -557,35 +895,89 @@ def traduc(infile,outfile,flog=None): #### traitement de CALC_G ############################## # Suppression SYME_CHAR - removeMotCle(jdc,"CALC_G","SYME_CHAR",pasDeRegle(),0) + removeMotCle(jdc, "CALC_G", "SYME_CHAR", pasDeRegle(), 0) # Règle sur DEGRE - removeMotCleInFactSiRegle(jdc,"CALC_G","LISSAGE","DEGRE",((("LISSAGE_THETA","LEGENDRE",jdc),"MCnaPasPourValeur")or(("LISSAGE_G","LEGENDRE",jdc),"MCnaPasPourValeur"),)) + removeMotCleInFactSiRegle( + jdc, + "CALC_G", + "LISSAGE", + "DEGRE", + ( + (("LISSAGE_THETA", "LEGENDRE", jdc), "MCnaPasPourValeur") + or (("LISSAGE_G", "LEGENDRE", jdc), "MCnaPasPourValeur"), + ), + ) # Suppression de DTAN_ORIG et DTAN_EXTR pour calcul automatique - removeMotCleInFact(jdc,"CALC_G","THETA","DTAN_ORIG",pasDeRegle(),1) - removeMotCleInFact(jdc,"CALC_G","THETA","DTAN_EXTR",pasDeRegle(),1) + removeMotCleInFact(jdc, "CALC_G", "THETA", "DTAN_ORIG", pasDeRegle(), 1) + removeMotCleInFact(jdc, "CALC_G", "THETA", "DTAN_EXTR", pasDeRegle(), 1) # Résorption de la sensibilité - removeMotCle(jdc,"CALC_G","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "CALC_G", "SENSIBILITE", pasDeRegle(), 0) # Restriction de ETAT_INIT à SIGM_INIT sous COMP_INCR - moveMotCleFromFactToFact(jdc,"CALC_G","ETAT_INIT","SIGM","COMP_INCR") - renameMotCleInFact(jdc,"CALC_G","COMP_INCR","SIGM","SIGM_INIT",pasDeRegle(),0) - removeMotCleInFactSiRegle(jdc,"CALC_G","COMP_INCR","SIGM_INIT",((("RELATION","ELAS",jdc),"MCnaPasPourValeur"),)) - removeMotCle(jdc,"CALC_G","ETAT_INIT",pasDeRegle(),0) + moveMotCleFromFactToFact(jdc, "CALC_G", "ETAT_INIT", "SIGM", "COMP_INCR") + renameMotCleInFact(jdc, "CALC_G", "COMP_INCR", "SIGM", "SIGM_INIT", pasDeRegle(), 0) + removeMotCleInFactSiRegle( + jdc, + "CALC_G", + "COMP_INCR", + "SIGM_INIT", + ((("RELATION", "ELAS", jdc), "MCnaPasPourValeur"),), + ) + removeMotCle(jdc, "CALC_G", "ETAT_INIT", pasDeRegle(), 0) # Renommage de l'option K_G_MODA en CALC_K_G - changementValeur(jdc,"CALC_G","OPTION",{"K_G_MODA":"CALC_K_G",}) + changementValeur( + jdc, + "CALC_G", + "OPTION", + { + "K_G_MODA": "CALC_K_G", + }, + ) # Suppression de EXCIT dans le cas elas_mult - removeMotCleSiRegle(jdc,"CALC_G","EXCIT",((("NOM_CAS",),"existe"),)) + removeMotCleSiRegle(jdc, "CALC_G", "EXCIT", ((("NOM_CAS",), "existe"),)) # Ajout règle UN_PARMI('THETA','FOND_FISS','FISSURE') - removeMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA",((("THETA","FOND_FISS",),"existeMCsousMCF"),)) - removeMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA",((("THETA","FISSURE",),"existeMCsousMCF"),)) + removeMotCleInFactSiRegle( + jdc, + "CALC_G", + "THETA", + "THETA", + ( + ( + ( + "THETA", + "FOND_FISS", + ), + "existeMCsousMCF", + ), + ), + ) + removeMotCleInFactSiRegle( + jdc, + "CALC_G", + "THETA", + "THETA", + ( + ( + ( + "THETA", + "FISSURE", + ), + "existeMCsousMCF", + ), + ), + ) #### traitement de CALC_IFS_DNL ############################## # Renommage CRIT_FLAMB en CRIT_STAB - renameMotCle(jdc,"CALC_IFS_DNL","CRIT_FLAMB","CRIT_STAB") - removeMotCleInFact(jdc,"CALC_IFS_DNL","CRIT_FLAMB","INST_CALCUL",pasDeRegle(),1) + renameMotCle(jdc, "CALC_IFS_DNL", "CRIT_FLAMB", "CRIT_STAB") + removeMotCleInFact( + jdc, "CALC_IFS_DNL", "CRIT_FLAMB", "INST_CALCUL", pasDeRegle(), 1 + ) # Résorption de la sensibilité - removeMotCle(jdc,"CALC_IFS_DNL","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "CALC_IFS_DNL", "SENSIBILITE", pasDeRegle(), 0) # Suppression de ARCHIVAGE/DETR_NUME_SUIV - removeMotCleInFact(jdc,"CALC_IFS_DNL","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0) + removeMotCleInFact( + jdc, "CALC_IFS_DNL", "ARCHIVAGE", "DETR_NUME_SUIV", pasDeRegle(), 0 + ) #### traitement de CALC_INTE_SPEC ############################## # Rien à faire @@ -595,245 +987,486 @@ def traduc(infile,outfile,flog=None): #### traitement de CALC_MATR_AJOU ############################## # Suppression d'algo pour PETSc - removeMotCleSiRegle(jdc,"RESOUDRE","ALGORITHME",((("BCGS","BICG","TFQMR",),"MCaPourValeur"),)) + removeMotCleSiRegle( + jdc, + "RESOUDRE", + "ALGORITHME", + ( + ( + ( + "BCGS", + "BICG", + "TFQMR", + ), + "MCaPourValeur", + ), + ), + ) #### traitement de CALC_MATR_ELEM ############################## # Rien à faire #### traitement de CALC_META ############################## # OPTION est obligatoire - chercheOperInsereFacteurSiRegle(jdc,"CALC_META","OPTION='META_ELNO'",((("OPTION",),"nexistepas"),),0) + chercheOperInsereFacteurSiRegle( + jdc, "CALC_META", "OPTION='META_ELNO'", ((("OPTION",), "nexistepas"),), 0 + ) #### traitement de CALC_MISS ############################## # Suppression de TYPE_CHARGE - removeMotCle(jdc,"CALC_MISS","TYPE_CHARGE",pasDeRegle(),0) + removeMotCle(jdc, "CALC_MISS", "TYPE_CHARGE", pasDeRegle(), 0) #### traitement de CALC_MODAL ############################## # renommage de STOP_FREQ_VIDE - renameMotCle(jdc,"CALC_MODAL","STOP_FREQ_VIDE","STOP_BANDE_VIDE") + renameMotCle(jdc, "CALC_MODAL", "STOP_FREQ_VIDE", "STOP_BANDE_VIDE") #### traitement de CALC_MODE_ROTATION ############################## # renommage de MATR_A et MATR_B - renameMotCle(jdc,"CALC_MODE_ROTATION","MATR_A","MATR_RIGI") - renameMotCle(jdc,"CALC_MODE_ROTATION","MATR_B","MATR_MASS") + renameMotCle(jdc, "CALC_MODE_ROTATION", "MATR_A", "MATR_RIGI") + renameMotCle(jdc, "CALC_MODE_ROTATION", "MATR_B", "MATR_MASS") #### traitement de CALC_NO ############################## # renommage de la commande - renameCommande(jdc,"CALC_NO","CALC_CHAMPNO", ) + renameCommande( + jdc, + "CALC_NO", + "CALC_CHAMPNO", + ) # Suppression des types de charges - removeMotCleInFact(jdc,"CALC_CHAMPNO","EXCIT","TYPE_CHARGE",pasDeRegle(),0) + removeMotCleInFact(jdc, "CALC_CHAMPNO", "EXCIT", "TYPE_CHARGE", pasDeRegle(), 0) # Redistribution des options de calcul ## dictionnaire contenant les options - lTOUT=["FORC_NODA","REAC_NODA","DERA_NOEU","DURT_NOEU","EFCA_NOEU", - "EFGE_NOEU","ENDO_NOEU","ENEL_NOEU","EPMG_NOEU","EPSG_NOEU", - "EPSI_NOEU","EPSP_NOEU","EPVC_NOEU","EPFD_NOEU","EPFP_NOEU", - "EPMQ_NOEU","EPEQ_NOEU","SIEQ_NOEU","ERME_NOEU","ERTH_NOEU", - "QIRE_NOEU","FLUX_NOEU","HYDR_NOEU","INTE_NOEU","META_NOEU", - "PMPB_NOEU","PRAC_NOEU","SIEF_NOEU","SICA_NOEU","SICO_NOEU", - "SIGM_NOEU","SIPO_NOEU","VAEX_NOEU","VARI_NOEU","DISS_NOEU"] - lCONTRAINTE=["EFCA_NOEU","EFGE_NOEU","SIEF_NOEU","SICA_NOEU", - "SICO_NOEU","SIGM_NOEU","SIPO_NOEU",] - lDEFORMATION=["EPMG_NOEU","EPSG_NOEU","EPSI_NOEU","EPSP_NOEU", - "EPVC_NOEU","EPFD_NOEU","EPFP_NOEU",] - lENERGIE=["ENEL_NOEU","DISS_NOEU",] - lCRITERES=["DERA_NOEU","ENDO_NOEU","EPEQ_NOEU","EPMQ_NOEU", - "SIEQ_NOEU","PMPB_NOEU",] - lVARI_INTERNE=["VAEX_NOEU","VARI_NOEU",] - lTHERMIQUE=["FLUX_NOEU","HYDR_NOEU",] - lACOUSTIQUE=["INTE_NOEU","PRAC_NOEU",] - lFORCE=["FORC_NODA","REAC_NODA",] - lERREUR=["ERME_NOEU","ERTH_NOEU","QIRE_NOEU",] - lMETA=["DURT_NOEU","META_NOEU",] + lTOUT = [ + "FORC_NODA", + "REAC_NODA", + "DERA_NOEU", + "DURT_NOEU", + "EFCA_NOEU", + "EFGE_NOEU", + "ENDO_NOEU", + "ENEL_NOEU", + "EPMG_NOEU", + "EPSG_NOEU", + "EPSI_NOEU", + "EPSP_NOEU", + "EPVC_NOEU", + "EPFD_NOEU", + "EPFP_NOEU", + "EPMQ_NOEU", + "EPEQ_NOEU", + "SIEQ_NOEU", + "ERME_NOEU", + "ERTH_NOEU", + "QIRE_NOEU", + "FLUX_NOEU", + "HYDR_NOEU", + "INTE_NOEU", + "META_NOEU", + "PMPB_NOEU", + "PRAC_NOEU", + "SIEF_NOEU", + "SICA_NOEU", + "SICO_NOEU", + "SIGM_NOEU", + "SIPO_NOEU", + "VAEX_NOEU", + "VARI_NOEU", + "DISS_NOEU", + ] + lCONTRAINTE = [ + "EFCA_NOEU", + "EFGE_NOEU", + "SIEF_NOEU", + "SICA_NOEU", + "SICO_NOEU", + "SIGM_NOEU", + "SIPO_NOEU", + ] + lDEFORMATION = [ + "EPMG_NOEU", + "EPSG_NOEU", + "EPSI_NOEU", + "EPSP_NOEU", + "EPVC_NOEU", + "EPFD_NOEU", + "EPFP_NOEU", + ] + lENERGIE = [ + "ENEL_NOEU", + "DISS_NOEU", + ] + lCRITERES = [ + "DERA_NOEU", + "ENDO_NOEU", + "EPEQ_NOEU", + "EPMQ_NOEU", + "SIEQ_NOEU", + "PMPB_NOEU", + ] + lVARI_INTERNE = [ + "VAEX_NOEU", + "VARI_NOEU", + ] + lTHERMIQUE = [ + "FLUX_NOEU", + "HYDR_NOEU", + ] + lACOUSTIQUE = [ + "INTE_NOEU", + "PRAC_NOEU", + ] + lFORCE = [ + "FORC_NODA", + "REAC_NODA", + ] + lERREUR = [ + "ERME_NOEU", + "ERTH_NOEU", + "QIRE_NOEU", + ] + lMETA = [ + "DURT_NOEU", + "META_NOEU", + ] ## Erreur pour les options supprimées - genereErreurValeur(jdc,"CALC_CHAMPNO","OPTION",("'SICA_NOEU'","'EFCA_NOEU'","'PMPB_NOEU'",)) - changementValeur(jdc,"CALC_CHAMPNO","OPTION",{"SICO_NOEU":"SIGM_NOEU",}) + genereErreurValeur( + jdc, + "CALC_CHAMPNO", + "OPTION", + ( + "'SICA_NOEU'", + "'EFCA_NOEU'", + "'PMPB_NOEU'", + ), + ) + changementValeur( + jdc, + "CALC_CHAMPNO", + "OPTION", + { + "SICO_NOEU": "SIGM_NOEU", + }, + ) ## copie de OPTION dans MCF TEMPORAIRE pour chaque type - chercheOperInsereFacteur(jdc,"CALC_CHAMPNO","TEMPORAIRE") - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","CONTRAINTE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","DEFORMATION",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","ENERGIE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","CRITERES",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","VARI_INTERNE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","THERMIQUE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","ACOUSTIQUE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","FORCE",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","ERREUR",pasDeRegle(),0) - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO","OPTION","TEMPORAIRE") - renameMotCleInFact(jdc,"CALC_CHAMPNO","TEMPORAIRE","OPTION","META",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMPNO","OPTION",pasDeRegle(),0) + chercheOperInsereFacteur(jdc, "CALC_CHAMPNO", "TEMPORAIRE") + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "CONTRAINTE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "DEFORMATION", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "ENERGIE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "CRITERES", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "VARI_INTERNE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "THERMIQUE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "ACOUSTIQUE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "FORCE", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "ERREUR", pasDeRegle(), 0 + ) + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", "OPTION", "TEMPORAIRE") + renameMotCleInFact( + jdc, "CALC_CHAMPNO", "TEMPORAIRE", "OPTION", "META", pasDeRegle(), 0 + ) + removeMotCle(jdc, "CALC_CHAMPNO", "OPTION", pasDeRegle(), 0) ## déplacement au premier niveau de mot-clés - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","CONTRAINTE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","DEFORMATION") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","ENERGIE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","CRITERES") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","VARI_INTERNE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","THERMIQUE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","ACOUSTIQUE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","FORCE") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","ERREUR") - moveMotCleFromFactToFather(jdc,"CALC_CHAMPNO","TEMPORAIRE","META") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "CONTRAINTE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "DEFORMATION") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "ENERGIE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "CRITERES") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "VARI_INTERNE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "THERMIQUE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "ACOUSTIQUE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "FORCE") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "ERREUR") + moveMotCleFromFactToFather(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "META") ## suppression des mot-clés s'ils ne contiennent pas d'options à traiter - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","CONTRAINTE",((("CONTRAINTE",lCONTRAINTE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","DEFORMATION",((("DEFORMATION",lDEFORMATION,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","ENERGIE",((("ENERGIE",lENERGIE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","CRITERES",((("CRITERES",lCRITERES,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","VARI_INTERNE",((("VARI_INTERNE",lVARI_INTERNE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","THERMIQUE",((("THERMIQUE",lTHERMIQUE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","ACOUSTIQUE",((("ACOUSTIQUE",lACOUSTIQUE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","FORCE",((("FORCE",lFORCE,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","ERREUR",((("ERREUR",lERREUR,jdc),"MCnaPasPourValeurDansListe"),)) - removeMotCleSiRegle(jdc,"CALC_CHAMPNO","META",((("META",lMETA,jdc),"MCnaPasPourValeurDansListe"),)) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "CONTRAINTE", + ((("CONTRAINTE", lCONTRAINTE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "DEFORMATION", + ((("DEFORMATION", lDEFORMATION, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "ENERGIE", + ((("ENERGIE", lENERGIE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "CRITERES", + ((("CRITERES", lCRITERES, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "VARI_INTERNE", + ((("VARI_INTERNE", lVARI_INTERNE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "THERMIQUE", + ((("THERMIQUE", lTHERMIQUE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "ACOUSTIQUE", + ((("ACOUSTIQUE", lACOUSTIQUE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "FORCE", + ((("FORCE", lFORCE, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "ERREUR", + ((("ERREUR", lERREUR, jdc), "MCnaPasPourValeurDansListe"),), + ) + removeMotCleSiRegle( + jdc, + "CALC_CHAMPNO", + "META", + ((("META", lMETA, jdc), "MCnaPasPourValeurDansListe"),), + ) ## suppression des valeurs non-licites - suppressionValeurs(jdc,"CALC_CHAMPNO","CONTRAINTE",list(set(lTOUT)-set(lCONTRAINTE))) - suppressionValeurs(jdc,"CALC_CHAMPNO","DEFORMATION",list(set(lTOUT)-set(lDEFORMATION))) - suppressionValeurs(jdc,"CALC_CHAMPNO","ENERGIE",list(set(lTOUT)-set(lENERGIE))) - suppressionValeurs(jdc,"CALC_CHAMPNO","CRITERES",list(set(lTOUT)-set(lCRITERES))) - suppressionValeurs(jdc,"CALC_CHAMPNO","VARI_INTERNE",list(set(lTOUT)-set(lVARI_INTERNE))) - suppressionValeurs(jdc,"CALC_CHAMPNO","THERMIQUE",list(set(lTOUT)-set(lTHERMIQUE))) - suppressionValeurs(jdc,"CALC_CHAMPNO","ACOUSTIQUE",list(set(lTOUT)-set(lACOUSTIQUE))) - suppressionValeurs(jdc,"CALC_CHAMPNO","FORCE",list(set(lTOUT)-set(lFORCE))) - suppressionValeurs(jdc,"CALC_CHAMPNO","ERREUR",list(set(lTOUT)-set(lERREUR))) - suppressionValeurs(jdc,"CALC_CHAMPNO","META",list(set(lTOUT)-set(lMETA))) + suppressionValeurs( + jdc, "CALC_CHAMPNO", "CONTRAINTE", list(set(lTOUT) - set(lCONTRAINTE)) + ) + suppressionValeurs( + jdc, "CALC_CHAMPNO", "DEFORMATION", list(set(lTOUT) - set(lDEFORMATION)) + ) + suppressionValeurs(jdc, "CALC_CHAMPNO", "ENERGIE", list(set(lTOUT) - set(lENERGIE))) + suppressionValeurs( + jdc, "CALC_CHAMPNO", "CRITERES", list(set(lTOUT) - set(lCRITERES)) + ) + suppressionValeurs( + jdc, "CALC_CHAMPNO", "VARI_INTERNE", list(set(lTOUT) - set(lVARI_INTERNE)) + ) + suppressionValeurs( + jdc, "CALC_CHAMPNO", "THERMIQUE", list(set(lTOUT) - set(lTHERMIQUE)) + ) + suppressionValeurs( + jdc, "CALC_CHAMPNO", "ACOUSTIQUE", list(set(lTOUT) - set(lACOUSTIQUE)) + ) + suppressionValeurs(jdc, "CALC_CHAMPNO", "FORCE", list(set(lTOUT) - set(lFORCE))) + suppressionValeurs(jdc, "CALC_CHAMPNO", "ERREUR", list(set(lTOUT) - set(lERREUR))) + suppressionValeurs(jdc, "CALC_CHAMPNO", "META", list(set(lTOUT) - set(lMETA))) ## ajout CALC_METANO ou CALC_ERREURNO - lMOTCLE=[] - lMOTCLE=["reuse","RESULTAT","TOUT_ORDRE","NUME_ORDRE","NUME_MODE","NOEUD_CMP","NOM_CAS", - "INST","FREQ","LIST_INST","LIST_FREQ","LIST_ORDRE","CRITERE","PRECISION","EXCIT"] + lMOTCLE = [] + lMOTCLE = [ + "reuse", + "RESULTAT", + "TOUT_ORDRE", + "NUME_ORDRE", + "NUME_MODE", + "NOEUD_CMP", + "NOM_CAS", + "INST", + "FREQ", + "LIST_INST", + "LIST_FREQ", + "LIST_ORDRE", + "CRITERE", + "PRECISION", + "EXCIT", + ] ### traitement métallurgie - llistMETA=[] - llistMETA=list(lMOTCLE) + llistMETA = [] + llistMETA = list(lMOTCLE) llistMETA.append("META") - for mc in llistMETA : - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO",mc,"TEMPORAIRE") - moveMCFToCommand(jdc,"CALC_CHAMPNO","TEMPORAIRE","CALC_METANO","TEMPORAIRE") - for mc in llistMETA : - moveMotCleFromFactToFather(jdc,"CALC_METANO","TEMPORAIRE",mc) - removeCommandeSiRegle(jdc,"CALC_METANO",((("META"),"nexistepasMCFParmi"),)) - renameMotCle(jdc,"CALC_METANO","META","OPTION") - removeMotCle(jdc,"CALC_METANO","TEMPORAIRE",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMPNO","TEMPORAIRE",pasDeRegle(),0) + for mc in llistMETA: + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", mc, "TEMPORAIRE") + moveMCFToCommand(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "CALC_METANO", "TEMPORAIRE") + for mc in llistMETA: + moveMotCleFromFactToFather(jdc, "CALC_METANO", "TEMPORAIRE", mc) + removeCommandeSiRegle(jdc, "CALC_METANO", ((("META"), "nexistepasMCFParmi"),)) + renameMotCle(jdc, "CALC_METANO", "META", "OPTION") + removeMotCle(jdc, "CALC_METANO", "TEMPORAIRE", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_CHAMPNO", "TEMPORAIRE", pasDeRegle(), 0) ### traitement calcul d'erreur - llistERREUR=[] - llistERREUR=list(lMOTCLE) + llistERREUR = [] + llistERREUR = list(lMOTCLE) llistERREUR.append("ERREUR") - for mc in llistERREUR : - copyMotClefInOperToFact(jdc,"CALC_CHAMPNO",mc,"TEMPORAIRE") - moveMCFToCommand(jdc,"CALC_CHAMPNO","TEMPORAIRE","CALC_ERREURNO","TEMPORAIRE") - for mc in llistERREUR : - moveMotCleFromFactToFather(jdc,"CALC_ERREURNO","TEMPORAIRE",mc) - removeCommandeSiRegle(jdc,"CALC_ERREURNO",((("ERREUR"),"nexistepasMCFParmi"),)) - renameMotCle(jdc,"CALC_ERREURNO","ERREUR","OPTION") - removeMotCle(jdc,"CALC_ERREURNO","TEMPORAIRE",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMPNO","TEMPORAIRE",pasDeRegle(),0) + for mc in llistERREUR: + copyMotClefInOperToFact(jdc, "CALC_CHAMPNO", mc, "TEMPORAIRE") + moveMCFToCommand(jdc, "CALC_CHAMPNO", "TEMPORAIRE", "CALC_ERREURNO", "TEMPORAIRE") + for mc in llistERREUR: + moveMotCleFromFactToFather(jdc, "CALC_ERREURNO", "TEMPORAIRE", mc) + removeCommandeSiRegle(jdc, "CALC_ERREURNO", ((("ERREUR"), "nexistepasMCFParmi"),)) + renameMotCle(jdc, "CALC_ERREURNO", "ERREUR", "OPTION") + removeMotCle(jdc, "CALC_ERREURNO", "TEMPORAIRE", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_CHAMPNO", "TEMPORAIRE", pasDeRegle(), 0) ## ménage final - removeCommandeSiRegle(jdc,"CALC_CHAMPNO",((("CONTRAINTE","DEFORMATION","ENERGIE","CRITERES","VARI_INTERNE","THERMIQUE","ACOUSTIQUE","FORCE"),"nexistepasMCFParmi"),)) - renameCommande(jdc,"CALC_CHAMPNO","CALC_CHAMP") - renameCommande(jdc,"CALC_METANO","CALC_META") - renameCommande(jdc,"CALC_ERREURNO","CALC_ERREUR") - removeMotCle(jdc,"CALC_CHAMP","METANO",pasDeRegle(),0) - removeMotCle(jdc,"CALC_CHAMP","ERREURNO",pasDeRegle(),0) + removeCommandeSiRegle( + jdc, + "CALC_CHAMPNO", + ( + ( + ( + "CONTRAINTE", + "DEFORMATION", + "ENERGIE", + "CRITERES", + "VARI_INTERNE", + "THERMIQUE", + "ACOUSTIQUE", + "FORCE", + ), + "nexistepasMCFParmi", + ), + ), + ) + renameCommande(jdc, "CALC_CHAMPNO", "CALC_CHAMP") + renameCommande(jdc, "CALC_METANO", "CALC_META") + renameCommande(jdc, "CALC_ERREURNO", "CALC_ERREUR") + removeMotCle(jdc, "CALC_CHAMP", "METANO", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_CHAMP", "ERREURNO", pasDeRegle(), 0) #### traitement de CALC_POINT_MAT ############################## # Rien à faire #### traitement de CALC_PRECONT ############################## # Renommage de IMPLEX - changementValeur(jdc,"CALC_PRECONT","METHODE",{"IMPL_EX":"IMPLEX"}) - removeMotCle(jdc,"CALC_PRECONT","IMPL_EX",pasDeRegle(),0) + changementValeur(jdc, "CALC_PRECONT", "METHODE", {"IMPL_EX": "IMPLEX"}) + removeMotCle(jdc, "CALC_PRECONT", "IMPL_EX", pasDeRegle(), 0) #### traitement de CALC_SENSI ############################## # Résorption de la sensibilité - removeCommande(jdc,"CALC_SENSI") - #genereErreurPourCommande(jdc,("CALC_SENSI",)) + removeCommande(jdc, "CALC_SENSI") + # genereErreurPourCommande(jdc,("CALC_SENSI",)) #### traitement de CALC_SPEC ############################## # Déplacement d'un mot-clé facteur facteur - moveMotCleFromFactToFather(jdc,"CALC_SPEC","TAB_ECHANT","LONGUEUR_ECH") - moveMotCleFromFactToFather(jdc,"CALC_SPEC","LONGUEUR_ECH","DUREE") - moveMotCleFromFactToFather(jdc,"CALC_SPEC","LONGUEUR_ECH","POURCENT") - moveMotCleFromFactToFather(jdc,"CALC_SPEC","LONGUEUR_ECH","NB_PTS") - removeMotCle(jdc,"CALC_SPEC","LONGUEUR_ECH",pasDeRegle(),0) - renameMotCle(jdc,"CALC_SPEC","DUREE","LONGUEUR_DUREE") - renameMotCle(jdc,"CALC_SPEC","POURCENT","LONGUEUR_POURCENT") - renameMotCle(jdc,"CALC_SPEC","NB_PTS","LONGUEUR_NB_PTS") - moveMotClefInOperToFact(jdc,"CALC_SPEC","LONGUEUR_DUREE","TAB_ECHANT") - moveMotClefInOperToFact(jdc,"CALC_SPEC","POURCENT_DUREE","TAB_ECHANT") - moveMotClefInOperToFact(jdc,"CALC_SPEC","LONGUEUR_NB_PTS","TAB_ECHANT") - moveMotCleFromFactToFather(jdc,"CALC_SPEC","TAB_ECHANT","RECOUVREMENT") - moveMotCleFromFactToFather(jdc,"CALC_SPEC","RECOUVREMENT","DUREE") - moveMotCleFromFactToFather(jdc,"CALC_SPEC","RECOUVREMENT","POURCENT") - moveMotCleFromFactToFather(jdc,"CALC_SPEC","RECOUVREMENT","NB_PTS") - removeMotCle(jdc,"CALC_SPEC","RECOUVREMENT",pasDeRegle(),0) - renameMotCle(jdc,"CALC_SPEC","DUREE","RECOUVREMENT_DUREE") - renameMotCle(jdc,"CALC_SPEC","POURCENT","RECOUVREMENT_POURCENT") - renameMotCle(jdc,"CALC_SPEC","NB_PTS","RECOUVREMENT_NB_PTS") - moveMotClefInOperToFact(jdc,"CALC_SPEC","RECOUVREMENT_DUREE","TAB_ECHANT") - moveMotClefInOperToFact(jdc,"CALC_SPEC","RECOUVREMENT_POURCENT","TAB_ECHANT") - moveMotClefInOperToFact(jdc,"CALC_SPEC","RECOUVREMENT_NB_PTS","TAB_ECHANT") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "TAB_ECHANT", "LONGUEUR_ECH") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "LONGUEUR_ECH", "DUREE") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "LONGUEUR_ECH", "POURCENT") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "LONGUEUR_ECH", "NB_PTS") + removeMotCle(jdc, "CALC_SPEC", "LONGUEUR_ECH", pasDeRegle(), 0) + renameMotCle(jdc, "CALC_SPEC", "DUREE", "LONGUEUR_DUREE") + renameMotCle(jdc, "CALC_SPEC", "POURCENT", "LONGUEUR_POURCENT") + renameMotCle(jdc, "CALC_SPEC", "NB_PTS", "LONGUEUR_NB_PTS") + moveMotClefInOperToFact(jdc, "CALC_SPEC", "LONGUEUR_DUREE", "TAB_ECHANT") + moveMotClefInOperToFact(jdc, "CALC_SPEC", "POURCENT_DUREE", "TAB_ECHANT") + moveMotClefInOperToFact(jdc, "CALC_SPEC", "LONGUEUR_NB_PTS", "TAB_ECHANT") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "TAB_ECHANT", "RECOUVREMENT") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "RECOUVREMENT", "DUREE") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "RECOUVREMENT", "POURCENT") + moveMotCleFromFactToFather(jdc, "CALC_SPEC", "RECOUVREMENT", "NB_PTS") + removeMotCle(jdc, "CALC_SPEC", "RECOUVREMENT", pasDeRegle(), 0) + renameMotCle(jdc, "CALC_SPEC", "DUREE", "RECOUVREMENT_DUREE") + renameMotCle(jdc, "CALC_SPEC", "POURCENT", "RECOUVREMENT_POURCENT") + renameMotCle(jdc, "CALC_SPEC", "NB_PTS", "RECOUVREMENT_NB_PTS") + moveMotClefInOperToFact(jdc, "CALC_SPEC", "RECOUVREMENT_DUREE", "TAB_ECHANT") + moveMotClefInOperToFact(jdc, "CALC_SPEC", "RECOUVREMENT_POURCENT", "TAB_ECHANT") + moveMotClefInOperToFact(jdc, "CALC_SPEC", "RECOUVREMENT_NB_PTS", "TAB_ECHANT") #### traitement de CALC_TABLE ############################## # Renommage de AJOUT en AJOUT_LIGNE - dOPE={"AJOUT":"AJOUT_LIGNE",} - changementValeurDsMCF(jdc,"CALC_TABLE","ACTION","OPERATION",dOPE) + dOPE = { + "AJOUT": "AJOUT_LIGNE", + } + changementValeurDsMCF(jdc, "CALC_TABLE", "ACTION", "OPERATION", dOPE) # Résorption de la sensibilité - removeMotCle(jdc,"CALC_TABLE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "CALC_TABLE", "SENSIBILITE", pasDeRegle(), 0) # Renommage critere table - dCRIT={"ABS_MAXI":"MAXI_ABS","ABS_MINI":"MINI_ABS"} - changementValeurDsMCF(jdc,"CALC_TABLE","FILTRE","CRIT_COMP",dCRIT) + dCRIT = {"ABS_MAXI": "MAXI_ABS", "ABS_MINI": "MINI_ABS"} + changementValeurDsMCF(jdc, "CALC_TABLE", "FILTRE", "CRIT_COMP", dCRIT) #### traitement de CALC_THETA ############################## # Résorption de la sensibilité - removeMotCle(jdc,"CALC_THETA","OPTION",pasDeRegle(),0) - removeMotCle(jdc,"CALC_THETA","THETA_BANDE",pasDeRegle(),1) - removeMotCle(jdc,"CALC_THETA","GRAD_NOEU_THETA",pasDeRegle(),0) + removeMotCle(jdc, "CALC_THETA", "OPTION", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_THETA", "THETA_BANDE", pasDeRegle(), 1) + removeMotCle(jdc, "CALC_THETA", "GRAD_NOEU_THETA", pasDeRegle(), 0) #### traitement de COMB_FOURIER ############################## # Homogénéisation de ANGLE - renameMotCle(jdc,"COMB_FOURIER","ANGL","ANGLE") + renameMotCle(jdc, "COMB_FOURIER", "ANGL", "ANGLE") #### traitement de COMB_SISM_MODAL ############################## - genereErreurValeur(jdc,"COMB_SISM_MODAL","OPTION",("'EFCA_ELNO'",)) + genereErreurValeur(jdc, "COMB_SISM_MODAL", "OPTION", ("'EFCA_ELNO'",)) #### traitement de CREA_CHAMP ############################## - removeMotCle(jdc,"CREA_CHAMP","SENSIBILITE",pasDeRegle(),0) - removeMotCle(jdc,"CREA_CHAMP","PROL_ZERO",pasDeRegle(),0) + removeMotCle(jdc, "CREA_CHAMP", "SENSIBILITE", pasDeRegle(), 0) + removeMotCle(jdc, "CREA_CHAMP", "PROL_ZERO", pasDeRegle(), 0) #### traitement de CREA_ELEM_SSD ############################## # Rien à faire #### traitement de CREA_MAILLAGE ############################## # Suppression de la possibilité de copier un maillage - lFACTEUR=['COQU_VOLU', 'CREA_FISS', 'CREA_GROUP_MA', 'CREA_MAILLE', 'CREA_POI1', - 'DETR_GROUP_MA', 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE', - 'QUAD_LINE', 'REPERE','RESTREINT','PENTA15_18','GEOM_FIBRE'] - renameCommandeSiRegle(jdc,"CREA_MAILLAGE","COPIER",(((lFACTEUR),"nexistepasMCFParmi"),)) - renameMotCle(jdc,"COPIER","MAILLAGE","CONCEPT") + lFACTEUR = [ + "COQU_VOLU", + "CREA_FISS", + "CREA_GROUP_MA", + "CREA_MAILLE", + "CREA_POI1", + "DETR_GROUP_MA", + "ECLA_PG", + "HEXA20_27", + "LINE_QUAD", + "MODI_MAILLE", + "QUAD_LINE", + "REPERE", + "RESTREINT", + "PENTA15_18", + "GEOM_FIBRE", + ] + renameCommandeSiRegle( + jdc, "CREA_MAILLAGE", "COPIER", (((lFACTEUR), "nexistepasMCFParmi"),) + ) + renameMotCle(jdc, "COPIER", "MAILLAGE", "CONCEPT") #### traitement de CREA_RESU ############################## # Rien à faire #### traitement de CREA_TABLE ############################## - removeMotCle(jdc,"CREA_TABLE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "CREA_TABLE", "SENSIBILITE", pasDeRegle(), 0) #### traitement de DEBUT ############################## # Suppression du mot-clé TITRE - removeMotCleInFact(jdc,"DEBUT","CATALOGUE","TITRE",pasDeRegle(),0) + removeMotCleInFact(jdc, "DEBUT", "CATALOGUE", "TITRE", pasDeRegle(), 0) # Suppression du mot-clé IMPRESSION - removeMotCle(jdc,"DEBUT","IMPRESSION",pasDeRegle(),0) + removeMotCle(jdc, "DEBUT", "IMPRESSION", pasDeRegle(), 0) # Suppression des mots-clés mémoire dynamique - removeMotCleInFact(jdc,"DEBUT","MEMOIRE","GESTION",pasDeRegle(),0) - removeMotCleInFact(jdc,"DEBUT","MEMOIRE","TYPE_ALLOCATION",pasDeRegle(),0) - removeMotCleInFact(jdc,"DEBUT","MEMOIRE","TAILLE",pasDeRegle(),0) - removeMotCleInFact(jdc,"DEBUT","MEMOIRE","PARTITION",pasDeRegle(),0) - removeMotCleInFact(jdc,"DEBUT","MEMOIRE","DYNAMIQUE",pasDeRegle(),0) + removeMotCleInFact(jdc, "DEBUT", "MEMOIRE", "GESTION", pasDeRegle(), 0) + removeMotCleInFact(jdc, "DEBUT", "MEMOIRE", "TYPE_ALLOCATION", pasDeRegle(), 0) + removeMotCleInFact(jdc, "DEBUT", "MEMOIRE", "TAILLE", pasDeRegle(), 0) + removeMotCleInFact(jdc, "DEBUT", "MEMOIRE", "PARTITION", pasDeRegle(), 0) + removeMotCleInFact(jdc, "DEBUT", "MEMOIRE", "DYNAMIQUE", pasDeRegle(), 0) #### traitement de DEFI_BASE_MODALE ############################## # Rien à faire @@ -843,95 +1476,158 @@ def traduc(infile,outfile,flog=None): #### traitement de DEFI_COMPOR ############################## # Suppression famille de sytèmes de glissement - lFAMGLIS=["'BASAL'", "'PRISMATIQUE'","'PYRAMIDAL1'","'PYRAMIDAL2'","'MACLAGE'",] - genereErreurValeurDsMCF(jdc,"DEFI_COMPOR","MONOCRISTAL","FAMI_SYST_GLIS",lFAMGLIS) + lFAMGLIS = [ + "'BASAL'", + "'PRISMATIQUE'", + "'PYRAMIDAL1'", + "'PYRAMIDAL2'", + "'MACLAGE'", + ] + genereErreurValeurDsMCF( + jdc, "DEFI_COMPOR", "MONOCRISTAL", "FAMI_SYST_GLIS", lFAMGLIS + ) # Suppression famille de sytèmes de glissement - genereErreurValeurDsMCF(jdc,"DEFI_COMPOR","MONOCRISTAL","ECOULEMENT",("'MONO_VISC3'",)) + genereErreurValeurDsMCF( + jdc, "DEFI_COMPOR", "MONOCRISTAL", "ECOULEMENT", ("'MONO_VISC3'",) + ) # Suppression de ALGO_1D - removeMotCleInFact(jdc,"DEFI_COMPOR","MULTIFIBRE","ALGO_1D",pasDeRegle(),0) - # Suppression de DEFORMATION - genereErreurMotCleInFact(jdc,"DEFI_COMPOR","MULTIFIBRE","DEFORMATION") + removeMotCleInFact(jdc, "DEFI_COMPOR", "MULTIFIBRE", "ALGO_1D", pasDeRegle(), 0) + # Suppression de DEFORMATION + genereErreurMotCleInFact(jdc, "DEFI_COMPOR", "MULTIFIBRE", "DEFORMATION") #### traitement de DEFI_CONTACT ############################## - genereErreurValeurDsMCF(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT",("'AVANCE'",)) - genereErreurValeurDsMCF(jdc,"DEFI_CONTACT","ZONE","ALGO_FROT",("'AVANCE'",)) + genereErreurValeurDsMCF(jdc, "DEFI_CONTACT", "ZONE", "ALGO_CONT", ("'AVANCE'",)) + genereErreurValeurDsMCF(jdc, "DEFI_CONTACT", "ZONE", "ALGO_FROT", ("'AVANCE'",)) # résorption de RACCORD_LINE_QUAD et éléments de Barsoum - genereErreurMCF(jdc,"DEFI_CONTACT","FOND_FISSURE") - genereErreurMCF(jdc,"DEFI_CONTACT","NOEUD_FOND") - genereErreurMCF(jdc,"DEFI_CONTACT","GROUP_NO_FOND") - genereErreurMCF(jdc,"DEFI_CONTACT","MAILLE_FOND") - genereErreurMCF(jdc,"DEFI_CONTACT","GROUP_MA_FOND") - genereErreurMCF(jdc,"DEFI_CONTACT","RACCORD_LINE_QUAD") - genereErreurMCF(jdc,"DEFI_CONTACT","NOEUD_RACC") - genereErreurMCF(jdc,"DEFI_CONTACT","GROUP_NO_RACC") - genereErreurMCF(jdc,"DEFI_CONTACT","EXCLUSION_PIV_NUL") - genereErreurMCF(jdc,"DEFI_CONTACT","COEF_ECHELLE") + genereErreurMCF(jdc, "DEFI_CONTACT", "FOND_FISSURE") + genereErreurMCF(jdc, "DEFI_CONTACT", "NOEUD_FOND") + genereErreurMCF(jdc, "DEFI_CONTACT", "GROUP_NO_FOND") + genereErreurMCF(jdc, "DEFI_CONTACT", "MAILLE_FOND") + genereErreurMCF(jdc, "DEFI_CONTACT", "GROUP_MA_FOND") + genereErreurMCF(jdc, "DEFI_CONTACT", "RACCORD_LINE_QUAD") + genereErreurMCF(jdc, "DEFI_CONTACT", "NOEUD_RACC") + genereErreurMCF(jdc, "DEFI_CONTACT", "GROUP_NO_RACC") + genereErreurMCF(jdc, "DEFI_CONTACT", "EXCLUSION_PIV_NUL") + genereErreurMCF(jdc, "DEFI_CONTACT", "COEF_ECHELLE") # résorption de COMPLIANCE - genereErreurMCF(jdc,"DEFI_CONTACT","COMPLIANCE") - genereErreurMCF(jdc,"DEFI_CONTACT","ASPERITE") - genereErreurMCF(jdc,"DEFI_CONTACT","E_N") - genereErreurMCF(jdc,"DEFI_CONTACT","E_V") + genereErreurMCF(jdc, "DEFI_CONTACT", "COMPLIANCE") + genereErreurMCF(jdc, "DEFI_CONTACT", "ASPERITE") + genereErreurMCF(jdc, "DEFI_CONTACT", "E_N") + genereErreurMCF(jdc, "DEFI_CONTACT", "E_V") # résorption de l'usure - genereErreurMCF(jdc,"DEFI_CONTACT","USURE") - genereErreurMCF(jdc,"DEFI_CONTACT","K") - genereErreurMCF(jdc,"DEFI_CONTACT","H") + genereErreurMCF(jdc, "DEFI_CONTACT", "USURE") + genereErreurMCF(jdc, "DEFI_CONTACT", "K") + genereErreurMCF(jdc, "DEFI_CONTACT", "H") # Suppression de schémas d'inégration pour XFEM - lSCHEMA=["FPG2","FPG3","FPG4","FPG6","FPG7","SIMPSON1","NCOTES1","NCOTES2"] - removeMotCleInFactSiRegle(jdc,"DEFI_CONTACT","ZONE","INTEGRATION",((("FORMULATION","XFEM",jdc),"MCaPourValeur")and(("ZONE","INTEGRATION",lSCHEMA,jdc),"MCsousMCFaPourValeurDansListe"),),) + lSCHEMA = ["FPG2", "FPG3", "FPG4", "FPG6", "FPG7", "SIMPSON1", "NCOTES1", "NCOTES2"] + removeMotCleInFactSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "INTEGRATION", + ( + (("FORMULATION", "XFEM", jdc), "MCaPourValeur") + and ( + ("ZONE", "INTEGRATION", lSCHEMA, jdc), + "MCsousMCFaPourValeurDansListe", + ), + ), + ) # règles sur relation - removeMotCleInFactSiRegle(jdc,"DEFI_CONTACT","ZONE","RELATION",((("ZONE","RELATION","NON",jdc),"MCsousMCFaPourValeur"),),) + removeMotCleInFactSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "RELATION", + ((("ZONE", "RELATION", "NON", jdc), "MCsousMCFaPourValeur"),), + ) # Suppression de schémas d'inégration pour méthode CONTINUE - lSCHEMA=["NOEUD","SIMPSON1","SIMPSON2","NCOTES1","NCOTES2"] - removeMotCleInFactSiRegle(jdc,"DEFI_CONTACT","ZONE","INTEGRATION",((("FORMULATION","CONTINUE",jdc),"MCaPourValeur")and(("ZONE","INTEGRATION",lSCHEMA,jdc),"MCsousMCFaPourValeurDansListe"),),) + lSCHEMA = ["NOEUD", "SIMPSON1", "SIMPSON2", "NCOTES1", "NCOTES2"] + removeMotCleInFactSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "INTEGRATION", + ( + (("FORMULATION", "CONTINUE", jdc), "MCaPourValeur") + and ( + ("ZONE", "INTEGRATION", lSCHEMA, jdc), + "MCsousMCFaPourValeurDansListe", + ), + ), + ) # Ajout règle sur REAC_GEOM - removeMotCleSiRegle(jdc,"DEFI_CONTACT","REAC_GEOM",((("ALGO_RESO_GEOM","NEWTON",jdc),"MCaPourValeur"),)) + removeMotCleSiRegle( + jdc, + "DEFI_CONTACT", + "REAC_GEOM", + ((("ALGO_RESO_GEOM", "NEWTON", jdc), "MCaPourValeur"),), + ) #### traitement de DEFI_COQU_MULT ############################## - renameCommande(jdc,"DEFI_COQU_MULT","DEFI_COMPOSITE", ) + renameCommande( + jdc, + "DEFI_COQU_MULT", + "DEFI_COMPOSITE", + ) #### traitement de DEFI_FICHIER ############################## # Rien à faire #### traitement de DEFI_FISS_XFEM ############################## # Suppression de ORIE_FOND - removeMotCle(jdc,"DEFI_FISS_XFEM","ORIE_FOND",pasDeRegle(),0) + removeMotCle(jdc, "DEFI_FISS_XFEM", "ORIE_FOND", pasDeRegle(), 0) # Fusion FORM_FISS='ELLIPSE' et FORM_FISS='INCLUSION' - dFORME={"INCLUSION":"ELLIPSE",} - changementValeurDsMCF(jdc,"DEFI_FISS_XFEM","DEFI_FISS","FORM_FISS",dOPE) + dFORME = { + "INCLUSION": "ELLIPSE", + } + changementValeurDsMCF(jdc, "DEFI_FISS_XFEM", "DEFI_FISS", "FORM_FISS", dOPE) #### traitement de DEFI_FONC_ELEC ############################## # Rien à faire #### traitement de DEFI_FOND_FISS ############################## - renameMotCle(jdc,"DEFI_FOND_FISS","FOND_FISS","FONDFISS") + renameMotCle(jdc, "DEFI_FOND_FISS", "FOND_FISS", "FONDFISS") # Cas FOND OUVERT - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_FOND_FISS","FONDFISS","TYPE_FOND='OUVERT'",((("FONDFISS",),"existe"),)) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DEFI_FOND_FISS", + "FONDFISS", + "TYPE_FOND='OUVERT'", + ((("FONDFISS",), "existe"),), + ) # Cas FOND FERME - chercheOperInsereFacteurSiRegle(jdc,"DEFI_FOND_FISS","TYPE_FOND='FERME'",((("FOND_FERME",),"existe"),),0) - renameMotCle(jdc,"DEFI_FOND_FISS","FOND_FERME","FONDFISS") - moveMotClefInOperToFact(jdc,"DEFI_FOND_FISS","TYPE_FOND","FONDFISS") + chercheOperInsereFacteurSiRegle( + jdc, "DEFI_FOND_FISS", "TYPE_FOND='FERME'", ((("FOND_FERME",), "existe"),), 0 + ) + renameMotCle(jdc, "DEFI_FOND_FISS", "FOND_FERME", "FONDFISS") + moveMotClefInOperToFact(jdc, "DEFI_FOND_FISS", "TYPE_FOND", "FONDFISS") # Cas FOND INF - chercheOperInsereFacteurSiRegle(jdc,"DEFI_FOND_FISS","TYPE_FOND='INF'",((("FOND_INF",),"existe"),),0) - renameMotCle(jdc,"DEFI_FOND_FISS","FOND_SUP","FONDFISS") - moveMotClefInOperToFact(jdc,"DEFI_FOND_FISS","TYPE_FOND","FONDFISS") + chercheOperInsereFacteurSiRegle( + jdc, "DEFI_FOND_FISS", "TYPE_FOND='INF'", ((("FOND_INF",), "existe"),), 0 + ) + renameMotCle(jdc, "DEFI_FOND_FISS", "FOND_SUP", "FONDFISS") + moveMotClefInOperToFact(jdc, "DEFI_FOND_FISS", "TYPE_FOND", "FONDFISS") # Cas FOND SUP - chercheOperInsereFacteurSiRegle(jdc,"DEFI_FOND_FISS","TYPE_FOND='SUP'",((("FOND_SUP",),"existe"),),0) - renameMotCle(jdc,"DEFI_FOND_FISS","FOND_SUP","FONDFISS") - moveMotClefInOperToFact(jdc,"DEFI_FOND_FISS","TYPE_FOND","FONDFISS") + chercheOperInsereFacteurSiRegle( + jdc, "DEFI_FOND_FISS", "TYPE_FOND='SUP'", ((("FOND_SUP",), "existe"),), 0 + ) + renameMotCle(jdc, "DEFI_FOND_FISS", "FOND_SUP", "FONDFISS") + moveMotClefInOperToFact(jdc, "DEFI_FOND_FISS", "TYPE_FOND", "FONDFISS") # Autres mots-clés - moveMotClefInOperToFact(jdc,"DEFI_FOND_FISS","DTAN_ORIG","FONDFISS") - moveMotClefInOperToFact(jdc,"DEFI_FOND_FISS","DTAN_EXTR","FONDFISS") - moveMotClefInOperToFact(jdc,"DEFI_FOND_FISS","VECT_GRNO_ORIG","FONDFISS") - moveMotClefInOperToFact(jdc,"DEFI_FOND_FISS","VECT_GRNO_EXTR","FONDFISS") - removeMotCle(jdc,"DEFI_FOND_FISS","NORMALE",pasDeRegle(),0) + moveMotClefInOperToFact(jdc, "DEFI_FOND_FISS", "DTAN_ORIG", "FONDFISS") + moveMotClefInOperToFact(jdc, "DEFI_FOND_FISS", "DTAN_EXTR", "FONDFISS") + moveMotClefInOperToFact(jdc, "DEFI_FOND_FISS", "VECT_GRNO_ORIG", "FONDFISS") + moveMotClefInOperToFact(jdc, "DEFI_FOND_FISS", "VECT_GRNO_EXTR", "FONDFISS") + removeMotCle(jdc, "DEFI_FOND_FISS", "NORMALE", pasDeRegle(), 0) # - renameMotCle(jdc,"DEFI_FOND_FISS","FONDFISS","FOND_FISS") + renameMotCle(jdc, "DEFI_FOND_FISS", "FONDFISS", "FOND_FISS") #### traitement de DEFI_GLRC ############################## # Renommage de mot-clés - renameMotCle(jdc,"DEFI_GLRC","GC","GAMMA_C") - renameMotCle(jdc,"DEFI_GLRC","SYC","NYC") - renameMotCle(jdc,"DEFI_GLRC","EPSI_FLEX","KAPPA_FLEX") + renameMotCle(jdc, "DEFI_GLRC", "GC", "GAMMA_C") + renameMotCle(jdc, "DEFI_GLRC", "SYC", "NYC") + renameMotCle(jdc, "DEFI_GLRC", "EPSI_FLEX", "KAPPA_FLEX") #### traitement de DEFI_GROUPE ############################## # Rien à faire @@ -940,49 +1636,51 @@ def traduc(infile,outfile,flog=None): # Rien à faire #### traitement de DEFI_LIST_INST ############################## - dMETHODE={"UNIFORME":"MANUEL","EXTRAPOLE":"MANUEL","AUCUNE":"AUTO"} - changementValeurDsMCF(jdc,"DEFI_LIST_INST","ECHEC","SUBD_METHODE",dMETHODE) - removeMotCleInFact(jdc,"DEFI_LIST_INST","ECHEC","SUBD_COEF_PAS_1",pasDeRegle(),0) + dMETHODE = {"UNIFORME": "MANUEL", "EXTRAPOLE": "MANUEL", "AUCUNE": "AUTO"} + changementValeurDsMCF(jdc, "DEFI_LIST_INST", "ECHEC", "SUBD_METHODE", dMETHODE) + removeMotCleInFact( + jdc, "DEFI_LIST_INST", "ECHEC", "SUBD_COEF_PAS_1", pasDeRegle(), 0 + ) #### traitement de DEFI_MATER_GC ############################## # Rien à faire, n'existe pas en 10 #### traitement de DEFI_MATERIAU ############################## # Suppression des critères pour les poutres - genereErreurMCF(jdc,"DEFI_MATERIAU","ECRO_FLEJOU") - genereErreurMCF(jdc,"DEFI_MATERIAU","VMIS_POUTRE") - genereErreurMCF(jdc,"DEFI_MATERIAU","VMIS_POUTRE_FO") + genereErreurMCF(jdc, "DEFI_MATERIAU", "ECRO_FLEJOU") + genereErreurMCF(jdc, "DEFI_MATERIAU", "VMIS_POUTRE") + genereErreurMCF(jdc, "DEFI_MATERIAU", "VMIS_POUTRE_FO") # Modification de la loi de grandissement - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","LEMAITRE_IRRA","GRAN_A") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","LEMAITRE_IRRA","GRAN_B") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","LEMAITRE_IRRA","GRAN_S") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","LMARC_IRRA","GRAN_A") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","LMARC_IRRA","GRAN_B") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","LMARC_IRRA","GRAN_S") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA_LOG","GRAN_A") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA_LOG","GRAN_B") - genereErreurMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA_LOG","GRAN_S") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "LEMAITRE_IRRA", "GRAN_A") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "LEMAITRE_IRRA", "GRAN_B") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "LEMAITRE_IRRA", "GRAN_S") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "LMARC_IRRA", "GRAN_A") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "LMARC_IRRA", "GRAN_B") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "LMARC_IRRA", "GRAN_S") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "GRAN_IRRA_LOG", "GRAN_A") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "GRAN_IRRA_LOG", "GRAN_B") + genereErreurMotCleInFact(jdc, "DEFI_MATERIAU", "GRAN_IRRA_LOG", "GRAN_S") # Modification des paramètres de la loi ENDO_SCALAIRE - genereErreurMCF(jdc,"DEFI_MATERIAU","ENDO_SCALAIRE") + genereErreurMCF(jdc, "DEFI_MATERIAU", "ENDO_SCALAIRE") # Modification des paramètres de la loi MAZARS - genereErreurMCF(jdc,"DEFI_MATERIAU","MAZARS") - genereErreurMCF(jdc,"DEFI_MATERIAU","MAZARS_FO") + genereErreurMCF(jdc, "DEFI_MATERIAU", "MAZARS") + genereErreurMCF(jdc, "DEFI_MATERIAU", "MAZARS_FO") # Modification des paramètres de la loi GLRC_DM - renameMotCleInFact(jdc,"DEFI_MATERIAU","GLRC_DM","SYT","NYT",pasDeRegle(),0) - renameMotCleInFact(jdc,"DEFI_MATERIAU","GLRC_DM","SYC","NYC",pasDeRegle(),0) - renameMotCleInFact(jdc,"DEFI_MATERIAU","GLRC_DM","SYF","NYF",pasDeRegle(),0) + renameMotCleInFact(jdc, "DEFI_MATERIAU", "GLRC_DM", "SYT", "NYT", pasDeRegle(), 0) + renameMotCleInFact(jdc, "DEFI_MATERIAU", "GLRC_DM", "SYC", "NYC", pasDeRegle(), 0) + renameMotCleInFact(jdc, "DEFI_MATERIAU", "GLRC_DM", "SYF", "NYF", pasDeRegle(), 0) # Suppression de la loi MONO_VISC3 - genereErreurMCF(jdc,"DEFI_MATERIAU","MONO_VISC3") + genereErreurMCF(jdc, "DEFI_MATERIAU", "MONO_VISC3") # Suppression de la loi MONO_DD_CC - genereErreurMCF(jdc,"DEFI_MATERIAU","MONO_DD_CC") + genereErreurMCF(jdc, "DEFI_MATERIAU", "MONO_DD_CC") #### traitement de DEFI_NAPPE ############################## # Rien à faire #### traitement de DEFI_PARA_SENSI ############################## # Résorption de la sensibilité - removeCommande(jdc,"DEFI_PARA_SENSI") - #genereErreurPourCommande(jdc,("DEFI_PARA_SENSI",)) + removeCommande(jdc, "DEFI_PARA_SENSI") + # genereErreurPourCommande(jdc,("DEFI_PARA_SENSI",)) #### traitement de DEFI_PART_FETI ############################## # Rien à faire @@ -992,112 +1690,237 @@ def traduc(infile,outfile,flog=None): #### traitement de DEFI_SPEC_TURB ############################## # Homogénéisation de ANGLE - renameMotCleInFact(jdc,"DEFI_SPEC_TURB","SPEC_EXCI_POINT","ANGL","ANGLE",pasDeRegle(),0) + renameMotCleInFact( + jdc, "DEFI_SPEC_TURB", "SPEC_EXCI_POINT", "ANGL", "ANGLE", pasDeRegle(), 0 + ) #### traitement de DETRUIRE ############################## # Résorption de la sensibilité - removeMotCleInFact(jdc,"DETRUIRE","CONCEPT","SENSIBILITE",pasDeRegle(),0) + removeMotCleInFact(jdc, "DETRUIRE", "CONCEPT", "SENSIBILITE", pasDeRegle(), 0) # Suppression mot-clé ALARME - removeMotCle(jdc,"DETRUIRE","ALARME",pasDeRegle(),0) + removeMotCle(jdc, "DETRUIRE", "ALARME", pasDeRegle(), 0) #### traitement de DYNA_ALEA_MODAL ############################## # Rien à faire #### traitement de DYNA_ISS_VARI ############################## - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DYNA_ISS_VARI","MATR_COHE","TYPE='MITA_LUCO'",((("MATR_COHE",),"existe"),)) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DYNA_ISS_VARI", + "MATR_COHE", + "TYPE='MITA_LUCO'", + ((("MATR_COHE",), "existe"),), + ) #### traitement de DYNA_LINE_HARM ############################## # Résorption de la sensibilité - removeMotCle(jdc,"DYNA_LINE_HARM","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "DYNA_LINE_HARM", "SENSIBILITE", pasDeRegle(), 0) # Suppression mot-clé TYPE_CHARGE - removeMotCleInFact(jdc,"DYNA_LINE_HARM","EXCIT","TYPE_CHARGE",pasDeRegle(),0) + removeMotCleInFact(jdc, "DYNA_LINE_HARM", "EXCIT", "TYPE_CHARGE", pasDeRegle(), 0) # Ajout AMOR_MODAL - chercheOperInsereFacteurSiRegle(jdc,"DYNA_LINE_HARM","AMOR_MODAL",((("AMOR_REDUIT","LIST_AMOR",),"existeMCFParmi"),),1) - moveMotClefInOperToFact(jdc,"DYNA_LINE_HARM","AMOR_REDUIT","AMOR_MODAL") - moveMotClefInOperToFact(jdc,"DYNA_LINE_HARM","LIST_AMOR","AMOR_MODAL") + chercheOperInsereFacteurSiRegle( + jdc, + "DYNA_LINE_HARM", + "AMOR_MODAL", + ( + ( + ( + "AMOR_REDUIT", + "LIST_AMOR", + ), + "existeMCFParmi", + ), + ), + 1, + ) + moveMotClefInOperToFact(jdc, "DYNA_LINE_HARM", "AMOR_REDUIT", "AMOR_MODAL") + moveMotClefInOperToFact(jdc, "DYNA_LINE_HARM", "LIST_AMOR", "AMOR_MODAL") #### traitement de DYNA_LINE_TRAN ############################## # Résorption de la sensibilité - removeMotCle(jdc,"DYNA_LINE_TRAN","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "DYNA_LINE_TRAN", "SENSIBILITE", pasDeRegle(), 0) # Ajout SCHEMA_TEMPS - chercheOperInsereFacteurSiRegle(jdc,"DYNA_LINE_TRAN","SCHEMA_TEMPS",((("NEWMARK","WILSON","DIFF_CENTRE","ADAPT",),"existeMCFParmi"),),1) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_LINE_TRAN","SCHEMA_TEMPS","SCHEMA='NEWMARK'",((("NEWMARK",),"existeMCFParmi"),)) - moveMotCleFromFactToFact(jdc,"DYNA_LINE_TRAN","NEWMARK","ALPHA","SCHEMA_TEMPS") - moveMotCleFromFactToFact(jdc,"DYNA_LINE_TRAN","NEWMARK","DELTA","SCHEMA_TEMPS") - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","SCHEMA_TEMPS","ALPHA","BETA",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","SCHEMA_TEMPS","DELTA","GAMMA",pasDeRegle(),0) - removeMotCle(jdc,"DYNA_LINE_TRAN","NEWMARK",pasDeRegle(),0) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_LINE_TRAN","SCHEMA_TEMPS","SCHEMA='WILSON'",((("WILSON",),"existeMCFParmi"),)) - moveMotCleFromFactToFact(jdc,"DYNA_LINE_TRAN","WILSON","THETA","SCHEMA_TEMPS") - removeMotCle(jdc,"DYNA_LINE_TRAN","WILSON",pasDeRegle(),0) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_LINE_TRAN","SCHEMA_TEMPS","SCHEMA='DIFF_CENTRE'",((("DIFF_CENTRE",),"existeMCFParmi"),)) - removeMotCle(jdc,"DYNA_LINE_TRAN","DIFF_CENTRE",pasDeRegle(),0) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_LINE_TRAN","SCHEMA_TEMPS","SCHEMA='ADAPT_ORDRE2'",((("ADAPT",),"existeMCFParmi"),)) - removeMotCle(jdc,"DYNA_LINE_TRAN","ADAPT",pasDeRegle(),0) + chercheOperInsereFacteurSiRegle( + jdc, + "DYNA_LINE_TRAN", + "SCHEMA_TEMPS", + ( + ( + ( + "NEWMARK", + "WILSON", + "DIFF_CENTRE", + "ADAPT", + ), + "existeMCFParmi", + ), + ), + 1, + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_LINE_TRAN", + "SCHEMA_TEMPS", + "SCHEMA='NEWMARK'", + ((("NEWMARK",), "existeMCFParmi"),), + ) + moveMotCleFromFactToFact(jdc, "DYNA_LINE_TRAN", "NEWMARK", "ALPHA", "SCHEMA_TEMPS") + moveMotCleFromFactToFact(jdc, "DYNA_LINE_TRAN", "NEWMARK", "DELTA", "SCHEMA_TEMPS") + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "SCHEMA_TEMPS", "ALPHA", "BETA", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "SCHEMA_TEMPS", "DELTA", "GAMMA", pasDeRegle(), 0 + ) + removeMotCle(jdc, "DYNA_LINE_TRAN", "NEWMARK", pasDeRegle(), 0) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_LINE_TRAN", + "SCHEMA_TEMPS", + "SCHEMA='WILSON'", + ((("WILSON",), "existeMCFParmi"),), + ) + moveMotCleFromFactToFact(jdc, "DYNA_LINE_TRAN", "WILSON", "THETA", "SCHEMA_TEMPS") + removeMotCle(jdc, "DYNA_LINE_TRAN", "WILSON", pasDeRegle(), 0) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_LINE_TRAN", + "SCHEMA_TEMPS", + "SCHEMA='DIFF_CENTRE'", + ((("DIFF_CENTRE",), "existeMCFParmi"),), + ) + removeMotCle(jdc, "DYNA_LINE_TRAN", "DIFF_CENTRE", pasDeRegle(), 0) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_LINE_TRAN", + "SCHEMA_TEMPS", + "SCHEMA='ADAPT_ORDRE2'", + ((("ADAPT",), "existeMCFParmi"),), + ) + removeMotCle(jdc, "DYNA_LINE_TRAN", "ADAPT", pasDeRegle(), 0) # Renommage dans ETAT_INIT - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ETAT_INIT","DYNA_TRANS","RESULTAT",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ETAT_INIT","DEPL_INIT","DEPL",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ETAT_INIT","ACCE_INIT","ACCE",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ETAT_INIT","VITE_INIT","VITE",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ETAT_INIT","NUME_INIT","NUME_ORDRE",pasDeRegle(),0) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "ETAT_INIT", "DYNA_TRANS", "RESULTAT", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "ETAT_INIT", "DEPL_INIT", "DEPL", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "ETAT_INIT", "ACCE_INIT", "ACCE", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "ETAT_INIT", "VITE_INIT", "VITE", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "ETAT_INIT", "NUME_INIT", "NUME_ORDRE", pasDeRegle(), 0 + ) # Suppression mot-clé TYPE_CHARGE - removeMotCleInFact(jdc,"DYNA_LINE_TRAN","EXCIT","TYPE_CHARGE",pasDeRegle(),0) + removeMotCleInFact(jdc, "DYNA_LINE_TRAN", "EXCIT", "TYPE_CHARGE", pasDeRegle(), 0) # Suppression mot-clé FONC_INST - genereErreurMotCleInFact(jdc,"DYNA_LINE_TRAN","INCREMENT","FONC_INST") + genereErreurMotCleInFact(jdc, "DYNA_LINE_TRAN", "INCREMENT", "FONC_INST") # Suppression mot-clé PAS_CALCUL - removeMotCleInFact(jdc,"DYNA_LINE_TRAN","INCREMENT","PAS_CALCUL",pasDeRegle(),0) + removeMotCleInFact( + jdc, "DYNA_LINE_TRAN", "INCREMENT", "PAS_CALCUL", pasDeRegle(), 0 + ) # Renommage dans ARCHIVAGE - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ARCHIVAGE","LIST_ARCH","LIST_INST",pasDeRegle(),0) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "ARCHIVAGE", "LIST_ARCH", "LIST_INST", pasDeRegle(), 0 + ) #### traitement de DYNA_NON_LINE ############################## # Renommage CRIT_FLAMB en CRIT_STAB - renameMotCle(jdc,"DYNA_NON_LINE","CRIT_FLAMB","CRIT_STAB") + renameMotCle(jdc, "DYNA_NON_LINE", "CRIT_FLAMB", "CRIT_STAB") # Résorption de la sensibilité - removeMotCle(jdc,"DYNA_NON_LINE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "DYNA_NON_LINE", "SENSIBILITE", pasDeRegle(), 0) # Suppression de ARCHIVAGE/DETR_NUME_SUIV - removeMotCleInFact(jdc,"DYNA_NON_LINE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0) + removeMotCleInFact( + jdc, "DYNA_NON_LINE", "ARCHIVAGE", "DETR_NUME_SUIV", pasDeRegle(), 0 + ) #### traitement de DYNA_SPEC_MODAL ############################## # Rien à faire #### traitement de DYNA_TRAN_MODAL ############################## # Ajout SCHEMA_TEMPS - chercheOperInsereFacteur(jdc,"DYNA_TRAN_MODAL","SCHEMA_TEMPS") - chercheOperInsereMotCleSiRegle(jdc,"DYNA_TRAN_MODAL","METHODE='EULER'",((("METHODE",),"nexistepas"),),) - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","METHODE","SCHEMA_TEMPS") - renameMotCleInFact(jdc,"DYNA_TRAN_MODAL","SCHEMA_TEMPS","METHODE","SCHEMA",pasDeRegle(),0) - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","BASE_ELAS_FLUI","SCHEMA_TEMPS") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","NUME_VITE_FLUI","SCHEMA_TEMPS") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","ETAT_STAT","SCHEMA_TEMPS") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","PREC_DUREE","SCHEMA_TEMPS") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","CHOC_FLUI","SCHEMA_TEMPS") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","NB_MODE","SCHEMA_TEMPS") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","NB_MODE_FLUI","SCHEMA_TEMPS") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","TS_REG_ETAB","SCHEMA_TEMPS") + chercheOperInsereFacteur(jdc, "DYNA_TRAN_MODAL", "SCHEMA_TEMPS") + chercheOperInsereMotCleSiRegle( + jdc, + "DYNA_TRAN_MODAL", + "METHODE='EULER'", + ((("METHODE",), "nexistepas"),), + ) + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "METHODE", "SCHEMA_TEMPS") + renameMotCleInFact( + jdc, "DYNA_TRAN_MODAL", "SCHEMA_TEMPS", "METHODE", "SCHEMA", pasDeRegle(), 0 + ) + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "BASE_ELAS_FLUI", "SCHEMA_TEMPS") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "NUME_VITE_FLUI", "SCHEMA_TEMPS") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "ETAT_STAT", "SCHEMA_TEMPS") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "PREC_DUREE", "SCHEMA_TEMPS") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "CHOC_FLUI", "SCHEMA_TEMPS") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "NB_MODE", "SCHEMA_TEMPS") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "NB_MODE_FLUI", "SCHEMA_TEMPS") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "TS_REG_ETAB", "SCHEMA_TEMPS") # Renommage des matrices - renameMotCle(jdc,"DYNA_TRAN_MODAL","MASS_GENE","MATR_MASS") - renameMotCle(jdc,"DYNA_TRAN_MODAL","RIGI_GENE","MATR_RIGI") - renameMotCle(jdc,"DYNA_TRAN_MODAL","AMOR_GENE","MATR_AMOR") + renameMotCle(jdc, "DYNA_TRAN_MODAL", "MASS_GENE", "MATR_MASS") + renameMotCle(jdc, "DYNA_TRAN_MODAL", "RIGI_GENE", "MATR_RIGI") + renameMotCle(jdc, "DYNA_TRAN_MODAL", "AMOR_GENE", "MATR_AMOR") # Ajout AMOR_MODAL - chercheOperInsereFacteurSiRegle(jdc,"DYNA_TRAN_MODAL","AMOR_MODAL",((("AMOR_REDUIT","LIST_AMOR",),"existeMCFParmi"),),1) - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","AMOR_REDUIT","AMOR_MODAL") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","LIST_AMOR","AMOR_MODAL") + chercheOperInsereFacteurSiRegle( + jdc, + "DYNA_TRAN_MODAL", + "AMOR_MODAL", + ( + ( + ( + "AMOR_REDUIT", + "LIST_AMOR", + ), + "existeMCFParmi", + ), + ), + 1, + ) + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "AMOR_REDUIT", "AMOR_MODAL") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "LIST_AMOR", "AMOR_MODAL") # couplage - chercheOperInsereFacteurSiRegle(jdc,"DYNA_TRAN_MODAL","VITESSE_VARIABLE='NON'",((("COUPLAGE_EDYOS"),"existe"),),1) - moveMotCleFromFactToFather(jdc,"DYNA_TRAN_MODAL","COUPLAGE_EDYOS","VITE_ROTA") + chercheOperInsereFacteurSiRegle( + jdc, + "DYNA_TRAN_MODAL", + "VITESSE_VARIABLE='NON'", + ((("COUPLAGE_EDYOS"), "existe"),), + 1, + ) + moveMotCleFromFactToFather(jdc, "DYNA_TRAN_MODAL", "COUPLAGE_EDYOS", "VITE_ROTA") # Renommage dans ETAT_INIT - renameMotCleInFact(jdc,"DYNA_TRAN_MODAL","ETAT_INIT","RESU_GENE","RESULTAT",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_TRAN_MODAL","ETAT_INIT","INIT_GENE","DEPL",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_TRAN_MODAL","ETAT_INIT","DEPL_INIT_GENE","DEPL",pasDeRegle(),0) - renameMotCleInFact(jdc,"DYNA_TRAN_MODAL","ETAT_INIT","VITE_INIT_GENE","VITE",pasDeRegle(),0) + renameMotCleInFact( + jdc, "DYNA_TRAN_MODAL", "ETAT_INIT", "RESU_GENE", "RESULTAT", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_TRAN_MODAL", "ETAT_INIT", "INIT_GENE", "DEPL", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_TRAN_MODAL", "ETAT_INIT", "DEPL_INIT_GENE", "DEPL", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, "DYNA_TRAN_MODAL", "ETAT_INIT", "VITE_INIT_GENE", "VITE", pasDeRegle(), 0 + ) # Renommage dans ARCHIVAGE - renameMotCleInFact(jdc,"DYNA_LINE_TRAN","ARCHIVAGE","LIST_ARCH","LIST_INST",pasDeRegle(),0) + renameMotCleInFact( + jdc, "DYNA_LINE_TRAN", "ARCHIVAGE", "LIST_ARCH", "LIST_INST", pasDeRegle(), 0 + ) # Paramètres LAME_FLUIDE - chercheOperInsereFacteurSiRegle(jdc,"DYNA_TRAN_MODAL","PARA_LAMEFLUI",((("NMAX_ITER","RESI_RELA","LAMBDA"),"existeMCFParmi"),),1) - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","NMAX_ITER","PARA_LAMEFLUI") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","RESI_RELA","PARA_LAMEFLUI") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_MODAL","LAMBDA","PARA_LAMEFLUI") - renameMotCle(jdc,"DYNA_TRAN_MODAL","PARA_LAMEFLUI","PARA_LAME_FLUI") + chercheOperInsereFacteurSiRegle( + jdc, + "DYNA_TRAN_MODAL", + "PARA_LAMEFLUI", + ((("NMAX_ITER", "RESI_RELA", "LAMBDA"), "existeMCFParmi"),), + 1, + ) + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "NMAX_ITER", "PARA_LAMEFLUI") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "RESI_RELA", "PARA_LAMEFLUI") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_MODAL", "LAMBDA", "PARA_LAMEFLUI") + renameMotCle(jdc, "DYNA_TRAN_MODAL", "PARA_LAMEFLUI", "PARA_LAME_FLUI") #### traitement de DYNA_VIBRA ############################## # Rien à faire, n'existe pas en 10 @@ -1107,22 +1930,26 @@ def traduc(infile,outfile,flog=None): #### traitement de EXTR_RESU ############################## # Résorption de la sensibilité - removeMotCle(jdc,"EXTR_RESU","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "EXTR_RESU", "SENSIBILITE", pasDeRegle(), 0) #### traitement de EXTR_TABLE ############################## # Renommage critere table - dCRIT={"ABS_MAXI":"MAXI_ABS","ABS_MINI":"MINI_ABS"} - changementValeurDsMCF(jdc,"RECU_TABLE","FILTRE","CRIT_COMP",dCRIT) + dCRIT = {"ABS_MAXI": "MAXI_ABS", "ABS_MINI": "MINI_ABS"} + changementValeurDsMCF(jdc, "RECU_TABLE", "FILTRE", "CRIT_COMP", dCRIT) #### traitement de FACTORISER ############################## # Suppression de RENUM - removeMotCleSiRegle(jdc,"FACTORISER","RENUM",((("PRE_COND","LDLT_INC",jdc),"MCaPourValeur"),)) - removeMotCleSiRegle(jdc,"FACTORISER","RENUM",((("PRE_COND","LDLT_SP",jdc),"MCaPourValeur"),)) + removeMotCleSiRegle( + jdc, "FACTORISER", "RENUM", ((("PRE_COND", "LDLT_INC", jdc), "MCaPourValeur"),) + ) + removeMotCleSiRegle( + jdc, "FACTORISER", "RENUM", ((("PRE_COND", "LDLT_SP", jdc), "MCaPourValeur"),) + ) # Modification mot-clés liés à la mémoire - removeMotCle(jdc,"FACTORISER","LIBERE_MEMOIRE",pasDeRegle(),0) - renameMotCle(jdc,"FACTORISER","OUT_OF_CORE","GESTION_MEMOIRE") - dMEM={"OUI":"OUT_OF_CORE","NON":"IN_CORE"} - changementValeur(jdc,"FACTORISER","GESTION_MEMOIRE",dCRIT) + removeMotCle(jdc, "FACTORISER", "LIBERE_MEMOIRE", pasDeRegle(), 0) + renameMotCle(jdc, "FACTORISER", "OUT_OF_CORE", "GESTION_MEMOIRE") + dMEM = {"OUI": "OUT_OF_CORE", "NON": "IN_CORE"} + changementValeur(jdc, "FACTORISER", "GESTION_MEMOIRE", dCRIT) #### traitement de FORMULE ############################## # Rien à faire @@ -1138,7 +1965,7 @@ def traduc(infile,outfile,flog=None): #### traitement de IMPR_CO ############################## # Résorption de la sensibilité - removeMotCleInFact(jdc,"IMPR_CO","CONCEPT","SENSIBILITE",pasDeRegle(),0) + removeMotCleInFact(jdc, "IMPR_CO", "CONCEPT", "SENSIBILITE", pasDeRegle(), 0) #### traitement de IMPR_DIAG_CAMPBELL ############################## # Rien à faire @@ -1154,46 +1981,98 @@ def traduc(infile,outfile,flog=None): #### traitement de IMPR_RESU ############################## # Résorption de la sensibilité - removeMotCleInFact(jdc,"IMPR_RESU","RESU","SENSIBILITE",pasDeRegle(),0) + removeMotCleInFact(jdc, "IMPR_RESU", "RESU", "SENSIBILITE", pasDeRegle(), 0) # Suppression de l'écriture au format ENSIGHT - genereErreurValeur(jdc,"IMPR_RESU","FORMAT",("'ENSIGHT'",)) + genereErreurValeur(jdc, "IMPR_RESU", "FORMAT", ("'ENSIGHT'",)) # Homogénéisation de ANGLE - renameMotCleInFact(jdc,"IMPR_RESU","FORMAT","ANGL","ANGLE",pasDeRegle(),0) + renameMotCleInFact(jdc, "IMPR_RESU", "FORMAT", "ANGL", "ANGLE", pasDeRegle(), 0) # Suppression mot-clé MODELE - removeMotCle(jdc,"IMPR_RESU","MODELE",pasDeRegle(),0) + removeMotCle(jdc, "IMPR_RESU", "MODELE", pasDeRegle(), 0) #### traitement de IMPR_STURM ############################## - renameMotCle(jdc,"IMPR_STURM","TYPE_RESU","TYPE_MODE") + renameMotCle(jdc, "IMPR_STURM", "TYPE_RESU", "TYPE_MODE") # renommage de MATR_A, MATR_B et MATR_C - renameMotCleSiRegle(jdc,"IMPR_STURM","MATR_A","MATR_RIGI",((("TYPE_MODE","DYNAMIQUE",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"IMPR_STURM","MATR_B","MATR_MASS",((("TYPE_MODE","DYNAMIQUE",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"IMPR_STURM","MATR_A","MATR_RIGI",((("TYPE_MODE","MODE_FLAMB",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"IMPR_STURM","MATR_B","MATR_RIGI_GEOM",((("TYPE_MODE","MODE_FLAMB",jdc),"MCaPourValeur"),),1) - renameMotCle(jdc,"IMPR_STURM","MATR_A","MATR_RIGI") - renameMotCle(jdc,"IMPR_STURM","MATR_B","MATR_MASS") + renameMotCleSiRegle( + jdc, + "IMPR_STURM", + "MATR_A", + "MATR_RIGI", + ((("TYPE_MODE", "DYNAMIQUE", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "IMPR_STURM", + "MATR_B", + "MATR_MASS", + ((("TYPE_MODE", "DYNAMIQUE", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "IMPR_STURM", + "MATR_A", + "MATR_RIGI", + ((("TYPE_MODE", "MODE_FLAMB", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "IMPR_STURM", + "MATR_B", + "MATR_RIGI_GEOM", + ((("TYPE_MODE", "MODE_FLAMB", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCle(jdc, "IMPR_STURM", "MATR_A", "MATR_RIGI") + renameMotCle(jdc, "IMPR_STURM", "MATR_B", "MATR_MASS") # - chercheOperInsereMotCleSiRegle(jdc,"IMPR_STURM","FREQ_MIN=0.",((("FREQ_MIN",),"nexistepas")and(("FREQ_MAX",),"existeMCFParmi"),),) - fusionMotCleToFact(jdc,"IMPR_STURM",("FREQ_MIN","FREQ_MAX"),"FREQ") - fusionMotCleToFact(jdc,"IMPR_STURM",("CHAR_CRIT_MIN","CHAR_CRIT_MAX"),"CHAR_CRIT") + chercheOperInsereMotCleSiRegle( + jdc, + "IMPR_STURM", + "FREQ_MIN=0.", + ((("FREQ_MIN",), "nexistepas") and (("FREQ_MAX",), "existeMCFParmi"),), + ) + fusionMotCleToFact(jdc, "IMPR_STURM", ("FREQ_MIN", "FREQ_MAX"), "FREQ") + fusionMotCleToFact( + jdc, "IMPR_STURM", ("CHAR_CRIT_MIN", "CHAR_CRIT_MAX"), "CHAR_CRIT" + ) # Ajout COMPTAGE - chercheOperInsereFacteurSiRegle(jdc,"IMPR_STURM","COMPTAGE",((("NMAX_ITER_SHIFT","PREC_SHIFT","SEUIL_FREQ"),"existeMCFParmi"),),1) - moveMotClefInOperToFact(jdc,"IMPR_STURM","NMAX_ITER_SHIFT","COMPTAGE") - moveMotClefInOperToFact(jdc,"IMPR_STURM","PREC_SHIFT","COMPTAGE") - moveMotClefInOperToFact(jdc,"IMPR_STURM","SEUIL_FREQ","COMPTAGE") - renameMotCleInFactSiRegle(jdc,"IMPR_STURM","COMPTAGE","SEUIL_FREQ","SEUIL_CHAR_CRIT",((("TYPE_MODE","MODE_FLAMB",jdc),"MCaPourValeur"),),) + chercheOperInsereFacteurSiRegle( + jdc, + "IMPR_STURM", + "COMPTAGE", + ((("NMAX_ITER_SHIFT", "PREC_SHIFT", "SEUIL_FREQ"), "existeMCFParmi"),), + 1, + ) + moveMotClefInOperToFact(jdc, "IMPR_STURM", "NMAX_ITER_SHIFT", "COMPTAGE") + moveMotClefInOperToFact(jdc, "IMPR_STURM", "PREC_SHIFT", "COMPTAGE") + moveMotClefInOperToFact(jdc, "IMPR_STURM", "SEUIL_FREQ", "COMPTAGE") + renameMotCleInFactSiRegle( + jdc, + "IMPR_STURM", + "COMPTAGE", + "SEUIL_FREQ", + "SEUIL_CHAR_CRIT", + ((("TYPE_MODE", "MODE_FLAMB", jdc), "MCaPourValeur"),), + ) # Suppression UNITE - removeMotCle(jdc,"IMPR_STURM","UNITE",pasDeRegle(),0) + removeMotCle(jdc, "IMPR_STURM", "UNITE", pasDeRegle(), 0) # Renommage de la commande - renameCommande(jdc,"IMPR_STURM","INFO_MODE", ) + renameCommande( + jdc, + "IMPR_STURM", + "INFO_MODE", + ) #### traitement de IMPR_TABLE ############################## # Résorption de la sensibilité - removeMotCle(jdc,"IMPR_TABLE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "IMPR_TABLE", "SENSIBILITE", pasDeRegle(), 0) # Renommage critere table - dCRIT={"ABS_MAXI":"MAXI_ABS","ABS_MINI":"MINI_ABS"} - changementValeurDsMCF(jdc,"IMPR_TABLE","FILTRE","CRIT_COMP",dCRIT) + dCRIT = {"ABS_MAXI": "MAXI_ABS", "ABS_MINI": "MINI_ABS"} + changementValeurDsMCF(jdc, "IMPR_TABLE", "FILTRE", "CRIT_COMP", dCRIT) # Suppression de FORMAT_C - genereErreurMCF(jdc,"IMPR_TABLE","FORMAT_C") + genereErreurMCF(jdc, "IMPR_TABLE", "FORMAT_C") #### traitement de INCLUDE ############################## # Rien à faire @@ -1227,33 +2106,53 @@ def traduc(infile,outfile,flog=None): #### traitement de LIRE_RESU ############################## # Suppression du type HARM_GENE - genereErreurValeur(jdc,"LIRE_RESU","TYPE_RESU",("'HARM_GENE'",)) + genereErreurValeur(jdc, "LIRE_RESU", "TYPE_RESU", ("'HARM_GENE'",)) # renommage de MATR_A et MATR_B - renameMotCle(jdc,"LIRE_RESU","MATR_A","MATR_RIGI") - renameMotCle(jdc,"LIRE_RESU","MATR_B","MATR_MASS") - removeMotCle(jdc,"LIRE_RESU","NUME_DDL",pasDeRegle(),0) + renameMotCle(jdc, "LIRE_RESU", "MATR_A", "MATR_RIGI") + renameMotCle(jdc, "LIRE_RESU", "MATR_B", "MATR_MASS") + removeMotCle(jdc, "LIRE_RESU", "NUME_DDL", pasDeRegle(), 0) # Suppression de certains champ - lSUPCHAMPS=["'EFCA_ELNO'","'EFCA_NOEU'","'EPTQ_ELNO'","'EPTU_ELNO'", - "'PMPB_ELNO'","'PMPB_NOEU'","'SITQ_ELNO'","'SICA_ELNO'", - "'SICO_ELNO'","'SITU_ELNO'","'SICA_NOEU'","'SICO_NOEU'", - "'SPMX_ELGA'","'VACO_ELNO'","'VATU_ELNO'",] - genereErreurValeurDsMCF(jdc,"LIRE_RESU","FORMAT_IDEAS","NOM_CHAM",lSUPCHAMPS) - genereErreurValeurDsMCF(jdc,"LIRE_RESU","FORMAT_MED","NOM_CHAM",lSUPCHAMPS) - genereErreurValeur(jdc,"LIRE_RESU","NOM_CHAM",lSUPCHAMPS) + lSUPCHAMPS = [ + "'EFCA_ELNO'", + "'EFCA_NOEU'", + "'EPTQ_ELNO'", + "'EPTU_ELNO'", + "'PMPB_ELNO'", + "'PMPB_NOEU'", + "'SITQ_ELNO'", + "'SICA_ELNO'", + "'SICO_ELNO'", + "'SITU_ELNO'", + "'SICA_NOEU'", + "'SICO_NOEU'", + "'SPMX_ELGA'", + "'VACO_ELNO'", + "'VATU_ELNO'", + ] + genereErreurValeurDsMCF(jdc, "LIRE_RESU", "FORMAT_IDEAS", "NOM_CHAM", lSUPCHAMPS) + genereErreurValeurDsMCF(jdc, "LIRE_RESU", "FORMAT_MED", "NOM_CHAM", lSUPCHAMPS) + genereErreurValeur(jdc, "LIRE_RESU", "NOM_CHAM", lSUPCHAMPS) #### traitement de LIRE_TABLE ############################## # Rien à faire #### traitement de MACR_ADAP_MAIL ############################## # Résorption de la sensibilité - removeMotCle(jdc,"MACR_ADAP_MAIL","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "MACR_ADAP_MAIL", "SENSIBILITE", pasDeRegle(), 0) # Changement de version - changementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V10_1":"V10_6"}) + changementValeur(jdc, "MACR_ADAP_MAIL", "VERSION_HOMARD", {"V10_1": "V10_6"}) # Changement d'adaptation - changementValeur(jdc,"MACR_ADAP_MAIL","ADAPTATION",{"RAFFINEMENT_ZONE":"RAFF_DERA_ZONE"}) + changementValeur( + jdc, "MACR_ADAP_MAIL", "ADAPTATION", {"RAFFINEMENT_ZONE": "RAFF_DERA_ZONE"} + ) # Renommage du mot-clé ELEMENTS_NON_HOMARD - renameMotCle(jdc,"MACR_ADAP_MAIL","ELEMENTS_NON_HOMARD","ELEMENTS_ACCEPTES") - changementValeur(jdc,"MACR_ADAP_MAIL","ELEMENTS_ACCEPTES",{"REFUSER":"HOMARD","IGNORER":"IGNORE_PYRA"}) + renameMotCle(jdc, "MACR_ADAP_MAIL", "ELEMENTS_NON_HOMARD", "ELEMENTS_ACCEPTES") + changementValeur( + jdc, + "MACR_ADAP_MAIL", + "ELEMENTS_ACCEPTES", + {"REFUSER": "HOMARD", "IGNORER": "IGNORE_PYRA"}, + ) #### traitement de MACR_ASCOUF_CALC ############################## # Rien à faire @@ -1268,55 +2167,108 @@ def traduc(infile,outfile,flog=None): # Rien à faire #### traitement de MACR_CARA_POUTRE ############################## - renameMotCle(jdc,"MACR_CARA_POUTRE","SYME_Y","SYME_ZZ") - renameMotCle(jdc,"MACR_CARA_POUTRE","SYME_X","SYME_Y") - renameMotCle(jdc,"MACR_CARA_POUTRE","SYME_ZZ","SYME_Z") + renameMotCle(jdc, "MACR_CARA_POUTRE", "SYME_Y", "SYME_ZZ") + renameMotCle(jdc, "MACR_CARA_POUTRE", "SYME_X", "SYME_Y") + renameMotCle(jdc, "MACR_CARA_POUTRE", "SYME_ZZ", "SYME_Z") #### traitement de MACR_ECLA_PG ############################## # Rien à faire #### traitement de MACR_ECRE_CALC ############################## # Changement de version - changementValeur(jdc,"MACR_ECRE_CALC","VERSION",{"3.1.1":"3.2.1","3.1.2":"3.2.1","3.2":"3.2.1"}) + changementValeur( + jdc, + "MACR_ECRE_CALC", + "VERSION", + {"3.1.1": "3.2.1", "3.1.2": "3.2.1", "3.2": "3.2.1"}, + ) #### traitement de MACR_ECREVISSE ############################## # Changement de version - changementValeur(jdc,"MACR_ECRE_CALC","VERSION",{"3.1.1":"3.2.1","3.1.2":"3.2.1","3.2":"3.2.1"}) + changementValeur( + jdc, + "MACR_ECRE_CALC", + "VERSION", + {"3.1.1": "3.2.1", "3.1.2": "3.2.1", "3.2": "3.2.1"}, + ) #### traitement de MACR_ELEM_DYNA ############################## # Rien à faire #### traitement de MACR_FIABILITE ############################## - genereErreurPourCommande(jdc,("MACR_FIABILITE",)) + genereErreurPourCommande(jdc, ("MACR_FIABILITE",)) #### traitement de MACR_FIAB_IMPR ############################## - genereErreurPourCommande(jdc,("MACR_FIAB_IMPR",)) + genereErreurPourCommande(jdc, ("MACR_FIAB_IMPR",)) #### traitement de MACR_INFO_MAIL ############################## # Changement de version - changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_1":"V10_6"}) + changementValeur(jdc, "MACR_INFO_MAIL", "VERSION_HOMARD", {"V10_1": "V10_6"}) # Renommage du mot-clé ELEMENTS_NON_HOMARD - renameMotCle(jdc,"MACR_INFO_MAIL","ELEMENTS_NON_HOMARD","ELEMENTS_ACCEPTES") - changementValeur(jdc,"MACR_INFO_MAIL","ELEMENTS_ACCEPTES",{"REFUSER":"HOMARD","IGNORER":"IGNORE_PYRA"}) + renameMotCle(jdc, "MACR_INFO_MAIL", "ELEMENTS_NON_HOMARD", "ELEMENTS_ACCEPTES") + changementValeur( + jdc, + "MACR_INFO_MAIL", + "ELEMENTS_ACCEPTES", + {"REFUSER": "HOMARD", "IGNORER": "IGNORE_PYRA"}, + ) #### traitement de MACR_LIGN_COUPE ############################## # Rien à faire #### traitement de MACRO_ELAS_MULT ############################## # Résorption de NUME_COUCHE NIVE_COUCHE - removeMotCleInFact(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","NUME_COUCHE",pasDeRegle(),0) - removeMotCleInFact(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","NIVE_COUCHE",pasDeRegle(),0) + removeMotCleInFact( + jdc, "MACRO_ELAS_MULT", "CAS_CHARGE", "NUME_COUCHE", pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "MACRO_ELAS_MULT", "CAS_CHARGE", "NIVE_COUCHE", pasDeRegle(), 0 + ) # Réduction de la liste des options calculables - lOPT=["'EFGE_ELNO'","'EPOT_ELEM'","'SIGM_ELNO'","'SICA_ELNO'","'EFCA_ELNO'", - "'DEGE_ELNO'","'EPSI_ELNO'","'EPSI_ELGA'","'EPSG_ELNO'","'EPSG_ELGA'", - "'EPSP_ELNO'","'EPSP_ELGA'","'ECIN_ELEM'","'FLUX_ELGA'","'FLUX_ELNO'", - "'SOUR_ELGA'","'PRAC_ELNO'","'INTE_ELNO'","'SIZ1_NOEU'","'ERZ1_ELEM'", - "'SIZ2_NOEU'","'ERZ2_ELEM'","'VNOR_ELEM_DEPL'","'ERME_ELNO'", - "'ERME_ELEM'","'SIEQ_ELNO'","'SIEQ_ELGA'","'EPEQ_ELNO'","'QIRE_ELEM'", - "'QIRE_ELNO'","'QIZ1_ELEM'","'QIZ2_ELEM'","'EPEQ_ELGA'","'FORC_NODA'", - "'REAC_NODA'","'EPSI_NOEU'","'SIGM_NOEU'","'EFGE_NOEU'","'SIEQ_NOEU'", - "'EPEQ_NOEU'","'FLUX_NOEU'",] - genereErreurValeurDsMCF(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","OPTION",lOPT) + lOPT = [ + "'EFGE_ELNO'", + "'EPOT_ELEM'", + "'SIGM_ELNO'", + "'SICA_ELNO'", + "'EFCA_ELNO'", + "'DEGE_ELNO'", + "'EPSI_ELNO'", + "'EPSI_ELGA'", + "'EPSG_ELNO'", + "'EPSG_ELGA'", + "'EPSP_ELNO'", + "'EPSP_ELGA'", + "'ECIN_ELEM'", + "'FLUX_ELGA'", + "'FLUX_ELNO'", + "'SOUR_ELGA'", + "'PRAC_ELNO'", + "'INTE_ELNO'", + "'SIZ1_NOEU'", + "'ERZ1_ELEM'", + "'SIZ2_NOEU'", + "'ERZ2_ELEM'", + "'VNOR_ELEM_DEPL'", + "'ERME_ELNO'", + "'ERME_ELEM'", + "'SIEQ_ELNO'", + "'SIEQ_ELGA'", + "'EPEQ_ELNO'", + "'QIRE_ELEM'", + "'QIRE_ELNO'", + "'QIZ1_ELEM'", + "'QIZ2_ELEM'", + "'EPEQ_ELGA'", + "'FORC_NODA'", + "'REAC_NODA'", + "'EPSI_NOEU'", + "'SIGM_NOEU'", + "'EFGE_NOEU'", + "'SIEQ_NOEU'", + "'EPEQ_NOEU'", + "'FLUX_NOEU'", + ] + genereErreurValeurDsMCF(jdc, "MACRO_ELAS_MULT", "CAS_CHARGE", "OPTION", lOPT) #### traitement de MACRO_EXPANS ############################## # Rien à faire @@ -1326,100 +2278,267 @@ def traduc(infile,outfile,flog=None): #### traitement de MACRO_MATR_ASSE ############################## # Suppression de paramètres mémoire - removeMotCleInFact(jdc,"MACRO_MATR_ASSE","SOLVEUR","OUT_OF_CORE",pasDeRegle(),0) - removeMotCleInFact(jdc,"MACRO_MATR_ASSE","SOLVEUR","LIBERE_MEMOIRE",pasDeRegle(),0) + removeMotCleInFact( + jdc, "MACRO_MATR_ASSE", "SOLVEUR", "OUT_OF_CORE", pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "MACRO_MATR_ASSE", "SOLVEUR", "LIBERE_MEMOIRE", pasDeRegle(), 0 + ) # Suppression de RIGI_MECA_LAGR - genereErreurValeurDsMCF(jdc,"MACRO_MATR_ASSE","MATR_ASSE","OPTION",("'RIGI_MECA_LAGR'",)) - genereErreurMotCleInFact(jdc,"MACRO_MATR_ASSE","MATR_ASSE","THETA") - genereErreurMotCleInFact(jdc,"MACRO_MATR_ASSE","MATR_ASSE","PROPAGATION") + genereErreurValeurDsMCF( + jdc, "MACRO_MATR_ASSE", "MATR_ASSE", "OPTION", ("'RIGI_MECA_LAGR'",) + ) + genereErreurMotCleInFact(jdc, "MACRO_MATR_ASSE", "MATR_ASSE", "THETA") + genereErreurMotCleInFact(jdc, "MACRO_MATR_ASSE", "MATR_ASSE", "PROPAGATION") # Renommage de la commande - renameCommande(jdc,"MACRO_MATR_ASSE","ASSEMBLAGE", ) + renameCommande( + jdc, + "MACRO_MATR_ASSE", + "ASSEMBLAGE", + ) #### traitement de MACRO_MISS_3D ############################## # Rien à faire #### traitement de MACRO_MODE_MECA ############################## # renommage de MATR_A et MATR_B - renameMotCle(jdc,"MACRO_MODE_MECA","MATR_A","MATR_RIGI") - renameMotCle(jdc,"MACRO_MODE_MECA","MATR_B","MATR_MASS") + renameMotCle(jdc, "MACRO_MODE_MECA", "MATR_A", "MATR_RIGI") + renameMotCle(jdc, "MACRO_MODE_MECA", "MATR_B", "MATR_MASS") # Suppression des mot-clés FREQ_* - renameMotCle(jdc,"MACRO_MODE_MECA","CALC_FREQ","CALCFREQ") - moveMotCleFromFactToFather(jdc,"MACRO_MODE_MECA","CALCFREQ","FREQ_MIN") - moveMotCleFromFactToFather(jdc,"MACRO_MODE_MECA","CALCFREQ","FREQ_MAX") - fusionMotCleToFact(jdc,"MACRO_MODE_MECA",("FREQ_MIN","FREQ_MAX"),"FREQ") - moveMotClefInOperToFact(jdc,"MACRO_MODE_MECA","FREQ","CALCFREQ",) - renameMotCle(jdc,"MACRO_MODE_MECA","CALCFREQ","CALC_FREQ") - removeMotCleInFact(jdc,"MACRO_MODE_MECA","CALC_FREQ","NB_BLOC_FREQ",pasDeRegle(),0) - renameMotCleInFact(jdc,"MACRO_MODE_MECA","CALC_FREQ","STOP_FREQ_VIDE","STOP_BANDE_VIDE",pasDeRegle(),0) + renameMotCle(jdc, "MACRO_MODE_MECA", "CALC_FREQ", "CALCFREQ") + moveMotCleFromFactToFather(jdc, "MACRO_MODE_MECA", "CALCFREQ", "FREQ_MIN") + moveMotCleFromFactToFather(jdc, "MACRO_MODE_MECA", "CALCFREQ", "FREQ_MAX") + fusionMotCleToFact(jdc, "MACRO_MODE_MECA", ("FREQ_MIN", "FREQ_MAX"), "FREQ") + moveMotClefInOperToFact( + jdc, + "MACRO_MODE_MECA", + "FREQ", + "CALCFREQ", + ) + renameMotCle(jdc, "MACRO_MODE_MECA", "CALCFREQ", "CALC_FREQ") + removeMotCleInFact( + jdc, "MACRO_MODE_MECA", "CALC_FREQ", "NB_BLOC_FREQ", pasDeRegle(), 0 + ) + renameMotCleInFact( + jdc, + "MACRO_MODE_MECA", + "CALC_FREQ", + "STOP_FREQ_VIDE", + "STOP_BANDE_VIDE", + pasDeRegle(), + 0, + ) # Renommage critere de Sturm - changementValeurDsMCF(jdc,"MACRO_MODE_MECA","VERI_MODE","STURM",{"OUI":"GLOBAL",}) + changementValeurDsMCF( + jdc, + "MACRO_MODE_MECA", + "VERI_MODE", + "STURM", + { + "OUI": "GLOBAL", + }, + ) #### traitement de MACRO_PROJ_BASE ############################## - renameMotCle(jdc,"MACRO_PROJ_BASE","PROFIL","STOCKAGE") + renameMotCle(jdc, "MACRO_PROJ_BASE", "PROFIL", "STOCKAGE") # Renommage de la commande - renameCommande(jdc,"MACRO_PROJ_BASE","PROJ_BASE", ) + renameCommande( + jdc, + "MACRO_PROJ_BASE", + "PROJ_BASE", + ) #### traitement de MACR_RECAL ############################## - renameMotCle(jdc,"MACR_RECAL","POIDS","LIST_POIDS") + renameMotCle(jdc, "MACR_RECAL", "POIDS", "LIST_POIDS") #### traitement de MACR_SPECTRE ############################## # Rien à faire #### traitement de MECA_STATIQUE ############################## # Résorption de la sensibilité - removeMotCle(jdc,"MECA_STATIQUE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "MECA_STATIQUE", "SENSIBILITE", pasDeRegle(), 0) #### traitement de MODE_ITER_INV ############################## # Résorption de la sensibilité - removeMotCle(jdc,"MODE_ITER_INV","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "MODE_ITER_INV", "SENSIBILITE", pasDeRegle(), 0) # renommage de MATR_A, MATR_B et MATR_C - renameMotCleSiRegle(jdc,"MODE_ITER_INV","MATR_A","MATR_RIGI",((("TYPE_RESU","DYNAMIQUE",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"MODE_ITER_INV","MATR_B","MATR_MASS",((("TYPE_RESU","DYNAMIQUE",jdc),"MCaPourValeur"),),1) - renameMotCle(jdc,"MODE_ITER_INV","MATR_C","MATR_AMOR") - renameMotCleSiRegle(jdc,"MODE_ITER_INV","MATR_A","MATR_RIGI",((("TYPE_RESU","MODE_FLAMB",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"MODE_ITER_INV","MATR_B","MATR_RIGI_GEOM",((("TYPE_RESU","MODE_FLAMB",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"MODE_ITER_INV","CALC_FREQ","CALC_CHAR_CRIT",((("TYPE_RESU","MODE_FLAMB",jdc),"MCaPourValeur")or(("TYPE_RESU","GENERAL",jdc),"MCaPourValeur"),),1) - renameMotCleInFact(jdc,"MODE_ITER_INV","CALC_CHAR_CRIT","NMAX_FREQ","NMAX_CHAR_CRIT",pasDeRegle(),0) - renameMotCleInFact(jdc,"MODE_ITER_INV","CALC_CHAR_CRIT","SEUIL_FREQ","SEUIL_CHAR_CRIT",pasDeRegle(),0) - renameMotCle(jdc,"MODE_ITER_INV","MATR_A","MATR_RIGI") - renameMotCle(jdc,"MODE_ITER_INV","MATR_B","MATR_MASS") + renameMotCleSiRegle( + jdc, + "MODE_ITER_INV", + "MATR_A", + "MATR_RIGI", + ((("TYPE_RESU", "DYNAMIQUE", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "MODE_ITER_INV", + "MATR_B", + "MATR_MASS", + ((("TYPE_RESU", "DYNAMIQUE", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCle(jdc, "MODE_ITER_INV", "MATR_C", "MATR_AMOR") + renameMotCleSiRegle( + jdc, + "MODE_ITER_INV", + "MATR_A", + "MATR_RIGI", + ((("TYPE_RESU", "MODE_FLAMB", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "MODE_ITER_INV", + "MATR_B", + "MATR_RIGI_GEOM", + ((("TYPE_RESU", "MODE_FLAMB", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "MODE_ITER_INV", + "CALC_FREQ", + "CALC_CHAR_CRIT", + ( + (("TYPE_RESU", "MODE_FLAMB", jdc), "MCaPourValeur") + or (("TYPE_RESU", "GENERAL", jdc), "MCaPourValeur"), + ), + 1, + ) + renameMotCleInFact( + jdc, + "MODE_ITER_INV", + "CALC_CHAR_CRIT", + "NMAX_FREQ", + "NMAX_CHAR_CRIT", + pasDeRegle(), + 0, + ) + renameMotCleInFact( + jdc, + "MODE_ITER_INV", + "CALC_CHAR_CRIT", + "SEUIL_FREQ", + "SEUIL_CHAR_CRIT", + pasDeRegle(), + 0, + ) + renameMotCle(jdc, "MODE_ITER_INV", "MATR_A", "MATR_RIGI") + renameMotCle(jdc, "MODE_ITER_INV", "MATR_B", "MATR_MASS") #### traitement de MODE_ITER_SIMULT ############################## # Résorption de la sensibilité - removeMotCle(jdc,"MODE_ITER_SIMULT","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "MODE_ITER_SIMULT", "SENSIBILITE", pasDeRegle(), 0) # renommage de MATR_A, MATR_B et MATR_C - renameMotCleSiRegle(jdc,"MODE_ITER_SIMULT","MATR_A","MATR_RIGI",((("TYPE_RESU","DYNAMIQUE",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"MODE_ITER_SIMULT","MATR_B","MATR_MASS",((("TYPE_RESU","DYNAMIQUE",jdc),"MCaPourValeur"),),1) - renameMotCle(jdc,"MODE_ITER_SIMULT","MATR_C","MATR_AMOR") - renameMotCleSiRegle(jdc,"MODE_ITER_SIMULT","MATR_A","MATR_RIGI",((("TYPE_RESU","MODE_FLAMB",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"MODE_ITER_SIMULT","MATR_B","MATR_RIGI_GEOM",((("TYPE_RESU","MODE_FLAMB",jdc),"MCaPourValeur"),),1) - renameMotCleSiRegle(jdc,"MODE_ITER_SIMULT","CALC_FREQ","CALC_CHAR_CRIT",((("TYPE_RESU","MODE_FLAMB",jdc),"MCaPourValeur")or(("TYPE_RESU","GENERAL",jdc),"MCaPourValeur"),),1) - renameMotCleInFact(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","NMAX_FREQ","NMAX_CHAR_CRIT",pasDeRegle(),0) - renameMotCleInFact(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","SEUIL_FREQ","SEUIL_CHAR_CRIT",pasDeRegle(),0) - renameMotCle(jdc,"MODE_ITER_SIMULT","MATR_A","MATR_RIGI") - renameMotCle(jdc,"MODE_ITER_SIMULT","MATR_B","MATR_MASS") + renameMotCleSiRegle( + jdc, + "MODE_ITER_SIMULT", + "MATR_A", + "MATR_RIGI", + ((("TYPE_RESU", "DYNAMIQUE", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "MODE_ITER_SIMULT", + "MATR_B", + "MATR_MASS", + ((("TYPE_RESU", "DYNAMIQUE", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCle(jdc, "MODE_ITER_SIMULT", "MATR_C", "MATR_AMOR") + renameMotCleSiRegle( + jdc, + "MODE_ITER_SIMULT", + "MATR_A", + "MATR_RIGI", + ((("TYPE_RESU", "MODE_FLAMB", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "MODE_ITER_SIMULT", + "MATR_B", + "MATR_RIGI_GEOM", + ((("TYPE_RESU", "MODE_FLAMB", jdc), "MCaPourValeur"),), + 1, + ) + renameMotCleSiRegle( + jdc, + "MODE_ITER_SIMULT", + "CALC_FREQ", + "CALC_CHAR_CRIT", + ( + (("TYPE_RESU", "MODE_FLAMB", jdc), "MCaPourValeur") + or (("TYPE_RESU", "GENERAL", jdc), "MCaPourValeur"), + ), + 1, + ) + renameMotCleInFact( + jdc, + "MODE_ITER_SIMULT", + "CALC_CHAR_CRIT", + "NMAX_FREQ", + "NMAX_CHAR_CRIT", + pasDeRegle(), + 0, + ) + renameMotCleInFact( + jdc, + "MODE_ITER_SIMULT", + "CALC_CHAR_CRIT", + "SEUIL_FREQ", + "SEUIL_CHAR_CRIT", + pasDeRegle(), + 0, + ) + renameMotCle(jdc, "MODE_ITER_SIMULT", "MATR_A", "MATR_RIGI") + renameMotCle(jdc, "MODE_ITER_SIMULT", "MATR_B", "MATR_MASS") # renommage STOP_FREQ_VIDE - renameMotCle(jdc,"MODE_ITER_SIMULT","STOP_FREQ_VIDE","STOP_BANDE_VIDE") + renameMotCle(jdc, "MODE_ITER_SIMULT", "STOP_FREQ_VIDE", "STOP_BANDE_VIDE") #### traitement de MODE_STATIQUE ############################## # renommage du mot-clé FREQ - renameMotCleInFact(jdc,"MODE_STATIQUE","MODE_INTERF","FREQ","SHIFT",pasDeRegle(),0) + renameMotCleInFact( + jdc, "MODE_STATIQUE", "MODE_INTERF", "FREQ", "SHIFT", pasDeRegle(), 0 + ) #### traitement de MODI_MODELE_XFEM ############################## - genereErreurValeur(jdc,"MODI_MODELE_XFEM","CONTACT",("'P1P1A'",)) + genereErreurValeur(jdc, "MODI_MODELE_XFEM", "CONTACT", ("'P1P1A'",)) #### traitement de MODI_REPERE ############################## # renommage de DEFI_REPERE - renameMotCle(jdc,"MODI_REPERE","DEFI_REPERE","AFFE") - moveMotCleFromFactToFather(jdc,"MODI_REPERE","AFFE","REPERE") + renameMotCle(jdc, "MODI_REPERE", "DEFI_REPERE", "AFFE") + moveMotCleFromFactToFather(jdc, "MODI_REPERE", "AFFE", "REPERE") # localisation dans AFFE - moveMotClefInOperToFact(jdc,"MODI_REPERE","GROUP_MA","AFFE",) - moveMotClefInOperToFact(jdc,"MODI_REPERE","GROUP_NO","AFFE",) - moveMotClefInOperToFact(jdc,"MODI_REPERE","MAILLE","AFFE",) - moveMotClefInOperToFact(jdc,"MODI_REPERE","NOEUD","AFFE",) + moveMotClefInOperToFact( + jdc, + "MODI_REPERE", + "GROUP_MA", + "AFFE", + ) + moveMotClefInOperToFact( + jdc, + "MODI_REPERE", + "GROUP_NO", + "AFFE", + ) + moveMotClefInOperToFact( + jdc, + "MODI_REPERE", + "MAILLE", + "AFFE", + ) + moveMotClefInOperToFact( + jdc, + "MODI_REPERE", + "NOEUD", + "AFFE", + ) #### traitement de NORM_MODE ############################## - removeMotCle(jdc,"NORM_MODE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "NORM_MODE", "SENSIBILITE", pasDeRegle(), 0) #### traitement de NUME_DDL ############################## # Rien à faire @@ -1429,8 +2548,8 @@ def traduc(infile,outfile,flog=None): #### traitement de OBSERVATION ############################## # renommage de MATR_A et MATR_B - renameMotCle(jdc,"OBSERVATION","MATR_A","MATR_RIGI") - renameMotCle(jdc,"OBSERVATION","MATR_B","MATR_MASS") + renameMotCle(jdc, "OBSERVATION", "MATR_A", "MATR_RIGI") + renameMotCle(jdc, "OBSERVATION", "MATR_B", "MATR_MASS") #### traitement de POST_BORDET ############################## # Rien à faire @@ -1440,7 +2559,7 @@ def traduc(infile,outfile,flog=None): #### traitement de POST_CHAM_XFEM ############################## # Suppression mot-clé MAILLAGE_SAIN - removeMotCle(jdc,"POST_CHAM_XFEM","MAILLAGE_SAIN",pasDeRegle(),0) + removeMotCle(jdc, "POST_CHAM_XFEM", "MAILLAGE_SAIN", pasDeRegle(), 0) #### traitement de POST_COQUE ############################## # Rien à faire @@ -1450,56 +2569,58 @@ def traduc(infile,outfile,flog=None): #### traitement de POST_DYNA_ALEA ############################## # Suppression du mot-clé NUME_VITE_FLUI - removeMotCle(jdc,"POST_DYNA_ALEA","NUME_VITE_FLUI",pasDeRegle(),0) + removeMotCle(jdc, "POST_DYNA_ALEA", "NUME_VITE_FLUI", pasDeRegle(), 0) #### traitement de POST_ELEM ############################## # Rien à faire #### traitement de POST_ENDO_FISS ############################## # Suppression du mot-clé MODELE - removeMotCle(jdc,"POST_ENDO_FISS","MODELE",pasDeRegle(),0) + removeMotCle(jdc, "POST_ENDO_FISS", "MODELE", pasDeRegle(), 0) # Renommage de SEUIL - renameMotCleInFact(jdc,"POST_ENDO_FISS","RECHERCHE","SEUIL","BORNE_MIN",pasDeRegle(),0) + renameMotCleInFact( + jdc, "POST_ENDO_FISS", "RECHERCHE", "SEUIL", "BORNE_MIN", pasDeRegle(), 0 + ) #### traitement de POST_FATIGUE ############################## # Suppression du chargement periodique - genereErreurValeur(jdc,"POST_FATIGUE","CHARGEMENT",("'PERIODIQUE'",)) + genereErreurValeur(jdc, "POST_FATIGUE", "CHARGEMENT", ("'PERIODIQUE'",)) #### traitement de POST_GP ############################## # Suppression de POST_GP au profit de CALC_GP - genereErreurPourCommande(jdc,("POST_GP",)) + genereErreurPourCommande(jdc, ("POST_GP",)) #### traitement de POST_K1_K2_K3 ############################## # Suppression de VECT_K1 - removeMotCle(jdc,"POST_K1_K2_K3","VECT_K1",pasDeRegle(),0) + removeMotCle(jdc, "POST_K1_K2_K3", "VECT_K1", pasDeRegle(), 0) # Suppression de SYME_CHAR - removeMotCle(jdc,"POST_K1_K2_K3","SYME_CHAR",pasDeRegle(),0) + removeMotCle(jdc, "POST_K1_K2_K3", "SYME_CHAR", pasDeRegle(), 0) # Suppression de TABL_DEPL - removeMotCle(jdc,"POST_K1_K2_K3","TABL_DEPL_SUP",pasDeRegle(),0) - removeMotCle(jdc,"POST_K1_K2_K3","TABL_DEPL_INF",pasDeRegle(),0) + removeMotCle(jdc, "POST_K1_K2_K3", "TABL_DEPL_SUP", pasDeRegle(), 0) + removeMotCle(jdc, "POST_K1_K2_K3", "TABL_DEPL_INF", pasDeRegle(), 0) # Suppression de MAILLAGE - removeMotCle(jdc,"POST_K1_K2_K3","MAILLAGE",pasDeRegle(),0) + removeMotCle(jdc, "POST_K1_K2_K3", "MAILLAGE", pasDeRegle(), 0) # Suppression de DTAN - removeMotCle(jdc,"POST_K1_K2_K3","DTAN_ORIG",pasDeRegle(),0) - removeMotCle(jdc,"POST_K1_K2_K3","DTAN_EXTR",pasDeRegle(),0) + removeMotCle(jdc, "POST_K1_K2_K3", "DTAN_ORIG", pasDeRegle(), 0) + removeMotCle(jdc, "POST_K1_K2_K3", "DTAN_EXTR", pasDeRegle(), 0) #### traitement de POST_K_TRANS ############################## # Suppression de la possibilité de donner un mode_meca - genereErreurMotCleInFact(jdc,"POST_K_TRANS","K_MODAL","RESU_MODA") + genereErreurMotCleInFact(jdc, "POST_K_TRANS", "K_MODAL", "RESU_MODA") #### traitement de POST_MAC3COEUR ############################## # Rien à faire, n'existe pas en 10 #### traitement de POST_MAIL_XFEM ############################## # Suppression du mot-clé MAILLAGE_SAIN - removeMotCle(jdc,"POST_MAIL_XFEM","MAILLAGE_SAIN",pasDeRegle(),0) + removeMotCle(jdc, "POST_MAIL_XFEM", "MAILLAGE_SAIN", pasDeRegle(), 0) #### traitement de POST_RCCM ############################## # Rien à faire #### traitement de POST_RELEVE_T ############################## # Résorption de la sensibilité - removeMotCle(jdc,"POST_RELEVE_T","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "POST_RELEVE_T", "SENSIBILITE", pasDeRegle(), 0) #### traitement de POST_RUPTURE ############################## # Rien à faire, n'existe pas en 10 @@ -1509,123 +2630,179 @@ def traduc(infile,outfile,flog=None): #### traitement de POURSUITE ############################## # Suppression du mot-clé TITRE - removeMotCleInFact(jdc,"POURSUITE","CATALOGUE","TITRE",pasDeRegle(),0) - removeMotCle(jdc,"POURSUITE","IMPRESSION",pasDeRegle(),0) + removeMotCleInFact(jdc, "POURSUITE", "CATALOGUE", "TITRE", pasDeRegle(), 0) + removeMotCle(jdc, "POURSUITE", "IMPRESSION", pasDeRegle(), 0) # Suppression des mots-clés mémoire dynamique - removeMotCleInFact(jdc,"POURSUITE","MEMOIRE","GESTION",pasDeRegle(),0) - removeMotCleInFact(jdc,"POURSUITE","MEMOIRE","TYPE_ALLOCATION",pasDeRegle(),0) - removeMotCleInFact(jdc,"POURSUITE","MEMOIRE","TAILLE",pasDeRegle(),0) - removeMotCleInFact(jdc,"POURSUITE","MEMOIRE","PARTITION",pasDeRegle(),0) - removeMotCleInFact(jdc,"POURSUITE","MEMOIRE","DYNAMIQUE",pasDeRegle(),0) + removeMotCleInFact(jdc, "POURSUITE", "MEMOIRE", "GESTION", pasDeRegle(), 0) + removeMotCleInFact(jdc, "POURSUITE", "MEMOIRE", "TYPE_ALLOCATION", pasDeRegle(), 0) + removeMotCleInFact(jdc, "POURSUITE", "MEMOIRE", "TAILLE", pasDeRegle(), 0) + removeMotCleInFact(jdc, "POURSUITE", "MEMOIRE", "PARTITION", pasDeRegle(), 0) + removeMotCleInFact(jdc, "POURSUITE", "MEMOIRE", "DYNAMIQUE", pasDeRegle(), 0) #### traitement de PROJ_BASE ############################## # Suppression de RESU_GENE pour défaut de validation - genereErreurMCF(jdc,"PROJ_BASE","RESU_GENE") + genereErreurMCF(jdc, "PROJ_BASE", "RESU_GENE") #### traitement de PROJ_CHAMP ############################## # Résorption de la sensibilité - removeMotCle(jdc,"PROJ_CHAMP","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "PROJ_CHAMP", "SENSIBILITE", pasDeRegle(), 0) #### traitement de PROJ_RESU_BASE ############################## # Suppression de RESU_GENE pour défaut de validation - genereErreurMCF(jdc,"PROJ_RESU_BASE","RESU_GENE") + genereErreurMCF(jdc, "PROJ_RESU_BASE", "RESU_GENE") #### traitement de PROJ_SPEC_BASE ############################## # Rien à faire #### traitement de PROPA_FISS ############################## # Suppression de DTAN_ORIG et DTAN_EXTR pour calcul automatique - removeMotCleInFact(jdc,"PROPA_FISS","FISSURE","DTAN_ORIG",pasDeRegle(),0) - removeMotCleInFact(jdc,"PROPA_FISS","FISSURE","DTAN_EXTR",pasDeRegle(),0) + removeMotCleInFact(jdc, "PROPA_FISS", "FISSURE", "DTAN_ORIG", pasDeRegle(), 0) + removeMotCleInFact(jdc, "PROPA_FISS", "FISSURE", "DTAN_EXTR", pasDeRegle(), 0) #### traitement de PROPA_XFEM ############################## # Suppression paramètres Loi de Paris - removeMotCle(jdc,"PROPA_XFEM","NB_POINT_FOND",pasDeRegle(),0) - removeMotCle(jdc,"PROPA_XFEM","TABLE",pasDeRegle(),0) - removeMotCle(jdc,"PROPA_XFEM","LOI_PROPA",pasDeRegle(),0) - removeMotCle(jdc,"PROPA_XFEM","COMP_LINE",pasDeRegle(),0) + removeMotCle(jdc, "PROPA_XFEM", "NB_POINT_FOND", pasDeRegle(), 0) + removeMotCle(jdc, "PROPA_XFEM", "TABLE", pasDeRegle(), 0) + removeMotCle(jdc, "PROPA_XFEM", "LOI_PROPA", pasDeRegle(), 0) + removeMotCle(jdc, "PROPA_XFEM", "COMP_LINE", pasDeRegle(), 0) #### traitement de RAFF_XFEM ############################## # Rien à faire #### traitement de RECU_FONCTION ############################## # Résorption de la sensibilité - removeMotCle(jdc,"RECU_FONCTION","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "RECU_FONCTION", "SENSIBILITE", pasDeRegle(), 0) # Renommage critere table - dCRIT={"ABS_MAXI":"MAXI_ABS","ABS_MINI":"MINI_ABS"} - changementValeurDsMCF(jdc,"RECU_FONCTION","FILTRE","CRIT_COMP",dCRIT) + dCRIT = {"ABS_MAXI": "MAXI_ABS", "ABS_MINI": "MINI_ABS"} + changementValeurDsMCF(jdc, "RECU_FONCTION", "FILTRE", "CRIT_COMP", dCRIT) #### traitement de RECU_GENE ############################## # Rien à faire #### traitement de RESOUDRE ############################## # Suppression d'algo pour PETSc - removeMotCleSiRegle(jdc,"RESOUDRE","ALGORITHME",((("BCGS","BICG","TFQMR",),"MCaPourValeur"),)) + removeMotCleSiRegle( + jdc, + "RESOUDRE", + "ALGORITHME", + ( + ( + ( + "BCGS", + "BICG", + "TFQMR", + ), + "MCaPourValeur", + ), + ), + ) #### traitement de REST_SPEC_PHYS ############################## # Rien à faire #### traitement de SIMU_POINT_MAT ############################## # VALE_REF obligatoire si NOM_VARC in ('TEMP', 'SECH') - lNOMVARC=["CORR","IRRA","HYDR","EPSA","M_ACIER","M_ZIRC","NEUT1","NEUT2"] - removeMotCleInFactSiRegle(jdc,"SIMU_POINT_MAT","AFFE_VARC","VALE_REF",((("NOM_VARC",lNOMVARC,jdc),"MCsousMCFcourantaPourValeurDansListe"),)) + lNOMVARC = ["CORR", "IRRA", "HYDR", "EPSA", "M_ACIER", "M_ZIRC", "NEUT1", "NEUT2"] + removeMotCleInFactSiRegle( + jdc, + "SIMU_POINT_MAT", + "AFFE_VARC", + "VALE_REF", + ((("NOM_VARC", lNOMVARC, jdc), "MCsousMCFcourantaPourValeurDansListe"),), + ) # Suppression de ARCHIVAGE/DETR_NUME_SUIV - removeMotCleInFact(jdc,"SIMU_POINT_MAT","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0) + removeMotCleInFact( + jdc, "SIMU_POINT_MAT", "ARCHIVAGE", "DETR_NUME_SUIV", pasDeRegle(), 0 + ) #### traitement de STANLEY ############################## # Rien à faire #### traitement de STAT_NON_LINE ############################## # Renommage de IMPLEX - changementValeur(jdc,"STAT_NON_LINE","METHODE",{"IMPL_EX":"IMPLEX"}) - removeMotCle(jdc,"STAT_NON_LINE","IMPL_EX",pasDeRegle(),0) + changementValeur(jdc, "STAT_NON_LINE", "METHODE", {"IMPL_EX": "IMPLEX"}) + removeMotCle(jdc, "STAT_NON_LINE", "IMPL_EX", pasDeRegle(), 0) # Renommage CRIT_FLAMB en CRIT_STAB - renameMotCle(jdc,"STAT_NON_LINE","CRIT_FLAMB","CRIT_STAB") + renameMotCle(jdc, "STAT_NON_LINE", "CRIT_FLAMB", "CRIT_STAB") # Résorption de la sensibilité - removeMotCle(jdc,"STAT_NON_LINE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "STAT_NON_LINE", "SENSIBILITE", pasDeRegle(), 0) # Déplacement du calcul d'erreur en temps ERRE_TEMPS - chercheOperInsereFacteurSiRegle(jdc,"STAT_NON_LINE","CRIT_QUALITE",((("INCREMENT","ERRE_TEMPS"),"existeMCsousMCF"),),1) - moveMotCleFromFactToFact(jdc,"STAT_NON_LINE","INCREMENT","ERRE_TEMPS","CRIT_QUALITE") - renameMotCleInFact(jdc,"STAT_NON_LINE","CRIT_QUALITE","ERRE_TEMPS","ERRE_TEMPS_THM",pasDeRegle(),0) - removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT","ERRE_TEMPS",pasDeRegle(),0) + chercheOperInsereFacteurSiRegle( + jdc, + "STAT_NON_LINE", + "CRIT_QUALITE", + ((("INCREMENT", "ERRE_TEMPS"), "existeMCsousMCF"),), + 1, + ) + moveMotCleFromFactToFact( + jdc, "STAT_NON_LINE", "INCREMENT", "ERRE_TEMPS", "CRIT_QUALITE" + ) + renameMotCleInFact( + jdc, + "STAT_NON_LINE", + "CRIT_QUALITE", + "ERRE_TEMPS", + "ERRE_TEMPS_THM", + pasDeRegle(), + 0, + ) + removeMotCleInFact(jdc, "STAT_NON_LINE", "INCREMENT", "ERRE_TEMPS", pasDeRegle(), 0) # Suppression de ARCHIVAGE/DETR_NUME_SUIV - removeMotCleInFact(jdc,"STAT_NON_LINE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0) + removeMotCleInFact( + jdc, "STAT_NON_LINE", "ARCHIVAGE", "DETR_NUME_SUIV", pasDeRegle(), 0 + ) #### traitement de THER_LINEAIRE ############################## # Résorption de la sensibilité - removeMotCle(jdc,"THER_LINEAIRE","SENSIBILITE",pasDeRegle(),0) - removeMotCle(jdc,"THER_LINEAIRE","SENS_INIT",pasDeRegle(),0) + removeMotCle(jdc, "THER_LINEAIRE", "SENSIBILITE", pasDeRegle(), 0) + removeMotCle(jdc, "THER_LINEAIRE", "SENS_INIT", pasDeRegle(), 0) # Suppression de ARCHIVAGE/DETR_NUME_SUIV - removeMotCleInFact(jdc,"THER_LINEAIRE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0) + removeMotCleInFact( + jdc, "THER_LINEAIRE", "ARCHIVAGE", "DETR_NUME_SUIV", pasDeRegle(), 0 + ) #### traitement de THER_NON_LINE ############################## # Résorption de la sensibilité - removeMotCle(jdc,"THER_NON_LINE","SENSIBILITE",pasDeRegle(),0) + removeMotCle(jdc, "THER_NON_LINE", "SENSIBILITE", pasDeRegle(), 0) # Suppression du mot clé OPTION ###################################### - moveMCFToCommand(jdc,"THER_NON_LINE","OPTION","CALC_CHAMP","THERMIQUE") + moveMCFToCommand(jdc, "THER_NON_LINE", "OPTION", "CALC_CHAMP", "THERMIQUE") # Suppression de ARCHIVAGE/DETR_NUME_SUIV - removeMotCleInFact(jdc,"THER_NON_LINE","ARCHIVAGE","DETR_NUME_SUIV",pasDeRegle(),0) + removeMotCleInFact( + jdc, "THER_NON_LINE", "ARCHIVAGE", "DETR_NUME_SUIV", pasDeRegle(), 0 + ) #### traitement de THER_NON_LINE_MO ############################## # Rien à faire ################################################################# - f=open(outfile,'w') + 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") + 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) + traduc(options.infile, options.outfile) + -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/Traducteur/traduitV11V12.py b/Traducteur/traduitV11V12.py index da0acf71..284df9e4 100755 --- a/Traducteur/traduitV11V12.py +++ b/Traducteur/traduitV11V12.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,7 +20,7 @@ # """ """ -usage="""usage: %prog [options] +usage = """usage: %prog [options] Typical use is: python traduitV11V12.py --infile=xxxx --outfile=yyyy """ @@ -29,591 +29,1049 @@ import log import optparse import sys -from Traducteur.load import getJDC +from Traducteur.load import getJDC from Traducteur.mocles import parseKeywords -from Traducteur.removemocle import * -from Traducteur.renamemocle import * -from Traducteur.renamemocle import * -from Traducteur.inseremocle import * +from Traducteur.removemocle import * +from Traducteur.renamemocle import * +from Traducteur.renamemocle import * +from Traducteur.inseremocle import * from Traducteur.changeValeur import * -from Traducteur.movemocle import * -from Traducteur.dictErreurs import * +from Traducteur.movemocle import * +from Traducteur.dictErreurs import * from Traducteur.regles import pasDeRegle -atraiter=( - "AFFE_CARA_ELEM", - "AFFE_CHAR_MECA", - "AFFE_CHAR_MECA_C", - "AFFE_CHAR_MECA_F", - "AFFE_CHAR_THER", - "AFFE_MODELE", - "ASSEMBLAGE", - "CALC_ESSAI_GEOMECA", - "CALC_EUROPLEXUS", - "CALC_FATIGUE", - "CALC_FERRAILLAGE", - "CALC_FONCTION", - "CALC_FORC_NONL", - "CALC_G", - "CALC_IFS_DNL", - "CALC_MAC3COEUR", - "CALC_MATR_ELEM", - "CALC_META", - "CALC_MISS", - "CALC_MODAL", - "CALC_PRECONT", - "CALCUL", - "CALC_VECT_ELEM", - "CREA_MAILLAGE", - "DEBUT", - "DEFI_COMPOR", - "DEFI_FISS_XFEM", - "DEFI_LIST_INST", - "DEFI_MATER_GC", - "DEFI_MATERIAU", - "DEFI_OBSTACLE", - "DEFI_PART_PA_OPS", - "DYNA_NON_LINE", - "DYNA_TRAN_MODAL", - "DYNA_VIBRA", - "EXTR_TABLE", - "FACTORISER", - "GENE_ACCE_SEISME", - "IMPR_MISS_3D", - "IMPR_RESU", - "INFO_FONCTION", - "LIRE_MAILLAGE", - "LIRE_MISS_3D", - "LIRE_RESU", - "MACR_ASCOUF_CALC", - "MACR_ASCOUF_MAIL", - "MACR_ASPIC_CALC", - "MACR_ECREVISSE", - "MACR_INFO_MAIL", - "MACRO_BASCULE_SCHEMA", - "MACRO_MISS_3D", - "MACRO_MODE_MECA", - "MECA_STATIQUE", - "MODE_ITER_INV", - "MODE_ITER_SIMULT", - "MODI_MAILLAGE", - "MODI_MODELE_XFEM", - "POST_DYNA_ALEA", - "POST_ELEM", - "POST_FATIGUE", - "POURSUITE", - "RECU_FONCTION", - "STAT_NON_LINE", - "SIMU_POINT_MAT", - "TEST_COMPOR", - "THER_NON_LINE", - "DEFI_PART_FETI" - ) - -dict_erreurs={ - "AFFE_CHAR_MECA_F_ONDE_PLANE_DIRECTION":"Trois valeurs sont nécessaire pour définir la DIRECTION", - "CREA_MAILLAGE_ECLA_PG":"Le mot-clé NOM_CHAM est obligatoire", - "CALC_EUROPLEXUS_FONC_PARASOL":"Le mot-clé GROUP_MA est obligatoire dans le mot-clé facteur FONC_PARASOL "+ - "pour l'opérateur CALC_EUROPLEXUS", - "CALC_FERRAILLAGE":"Certains mots clés de CALC_FERRAILLAGE / AFFE sont obligatoires. "+ - "Pour TYPE_COMB='ELU' : PIVA et PIVB et ES, ES doit être supérieur à 0. "+ - "Pour TYPE_COMB='ELS' : CEQUI.", - "CALC_FONCTION_DSP_FREQ":"Le mot-clé FREQ n'est plus disponible remplacer par LIST_FREQ. La liste de réel \ +atraiter = ( + "AFFE_CARA_ELEM", + "AFFE_CHAR_MECA", + "AFFE_CHAR_MECA_C", + "AFFE_CHAR_MECA_F", + "AFFE_CHAR_THER", + "AFFE_MODELE", + "ASSEMBLAGE", + "CALC_ESSAI_GEOMECA", + "CALC_EUROPLEXUS", + "CALC_FATIGUE", + "CALC_FERRAILLAGE", + "CALC_FONCTION", + "CALC_FORC_NONL", + "CALC_G", + "CALC_IFS_DNL", + "CALC_MAC3COEUR", + "CALC_MATR_ELEM", + "CALC_META", + "CALC_MISS", + "CALC_MODAL", + "CALC_PRECONT", + "CALCUL", + "CALC_VECT_ELEM", + "CREA_MAILLAGE", + "DEBUT", + "DEFI_COMPOR", + "DEFI_FISS_XFEM", + "DEFI_LIST_INST", + "DEFI_MATER_GC", + "DEFI_MATERIAU", + "DEFI_OBSTACLE", + "DEFI_PART_PA_OPS", + "DYNA_NON_LINE", + "DYNA_TRAN_MODAL", + "DYNA_VIBRA", + "EXTR_TABLE", + "FACTORISER", + "GENE_ACCE_SEISME", + "IMPR_MISS_3D", + "IMPR_RESU", + "INFO_FONCTION", + "LIRE_MAILLAGE", + "LIRE_MISS_3D", + "LIRE_RESU", + "MACR_ASCOUF_CALC", + "MACR_ASCOUF_MAIL", + "MACR_ASPIC_CALC", + "MACR_ECREVISSE", + "MACR_INFO_MAIL", + "MACRO_BASCULE_SCHEMA", + "MACRO_MISS_3D", + "MACRO_MODE_MECA", + "MECA_STATIQUE", + "MODE_ITER_INV", + "MODE_ITER_SIMULT", + "MODI_MAILLAGE", + "MODI_MODELE_XFEM", + "POST_DYNA_ALEA", + "POST_ELEM", + "POST_FATIGUE", + "POURSUITE", + "RECU_FONCTION", + "STAT_NON_LINE", + "SIMU_POINT_MAT", + "TEST_COMPOR", + "THER_NON_LINE", + "DEFI_PART_FETI", +) + +dict_erreurs = { + "AFFE_CHAR_MECA_F_ONDE_PLANE_DIRECTION": "Trois valeurs sont nécessaire pour définir la DIRECTION", + "CREA_MAILLAGE_ECLA_PG": "Le mot-clé NOM_CHAM est obligatoire", + "CALC_EUROPLEXUS_FONC_PARASOL": "Le mot-clé GROUP_MA est obligatoire dans le mot-clé facteur FONC_PARASOL " + + "pour l'opérateur CALC_EUROPLEXUS", + "CALC_FERRAILLAGE": "Certains mots clés de CALC_FERRAILLAGE / AFFE sont obligatoires. " + + "Pour TYPE_COMB='ELU' : PIVA et PIVB et ES, ES doit être supérieur à 0. " + + "Pour TYPE_COMB='ELS' : CEQUI.", + "CALC_FONCTION_DSP_FREQ": "Le mot-clé FREQ n'est plus disponible remplacer par LIST_FREQ. La liste de réel \ doit être obtenu avec DEFI_LIST_REEL", - "CALC_MODAL":"La commande CALC_MODAL a été supprimé et remplacer par CALC_MODES", - "CREA_MAILLAGE_DETR_GROUP_MA":"Le mot-clé DETR_GROUP_MA n'est plus disponible dans CREA_MAILLAGE. Utiliser la commande "+ - "DEFI_GROUP a la place, attention celle-ci est réentrante.", - "DEFI_COMPOR_POLYCRISTAL":"Le mot-clé MU_LOCA est obligatoire.", - "DEFI_FISS_XFEM":"Le mot-clé MAILLAGE est obligatoire", - "DEFI_MATER_GC_MAZARS":"Les mot-clés EIJ, EPSI_C, FTJ du mot-clé facteur MAZARS sont obligatoire", - "DEFI_MATERIAU_THER_FO":"Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', "+ - "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", - "DEFI_MATERIAU_THER_ORTH":"Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', "+ - "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", - "DEFI_MATERIAU_THER_NL":"Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', "+ - "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", - "DEFI_MATERIAU_THER_HYDR":"Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', "+ - "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", - "DEFI_MATERIAU_THER_COQUE":"Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', "+ - "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", - "DEFI_MATERIAU_THER_COQUE_FO":"Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', "+ - "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", - "DEFI_MATERIAU_DIS_VISC":"Les mot-clés C et PUIS_ALPHA du mot-clé facteur DIS_VISC sont obligatoire.", - "GENE_ACCE_SEISME_MODULATION":"Le mot-clé DUREE_PHASE_FORTE est obligatoire.", - "IMPR_MISS_3D":"Les commandes IMPR_MISS_3D, MACRO_MISS_3D et LIRE_MISS_3D ont été réunies dans la commande"+ - " CALC_MISS", - "INFO_FONCTION_NOCI_SEISME":"Le mot-clé FREQ_FOND est obligatoire.", - "LIRE_MISS_3D":"Les commandes IMPR_MISS_3D, MACRO_MISS_3D et LIRE_MISS_3D ont été réunies dans la commande"+ - " CALC_MISS", - "MACRO_MISS_3D":"Les commandes IMPR_MISS_3D, MACRO_MISS_3D et LIRE_MISS_3D ont été réunies dans la commande"+ - " CALC_MISS", - "RECU_FONCTION_TABLE":"Si la valeur de TABLE est obtenu par GENE_FONC_ALEA remplacer par le mot-clé " - "INTE_SPEC", - "TEST_COMPOR":"La commande TEST_COMPOR produit une table de sortie dans tous les cas.", - } - -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 + "CALC_MODAL": "La commande CALC_MODAL a été supprimé et remplacer par CALC_MODES", + "CREA_MAILLAGE_DETR_GROUP_MA": "Le mot-clé DETR_GROUP_MA n'est plus disponible dans CREA_MAILLAGE. Utiliser la commande " + + "DEFI_GROUP a la place, attention celle-ci est réentrante.", + "DEFI_COMPOR_POLYCRISTAL": "Le mot-clé MU_LOCA est obligatoire.", + "DEFI_FISS_XFEM": "Le mot-clé MAILLAGE est obligatoire", + "DEFI_MATER_GC_MAZARS": "Les mot-clés EIJ, EPSI_C, FTJ du mot-clé facteur MAZARS sont obligatoire", + "DEFI_MATERIAU_THER_FO": "Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', " + + "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", + "DEFI_MATERIAU_THER_ORTH": "Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', " + + "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", + "DEFI_MATERIAU_THER_NL": "Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', " + + "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", + "DEFI_MATERIAU_THER_HYDR": "Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', " + + "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", + "DEFI_MATERIAU_THER_COQUE": "Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', " + + "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", + "DEFI_MATERIAU_THER_COQUE_FO": "Attention les mot-clés suivants ('THER','THER_FO','THER_ORTH','THER_NL','THER_HYDR', " + + "'THER_COQUE','THER_COQUE_FO') ne peuvent être utilisé en même temps.", + "DEFI_MATERIAU_DIS_VISC": "Les mot-clés C et PUIS_ALPHA du mot-clé facteur DIS_VISC sont obligatoire.", + "GENE_ACCE_SEISME_MODULATION": "Le mot-clé DUREE_PHASE_FORTE est obligatoire.", + "IMPR_MISS_3D": "Les commandes IMPR_MISS_3D, MACRO_MISS_3D et LIRE_MISS_3D ont été réunies dans la commande" + + " CALC_MISS", + "INFO_FONCTION_NOCI_SEISME": "Le mot-clé FREQ_FOND est obligatoire.", + "LIRE_MISS_3D": "Les commandes IMPR_MISS_3D, MACRO_MISS_3D et LIRE_MISS_3D ont été réunies dans la commande" + + " CALC_MISS", + "MACRO_MISS_3D": "Les commandes IMPR_MISS_3D, MACRO_MISS_3D et LIRE_MISS_3D ont été réunies dans la commande" + + " CALC_MISS", + "RECU_FONCTION_TABLE": "Si la valeur de TABLE est obtenu par GENE_FONC_ALEA remplacer par le mot-clé " + "INTE_SPEC", + "TEST_COMPOR": "La commande TEST_COMPOR produit une table de sortie dans tous les cas.", +} + +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) #### traitement de DEFI_PART_PA_OPS ############################## - genereErreurPourCommande(jdc,"DEFI_PART_PA_OPS") + genereErreurPourCommande(jdc, "DEFI_PART_PA_OPS") #### traitement de AFFE_CARA_ELEM ############################## - changementValeurDsMCFSiRegle(jdc,"AFFE_CARA_ELEM","POUTRE","CARA",{"R1":"R_DEBUT","R2":"R_FIN", - "EP1":"EP_DEBUT","EP2":"EP_FIN"}, - ((("POUTRE","MAILLE",),"nexistepasMCsousMCF"), - (("POUTRE","SECTION","CERCLE",jdc),"MCsousMCFaPourValeur"), - (("POUTRE","VARI_SECT","HOMOTHETIQUE",jdc),"MCsousMCFaPourValeur"), - ), - ) + changementValeurDsMCFSiRegle( + jdc, + "AFFE_CARA_ELEM", + "POUTRE", + "CARA", + {"R1": "R_DEBUT", "R2": "R_FIN", "EP1": "EP_DEBUT", "EP2": "EP_FIN"}, + ( + ( + ( + "POUTRE", + "MAILLE", + ), + "nexistepasMCsousMCF", + ), + (("POUTRE", "SECTION", "CERCLE", jdc), "MCsousMCFaPourValeur"), + (("POUTRE", "VARI_SECT", "HOMOTHETIQUE", jdc), "MCsousMCFaPourValeur"), + ), + ) #### traitement de AFFE_CHAR_MECA ############################## # Suppression du mot-clé METHODE - removeMotCle(jdc,"AFFE_CHAR_MECA","METHODE",pasDeRegle(),0) + removeMotCle(jdc, "AFFE_CHAR_MECA", "METHODE", pasDeRegle(), 0) # Suppression des mot-clés LIAISON_XFEM - removeMotCle(jdc,"AFFE_CHAR_MECA","LIAISON_XFEM",pasDeRegle(),0) - removeMotCle(jdc,"AFFE_CHAR_MECA","CONTACT_XFEM",pasDeRegle(),0) + removeMotCle(jdc, "AFFE_CHAR_MECA", "LIAISON_XFEM", pasDeRegle(), 0) + removeMotCle(jdc, "AFFE_CHAR_MECA", "CONTACT_XFEM", pasDeRegle(), 0) # Modification des parametres du mot-clé DDL_POUTRE - renameMotCleInFact(jdc,"AFFE_CHAR_MECA","DDL_POUTRE","GROUP_MA","GROUP_MA_REPE",pasDeRegle(),0) - renameMotCleInFact(jdc,"AFFE_CHAR_MECA","DDL_POUTRE","MAILLE","MAILLE_REPE",pasDeRegle(),0) + renameMotCleInFact( + jdc, + "AFFE_CHAR_MECA", + "DDL_POUTRE", + "GROUP_MA", + "GROUP_MA_REPE", + pasDeRegle(), + 0, + ) + renameMotCleInFact( + jdc, "AFFE_CHAR_MECA", "DDL_POUTRE", "MAILLE", "MAILLE_REPE", pasDeRegle(), 0 + ) # Résorption des mot-clés ANGLE_NAUT et CENTRE - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","LIAISON_SOLIDE","ANGL_NAUT",pasDeRegle(),0) - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","LIAISON_SOLIDE","CENTRE",pasDeRegle(),0) + removeMotCleInFact( + jdc, "AFFE_CHAR_MECA", "LIAISON_SOLIDE", "ANGL_NAUT", pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "AFFE_CHAR_MECA", "LIAISON_SOLIDE", "CENTRE", pasDeRegle(), 0 + ) #### traitement de AFFE_CHAR_MECA_F ############################## # Suppression du mot-clé METHODE - removeMotCle(jdc,"AFFE_CHAR_MECA_F","METHODE",pasDeRegle(),0) + removeMotCle(jdc, "AFFE_CHAR_MECA_F", "METHODE", pasDeRegle(), 0) # Résorption des mot-clés ANGLE_NAUT et CENTRE - removeMotCleInFact(jdc,"AFFE_CHAR_MECA_F","LIAISON_SOLIDE","ANGL_NAUT",pasDeRegle(),0) - removeMotCleInFact(jdc,"AFFE_CHAR_MECA_F","LIAISON_SOLIDE","CENTRE",pasDeRegle(),0) + removeMotCleInFact( + jdc, "AFFE_CHAR_MECA_F", "LIAISON_SOLIDE", "ANGL_NAUT", pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "AFFE_CHAR_MECA_F", "LIAISON_SOLIDE", "CENTRE", pasDeRegle(), 0 + ) - genereErreurMotCleInFact(jdc,"AFFE_CHAR_MECA_F","ONDE_PLANE","DIRECTION") + genereErreurMotCleInFact(jdc, "AFFE_CHAR_MECA_F", "ONDE_PLANE", "DIRECTION") #### traitement de AFFE_CHAR_THER ############################## # Suppression du mot-clé METHODE - removeMotCle(jdc,"AFFE_CHAR_THER","METHODE",pasDeRegle(),0) + removeMotCle(jdc, "AFFE_CHAR_THER", "METHODE", pasDeRegle(), 0) #### traitement de AFFE_MODELE ############################## # Suppression des mot-clés GRILLE et VERIF - removeMotCle(jdc,"AFFE_MODELE","GRILLE",pasDeRegle(),0) - removeMotCle(jdc,"AFFE_MODELE","VERIF",pasDeRegle(),0) - - d3DINCO={"3D_INCO":"3D_INCO_UP","3D_INCO_OSGS":"3D_INCO_UPO", - "3D_INCO_GD":"3D_INCO_UPG","3D_INCO_LOG":"3D_INCO_UPG", - "3D_INCO_LUP":"3D_INCO_UP",} - dAXIS={"AXIS_INCO":"AXIS_INCO_UP","AXIS_INCO_OSGS":"AXIS_INCO_UPO", - "AXIS_INCO_GD":"AXIS_INCO_UPG","AXIS_INCO_LOG":"AXIS_INCO_UPG", - "AXIS_INCO_LUP":"AXIS_INCO_UP",} - dDPLAN={"D_PLAN_INCO":"D_PLAN_INCO_UP","D_PLAN_INCO_OSGS":"D_PLAN_INCO_UPO", - "D_PLAN_INCO_GD":"D_PLAN_INCO_UPG","D_PLAN_INCO_LOG":"D_PLAN_INCO_UPG", - "D_PLAN_INCO_LUP":"D_PLAN_INCO_UP",} - dINCO={} + removeMotCle(jdc, "AFFE_MODELE", "GRILLE", pasDeRegle(), 0) + removeMotCle(jdc, "AFFE_MODELE", "VERIF", pasDeRegle(), 0) + + d3DINCO = { + "3D_INCO": "3D_INCO_UP", + "3D_INCO_OSGS": "3D_INCO_UPO", + "3D_INCO_GD": "3D_INCO_UPG", + "3D_INCO_LOG": "3D_INCO_UPG", + "3D_INCO_LUP": "3D_INCO_UP", + } + dAXIS = { + "AXIS_INCO": "AXIS_INCO_UP", + "AXIS_INCO_OSGS": "AXIS_INCO_UPO", + "AXIS_INCO_GD": "AXIS_INCO_UPG", + "AXIS_INCO_LOG": "AXIS_INCO_UPG", + "AXIS_INCO_LUP": "AXIS_INCO_UP", + } + dDPLAN = { + "D_PLAN_INCO": "D_PLAN_INCO_UP", + "D_PLAN_INCO_OSGS": "D_PLAN_INCO_UPO", + "D_PLAN_INCO_GD": "D_PLAN_INCO_UPG", + "D_PLAN_INCO_LOG": "D_PLAN_INCO_UPG", + "D_PLAN_INCO_LUP": "D_PLAN_INCO_UP", + } + dINCO = {} dINCO.update(d3DINCO) dINCO.update(dAXIS) dINCO.update(dDPLAN) - changementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",dINCO) + changementValeurDsMCF(jdc, "AFFE_MODELE", "AFFE", "MODELISATION", dINCO) #### traitement de ASSEMBLAGE ############################## - genereErreurValeurDsMCF(jdc,"ASSEMBLAGE","MATR_ASSE","OPTION",("'MASS_THER'",)) + genereErreurValeurDsMCF(jdc, "ASSEMBLAGE", "MATR_ASSE", "OPTION", ("'MASS_THER'",)) #### traitement de CALC_ESSAI_GEOMECA ############################## - renameMotCleInFact(jdc,"CALC_ESSAI_GEOMECA","ESSAI_CISA_C","EPSI_IMPOSE","GAMMA_IMPOSE",pasDeRegle(),0) - renameMotCleInFact(jdc,"CALC_ESSAI_GEOMECA","ESSAI_CISA_C","EPSI_ELAS","GAMMA_ELAS",pasDeRegle(),0) + renameMotCleInFact( + jdc, + "CALC_ESSAI_GEOMECA", + "ESSAI_CISA_C", + "EPSI_IMPOSE", + "GAMMA_IMPOSE", + pasDeRegle(), + 0, + ) + renameMotCleInFact( + jdc, + "CALC_ESSAI_GEOMECA", + "ESSAI_CISA_C", + "EPSI_ELAS", + "GAMMA_ELAS", + pasDeRegle(), + 0, + ) #### traitement de CALC_EUROPLEXUS ############################## - removeMotCle(jdc,"CALC_EUROPLEXUS","DIME",pasDeRegle(),0) - genereErreurMCF(jdc,"CALC_EUROPLEXUS","FONC_PARASOL") - removeMotCleInFact(jdc,"CALC_EUROPLEXUS","ARCHIVAGE","CONT_GENER") + removeMotCle(jdc, "CALC_EUROPLEXUS", "DIME", pasDeRegle(), 0) + genereErreurMCF(jdc, "CALC_EUROPLEXUS", "FONC_PARASOL") + removeMotCleInFact(jdc, "CALC_EUROPLEXUS", "ARCHIVAGE", "CONT_GENER") #### traitement de CALC_FERRAILLAGE ############################## - genereErreurPourCommande(jdc,"CALC_FERRAILLAGE") + genereErreurPourCommande(jdc, "CALC_FERRAILLAGE") #### traitement de CALC_FONCTION ############################## - ajouteMotClefDansFacteur(jdc,"CALC_FONCTION","CORR_ACCE","METHODE='POLYNOME'",pasDeRegle(),0) - genereErreurMotCleInFact(jdc,"CALC_FONCTION","DSP","FREQ") + ajouteMotClefDansFacteur( + jdc, "CALC_FONCTION", "CORR_ACCE", "METHODE='POLYNOME'", pasDeRegle(), 0 + ) + genereErreurMotCleInFact(jdc, "CALC_FONCTION", "DSP", "FREQ") #### traitement de CALC_G ############################## - removeMotCleInFact(jdc,"CALC_G","COMP_ELAS","RESI_INTE_RELA",pasDeRegle(),0) - removeMotCleInFact(jdc,"CALC_G","COMP_ELAS","ITER_INTE_MAXI",pasDeRegle(),0) + removeMotCleInFact(jdc, "CALC_G", "COMP_ELAS", "RESI_INTE_RELA", pasDeRegle(), 0) + removeMotCleInFact(jdc, "CALC_G", "COMP_ELAS", "ITER_INTE_MAXI", pasDeRegle(), 0) #### traitement de CALC_FATIGUE ############################## - changementValeur(jdc,"CALC_FATIGUE","COURBE_GRD_VIE",{"MANSON_C":"MANSON_COFFIN",}) + changementValeur( + jdc, + "CALC_FATIGUE", + "COURBE_GRD_VIE", + { + "MANSON_C": "MANSON_COFFIN", + }, + ) #### traitement de CALC_IFS_DNL ############################## - removeMotCle(jdc,"CALC_IFS_DNL","ENERGIE",pasDeRegle(),0) + removeMotCle(jdc, "CALC_IFS_DNL", "ENERGIE", pasDeRegle(), 0) #### traitement de CALC_MAC3COEUR ############################## - ajouteMotClefDansFacteur(jdc,"CALC_MAC3COEUR","DEFORMATION","ARCHIMEDE = 'OUI'",pasDeRegle()) + ajouteMotClefDansFacteur( + jdc, "CALC_MAC3COEUR", "DEFORMATION", "ARCHIMEDE = 'OUI'", pasDeRegle() + ) #### traitement de CALC_MATR_ELEM ############################## - genereErreurValeur(jdc,"CALC_MATR_ELEM","OPTION",("'MASS_THER'",)) + genereErreurValeur(jdc, "CALC_MATR_ELEM", "OPTION", ("'MASS_THER'",)) #### traitement de CALC_MISS ############################## - genereErreurValeurDsMCF(jdc,"CALC_MISS","PARAMETRE","ISSF",("'OUI'",)) + genereErreurValeurDsMCF(jdc, "CALC_MISS", "PARAMETRE", "ISSF", ("'OUI'",)) #### traitement de CALC_MODAL ############################## # renameCommande(jdc,"CALC_MODAL","CALC_MODES", ) - genereErreurPourCommande(jdc,"CALC_MODAL") + genereErreurPourCommande(jdc, "CALC_MODAL") #### traitement de CALC_VECT_ELEM ############################## - genereErreurValeur(jdc,"CALC_VECT_ELEM","OPTION",("'FORC_NODA'",)) + genereErreurValeur(jdc, "CALC_VECT_ELEM", "OPTION", ("'FORC_NODA'",)) #### traitement de CREA_MAILLAGE ############################## - renameMotCle(jdc,"CREA_MAILLAGE","CREA_GROUP_MA","CREA_MAILLE") - genereErreurMCF(jdc,"CREA_MAILLAGE","ECLA_PG") - - lMCLEF=['COQU_VOLU', 'CREA_FISS', 'CREA_GROUP_MA', 'CREA_MAILLE', 'CREA_POI1', - 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE','QUAD_LINE', - 'REPERE','RESTREINT','PENTA15_18'] - genereErreurMCF(jdc,"CREA_MAILLAGE","DETR_GROUP_MA") - removeMotCleInFactSiRegle(jdc,"CREA_MAILLAGE","DETR_GROUP_MA","NB_MAILLE",((lMCLEF,"nexistepasMCFParmi"),)) - renameMotCleInFactSiRegle(jdc,"CREA_MAILLAGE","DETR_GROUP_MA","GROUP_MA","NOM",((lMCLEF,"nexistepasMCFParmi"),)) - renameCommandeSiRegle(jdc,"CREA_MAILLAGE","DEFI_GROUP",((lMCLEF,"nexistepasMCFParmi"),)) + renameMotCle(jdc, "CREA_MAILLAGE", "CREA_GROUP_MA", "CREA_MAILLE") + genereErreurMCF(jdc, "CREA_MAILLAGE", "ECLA_PG") + + lMCLEF = [ + "COQU_VOLU", + "CREA_FISS", + "CREA_GROUP_MA", + "CREA_MAILLE", + "CREA_POI1", + "ECLA_PG", + "HEXA20_27", + "LINE_QUAD", + "MODI_MAILLE", + "QUAD_LINE", + "REPERE", + "RESTREINT", + "PENTA15_18", + ] + genereErreurMCF(jdc, "CREA_MAILLAGE", "DETR_GROUP_MA") + removeMotCleInFactSiRegle( + jdc, + "CREA_MAILLAGE", + "DETR_GROUP_MA", + "NB_MAILLE", + ((lMCLEF, "nexistepasMCFParmi"),), + ) + renameMotCleInFactSiRegle( + jdc, + "CREA_MAILLAGE", + "DETR_GROUP_MA", + "GROUP_MA", + "NOM", + ((lMCLEF, "nexistepasMCFParmi"),), + ) + renameCommandeSiRegle( + jdc, "CREA_MAILLAGE", "DEFI_GROUP", ((lMCLEF, "nexistepasMCFParmi"),) + ) #### traitement de DEBUT ############################## # genereErreurPourCommande(jdc,("DEBUT",)) - removeMotCleInFact(jdc,"DEBUT","CODE","NOM",pasDeRegle(),0) + removeMotCleInFact(jdc, "DEBUT", "CODE", "NOM", pasDeRegle(), 0) #### traitement de DEFI_COMPOR ############################## - genereErreurValeur(jdc,"DEFI_COMPOR","LOCALISATION",["'RL'",]) - genereErreurValeur(jdc,"DEFI_COMPOR","RELATION_KIT",["'RVMIS_ISOT_CINE'",]) - genereErreurValeurDsMCF(jdc,"DEFI_COMPOR","MULTIFIBRE","RELATION",["'LABORD_1D'"]) - genereErreurMCF(jdc,"DEFI_COMPOR","POLYCRISTAL") + genereErreurValeur( + jdc, + "DEFI_COMPOR", + "LOCALISATION", + [ + "'RL'", + ], + ) + genereErreurValeur( + jdc, + "DEFI_COMPOR", + "RELATION_KIT", + [ + "'RVMIS_ISOT_CINE'", + ], + ) + genereErreurValeurDsMCF( + jdc, "DEFI_COMPOR", "MULTIFIBRE", "RELATION", ["'LABORD_1D'"] + ) + genereErreurMCF(jdc, "DEFI_COMPOR", "POLYCRISTAL") #### traitement de DEFI_FISS_XFEM ############################## - genereErreurPourCommande(jdc,("DEFI_FISS_XFEM",)) - removeMotCle(jdc,"DEFI_FISS_XFEM","MODELE",pasDeRegle(),0) - removeMotCle(jdc,"DEFI_FISS_XFEM","MODELE_GRILLE",pasDeRegle(),0) + genereErreurPourCommande(jdc, ("DEFI_FISS_XFEM",)) + removeMotCle(jdc, "DEFI_FISS_XFEM", "MODELE", pasDeRegle(), 0) + removeMotCle(jdc, "DEFI_FISS_XFEM", "MODELE_GRILLE", pasDeRegle(), 0) #### traitement de DEFI_LIST_INST ############################## - changementValeurDsMCF(jdc,"DEFI_LIST_INST","ECHEC","ACTION",{"REAC_PRECOND":"DECOUPE"}) + changementValeurDsMCF( + jdc, "DEFI_LIST_INST", "ECHEC", "ACTION", {"REAC_PRECOND": "DECOUPE"} + ) #### traitement de DEFI_MATER_GC ############################## - ajouteMotClefDansFacteur(jdc,"DEFI_MATER_GC","MAZARS","CODIFICATION='ESSAI'",pasDeRegle(),0) - - removeMotCleInFactSiRegle(jdc,"DEFI_MATER_GC","MAZARS","UNITE_LONGUEUR", - ((("MAZARS","CODIFICATION",["ESSAI"],jdc),"MCsousMCFaPourValeurDansListe"),),) - renameMotCleInFact(jdc,"DEFI_MATER_GC","MAZARS","UNITE_LONGUEUR","UNITE_CONTRAINTE") - changementValeurDsMCF(jdc,"DEFI_MATER_GC","MAZARS","UNITE_CONTRAINTE",{"MM":"MPa"}) - changementValeurDsMCF(jdc,"DEFI_MATER_GC","MAZARS","UNITE_CONTRAINTE",{"M":"Pa"}) - - genereErreurMCF(jdc,"DEFI_MATER_GC","MAZARS") + ajouteMotClefDansFacteur( + jdc, "DEFI_MATER_GC", "MAZARS", "CODIFICATION='ESSAI'", pasDeRegle(), 0 + ) + + removeMotCleInFactSiRegle( + jdc, + "DEFI_MATER_GC", + "MAZARS", + "UNITE_LONGUEUR", + ( + ( + ("MAZARS", "CODIFICATION", ["ESSAI"], jdc), + "MCsousMCFaPourValeurDansListe", + ), + ), + ) + renameMotCleInFact( + jdc, "DEFI_MATER_GC", "MAZARS", "UNITE_LONGUEUR", "UNITE_CONTRAINTE" + ) + changementValeurDsMCF( + jdc, "DEFI_MATER_GC", "MAZARS", "UNITE_CONTRAINTE", {"MM": "MPa"} + ) + changementValeurDsMCF( + jdc, "DEFI_MATER_GC", "MAZARS", "UNITE_CONTRAINTE", {"M": "Pa"} + ) + + genereErreurMCF(jdc, "DEFI_MATER_GC", "MAZARS") #### traitement de DEFI_MATERIAU ############################## - lMLA=["F_MRR_RR", "C_MRR_RR", "F_MTT_TT", "C_MTT_TT", "F_MZZ_ZZ", - "C_MZZ_ZZ", "F_MRT_RT", "C_MRT_RT", "F_MRZ_RZ", "C_MRZ_RZ", - "F_MTZ_TZ", "C_MTZ_TZ",] + lMLA = [ + "F_MRR_RR", + "C_MRR_RR", + "F_MTT_TT", + "C_MTT_TT", + "F_MZZ_ZZ", + "C_MZZ_ZZ", + "F_MRT_RT", + "C_MRT_RT", + "F_MRZ_RZ", + "C_MRZ_RZ", + "F_MTZ_TZ", + "C_MTZ_TZ", + ] for param in lMLA: - removeMotCleInFact(jdc,"DEFI_MATERIAU","META_LEMA_ANI",param,pasDeRegle(),0) - removeMotCleInFact(jdc,"DEFI_MATERIAU","META_LEMA_ANI_FO",param,pasDeRegle(),0) - - lMDC=["BETA","DELTA1", "DELTA2", "DEPDT",] + removeMotCleInFact( + jdc, "DEFI_MATERIAU", "META_LEMA_ANI", param, pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "DEFI_MATERIAU", "META_LEMA_ANI_FO", param, pasDeRegle(), 0 + ) + + lMDC = [ + "BETA", + "DELTA1", + "DELTA2", + "DEPDT", + ] for mcle in lMDC: - removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC",mcle,pasDeRegle(),0) - removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC_IRRA",mcle,pasDeRegle(),0) - - removeMotCleInFact(jdc,"DEFI_MATERIAU","UMAT","NB_VALE",pasDeRegle(),0) - removeMotCleInFact(jdc,"DEFI_MATERIAU","UMAT_FO","NB_VALE",pasDeRegle(),0) - listeMc=["C"+str(i) for i in range(1,198)] - fusionMotCleInFact(jdc,"DEFI_MATERIAU","UMAT",listeMc,"LISTE_COEF") - fusionMotCleInFact(jdc,"DEFI_MATERIAU","UMAT_FO",listeMc,"LISTE_COEF") - - removeMotCle(jdc,"DEFI_MATERIAU","LABORD_1D",pasDeRegle(),0) - - genereErreurMCF(jdc,"DEFI_MATERIAU","DIS_VISC") - lDISC=["PUIS_DX", "PUIS_DY", "PUIS_DZ", "PUIS_RX", "PUIS_RY", "PUIS_RZ", - "COEF_DX", "COEF_DY", "COEF_DZ", "COEF_RX", "COEF_RY", "COEF_RZ"] + removeMotCleInFact(jdc, "DEFI_MATERIAU", "MONO_DD_CC", mcle, pasDeRegle(), 0) + removeMotCleInFact( + jdc, "DEFI_MATERIAU", "MONO_DD_CC_IRRA", mcle, pasDeRegle(), 0 + ) + + removeMotCleInFact(jdc, "DEFI_MATERIAU", "UMAT", "NB_VALE", pasDeRegle(), 0) + removeMotCleInFact(jdc, "DEFI_MATERIAU", "UMAT_FO", "NB_VALE", pasDeRegle(), 0) + listeMc = ["C" + str(i) for i in range(1, 198)] + fusionMotCleInFact(jdc, "DEFI_MATERIAU", "UMAT", listeMc, "LISTE_COEF") + fusionMotCleInFact(jdc, "DEFI_MATERIAU", "UMAT_FO", listeMc, "LISTE_COEF") + + removeMotCle(jdc, "DEFI_MATERIAU", "LABORD_1D", pasDeRegle(), 0) + + genereErreurMCF(jdc, "DEFI_MATERIAU", "DIS_VISC") + lDISC = [ + "PUIS_DX", + "PUIS_DY", + "PUIS_DZ", + "PUIS_RX", + "PUIS_RY", + "PUIS_RZ", + "COEF_DX", + "COEF_DY", + "COEF_DZ", + "COEF_RX", + "COEF_RY", + "COEF_RZ", + ] for param in lDISC: - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_VISC",param,pasDeRegle(),0) - - lTHMD=["PERMIN_X", "PERMIN_Y", "PERMIN_Z", "PERMINXY", "PERMINYZ", "PERMINZX",] + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_VISC", param, pasDeRegle(), 0) + + lTHMD = [ + "PERMIN_X", + "PERMIN_Y", + "PERMIN_Z", + "PERMINXY", + "PERMINYZ", + "PERMINZX", + ] for param in lTHMD: - removeMotCleInFact(jdc,"DEFI_MATERIAU","THM_DIFFU",param,pasDeRegle(),0) + removeMotCleInFact(jdc, "DEFI_MATERIAU", "THM_DIFFU", param, pasDeRegle(), 0) # lMONODD=["DELTA1", "DELTA2"] # for param in lMONODD: - # removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC",param,pasDeRegle(),0) - # removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC_IRRA",param,pasDeRegle(),0) - - removeMotCleInFact(jdc,"DEFI_MATERIAU","GLRC_DM","EF",pasDeRegle(),0) - removeMotCleInFact(jdc,"DEFI_MATERIAU","GLRC_DM","NUF",pasDeRegle(),0) + # removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC",param,pasDeRegle(),0) + # removeMotCleInFact(jdc,"DEFI_MATERIAU","MONO_DD_CC_IRRA",param,pasDeRegle(),0) - genereErreurMCF(jdc,"DEFI_MATERIAU","THER_FO") - genereErreurMCF(jdc,"DEFI_MATERIAU","THER_NL") - genereErreurMCF(jdc,"DEFI_MATERIAU","THER_HYDR") - genereErreurMCF(jdc,"DEFI_MATERIAU","THER_COQUE") - genereErreurMCF(jdc,"DEFI_MATERIAU","THER_COQUE_FO") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "GLRC_DM", "EF", pasDeRegle(), 0) + removeMotCleInFact(jdc, "DEFI_MATERIAU", "GLRC_DM", "NUF", pasDeRegle(), 0) + genereErreurMCF(jdc, "DEFI_MATERIAU", "THER_FO") + genereErreurMCF(jdc, "DEFI_MATERIAU", "THER_NL") + genereErreurMCF(jdc, "DEFI_MATERIAU", "THER_HYDR") + genereErreurMCF(jdc, "DEFI_MATERIAU", "THER_COQUE") + genereErreurMCF(jdc, "DEFI_MATERIAU", "THER_COQUE_FO") #### traitement de DEFI_OBSTACLE ############################## - lMCLE=("CRAYON_900","CRAYON_1300","GUID_A_CARTE_900", - "GUID_B_CARTE_900","GUID_C_CARTE_900","GUID_D_CARTE_900","GUID_E_CARTE_900", - "GUID_F_CARTE_900","GUID_A_CARTE_1300","GUID_B_CARTE_1300","GUID_C_CARTE_1300", - "GUID_D_CARTE_1300","GUID_E_CARTE_1300","GUID_F_CARTE_1300","GUID_A_CARSP_900", - "GUID_B_CARSP_900","GUID_C_CARSP_900","GUID_D_CARSP_900","GUID_E_CARSP_900", - "GUID_F_CARSP_900","GUID_A_CARSP_1300","GUID_B_CARSP_1300","GUID_C_CARSP_1300", - "GUID_D_CARSP_1300","GUID_E_CARSP_1300","GUID_F_CARSP_1300","GUID_A_GCONT_900", - "GUID_B_GCONT_900","GUID_C_GCONT_900","GUID_D_GCONT_900","GUID_E_GCONT_900", - "GUID_F_GCONT_900","GUID_A_GCONT_1300","GUID_B_GCONT_1300","GUID_C_GCONT_1300", - "GUID_D_GCONT_1300","GUID_E_GCONT_1300","GUID_F_GCONT_1300","GUID_A_GCOMB_900", - "GUID_B_GCOMB_900","GUID_C_GCOMB_900","GUID_D_GCOMB_900","GUID_E_GCOMB_900", - "GUID_F_GCOMB_900","GUID_A_GCOMB_1300","GUID_B_GCOMB_1300","GUID_C_GCOMB_1300", - "GUID_D_GCOMB_1300","GUID_E_GCOMB_1300","GUID_F_GCOMB_1300",) - genereErreurValeur(jdc,"DEFI_OBSTACLE","TYPE",lMCLE) + lMCLE = ( + "CRAYON_900", + "CRAYON_1300", + "GUID_A_CARTE_900", + "GUID_B_CARTE_900", + "GUID_C_CARTE_900", + "GUID_D_CARTE_900", + "GUID_E_CARTE_900", + "GUID_F_CARTE_900", + "GUID_A_CARTE_1300", + "GUID_B_CARTE_1300", + "GUID_C_CARTE_1300", + "GUID_D_CARTE_1300", + "GUID_E_CARTE_1300", + "GUID_F_CARTE_1300", + "GUID_A_CARSP_900", + "GUID_B_CARSP_900", + "GUID_C_CARSP_900", + "GUID_D_CARSP_900", + "GUID_E_CARSP_900", + "GUID_F_CARSP_900", + "GUID_A_CARSP_1300", + "GUID_B_CARSP_1300", + "GUID_C_CARSP_1300", + "GUID_D_CARSP_1300", + "GUID_E_CARSP_1300", + "GUID_F_CARSP_1300", + "GUID_A_GCONT_900", + "GUID_B_GCONT_900", + "GUID_C_GCONT_900", + "GUID_D_GCONT_900", + "GUID_E_GCONT_900", + "GUID_F_GCONT_900", + "GUID_A_GCONT_1300", + "GUID_B_GCONT_1300", + "GUID_C_GCONT_1300", + "GUID_D_GCONT_1300", + "GUID_E_GCONT_1300", + "GUID_F_GCONT_1300", + "GUID_A_GCOMB_900", + "GUID_B_GCOMB_900", + "GUID_C_GCOMB_900", + "GUID_D_GCOMB_900", + "GUID_E_GCOMB_900", + "GUID_F_GCOMB_900", + "GUID_A_GCOMB_1300", + "GUID_B_GCOMB_1300", + "GUID_C_GCOMB_1300", + "GUID_D_GCOMB_1300", + "GUID_E_GCOMB_1300", + "GUID_F_GCOMB_1300", + ) + genereErreurValeur(jdc, "DEFI_OBSTACLE", "TYPE", lMCLE) #### traitement de DYNA_TRAN_MODAL ############################## - removeMotCle(jdc,"DYNA_TRAN_MODAL","LAME_FLUIDE",pasDeRegle(),0) - removeMotCle(jdc,"DYNA_TRAN_MODAL","PARA_LAME_FLUI",pasDeRegle(),0) - removeMotCle(jdc,"DYNA_TRAN_MODAL","RELA_TRANSIS",pasDeRegle(),0) + removeMotCle(jdc, "DYNA_TRAN_MODAL", "LAME_FLUIDE", pasDeRegle(), 0) + removeMotCle(jdc, "DYNA_TRAN_MODAL", "PARA_LAME_FLUI", pasDeRegle(), 0) + removeMotCle(jdc, "DYNA_TRAN_MODAL", "RELA_TRANSIS", pasDeRegle(), 0) #### traitement de DYNA_VIBRA ############################## - removeMotCle(jdc,"DYNA_VIBRA","LAME_FLUIDE",pasDeRegle(),0) - removeMotCle(jdc,"DYNA_VIBRA","PARA_LAME_FLUI",pasDeRegle(),0) - removeMotCle(jdc,"DYNA_VIBRA","RELA_TRANSIS",pasDeRegle(),0) + removeMotCle(jdc, "DYNA_VIBRA", "LAME_FLUIDE", pasDeRegle(), 0) + removeMotCle(jdc, "DYNA_VIBRA", "PARA_LAME_FLUI", pasDeRegle(), 0) + removeMotCle(jdc, "DYNA_VIBRA", "RELA_TRANSIS", pasDeRegle(), 0) #### traitement de EXTR_TABLE ############################## - changementValeurDsMCF(jdc,"EXTR_TABLE","FILTRE","VALE_K",{"MATR_ELEM":"MATR_TANG_ELEM"}) - changementValeurDsMCF(jdc,"EXTR_TABLE","FILTRE","VALE_K",{"CODE_RETOUR":"CODE_RETOUR_INTE"}) + changementValeurDsMCF( + jdc, "EXTR_TABLE", "FILTRE", "VALE_K", {"MATR_ELEM": "MATR_TANG_ELEM"} + ) + changementValeurDsMCF( + jdc, "EXTR_TABLE", "FILTRE", "VALE_K", {"CODE_RETOUR": "CODE_RETOUR_INTE"} + ) #### traitement de FACTORISER ############################## - renameMotCle(jdc,"FACTORISER","ELIM_LAGR2","ELIM_LAGR") - changementValeur(jdc,"FACTORISER","ELIM_LAGR",{"OUI":"LAGR2",}) + renameMotCle(jdc, "FACTORISER", "ELIM_LAGR2", "ELIM_LAGR") + changementValeur( + jdc, + "FACTORISER", + "ELIM_LAGR", + { + "OUI": "LAGR2", + }, + ) #### traitement de GENE_ACCE_SEISME ############################## - genereErreurMCF(jdc,"GENE_ACCE_SEISME","MODULATION") - moveMotCleFromFactToFather(jdc,"GENE_ACCE_SEISME","MODULATION","DUREE_PHASE_FORTE") - - - removeMotCleInFact(jdc,"GENE_ACCE_SEISME","MODULATION","PARA") - removeMotCleInFactSiRegle(jdc,"GENE_ACCE_SEISME","MODULATION","INST_INI",((("MODULATION","TYPE",["GAMMA"],jdc),"MCsousMCFnaPasPourValeurDansListe"),)) - - removeMotCleInFact(jdc,"GENE_ACCE_SEISME","DSP","FREQ_PENTE") + genereErreurMCF(jdc, "GENE_ACCE_SEISME", "MODULATION") + moveMotCleFromFactToFather( + jdc, "GENE_ACCE_SEISME", "MODULATION", "DUREE_PHASE_FORTE" + ) + + removeMotCleInFact(jdc, "GENE_ACCE_SEISME", "MODULATION", "PARA") + removeMotCleInFactSiRegle( + jdc, + "GENE_ACCE_SEISME", + "MODULATION", + "INST_INI", + ( + ( + ("MODULATION", "TYPE", ["GAMMA"], jdc), + "MCsousMCFnaPasPourValeurDansListe", + ), + ), + ) + + removeMotCleInFact(jdc, "GENE_ACCE_SEISME", "DSP", "FREQ_PENTE") #### traitement de IMPR_MISS_3D ############################## - genereErreurPourCommande(jdc,"IMPR_MISS_3D") + genereErreurPourCommande(jdc, "IMPR_MISS_3D") # removeCommande(jdc,"IMPR_MISS_3D") #### traitement de IMPR_RESU ############################## - removeMotCle(jdc,"IMPR_RESU","RESTREINT",pasDeRegle(),0) + removeMotCle(jdc, "IMPR_RESU", "RESTREINT", pasDeRegle(), 0) #### traitement de INFO_FONCTION ############################## - genereErreurMCF(jdc,"INFO_FONCTION","NOCI_SEISME") + genereErreurMCF(jdc, "INFO_FONCTION", "NOCI_SEISME") #### traitement de LIRE_MAILLAGE ############################## - removeMotCle(jdc,"LIRE_MAILLAGE","ABSC_CURV",pasDeRegle(),0) + removeMotCle(jdc, "LIRE_MAILLAGE", "ABSC_CURV", pasDeRegle(), 0) #### traitement de LIRE_MISS_3D ############################## - genereErreurPourCommande(jdc,"LIRE_MISS_3D") + genereErreurPourCommande(jdc, "LIRE_MISS_3D") #### traitement de MACR_ASCOUF_CALC ############################## - removeMotCle(jdc,"MACR_ASCOUF_CALC","CL_BOL_P2_GV",pasDeRegle(),0) + removeMotCle(jdc, "MACR_ASCOUF_CALC", "CL_BOL_P2_GV", pasDeRegle(), 0) # genereErreurMCF(jdc,"MACR_ASCOUF_CALC","COMP_ELAS") #### traitement de MACR_ASCOUF_MAIL ############################## - genereErreurValeurDsMCF(jdc,"MACR_ASCOUF_MAIL","COUDE","BOL_P2",("'GV'",)) + genereErreurValeurDsMCF(jdc, "MACR_ASCOUF_MAIL", "COUDE", "BOL_P2", ("'GV'",)) #### traitement de MACR_ASPIC_CALC ############################## # genereErreurMCF(jdc,"MACR_ASPIC_CALC","COMP_ELAS") #### traitement de MACR_ECREVISSE ############################## - genereErreurMCF(jdc,"MACR_ECREVISSE","COMP_INCR") + genereErreurMCF(jdc, "MACR_ECREVISSE", "COMP_INCR") #### traitement de MACR_INFO_MAIL ############################## - changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_6":"V11_2"}) - changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_N":"V11_N"}) - changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V10_N_PERSO":"V11_N_PERSO"}) + changementValeur(jdc, "MACR_INFO_MAIL", "VERSION_HOMARD", {"V10_6": "V11_2"}) + changementValeur(jdc, "MACR_INFO_MAIL", "VERSION_HOMARD", {"V10_N": "V11_N"}) + changementValeur( + jdc, "MACR_INFO_MAIL", "VERSION_HOMARD", {"V10_N_PERSO": "V11_N_PERSO"} + ) #### traitement de MACRO_BASCULE_SCHEMA ############################## - renameMotCle(jdc,"MACRO_BASCULE_SCHEMA","COMP_INCR_IMPL","COMPORTEMENT_IMPL",pasDeRegle()) - renameMotCle(jdc,"MACRO_BASCULE_SCHEMA","COMP_INCR_EXPL","COMPORTEMENT_EXPL",pasDeRegle()) + renameMotCle( + jdc, "MACRO_BASCULE_SCHEMA", "COMP_INCR_IMPL", "COMPORTEMENT_IMPL", pasDeRegle() + ) + renameMotCle( + jdc, "MACRO_BASCULE_SCHEMA", "COMP_INCR_EXPL", "COMPORTEMENT_EXPL", pasDeRegle() + ) #### traitement de MACRO_MISS_3D ############################## - genereErreurPourCommande(jdc,"MACRO_MISS_3D") + genereErreurPourCommande(jdc, "MACRO_MISS_3D") #### traitement de MACRO_MODE_MECA ############################## # insereMotCleDansCommande(jdc,"MACRO_MODE_MECA","TYPE_RESU='DYNAMIQUE'") - chercheOperInsereFacteur(jdc,"MACRO_MODE_MECA","SOLVEUR_MODAL",) - chercheOperInsereFacteur(jdc,"MACRO_MODE_MECA","OPTION='BANDE'",pasDeRegle(),0) - chercheOperInsereFacteurSiRegle(jdc,"MACRO_MODE_MECA","NORM_MODE",((("NORM_MODE",),"nexistepas"),),1) - - lMCLE=["PREC_SOREN", "NMAX_ITER_SOREN", "PARA_ORTHO_SOREN"] + chercheOperInsereFacteur( + jdc, + "MACRO_MODE_MECA", + "SOLVEUR_MODAL", + ) + chercheOperInsereFacteur(jdc, "MACRO_MODE_MECA", "OPTION='BANDE'", pasDeRegle(), 0) + chercheOperInsereFacteurSiRegle( + jdc, "MACRO_MODE_MECA", "NORM_MODE", ((("NORM_MODE",), "nexistepas"),), 1 + ) + + lMCLE = ["PREC_SOREN", "NMAX_ITER_SOREN", "PARA_ORTHO_SOREN"] for mcle in lMCLE: - moveMotClefInOperToFact(jdc,"MACRO_MODE_MECA",mcle,"SOLVEUR_MODAL") - - moveMotCleFromFactToFact(jdc,"MACRO_MODE_MECA","CALC_FREQ","COEF_DIM_ESPACE","SOLVEUR_MODAL") - moveMotCleFromFactToFact(jdc,"MACRO_MODE_MECA","CALC_FREQ","DIM_SOUS_ESPACE","SOLVEUR_MODAL") - renameCommande(jdc,"MACRO_MODE_MECA","CALC_MODES", ) + moveMotClefInOperToFact(jdc, "MACRO_MODE_MECA", mcle, "SOLVEUR_MODAL") + + moveMotCleFromFactToFact( + jdc, "MACRO_MODE_MECA", "CALC_FREQ", "COEF_DIM_ESPACE", "SOLVEUR_MODAL" + ) + moveMotCleFromFactToFact( + jdc, "MACRO_MODE_MECA", "CALC_FREQ", "DIM_SOUS_ESPACE", "SOLVEUR_MODAL" + ) + renameCommande( + jdc, + "MACRO_MODE_MECA", + "CALC_MODES", + ) #### traitement de MODE_ITER_INV ############################## - chercheOperInsereFacteur(jdc,"MODE_ITER_INV","SOLVEUR_MODAL",) - moveMotCleFromFactToFather(jdc,"MODE_ITER_INV","CALC_FREQ","OPTION") - moveMotCleFromFactToFather(jdc,"MODE_ITER_INV","CALC_CHAR_CRIT","OPTION") - - lINV=["OPTION", "PREC", "NMAX_ITER",] + chercheOperInsereFacteur( + jdc, + "MODE_ITER_INV", + "SOLVEUR_MODAL", + ) + moveMotCleFromFactToFather(jdc, "MODE_ITER_INV", "CALC_FREQ", "OPTION") + moveMotCleFromFactToFather(jdc, "MODE_ITER_INV", "CALC_CHAR_CRIT", "OPTION") + + lINV = [ + "OPTION", + "PREC", + "NMAX_ITER", + ] for mcle in lINV: - renameMotCleInFact(jdc,"MODE_ITER_INV","CALC_MODE",mcle,mcle+"_INV",pasDeRegle(),0) - moveMotCleFromFactToFact(jdc,"MODE_ITER_INV","CALC_MODE",mcle+"_INV","SOLVEUR_MODAL") - - lMCLE=["NMAX_ITER_AJUSTE","PREC_AJUSTE",] + renameMotCleInFact( + jdc, "MODE_ITER_INV", "CALC_MODE", mcle, mcle + "_INV", pasDeRegle(), 0 + ) + moveMotCleFromFactToFact( + jdc, "MODE_ITER_INV", "CALC_MODE", mcle + "_INV", "SOLVEUR_MODAL" + ) + + lMCLE = [ + "NMAX_ITER_AJUSTE", + "PREC_AJUSTE", + ] for mcle in lMCLE: - moveMotCleFromFactToFact(jdc,"MODE_ITER_INV","CALC_FREQ",mcle,"SOLVEUR_MODAL") - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","PREC_JACOBI","SOLVEUR_MODAL") - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","PREC_BATHE","SOLVEUR_MODAL") + moveMotCleFromFactToFact( + jdc, "MODE_ITER_INV", "CALC_FREQ", mcle, "SOLVEUR_MODAL" + ) + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", "PREC_JACOBI", "SOLVEUR_MODAL") + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", "PREC_BATHE", "SOLVEUR_MODAL") - removeMotCle(jdc,"MODE_ITER_INV","CALC_MODE",pasDeRegle(),0) + removeMotCle(jdc, "MODE_ITER_INV", "CALC_MODE", pasDeRegle(), 0) - chercheOperInsereMotCleSiRegle(jdc,"MODE_ITER_INV","OPTION='AJUSTE'",((("OPTION",),"nexistepas"),),0) + chercheOperInsereMotCleSiRegle( + jdc, "MODE_ITER_INV", "OPTION='AJUSTE'", ((("OPTION",), "nexistepas"),), 0 + ) - renameCommande(jdc,"MODE_ITER_INV","CALC_MODES", ) + renameCommande( + jdc, + "MODE_ITER_INV", + "CALC_MODES", + ) #### traitement de MODE_ITER_SIMULT ############################## - chercheOperInsereFacteur(jdc,"MODE_ITER_SIMULT","SOLVEUR_MODAL",) - removeMotCleSiRegle(jdc,"MODE_ITER_SIMULT","OPTION",((("METHODE","TRI_DIAG",jdc),"MCnaPasPourValeur"),),) - removeMotCleSiRegle(jdc,"MODE_ITER_SIMULT","OPTION",((("OPTION","SANS",jdc),"MCaPourValeur"),),) - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","OPTION","SOLVEUR_MODAL") - changementValeurDsMCF(jdc,"MODE_ITER_SIMULT","SOLVEUR_MODAL","OPTION",{"MODE_RIGIDE":"OUI"}) - renameMotCleInFact(jdc,"MODE_ITER_SIMULT","SOLVEUR_MODAL","OPTION","MODE_RIGIDE") - moveMotCleFromFactToFather(jdc,"MODE_ITER_SIMULT","CALC_FREQ","OPTION") - moveMotCleFromFactToFather(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","OPTION") + chercheOperInsereFacteur( + jdc, + "MODE_ITER_SIMULT", + "SOLVEUR_MODAL", + ) + removeMotCleSiRegle( + jdc, + "MODE_ITER_SIMULT", + "OPTION", + ((("METHODE", "TRI_DIAG", jdc), "MCnaPasPourValeur"),), + ) + removeMotCleSiRegle( + jdc, + "MODE_ITER_SIMULT", + "OPTION", + ((("OPTION", "SANS", jdc), "MCaPourValeur"),), + ) + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", "OPTION", "SOLVEUR_MODAL") + changementValeurDsMCF( + jdc, "MODE_ITER_SIMULT", "SOLVEUR_MODAL", "OPTION", {"MODE_RIGIDE": "OUI"} + ) + renameMotCleInFact( + jdc, "MODE_ITER_SIMULT", "SOLVEUR_MODAL", "OPTION", "MODE_RIGIDE" + ) + moveMotCleFromFactToFather(jdc, "MODE_ITER_SIMULT", "CALC_FREQ", "OPTION") + moveMotCleFromFactToFather(jdc, "MODE_ITER_SIMULT", "CALC_CHAR_CRIT", "OPTION") # chercheOperInsereFacteurSiRegle(jdc,"MODE_ITER_SIMULT","SOLVEUR_MODAL",((("METHODE",),"existe"),),1) - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","METHODE","SOLVEUR_MODAL") - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","TYPE_QZ","SOLVEUR_MODAL") - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT","NMAX_ITER_BATHE","SOLVEUR_MODAL") - moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_FREQ","COEF_DIM_ESPACE","SOLVEUR_MODAL") - moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_FREQ","DIM_SOUS_ESPACE","SOLVEUR_MODAL") - moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","COEF_DIM_ESPACE","SOLVEUR_MODAL") - moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","DIM_SOUS_ESPACE","SOLVEUR_MODAL") - - removeMotCleInFactSiRegle(jdc,"MODE_ITER_SIMULT","CALC_FREQ","APPROCHE", - ((("SOLVEUR_MODAL","METHODE",["QZ"],jdc),"MCsousMCFnaPasPourValeurDansListe")or - (("SOLVEUR_MODAL","METHODE",),"nexistepasMCsousMCF"), - ) - ) - - moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_FREQ","APPROCHE","SOLVEUR_MODAL") - moveMotCleFromFactToFact(jdc,"MODE_ITER_SIMULT","CALC_CHAR_CRIT","APPROCHE","SOLVEUR_MODAL") - - lMCLE=["PREC_SOREN", "NMAX_ITER_SOREN", "PARA_ORTHO_SOREN"] + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", "METHODE", "SOLVEUR_MODAL") + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", "TYPE_QZ", "SOLVEUR_MODAL") + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", "NMAX_ITER_BATHE", "SOLVEUR_MODAL") + moveMotCleFromFactToFact( + jdc, "MODE_ITER_SIMULT", "CALC_FREQ", "COEF_DIM_ESPACE", "SOLVEUR_MODAL" + ) + moveMotCleFromFactToFact( + jdc, "MODE_ITER_SIMULT", "CALC_FREQ", "DIM_SOUS_ESPACE", "SOLVEUR_MODAL" + ) + moveMotCleFromFactToFact( + jdc, "MODE_ITER_SIMULT", "CALC_CHAR_CRIT", "COEF_DIM_ESPACE", "SOLVEUR_MODAL" + ) + moveMotCleFromFactToFact( + jdc, "MODE_ITER_SIMULT", "CALC_CHAR_CRIT", "DIM_SOUS_ESPACE", "SOLVEUR_MODAL" + ) + + removeMotCleInFactSiRegle( + jdc, + "MODE_ITER_SIMULT", + "CALC_FREQ", + "APPROCHE", + ( + ( + ("SOLVEUR_MODAL", "METHODE", ["QZ"], jdc), + "MCsousMCFnaPasPourValeurDansListe", + ) + or ( + ( + "SOLVEUR_MODAL", + "METHODE", + ), + "nexistepasMCsousMCF", + ), + ), + ) + + moveMotCleFromFactToFact( + jdc, "MODE_ITER_SIMULT", "CALC_FREQ", "APPROCHE", "SOLVEUR_MODAL" + ) + moveMotCleFromFactToFact( + jdc, "MODE_ITER_SIMULT", "CALC_CHAR_CRIT", "APPROCHE", "SOLVEUR_MODAL" + ) + + lMCLE = ["PREC_SOREN", "NMAX_ITER_SOREN", "PARA_ORTHO_SOREN"] for mcle in lMCLE: - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT",mcle,"SOLVEUR_MODAL") + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", mcle, "SOLVEUR_MODAL") - lMCLE=["NMAX_ITER_QR", "PREC_ORTHO", "NMAX_ITER_ORTHO", "PREC_LANCZOS"] + lMCLE = ["NMAX_ITER_QR", "PREC_ORTHO", "NMAX_ITER_ORTHO", "PREC_LANCZOS"] for mcle in lMCLE: - moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT",mcle,"SOLVEUR_MODAL") - + moveMotClefInOperToFact(jdc, "MODE_ITER_SIMULT", mcle, "SOLVEUR_MODAL") - renameCommande(jdc,"MODE_ITER_SIMULT","CALC_MODES", ) + renameCommande( + jdc, + "MODE_ITER_SIMULT", + "CALC_MODES", + ) #### traitement de MODI_MAILLAGE ############################## - genereErreurValeurDsMCF(jdc,"MODI_MAILLAGE","DEFORME","OPTION",("'TRAN_APPUI'",)) - removeMotCleInFact(jdc,"MODI_MAILLAGE","DEFORME",["GROUP_NO_APPUI"],pasDeRegle(),0) - removeMotCleInFact(jdc,"MODI_MAILLAGE","DEFORME",["GROUP_NO_STRU"],pasDeRegle(),0) + genereErreurValeurDsMCF( + jdc, "MODI_MAILLAGE", "DEFORME", "OPTION", ("'TRAN_APPUI'",) + ) + removeMotCleInFact( + jdc, "MODI_MAILLAGE", "DEFORME", ["GROUP_NO_APPUI"], pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "MODI_MAILLAGE", "DEFORME", ["GROUP_NO_STRU"], pasDeRegle(), 0 + ) #### traitement de MODI_MODELE_XFEM ############################## - changementValeur(jdc,"MODI_MODELE_XFEM","CONTACT",{"P1P1":"STANDARD",}) - changementValeur(jdc,"MODI_MODELE_XFEM","CONTACT",{"P2P1":"STANDARD",}) - + changementValeur( + jdc, + "MODI_MODELE_XFEM", + "CONTACT", + { + "P1P1": "STANDARD", + }, + ) + changementValeur( + jdc, + "MODI_MODELE_XFEM", + "CONTACT", + { + "P2P1": "STANDARD", + }, + ) #### traitement de POST_DYNA_ALEA ############################## - chercheOperInsereFacteurSiRegle(jdc,"POST_DYNA_ALEA","INTERSPECTRE",((("INTE_SPEC",),"existe"),),1) - lPDA=["INTE_SPEC", "NUME_ORDRE_I", "NOEUD_I", "OPTION", "NUME_ORDRE_J", - "NOEUD_J", "NOM_CMP_I", "NOM_CMP_J", "MOMENT", "DUREE"] + chercheOperInsereFacteurSiRegle( + jdc, "POST_DYNA_ALEA", "INTERSPECTRE", ((("INTE_SPEC",), "existe"),), 1 + ) + lPDA = [ + "INTE_SPEC", + "NUME_ORDRE_I", + "NOEUD_I", + "OPTION", + "NUME_ORDRE_J", + "NOEUD_J", + "NOM_CMP_I", + "NOM_CMP_J", + "MOMENT", + "DUREE", + ] for mcle in lPDA: - moveMotClefInOperToFact(jdc,"POST_DYNA_ALEA",mcle,"INTERSPECTRE") - removeMotCle(jdc,"POST_DYNA_ALEA","TOUT_ORDRE",pasDeRegle(),0) + moveMotClefInOperToFact(jdc, "POST_DYNA_ALEA", mcle, "INTERSPECTRE") + removeMotCle(jdc, "POST_DYNA_ALEA", "TOUT_ORDRE", pasDeRegle(), 0) - ajouteMotClefDansFacteur(jdc,"POST_DYNA_ALEA","FRAGILITE","METHODE = 'EMV'",pasDeRegle()) + ajouteMotClefDansFacteur( + jdc, "POST_DYNA_ALEA", "FRAGILITE", "METHODE = 'EMV'", pasDeRegle() + ) #### traitement de POST_ELEM ############################## - ajouteMotClefDansFacteurSiRegle(jdc,"POST_ELEM","VOLUMOGRAMME","NB_INTERV=5", - ((("VOLUMOGRAMME","NB_INTERV",),"nexistepasMCsousMCF"),),) + ajouteMotClefDansFacteurSiRegle( + jdc, + "POST_ELEM", + "VOLUMOGRAMME", + "NB_INTERV=5", + ( + ( + ( + "VOLUMOGRAMME", + "NB_INTERV", + ), + "nexistepasMCsousMCF", + ), + ), + ) #### traitement de POST_FATIGUE ############################## - changementValeur(jdc,"POST_FATIGUE","DOMMAGE",{"MANSON_C":"MANSON_COFFIN",}) + changementValeur( + jdc, + "POST_FATIGUE", + "DOMMAGE", + { + "MANSON_C": "MANSON_COFFIN", + }, + ) #### traitement de POURSUITE ############################## - removeMotCle(jdc,"POURSUITE","CODE",)#"NOM",pasDeRegle(),0) + removeMotCle( + jdc, + "POURSUITE", + "CODE", + ) # "NOM",pasDeRegle(),0) #### traitement de RECU_FONCTION ############################## - genereErreurMCF(jdc,"RECU_FONCTION","TABLE") + genereErreurMCF(jdc, "RECU_FONCTION", "TABLE") #### traitement de C_COMP_INCR et C_COMP_ELAS ############################## - lCOM=["CALCUL","STAT_NON_LINE","CALC_G", "CALC_PRECONT","DYNA_NON_LINE","CALC_META", - "TEST_COMPOR","SIMU_POINT_MAT","CALC_ESSAI_GEOMECA","CALC_FORC_NONL","LIRE_RESU", - "MACR_ASCOUF_CALC","MACR_ASPIC_CALC","CALC_EUROPLEXUS","MACR_ECREVISSE",] + lCOM = [ + "CALCUL", + "STAT_NON_LINE", + "CALC_G", + "CALC_PRECONT", + "DYNA_NON_LINE", + "CALC_META", + "TEST_COMPOR", + "SIMU_POINT_MAT", + "CALC_ESSAI_GEOMECA", + "CALC_FORC_NONL", + "LIRE_RESU", + "MACR_ASCOUF_CALC", + "MACR_ASPIC_CALC", + "CALC_EUROPLEXUS", + "MACR_ECREVISSE", + ] for com in lCOM: # chercheOperInsereFacteurSiRegle(jdc,com,"COMPORTEMENT",(((["COMPORTEMENT"],),"nexistepasMCFParmi"),),1) - fusionMCFToMCF(jdc,com,["COMP_ELAS","COMP_INCR"],"COMPORTEMENT") + fusionMCFToMCF(jdc, com, ["COMP_ELAS", "COMP_INCR"], "COMPORTEMENT") # renameMotCle(jdc,com,"COMP_ELAS","COMPORTEMENT") # renameMotCle(jdc,com,"COMP_INCR","COMPORTEMENT") - chercheOperInsereFacteurSiRegle(jdc,com,"ETAT_INIT",((("COMPORTEMENT","SIGM_INIT",),"existeMCsousMCF"),),1) - moveMotCleFromFactToFact(jdc,com,"COMPORTEMENT","SIGM_INIT","ETAT_INIT") - renameMotCleInFact(jdc,com,"ETAT_INIT","SIGM_INIT","SIGM",pasDeRegle(),0) - removeMotCleInFact(jdc,com,"COMPORTEMENT","SIGM_INIT",pasDeRegle(),0) - - changementValeur(jdc,com,"OPTION",{"FORC_INT_ELEM":"FORC_INTE_ELEM"}) - - removeMotCleInFactSiRegle(jdc,com,"COMPORTEMENT","NB_VARI",((("COMPORTEMENT","RELATION","'MFRONT'",jdc),"MCsousMCFaPourValeur"),)) - + chercheOperInsereFacteurSiRegle( + jdc, + com, + "ETAT_INIT", + ( + ( + ( + "COMPORTEMENT", + "SIGM_INIT", + ), + "existeMCsousMCF", + ), + ), + 1, + ) + moveMotCleFromFactToFact(jdc, com, "COMPORTEMENT", "SIGM_INIT", "ETAT_INIT") + renameMotCleInFact(jdc, com, "ETAT_INIT", "SIGM_INIT", "SIGM", pasDeRegle(), 0) + removeMotCleInFact(jdc, com, "COMPORTEMENT", "SIGM_INIT", pasDeRegle(), 0) + + changementValeur(jdc, com, "OPTION", {"FORC_INT_ELEM": "FORC_INTE_ELEM"}) + + removeMotCleInFactSiRegle( + jdc, + com, + "COMPORTEMENT", + "NB_VARI", + ((("COMPORTEMENT", "RELATION", "'MFRONT'", jdc), "MCsousMCFaPourValeur"),), + ) #### traitement de TEST_COMPOR ############################## - genereErreurPourCommande(jdc,"TEST_COMPOR") + genereErreurPourCommande(jdc, "TEST_COMPOR") #### traitement de THER_NON_LINE ############################## - renameMotCle(jdc,"THER_NON_LINE","COMP_THER_NL","COMPORTEMENT") + renameMotCle(jdc, "THER_NON_LINE", "COMP_THER_NL", "COMPORTEMENT") #### traitement de C_SOLVEUR ############################## - lCOM=['CALC_ERREUR', 'CALC_FORC_AJOU', 'CALC_IFS_DNL', 'CALC_MATR_AJOU', 'CALC_PRECONT', - 'CREA_ELEM_SSD', 'DEFI_BASE_MODALE', 'DYNA_LINE_HARM', 'DYNA_LINE_TRAN', 'DYNA_NON_LINE', - 'DYNA_TRAN_MODAL', 'INFO_MODE', 'MACR_ASCOUF_CALC', 'MACR_ASPIC_CALC', 'MACRO_BASCULE_SCHEMA', - 'MACRO_MATR_AJOU', 'MECA_STATIQUE', 'MODE_ITER_SIMULT', 'MODE_ITER_INV', 'MODE_STATIQUE', - 'STAT_NON_LINE', 'THER_LINEAIRE', 'THER_NON_LINE', 'THER_NON_LINE_MO', 'CALC_ERC_DYN','CALC_MODES',] + lCOM = [ + "CALC_ERREUR", + "CALC_FORC_AJOU", + "CALC_IFS_DNL", + "CALC_MATR_AJOU", + "CALC_PRECONT", + "CREA_ELEM_SSD", + "DEFI_BASE_MODALE", + "DYNA_LINE_HARM", + "DYNA_LINE_TRAN", + "DYNA_NON_LINE", + "DYNA_TRAN_MODAL", + "INFO_MODE", + "MACR_ASCOUF_CALC", + "MACR_ASPIC_CALC", + "MACRO_BASCULE_SCHEMA", + "MACRO_MATR_AJOU", + "MECA_STATIQUE", + "MODE_ITER_SIMULT", + "MODE_ITER_INV", + "MODE_STATIQUE", + "STAT_NON_LINE", + "THER_LINEAIRE", + "THER_NON_LINE", + "THER_NON_LINE_MO", + "CALC_ERC_DYN", + "CALC_MODES", + ] for com in lCOM: # Suppression de ELIM_LAGR2 - changementValeurDsMCF(jdc,com,"SOLVEUR","ELIM_LAGR2",{"OUI":"LAGR2"}) - removeMotCleInFactSiRegle(jdc,com,"SOLVEUR","ELIM_LAGR2",((("SOLVEUR","ELIM_LAGR2","NON",jdc),"MCsousMCFaPourValeur"),)) - renameMotCleInFact(jdc,com,"SOLVEUR","ELIM_LAGR2","ELIM_LAGR") + changementValeurDsMCF(jdc, com, "SOLVEUR", "ELIM_LAGR2", {"OUI": "LAGR2"}) + removeMotCleInFactSiRegle( + jdc, + com, + "SOLVEUR", + "ELIM_LAGR2", + ((("SOLVEUR", "ELIM_LAGR2", "NON", jdc), "MCsousMCFaPourValeur"),), + ) + renameMotCleInFact(jdc, com, "SOLVEUR", "ELIM_LAGR2", "ELIM_LAGR") # Suppression de la méthode FETI - genereErreurValeurDsMCF(jdc,com,"SOLVEUR","METHODE",["FETI"]) - lMCLE=["NB_REORTHO_DD","NMAX_ITER","INFO_FETI","RESI_RELA","PARTITION"] + genereErreurValeurDsMCF(jdc, com, "SOLVEUR", "METHODE", ["FETI"]) + lMCLE = ["NB_REORTHO_DD", "NMAX_ITER", "INFO_FETI", "RESI_RELA", "PARTITION"] for mocle in lMCLE: - genereErreurMotCleInFact(jdc,com,"SOLVEUR",mocle) + genereErreurMotCleInFact(jdc, com, "SOLVEUR", mocle) #### traitement de DEFI_PART_FETI ############################## - genereErreurMCF(jdc,"DEFI_PART_FETI","EXCIT") - removeMotCle(jdc,"DEFI_PART_FETI","EXCIT",pasDeRegle(),0) - removeMotCle(jdc,"DEFI_PART_FETI","CORRECTION_CONNEX",pasDeRegle(),0) - genereErreurPourCommande(jdc,"DEFI_PART_FETI") - renameCommande(jdc,"DEFI_PART_FETI","DEFI_PARTITION", ) + genereErreurMCF(jdc, "DEFI_PART_FETI", "EXCIT") + removeMotCle(jdc, "DEFI_PART_FETI", "EXCIT", pasDeRegle(), 0) + removeMotCle(jdc, "DEFI_PART_FETI", "CORRECTION_CONNEX", pasDeRegle(), 0) + genereErreurPourCommande(jdc, "DEFI_PART_FETI") + renameCommande( + jdc, + "DEFI_PART_FETI", + "DEFI_PARTITION", + ) ################################################################# - f=open(outfile,'w') + 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") + 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) + traduc(options.infile, options.outfile) + -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/Traducteur/traduitV7V8.py b/Traducteur/traduitV7V8.py index 8294f9ff..8b1ad75d 100644 --- a/Traducteur/traduitV7V8.py +++ b/Traducteur/traduitV7V8.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,500 +20,1023 @@ # """ """ -usage="""usage: %prog [options] +usage = """usage: %prog [options] Typical use is: python traduitV7V8.py --infile=xxxx --outfile=yyyy """ -import argparse # optparse deprecated since Python version 3.2 +import argparse # optparse deprecated since Python version 3.2 import sys import Traducteur.log as log -from load import getJDC +from load import getJDC from mocles import parseKeywords -from removemocle import * -from renamemocle import * -from renamemocle import * -from inseremocle import * +from removemocle import * +from renamemocle import * +from renamemocle import * +from inseremocle import * from changeValeur import * -from movemocle import * -from dictErreurs import genereErreurPourCommande,genereErreurMotCleInFact +from movemocle import * +from dictErreurs import genereErreurPourCommande, genereErreurMotCleInFact import calcG -atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE", - "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G","AFFE_CHAR_MECA", - "AFFE_CHAR_THER_F","IMPR_CO","DEFI_SQUELETTE","DEFI_FONCTION", - "CALC_THETA","AFFE_MODELE","DYNA_NON_LINE","CALC_ELEM", - "CALC_NO","EXTR_MODE","CALC_META","IMPR_RESU","TEST_RESU", - "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT","CALC_CHAM_ELEM", - "AFFE_CHAR_THER", "MACR_LIGN_COUPE","POST_RCCM","PROJ_MESU_MODAL", - "CREA_RESU","CREA_CHAMP","DIST_LIGN_3D","MODI_MAILLAGE","LIRE_TABLE", - "POST_SIMPLIFIE","AFFE_MATERIAU","DEFI_MAILLAGE","DEPL_INTERNE", - "POST_DYNA_ALEA","RECU_FONCTION","DYNA_TRAN_MODAL","DEFI_INTERF_DYNA", - "CALC_PRECONT","DEFI_TEXTURE","TEST_RESU","COMB_CHAM_NO","COMB_CHAM_ELEM", - "CALC_FATIGUE","IMPR_OAR", "AFFE_CHAR_MECA_F", - "MACR_ASCOUF_CALC","MACR_ASPIC_CALC","MACR_CABRI_CALC", - "MACR_ADAP_MAIL","IMPR_FICO_HOMARD","DEFI_PART_FETI" - ) - -dict_erreurs={ -#STA8 - "DIST_LIGN_3D": "la commande DIST_LIGN_3D a ete supprimee", - "DEFI_THER_JOULE": "la commande DIST_LIGN_3D a ete supprimee", - "DIST_LIGN_3D": "la commande DIST_LIGN_3D a ete supprimee", - "AFFE_MODELE_AFFE": "Les modelisations APPUI_REP, ASSE_GRIL et 3D_JOINT_CT ont ete supprimees", - "AFFE_CHAR_MECA_CONTACT_FROTTEMENT": "Suppression d un mot clef FROTTEMENT", - "AFFE_CHAR_MECA_SECH_CALCULEE": "le sechage est maintenant une variable de commande", - "AFFE_CHAR_MECA_HYDR_CALCULEE": "l'hydratation est maintenant une variable de commande", - "AFFE_CHAR_MECA_EPSA_CALCULEE":"EPSA est maintenant une variable de commande", - "AFFE_CHAR_MECA_PRESSION_CALCULEE":"PRESSION_CALCULEE est remplace par EVOL_CHAR", - "MACR_LIGN_COUPE" : "MACR_LIGN_COUPE demande un traitement manuel", - "POST_RCCM" : "POST_RCCM demande un traitement manuel", - "DEFI_MATERIAU_CHABOCHE" : "remplacer la valeur CINx_CHAB", - "DEFI_MATERIAU_POLY_CFC" : "le materiau POLY_CFC est remplace par le comportement POLYCRISTAL", - "DEFI_MATERIAU_ECOU_PLAS1" : "le materiau ECOU_PLAS1 est supprime", - "DEFI_MATERIAU_COMP_THM_ELAS_THM" : "le materiau ELAS_THM a ete supprime", - "DEFI_MATERIAU_COMP_THM_SURF_ETAT_SATU" : "le materiau SURF_ETAT_SATU a ete supprime", - "DEFI_MATERIAU_COMP_THM_SURF_ETAT_NSAT" : "le materiau SURF_ETAT_NSAT a ete supprime", - "DEFI_MATERIAU_COMP_THM_CAM_CLAY_THM" : "le materiau CAM_CLAY_THM a ete supprime", - "DEFI_MATERIAU_COMP_THM_LIQU_SATU_GAT" : "le materiau LIQU_SATU_GAT a ete supprime", - "DEFI_MATERIAU_COMP_THM_LIQU_NSAT_GAT" : "le materiau LIQU_NSAT_GAT a ete supprime", - "DEFI_MATERIAU_GLRC" : "le materiau GLRC a ete remplace par GLRC_DAMAGE", - "DEFI_MATERIAU_GLRC_FO" : "le materiau GLRC_FO a ete remplace par GLRC_DAMAGE", - "DEFI_MATERIAU_OHNO" : "le materiau OHNO a ete remplace par TAHERI", - "DEFI_MATERIAU_OHNO_FO" : "le materiau OHNO a ete remplace par TAHERI", - "CALC_CHAM_ELEM":"reecrire la partie SOUR_ELGA_ELEC", - "CALC_G_THETA_T_OPTION_VALEUR":"verifier la valeur d OPTION", - "CALC_G_THETA_T_OPTION_DEFAUT":"verifier la valeur d OPTION donnee a la place du defaut", - "CALC_G_MODELE":"Mot Clef MODELE supprime sous CALC_G", - "CALC_G_DEPL":"Mot Clef DEPL supprime sous CALC_G", - "CALC_G_CHAM_MATER":"Mot Clef CHAM_MATER supprime sous CALC_G", - "CALC_G_CARA_ELEM":"Mot Clef CARA_ELEM supprime sous CALC_G", - "CALC_G_RESULTAT=XXX,":"Mot Clef RESULTAT a completer sous CALC_G", - "AFFE_MODELE_AFFE_MODELISATION_VALEUR":"verifier la valeur de MODELISATION", - "STAT_NON_LINE_COMP_INCR_RELATION_VALEUR":"verifier la valeur de RELATION", - "STAT_NON_LINE_COMP_INCR_RELATION_KIT_VALEUR":"verifier la valeur de RELATION_KIT", - "STAT_NON_LINE_VARI_COMM":"suppression des variables de commande", - "STAT_NON_LINE_INCREMENT_SUBD_PAS":"Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du STAT_NON_LINE", - "DYNA_NON_LINE_COMP_INCR_RELATION_VALEUR":"verifier la valeur de RELATION", - "DYNA_NON_LINE_COMP_INCR_RELATION_KIT_VALEUR":"verifier la valeur de RELATION_KIT", - "DYNA_NON_LINE_VARI_COMM":"suppression des variables de commande", - "DYNA_NON_LINE_INCREMENT_SUBD_PAS":"Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du DYNA_NON_LINE", - "CALC_PRECONT_SUBD_PAS":"Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du CALC_PRECONT", - "TEST_RESU_UNITE":"suppression du mot clef UNITE dans TEST_RESU", - "POST_SIMPLIFIE":"commande POST_SIMPLIFIE supprimee", - "POST_DYNA_ALEA_GAUSS":"la methode GAUSS a ete supprimee de POST_DYNA_ALEA", - "POST_DYNA_ALEA_VANMARCKE":"la methode VANMARCKE a ete supprimee de POST_DYNA_ALEA", - "POST_DYNA_ALEA_DEPASSEMENT":"la methode DEPASSEMENT a ete supprimee de POST_DYNA_ALEA", - "POST_DYNA_ALEA_RAYLEIGH":"la methode RAYLEIGH a ete supprimee de POST_DYNA_ALEA", - "DYNA_TRAN_MODAL_EXCIT_NUME_MODE":"le numero du mode utilise pour EXCIT DYNA_TRAN_MODAL est le numero d'ORDRE", - "DEFI_INTERF_DYNA_INTERFACE_DDL_ACTIF":"DDL_ACTIF supprime de DEFI_INTERF_DYNA; utiliser MASQUE", - "DEFI_TEXTURE":"le materiau POLY_CFC est remplace par le comportement POLYCRISTAL", - "CREA_RESU_NOM_CHAM_VALEUR":"HYDR_ELGA est remplace par HYDR_ELNO_ELGA et HYDR_NOEU_ELGA", - "COMB_CHAM_NO":"COMB_CHAM_NO est remplace par CREA_CHAMP", - "COMB_CHAM_ELEM":"COMB_CHAM_ELEM est remplace par CREA_CHAMP", - "IMPR_OAR":"IMPR_OAR demande un traitement manuel", - "IMPR_FICO_HOMARD":"IMPR_FICO_HOMARD a ete integre dans MACR_ADPA_MAIL", - } - -sys.dict_erreurs=dict_erreurs - -#atraiter=( "MACR_ADAP_MAIL",) - -def traduc(infile,outfile,flog=None): - - hdlr=log.initialise(flog) - jdc=getJDC(infile,atraiter) - root=jdc.root - - #Parse les mocles des commandes +atraiter = ( + "IMPR_GENE", + "CALC_FONCTION", + "DEFI_MATERIAU", + "STAT_NON_LINE", + "CALC_G_LOCAL_T", + "CALC_G_THETA_T", + "CALC_G", + "AFFE_CHAR_MECA", + "AFFE_CHAR_THER_F", + "IMPR_CO", + "DEFI_SQUELETTE", + "DEFI_FONCTION", + "CALC_THETA", + "AFFE_MODELE", + "DYNA_NON_LINE", + "CALC_ELEM", + "CALC_NO", + "EXTR_MODE", + "CALC_META", + "IMPR_RESU", + "TEST_RESU", + "DEFI_THER_JOULE", + "DYNA_TRAN_EXPLI", + "DEBUT", + "CALC_CHAM_ELEM", + "AFFE_CHAR_THER", + "MACR_LIGN_COUPE", + "POST_RCCM", + "PROJ_MESU_MODAL", + "CREA_RESU", + "CREA_CHAMP", + "DIST_LIGN_3D", + "MODI_MAILLAGE", + "LIRE_TABLE", + "POST_SIMPLIFIE", + "AFFE_MATERIAU", + "DEFI_MAILLAGE", + "DEPL_INTERNE", + "POST_DYNA_ALEA", + "RECU_FONCTION", + "DYNA_TRAN_MODAL", + "DEFI_INTERF_DYNA", + "CALC_PRECONT", + "DEFI_TEXTURE", + "TEST_RESU", + "COMB_CHAM_NO", + "COMB_CHAM_ELEM", + "CALC_FATIGUE", + "IMPR_OAR", + "AFFE_CHAR_MECA_F", + "MACR_ASCOUF_CALC", + "MACR_ASPIC_CALC", + "MACR_CABRI_CALC", + "MACR_ADAP_MAIL", + "IMPR_FICO_HOMARD", + "DEFI_PART_FETI", +) + +dict_erreurs = { + # STA8 + "DIST_LIGN_3D": "la commande DIST_LIGN_3D a ete supprimee", + "DEFI_THER_JOULE": "la commande DIST_LIGN_3D a ete supprimee", + "DIST_LIGN_3D": "la commande DIST_LIGN_3D a ete supprimee", + "AFFE_MODELE_AFFE": "Les modelisations APPUI_REP, ASSE_GRIL et 3D_JOINT_CT ont ete supprimees", + "AFFE_CHAR_MECA_CONTACT_FROTTEMENT": "Suppression d un mot clef FROTTEMENT", + "AFFE_CHAR_MECA_SECH_CALCULEE": "le sechage est maintenant une variable de commande", + "AFFE_CHAR_MECA_HYDR_CALCULEE": "l'hydratation est maintenant une variable de commande", + "AFFE_CHAR_MECA_EPSA_CALCULEE": "EPSA est maintenant une variable de commande", + "AFFE_CHAR_MECA_PRESSION_CALCULEE": "PRESSION_CALCULEE est remplace par EVOL_CHAR", + "MACR_LIGN_COUPE": "MACR_LIGN_COUPE demande un traitement manuel", + "POST_RCCM": "POST_RCCM demande un traitement manuel", + "DEFI_MATERIAU_CHABOCHE": "remplacer la valeur CINx_CHAB", + "DEFI_MATERIAU_POLY_CFC": "le materiau POLY_CFC est remplace par le comportement POLYCRISTAL", + "DEFI_MATERIAU_ECOU_PLAS1": "le materiau ECOU_PLAS1 est supprime", + "DEFI_MATERIAU_COMP_THM_ELAS_THM": "le materiau ELAS_THM a ete supprime", + "DEFI_MATERIAU_COMP_THM_SURF_ETAT_SATU": "le materiau SURF_ETAT_SATU a ete supprime", + "DEFI_MATERIAU_COMP_THM_SURF_ETAT_NSAT": "le materiau SURF_ETAT_NSAT a ete supprime", + "DEFI_MATERIAU_COMP_THM_CAM_CLAY_THM": "le materiau CAM_CLAY_THM a ete supprime", + "DEFI_MATERIAU_COMP_THM_LIQU_SATU_GAT": "le materiau LIQU_SATU_GAT a ete supprime", + "DEFI_MATERIAU_COMP_THM_LIQU_NSAT_GAT": "le materiau LIQU_NSAT_GAT a ete supprime", + "DEFI_MATERIAU_GLRC": "le materiau GLRC a ete remplace par GLRC_DAMAGE", + "DEFI_MATERIAU_GLRC_FO": "le materiau GLRC_FO a ete remplace par GLRC_DAMAGE", + "DEFI_MATERIAU_OHNO": "le materiau OHNO a ete remplace par TAHERI", + "DEFI_MATERIAU_OHNO_FO": "le materiau OHNO a ete remplace par TAHERI", + "CALC_CHAM_ELEM": "reecrire la partie SOUR_ELGA_ELEC", + "CALC_G_THETA_T_OPTION_VALEUR": "verifier la valeur d OPTION", + "CALC_G_THETA_T_OPTION_DEFAUT": "verifier la valeur d OPTION donnee a la place du defaut", + "CALC_G_MODELE": "Mot Clef MODELE supprime sous CALC_G", + "CALC_G_DEPL": "Mot Clef DEPL supprime sous CALC_G", + "CALC_G_CHAM_MATER": "Mot Clef CHAM_MATER supprime sous CALC_G", + "CALC_G_CARA_ELEM": "Mot Clef CARA_ELEM supprime sous CALC_G", + "CALC_G_RESULTAT=XXX,": "Mot Clef RESULTAT a completer sous CALC_G", + "AFFE_MODELE_AFFE_MODELISATION_VALEUR": "verifier la valeur de MODELISATION", + "STAT_NON_LINE_COMP_INCR_RELATION_VALEUR": "verifier la valeur de RELATION", + "STAT_NON_LINE_COMP_INCR_RELATION_KIT_VALEUR": "verifier la valeur de RELATION_KIT", + "STAT_NON_LINE_VARI_COMM": "suppression des variables de commande", + "STAT_NON_LINE_INCREMENT_SUBD_PAS": "Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du STAT_NON_LINE", + "DYNA_NON_LINE_COMP_INCR_RELATION_VALEUR": "verifier la valeur de RELATION", + "DYNA_NON_LINE_COMP_INCR_RELATION_KIT_VALEUR": "verifier la valeur de RELATION_KIT", + "DYNA_NON_LINE_VARI_COMM": "suppression des variables de commande", + "DYNA_NON_LINE_INCREMENT_SUBD_PAS": "Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du DYNA_NON_LINE", + "CALC_PRECONT_SUBD_PAS": "Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du CALC_PRECONT", + "TEST_RESU_UNITE": "suppression du mot clef UNITE dans TEST_RESU", + "POST_SIMPLIFIE": "commande POST_SIMPLIFIE supprimee", + "POST_DYNA_ALEA_GAUSS": "la methode GAUSS a ete supprimee de POST_DYNA_ALEA", + "POST_DYNA_ALEA_VANMARCKE": "la methode VANMARCKE a ete supprimee de POST_DYNA_ALEA", + "POST_DYNA_ALEA_DEPASSEMENT": "la methode DEPASSEMENT a ete supprimee de POST_DYNA_ALEA", + "POST_DYNA_ALEA_RAYLEIGH": "la methode RAYLEIGH a ete supprimee de POST_DYNA_ALEA", + "DYNA_TRAN_MODAL_EXCIT_NUME_MODE": "le numero du mode utilise pour EXCIT DYNA_TRAN_MODAL est le numero d'ORDRE", + "DEFI_INTERF_DYNA_INTERFACE_DDL_ACTIF": "DDL_ACTIF supprime de DEFI_INTERF_DYNA; utiliser MASQUE", + "DEFI_TEXTURE": "le materiau POLY_CFC est remplace par le comportement POLYCRISTAL", + "CREA_RESU_NOM_CHAM_VALEUR": "HYDR_ELGA est remplace par HYDR_ELNO_ELGA et HYDR_NOEU_ELGA", + "COMB_CHAM_NO": "COMB_CHAM_NO est remplace par CREA_CHAMP", + "COMB_CHAM_ELEM": "COMB_CHAM_ELEM est remplace par CREA_CHAMP", + "IMPR_OAR": "IMPR_OAR demande un traitement manuel", + "IMPR_FICO_HOMARD": "IMPR_FICO_HOMARD a ete integre dans MACR_ADPA_MAIL", +} + +sys.dict_erreurs = dict_erreurs + +# atraiter=( "MACR_ADAP_MAIL",) + + +def traduc(infile, outfile, flog=None): + hdlr = log.initialise(flog) + jdc = getJDC(infile, atraiter) + root = jdc.root + + # Parse les mocles des commandes parseKeywords(root) ####################### traitement erreurs ######################## - genereErreurPourCommande(jdc,("DEBUT","POST_RCCM","DIST_LIGN_3D","IMPR_OAR","COMB_CHAM_NO","COMB_CHAM_ELEM")) + genereErreurPourCommande( + jdc, + ( + "DEBUT", + "POST_RCCM", + "DIST_LIGN_3D", + "IMPR_OAR", + "COMB_CHAM_NO", + "COMB_CHAM_ELEM", + ), + ) ####################### traitement CALC_META ####################### - renameMotCleInFact(jdc,"CALC_META","ETAT_INIT","META_INIT","META_INIT_ELNO") + 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"),)) - renameMotCleInFact(jdc,"CALC_FONCTION","LISS_ENVELOP","FONCTION","NAPPE") + removeMotCleSiRegle( + jdc, "CALC_FONCTION", "NOM_PARA", ((("MAX"), "existeMCFParmi"),) + ) + renameCommandeSiRegle( + jdc, + "CALC_FONCTION", + "INFO_FONCTION", + ((("RMS", "MAX", "NOCI_SEISME", "NORME", "ECART-TYPE"), "existeMCFParmi"),), + ) + renameMotCleInFact(jdc, "CALC_FONCTION", "LISS_ENVELOP", "FONCTION", "NAPPE") ####################### traitement IMPR_GENE ####################### - moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","UNITE") - moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","FORMAT") + moveMotCleFromFactToFather(jdc, "IMPR_GENE", "GENE", "UNITE") + moveMotCleFromFactToFather(jdc, "IMPR_GENE", "GENE", "FORMAT") ####################### 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")) - moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS")) - removeMotCleAvecErreur(jdc,"STAT_NON_LINE","VARI_COMM") - moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) - 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")) - removeMotCleAvecErreur(jdc,"DYNA_NON_LINE","VARI_COMM") - - dStatNonLine={"ELAS":"ELAS_THER"} - lavertit=("ELAS") - changementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION_KIT",dStatNonLine,lavertit) - - lavertit=("CHABOCHE","ASSE_COMBU","OHNO","GLRC") - dchaboche={"CHABOCHE":"VMIS_CIN1_CHAB","ASSE_COMBU":"XXX_IRA","OHNO":"VISC_TAHERI","GLRC":"GLRC_DAMAGE"} - changementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit) - changementValeurDsMCFAvecAvertissement(jdc,"DYNA_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit) - - removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","INCREMENT","SUBD_PAS_MINI",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","INCREMENT","COEF_SUBD_PAS_1",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleInFactSiRegleAvecErreur(jdc,"STAT_NON_LINE","INCREMENT","SUBD_PAS",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"STAT_NON_LINE","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),)) - renameMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1") - removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","INCREMENT","SUBD_PAS_MINI",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","INCREMENT","COEF_SUBD_PAS_1",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleInFactSiRegleAvecErreur(jdc,"DYNA_NON_LINE","INCREMENT","SUBD_PAS",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_NON_LINE","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),)) - renameMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1") - - moveMotClefInOperToFact(jdc,"STAT_NON_LINE","PARM_THETA","COMP_INCR") - moveMotClefInOperToFact(jdc,"DYNA_NON_LINE","PARM_THETA","COMP_INCR") - moveMotClefInOperToFact(jdc,"DYNA_TRAN_EXPLI","PARM_THETA","COMP_INCR") + 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") + ) + moveMotCleFromFactToFactMulti( + jdc, "STAT_NON_LINE", "CONVERGENCE", "RESO_INTE", ("COMP_INCR", "COMP_ELAS") + ) + removeMotCleAvecErreur(jdc, "STAT_NON_LINE", "VARI_COMM") + moveMotCleFromFactToFactMulti( + jdc, + "DYNA_NON_LINE", + "CONVERGENCE", + "RESI_INTE_RELA", + ("COMP_INCR", "COMP_ELAS"), + ) + 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") + ) + removeMotCleAvecErreur(jdc, "DYNA_NON_LINE", "VARI_COMM") + + dStatNonLine = {"ELAS": "ELAS_THER"} + lavertit = "ELAS" + changementValeurDsMCFAvecAvertissement( + jdc, "STAT_NON_LINE", "COMP_INCR", "RELATION_KIT", dStatNonLine, lavertit + ) + + lavertit = ("CHABOCHE", "ASSE_COMBU", "OHNO", "GLRC") + dchaboche = { + "CHABOCHE": "VMIS_CIN1_CHAB", + "ASSE_COMBU": "XXX_IRA", + "OHNO": "VISC_TAHERI", + "GLRC": "GLRC_DAMAGE", + } + changementValeurDsMCFAvecAvertissement( + jdc, "STAT_NON_LINE", "COMP_INCR", "RELATION", dchaboche, lavertit + ) + changementValeurDsMCFAvecAvertissement( + jdc, "DYNA_NON_LINE", "COMP_INCR", "RELATION", dchaboche, lavertit + ) + + removeMotCleInFactSiRegle( + jdc, + "STAT_NON_LINE", + "INCREMENT", + "SUBD_PAS_MINI", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleInFactSiRegle( + jdc, + "STAT_NON_LINE", + "INCREMENT", + "COEF_SUBD_PAS_1", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleInFactSiRegleAvecErreur( + jdc, + "STAT_NON_LINE", + "INCREMENT", + "SUBD_PAS", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "STAT_NON_LINE", + "INCREMENT", + "SUBD_METHODE='UNIFORME',", + ((("INCREMENT", "SUBD_PAS"), "existeMCsousMCF"),), + ) + renameMotCleInFact( + jdc, "STAT_NON_LINE", "INCREMENT", "COEF_SUBD_PAS_1", "SUBD_COEF_PAS_1" + ) + removeMotCleInFactSiRegle( + jdc, + "DYNA_NON_LINE", + "INCREMENT", + "SUBD_PAS_MINI", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleInFactSiRegle( + jdc, + "DYNA_NON_LINE", + "INCREMENT", + "COEF_SUBD_PAS_1", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleInFactSiRegleAvecErreur( + jdc, + "DYNA_NON_LINE", + "INCREMENT", + "SUBD_PAS", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_NON_LINE", + "INCREMENT", + "SUBD_METHODE='UNIFORME',", + ((("INCREMENT", "SUBD_PAS"), "existeMCsousMCF"),), + ) + renameMotCleInFact( + jdc, "DYNA_NON_LINE", "INCREMENT", "COEF_SUBD_PAS_1", "SUBD_COEF_PAS_1" + ) + + moveMotClefInOperToFact(jdc, "STAT_NON_LINE", "PARM_THETA", "COMP_INCR") + moveMotClefInOperToFact(jdc, "DYNA_NON_LINE", "PARM_THETA", "COMP_INCR") + moveMotClefInOperToFact(jdc, "DYNA_TRAN_EXPLI", "PARM_THETA", "COMP_INCR") ####################### 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") - renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","OHNO","TAHERI") - renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","OHNO_FO","TAHERI_FO") - renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","GLRC","GLRC_DAMAGE") - renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","GLRC_FO","GLRC_DAMAGE") - - 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") - moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_A",("LEMAITRE_IRRA",)) - 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") - - 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",)) - moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","ALPHA",("ELAS",)) - ajouteMotClefDansFacteurSiRegle(jdc,"DEFI_MATERIAU","ELAS","NU=0.,",((("ELAS","NU"),"nexistepasMCsousMCF"),)) - - removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","POLY_CFC") - removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","ECOU_PLAS1") - - lavertit=("ELAS_THM","SURF_ETAT_SATU","SURF_ETAT_NSAT","CAM_CLAY_THM","LIQU_SATU_GAT","LIQU_NSAT_GAT") - dTHM={"ELAS_THM":"xxx", "SURF_ETAT_SATU":"xxx", "SURF_ETAT_NSAT":"xxx","CAM_CLAY_THM":"xxx","LIQU_SATU_GAT":"xxx","LIQU_NSAT_GAT":"xxx"} - changementValeurAvecAvertissement(jdc,"DEFI_MATERIAU","COMP_THM",dTHM,lavertit) - - dfatigue={"MATAKE":"MATAKE_MODI_AC", "DOMM_MAXI":"MATAKE_MODI_AV", "FATEMI_SOCIE":"FATESOCI_MODI_AV"} - changementValeurDsMCF(jdc,"DEFI_MATERIAU","CISA_PLAN_CRIT","CRITERE",dfatigue) + 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") + renameMotCleAvecErreur(jdc, "DEFI_MATERIAU", "OHNO", "TAHERI") + renameMotCleAvecErreur(jdc, "DEFI_MATERIAU", "OHNO_FO", "TAHERI_FO") + renameMotCleAvecErreur(jdc, "DEFI_MATERIAU", "GLRC", "GLRC_DAMAGE") + renameMotCleAvecErreur(jdc, "DEFI_MATERIAU", "GLRC_FO", "GLRC_DAMAGE") + + 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") + moveMotCleFromFactToFactMulti( + jdc, "DEFI_MATERIAU", "GRAN_IRRA", "GRAN_A", ("LEMAITRE_IRRA",) + ) + 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") + + 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",)) + moveMotCleFromFactToFactMulti(jdc, "DEFI_MATERIAU", "CABLE", "ALPHA", ("ELAS",)) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DEFI_MATERIAU", + "ELAS", + "NU=0.,", + ((("ELAS", "NU"), "nexistepasMCsousMCF"),), + ) + + removeMotCleAvecErreur(jdc, "DEFI_MATERIAU", "POLY_CFC") + removeMotCleAvecErreur(jdc, "DEFI_MATERIAU", "ECOU_PLAS1") + + lavertit = ( + "ELAS_THM", + "SURF_ETAT_SATU", + "SURF_ETAT_NSAT", + "CAM_CLAY_THM", + "LIQU_SATU_GAT", + "LIQU_NSAT_GAT", + ) + dTHM = { + "ELAS_THM": "xxx", + "SURF_ETAT_SATU": "xxx", + "SURF_ETAT_NSAT": "xxx", + "CAM_CLAY_THM": "xxx", + "LIQU_SATU_GAT": "xxx", + "LIQU_NSAT_GAT": "xxx", + } + changementValeurAvecAvertissement(jdc, "DEFI_MATERIAU", "COMP_THM", dTHM, lavertit) + + dfatigue = { + "MATAKE": "MATAKE_MODI_AC", + "DOMM_MAXI": "MATAKE_MODI_AV", + "FATEMI_SOCIE": "FATESOCI_MODI_AV", + } + changementValeurDsMCF(jdc, "DEFI_MATERIAU", "CISA_PLAN_CRIT", "CRITERE", dfatigue) ####################### traitement IMPR_CO ####################### - chercheOperInsereFacteurSiRegle(jdc,"IMPR_CO","CONCEPT",((("CO",),"existe"),)) - moveMotClefInOperToFact(jdc,"IMPR_CO","CO","CONCEPT") - renameMotCleInFact(jdc,"IMPR_CO","CONCEPT","CO","NOM") + 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") + 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_MECA","SECH_CALCULEE") - removeMotCle(jdc,"AFFE_CHAR_MECA","HYDR_CALCULEE") - removeMotCle(jdc,"AFFE_CHAR_MECA","PRESSION_CALCULEE") - removeMotCleAvecErreur(jdc,"AFFE_CHAR_MECA","EPSA_CALCULEE") - removeMotCle(jdc,"AFFE_CHAR_THER_F","VERI_DDL") - removeMotCle(jdc,"AFFE_CHAR_THER","VERI_DDL") + removeMotCle(jdc, "AFFE_CHAR_MECA", "VERI_DDL") + removeMotCle(jdc, "AFFE_CHAR_MECA", "SECH_CALCULEE") + removeMotCle(jdc, "AFFE_CHAR_MECA", "HYDR_CALCULEE") + removeMotCle(jdc, "AFFE_CHAR_MECA", "PRESSION_CALCULEE") + removeMotCleAvecErreur(jdc, "AFFE_CHAR_MECA", "EPSA_CALCULEE") + removeMotCle(jdc, "AFFE_CHAR_THER_F", "VERI_DDL") + removeMotCle(jdc, "AFFE_CHAR_THER", "VERI_DDL") ####################### traitement AFFE_CHAR_MECA (CONTACT) ####################### - renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","COEF_MULT_ESCL","COEF_MULT") - renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","NOM_CHAM","NOM_CMP") - renameMotCleInFactSiRegle(jdc,"AFFE_CHAR_MECA","CONTACT","GROUP_MA_ESCL","GROUP_MA",((("CONTACT","NOM_CMP"),"existeMCsousMCF"),)) - renameMotCleSiRegle(jdc,"AFFE_CHAR_MECA","CONTACT","LIAISON_UNILATER",((("CONTACT","NOM_CMP"),"existeMCsousMCF"),)) - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","LIAISON_UNILATER","APPARIEMENT") + renameMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "COEF_MULT_ESCL", "COEF_MULT") + renameMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "NOM_CHAM", "NOM_CMP") + renameMotCleInFactSiRegle( + jdc, + "AFFE_CHAR_MECA", + "CONTACT", + "GROUP_MA_ESCL", + "GROUP_MA", + ((("CONTACT", "NOM_CMP"), "existeMCsousMCF"),), + ) + renameMotCleSiRegle( + jdc, + "AFFE_CHAR_MECA", + "CONTACT", + "LIAISON_UNILATER", + ((("CONTACT", "NOM_CMP"), "existeMCsousMCF"),), + ) + removeMotCleInFact(jdc, "AFFE_CHAR_MECA", "LIAISON_UNILATER", "APPARIEMENT") ####################### traitement AFFE_CHAR_MECA_F (CONTACT) ####################### - renameMotCleInFact(jdc,"AFFE_CHAR_MECA_F","CONTACT","COEF_MULT_ESCL","COEF_MULT") - renameMotCleInFact(jdc,"AFFE_CHAR_MECA_F","CONTACT","NOM_CHAM","NOM_CMP") - renameMotCleInFactSiRegle(jdc,"AFFE_CHAR_MECA_F","CONTACT","GROUP_MA_ESCL","GROUP_MA",((("CONTACT","NOM_CMP"),"existeMCsousMCF"),)) - renameMotCleSiRegle(jdc,"AFFE_CHAR_MECA_F","CONTACT","LIAISON_UNILATER",((("CONTACT","NOM_CMP"),"existeMCsousMCF"),)) - removeMotCleInFact(jdc,"AFFE_CHAR_MECA_F","LIAISON_UNILATER","APPARIEMENT") + renameMotCleInFact( + jdc, "AFFE_CHAR_MECA_F", "CONTACT", "COEF_MULT_ESCL", "COEF_MULT" + ) + renameMotCleInFact(jdc, "AFFE_CHAR_MECA_F", "CONTACT", "NOM_CHAM", "NOM_CMP") + renameMotCleInFactSiRegle( + jdc, + "AFFE_CHAR_MECA_F", + "CONTACT", + "GROUP_MA_ESCL", + "GROUP_MA", + ((("CONTACT", "NOM_CMP"), "existeMCsousMCF"),), + ) + renameMotCleSiRegle( + jdc, + "AFFE_CHAR_MECA_F", + "CONTACT", + "LIAISON_UNILATER", + ((("CONTACT", "NOM_CMP"), "existeMCsousMCF"),), + ) + removeMotCleInFact(jdc, "AFFE_CHAR_MECA_F", "LIAISON_UNILATER", "APPARIEMENT") ####################### traitement CALC_G ####################### - chercheOperInsereFacteurSiRegle(jdc,"CALC_G_LOCAL_T","LISSAGE",((("LISSAGE_G","LISSAGE_THETA","DEGRE"),"existeMCFParmi"),)) - moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_THETA","LISSAGE") - moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_G","LISSAGE") - moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","DEGRE","LISSAGE") - - dlocal={"CALC_G_LGLO":"G_LAGR", "G_BILINEAIRE":"G_BILI", "CALC_G_MAX":"G_MAX"} - changementValeur(jdc,"CALC_G_LOCAL_T","OPTION",dlocal) + chercheOperInsereFacteurSiRegle( + jdc, + "CALC_G_LOCAL_T", + "LISSAGE", + ((("LISSAGE_G", "LISSAGE_THETA", "DEGRE"), "existeMCFParmi"),), + ) + moveMotClefInOperToFact(jdc, "CALC_G_LOCAL_T", "LISSAGE_THETA", "LISSAGE") + moveMotClefInOperToFact(jdc, "CALC_G_LOCAL_T", "LISSAGE_G", "LISSAGE") + moveMotClefInOperToFact(jdc, "CALC_G_LOCAL_T", "DEGRE", "LISSAGE") + + 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"} + 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") - changementValeurAvecAvertissement(jdc,"CALC_G_THETA_T","OPTION",dtheta,lavertit) - renameOper(jdc,"CALC_G_LOCAL_T","CALC_G") - renameOper(jdc,"CALC_G_THETA_T","CALC_G") + lavertit = ("CALC_G_LAGR", "CALC_G", "defaut") + changementValeurAvecAvertissement(jdc, "CALC_G_THETA_T", "OPTION", dtheta, lavertit) + renameOper(jdc, "CALC_G_LOCAL_T", "CALC_G") + renameOper(jdc, "CALC_G_THETA_T", "CALC_G") # Attention cela necessite un traitement particulier et ne peut pas etre generalise tel quel # Attention egalement doit etre fait avant le regroupement dans THETA calcG.traitementRayon(jdc) - renameMotCle(jdc,"CALC_G","THETA","THETA_OLD") - chercheOperInsereFacteur(jdc,"CALC_G","THETA") - moveMotClefInOperToFact(jdc,"CALC_G","THETA_OLD","THETA") - renameMotCleInFact(jdc,"CALC_G","THETA","THETA_OLD","THETA") - - moveMotClefInOperToFact(jdc,"CALC_G","FOND_FISS","THETA") - moveMotClefInOperToFact(jdc,"CALC_G","R_INF_FO","THETA") - moveMotClefInOperToFact(jdc,"CALC_G","R_SUP_FO","THETA") - moveMotClefInOperToFact(jdc,"CALC_G","R_INF","THETA") - moveMotClefInOperToFact(jdc,"CALC_G","R_SUP","THETA") - moveMotClefInOperToFact(jdc,"CALC_G","FISSURE","THETA") - renameMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA","THETA_LAGR",((("THETA","R_INF"),"existeMCsousMCF"),)) - renameMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA","THETA_LAGR",((("THETA","R_SUP"),"existeMCsousMCF"),)) - moveMotCleFromFactToFather(jdc,"CALC_G","THETA","THETA_LAGR") - removeMotCleAvecErreur(jdc,"CALC_G","MODELE") - removeMotCleAvecErreur(jdc,"CALC_G","DEPL") - removeMotCleAvecErreur(jdc,"CALC_G","CHAM_MATER") - removeMotCleAvecErreur(jdc,"CALC_G","CARA_ELEM") - chercheOperInsereFacteurSiRegleAvecAvertissement(jdc,"CALC_G","RESULTAT=XXX,",((("THETA_LAGR",),"existeMCFParmi"),),0) + renameMotCle(jdc, "CALC_G", "THETA", "THETA_OLD") + chercheOperInsereFacteur(jdc, "CALC_G", "THETA") + moveMotClefInOperToFact(jdc, "CALC_G", "THETA_OLD", "THETA") + renameMotCleInFact(jdc, "CALC_G", "THETA", "THETA_OLD", "THETA") + + moveMotClefInOperToFact(jdc, "CALC_G", "FOND_FISS", "THETA") + moveMotClefInOperToFact(jdc, "CALC_G", "R_INF_FO", "THETA") + moveMotClefInOperToFact(jdc, "CALC_G", "R_SUP_FO", "THETA") + moveMotClefInOperToFact(jdc, "CALC_G", "R_INF", "THETA") + moveMotClefInOperToFact(jdc, "CALC_G", "R_SUP", "THETA") + moveMotClefInOperToFact(jdc, "CALC_G", "FISSURE", "THETA") + renameMotCleInFactSiRegle( + jdc, + "CALC_G", + "THETA", + "THETA", + "THETA_LAGR", + ((("THETA", "R_INF"), "existeMCsousMCF"),), + ) + renameMotCleInFactSiRegle( + jdc, + "CALC_G", + "THETA", + "THETA", + "THETA_LAGR", + ((("THETA", "R_SUP"), "existeMCsousMCF"),), + ) + moveMotCleFromFactToFather(jdc, "CALC_G", "THETA", "THETA_LAGR") + removeMotCleAvecErreur(jdc, "CALC_G", "MODELE") + removeMotCleAvecErreur(jdc, "CALC_G", "DEPL") + removeMotCleAvecErreur(jdc, "CALC_G", "CHAM_MATER") + removeMotCleAvecErreur(jdc, "CALC_G", "CARA_ELEM") + chercheOperInsereFacteurSiRegleAvecAvertissement( + jdc, "CALC_G", "RESULTAT=XXX,", ((("THETA_LAGR",), "existeMCFParmi"),), 0 + ) ####################### traitement AFFE_MODELE ####################### - daffeModele={"PLAN_FISSURE":"PLAN_JOINT", "AXIS_FISSURE":"AXIS_JOINT"} - changementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",daffeModele) - removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","APPUI_REP",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","ASSE_GRIL",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","3D_JOINT_CT",jdc),"MCsousMCFaPourValeur"),)) - renameMotCleInFact(jdc,"AFFE_MODELE","AFFE_SOUS_STRUC","MAILLE","SUPER_MAILLE") + daffeModele = {"PLAN_FISSURE": "PLAN_JOINT", "AXIS_FISSURE": "AXIS_JOINT"} + changementValeurDsMCF(jdc, "AFFE_MODELE", "AFFE", "MODELISATION", daffeModele) + removeMotCleSiRegleAvecErreur( + jdc, + "AFFE_MODELE", + "AFFE", + ((("AFFE", "MODELISATION", "APPUI_REP", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleSiRegleAvecErreur( + jdc, + "AFFE_MODELE", + "AFFE", + ((("AFFE", "MODELISATION", "ASSE_GRIL", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleSiRegleAvecErreur( + jdc, + "AFFE_MODELE", + "AFFE", + ((("AFFE", "MODELISATION", "3D_JOINT_CT", jdc), "MCsousMCFaPourValeur"),), + ) + renameMotCleInFact(jdc, "AFFE_MODELE", "AFFE_SOUS_STRUC", "MAILLE", "SUPER_MAILLE") ####################### 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"),)) + removeMotCleInFact(jdc, "PROJ_MESU_MODAL", "MODELE_MESURE", "NOM_PARA") + removeMotCleInFactSiRegleAvecErreur( + jdc, + "AFFE_CHAR_MECA", + "CONTACT", + "FROTTEMENT", + ((("CONTACT", "METHODE", "CONTRAINTE", jdc), "MCsousMCFaPourValeur"),), + ) ####################### 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","EPGR_ELNO":"EPFP_ELNO","EPGR_ELGA":"EPFP_ELGA","DURT_ELGA_TEMP":"DURT_ELNO_TEMP"} - 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") - - chercheOperInsereFacteurSiRegle(jdc,"CALC_ELEM","REPE_COQUE",((("NUME_COUCHE","NIVE_COUCHE","ANGLE","PLAN"),"existeMCFParmi"),)) - moveMotClefInOperToFact(jdc,"CALC_ELEM","NIVE_COUCHE","REPE_COQUE") - moveMotClefInOperToFact(jdc,"CALC_ELEM","NUME_COUCHE","REPE_COQUE") - moveMotClefInOperToFact(jdc,"CALC_ELEM","ANGLE","REPE_COQUE") - moveMotClefInOperToFact(jdc,"CALC_ELEM","PLAN","REPE_COQUE") - + 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", + "EPGR_ELNO": "EPFP_ELNO", + "EPGR_ELGA": "EPFP_ELGA", + "DURT_ELGA_TEMP": "DURT_ELNO_TEMP", + } + 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") + + chercheOperInsereFacteurSiRegle( + jdc, + "CALC_ELEM", + "REPE_COQUE", + ((("NUME_COUCHE", "NIVE_COUCHE", "ANGLE", "PLAN"), "existeMCFParmi"),), + ) + moveMotClefInOperToFact(jdc, "CALC_ELEM", "NIVE_COUCHE", "REPE_COQUE") + moveMotClefInOperToFact(jdc, "CALC_ELEM", "NUME_COUCHE", "REPE_COQUE") + moveMotClefInOperToFact(jdc, "CALC_ELEM", "ANGLE", "REPE_COQUE") + moveMotClefInOperToFact(jdc, "CALC_ELEM", "PLAN", "REPE_COQUE") ####################### traitement EXTR_MODE ####################### - ajouteMotClefDansFacteurSiRegle(jdc,"EXTR_MODE","FILTRE_MODE","SEUIL=1.E-3", ((("FILTRE_MODE","CRIT_EXTR",),"existeMCsousMCF"),(("FILTRE_MODE","SEUIL",),"nexistepasMCsousMCF"))) + ajouteMotClefDansFacteurSiRegle( + jdc, + "EXTR_MODE", + "FILTRE_MODE", + "SEUIL=1.E-3", + ( + ( + ( + "FILTRE_MODE", + "CRIT_EXTR", + ), + "existeMCsousMCF", + ), + ( + ( + "FILTRE_MODE", + "SEUIL", + ), + "nexistepasMCsousMCF", + ), + ), + ) ####################### traitement DYNA_TRAN_EXPLI ####################### - removeMotCle(jdc,"DYNA_TRAN_EXPLI","NEWMARK") - removeMotCle(jdc,"DYNA_TRAN_EXPLI","HHT") - chercheOperInsereFacteur(jdc,"DYNA_TRAN_EXPLI","DIFF_CENT") + removeMotCle(jdc, "DYNA_TRAN_EXPLI", "NEWMARK") + removeMotCle(jdc, "DYNA_TRAN_EXPLI", "HHT") + 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) + dcrearesu = {"HYDR_ELGA": "HYDR_NOEU_ELGA"} + lavertit = ("HYDR_ELGA",) + changementValeur(jdc, "CREA_RESU", "NOM_CHAM", dcrearesu, lavertit) ####################### traitement CREA_CHAMP ####################### - dcrearesu={"HYDR_ELGA":"HYDR_ELNO_ELGA"} - lavertit=("HYDR_ELGA",) - changementValeur(jdc,"CREA_CHAMP","NOM_CHAM",dcrearesu,lavertit) - changementValeur(jdc,"CREA_CHAMP","TYPE_CHAM",dcrearesu,lavertit) + dcrearesu = {"HYDR_ELGA": "HYDR_ELNO_ELGA"} + lavertit = ("HYDR_ELGA",) + changementValeur(jdc, "CREA_CHAMP", "NOM_CHAM", dcrearesu, lavertit) + changementValeur(jdc, "CREA_CHAMP", "TYPE_CHAM", dcrearesu, lavertit) ####################### traitement TEST_RESU ####################### - dcrearesu={"HYDR_ELGA":"HYDR_NOEU_ELGA"} - lavertit=("HYDR_ELGA",) - changementValeurDsMCFAvecAvertissement(jdc,"TEST_RESU","RESU","NOM_CHAM",dcrearesu,lavertit) + dcrearesu = {"HYDR_ELGA": "HYDR_NOEU_ELGA"} + lavertit = ("HYDR_ELGA",) + changementValeurDsMCFAvecAvertissement( + jdc, "TEST_RESU", "RESU", "NOM_CHAM", dcrearesu, lavertit + ) ####################### traitement DEBUT ####################### - removeMotCleSiRegle(jdc,"DEBUT","BASE",((("BASE","FICHIER","LOCALE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleSiRegle( + jdc, + "DEBUT", + "BASE", + ((("BASE", "FICHIER", "LOCALE", jdc), "MCsousMCFaPourValeur"),), + ) ####################### traitement DEFI_THER_JOULE ####################### - removeCommande(jdc,"DEFI_THER_JOULE") + removeCommande(jdc, "DEFI_THER_JOULE") ####################### traitement CALC_CHAM_ELEM ####################### - removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),)) + removeCommandeSiRegleAvecErreur( + jdc, "CALC_CHAM_ELEM", ((("OPTION", "SOUR_ELGA_ELEC", jdc), "MCaPourValeur"),) + ) ####################### traitement MACR_LIGNE_COUPE ####################### - appelleMacroSelonValeurConcept(jdc,"MACR_LIGN_COUPE",("LIGN_COUPE","TABLE")) - removeMotCleInFact(jdc,"MACR_LIGN_COUPE","LIGN_COUPE","TABLE") + appelleMacroSelonValeurConcept(jdc, "MACR_LIGN_COUPE", ("LIGN_COUPE", "TABLE")) + removeMotCleInFact(jdc, "MACR_LIGN_COUPE", "LIGN_COUPE", "TABLE") ####################### traitement MODI_MAILLAGE ####################### - removeMotCle(jdc,"MODI_MAILLAGE","MODELE") + removeMotCle(jdc, "MODI_MAILLAGE", "MODELE") ####################### traitement LIRE_TABLE ####################### - removeMotCle(jdc,"LIRE_TABLE","TYPE_TABLE") + removeMotCle(jdc, "LIRE_TABLE", "TYPE_TABLE") ####################### traitement POST_SIMPLIFIE ####################### - removeCommande(jdc,"POST_SIMPLIFIE") + removeCommande(jdc, "POST_SIMPLIFIE") ####################### traitement AFFE_MATERIAU ####################### - removeMotCleInFact(jdc,"AFFE_MATERIAU","AFFE","SECH_REF") + removeMotCleInFact(jdc, "AFFE_MATERIAU", "AFFE", "SECH_REF") ####################### traitement DEFI_MAILLAGE ####################### - renameMotCleInFact(jdc,"DEFI_MAILLAGE","DEFI_MAILLE","MAILLE","SUPER_MAILLE") - renameMotCle(jdc,"DEFI_MAILLAGE","DEFI_MAILLE","DEFI_SUPER_MAILLE") - renameMotCleInFact(jdc,"DEFI_MAILLAGE","RECO_GLOBAL","MAILLE","SUPER_MAILLE") - renameMotCleInFact(jdc,"DEFI_MAILLAGE","RECO_MAILLE","MAILLE","SUPER_MAILLE") - renameMotCle(jdc,"DEFI_MAILLAGE","RECO_MAILLE","RECO_SUPER_MAILLE") - renameMotCleInFact(jdc,"DEFI_MAILLAGE","DEFI_NOEUD","MAILLE","SUPER_MAILLE") - renameMotCleInFact(jdc,"DEFI_MAILLAGE","DEFI_GROUP_NO","MAILLE","SUPER_MAILLE") + renameMotCleInFact(jdc, "DEFI_MAILLAGE", "DEFI_MAILLE", "MAILLE", "SUPER_MAILLE") + renameMotCle(jdc, "DEFI_MAILLAGE", "DEFI_MAILLE", "DEFI_SUPER_MAILLE") + renameMotCleInFact(jdc, "DEFI_MAILLAGE", "RECO_GLOBAL", "MAILLE", "SUPER_MAILLE") + renameMotCleInFact(jdc, "DEFI_MAILLAGE", "RECO_MAILLE", "MAILLE", "SUPER_MAILLE") + renameMotCle(jdc, "DEFI_MAILLAGE", "RECO_MAILLE", "RECO_SUPER_MAILLE") + renameMotCleInFact(jdc, "DEFI_MAILLAGE", "DEFI_NOEUD", "MAILLE", "SUPER_MAILLE") + renameMotCleInFact(jdc, "DEFI_MAILLAGE", "DEFI_GROUP_NO", "MAILLE", "SUPER_MAILLE") ####################### traitement DEPL_INTERNE ####################### - renameMotCle(jdc,"DEPL_INTERNE","MAILLE","SUPER_MAILLE") - + renameMotCle(jdc, "DEPL_INTERNE", "MAILLE", "SUPER_MAILLE") ####################### traitement POST_DYNA_ALEA ####################### - removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","GAUSS") - removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","RAYLEIGH") - removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","DEPASSEMENT") - removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","VANMARCKE") + removeMotCleAvecErreur(jdc, "POST_DYNA_ALEA", "GAUSS") + removeMotCleAvecErreur(jdc, "POST_DYNA_ALEA", "RAYLEIGH") + removeMotCleAvecErreur(jdc, "POST_DYNA_ALEA", "DEPASSEMENT") + removeMotCleAvecErreur(jdc, "POST_DYNA_ALEA", "VANMARCKE") ####################### traitement RECU_FONCTION ####################### -# il faut aussi ajouter la regle suivante : -# s'il existe TYPE_RESU='FONCTION_C', renommer NOM_PARA_TABL='FONCTION_C' - removeMotCleSiRegle(jdc,"RECU_FONCTION","NOM_PARA_TABL",((("TYPE_RESU","FONCTION_C",jdc),"MCaPourValeur"),)) - chercheOperInsereFacteurSiRegle(jdc,"RECU_FONCTION","NOM_PARA_TABL='FONCTION_C',",((("TYPE_RESU","FONCTION_C",jdc),"MCaPourValeur"),),estunFacteur=0) - removeMotCle(jdc,"RECU_FONCTION","TYPE_RESU") - chercheOperInsereFacteurSiRegle(jdc,"RECU_FONCTION","NOM_PARA_TABL='FONCTION',",((("OBSTACLE",),"existe"),),estunFacteur=0) - chercheOperInsereFacteurSiRegle(jdc,"RECU_FONCTION","FILTRE",((("OBSTACLE",),"existe"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"RECU_FONCTION","FILTRE","NOM_PARA='LIEU',",((("OBSTACLE",),"existe"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"RECU_FONCTION","FILTRE","VALE_K='DEFIOBST',",((("OBSTACLE",),"existe"),)) - renameMotCle(jdc,"RECU_FONCTION","OBSTACLE","TABLE") + # il faut aussi ajouter la regle suivante : + # s'il existe TYPE_RESU='FONCTION_C', renommer NOM_PARA_TABL='FONCTION_C' + removeMotCleSiRegle( + jdc, + "RECU_FONCTION", + "NOM_PARA_TABL", + ((("TYPE_RESU", "FONCTION_C", jdc), "MCaPourValeur"),), + ) + chercheOperInsereFacteurSiRegle( + jdc, + "RECU_FONCTION", + "NOM_PARA_TABL='FONCTION_C',", + ((("TYPE_RESU", "FONCTION_C", jdc), "MCaPourValeur"),), + estunFacteur=0, + ) + removeMotCle(jdc, "RECU_FONCTION", "TYPE_RESU") + chercheOperInsereFacteurSiRegle( + jdc, + "RECU_FONCTION", + "NOM_PARA_TABL='FONCTION',", + ((("OBSTACLE",), "existe"),), + estunFacteur=0, + ) + chercheOperInsereFacteurSiRegle( + jdc, "RECU_FONCTION", "FILTRE", ((("OBSTACLE",), "existe"),) + ) + ajouteMotClefDansFacteurSiRegle( + jdc, "RECU_FONCTION", "FILTRE", "NOM_PARA='LIEU',", ((("OBSTACLE",), "existe"),) + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "RECU_FONCTION", + "FILTRE", + "VALE_K='DEFIOBST',", + ((("OBSTACLE",), "existe"),), + ) + renameMotCle(jdc, "RECU_FONCTION", "OBSTACLE", "TABLE") ####################### traitement DYNA_TRAN_MODAL ####################### - renameMotCleInFact(jdc,"DYNA_TRAN_MODAL","EXCIT","NUME_MODE","NUME_ORDRE",erreur=1) + renameMotCleInFact( + jdc, "DYNA_TRAN_MODAL", "EXCIT", "NUME_MODE", "NUME_ORDRE", erreur=1 + ) ####################### traitement DEFI_INTERF_DYNA ####################### - removeMotCleInFact(jdc,"DEFI_INTERF_DYNA","INTERFACE","DDL_ACTIF",erreur=1) - + removeMotCleInFact(jdc, "DEFI_INTERF_DYNA", "INTERFACE", "DDL_ACTIF", erreur=1) ####################### traitement CALC_PRECONT ####################### - removeMotCleInFactSiRegle(jdc,"CALC_PRECONT","INCREMENT","SUBD_PAS_MINI",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleInFactSiRegle(jdc,"CALC_PRECONT","INCREMENT","COEF_SUBD_PAS_1",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleInFactSiRegleAvecErreur(jdc,"CALC_PRECONT","INCREMENT","SUBD_PAS",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"CALC_PRECONT","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),)) - moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS")) - renameMotCleInFact(jdc,"CALC_PRECONT","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1") - + removeMotCleInFactSiRegle( + jdc, + "CALC_PRECONT", + "INCREMENT", + "SUBD_PAS_MINI", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleInFactSiRegle( + jdc, + "CALC_PRECONT", + "INCREMENT", + "COEF_SUBD_PAS_1", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleInFactSiRegleAvecErreur( + jdc, + "CALC_PRECONT", + "INCREMENT", + "SUBD_PAS", + ((("INCREMENT", "SUBD_PAS", "1", jdc), "MCsousMCFaPourValeur"),), + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "CALC_PRECONT", + "INCREMENT", + "SUBD_METHODE='UNIFORME',", + ((("INCREMENT", "SUBD_PAS"), "existeMCsousMCF"),), + ) + moveMotCleFromFactToFactMulti( + jdc, "CALC_PRECONT", "CONVERGENCE", "RESI_INTE_RELA", ("COMP_INCR", "COMP_ELAS") + ) + moveMotCleFromFactToFactMulti( + jdc, "CALC_PRECONT", "CONVERGENCE", "ITER_INTE_MAXI", ("COMP_INCR", "COMP_ELAS") + ) + moveMotCleFromFactToFactMulti( + jdc, "CALC_PRECONT", "CONVERGENCE", "ITER_INTE_PAS", ("COMP_INCR", "COMP_ELAS") + ) + moveMotCleFromFactToFactMulti( + jdc, "CALC_PRECONT", "CONVERGENCE", "RESO_INTE", ("COMP_INCR", "COMP_ELAS") + ) + renameMotCleInFact( + jdc, "CALC_PRECONT", "INCREMENT", "COEF_SUBD_PAS_1", "SUBD_COEF_PAS_1" + ) ####################### traitement DEFI_TEXTURE ####################### - removeCommande(jdc,"DEFI_TEXTURE") - + removeCommande(jdc, "DEFI_TEXTURE") ####################### traitement COMB_CHAM_NO ####################### - renameMotCleInFact(jdc,"COMB_CHAM_NO","COMB_C","CHAM_NO","CHAM_GD") - chercheOperInsereFacteur(jdc,"COMB_CHAM_NO","TYPE_CHAM='xxx',",estunFacteur=0,erreur=1) - chercheOperInsereFacteur(jdc,"COMB_CHAM_NO","MODELE=xxx,",estunFacteur=0,erreur=1) - chercheOperInsereFacteur(jdc,"COMB_CHAM_NO","OPERATION='ASSE',",estunFacteur=0,erreur=1) - renameMotCle(jdc,"COMB_CHAM_NO","COMB_C","ASSE") - ajouteMotClefDansFacteur(jdc,"COMB_CHAM_NO","ASSE","CUMUL='NON',") - ajouteMotClefDansFacteur(jdc,"COMB_CHAM_NO","ASSE","TOUT='OUI',") - renameOper(jdc,"COMB_CHAM_NO","CREA_CHAMP") - + renameMotCleInFact(jdc, "COMB_CHAM_NO", "COMB_C", "CHAM_NO", "CHAM_GD") + chercheOperInsereFacteur( + jdc, "COMB_CHAM_NO", "TYPE_CHAM='xxx',", estunFacteur=0, erreur=1 + ) + chercheOperInsereFacteur( + jdc, "COMB_CHAM_NO", "MODELE=xxx,", estunFacteur=0, erreur=1 + ) + chercheOperInsereFacteur( + jdc, "COMB_CHAM_NO", "OPERATION='ASSE',", estunFacteur=0, erreur=1 + ) + renameMotCle(jdc, "COMB_CHAM_NO", "COMB_C", "ASSE") + ajouteMotClefDansFacteur(jdc, "COMB_CHAM_NO", "ASSE", "CUMUL='NON',") + ajouteMotClefDansFacteur(jdc, "COMB_CHAM_NO", "ASSE", "TOUT='OUI',") + renameOper(jdc, "COMB_CHAM_NO", "CREA_CHAMP") ####################### traitement MACR_ASCOUF_CALC ####################### - ajouteMotClefDansFacteurSiRegle(jdc,"MACR_ASCOUF_CALC","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),)) - renameMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1") - moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS")) - + ajouteMotClefDansFacteurSiRegle( + jdc, + "MACR_ASCOUF_CALC", + "INCREMENT", + "SUBD_METHODE='UNIFORME',", + ((("INCREMENT", "SUBD_PAS"), "existeMCsousMCF"),), + ) + renameMotCleInFact( + jdc, "MACR_ASCOUF_CALC", "INCREMENT", "COEF_SUBD_PAS_1", "SUBD_COEF_PAS_1" + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_ASCOUF_CALC", + "CONVERGENCE", + "RESI_INTE_RELA", + ("COMP_INCR", "COMP_ELAS"), + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_ASCOUF_CALC", + "CONVERGENCE", + "ITER_INTE_MAXI", + ("COMP_INCR", "COMP_ELAS"), + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_ASCOUF_CALC", + "CONVERGENCE", + "ITER_INTE_PAS", + ("COMP_INCR", "COMP_ELAS"), + ) + moveMotCleFromFactToFactMulti( + jdc, "MACR_ASCOUF_CALC", "CONVERGENCE", "RESO_INTE", ("COMP_INCR", "COMP_ELAS") + ) ####################### traitement MACR_ASPIC_CALC ####################### - ajouteMotClefDansFacteurSiRegle(jdc,"MACR_ASPIC_CALC","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),)) - renameMotCleInFact(jdc,"MACR_ASPIC_CALC","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1") - moveMotCleFromFactToFactMulti(jdc,"MACR_ASPIC_CALC","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"MACR_ASPIC_CALC","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"MACR_ASPIC_CALC","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS")) - + ajouteMotClefDansFacteurSiRegle( + jdc, + "MACR_ASPIC_CALC", + "INCREMENT", + "SUBD_METHODE='UNIFORME',", + ((("INCREMENT", "SUBD_PAS"), "existeMCsousMCF"),), + ) + renameMotCleInFact( + jdc, "MACR_ASPIC_CALC", "INCREMENT", "COEF_SUBD_PAS_1", "SUBD_COEF_PAS_1" + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_ASPIC_CALC", + "CONVERGENCE", + "RESI_INTE_RELA", + ("COMP_INCR", "COMP_ELAS"), + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_ASPIC_CALC", + "CONVERGENCE", + "ITER_INTE_MAXI", + ("COMP_INCR", "COMP_ELAS"), + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_ASPIC_CALC", + "CONVERGENCE", + "ITER_INTE_PAS", + ("COMP_INCR", "COMP_ELAS"), + ) ####################### traitement MACR_CABRI_CALC ####################### - ajouteMotClefDansFacteurSiRegle(jdc,"MACR_CABRI_CALC","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),)) - renameMotCleInFact(jdc,"MACR_CABRI_CALC","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1") - moveMotCleFromFactToFactMulti(jdc,"MACR_CABRI_CALC","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"MACR_CABRI_CALC","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS")) - moveMotCleFromFactToFactMulti(jdc,"MACR_CABRI_CALC","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS")) - + ajouteMotClefDansFacteurSiRegle( + jdc, + "MACR_CABRI_CALC", + "INCREMENT", + "SUBD_METHODE='UNIFORME',", + ((("INCREMENT", "SUBD_PAS"), "existeMCsousMCF"),), + ) + renameMotCleInFact( + jdc, "MACR_CABRI_CALC", "INCREMENT", "COEF_SUBD_PAS_1", "SUBD_COEF_PAS_1" + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_CABRI_CALC", + "CONVERGENCE", + "RESI_INTE_RELA", + ("COMP_INCR", "COMP_ELAS"), + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_CABRI_CALC", + "CONVERGENCE", + "ITER_INTE_MAXI", + ("COMP_INCR", "COMP_ELAS"), + ) + moveMotCleFromFactToFactMulti( + jdc, + "MACR_CABRI_CALC", + "CONVERGENCE", + "ITER_INTE_PAS", + ("COMP_INCR", "COMP_ELAS"), + ) ####################### traitement CALC_FATIGUE ####################### - dfatigue={"MATAKE":"MATAKE_MODI_AC", "DOMM_MAXI":"MATAKE_MODI_AV", "FATEMI_SOCIE":"FATESOCI_MODI_AV"} - changementValeur(jdc,"CALC_FATIGUE","CRITERE",dfatigue) + dfatigue = { + "MATAKE": "MATAKE_MODI_AC", + "DOMM_MAXI": "MATAKE_MODI_AV", + "FATEMI_SOCIE": "FATESOCI_MODI_AV", + } + changementValeur(jdc, "CALC_FATIGUE", "CRITERE", dfatigue) ####################### traitement DEFI_PART_FETI ####################### - removeMotCleSiRegle(jdc,"DEFI_PART_FETI","MAILLAGE", ((("MODELE",),"existeMCFParmi"),(("MAILLAGE",),"existeMCFParmi"))) + removeMotCleSiRegle( + jdc, + "DEFI_PART_FETI", + "MAILLAGE", + ((("MODELE",), "existeMCFParmi"), (("MAILLAGE",), "existeMCFParmi")), + ) ####################### traitement MACR_ADAP_MAIL ####################### - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","MAILLAGE_N") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","MAILLAGE_NP1") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","RESULTAT_N") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","INDICATEUR") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","NOM_CMP_INDICA") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_RAFF_PE") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_RAFF_ABS") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_RAFF_REL") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_DERA_PE") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_DERA_ABS") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_DERA_REL") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","NIVE_MAX") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","INST") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","PRECISION") - moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRITERE") - chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RAFFINEMENT',",((("ADAPTATION","LIBRE","RAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0) - chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='DERAFFINEMENT',",((("ADAPTATION","LIBRE","DERAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0) - chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RAFF_DERA',",((("ADAPTATION","LIBRE","RAFF_DERA",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0) - chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RAFFINEMENT_UNIFORME',",((("ADAPTATION","UNIFORME","RAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0) - chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='DERAFFINEMENT_UNIFORME',",((("ADAPTATION","UNIFORME","DERAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0) - chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RIEN',",((("ADAPTATION","UNIFORME","RIEN",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0) - removeMotCle(jdc,"MACR_ADAP_MAIL","ADAPTATION") - renameMotCle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW","ADAPTATION") - 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","EPGR_ELNO":"EPFP_ELNO","EPGR_ELGA":"EPFP_ELGA","DURT_ELGA_TEMP":"DURT_ELNO_TEMP"} - changementValeur(jdc,"MACR_ADAP_MAIL","ADAPTATION",dcalcelemno) - + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "MAILLAGE_N") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "MAILLAGE_NP1") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "RESULTAT_N") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "INDICATEUR") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "NOM_CMP_INDICA") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "CRIT_RAFF_PE") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "CRIT_RAFF_ABS") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "CRIT_RAFF_REL") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "CRIT_DERA_PE") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "CRIT_DERA_ABS") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "CRIT_DERA_REL") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "NIVE_MAX") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "INST") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "PRECISION") + moveMotCleFromFactToFather(jdc, "MACR_ADAP_MAIL", "ADAPTATION", "CRITERE") + chercheOperInsereFacteurSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ADAPTATIONEW='RAFFINEMENT',", + ((("ADAPTATION", "LIBRE", "RAFFINEMENT", jdc), "MCsousMCFaPourValeur"),), + estunFacteur=0, + ) + chercheOperInsereFacteurSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ADAPTATIONEW='DERAFFINEMENT',", + ((("ADAPTATION", "LIBRE", "DERAFFINEMENT", jdc), "MCsousMCFaPourValeur"),), + estunFacteur=0, + ) + chercheOperInsereFacteurSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ADAPTATIONEW='RAFF_DERA',", + ((("ADAPTATION", "LIBRE", "RAFF_DERA", jdc), "MCsousMCFaPourValeur"),), + estunFacteur=0, + ) + chercheOperInsereFacteurSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ADAPTATIONEW='RAFFINEMENT_UNIFORME',", + ((("ADAPTATION", "UNIFORME", "RAFFINEMENT", jdc), "MCsousMCFaPourValeur"),), + estunFacteur=0, + ) + chercheOperInsereFacteurSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ADAPTATIONEW='DERAFFINEMENT_UNIFORME',", + ((("ADAPTATION", "UNIFORME", "DERAFFINEMENT", jdc), "MCsousMCFaPourValeur"),), + estunFacteur=0, + ) + chercheOperInsereFacteurSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ADAPTATIONEW='RIEN',", + ((("ADAPTATION", "UNIFORME", "RIEN", jdc), "MCsousMCFaPourValeur"),), + estunFacteur=0, + ) + removeMotCle(jdc, "MACR_ADAP_MAIL", "ADAPTATION") + renameMotCle(jdc, "MACR_ADAP_MAIL", "ADAPTATIONEW", "ADAPTATION") + 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", + "EPGR_ELNO": "EPFP_ELNO", + "EPGR_ELGA": "EPFP_ELGA", + "DURT_ELGA_TEMP": "DURT_ELNO_TEMP", + } + changementValeur(jdc, "MACR_ADAP_MAIL", "ADAPTATION", dcalcelemno) ####################### traitement IMPR_FICO_HOMARD ####################### - removeCommande(jdc,"IMPR_FICO_HOMARD") - + removeCommande(jdc, "IMPR_FICO_HOMARD") ######################################################################### - - f=open(outfile,'w') + f = open(outfile, "w") f.write(jdc.getSource()) f.close() log.ferme(hdlr) + def main(): parser = argparse.ArgumentParser(usage=usage) - parser.add_argument('-i','--infile', dest="infile", default='toto.comm', - help="Le fichier COMM en entree, a traduire") - parser.add_argument('-o','--outfile', dest="outfile", default='tutu.comm', - help="Le fichier COMM en sortie, traduit") + parser.add_argument( + "-i", + "--infile", + dest="infile", + default="toto.comm", + help="Le fichier COMM en entree, a traduire", + ) + parser.add_argument( + "-o", + "--outfile", + dest="outfile", + default="tutu.comm", + help="Le fichier COMM en sortie, traduit", + ) args = parser.parse_args() - traduc(args.infile,args.outfile) + traduc(args.infile, args.outfile) + -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/Traducteur/traduitV8V9.py b/Traducteur/traduitV8V9.py index 1c74be2e..edc21cce 100644 --- a/Traducteur/traduitV8V9.py +++ b/Traducteur/traduitV8V9.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,417 +20,754 @@ # """ """ -usage="""usage: %prog [options] +usage = """usage: %prog [options] Typical use is: python traduitV7V8.py --infile=xxxx --outfile=yyyy """ -import argparse # optparse deprecated since Python version 3.2 +import argparse # optparse deprecated since Python version 3.2 import sys import Traducteur.log as log -from load import getJDC +from load import getJDC from mocles import parseKeywords -from removemocle import * -from renamemocle import * -from renamemocle import * -from inseremocle import * +from removemocle import * +from renamemocle import * +from renamemocle import * +from inseremocle import * from changeValeur import * -from movemocle import * -from dictErreurs import genereErreurPourCommande,genereErreurMotCleInFact +from movemocle import * +from dictErreurs import genereErreurPourCommande, genereErreurMotCleInFact import calcG -atraiter=( "DEFI_MAILLAGE","CALC_VECT_ELEM","DYNA_TRAN_EXPLI","DYNA_NON_LINE","STAT_NON_LINE","FACT_LDLT","FACT_GRAD","RESO_LDLT","RESO_GRAD","DYNA_TRAN_MODAL","NORM_MODE","MACRO_MODE_MECA","POST_RCCM","THER_NON_LINE","THER_NON_LINE_MO","THER_LINEAIRE","THER_NON_LINE_MO","DEFI_CABLE_BP","GENE_VARI_ALEA","DEFI_MATERIAU","IMPR_MATRICE","CALC_G","CALC_MATR_ELEM","MACR_ADAP_MAIL","MACR_INFO_MAIL","REST_BASE_PHYS","COMB_SISM_MODAL","TEST_FICHIER","MACR_ELEM_DYNA","CREA_CHAMP","AFFE_CHAR_MECA","AFE_CHAR_MECA_F","MODI_MAILLAGE","DEFI_FISS_XFEM","AFFE_MODELE","POST_MAIL_XFEM","CALC_NO","LIRE_CHAMP","AFFE_MATERIAU","MACR_ASCOUF_CALC","MACR_ASPIC_CALC","CALC_PRECONT","LIRE_INTE_SPEC","MACR_CARA_POUTRE","MACR_LIGN_COUPE") - -dict_erreurs={ -# STA9 - "POST_RCCM_SITUATION_NUME_PASSAGE":"Utilisation de NUME_PASSAGE pour le type TUYAUTERIE impossible en 9.2. On ne traite pour le moment que les chemins de passage simples.", - "POST_RCCM_SITUATION_NB_CYCL_SEISME":"POST_RCCM : maintenant les SITUATIONS sismiques ont leur propre mot clef facteur SEISME, attention, traduction incomplete", - "DEFI_MATERIAU_BAZANT_FD" : "le materiau BAZANT_FD a ete supprime", - "DEFI_MATERIAU_APPUI_ELAS" : "le materiau APPUI_ELAS a ete supprime", - "DEFI_MATERIAU_PORO_JOINT" : "le materiau PORO_JOINT a ete supprime", - "DEFI_MATERIAU_ZIRC_CYRA2" : "le materiau ZIRC_CYRA2 a ete supprime", - "DEFI_MATERIAU_ZIRC_EPRI" : "le materiau ZIRC_EPRI a ete supprime", - "IMPR_MATRICE_MATR_ELEM_FORMAT=RESULTAT" : "IMPR_MATRICE au format RESULTAT a ete supprime", - "IMPR_MATRICE_MATR_ASSE_FORMAT=RESULTAT" : "IMPR_MATRICE au format RESULTAT a ete supprime", - "CALC_G_OPTION=G_LAGR" : "l'OPTION G_LAGR de CALC_G a ete supprimee", - "CALC_G_OPTION=G_LAGR_GLOB" : "l'OPTION G_LAGR_GLOB de CALC_G a ete supprimee", - "CALC_MATR_ELEM_THETA" : "l'OPTION RIGI_MECA_LAGR de CALC_MATR_ELEM a ete supprimee", - "TEST_FICHIER_NB_CHIFFRE" : "le fonctionnement de TEST_FICHIER a change entre la V8 et la V9, consultez la doc, en particulier pour entrer la bonne valeur de NB_VALE", - "DYNA_NON_LINE_PILOTAGE" : "le PILOTAGE n'est pas actif dans DYNA_NON_LINE ", - "DYNA_NON_LINE_RECH_LINEAIRE" : "la RECH_LINEAIRE n'est pas active dans DYNA_NON_LINE ", - "DEFI_FISS_XFEM_CONTACT" : "en v9, le contact pour XFEM est defini dans un AFFE_CHAR_MECA(CONTACT=_F) en propre", - "POST_MAIL_XFEM" : "dans POST_MAIL_XFEM il faut entrer le MODELE et le MAILLAGE_SAIN", - "AFFE_MATERIAU_AFFE_TEMP_REF" : "Passage aux variables de commande : definir un materiau dependant de la temperature 'AFFE_MATERIAU(AFFE_VARC=_F(...))' et supprimer TEMP_CALCULEE dans les chargements", - "STAT_NON_LINE_LAGR_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "STAT_NON_LINE_SOLV_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "STAT_NON_LINE_ETAT_INIT_VARI_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "DYNA_NON_LINE_LAGR_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "DYNA_NON_LINE_SOLV_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "DYNA_NON_LINE_ETAT_INIT_VARI_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "CALC_PRECONT_LAGR_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "CALC_PRECONT_SOLV_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - "CALC_PRECONT_ETAT_INIT_VARI_NON_LOCAL" : "Le solveur NON_LOCAL a ete supprime", - } - -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 +atraiter = ( + "DEFI_MAILLAGE", + "CALC_VECT_ELEM", + "DYNA_TRAN_EXPLI", + "DYNA_NON_LINE", + "STAT_NON_LINE", + "FACT_LDLT", + "FACT_GRAD", + "RESO_LDLT", + "RESO_GRAD", + "DYNA_TRAN_MODAL", + "NORM_MODE", + "MACRO_MODE_MECA", + "POST_RCCM", + "THER_NON_LINE", + "THER_NON_LINE_MO", + "THER_LINEAIRE", + "THER_NON_LINE_MO", + "DEFI_CABLE_BP", + "GENE_VARI_ALEA", + "DEFI_MATERIAU", + "IMPR_MATRICE", + "CALC_G", + "CALC_MATR_ELEM", + "MACR_ADAP_MAIL", + "MACR_INFO_MAIL", + "REST_BASE_PHYS", + "COMB_SISM_MODAL", + "TEST_FICHIER", + "MACR_ELEM_DYNA", + "CREA_CHAMP", + "AFFE_CHAR_MECA", + "AFE_CHAR_MECA_F", + "MODI_MAILLAGE", + "DEFI_FISS_XFEM", + "AFFE_MODELE", + "POST_MAIL_XFEM", + "CALC_NO", + "LIRE_CHAMP", + "AFFE_MATERIAU", + "MACR_ASCOUF_CALC", + "MACR_ASPIC_CALC", + "CALC_PRECONT", + "LIRE_INTE_SPEC", + "MACR_CARA_POUTRE", + "MACR_LIGN_COUPE", +) + +dict_erreurs = { + # STA9 + "POST_RCCM_SITUATION_NUME_PASSAGE": "Utilisation de NUME_PASSAGE pour le type TUYAUTERIE impossible en 9.2. On ne traite pour le moment que les chemins de passage simples.", + "POST_RCCM_SITUATION_NB_CYCL_SEISME": "POST_RCCM : maintenant les SITUATIONS sismiques ont leur propre mot clef facteur SEISME, attention, traduction incomplete", + "DEFI_MATERIAU_BAZANT_FD": "le materiau BAZANT_FD a ete supprime", + "DEFI_MATERIAU_APPUI_ELAS": "le materiau APPUI_ELAS a ete supprime", + "DEFI_MATERIAU_PORO_JOINT": "le materiau PORO_JOINT a ete supprime", + "DEFI_MATERIAU_ZIRC_CYRA2": "le materiau ZIRC_CYRA2 a ete supprime", + "DEFI_MATERIAU_ZIRC_EPRI": "le materiau ZIRC_EPRI a ete supprime", + "IMPR_MATRICE_MATR_ELEM_FORMAT=RESULTAT": "IMPR_MATRICE au format RESULTAT a ete supprime", + "IMPR_MATRICE_MATR_ASSE_FORMAT=RESULTAT": "IMPR_MATRICE au format RESULTAT a ete supprime", + "CALC_G_OPTION=G_LAGR": "l'OPTION G_LAGR de CALC_G a ete supprimee", + "CALC_G_OPTION=G_LAGR_GLOB": "l'OPTION G_LAGR_GLOB de CALC_G a ete supprimee", + "CALC_MATR_ELEM_THETA": "l'OPTION RIGI_MECA_LAGR de CALC_MATR_ELEM a ete supprimee", + "TEST_FICHIER_NB_CHIFFRE": "le fonctionnement de TEST_FICHIER a change entre la V8 et la V9, consultez la doc, en particulier pour entrer la bonne valeur de NB_VALE", + "DYNA_NON_LINE_PILOTAGE": "le PILOTAGE n'est pas actif dans DYNA_NON_LINE ", + "DYNA_NON_LINE_RECH_LINEAIRE": "la RECH_LINEAIRE n'est pas active dans DYNA_NON_LINE ", + "DEFI_FISS_XFEM_CONTACT": "en v9, le contact pour XFEM est defini dans un AFFE_CHAR_MECA(CONTACT=_F) en propre", + "POST_MAIL_XFEM": "dans POST_MAIL_XFEM il faut entrer le MODELE et le MAILLAGE_SAIN", + "AFFE_MATERIAU_AFFE_TEMP_REF": "Passage aux variables de commande : definir un materiau dependant de la temperature 'AFFE_MATERIAU(AFFE_VARC=_F(...))' et supprimer TEMP_CALCULEE dans les chargements", + "STAT_NON_LINE_LAGR_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "STAT_NON_LINE_SOLV_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "STAT_NON_LINE_ETAT_INIT_VARI_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "DYNA_NON_LINE_LAGR_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "DYNA_NON_LINE_SOLV_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "DYNA_NON_LINE_ETAT_INIT_VARI_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "CALC_PRECONT_LAGR_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "CALC_PRECONT_SOLV_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", + "CALC_PRECONT_ETAT_INIT_VARI_NON_LOCAL": "Le solveur NON_LOCAL a ete supprime", +} + +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) ####################### traitement erreurs ######################## - genereErreurPourCommande(jdc,("POST_RCCM","DEFI_MATERIAU","TEST_FICHIER","DYNA_NON_LINE","DEFI_FISS_XFEM","POST_MAIL_XFEM")) + genereErreurPourCommande( + jdc, + ( + "POST_RCCM", + "DEFI_MATERIAU", + "TEST_FICHIER", + "DYNA_NON_LINE", + "DEFI_FISS_XFEM", + "POST_MAIL_XFEM", + ), + ) ####################### traitement Sous-Structuration ####################### - renameMotCleInFact(jdc,"DEFI_MAILLAGE","DEFI_SUPER_MAILLE","MACR_ELEM_STAT","MACR_ELEM") - renameMotCleInFact(jdc,"DYNA_NON_LINE","SOUS_STRUC","MAILLE","SUPER_MAILLE") - renameMotCleInFact(jdc,"STAT_NON_LINE","SOUS_STRUC","MAILLE","SUPER_MAILLE") - renameMotCleInFact(jdc,"CALC_VECT_ELEM","SOUS_STRUC","MAILLE","SUPER_MAILLE") + renameMotCleInFact( + jdc, "DEFI_MAILLAGE", "DEFI_SUPER_MAILLE", "MACR_ELEM_STAT", "MACR_ELEM" + ) + renameMotCleInFact(jdc, "DYNA_NON_LINE", "SOUS_STRUC", "MAILLE", "SUPER_MAILLE") + renameMotCleInFact(jdc, "STAT_NON_LINE", "SOUS_STRUC", "MAILLE", "SUPER_MAILLE") + renameMotCleInFact(jdc, "CALC_VECT_ELEM", "SOUS_STRUC", "MAILLE", "SUPER_MAILLE") ######################################################################### ####################### traitement MACR_ELEM_DYNA ####################### - removeMotCle(jdc,"MACR_ELEM_DYNA","OPTION") + removeMotCle(jdc, "MACR_ELEM_DYNA", "OPTION") ######################################################################### ####################### traitement MODI_MAILLAGE ####################### - renameMotCle(jdc,"MODI_MAILLAGE","ORIE_SHB8","ORIE_SHB") + renameMotCle(jdc, "MODI_MAILLAGE", "ORIE_SHB8", "ORIE_SHB") ######################################################################### ####################### traitement XFEM ####################### - dXFEM={"3D_XFEM":"3D", "C_PLAN_X":"C_PLAN", "D_PLAN_X":"D_PLAN"} - changementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",dXFEM) - renameMotCleInFact(jdc,"DEFI_FISS_XFEM","ORIE_FOND","PT_ORIGIN","POINT_ORIG") - removeMotCleAvecErreur(jdc,"DEFI_FISS_XFEM","CONTACT") + dXFEM = {"3D_XFEM": "3D", "C_PLAN_X": "C_PLAN", "D_PLAN_X": "D_PLAN"} + changementValeurDsMCF(jdc, "AFFE_MODELE", "AFFE", "MODELISATION", dXFEM) + renameMotCleInFact(jdc, "DEFI_FISS_XFEM", "ORIE_FOND", "PT_ORIGIN", "POINT_ORIG") + removeMotCleAvecErreur(jdc, "DEFI_FISS_XFEM", "CONTACT") ######################################################################### ####################### traitement Resolution lineaire ##################### - renameMotCle(jdc,"RESO_LDLT","MATR_FACT","MATR") - renameMotCle(jdc,"RESO_GRAD","MATR_ASSE","MATR") - renameMotCle(jdc,"RESO_GRAD","MATR_FACT","MATR_PREC") - renameOper(jdc,"RESO_LDLT","RESOUDRE") - renameOper(jdc,"RESO_GRAD","RESOUDRE") - renameOper(jdc,"FACT_LDLT","FACTORISER") - renameOper(jdc,"FACT_GRAD","FACTORISER") + renameMotCle(jdc, "RESO_LDLT", "MATR_FACT", "MATR") + renameMotCle(jdc, "RESO_GRAD", "MATR_ASSE", "MATR") + renameMotCle(jdc, "RESO_GRAD", "MATR_FACT", "MATR_PREC") + renameOper(jdc, "RESO_LDLT", "RESOUDRE") + renameOper(jdc, "RESO_GRAD", "RESOUDRE") + renameOper(jdc, "FACT_LDLT", "FACTORISER") + renameOper(jdc, "FACT_GRAD", "FACTORISER") ######################################################################### ####################### traitement DYNA_TRAN_MODAL ###################### - removeMotCle(jdc,"DYNA_TRAN_MODAL","NB_MODE_DIAG") + removeMotCle(jdc, "DYNA_TRAN_MODAL", "NB_MODE_DIAG") ######################################################################### ############# traitement MASS_INER dans NORM_MODE/MACRO_MODE_MECA ########## - removeMotCle(jdc,"NORM_MODE","MASS_INER") - removeMotCleInFact(jdc,"MACRO_MODE_MECA","NORM_MODE","MASS_INER") + removeMotCle(jdc, "NORM_MODE", "MASS_INER") + removeMotCleInFact(jdc, "MACRO_MODE_MECA", "NORM_MODE", "MASS_INER") ######################################################################### ####################### traitement POST_RCCM ############################ - removeMotCleInFactSiRegleAvecErreur(jdc,"POST_RCCM","SITUATION","NUME_PASSAGE",((("TYPE_RESU_MECA","TUYAUTERIE",jdc),"MCaPourValeur"),)) - chercheOperInsereFacteurSiRegle(jdc,"POST_RCCM","SEISME", ((("SITUATION","NB_CYCL_SEISME"),"existeMCsousMCF"),)) - moveMotCleFromFactToFact(jdc,"POST_RCCM","SITUATION","NB_CYCL_SEISME","SEISME") -# ajouteMotClefDansFacteurSiRegle(jdc,"POST_RCCM","SITUATION", "transferez_au_bloc_SEISME_CHAR_ETAT_NB_OCCUR,NUME_SITU,NUME_GROUP_et_eventuellement_NOM_SITU_et_NUME_RESU_THER",((("SITUATION","NB_CYCL_SEISME"),"existeMCsousMCF"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"POST_RCCM","SITUATION","supprimez_a_la_main_ce_bloc",((("SITUATION","NB_CYCL_SEISME"),"existeMCsousMCF"),)) -# removeMotCleInFactSiRegleAvecErreur(jdc,"POST_RCCM","SITUATION","NB_CYCL_SEISME",((("SITUATION","NB_CYCL_SEISME"),"existeMCsousMCF"),)) - removeMotCleInFactSiRegle(jdc,"POST_RCCM","SITUATION","NB_CYCL_SEISME",((("SITUATION","NB_CYCL_SEISME"),"existeMCsousMCF"),)) - removeMotCleInFact(jdc,"POST_RCCM","CHAR_MECA","TYPE_CHAR",) - removeMotCleInFact(jdc,"POST_RCCM","RESU_MECA","TYPE_CHAR",) + removeMotCleInFactSiRegleAvecErreur( + jdc, + "POST_RCCM", + "SITUATION", + "NUME_PASSAGE", + ((("TYPE_RESU_MECA", "TUYAUTERIE", jdc), "MCaPourValeur"),), + ) + chercheOperInsereFacteurSiRegle( + jdc, + "POST_RCCM", + "SEISME", + ((("SITUATION", "NB_CYCL_SEISME"), "existeMCsousMCF"),), + ) + moveMotCleFromFactToFact(jdc, "POST_RCCM", "SITUATION", "NB_CYCL_SEISME", "SEISME") + # ajouteMotClefDansFacteurSiRegle(jdc,"POST_RCCM","SITUATION", "transferez_au_bloc_SEISME_CHAR_ETAT_NB_OCCUR,NUME_SITU,NUME_GROUP_et_eventuellement_NOM_SITU_et_NUME_RESU_THER",((("SITUATION","NB_CYCL_SEISME"),"existeMCsousMCF"),)) + ajouteMotClefDansFacteurSiRegle( + jdc, + "POST_RCCM", + "SITUATION", + "supprimez_a_la_main_ce_bloc", + ((("SITUATION", "NB_CYCL_SEISME"), "existeMCsousMCF"),), + ) + # removeMotCleInFactSiRegleAvecErreur(jdc,"POST_RCCM","SITUATION","NB_CYCL_SEISME",((("SITUATION","NB_CYCL_SEISME"),"existeMCsousMCF"),)) + removeMotCleInFactSiRegle( + jdc, + "POST_RCCM", + "SITUATION", + "NB_CYCL_SEISME", + ((("SITUATION", "NB_CYCL_SEISME"), "existeMCsousMCF"),), + ) + removeMotCleInFact( + jdc, + "POST_RCCM", + "CHAR_MECA", + "TYPE_CHAR", + ) + removeMotCleInFact( + jdc, + "POST_RCCM", + "RESU_MECA", + "TYPE_CHAR", + ) ######################################################################### ####################### traitement THER_NON_LINE ############################ - renameMotCleInFact(jdc,"THER_NON_LINE","TEMP_INIT","NUME_INIT","NUME_ORDRE") - renameMotCle(jdc,"THER_NON_LINE","TEMP_INIT","ETAT_INIT",) - renameMotCleInFact(jdc,"THER_NON_LINE","INCREMENT","NUME_INIT","NUME_INST_INIT") - renameMotCleInFact(jdc,"THER_NON_LINE","INCREMENT","NUME_FIN","NUME_INST_FIN") - - renameMotCleInFact(jdc,"THER_NON_LINE_MO","TEMP_INIT","NUME_INIT","NUME_ORDRE") - renameMotCle(jdc,"THER_NON_LINE_MO","TEMP_INIT","ETAT_INIT",) + renameMotCleInFact(jdc, "THER_NON_LINE", "TEMP_INIT", "NUME_INIT", "NUME_ORDRE") + renameMotCle( + jdc, + "THER_NON_LINE", + "TEMP_INIT", + "ETAT_INIT", + ) + renameMotCleInFact(jdc, "THER_NON_LINE", "INCREMENT", "NUME_INIT", "NUME_INST_INIT") + renameMotCleInFact(jdc, "THER_NON_LINE", "INCREMENT", "NUME_FIN", "NUME_INST_FIN") + + renameMotCleInFact(jdc, "THER_NON_LINE_MO", "TEMP_INIT", "NUME_INIT", "NUME_ORDRE") + renameMotCle( + jdc, + "THER_NON_LINE_MO", + "TEMP_INIT", + "ETAT_INIT", + ) ######################################################################### ####################### traitement THER_LINEAIRE ############################ - renameMotCleInFact(jdc,"THER_LINEAIRE","TEMP_INIT","NUME_INIT","NUME_ORDRE") - renameMotCle(jdc,"THER_LINEAIRE","TEMP_INIT","ETAT_INIT",) - renameMotCleInFact(jdc,"THER_LINEAIRE","INCREMENT","NUME_INIT","NUME_INST_INIT") - renameMotCleInFact(jdc,"THER_LINEAIRE","INCREMENT","NUME_FIN","NUME_INST_FIN") - renameMotCleInFact(jdc,"THER_LINEAIRE","ARCHIVAGE","LIST_ARCH","LIST_INST") + renameMotCleInFact(jdc, "THER_LINEAIRE", "TEMP_INIT", "NUME_INIT", "NUME_ORDRE") + renameMotCle( + jdc, + "THER_LINEAIRE", + "TEMP_INIT", + "ETAT_INIT", + ) + renameMotCleInFact(jdc, "THER_LINEAIRE", "INCREMENT", "NUME_INIT", "NUME_INST_INIT") + renameMotCleInFact(jdc, "THER_LINEAIRE", "INCREMENT", "NUME_FIN", "NUME_INST_FIN") + renameMotCleInFact(jdc, "THER_LINEAIRE", "ARCHIVAGE", "LIST_ARCH", "LIST_INST") ######################################################################### ####################### traitement THER_NON_LINE ############################ - renameMotCleInFact(jdc,"THER_NON_LINE","TEMP_INIT","NUME_INIT","NUME_ORDRE") - renameMotCle(jdc,"THER_NON_LINE","TEMP_INIT","ETAT_INIT",) + renameMotCleInFact(jdc, "THER_NON_LINE", "TEMP_INIT", "NUME_INIT", "NUME_ORDRE") + renameMotCle( + jdc, + "THER_NON_LINE", + "TEMP_INIT", + "ETAT_INIT", + ) ######################################################################### ####################### traitement DEFI_CABLE_BP ###################### - removeMotCle(jdc,"DEFI_CABLE_BP","MAILLAGE") + removeMotCle(jdc, "DEFI_CABLE_BP", "MAILLAGE") ######################################################################### ####################### traitement GENE_VARI_ALEA ###################### - removeMotCleSiRegle(jdc,"GENE_VARI_ALEA","COEF_VAR",((("TYPE","EXPONENTIELLE",jdc),"MCaPourValeur"),)) + removeMotCleSiRegle( + jdc, + "GENE_VARI_ALEA", + "COEF_VAR", + ((("TYPE", "EXPONENTIELLE", jdc), "MCaPourValeur"),), + ) ######################################################################### ####################### traitement DEFI_MATERIAU ###################### - removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","BAZANT_FD") - removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","PORO_JOINT") - removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","APPUI_ELAS") - removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","ZIRC_EPRI") - removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","ZIRC_CYRA2") + removeMotCleAvecErreur(jdc, "DEFI_MATERIAU", "BAZANT_FD") + removeMotCleAvecErreur(jdc, "DEFI_MATERIAU", "PORO_JOINT") + removeMotCleAvecErreur(jdc, "DEFI_MATERIAU", "APPUI_ELAS") + removeMotCleAvecErreur(jdc, "DEFI_MATERIAU", "ZIRC_EPRI") + removeMotCleAvecErreur(jdc, "DEFI_MATERIAU", "ZIRC_CYRA2") # BARCELONE - moveMotCleFromFactToFact(jdc,"DEFI_MATERIAU","CAM_CLAY","MU","BARCELONE") - moveMotCleFromFactToFact(jdc,"DEFI_MATERIAU","CAM_CLAY","PORO","BARCELONE") - moveMotCleFromFactToFact(jdc,"DEFI_MATERIAU","CAM_CLAY","LAMBDA","BARCELONE") - moveMotCleFromFactToFact(jdc,"DEFI_MATERIAU","CAM_CLAY","KAPPA","BARCELONE") - moveMotCleFromFactToFact(jdc,"DEFI_MATERIAU","CAM_CLAY","M","BARCELONE") - moveMotCleFromFactToFact(jdc,"DEFI_MATERIAU","CAM_CLAY","PRES_CRIT","BARCELONE") - moveMotCleFromFactToFact(jdc,"DEFI_MATERIAU","CAM_CLAY","PA","BARCELONE") - renameMotCleInFact(jdc,"DEFI_MATERIAU","CAM_CLAY","PA","KCAM") + moveMotCleFromFactToFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "MU", "BARCELONE") + moveMotCleFromFactToFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "PORO", "BARCELONE") + moveMotCleFromFactToFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "LAMBDA", "BARCELONE") + moveMotCleFromFactToFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "KAPPA", "BARCELONE") + moveMotCleFromFactToFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "M", "BARCELONE") + moveMotCleFromFactToFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "PRES_CRIT", "BARCELONE") + moveMotCleFromFactToFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "PA", "BARCELONE") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "CAM_CLAY", "PA", "KCAM") # CAM_CLAY -# ajouteMotClefDansFacteur(jdc,"DEFI_MATERIAU","CAM_CLAY","MU=xxx",) -# ajouteMotClefDansFacteurSiRegle(jdc,"DEFI_MATERIAU","CAM_CLAY","PTRAC=XXX",((("CAM_CLAY","KCAM"),"existeMCsousMCF"),)) + # ajouteMotClefDansFacteur(jdc,"DEFI_MATERIAU","CAM_CLAY","MU=xxx",) + # ajouteMotClefDansFacteurSiRegle(jdc,"DEFI_MATERIAU","CAM_CLAY","PTRAC=XXX",((("CAM_CLAY","KCAM"),"existeMCsousMCF"),)) # VENDOCHAB - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB","S_VP","S") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB","N_VP","N") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB","M_VP","UN_SUR_M", erreur=1) - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB","K_VP","UN_SUR_K") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB","SEDVP1","ALPHA_D") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB","SEDVP2","BETA_D") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","S_VP","S") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","N_VP","N") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","M_VP","UN_SUR_M", erreur=1) - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","K_VP","UN_SUR_K") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","SEDVP1","ALPHA_D") - renameMotCleInFact(jdc,"DEFI_MATERIAU","VENDOCHAB_FO","SEDVP2","BETA_D") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB", "S_VP", "S") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB", "N_VP", "N") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB", "M_VP", "UN_SUR_M", erreur=1) + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB", "K_VP", "UN_SUR_K") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB", "SEDVP1", "ALPHA_D") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB", "SEDVP2", "BETA_D") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB_FO", "S_VP", "S") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB_FO", "N_VP", "N") + renameMotCleInFact( + jdc, "DEFI_MATERIAU", "VENDOCHAB_FO", "M_VP", "UN_SUR_M", erreur=1 + ) + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB_FO", "K_VP", "UN_SUR_K") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB_FO", "SEDVP1", "ALPHA_D") + renameMotCleInFact(jdc, "DEFI_MATERIAU", "VENDOCHAB_FO", "SEDVP2", "BETA_D") # GLRC - renameCommandeSiRegle(jdc,"DEFI_MATERIAU","DEFI_GLRC", ((("GLRC_DAMAGE","GLRC_ACIER",),"existeMCFParmi"),)) + renameCommandeSiRegle( + jdc, + "DEFI_MATERIAU", + "DEFI_GLRC", + ( + ( + ( + "GLRC_DAMAGE", + "GLRC_ACIER", + ), + "existeMCFParmi", + ), + ), + ) ######################################################################### ####################### traitement IMPR_MATRICE ###################### - removeCommandeSiRegleAvecErreur(jdc,"IMPR_MATRICE",((("MATR_ELEM","FORMAT","RESULTAT",jdc),"MCsousMCFaPourValeur"),)) - removeCommandeSiRegleAvecErreur(jdc,"IMPR_MATRICE",((("MATR_ASSE","FORMAT","RESULTAT",jdc),"MCsousMCFaPourValeur"),)) + removeCommandeSiRegleAvecErreur( + jdc, + "IMPR_MATRICE", + ((("MATR_ELEM", "FORMAT", "RESULTAT", jdc), "MCsousMCFaPourValeur"),), + ) + removeCommandeSiRegleAvecErreur( + jdc, + "IMPR_MATRICE", + ((("MATR_ASSE", "FORMAT", "RESULTAT", jdc), "MCsousMCFaPourValeur"),), + ) ######################################################################### ####################### traitement MACR_ADAP/INFO_MAIL ###################### - dadap_mail={ "V8_5":"V9_5", "V8_N":"V9_N", "V8_N_PERSO":"V9_N_PERSO"} - changementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",dadap_mail) - changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",dadap_mail) + dadap_mail = {"V8_5": "V9_5", "V8_N": "V9_N", "V8_N_PERSO": "V9_N_PERSO"} + changementValeur(jdc, "MACR_ADAP_MAIL", "VERSION_HOMARD", dadap_mail) + changementValeur(jdc, "MACR_INFO_MAIL", "VERSION_HOMARD", dadap_mail) ######################################################################### ####################### traitement REST_BASE_PHYS ###################### - renameCommandeSiRegle(jdc,"REST_BASE_PHYS","REST_SOUS_STRUC", ((("RESULTAT","SQUELETTE","SOUS_STRUC","BASE_MODALE","CYCLIQUE","SECTEUR"),"existeMCFParmi"),)) - renameCommandeSiRegle(jdc,"REST_BASE_PHYS","REST_COND_TRAN", ((("MACR_ELEM_DYNA","RESU_PHYS"),"existeMCFParmi"),)) - renameCommande(jdc,"REST_BASE_PHYS","REST_GENE_PHYS", ) + renameCommandeSiRegle( + jdc, + "REST_BASE_PHYS", + "REST_SOUS_STRUC", + ( + ( + ( + "RESULTAT", + "SQUELETTE", + "SOUS_STRUC", + "BASE_MODALE", + "CYCLIQUE", + "SECTEUR", + ), + "existeMCFParmi", + ), + ), + ) + renameCommandeSiRegle( + jdc, + "REST_BASE_PHYS", + "REST_COND_TRAN", + ((("MACR_ELEM_DYNA", "RESU_PHYS"), "existeMCFParmi"),), + ) + renameCommande( + jdc, + "REST_BASE_PHYS", + "REST_GENE_PHYS", + ) ######################################################################### ####################### traitement CALC_G ###################### - removeMotCleSiRegleAvecErreur(jdc,"CALC_G","OPTION",((("OPTION","G_LAGR",jdc),"MCaPourValeur"),)) - removeMotCleSiRegleAvecErreur(jdc,"CALC_G","OPTION",((("OPTION","G_LAGR_GLOB",jdc),"MCaPourValeur"),)) - removeMotCle(jdc,"CALC_G","PROPAGATION") - removeMotCle(jdc,"CALC_G","THETA_LAGR") - removeMotCle(jdc,"CALC_G","DIRE_THETA_LAGR") + removeMotCleSiRegleAvecErreur( + jdc, "CALC_G", "OPTION", ((("OPTION", "G_LAGR", jdc), "MCaPourValeur"),) + ) + removeMotCleSiRegleAvecErreur( + jdc, "CALC_G", "OPTION", ((("OPTION", "G_LAGR_GLOB", jdc), "MCaPourValeur"),) + ) + removeMotCle(jdc, "CALC_G", "PROPAGATION") + removeMotCle(jdc, "CALC_G", "THETA_LAGR") + removeMotCle(jdc, "CALC_G", "DIRE_THETA_LAGR") ######################################################################### ####################### traitement COMB_SISM_MODAL ###################### - ajouteMotClefDansFacteurSiRegle(jdc,"COMB_SISM_MODAL","EXCIT","MULTI_APPUI='DECORRELE'", ((("EXCIT","MONO_APPUI"),"nexistepasMCsousMCF"),)) + ajouteMotClefDansFacteurSiRegle( + jdc, + "COMB_SISM_MODAL", + "EXCIT", + "MULTI_APPUI='DECORRELE'", + ((("EXCIT", "MONO_APPUI"), "nexistepasMCsousMCF"),), + ) ######################################################################### ####################### traitement TEST_FICHIER ###################### - renameMotCleAvecErreur(jdc,"TEST_FICHIER","NB_CHIFFRE","NB_VALE") - removeMotCle(jdc,"TEST_FICHIER","EPSILON") + renameMotCleAvecErreur(jdc, "TEST_FICHIER", "NB_CHIFFRE", "NB_VALE") + removeMotCle(jdc, "TEST_FICHIER", "EPSILON") ######################################################################### ####################### traitement CALC_MATR_ELEM ###################### - removeMotCleSiRegle(jdc,"CALC_MATR_ELEM","OPTION",((("OPTION","RIGI_MECA_LAGR",jdc),"MCaPourValeur"),)) - removeMotCleAvecErreur(jdc,"CALC_MATR_ELEM","PROPAGATION") - removeMotCle(jdc,"CALC_MATR_ELEM","THETA") + removeMotCleSiRegle( + jdc, + "CALC_MATR_ELEM", + "OPTION", + ((("OPTION", "RIGI_MECA_LAGR", jdc), "MCaPourValeur"),), + ) + removeMotCleAvecErreur(jdc, "CALC_MATR_ELEM", "PROPAGATION") + removeMotCle(jdc, "CALC_MATR_ELEM", "THETA") ######################################################################### ####################### traitement ITER_INTE_PAS ###################### - removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","COMP_INCR","ITER_INTE_PAS",((("COMP_INCR","DEFORMATION","SIMO_MIEHE",jdc),"MCsousMCFaPourValeur"),)) - removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","COMP_INCR","ITER_INTE_PAS",((("COMP_INCR","DEFORMATION","SIMO_MIEHE",jdc),"MCsousMCFaPourValeur"),)) + removeMotCleInFactSiRegle( + jdc, + "STAT_NON_LINE", + "COMP_INCR", + "ITER_INTE_PAS", + ((("COMP_INCR", "DEFORMATION", "SIMO_MIEHE", jdc), "MCsousMCFaPourValeur"),), + ) + removeMotCleInFactSiRegle( + jdc, + "DYNA_NON_LINE", + "COMP_INCR", + "ITER_INTE_PAS", + ((("COMP_INCR", "DEFORMATION", "SIMO_MIEHE", jdc), "MCsousMCFaPourValeur"),), + ) ######################################################################### ################## traitement RECH_LINEAIRE et PILOTAGE dans DYNA_NON_LINE ################# - removeMotCleAvecErreur(jdc,"DYNA_NON_LINE","RECH_LINEAIRE") - removeMotCleAvecErreur(jdc,"DYNA_NON_LINE","PILOTAGE") + removeMotCleAvecErreur(jdc, "DYNA_NON_LINE", "RECH_LINEAIRE") + removeMotCleAvecErreur(jdc, "DYNA_NON_LINE", "PILOTAGE") ######################################################################### ####################### traitement DYNA_TRAN_EXPLI ###################### - renameOper(jdc,"DYNA_TRAN_EXPLI","DYNA_NON_LINE") - ajouteMotClefDansFacteur(jdc,"DYNA_NON_LINE","TCHAMWA","FORMULATION='ACCELERATION'") - ajouteMotClefDansFacteur(jdc,"DYNA_NON_LINE","DIFF_CENT","FORMULATION='ACCELERATION'") + renameOper(jdc, "DYNA_TRAN_EXPLI", "DYNA_NON_LINE") + ajouteMotClefDansFacteur( + jdc, "DYNA_NON_LINE", "TCHAMWA", "FORMULATION='ACCELERATION'" + ) + ajouteMotClefDansFacteur( + jdc, "DYNA_NON_LINE", "DIFF_CENT", "FORMULATION='ACCELERATION'" + ) ######################################################################### ####################### traitement SCHEMA_TEMPS dans DYNA_NON_LINE ###################### - ajouteMotClefDansFacteur(jdc,"DYNA_NON_LINE","NEWMARK","FORMULATION='DEPLACEMENT'") - ajouteMotClefDansFacteur(jdc,"DYNA_NON_LINE","HHT","FORMULATION='DEPLACEMENT'") - ajouteMotClefDansFacteur(jdc,"DYNA_NON_LINE","TETA_METHODE","FORMULATION='DEPLACEMENT'") - renameMotCleInFact(jdc,"DYNA_NON_LINE","NEWMARK","ALPHA","BETA",) - renameMotCleInFact(jdc,"DYNA_NON_LINE","NEWMARK","DELTA","GAMMA",) - renameMotCleInFact(jdc,"DYNA_NON_LINE","TETA_METHODE","TETA","THETA",) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_NON_LINE","NEWMARK","SCHEMA='NEWMARK'",((("NEWMARK",),"existeMCFParmi"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_NON_LINE","TETA_METHODE","SCHEMA='THETA_METHODE'",((("TETA_METHODE",),"existeMCFParmi"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_NON_LINE","HHT","SCHEMA='HHT'",((("HHT",),"existeMCFParmi"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_NON_LINE","TCHAMWA","SCHEMA='TCHAMWA'",((("TCHAMWA",),"existeMCFParmi"),)) - ajouteMotClefDansFacteurSiRegle(jdc,"DYNA_NON_LINE","DIFF_CENT","SCHEMA='DIFF_CENT'",((("DIFF_CENT",),"existeMCFParmi"),)) - renameMotCle(jdc,"DYNA_NON_LINE","NEWMARK","SCHEMA_TEMPS") - renameMotCle(jdc,"DYNA_NON_LINE","TETA_METHODE","SCHEMA_TEMPS") - renameMotCle(jdc,"DYNA_NON_LINE","HHT","SCHEMA_TEMPS") - renameMotCle(jdc,"DYNA_NON_LINE","DIFF_CENT","SCHEMA_TEMPS") - renameMotCle(jdc,"DYNA_NON_LINE","TCHAMWA","SCHEMA_TEMPS") - removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT","EVOLUTION") - moveMotClefInOperToFact(jdc,"DYNA_NON_LINE","STOP_CFL","SCHEMA_TEMPS") + ajouteMotClefDansFacteur( + jdc, "DYNA_NON_LINE", "NEWMARK", "FORMULATION='DEPLACEMENT'" + ) + ajouteMotClefDansFacteur(jdc, "DYNA_NON_LINE", "HHT", "FORMULATION='DEPLACEMENT'") + ajouteMotClefDansFacteur( + jdc, "DYNA_NON_LINE", "TETA_METHODE", "FORMULATION='DEPLACEMENT'" + ) + renameMotCleInFact( + jdc, + "DYNA_NON_LINE", + "NEWMARK", + "ALPHA", + "BETA", + ) + renameMotCleInFact( + jdc, + "DYNA_NON_LINE", + "NEWMARK", + "DELTA", + "GAMMA", + ) + renameMotCleInFact( + jdc, + "DYNA_NON_LINE", + "TETA_METHODE", + "TETA", + "THETA", + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_NON_LINE", + "NEWMARK", + "SCHEMA='NEWMARK'", + ((("NEWMARK",), "existeMCFParmi"),), + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_NON_LINE", + "TETA_METHODE", + "SCHEMA='THETA_METHODE'", + ((("TETA_METHODE",), "existeMCFParmi"),), + ) + ajouteMotClefDansFacteurSiRegle( + jdc, "DYNA_NON_LINE", "HHT", "SCHEMA='HHT'", ((("HHT",), "existeMCFParmi"),) + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_NON_LINE", + "TCHAMWA", + "SCHEMA='TCHAMWA'", + ((("TCHAMWA",), "existeMCFParmi"),), + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "DYNA_NON_LINE", + "DIFF_CENT", + "SCHEMA='DIFF_CENT'", + ((("DIFF_CENT",), "existeMCFParmi"),), + ) + renameMotCle(jdc, "DYNA_NON_LINE", "NEWMARK", "SCHEMA_TEMPS") + renameMotCle(jdc, "DYNA_NON_LINE", "TETA_METHODE", "SCHEMA_TEMPS") + renameMotCle(jdc, "DYNA_NON_LINE", "HHT", "SCHEMA_TEMPS") + renameMotCle(jdc, "DYNA_NON_LINE", "DIFF_CENT", "SCHEMA_TEMPS") + renameMotCle(jdc, "DYNA_NON_LINE", "TCHAMWA", "SCHEMA_TEMPS") + removeMotCleInFact(jdc, "DYNA_NON_LINE", "INCREMENT", "EVOLUTION") + moveMotClefInOperToFact(jdc, "DYNA_NON_LINE", "STOP_CFL", "SCHEMA_TEMPS") ######################################################################### ####################### traitement CONTACT ###################### - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","KT_ULTM") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","EFFO_N_INIT") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","RIGI_N_IRRA") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","RIGI_N_FO") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","RIGI_MZ") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","ANGLE_1") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","ANGLE_2") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","ANGLE_3") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","ANGLE_4") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","MOMENT_1") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","MOMENT_2") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","MOMENT_3") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","MOMENT_4") - removeMotCleInFact(jdc,"DEFI_MATERIAU","DIS_CONTACT","C_PRAGER_MZ") - dDis_Choc={"DIS_CONTACT":"DIS_CHOC"} - changementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dDis_Choc) - changementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_INCR","RELATION",dDis_Choc) - renameMotCleInFact(jdc,"STAT_NON_LINE","COMP_INCR","DIS_CONTACT","DIS_CHOC") - renameMotCleInFact(jdc,"DYNA_NON_LINE","COMP_INCR","DIS_CONTACT","DIS_CHOC") - dGrilles={"GRILLE_CRAYONS":"DIS_GRICRA"} - changementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dGrilles) - changementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_INCR","RELATION",dGrilles) - - renameCommandeSiRegle(jdc,"AFFE_CHAR_MECA_F","AFFE_CHAR_MECA",((("CONTACT",),"existeMCFParmi"),)) - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","RECHERCHE") - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","PROJECTION") - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","VECT_Y") - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","VECT_ORIE_POU") - removeMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","MODL_AXIS") - dAppariement={"MAIT_ESCL_SYME":"MAIT_ESCL"} - changementValeurDsMCF(jdc,"AFFE_CHAR_MECA","CONTACT","APPARIEMENT",dAppariement) - - ajouteMotClefDansFacteurSiRegle(jdc,"AFFE_CHAR_MECA","CONTACT","TYPE_APPA='FIXE'",((("CONTACT","DIRE_APPA",),"existeMCsousMCF"),)) + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "KT_ULTM") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "EFFO_N_INIT") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "RIGI_N_IRRA") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "RIGI_N_FO") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "RIGI_MZ") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "ANGLE_1") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "ANGLE_2") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "ANGLE_3") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "ANGLE_4") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "MOMENT_1") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "MOMENT_2") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "MOMENT_3") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "MOMENT_4") + removeMotCleInFact(jdc, "DEFI_MATERIAU", "DIS_CONTACT", "C_PRAGER_MZ") + dDis_Choc = {"DIS_CONTACT": "DIS_CHOC"} + changementValeurDsMCF(jdc, "STAT_NON_LINE", "COMP_INCR", "RELATION", dDis_Choc) + changementValeurDsMCF(jdc, "DYNA_NON_LINE", "COMP_INCR", "RELATION", dDis_Choc) + renameMotCleInFact(jdc, "STAT_NON_LINE", "COMP_INCR", "DIS_CONTACT", "DIS_CHOC") + renameMotCleInFact(jdc, "DYNA_NON_LINE", "COMP_INCR", "DIS_CONTACT", "DIS_CHOC") + dGrilles = {"GRILLE_CRAYONS": "DIS_GRICRA"} + changementValeurDsMCF(jdc, "STAT_NON_LINE", "COMP_INCR", "RELATION", dGrilles) + changementValeurDsMCF(jdc, "DYNA_NON_LINE", "COMP_INCR", "RELATION", dGrilles) + + renameCommandeSiRegle( + jdc, "AFFE_CHAR_MECA_F", "AFFE_CHAR_MECA", ((("CONTACT",), "existeMCFParmi"),) + ) + removeMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "RECHERCHE") + removeMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "PROJECTION") + removeMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "VECT_Y") + removeMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "VECT_ORIE_POU") + removeMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "MODL_AXIS") + dAppariement = {"MAIT_ESCL_SYME": "MAIT_ESCL"} + changementValeurDsMCF(jdc, "AFFE_CHAR_MECA", "CONTACT", "APPARIEMENT", dAppariement) + + ajouteMotClefDansFacteurSiRegle( + jdc, + "AFFE_CHAR_MECA", + "CONTACT", + "TYPE_APPA='FIXE'", + ( + ( + ( + "CONTACT", + "DIRE_APPA", + ), + "existeMCsousMCF", + ), + ), + ) ######################################################################### ####################### traitement CREA_CHAMP ###################### - chercheOperInsereFacteurSiRegle(jdc,"CREA_CHAMP","PRECISION=1.E-3,", ((("PRECISION",),"nexistepas"),(("CRITERE",),"existe"),),0) - dTypeChamp={"ELEM_ERREUR":"ELEM_ERRE_R"} - changementValeur(jdc,"CREA_CHAMP","TYPE_CHAM",dTypeChamp) + chercheOperInsereFacteurSiRegle( + jdc, + "CREA_CHAMP", + "PRECISION=1.E-3,", + ( + (("PRECISION",), "nexistepas"), + (("CRITERE",), "existe"), + ), + 0, + ) + dTypeChamp = {"ELEM_ERREUR": "ELEM_ERRE_R"} + changementValeur(jdc, "CREA_CHAMP", "TYPE_CHAM", dTypeChamp) ######################################################################### ####################### traitement CALC_NO ###################### - chercheOperInsereFacteurSiRegle(jdc,"CALC_NO","PRECISION=1.E-3,", ((("PRECISION",),"nexistepas"),(("CRITERE",),"existe"),),0) + chercheOperInsereFacteurSiRegle( + jdc, + "CALC_NO", + "PRECISION=1.E-3,", + ( + (("PRECISION",), "nexistepas"), + (("CRITERE",), "existe"), + ), + 0, + ) ######################################################################### ######### traitement variables de commandes TEMP_CALCULEE/TEMP_REF ############## - genereErreurMotCleInFact(jdc,"AFFE_MATERIAU","AFFE","TEMP_REF") + genereErreurMotCleInFact(jdc, "AFFE_MATERIAU", "AFFE", "TEMP_REF") ################################################################################ ################# traitement LIRE_CHAMP ####################################### -# dTypeChamp={"ELEM_ERREUR":"ELEM_ERRE_R"} - changementValeur(jdc,"LIRE_CHAMP","TYPE_CHAM",dTypeChamp) + # dTypeChamp={"ELEM_ERREUR":"ELEM_ERRE_R"} + changementValeur(jdc, "LIRE_CHAMP", "TYPE_CHAM", dTypeChamp) ################################################################################ - ######### traitement SUIVI_DDL ################################################# -# en pre-traitement il faudrait une methode qui separe tous les mots clefs facteurs en les dupliquant -# par exemple ici mettre autant de mots clefs facteurs SUIVI_DDL qu'il a de _F - ajouteMotClefDansFacteur(jdc,"STAT_NON_LINE","SUIVI_DDL","SUIVI_DDL='OUI'") - renameMotCle(jdc,"STAT_NON_LINE","SUIVI_DDL","OBSERVATION") -# en post-traitement il faudrait une methode qui fusionne tous les mots clefs facteurs en double -# par exemple ici les OBSERVATION + # en pre-traitement il faudrait une methode qui separe tous les mots clefs facteurs en les dupliquant + # par exemple ici mettre autant de mots clefs facteurs SUIVI_DDL qu'il a de _F + ajouteMotClefDansFacteur(jdc, "STAT_NON_LINE", "SUIVI_DDL", "SUIVI_DDL='OUI'") + renameMotCle(jdc, "STAT_NON_LINE", "SUIVI_DDL", "OBSERVATION") + # en post-traitement il faudrait une methode qui fusionne tous les mots clefs facteurs en double + # par exemple ici les OBSERVATION ################################################################################ - ######### traitement EVOLUTION in STAT/DYNA_NON_LINE ########################### - removeMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT","EVOLUTION") - removeMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT","EVOLUTION") + removeMotCleInFact(jdc, "STAT_NON_LINE", "INCREMENT", "EVOLUTION") + removeMotCleInFact(jdc, "DYNA_NON_LINE", "INCREMENT", "EVOLUTION") ################################################################################ ######### traitement du MODELE GRILLE ############################################## - dGrille={"GRILLE":"GRILLE_EXCENTRE"} - changementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",dGrille) + dGrille = {"GRILLE": "GRILLE_EXCENTRE"} + changementValeurDsMCF(jdc, "AFFE_MODELE", "AFFE", "MODELISATION", dGrille) ################################################################################ ######### traitement de MACR_ASPIC/ASCOUF_CALC GRILLE ########################## - removeMotCle(jdc,"MACR_ASCOUF_CALC","CHARGE") - removeMotCle(jdc,"MACR_ASPIC_CALC","CHARGE") + removeMotCle(jdc, "MACR_ASCOUF_CALC", "CHARGE") + removeMotCle(jdc, "MACR_ASPIC_CALC", "CHARGE") ################################################################################ - ############ suppression de NON_LOCAL ########################################## - removeMotCleAvecErreur(jdc,"STAT_NON_LINE","LAGR_NON_LOCAL") - removeMotCleAvecErreur(jdc,"STAT_NON_LINE","SOLV_NON_LOCAL") - removeMotCleInFact(jdc,"STAT_NON_LINE","ETAT_INIT","VARI_NON_LOCAL",erreur=1) + removeMotCleAvecErreur(jdc, "STAT_NON_LINE", "LAGR_NON_LOCAL") + removeMotCleAvecErreur(jdc, "STAT_NON_LINE", "SOLV_NON_LOCAL") + removeMotCleInFact(jdc, "STAT_NON_LINE", "ETAT_INIT", "VARI_NON_LOCAL", erreur=1) - removeMotCleAvecErreur(jdc,"DYNA_NON_LINE","LAGR_NON_LOCAL") - removeMotCleAvecErreur(jdc,"DYNA_NON_LINE","SOLV_NON_LOCAL") - removeMotCleInFact(jdc,"DYNA_NON_LINE","ETAT_INIT","VARI_NON_LOCAL",erreur=1) + removeMotCleAvecErreur(jdc, "DYNA_NON_LINE", "LAGR_NON_LOCAL") + removeMotCleAvecErreur(jdc, "DYNA_NON_LINE", "SOLV_NON_LOCAL") + removeMotCleInFact(jdc, "DYNA_NON_LINE", "ETAT_INIT", "VARI_NON_LOCAL", erreur=1) - removeMotCleAvecErreur(jdc,"CALC_PRECONT","LAGR_NON_LOCAL") - removeMotCleAvecErreur(jdc,"CALC_PRECONT","SOLV_NON_LOCAL") - removeMotCleInFact(jdc,"CALC_PRECONT","ETAT_INIT","VARI_NON_LOCAL",erreur=1) + removeMotCleAvecErreur(jdc, "CALC_PRECONT", "LAGR_NON_LOCAL") + removeMotCleAvecErreur(jdc, "CALC_PRECONT", "SOLV_NON_LOCAL") + removeMotCleInFact(jdc, "CALC_PRECONT", "ETAT_INIT", "VARI_NON_LOCAL", erreur=1) ################################################################################ ######### traitement de LIRE_INTE_SPEC ######################################### - renameMotCle(jdc,"LIRE_INTE_SPEC","FORMAT","FORMAT_C") + renameMotCle(jdc, "LIRE_INTE_SPEC", "FORMAT", "FORMAT_C") ################################################################################ ######### traitement de MACR_CARA_POUTRE ###################################### - chercheOperInsereFacteurSiRegle(jdc,"MACR_CARA_POUTRE","FORMAT='ASTER'", ((("UNITE_MAILLAGE",),"existe"),),0) - renameMotCle(jdc,"MACR_CARA_POUTRE","UNITE_MAILLAGE","UNITE") + chercheOperInsereFacteurSiRegle( + jdc, "MACR_CARA_POUTRE", "FORMAT='ASTER'", ((("UNITE_MAILLAGE",), "existe"),), 0 + ) + renameMotCle(jdc, "MACR_CARA_POUTRE", "UNITE_MAILLAGE", "UNITE") ################################################################################ ######### traitement de MACR_LIGN_COUPE ###################################### -# il y a un probleme s'il y a plusieurs mots clefs facteurs LIGN_COUPE : la regle ne marche qu'une fois par commande - ajouteMotClefDansFacteurSiRegle(jdc,"MACR_LIGN_COUPE","LIGN_COUPE","REPERE='LOCAL'", ((("LIGN_COUPE","VECT_Y",),"existeMCsousMCF"),),0) -# autre probleme : s'il y a plusieurs mots clefs facteurs le traducteur peut, dans l'insertion, se tromper de mot clef facteur - ajouteMotClefDansFacteurSiRegle(jdc,"MACR_LIGN_COUPE","LIGN_COUPE","TYPE='GROUP_NO'", ((("LIGN_COUPE","GROUP_NO",),"existeMCsousMCF"),),0) - ajouteMotClefDansFacteurSiRegle(jdc,"MACR_LIGN_COUPE","LIGN_COUPE","TYPE='GROUP_MA'", ((("LIGN_COUPE","GROUP_MA",),"existeMCsousMCF"),),0) + # il y a un probleme s'il y a plusieurs mots clefs facteurs LIGN_COUPE : la regle ne marche qu'une fois par commande + ajouteMotClefDansFacteurSiRegle( + jdc, + "MACR_LIGN_COUPE", + "LIGN_COUPE", + "REPERE='LOCAL'", + ( + ( + ( + "LIGN_COUPE", + "VECT_Y", + ), + "existeMCsousMCF", + ), + ), + 0, + ) + # autre probleme : s'il y a plusieurs mots clefs facteurs le traducteur peut, dans l'insertion, se tromper de mot clef facteur + ajouteMotClefDansFacteurSiRegle( + jdc, + "MACR_LIGN_COUPE", + "LIGN_COUPE", + "TYPE='GROUP_NO'", + ( + ( + ( + "LIGN_COUPE", + "GROUP_NO", + ), + "existeMCsousMCF", + ), + ), + 0, + ) + ajouteMotClefDansFacteurSiRegle( + jdc, + "MACR_LIGN_COUPE", + "LIGN_COUPE", + "TYPE='GROUP_MA'", + ( + ( + ( + "LIGN_COUPE", + "GROUP_MA", + ), + "existeMCsousMCF", + ), + ), + 0, + ) ################################################################################ ####################### traitement DRUCKER_PRAGER ####################### - dPRAGER={"DRUCKER_PRAGER":"DRUCK_PRAGER",} - changementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dPRAGER) - changementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_INCR","RELATION",dPRAGER) - changementValeurDsMCF(jdc,"SIMU_POINT_MAT","COMP_INCR","RELATION",dPRAGER) - changementValeurDsMCF(jdc,"CALC_PRECONT","COMP_INCR","RELATION",dPRAGER) + dPRAGER = { + "DRUCKER_PRAGER": "DRUCK_PRAGER", + } + changementValeurDsMCF(jdc, "STAT_NON_LINE", "COMP_INCR", "RELATION", dPRAGER) + changementValeurDsMCF(jdc, "DYNA_NON_LINE", "COMP_INCR", "RELATION", dPRAGER) + changementValeurDsMCF(jdc, "SIMU_POINT_MAT", "COMP_INCR", "RELATION", dPRAGER) + changementValeurDsMCF(jdc, "CALC_PRECONT", "COMP_INCR", "RELATION", dPRAGER) ######################################################################### ####################### traitement RELATION_KIT ####################### - dKIT={"ELAS_THER":"ELAS",} - changementValeurDsMCF(jdc,"STAT_NON_LINE","COMP_INCR","RELATION_KIT",dKIT) - changementValeurDsMCF(jdc,"DYNA_NON_LINE","COMP_INCR","RELATION_KIT",dKIT) - changementValeurDsMCF(jdc,"SIMU_POINT_MAT","COMP_INCR","RELATION_KIT",dKIT) - changementValeurDsMCF(jdc,"CALC_PRECONT","COMP_INCR","RELATION_KIT",dKIT) + dKIT = { + "ELAS_THER": "ELAS", + } + changementValeurDsMCF(jdc, "STAT_NON_LINE", "COMP_INCR", "RELATION_KIT", dKIT) + changementValeurDsMCF(jdc, "DYNA_NON_LINE", "COMP_INCR", "RELATION_KIT", dKIT) + changementValeurDsMCF(jdc, "SIMU_POINT_MAT", "COMP_INCR", "RELATION_KIT", dKIT) + changementValeurDsMCF(jdc, "CALC_PRECONT", "COMP_INCR", "RELATION_KIT", dKIT) ######################################################################### - - f=open(outfile,'w') + f = open(outfile, "w") f.write(jdc.getSource()) f.close() log.ferme(hdlr) + def main(): parser = argparse.ArgumentParser(usage=usage) - parser.add_argument('-i','--infile', dest="infile", default='toto.comm', - help="Le fichier COMM en entree, a traduire") - parser.add_argument('-o','--outfile', dest="outfile", default='tutu.comm', - help="Le fichier COMM en sortie, traduit") + parser.add_argument( + "-i", + "--infile", + dest="infile", + default="toto.comm", + help="Le fichier COMM en entree, a traduire", + ) + parser.add_argument( + "-o", + "--outfile", + dest="outfile", + default="tutu.comm", + help="Le fichier COMM en sortie, traduit", + ) args = parser.parse_args() - traduc(args.infile,args.outfile) + traduc(args.infile, args.outfile) + -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/Traducteur/traduitV9V10.py b/Traducteur/traduitV9V10.py index bc7bd89c..ce759f1c 100755 --- a/Traducteur/traduitV9V10.py +++ b/Traducteur/traduitV9V10.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,729 +20,1383 @@ # """ """ -usage="""usage: %prog [options] +usage = """usage: %prog [options] Typical use is: python traduitV9V10.py --infile=xxxx --outfile=yyyy """ -import argparse # optparse deprecated since Python version 3.2 +import argparse # optparse deprecated since Python version 3.2 import sys import Traducteur.log as log -from Traducteur.load import getJDC +from Traducteur.load import getJDC from Traducteur.mocles import parseKeywords -from Traducteur.removemocle import * -from Traducteur.renamemocle import * -from Traducteur.renamemocle import * -from Traducteur.inseremocle import * +from Traducteur.removemocle import * +from Traducteur.renamemocle import * +from Traducteur.renamemocle import * +from Traducteur.inseremocle import * from Traducteur.changeValeur import * -from Traducteur.movemocle import * -from Traducteur.dictErreurs import * +from Traducteur.movemocle import * +from Traducteur.dictErreurs import * from Traducteur.regles import pasDeRegle -atraiter=("AFFE_CARA_ELEM","AFFE_CHAR_CINE","AFFE_CHAR_MECA","AFFE_CHAR_MECA_F","AFFE_MATERIAU","AFFE_MODELE", - "CALC_CHAM_ELEM","CALC_ELEM","CALC_G","CALC_META","CALC_MODAL","CALC_PRECONT","CALCUL","CALC_MISS","CALC_NO", - "COMB_FOURIER","COMB_SISM_MODAL","CREA_CHAMP","CREA_RESU", - "DEFI_BASE_MODALE","DEFI_COMPOR","DEFI_CONTACT","DEFI_GLRC","DEFI_LIST_INST","DEFI_MATERIAU", - "DYNA_ISS_VARI","DYNA_LINE_HARM","DYNA_LINE_TRAN","DYNA_NON_LINE","DYNA_TRAN_MODAL", - "EXTR_RESU","IMPR_MACR_ELEM","IMPR_MATRICE","IMPR_RESU","LIRE_RESU", - "MACR_ADAP_MAIL","MACR_ASCOUF_CALC","MACR_ASPIC_CALC","MACR_ECREVISSE", - "MACR_INFO_MAIL","MACR_LIGN_COUPE","MACRO_ELAS_MULT","MACRO_MATR_AJOU","MACRO_MISS_3D", - "MECA_STATIQUE","MODE_ITER_INV","MODE_ITER_SIMULT","MODE_STATIQUE","MODI_REPERE", - "POST_CHAM_XFEM","POST_ELEM","POST_GP","POST_K1_K2_K3","POST_RCCM","POST_RELEVE_T","POST_ZAC", - "PROJ_CHAMP","PROJ_MESU_MODAL","RECU_FONCTION","REST_SOUS_STRUC","REST_GENE_PHYS","REST_SPEC_PHYS", - "STAT_NON_LINE","SIMU_POINT_MAT","TEST_RESU","THER_LINEAIRE","THER_NON_LINE","THER_NON_LINE_MO",) - -dict_erreurs={ -# STA10 -# - "AFFE_CHAR_MECA_CONTACT":"Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", - "AFFE_CHAR_MECA_LIAISON_UNILATER":"Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", - "AFFE_CHAR_MECA_F_LIAISON_UNILATER":"Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", - "AFFE_CHAR_MECA_GRAPPE_FLUIDE":"Resorption de GRAPPE_FLUIDE en version 10", - "DEFI_MATERIAU_LMARC":"Resorption loi LMARC en version 10", - "DEFI_MATERIAU_LMARC_FO":"Resorption loi LMARC en version 10", - "POST_ZAC":"Resorption POST_ZAC en version 10", - "AFFE_CHAR_MECA_ARLEQUIN":"Resorption ARLEQUIN en version 10", - - "PROJ_CHAMP_CHAM_NO":"Attention, verifier pour PROJ_CHAMP la presence de MODELE1/MAILLAGE1 et MODELE2/MAILLAGE2", - - "COMB_SISM_MODAL_COMB_MULT_APPUI":"Attention, verifier GROUP_APPUI pour COMB_SISM_MODAL car on est dans le cas MULTI_APPUI=DECORRELE", - - "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":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans STAT_NON_LINE", - "CALC_PRECONT_INCREMENT":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans CALC_PRECONT", - "DYNA_NON_LINE_INCREMENT":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans DYNA_NON_LINE", - "MACR_ASCOUF_CALC_INCREMENT":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans MACR_ASCOUF_CALC", - "MACR_ASPIQ_CALC_INCREMENT":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans MACR_ASPIQ_CALC", - "SIMU_POINT_MAT_INCREMENT":"Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans SIMU_POINT_MAT", - - "CALC_ELEM_SENSIBILITE":"Le post-traitement SENSIBILITE est a supprimer de CALC_ELEM et a faire via CALC_SENSI", - - "CALC_MISS_OPTION":"Attention, transfert MACRO_MISS_3D en CALC_MISS : utiliser un DEFI_SOL_MISS pour obtenir TABLE_SOL", - } - -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 +atraiter = ( + "AFFE_CARA_ELEM", + "AFFE_CHAR_CINE", + "AFFE_CHAR_MECA", + "AFFE_CHAR_MECA_F", + "AFFE_MATERIAU", + "AFFE_MODELE", + "CALC_CHAM_ELEM", + "CALC_ELEM", + "CALC_G", + "CALC_META", + "CALC_MODAL", + "CALC_PRECONT", + "CALCUL", + "CALC_MISS", + "CALC_NO", + "COMB_FOURIER", + "COMB_SISM_MODAL", + "CREA_CHAMP", + "CREA_RESU", + "DEFI_BASE_MODALE", + "DEFI_COMPOR", + "DEFI_CONTACT", + "DEFI_GLRC", + "DEFI_LIST_INST", + "DEFI_MATERIAU", + "DYNA_ISS_VARI", + "DYNA_LINE_HARM", + "DYNA_LINE_TRAN", + "DYNA_NON_LINE", + "DYNA_TRAN_MODAL", + "EXTR_RESU", + "IMPR_MACR_ELEM", + "IMPR_MATRICE", + "IMPR_RESU", + "LIRE_RESU", + "MACR_ADAP_MAIL", + "MACR_ASCOUF_CALC", + "MACR_ASPIC_CALC", + "MACR_ECREVISSE", + "MACR_INFO_MAIL", + "MACR_LIGN_COUPE", + "MACRO_ELAS_MULT", + "MACRO_MATR_AJOU", + "MACRO_MISS_3D", + "MECA_STATIQUE", + "MODE_ITER_INV", + "MODE_ITER_SIMULT", + "MODE_STATIQUE", + "MODI_REPERE", + "POST_CHAM_XFEM", + "POST_ELEM", + "POST_GP", + "POST_K1_K2_K3", + "POST_RCCM", + "POST_RELEVE_T", + "POST_ZAC", + "PROJ_CHAMP", + "PROJ_MESU_MODAL", + "RECU_FONCTION", + "REST_SOUS_STRUC", + "REST_GENE_PHYS", + "REST_SPEC_PHYS", + "STAT_NON_LINE", + "SIMU_POINT_MAT", + "TEST_RESU", + "THER_LINEAIRE", + "THER_NON_LINE", + "THER_NON_LINE_MO", +) + +dict_erreurs = { + # STA10 + # + "AFFE_CHAR_MECA_CONTACT": "Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_LIAISON_UNILATER": "Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_F_LIAISON_UNILATER": "Attention, modification de la definition du CONTACT : nommer DEFI_CONTACT,verifier les parametres globaux et le mettre dans le calcul", + "AFFE_CHAR_MECA_GRAPPE_FLUIDE": "Resorption de GRAPPE_FLUIDE en version 10", + "DEFI_MATERIAU_LMARC": "Resorption loi LMARC en version 10", + "DEFI_MATERIAU_LMARC_FO": "Resorption loi LMARC en version 10", + "POST_ZAC": "Resorption POST_ZAC en version 10", + "AFFE_CHAR_MECA_ARLEQUIN": "Resorption ARLEQUIN en version 10", + "PROJ_CHAMP_CHAM_NO": "Attention, verifier pour PROJ_CHAMP la presence de MODELE1/MAILLAGE1 et MODELE2/MAILLAGE2", + "COMB_SISM_MODAL_COMB_MULT_APPUI": "Attention, verifier GROUP_APPUI pour COMB_SISM_MODAL car on est dans le cas MULTI_APPUI=DECORRELE", + "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": "Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans STAT_NON_LINE", + "CALC_PRECONT_INCREMENT": "Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans CALC_PRECONT", + "DYNA_NON_LINE_INCREMENT": "Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans DYNA_NON_LINE", + "MACR_ASCOUF_CALC_INCREMENT": "Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans MACR_ASCOUF_CALC", + "MACR_ASPIQ_CALC_INCREMENT": "Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans MACR_ASPIQ_CALC", + "SIMU_POINT_MAT_INCREMENT": "Attention, modification de la subdivision des pas : nommer DEFI_LIST_INST et verifier son appel dans SIMU_POINT_MAT", + "CALC_ELEM_SENSIBILITE": "Le post-traitement SENSIBILITE est a supprimer de CALC_ELEM et a faire via CALC_SENSI", + "CALC_MISS_OPTION": "Attention, transfert MACRO_MISS_3D en CALC_MISS : utiliser un DEFI_SOL_MISS pour obtenir TABLE_SOL", +} + +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") - + 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/. + # 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") + 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") + 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) + 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()) + removeMotCle(jdc, "CALC_MODAL", "SOLVEUR", pasDeRegle()) ##################### traitement DYNA_TRAN-MODAL ADAPT ################# - changementValeur(jdc,"DYNA_TRAN_MODAL","METHODE",{"ADAPT":"ADAPT_ORDRE2"}) + changementValeur(jdc, "DYNA_TRAN_MODAL", "METHODE", {"ADAPT": "ADAPT_ORDRE2"}) #################### traitement STAT/DYNA_NON_LINE OBSERVATION SUIVI_DDL=NON ########### - removeMotCleInFactCourantSiRegle(jdc,"STAT_NON_LINE","OBSERVATION","SUIVI_DDL",((("SUIVI_DDL","NON",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"DYNA_NON_LINE","OBSERVATION","SUIVI_DDL",((("SUIVI_DDL","NON",jdc),"MCsousMCFcourantaPourValeur"),)) + removeMotCleInFactCourantSiRegle( + jdc, + "STAT_NON_LINE", + "OBSERVATION", + "SUIVI_DDL", + ((("SUIVI_DDL", "NON", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "DYNA_NON_LINE", + "OBSERVATION", + "SUIVI_DDL", + ((("SUIVI_DDL", "NON", jdc), "MCsousMCFcourantaPourValeur"),), + ) ################### traitement STAT/DYNA_NON_LINE ARCH_ETAT_INIT ########### - removeMotCleInFact(jdc,"STAT_NON_LINE","ARCHIVAGE","ARCH_ETAT_INIT",pasDeRegle(),0) - removeMotCleInFact(jdc,"SIMU_POINT_MAT","ARCHIVAGE","ARCH_ETAT_INIT",pasDeRegle(),0) - removeMotCleInFact(jdc,"DYNA_NON_LINE","ARCHIVAGE","ARCH_ETAT_INIT",pasDeRegle(),0) + removeMotCleInFact( + jdc, "STAT_NON_LINE", "ARCHIVAGE", "ARCH_ETAT_INIT", pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "SIMU_POINT_MAT", "ARCHIVAGE", "ARCH_ETAT_INIT", pasDeRegle(), 0 + ) + removeMotCleInFact( + jdc, "DYNA_NON_LINE", "ARCHIVAGE", "ARCH_ETAT_INIT", pasDeRegle(), 0 + ) ################### traitement STAT/DYNA_NON_LINE CRIT_FLAMB ############### - removeMotCleInFactCourantSiRegle(jdc,"STAT_NON_LINE","CRIT_FLAMB","INST_CALCUL",((("INST_CALCUL","TOUT_PAS",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"DYNA_NON_LINE","CRIT_FLAMB","INST_CALCUL",((("INST_CALCUL","TOUT_PAS",jdc),"MCsousMCFcourantaPourValeur"),)) + removeMotCleInFactCourantSiRegle( + jdc, + "STAT_NON_LINE", + "CRIT_FLAMB", + "INST_CALCUL", + ((("INST_CALCUL", "TOUT_PAS", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "DYNA_NON_LINE", + "CRIT_FLAMB", + "INST_CALCUL", + ((("INST_CALCUL", "TOUT_PAS", jdc), "MCsousMCFcourantaPourValeur"),), + ) #####COMPORTEMENT/CARA ################### traitement AFFE_MODELE/SHB8 ########################## - changementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",{"SHB8":"SHB"}) + changementValeurDsMCF(jdc, "AFFE_MODELE", "AFFE", "MODELISATION", {"SHB8": "SHB"}) ################### 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) + 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"} - removeMotCleInFactCourantSiRegle(jdc,"STAT_NON_LINE","COMP_ELAS","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"STAT_NON_LINE","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"DYNA_NON_LINE","COMP_ELAS","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"DYNA_NON_LINE","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"CALCUL","COMP_ELAS","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"CALCUL","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"MACR_ASCOUF_CALC","COMP_ELAS","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"MACR_ASCOUF_CALC","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"MACR_ASPIQ_CALC","COMP_ELAS","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"MACR_ASPIQ_CALC","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"SIMU_POINT_MAT","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"CALC_PRE_CONT","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"CALC_NO","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"LIRE_RESU","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - removeMotCleInFactCourantSiRegle(jdc,"MACR_ECREVISSE","COMP_INCR","RESO_INTE",((("RESO_INTE","IMPLICITE",jdc),"MCsousMCFcourantaPourValeur"),)) - - 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") + dALGOI = {"RUNGE_KUTTA_2": "RUNGE_KUTTA", "RUNGE_KUTTA_4": "RUNGE_KUTTA"} + removeMotCleInFactCourantSiRegle( + jdc, + "STAT_NON_LINE", + "COMP_ELAS", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "STAT_NON_LINE", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "DYNA_NON_LINE", + "COMP_ELAS", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "DYNA_NON_LINE", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "CALCUL", + "COMP_ELAS", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "CALCUL", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "MACR_ASCOUF_CALC", + "COMP_ELAS", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "MACR_ASCOUF_CALC", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "MACR_ASPIQ_CALC", + "COMP_ELAS", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "MACR_ASPIQ_CALC", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "SIMU_POINT_MAT", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "CALC_PRE_CONT", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "CALC_NO", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "LIRE_RESU", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + removeMotCleInFactCourantSiRegle( + jdc, + "MACR_ECREVISSE", + "COMP_INCR", + "RESO_INTE", + ((("RESO_INTE", "IMPLICITE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + + 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) + 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"}) + 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) + 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) + 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") + 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") + 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") - ajouteMotClefDansFacteurCourantSiRegle(jdc,"AFFE_CARA_ELEM","DISCRET","SYME='NON'",((("CARA",dlist_DISCRET,jdc),"MCsousMCFcourantaPourValeurDansListe"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"AFFE_CARA_ELEM","DISCRET_2D","SYME='NON'",((("CARA",dlist_DISCRET,jdc),"MCsousMCFcourantaPourValeurDansListe"),)) - changementValeurDsMCF(jdc,"AFFE_CARA_ELEM","DISCRET_2D","CARA",dDISCRET) - changementValeurDsMCF(jdc,"AFFE_CARA_ELEM","DISCRET","CARA",dDISCRET) + 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") + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "AFFE_CARA_ELEM", + "DISCRET", + "SYME='NON'", + ((("CARA", dlist_DISCRET, jdc), "MCsousMCFcourantaPourValeurDansListe"),), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "AFFE_CARA_ELEM", + "DISCRET_2D", + "SYME='NON'", + ((("CARA", dlist_DISCRET, jdc), "MCsousMCFcourantaPourValeurDansListe"),), + ) + 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") - ajouteMotClefDansFacteurCourantSiRegle(jdc,"AFFE_CHAR_MECA","CONTACT","RESOLUTION='NON'",((("METHODE","VERIF",jdc),"MCsousMCFcourantaPourValeur"),)) - 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"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='LAGRANGIEN'",((("METHODE","LAGRANGIEN",jdc),"MCsousMCFcourantaPourValeur"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_FROT='LAGRANGIEN'",((("METHODE","LAGRANGIEN",jdc),"MCsousMCFcourantaPourValeur"),(("COULOMB",),"existeMCsousMCFcourant"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='GCP'",((("METHODE","GCP",jdc),"MCsousMCFcourantaPourValeur"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='PENALISATION'",((("METHODE","PENALISATION",jdc),"MCsousMCFcourantaPourValeur"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_FROT='PENALISATION'",((("METHODE","PENALISATION",jdc),"MCsousMCFcourantaPourValeur"),(("COULOMB",),"existeMCsousMCFcourant"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DEFI_CONTACT","ZONE","ALGO_CONT='CONTRAINTE'",((("METHODE","CONTRAINTE",jdc),"MCsousMCFcourantaPourValeur"),)) - 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") - + renameMotCleInFact( + jdc, "AFFE_CHAR_MECA", "CONTACT", "ITER_MULT_MAXI", "ITER_CONT_MULT" + ) + renameMotCleInFact(jdc, "AFFE_CHAR_MECA", "CONTACT", "NB_REAC_GEOM", "NB_ITER_GEOM") + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "AFFE_CHAR_MECA", + "CONTACT", + "RESOLUTION='NON'", + ((("METHODE", "VERIF", jdc), "MCsousMCFcourantaPourValeur"),), + ) + 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"),), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "ALGO_CONT='LAGRANGIEN'", + ((("METHODE", "LAGRANGIEN", jdc), "MCsousMCFcourantaPourValeur"),), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "ALGO_FROT='LAGRANGIEN'", + ( + (("METHODE", "LAGRANGIEN", jdc), "MCsousMCFcourantaPourValeur"), + (("COULOMB",), "existeMCsousMCFcourant"), + ), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "ALGO_CONT='GCP'", + ((("METHODE", "GCP", jdc), "MCsousMCFcourantaPourValeur"),), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "ALGO_CONT='PENALISATION'", + ((("METHODE", "PENALISATION", jdc), "MCsousMCFcourantaPourValeur"),), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "ALGO_FROT='PENALISATION'", + ( + (("METHODE", "PENALISATION", jdc), "MCsousMCFcourantaPourValeur"), + (("COULOMB",), "existeMCsousMCFcourant"), + ), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DEFI_CONTACT", + "ZONE", + "ALGO_CONT='CONTRAINTE'", + ((("METHODE", "CONTRAINTE", jdc), "MCsousMCFcourantaPourValeur"),), + ) + 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") + 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 apparait dans DECORELLE - moveMotCleFromFactToFather(jdc,"COMB_SISM_MODAL","EXCIT","MONO_APPUI") - moveMotCleFromFactToFather(jdc,"COMB_SISM_MODAL","EXCIT","MULTI_APPUI") - removeMotCleInFactSiRegle(jdc,"COMB_SISM_MODAL","COMB_MULT_APPUI","TYPE_COMBI",((("MULTI_APPUI","DECORRELE",jdc),"MCaPourValeur"),)) - renameMotCleSiRegle(jdc,"COMB_SISM_MODAL","COMB_MULT_APPUI","GROUP_APPUI",((("MULTI_APPUI","DECORRELE",jdc),"MCaPourValeur"),),1) + moveMotCleFromFactToFather(jdc, "COMB_SISM_MODAL", "EXCIT", "MONO_APPUI") + moveMotCleFromFactToFather(jdc, "COMB_SISM_MODAL", "EXCIT", "MULTI_APPUI") + removeMotCleInFactSiRegle( + jdc, + "COMB_SISM_MODAL", + "COMB_MULT_APPUI", + "TYPE_COMBI", + ((("MULTI_APPUI", "DECORRELE", jdc), "MCaPourValeur"),), + ) + renameMotCleSiRegle( + jdc, + "COMB_SISM_MODAL", + "COMB_MULT_APPUI", + "GROUP_APPUI", + ((("MULTI_APPUI", "DECORRELE", jdc), "MCaPourValeur"),), + 1, + ) ######################## traitement DYNA_TRAN_MODAL ################## - ajouteMotClefDansFacteurCourantSiRegle(jdc,"DYNA_TRAN_MODAL","CHOC","FROTTEMENT='COULOMB'",((("COULOMB",),"existeMCsousMCFcourant"),)) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "DYNA_TRAN_MODAL", + "CHOC", + "FROTTEMENT='COULOMB'", + ((("COULOMB",), "existeMCsousMCFcourant"),), + ) ######################### 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") + 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") + 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") - + renameMotCle(jdc, "DYNA_ISS_VARI", "PAS", "FREQ_PAS") #####IMPRESSION #################### traitement IMPR_RESU ####################### - removeMotCleInFact(jdc,"IMPR_RESU","RESU","INFO_RESU") + removeMotCleInFact(jdc, "IMPR_RESU", "RESU", "INFO_RESU") ######################### traitement IMPR_MATRICE #################### - removeCommande(jdc,"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"}) + 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_RELATIVE":"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") - ajouteMotClefDansFacteurCourantSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='BOITE'",((("RAYON",),"nexistepasMCsousMCFcourant"),)) - ajouteMotClefDansFacteurCourantSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='SPHERE'",((("RAYON",),"existeMCsousMCFcourant"),)) - changementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_5":"V10_1"}) - changementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_N":"V10_1_N"}) - changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_5":"V10_1"}) - changementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_N":"V10_1_N"}) + changementValeur( + jdc, + "MACR_ADAP_MAIL", + "TYPE_VALEUR_INDICA", + {"V_ABSOLUE": "ABSOLU", "V_RELATIVE": "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") + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ZONE", + "TYPE='BOITE'", + ((("RAYON",), "nexistepasMCsousMCFcourant"),), + ) + ajouteMotClefDansFacteurCourantSiRegle( + jdc, + "MACR_ADAP_MAIL", + "ZONE", + "TYPE='SPHERE'", + ((("RAYON",), "existeMCsousMCFcourant"),), + ) + changementValeur(jdc, "MACR_ADAP_MAIL", "VERSION_HOMARD", {"V9_5": "V10_1"}) + changementValeur(jdc, "MACR_ADAP_MAIL", "VERSION_HOMARD", {"V9_N": "V10_1_N"}) + changementValeur(jdc, "MACR_INFO_MAIL", "VERSION_HOMARD", {"V9_5": "V10_1"}) + changementValeur(jdc, "MACR_INFO_MAIL", "VERSION_HOMARD", {"V9_N": "V10_1_N"}) ###################### 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) + 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) + 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) + renameMotCleInFact( + jdc, + "AFFE_CARA_ELEM", + "RIGI_PARASOL", + "UNITE_EUROPLEXUS", + "UNITE", + pasDeRegle(), + 0, + ) #################### traitement DEFI_GLRC/IMPRESSION ############# - removeMotCle(jdc,"DEFI_GLRC","IMPRESSION",pasDeRegle(),0) + 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) + 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) + 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) + 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) + 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", + # 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" - changementValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VARC","NOM_CHAM",dOPTION) - changementValeur(jdc,"COMB_FOURIER","NOM_CHAM",dOPTION) - changementValeur(jdc,"CREA_CHAMP","NOM_CHAM",dOPTION) - changementValeur(jdc,"CREA_RESU","NOM_CHAM",dOPTION) - changementValeurDsMCF(jdc,"EXTR_RESU","ARCHIVAGE","NOM_CHAM",dOPTION) - changementValeurDsMCF(jdc,"IMPR_RESU","RESU","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) - changementValeur(jdc,"MACR_ADAP_MAIL","NOM_CHAM",dOPTION) - changementValeurDsMCF(jdc,"MACR_ASPIC_CALC","IMPRESSION","NOM_CHAM",dOPTION) - changementValeur(jdc,"MACR_LIGN_COUPE","NOM_CHAM",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) - changementValeurDsMCF(jdc,"POST_RCCM","RESU_MECA","NOM_CHAM",dOPTION) - changementValeurDsMCF(jdc,"POST_RELEVE_T","ACTION","NOM_CHAM",dOPTION) - changementValeur(jdc,"PROJ_CHAMP","NOM_CHAM",dOPTION) - changementValeurDsMCF(jdc,"PROJ_MESU_MODAL","MODELE_MESURE","NOM_CHAM",dOPTION) - changementValeur(jdc,"RECU_FONCTION","NOM_CHAM",dOPTION) - changementValeur(jdc,"REST_GENE_PHYS","NOM_CHAM",dOPTION) - changementValeur(jdc,"REST_SOUS_STRUC","NOM_CHAM",dOPTION) - changementValeur(jdc,"REST_SPEC_PHYS","NOM_CHAM",dOPTION) - changementValeurDsMCF(jdc,"TEST_RESU","RESU","NOM_CHAM",dOPTION) - changementValeurDsMCF(jdc,"TEST_RESU","GENE","NOM_CHAM",dOPTION) - - changementValeur(jdc,"CALC_CHAM_ELEM","OPTION",dOPTION) - changementValeur(jdc,"CALC_ELEM","OPTION",dOPTION) - changementValeur(jdc,"CALC_META","OPTION",dOPTION) - changementValeur(jdc,"CALC_NO","OPTION",dOPTION) - changementValeur(jdc,"COMB_SISM_MODAL","OPTION",dOPTION) - changementValeur(jdc,"MECA_STATIQUE","OPTION",dOPTION) - changementValeurDsMCF(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","OPTION",dOPTION) - changementValeur(jdc,"THER_NON_LINE","OPTION",dOPTION) + 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" + changementValeurDsMCF(jdc, "AFFE_MATERIAU", "AFFE_VARC", "NOM_CHAM", dOPTION) + changementValeur(jdc, "COMB_FOURIER", "NOM_CHAM", dOPTION) + changementValeur(jdc, "CREA_CHAMP", "NOM_CHAM", dOPTION) + changementValeur(jdc, "CREA_RESU", "NOM_CHAM", dOPTION) + changementValeurDsMCF(jdc, "EXTR_RESU", "ARCHIVAGE", "NOM_CHAM", dOPTION) + changementValeurDsMCF(jdc, "IMPR_RESU", "RESU", "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) + changementValeur(jdc, "MACR_ADAP_MAIL", "NOM_CHAM", dOPTION) + changementValeurDsMCF(jdc, "MACR_ASPIC_CALC", "IMPRESSION", "NOM_CHAM", dOPTION) + changementValeur(jdc, "MACR_LIGN_COUPE", "NOM_CHAM", 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) + changementValeurDsMCF(jdc, "POST_RCCM", "RESU_MECA", "NOM_CHAM", dOPTION) + changementValeurDsMCF(jdc, "POST_RELEVE_T", "ACTION", "NOM_CHAM", dOPTION) + changementValeur(jdc, "PROJ_CHAMP", "NOM_CHAM", dOPTION) + changementValeurDsMCF(jdc, "PROJ_MESU_MODAL", "MODELE_MESURE", "NOM_CHAM", dOPTION) + changementValeur(jdc, "RECU_FONCTION", "NOM_CHAM", dOPTION) + changementValeur(jdc, "REST_GENE_PHYS", "NOM_CHAM", dOPTION) + changementValeur(jdc, "REST_SOUS_STRUC", "NOM_CHAM", dOPTION) + changementValeur(jdc, "REST_SPEC_PHYS", "NOM_CHAM", dOPTION) + changementValeurDsMCF(jdc, "TEST_RESU", "RESU", "NOM_CHAM", dOPTION) + changementValeurDsMCF(jdc, "TEST_RESU", "GENE", "NOM_CHAM", dOPTION) + + changementValeur(jdc, "CALC_CHAM_ELEM", "OPTION", dOPTION) + changementValeur(jdc, "CALC_ELEM", "OPTION", dOPTION) + changementValeur(jdc, "CALC_META", "OPTION", dOPTION) + changementValeur(jdc, "CALC_NO", "OPTION", dOPTION) + changementValeur(jdc, "COMB_SISM_MODAL", "OPTION", dOPTION) + changementValeur(jdc, "MECA_STATIQUE", "OPTION", dOPTION) + changementValeurDsMCF(jdc, "MACRO_ELAS_MULT", "CAS_CHARGE", "OPTION", dOPTION) + changementValeur(jdc, "THER_NON_LINE", "OPTION", dOPTION) ############ Message si suppressionValeurs ou Valeurs ambigue CALC_ELEM/OPTION - rOPTION=("'DEUL_ELGA_DEPL'","'DEUL_ELGA_TEMP'","'DURT_ELGA_META'", - "'ERRE_ELNO_DEPL'", "'ERRE_NOEU_ELEM'", "'ERRE_ELNO_ELEM'","'EPSP_NOEU_ZAC'","'HYDR_ELNO_ELGA'", - "'SIGM_NOEU_ZAC'","'SIGM_ELNO_SIEF'","'SIGM_NOEU_SIEF'","'SIPO_ELNO_SIEF'","'SIPO_NOEU_SIEF'", - "'SIRE_ELNO_DEPL'","'SIRE_NOEU_DEPL'","'SIEF_NOEU'", - "'PRES_ELNO_DBEL'", "'VARI_NOEU'") + rOPTION = ( + "'DEUL_ELGA_DEPL'", + "'DEUL_ELGA_TEMP'", + "'DURT_ELGA_META'", + "'ERRE_ELNO_DEPL'", + "'ERRE_NOEU_ELEM'", + "'ERRE_ELNO_ELEM'", + "'EPSP_NOEU_ZAC'", + "'HYDR_ELNO_ELGA'", + "'SIGM_NOEU_ZAC'", + "'SIGM_ELNO_SIEF'", + "'SIGM_NOEU_SIEF'", + "'SIPO_ELNO_SIEF'", + "'SIPO_NOEU_SIEF'", + "'SIRE_ELNO_DEPL'", + "'SIRE_NOEU_DEPL'", + "'SIEF_NOEU'", + "'PRES_ELNO_DBEL'", + "'VARI_NOEU'", + ) # Options ambigue : PRES_ELNO_DBEL --> prac_elno/prme_elno, ERRE* --> ERME_ELNO ou ERTH_ELNO selon PHENOMENE # En commentaires les commandes non concernees par rOPTION - genereErreurValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VARC","NOM_CHAM",rOPTION) - #genereErreurValeur(jdc,"COMB_FOURIER","NOM_CHAM",rOPTION) - genereErreurValeur(jdc,"CREA_CHAMP","NOM_CHAM",rOPTION) - genereErreurValeur(jdc,"CREA_RESU","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"EXTR_RESU","ARCHIVAGE","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"IMPR_RESU","RESU","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) - genereErreurValeur(jdc,"MACR_ADAP_MAIL","NOM_CHAM",rOPTION) - #genereErreurDsMCF(jdc,"MACR_ASPIC_CALC","IMPRESSION","NOM_CHAM",rOPTION) - genereErreurValeur(jdc,"MACR_LIGN_COUPE","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"MODI_REPERE","MODI_CHAM","NOM_CHAM",rOPTION) - #genereErreurValeurDsMCF(jdc,"POST_RCCM","RESU_MECA","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"POST_ELEM","INTEGRALE","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"POST_ELEM","MINMAX","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"POST_RELEVE_T","ACTION","NOM_CHAM",rOPTION) - genereErreurValeur(jdc,"PROJ_CHAMP","NOM_CHAM",rOPTION) - #genereErreurValeurDsMCF(jdc,"PROJ_MESU_MODAL","MODELE_MESURE","NOM_CHAM",rOPTION) - genereErreurValeur(jdc,"RECU_FONCTION","NOM_CHAM",rOPTION) - #genereErreurValeur(jdc,"REST_GENE_PHYS","NOM_CHAM",rOPTION) - #genereErreurValeur(jdc,"REST_SOUS_STRUC","NOM_CHAM",rOPTION) - #genereErreurValeur(jdc,"REST_SPEC_PHYS","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"TEST_RESU","RESU","NOM_CHAM",rOPTION) - genereErreurValeurDsMCF(jdc,"TEST_RESU","GENE","NOM_CHAM",rOPTION) - - genereErreurValeur(jdc,"CALC_CHAM_ELEM","OPTION",rOPTION) - genereErreurValeur(jdc,"CALC_ELEM","OPTION",rOPTION) - #genereErreurValeur(jdc,"CALC_META","OPTION",rOPTION) - genereErreurValeur(jdc,"CALC_NO","OPTION",rOPTION) - #genereErreurValeur(jdc,"COMB_SISM_MODAL","OPTION",rOPTION) - #genereErreurValeur(jdc,"MECA_STATIQUE","OPTION",rOPTION) - genereErreurValeurDsMCF(jdc,"MACRO_ELAS_MULT","CAS_CHARGE","OPTION",rOPTION) - #genereErreurValeur(jdc,"THER_NON_LINE","OPTION",rOPTION) + genereErreurValeurDsMCF(jdc, "AFFE_MATERIAU", "AFFE_VARC", "NOM_CHAM", rOPTION) + # genereErreurValeur(jdc,"COMB_FOURIER","NOM_CHAM",rOPTION) + genereErreurValeur(jdc, "CREA_CHAMP", "NOM_CHAM", rOPTION) + genereErreurValeur(jdc, "CREA_RESU", "NOM_CHAM", rOPTION) + genereErreurValeurDsMCF(jdc, "EXTR_RESU", "ARCHIVAGE", "NOM_CHAM", rOPTION) + genereErreurValeurDsMCF(jdc, "IMPR_RESU", "RESU", "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) + genereErreurValeur(jdc, "MACR_ADAP_MAIL", "NOM_CHAM", rOPTION) + # genereErreurDsMCF(jdc,"MACR_ASPIC_CALC","IMPRESSION","NOM_CHAM",rOPTION) + genereErreurValeur(jdc, "MACR_LIGN_COUPE", "NOM_CHAM", rOPTION) + genereErreurValeurDsMCF(jdc, "MODI_REPERE", "MODI_CHAM", "NOM_CHAM", rOPTION) + # genereErreurValeurDsMCF(jdc,"POST_RCCM","RESU_MECA","NOM_CHAM",rOPTION) + genereErreurValeurDsMCF(jdc, "POST_ELEM", "INTEGRALE", "NOM_CHAM", rOPTION) + genereErreurValeurDsMCF(jdc, "POST_ELEM", "MINMAX", "NOM_CHAM", rOPTION) + genereErreurValeurDsMCF(jdc, "POST_RELEVE_T", "ACTION", "NOM_CHAM", rOPTION) + genereErreurValeur(jdc, "PROJ_CHAMP", "NOM_CHAM", rOPTION) + # genereErreurValeurDsMCF(jdc,"PROJ_MESU_MODAL","MODELE_MESURE","NOM_CHAM",rOPTION) + genereErreurValeur(jdc, "RECU_FONCTION", "NOM_CHAM", rOPTION) + # genereErreurValeur(jdc,"REST_GENE_PHYS","NOM_CHAM",rOPTION) + # genereErreurValeur(jdc,"REST_SOUS_STRUC","NOM_CHAM",rOPTION) + # genereErreurValeur(jdc,"REST_SPEC_PHYS","NOM_CHAM",rOPTION) + genereErreurValeurDsMCF(jdc, "TEST_RESU", "RESU", "NOM_CHAM", rOPTION) + genereErreurValeurDsMCF(jdc, "TEST_RESU", "GENE", "NOM_CHAM", rOPTION) + + genereErreurValeur(jdc, "CALC_CHAM_ELEM", "OPTION", rOPTION) + genereErreurValeur(jdc, "CALC_ELEM", "OPTION", rOPTION) + # genereErreurValeur(jdc,"CALC_META","OPTION",rOPTION) + genereErreurValeur(jdc, "CALC_NO", "OPTION", rOPTION) + # genereErreurValeur(jdc,"COMB_SISM_MODAL","OPTION",rOPTION) + # genereErreurValeur(jdc,"MECA_STATIQUE","OPTION",rOPTION) + genereErreurValeurDsMCF(jdc, "MACRO_ELAS_MULT", "CAS_CHARGE", "OPTION", rOPTION) + # genereErreurValeur(jdc,"THER_NON_LINE","OPTION",rOPTION) ########### Message si CALC_ELEM/SENSIBILITE - genereErreurMCF(jdc,"CALC_ELEM","SENSIBILITE") + genereErreurMCF(jdc, "CALC_ELEM", "SENSIBILITE") # non fait CALC_NO OPTION=FORC_NODA_NONL ########## traitement MACRO_MISS_3D --> CALC_MISS - renameCommandeSiRegle(jdc,"MACRO_MISS_3D","CALC_MISS",((("OPTION","MODULE","MISS_IMPE",jdc),"MCsousMCFaPourValeur"),(("PARAMETRE","ISSF"),"nexistepasMCsousMCF"),(("PARAMETRE","DIRE_ONDE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_LISTE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_NB"),"nexistepasMCsousMCF"),)) - renameCommandeSiRegle(jdc,"MACRO_MISS_3D","CALC_MISS",((("OPTION","MODULE","MISS_IMPE",jdc),"MCsousMCFaPourValeur"),(("PARAMETRE","ISSF","NON",jdc),"MCsousMCFaPourValeur"),(("PARAMETRE","DIRE_ONDE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_LISTE"),"nexistepasMCsousMCF"),(("PARAMETRE","CONTR_NB"),"nexistepasMCsousMCF"),)) - removeMotCleInFact(jdc,"CALC_MISS","PARAMETRE","FICH_RESU_IMPE",pasDeRegle(),0) - removeMotCleInFact(jdc,"CALC_MISS","PARAMETRE","FICH_RESU_FORC",pasDeRegle(),0) - removeMotCleInFact(jdc,"CALC_MISS","PARAMETRE","FICH_POST_TRAI",pasDeRegle(),0) - removeMotCle(jdc,"CALC_MISS","UNITE_OPTI_MISS",pasDeRegle()) - removeMotCle(jdc,"CALC_MISS","UNITE_MODELE_SOL",pasDeRegle()) - removeMotCle(jdc,"CALC_MISS","OPTION",pasDeRegle(),1) - changementValeur(jdc,"CALC_MISS","VERSION",{"V1_4":"V6.5"}) - changementValeur(jdc,"CALC_MISS","VERSION",{"V1_5":"V6.6"}) - changementValeur(jdc,"CALC_MISS","VERSION",{"V1_3":"V6.5"}) - - macr="" - interf="" - amor="" + renameCommandeSiRegle( + jdc, + "MACRO_MISS_3D", + "CALC_MISS", + ( + (("OPTION", "MODULE", "MISS_IMPE", jdc), "MCsousMCFaPourValeur"), + (("PARAMETRE", "ISSF"), "nexistepasMCsousMCF"), + (("PARAMETRE", "DIRE_ONDE"), "nexistepasMCsousMCF"), + (("PARAMETRE", "CONTR_LISTE"), "nexistepasMCsousMCF"), + (("PARAMETRE", "CONTR_NB"), "nexistepasMCsousMCF"), + ), + ) + renameCommandeSiRegle( + jdc, + "MACRO_MISS_3D", + "CALC_MISS", + ( + (("OPTION", "MODULE", "MISS_IMPE", jdc), "MCsousMCFaPourValeur"), + (("PARAMETRE", "ISSF", "NON", jdc), "MCsousMCFaPourValeur"), + (("PARAMETRE", "DIRE_ONDE"), "nexistepasMCsousMCF"), + (("PARAMETRE", "CONTR_LISTE"), "nexistepasMCsousMCF"), + (("PARAMETRE", "CONTR_NB"), "nexistepasMCsousMCF"), + ), + ) + removeMotCleInFact(jdc, "CALC_MISS", "PARAMETRE", "FICH_RESU_IMPE", pasDeRegle(), 0) + removeMotCleInFact(jdc, "CALC_MISS", "PARAMETRE", "FICH_RESU_FORC", pasDeRegle(), 0) + removeMotCleInFact(jdc, "CALC_MISS", "PARAMETRE", "FICH_POST_TRAI", pasDeRegle(), 0) + removeMotCle(jdc, "CALC_MISS", "UNITE_OPTI_MISS", pasDeRegle()) + removeMotCle(jdc, "CALC_MISS", "UNITE_MODELE_SOL", pasDeRegle()) + removeMotCle(jdc, "CALC_MISS", "OPTION", pasDeRegle(), 1) + changementValeur(jdc, "CALC_MISS", "VERSION", {"V1_4": "V6.5"}) + changementValeur(jdc, "CALC_MISS", "VERSION", {"V1_5": "V6.6"}) + changementValeur(jdc, "CALC_MISS", "VERSION", {"V1_3": "V6.5"}) + + macr = "" + interf = "" + amor = "" for c in jdc.root.childNodes: - if c.name != "IMPR_MACR_ELEM" : continue + if c.name != "IMPR_MACR_ELEM": + continue for mc in c.childNodes: - if mc.name == "MACR_ELEM_DYNA" : macr=mc.getText(jdc) - if mc.name == "GROUP_MA_INTERF": interf=mc.getText(jdc) - if mc.name == "AMOR_REDUIT": amor=mc.getText(jdc) - if amor != "" : chercheOperInsereFacteur(jdc,"CALC_MISS",amor,pasDeRegle(),0) - if interf != "" : chercheOperInsereFacteur(jdc,"CALC_MISS",interf,pasDeRegle(),0) - if macr != "" : chercheOperInsereFacteur(jdc,"CALC_MISS",macr,pasDeRegle(),0) - - chercheOperInsereFacteur(jdc,"CALC_MISS","TABLE_SOL=''",pasDeRegle(),0) - chercheOperInsereFacteur(jdc,"CALC_MISS","TYPE_RESU='FICHIER'",pasDeRegle(),0) + if mc.name == "MACR_ELEM_DYNA": + macr = mc.getText(jdc) + if mc.name == "GROUP_MA_INTERF": + interf = mc.getText(jdc) + if mc.name == "AMOR_REDUIT": + amor = mc.getText(jdc) + if amor != "": + chercheOperInsereFacteur(jdc, "CALC_MISS", amor, pasDeRegle(), 0) + if interf != "": + chercheOperInsereFacteur(jdc, "CALC_MISS", interf, pasDeRegle(), 0) + if macr != "": + chercheOperInsereFacteur(jdc, "CALC_MISS", macr, pasDeRegle(), 0) + + chercheOperInsereFacteur(jdc, "CALC_MISS", "TABLE_SOL=''", pasDeRegle(), 0) + chercheOperInsereFacteur(jdc, "CALC_MISS", "TYPE_RESU='FICHIER'", pasDeRegle(), 0) ################################################################# - f=open(outfile,'w') + f = open(outfile, "w") f.write(jdc.getSource()) f.close() log.ferme(hdlr) + def main(): parser = argparse.ArgumentParser(usage=usage) - parser.add_argument('-i','--infile', dest="infile", default='toto.comm', - help="Le fichier COMM en entree, a traduire") - parser.add_argument('-o','--outfile', dest="outfile", default='tutu.comm', - help="Le fichier COMM en sortie, traduit") + parser.add_argument( + "-i", + "--infile", + dest="infile", + default="toto.comm", + help="Le fichier COMM en entree, a traduire", + ) + parser.add_argument( + "-o", + "--outfile", + dest="outfile", + default="tutu.comm", + help="Le fichier COMM en sortie, traduit", + ) args = parser.parse_args() - traduc(args.infile,args.outfile) + traduc(args.infile, args.outfile) + -if __name__ == '__main__': +if __name__ == "__main__": main() diff --git a/Traducteur/utils.py b/Traducteur/utils.py index 31ab5e87..98a9d55a 100644 --- a/Traducteur/utils.py +++ b/Traducteur/utils.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,26 +20,30 @@ import re + def indexToCoordinates(src, index): """return le numero de la colonne (x) et le numero de la ligne (y) dans src""" - y = src[: index].count("\n") - startOfLineIdx = src.rfind("\n", 0, index)+1 - x = index-startOfLineIdx + y = src[:index].count("\n") + startOfLineIdx = src.rfind("\n", 0, index) + 1 + x = index - startOfLineIdx return x, y + def lineToDict(line): """Transforme une ligne (string) en un dictionnaire de mots - reperes par le numero de la colonne""" + reperes par le numero de la colonne""" words = re.split("(\w+)", line) - h = {};i = 0 + h = {} + i = 0 for word in words: h[i] = word - i+=len(word) + i += len(word) return h + def dictToLine(d): """Transformation inverse: a partir d'un dictionnaire retourne une ligne""" cols = d cols.sort() - return "".join([d[colno]for colno in cols]) + return "".join([d[colno] for colno in cols]) diff --git a/Traducteur/visiteur.py b/Traducteur/visiteur.py index 94307123..ee355795 100644 --- a/Traducteur/visiteur.py +++ b/Traducteur/visiteur.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2017 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,61 +20,67 @@ import re from ast import NodeVisitor -debug=0 -class MatchFinder (NodeVisitor): - """Visiteur de base : gestion des matches """ - def reset(self,line): - self.matches=[] +debug = 0 + + +class MatchFinder(NodeVisitor): + """Visiteur de base : gestion des matches""" + + def reset(self, line): + self.matches = [] self._matches = [] - self.words = re.split("(\w+)", line) # every other one is a non word + self.words = re.split("(\w+)", line) # every other one is a non word self.positions = [] i = 0 for word in self.words: self.positions.append(i) - i+=len(word) + i += len(word) self.index = 0 - if debug : print ('fin reset', self.words) + if debug: + print("fin reset", self.words) def popWordsUpTo(self, word): if word == "*": - return # won't be able to find this + return # won't be able to find this posInWords = self.words.index(word) idx = self.positions[posInWords] - self.words = self.words[posInWords+1:] - self.positions = self.positions[posInWords+1:] + self.words = self.words[posInWords + 1 :] + self.positions = self.positions[posInWords + 1 :] - def appendMatch(self,name): + def appendMatch(self, name): idx = self.getNextIndexOfWord(name) self._matches.append((idx, name)) - def getNextIndexOfWord(self,name): + def getNextIndexOfWord(self, name): return self.positions[self.words.index(name)] class KeywordFinder(MatchFinder): - """Visiteur pour les keywords d'une commande """ + """Visiteur pour les keywords d'une commande""" - def visit_keyword(self,node): - if debug : print (' visit_keyword', node.arg) + def visit_keyword(self, node): + if debug: + print(" visit_keyword", node.arg) idx = self.getNextIndexOfWord(node.arg) self.popWordsUpTo(node.arg) - prevmatches=self._matches + prevmatches = self._matches self._matches = [] - #for child in node.getChildNodes(): + # for child in node.getChildNodes(): # self.visit(child) self.generic_visit(node) - prevmatches.append((idx, node.arg,self._matches)) - self._matches=prevmatches - #on ne garde que les matches du niveau Keyword le plus haut - self.matches=self._matches + prevmatches.append((idx, node.arg, self._matches)) + self._matches = prevmatches + # on ne garde que les matches du niveau Keyword le plus haut + self.matches = self._matches - def visit_Tuple(self,node): - matchlist=[] + def visit_Tuple(self, node): + matchlist = [] # Pour eviter les tuples et listes ordinaires, - if not hasattr(node,'getChildNodes') : return - print ('*********************************************************************') - print ("_____________ visit_Tuple", node) + if not hasattr(node, "getChildNodes"): + return + print("*********************************************************************") + print("_____________ visit_Tuple", node) for child in node.getChildNodes(): self._matches = [] self.visit(child) @@ -82,17 +88,19 @@ class KeywordFinder(MatchFinder): # Pour eviter les tuples et listes ordinaires, # on ne garde que les visites fructueuses matchlist.append(self._matches) - self._matches=matchlist - #self.generic_visit(node) + self._matches = matchlist + # self.generic_visit(node) - visit_List=visit_Tuple + visit_List = visit_Tuple - def visit_Name(self,node): - if debug : print ('visit_Name', node.id) + def visit_Name(self, node): + if debug: + print("visit_Name", node.id) self.popWordsUpTo(node.id) self.generic_visit(node) - def visit_AssName(self,node): - if debug : print ('visit_AssName', node.id) + def visit_AssName(self, node): + if debug: + print("visit_AssName", node.id) self.popWordsUpTo(node.id) self.generic_visit(node) diff --git a/Validation/CMakeLists.txt b/Validation/CMakeLists.txt index e3ce0580..c8c84624 100644 --- a/Validation/CMakeLists.txt +++ b/Validation/CMakeLists.txt @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR diff --git a/Validation/V_AU_MOINS_UN.py b/Validation/V_AU_MOINS_UN.py index bc43c083..ce4692be 100644 --- a/Validation/V_AU_MOINS_UN.py +++ b/Validation/V_AU_MOINS_UN.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,34 +17,36 @@ # # # ====================================================================== +from builtins import object + class AU_MOINS_UN(object): """ - La regle AU_MOINS_UN verifie que l'on trouve au moins un des mots-cles - de la regle parmi les arguments d'un OBJECT. + La regle AU_MOINS_UN verifie que l'on trouve au moins un des mots-cles + de la regle parmi les arguments d'un OBJECT. - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif verifie que l'on trouve au moins un des mos-cles - de la liste self.mcs parmi les elements de args + La methode verif verifie que l'on trouve au moins un des mos-cles + de la liste self.mcs parmi les elements de args - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on compte le nombre de mots cles presents - text = '' + text = "" count = 0 args = self.listeToDico(args) for mc in self.mcs: - if mc in args : + if mc in args: count = count + 1 if count == 0: - text = "- Il faut au moins un mot-cle parmi : " + repr(self.mcs)+'\n' + text = "- Il faut au moins un mot-cle parmi : " + repr(self.mcs) + "\n" return text, 0 return text, 1 diff --git a/Validation/V_AU_PLUS_UN.py b/Validation/V_AU_PLUS_UN.py index b44c2e5f..b64ae16b 100644 --- a/Validation/V_AU_PLUS_UN.py +++ b/Validation/V_AU_PLUS_UN.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -16,34 +16,37 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +from builtins import object + class AU_PLUS_UN(object): """ - La regle verifie que l'on trouve 1 (au plus) des mots-cles - de la regle parmi les arguments d'un OBJECT. + La regle verifie que l'on trouve 1 (au plus) des mots-cles + de la regle parmi les arguments d'un OBJECT. - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif verifie que l'on trouve 1 (au plus) des mos-cles - de la liste self.mcs parmi les elements de args + La methode verif verifie que l'on trouve 1 (au plus) des mos-cles + de la liste self.mcs parmi les elements de args - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on compte le nombre de mots cles presents - text = '' + text = "" count = 0 args = self.listeToDico(args) for mc in self.mcs: count = count + args.get(mc, 0) if count > 1: - text = "- Il ne faut qu'un mot-cle (au plus) parmi : " + \ - repr(self.mcs)+'\n' + text = ( + "- Il ne faut qu'un mot-cle (au plus) parmi : " + repr(self.mcs) + "\n" + ) return text, 0 return text, 1 @@ -56,4 +59,4 @@ class AU_PLUS_UN(object): dico[arg] = dico.get(arg, 0) + 1 return dico else: - raise Exception( "Erreur ce n'est ni un dictionnaire ni une liste %s" % args) + raise Exception("Erreur ce n'est ni un dictionnaire ni une liste %s" % args) diff --git a/Validation/V_A_CLASSER.py b/Validation/V_A_CLASSER.py index b3259a78..645f4c16 100644 --- a/Validation/V_A_CLASSER.py +++ b/Validation/V_A_CLASSER.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,33 +17,40 @@ # # # ====================================================================== - - - from builtins import str +from builtins import object + class A_CLASSER(object): """ - La regle A_CLASSER verifie que ... + La regle A_CLASSER verifie que ... """ def __init__(self, *args): if len(args) > 2: - print ("Erreur a la creation de la regle A_CLASSER(%s)" % str(args)) + print("Erreur a la creation de la regle A_CLASSER(%s)" % str(args)) return self.args = args - if type(args[0]) == tuple: self.args0 = args[0] - elif type(args[0]) == str: self.args0 = (args[0],) + if type(args[0]) == tuple: + self.args0 = args[0] + elif type(args[0]) == str: + self.args0 = (args[0],) else: - print ( "Le premier argument de : %s doit etre un tuple ou une chaine" % str(args)) + print( + "Le premier argument de : %s doit etre un tuple ou une chaine" + % str(args) + ) if type(args[1]) == tuple: self.args1 = args[1] elif type(args[1]) == str: self.args1 = (args[1],) else: - print ("Le deuxieme argument de : %s doit etre un tuple ou une chaine" % str(args)) + print( + "Le deuxieme argument de : %s doit etre un tuple ou une chaine" + % str(args) + ) # creation de la liste des mcs liste = [] liste.extend(self.args0) @@ -52,8 +59,8 @@ class A_CLASSER(object): self.initCouplesPermis() def initCouplesPermis(self): - """ Cree la liste des couples permis parmi les self.args, cad pour chaque element - de self.args0 cree tous les couples possibles avec un element de self.args1""" + """Cree la liste des couples permis parmi les self.args, cad pour chaque element + de self.args0 cree tous les couples possibles avec un element de self.args1""" liste = [] for arg0 in self.args0: for arg1 in self.args1: @@ -62,27 +69,32 @@ class A_CLASSER(object): def verif(self, args): """ - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # creation de la liste des couples presents dans le fichier de # commandes l_couples = [] couple = [] - text = u'' + text = "" test = 1 for nom in args: if nom in self.mcs: couple.append(nom) if len(couple) == 2: l_couples.append(tuple(couple)) - couple = [nom, ] + couple = [ + nom, + ] if len(couple) > 0: l_couples.append(tuple(couple)) # l_couples peut etre vide si l'on n'a pas reussi a trouver au moins un # element de self.mcs if len(l_couples) == 0: - message = "- Il faut qu'au moins un objet de la liste : %s soit suivi d'au moins un objet de la liste %s : " % (self.args0,self.args1) + message = ( + "- Il faut qu'au moins un objet de la liste : %s soit suivi d'au moins un objet de la liste %s : " + % (self.args0, self.args1) + ) return message, 0 # A ce stade, on a trouve des couples : il faut verifier qu'ils sont # tous licites @@ -92,16 +104,27 @@ class A_CLASSER(object): if len(couple) == 1: # on a un 'faux' couple if couple[0] not in self.args1: - text = text + "- L'objet : %s doit etre suivi d'un objet de la liste : %r\n" %(couple[0], self.args1) + text = ( + text + + "- L'objet : %s doit etre suivi d'un objet de la liste : %r\n" + % (couple[0], self.args1) + ) test = 0 else: if num > 1: # ce n'est pas le seul couple --> licite break else: - text = text + "- L'objet : %s doit etre precede d'un objet de la liste : %r\n" %(couple[0], self.args0) + text = ( + text + + "- L'objet : %s doit etre precede d'un objet de la liste : %r\n" + % (couple[0], self.args0) + ) test = 0 elif couple not in self.liste_couples: - text = text + "- L'objet : %s ne peut etre suivi de : %s\n" %(couple[0], couple[1]) + text = text + "- L'objet : %s ne peut etre suivi de : %s\n" % ( + couple[0], + couple[1], + ) test = 0 return text, test diff --git a/Validation/V_ENSEMBLE.py b/Validation/V_ENSEMBLE.py index 27c5d642..bbb7a221 100644 --- a/Validation/V_ENSEMBLE.py +++ b/Validation/V_ENSEMBLE.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 1991 - 2017 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2024 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -18,26 +18,28 @@ # # ====================================================================== +from builtins import object + class ENSEMBLE(object): """ - La regle verifie que si un mot-cle de self.mcs est present - parmi les elements de args tous les autres doivent etre presents. + La regle verifie que si un mot-cle de self.mcs est present + parmi les elements de args tous les autres doivent etre presents. - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif effectue la verification specifique a la regle. - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + La methode verif effectue la verification specifique a la regle. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on compte le nombre de mots cles presents, il doit etre egal a la liste # figurant dans la regle - text = '' + text = "" test = 1 args = self.listeToDico(args) pivot = None @@ -48,8 +50,15 @@ class ENSEMBLE(object): if pivot: for mc in self.mcs: if mc != pivot: - if not mc in args : - text = text + "- " + pivot + " etant present, " + \ - mc + " doit etre present" + '\n' + if not mc in args: + text = ( + text + + "- " + + pivot + + " etant present, " + + mc + + " doit etre present" + + "\n" + ) test = 0 return text, test diff --git a/Validation/V_ETAPE.py b/Validation/V_ETAPE.py index acfc91bb..94400e21 100644 --- a/Validation/V_ETAPE.py +++ b/Validation/V_ETAPE.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,8 +17,6 @@ # # # ====================================================================== - - """ Ce module contient la classe mixin ETAPE qui porte les methodes necessaires pour realiser la validation d'un objet de type ETAPE @@ -42,47 +40,45 @@ from Noyau.N_utils import AsType from Extensions.i18n import tr - class ETAPE(V_MCCOMPO.MCCOMPO): - """ - """ + """ """ def validChild(self): - """ Cette methode teste la validite des mots cles de l'etape """ + """Cette methode teste la validite des mots cles de l'etape""" for child in self.mcListe: if not child.isValid(): return 0 return 1 def validRegles(self, cr): - """ Cette methode teste la validite des regles de l'etape """ + """Cette methode teste la validite des regles de l'etape""" text_erreurs, test_regles = self.verifRegles() if not test_regles: - if cr == 'oui': - self.cr.fatal( "Regle(s) non respectee(s) : %s" % text_erreurs) + if cr == "oui": + self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs) return 0 return 1 def validSdnom(self, cr): - """ Cette methode teste la validite du nom du concept produit par l'etape """ + """Cette methode teste la validite du nom du concept produit par l'etape""" valid = 1 if self.sd.nom != None: - if self.sd.nom.find('sansnom') != -1: + if self.sd.nom.find("sansnom") != -1: # la SD est 'sansnom' : --> erreur - if cr == 'oui': + if cr == "oui": self.cr.fatal(("object must have a name")) valid = 0 - elif re.search('^SD_[0-9]*$', self.sd.nom): + elif re.search("^SD_[0-9]*$", self.sd.nom): # la SD est 'SD_' cad son nom = son id donc pas de nom donne # par utilisateur : --> erreur - if cr == 'oui': - self.cr.fatal( ("invalid name ('SD_' is a reserved keyword)")) + if cr == "oui": + self.cr.fatal(("invalid name ('SD_' is a reserved keyword)")) valid = 0 return valid def getValid(self): - if hasattr(self, 'valid'): + if hasattr(self, "valid"): return self.valid else: self.valid = None @@ -91,47 +87,49 @@ class ETAPE(V_MCCOMPO.MCCOMPO): def setValid(self, valid): old_valid = self.getValid() self.valid = valid - self.state = 'unchanged' + self.state = "unchanged" if not old_valid or old_valid != self.valid: self.initModifUp() - def isValid(self, sd='oui', cr='non'): + def isValid(self, sd="oui", cr="non"): """ - Methode pour verifier la validite de l'objet ETAPE. Cette methode - peut etre appelee selon plusieurs modes en fonction de la valeur - de sd et de cr. + Methode pour verifier la validite de l'objet ETAPE. Cette methode + peut etre appelee selon plusieurs modes en fonction de la valeur + de sd et de cr. - Si cr vaut oui elle cree en plus un compte-rendu. + Si cr vaut oui elle cree en plus un compte-rendu. - Cette methode a plusieurs fonctions : + Cette methode a plusieurs fonctions : - - mettre a jour l'etat de self (update) + - mettre a jour l'etat de self (update) - - retourner un indicateur de validite 0=non, 1=oui + - retourner un indicateur de validite 0=non, 1=oui - - produire un compte-rendu : self.cr + - produire un compte-rendu : self.cr """ - #if CONTEXT.debug: - #if 1 : + # if CONTEXT.debug: + # if 1 : # print(("ETAPE.isValid ", self.nom, self.state)) # import traceback # traceback.print_stack() - if self.state == 'unchanged': + if self.state == "unchanged": return self.valid else: valid = self.validChild() valid = valid * self.validRegles(cr) - if cr == 'oui' : - if not hasattr(self,'cr') : + if cr == "oui": + if not hasattr(self, "cr"): from Noyau.N_CR import CR - self.cr=CR() - else : + + self.cr = CR() + else: self.cr.purge() if self.reste_val != {}: - if cr == 'oui': + if cr == "oui": self.cr.fatal( - "unknown keywords : %s" % ','.join(list(self.reste_val.keys()))) + "unknown keywords : %s" % ",".join(list(self.reste_val.keys())) + ) valid = 0 if sd == "non": @@ -140,17 +138,16 @@ class ETAPE(V_MCCOMPO.MCCOMPO): # l'indicateur de validite valid return valid - if self.definition.reentrant == 'n' and self.reuse: + if self.definition.reentrant == "n" and self.reuse: # Il ne peut y avoir de concept reutilise avec un OPER non # reentrant - if cr == 'oui': - self.cr.fatal( - 'Operateur non reentrant : ne pas utiliser reuse') + if cr == "oui": + self.cr.fatal("Operateur non reentrant : ne pas utiliser reuse") valid = 0 if self.sd == None: # Le concept produit n'existe pas => erreur - if cr == 'oui': + if cr == "oui": self.cr.fatal(("Concept is not defined")) valid = 0 else: @@ -163,17 +160,17 @@ class ETAPE(V_MCCOMPO.MCCOMPO): return self.valid - def updateSdprod(self, cr='non'): + def updateSdprod(self, cr="non"): """ - Cette methode met a jour le concept produit en fonction des conditions initiales : + Cette methode met a jour le concept produit en fonction des conditions initiales : - 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None) + 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None) - 2. Le concept retourne n existait pas (self.sd == None) + 2. Le concept retourne n existait pas (self.sd == None) - 3. Le concept retourne existait. On change alors son type ou on le supprime + 3. Le concept retourne existait. On change alors son type ou on le supprime - En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1 + En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1 """ sd_prod = self.definition.sd_prod if type(sd_prod) == types.FunctionType: # Type de concept retourne calcule @@ -185,28 +182,33 @@ class ETAPE(V_MCCOMPO.MCCOMPO): if CONTEXT.debug: traceback.print_exc() self.sd = None - if cr == 'oui': - l = traceback.format_exception(sys.exc_info()[0], - sys.exc_info()[1], - sys.exc_info()[2]) + if cr == "oui": + l = traceback.format_exception( + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) self.cr.fatal( - 'unable to affect type to concept\n %s' % ' '.join(l[2:])) + "unable to affect type to concept\n %s" % " ".join(l[2:]) + ) return 0 # on teste maintenant si la SD est reutilisee ou s'il faut la # creer valid = 1 if self.reuse: if AsType(self.reuse) != sd_prod: - if cr == 'oui': + if cr == "oui": self.cr.fatal( - ('Type de concept reutilise incompatible avec type produit')) + ("Type de concept reutilise incompatible avec type produit") + ) valid = 0 - if self.sdnom != '': - if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom: + if self.sdnom != "": + if self.sdnom[0] != "_" and self.reuse.nom != self.sdnom: # Le nom de la variable de retour (self.sdnom) doit etre le # meme que celui du concept reutilise (self.reuse.nom) - if cr == 'oui': - self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' % ( self.reuse.nom, self.sdnom)) + if cr == "oui": + self.cr.fatal( + "Concept reutilise : le nom de la variable de retour devrait etre %s et non %s" + % (self.reuse.nom, self.sdnom) + ) valid = 0 if valid: self.sd = self.reuse @@ -223,36 +225,47 @@ class ETAPE(V_MCCOMPO.MCCOMPO): self.sd.changeType(sd_prod) else: # Le sd n existait pas , on ne le cree pas - if cr == 'oui': + if cr == "oui": self.cr.fatal("Concept retourne non defini") valid = 0 - if self.definition.reentrant == 'o': - if cr == 'oui': + if self.definition.reentrant == "o": + if cr == "oui": self.cr.fatal( - ('Commande obligatoirement reentrante : specifier reuse=concept')) + ( + "Commande obligatoirement reentrante : specifier reuse=concept" + ) + ) valid = 0 return valid def report(self): """ - Methode pour generation d un rapport de validite + Methode pour generation d un rapport de validite """ - self.cr = self.CR(debut='Command : ' + tr(self.nom) - + ' line : ' + repr(self.appel[0]) - + ' file : ' + repr(self.appel[1]), - fin='End Command : ' + tr(self.nom)) - self.state = 'modified' + self.cr = self.CR( + debut="Command : " + + tr(self.nom) + + " line : " + + repr(self.appel[0]) + + " file : " + + repr(self.appel[1]), + fin="End Command : " + tr(self.nom), + ) + self.state = "modified" try: - self.isValid(cr='oui') + self.isValid(cr="oui") except AsException as e: if CONTEXT.debug: traceback.print_exc() - self.cr.fatal('Command : %s line : %r file : %r %s' % (tr(self.nom), self.appel[0], self.appel[1], e)) + self.cr.fatal( + "Command : %s line : %r file : %r %s" + % (tr(self.nom), self.appel[0], self.appel[1], e) + ) i = 0 for child in self.mcListe: i += 1 if i > MAXSIZE: - print (MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mcListe))) + print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mcListe))) break self.cr.add(child.report()) return self.cr diff --git a/Validation/V_EXCLUS.py b/Validation/V_EXCLUS.py index 52ca8ffb..d01319f0 100644 --- a/Validation/V_EXCLUS.py +++ b/Validation/V_EXCLUS.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,32 +17,34 @@ # # # ====================================================================== +from builtins import object + class EXCLUS(object): """ - La regle verifie qu'un seul mot-cle de self.mcs est present - parmi les elements de args. + La regle verifie qu'un seul mot-cle de self.mcs est present + parmi les elements de args. - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif effectue la verification specifique a la regle. - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + La methode verif effectue la verification specifique a la regle. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on compte le nombre de mots cles presents - text = '' + text = "" count = 0 args = self.listeToDico(args) for mc in self.mcs: if mc in args: count = count + 1 if count > 1: - text = "- Il ne faut qu un mot cle parmi : " + repr(self.mcs)+'\n' + text = "- Il ne faut qu un mot cle parmi : " + repr(self.mcs) + "\n" return text, 0 return text, 1 diff --git a/Validation/V_JDC.py b/Validation/V_JDC.py index 7a5e0b9d..7bc231c3 100644 --- a/Validation/V_JDC.py +++ b/Validation/V_JDC.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,8 +17,6 @@ # # # ====================================================================== - - """ Ce module contient la classe mixin JDC qui porte les methodes necessaires pour realiser la validation d'un objet de type JDC @@ -27,7 +25,7 @@ Une classe mixin porte principalement des traitements et est utilisee par heritage multiple pour composer les traitements. """ -from __future__ import absolute_import + # Modules EFICAS from . import V_MCCOMPO from Noyau.N_Exception import AsException @@ -36,40 +34,41 @@ from Noyau.N_utils import AsType class JDC(V_MCCOMPO.MCCOMPO): - """ - """ + """ """ def report(self): """ - Methode pour generation d un rapport de validite + Methode pour generation d un rapport de validite """ self.cr.purge() - #self.cr.debut = "DEBUT CR validation : " + self.nom - #self.cr.fin = "FIN CR validation :" + self.nom + # self.cr.debut = "DEBUT CR validation : " + self.nom + # self.cr.fin = "FIN CR validation :" + self.nom self.cr.debut = "BEGIN validation report : " + self.nom self.cr.fin = "END validation report :" + self.nom for e in self.etapes: if e.isActif(): self.cr.add(e.report()) - self.state = 'modified' - self.isValid(cr='oui') + self.state = "modified" + self.isValid(cr="oui") return self.cr - def isValid(self, cr='non'): + def isValid(self, cr="non"): """ - Methode booleenne qui retourne 0 si le JDC est invalide, 1 sinon + Methode booleenne qui retourne 0 si le JDC est invalide, 1 sinon """ # FR : on prend en compte l'etat du JDC ('unchanged','modified','undetermined') # afin d'accelerer le test de validite du JDC - if self.state == 'unchanged': + if self.state == "unchanged": return self.valid else: valid = 1 texte, test = self.verifRegles() if test == 0: - if cr == 'oui': - if texte != "" and (' '.strip(texte) == "") : self.cr.fatal(texte) - else : self.cr.fatal(' '.strip(texte)) + if cr == "oui": + if texte != "" and (" ".strip(texte) == ""): + self.cr.fatal(texte) + else: + self.cr.fatal(" ".strip(texte)) valid = 0 if valid: for e in self.etapes: @@ -87,7 +86,7 @@ class JDC(V_MCCOMPO.MCCOMPO): Effectue la verification de validite des regles du jeu de commandes """ noms_etapes = [etape.nom for etape in self.etapes] - texte_global = '' + texte_global = "" test_global = 1 for regle in self.regles: texte, test = regle.verif(noms_etapes) diff --git a/Validation/V_MACRO_ETAPE.py b/Validation/V_MACRO_ETAPE.py index e5a49c91..371b4912 100644 --- a/Validation/V_MACRO_ETAPE.py +++ b/Validation/V_MACRO_ETAPE.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,8 +17,6 @@ # # # ====================================================================== - - """ Ce module contient la classe mixin MACRO_ETAPE qui porte les methodes necessaires pour realiser la validation d'un objet de type MACRO_ETAPE @@ -27,6 +25,7 @@ Une classe mixin porte principalement des traitements et est utilisee par heritage multiple pour composer les traitements. """ + # Modules Python import types import sys @@ -41,29 +40,28 @@ from Noyau.N_utils import AsType class MACRO_ETAPE(V_ETAPE.ETAPE): - """ - """ + """ """ - def isValid(self, sd='oui', cr='non'): + def isValid(self, sd="oui", cr="non"): """ - Methode pour verifier la validite de l'objet ETAPE. Cette methode - peut etre appelee selon plusieurs modes en fonction de la valeur - de sd et de cr. + Methode pour verifier la validite de l'objet ETAPE. Cette methode + peut etre appelee selon plusieurs modes en fonction de la valeur + de sd et de cr. - Si cr vaut oui elle cree en plus un compte-rendu. + Si cr vaut oui elle cree en plus un compte-rendu. - Cette methode a plusieurs fonctions : + Cette methode a plusieurs fonctions : - - mettre a jour l'etat de self (update) + - mettre a jour l'etat de self (update) - - retourner un indicateur de validite 0=non, 1=oui + - retourner un indicateur de validite 0=non, 1=oui - - produire un compte-rendu : self.cr + - produire un compte-rendu : self.cr """ if CONTEXT.debug: print(("ETAPE.isValid ", self.nom)) - if self.state == 'unchanged': + if self.state == "unchanged": return self.valid else: valid = 1 @@ -79,17 +77,21 @@ class MACRO_ETAPE(V_ETAPE.ETAPE): # Cette situation est interdite # Pb: La macro-commande a passe le concept a une commande # (macro ?) mal definie - if cr == 'oui': - self.cr.fatal("Macro-commande mal definie : le concept n'a pas ete type par un appel a typeSDProd pour %s" % c.nom) + if cr == "oui": + self.cr.fatal( + "Macro-commande mal definie : le concept n'a pas ete type par un appel a typeSDProd pour %s" + % c.nom + ) valid = 0 valid = valid * self.validChild() valid = valid * self.validRegles(cr) if self.reste_val != {}: - if cr == 'oui': + if cr == "oui": self.cr.fatal( - "unknown keyword : %s" %','.join(list(self.reste_val.keys()))) + "unknown keyword : %s" % ",".join(list(self.reste_val.keys())) + ) valid = 0 if sd == "non": @@ -100,11 +102,13 @@ class MACRO_ETAPE(V_ETAPE.ETAPE): if self.sd != None: valid = valid * self.validSdnom(cr) - if self.definition.reentrant == 'n' and self.reuse: + if self.definition.reentrant == "n" and self.reuse: # Il ne peut y avoir de concept reutilise avec une MACRO non # reentrante - if cr == 'oui': self.cr.fatal( - 'Macro-commande non reentrante : ne pas utiliser reuse') + if cr == "oui": + self.cr.fatal( + "Macro-commande non reentrante : ne pas utiliser reuse" + ) valid = 0 if valid: @@ -120,17 +124,17 @@ class MACRO_ETAPE(V_ETAPE.ETAPE): return self.valid - def updateSdprod(self, cr='non'): + def updateSdprod(self, cr="non"): """ - Cette methode met a jour le concept produit en fonction des conditions initiales : + Cette methode met a jour le concept produit en fonction des conditions initiales : - 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None) + 1. Il n'y a pas de concept retourne (self.definition.sd_prod == None) - 2. Le concept retourne n existait pas (self.sd == None) + 2. Le concept retourne n existait pas (self.sd == None) - 3. Le concept retourne existait. On change alors son type ou on le supprime + 3. Le concept retourne existait. On change alors son type ou on le supprime - En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1 + En cas d'erreur (exception) on retourne un indicateur de validite de 0 sinon de 1 """ sd_prod = self.definition.sd_prod # On memorise le type retourne dans l attribut typret @@ -151,11 +155,14 @@ class MACRO_ETAPE(V_ETAPE.ETAPE): if CONTEXT.debug: traceback.print_exc() self.sd = None - if cr == 'oui': - l = traceback.format_exception(sys.exc_info()[0], - sys.exc_info()[1], - sys.exc_info()[2]) - self.cr.fatal( 'Impossible d affecter un type au resultat\n%s' % ' '.join(l[2:])) + if cr == "oui": + l = traceback.format_exception( + sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2] + ) + self.cr.fatal( + "Impossible d affecter un type au resultat\n%s" + % " ".join(l[2:]) + ) return 0 # on teste maintenant si la SD est reutilisee ou s'il faut la # creer @@ -163,16 +170,20 @@ class MACRO_ETAPE(V_ETAPE.ETAPE): if self.reuse: # Un concept reutilise a ete specifie if AsType(self.reuse) != sd_prod: - if cr == 'oui': + if cr == "oui": self.cr.fatal( - 'Type de concept reutilise incompatible avec type produit') + "Type de concept reutilise incompatible avec type produit" + ) valid = 0 - if self.sdnom != '': - if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom: + if self.sdnom != "": + if self.sdnom[0] != "_" and self.reuse.nom != self.sdnom: # Le nom de la variable de retour (self.sdnom) doit etre le # meme que celui du concept reutilise (self.reuse.nom) - if cr == 'oui': - self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' % (self.reuse.nom, self.sdnom)) + if cr == "oui": + self.cr.fatal( + "Concept reutilise : le nom de la variable de retour devrait etre %s et non %s" + % (self.reuse.nom, self.sdnom) + ) valid = 0 if valid: self.sd = self.reuse @@ -192,19 +203,20 @@ class MACRO_ETAPE(V_ETAPE.ETAPE): else: # Le sd n existait pas , on ne le cree pas self.typret = sd_prod - if cr == 'oui': + if cr == "oui": self.cr.fatal("Concept retourne non defini") valid = 0 - if self.definition.reentrant == 'o': - if cr == 'oui': + if self.definition.reentrant == "o": + if cr == "oui": self.cr.fatal( - 'Commande obligatoirement reentrante : specifier reuse=concept') + "Commande obligatoirement reentrante : specifier reuse=concept" + ) valid = 0 return valid def report(self): """ - Methode pour la generation d un rapport de validation + Methode pour la generation d un rapport de validation """ V_ETAPE.ETAPE.report(self) for e in self.etapes: diff --git a/Validation/V_MCBLOC.py b/Validation/V_MCBLOC.py index d01811ef..f2859fa3 100644 --- a/Validation/V_MCBLOC.py +++ b/Validation/V_MCBLOC.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,8 +17,6 @@ # # # ====================================================================== - - """ Ce module contient la classe mixin MCBLOC qui porte les methodes necessaires pour realiser la validation d'un objet de type MCBLOC @@ -27,6 +25,7 @@ Une classe mixin porte principalement des traitements et est utilisee par heritage multiple pour composer les traitements. """ + # Modules EFICAS from . import V_MCCOMPO @@ -34,27 +33,27 @@ from . import V_MCCOMPO class MCBLOC(V_MCCOMPO.MCCOMPO): """ - Cette classe a un attribut de classe : + Cette classe a un attribut de classe : - - txt_nat qui sert pour les comptes-rendus lies a cette classe + - txt_nat qui sert pour les comptes-rendus lies a cette classe """ - txt_nat = u"Bloc :" + txt_nat = "Bloc :" - def isValid(self, sd='oui', cr='non'): + def isValid(self, sd="oui", cr="non"): """ - Methode pour verifier la validite du MCBLOC. Cette methode - peut etre appelee selon plusieurs modes en fonction de la valeur - de sd et de cr. + Methode pour verifier la validite du MCBLOC. Cette methode + peut etre appelee selon plusieurs modes en fonction de la valeur + de sd et de cr. - Si cr vaut oui elle cree en plus un compte-rendu - sd est present pour compatibilite de l'interface mais ne sert pas + Si cr vaut oui elle cree en plus un compte-rendu + sd est present pour compatibilite de l'interface mais ne sert pas """ - if self.state == 'unchanged': + if self.state == "unchanged": return self.valid else: valid = 1 - if hasattr(self, 'valid'): + if hasattr(self, "valid"): old_valid = self.valid else: old_valid = None @@ -66,11 +65,11 @@ class MCBLOC(V_MCCOMPO.MCCOMPO): # la validite des regles text_erreurs, test_regles = self.verifRegles() if not test_regles: - if cr == 'oui': - self.cr.fatal( "Regle(s) non respectee(s) : %s" % text_erreurs) + if cr == "oui": + self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs) valid = 0 self.valid = valid - self.state = 'unchanged' + self.state = "unchanged" if not old_valid or old_valid != self.valid: self.initModifUp() return self.valid diff --git a/Validation/V_MCCOMPO.py b/Validation/V_MCCOMPO.py index dbde394c..6034cafe 100644 --- a/Validation/V_MCCOMPO.py +++ b/Validation/V_MCCOMPO.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,13 +17,14 @@ # # # ====================================================================== - - """ Ce module contient la classe de base MCCOMPO qui sert a factoriser les traitements des objets composites de type OBJECT """ + +# Modules Python from builtins import str +from builtins import object import os import traceback @@ -37,28 +38,28 @@ from Noyau.N_Exception import AsException class MCCOMPO(object): """ - L'attribut mcListe a ete cree par une classe derivee de la - classe MCCOMPO du Noyau + L'attribut mcListe a ete cree par une classe derivee de la + classe MCCOMPO du Noyau """ CR = N_CR.CR def __init__(self): - self.state = 'undetermined' + self.state = "undetermined" # defini dans les classes derivees - self.txt_nat = '' + self.txt_nat = "" def initModifUp(self): """ - Propage l'etat modifie au parent s'il existe et n'est pas l'objet - lui-meme + Propage l'etat modifie au parent s'il existe et n'est pas l'objet + lui-meme """ if self.parent and self.parent != self: - self.parent.state = 'modified' + self.parent.state = "modified" def report(self): """ - Genere le rapport de validation de self + Genere le rapport de validation de self """ self.cr = self.CR() self.cr.debut = self.txt_nat + self.nom @@ -70,45 +71,45 @@ class MCCOMPO(object): print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mcListe))) break self.cr.add(child.report()) - self.state = 'modified' + self.state = "modified" try: - self.isValid(cr='oui') + self.isValid(cr="oui") except AsException as e: if CONTEXT.debug: traceback.print_exc() - self.cr.fatal(' '.join((self.txt_nat, self.nom, str(e)))) + self.cr.fatal(" ".join((self.txt_nat, self.nom, str(e)))) return self.cr def verifRegles(self): """ - A partir du dictionnaire des mots-cles presents, verifie si les regles - de self sont valides ou non. + A partir du dictionnaire des mots-cles presents, verifie si les regles + de self sont valides ou non. - Retourne une chaine et un booleen : + Retourne une chaine et un booleen : - - texte = la chaine contient le message d'erreur de la (les) regle(s) violee(s) ('' si aucune) + - texte = la chaine contient le message d'erreur de la (les) regle(s) violee(s) ('' si aucune) - - testglob = booleen 1 si toutes les regles OK, 0 sinon + - testglob = booleen 1 si toutes les regles OK, 0 sinon """ # On verifie les regles avec les defauts affectes - dictionnaire = self.dictMcPresents(restreint='non') - texte = [''] + dictionnaire = self.dictMcPresents(restreint="non") + texte = [""] testglob = 1 for r in self.definition.regles: erreurs, test = r.verif(dictionnaire) testglob = testglob * test - if erreurs != '': + if erreurs != "": texte.append(str(erreurs)) texte = os.linesep.join(texte) return texte, testglob - def dictMcPresents(self, restreint='non'): + def dictMcPresents(self, restreint="non"): """ - Retourne le dictionnaire {mocle : objet} construit a partir de self.mcListe - Si restreint == 'non' : on ajoute tous les mots-cles simples du catalogue qui ont - une valeur par defaut - Si restreint == 'oui' : on ne prend que les mots-cles effectivement entres par - l'utilisateur (cas de la verification des regles) + Retourne le dictionnaire {mocle : objet} construit a partir de self.mcListe + Si restreint == 'non' : on ajoute tous les mots-cles simples du catalogue qui ont + une valeur par defaut + Si restreint == 'oui' : on ne prend que les mots-cles effectivement entres par + l'utilisateur (cas de la verification des regles) """ dico = {} # on ajoute les couples {nom mot-cle:objet mot-cle} effectivement @@ -118,17 +119,17 @@ class MCCOMPO(object): continue k = v.nom dico[k] = v - if restreint == 'oui': + if restreint == "oui": return dico # Si restreint != 'oui', # on ajoute les couples {nom mot-cle:objet mot-cle} des mots-cles simples # possibles pour peu qu'ils aient une valeur par defaut for k, v in list(self.definition.entites.items()): - if v.label != 'SIMP': + if v.label != "SIMP": continue if not v.defaut: continue - if not k in dico : + if not k in dico: dico[k] = v(nom=k, val=None, parent=self) # on ajoute l'objet detenteur de regles pour des validations plus # sophistiquees (a manipuler avec precaution) diff --git a/Validation/V_MCFACT.py b/Validation/V_MCFACT.py index 992e1c80..94b381b1 100644 --- a/Validation/V_MCFACT.py +++ b/Validation/V_MCFACT.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,8 +17,6 @@ # # # ====================================================================== - - """ Ce module contient la classe mixin MCFACT qui porte les methodes necessaires pour realiser la validation d'un objet de type MCFACT @@ -34,27 +32,27 @@ from . import V_MCCOMPO class MCFACT(V_MCCOMPO.MCCOMPO): """ - Cette classe a un attribut de classe : + Cette classe a un attribut de classe : - - txt_nat qui sert pour les comptes-rendus lies a cette classe + - txt_nat qui sert pour les comptes-rendus lies a cette classe """ txt_nat = "Mot cle Facteur :" - def isValid(self, sd='oui', cr='non'): + def isValid(self, sd="oui", cr="non"): """ - Methode pour verifier la validite du MCFACT. Cette methode - peut etre appelee selon plusieurs modes en fonction de la valeur - de sd et de cr. + Methode pour verifier la validite du MCFACT. Cette methode + peut etre appelee selon plusieurs modes en fonction de la valeur + de sd et de cr. - Si cr vaut oui elle cree en plus un compte-rendu - sd est present pour compatibilite de l'interface mais ne sert pas + Si cr vaut oui elle cree en plus un compte-rendu + sd est present pour compatibilite de l'interface mais ne sert pas """ - if self.state == 'unchanged': + if self.state == "unchanged": return self.valid else: valid = 1 - if hasattr(self, 'valid'): + if hasattr(self, "valid"): old_valid = self.valid else: old_valid = None @@ -66,24 +64,31 @@ class MCFACT(V_MCCOMPO.MCCOMPO): # la validite des regles text_erreurs, test_regles = self.verifRegles() if not test_regles: - if cr == 'oui': + if cr == "oui": self.cr.fatal("Regle(s) non respectee(s) : %s" % text_erreurs) valid = 0 # # On verifie les validateurs s'il y en a # - if self.definition.validators and not self.definition.validators.verif(self.valeur): - if cr == 'oui': - self.cr.fatal("Keyword : %s should have %s" %( self.nom, self.definition.validators.info())) + if self.definition.validators and not self.definition.validators.verif( + self.valeur + ): + if cr == "oui": + self.cr.fatal( + "Keyword : %s should have %s" + % (self.nom, self.definition.validators.info()) + ) valid = 0 # fin des validateurs # if self.reste_val != {}: - if cr == 'oui': - self.cr.fatal("unknow keyword : %s" % ','.join(list(self.reste_val.keys()))) + if cr == "oui": + self.cr.fatal( + "unknow keyword : %s" % ",".join(list(self.reste_val.keys())) + ) valid = 0 self.valid = valid - self.state = 'unchanged' + self.state = "unchanged" if not old_valid or old_valid != self.valid: self.initModifUp() return self.valid diff --git a/Validation/V_MCLIST.py b/Validation/V_MCLIST.py index 7331fda7..4c4d8ace 100644 --- a/Validation/V_MCLIST.py +++ b/Validation/V_MCLIST.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,8 +17,6 @@ # # # ====================================================================== - - """ Ce module contient la classe mixin MCList qui porte les methodes necessaires pour realiser la validation d'un objet de type MCList @@ -28,7 +26,7 @@ utilisee par heritage multiple pour composer les traitements. """ # Modules Python - +from builtins import object import traceback # Modules EFICAS @@ -41,30 +39,30 @@ from Noyau.N_Exception import AsException class MCList(object): """ - Cette classe a deux attributs de classe : + Cette classe a deux attributs de classe : - - CR qui sert a construire l'objet compte-rendu + - CR qui sert a construire l'objet compte-rendu - - txt_nat qui sert pour les comptes-rendus lies a cette classe + - txt_nat qui sert pour les comptes-rendus lies a cette classe """ CR = N_CR.CR txt_nat = "Mot cle Facteur Multiple :" - def isValid(self, cr='non'): + def isValid(self, cr="non"): """ - Methode pour verifier la validite du MCList. Cette methode - peut etre appelee selon plusieurs modes en fonction de la valeur - de cr. - - Si cr vaut oui elle cree en plus un compte-rendu. - - On n'utilise pas d'attribut pour stocker l'etat et on ne remonte pas - le changement d'etat au parent (pourquoi ??) - MCLIST est une liste de MCFACT. Les MCFACT ont le meme parent - que le MCLIST qui les contient. Il n'est donc pas necessaire de - remonter le changement d'etat au parent. C'est deja fait - par les MCFACT. + Methode pour verifier la validite du MCList. Cette methode + peut etre appelee selon plusieurs modes en fonction de la valeur + de cr. + + Si cr vaut oui elle cree en plus un compte-rendu. + + On n'utilise pas d'attribut pour stocker l'etat et on ne remonte pas + le changement d'etat au parent (pourquoi ??) + MCLIST est une liste de MCFACT. Les MCFACT ont le meme parent + que le MCLIST qui les contient. Il n'est donc pas necessaire de + remonter le changement d'etat au parent. C'est deja fait + par les MCFACT. """ if len(self.data) == 0: return 0 @@ -74,49 +72,61 @@ class MCList(object): # Verification du nombre des mots cles facteurs if definition.min is not None and len(self.data) < definition.min: valid = 0 - if cr == 'oui': - self.cr.fatal( "Nombre de mots cles facteurs insuffisant minimum : %s" % definition.min) + if cr == "oui": + self.cr.fatal( + "Nombre de mots cles facteurs insuffisant minimum : %s" + % definition.min + ) if definition.max is not None and len(self.data) > definition.max: valid = 0 - if cr == 'oui': + if cr == "oui": self.cr.fatal( - "Nombre de mots cles facteurs trop grand maximum : %s" % definition.max) + "Nombre de mots cles facteurs trop grand maximum : %s" + % definition.max + ) num = 0 for i in self.data: num = num + 1 if not i.isValid(): valid = 0 - if cr == 'oui' and len(self) > 1: - self.cr.fatal( "L'occurrence numero %d du mot-cle facteur : %s n'est pas valide" % (num, self.nom)) + if cr == "oui" and len(self) > 1: + self.cr.fatal( + "L'occurrence numero %d du mot-cle facteur : %s n'est pas valide" + % (num, self.nom) + ) return valid def report(self): """ - Genere le rapport de validation de self + Genere le rapport de validation de self """ if len(self) > 1: # Mot cle facteur multiple - self.cr = self.CR( debut="Mot-cle facteur multiple : " + tr(self.nom), - fin="Fin Mot-cle facteur multiple : " + tr(self.nom)) + self.cr = self.CR( + debut="Mot-cle facteur multiple : " + tr(self.nom), + fin="Fin Mot-cle facteur multiple : " + tr(self.nom), + ) j = 0 for i in self.data: j += 1 if j > MAXSIZE: - print (MAXSIZE_MSGCHK.format(MAXSIZE, len(self.data))) + print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.data))) break self.cr.add(i.report()) elif len(self) == 1: # Mot cle facteur non multiple self.cr = self.data[0].report() else: - self.cr = self.CR(debut="Mot-cle facteur : " + tr(self.nom) , - fin="Fin Mot-cle facteur : " + tr(self.nom)) + self.cr = self.CR( + debut="Mot-cle facteur : " + tr(self.nom), + fin="Fin Mot-cle facteur : " + tr(self.nom), + ) try: - self.isValid(cr='oui') + self.isValid(cr="oui") except AsException as e: if CONTEXT.debug: traceback.print_exc() - self.cr.fatal(" %s Mot-cle facteur multiple : %s" %( self.nom, e)) + self.cr.fatal(" %s Mot-cle facteur multiple : %s" % (self.nom, e)) return self.cr diff --git a/Validation/V_MCSIMP.py b/Validation/V_MCSIMP.py index da4daa65..90d819a7 100644 --- a/Validation/V_MCSIMP.py +++ b/Validation/V_MCSIMP.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -27,7 +27,8 @@ utilisee par heritage multiple pour composer les traitements. """ # Modules Python -import traceback +from builtins import str +from builtins import object # Modules EFICAS from Noyau import N_CR @@ -40,36 +41,41 @@ from Extensions.i18n import tr class MCSIMP(object): """ - COMMENTAIRE CCAR: - Cette classe est quasiment identique a la classe originale d'EFICAS - a part quelques changements cosmetiques et des chagements pour la - faire fonctionner de facon plus autonome par rapport a l'environnement - EFICAS - - A mon avis, il faudrait aller plus loin et reduire les dependances - amont au strict necessaire. - - - Est il indispensable de faire l'evaluation de la valeur dans le contexte - du jdc dans cette classe. - oui surtout pour les filtres et les validateurs - - - Ne pourrait on pas doter les objets en presence des methodes suffisantes - pour eviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai - d'ailleurs modifie la classe pour eviter l'import de GEOM + COMMENTAIRE CCAR: + Cette classe est quasiment identique a la classe originale d'EFICAS + a part quelques changements cosmetiques et des chagements pour la + faire fonctionner de facon plus autonome par rapport a l'environnement + EFICAS + + A mon avis, il faudrait aller plus loin et reduire les dependances + amont au strict necessaire. + + - Est il indispensable de faire l'evaluation de la valeur dans le contexte + du jdc dans cette classe. + oui surtout pour les filtres et les validateurs + + - Ne pourrait on pas doter les objets en presence des methodes suffisantes + pour eviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai + d'ailleurs modifie la classe pour eviter l'import de GEOM """ CR = N_CR.CR def __init__(self): - self.state = 'undetermined' + self.state = "undetermined" self.typeProto = TypeProtocol("type", typ=self.definition.type) self.intoProto = IntoProtocol( - "into", into=self.definition.into, val_min=self.definition.val_min, val_max=self.definition.val_max) + "into", + into=self.definition.into, + val_min=self.definition.val_min, + val_max=self.definition.val_max, + ) self.cardProto = CardProtocol( - "card", min=self.definition.min, max=self.definition.max) + "card", min=self.definition.min, max=self.definition.max + ) def getValid(self): - if hasattr(self, 'valid'): + if hasattr(self, "valid"): return self.valid else: self.valid = None @@ -78,43 +84,44 @@ class MCSIMP(object): def setValid(self, valid): old_valid = self.getValid() self.valid = valid - self.state = 'unchanged' + self.state = "unchanged" if not old_valid or old_valid != self.valid: self.initModifUp() - def isValid(self, cr='non'): + def isValid(self, cr="non"): """ - Cette methode retourne un indicateur de validite de l'objet de type MCSIMP + Cette methode retourne un indicateur de validite de l'objet de type MCSIMP - - 0 si l'objet est invalide - - 1 si l'objet est valide + - 0 si l'objet est invalide + - 1 si l'objet est valide - Le parametre cr permet de parametrer le traitement. Si cr == 'oui' - la methode construit egalement un comte-rendu de validation - dans self.cr qui doit avoir ete cree prealablement. + Le parametre cr permet de parametrer le traitement. Si cr == 'oui' + la methode construit egalement un comte-rendu de validation + dans self.cr qui doit avoir ete cree prealablement. """ - if self.state == 'unchanged': + if self.state == "unchanged": return self.valid else: valid = 1 v = self.valeur # verification presence - if self.isOblig() and (v == None or v == "" ): - if cr == 'oui': - self.cr.fatal( "Mandatory keyword : %s has no value" % tr(self.nom)) + if self.isOblig() and (v == None or v == ""): + if cr == "oui": + self.cr.fatal("Mandatory keyword : %s has no value" % tr(self.nom)) valid = 0 lval = listProto.adapt(v) # Ajout PN # Pour tenir compte des Tuples - if hasattr(self.definition.type[0],'ntuple') : - try : - if (not (type(lval[0]) is tuple)) and (not (type(lval[0]) is list)) : lval=(lval,) - except : + if hasattr(self.definition.type[0], "ntuple"): + try: + if (not (type(lval[0]) is tuple)) and (not (type(lval[0]) is list)): + lval = (lval,) + except: pass if lval is None: valid = 0 - if cr == 'oui': + if cr == "oui": self.cr.fatal("None is not a valid value") else: # type,into ... @@ -127,7 +134,7 @@ class MCSIMP(object): typeProto = self.typeProto intoProto = self.intoProto cardProto = self.cardProto - if cr == 'oui': + if cr == "oui": # un cr est demande : on collecte tous les types d'erreur try: for val in lval: @@ -153,7 +160,14 @@ class MCSIMP(object): try: self.definition.validators.convert(lval) except ValError as e: - self.cr.fatal( "invalid keyword %s : %s\nCriteria : %s" % (tr(self.nom), str(e), self.definition.validators.info())) + self.cr.fatal( + "invalid keyword %s : %s\nCriteria : %s" + % ( + tr(self.nom), + str(e), + self.definition.validators.info(), + ) + ) valid = 0 else: # si pas de cr demande, on sort a la toute premiere erreur @@ -163,7 +177,7 @@ class MCSIMP(object): intoProto.adapt(val) cardProto.adapt(lval) if self.definition.validators: - if hasattr(self.definition.validators, 'set_MCSimp'): + if hasattr(self.definition.validators, "set_MCSimp"): self.definition.validators.set_MCSimp(self) self.definition.validators.convert(lval) except ValError as e: @@ -173,26 +187,25 @@ class MCSIMP(object): return self.valid def isOblig(self): - """ indique si le mot-cle est obligatoire - """ - return self.definition.statut == 'o' + """indique si le mot-cle est obligatoire""" + return self.definition.statut == "o" def initModifUp(self): """ - Propage l'etat modifie au parent s'il existe et n'est l'objet - lui-meme + Propage l'etat modifie au parent s'il existe et n'est l'objet + lui-meme """ if self.parent and self.parent != self: - self.parent.state = 'modified' + self.parent.state = "modified" def report(self): - """ genere le rapport de validation de self """ + """genere le rapport de validation de self""" self.cr = self.CR() self.cr.debut = "Simple Keyword : " + tr(self.nom) self.cr.fin = "End Simple Keyword: " + tr(self.nom) - self.state = 'modified' + self.state = "modified" try: - self.isValid(cr='oui') + self.isValid(cr="oui") except AsException as e: if CONTEXT.debug: traceback.print_exc() diff --git a/Validation/V_MEME_NOMBRE.py b/Validation/V_MEME_NOMBRE.py index dae6a88c..2f34b384 100644 --- a/Validation/V_MEME_NOMBRE.py +++ b/Validation/V_MEME_NOMBRE.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -15,28 +15,30 @@ # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +from builtins import object + class MEME_NOMBRE(object): """ - La regle MEME_NOMBRE verifie que l'on trouve au moins un des mots-cles - de la regle parmi les arguments d'un OBJECT. + La regle MEME_NOMBRE verifie que l'on trouve au moins un des mots-cles + de la regle parmi les arguments d'un OBJECT. - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif verifie que l'on trouve au moins un des mos-cles - de la liste self.mcs parmi les elements de args + La methode verif verifie que l'on trouve au moins un des mos-cles + de la liste self.mcs parmi les elements de args - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on compte le nombre de mots cles presents - text = '' + text = "" args = self.listeToDico(args) size = -1 diff --git a/Validation/V_PRESENT_ABSENT.py b/Validation/V_PRESENT_ABSENT.py index 75a9c513..c8bd5b21 100644 --- a/Validation/V_PRESENT_ABSENT.py +++ b/Validation/V_PRESENT_ABSENT.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,35 +17,44 @@ # # # ====================================================================== +from builtins import object + class PRESENT_ABSENT(object): """ - La regle verifie que si le premier mot-cle de self.mcs est present - parmi les elements de args les autres mots cles de self.mcs - doivent etre absents + La regle verifie que si le premier mot-cle de self.mcs est present + parmi les elements de args les autres mots cles de self.mcs + doivent etre absents - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif effectue la verification specifique a la regle. - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + La methode verif effectue la verification specifique a la regle. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on verifie que si le premier de la liste est present, # les autres sont absents - text = '' + text = "" test = 1 args = self.listeToDico(args) mc0 = self.mcs[0] - if mc0 in args : - for mc in self.mcs[1:len(self.mcs)]: - if mc in args : - text = text + "- Le mot cle " + repr(mc0)+ " etant present, il faut que : " +\ - mc + " soit absent" + '\n' + if mc0 in args: + for mc in self.mcs[1 : len(self.mcs)]: + if mc in args: + text = ( + text + + "- Le mot cle " + + repr(mc0) + + " etant present, il faut que : " + + mc + + " soit absent" + + "\n" + ) test = 0 return text, test diff --git a/Validation/V_PRESENT_PRESENT.py b/Validation/V_PRESENT_PRESENT.py index ec9df4f9..9ce4364e 100644 --- a/Validation/V_PRESENT_PRESENT.py +++ b/Validation/V_PRESENT_PRESENT.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,35 +17,43 @@ # # # ====================================================================== +from builtins import object + class PRESENT_PRESENT(object): """ - La regle verifie que si le premier mot-cle de self.mcs est present - parmi les elements de args les autres doivent l'etre aussi + La regle verifie que si le premier mot-cle de self.mcs est present + parmi les elements de args les autres doivent l'etre aussi - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif effectue la verification specifique a la regle. - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + La methode verif effectue la verification specifique a la regle. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on verifie que si le premier de la liste est present, # les autres le sont aussi mc0 = self.mcs[0] - text = '' + text = "" test = 1 args = self.listeToDico(args) - if mc0 in args : - for mc in self.mcs[1:len(self.mcs)]: - if not mc in args : - text = text + "- Le mot cle " + repr(mc0)+ \ - " etant present, il faut que : " + \ - mc + " soit present" + '\n' + if mc0 in args: + for mc in self.mcs[1 : len(self.mcs)]: + if not mc in args: + text = ( + text + + "- Le mot cle " + + repr(mc0) + + " etant present, il faut que : " + + mc + + " soit present" + + "\n" + ) test = 0 return text, test diff --git a/Validation/V_PROC_ETAPE.py b/Validation/V_PROC_ETAPE.py index 07a66c7e..89c284f8 100644 --- a/Validation/V_PROC_ETAPE.py +++ b/Validation/V_PROC_ETAPE.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -15,7 +15,6 @@ # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== - """ Ce module contient la classe mixin PROC_ETAPE qui porte les methodes necessaires pour realiser la validation d'un objet de type PROC_ETAPE @@ -34,40 +33,43 @@ from Extensions.i18n import tr class PROC_ETAPE(V_ETAPE.ETAPE): """ - On reutilise les methodes report,verifRegles - de ETAPE par heritage. + On reutilise les methodes report,verifRegles + de ETAPE par heritage. """ - def isValid(self, sd='oui', cr='non'): + def isValid(self, sd="oui", cr="non"): """ - Methode pour verifier la validite de l'objet PROC_ETAPE. Cette methode - peut etre appelee selon plusieurs modes en fonction de la valeur - de sd et de cr (sd n'est pas utilise). + Methode pour verifier la validite de l'objet PROC_ETAPE. Cette methode + peut etre appelee selon plusieurs modes en fonction de la valeur + de sd et de cr (sd n'est pas utilise). - Si cr vaut oui elle cree en plus un compte-rendu. + Si cr vaut oui elle cree en plus un compte-rendu. - Cette methode a plusieurs fonctions : + Cette methode a plusieurs fonctions : - - retourner un indicateur de validite 0=non, 1=oui + - retourner un indicateur de validite 0=non, 1=oui - - produire un compte-rendu : self.cr + - produire un compte-rendu : self.cr - - propager l'eventuel changement d'etat au parent + - propager l'eventuel changement d'etat au parent """ if CONTEXT.debug: print(("ETAPE.isValid ", self.nom)) - if self.state == 'unchanged': + if self.state == "unchanged": return self.valid else: valid = self.validChild() valid = valid * self.validRegles(cr) if self.reste_val != {}: - if not hasattr(self,'cr') : + if not hasattr(self, "cr"): from Noyau.N_CR import CR - self.cr=CR() - if cr == 'oui': + + self.cr = CR() + if cr == "oui": self.cr.fatal( - tr("unknown keywords : %s") % ','.join(list(self.reste_val.keys()))) + tr("unknown keywords : %s") + % ",".join(list(self.reste_val.keys())) + ) valid = 0 self.setValid(valid) return self.valid diff --git a/Validation/V_UN_PARMI.py b/Validation/V_UN_PARMI.py index a9f51303..b4b26d0b 100644 --- a/Validation/V_UN_PARMI.py +++ b/Validation/V_UN_PARMI.py @@ -1,6 +1,6 @@ # coding=utf-8 # ====================================================================== -# COPYRIGHT (C) 2007-2024 EDF R&D +# COPYRIGHT (C) 2007-2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,36 +17,36 @@ # # # ====================================================================== +from builtins import object class UN_PARMI(object): """ - La regle verifie que l'on trouve un des mots-cles - de la regle parmi les arguments d'un OBJECT. + La regle verifie que l'on trouve un des mots-cles + de la regle parmi les arguments d'un OBJECT. - Ces arguments sont transmis a la regle pour validation sous la forme - d'une liste de noms de mots-cles ou d'un dictionnaire dont - les cles sont des noms de mots-cles. + Ces arguments sont transmis a la regle pour validation sous la forme + d'une liste de noms de mots-cles ou d'un dictionnaire dont + les cles sont des noms de mots-cles. """ def verif(self, args): """ - La methode verif verifie que l'on trouve un des mos-cles - de la liste self.mcs parmi les elements de args + La methode verif verifie que l'on trouve un des mos-cles + de la liste self.mcs parmi les elements de args - args peut etre un dictionnaire ou une liste. Les elements de args - sont soit les elements de la liste soit les cles du dictionnaire. + args peut etre un dictionnaire ou une liste. Les elements de args + sont soit les elements de la liste soit les cles du dictionnaire. """ # on compte le nombre de mots cles presents - text = '' + text = "" count = 0 args = self.listeToDico(args) for mc in self.mcs: - if mc in args : + if mc in args: count = count + 1 if count != 1: - text = "- Il faut un et un seul mot-cle parmi : " + \ - repr(self.mcs)+'\n' + text = "- Il faut un et un seul mot-cle parmi : " + repr(self.mcs) + "\n" return text, 0 return text, 1 diff --git a/generator/CMakeLists.txt b/generator/CMakeLists.txt index ecd26bf1..c0454eed 100644 --- a/generator/CMakeLists.txt +++ b/generator/CMakeLists.txt @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2024 EDF R&D # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR diff --git a/generator/Formatage.py b/generator/Formatage.py index 6e71a409..b490e451 100644 --- a/generator/Formatage.py +++ b/generator/Formatage.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,304 +22,328 @@ liste de chaines de caractères dans une syntaxe représentative d'un jeu de commandes en un texte présentable """ -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import object -except : pass -import types,re +from builtins import object +import types, re from Extensions.i18n import tr -filePattern="'[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*'" -filePattern2='"[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*"' -class Formatage (object): +filePattern = "'[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*'" +filePattern2 = '"[^\(\)]([^\(\)]*\([^\(\)]*\))*[^\(\)]*"' + + +class Formatage(object): """ - Cette classe contient toutes les méthodes nécessaires au formatage - de la chaine de caracteres issue d'un generator en un fichier - 'lisible' ie avec indentations + Cette classe contient toutes les méthodes nécessaires au formatage + de la chaine de caracteres issue d'un generator en un fichier + 'lisible' ie avec indentations - L'objet attend en parametre du constructeur (argument l_jdc) une representation - du jeu de commandes sous la forme d'une liste. + L'objet attend en parametre du constructeur (argument l_jdc) une representation + du jeu de commandes sous la forme d'une liste. - Chaque element de la liste est la representation d'une etape. + Chaque element de la liste est la representation d'une etape. - La representation d'une etape est une liste dont le premier element est une chaine de - caracteres donnant le debut de la commande ("xxx=lire_maillage(", par exemple). - Les elements suivants sont les representations des mots cles simples et facteurs. - Elle se termine avec un element de fin : ");" + La representation d'une etape est une liste dont le premier element est une chaine de + caracteres donnant le debut de la commande ("xxx=lire_maillage(", par exemple). + Les elements suivants sont les representations des mots cles simples et facteurs. + Elle se termine avec un element de fin : ");" - La representation d'un mot cle simple est une chaine de caracteres (info=2, par exemple). + La representation d'un mot cle simple est une chaine de caracteres (info=2, par exemple). - La representation d'un mot cle facteur est semblable à celle de l'étape : premier element - caracteristique du mot cle facteur suivi d'elements representatifs des mots cles simples. - Elle se termine avec un element de fin : ")" ou "),". + La representation d'un mot cle facteur est semblable à celle de l'étape : premier element + caracteristique du mot cle facteur suivi d'elements representatifs des mots cles simples. + Elle se termine avec un element de fin : ")" ou "),". """ - def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max=72): + + def __init__(self, l_jdc, code=None, mode=None, sep="=", l_max=72): # l_jdc représente le jeu de commandes brut sous forme de liste self.l_jdc = l_jdc - self.jdc_fini ='' + self.jdc_fini = "" self.count = 0 - self.sep=sep - self.l_max=l_max - if mode == '.py': - self.sep = '=' + self.sep = sep + self.l_max = l_max + if mode == ".py": + self.sep = "=" self.l_max = 132 - elif code == 'ASTER': - self.sep = ':' + elif code == "ASTER": + self.sep = ":" self.l_max = 72 def formateJdc(self): - comment=re.compile("\n#") - commentaireavant=0 + comment = re.compile("\n#") + commentaireavant = 0 for etape in self.l_jdc: - self.count = self.count+1 - self.texte_etape = '' - if type(etape)==list: + self.count = self.count + 1 + self.texte_etape = "" + if type(etape) == list: # L'etape est sous la forme d'une liste dont le premier element est une chaine - self.indent=[] + self.indent = [] self.indent.append(len(etape[0])) self.indent_courant = self.indent[0] - self.texte_etape = '\n' + etape[0] - if len(etape)>1 : + self.texte_etape = "\n" + etape[0] + if len(etape) > 1: self.formateEtape(etape[1:]) - else : + else: # L'etape est deja sous forme de chaine de caracteres - self.indent=[] + self.indent = [] self.texte_etape = etape - m=comment.match(self.texte_etape) + m = comment.match(self.texte_etape) # si ce n est pas la premiere ligne - if self.jdc_fini != "" : + if self.jdc_fini != "": # si il n y avait pas de commentaire avant on met un saut de ligne - if commentaireavant == 0 : - self.jdc_fini = self.jdc_fini + '\n' + self.texte_etape - else : + if commentaireavant == 0: + self.jdc_fini = self.jdc_fini + "\n" + self.texte_etape + else: self.jdc_fini = self.jdc_fini + self.texte_etape # si c est la premiere ligne - else : + else: # on ne met pas de saut de ligne avant la premiere ligne # si c est un commentaire on enleve le saut de ligne precedent - if m : self.texte_etape=self.texte_etape[1:] + if m: + self.texte_etape = self.texte_etape[1:] self.jdc_fini = self.texte_etape - if m : - commentaireavant=1 - else : - commentaireavant=0 + if m: + commentaireavant = 1 + else: + commentaireavant = 0 return self.jdc_fini - - - def formateEtape(self,liste): + def formateEtape(self, liste): """ - Enrichissement de la chaine de caracteres representant l'etape (attribut - texte_etape de l'objet Formatage). - Les elements a ajouter sont dans l'argument liste de la methode. - L'objet "liste" à traiter a été produit par le module generator. En particulier - les parenthèses et les virgules ont été produites par ce module + Enrichissement de la chaine de caracteres representant l'etape (attribut + texte_etape de l'objet Formatage). + Les elements a ajouter sont dans l'argument liste de la methode. + L'objet "liste" à traiter a été produit par le module generator. En particulier + les parenthèses et les virgules ont été produites par ce module """ - l_patterns_fin_etape = ( ');' , ');\n' ) - l_patterns_fin_mcf = ( ')' , '),' ) + l_patterns_fin_etape = (");", ");\n") + l_patterns_fin_mcf = (")", "),") ind = 0 - for element in liste : - if type(element)==list: - + for element in liste: + if type(element) == list: # il s'agit d'un mot-clé facteur # on écrit son nom (element[0]) longueur = self.longueur(self.texte_etape) try: - increment = len(('\n'+self.indent_courant*' ')*ind + element[0]) + increment = len( + ("\n" + self.indent_courant * " ") * ind + element[0] + ) except: - print (tr('ERREUR')) - print (liste) - print (element) - self.texte_etape = self.texte_etape + (u'\n'+self.indent_courant*' ')*ind + element[0] + print(tr("ERREUR")) + print(liste) + print(element) + self.texte_etape = ( + self.texte_etape + + ("\n" + self.indent_courant * " ") * ind + + element[0] + ) length = len(self.indent) - self.indent.insert(length,self.indent[length-1]+len(element[0])) + self.indent.insert(length, self.indent[length - 1] + len(element[0])) self.indent_courant = self.indent[length] # on écrit ses fils self.formateEtape(element[1:]) - #elif type(element) == types.StringType: - #elif type(element) == bytes: + # elif type(element) == types.StringType: + # elif type(element) == bytes: # PNPNPN -> marre du python 2 et 3 # on remplace par else dans if - else : - + else: # il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n' - if element in l_patterns_fin_mcf : - self.traiteMcfact(s_mcfact=element,ind=ind) - elif element in l_patterns_fin_etape : - self.traiteEtape(s_etape=element,ind=ind) - else : - self.traiteMcsimp(s_mcsimp=element,ind=ind) + if element in l_patterns_fin_mcf: + self.traiteMcfact(s_mcfact=element, ind=ind) + elif element in l_patterns_fin_etape: + self.traiteEtape(s_etape=element, ind=ind) + else: + self.traiteMcsimp(s_mcsimp=element, ind=ind) ind = 1 - def traiteEtape(self,s_etape,ind) : + def traiteEtape(self, s_etape, ind): """ - Traite une partie du jdc formaté : s_etape, une chaîne de caractères - contenant une étape - L'attribut self.texte_etape est modifié (complété) par le traitement - L'attribut self.indent est modifié par le traitement - L'attribut self.indent_courant est modifié par le traitement + Traite une partie du jdc formaté : s_etape, une chaîne de caractères + contenant une étape + L'attribut self.texte_etape est modifié (complété) par le traitement + L'attribut self.indent est modifié par le traitement + L'attribut self.indent_courant est modifié par le traitement """ length = len(self.indent) if length > 1: - last = self.indent[length-1] + last = self.indent[length - 1] self.indent.remove(last) - self.indent_courant=self.indent[length-2] - else : - self.indent_courant=self.indent[0] + self.indent_courant = self.indent[length - 2] + else: + self.indent_courant = self.indent[0] self.texte_etape = self.texte_etape + s_etape.strip() - def traiteMcfact(self,s_mcfact,ind) : + def traiteMcfact(self, s_mcfact, ind): """ - Traite une partie du jdc formaté : s_mcfact, une chaîne de caractères - contenant un mot-clef facteur. - L'attribut self.texte_etape est modifié (complété) par le traitement - L'attribut self.indent est modifié par le traitement - L'attribut self.indent_courant est modifié par le traitement + Traite une partie du jdc formaté : s_mcfact, une chaîne de caractères + contenant un mot-clef facteur. + L'attribut self.texte_etape est modifié (complété) par le traitement + L'attribut self.indent est modifié par le traitement + L'attribut self.indent_courant est modifié par le traitement """ self.texte_etape = self.texte_etape + s_mcfact.strip() length = len(self.indent) if length > 1: - last = self.indent[length-1] + last = self.indent[length - 1] self.indent.remove(last) - self.indent_courant=self.indent[length-2] - else : - self.indent_courant=self.indent[0] + self.indent_courant = self.indent[length - 2] + else: + self.indent_courant = self.indent[0] return - - def traiteMcsimp(self,s_mcsimp,ind) : + def traiteMcsimp(self, s_mcsimp, ind): """ - Traite une partie du jdc formaté : s_mcsimp, une chaîne de caractères - contenant un mot-clef simple. - L'attribut self.texte_etape est modifié (complété) par le traitement + Traite une partie du jdc formaté : s_mcsimp, une chaîne de caractères + contenant un mot-clef simple. + L'attribut self.texte_etape est modifié (complété) par le traitement """ # # Ajout PN pour defi_fonction - if self.texte_etape.find("DEFI_FONCTION") > 1 : - bool_fonction=1 - if s_mcsimp.find("\n") > 1: - txt=""; bool = 0; numident=1 - for l in s_mcsimp.splitlines() : - if bool == 0 : + if self.texte_etape.find("DEFI_FONCTION") > 1: + bool_fonction = 1 + if s_mcsimp.find("\n") > 1: + txt = "" + bool = 0 + numident = 1 + for l in s_mcsimp.splitlines(): + if bool == 0: bool = 1 - numident=s_mcsimp.find("=")+2 - txt=l - else : - txt=txt+('\n'+self.indent_courant*' '+numident*' ')*ind+l + numident = s_mcsimp.find("=") + 2 + txt = l + else: + txt = ( + txt + + ("\n" + self.indent_courant * " " + numident * " ") * ind + + l + ) s_mcsimp = txt - else : - bool_fonction=0 + else: + bool_fonction = 0 longueur = self.longueur(self.texte_etape) - increment = len((u'\n'+self.indent_courant*' ')*ind + s_mcsimp.strip()) - if (bool_fonction == 1 ) : - self.texte_etape = self.texte_etape+'\n'+self.indent_courant*' ' +s_mcsimp - elif ( ((1-ind)*longueur+increment) <= self.l_max ) : - self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind +s_mcsimp.strip() - else : + increment = len(("\n" + self.indent_courant * " ") * ind + s_mcsimp.strip()) + if bool_fonction == 1: + self.texte_etape = ( + self.texte_etape + "\n" + self.indent_courant * " " + s_mcsimp + ) + elif ((1 - ind) * longueur + increment) <= self.l_max: + self.texte_etape = ( + self.texte_etape + + ("\n" + self.indent_courant * " ") * ind + + s_mcsimp.strip() + ) + else: # il faut couper ... - nom,valeur = str.split(s_mcsimp,self.sep,1) - chaine = self.creerChaine(nom,valeur,'\n'+self.indent_courant*' ',ind) + nom, valeur = str.split(s_mcsimp, self.sep, 1) + chaine = self.creerChaine( + nom, valeur, "\n" + self.indent_courant * " ", ind + ) self.texte_etape = self.texte_etape + chaine return - - def longueur(self,texte): + def longueur(self, texte): """ - texte est une string qui peut contenir des retours chariots - Cette méthode retourne la longueur de la dernière ligne de texte + texte est une string qui peut contenir des retours chariots + Cette méthode retourne la longueur de la dernière ligne de texte """ - #liste = texte.split('\n') - #return len(liste[-1]) - if texte [-1] == '\n' : return 0 - return len(texte[texte.rfind('\n'):-1]) + # liste = texte.split('\n') + # return len(liste[-1]) + if texte[-1] == "\n": + return 0 + return len(texte[texte.rfind("\n") : -1]) - - def creerChaine(self,nom,valeur,increment,ind): + def creerChaine(self, nom, valeur, increment, ind): """ - La methode creerChaine reconstitue un objet Eficas à partir de - - son nom, - - sa valeur. + La methode creerChaine reconstitue un objet Eficas à partir de + - son nom, + - sa valeur. """ - s='' + s = "" if len(increment + nom + self.sep) <= self.l_max: - texte = increment*ind + texte = increment * ind label = nom + self.sep - s=texte + label + s = texte + label longueur = len(increment + label) - if ('(' not in valeur) or (valeur[0:3]=='"""') : + if ("(" not in valeur) or (valeur[0:3] == '"""'): # il s'agit d'une vraie chaîne de caractères val = len(valeur) - texte = (self.l_max-2-val)*' '+valeur - s=s+'\\\n'+texte - elif re.match(filePattern,valeur) or re.match(filePattern2,valeur): + texte = (self.l_max - 2 - val) * " " + valeur + s = s + "\\\n" + texte + elif re.match(filePattern, valeur) or re.match(filePattern2, valeur): val = len(valeur) - texte = (self.l_max-2-val)*' '+valeur - s=s+'\\\n'+texte - elif ',' in valeur: + texte = (self.l_max - 2 - val) * " " + valeur + s = s + "\\\n" + texte + elif "," in valeur: # il s'agit d'une liste de tuple # c est trop complique on ne splitte pas - if valeur[0:2]=='((' or valeur[0:2]=='[(': - s=s+valeur + if valeur[0:2] == "((" or valeur[0:2] == "[(": + s = s + valeur return s # il s'agit d'une liste - liste = valeur.split(',') - i=0 - for arg in liste : + liste = valeur.split(",") + i = 0 + for arg in liste: ajout = arg.strip() - if len(ajout) == 0 : continue - longueur = self.longueur(texte = (texte + label)) + len(ajout +',') + (1-i)*len(increment) - if longueur <= self.l_max: - if ajout[-1] != ')': - texte = texte + ajout +',' - else : + if len(ajout) == 0: + continue + longueur = ( + self.longueur(texte=(texte + label)) + + len(ajout + ",") + + (1 - i) * len(increment) + ) + if longueur <= self.l_max: + if ajout[-1] != ")": + texte = texte + ajout + "," + else: texte = texte + ajout - else : - i=1 - if ajout[-1] != ')': - texte = texte + increment + (len(label)+2)*' ' + ajout + ',' - else : - texte = texte + increment + (len(label)+2)*' ' + ajout + else: + i = 1 + if ajout[-1] != ")": + texte = ( + texte + increment + (len(label) + 2) * " " + ajout + "," + ) + else: + texte = texte + increment + (len(label) + 2) * " " + ajout - s=s+texte - s = s + ',' + s = s + texte + s = s + "," - else : + else: # On a une ( mais pas de , . On passe la chaine sans modification - val = len(valeur) +len(label) - texte = (self.l_max-2-val)*' '+valeur - s='\n'+s+texte - else : + val = len(valeur) + len(label) + texte = (self.l_max - 2 - val) * " " + valeur + s = "\n" + s + texte + else: label = nom + self.sep - val = len(valeur) +len(label) - s = '\n'+(self.l_max-2-val)*' '+label+valeur + val = len(valeur) + len(label) + s = "\n" + (self.l_max - 2 - val) * " " + label + valeur return s -class FormatageLigne(Formatage) : - def __init__(self,l_jdc,code=None,mode=None,sep='=',l_max="**"): - Formatage.__init__(self,l_jdc,code=None,mode=None,sep='=',l_max="**") + +class FormatageLigne(Formatage): + def __init__(self, l_jdc, code=None, mode=None, sep="=", l_max="**"): + Formatage.__init__(self, l_jdc, code=None, mode=None, sep="=", l_max="**") def formateJdc(self): - texte1=Formatage.formateJdc(self) - newText="" - lignes=texte1.split("\n") - texte="" - pattern_debut_blanc = re.compile(r"^ \s*.*") - pattern_commentaire = re.compile(r"^\s*#.*") - pattern_vide=re.compile(r"\s*^$") - for l in lignes : + texte1 = Formatage.formateJdc(self) + newText = "" + lignes = texte1.split("\n") + texte = "" + pattern_debut_blanc = re.compile(r"^ \s*.*") + pattern_commentaire = re.compile(r"^\s*#.*") + pattern_vide = re.compile(r"\s*^$") + for l in lignes: if pattern_commentaire.match(l) or pattern_vide.match(l): - newText+=l+"\n" + newText += l + "\n" continue - if not pattern_debut_blanc.match(l) : texte=l - else : texte+=re.sub(r'^ \s*',' ',l) - if texte[-1]==";" : - newText+=texte+"\n" - texte="" + if not pattern_debut_blanc.match(l): + texte = l + else: + texte += re.sub(r"^ \s*", " ", l) + if texte[-1] == ";": + newText += texte + "\n" + texte = "" return newText diff --git a/generator/__init__.py b/generator/__init__.py index f75236bf..06322fc0 100644 --- a/generator/__init__.py +++ b/generator/__init__.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -24,9 +24,8 @@ Ces generateurs sont implementes sous forme de plugins """ -from __future__ import absolute_import from Extensions import pluginloader import generator -plugins=pluginloader.PluginLoader(generator) +plugins = pluginloader.PluginLoader(generator) diff --git a/generator/generator_5CRequeteSelection.py b/generator/generator_5CRequeteSelection.py new file mode 100644 index 00000000..8da00a26 --- /dev/null +++ b/generator/generator_5CRequeteSelection.py @@ -0,0 +1,110 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2024 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS. +""" + +import traceback +from Extensions.i18n import tr +from generator.generator_python import PythonGenerator + + +def entryPoint(): + """ + Retourne les informations necessaires pour le chargeur de plugins + Ces informations sont retournees dans un dictionnaire + # name: Le nom du plugin + # factory: La factory pour creer une instance du plugin + """ + return { + "name": "5CRequeteSelection", + "factory": RequeteSelectionGenerator, + } + + +class RequeteSelectionGenerator(PythonGenerator): + """ + Ce generateur parcourt un etapeSelectionet de type JDC et produit + un texte pour requeter la base + """ + + # Les extensions de fichier permis? + pass + extensions = (".comm",) + + # ---------------------------------------------------------------------------------------- + def genereRequeteSelection(self, jdc): + debug = 0 + + texteRequete = "select id from JobPerformance where " + etapeSelection = jdc.etapes[0] + if debug: + print("appelle genereRequeteSelection avec jdc", jdc) + if debug: + print("etapeSelection", etapeSelection) + + # L etapeSelection n est pas valide : Tout est obligatoire or tout n est pas rempli + # On se contente de verifier les regles d afficher les regles non valides + # en enelvant les motclefs invalides + listeRegles = etapeSelection.getRegles() + dictObjPresents = etapeSelection.dictMcPresents(restreint="oui") + dictObjPresentsValides = {} + + for nomObj, obj in dictObjPresents.items(): + if obj.isValid(): + dictObjPresentsValides[nomObj] = obj + if debug: + print("dictObjPresentsValides", dictObjPresentsValides) + + commentaire = "Les données sont insuffisantes pour générer les requetes : \n" + reglesOk = 1 + texteErreurs = [] + if len(listeRegles) > 0: + for regle in listeRegles: + if debug: + print(regle) + texteRegle = regle.getText() + texteMauvais, test = regle.verif(dictObjPresentsValides) + if debug: + print(texteMauvais, test) + if not test: + reglesOk = 0 + texteErreurs.append(texteMauvais) + if not reglesOk: + return 0, commentaire, "".join(texteErreurs) + + separateur = "" + for nomObj, obj in dictObjPresentsValides.items(): + texteRequete += separateur + texteRequete += nomObj + if nomObj.startswith("Debut"): + operateur = ">" + elif nomObj.endswith("Fin"): + operateur = "<" + else: + operateur = "=" + texteRequete += operateur + lesTypes = obj.getType() + if "TXM" in lesTypes: + texteRequete += "'" + texteRequete += str(obj.valeur) + if "TXM" in lesTypes: + texteRequete += "'" + separateur = " and " + return 1, "requete generee : ", texteRequete diff --git a/generator/generator_GroupMA.py b/generator/generator_GroupMA.py index 6a67088a..4e428060 100644 --- a/generator/generator_GroupMA.py +++ b/generator/generator_GroupMA.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,61 +20,63 @@ """ Ce module contient le plugin generateur d une liste des GroupNo et GroupMA """ -from __future__ import absolute_import import traceback -import types,re +import types, re from .generator_python import PythonGenerator + + def entryPoint(): """ - Retourne les informations necessaires pour le chargeur de plugins + Retourne les informations necessaires pour le chargeur de plugins - Ces informations sont retournees dans un dictionnaire + Ces informations sont retournees dans un dictionnaire """ return { - # Le nom du plugin - 'name' : 'GroupMA', - # La factory pour creer une instance du plugin - 'factory' : GroupMAGenerator, - } + # Le nom du plugin + "name": "GroupMA", + # La factory pour creer une instance du plugin + "factory": GroupMAGenerator, + } class GroupMAGenerator(PythonGenerator): """ - Ce generateur parcourt un objet de type JDC et produit - un texte au format eficas et - un texte au format homard + Ce generateur parcourt un objet de type JDC et produit + un texte au format eficas et + un texte au format homard """ + # Les extensions de fichier preconisees - extensions=('.comm',) + extensions = (".comm",) def __init__(self): PythonGenerator.__init__(self) - self.listeMA=[] - self.listeNO=[] + self.listeMA = [] + self.listeNO = [] - def gener(self,obj,format='brut',config=None): - self.liste=[] - self.text=PythonGenerator.gener(self,obj,'brut',config=None) - return self.listeMA,self.listeNO + def gener(self, obj, format="brut", config=None): + self.liste = [] + self.text = PythonGenerator.gener(self, obj, "brut", config=None) + return self.listeMA, self.listeNO - def generMCSIMP(self,obj) : - if 'grma' in repr(obj.definition.type) : + def generMCSIMP(self, obj): + if "grma" in repr(obj.definition.type): if not type(obj.valeur) in (list, tuple): - aTraiter=(obj.valeur,) - else : - aTraiter=obj.valeur - for group in aTraiter : - if group not in self.listeMA : + aTraiter = (obj.valeur,) + else: + aTraiter = obj.valeur + for group in aTraiter: + if group not in self.listeMA: self.listeMA.append(group) - if 'grno' in repr(obj.definition.type) : + if "grno" in repr(obj.definition.type): if not type(obj.valeur) in (list, tuple): - aTraiter=(obj.valeur,) - else : - aTraiter=obj.valeur - for group in aTraiter : - if group not in self.listeNO : + aTraiter = (obj.valeur,) + else: + aTraiter = obj.valeur + for group in aTraiter: + if group not in self.listeNO: self.listeNO.append(group) - s=PythonGenerator.generMCSIMP(self,obj) + s = PythonGenerator.generMCSIMP(self, obj) return s diff --git a/generator/generator_TELEMAC.py b/generator/generator_TELEMAC.py index 0a503552..86c94c91 100644 --- a/generator/generator_TELEMAC.py +++ b/generator/generator_TELEMAC.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -19,347 +19,391 @@ # """Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS. """ - -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import str -except : pass +from builtins import str import traceback -import types,re,os +import types, re, os from Extensions.i18n import tr from .generator_python import PythonGenerator -extensions=('.comm',) - - +extensions = (".comm",) def entryPoint(): """ - Retourne les informations necessaires pour le chargeur de plugins - Ces informations sont retournees dans un dictionnaire + Retourne les informations necessaires pour le chargeur de plugins + Ces informations sont retournees dans un dictionnaire """ return { - # Le nom du plugin - 'name' : 'TELEMAC', - # La factory pour creer une instance du plugin - 'factory' : TELEMACGenerator, - } + # Le nom du plugin + "name": "TELEMAC", + # La factory pour creer une instance du plugin + "factory": TELEMACGenerator, + } class TELEMACGenerator(PythonGenerator): """ - Ce generateur parcourt un objet de type JDC et produit - un texte au format eficas et - un texte au format dictionnaire + Ce generateur parcourt un objet de type JDC et produit + un texte au format eficas et + un texte au format dictionnaire """ -#---------------------------------------------------------------------------------------- - def gener(self,obj,format='brut',config=None,appliEficas=None,statut="Leger"): - - self.statut = statut - self.langue = appliEficas.langue - try : self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn - except : - print ('Attention : pas de TelemacdicoEn declare') + # ---------------------------------------------------------------------------------------- + def gener(self, obj, format="brut", config=None, appliEficas=None, statut="Leger"): + self.statut = statut + self.langue = appliEficas.langue + try: + self.TelemacdicoEn = appliEficas.readercata.TelemacdicoEn + except: + print("Attention : pas de TelemacdicoEn declare") self.TelemacdicoEn = {} self.DicoEnumCasEnInverse = {} - #from enum_Telemac2d_auto import self.TelemacdicoEn + # from enum_Telemac2d_auto import self.TelemacdicoEn for motClef in self.TelemacdicoEn: - d={} + d = {} for valTelemac in self.TelemacdicoEn[motClef]: - valEficas = self.TelemacdicoEn[motClef][valTelemac] - d[valEficas] =valTelemac - self.DicoEnumCasEnInverse[motClef]=d - if self.langue == 'fr' : - #from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn - self.DicoEnumCasFrToEnumCasEn = appliEficas.readercata.DicoEnumCasFrToEnumCasEn + valEficas = self.TelemacdicoEn[motClef][valTelemac] + d[valEficas] = valTelemac + self.DicoEnumCasEnInverse[motClef] = d + if self.langue == "fr": + # from enum_Telemac2d_auto import DicoEnumCasFrToEnumCasEn + self.DicoEnumCasFrToEnumCasEn = ( + appliEficas.readercata.DicoEnumCasFrToEnumCasEn + ) for motClef in self.DicoEnumCasFrToEnumCasEn: - d={} + d = {} for valTelemac in self.DicoEnumCasFrToEnumCasEn[motClef]: - valEficas = self.DicoEnumCasFrToEnumCasEn[motClef][valTelemac] + valEficas = self.DicoEnumCasFrToEnumCasEn[motClef][valTelemac] d[valEficas] = valTelemac - self.DicoEnumCasEnInverse[motClef]=d + self.DicoEnumCasEnInverse[motClef] = d self.initDico() # Pour Simplifier les verifs d ecriture - if hasattr(appliEficas,'listeTelemac') : self.listeTelemac=appliEficas.listeTelemac - else : self.listeTelemac = () - - self.dicoCataToCas={} - try : - self.dicoCasToCata=appliEficas.readercata.dicoCasToCata - except : - print ('Attention pas de dicoCasToCata declare') - self.dicoCasToCata={} - self.dicoCataToCas={} + if hasattr(appliEficas, "listeTelemac"): + self.listeTelemac = appliEficas.listeTelemac + else: + self.listeTelemac = () + + self.dicoCataToCas = {} + try: + self.dicoCasToCata = appliEficas.readercata.dicoCasToCata + except: + print("Attention pas de dicoCasToCata declare") + self.dicoCasToCata = {} + self.dicoCataToCas = {} for motClef in self.dicoCasToCata: - self.dicoCataToCas[self.dicoCasToCata[motClef]]=motClef - - + self.dicoCataToCas[self.dicoCasToCata[motClef]] = motClef # Cette instruction genere le contenu du fichier de commandes (persistance) - self.text=PythonGenerator.gener(self,obj,format) + self.text = PythonGenerator.gener(self, obj, format) return self.text + # ---------------------------------------------------------------------------------------- + # initialisations + # ---------------------------------------------------------------------------------------- -#---------------------------------------------------------------------------------------- -# initialisations -#---------------------------------------------------------------------------------------- - - def initDico(self) : - - self.PE=False - self.FE=False - self.VE=False + def initDico(self): + self.PE = False + self.FE = False + self.VE = False self.commentaireAvant = False - self.texteCom='' - if self.langue == "fr" : - self.textPE = 'COTES IMPOSEES :' - self.textFE = 'DEBITS IMPOSES :' - self.textVE = 'VITESSES IMPOSEES :' - else : - self.textPE = 'PRESCRIBED ELEVATIONS :' - self.textFE = 'PRESCRIBED FLOWRATES :' - self.textVE = 'PRESCRIBED VELOCITIES :' + self.texteCom = "" + if self.langue == "fr": + self.textPE = "COTES IMPOSEES :" + self.textFE = "DEBITS IMPOSES :" + self.textVE = "VITESSES IMPOSEES :" + else: + self.textPE = "PRESCRIBED ELEVATIONS :" + self.textFE = "PRESCRIBED FLOWRATES :" + self.textVE = "PRESCRIBED VELOCITIES :" self.nbTracers = 0 self.texteDico = "" - - - -#---------------------------------------------------------------------------------------- -# ecriture de tout -#---------------------------------------------------------------------------------------- - - def writeDefault(self,fn) : - self.texteDico+='&ETA\n' - #if self.statut == 'Leger' : extension = ".Lcas" - #else : extension = ".cas" - extension=".cas" - fileDico = fn[:fn.rfind(".")] + extension - f = open( str(fileDico), 'w') - f.write( self.texteDico ) + # ---------------------------------------------------------------------------------------- + # ecriture de tout + # ---------------------------------------------------------------------------------------- + + def writeDefault(self, fn): + self.texteDico += "&ETA\n" + # if self.statut == 'Leger' : extension = ".Lcas" + # else : extension = ".cas" + extension = ".cas" + fileDico = fn[: fn.rfind(".")] + extension + f = open(str(fileDico), "w") + f.write(self.texteDico) f.close() -#---------------------------------------------------------------------------------------- -# ecriture de Leger -#---------------------------------------------------------------------------------------- + # ---------------------------------------------------------------------------------------- + # ecriture de Leger + # ---------------------------------------------------------------------------------------- - def writeComplet(self,fn,jdc,config,appliEficas) : - jdc_formate=self.gener(jdc,config=config,appliEficas=appliEficas,statut="Entier") + def writeComplet(self, fn, jdc, config, appliEficas): + jdc_formate = self.gener( + jdc, config=config, appliEficas=appliEficas, statut="Entier" + ) self.writeDefault(fn) - -#---------------------------------------------------------------------------------------- -# analyse de chaque noeud de l'arbre -#---------------------------------------------------------------------------------------- - - def generPROC_ETAPE(self,obj): - if not self.commentaireAvant or self.texteCom.find(obj.nom) < 0: - self.texteDico += '/------------------------------------------------------------------/\n' - self.texteDico += '/\t\t\t'+obj.nom +'\n' - self.texteDico += '/------------------------------------------------------------------/\n' + # ---------------------------------------------------------------------------------------- + # analyse de chaque noeud de l'arbre + # ---------------------------------------------------------------------------------------- + + def generPROC_ETAPE(self, obj): + if not self.commentaireAvant or self.texteCom.find(obj.nom) < 0: + self.texteDico += ( + "/------------------------------------------------------------------/\n" + ) + self.texteDico += "/\t\t\t" + obj.nom + "\n" + self.texteDico += ( + "/------------------------------------------------------------------/\n" + ) self.commentaireAvant = False - self.texteCom='' - s=PythonGenerator.generPROC_ETAPE(self,obj) - if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom](*(self,obj)) + self.texteCom = "" + s = PythonGenerator.generPROC_ETAPE(self, obj) + if obj.nom in TELEMACGenerator.__dict__: + TELEMACGenerator.__dict__[obj.nom](*(self, obj)) return s - def generMCSIMP(self,obj) : + def generMCSIMP(self, obj): """recuperation de l objet MCSIMP""" - s=PythonGenerator.generMCSIMP(self,obj) - + s = PythonGenerator.generMCSIMP(self, obj) # Attention pas sur --> ds certains cas non traite par MCFACT ? # a reflechir avec Yoann # ajouter le statut ? - if self.statut == 'Leger' : - if hasattr(obj.definition,'defaut') and (obj.definition.defaut == obj.valeur) and (obj.nom not in self.listeTelemac) : return s - if hasattr(obj.definition,'defaut') and obj.definition.defaut != None and (type(obj.valeur) == tuple or type(obj.valeur) == list) and (tuple(obj.definition.defaut) == tuple(obj.valeur)) and (obj.nom not in self.listeTelemac) : return s - - - #nomMajuscule=obj.nom.upper() - #nom=nomMajuscule.replace('_',' ') - #if nom in listeSupprime or s == "" : return s - if s == "None," : s=None - if s == "" or s==None : return s + if self.statut == "Leger": + if ( + hasattr(obj.definition, "defaut") + and (obj.definition.defaut == obj.valeur) + and (obj.nom not in self.listeTelemac) + ): + return s + if ( + hasattr(obj.definition, "defaut") + and obj.definition.defaut != None + and (type(obj.valeur) == tuple or type(obj.valeur) == list) + and (tuple(obj.definition.defaut) == tuple(obj.valeur)) + and (obj.nom not in self.listeTelemac) + ): + return s + + # nomMajuscule=obj.nom.upper() + # nom=nomMajuscule.replace('_',' ') + # if nom in listeSupprime or s == "" : return s + if s == "None,": + s = None + if s == "" or s == None: + return s - sTelemac=s[0:-1] - if not( type(obj.valeur) in (tuple,list) ): + sTelemac = s[0:-1] + if not (type(obj.valeur) in (tuple, list)): if obj.nom in self.DicoEnumCasEnInverse: - try : sTelemac=str(self.DicoEnumCasEnInverse[obj.nom][obj.valeur]) - except : - if obj.valeur==None : sTelemac=obj.valeur - else : print(("generMCSIMP Pb valeur avec ", obj.nom, obj.valeur)) + try: + sTelemac = str(self.DicoEnumCasEnInverse[obj.nom][obj.valeur]) + except: + if obj.valeur == None: + sTelemac = obj.valeur + else: + print(("generMCSIMP Pb valeur avec ", obj.nom, obj.valeur)) # Si le resultat est du texte on ajoute des guillemets - if sTelemac[0] not in '0123456789': - sTelemac = "'" + sTelemac +"'" + if sTelemac[0] not in "0123456789": + sTelemac = "'" + sTelemac + "'" - if type(obj.valeur) in (tuple,list) : + if type(obj.valeur) in (tuple, list): if obj.nom in self.DicoEnumCasEnInverse: - #sT = "'" - sT='' + # sT = "'" + sT = "" for v in obj.valeur: - try : sT +=str(self.DicoEnumCasEnInverse[obj.nom][v]) +";" - except : - if obj.definition.intoSug != [] : sT +=str(v) + ";" - else : print(("generMCSIMP Pb Tuple avec ", obj.nom, v, obj.valeur)) - #sTelemac=sT[0:-1]+"'" - sTelemac=sT[0:-1] - else : - sTelemac=sTelemac[0:-1] - if sTelemac.find("'") > 0 : - sTelemac= sTelemac.replace (',',';\n ') + try: + sT += str(self.DicoEnumCasEnInverse[obj.nom][v]) + ";" + except: + if obj.definition.intoSug != []: + sT += str(v) + ";" + else: + print( + ("generMCSIMP Pb Tuple avec ", obj.nom, v, obj.valeur) + ) + # sTelemac=sT[0:-1]+"'" + sTelemac = sT[0:-1] + else: + sTelemac = sTelemac[0:-1] + if sTelemac.find("'") > 0: + sTelemac = sTelemac.replace(",", ";\n ") # on enleve le dernier ';' - index=(sTelemac.rfind(";")) - sTelemac=sTelemac[:index]+' '+sTelemac[index+1:] - - if self.langue=='fr' : - s1=str(sTelemac).replace('True','OUI') - s2=s1.replace('False','NON') - else : - s1=str(sTelemac).replace('True','YES') - s2=s1.replace('False','NO') - if hasattr(obj.definition,'max'): + index = sTelemac.rfind(";") + sTelemac = sTelemac[:index] + " " + sTelemac[index + 1 :] + + if self.langue == "fr": + s1 = str(sTelemac).replace("True", "OUI") + s2 = s1.replace("False", "NON") + else: + s1 = str(sTelemac).replace("True", "YES") + s2 = s1.replace("False", "NO") + if hasattr(obj.definition, "max"): if obj.definition.max != 1: - s3=s2.replace(',',';') + s3 = s2.replace(",", ";") else: - s3=s2 - if s3 != "" and s3[0]=='(' : - try : s3=s3[1:-1] # cas de liste vide - except : s3 = ' ' - + s3 = s2 + if s3 != "" and s3[0] == "(": + try: + s3 = s3[1:-1] # cas de liste vide + except: + s3 = " " # LIQUID_BOUNDARIES - #if obj.nom in ('PRESCRIBED_FLOWRATES','PRESCRIBED_VELOCITIES','PRESCRIBED_ELEVATIONS') : + # if obj.nom in ('PRESCRIBED_FLOWRATES','PRESCRIBED_VELOCITIES','PRESCRIBED_ELEVATIONS') : # return s # cas des Tuples - if obj.waitTuple() and s3 != '' and s3 != 'None': - s3=s - if s3[-1] == ',': s3=s3[:-1] - - - if obj.nom not in self.dicoCataToCas : - if obj.nom == 'Consigne' : return "" + if obj.waitTuple() and s3 != "" and s3 != "None": + s3 = s + if s3[-1] == ",": + s3 = s3[:-1] + + if obj.nom not in self.dicoCataToCas: + if obj.nom == "Consigne": + return "" return s - nom=self.dicoCataToCas[obj.nom] - if nom in ["VARIABLES FOR GRAPHIC PRINTOUTS", "VARIABLES POUR LES SORTIES GRAPHIQUES", - "VARIABLES TO BE PRINTED","VARIABLES A IMPRIMER", - "VARIABLES FOR 3D GRAPHIC PRINTOUTS", "VARIABLES POUR LES SORTIES GRAPHIQUES 3D", - "VARIABLES POUR LES SORTIES GRAPHIQUES 2D", "VARIABLES FOR 2D GRAPHIC PRINTOUTS", - "C_VSM_PRINTOUT_SELECTION"]: - if s3 != '' and s3 != 'None': - s3=s3.replace(';',',') - s3="'"+ s3 +"'" + nom = self.dicoCataToCas[obj.nom] + if nom in [ + "VARIABLES FOR GRAPHIC PRINTOUTS", + "VARIABLES POUR LES SORTIES GRAPHIQUES", + "VARIABLES TO BE PRINTED", + "VARIABLES A IMPRIMER", + "VARIABLES FOR 3D GRAPHIC PRINTOUTS", + "VARIABLES POUR LES SORTIES GRAPHIQUES 3D", + "VARIABLES POUR LES SORTIES GRAPHIQUES 2D", + "VARIABLES FOR 2D GRAPHIC PRINTOUTS", + "C_VSM_PRINTOUT_SELECTION", + ]: + if s3 != "" and s3 != "None": + s3 = s3.replace(";", ",") + s3 = "'" + s3 + "'" else: s3 = "''" if nom in ["COUPLING WITH", "COUPLAGE AVEC"]: - s3 = s3.strip().replace("\n","")\ - .replace(" ", "")\ - .replace("\t", "")\ - .replace("';'", ",") - if s3 == "" or s3 == " " : s3 = " " - ligne=nom+ " : " + s3 + "\n" - if len(ligne) > 72 : ligne=self.redecoupeLigne(nom,s3) - self.texteDico+=ligne - - def generMCFACT(self,obj): - """ - """ - s=PythonGenerator.generMCFACT(self,obj) - if obj.nom in TELEMACGenerator.__dict__ : TELEMACGenerator.__dict__[obj.nom](self,obj) + s3 = ( + s3.strip() + .replace("\n", "") + .replace(" ", "") + .replace("\t", "") + .replace("';'", ",") + ) + if s3 == "" or s3 == " ": + s3 = " " + ligne = nom + " : " + s3 + "\n" + if len(ligne) > 72: + ligne = self.redecoupeLigne(nom, s3) + self.texteDico += ligne + + def generMCFACT(self, obj): + """ """ + s = PythonGenerator.generMCFACT(self, obj) + if obj.nom in TELEMACGenerator.__dict__: + TELEMACGenerator.__dict__[obj.nom](self, obj) return s + def TRACERS(self, obj): + if self.nbTracers != 0: + self.texteDico += "NUMBER_OF_TRACERS : " + str(self.nbTracers) + "\n" - def TRACERS(self,obj): - if self.nbTracers != 0 : self.texteDico += 'NUMBER_OF_TRACERS : '+str(self.nbTracers) + '\n' - - - def NAME_OF_TRACER(self,obj): - print((dir(obj) )) + def NAME_OF_TRACER(self, obj): + print((dir(obj))) print((obj.getGenealogiePrecise())) - def Validation(self,obj): + def Validation(self, obj): self.texteDico += "VALIDATION : True \n" - def Date_De_L_Origine_Des_Temps (self,obj): - an=obj.getChild('Year').valeur - mois=obj.getChild('Month').valeur - jour=obj.getChild('Day').valeur - self.texteDico += "ORIGINAL DATE OF TIME :"+ str(an)+ " ,"+str(mois)+ "," +str(jour)+ "\n" - - def Original_Hour_Of_Time (self,obj): - hh=obj.getChild('Hour').valeur - mm=obj.getChild('Minute').valeur - ss=obj.getChild('Second').valeur - self.texteDico += "ORIGINAL HOUR OF TIME :"+str(hh)+" ,"+str(mm)+ ","+str(ss)+"\n" - - def Type_Of_Advection(self,obj): - listeAdvection=[1,5,1,1] - listeSupg=[2,2,2,2] - listeUpwind=[1.,1.,1.,1.] - self.listeMCAdvection=[] + def Date_De_L_Origine_Des_Temps(self, obj): + an = obj.getChild("Year").valeur + mois = obj.getChild("Month").valeur + jour = obj.getChild("Day").valeur + self.texteDico += ( + "ORIGINAL DATE OF TIME :" + + str(an) + + " ," + + str(mois) + + "," + + str(jour) + + "\n" + ) + + def Original_Hour_Of_Time(self, obj): + hh = obj.getChild("Hour").valeur + mm = obj.getChild("Minute").valeur + ss = obj.getChild("Second").valeur + self.texteDico += ( + "ORIGINAL HOUR OF TIME :" + str(hh) + " ," + str(mm) + "," + str(ss) + "\n" + ) + + def Type_Of_Advection(self, obj): + listeAdvection = [1, 5, 1, 1] + listeSupg = [2, 2, 2, 2] + listeUpwind = [1.0, 1.0, 1.0, 1.0] + self.listeMCAdvection = [] self.chercheChildren(obj) - dicoSuf={ 'U_And_V' : 0, 'H' : 1, 'K_And_Epsilon' : 2, 'Tracers' : 3} - for c in self.listeMCAdvection: - if c.nom[0:18] == 'Type_Of_Advection_' and c.valeur!=None: - suf=c.nom[18:] - index=dicoSuf[suf] - listeAdvection[index]=self.DicoEnumCasEnInverse['Type_Of_Advection'][c.valeur] - if c.nom[0:13] == 'Supg_Option_' and c.valeur!=None: - suf=c.nom[13:] - index=dicoSuf[suf] - listeAdvection[index]=self.DicoEnumCasEnInverse['Supg_Option'][c.valeur] - if c.nom[0:23] == 'Upwind_Coefficients_Of_' and c.valeur!=None: - suf=c.nom[23:] - index=dicoSuf[suf] - listeUpwind[index]=c.valeur - self.texteDico += "TYPE OF ADVECTION = "+ str(listeAdvection) + "\n" - self.texteDico += "SUPG OPTION = "+ str(listeSupg) + "\n" - self.texteDico += "UPWIND COEFFICIENTS = "+ str(listeUpwind) + "\n" - - def chercheChildren(self,obj): + dicoSuf = {"U_And_V": 0, "H": 1, "K_And_Epsilon": 2, "Tracers": 3} + for c in self.listeMCAdvection: + if c.nom[0:18] == "Type_Of_Advection_" and c.valeur != None: + suf = c.nom[18:] + index = dicoSuf[suf] + listeAdvection[index] = self.DicoEnumCasEnInverse["Type_Of_Advection"][ + c.valeur + ] + if c.nom[0:13] == "Supg_Option_" and c.valeur != None: + suf = c.nom[13:] + index = dicoSuf[suf] + listeAdvection[index] = self.DicoEnumCasEnInverse["Supg_Option"][ + c.valeur + ] + if c.nom[0:23] == "Upwind_Coefficients_Of_" and c.valeur != None: + suf = c.nom[23:] + index = dicoSuf[suf] + listeUpwind[index] = c.valeur + self.texteDico += "TYPE OF ADVECTION = " + str(listeAdvection) + "\n" + self.texteDico += "SUPG OPTION = " + str(listeSupg) + "\n" + self.texteDico += "UPWIND COEFFICIENTS = " + str(listeUpwind) + "\n" + + def chercheChildren(self, obj): for c in obj.listeMcPresents(): - objc=obj.getChild(c) - if hasattr(objc,'listeMcPresents') and objc.listeMcPresents() != [] : self.chercheChildren(objc) - else : self.listeMCAdvection.append(objc) - - + objc = obj.getChild(c) + if hasattr(objc, "listeMcPresents") and objc.listeMcPresents() != []: + self.chercheChildren(objc) + else: + self.listeMCAdvection.append(objc) - def redecoupeLigne(self,nom,valeur) : - text=nom+ " : \n" - valeur=valeur + def redecoupeLigne(self, nom, valeur): + text = nom + " : \n" + valeur = valeur if valeur.find("'") > -1: - lval=valeur.split(";") - for v in lval : text+=' '+v+';' - text=text[0:-1]+'\n' - else : - lval=valeur.split(";") - ligne=" " - for v in lval : - if len(ligne+ str(v)+'; ') < 70 : ligne += str(v)+'; ' - else : - text+= ligne+"\n" - ligne=" "+str(v)+'; ' - text+= ligne[0:-2]+'\n' + lval = valeur.split(";") + for v in lval: + text += " " + v + ";" + text = text[0:-1] + "\n" + else: + lval = valeur.split(";") + ligne = " " + for v in lval: + if len(ligne + str(v) + "; ") < 70: + ligne += str(v) + "; " + else: + text += ligne + "\n" + ligne = " " + str(v) + "; " + text += ligne[0:-2] + "\n" return text - def generCOMMENTAIRE(self,obj): - sans_saut = re.sub("\n$","",obj.valeur) - l_lignes = sans_saut.split('\n') - txt='/'+66*'-'+'/'+'\n' - i=1 + def generCOMMENTAIRE(self, obj): + sans_saut = re.sub("\n$", "", obj.valeur) + l_lignes = sans_saut.split("\n") + txt = "/" + 66 * "-" + "/" + "\n" + i = 1 for ligne in l_lignes: - self.texteCom+=ligne+'\n' - txt = txt + '/'+ligne+'\n' - txt= txt + '/'+66*'-'+'/'+'\n' + self.texteCom += ligne + "\n" + txt = txt + "/" + ligne + "\n" + txt = txt + "/" + 66 * "-" + "/" + "\n" self.texteDico += txt - self.commentaireAvant= True - return PythonGenerator.generCOMMENTAIRE(self,obj) + self.commentaireAvant = True + return PythonGenerator.generCOMMENTAIRE(self, obj) diff --git a/generator/generator_UQ.py b/generator/generator_UQ.py new file mode 100755 index 00000000..81f9e174 --- /dev/null +++ b/generator/generator_UQ.py @@ -0,0 +1,1092 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2024 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +""" + Ce module contient le plugin generateur de fichier au format + UQ pour EFICAS. + +""" +from builtins import str + +import traceback +import types, re, os +import Accas + +from .generator_python import PythonGenerator + +# texteUranie present dans le banc Reacteur Numerique +# textePresalys present hors le banc Reacteur Numerique +try: + from .texteUranie import SCRIPT_URANIE +except: + pass + +try: + from .textePersalys import ( + headerScriptPersalys, + fonctionPersalys, + etudeScript, + codePersalys, + ) + from .textePersalys import mainPersalys, inputHeaderPersalys, outputHeaderPersalys + from .textePersalys import getResultCall, getResultCallAvoidPersalysBug + from .textePersalys import centralTendencyTaylor, resultTaylor + from .textePersalys import optionalResultTaylor, optionalPrintResultTaylor + from .textePersalys import centralTendencyMC, resultMC + from .textePersalys import critereArretMC, advancedParameterMC + from .textePersalys import optionalResultMC, optionalPrintResultMC + from .textePersalys import printResultMC, printResultTaylor + from .textePersalys import ( + yacsJobParameters, + yacsJobClusterParameters, + yacsJobClusterMultiJob, + ) + + genereScriptPersalys = True +except: + genereScriptPersalys = False + +genereScriptPersalys = False + + +def entryPoint(): + """ + Retourne les informations necessaires pour le chargeur de plugins + + Ces informations sont retournees dans un dictionnaire + """ + return { + # Le nom du plugin + "name": "UQ", + # La factory pour creer une instance du plugin + "factory": UQGenerator, + } + + +class UQGenerator(PythonGenerator): + """ + Ce generateur parcourt un objet de type JDC et produit + un texte au format eficas 'normal' + un texte au format eficas avec balise + un script python permettant de piloter Persalys + + """ + + def gener(self, jdc, format="beautifie"): + self.indent1 = " " + + # On remet a jour les MCPath + self.jdc = jdc + self.recalculeMCPath() + if jdc.nature != "JDC" or not jdc.isValid(): + ret, commentaire = self.sauveUniquementCommEt_UQComm(jdc) + if not ret: + return (ret, commentaire) + self.commentaire = "Le JDC doit etre valide pour generer le script de lancement et le fichier à balises\n" + self.commentaire += ( + "Seuls les fichiers _det.comm et .comm ont été sauvegardés" + ) + return 2 + ret, commentaire = self.analyseIncertitude() + if not ret: + self.commentaire = commentaire + return ret + self.inGenerUQ = True + self.generDeterministe = False + self.textUQ = PythonGenerator.gener(self, jdc, format) + self.inGenerUQ = False + self.generDeterministe = True + self.text = PythonGenerator.gener(self, jdc, format) + return self.text + + def creeNomsFichiers(self, fichier): + self.cheminFichierComm = os.path.abspath(os.path.dirname(fichier)) + if fichier.endswith(".xml"): + self.fichierSansSuffixe = os.path.basename(fichier[:-5]) + elif fichier.endswith(".comm"): + self.fichierSansSuffixe = os.path.basename(fichier[:-5]) + else: + self.commentaire = "Le nom du fichier doit finir par .comm ou .xml\n" + return ( + 0, + "le fichier jeux de données |" + + fichier + + "| doit être suffixé par .comm", + ) + self.fichierComm = self.fichierSansSuffixe + ".comm" + self.fichierDetComm = self.fichierSansSuffixe + "_det.comm" + self.fichierBalise = self.fichierSansSuffixe + "_@det.comm" + self.fichierUQExe = self.fichierSansSuffixe + "_UQ.py" + self.fichierUQModule = os.path.basename(self.fichierUQExe)[:-3] + return (1, "") + + def sauveUniquementCommEt_UQComm(self, jdc): + self.inGenerUQ = False + self.generDeterministe = True + self.text = PythonGenerator.gener(self, jdc, "beautifie") + fichierDetComm = os.path.join(self.cheminFichierComm, self.fichierDetComm) + if not self.writeFile(fichierDetComm): + return (0, "impossible de sauvegarder le _det.comm") + self.generDeterministe = False + self.text = PythonGenerator.gener(self, jdc, "beautifie") + fichierComm = os.path.join(self.cheminFichierComm, self.fichierComm) + if not self.writeFile(fichierComm): + return (0, "impossible de sauvegarder le .comm") + return (1, "") + + def writeUQ(self, fichier): + # il manque le checksum + fichierBalise = os.path.join(self.cheminFichierComm, self.fichierBalise) + fichierUQExe = os.path.join(self.cheminFichierComm, self.fichierUQExe) + try: + with open(fichierBalise, "w") as fp: + fp.write(self.textUQ) + except: + return (0, "impossible de sauvegarder le _@det.py") + try: + # if 1 : + with open(fichierUQExe, "w") as fp: + fp.write(self.txtScript) + except: + if self.txtScript != "": + return (0, "impossible de sauvegarder le .py") + # a reecrire pour ne pas appeler trop de fois le gener + retour, commentaire = self.sauveUniquementCommEt_UQComm(self.jdc) + if not retour: + return (retour, commentaire) + return (1, None) + + def generPROC_ETAPE(self, obj): + if not self.inGenerUQ: + return PythonGenerator.generPROC_ETAPE(self, obj) + if obj.nom == "ExpressionIncertitude" and self.inGenerUQ: + return "" + else: + return PythonGenerator.generPROC_ETAPE(self, obj) + # il faut remplacer @xxx@ + # DU coup qu est ce que xxx + + def generMCSIMP(self, obj): + # inutile tant que FACT et BLOC ne sont pas surcharges + if obj.nom == "Consigne": + return + if not self.inGenerUQ: + return PythonGenerator.generMCSIMP(self, obj) + if not obj in self.mcIncertains: + return PythonGenerator.generMCSIMP(self, obj) + else: + # a refaire si on decide que les incertains sont sous des fact multiples + # ce qui ne me parait pas possible mais ? + if obj.etape.nature == "OPERATEUR": + return "@ " + obj.etape.sd.nom + "__" + obj.nom + " @," + else: + return "@ " + obj.nom + " @," + + def recalculeMCPath(self): + etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude") + if len(etapeIncertitude) != 1: + return + etapeIncertitude = etapeIncertitude[0] + self.lesVariablesInput = etapeIncertitude.getChild("Input")[ + 0 + ].getChildOrChildInBloc("VariableProbabiliste") + index = 0 + for mc in self.lesVariablesInput.data: + itemMCPath = mc.getChild("MCPath") + itemMCPath.setValeur(mc.variableDeterministe.getMCPath()) + + def analyseIncertitude(self): + from functools import reduce as reduce + + self.txtScriptPersalys = "" + self.txtScript = "" + etapeScenarioData = self.jdc.getEtapesByName("Scenario_data") + if etapeScenarioData == []: + return ( + 0, + "il faut au moins un mot-clef Scenario_data", + ) # TODO : à Résorber après modification du catalogue + if len(etapeScenarioData) != 1: + return ( + 0, + "il faut au plus un mot-clef Scenario_data", + ) # TODO : à Résorber après modification du catalogue + etapeScenarioData = etapeScenarioData[0] + self.ScenarioType = etapeScenarioData.getChildOrChildInBloc( + "scenario_type" + ).valeur + + etapeIncertitude = self.jdc.getEtapesByName("ExpressionIncertitude") + if etapeIncertitude == []: + return (0, "il faut au moins un mot-clef ExpressionIncertitude") + if len(etapeIncertitude) != 1: + return (0, "il faut au plus un mot-clef ExpressionIncertitude") + etapeIncertitude = etapeIncertitude[0] + + incertitudeInput = etapeIncertitude.getChildOrChildInBloc("Input") + self.lesVariablesInput = incertitudeInput[0].getChildOrChildInBloc( + "VariableProbabiliste" + ) + self.mcIncertains = [] + self.nomsDesVariablesInput = [] + self.chaineDesVariablesInput = "" + for mc in self.lesVariablesInput: + if mc.variableDeterministe.etape.nature == "OPERATEUR": + self.chaineDesVariablesInput += ( + mc.variableDeterministe.etape.sd.nom + + "__" + + mc.variableDeterministe.nom + + ", " + ) + self.nomsDesVariablesInput.append( + mc.variableDeterministe.etape.sd.nom + + "__" + + mc.variableDeterministe.nom + ) + else: + self.chaineDesVariablesInput += mc.variableDeterministe.nom + ", " + self.nomsDesVariablesInput.append(mc.variableDeterministe.nom) + self.mcIncertains.append(mc.variableDeterministe) + + sectionOutput = etapeIncertitude.getChildOrChildInBloc("Output")[0] + self.ScriptPosttraitement = sectionOutput.getChildOrChildInBloc( + "ScriptPosttraitement" + ) + # dans le cas du catalogue UQ gere dans le banc RN, ScriptPosttraitement n existe pas + if self.ScriptPosttraitement: + self.ScriptPosttraitement = sectionOutput.getChildOrChildInBloc( + "ScriptPosttraitement" + ).valeur + if isinstance(self.ScriptPosttraitement, Accas.PARAMETRE): + self.ScriptPosttraitement = self.ScriptPosttraitement.valeur + self.chaineDesVariablesInput = self.chaineDesVariablesInput[0:-2] + + # Cas RN OpenTurns ScriptPosttraitement = None + # on ne fait pas le return : la suite du traitement est necessaire a uranie + sectionPropagation = etapeIncertitude.getChildOrChildInBloc("Propagation")[0] + self.Methode = sectionPropagation.getChildOrChildInBloc("Methode").valeur + if not sectionPropagation.getChildOrChildInBloc("Result"): + self.Result = None + else: + self.Result = sectionPropagation.getChildOrChildInBloc("Result")[0] + if self.Methode == "MonteCarlo": + self.critereArret = sectionPropagation.getChildOrChildInBloc( + "CritereArret" + )[0] + if sectionPropagation.getChildOrChildInBloc("EvaluationParameter"): + sectionEvaluationParameter = sectionPropagation.getChildOrChildInBloc( + "EvaluationParameter" + )[0] + self.Blocksize = sectionEvaluationParameter.getChildOrChildInBloc( + "BlockSize" + ).valeur + self.advancedParameter = sectionPropagation.getChildOrChildInBloc( + "AdvancedParameter" + ) + if self.advancedParameter != None: + self.advancedParameter = self.advancedParameter[0] + # self.ComputeConfidenceIntervalAt = self.advancedParameter.getChildOrChildInBloc('ComputeConfidenceIntervalAt')[0] + # self.Seed = self.advancedParameter.getChildOrChildInBloc('Seed')[0] + self.lesVariablesOutput = sectionOutput.getChildOrChildInBloc( + "VariableDeSortie" + ) + self.chaineDesVariablesOutputEncodee = "" + self.txtOutputVariableInitList = "" + self.txtGetAllResults = "" + # TODO? from cata_UQ import FonctionDAggregationDict + fctAggPy = { + "valeur à t=O": "vInitialTime", + "valeur à mi-temps": "vHalfTime", + "valeur à t final": "vFinalTime", + "valeur moyenne": "vMean", + "valeur cumulée": "vSum", + "valeur minimale": "vMin", + "valeur maximale": "vMax", + } + + index = 0 + self.resultSkList = [0] + for mc in self.lesVariablesOutput: + nomShortVariableOutputList = "" + nomFctAggPyList = "" + nomOutputList = "" + nomVar = mc.getChildOrChildInBloc("VariablePhysique").valeur + nomVarEncode = nomVar.replace(" ", "__") # TODO : function + nomVarPostraite = mc.getChildOrChildInBloc( + "VariablePosttraiteeAssociee" + ).valeur + nomFctAggList = mc.getChildOrChildInBloc("FonctionDAggregation").valeur + for nomFctAgg in nomFctAggList: + nomFctAggPy = fctAggPy[nomFctAgg] + nomFctAggPyList += nomFctAggPy + ", " + nomOutput = nomVarEncode + "_" + nomFctAggPy + nomOutputList += nomOutput + ", " + self.chaineDesVariablesOutputEncodee += nomOutput + ", " + variablesOutputDesc = ( + '("' + nomFctAgg + '","' + nomVarPostraite + '")' + ) # TODO : Interdire ',' dans FctAgg et nomVarPost + nomShortVariableOutputList += ( + "a" + str(index) + ", " + ) # Avoid a Persalys Bug + index += 1 + self.txtOutputVariableInitList += ( + self.indent1 + + nomOutput + + " = persalys.Output('" + + nomVar + + " (" + + nomFctAgg + + ")" + + "', '" + + variablesOutputDesc + + "')\n" + ) + # tmpGetResultCall = getResultCall.format( + tmpGetResultCall = ( + getResultCallAvoidPersalysBug.format( # Avoid a Persalys Bug + variableOutputList=nomOutputList[0:-2], + nomVarPostraite=nomVarPostraite, + fonctionAggregationList=nomFctAggPyList[0:-2], + shortVariableOutputList=nomShortVariableOutputList[ + 0:-2 + ], # Avoid a Persalys Bug + ) + ) + self.txtGetAllResults += tmpGetResultCall + self.resultSkList.append(index) + + self.chaineDesVariablesOutputEncodee = self.chaineDesVariablesOutputEncodee[ + 0:-2 + ] + self.chaineDesShortVariablesOutput = reduce( + lambda x, y: x + y, ["a" + str(i) + ", " for i in range(index)] + )[0:-2] + + sectionExecution = etapeIncertitude.getChildOrChildInBloc("Execution")[0] + if ( + etapeIncertitude.getChildOrChildInBloc("UncertaintyTool").valeur + == "Persalys" + ): + self.NbDeBranches = sectionExecution.getChildOrChildInBloc( + "NbDeBranches" + ).valeur + if genereScriptPersalys: + if sectionExecution.getChildOrChildInBloc("ExecutionMode") != None: + self.ExecutionMode = sectionExecution.getChildOrChildInBloc( + "ExecutionMode" + ).valeur + self.JobName = sectionExecution.getChildOrChildInBloc("JobName").valeur + self.ResourceName = sectionExecution.getChildOrChildInBloc( + "ResourceName" + ).valeur + self.Login = sectionExecution.getChildOrChildInBloc("Login").valeur + self.WorkDirectory = sectionExecution.getChildOrChildInBloc( + "WorkDirectory" + ).valeur + self.ResultDirectory = sectionExecution.getChildOrChildInBloc( + "ResultDirectory" + ).valeur + self.UncertaintyScript = sectionExecution.getChildOrChildInBloc( + "UncertaintyScript" + ).valeur + if isinstance(self.UncertaintyScript, Accas.PARAMETRE): + self.UncertaintyScript = self.UncertaintyScript.valeur + print("self.UncertaintyScript : ", self.UncertaintyScript) + NbOfProcs = sectionExecution.getChildOrChildInBloc( + "NbOfProcs" + ) # None si 'desktop', vérification à faire ds jobmanager + MultiJobStudy = sectionExecution.getChildOrChildInBloc( + "MultiJobStudy" + ) # None si 'desktop' + if NbOfProcs != None: + self.NbOfProcs = NbOfProcs.valeur + else: + self.NbOfProcs = None + if MultiJobStudy != None: + self.MultiJobStudy = MultiJobStudy.valeur + else: + self.MultiJobStudy = None + self.creeScriptPersalys() + if etapeIncertitude.getChildOrChildInBloc("UncertaintyTool").valeur == "Uranie": + if ( + sectionExecution.getChildOrChildInBloc("ExecutionMode").valeur + == "desktop" + ): + self.ExecutionMode = sectionExecution.getChildOrChildInBloc( + "ExecutionMode" + ).valeur + self.visualization = sectionExecution.getChildOrChildInBloc( + "visualization" + ).valeur + self.sample_size = sectionExecution.getChildOrChildInBloc( + "sample_size" + ).valeur + self.launcher_type = sectionExecution.getChildOrChildInBloc( + "launcher_type" + ).valeur + if self.launcher_type == "distrib": + self.parallel_execs = sectionExecution.getChildOrChildInBloc( + "parallel_executions" + ).valeur + self.WorkDirectory = sectionExecution.getChildOrChildInBloc( + "UWorkDirectory" + ).valeur + self.ResultDirectory = sectionExecution.getChildOrChildInBloc( + "UResultDirectory" + ).valeur + self.cree_script_uranie() + + elif ( + sectionExecution.getChildOrChildInBloc("ExecutionMode").valeur + == "cluster" + ): + self.ExecutionMode = sectionExecution.getChildOrChildInBloc( + "ExecutionMode" + ).valeur + self.sample_size = sectionExecution.getChildOrChildInBloc( + "sample_size" + ).valeur + self.parallel_execs = sectionExecution.getChildOrChildInBloc( + "parallel_executions" + ).valeur + self.WorkDirectory = sectionExecution.getChildOrChildInBloc( + "UWorkDirectory" + ).valeur + self.ResultDirectory = sectionExecution.getChildOrChildInBloc( + "UResultDirectory" + ).valeur + self.nb_of_tasks = sectionExecution.getChildOrChildInBloc( + "nb_of_tasks" + ).valeur + self.nb_of_cpu_per_task = sectionExecution.getChildOrChildInBloc( + "nb_of_cpu_per_task" + ).valeur + self.memory_per_cpu = sectionExecution.getChildOrChildInBloc( + "memory_per_cpu" + ).valeur + self.partitions = sectionExecution.getChildOrChildInBloc( + "partitions" + ).valeur + self.qos = sectionExecution.getChildOrChildInBloc("qos").valeur + self.account = sectionExecution.getChildOrChildInBloc("account").valeur + self.walltime = sectionExecution.getChildOrChildInBloc( + "walltime" + ).valeur + self.job_name = sectionExecution.getChildOrChildInBloc( + "job_name" + ).valeur + self.output_file = sectionExecution.getChildOrChildInBloc( + "output_file" + ).valeur + self.error_file = sectionExecution.getChildOrChildInBloc( + "error_file" + ).valeur + self.email = sectionExecution.getChildOrChildInBloc("email").valeur + self.email_type = sectionExecution.getChildOrChildInBloc( + "email_type" + ).valeur + self.liste_of_nodes = sectionExecution.getChildOrChildInBloc( + "liste_of_nodes" + ).valeur + self.myscript_to_launch = sectionExecution.getChildOrChildInBloc( + "myscript_to_launch" + ).valeur + self.cree_script_uranie() + + return (1, "") + + def cree_script_uranie(self, debug: bool = False): + import pickle + import logging + import shutil + import uranie_interface.uncertainty_data as uncertainty_data + import uranie_interface.serialize_data as serialize_data + + if debug: + print("def cree_script_uranie(self, debug = True):") + + generatorDir = os.path.abspath(os.path.dirname(__file__)) + if debug: + print("generatorDir: ", generatorDir) + + ## inputs ## + u_inputs = uncertainty_data.Inputs() + for mc in self.lesVariablesInput: + if mc.variableDeterministe.etape.nature == "OPERATEUR": + name = ( + mc.variableDeterministe.etape.sd.nom + + "__" + + mc.variableDeterministe.nom + ) + else: + name = mc.variableDeterministe.nom + balise = " @" + name + "@ " + object_name = mc.variableDeterministe.etape.sd.nom + model_variable = mc.variableDeterministe.nom + + distribution_info = u_inputs.Distribution() + distribution = mc.getChildOrChildInBloc("Distribution").valeur + if distribution == "Uniform": + lower_bound = mc.getChildOrChildInBloc("A").valeur + upper_bound = mc.getChildOrChildInBloc("B").valeur + distribution_info.add_distribution_uniform( + distribution, lower_bound, upper_bound + ) + elif distribution == "TruncatedNormal": + lower_bound = mc.getChildOrChildInBloc("A").valeur + upper_bound = mc.getChildOrChildInBloc("B").valeur + standard_deviation = mc.getChildOrChildInBloc("SigmaN").valeur + mean = mc.getChildOrChildInBloc("MuN").valeur + distribution_info.add_distribution_truncated_normal( + distribution, lower_bound, upper_bound, mean, standard_deviation + ) + else: + values = mc.getChildOrChildInBloc("Values").valeur + distribution_info.add_distribution_user_defined(distribution, values) + + if debug: + print("balise = ", balise) + flag = balise.replace(" ", "") + if debug: + print("flag = ", flag) + u_inputs.add_input( + balise, + object_name, + model_variable, + distribution_info.distribution_info, + flag, + ) + + if debug: + print("len(u_inputs.inputs) = ", len(u_inputs.inputs)) + for i in range(0, len(u_inputs.inputs)): + print(f"u_inputs.inputs[{i}].balise = {u_inputs.inputs[i].balise}") + print( + f"u_inputs.inputs[{i}].balise_flag = {u_inputs.inputs[i].balise_flag}" + ) + print( + f"u_inputs.inputs[{i}].object_name = {u_inputs.inputs[i].object_name}" + ) + print( + f"u_inputs.inputs[{i}].model_variable = {u_inputs.inputs[i].model_variable}" + ) + if u_inputs.inputs[i].distribution_info[0].distribution == "Uniform": + print( + f"u_inputs.inputs[{i}].distribution_info[0].distribution = " + f"{u_inputs.inputs[i].distribution_info[0].distribution}" + ) + print( + f"u_inputs.inputs[{i}].distribution_info[0].lower_bound = " + f"{u_inputs.inputs[i].distribution_info[0].lower_bound}" + ) + print( + f"u_inputs.inputs[{i}].distribution_info[0].upper_bound = " + f"{u_inputs.inputs[i].distribution_info[0].upper_bound}" + ) + elif ( + u_inputs.inputs[i].distribution_info[0].distribution + == "TruncatedNormal" + ): + print( + f"u_inputs.inputs[{i}].distribution_info[0].distribution = " + f"{u_inputs.inputs[i].distribution_info[0].distribution}" + ) + print( + f"u_inputs.inputs[{i}].distribution_info[0].lower_bound = " + f"{u_inputs.inputs[i].distribution_info[0].lower_bound}" + ) + print( + f"u_inputs.inputs[{i}].distribution_info[0].upper_bound = " + f"{u_inputs.inputs[i].distribution_info[0].upper_bound}" + ) + print( + f"u_inputs.inputs[{i}].distribution_info[0].standard_deviation = " + f"{u_inputs.inputs[i].distribution_info[0].standard_deviation}" + ) + print( + f"u_inputs.inputs[{i}].distribution_info[0].mean = " + f"{u_inputs.inputs[i].distribution_info[0].mean}" + ) + elif ( + u_inputs.inputs[i].distribution_info[0].distribution + == "UserDefined" + ): + print( + f"u_inputs.inputs[{i}].distribution_info[0].distribution = " + f"{u_inputs.inputs[i].distribution_info[0].distribution}" + ) + print( + f"u_inputs.inputs[{i}].distribution_info[0].values = " + f"{u_inputs.inputs[i].distribution_info[0].values}" + ) + + file_balise_dot_comm = self.fichierBalise + u_inputs.add_file_balise_dot_comm(file_balise_dot_comm) + if debug: + print("u_inputs.file_balise_dot_comm = ", u_inputs.file_balise_dot_comm) + + ## propagation ## + u_propagation = uncertainty_data.Propagation() + u_propagation.set_sampling_method(self.Methode) + if debug: + print("u_propagation.sampling_method = ", self.Methode) + + ## outputs ## + u_outputs = uncertainty_data.Outputs() + aggregation_functions = u_outputs.AggregationFunction() + agg_fct_py = { + "valeur_a_t=0": "vInitialTime", + "valeur_a_mi_temps": "vHalfTime", + "valeur_a_t_final": "vFinalTime", + "valeur_moyenne": "vMean", + "valeur_cumulee": "vSum", + "valeur_minimale": "vMin", + "valeur_maximale": "vMax", + } + if debug: + print( + "GENERATOR_UQ.PY: self.lesVariablesOutput = ", self.lesVariablesOutput + ) # self.lesVariablesOutput.valeur + for mc in self.lesVariablesOutput: + type_of_physics = mc.getChildOrChildInBloc("Physique").valeur + variable_physics = mc.getChildOrChildInBloc("VariablePhysique").valeur + var_post_processed = mc.getChildOrChildInBloc( + "VariablePosttraiteeAssociee" + ).valeur + nom_agg_fct_list = mc.getChildOrChildInBloc("FonctionDAggregation").valeur + if debug: + print("GENERATOR_UQ.PY: nom_agg_fct_list = ", nom_agg_fct_list) + for nom_agg_fct in nom_agg_fct_list: + nom_agg_fct = nom_agg_fct.replace(" ", "_") + nom_agg_fct = nom_agg_fct.replace("-", "_") + nom_agg_fct = nom_agg_fct.replace("O", "0") + nom_agg_fct = nom_agg_fct.replace("à", "a") + nom_agg_fct = nom_agg_fct.replace("é", "e") + aggregation_functions.add_aggregation_function( + nom_agg_fct, agg_fct_py[nom_agg_fct] + ) + if debug: + print("GENERATOR_UQ.PY: nom_agg_fct_list = ", nom_agg_fct_list) + + u_outputs.add_output( + type_of_physics, + variable_physics, + var_post_processed, + aggregation_functions.aggregation_functions, + ) + if debug: + for i in range(0, len(u_outputs.outputs)): + print( + f"u_outputs.outputs[{i}].type_of_physics = " + f"{u_outputs.outputs[i].type_of_physics}" + ) + print( + f"u_outputs.outputs[{i}].variable_physics = " + f"{u_outputs.outputs[i].variable_physics}" + ) + print( + f"u_outputs.outputs[{i}].var_post_processed = " + f"{u_outputs.outputs[i].var_post_processed}" + ) + print( + f"u_outputs.outputs[{i}].aggregation_functions = " + f"{u_outputs.outputs[i].aggregation_functions}" + ) + for cle, valeur in u_outputs.outputs[ + i + ].aggregation_functions.items(): + print( + "nom_agg_fct = ", cle, ", aggregation_function = ", valeur + ) + + ## execution ## + u_execution = uncertainty_data.Execution() + u_execution.set_execution_mode(self.ExecutionMode) + if self.ExecutionMode == "desktop": + u_execution.set_visualization(self.visualization) + u_execution.set_sample_size(self.sample_size) + u_execution.set_launcher_type(self.launcher_type) + if self.launcher_type == "distrib": + u_execution.set_parallel_execs(self.parallel_execs) + u_execution.set_work_dir_name(self.WorkDirectory) + u_execution.set_output_dir_name(self.ResultDirectory) + + elif self.ExecutionMode == "cluster": + u_execution.set_sample_size(self.sample_size) + u_execution.set_parallel_execs(self.parallel_execs) + u_execution.set_work_dir_name(self.WorkDirectory) + u_execution.set_output_dir_name(self.ResultDirectory) + u_execution.set_nb_of_tasks(self.nb_of_tasks) + u_execution.set_nb_of_cpu_per_task(self.nb_of_cpu_per_task) + u_execution.set_memory_per_cpu(self.memory_per_cpu) + u_execution.set_partitions(self.partitions) + u_execution.set_qos(self.qos) + u_execution.set_account(self.account) + u_execution.set_walltime(self.walltime) + u_execution.set_job_name(self.job_name) + u_execution.set_output_file(self.output_file) + u_execution.set_error_file(self.error_file) + u_execution.set_email(self.email) + u_execution.set_email_type(self.email_type) + u_execution.set_liste_of_nodes(self.liste_of_nodes) + u_execution.set_myscript_to_launch(self.myscript_to_launch) + + if debug: + if self.ExecutionMode == "desktop": + print("u_execution.visualization = ", u_execution.visualization) + print("u_execution.sample_size = ", u_execution.sample_size) + print("u_execution.launcher_type = ", u_execution.launcher_type) + if self.launcher_type == "distrib": + print("u_execution.parallel_execs = ", u_execution.parallel_execs) + print("u_execution.work_dir_name = ", u_execution.work_dir_name) + print("u_execution.output_dir_name = ", u_execution.output_dir_name) + + elif self.ExecutionMode == "cluster": + print("u_execution.sample_size = ", u_execution.sample_size) + print("u_execution.parallel_execs = ", u_execution.parallel_execs) + print("u_execution.work_dir_name = ", u_execution.work_dir_name) + print( + "u_execution.output_dir_name = ", u_execution.output_dir_name + ) + print("u_execution.nb_of_tasks = ", u_execution.nb_of_tasks) + print( + "u_execution.nb_of_cpu_per_task = ", + u_execution.nb_of_cpu_per_task, + ) + print("u_execution.memory_per_cpu = ", u_execution.memory_per_cpu) + print("u_execution.partitions = ", u_execution.partitions) + print("u_execution.qos = ", u_execution.qos) + print("u_execution.account = ", u_execution.account) + print("u_execution.walltime = ", u_execution.walltime) + print("u_execution.job_name = ", u_execution.job_name) + print("u_execution.output_file = ", u_execution.output_file) + print("u_execution.error_file = ", u_execution.error_file) + print("u_execution.email = ", u_execution.email) + print("u_execution.email_type = ", u_execution.email_type) + print("u_execution.liste_of_nodes = ", u_execution.liste_of_nodes) + print( + "u_execution.myscript_to_launch = ", + u_execution.myscript_to_launch, + ) + + # Creat the pickle_dir_name directory + pickle_dir_name = "." + u_execution.output_dir_name + "_uncertainty_parameters" + pickle_dir_name_path = os.path.join(u_execution.work_dir_name, pickle_dir_name) + print("pickle_dir_name_path = ", pickle_dir_name_path) + if os.path.exists(pickle_dir_name_path): + choice = input( + f"The output directory '{pickle_dir_name_path}' already exist." + f" Do you want to overwrite it ? (y/n): " + ).lower() + yess = ["y", "yes"] + nos = ["n", "no"] + while choice not in yess and choice not in nos: + choice = input("Please choose 'y' (yes) or 'n' (no)") + if choice in yess: + shutil.rmtree(pickle_dir_name_path) + os.makedirs(pickle_dir_name_path, exist_ok=True) + print("Overwriting of the directory... Done !") + else: + logging.log( + logging.WARNING, "Execution terminated. Directory is not removed." + ) + return 1 + else: + os.makedirs(pickle_dir_name_path, exist_ok=True) + print("Writing of the directory... Done !") + + serialize_data.save( + pickle_dir_name_path, u_inputs, u_propagation, u_outputs, u_execution + ) + + self.txtScript = SCRIPT_URANIE.format(pickle_dir=pickle_dir_name_path) + + def parseMcInputVariable(self, mc, indent): + if mc.variableDeterministe.etape.nature == "OPERATEUR": + nom = ( + mc.variableDeterministe.etape.sd.nom + + "__" + + mc.variableDeterministe.nom + ) + else: + nom = mc.variableDeterministe.nom + loiDistribution = mc.getChildOrChildInBloc("Distribution").valeur + + # on cherche le bloc qui contient ce qui est necessaire a la loi + # on est confiant !!!! sur l adequation du catalogue et des attributs des lois persalys + # reflechir a cela + chaineArgs = "" + leBlocDesArgs = None + for mc in mc.mcListe: + if (mc.nom).find("b_Model_Variable_") == 0: + for mcFils in mc.mcListe: + if mcFils.nom.find(loiDistribution) > 1: + leBlocDesArgs = mcFils + break + if not leBlocDesArgs: + print("souci pour dumper la loi") + return "" + for mcFils in leBlocDesArgs.mcListe: + chaineArgs += str(mcFils.valeur) + ", " + + return nom, loiDistribution, chaineArgs[0:-2] + + def creeTexteInputVariables(self, indent): + texte = "" + for v in self.lesVariablesInput: + nomVariableInput, loiDistribution, chaineArgs = self.parseMcInputVariable( + v, indent + ) + texte += "{}{} = persalys.Input('{}', ot.{}(".format( + indent, nomVariableInput, nomVariableInput, loiDistribution + ) + texte += chaineArgs + "))\n" + + return texte + + def creeTexteInputVariablesSummary(self, indent): + texte = "" + for v in self.lesVariablesInput: + nomVariableInput, loiDistribution, chaineArgs = self.parseMcInputVariable( + v, indent + ) + texte += "{}'{}{} : {}({})\\n'\n".format( + 2 * indent, indent, nomVariableInput, loiDistribution, chaineArgs + ) + # texte+=chaineArgs[0:-2]+'))\n' + # texte+='\n' + + return texte[0:-1] + + def creeScriptPersalys(self, debug=True): + from functools import reduce + + # chaineDesVariablesInput=reduce(lambda x,y:x+','+y,l) + def getStrVarList(l, sep=","): + return reduce(lambda x, y: str(x) + sep + str(y), l) + + def getStrVarStrList(l, sep=","): + return reduce( + lambda x, y: x + sep + y, map(lambda x: "'" + str(x) + "'", l) + ) + + def getStrInitList(l): + return getStrVarList( + map(lambda x: "self.{} = {}".format(x, x), l), "\n" + 2 * self.indent1 + ) + + def getStrReplaceVarList(l): + return getStrVarList( + map(lambda x: "'@ {} @': repr(self.{})".format(x, x), l), "," + ) + + def getStrSelfVarList(l): + return getStrVarList(map(lambda x: "self.{}".format(x), l), ",") + + generatorDir = os.path.abspath(os.path.dirname(__file__)) + nomEtude = "monEtude" # TODO + if debug: + print("nomEtude : ", nomEtude, "generatorDir :", generatorDir) + + self.txtScriptPersalys += headerScriptPersalys + + # TODO: Résorber le cas particulier du HLO en mettant les options de lancement ds le catalog + if self.ScenarioType == "HLO": + txtUncertaintyScriptParameters = ( + self.fichierComm + " --cocagne-thermo-solver\ FaSTT" + ) + else: + txtUncertaintyScriptParameters = self.fichierComm + + print("self.nomsDesVariablesInput :", self.nomsDesVariablesInput) + self.txtScriptPersalys += etudeScript.format( + chaineDesVariablesInput=self.chaineDesVariablesInput, + chaineSelfDesVariablesInput=getStrSelfVarList(self.nomsDesVariablesInput), + chaineInitDesVariablesInput=getStrInitList(self.nomsDesVariablesInput), + commFileBalise=self.fichierBalise, + commFile=self.fichierComm, + nproc=self.NbOfProcs, # En local le nombre de procs est inutile + # sauf si lancement mpi externe au script applicatif + # auquel cas != NbOfTasks du jobmanager car + # on ne compte pas les threads + replaceDataList=getStrReplaceVarList(self.nomsDesVariablesInput), + uncertaintyScript=os.path.basename(self.UncertaintyScript), + uncertaintyScriptParameters=txtUncertaintyScriptParameters, + workDirectory=self.WorkDirectory, + ) + + txtFonctionPersalys = fonctionPersalys.format( + currentFile=self.fichierUQModule, + chaineDesVariablesInput=self.chaineDesVariablesInput, + getAllResults=self.txtGetAllResults, + # chaineDesVariablesOutput = self.chaineDesVariablesOutputEncodee + chaineDesVariablesOutput=self.chaineDesShortVariablesOutput, # Avoid a Persalys Bug until v9.9 + ) + self.txtScriptPersalys += codePersalys.format( + fonctionPersalys=txtFonctionPersalys + ) + + ## Propagation des incertitudes : + ## Choix de la méthode, de ses paramètres, et des résultats attendus + if self.Methode == "Taylor": + txtCentralTendencyPersalys = centralTendencyTaylor + optionalResult = optionalResultTaylor + optionalPrintResult = optionalPrintResultTaylor + printResult = printResultTaylor + txtResultCT = resultTaylor + elif self.Methode == "MonteCarlo": + critereArret = "" + for mc in self.critereArret.mcListe: + critereArret += ( + self.indent1 + + critereArretMC[mc.nom].format(**{mc.nom: mc.valeur}) + + "\n" + ) + + txtAdvancedParameterMC = "" + advancedParameter = "" + if self.advancedParameter != None: + for mc in self.advancedParameter.mcListe: + advancedParameter += ( + self.indent1 + + advancedParameterMC[mc.nom].format(**{mc.nom: mc.valeur}) + + "\n" + ) + + txtCentralTendencyPersalys = centralTendencyMC.format( + critereArretMC=critereArret, + advancedParameterMC=advancedParameter, + BlockSize=self.Blocksize, + ) + optionalResult = optionalResultMC + optionalPrintResult = optionalPrintResultMC + printResult = printResultMC + txtResultCT = resultMC + else: + return (0, "Impossible de gérer la méthode :", self.Methode) + + result = "" + optionalResultNames = [] + if self.Result: + for mc in self.Result.mcListe: + # print('mc : ',mc) + # print('mc.nature : ',mc.nature) + # print('mc.valeur : ',mc.valeur) + if mc.nom == "EmpiricalQuantile" and mc.valeur == "yes": + mc_nom = ( + mc.nom[0].lower() + mc.nom[1:] + ) ##TODO: Utiliser un nv dict commun des symboles avec optionalResult + optionalResultNames.append(mc_nom) + empiricalQuantile_Order = self.Result.getChildOrChildInBloc( + "EmpiricalQuantile_Order" + ) + result += ( + self.indent1 + + optionalResult[mc.nom].format( + **{ + empiricalQuantile_Order.nom: empiricalQuantile_Order.valeur + } + ) + + "\n" + ) + result += ( + self.indent1 + + optionalPrintResult["EmpiricalQuantile_Order"] + + "\n" + ) + result += self.indent1 + optionalPrintResult[mc.nom] + "\n" + elif mc.nature == "MCSIMP" and mc.valeur == "yes": + mc_nom = ( + mc.nom[0].lower() + mc.nom[1:] + ) ##TODO: Utiliser un nv dict commun des symboles avec optionalResult + optionalResultNames.append(mc_nom) + result += self.indent1 + optionalResult[mc.nom] + "\n" + # result+= self.indent1+optionalPrintResult[mc.nom] + '\n' + + # print('result:',result) + # print('txtResultCT:',txtResultCT) + optionalResultList = getStrVarList(optionalResultNames) + optionalResultStrList = getStrVarStrList(optionalResultNames) + post_csv_rnScript = os.path.basename(self.ScriptPosttraitement).split(".")[0] + post_csv_rnPath = os.path.dirname(self.ScriptPosttraitement) + print(post_csv_rnScript) + print(post_csv_rnPath) + txtPrintResult = printResult.format( + post_csv_rnScript=post_csv_rnScript, + post_csv_rnPath=post_csv_rnPath, + optionalResultList=optionalResultList, + optionalResultStrList=optionalResultStrList, + resultSkList=getStrVarList(self.resultSkList), + Uncertain_inputs=self.creeTexteInputVariablesSummary(self.indent1), + ) + txtResult = txtResultCT.format(optionalResult=result) + txtResult += txtPrintResult + + # TODO ;: Tester si Cluster== Gaia, ajouter les champs suivants + # resourceName = 'gaia' + # login='C65845' + # workDirectory = '/scratch/'+login+'/workingdir/persalys_light' #TODO: path.join + # resultDirectory = '/tmp/result_0' + wckey = "P11N0:SALOME" + + inFiles = [] + inFiles.append(os.path.join(generatorDir, "incertainty_tools.py")) + pyFile = self.fichierUQExe + inFiles.append(os.path.join(self.cheminFichierComm, pyFile)) + pyFile = self.fichierBalise + inFiles.append(os.path.join(self.cheminFichierComm, pyFile)) + scriptFile = os.path.abspath(self.UncertaintyScript) + inFiles.append(scriptFile) + postFile = os.path.abspath(self.ScriptPosttraitement) + inFiles.append(postFile) + + if self.ExecutionMode == "cluster": + txtYacsJobClusterParameters = yacsJobClusterParameters.format( + nprocs=self.NbOfProcs, wckey=wckey + ) + else: + txtYacsJobClusterParameters = "" + + txtYacsJobParameters = yacsJobParameters.format( + nomEtude=self.JobName, + workDirectory=self.WorkDirectory, + resultDirectory=self.ResultDirectory, + resourceName=self.ResourceName, + nbBranches=self.NbDeBranches, + inFiles=repr(inFiles), + ) + txtYacsJobParameters += txtYacsJobClusterParameters + if self.MultiJobStudy != None and self.MultiJobStudy == True: + txtYacsJobParameters += yacsJobClusterMultiJob + + self.txtScriptPersalys += mainPersalys.format( + nomEtude=nomEtude, + inputVariableInitList=self.creeTexteInputVariables(self.indent1), + outputVariableInitList=self.txtOutputVariableInitList, + # outputVariableInitList = '#Not yet implemented', + inputHeaderPersalys=inputHeaderPersalys.format(indent=self.indent1), + chaineDesVariablesInput=self.chaineDesVariablesInput, + outputHeaderPersalys=outputHeaderPersalys.format(indent=self.indent1), + chaineDesVariablesOutput=self.chaineDesVariablesOutputEncodee, + yacsJobParameters=txtYacsJobParameters, + centralTendencyPersalys=txtCentralTendencyPersalys, + scenarioType=self.ScenarioType, + resultPersalys=txtResult, + ) + self.txtScript = self.txtScriptPersalys diff --git a/generator/generator_XML.py b/generator/generator_XML.py index f336e416..48325cc2 100644 --- a/generator/generator_XML.py +++ b/generator/generator_XML.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -19,98 +19,104 @@ # """Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS. """ - -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import str -except : pass +from builtins import str import traceback -import types,re,os +import types, re, os from Extensions.i18n import tr from .generator_python import PythonGenerator + def entryPoint(): """ - Retourne les informations necessaires pour le chargeur de plugins - Ces informations sont retournees dans un dictionnaire + Retourne les informations necessaires pour le chargeur de plugins + Ces informations sont retournees dans un dictionnaire """ return { - # Le nom du plugin - 'name' : 'xml', - # La factory pour creer une instance du plugin - 'factory' : XMLGenerator, - } + # Le nom du plugin + "name": "xml", + # La factory pour creer une instance du plugin + "factory": XMLGenerator, + } class XMLGenerator(PythonGenerator): """ - Ce generateur parcourt un objet de type JDC et produit - un texte au format eficas et + Ce generateur parcourt un objet de type JDC et produit + un texte au format eficas et """ - # Les extensions de fichier permis? - extensions=('.comm',) -#---------------------------------------------------------------------------------------- - def gener(self,obj,format='brut',config=None,appliEficas=None): - - try : - #if 1 : - self.texteXML=obj.toXml() - except : - self.texteXML='erreur generation' - #print (self.texteXML) + # Les extensions de fichier permis? + extensions = (".comm",) + + # ---------------------------------------------------------------------------------------- + def gener( + self, obj, format="brut", config=None, appliEficas=None, uniteAsAttribut=False + ): + # try : + if 1: + self.texteXML = obj.toXml() + # except : + # self.texteXML='Erreur a la generation du fichier XML' + # print (self.texteXML) # pass - self.textePourAide ="" - self.dictNbNomObj={} + self.textePourAide = "" + self.dictNbNomObj = {} # Cette instruction genere le contenu du fichier de commandes (persistance) - self.text=PythonGenerator.gener(self,obj,format) + self.text = PythonGenerator.gener(self, obj, format) return self.text + # ---------------------------------------------------------------------------------------- + # initialisations + # ---------------------------------------------------------------------------------------- -#---------------------------------------------------------------------------------------- -# initialisations -#---------------------------------------------------------------------------------------- + # ecriture + # ---------------------------------------------------------------------------------------- -# ecriture -#---------------------------------------------------------------------------------------- - - def writeDefault(self,fn) : - fileXML = fn[:fn.rfind(".")] + '.xml' - #filePyxb = fn[:fn.rfind(".")] + '.py' + def writeDefault(self, fn): + if self.texteXML == "Erreur a la generation du fichier XML": + print(self.texteXML) + return 0 + fileXML = fn[: fn.rfind(".")] + ".xml" + # filePyxb = fn[:fn.rfind(".")] + '.py' fileBase = os.path.basename(fileXML) - fileBase = fileBase[:fileBase.rfind(".")] + '.py' - filePyxb = '/tmp/example_' + fileBase - #print (filePyxb) - #fileDico='/tmp/toto.xml' - #print (self.texteXML) - f = open( str(fileXML), 'w') + fileBase = fileBase[: fileBase.rfind(".")] + ".py" + filePyxb = "/tmp/example_" + fileBase + # print (filePyxb) + # fileDico='/tmp/toto.xml' + # print (self.texteXML) + f = open(str(fileXML), "w") f.write(str(self.texteXML)) f.close() - f = open( str(filePyxb), 'w') - self.textePourAide='txt=""'+'\n'+self.textePourAide - self.textePourAide=self.textePourAide+'print (txt)'+'\n' + f = open(str(filePyxb), "w") + self.textePourAide = 'txt=""' + "\n" + self.textePourAide + self.textePourAide = self.textePourAide + "print (txt)" + "\n" f.write(str(self.textePourAide)) f.close() + return 1 - - def generMCSIMP(self,obj) : - if obj.nom != 'Consigne' : + def generMCSIMP(self, obj): + if obj.nom != "Consigne": if obj.nom in self.dictNbNomObj.keys(): nomUtil = obj.nom + "_" + str(self.dictNbNomObj[obj.nom]) self.dictNbNomObj[obj.nom] += 1 - else : + else: nomUtil = obj.nom self.dictNbNomObj[obj.nom] = 1 - if obj.definition.avecBlancs : self.textePourAide += nomUtil + " = vimmpCase." + obj.getNomDsXML() + ".s\n" - else : self.textePourAide += nomUtil + " = vimmpCase." + obj.getNomDsXML() + "\n" - self.textePourAide +='txt += "' + nomUtil + '" + " = " +str( ' + nomUtil + ')+"\\n"'+ "\n" - - - - s=PythonGenerator.generMCSIMP(self,obj) + if obj.definition.avecBlancs: + self.textePourAide += ( + nomUtil + " = vimmpCase." + obj.getNomDsXML() + ".s\n" + ) + else: + self.textePourAide += ( + nomUtil + " = vimmpCase." + obj.getNomDsXML() + "\n" + ) + self.textePourAide += ( + 'txt += "' + nomUtil + '" + " = " +str( ' + nomUtil + ')+"\\n"' + "\n" + ) + + s = PythonGenerator.generMCSIMP(self, obj) return s diff --git a/generator/generator_aplat.py b/generator/generator_aplat.py index 10511063..5c1d519d 100644 --- a/generator/generator_aplat.py +++ b/generator/generator_aplat.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,255 +22,259 @@ aplat pour EFICAS. """ -try : +try: from builtins import str from builtins import object -except : pass +except: + pass import traceback -import types,re +import types, re from Extensions.i18n import tr from Extensions.eficas_exception import EficasException from Noyau import N_CR from Noyau.N_utils import repr_float -from Accas import ETAPE,PROC_ETAPE,MACRO_ETAPE,ETAPE_NIVEAU,JDC,FORM_ETAPE -from Accas import MCSIMP,MCFACT,MCBLOC,MCList,EVAL -from Accas import GEOM,ASSD,MCNUPLET -from Accas import COMMENTAIRE,PARAMETRE, PARAMETRE_EVAL,COMMANDE_COMM +from Accas import ETAPE, PROC_ETAPE, MACRO_ETAPE, ETAPE_NIVEAU, JDC, FORM_ETAPE +from Accas import MCSIMP, MCFACT, MCBLOC, MCList, EVAL +from Accas import GEOM, ASSD, MCNUPLET +from Accas import COMMENTAIRE, PARAMETRE, PARAMETRE_EVAL, COMMANDE_COMM + def entryPoint(): """ - Retourne les informations necessaires pour le chargeur de plugins + Retourne les informations necessaires pour le chargeur de plugins - Ces informations sont retournees dans un dictionnaire + Ces informations sont retournees dans un dictionnaire """ return { - # Le nom du plugin - 'name' : 'aplat', - # La factory pour creer une instance du plugin - 'factory' : AplatGenerator, - } + # Le nom du plugin + "name": "aplat", + # La factory pour creer une instance du plugin + "factory": AplatGenerator, + } class AplatGenerator(object): """ - Ce generateur parcourt un objet de type JDC et produit - un fichier au format aplat + Ce generateur parcourt un objet de type JDC et produit + un fichier au format aplat - L'acquisition et le parcours sont realises par la methode - generator.gener(objet_jdc,format) + L'acquisition et le parcours sont realises par la methode + generator.gener(objet_jdc,format) - L'ecriture du fichier au format ini par appel de la methode - generator.writeFile(nom_fichier) + L'ecriture du fichier au format ini par appel de la methode + generator.writeFile(nom_fichier) - Ses caracteristiques principales sont exposees dans des attributs - de classe : - - extensions : qui donne une liste d'extensions de fichier preconisees + Ses caracteristiques principales sont exposees dans des attributs + de classe : + - extensions : qui donne une liste d'extensions de fichier preconisees """ + # Les extensions de fichier preconisees - extensions=('.*',) + extensions = (".*",) - def __init__(self,cr=None): + def __init__(self, cr=None): # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard - if cr : - self.cr=cr + if cr: + self.cr = cr else: - self.cr=N_CR.CR(debut='CR generateur format aplat pour eficas', - fin='fin CR format aplat pour eficas') - self.init='' + self.cr = N_CR.CR( + debut="CR generateur format aplat pour eficas", + fin="fin CR format aplat pour eficas", + ) + self.init = "" # Le separateur utiise - self.sep='//' + self.sep = "//" # Le texte au format aplat est stocke dans l'attribut text - self.text='' + self.text = "" - def writefile(self,filename): - fp=open(filename,'w') + def writefile(self, filename): + fp = open(filename, "w") fp.write(self.text) fp.close() - def gener(self,obj,format='brut',config=None,appliEficas=None): + def gener(self, obj, format="brut", config=None, appliEficas=None): """ - Retourne une representation du JDC obj sous une forme qui est parametree par format. - Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator + Retourne une representation du JDC obj sous une forme qui est parametree par format. + Si format vaut 'brut', 'standard' ou 'beautifie', retourne le texte issu de generator """ - liste= self.generator(obj) - if format == 'brut': - self.text=liste - elif format == 'standard': - self.text=liste - elif format == 'beautifie': - self.text=liste + liste = self.generator(obj) + if format == "brut": + self.text = liste + elif format == "standard": + self.text = liste + elif format == "beautifie": + self.text = liste else: raise EficasException(tr("Format pas implemente : %s", format)) return self.text - def generator(self,obj): + def generator(self, obj): """ - Cette methode joue un role d'aiguillage en fonction du type de obj - On pourrait utiliser les methodes accept et visitxxx a la - place (depend des gouts !!!) + Cette methode joue un role d'aiguillage en fonction du type de obj + On pourrait utiliser les methodes accept et visitxxx a la + place (depend des gouts !!!) """ # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage) - if isinstance(obj,PROC_ETAPE): + if isinstance(obj, PROC_ETAPE): return self.generPROC_ETAPE(obj) - elif isinstance(obj,MACRO_ETAPE): + elif isinstance(obj, MACRO_ETAPE): return self.generMACRO_ETAPE(obj) - elif isinstance(obj,FORM_ETAPE): + elif isinstance(obj, FORM_ETAPE): return self.generFORM_ETAPE(obj) - elif isinstance(obj,ETAPE): + elif isinstance(obj, ETAPE): return self.generETAPE(obj) - elif isinstance(obj,MCFACT): + elif isinstance(obj, MCFACT): return self.generMCFACT(obj) - elif isinstance(obj,MCList): + elif isinstance(obj, MCList): return self.generMCList(obj) - elif isinstance(obj,MCBLOC): + elif isinstance(obj, MCBLOC): return self.generMCBLOC(obj) - elif isinstance(obj,MCSIMP): + elif isinstance(obj, MCSIMP): return self.generMCSIMP(obj) - elif isinstance(obj,ASSD): + elif isinstance(obj, ASSD): return self.generASSD(obj) - elif isinstance(obj,ETAPE_NIVEAU): + elif isinstance(obj, ETAPE_NIVEAU): return self.generETAPE_NIVEAU(obj) - elif isinstance(obj,COMMENTAIRE): + elif isinstance(obj, COMMENTAIRE): return self.generCOMMENTAIRE(obj) # Attention doit etre place avant PARAMETRE (raison : heritage) - elif isinstance(obj,PARAMETRE_EVAL): + elif isinstance(obj, PARAMETRE_EVAL): return self.generPARAMETRE_EVAL(obj) - elif isinstance(obj,PARAMETRE): + elif isinstance(obj, PARAMETRE): return self.generPARAMETRE(obj) - elif isinstance(obj,EVAL): + elif isinstance(obj, EVAL): return self.generEVAL(obj) - elif isinstance(obj,COMMANDE_COMM): + elif isinstance(obj, COMMANDE_COMM): return self.generCOMMANDE_COMM(obj) - elif isinstance(obj,JDC): + elif isinstance(obj, JDC): return self.generJDC(obj) - elif isinstance(obj,MCNUPLET): + elif isinstance(obj, MCNUPLET): return self.generMCNUPLET(obj) else: raise EficasException(tr("Format non implemente : %s", format)) - - def generJDC(self,obj): + def generJDC(self, obj): """ - Cette methode convertit un objet JDC en une chaine de - caracteres a la syntaxe aplat + Cette methode convertit un objet JDC en une chaine de + caracteres a la syntaxe aplat """ - text='' - if obj.definition.l_niveaux == (): + text = "" + if obj.definition.lNiveaux == (): # Il n'y a pas de niveaux for etape in obj.etapes: - text=text+self.generator(etape)+'\n' + text = text + self.generator(etape) + "\n" else: # Il y a des niveaux for etape_niveau in obj.etapes_niveaux: - text=text+self.generator(etape_niveau)+'\n' + text = text + self.generator(etape_niveau) + "\n" return text - def generCOMMANDE_COMM(self,obj): + def generCOMMANDE_COMM(self, obj): """ - Cette methode convertit un COMMANDE_COMM - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit un COMMANDE_COMM + en une chaine de caracteres a la syntaxe aplat """ - l_lignes = obj.valeur.split('\n') - txt='' + l_lignes = obj.valeur.split("\n") + txt = "" for ligne in l_lignes: - txt = txt + '##'+ligne+'\n' + txt = txt + "##" + ligne + "\n" return txt - def generEVAL(self,obj): + def generEVAL(self, obj): """ - Cette methode convertit un EVAL - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit un EVAL + en une chaine de caracteres a la syntaxe aplat """ - return 'EVAL("""'+ obj.valeur +'""")' + return 'EVAL("""' + obj.valeur + '""")' - def generCOMMENTAIRE(self,obj): + def generCOMMENTAIRE(self, obj): """ - Cette methode convertit un COMMENTAIRE - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit un COMMENTAIRE + en une chaine de caracteres a la syntaxe aplat """ - l_lignes = obj.valeur.split('\n') - txt='' + l_lignes = obj.valeur.split("\n") + txt = "" for ligne in l_lignes: - txt = txt + '#'+ligne+'\n' + txt = txt + "#" + ligne + "\n" return txt - def generPARAMETRE_EVAL(self,obj): + def generPARAMETRE_EVAL(self, obj): """ - Cette methode convertit un PARAMETRE_EVAL - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit un PARAMETRE_EVAL + en une chaine de caracteres a la syntaxe aplat """ if obj.valeur == None: - return obj.nom + ' = None ;\n' + return obj.nom + " = None ;\n" else: - return obj.nom + ' = '+ self.generator(obj.valeur) +';\n' + return obj.nom + " = " + self.generator(obj.valeur) + ";\n" - def generPARAMETRE(self,obj): + def generPARAMETRE(self, obj): """ - Cette methode convertit un PARAMETRE - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit un PARAMETRE + en une chaine de caracteres a la syntaxe aplat """ - if type(obj.valeur) == bytes or type(obj.valeur) == str: + if type(obj.valeur) == bytes or type(obj.valeur) == str: # PN pour corriger le bug a='3+4' au lieu de a= 3+4 - #return obj.nom + " = '" + obj.valeur + "';\n" + # return obj.nom + " = '" + obj.valeur + "';\n" return obj.nom + " = " + obj.valeur + ";\n" else: - return obj.nom + ' = ' + str(obj.valeur) + ';\n' + return obj.nom + " = " + str(obj.valeur) + ";\n" - def generETAPE_NIVEAU(self,obj): + def generETAPE_NIVEAU(self, obj): """ - Cette methode convertit une etape niveau - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit une etape niveau + en une chaine de caracteres a la syntaxe aplat """ - text='' + text = "" if obj.etapes_niveaux == []: for etape in obj.etapes: - text=text+self.generator(etape)+'\n' + text = text + self.generator(etape) + "\n" else: for etape_niveau in obj.etapes_niveaux: - text=text+self.generator(etape_niveau)+'\n' + text = text + self.generator(etape_niveau) + "\n" return text - def gener_etape(self,obj): + def gener_etape(self, obj): """ - Cette methode est utilise pour convertir les objets etape - en une chaine de caracteres a la syntaxe aplat + Cette methode est utilise pour convertir les objets etape + en une chaine de caracteres a la syntaxe aplat """ - text='' + text = "" for v in obj.mcListe: - text=text + self.generator(v) - if text=='': - return self.init+'\n' + text = text + self.generator(v) + if text == "": + return self.init + "\n" else: return text - def generETAPE(self,obj): + def generETAPE(self, obj): """ - Cette methode convertit une etape - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit une etape + en une chaine de caracteres a la syntaxe aplat """ try: - sdname= self.generator(obj.sd) + sdname = self.generator(obj.sd) except: - sdname='sansnom' + sdname = "sansnom" self.init = sdname + self.sep + obj.nom return self.gener_etape(obj) - def generMACRO_ETAPE(self,obj): + def generMACRO_ETAPE(self, obj): """ - Cette methode convertit une macro-etape - en une chaine de caracteres a la syntaxe aplat + Cette methode convertit une macro-etape + en une chaine de caracteres a la syntaxe aplat """ try: if obj.sd == None: self.init = obj.nom else: - sdname= self.generator(obj.sd) + sdname = self.generator(obj.sd) self.init = sdname + self.sep + obj.nom except: - self.init = 'sansnom' + self.sep + obj.nom + self.init = "sansnom" + self.sep + obj.nom return self.gener_etape(obj) @@ -278,68 +282,68 @@ class AplatGenerator(object): generFORM_ETAPE = generMACRO_ETAPE - def generASSD(self,obj): + def generASSD(self, obj): """ - Convertit un objet derive d'ASSD en une chaine de caracteres a la - syntaxe aplat + Convertit un objet derive d'ASSD en une chaine de caracteres a la + syntaxe aplat """ return obj.getName() - def generMCList(self,obj): + def generMCList(self, obj): """ - Convertit un objet MCList en une chaine de caracteres a la - syntaxe aplat + Convertit un objet MCList en une chaine de caracteres a la + syntaxe aplat """ - i=0 - text = '' + i = 0 + text = "" init = self.init + self.sep + obj.nom - old_init=self.init - for data in obj.data : - i=i+1 - self.init = init + self.sep + "occurrence n"+repr(i) + old_init = self.init + for data in obj.data: + i = i + 1 + self.init = init + self.sep + "occurrence n" + repr(i) text = text + self.generator(data) - self.init=old_init + self.init = old_init return text - def generMCSIMP(self,obj) : + def generMCSIMP(self, obj): """ - Convertit un objet MCSIMP en une chaine de caracteres a la - syntaxe aplat + Convertit un objet MCSIMP en une chaine de caracteres a la + syntaxe aplat """ - if type(obj.valeur) in (tuple,list) : + if type(obj.valeur) in (tuple, list): # On est en presence d'une liste de valeur - rep = '(' + rep = "(" for val in obj.valeur: - #if type(val) == types.InstanceType : - if isinstance(val,object): - rep = rep + self.generator(val) +',' + # if type(val) == types.InstanceType : + if isinstance(val, object): + rep = rep + self.generator(val) + "," else: - rep = rep + repr(val)+',' - rep = rep + ')' - #elif type(obj.valeur) == types.InstanceType : - elif type(obj.valeur) == object : + rep = rep + repr(val) + "," + rep = rep + ")" + # elif type(obj.valeur) == types.InstanceType : + elif type(obj.valeur) == object: # On est en presence d'une valeur unique de type instance rep = self.generator(obj.valeur) - else : + else: # On est en presence d'une valeur unique rep = repr(obj.valeur) - return self.init + self.sep + obj.nom + ' :' + rep + '\n' + return self.init + self.sep + obj.nom + " :" + rep + "\n" - def generMCCOMPO(self,obj): + def generMCCOMPO(self, obj): """ - Convertit un objet MCCOMPO en une chaine de caracteres a la - syntaxe aplat + Convertit un objet MCCOMPO en une chaine de caracteres a la + syntaxe aplat """ - text = '' - old_init=self.init + text = "" + old_init = self.init self.init = self.init + self.sep + obj.nom - for mocle in obj.mcListe : + for mocle in obj.mcListe: text = text + self.generator(mocle) - self.init=old_init + self.init = old_init return text - generMCFACT=generMCCOMPO + generMCFACT = generMCCOMPO - generMCBLOC=generMCCOMPO + generMCBLOC = generMCCOMPO - generMCNUPLET=generMCCOMPO + generMCNUPLET = generMCCOMPO diff --git a/generator/generator_dico.py b/generator/generator_dico.py index 5122789a..4cc2fb2b 100644 --- a/generator/generator_dico.py +++ b/generator/generator_dico.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,81 +20,164 @@ """Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS. """ -from __future__ import absolute_import -from __future__ import print_function -try : - from builtins import str -except : pass +from builtins import str import traceback -import types,re,os +import types, re, os from Extensions.i18n import tr from .generator_python import PythonGenerator + def entryPoint(): """ - Retourne les informations necessaires pour le chargeur de plugins - Ces informations sont retournees dans un dictionnaire + Retourne les informations necessaires pour le chargeur de plugins + Ces informations sont retournees dans un dictionnaire """ return { - # Le nom du plugin - 'name' : 'dico', - # La factory pour creer une instance du plugin - 'factory' : DicoGenerator, - } + # Le nom du plugin + "name": "dico", + # La factory pour creer une instance du plugin + "factory": DicoGenerator, + } class DicoGenerator(PythonGenerator): """ - Ce generateur parcourt un objet de type JDC et produit - un texte au format eficas et - un texte au format dictionnaire + Ce generateur parcourt un objet de type JDC et produit + un texte au format eficas et + un texte au format dictionnaire """ - # Les extensions de fichier permis? - extensions=('.comm',) -#---------------------------------------------------------------------------------------- - def gener(self,obj,format='brut',config=None,appliEficas=None): + # Les extensions de fichier permis? + extensions = (".comm",) + # ---------------------------------------------------------------------------------------- + def gener(self, obj, format="brut", config=None, appliEficas=None): self.initDico() # Cette instruction genere le contenu du fichier de commandes (persistance) - self.text=PythonGenerator.gener(self,obj,format) + self.text = PythonGenerator.gener(self, obj, format) return self.text + def generDico(self, obj, format="brut", config=None, appliEficas=None): + self.initDico() + # Cette instruction genere le contenu du fichier de commandes (persistance) + self.text = PythonGenerator.gener(self, obj, format) + return self.dicoComm -#---------------------------------------------------------------------------------------- -# initialisations -#---------------------------------------------------------------------------------------- - - def initDico(self) : - - self.Dico={} - self.texteDico = "" + # ---------------------------------------------------------------------------------------- + # initialisations + # ---------------------------------------------------------------------------------------- + def initDico(self): + self.dicoComm = {} + self.rang = 0 -#---------------------------------------------------------------------------------------- -# ecriture -#---------------------------------------------------------------------------------------- + # ---------------------------------------------------------------------------------------- + # ecriture + # ---------------------------------------------------------------------------------------- - def writeDefault(self,fn) : - fileDico = fn[:fn.rfind(".")] + '.py' - f = open( str(fileDico), 'w') - f.write('Dico = '+str(self.Dico)) + def writeDefault(self, fn): + fileDico = fn[: fn.rfind(".")] + ".py" + f = open(str(fileDico), "w") + f.write("dicoComm = " + str(self.dicoComm)) f.close() -#---------------------------------------------------------------------------------------- -# analyse de chaque noeud de l'arbre -#---------------------------------------------------------------------------------------- + # ---------------------------------------------------------------------------------------- + # analyse de chaque noeud de l'arbre + # ---------------------------------------------------------------------------------------- - def generMCSIMP(self,obj) : + def generMCSIMP(self, obj): """recuperation de l objet MCSIMP""" - s=PythonGenerator.generMCSIMP(self,obj) - courant=self.Dico - for p in obj.getGenealogiePrecise()[0:-1]: - if not (p in courant.keys()) : courant[p]={} - courant=courant[p] - courant[obj.nom]=obj.val - self.texteDico+=obj.nom+ "=" + s[0:-1]+ "\n" + s = PythonGenerator.generMCSIMP(self, obj) + listeParents = [] + objTraite = obj + while hasattr(objTraite, "parent") and objTraite.parent != None: + objTraite = objTraite.parent + if objTraite.nature == "JDC": + break + if objTraite.nature == "BLOC": + continue + if objTraite.nature == "OPERATEUR" or objTraite.nature == "PROCEDURE": + listeParents.insert(0, objTraite) + elif objTraite.nature == "MCList": + if len(objTraite.data > 1): + monRang = objTraite.data.index(objTraite) + listeParents.insert(0, objTraite.nom + "_" + str(monRang)) + else: + listeParents.insert(0, objTraite.nom) + else: + listeParents.insert(0, objTraite.nom) + courant = self.dicoComm + # On traite l etape pour ajouter le rang et la classe + etape = listeParents[0] + ordreId = etape.parent.etapes.index(etape) + if etape.nature == "OPERATEUR": + if not etape.sd.nom in courant.keys(): + courant[etape.sd.nom] = {} + courant[etape.sd.nom]["@classeAccas"] = etape.nom + courant[etape.sd.nom]["@ordreAccas"] = ordreId + courant = courant[etape.sd.nom] + else: + if not etape.nom in courant.keys(): + courant[etape.nom] = {} + courant[etape.nom]["@classeAccas"] = etape.nom + courant[etape.nom]["@ordreAccas"] = ordreId + courant = courant[etape.nom] + else: + if not (isinstance(courant[etape.nom], list)): + laListe = [ + courant[etape.nom], + ] + courant[etape.nom] = laListe + newDict = {} + newDict["@classeAccas"] = etape.nom + newDict["@ordreAccas"] = ordreId + courant[etape.nom].append(newDict) + courant = newDict + for p in listeParents[1:]: + if not (p in courant.keys()): + courant[p] = {} + courant = courant[p] + # on transforme les concepts en nom + laValeur = self.transformeObjInRef(obj) + courant[obj.nom] = laValeur return s + + def transformeObjInRef(self, obj): + # cas d une matrice d ASSD + for ssType in obj.definition.type: + if hasattr(ssType, "typElt"): + if ssType.typElt not in ("R", "I", "C", "TXM"): + # on a une matrice d ASSD + listeLigne = [] + for ligne in obj.val: + col = [] + for elt in ligne: + col.append(elt.nom) + listeLigne.append(col) + return listeLigne + waitASSDTuple = 0 + if type(obj.valeur) in (tuple, list): + for ss_type in obj.definition.type: + if repr(ss_type).find("Tuple") != -1: + if hasattr(ssType, "typeDesTuples"): + for t in ssType.typeDesTuples: + if t not in ("R", "I", "C", "TXM"): + waitASSDTuple = 1 + break + elif ss_type not in ("R", "I", "C", "TXM"): + waitASSDTuple = 1 + if waitASSDTuple: + listeRetour = [] + for elt in obj.val: + if hasattr(elt, "nom"): + listeRetour.append(elt.nom) + else: + listeRetour.append(elt) + return listeRetour + + if hasattr(obj.val, "nom"): + listeRetour.append(obj.val.nom) + return obj.val diff --git a/generator/generator_dicoImbrique.py b/generator/generator_dicoImbrique.py index 07c91ccd..596ec132 100644 --- a/generator/generator_dicoImbrique.py +++ b/generator/generator_dicoImbrique.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -20,131 +20,134 @@ """Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS. """ -from __future__ import absolute_import -try : - from builtins import str -except : pass +from builtins import str import traceback -import types,re,os +import types, re, os from Extensions.i18n import tr from .generator_python import PythonGenerator + def entryPoint(): """ - Retourne les informations necessaires pour le chargeur de plugins - Ces informations sont retournees dans un dictionnaire + Retourne les informations necessaires pour le chargeur de plugins + Ces informations sont retournees dans un dictionnaire """ return { - # Le nom du plugin - 'name' : 'dicoImbrique', - # La factory pour creer une instance du plugin - 'factory' : DicoImbriqueGenerator, - } + # Le nom du plugin + "name": "dicoImbrique", + # La factory pour creer une instance du plugin + "factory": DicoImbriqueGenerator, + } class DicoImbriqueGenerator(PythonGenerator): """ - Ce generateur parcourt un objet de type JDC et produit - un texte au format eficas et - un texte au format dictionnaire + Ce generateur parcourt un objet de type JDC et produit + un texte au format eficas et + un texte au format dictionnaire """ - # Les extensions de fichier permis? - extensions=('.comm',) -#---------------------------------------------------------------------------------------- - def gener(self,obj,format='brut',config=None, appliEficas=None): + # Les extensions de fichier permis? + extensions = (".comm",) + # ---------------------------------------------------------------------------------------- + def gener(self, obj, format="brut", config=None, appliEficas=None): self.initDico() # Cette instruction genere le contenu du fichier de commandes (persistance) - self.text=PythonGenerator.gener(self,obj,format) - #print (self.text) - print (self.Dico) + self.text = PythonGenerator.gener(self, obj, format) + # print (self.text) + print(self.Dico) return self.text + # ---------------------------------------------------------------------------------------- + # initialisations + # ---------------------------------------------------------------------------------------- + def initDico(self): + self.Dico = {} + self.DicoDejaLa = {} + self.Entete = "" -#---------------------------------------------------------------------------------------- -# initialisations -#---------------------------------------------------------------------------------------- - - def initDico(self) : - - self.Dico={} - self.DicoDejaLa={} - self.Entete = '' - - -#---------------------------------------------------------------------------------------- -# ecriture -#---------------------------------------------------------------------------------------- + # ---------------------------------------------------------------------------------------- + # ecriture + # ---------------------------------------------------------------------------------------- - def writeDefault(self,fn) : - fileDico = fn[:fn.rfind(".")] + '.py' - f = open( str(fileDico), 'w') + def writeDefault(self, fn): + fileDico = fn[: fn.rfind(".")] + ".py" + f = open(str(fileDico), "w") - f.write( "Dico =" + str(self.Dico) ) - #f.write( self.Entete + "Dico =" + str(self.Dico) ) + f.write("Dico =" + str(self.Dico)) + # f.write( self.Entete + "Dico =" + str(self.Dico) ) f.close() -#---------------------------------------------------------------------------------------- -# analyse de chaque noeud de l'arbre -#---------------------------------------------------------------------------------------- + # ---------------------------------------------------------------------------------------- + # analyse de chaque noeud de l'arbre + # ---------------------------------------------------------------------------------------- - def generMCSIMP(self,obj) : + def generMCSIMP(self, obj): """recuperation de l objet MCSIMP""" - s=PythonGenerator.generMCSIMP(self,obj) - if obj.isInformation() : return s - if not obj.isValid() : return s + s = PythonGenerator.generMCSIMP(self, obj) + if obj.isInformation(): + return s + if not obj.isValid(): + return s - liste=obj.getGenealogiePrecise() + liste = obj.getGenealogiePrecise() - if obj.etape.nom=='MODIFICATION_CATALOGUE' : return s + if obj.etape.nom == "MODIFICATION_CATALOGUE": + return s nom = obj.etape.nom - if hasattr(obj.etape,'sdnom') and obj.etape.sdnom != None and obj.etape.sdnom != "" : - nom = nom+ obj.etape.sdnom + if ( + hasattr(obj.etape, "sdnom") + and obj.etape.sdnom != None + and obj.etape.sdnom != "" + ): + nom = nom + obj.etape.sdnom - if not(nom in self.Dico) : dicoCourant={} - else : dicoCourant=self.Dico [nom] + if not (nom in self.Dico): + dicoCourant = {} + else: + dicoCourant = self.Dico[nom] - nomFeuille=liste[-1] + nomFeuille = liste[-1] if nomFeuille in dicoCourant or nomFeuille in self.DicoDejaLa: if nomFeuille in self.DicoDejaLa: - nomTravail= nomFeuille +'_'+str(self.DicoDejaLa[nomFeuille]) - self.DicoDejaLa[nomFeuille]=self.DicoDejaLa[nomFeuille]+1 - nomFeuille=nomTravail - else : - self.DicoDejaLa[nomFeuille]=3 - nom1=nomFeuille +'_1' - dicoCourant[nom1]= dicoCourant[nomFeuille] + nomTravail = nomFeuille + "_" + str(self.DicoDejaLa[nomFeuille]) + self.DicoDejaLa[nomFeuille] = self.DicoDejaLa[nomFeuille] + 1 + nomFeuille = nomTravail + else: + self.DicoDejaLa[nomFeuille] = 3 + nom1 = nomFeuille + "_1" + dicoCourant[nom1] = dicoCourant[nomFeuille] del dicoCourant[nomFeuille] - nomFeuille=nomFeuille +'_2' - - - if hasattr(obj.valeur,'nom'): dicoCourant[nomFeuille]=obj.valeur.nom - else : - if type(obj.valeur) in (list,tuple): - try : -#PNPNPN a remplacer par plus propre - if obj.definition.validators.typeDesTuples[0] !='R' : - val=[] - elt=[] - for tupleElt in obj.valeur : - elt=(str(tupleElt[0]),tupleElt[1]) + nomFeuille = nomFeuille + "_2" + + if hasattr(obj.valeur, "nom"): + dicoCourant[nomFeuille] = obj.valeur.nom + else: + if type(obj.valeur) in (list, tuple): + try: + # PNPNPN a remplacer par plus propre + if obj.definition.validators.typeDesTuples[0] != "R": + val = [] + elt = [] + for tupleElt in obj.valeur: + elt = (str(tupleElt[0]), tupleElt[1]) val.append(elt) - dicoCourant[nomFeuille]=val - else : - dicoCourant[nomFeuille]=obj.valeur - except : - dicoCourant[nomFeuille]=obj.valeurFormatee - #else :dicoCourant[nomFeuille]=obj.valeurFormatee - else : - dicoCourant[nomFeuille]=obj.valeurFormatee - #print nomFeuille, obj.valeurFormatee - self.Dico[nom]=dicoCourant + dicoCourant[nomFeuille] = val + else: + dicoCourant[nomFeuille] = obj.valeur + except: + dicoCourant[nomFeuille] = obj.valeurFormatee + # else :dicoCourant[nomFeuille]=obj.valeurFormatee + else: + dicoCourant[nomFeuille] = obj.valeurFormatee + # print nomFeuille, obj.valeurFormatee + self.Dico[nom] = dicoCourant return s diff --git a/generator/generator_modification.py b/generator/generator_modification.py index bcb3d340..0b3568ea 100644 --- a/generator/generator_modification.py +++ b/generator/generator_modification.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -21,27 +21,47 @@ Ce module sert pour charger les parametres de configuration d'EFICAS """ # Modules Python -from __future__ import absolute_import -try : - from builtins import str - from builtins import object -except : pass +from builtins import str +from builtins import object -import os, sys, types, re +import os, sys, types, re from Extensions.i18n import tr + class ModificationGenerator(object): - def generTexteModif(self,obj): - texteModification="" - for t in list(obj.editor.dicoNouveauxMC.keys()) : + def generTexteModif(self, obj): + texteModification = "" + for t in list(obj.editor.dicoNouveauxMC.keys()): # 'ajoutDefinitionMC',etape,listeAvant,nomDuMC,typ,args - fonction,Etape,Genea,nomSIMP,typeSIMP,arguments = obj.editor.dicoNouveauxMC[t] - texteModification += "MODIFICATION_CATALOGUE(Fonction = '" + str(fonction)+ "',\n" - texteModification += " Etape = '" + str(Etape) + "',\n" - texteModification += " Genea = " + str(Genea) + ",\n" - texteModification += " NomSIMP = '" + str(nomSIMP) + "',\n" - texteModification += " TypeSIMP = '" + str(typeSIMP)+ "',\n" - texteModification += " PhraseArguments = " +'"' + str(arguments)+ '"'+ ",);\n" - + ( + fonction, + Etape, + Genea, + nomSIMP, + typeSIMP, + arguments, + ) = obj.editor.dicoNouveauxMC[t] + texteModification += ( + "MODIFICATION_CATALOGUE(Fonction = '" + str(fonction) + "',\n" + ) + texteModification += ( + " Etape = '" + str(Etape) + "',\n" + ) + texteModification += ( + " Genea = " + str(Genea) + ",\n" + ) + texteModification += ( + " NomSIMP = '" + str(nomSIMP) + "',\n" + ) + texteModification += ( + " TypeSIMP = '" + str(typeSIMP) + "',\n" + ) + texteModification += ( + " PhraseArguments = " + + '"' + + str(arguments) + + '"' + + ",);\n" + ) return texteModification diff --git a/generator/generator_python.py b/generator/generator_python.py index 22399eeb..5226a0d9 100644 --- a/generator/generator_python.py +++ b/generator/generator_python.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# Copyright (C) 2007-2024 EDF R&D # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -22,23 +22,20 @@ python pour EFICAS. """ -from __future__ import absolute_import -try : - from builtins import str - from builtins import object - from builtins import range -except : pass +from builtins import str +from builtins import object +from builtins import range import traceback -import types,re +import types, re from Noyau import N_CR from Noyau.N_utils import repr_float import Accas import Extensions from Extensions.parametre import ITEM_PARAMETRE -from .Formatage import Formatage -from .Formatage import FormatageLigne +from generator.Formatage import Formatage +from generator.Formatage import FormatageLigne from Extensions.param2 import Formula from Extensions.eficas_exception import EficasException from Extensions.i18n import tr @@ -46,154 +43,157 @@ from Extensions.i18n import tr def entryPoint(): """ - Retourne les informations necessaires pour le chargeur de plugins + Retourne les informations necessaires pour le chargeur de plugins - Ces informations sont retournees dans un dictionnaire + Ces informations sont retournees dans un dictionnaire """ return { - # Le nom du plugin - 'name' : 'python', - # La factory pour creer une instance du plugin - 'factory' : PythonGenerator, - } + # Le nom du plugin + "name": "python", + # La factory pour creer une instance du plugin + "factory": PythonGenerator, + } class PythonGenerator(object): """ - Ce generateur parcourt un objet de type JDC et produit - un fichier au format python + Ce generateur parcourt un objet de type JDC et produit + un fichier au format python - L'acquisition et le parcours sont realises par la methode - generator.gener(objet_jdc,format) + L'acquisition et le parcours sont realises par la methode + generator.gener(objet_jdc,format) - L'ecriture du fichier au format ini par appel de la methode - generator.writeFile(nom_fichier) + L'ecriture du fichier au format ini par appel de la methode + generator.writeFile(nom_fichier) - Ses caracteristiques principales sont exposees dans des attributs - de classe : - - extensions : qui donne une liste d'extensions de fichier preconisees + Ses caracteristiques principales sont exposees dans des attributs + de classe : + - extensions : qui donne une liste d'extensions de fichier preconisees """ + # Les extensions de fichier preconisees - extensions=('.comm',) + extensions = (".comm",) - def __init__(self,cr=None): + def __init__(self, cr=None): # Si l'objet compte-rendu n'est pas fourni, on utilise le compte-rendu standard - if cr : - self.cr=cr + if cr: + self.cr = cr else: - self.cr=N_CR.CR(debut='CR generateur format python pour python', - fin='fin CR format python pour python') + self.cr = N_CR.CR( + debut="CR generateur format python pour python", + fin="fin CR format python pour python", + ) # Le texte au format python est stocke dans l'attribut text - self.text='' - self.appliEficas=None + self.text = "" + self.appliEficas = None - def writeFile(self,filename): - fp=open(filename,'w') - fp.write(self.text) - fp.close() + def writeFile(self, filename): + try: + with open(filename, "w") as fp: + fp.write(self.text) + return 1 + except: + return 0 - def gener(self,obj,format='brut',config=None,appliEficas=None): + def gener(self, obj, format="brut", config=None, appliEficas=None): """ - Retourne une representation du JDC obj sous une - forme qui est parametree par format. - Si format vaut 'brut', retourne une liste de listes de ... - Si format vaut 'standard', retourne un texte obtenu par concatenation de la liste - Si format vaut 'beautifie', retourne le meme texte beautifie + Retourne une representation du JDC obj sous une + forme qui est parametree par format. + Si format vaut 'brut', retourne une liste de listes de ... + Si format vaut 'standard', retourne un texte obtenu par concatenation de la liste + Si format vaut 'beautifie', retourne le meme texte beautifie """ - import logging - if obj == None : - print ('appel a gener avec None') + if obj == None: return - self.appliEficas=appliEficas - liste= self.generator(obj) - #format='standard' - if format == 'brut': - self.text=liste - elif format == 'standard': - self.text=''.join(liste) - elif format == 'beautifie': - jdc_formate = Formatage(liste,mode='.py') - #import cProfile, pstats, StringIO - #pr = cProfile.Profile() - #pr.enable() - self.text=jdc_formate.formateJdc() - #pr.disable() - #s = StringIO.StringIO() - #sortby = 'cumulative' - #ps = pstats.Stats(pr, stream=s).sort_stats(sortby) - #ps.print_stats() - #print (s.getValue()) - - elif format == 'Ligne': - jdc_formate = FormatageLigne(liste,mode='.py') - self.text=jdc_formate.formateJdc() + self.appliEficas = appliEficas + liste = self.generator(obj) + if format == "brut": + self.text = liste + elif format == "standard": + self.text = "".join(liste) + elif format == "beautifie": + jdc_formate = Formatage(liste, mode=".py") + # import cProfile, pstats, StringIO + # pr = cProfile.Profile() + # pr.enable() + self.text = jdc_formate.formateJdc() + # pr.disable() + # s = StringIO.StringIO() + # sortby = 'cumulative' + # ps = pstats.Stats(pr, stream=s).sort_stats(sortby) + # ps.print_stats() + # print (s.getValue()) + + elif format == "Ligne": + jdc_formate = FormatageLigne(liste, mode=".py") + self.text = jdc_formate.formateJdc() else: - raise EficasException(tr("Format non implemente ") +format) + raise EficasException(tr("Format non implemente ") + format) return self.text - def generator(self,obj): + def generator(self, obj): """ - Cette methode joue un role d'aiguillage en fonction du type de obj - On pourrait utiliser les methodes accept et visitxxx a la - place (depend des gouts !!!) + Cette methode joue un role d'aiguillage en fonction du type de obj + On pourrait utiliser les methodes accept et visitxxx a la + place (depend des gouts !!!) """ # ATTENTION a l'ordre des tests : il peut avoir de l'importance (heritage) - if isinstance(obj,Accas.PROC_ETAPE): + if isinstance(obj, Accas.PROC_ETAPE): return self.generPROC_ETAPE(obj) # Attention doit etre place avant MACRO (raison : heritage) - elif isinstance(obj,Accas.FORM_ETAPE): + elif isinstance(obj, Accas.FORM_ETAPE): return self.generFORM_ETAPE(obj) - elif isinstance(obj,Accas.MACRO_ETAPE): + elif isinstance(obj, Accas.MACRO_ETAPE): return self.generMACRO_ETAPE(obj) - elif isinstance(obj,Accas.ETAPE): + elif isinstance(obj, Accas.ETAPE): return self.generETAPE(obj) - elif isinstance(obj,Accas.MCFACT): + elif isinstance(obj, Accas.MCFACT): return self.generMCFACT(obj) - elif isinstance(obj,Accas.MCList): + elif isinstance(obj, Accas.MCList): return self.generMCList(obj) - elif isinstance(obj,Accas.MCBLOC): + elif isinstance(obj, Accas.MCBLOC): return self.generMCBLOC(obj) - elif isinstance(obj,Accas.MCSIMP): + elif isinstance(obj, Accas.MCSIMP): return self.generMCSIMP(obj) - elif isinstance(obj,Accas.ASSD): + elif isinstance(obj, Accas.ASSD): return self.generASSD(obj) - elif isinstance(obj,Accas.ETAPE_NIVEAU): + elif isinstance(obj, Accas.ETAPE_NIVEAU): return self.generETAPE_NIVEAU(obj) - elif isinstance(obj,Accas.COMMENTAIRE): + elif isinstance(obj, Accas.COMMENTAIRE): return self.generCOMMENTAIRE(obj) # Attention doit etre place avant PARAMETRE (raison : heritage) - elif isinstance(obj,Accas.PARAMETRE_EVAL): + elif isinstance(obj, Accas.PARAMETRE_EVAL): return self.generPARAMETRE_EVAL(obj) - elif isinstance(obj,Accas.PARAMETRE): + elif isinstance(obj, Accas.PARAMETRE): return self.generPARAMETRE(obj) - elif isinstance(obj,Accas.EVAL): + elif isinstance(obj, Accas.EVAL): return self.generEVAL(obj) - elif isinstance(obj,Accas.COMMANDE_COMM): + elif isinstance(obj, Accas.COMMANDE_COMM): return self.generCOMMANDE_COMM(obj) - elif isinstance(obj,Accas.JDC): + elif isinstance(obj, Accas.JDC): return self.generJDC(obj) - elif isinstance(obj,Accas.MCNUPLET): + elif isinstance(obj, Accas.MCNUPLET): return self.generMCNUPLET(obj) - elif isinstance(obj,ITEM_PARAMETRE): + elif isinstance(obj, ITEM_PARAMETRE): return self.generITEM_PARAMETRE(obj) - elif isinstance(obj,Formula): + elif isinstance(obj, Formula): return self.generFormula(obj) else: - raise EficasException(tr("Type d'objet non prevu") +obj) + raise EficasException(tr("Type d'objet non prevu") + obj) - def generJDC(self,obj): + def generJDC(self, obj): """ - Cette methode convertit un objet JDC en une liste de chaines de - caracteres a la syntaxe python + Cette methode convertit un objet JDC en une liste de chaines de + caracteres a la syntaxe python """ - l=[] + l = [] - #print ('generJDC', obj.sdsDict) - for objRef in obj.sdsDict : - if (isinstance(obj.sdsDict[objRef],Accas.UserASSD)): + # print ('generJDC', obj.sdsDict) + for objRef in obj.sdsDict: + if isinstance(obj.sdsDict[objRef], Accas.UserASSD): l.append(self.generUserASSD(obj.sdsDict[objRef])) - if obj.definition.l_niveaux == (): + if obj.definition.lNiveaux == (): # Il n'y a pas de niveaux for etape in obj.etapes: l.append(self.generator(etape)) @@ -201,106 +201,106 @@ class PythonGenerator(object): # Il y a des niveaux for etape_niveau in obj.etapes_niveaux: l.extend(self.generator(etape_niveau)) - if l != [] : + if l != []: # Si au moins une etape, on ajoute le retour chariot sur la derniere etape - if type(l[-1])==list: - l[-1][-1] = l[-1][-1]+'\n' - elif type(l[-1])==bytes or type(l[-1])==str: - l[-1] = l[-1]+'\n' + if type(l[-1]) == list: + l[-1][-1] = l[-1][-1] + "\n" + elif type(l[-1]) == bytes or type(l[-1]) == str: + l[-1] = l[-1] + "\n" return l - def generUserASSD(self,obj): - classeName = obj.__class__.__name__ - if obj.valeur == None : - texte = obj.nom + '=' + classeName + '()' + def generUserASSD(self, obj): + classeName = obj.__class__.__name__ + if obj.valeur == None: + texte = obj.nom + "=" + classeName + "()" return texte - def generMCNUPLET(self,obj): + def generMCNUPLET(self, obj): """ - Methode generant une representation de self permettant son ecriture - dans le format python + Methode generant une representation de self permettant son ecriture + dans le format python """ - l=[] - l.append('(') + l = [] + l.append("(") for v in obj.mcListe: - text = re.sub(".*=","",self.generator(v)) + text = re.sub(".*=", "", self.generator(v)) l.append(text) - l.append('),') + l.append("),") return l - def generCOMMANDE_COMM(self,obj): + def generCOMMANDE_COMM(self, obj): """ - Cette methode convertit un COMMANDE_COMM - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit un COMMANDE_COMM + en une liste de chaines de caracteres a la syntaxe python """ - l_lignes = obj.valeur.split('\n') - txt='' + l_lignes = obj.valeur.split("\n") + txt = "" for ligne in l_lignes: - txt = txt + '##'+ligne+'\n' + txt = txt + "##" + ligne + "\n" return txt - def generEVAL(self,obj): + def generEVAL(self, obj): """ - Cette methode convertit un EVAL - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit un EVAL + en une liste de chaines de caracteres a la syntaxe python """ - return 'EVAL("""'+ obj.valeur +'""")' + return 'EVAL("""' + obj.valeur + '""")' - def generCOMMENTAIRE(self,obj): + def generCOMMENTAIRE(self, obj): """ - Cette methode convertit un COMMENTAIRE - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit un COMMENTAIRE + en une liste de chaines de caracteres a la syntaxe python """ # modification pour repondre a la demande de C. Durand, d'eviter # l'ajout systematique d'un diese, a la suite du commentaire # Dans la chaine de caracteres obj.valeur, on supprime le dernier # saut de ligne - sans_saut = re.sub("\n$","",obj.valeur) - l_lignes = sans_saut.split('\n') - txt='' - i=1 + sans_saut = re.sub("\n$", "", obj.valeur) + l_lignes = sans_saut.split("\n") + txt = "" + i = 1 for ligne in l_lignes: - txt = txt + '#'+ligne+'\n' + txt = txt + "#" + ligne + "\n" # suppression du dernier saut de ligne - #txt = re.sub("\n$","",txt) + # txt = re.sub("\n$","",txt) # on ajoute un saut de ligne avant - pattern=re.compile(" ?\#") - m=pattern.match(txt) + pattern = re.compile(" ?\#") + m = pattern.match(txt) if m: - txt="\n"+txt + txt = "\n" + txt return txt - def generPARAMETRE_EVAL(self,obj): + def generPARAMETRE_EVAL(self, obj): """ - Cette methode convertit un PARAMETRE_EVAL - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit un PARAMETRE_EVAL + en une liste de chaines de caracteres a la syntaxe python """ if obj.valeur == None: - return obj.nom + ' = None ;\n' + return obj.nom + " = None ;\n" else: - return obj.nom + ' = '+ self.generator(obj.valeur) +';\n' + return obj.nom + " = " + self.generator(obj.valeur) + ";\n" - def generITEM_PARAMETRE(self,obj): + def generITEM_PARAMETRE(self, obj): return repr(obj) - def generFormula(self,obj): - #return repr(obj) + def generFormula(self, obj): + # return repr(obj) return str(obj) - def generPARAMETRE(self,obj): + def generPARAMETRE(self, obj): """ - Cette methode convertit un PARAMETRE - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit un PARAMETRE + en une liste de chaines de caracteres a la syntaxe python """ return repr(obj) + ";\n" - def generETAPE_NIVEAU(self,obj): + def generETAPE_NIVEAU(self, obj): """ - Cette methode convertit une etape niveau - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit une etape niveau + en une liste de chaines de caracteres a la syntaxe python """ - l=[] + l = [] if obj.etapes_niveaux == []: for etape in obj.etapes: l.append(self.generator(etape)) @@ -309,330 +309,355 @@ class PythonGenerator(object): l.extend(self.generator(etape_niveau)) return l - def generETAPE(self,obj): + def generETAPE(self, obj): """ - Cette methode convertit une etape - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit une etape + en une liste de chaines de caracteres a la syntaxe python """ try: - sdname= self.generator(obj.sd) - if sdname.find('SD_') != -1: sdname='sansnom' + sdname = self.generator(obj.sd) + if sdname.find("SD_") != -1: + sdname = "sansnom" except: - sdname='sansnom' - l=[] - label=sdname + '='+obj.definition.nom+'(' + sdname = "sansnom" + l = [] + label = sdname + "=" + obj.definition.nom + "(" l.append(label) - if obj.reuse != None : - str = 'reuse ='+ self.generator(obj.reuse) + ',' + if obj.reuse != None: + str = "reuse =" + self.generator(obj.reuse) + "," l.append(str) for v in obj.mcListe: - if isinstance(v,Accas.MCBLOC) : - liste=self.generator(v) - for mocle in liste : + if isinstance(v, Accas.MCBLOC): + liste = self.generator(v) + for mocle in liste: l.append(mocle) - elif isinstance(v,Accas.MCSIMP) : - text=self.generator(v) - l.append(v.nom+'='+text) + elif isinstance(v, Accas.MCSIMP): + text = self.generator(v) + l.append(v.nom + "=" + text) else: # MCFACT ou MCList - liste=self.generator(v) - liste[0]=v.nom+'='+liste[0] + liste = self.generator(v) + liste[0] = v.nom + "=" + liste[0] l.append(liste) if len(l) == 1: - l[0]=label+');' - else : - l.append(');') + l[0] = label + ");" + else: + l.append(");") return l - def generFORM_ETAPE(self,obj): + def generFORM_ETAPE(self, obj): """ - Methode particuliere pour les objets de type FORMULE + Methode particuliere pour les objets de type FORMULE """ - l=[] + l = [] nom = obj.getNom() - if nom == '' : nom = 'sansnom' - l.append(nom + ' = FORMULE(') + if nom == "": + nom = "sansnom" + l.append(nom + " = FORMULE(") for v in obj.mcListe: - text=self.generator(v) - l.append(v.nom+'='+text) - l.append(');') + text = self.generator(v) + l.append(v.nom + "=" + text) + l.append(");") return l - def generMACRO_ETAPE(self,obj): + def generMACRO_ETAPE(self, obj): """ - Cette methode convertit une macro-etape - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit une macro-etape + en une liste de chaines de caracteres a la syntaxe python """ try: if obj.sd == None: - sdname='' + sdname = "" else: - sdname= self.generator(obj.sd)+'=' - if sdname.find('SD_') != -1: sdname='' + sdname = self.generator(obj.sd) + "=" + if sdname.find("SD_") != -1: + sdname = "" except: - sdname='sansnom=' - l=[] - label = sdname + obj.definition.nom+'(' + sdname = "sansnom=" + l = [] + label = sdname + obj.definition.nom + "(" l.append(label) if obj.reuse != None: # XXX faut il la virgule ou pas ???? - str = "reuse =" + self.generator(obj.reuse) + ',' + str = "reuse =" + self.generator(obj.reuse) + "," l.append(str) for v in obj.mcListe: - if isinstance(v,Accas.MCBLOC) : - liste=self.generator(v) - for mocle in liste : + if isinstance(v, Accas.MCBLOC): + liste = self.generator(v) + for mocle in liste: l.append(mocle) - elif isinstance(v,Accas.MCSIMP) : - text=self.generator(v) - l.append(v.nom+'='+text) + elif isinstance(v, Accas.MCSIMP): + text = self.generator(v) + l.append(v.nom + "=" + text) else: # MCFACT ou MCList - liste=self.generator(v) - liste[0]=v.nom+'='+liste[0] + liste = self.generator(v) + liste[0] = v.nom + "=" + liste[0] l.append(liste) if len(l) == 1: - l[0]=label+');' - else : - l.append(');') + l[0] = label + ");" + else: + l.append(");") return l - def generPROC_ETAPE(self,obj): + def generPROC_ETAPE(self, obj): """ - Cette methode convertit une PROC etape - en une liste de chaines de caracteres a la syntaxe python + Cette methode convertit une PROC etape + en une liste de chaines de caracteres a la syntaxe python """ - l=[] - label=obj.definition.nom+'(' + if ( + obj.nom == "ExpressionIncertitude" + and hasattr(self, "generDeterministe") + and self.generDeterministe == True + ): + return "" + l = [] + label = obj.definition.nom + "(" l.append(label) for v in obj.mcListe: - if isinstance(v,Accas.MCBLOC) : - liste=self.generator(v) - for mocle in liste : + if isinstance(v, Accas.MCBLOC): + liste = self.generator(v) + for mocle in liste: l.append(mocle) - elif isinstance(v,Accas.MCSIMP) : - text=self.generator(v) - if text==None : text= "" - l.append(v.nom+'='+text) + elif isinstance(v, Accas.MCSIMP): + text = self.generator(v) + if text == None: + text = "" + l.append(v.nom + "=" + text) else: # MCFACT ou MCList - liste=self.generator(v) - liste[0]=v.nom+'='+liste[0] + liste = self.generator(v) + liste[0] = v.nom + "=" + liste[0] l.append(liste) if len(l) == 1: - l[0]=label+');' - else : - l.append(');') + l[0] = label + ");" + else: + l.append(");") return l - def generASSD(self,obj): + def generASSD(self, obj): """ - Convertit un objet derive d'ASSD en une chaine de caracteres a la - syntaxe python + Convertit un objet derive d'ASSD en une chaine de caracteres a la + syntaxe python """ return obj.getName() - - def generMCFACT(self,obj): + def generMCFACT(self, obj): """ - Convertit un objet MCFACT en une liste de chaines de caracteres a la - syntaxe python + Convertit un objet MCFACT en une liste de chaines de caracteres a la + syntaxe python """ - l=[] - l.append('_F(') + l = [] + l.append("_F(") for v in obj.mcListe: - if not isinstance(v,Accas.MCSIMP) and not isinstance (v,Accas.MCBLOC) : + if not isinstance(v, Accas.MCSIMP) and not isinstance(v, Accas.MCBLOC): # on est en presence d'une entite composee : on recupere une liste - liste=self.generator(v) - liste[0]=v.nom+'='+liste[0] + liste = self.generator(v) + liste[0] = v.nom + "=" + liste[0] l.append(liste) - elif isinstance(v,Accas.MCBLOC): - liste=self.generator(v) - for arg in liste : + elif isinstance(v, Accas.MCBLOC): + liste = self.generator(v) + for arg in liste: l.append(arg) else: # on est en presence d'un MCSIMP : on recupere une string - text =self.generator(v) - if text== None : text ="" - if v.nom != "Consigne" : l.append(v.nom+'='+text) + text = self.generator(v) + if text == None: + text = "" + if v.nom != "Consigne": + l.append(v.nom + "=" + text) # il faut etre plus subtil dans l'ajout de la virgule en differenciant # le cas ou elle est obligatoire (si self a des freres cadets # dans self.parent) ou non # (cas ou self est seul ou le benjamin de self.parent) - l.append('),') + l.append("),") return l - def generMCList(self,obj): + def generMCList(self, obj): """ - Convertit un objet MCList en une liste de chaines de caracteres a la - syntaxe python + Convertit un objet MCList en une liste de chaines de caracteres a la + syntaxe python """ if len(obj.data) > 1: - l=['('] - for mcfact in obj.data: l.append(self.generator(mcfact)) - l.append('),') + l = ["("] + for mcfact in obj.data: + l.append(self.generator(mcfact)) + l.append("),") else: - l= self.generator(obj.data[0]) + l = self.generator(obj.data[0]) return l - def generMCBLOC(self,obj): + def generMCBLOC(self, obj): """ - Convertit un objet MCBLOC en une liste de chaines de caracteres a la - syntaxe python + Convertit un objet MCBLOC en une liste de chaines de caracteres a la + syntaxe python """ - l=[] + l = [] for v in obj.mcListe: - if isinstance(v,Accas.MCBLOC) : - liste=self.generator(v) - for mocle in liste : + if isinstance(v, Accas.MCBLOC): + liste = self.generator(v) + for mocle in liste: l.append(mocle) - elif isinstance(v,Accas.MCFACT): - liste=self.generator(v) - elif isinstance(v,Accas.MCList): - liste=self.generator(v) - liste[0]=v.nom+'='+liste[0] + elif isinstance(v, Accas.MCFACT): + liste = self.generator(v) + elif isinstance(v, Accas.MCList): + liste = self.generator(v) + liste[0] = v.nom + "=" + liste[0] # PN essai de correction bug identation - if (hasattr(v,'data')) : - if (isinstance(v.data[0],Accas.MCFACT) and (len(v.data) == 1)): + if hasattr(v, "data"): + if isinstance(v.data[0], Accas.MCFACT) and (len(v.data) == 1): l.append(liste) else: - for mocle in liste : + for mocle in liste: l.append(mocle) - else : - for mocle in liste : + else: + for mocle in liste: l.append(mocle) else: - data=self.generator(v) - if data==None : data= "" + data = self.generator(v) + if data == None: + data = "" if type(data) == list: - data[0]=v.nom+'='+data[0] + data[0] = v.nom + "=" + data[0] else: - data=v.nom+'='+data - l.append(data) + data = v.nom + "=" + data + if v.nom != "Consigne": + l.append(data) return l - - def formatItem(self,valeur,etape,obj,vientDeListe=0,matriceDAssd=0): - if (type(valeur) == float or 'R' in obj.definition.type) and not(isinstance(valeur,Accas.PARAMETRE)) : + def formatItem(self, valeur, etape, obj, vientDeListe=0, matriceDAssd=0): + if (type(valeur) == float or "R" in obj.definition.type) and not ( + isinstance(valeur, Accas.PARAMETRE) + ): # Pour un flottant on utilise str ou repr si on vient d une liste # ou la notation scientifique # On ajoute un . si il n y en a pas dans la valeur s = str(valeur) - if vientDeListe and repr(valeur) != str(valeur) : s=repr(valeur) - if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.0' - clefobj=etape.getSdname() + if vientDeListe and repr(valeur) != str(valeur): + s = repr(valeur) + if s.find(".") == -1 and s.find("e") == -1 and s.find("E") == -1: + s = s + ".0" + clefobj = etape.getSdname() if self.appliEficas and clefobj in self.appliEficas.dict_reels: if valeur in self.appliEficas.dict_reels[clefobj]: - s=self.appliEficas.dict_reels[clefobj][valeur] + s = self.appliEficas.dict_reels[clefobj][valeur] - elif type(valeur) == bytes or type(valeur) == str : - if valeur.find('\n') == -1: - # pas de retour chariot, on utilise repr + elif type(valeur) == bytes or type(valeur) == str: + if valeur.find("\n") == -1: + # pas de retour chariot, on utilise repr s = repr(valeur) elif valeur.find('"""') == -1: # retour chariot mais pas de triple ", on formatte - s='"""'+valeur+'"""' + s = '"""' + valeur + '"""' else: s = repr(valeur) - elif isinstance(valeur,Accas.CO) or hasattr(etape,'sdprods') and valeur in etape.sdprods: - s = "CO('"+ self.generator(valeur) +"')" - elif isinstance(valeur,Accas.UserASSD): - # ici on ne prend que la reference + elif ( + isinstance(valeur, Accas.CO) + or hasattr(etape, "sdprods") + and valeur in etape.sdprods + ): + s = "CO('" + self.generator(valeur) + "')" + elif isinstance(valeur, Accas.UserASSD): + # ici on ne prend que la reference s = valeur.nom - elif isinstance(valeur,Accas.ASSD): + elif isinstance(valeur, Accas.ASSD): s = self.generator(valeur) - elif isinstance(valeur,Accas.PARAMETRE): + elif isinstance(valeur, Accas.PARAMETRE): # il ne faut pas prendre la string que retourne gener # mais seulement le nom dans le cas d'un parametre s = valeur.nom - #elif type(valeur) == types.InstanceType or isinstance(valeur,object): + # elif type(valeur) == types.InstanceType or isinstance(valeur,object): # if valeur.__class__.__name__ == 'CO' or hasattr(etape,'sdprods') and valeur in etape.sdprods : # s = "CO('"+ self.generator(valeur) +"')" # elif isinstance(valeur,Accas.PARAMETRE): - # il ne faut pas prendre la string que retourne gener - # mais seulement le nom dans le cas d'un parametre + # il ne faut pas prendre la string que retourne gener + # mais seulement le nom dans le cas d'un parametre # s = valeur.nom # else: # s = self.generator(valeur) - elif matriceDAssd : - s='[' - for v in valeur : - s=s+str(self.generator(v))+', ' - - s=s+']' - else : + elif matriceDAssd: + s = "[" + for v in valeur: + s = s + str(self.generator(v)) + ", " + + s = s + "]" + else: # Pour les autres types on utilise repr s = repr(valeur) return s - def generMCSIMP(self,obj) : + def generMCSIMP(self, obj): """ - Convertit un objet MCSIMP en une liste de chaines de caracteres a la - syntaxe python + Convertit un objet MCSIMP en une liste de chaines de caracteres a la + syntaxe python """ - waitTuple=0 - matriceDAssd=0 + waitTuple = 0 + matriceDAssd = 0 for ssType in obj.definition.type: - if hasattr(ssType,'typElt') : - if ssType.typElt not in ('R','I','C','TXM') : - matriceDAssd=1 + if hasattr(ssType, "typElt"): + if ssType.typElt not in ("R", "I", "C", "TXM"): + matriceDAssd = 1 break - if type(obj.valeur) in (tuple,list) : - s = '' + if type(obj.valeur) in (tuple, list): + s = "" for ss_type in obj.definition.type: - if repr(ss_type).find('Tuple') != -1 : - waitTuple=1 + if repr(ss_type).find("Tuple") != -1: + waitTuple = 1 break - if waitTuple : - #s = str(obj.valeur) +',' - #obj.valeurFormatee=obj.valeur - s = obj.getText() +',' - obj.valeurFormatee=obj.getText() - else : - obj.valeurFormatee=[] - for val in obj.valeur : - s =s +self.formatItem(val,obj.etape,obj,1,matriceDAssd) + ',' - if obj.waitTxm() : + if waitTuple: + # s = str(obj.valeur) +',' + # obj.valeurFormatee=obj.valeur + s = obj.getText() + "," + obj.valeurFormatee = obj.getText() + else: + obj.valeurFormatee = [] + for val in obj.valeur: + s = s + self.formatItem(val, obj.etape, obj, 1, matriceDAssd) + "," + if obj.waitTxm(): obj.valeurFormatee.append(val) - else : - obj.valeurFormatee.append(self.formatItem(val,obj.etape,obj)) + else: + obj.valeurFormatee.append(self.formatItem(val, obj.etape, obj)) if len(obj.valeur) >= 1: - s = '(' + s + '),' - if obj.valeur==[] or obj.valeur==() : s="()," - if obj.nbrColonnes() : - s=self.formatColonnes(obj.nbrColonnes(),obj.valeur,obj) - else : - obj.valeurFormatee=obj.valeur - s=self.formatItem(obj.valeur,obj.etape,obj) + ',' + s = "(" + s + ")," + if obj.valeur == [] or obj.valeur == (): + s = "()," + if obj.nbrColonnes(): + s = self.formatColonnes(obj.nbrColonnes(), obj.valeur, obj) + else: + obj.valeurFormatee = obj.valeur + s = self.formatItem(obj.valeur, obj.etape, obj) + "," return s - - def formatColonnes(self,nbrColonnes,listeValeurs,obj): - try : - #if 1 == 1 : - indice=0 - textformat="(" - while ( indice < len(listeValeurs) ) : - try : - #if 1 : - for l in range(nbrColonnes) : - texteVariable=self.formatItem(listeValeurs[indice],obj.etape,obj) - textformat=textformat+texteVariable+" ," - indice=indice+1 - textformat=textformat+"\n" - except : - #else : - while ( indice < len(listeValeurs) ) : - texteVariable=self.formatItem(listeValeurs[indice],obj.etape,obj) - textformat=textformat+texteVariable+", " - indice=indice+1 - textformat=textformat+"\n" - textformat=textformat[0:-1]+"),\n" - except : - #else : - textformat=str(obj.valeur) + def formatColonnes(self, nbrColonnes, listeValeurs, obj): + try: + # if 1 == 1 : + indice = 0 + textformat = "(" + while indice < len(listeValeurs): + try: + # if 1 : + for l in range(nbrColonnes): + texteVariable = self.formatItem( + listeValeurs[indice], obj.etape, obj + ) + textformat = textformat + texteVariable + " ," + indice = indice + 1 + textformat = textformat + "\n" + except: + # else : + while indice < len(listeValeurs): + texteVariable = self.formatItem( + listeValeurs[indice], obj.etape, obj + ) + textformat = textformat + texteVariable + ", " + indice = indice + 1 + textformat = textformat + "\n" + textformat = textformat[0:-1] + "),\n" + except: + # else : + textformat = str(obj.valeur) return textformat diff --git a/generator/incertainty_tools.py b/generator/incertainty_tools.py new file mode 100755 index 00000000..0f069846 --- /dev/null +++ b/generator/incertainty_tools.py @@ -0,0 +1,70 @@ +# -*- coding: utf-8 -*- +import os + + +def value_repr_name(values): + """ + Create a directory name using the representation of the values. + Example: + >>> valueReprName([0.5, 3.0 / 7.0]) + 'c0.5_0.42857142857142855_' + """ + s = "c" + for v in values: + s += repr(v) + "_" + return s + + +def hashname(values): + """ + Create a directory name using a hash function. + Example: + >>> hashName([0.5, 3.0 / 7.0]) + '6f454e45e9a4fa8856688e80de6bfc58' + """ + import hashlib + + h = hashlib.md5(repr(values)) + return h.hexdigest() + + +def temp_dirname(): + """ + Create a temporary directory in the current directory. + """ + import tempfile + + return tempfile.mkdtemp(dir=os.getcwd()) + + +def replace_data(filename, key_values, filename_out=""): + """ + Modify an input file using replace function. + Example: + origin file: "CPHY_MAT_ISO= $rho $cp $lambda -1 " + key_values: {'$rho':'3', '$cp':'5', '$lambda':7} + modified file: "CPHY_MAT_ISO= 3 5 7 -1" + """ + with open(filename, "r") as f: + filedata = f.read() + for key, value in key_values.items(): + filedata = filedata.replace(key, value) + if len(filename_out) == 0: + filename_out = filename + with open(filename_out, "w") as f: + f.write(filedata) + + +def format_data(filename, key_values): + """ + Modify an input file using format function. + Example: + origin file: "CPHY_MAT_ISO= {rho} {cp} {lambda} -1 " + key_values: {'rho':'3', 'cp':'5', 'lambda':'7'} + modified file: "CPHY_MAT_ISO= 3 5 7 -1" + """ + with open(filename, "r") as f: + filedata = f.read() + filedata = filedata.format(**key_values) + with open(filename, "w") as f: + f.write(filedata) diff --git a/generator/post_csv_rn.py b/generator/post_csv_rn.py new file mode 100755 index 00000000..ed6c53ed --- /dev/null +++ b/generator/post_csv_rn.py @@ -0,0 +1,167 @@ +# Exemple de script pour lire la sortie csv du banc d'intégration odysee +# +# Lecture des valeurs dans le csv et renvoi de la valeur après application de la fonction d'agragation max,min et moy + +# To get the history in python +# print('\n'.join([str(readline.get_history_item(i + 1)) for i in range(readline.get_current_history_length())])) + + +def vMax(arrayNx2): + import numpy as np + + return np.apply_along_axis(max, 0, arrayNx2[:, 1]).item() + + +def vMin(arrayNx2): + import numpy as np + + return np.apply_along_axis(min, 0, arrayNx2[:, 1]).item() + + +def vMean(arrayNx2): + import numpy as np + import statistics + + return np.apply_along_axis(statistics.mean, 0, arrayNx2[:, 1]).item() + + +def vSum(arrayNx2): + import numpy as np + + return np.apply_along_axis(sum, 0, arrayNx2[:, 1]).item() + + +def vInitialTime(arrayNx2): + import numpy as np + + # Dates on first column, Values on second one + timeColumn = arrayNx2[:, 0] + # Tmin=np.apply_along_axis(min, 0, timeColumn) + # assert(arrayNx2[0,0]==Tmin) + idxTmin = timeColumn.argmin() + assert idxTmin == 0 + + valTmin = arrayNx2[idxTmin][1].item() + + return valTmin + + +def vFinalTime(arrayNx2): + import numpy as np + + # Dates on first column, Values on second one + timeColumn = arrayNx2[:, 0] + # Tmax=np.apply_along_axis(max, 0, timeColumn) + # assert(arrayNx2[timeColumn.size,0]==Tmax) + idxTmax = timeColumn.argmax() + idxMax = timeColumn.size - 1 + assert idxTmax == idxMax + + valTmax = arrayNx2[idxTmax][1].item() + + return valTmax + + +def vHalfTime(arrayNx2): + import numpy as np + + # Dates on first column, Values on second one + timeColumn = arrayNx2[:, 0] + Tmin = np.apply_along_axis(min, 0, timeColumn) + Tmax = np.apply_along_axis(max, 0, timeColumn) + + Thalf = (Tmax - Tmin) / 2 + Tmin + idxThalf = (np.abs(timeColumn - Thalf)).argmin() + valThalf = arrayNx2[idxThalf][1].item() + + return valThalf + + +def get_result_from_csv( + variableName: str, functionList, filename: str = None, delimiter="," +): + from csv import reader + import numpy as np + + transientName = "Transient duration" + + # ex: file_csv = "Fuel temperature@Thermalhydraulics@MAX.csv" + if filename == None: + filename = variableName + ".csv" + + with open(filename, "r") as csv_file: + csv_reader = reader(csv_file, delimiter=delimiter) + header = next(csv_reader) + header_transient_name = header[1] + header_variable_name = header[2] + if header_variable_name != variableName: + print( + sys.stderr, + "The variable name {} differs from the file's header one {}".format( + variableName, header_variable_name + ), + ) + return -1 # TODO Exception ? + if header_transient_name != transientName: + print( + sys.stderr, + "The transient duration name {} differs from the file's header one {}".format( + transientName, header_transient_name + ), + ) + return -1 # TODO Exception ? + + date_value_array = np.loadtxt(filename, delimiter=delimiter, skiprows=1)[:, 1:3] + valList = [] + for func in functionList: + valList.append(func(date_value_array)) + return valList + + +# Fuel-temperature_Thermalhydraulics_MAX +# value at t_initial value at t_mid value at t_final mean value cumsum value min value max value +# MeanFirstOrder (°C): 1113.040047 1009.112047 968.544065 207597.218716 1113.040047 968.544064 1032.821984 +# StandardDeviationFirstOrder (°C): 203.302658 250.504351 255.172144 43724.195535 203.302658 256.008518 217.533311 + + +def write_result_from_persalys(resultNp, indexNp, resSk, outputs): + import numpy as np + import pandas as pnd + from functools import reduce + + # resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ]) + # Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne + # resultNp = np.array([ {optionalResultList} ]) + # Noms de lignes + # index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ] + # indexNp = [ {optionalResultStrList} ] + nResult = len(indexNp) + # Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global + # resultSk = [0,7,10] + # resSk = [ {resultSkList} ] + nOutVar = len(resSk) - 1 + + print("\n") + for i in range(nOutVar): + # Récupère les couples (fctAggrégation,Nom de variable ss fct Agg) + # des champs de description des sorties. + # Les sorties concernées proviennent de la section de résultatNp + # qui doit correspondre à une même variable hors fct Agg + fctAgg_outVarName = list( + map(lambda o: eval(o.getDescription()), outputs[resSk[i] : resSk[i + 1]]) + ) + outVarName = fctAgg_outVarName[0][1] + checkOutVarName = reduce( + lambda n1, n2: n1 == n2, + [True] + list(map(lambda o: o[1] == outVarName, fctAgg_outVarName)), + ) + assert checkOutVarName == True + print(outVarName) + columns = list(map(lambda o1: o1[0], fctAgg_outVarName)) + resultDf = pnd.DataFrame( + resultNp[:, resSk[i] : (resSk[i + 1])], index=indexNp, columns=columns + ) + print(resultDf, "\n") + # name_csv = str.replace(str.replace(outVarName,"@","_"),' ','-') + name_csv = outVarName + resultDf.to_csv(name_csv + "-uncertainty.csv") diff --git a/generator/textePersalys.py b/generator/textePersalys.py new file mode 100755 index 00000000..f61faa0c --- /dev/null +++ b/generator/textePersalys.py @@ -0,0 +1,449 @@ +# ---------------------------------- +# headerScriptPersalys +# Parametres pour format : +# nom de l etude, nom de l etude, nom de l etude, path pour wrapper, wrapper, nom de la fonction +# sys.path[:0]=[{}] + +headerScriptPersalys = """#! /usr/bin/env python3 +# coding: utf-8 +# -------------------------------------------------------------------------- +# Script Eficas genere pour lancement Etude Probabiliste +# --------------------------------------------------------------------------- +# Exemple d'utilisation standalone avec salome : +# ~/salome/appli_V9_7_0_package/salome start -k -t python3 mon_fichier_uq_genere.py +# ou +# ~/salome/appli_V9_7_0_package/salome start -k -t +# ~/salome/appli_V9_7_0_package/salome shell python3 mon_fichier_uq_genere.py + +# Chargement du module systeme +import sys +import os + +# Chargement du module OpenTURNS #TODO : Parametrer OpenTurns/Uranie +import openturns as ot +import persalys + +""" + +# def run_case(self): +# """ +# Launch the calculation once the case files are ready. +# """ +# command = './run.sh ' +# command += './syrthes.py -n ' + str(self.nproc) + ' -d ' + self.comm_file +# command += ' >' + os.path.join(self.workdir, "std.log") +# command += ' 2>' + os.path.join(self.workdir, "err.log") +# os.system(command) +# pass + + +# ---------------------------------- +# etudeScript +etudeScript = """ +class Study: + import os + import subprocess + + def __init__(self, {chaineDesVariablesInput}): + {chaineInitDesVariablesInput} + + def do_sh(self, command, execdir=os.getcwd()): + print('Execution directory is : ', execdir) + import subprocess + sh = subprocess.Popen(command, shell=True, cwd=execdir, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT) + out, err = sh.communicate() + return out, err, sh.poll() + + #TODO : Définir un décorateur pour sélectionner la fonction voulue + def define_workdirectory(self): + from incertainty_tools import value_repr_name + self.workdir = value_repr_name([{chaineSelfDesVariablesInput}]) + + def case_exists(self): + ok = True + if os.path.isdir(self.workdir): + try: + ok = False #TODO + except: + ok = False + else: + ok = False + return ok + + def prepare_case(self): + from incertainty_tools import replace_data + import shutil + + if not os.path.isdir(self.workdir): + os.mkdir(self.workdir) + + #section spécifique au code de calcul + comm_file_balise = '{commFileBalise}' + + self.nproc = {nproc} # La présence de cette variable dépend + # du mode de lancement MPI + # S'il est géré par le script appelé à partir du MDD, il est inutile de le stocker + self.comm_file_balise = os.path.join(self.workdir, comm_file_balise) + shutil.copy(comm_file_balise, self.comm_file_balise) + + self.comm_file = os.path.join(self.workdir, '{commFile}') + replace_data(self.comm_file_balise, {{ {replaceDataList} }} , self.comm_file) + #TODO: Lancer la validation du fichier généré avant tout lancement : Le banc le fait + + pass + + def get_result_from_csv(self,postProcessedVar, aggregationFctList): + from post_csv_rn import get_result_from_csv + #TODO: Fonctions a implementer dans un fichier post_csv provenant + # de la mise en donnée pour définir la façon d'aggréger les valeurs + from post_csv_rn import vInitialTime, vHalfTime, vFinalTime, vMean, vSum, vMin, vMax + + savdir=os.getcwd() + os.chdir(self.workdir) + results = get_result_from_csv(postProcessedVar, aggregationFctList) + os.chdir(savdir) + return results + + def run_case(self): + #os.chdir(self.workdir) + # Si lancement mpi externe à ib_test.sh il faut utiliser self.nproc : mpiexec -n self.nproc ib_test.sh + #o,e,c = self.do_sh(command="ib_test.sh", execdir=self.workdir) + command="{uncertaintyScript} {uncertaintyScriptParameters}" + o,e,c = self.do_sh(command=command, execdir=self.workdir) + if o != None : print(o.decode()) + if e != None : print(e.decode()) + if c != 0: + raise Exception(' Study::run_case : Execution error : cd ' + + os.path.join('{workDirectory}',self.workdir) + + ' && '+ os.path.join('../','{uncertaintyScript}') + + ' '+ '{uncertaintyScriptParameters}') + +""" + +# /home/C65845/VIMMP/Banc_integration.newer_odysee/environment/bin/python3 /home/C65845/VIMMP/Banc_integration.newer_odysee/environment/bin/ib-run --cocagne-neutro-solver SPN --cocagne-thermo-solver THERMOMI/TRMIC -- /home/C65845/VIMMP/Banc_integration.newer_odysee/integration_bench/tests/control_rod_ejection_small_core_cathare3_cocagne.comm /home/C65845/VIMMP/Banc_integration.newer_odysee/integration_bench/tests/control_rod_ejection_small_core_cathare3_cocagne_spn_thermomi-trmic_serial + +getResultCall = """ {variableOutputList}, = study.get_result_from_csv( '{nomVarPostraite}', [{fonctionAggregationList}] ) + print( '{nomVarPostraite}: ({variableOutputList})',{variableOutputList}) +""" + +getResultCallAvoidPersalysBug = """ {variableOutputList}, = study.get_result_from_csv( '{nomVarPostraite}', [{fonctionAggregationList}] ) + + print( '{nomVarPostraite}: ({variableOutputList})',{variableOutputList}) + + #Contournement Bug Persalys sur la longueur de la chaine retour + {shortVariableOutputList} = {variableOutputList} + +""" + +# ------------------------- +# fonctionPersalys +# ------------------------ +fonctionPersalys = """ +def _exec({chaineDesVariablesInput}): + from post_csv_rn import vInitialTime, vHalfTime, vFinalTime, vMean, vSum, vMin, vMax + from {currentFile} import Study + + study = Study({chaineDesVariablesInput}) + study.define_workdirectory() + if not study.case_exists(): + study.prepare_case() + study.run_case() + +{getAllResults} + return {chaineDesVariablesOutput} +""" + +# ------------------------ +# codePersalys +# ------------------------ +codePersalys = """ +code = ''' +{fonctionPersalys} +''' +""" + +# ---------------------------- +# inputHeaderPersalys +# ---------------------------- +inputHeaderPersalys = """ +{indent}# definition des Inputs +{indent}# --------------------- +""" + +# inputPersalysUniform='{}{} = persalys.Input({}, {})' +# inputPersalys='{}{} = persalys.Input({}, {})' + +# ------------------------------ +# ouputHeaderPersalys +# ------------------------------ +outputHeaderPersalys = """ +{indent}# definition des Outputs +{indent}# ---------------------- +""" + +# ------------------ +# mainPersalys +# ------------------ +mainPersalys = """ +# ------------------ +# definition du main +# ------------------ +if __name__ == '__main__': + + from datetime import datetime + + {nomEtude} = persalys.Study('{nomEtude}') + persalys.Study.Add({nomEtude}) + +{inputVariableInitList} +{outputVariableInitList} + +{inputHeaderPersalys} + inputs = [{chaineDesVariablesInput}] + nInputs = len(inputs) + +{outputHeaderPersalys} + outputs = [{chaineDesVariablesOutput}] + nOutputs = len(outputs) + + yacsPhysicalModel = persalys.YACSPhysicalModel('PhysicalModel', inputs, outputs, code) +{yacsJobParameters} + {nomEtude}.add(yacsPhysicalModel) + +{centralTendencyPersalys} + {nomEtude}.add(centralTendency) + +################ CUT THE FILE HERE IF YOU WANT TO IMPORT IT IN THE SALOME PERSALYS MODULE ################ + + head_study = str(datetime.now()) +" {scenarioType} "+"" + + centralTendency.run() +{resultPersalys} + +""" +# a = persalys.Input('a', 0, '') +# b = persalys.Input('b', 0, '') +# d = persalys.Output('d', '') +# inputs = [a, b] +# outputs = [d] + +# empiricalMean = ot.Sample(result.getMean())[nInputs:] +# empiricalStandardDeviation = ot.Sample(result.getStandardDeviation())[nInputs:] +# resultNp.reshape(nbindex,nbsorties) + +printResultMC = """ import numpy as np + sys.path.append(os.path.abspath('{post_csv_rnPath}')) + from {post_csv_rnScript} import write_result_from_persalys + + #Noms de lignes + #index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ] + indexNp = [ {optionalResultStrList} ] + nResult = len(indexNp) + + #resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ]) + #Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne + resultNp = np.array([ {optionalResultList} ]) + resultNp = resultNp.reshape(nResult, nOutputs) #En MC à cause du ot.Sample( PointsCollection) il y a un niveau de liste en trop + + #Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global + # ex pour deux variables et respectivement 7 et 3 fcts aggrégation : resultSk = [0,7,10] + #nOutVar = len(resSk)-1 + resSk = [ {resultSkList} ] + + print('\\n\\n') + print('*********************************************************************************\\n') + print(' UNCERTAINTY QUANTIFICATION RESULTS\\n') + + print(head_study,'\\n') + + print('Uncertain inputs list :','\\n') + print( +{Uncertain_inputs}'\\n' + ) + print('\\nElapsed Time : ', centralTendency.getElapsedTime(),'\\n') #Monte Carlo ou Taylor + + print('\\nDesign of Experiment :') + print(result.getDesignOfExperiment().getInputSample(),'\\n') #TODO: générer un fichier csv + + print('\\nCoefficient of Variation :') + print(ot.Sample(result.getCoefficientOfVariation())[nInputs:],'\\n') #TODO: générer un fichier csv + write_result_from_persalys(resultNp, indexNp, resSk, outputs) + + print('\\n*********************************************************************************\\n') +""" + + +printResultTaylor = """ import numpy as np + sys.path.append(os.path.abspath('{post_csv_rnPath}')) + from {post_csv_rnScript} import write_result_from_persalys + + #resultNp = np.array([meanFirstOrder, meanSecondOrderOrder, standardDeviationFirstOrder ]) + #Lignes de résultats demandés pour toutes les fcts d'aggrégation en colonne + resultNp = np.array([ {optionalResultList} ]) + + #Noms de lignes + #index = ['meanFirstOrder', 'meanSecondOrderOrder', 'standardDeviationFirstOrder' ] + #nResult = len(indexNp) + indexNp = [ {optionalResultStrList} ] + + #nResult = len(indexNp) + + #Tableau skyline localisant les variables (hors fctAgg) dans le tableau de résultat global + # ex pour deux variables et respectivement 7 et 3 fcts aggrégation : resultSk = [0,7,10] + #nOutVar = len(resSk)-1 + resSk = [ {resultSkList} ] + + print('\\n\\n') + print('*********************************************************************************\\n') + print(' UNCERTAINTY QUANTIFICATION RESULTS\\n') + + print(head_study,'\\n') + + print('Uncertain inputs list :','\\n') + print( +{Uncertain_inputs}'\\n' + ) + print('\\nElapsed Time : ', centralTendency.getElapsedTime(),'\\n') #Monte Carlo ou Taylor + + # print('\\nDesign of Experiment :') + # print(result.getDesignOfExperiment().getInputSample(),'\\n') #TODO: Activer uniquement en MC + fichier csv + + # print('\\nCoefficient of Variation :') + # print(result.getCoefficientOfVariation(),'\\n') #TODO: Activer uniquement en MC + fichier csv + write_result_from_persalys(resultNp, indexNp, resSk, outputs) + + print('\\n*********************************************************************************\\n') +""" + +## Tendance Centrale Taylor +centralTendencyTaylor = """ + centralTendency = persalys.TaylorExpansionMomentsAnalysis('centralTendencyTaylor', yacsPhysicalModel) +""" + +# Le result est une liste de taille +resultTaylor = """ + result = centralTendency.getResult() +{optionalResult} + +""" + +optionalResultTaylor = { + "MeanFirstOrder": "meanFirstOrder = result.getMeanFirstOrder()", + "StandardDeviationFirstOrder": "standardDeviationFirstOrder = result.getStandardDeviation()", + "MeanSecondOrder": "meanSecondOrder = result.getMeanSecondOrder()", + "Variance": "variance = result.getVariance()", +} +optionalPrintResultTaylor = { + "MeanFirstOrder": 'print("MeanFirstOrder : ",meanFirstOrder)', + "StandardDeviationFirstOrder": 'print("StandardDeviationFirstOrder :",standardDeviationFirstOrder)', + "MeanSecondOrder": 'print("MeanSecondOrder :",meanSecondOrder)', + "Variance": 'print("Variance :",variance)', +} + +## Tendance Centrale MC +centralTendencyMC = """ + centralTendency = persalys.MonteCarloAnalysis('centralTendencyMC', yacsPhysicalModel) +{critereArretMC} +{advancedParameterMC} + centralTendency.setBlockSize({BlockSize}) +""" + +critereArretMC = { + "SimulationsNumber": "centralTendency.setMaximumCalls({SimulationsNumber})", + "MaximumElapsedTime": "centralTendency.setMaximumElapsedTime({MaximumElapsedTime})", + "Accuracy": "centralTendency.setMaximumCoefficientOfVariation({Accuracy})", +} + +advancedParameterMC = { + "Seed": "centralTendency.setSeed({Seed})", # TODO : A ajouter dans le catalogue + "ComputeConfidenceIntervalAt": "centralTendency.setLevelConfidenceInterval({ComputeConfidenceIntervalAt})", +} + +# TODO: Gérer les unités +resultMC = """ + result = centralTendency.getResult() +{optionalResult} +""" + +optionalResultMC = { + "EmpiricalMean": "empiricalMean = ot.Sample(result.getMean())[nInputs:]", # En MC les inputs apparaissent en début de résultat ! + "Variance": "variance = ot.Sample(result.getVariance())[nInputs:]", # et on utilise ot.Sample pour accéder aux valeurs des Points + "EmpiricalStandardDeviation": "empiricalStandardDeviation = ot.Sample(result.getStandardDeviation())[nInputs:]", # Idem. + "EmpiricalQuantile": """ + designOfExperiment=result.getDesignOfExperiment() + outputSample=designOfExperiment.getOutputSample() + empiricalQuantile_Order = {EmpiricalQuantile_Order} + empiricalQuantile=outputSample.computeQuantile(empiricalQuantile_Order) + """, +} + +optionalPrintResultMC = { + "EmpiricalMean": 'print("EmpiricalMean : ", empiricalMean)', + "Variance": 'print("Variance : ", variance)', + "EmpiricalStandardDeviation": 'print("EmpiricalStandardDeviation : ",empiricalStandardDeviation)', + "EmpiricalQuantile": 'print("EmpiricalQuantile : ",empiricalQuantile)', + "EmpiricalQuantile_Order": 'print("EmpiricalQuantile_Order : ",empiricalQuantile_Order)', +} + + +# designOfExperiment=result.getDesignOfExperiment() +# outputSample=designOfExperiment.getOutputSample() +# computeQuantile=outputSample.computeQuantile(empiricalQuantile_Order) +# ##isample=designOfExperiment.getSample() +# ##computeQuantile=sample.computeQuantile(0.95) +# ##nputSample=designOfExperiment.getInputSample() +# ##computeQuantile=inputSample.computeQuantile(0.95) + + +# En local le nombre de procs est inutile +# TODO: S'il on peut récupérer les fichiers .csv des tirages, +# il faut ajouter une ligne out_files +yacsJobParameters = """ + yacsPhysicalModel.jobParameters().salome_parameters.resource_required.name = '{resourceName}' + yacsPhysicalModel.jobParameters().salome_parameters.job_name = '{nomEtude}' + yacsPhysicalModel.jobParameters().salome_parameters.work_directory = '{workDirectory}' + yacsPhysicalModel.jobParameters().salome_parameters.result_directory = '{resultDirectory}' + yacsPhysicalModel.jobParameters().salome_parameters.in_files = {inFiles} # Chemins des fichiers locaux à copier dans work_directory + yacsPhysicalModel.jobParameters().nb_branches = {nbBranches} # nombre de jobs parallèles +""" + +# Le nombre de procs du job manager est uniquement utile pour les clusters +yacsJobClusterParameters = """ + yacsPhysicalModel.jobParameters().salome_parameters.resource_required.nb_proc = {nprocs} + yacsPhysicalModel.jobParameters().salome_parameters.wckey = '{wckey}' +""" + +# Ces 3 lignes permettent de modifier le mode d'évaluation par défaut qui est +# d'avoir toutes les évaluations dans un seul job. +# Ici jobs seront crées dynamiquement pour lancer chaque évaluation +# chaque job demandera la réservation de nprocs processus. +yacsJobClusterMultiJob = """ + import pydefx + multiJobModel = pydefx.MultiJobStudy() # mode un job par évaluation + yacsPhysicalModel.setJobModel(multiJobModel) +""" + +# yacsJobParametersRef=""" +# yacsPhysicalModel.jobParameters().salome_parameters.job_name = '{nomEtude}_idefix_job' +# yacsPhysicalModel.jobParameters().salome_parameters.work_directory = '/scratch/C65845/workingdir/persalys_light' +# yacsPhysicalModel.jobParameters().salome_parameters.result_directory = '/tmp/local_result' +# yacsPhysicalModel.jobParameters().salome_parameters.resource_required.name = 'gaia' +# yacsPhysicalModel.jobParameters().salome_parameters.resource_required.nb_proc = 1 +# yacsPhysicalModel.jobParameters().salome_parameters.wckey = 'P11N0:SALOME' +# yacsPhysicalModel.jobParameters().salome_parameters.in_files = [] # Chemins des fichiers locaux à copier dans work_directory +# yacsPhysicalModel.jobParameters().nb_branches = 3 # nombre de jobs parallèles + +# # Ces 4 lignes permettent de modifier le mode d'évaluation par défaut qui est +# # d'avoir toutes les évaluations dans un seul job. +# import pydefx +# import os +# myModel = pydefx.MultiJobStudy() # mode un job par évaluation + +# PhysicalModel.setJobModel(myModel) +# """ + + +if __name__ == "__main__": + pass -- 2.39.2