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
Accas class for catalog rule AU_MOINS_UN
__init__ is in N_REGLE.REGLE
"""
+
pass
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
Accas class for catalog rule AVANT
class instantiation automatically invokes REGLE.__init__()
"""
+
pass
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
"""
Accas class for catalog definition keyword BLOC
"""
+
class_instance = A_MCBLOC.MCBLOC
def __init__(self, *tup, **args):
Accas class for catalog rule ENSEMBLE
class instantiation automatically invokes REGLE.__init__()
"""
+
pass
#
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)
Accas class for catalog rule EXCLUS
class instantiation automatically invokes REGLE.__init__()
"""
+
pass
"""
Accas class for catalog definition keyword FACT
"""
+
class_instance = A_MCFACT.MCFACT
list_instance = A_MCLIST.MCList
from Noyau import N_OBJECT
from Ihm import I_OBJECT
+
class ErrorObj(I_OBJECT.ErrorObj, N_OBJECT.ErrorObj):
pass
(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
#
# 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
"""
Accas class for catalog definition keyword FORMULE
"""
+
class_instance = A_FORM_ETAPE.FORM_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)
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):
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):
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
#
# 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
parent class of MACRO definition
unused class that could/should be reactivated
"""
+
class_instance = A_MACRO_ETAPE.MACRO_ETAPE
def __init__(self, *tup, **args):
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={}):
#
# 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
"""
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)
#
# 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
"""
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)
#
# 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
class of keywords which are also lists
overload the python list class
"""
+
def __init__(self):
N_MCLIST.MCList.__init__(self)
"""
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)
#
# 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
"""
Accas class for catalog rule MEME_NOMBRE
"""
+
pass
#
# 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
#
# 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
#
# 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
"""
Accas class for catalog definition keyword PROC
"""
+
class_instance = A_PROC_ETAPE.PROC_ETAPE
def __init__(self, *tup, **args):
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)
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
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
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):
"""
Accas class for catalog definition keyword Tuple
"""
+
pass
"""
Accas class for catalog definition keyword Matrice
"""
- pass
+ pass
"""
Accas class for catalog rule UN_PARMI
"""
+
pass
--- /dev/null
+# -*- 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="**"))
--- /dev/null
+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)
+
--- /dev/null
+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
+
--- /dev/null
+# 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')
--- /dev/null
+# 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__)))
--- /dev/null
+# -*- 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
+++ /dev/null
-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
# -*- 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
# -*- 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
# 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
"""
"""
+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
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)
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)
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):
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:
except:
self.nom = ""
- if self.nom=='sansnom' or self.nom == '':
+ if self.nom == "sansnom" or self.nom == "":
self.nom = self.id
return self.nom
# '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
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__)
# 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
# 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
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:
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
"""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()
# 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
# 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
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
if valeur.isTypCO():
return valeur
raise ValError("Pas un concept CO")
+
__convert__ = classmethod(__convert__)
# 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
"""
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,)
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):
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):
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
# 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
""" 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
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
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 = []
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):
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()
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):
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
# 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
#
#
# ======================================================================
-
-
"""
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)))
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 += "<ns1:{}>".format(self.nom)
+ texte += "%{}".format(self.fr)
+ texte += "</ns1:{}>".format(self.nom)
+ else:
+ if self.label == "FACT":
+ texte += "<ns1:{}>".format(self.nom)
+ for c in self.entites.values():
+ texte += c.dumpGitStringFormat()
+ if self.label == "FACT":
+ texte += "</ns1:{}>".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
# 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
# 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
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)
"""
# 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
self.actif = 1
self.makeRegister()
self.icmd = None
- self.userASSDCrees=[]
+ self.userASSDCrees = []
def makeRegister(self):
"""
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)
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:
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
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
# 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)
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
# 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):
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)
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()
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)
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))
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
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()
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)
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)
"""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
# 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
"""
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)
# 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
""" 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
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
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
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
# 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
# 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
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):
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)
"""
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
# 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
# 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
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
# 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
#
# 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é
"""
# 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
# 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:
if not self.parent:
self.id = None
- elif reg == 'oui':
+ elif reg == "oui":
self.id = self.parent.regSD(self)
self.nom = nom
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__)
# 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
"""
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
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 = """
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
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
#
# 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
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 :
"""
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):
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)
# 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()
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 ...')
# erreur
CONTEXT.unsetCurrentStep()
self.afficheFinExec()
- self.traiterFinExec('commande')
+ self.traiterFinExec("commande")
except AsException as e:
# une erreur a ete identifiee
# 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
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
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)
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)
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
# 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
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):
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:
# aux commandes qui sont dans le buffer de la console
import linecache
import code
- console = code.InteractiveConsole(
- self.g_context, filename="<console>")
+
+ console = code.InteractiveConsole(self.g_context, filename="<console>")
linecache.cache["<console>"] = 0, 0, console.buffer, "<console>"
- banner = """***********************************************
+ banner = (
+ """***********************************************
* Interpreteur interactif %s
-***********************************************""" % self.code
+***********************************************"""
+ % self.code
+ )
console.interact(banner)
finally:
console = None
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
# 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:
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:
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()
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):
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)
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()]
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):
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
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
# 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
qui permet de spécifier les caractéristiques d'un JDC
"""
-from __future__ import absolute_import
import types
import traceback
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
# 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:
# 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 += "<ns1:{}>".format(c.nom)
+ texte += c.dumpGitStringFormat()
+ texte += "</ns1:{}>".format(c.nom)
+ texte += "'"
return texte
# -*- 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
# 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
# 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
# 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
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
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:
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()
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
# 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
"""
# 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
class MACRO_ETAPE(N_ETAPE.ETAPE):
- """
+ """ """
- """
nature = "COMMANDE"
typeCO = CO
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
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:
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()
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
# 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
# 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):
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:
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
# 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
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
#
# 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)
# 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)
# 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
# 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:
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
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
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
# 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)
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
# 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
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
# 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
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))
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)
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)
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)
# 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
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
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 = {}
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)
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
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
sauf pour INCLUDE.
"""
if CONTEXT.debug:
- print((' `- MACRO sdAccessible :', self.nom))
+ print((" `- MACRO sdAccessible :", self.nom))
return self.parent.sdAccessible() or not self.isInclude()
# 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
de type ENTITE
"""
-from __future__ import absolute_import
+
import types
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
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 = {}
# 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
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)
# 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
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
# 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()
# 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]
# 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]
# 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)
# 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 = {}
# 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
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:
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:
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)
# 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)
# 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:
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 !!!!!!!
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()
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': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
- <Cata.cata.fonction_sdaster instance at 0x941a204> ],
- 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
+ { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+ <Cata.cata.fonction_sdaster instance at 0x941a204> ],
+ 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
"""
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])
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:
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
# return l
-
def intersection_vide(dict1, dict2):
"""Verification qu'il n'y a pas de clé commune entre 'dict1' et 'dict2'."""
sk1 = set(dict1)
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
# 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
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
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
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
+ )
# 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
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
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
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
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': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
- <Cata.cata.fonction_sdaster instance at 0x941a204> ],
- 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
+ { 'VALE_F': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+ <Cata.cata.fonction_sdaster instance at 0x941a204> ],
+ 'MODELE': [<Cata.cata.modele instance at 0x941550c>] }
"""
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])
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:
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:
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
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 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
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)
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:
return dresu
def longueurDsArbre(self):
- # pour Pyxb : longueur dans le orderedcontent de pyxb
+ # pour Pyxb : longueur dans le orderedcontent de pyxb
return len(self)
# 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
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
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
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.
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,...)
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 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):
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': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
- <Cata.cata.fonction_sdaster instance at 0x941a204> ] }
+ 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': [ <Cata.cata.fonction_sdaster instance at 0x9419854>,
+ <Cata.cata.fonction_sdaster instance at 0x941a204> ] }
"""
l = self.getSd_utilisees()
dico = {}
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
## 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
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
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()
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
# 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
-
# 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
qui permet de spécifier les caractéristiques d'un opérateur
"""
-from __future__ import absolute_import
+
import types
import traceback
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
self.ang = ang
self.repetable = repetable
self.docu = docu
- self.fenetreIhm= fenetreIhm
+ self.fenetreIhm = fenetreIhm
if type(regles) == tuple:
self.regles = regles
else:
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()
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
# 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
#
# 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
macro.set_icmd(1)
return 0
+
EMPTY_OPS = NOTHING(None)
# 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
qui permet de spécifier les caractéristiques d'une procédure
"""
-from __future__ import absolute_import
+
import types
import traceback
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)
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()
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
# 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
"""
# Modules Python
-from __future__ import absolute_import
+
import types
import sys
import traceback
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={}):
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
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))
# 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
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
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)
# -*- 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
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.
"""
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
# -----------------------------------------------------------------------------
- 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
# -----------------------------------------------------------------------------
'.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:
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
# 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
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
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()
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,
+ )
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
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
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)
__repr__ = info
__str__ = info
+
class N_Matrice_Correlation(N_Matrice):
pass
# 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
"""
-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):
def __str__(self):
return self.getName() or "<None>"
-
# 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
# 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
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
# 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
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
from Extensions.i18n import tr
-
class ValError(Exception):
pass
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)
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 = {}
def register(cls, T, A):
cls.registry[T] = A
+
register = classmethod(register)
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:
# 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 = {}
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)
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
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:
# 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 = {}
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
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))
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):
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
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):
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
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:
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:
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=()):
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
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):
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=()):
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
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):
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):
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=()):
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
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):
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):
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 = ""
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):
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):
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")
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):
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):
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
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
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
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=()):
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 = []
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()
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)
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=()):
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])
return chaine
def infoErreurListe(self):
- chaine=""
+ chaine = ""
a = 1
for v in self.validators:
if v.infoErreurListe() != " ":
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)
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:
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:
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
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):
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
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):
self.cata_info = ""
def info(self):
- return _(u"valeur paire")
+ return _("valeur paire")
def infoErreurItem(self):
return tr("La valeur saisie doit etre paire")
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):
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=()):
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:
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:
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):
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):
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):
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):
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:
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:
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):
class VerifTypeTuple(ListVal):
-
def __init__(self, typeDesTuples):
self.typeDesTuples = typeDesTuples
Valid.__init__(self)
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):
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):
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):
self.niveauVerif = niveauVerif
self.MCSimp = None
self.listeDesFreres = ()
- self.fonctions = ('verifieListe', 'set_MCSimp')
+ self.fonctions = ("verifieListe", "set_MCSimp")
def isList(self):
return 1
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
self.MCSimp = MCSimp
k = self.niveauVerif
mc = MCSimp
- while (k != 0):
+ while k != 0:
parent = mc.parent
mc = parent
k = k - 1
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):
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):
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):
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
# 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
#
# 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"):
def copy(self):
import copy
+
c = copy.copy(self)
c.data = self.data.copy()
return c
# 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
"""
# eficas sentinel
-from __future__ import absolute_import
-import six
+
+
try:
import numpy as NP
+
_np_arr = NP.ndarray
except ImportError:
_np_arr = None
def isComplex(obj):
return isinstance(obj, complex)
+
from decimal import Decimal
def isStr(obj):
+ import six
+
return isinstance(obj, (str, six.text_type))
def isASSD(obj):
from .N_ASSD import ASSD
+
return isinstance(obj, ASSD)
sinon retourne [obj,] (en tant que list).
"""
if not isSequence(obj):
- obj = [obj, ]
+ obj = [
+ obj,
+ ]
return list(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)
# 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
"""
# 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
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:
# 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:
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])
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
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]
"""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"""
# 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
#
#
# ======================================================================
-
-
"""
Ce package fournit les classes de base d'EFICAS.
Ces classes permettent d'effectuer quelques operations basiques :
# 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 = ' <I> Only the first {0} occurrences (total: {1}) have been checked.'
-MAXSIZE_MSGKEEP = ' <I> Only the first {0} occurrences (total: {1}) have been printed.'
+MAXSIZE = 500
+MAXSIZE_MSGCHK = " <I> Only the first {0} occurrences (total: {1}) have been checked."
+MAXSIZE_MSGKEEP = " <I> Only the first {0} occurrences (total: {1}) have been printed."
# 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
#
# ======================================================================
-from __future__ import absolute_import
_root = None
_cata = None
-_jdc = None
+_jdc = None
debug = 0
# Le "current step" est l'etape courante.
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:
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
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:
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
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
# 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
"""
# Modules Python
-from __future__ import absolute_import
-try :
- from builtins import str
-except :
- pass
+from builtins import str
import re
import linecache
import sys
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*#.*")
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
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
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
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"""
"""Appel à la fonction de nommage."""
return self.naming_func(*args)
+
getNomConceptResultat = NamingSystem()
# 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
"""
# 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
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
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")
# -*- 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
# -*- 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
#### -*- 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
# -*- 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
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
# -*- 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
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,
+ )
# -*- 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
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
# 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())
# -*- 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
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
# -*- 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
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)
# -*- 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
# 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
# -*- 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
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())
# -*- 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
#
# 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
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
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
# -*- 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
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
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]
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]
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
"""
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
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
"""
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
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]
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]
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]
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]
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]
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)
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]
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)
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()
# -*- 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
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)
# -*- 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
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)
#!/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
#
"""
"""
-usage="""usage: %prog [options]
+usage = """usage: %prog [options]
Typical use is:
python traduitV10V11.py --infile=xxxx --outfile=yyyy
"""
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
#### 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
#### 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
#### 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
#### 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
#### 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
# 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
#### 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
#### 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
#### 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
#### 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
#### 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
# 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
#### 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
#### 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
#### 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
#### 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
#### 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()
#!/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
#
"""
"""
-usage="""usage: %prog [options]
+usage = """usage: %prog [options]
Typical use is:
python traduitV11V12.py --infile=xxxx --outfile=yyyy
"""
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()
#!/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
#
"""
"""
-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()
#!/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
#
"""
"""
-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()
#!/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
#
"""
"""
-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()
# -*- 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
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])
# -*- 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
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)
# 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)
# -*- 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
# 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
#
#
# ======================================================================
+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
# 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
# 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
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)
# 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
#
#
# ======================================================================
-
-
-
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)
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:
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
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
# 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
#
# ======================================================================
+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
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
# 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
#
#
# ======================================================================
-
-
"""
Ce module contient la classe mixin ETAPE qui porte les methodes
necessaires pour realiser la validation d'un objet de type ETAPE
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
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":
# 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:
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
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
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
# 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
#
#
# ======================================================================
+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
# 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
#
#
# ======================================================================
-
-
"""
Ce module contient la classe mixin JDC qui porte les methodes
necessaires pour realiser la validation d'un objet de type JDC
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
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:
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)
# 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
#
#
# ======================================================================
-
-
"""
Ce module contient la classe mixin MACRO_ETAPE qui porte les methodes
necessaires pour realiser la validation d'un objet de type MACRO_ETAPE
Une classe mixin porte principalement des traitements et est
utilisee par heritage multiple pour composer les traitements.
"""
+
# Modules Python
import types
import sys
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
# 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":
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:
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
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
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
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:
# 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
#
#
# ======================================================================
-
-
"""
Ce module contient la classe mixin MCBLOC qui porte les methodes
necessaires pour realiser la validation d'un objet de type MCBLOC
Une classe mixin porte principalement des traitements et est
utilisee par heritage multiple pour composer les traitements.
"""
+
# Modules EFICAS
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
# 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
# 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
#
#
# ======================================================================
-
-
"""
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
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
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
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)
# 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
#
#
# ======================================================================
-
-
"""
Ce module contient la classe mixin MCFACT qui porte les methodes
necessaires pour realiser la validation d'un objet de type MCFACT
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
# 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
# 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
#
#
# ======================================================================
-
-
"""
Ce module contient la classe mixin MCList qui porte les methodes
necessaires pour realiser la validation d'un objet de type MCList
utilisee par heritage multiple pour composer les traitements.
"""
# Modules Python
-
+from builtins import object
import traceback
# Modules EFICAS
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
# 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
# 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
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
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
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 ...
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:
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
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:
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()
# 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
# 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
# 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
#
#
# ======================================================================
+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
# 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
#
#
# ======================================================================
+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
# 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
# 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
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
# 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
#
#
# ======================================================================
+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
# -*- 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
# -*- 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
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
# -*- 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
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)
--- /dev/null
+# -*- 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
# -*- 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
"""
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
# -*- 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
#
"""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)
--- /dev/null
+# -*- 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
# -*- 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
#
"""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
# -*- 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
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)
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
# -*- 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
"""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
# -*- 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
"""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
# -*- 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
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
# -*- 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
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
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))
# 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))
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
--- /dev/null
+# -*- 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)
--- /dev/null
+# 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")
--- /dev/null
+# ----------------------------------
+# 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 <nombre de variables de sortie>
+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 <nb_branches> 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
