from Noyau.N_ASSD import not_checked
from A_VALIDATOR import OrVal,AndVal,OnlyStr
-from A_VALIDATOR import OrdList,NoRepeat,LongStr,Compulsory
+from A_VALIDATOR import OrdList,NoRepeat,LongStr,Compulsory,Absent,Together
from A_VALIDATOR import RangeVal, EnumVal, TypeVal, PairVal
from A_VALIDATOR import CardVal, InstanceVal
from A_VALIDATOR import VerifTypeTuple, VerifExiste
--- /dev/null
+# -*- coding: utf-8 -*-
+# --------------------------------------------------
+# Copyright (C) 2007-2013 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 os
+import sys
+from Accas import *
+import types
+from decimal import Decimal
+# repertoire ou sont stockés le catalogue carmel3d
+# et les fichiers de donnees des materiaux de reference
+from prefs_CARMEL3D import repIni
+
+#print "catalogue carmel"
+#print "repIni = ", repIni
+
+# Version du catalogue
+VERSION_CATA = "Code_Carmel3D 2.4.0 for harmonic problems"
+# --------------------------------------------------
+# definition d une classe pour les materiaux
+# definition d une classe pour les sources
+# definition d une classe pour les groupes de mailles
+# --------------------------------------------------
+class material ( ASSD ) : pass
+class source ( ASSD ) : pass
+class grmaille ( ASSD ) : pass
+class stranded_inductor_geometry ( ASSD ) : pass
+class macro_groupe ( ASSD ) : pass
+
+#CONTEXT.debug = 1
+# --------------------------------------------------
+# déclaration du jeu de commandes : 1ere instruction du catalogue obligatoire
+#---------------------------------------------------
+
+##=========================================================
+JdC = JDC_CATA ( code = 'CARMEL3D',
+ execmodul = None,
+ regles =(
+ AU_MOINS_UN ('PARAMETERS'),
+ AU_PLUS_UN ('PARAMETERS'),
+ AU_MOINS_UN ('SOLVEUR'),
+ AU_PLUS_UN ('SOLVEUR'),
+ AU_MOINS_UN ('POST_COMMANDS'),
+ AU_PLUS_UN ('POST_COMMANDS'),
+ AU_MOINS_UN ('MATERIAL','INCLUDE'),
+ AU_MOINS_UN ('SOURCE','INCLUDE'),
+ AU_MOINS_UN ('MESHGROUP'),
+ ),
+ ) # Fin JDC_CATA
+
+import opsCarmel
+
+#======================================================================
+# 1er bloc : bloc VERSION
+# ce bloc est volontairement cache dans l IHM
+#===================================================
+
+VERSION = PROC ( nom = "VERSION",
+ op = None,
+ repetable = 'n',
+ UIinfo= {"groupes":("CACHE",)},
+ ang= "version block definition",
+
+#----------------------
+# Liste des parametres
+#----------------------
+
+ NUM = SIMP (statut="o",
+ typ="I",
+ defaut=1,
+ ang="version number of the physical model",
+ into=( 1,),
+ ),
+ FILETYPE = SIMP (statut="o",
+ typ="TXM",
+ defaut="PHYS",
+ ang="file type",
+ into=( "PHYS",),
+ ),
+
+) # Fin PROC VERSION
+
+PARAMETERS= PROC ( nom = "PARAMETERS",
+ op = None,
+ repetable = 'n',
+ UIinfo = { "groupes" : ( "1) Parametres", ) },
+ ang= "General parameters for this study",
+ fr= u"Paramètres généraux de l'étude",
+#----------------------
+# Liste des parametres
+#----------------------
+ RepCarmel=SIMP(typ='Repertoire', statut='o',
+ ang= "Code_Carmel3D executables directory",
+ fr= u"Répertoire contenant les programmes de Code_Carmel3D",
+ ),
+ Fichier_maillage = SIMP (statut="o", typ=("FichierNoAbs",'All Files (*)',), # l'existence du fichier n'est pas vérifiée
+ ang="Mesh file path (relative, aka file name, or absolute path).",
+ fr =u"Emplacement du fichier contenant le maillage (relatif, i.e., nom du fichier, ou absolu, i.e., chemin complet).",
+ ),
+
+ Echelle_du_maillage = SIMP (statut='o', typ="TXM", defaut= "Millimetre", into = ("Metre", "Millimetre"),
+ ang="Mesh geometry units.",
+ fr =u"Unités géométriques du maillage.",
+ ),
+
+ Formulation=SIMP(statut='o', typ='TXM', into=("TOMEGA","APHI"),
+ ang="Problem formulation.",
+ fr =u"Formulation du problème.",
+ ),
+
+ FREQUENCY = SIMP (statut="o",
+ typ="R",
+ defaut=50.0,
+ ang = "enter the source frequency value, in Hz units",
+ fr = u"saisir la valeur de la fréquence de la source, en Hz",
+ val_min=0.0,
+ ),
+
+ Realiser_topologie_gendof = SIMP (statut='o', typ="TXM", defaut="TRUE", into=("TRUE", "FALSE"),
+ ang="Build topology (.car file) using gendof.exe.",
+ fr =u"Construction de la topologie (fichier .car) en éxécutant gendof.exe.",
+ ),
+ Resoudre_probleme = SIMP (statut='o', typ="TXM", defaut="TRUE", into=("TRUE", "FALSE"),
+ ang="Solve the problem using fcarmel.exe.",
+ fr =u"Résolution du problème en éxécutant fcarmel.exe.",
+ ),
+
+ Realiser_post_traitement_aposteriori = SIMP (statut='o', typ="TXM", defaut="TRUE", into=("TRUE", "FALSE"),
+ ang="Make post-processing using postprocess.exe.",
+ fr =u"Réalisation du post-traitement en éxécutant postprocess.exe.",
+ ),
+) # Fin PROC PARAMETERS
+
+SOLVEUR = PROC ( nom ="SOLVEUR",
+ op=None,
+ repetable = 'n',
+ UIinfo= {"groupes":("1) Parametres",)},
+ ang= "Solver parameters for this study",
+ fr= u"Paramètres liés au solveur de l'étude",
+
+ Type= SIMP (statut="o",
+ typ="TXM",
+ into=('Solveur_lineaire',),
+ defaut='Solveur_lineaire',
+ ang="Linear solver only for harmonic problems.",
+ fr =u"Solveur linéaire seulement pour les problèmes fréquentiels.",
+ ),
+
+ Solveur_lineaire=BLOC(condition="Type=='Solveur_lineaire'",
+ ang="This block contains whole linear solver properties.",
+ fr =u"Ce bloc contient toutes les propriétés du solveur linéaire.",
+ Methode_lineaire=SIMP(statut='o', typ='TXM', into=("Methode iterative BICGCR", "Methode directe MUMPS"),
+ ang="Algorithm used for this linear solver.",
+ fr =u"Méthode (algorithme) utilisée par ce solveur linéaire.",
+ ),
+
+ Parametres_methode_iterative_BICGCR=BLOC(condition="Methode_lineaire=='Methode iterative BICGCR'",
+ ang="This block contains whole BICGCR algorithm properties used for the linear solver.",
+ fr =u"Ce bloc contient toutes les propriétés de la méthode BICGCR utilisée par le solveur linéaire.",
+ Precision=SIMP(statut='o', typ='R', defaut=1e-9,
+ ang="Accuracy on linear computations.",
+ fr =u"Précision du calcul linéaire.",
+ ),
+ Nombre_iterations_max=SIMP(statut='o', typ='I',defaut=10000,
+ ang="Maximal number of iterations.",
+ fr =u"Nombre maximal d'itérations.",
+ ),
+ Preconditionneur=SIMP(statut='f', typ='TXM', into=("Jacobi"), defaut='Jacobi',
+ ang="Preconditioner choice. Jacobi only.",
+ fr =u"Choix du préconditioneur. Jacobi disponible seulement.",
+ ),
+ ),
+
+ Parametres_methode_directe_MUMPS=BLOC(condition="Methode_lineaire=='Methode directe MUMPS'",
+ ang="This block contains whole MUMPS properties used for the linear solver.",
+ fr =u"Ce bloc contient toutes les propriétés de la méthode MUMPS utilisée par le solveur linéaire.",
+ Type_de_matrice=SIMP(statut='o', typ='I', defaut=2,
+ ang="Matrix type (symetry). 2: symetric. Please refer to MUMPS documentation.",
+ fr =u"Type de matrice (symétrie). Choisir 2 pour une matrice symétrique. Expliqué dans la documentation MUMPS.",
+ ),
+ ICNTL_Control_Parameters=SIMP(statut='o', typ='I', defaut=7,
+ ang="ICNTL control parameter. Please refer to MUMPS documentation.",
+ fr =u"Paramètre de contrôle ICNTL. Expliqué dans la documentation MUMPS.",
+ ),
+ CNTL_Control_Parameters=SIMP(statut='o', typ='I', defaut=5,
+ ang="CNTL control parameter. Please refer to MUMPS documentation.",
+ fr =u"Paramètre de contrôle CNTL. Expliqué dans la documentation MUMPS.",
+ ),
+ ),
+ ),
+ )
+
+POST_COMMANDS = PROC ( nom = "POST_COMMANDS",
+ op = None,
+ repetable = 'n',
+ UIinfo = { "groupes" : ( "1) Parametres", ) },
+ ang= "post-processing commands .cmd or .post file",
+ fr= u"fichiers .cmd ou .post de commandes de post-traitement",
+ # Sous-parties, moins indentées pour améliorer la lisibilité
+ # Grandeurs globales
+ GLOBAL = FACT ( statut="f",
+ ang ="Post-processing of global quantities",
+ fr =u"Post-traitement des grandeurs globales",
+ ),
+ # Carte de tous les champs possibles
+ VISU = FACT ( statut="f",
+ ang ="Post-processing of field maps",
+ fr =u"Post-traitement des cartes de champ",
+ VISU_Format=SIMP(statut='o', typ='TXM', into=("MED", "VTK"), defaut="MED"),
+ VISU_Type=SIMP(statut='o', typ='TXM', into=("ELEMENT", "NOEUD"), defaut="ELEMENT"),
+ ),
+ # Ligne de coupe
+ CUTLINE = FACT ( statut="f",
+ ang = "Post-processing of one cutline",
+ fr = u"Post-traitement d'une ligne de coupe",
+ first_point = SIMP(statut='o', typ='R', min=3, max=3,
+ ang="First point of the cutline (cartesian coordinates).",
+ fr=u"Point de départ (premier point) de la ligne de coupe (coordonnées cartésiennes)."
+ ),
+ last_point = SIMP(statut='o', typ='R', min=3, max=3,
+ ang="Last point of the cutline (cartesian coordinates).",
+ fr=u"Point d'arrivée (dernier point) de la ligne de coupe (coordonnées cartésiennes)."
+ ),
+ number_of_points = SIMP(statut='o', typ='I',
+ ang="Number of points of the cutline.",
+ fr=u"Nombre de points de la ligne de coupe."
+ ),
+ name = SIMP(statut='o', typ='TXM',
+ ang="Name of the cutline, used in the output filename.",
+ fr=u"Nom de la ligne de coupe, utilisé dans le nom du fichier de sortie."
+ ),
+ field = SIMP(statut='o', typ='TXM', into=("H", "B", "J", "E"),
+ ang="Field on which the cutline is applied.",
+ fr=u"Champ pour lequel la ligne de coupe est définie."
+ ),
+ ),
+ # Plan de coupe
+ CUTPLANE = FACT ( statut="f",
+ ang = "Post-processing of one cutplane",
+ fr = u"Post-traitement d'un plan de coupe",
+ normal_vector = SIMP(statut='o', typ='TXM', into=("Ox", "Oy", "Oz"),
+ ang="Cutplane normal vector, i.e., perpendicular axis, 3 possible cartesian values: Ox, Oy, Oz.",
+ fr=u"Vecteur normal au plan de coupe, i.e., son axe perpendiculaire, parmi les 3 valeurs cartésiennes Ox, Oy et Oz."
+ ),
+ plane_position = SIMP(statut='o', typ='R',
+ ang="Cutplane position, i.e., its coordinate along the normal vector axis.",
+ fr=u"Position du plan de coupe, i.e., coordonnée le long de l'axe de vecteur normal."
+ ),
+ number_of_points = SIMP(statut='o', typ='I', min=2, max=2,
+ ang="Number of points on the cutplane, which define a cartesian grid along its canonical directions, e.g., Ox and Oy if plane normal to Oz.",
+ fr=u"Nombre de points sur le plan de coupe dans les deux directions (grille cartésienne), e.g., Ox et Oy si le plan est normal à Oz."
+ ),
+ name = SIMP(statut='o', typ='TXM',
+ ang="Name of the cutplane, used in the output filename.",
+ fr=u"Nom du plan de coupe, utilisé dans le nom du fichier de sortie."
+ ),
+ field = SIMP(statut='o', typ='TXM', into=("H", "B", "J", "E"),
+ ang="Field on which the cutplane is applied.",
+ fr=u"Champ pour lequel le plan de coupe est défini."
+ ),
+ ),
+
+) # Fin PROC POST_COMMANDS
+
+
+#======================================================================
+# le fichier .PHYS contient 3 blocs et jusqu'a 3 niveaux de sous-blocs
+#
+#======================================================================
+
+#===================================================================
+# 2eme bloc : bloc MATERIALS
+#===================================================================
+# definition des matériaux utilisateurs
+# a partir des materiaux de reference ou de materiaux generiques
+#-------------------------------------------------------------------
+
+MATERIAL = OPER (nom = "MATERIAL",
+ op = None,
+ repetable = 'n',
+ UIinfo = { "groupes" : ( "2) Proprietes", ) },
+ ang= "real material block definition",
+ fr= u"définition d'un matériau réel",
+ sd_prod= material,
+ # regles=EXCLUS('PERMITTIVITY','CONDUCTIVITY'),
+
+#---------------------------------------------------------------------
+# liste des matériaux de reference fournis par THEMIS et des
+# materiaux generiques (les materiaux generiques peuvent etre utilises
+# si aucun materiau de reference ne convient)
+#---------------------------------------------------------------------
+ TYPE = SIMP(statut='o',
+ typ='TXM',
+ into=(
+# matériaux génériques
+ "DIELECTRIC",
+ "CONDUCTOR",
+ "ZINSULATOR","ZSURFACIC",
+ "NILMAT","EM_ISOTROPIC","EM_ANISOTROPIC",
+ ),
+ ang = "generic materials list",
+ fr = u"liste des matériaux génériques",
+ ),
+
+##############################################################################
+# Remarque generale a tous les materiaux :
+# pour conserver l'affichage scientifique le nombre derriere l'exposant doit
+# etre strictement superieur au nombre de decimales
+#
+
+##----------------------------------------------------------------------------------------------
+# Données de perméabilité, utilisée pour les diélectriques, conducteurs et impédances de surface
+#-----------------------------------------------------------------------------------------------
+ #HAS_PERMEABILITY = BLOC(condition="TYPE in ('DIELECTRIC','CONDUCTOR','ZSURFACIC')",
+
+#------------------------------------------------
+# sous bloc niveau 2 : PERMEABILITY
+#------------------------------------------------
+#
+ PERMEABILITY_properties = BLOC (condition="TYPE=='DIELECTRIC' or TYPE=='CONDUCTOR'",
+ PERMEABILITY = FACT ( statut="o",
+ ang ="Permeability properties",
+ fr =u"propriétés de perméabilité du matériau",
+ HOMOGENEOUS = SIMP (statut="o",
+ typ="TXM",
+ defaut="TRUE",
+ into = ("TRUE","FALSE"),
+ ang = "the material is homogeneous or not",
+ fr = u"le matériau est homogène ou non",
+ ),
+ ISOTROPIC = SIMP (statut="o",
+ typ="TXM",
+ defaut="TRUE",
+ into = ("TRUE","FALSE"),
+ ang = "the material is isotropic or not",
+ fr = u"le matériau est isotrope ou non",
+ ),
+ HOMOGENEOUS_ISOTROPIC_PROPERTIES = BLOC (condition="HOMOGENEOUS=='TRUE' and ISOTROPIC=='TRUE'",
+ LAW = SIMP (statut="o",
+ typ="TXM",
+ defaut="LINEAR",
+ into = ("LINEAR","NONLINEAR"),
+ ang = "harmonic or time-domain linear or nonlinear law only for homogeneous and isotropic materials",
+ fr = u"loi linéaire (fréquentielle ou temporelle) ou non (homogène et isotrope seulement)",
+ ),
+ VALUE = SIMP (statut="o",
+ typ="C",
+ defaut=1,
+ ang = "Relative linear permeability value, also used at first nonlinear iteration",
+ fr = u"Valeur de la perméabilité relative à l'air utilisée pour une loi linéaire ou pour la première itération non-linéaire",
+ ),
+
+ NONLINEAR_LAW_PROPERTIES = BLOC (condition="LAW=='NONLINEAR'",
+ NATURE = SIMP (statut="o",
+ typ="TXM",
+ defaut="MARROCCO",
+ into = ("SPLINE","MARROCCO","MARROCCO+SATURATION"),
+ ang = "nature law",
+ fr = u"nature de la loi",
+ ),
+ SPLINE_LAW_PROPERTIES = BLOC (condition="NATURE=='SPLINE'",
+ FILENAME = SIMP (statut="o",
+ typ=("FichierNoAbs",'All Files (*)',), # l'existence du fichier n'est pas vérifiée
+ ang="data file name",
+ fr =u"nom du fichier contenant les mesures expérimentales B(H)",
+ ),
+ ), # Fin BLOC SPLINE_PROPERTIES
+ MARROCCO_LAW_PROPERTIES = BLOC (condition="NATURE in ('MARROCCO','MARROCCO+SATURATION')",
+ ALPHA = SIMP (statut="o",
+ typ="R",
+ defaut=0,
+ val_min=0,
+ ang="alpha parameter",
+ fr =u"paramètre alpha de la loi de Marrocco" ,
+ ),
+ TAU = SIMP (statut="o",
+ typ="R",
+ defaut=0,
+ val_min=0,
+ ang="tau parameter",
+ fr =u"paramètre tau de la loi de Marrocco" ,
+ ),
+ C = SIMP (statut="o",
+ typ="R",
+ defaut=0,
+ val_min=0,
+ ang="c parameter",
+ fr =u"paramètre c de la loi de Marrocco" ,
+ ),
+ EPSILON = SIMP (statut="o",
+ typ="R",
+ defaut=0,
+ val_min=0,
+ ang="epsilon parameter",
+ fr =u"paramètre epsilon de la loi de Marrocco" ,
+ ),
+ ), # Fin BLOC MARROCCO_LAW_PROPERTIES
+ SATURATION_LAW_PROPERTIES = BLOC (condition="NATURE=='MARROCCO+SATURATION'",
+ BMAX = SIMP (statut="o",
+ typ="R",
+ defaut=0,
+ val_min=0,
+ ang="intersection B",
+ fr = u"valeur de B marquant la fin de la loi de Marrocco et le début du raccord à la loi de saturation",
+ ),
+ HSAT = SIMP (statut="o",
+ typ="R",
+ defaut=0,
+ val_min=0,
+ ang="H value",
+ fr = u"valeur de H définissant la loi de saturation",
+ ),
+ BSAT = SIMP (statut="o",
+ typ="R",
+ defaut=0,
+ val_min=0,
+ ang="B value",
+ fr = u"valeur de B définissant la loi de saturation",
+ ),
+ JOIN = SIMP (statut="o",
+ typ="TXM",
+ defaut="SPLINE",
+ into= ("SPLINE","PARABOLIC","LINEAR"),
+ ang="type of join between laws",
+ fr =u"type de raccord entre la loi choisie et la loi de saturation" ,
+ ),
+ ), # Fin BLOC SATURATION_LAW_PROPERTIES
+ APPLIEDTO = SIMP (statut="o",
+ typ="TXM",
+ into=("B(H)&H(B)","B(H)","H(B)"),
+ defaut="B(H)&H(B)",
+ ang="join applied to",
+ fr =u"Le raccord tel que défini est appliqué à la courbe B(H) seulement, à la courbe H(B) seulement ou aux deux courbes à la fois. Dans les deux premiers cas, le raccord de la courbe H(B) est inversé numériquement à partir du raccord défini pour la courbe B(H), et vice-versa.",
+ ),
+ ), # Fin BLOC NONLINEAR_LAW_PROPERTIES
+ ), # Fin BLOC HOMOGENEOUS_ISOTROPIC_PROPERTIES
+ ),
+ ),# fin FACT PERMEABILITY
+
+
+##----------------------------------------------------------------------------------------------
+# Données de conductivité, utilisée pour les conducteurs et impédances de surface
+#-----------------------------------------------------------------------------------------------
+ #HAS_CONDUCTIVITY = BLOC(condition="TYPE in ('CONDUCTOR','ZSURFACIC')",
+#------------------------------------------------
+# sous bloc niveau 2 : CONDUCTIVITY
+#------------------------------------------------
+
+ CONDUCTIVITY_properties= BLOC (condition="TYPE=='CONDUCTOR'",
+ CONDUCTIVITY = FACT ( statut="o",
+ ang ="Permittivity properties",
+ fr = u"propriétés de permittivité du matériau",
+ HOMOGENEOUS = SIMP (statut="o",
+ typ="TXM",
+ defaut="TRUE",
+ into = ("TRUE","FALSE"),
+ ang = "the material is homogeneous or not",
+ fr = u"le matériau est homogène ou non",
+ ),
+ ISOTROPIC = SIMP (statut="o",
+ typ="TXM",
+ defaut="TRUE",
+ into = ("TRUE","FALSE"),
+ ang = "the material is isotropic or not",
+ fr = u"le matériau est isotrope ou non",
+ ),
+ HOMOGENEOUS_ISOTROPIC_PROPERTIES = BLOC (condition="HOMOGENEOUS=='TRUE' and ISOTROPIC=='TRUE'",
+ LAW = SIMP (statut="o",
+ typ="TXM",
+ defaut="LINEAR",
+ into = ("LINEAR",),
+ ang = "linear law",
+ fr = u"loi linéaire",
+ ),
+ VALUE = SIMP (statut="o",
+ typ="C",
+ defaut=1,
+ ang = "enter a complex relative value",
+ fr = u"saisir une valeur complexe relative",
+ ),
+ ), # Fin BLOC HOMOGENEOUS_ISOTROPIC_PROPERTIES
+ ),
+
+ ),
+
+
+ # fin FACT CONDUCTIVITY
+
+
+
+###################################################################################################
+#---------------------------------------------
+# sous bloc niveau 1
+#---------------------------------------
+# matériau generique de type ZINSULATOR
+#---------------------------------------
+
+# aucun parametre a saisir pour ce materiau
+
+
+###################################################################################################
+#---------------------------------------------
+# sous bloc niveau 1
+#---------------------------------------------
+# matériau generique de type NILMAT (fictif)
+#---------------------------------------------
+
+# aucun parametre a saisir pour ce materiau
+
+
+###################################################################################################
+#----------------------------------------------------------
+# sous bloc niveau 1 : EM_ISOTROPIC_FILES
+#-------------------------------------------------
+# matériau isotropique non homogene generique
+#-------------------------------------------------
+ EM_ISOTROPIC_properties=BLOC(condition="TYPE=='EM_ISOTROPIC'",
+ regles =(
+ AU_MOINS_UN ('CONDUCTIVITY_File','PERMEABILITY_File'),
+ ),
+ CONDUCTIVITY_File = SIMP (statut="f",
+ typ=("FichierNoAbs",'MED Files (*.med)',),
+ ang="CONDUCTIVITY MED data file name",
+ fr = u"nom du fichier MED CONDUCTIVITY",
+ ),
+ PERMEABILITY_File = SIMP (statut="f",
+ typ=("FichierNoAbs",'MED Files (*.med)',),
+ ang="PERMEABILITY MED data file name",
+ fr = u"nom du fichier MED PERMEABILITY",
+ ),
+ ), # fin bloc EM_ISOTROPIC_properties
+
+
+#---------------------------------------------------
+# matériau anisotropique non homogene generique
+#---------------------------------------------------
+ EM_ANISOTROPIC_properties=BLOC(condition="TYPE=='EM_ANISOTROPIC'",
+ regles =(
+ AU_MOINS_UN ('CONDUCTIVITY_File','PERMEABILITY_File'),
+ ),
+ PERMEABILITY_File = SIMP (statut="f",
+ #typ=("Fichier",'.mater Files (*.mater)'), # le fichier doit exister dans le répertoire d'où on lancer Eficas si le fichier est défini par un nom relatif, ce qui est trop contraignant
+ #typ=("Fichier",'.mater Files (*.mater)','Sauvegarde'), # Le fichier peut ne pas exister, mais on propose de le sauvegarder et d'écraser un fichier existant : pas approprié
+ typ=("FichierNoAbs",'.mater Files (*.mater)'), # l'existence du fichier n'est pas vérifiée, mais on peut le sélectionner quand même via la navigateur. C'est suffisant et permet une bibliothèque de matériaux.
+ ang="PERMEABILITY .mater data file name",
+ fr ="nom du fichier .mater PERMEABILITY",
+ ),
+ CONDUCTIVITY_File = SIMP (statut="f",
+ typ=("FichierNoAbs",'.mater Files (*.mater)'),
+ ang="CONDUCTIVITY .mater data file name",
+ fr ="nom du fichier .mater CONDUCTIVITY",
+ ),
+ ), # fin bloc EM_ANISOTROPIC_properties
+
+
+#------------------------------------------------------------------
+# Données de permittivité, utilisée pour les diélectriques seulement
+#-------------------------------------------------------------------
+ #HAS_PERMITTIVITY = BLOC(condition="TYPE == 'DIELECTRIC'",
+
+#------------------------------------------------
+# sous bloc niveau 2 : PERMITTIVITY
+#------------------------------------------------
+
+ Utiliser_la_permittivite = SIMP (statut='o',
+ typ='TXM',
+ into = ("OUI","NON"),
+ defaut="NON",
+ ang ="Optionnaly use permittivity or not (default)",
+ fr = u"Utilisation optionnelle de la permittivité du matériau. Pas d'utilisation par défaut.",
+ ),
+ PERMITTIVITY_properties = BLOC (condition="Utiliser_la_permittivite=='OUI'",
+ PERMITTIVITY = FACT ( statut="o",
+ ang ="Permittivity properties",
+ fr = u"propriétés de permittivité du matériau",
+ HOMOGENEOUS = SIMP (statut="o",
+ typ="TXM",
+ defaut="TRUE",
+ into = ("TRUE","FALSE"),
+ ang = "the material is homogeneous or not",
+ fr = u"le matériau est homogène ou non",
+ ),
+ ISOTROPIC = SIMP (statut="o",
+ typ="TXM",
+ defaut="TRUE",
+ into = ("TRUE","FALSE"),
+ ang = "the material is isotropic or not",
+ fr = u"le matériau est isotrope ou non",
+ ),
+ HOMOGENEOUS_ISOTROPIC_PROPERTIES = BLOC (condition="HOMOGENEOUS=='TRUE' and ISOTROPIC=='TRUE'",
+ LAW = SIMP (statut="o",
+ typ="TXM",
+ defaut="LINEAR",
+ into = ("LINEAR",),
+ ang = "linear law",
+ fr = u"loi linéaire",
+ ),
+ VALUE = SIMP (statut="o",
+ typ="C",
+ defaut=1,
+ ang = "enter a complex relative value",
+ fr = u"saisir une valeur complexe relative",
+ ),
+ ), # Fin BLOC HOMOGENEOUS_ISOTROPIC_PROPERTIES
+ ),
+ ),# fin FACT PERMITTIVITY
+
+ ) # fin OPER MATERIAL
+
+
+
+##############################################################################
+# Remarque generale a tous les materiaux :
+# pour conserver l'affichage scientifique le nombre derriere l'exposant doit
+# etre strictement superieur au nombre de decimales
+
+
+#===================================================================
+# 3eme bloc : bloc SOURCES
+#====================================================================
+# definition des differentes sources qui seront dans le bloc SOURCES
+#-------------------------------------------------------------------
+
+
+
+SOURCE = OPER ( nom = "SOURCE",
+ op = None,
+ repetable = 'n',
+ UIinfo = { "groupes" : ( "2) Proprietes", ) },
+ ang = "source definition",
+ fr = u"définition d'une source",
+ sd_prod = source,
+# regles = (UN_PARMI('STRANDED_INDUCTOR','HPORT','EPORT'), # choix d'un type de source
+# UN_PARMI('WAVEFORM_CONSTANT','WAVEFORM_SINUS'), # choix d'une forme de source
+
+
+#----------------------------------------------------------
+# sous bloc niveau 1 : stranded inductor source
+##---------------------------------------------------------
+ Type=SIMP(statut='o',
+ typ='TXM',
+ into=("STRANDED_INDUCTOR", "HPORT", "EPORT"),
+ ang = "Source type",
+ fr = u"Type de source",
+ ),
+
+ STRANDED_INDUCTOR_properties = BLOC (condition="Type=='STRANDED_INDUCTOR'",
+ STRANDED_INDUCTOR = FACT(statut='o',
+ ang="Stranded inductor source",
+ fr=u"source de type inducteur bobiné",
+ NTURNS = SIMP (statut="o",
+ typ="I",
+ defaut=1,
+ ang="number of turns in the inductor",
+ fr= u"nombre de tours dans l'inducteur bobiné",
+ ),
+ TYPE = SIMP (statut="o",
+ typ="TXM",
+ defaut="CURRENT",
+ into=("CURRENT",),
+ fr= u"source de type courant",
+ ang="current source type",
+ ),
+ ),
+ ),# FIN de FACT STRANDED_INDUCTOR
+ HPORT_properties = BLOC (condition="Type=='HPORT'",
+ HPORT = FACT(statut='o',
+ ang="Magnetic port source",
+ fr=u"source de type port magnétique",
+ TYPE = SIMP (statut="o",
+ typ="TXM",
+ into=("VOLTAGE","CURRENT"),
+ fr= u"source de type tension ou courant",
+ ang="voltage or current source type",
+ ),
+ ),
+ ),# FIN de FACT HPORT
+ EPORT_properties = BLOC (condition="Type=='EPORT'",
+ EPORT = FACT(statut='o',
+ ang="Electric port source",
+ fr=u"source de type port électrique",
+ TYPE = SIMP (statut="o",
+ typ="TXM",
+ into=("VOLTAGE","CURRENT"),
+ fr= u"source de type tension ou courant",
+ ang="voltage or current source type",
+ ),
+ ),
+ ),# FIN de FACT EPORT
+
+ Signal=SIMP(statut='o',
+ typ='TXM',
+ into=("WAVEFORM_CONSTANT", "WAVEFORM_SINUS"),
+ ang = "Signal type, i.e., source evolution shape",
+ fr = u"Type de signal, i.e., forme de la source",
+ ),
+ WAVEFORM_CONSTANT_properties = BLOC (condition="Signal=='WAVEFORM_CONSTANT'",
+ WAVEFORM_CONSTANT = FACT(statut='o',
+ ang="constant source",
+ fr=u"source constante",
+ AMPLITUDE = SIMP (statut="o",
+ typ="R",
+ defaut=1,
+ ang = "enter the source magnitude value, in A or V units",
+ fr = u"saisir la valeur de l'amplitude de la source, en unités A ou V",
+ ),
+ ),
+ ),# FIN de FACT WAVEFORM_CONSTANT
+
+ WAVEFORM_SINUS_properties = BLOC (condition="Signal=='WAVEFORM_SINUS'",
+ WAVEFORM_SINUS = FACT(statut='o',
+ ang="sinus variation source",
+ fr=u"source variant avec une forme sinusoïdale, définie par son amplitude, sa fréquence et sa phase",
+ AMPLITUDE = SIMP (statut="o",
+ typ="R",
+ defaut=1,
+ ang = "enter the source magnitude value, in A or V units",
+ fr = u"saisir la valeur de l'amplitude de la source, en unités A ou V",
+ ),
+ FREQUENCY = SIMP (statut="o",
+ typ="R",
+ defaut=0.0,
+ ang = "enter the source frequency value, in Hz units",
+ fr = u"saisir la valeur de la fréquence de la source, en Hz",
+ ),
+ PHASE = SIMP (statut="o",
+ typ="R",
+ defaut=0.0,
+ ang = "enter the source phase value, in degrees units",
+ fr = u"saisir la valeur de la phase de la source, en degrés",
+ ),
+ ),
+ ),# FIN de FACT WAVEFORM_SINUS
+
+
+)# Fin OPER SOURCE
+
+
+STRANDED_INDUCTOR_GEOMETRY=OPER(nom="STRANDED_INDUCTOR_GEOMETRY",
+ op=None,
+ repetable = 'n',
+ sd_prod=stranded_inductor_geometry,
+ UIinfo = { "groupes" : ( "2) Proprietes", ) },
+ ang = "Geometry properties (shape, direction, etc.) for this stranded inductor",
+ fr = u"Propriétés géométriques de cet inducteur bobiné, e.g., forme, direction, sens",
+
+ Forme=SIMP(statut='o', typ="TXM", into=("Droit", "Circulaire"),
+ ang = "Stranded inductor shape. Straight or circular.",
+ fr = u"Forme de l'inducteur bobiné (complet ou morceau) : droit ou circulaire.",
+ ),
+ Propriete= BLOC (condition="Forme=='Circulaire'",
+ Centre=SIMP(statut='o',typ='R',min=3,max=3,
+ ang = "Circular stranded inductor rotation center (cartesian coordinates).",
+ fr = u"Centre de rotation, en coordonnées cartésiennes, de l'inducteur bobiné (complet ou morceau) circulaire.",
+ ),
+ ),
+ Direction=SIMP(statut='o',typ='R',min=3,max=3,
+ ang = "Stranded inductor direction (or rotation) axis for the straight (circular) inductor (cartesian coordinates).",
+ fr = u"Axe indiquant la direction de l'inducteur bobiné droit, ou l'axe de rotation (support : Centre) de l'inducteur circulaire, en coordonnées cartésiennes.",
+ ),
+ Section=SIMP(statut='o', typ='R',
+ ang = "Stranded inductor section (m^2).",
+ fr = u"Section de l'inducteur bobiné, en m^2.",
+ ),
+)
+
+#=========================================================
+# création d'une macro pour traiter les INCLUDE
+#
+#----------------------------------------------------------
+
+INCLUDE = MACRO ( nom = "INCLUDE",
+ op = None,
+ UIinfo = { "groupes" : ( "3) Bibliotheque", ) },
+ sd_prod = opsCarmel.INCLUDE,
+ op_init = opsCarmel.INCLUDE_context,
+ fichier_ini = 1,
+ ang = "Used in order to add external material, source, etc. libraries to the study.",
+ fr = u"Permet d'utiliser des bibliothèques de matériaux, sources, etc., dans l'étude.",
+
+ FileName = SIMP ( statut = "o",
+ typ = ('Fichier', 'comm Files (*.comm);;All Files (*)',),
+ fr = u"Emplacement du fichier (chemin absolu ou relatif) contenant la bibliothèque des matériaux, etc.",
+ ang = "material library file (full or relative path)",
+ ),
+
+ ) # Fin MACRO
+
+MESHGROUP = OPER (nom = "MESHGROUP",
+ op = None,
+ repetable = 'n',
+ UIinfo= {"groupes":("4) Maillage",)},
+ fr= u"attribution d'un matériau ou d'une source à un groupe du maillage",
+ ang = "mesh group association to material or source",
+ sd_prod= grmaille,
+ regles =(
+ EXCLUS ('MATERIAL','SOURCE'),
+ ),
+
+# ----------------------------------------------------------
+# le mot cle SIMP doit etre facultatif sinon la recuperation
+# des groupes de mailles sous SALOME ne fonctionne pas car
+# le concept ne peut pas etre nomme car non valide
+#-----------------------------------------------------------
+ Domaine = SIMP (statut="f",
+ typ=(grmaille, 'TXM'),
+ defaut="default",
+ ang="Domain used with stranded inductors or topological holes.",
+ fr =u"Domaine utilisé par les inducteurs bobinés ou les trous topologiques.",
+ ),
+
+ MATERIAL = SIMP (statut="f",
+ typ=(material),
+ ang="name of the linked real or imaginary material",
+ fr =u"nom du matériau réel ou imaginaire associé",
+ ),
+ SOURCE = SIMP (statut="f",
+ typ=(source,),
+ ang="name of the linked source",
+ fr =u"nom de la source associée",
+ ),
+ STRANDED_INDUCTOR_GEOMETRY = SIMP ( statut="f",
+ typ=(stranded_inductor_geometry),
+ ang="name of the linked stranded inductor geometry",
+ fr =u"nom de la géométrie d'inducteur bobiné associée",
+ )
+ )
+
+# --------------------------------------------------
+# definition de macro-groupe de mailles
+# il est associe a un materiau, source ou inducteur bobiné en morceaux
+#---------------------------------------------------
+
+MACRO_GROUPE = OPER (nom="MACRO_GROUPE",
+ op=None,
+ repetable='n',
+ sd_prod=macro_groupe,
+ UIinfo = { "groupes" : ( "4) Maillage", ) },
+ fr=u"Macro-groupe = liste de groupes de maillage, e.g., inducteur bobiné en morceaux.",
+ ang=u"Macro-groupe = liste of mesh groups, e.g., stranded inductor defined as several parts.",
+ regles =(
+ EXCLUS ('MATERIAL','SOURCE'),
+ ),
+ Domaine = SIMP (statut='f',
+ typ=(grmaille, 'TXM'),
+ defaut="default",
+ ang="Domain used with stranded inductors or topological holes.",
+ fr =u"Domaine utilisé par les inducteurs bobinés ou les trous topologiques.",
+ ),
+
+ MATERIAL = SIMP (statut="f",
+ typ=(material,),
+ ang="name of the linked real or imaginary material",
+ fr =u"nom du matériau réel ou imaginaire associé",
+ ),
+ SOURCE = SIMP (statut="f",
+ typ=(source,),
+ ang="name of the linked source",
+ fr =u"nom de la source associée",
+ ),
+ LISTE_MESHGROUP=SIMP(statut='f',# facultatif pour l'acquisition automatique des groupes du maillage
+ typ=(grmaille,),
+ min=1,max=100,
+ ang="Ordered list of associated mesh groups, e.g., stranded inductor parts or topological hole parts.",
+ fr =u"Liste ordonnée de groupes de maillage associés entre eux, e.g., morceaux d'un inducteur bobiné ou d'un trou topologique.",
+ ),
+) # Fin OPER
If no locale is specified by the user, the system locale
is used instead, for both Qt base and Eficas translators.
"""
- from PyQt4.QtCore import QLibraryInfo, QTextCodec
-
- #QTextCodec.setCodecForTr(QTextCodec.codecForName("utf-8"))
-
+ from PyQt4.QtCore import QLibraryInfo
from PyQt4.QtCore import QLocale
from PyQt4.QtGui import QApplication
sys_locale = QLocale.system().name()
Remplace la valeur de self par new_valeur interprétée
"""
self.valeur = self.interprete_valeur(new_valeur)
+ self.val=repr(self.valeur)
self.parent.update_concept_after_etape(self,self)
self.init_modif()
else:
raise EficasException("ValueError: i18n.translation.tr_qt: \
Improper formatted string parameter set")
+# print r
return unicode(r)
# enregistre dans le jdc (pas ajoute dans jdc.etapes)
parent=self.parent
pos=self.parent.etapes.index(self)
+ # on ajoute une fin à la commande pour pouvoir en commenter 2
+ texte_commande+='\nFin Commentaire'
commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
reg='non',
parent=parent)
ou leve une exception
--> utilisee par ops.POURSUITE et INCLUDE
"""
- print "get_contexte_jdc",self,self.nom
+ #print "get_contexte_jdc",self,self.nom
# On recupere l'etape courante
step=CONTEXT.get_current_step()
try:
# Erreurs dans l'INCLUDE. On garde la memoire du fichier
# mais on n'insere pas les concepts
# On retablit l'etape courante step
- print j.cr
+ #print j.cr
#print j.isvalid()
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
Ajoute un parametre a l'interieur du JDC :
"""
self.editor.init_modif()
- if after:
- pos = 'after'
- else:
- pos = 'before'
- return self.append_brother( PARAMETERS, pos )
+ if after: pos = 'after'
+ else: pos = 'before'
+ child=self.append_brother( PARAMETERS, pos )
+ return child
def select( self ):
typeNode.PopUpMenuRacine.createPopUpMenu(self)
def addParameters(self,apres):
- self.append_child("PARAMETRE",pos=0)
+ param=self.append_child("PARAMETRE",pos=0)
+ return param
+
class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
import compooper
import browser
import typeNode
+from PyQt4.QtGui import QAction
+from PyQt4.QtCore import Qt, SIGNAL, QVariant
class MACRONode(browser.JDCNode,typeNode.PopUpMenuNode):
from monMacroPanel import MonMacroPanel
return MonMacroPanel (self,parent=self.editor )
- def getPanel2(self):
- from monWidgetCommande import MonWidgetCommande
- return MonWidgetCommande(self,self.editor,self.item.object)
-
def createPopUpMenu(self):
typeNode.PopUpMenuNode.createPopUpMenu(self)
+ if ("AFFE_CARA_ELEM" in self.item.get_genealogie()) and self.editor.salome:
+ self.ViewElt = QAction(tr('View3D'),self.tree)
+ self.tree.connect(self.ViewElt,SIGNAL("activated()"),self.view3D)
+ self.ViewElt.setStatusTip(tr("affiche dans Geom les elements de structure"))
+ self.menu.addAction(self.ViewElt)
+ if self.item.isvalid() :
+ self.ViewElt.setEnabled(1)
+ else:
+ self.ViewElt.setEnabled(0)
+
+ def view3D(self) :
+ from Editeur import TroisDPal
+ troisD=TroisDPal.TroisDPilote(self.item,self.editor.appliEficas)
+ troisD.envoievisu()
+
#def doPaste(self,node_selected):
# print 'je suis la'
def getPanel2(self):
"""
"""
- from monParamPanel import MonParamPanel
- return MonParamPanel(self, parent=self.editor )
+ from monWidgetParam import MonWidgetParam
+ return MonWidgetParam(self, self.editor,self.item.object)
def createPopUpMenu(self):
typeNode.PopUpMenuNodePartiel.createPopUpMenu(self)
# Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
if maDefinition.max == 1 :
- # Listes de valeur discretes
if maDefinition.into != [] and maDefinition.into != None:
if len(maDefinition.into) < 4 :
from monWidgetRadioButton import MonWidgetRadioButton
elif self.item.wait_co():
if len(self.item.get_sd_avant_du_bon_type()) == 0 :
- from monWidgetSDCO import MonWidgetSDCO
- widget=MonWidgetSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ from monWidgetUniqueSDCO import MonWidgetUniqueSDCO
+ widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
else :
from monWidgetSDCOInto import MonWidgetSDCOInto
widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
from Editeur import Objecttreeitem
from desBaseWidget import Ui_baseWidget
from monViewTexte import ViewText
-from monWidgetParam import MonWidgetParam
+from monWidgetCreeParam import MonWidgetCreeParam
import browser
import readercata
#-----------------------#
def gestionParam(self):
#-----------------------#
- w = MonWidgetParam( self)
+ w = MonWidgetCreeParam( self)
w.show()
#-----------------------#
#---------------------------#
def _newTELEMAC(self):
#---------------------------#
- #texte="INITIALIZATION();INITIAL_STATE();BOUNDARY_CONDITIONS();NUMERICAL_PARAMETERS();PHYSICAL_PARAMETERS()"
- texte=""
+ texte="INITIALIZATION();INITIAL_STATE();BOUNDARY_CONDITIONS();NUMERICAL_PARAMETERS();PHYSICAL_PARAMETERS()"
+ #texte=""
return texte
#---------------------------#
#print " c est le moment de gerer le passage au suivant"
if not(hasattr (self,'RBValide')) : return
icon = QIcon()
+ repIcon=os.path.join(os.path.abspath(os.path.dirname(__file__)),'../Editeur/icons')
if self.node.item.object.isvalid() :
- icon=QIcon(self.repIcon+"/ast-green-ball.png")
+ icon=QIcon(repIcon+"/ast-green-ball.png")
else :
- icon=QIcon(self.repIcon+"/ast-red-ball.png")
+ icon=QIcon(repIcon+"/ast-red-ball.png")
self.RBValide.setIcon(icon)
# il faut chercher la bonne fenetre
def rendVisible(self):
- print "je passe par rendVisible de FacultatifOuOptionnel"
- print self
- print self.node.fenetre
- print "return pour etre sure"
+ #print "je passe par rendVisible de FacultatifOuOptionnel"
+ #print self
+ #print self.node.fenetre
+ #print "return pour etre sure"
return
#PNPN
newNode=self.node.treeParent.chercheNoeudCorrespondant(self.node.item.object)
- print newNode
+ #print newNode
self.editor.fenetreCentraleAffichee.scrollAreaCommandes.ensureWidgetVisible(newNode.fenetre)
#newNode.fenetre.setFocus()
if version == "V10V11" :
from Traducteur import traduitV10V11
suffixe="v11.comm"
+ if version == "V11V12" :
+ from Traducteur import traduitV11V12
+ suffixe="v12.comm"
fn = QFileDialog.getOpenFileName(
editor.appliEficas,
qApp.setOverrideCursor(QCursor(Qt.WaitCursor))
if version == "V9V10" : traduitV9V10.traduc(FichieraTraduire,FichierTraduit,log)
if version == "V10V11" : traduitV10V11.traduc(FichieraTraduire,FichierTraduit,log)
+ if version == "V11V12" : traduitV11V12.traduc(FichieraTraduire,FichierTraduit,log)
qApp.setOverrideCursor(QCursor(Qt.ArrowCursor))
Entete=tr("Fichier Traduit : %s\n\n",str(FichierTraduit))
maPolice= QFont("Times", 10,)
self.setFont(maPolice)
- self.repIcon=self.appliEficas.repIcon
self.labelNomCommande.setText(tr(self.obj.nom))
self.commandesLayout.addStretch()
def donnePremier(self):
#print "dans donnePremier"
qApp.processEvents()
- self.listeAffichageWidget[0].setFocus(7)
- #print self.listeAffichageWidget
+ if self.listeAffichageWidget != [] :
+ self.listeAffichageWidget[0].setFocus(7)
qApp.processEvents()
#print self.focusWidget()
-# -*- coding: utf-8 -*-
# Copyright (C) 2007-2013 EDF R&D
#
# This library is free software; you can redistribute it and/or
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
# Modules Python
-import string,types,os,re
-
# Modules Eficas
-from PyQt4 import *
+from desWidgetParam import Ui_WidgetParam
+from gereIcones import FacultatifOuOptionnel
from PyQt4.QtGui import *
from PyQt4.QtCore import *
from Extensions.i18n import tr
-from desWidgetParam import Ui_desWidgetParam
+from Extensions.eficas_exception import EficasException
+import Accas
+import os, re
+import string
+import types
+
+pattern_name = re.compile(r'^[^\d\W]\w*\Z')
+
+# Import des panels
-class MonWidgetParam(Ui_desWidgetParam,QDialog):
+class MonWidgetParam(QWidget,Ui_WidgetParam,FacultatifOuOptionnel):
"""
"""
- def __init__(self,editor, name = None,fl = 0):
- self.editor=editor
- QDialog.__init__(self,editor)
- self.setupUi(self)
- self.connecterSignaux()
- self.dejaExistant=0
- self.listeTousParam=self.editor.jdc.params
- self.dictListe={}
- self.initToutesVal()
-
- def connecterSignaux(self) :
- self.connect(self.lineEditVal,SIGNAL("returnPressed()"),self.lineEditValReturnPressed)
- self.connect(self.lineEditNom,SIGNAL("returnPressed()"),self.lineEditNomReturnPressed)
-
-
- def CreeParametre(self):
- nom=str(self.lineEditNom.text())
- val=str(self.lineEditVal.text())
- if val == "" or None : return
- if nom == "" or None : return
- print self.editor.tree
- if len(self.editor.tree.selectedItems()) == 0 :
- itemAvant=self.editor.tree.racine
- param=itemAvant.addParameters(True)
- else :
- itemAvant=self.editor.tree.selectedItems()[0]
- param=itemAvant.addParameters(False)
- param.item.set_nom(nom)
- param.item.set_valeur(val)
- param.update_node_texte()
-
-
- def lineEditValReturnPressed(self):
- qtVal=self.lineEditVal.text()
+ def __init__(self,node,editor,commentaire):
+ QWidget.__init__(self,None)
+ self.node=node
+ self.node.fenetre=self
+ self.setupUi(self)
+ self.editor=editor
+ self.setIconePoubelle()
+ self.remplit()
+ if self.editor.code in ['MAP','CARMELCND'] : self.bCatalogue.close()
+ else : self.connect(self.bCatalogue,SIGNAL("clicked()"), self.afficheCatalogue)
+ self.connect(self.lineEditVal,SIGNAL("returnPressed()"),self.LEValeurPressed)
+ self.connect(self.lineEditNom,SIGNAL("returnPressed()"),self.LENomPressed)
+ self.connect(self.bAvant,SIGNAL("clicked()"), self.afficheAvant)
+ self.connect(self.bApres,SIGNAL("clicked()"), self.afficheApres)
+ self.connect(self.bVerifie,SIGNAL("clicked()"), self.verifiePressed)
+ self.editor.affiche_infos("")
+
+
+
+ def afficheCatalogue(self):
+ self.node.tree.racine.affichePanneau()
+ if self.node : self.node.select()
+ else : self.node.tree.racine.select()
+
+ def remplit(self):
+ nom=self.node.item.get_nom()
+ self.lineEditNom.setText(nom)
+
+ valeur=self.node.item.get_valeur()
+ if valeur == None :
+ self.lineEditVal.clear()
+ elif type(valeur) == types.ListType :
+ texte="["
+ for l in valeur :
+ texte=texte+str(l) +","
+ texte=texte[0:-1]+"]"
+ self.lineEditVal.setText(texte)
+ else :
+ self.lineEditVal.setText(str(valeur))
+
+
+ def donnePremier(self):
+ self.lineEditVal.setFocus(7)
+
+ def LEValeurPressed(self):
+ if self.verifiePressed() == False :
+ QMessageBox.warning( self,tr( "Modification Impossible"),tr( "le parametre n'est pas valide"))
+ nom=str(self.lineEditNom.text())
+ val=str(self.lineEditVal.text())
+ self.node.item.set_nom(nom)
+ self.node.item.set_valeur(val)
+ self.node.update_texte()
+ self.node.update_node_valid()
+
+ def LENomPressed(self):
+ self.LEValeurPressed()
+
+ def verifiePressed(self):
+ nomString=str(self.lineEditNom.text())
+ if not pattern_name.match(nomString) :
+ self.LECommentaire.setText(nomString + tr(" n est pas un identifiant correct"))
+ return False
+
valString=str(self.lineEditVal.text())
+
contexte={}
exec "from math import *" in contexte
- jdc=self.editor.jdc
- if jdc == None :
- self.editor.affiche_infos(tr("La Creation de parametre n est possible que dans un jeu de données"),Qt.red)
- return
-
+ jdc=self.node.item.get_jdc()
for p in jdc.params :
try:
- tp=p.nom+'='+str(p.val)
+ tp=p.nom+'='+str(repr(p.valeur))
exec tp in contexte
- except :
+ except exc :
pass
- monTexte="monParam="+valString
+
+ monTexte=nomString+"="+valString
try :
exec monTexte in contexte
+ except (ValueError,TypeError, NameError,RuntimeError,ZeroDivisionError), exc:
+ self.LECommentaire.setText(tr("Valeur incorrecte: ")+unicode (exc))
+ return False
except :
- self.editor.affiche_infos(tr("Valeur incorrecte"),Qt.red)
- if self.lineEditNom.text()!="" and self.dejaExistant==False : self.CreeParametre()
-
-
- def lineEditNomReturnPressed(self):
- qtNom=self.lineEditNom.text()
- nom=str(qtNom)
- numDebutPattern=re.compile('[a-zA-Z"_"]')
- if not (numDebutPattern.match(nom)) :
- commentaire=tr("Les noms de parametre doivent commencer par une lettre ou un souligne")
- self.lineEditNom.setText("")
- self.editor.affiche_infos(commentaire,Qt.red)
- if self.lineEditVal.text()!="" : self.CreeParametre()
- self.lineEditVal.setFocus(Qt.OtherFocusReason)
-
-
- def initToutesVal(self):
- self.LBParam.clear()
- for param in self.listeTousParam :
- self.LBParam.addItem(QString(repr(param)))
- self.dictListe[QString(repr(param))] = param
-
- def valideParam(self):
- if self.LBParam.selectedItems()== None : return
- lParam=[]
- for indice in range(len(self.LBParam.selectedItems())):
- i=self.LBParam.selectedItems()[indice].text()
- param=self.dictListe[i]
- lParam.append(param)
+ self.LECommentaire.setText(tr("Valeur incorrecte "))
+ return False
+
+ self.LECommentaire.setText(tr("Valeur correcte "))
+ return True
+
+ def afficheApres(self):
+ self.node.selectApres()
+
+ def afficheAvant(self):
+ self.node.selectAvant()
- try :
- self.panel.AjoutNValeur(lParam)
- except :
- for p in lParam :
- self.panel.Ajout1Valeur(p)
- self.close()
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
Feuille.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
+ print "MonWidgetSimpBase", nom
self.parentQt.commandesLayout.insertWidget(-1,self)
self.setFocusPolicy(Qt.StrongFocus)
self.connect(self.lineEditVal,SIGNAL("returnPressed()"),self.LEValeurPressed)
# c est juste la taille des differents widgets de base qui change
def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
+ print "MonWidgetSimpTxt", nom
MonWidgetSimpBase.__init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
def ASTER(self) :
self.menuTraduction = self.menubar.addMenu("menuTraduction")
- self.menuTraduction.addAction(self.actionTraduitV7V8)
- self.menuTraduction.addAction(self.actionTraduitV8V9)
+ self.menuTraduction.addAction(self.actionTraduitV11V12)
+ self.menuTraduction.addAction(self.actionTraduitV10V11)
self.menuTraduction.addAction(self.actionTraduitV9V10)
self.menuTraduction.setTitle(tr("Traduction"))
#self.connect(self.helpContentsAction,SIGNAL("activated()"),self.helpContents)
# Pour Aster
- self.actionTraduitV7V8 = QAction(self)
- self.actionTraduitV7V8.setObjectName("actionTraduitV7V8")
- self.actionTraduitV8V9 = QAction(self)
- self.actionTraduitV8V9.setObjectName("actionTraduitV8V9")
self.actionTraduitV9V10 = QAction(self)
self.actionTraduitV9V10.setObjectName("actionTraduitV9V10")
- self.actionTraduitV7V8.setText(tr("TraduitV7V8"))
- self.actionTraduitV8V9.setText(tr("TraduitV8V9"))
self.actionTraduitV9V10.setText(tr("TraduitV9V10"))
+ self.actionTraduitV10V11 = QAction(self)
+ self.actionTraduitV10V11.setObjectName("actionTraduitV10V11")
+ self.actionTraduitV10V11.setText(tr("TraduitV10V11"))
+ self.actionTraduitV11V12 = QAction(self)
+ self.actionTraduitV11V12.setObjectName("actionTraduitV11V12")
+ self.actionTraduitV11V12.setText(tr("TraduitV11V12"))
self.actionSauveLigne = QAction(self)
self.actionSauveLigne.setText(tr("Sauve Format Ligne"))
self.connect(self.actionParametres_Eficas,SIGNAL("activated()"),self.optionEditeur)
self.connect(self.actionLecteur_Pdf,SIGNAL("activated()"),self.optionPdf)
- self.connect(self.actionTraduitV7V8,SIGNAL("activated()"),self.traductionV7V8)
- self.connect(self.actionTraduitV8V9,SIGNAL("activated()"),self.traductionV8V9)
self.connect(self.actionTraduitV9V10,SIGNAL("activated()"),self.traductionV9V10)
+ self.connect(self.actionTraduitV10V11,SIGNAL("activated()"),self.traductionV10V11)
+ self.connect(self.actionTraduitV11V12,SIGNAL("activated()"),self.traductionV11V12)
self.connect(self.actionSauveLigne,SIGNAL("activated()"),self.sauveLigne)
- def traductionV7V8(self):
+ def traductionV11V12(self):
from gereTraduction import traduction
- traduction(self.CONFIGURATION.repIni,self.viewmanager,"V7V8")
+ traduction(self.CONFIGURATION.repIni,self.viewmanager,"V11V12")
- def traductionV8V9(self):
+ def traductionV10V11(self):
from gereTraduction import traduction
- traduction(self.CONFIGURATION.repIni,self.viewmanager,"V8V9")
+ traduction(self.CONFIGURATION.repIni,self.viewmanager,"V10V11")
def traductionV9V10(self):
from gereTraduction import traduction
return listeValeurs,1
-
+class SaisieSDCO :
+
+ def LESDCOReturnPressed(self):
+ """
+ Lit le nom donné par l'utilisateur au concept de type CO qui doit être
+ la valeur du MCS courant et stocke cette valeur
+ """
+ self.editor.init_modif()
+ anc_val = self.node.item.get_valeur()
+ if anc_val != None:
+ # il faut egalement propager la destruction de l'ancien concept
+ self.node.item.delete_valeur_co(valeur=anc_val)
+ # et on force le recalcul des concepts de sortie de l'etape
+ self.node.item.object.etape.get_type_produit(force=1)
+ # et le recalcul du contexte
+ self.node.item.object.etape.parent.reset_context()
+ nomConcept = str(self.LESDCO.text())
+ if nomConcept == "" : return
+
+ test,commentaire=self.node.item.set_valeur_co(nomConcept)
+ if test:
+ commentaire=tr("Valeur du mot-clef enregistree")
+ self.node.update_node_valid()
+ else :
+ cr = self.node.item.get_cr()
+ commentaire = tr("Valeur du mot-clef non autorisee :")+cr.get_mess_fatal()
+
def handlegestionParam(self):
index=self.myQtab.currentIndex()
- if index < 0 : return
+ if index < 0 :
+ QMessageBox.warning( self.appliEficas,tr( "Creation Paramètre indisponible"),tr( "les paramètres sont liés à un jeu de données"))
+ return
self.dict_editors[index].gestionParam()
def handleViewJdcRapport(self):
# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 re
-import types
import N_CR
import N_OPS
import N_VALIDATOR
from strfunc import ufmt
+try:
+ from PyQt4 import QtCore
+ stringTypes = (str, unicode, QtCore.QString)
+except ImportError:
+ stringTypes = (str, unicode)
+
class ENTITE:
def check_fr(self):
"""Vérifie l'attribut fr."""
- if type(self.fr) not in (str, unicode):
+ if type(self.fr) not in stringTypes:
self.cr.fatal(
_(u"L'attribut 'fr' doit être une chaine de caractères : %r"),
self.fr)
def check_docu(self):
"""Vérifie l'attribut docu."""
- if type(self.docu) not in (str, unicode):
+ if type(self.docu) not in stringTypes:
self.cr.fatal(
_(u"L'attribut 'docu' doit être une chaine de caractères : %r"),
self.docu)
def check_nom(self):
"""Vérifie l'attribut proc."""
- if type(self.nom) != types.StringType:
+ if type(self.nom) is not str:
self.cr.fatal(
_(u"L'attribut 'nom' doit être une chaine de caractères : %r"),
self.nom)
def check_condition(self):
"""Vérifie l'attribut condition."""
if self.condition != None:
- if type(self.condition) != types.StringType:
+ if type(self.condition) is not str:
self.cr.fatal(
_(u"L'attribut 'condition' doit être une chaine de caractères : %r"),
self.condition)
def check_min_max(self):
"""Vérifie les attributs min/max."""
- if type(self.min) != types.IntType:
+ if type(self.min) != int:
if self.min != '**':
self.cr.fatal(
_(u"L'attribut 'min' doit être un entier : %r"), self.min)
- if type(self.max) != types.IntType:
+ if type(self.max) != int:
if self.max != '**':
self.cr.fatal(
_(u"L'attribut 'max' doit être un entier : %r"), self.max)
def check_into(self):
"""Vérifie l'attribut into."""
if self.into != None:
- if type(self.into) != types.TupleType:
+ if type(self.into) not in (list, tuple):
self.cr.fatal(
_(u"L'attribut 'into' doit être un tuple : %r"), self.into)
sd_prod = apply(self.definition.sd_prod, (), d)
except EOFError:
raise
- except:
+ except Exception, exc:
if CONTEXT.debug:
traceback.print_exc()
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1],
- sys.exc_info()[2])
- raise AsException("impossible d affecter un type au resultat",
- string.join(l[2:]))
- # sys.exc_info()[0],sys.exc_info()[1],)
+ 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 réutilisée ou s'il faut la créer
# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe AsException
"""
# Modules EFICAS
-from strfunc import get_encoding
+from strfunc import get_encoding, to_unicode
class AsException(Exception):
def __unicode__(self):
- return " ".join([unicode(x) for x in self.args])
+ args = []
+ for x in self.args:
+ ustr = to_unicode(x)
+ if type(ustr) is not unicode:
+ ustr = unicode( repr(x) )
+ args.append(ustr)
+ return " ".join(args)
def __str__(self):
return unicode(self).encode(get_encoding())
from N_ASSD import ASSD
from N_info import message, SUPERV
from strfunc import get_encoding
-try :
- from Extensions.i18n import tr
-except :
- def tr(txt):
- return txt
+
MemoryErrorMsg = """MemoryError :
"""
o = self.sds_dict.get(sdnom, None)
if isinstance(o, ASSD):
- raise AsException(tr("Nom de concept deja defini : %s" % sdnom))
+ raise AsException("Nom de concept deja defini : %s" % sdnom)
if sdnom in self._reserved_kw:
raise AsException(
- tr( "Nom de concept invalide. '%s' est un mot-clé réservé." % sdnom))
+ "Nom de concept invalide. '%s' est un mot-clé réservé." % sdnom)
# Ajoute a la creation (appel de reg_sd).
self.sds_dict[sdnom] = sd
if os.path.exists("fort." + str(unite)):
fname = "fort." + str(unite)
if fname == None:
- raise AsException(tr("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 (tr("%s n'est pas un fichier existant" % fname))
+ raise AsException("%s n'est pas un fichier existant" % fname)
fproc = open(fname, 'r')
text = fproc.read()
fproc.close()
except KeyError:
from warnings import warn
warn(
- tr("concept '%s' absent du contexte de %s" % (
- nom, self.nom)),
+ "concept '%s' absent du contexte de %s" % (
+ nom, self.nom),
RuntimeWarning, stacklevel=2)
return d
if etape:
sd_prod = apply(sd_prod, (self,), d)
except (EOFError, self.UserError):
raise
- except:
+ except Exception, exc:
if CONTEXT.debug:
traceback.print_exc()
- l = traceback.format_exception(
- sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
- raise AsException(
- "impossible d affecter un type au resultat\n", string.join(l[2:]))
+ raise AsException("impossible d affecter un type au resultat:",
+ str(exc))
# on teste maintenant si la SD est réutilisée ou s'il faut la créer
if self.definition.reentrant != 'n' and self.reuse:
# 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 self.definition.entites.items():
- if v.label != 'BLOC': continue
-
+ if v.label != 'BLOC':
+ continue
# condition and a or b : Equivalent de l'expression : condition ?
# a : b du langage C
+
#PNPN on recalcule dico_valeurs dans le for
# pour les globaux imbriques (exple Telemac Advection)
# avant le calcul etait avant le for
self.reentrant = reentrant
self.repetable = repetable
self.fr = fr
+ #self.ang=""
self.ang=ang
self.docu = docu
if type(regles) == types.TupleType:
- defaut : valeur par défaut
- min : nombre minimal de valeurs
- max : nombre maximal de valeurs
- - homo : homogene (toutes les valeurs d une liste sont de meme type)
+ - homo : ?
- 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 : ?
- - sug : suggere
+ - sug : ?
"""
N_ENTITE.ENTITE.__init__(self, validators)
# Initialisation des attributs
# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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
+# 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.
+# ======================================================================
"""
Ce module contient toutes les classes necessaires pour
class Compulsory(ListVal):
-
"""
Validateur operationnel
Verification de la présence obligatoire d'un élément dans une liste
return _(u"La valeur n'est pas dans la liste des choix possibles")
-class NoRepeat(ListVal):
+class Together(ListVal):
+ """
+ Validateur operationnel
+ si un des éléments est présent les autres doivent aussi l'être
+ """
+ registry = {}
+
+ def __init__(self, elem=()):
+ if not is_sequence(elem):
+ elem = (elem,)
+ Valid.__init__(self, elem=elem)
+ self.elem = elem
+ self.cata_info = ""
+
+ def info(self):
+ return ufmt(_(u"%s présent ensemble"), `self.elem`)
+
+ def default(self, valeur, elem):
+ return valeur
+
+ def verif_item(self, valeur):
+ return 1
+
+ def convert(self, 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( ufmt(_(u"%s ne contient pas les éléments devant être présent ensemble: %s "), valeur, elem))
+ return valeur
+
+ def has_into(self):
+ return 1
+
+ def verif(self, valeur):
+ if not is_sequence(valeur):
+ liste = list(valeur)
+ else:
+ 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
+ return 1
+
+ def info_erreur_item(self):
+ return _(u"La valeur n'est pas dans la liste des choix possibles")
+
+class Absent(ListVal):
"""
Validateur operationnel
- Verification d'absence de doublons dans la liste.
+ si un des éléments est présent non valide
"""
+ registry = {}
+
+ def __init__(self, elem=()):
+ if not is_sequence(elem):
+ elem = (elem,)
+ Valid.__init__(self, elem=elem)
+ self.elem = elem
+ self.cata_info = ""
+
+ def info(self):
+ return ufmt(_(u"%s absent"), `self.elem`)
+
+ def default(self, valeur, elem):
+ return valeur
+
+ def verif_item(self, valeur):
+ return 1
+
+ def convert(self, valeur):
+ elem = list(self.elem)
+ for val in valeur:
+ v = self.adapt(val)
+ if v in elem:
+ raise ValError( ufmt(_(u"%s n'est pas autorisé : %s "), v, elem))
+ return valeur
+
+ def has_into(self):
+ return 1
+
+ def verif(self, valeur):
+ if not is_sequence(valeur):
+ liste = list(valeur)
+ else:
+ liste = valeur
+ for val in self.elem:
+ if val in liste: return 0
+ return 1
+
+ def info_erreur_item(self):
+ return _(u"La valeur n'est pas dans la liste des choix possibles")
+
+class NoRepeat(ListVal):
+ """
+ Validateur operationnel
+ Verification d'absence de doublons dans la liste.
+ """
def __init__(self):
Valid.__init__(self)
self.cata_info = ""
return self.function.info
def verif(self, valeur):
-#PNPN --> a corriger evtl voir verif_item
return self.function(valeur)
def verif_item(self, valeur):
self.ext = ext
self.errormsg = u'"%%(value)s" n\'est pas un nom de fichier %(ext)s valide' % {
"ext": ext}
- RegExpVal.__init__(self, "^[\S]+\.%s$" % self.ext)
+ RegExpVal.__init__(self, "^[\w\-]+\.%s$" % self.ext)
def info(self):
return u'Un nom de fichier se terminant par ".%s" est attendu.' % self.ext
# coding=utf-8
-# Copyright (C) 2007-2013 EDF R&D
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
+# ======================================================================
"""
# values in a MCSIMP.
MAXSIZE = 500
-MAXSIZE_MSGCHK = ' <A> Only the first {0} occurrences (total: {1}) have been checked.'
-MAXSIZE_MSGKEEP = ' <A> Only the first {0} occurrences (total: {1}) have been kept.'
+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-2013 EDF R&D
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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
+# 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.
+# ======================================================================
"""
Description des OJB jeveux
else:
return None
+ def changeJeveuxValues(self, nbval, indices, reel, imag, num = 1):
+ """Modify values of existing data structures"""
+ nomj = self.nomj()
+ if aster.jeveux_exists(nomj):
+ obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S'
+ if obj_simple:
+ assert num==1,"""For vectors last argument must be set to 1"""
+ # aster.putvectjev can be used for vectors (num=1) and collections
+ aster.putvectjev(nomj, nbval, indices, reel, imag, num)
+
def get_stripped(self):
"""Fonction utilitaire, renvoie une liste de chaines 'strippées'"""
data = self.get()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
from parseur import FactNode
-from dictErreurs import jdcSet
+from load import jdcSet
import logging
dict_commande={}
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+from utils import lineToDict
import logging
from dictErreurs import EcritErreur
-from dictErreurs import jdcSet
+from load import jdcSet
from renamemocle import decaleLignesdeNBlancs
from removemocle import removeMotCleInFact
+import regles
#--------------------------------------------------------------------------
MaLigneGlob=jdc.getLines()[indexLigneGlob]
MaLigneTexte=liste_ligne_MC[indexTexteMC]
for Valeur in DictNouvVal.keys() :
- trouve=MaLigneTexte.find(Valeur)
- if trouve > -1 :
+ MaLigneTexteDict=lineToDict(MaLigneTexte)
+ trouvecol=MaLigneTexte.find(Valeur)
+ if trouvecol > -1:
+ trouve=(Valeur==MaLigneTexteDict[trouvecol])
+ else:
+ trouve=False
+ if trouve:
debut=MaLigneGlob.find(motcle)
if debut==-1 : debut=0
Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur])
if boolChange : jdc.reset(jdc.getSource())
#--------------------------------------------------------------------------------
-def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=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
- for mcF in c.childNodes:
- if mcF.name != fact : continue
- l=mcF.childNodes[:]
- l.reverse()
- for ll in l:
- trouveUnMC=0
- for mc in ll.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.keys() :
- trouve=MaLigneTexte.find(Valeur)
- if trouve > -1 :
- 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 à verifier ligne %s" ,c.lineno )
- EcritErreur((command,fact,motcle,"DEFAUT"),c.lineno)
+ if c.name != command : continue
+ for mcF in c.childNodes:
+ if mcF.name != fact : continue
+ l=mcF.childNodes[:]
+ l.reverse()
+ for ll in l:
+ 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.keys() :
+ MaLigneTexteDict=lineToDict(MaLigneTexte)
+ trouvecol=MaLigneTexte.find(Valeur)
+ if trouvecol > -1:
+ trouve=(Valeur==MaLigneTexteDict[trouvecol])
+ else:
+ 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 à 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):
#---------------------------------------------------------------------------------------
#
import logging
-import sets
-
-jdcSet=sets.Set()
+from load import jdcSet
def EcritErreur(listeGena,ligne=None) :
commands= jdc.root.childNodes[:]
commands.reverse()
for c in commands:
- jdcSet.add(c.name)
- 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)
def GenereErreurMotCleInFact(jdc,command,fact,mocle):
for c in jdc.root.childNodes:
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)
+ logging.warning("%s doit etre supprimee ou modifiee dans %s : ligne %d",valeur,c.name,n.lineno)
#
import logging
from parseur import FactNode
-from dictErreurs import jdcSet
+from load import jdcSet
from dictErreurs import EcritErreur
import string
import regles
texte=texte+"\n"
ligneaCouper=facteur.lineno
- trouve=0
- trouveF=0
- trouveP=0
while ligneaCouper < facteur.endline + 1 :
- 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:]
- continue
+ 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:]
+ 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"
+ break
+ if ancien[indiceParcours] != " " :
+ trouveP=0
+ # print "mouv"
+ break
+ 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)
+ jdc.joinLineandNext(ligneaCouper)
+ logging.info("Insertion de %s ligne %d", texteinfo,ligneaCouper)
- 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"
- break
- indiceParcours = indiceParcours+1
- trouve = trouveP * trouveF
- if trouve : break
- ancien=ancien[indice+1:]
-
- trouve = trouveP * trouveF
- if trouve : break
- ligneaCouper=ligneaCouper+1
- ancien=jdc.getLine(ligneaCouper)
-
- if trouve :
- debut=indiceDeCoupe + 3
- jdc.splitLine(ligneaCouper,debut)
- else :
- print "Le traducteur ne sait pas faire"
- assert 0
-
- # enleve les blancs en debut de texte
- i = 0
- while i < len(texte) :
- if texte[i] != " " : break
- i = i +1
+ # Gestion du cas particulier du mot clef facteur vide
+ if facteur.childNodes == []:
+ jdc.joinLineandNext(facteur.lineno)
- jdc.addLine(texte,ligneaCouper)
- jdc.joinLineandNext(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)
#-----------------------------------
for c in commands:
if c.name != commande : continue
for mcF in c.childNodes:
- if mcF.name != fact : continue
- if ensemble.verif(c) == 0 : continue
- l=mcF.childNodes[:]
- l.reverse()
- boolChange=1
- insereMotCleDansFacteur(jdc,mcF,texte)
+ if mcF.name != fact : continue
+ if ensemble.verif(c) == 0 : continue
+ boolChange=1
+ insereMotCleDansFacteur(jdc,mcF,texte)
if boolChange : jdc.reset(jdc.getSource())
#-------------------------------------------------------------------------------------------
import parseur
from mocles import parseKeywords
+import sets
+jdcSet=sets.Set()
class JDCTrad:
#----------------------------------------
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):
#---------------------------
import types
from parseur import Keyword, FactNode, lastparen, lastparen2,maskStringsAndComments
from visiteur import KeywordFinder, visitor
-from Traducteur.utils import indexToCoordinates, lineToDict, DictToLine
+from utils import indexToCoordinates, lineToDict, DictToLine
debug=0
import removemocle
import inseremocle
from parseur import lastparen
-from dictErreurs import jdcSet
+from load import jdcSet
debug=0
#-----------------------------------------------------
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)
removemocle.removeMotCle(jdc,command,mc)
jdc.reset(jdc.getSource())
+#-----------------------------------------------------
+def FusionMotCleInFact(jdc,command,fact,liste_mc,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
+ for mcF in c.childNodes:
+ if mcF.name != fact: continue
+ for ll in mcF.childNodes[:]:
+ for mc in ll.childNodes:
+ if mc.name not in liste_mc : 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)
+ jdc.reset(jdc.getSource())
+ boolChange=1
+ if boolChange :
+ jdc.reset(jdc.getSource())
+ for mc in liste_mc :
+ removemocle.removeMotCleInFact(jdc,command,fact,mc)
+ jdc.reset(jdc.getSource())
+
+#-----------------------------------------------------
+def FusionMCFToMCF(jdc,command,liste_mcf,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
+ for mcF in c.childNodes:
+ if mcF.name not in liste_mcf : continue
+ trouveUnMC=1
+ val=mcF.getText(jdc)
+ # esp=esp1+(inseremocle.chercheDebutFacteur(jdc,mcF)-len(mcF.name))*' '
+ esp=esp1+inseremocle.chercheAlignement(jdc,c)
+ # print len(esp)
+ for ll in mcF.childNodes[:]:
+ # if(pp>0): TexteMC+=esp
+ TexteMC+='_F('
+ for mc in ll.childNodes:
+ 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
+ # TexteMC+='),'
+ TexteMC+='),'
+ # print TexteMC
+ if(trouveUnMC):
+ inseremocle.insereMotCle(jdc,c,TexteMC)
+ jdc.reset(jdc.getSource())
+ boolChange=1
+ if boolChange :
+ jdc.reset(jdc.getSource())
+ for mcF in liste_mcf :
+ removemocle.removeMotCle(jdc,command,mcF)
+ jdc.reset(jdc.getSource())
+
+
+
#--------------------------------------------------------------------
def EclaMotCleToFact(jdc,command,motcle,mot1,mot2,defaut=0):
#--------------------------------------------------------------------------
if bool : return 0
return 1
+#-----------------------------------------
+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
+ return 1
+
#------------------------------
class MCaPourValeur :
#------------------------------
"MCsousMCFcourantaPourValeur":MCsousMCFcourantaPourValeur,
"MCsousMCFcourantaPourValeurDansListe":MCsousMCFcourantaPourValeurDansListe,
"MCsousMCFcourantnaPasPourValeurDansListe":MCsousMCFcourantnaPasPourValeurDansListe,
+ "MCsousMCFnaPasPourValeurDansListe":MCsousMCFnaPasPourValeurDansListe,
"MCaPourValeurDansListe":MCaPourValeurDansListe,
"MCnaPasPourValeurDansListe":MCnaPasPourValeurDansListe}
import regles
from parseur import FactNode
from dictErreurs import EcritErreur
-from dictErreurs import jdcSet
+from load import jdcSet
debug=0
#debug=1
import logging
import sys
from parseur import FactNode
-from dictErreurs import jdcSet
+from load import jdcSet
import regles
from dictErreurs import EcritErreur
#debug=1
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# 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
+#
+"""
+"""
+usage="""usage: %prog [options]
+Typical use is:
+ python traduitV10V11.py --infile=xxxx --outfile=yyyy
+"""
+
+import log
+import optparse
+import sys
+
+from load import getJDC
+from mocles import parseKeywords
+from removemocle import *
+from renamemocle import *
+from renamemocle import *
+from inseremocle import *
+from changeValeur import *
+from movemocle import *
+from dictErreurs import *
+from regles import pasDeRegle
+
+atraiter=(
+ "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",))
+
+
+ #### 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")
+
+ #### 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)
+ # 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")
+ # Suppression de GRILLE_NCOU
+ removeMotCleInFact(jdc,"AFFE_CARA_ELEM","GRILLE","GRILLE_NCOU",pasDeRegle(),0)
+ # Suppression de ORIG_AXE
+ 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")
+
+ #### Traitement de 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")
+
+ #### 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"),))
+ # renommage CHAMP_GD en CHAM_GD
+ 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)
+
+ #### Traitement de ASSE_ELEM_SSD ##############################
+ # Rien à faire
+
+ #### Traitement de ASSEMBLAGE ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### 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)
+
+ #### 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)
+
+ #### 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)
+
+ #### Traitement de CALC_CHAMP ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de CALC_ECREVISSE ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_ELEM ##############################
+ # renommage de la commande
+ renameCommande(jdc,"CALC_ELEM","CALC_CHAMP", )
+ # Suppression des types de charges
+ removeMotCleInFact(jdc,"CALC_CHAMP","EXCIT","TYPE_CHARGE",pasDeRegle(),0)
+ # Suppression des types d'option'
+ 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
+ ## 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)
+ ## 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)
+ ## 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")
+ ## 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"),))
+ ## 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)))
+ ## 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"]
+ ### 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)
+ ### 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)
+ ### traitement de REPE_COQUE
+ 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)
+
+ #### Traitement de CALC_ERREUR ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de CALC_ESSAI ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_EUROPLEXUS ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_FATIGUE ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_FERRAILLAGE ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_FONCTION ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_FORC_AJOU ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_G ##############################
+ # Suppression SYME_CHAR
+ 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"),))
+ # 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)
+ # Résorption de la sensibilité
+ 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)
+ # Renommage de l'option K_G_MODA en 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"),))
+ # 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"),))
+
+ #### 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)
+ # Résorption de la sensibilité
+ 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)
+
+ #### Traitement de CALC_INTE_SPEC ##############################
+ # Rien à faire
+
+ #### Traitement de CALC_MAC3COEUR ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de CALC_MATR_AJOU ##############################
+ # Suppression d'algo pour PETSc
+ 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)
+
+ #### Traitement de CALC_MISS ##############################
+ # Suppression de TYPE_CHARGE
+ 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")
+
+ #### 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")
+
+ #### Traitement de CALC_NO ##############################
+ # renommage de la commande
+ renameCommande(jdc,"CALC_NO","CALC_CHAMPNO", )
+ # Suppression des types de charges
+ 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",]
+ ## 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",})
+ ## 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)
+ ## 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")
+ ## 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"),))
+ ## 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)))
+ ## 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"]
+ ### traitement métallurgie
+ 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)
+ ### traitement calcul d'erreur
+ 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)
+ ## 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)
+
+ #### 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)
+
+ #### Traitement de CALC_SENSI ##############################
+ # Résorption de la sensibilité
+ 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")
+
+ #### Traitement de CALC_TABLE ##############################
+ # Renommage de AJOUT en AJOUT_LIGNE
+ dOPE={"AJOUT":"AJOUT_LIGNE",}
+ ChangementValeurDsMCF(jdc,"CALC_TABLE","ACTION","OPERATION",dOPE)
+ # Résorption de la sensibilité
+ 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)
+
+ #### 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)
+
+ #### Traitement de COMB_FOURIER ##############################
+ # Homogénéisation de ANGLE
+ renameMotCle(jdc,"COMB_FOURIER","ANGL","ANGLE")
+
+ #### Traitement de COMB_SISM_MODAL ##############################
+ 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)
+
+ #### 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")
+
+ #### Traitement de CREA_RESU ##############################
+ # Rien à faire
+
+ #### Traitement de CREA_TABLE ##############################
+ removeMotCle(jdc,"CREA_TABLE","SENSIBILITE",pasDeRegle(),0)
+
+ #### Traitement de DEBUT ##############################
+ # Suppression du mot-clé TITRE
+ removeMotCleInFact(jdc,"DEBUT","CATALOGUE","TITRE",pasDeRegle(),0)
+ # Suppression du mot-clé IMPRESSION
+ 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)
+
+ #### Traitement de DEFI_BASE_MODALE ##############################
+ # Rien à faire
+
+ #### Traitement de DEFI_CABLE_BP ##############################
+ # 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)
+ # Suppression famille de sytèmes de glissement
+ 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")
+
+ #### Traitement de DEFI_CONTACT ##############################
+ 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")
+ # 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")
+ # résorption de l'usure
+ 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"),),)
+ # règles sur relation
+ 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"),),)
+ # Ajout règle sur REAC_GEOM
+ removeMotCleSiRegle(jdc,"DEFI_CONTACT","REAC_GEOM",((("ALGO_RESO_GEOM","NEWTON",jdc),"MCaPourValeur"),))
+
+ #### Traitement de DEFI_COQU_MULT ##############################
+ 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)
+ # Fusion FORM_FISS='ELLIPSE' et FORM_FISS='INCLUSION'
+ 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")
+ # Cas FOND OUVERT
+ 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")
+ # 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")
+ # 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")
+ # 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)
+ #
+ 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")
+
+ #### Traitement de DEFI_GROUPE ##############################
+ # Rien à faire
+
+ #### Traitement de DEFI_INTE_SPEC ##############################
+ # 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)
+
+ #### 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")
+ # 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")
+ # Modification des paramètres de la loi 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")
+ # 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)
+ # Suppression de la loi MONO_VISC3
+ GenereErreurMCF(jdc,"DEFI_MATERIAU","MONO_VISC3")
+ # Suppression de la loi 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",))
+
+ #### Traitement de DEFI_PART_FETI ##############################
+ # Rien à faire
+
+ #### Traitement de DEFI_SOL_MISS ##############################
+ # Rien à faire
+
+ #### Traitement de DEFI_SPEC_TURB ##############################
+ # Homogénéisation de ANGLE
+ 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)
+ # Suppression mot-clé ALARME
+ 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"),))
+
+ #### Traitement de DYNA_LINE_HARM ##############################
+ # Résorption de la sensibilité
+ removeMotCle(jdc,"DYNA_LINE_HARM","SENSIBILITE",pasDeRegle(),0)
+ # Suppression mot-clé TYPE_CHARGE
+ 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")
+
+ #### Traitement de DYNA_LINE_TRAN ##############################
+ # Résorption de la sensibilité
+ 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)
+ # 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)
+ # Suppression mot-clé TYPE_CHARGE
+ removeMotCleInFact(jdc,"DYNA_LINE_TRAN","EXCIT","TYPE_CHARGE",pasDeRegle(),0)
+ # Suppression mot-clé 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)
+ # Renommage dans ARCHIVAGE
+ 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")
+ # Résorption de la sensibilité
+ 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)
+
+ #### 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")
+ # 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")
+ # 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")
+ # couplage
+ 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)
+ # Renommage dans ARCHIVAGE
+ 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")
+
+ #### Traitement de DYNA_VIBRA ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de EXEC_LOGICIEL ##############################
+ # Rien à faire
+
+ #### Traitement de EXTR_RESU ##############################
+ # Résorption de la sensibilité
+ 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)
+
+ #### 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"),))
+ # 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)
+
+ #### Traitement de FORMULE ##############################
+ # Rien à faire
+
+ #### Traitement de GENE_ACCE_SEISME ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de GENE_FONC_ALEA ##############################
+ # Rien à faire
+
+ #### Traitement de GENE_VARI_ALEA ##############################
+ # Rien à faire
+
+ #### Traitement de IMPR_CO ##############################
+ # Résorption de la sensibilité
+ removeMotCleInFact(jdc,"IMPR_CO","CONCEPT","SENSIBILITE",pasDeRegle(),0)
+
+ #### Traitement de IMPR_DIAG_CAMPBELL ##############################
+ # Rien à faire
+
+ #### Traitement de IMPR_FONCTION ##############################
+ # Rien à faire
+
+ #### Traitement de IMPR_GENE ##############################
+ # Rien à faire
+
+ #### Traitement de IMPR_OAR ##############################
+ # Rien à faire
+
+ #### Traitement de IMPR_RESU ##############################
+ # Résorption de la sensibilité
+ removeMotCleInFact(jdc,"IMPR_RESU","RESU","SENSIBILITE",pasDeRegle(),0)
+ # Suppression de l'écriture au format ENSIGHT
+ GenereErreurValeur(jdc,"IMPR_RESU","FORMAT",("'ENSIGHT'",))
+ # Homogénéisation de ANGLE
+ renameMotCleInFact(jdc,"IMPR_RESU","FORMAT","ANGL","ANGLE",pasDeRegle(),0)
+ # Suppression mot-clé MODELE
+ removeMotCle(jdc,"IMPR_RESU","MODELE",pasDeRegle(),0)
+
+ #### Traitement de IMPR_STURM ##############################
+ 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")
+ #
+ 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"),),)
+ # Suppression UNITE
+ removeMotCle(jdc,"IMPR_STURM","UNITE",pasDeRegle(),0)
+ # Renommage de la commande
+ renameCommande(jdc,"IMPR_STURM","INFO_MODE", )
+
+ #### Traitement de IMPR_TABLE ##############################
+ # Résorption de la sensibilité
+ 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)
+ # Suppression de FORMAT_C
+ GenereErreurMCF(jdc,"IMPR_TABLE","FORMAT_C")
+
+ #### Traitement de INCLUDE ##############################
+ # Rien à faire
+
+ #### Traitement de INCLUDE_MATERIAU ##############################
+ # Rien à faire
+
+ #### Traitement de INFO_EXEC_ASTER ##############################
+ # Rien à faire
+
+ #### Traitement de INFO_FONCTION ##############################
+ # Rien à faire
+
+ #### Traitement de INFO_MODE ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de LIRE_CHAMP ##############################
+ # Rien à faire
+
+ #### Traitement de LIRE_FONCTION ##############################
+ # Rien à faire
+
+ #### Traitement de LIRE_IMPE_MISS ##############################
+ # Rien à faire
+
+ #### Traitement de LIRE_INTE_SPEC ##############################
+ # Rien à faire
+
+ #### Traitement de LIRE_MAILLAGE ##############################
+ # Rien à faire
+
+ #### Traitement de LIRE_RESU ##############################
+ # Suppression du type 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)
+ # 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)
+
+ #### Traitement de LIRE_TABLE ##############################
+ # Rien à faire
+
+ #### Traitement de MACR_ADAP_MAIL ##############################
+ # Résorption de la sensibilité
+ removeMotCle(jdc,"MACR_ADAP_MAIL","SENSIBILITE",pasDeRegle(),0)
+ # Changement de version
+ 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"})
+ # 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"})
+
+ #### Traitement de MACR_ASCOUF_CALC ##############################
+ # Rien à faire
+
+ #### Traitement de MACR_ASCOUF_MAIL ##############################
+ # Rien à faire
+
+ #### Traitement de MACR_ASPIC_CALC ##############################
+ # Rien à faire
+
+ #### Traitement de MACR_ASPIC_MAIL ##############################
+ # 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")
+
+ #### 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"})
+
+ #### 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"})
+
+ #### Traitement de MACR_ELEM_DYNA ##############################
+ # Rien à faire
+
+ #### Traitement de MACR_FIABILITE ##############################
+ GenereErreurPourCommande(jdc,("MACR_FIABILITE",))
+
+ #### Traitement de 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"})
+ # 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"})
+
+ #### 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)
+ # 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)
+
+ #### Traitement de MACRO_EXPANS ##############################
+ # Rien à faire
+
+ #### Traitement de MACRO_MATR_AJOU ##############################
+ # 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)
+ # 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")
+ # Renommage de la commande
+ 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")
+ # 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)
+ # Renommage critere de Sturm
+ ChangementValeurDsMCF(jdc,"MACRO_MODE_MECA","VERI_MODE","STURM",{"OUI":"GLOBAL",})
+
+ #### Traitement de MACRO_PROJ_BASE ##############################
+ renameMotCle(jdc,"MACRO_PROJ_BASE","PROFIL","STOCKAGE")
+ # Renommage de la commande
+ renameCommande(jdc,"MACRO_PROJ_BASE","PROJ_BASE", )
+
+ #### Traitement de MACR_RECAL ##############################
+ 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)
+
+ #### Traitement de MODE_ITER_INV ##############################
+ # Résorption de la sensibilité
+ 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")
+
+ #### Traitement de MODE_ITER_SIMULT ##############################
+ # Résorption de la sensibilité
+ 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")
+ # renommage STOP_FREQ_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)
+
+ #### Traitement de MODI_MODELE_XFEM ##############################
+ 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")
+ # 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",)
+
+ #### Traitement de NORM_MODE ##############################
+ removeMotCle(jdc,"NORM_MODE","SENSIBILITE",pasDeRegle(),0)
+
+ #### Traitement de NUME_DDL ##############################
+ # Rien à faire
+
+ #### Traitement de NUME_DDL_GENE ##############################
+ # 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")
+
+ #### Traitement de POST_BORDET ##############################
+ # Rien à faire
+
+ #### Traitement de POST_CHAMP ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de POST_CHAM_XFEM ##############################
+ # Suppression mot-clé MAILLAGE_SAIN
+ removeMotCle(jdc,"POST_CHAM_XFEM","MAILLAGE_SAIN",pasDeRegle(),0)
+
+ #### Traitement de POST_COQUE ##############################
+ # Rien à faire
+
+ #### Traitement de POST_DECOLLEMENT ##############################
+ # Rien à faire
+
+ #### Traitement de POST_DYNA_ALEA ##############################
+ # Suppression du mot-clé NUME_VITE_FLUI
+ 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)
+ # Renommage de SEUIL
+ 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'",))
+
+ #### Traitement de POST_GP ##############################
+ # Suppression de POST_GP au profit de CALC_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)
+ # Suppression de SYME_CHAR
+ 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)
+ # Suppression de MAILLAGE
+ 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)
+
+ #### Traitement de POST_K_TRANS ##############################
+ # Suppression de la possibilité de donner un mode_meca
+ 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)
+
+ #### Traitement de POST_RCCM ##############################
+ # Rien à faire
+
+ #### Traitement de POST_RELEVE_T ##############################
+ # Résorption de la sensibilité
+ removeMotCle(jdc,"POST_RELEVE_T","SENSIBILITE",pasDeRegle(),0)
+
+ #### Traitement de POST_RUPTURE ##############################
+ # Rien à faire, n'existe pas en 10
+
+ #### Traitement de POST_USURE ##############################
+ # Rien à faire
+
+ #### Traitement de POURSUITE ##############################
+ # Suppression du mot-clé TITRE
+ 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)
+
+ #### Traitement de PROJ_BASE ##############################
+ # Suppression de RESU_GENE pour défaut de validation
+ GenereErreurMCF(jdc,"PROJ_BASE","RESU_GENE")
+
+ #### Traitement de PROJ_CHAMP ##############################
+ # Résorption de la sensibilité
+ 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")
+
+ #### 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)
+
+ #### 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)
+
+ #### Traitement de RAFF_XFEM ##############################
+ # Rien à faire
+
+ #### Traitement de RECU_FONCTION ##############################
+ # Résorption de la sensibilité
+ 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)
+
+ #### Traitement de RECU_GENE ##############################
+ # Rien à faire
+
+ #### Traitement de RESOUDRE ##############################
+ # Suppression d'algo pour PETSc
+ 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"),))
+ # Suppression de ARCHIVAGE/DETR_NUME_SUIV
+ 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)
+ # Renommage CRIT_FLAMB en CRIT_STAB
+ renameMotCle(jdc,"STAT_NON_LINE","CRIT_FLAMB","CRIT_STAB")
+ # Résorption de la sensibilité
+ 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)
+ # Suppression de ARCHIVAGE/DETR_NUME_SUIV
+ 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)
+ # Suppression de ARCHIVAGE/DETR_NUME_SUIV
+ 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)
+ # Suppression du mot clé OPTION ######################################
+ 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)
+
+ #### Traitement de THER_NON_LINE_MO ##############################
+ # Rien à faire
+
+ #################################################################
+ f=open(outfile,'w')
+ f.write(jdc.getSource())
+ f.close()
+
+ log.ferme(hdlr)
+
+def main():
+ parser = optparse.OptionParser(usage=usage)
+
+ parser.add_option('-i','--infile', dest="infile", default='toto.comm',
+ help="Le fichier à traduire")
+ parser.add_option('-o','--outfile', dest="outfile", default='tutu.comm',
+ help="Le fichier traduit")
+
+ options, args = parser.parse_args()
+ traduc(options.infile,options.outfile)
+
+if __name__ == '__main__':
+ main()
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# 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
+#
+"""
+"""
+usage="""usage: %prog [options]
+Typical use is:
+ python traduitV11V12.py --infile=xxxx --outfile=yyyy
+"""
+
+import log
+import optparse
+import sys
+
+from load import getJDC
+from mocles import parseKeywords
+from removemocle import *
+from renamemocle import *
+from renamemocle import *
+from inseremocle import *
+from changeValeur import *
+from movemocle import *
+from dictErreurs import *
+from regles import pasDeRegle
+
+atraiter=(
+ "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
+ parseKeywords(root)
+
+ #### Traitement de 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"),
+ ),
+ )
+
+ #### Traitement de AFFE_CHAR_MECA ##############################
+ # Suppression du mot-clé METHODE
+ 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)
+ # 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)
+
+ # 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)
+
+ #### Traitement de AFFE_CHAR_MECA_F ##############################
+ # Suppression du mot-clé METHODE
+ 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)
+
+ 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)
+
+ #### 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={}
+ dINCO.update(d3DINCO)
+ dINCO.update(dAXIS)
+ dINCO.update(dDPLAN)
+ ChangementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",dINCO)
+
+ #### Traitement de ASSEMBLAGE ##############################
+ 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)
+
+ #### Traitement de CALC_EUROPLEXUS ##############################
+ 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")
+
+ #### Traitement de CALC_FONCTION ##############################
+ 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)
+
+ #### Traitement de CALC_FATIGUE ##############################
+ ChangementValeur(jdc,"CALC_FATIGUE","COURBE_GRD_VIE",{"MANSON_C":"MANSON_COFFIN",})
+
+ #### Traitement de CALC_IFS_DNL ##############################
+ removeMotCle(jdc,"CALC_IFS_DNL","ENERGIE",pasDeRegle(),0)
+
+ #### Traitement de CALC_MAC3COEUR ##############################
+ AjouteMotClefDansFacteur(jdc,"CALC_MAC3COEUR","DEFORMATION","ARCHIMEDE = 'OUI'",pasDeRegle())
+
+ #### Traitement de CALC_MATR_ELEM ##############################
+ GenereErreurValeur(jdc,"CALC_MATR_ELEM","OPTION",("'MASS_THER'",))
+
+ #### Traitement de CALC_MISS ##############################
+ GenereErreurValeurDsMCF(jdc,"CALC_MISS","PARAMETRE","ISSF",("'OUI'",))
+
+ #### Traitement de CALC_MODAL ##############################
+ # renameCommande(jdc,"CALC_MODAL","CALC_MODES", )
+ GenereErreurPourCommande(jdc,"CALC_MODAL")
+
+ #### Traitement de CALC_VECT_ELEM ##############################
+ 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"),))
+
+ #### Traitement de DEBUT ##############################
+ # GenereErreurPourCommande(jdc,("DEBUT",))
+ 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")
+
+ #### 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)
+
+ #### Traitement de DEFI_LIST_INST ##############################
+ 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")
+
+ #### 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",]
+ 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",]
+ 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)
+ liste_mc=["C"+str(i) for i in range(1,198)]
+ FusionMotCleInFact(jdc,"DEFI_MATERIAU","UMAT",liste_mc,"LISTE_COEF")
+ FusionMotCleInFact(jdc,"DEFI_MATERIAU","UMAT_FO",liste_mc,"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",]
+ for param in lTHMD:
+ 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)
+
+ 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)
+
+ #### 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)
+
+ #### 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)
+
+ #### 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"})
+
+ #### Traitement de FACTORISER ##############################
+ 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")
+
+ #### Traitement de IMPR_MISS_3D ##############################
+ GenereErreurPourCommande(jdc,"IMPR_MISS_3D")
+ # removeCommande(jdc,"IMPR_MISS_3D")
+
+ #### Traitement de IMPR_RESU ##############################
+ removeMotCle(jdc,"IMPR_RESU","RESTREINT",pasDeRegle(),0)
+
+ #### Traitement de INFO_FONCTION ##############################
+ GenereErreurMCF(jdc,"INFO_FONCTION","NOCI_SEISME")
+
+ #### Traitement de LIRE_MAILLAGE ##############################
+ removeMotCle(jdc,"LIRE_MAILLAGE","ABSC_CURV",pasDeRegle(),0)
+
+ #### Traitement de LIRE_MISS_3D ##############################
+ GenereErreurPourCommande(jdc,"LIRE_MISS_3D")
+
+ #### Traitement de MACR_ASCOUF_CALC ##############################
+ 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'",))
+
+ #### Traitement de MACR_ASPIC_CALC ##############################
+ # GenereErreurMCF(jdc,"MACR_ASPIC_CALC","COMP_ELAS")
+
+ #### Traitement de MACR_ECREVISSE ##############################
+ 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"})
+
+ #### 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())
+
+ #### Traitement de 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"]
+ 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", )
+
+ #### 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",]
+ 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",]
+ 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")
+
+ removeMotCle(jdc,"MODE_ITER_INV","CALC_MODE",pasDeRegle(),0)
+
+ chercheOperInsereMotCleSiRegle(jdc,"MODE_ITER_INV","OPTION='AJUSTE'",((("OPTION",),"nexistepas"),),0)
+
+ 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")
+
+ # 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"]
+ for mcle in lMCLE:
+ moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT",mcle,"SOLVEUR_MODAL")
+
+ lMCLE=["NMAX_ITER_QR", "PREC_ORTHO", "NMAX_ITER_ORTHO", "PREC_LANCZOS"]
+ for mcle in lMCLE:
+ moveMotClefInOperToFact(jdc,"MODE_ITER_SIMULT",mcle,"SOLVEUR_MODAL")
+
+
+ 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)
+
+ #### Traitement de MODI_MODELE_XFEM ##############################
+ 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"]
+ for mcle in lPDA:
+ 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())
+
+ #### Traitement de POST_ELEM ##############################
+ 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",})
+
+ #### Traitement de POURSUITE ##############################
+ removeMotCle(jdc,"POURSUITE","CODE",)#"NOM",pasDeRegle(),0)
+
+ #### Traitement de RECU_FONCTION ##############################
+ 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",]
+ for com in lCOM:
+ # chercheOperInsereFacteurSiRegle(jdc,com,"COMPORTEMENT",(((["COMPORTEMENT"],),"nexistepasMCFParmi"),),1)
+ 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"),))
+
+
+ #### Traitement de TEST_COMPOR ##############################
+ GenereErreurPourCommande(jdc,"TEST_COMPOR")
+
+ #### Traitement de THER_NON_LINE ##############################
+ 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',]
+ 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")
+
+ # Suppression de la méthode FETI
+ 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)
+
+ #### 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", )
+
+ #################################################################
+ f=open(outfile,'w')
+ f.write(jdc.getSource())
+ f.close()
+
+ log.ferme(hdlr)
+
+def main():
+ parser = optparse.OptionParser(usage=usage)
+
+ parser.add_option('-i','--infile', dest="infile", default='toto.comm',
+ help="Le fichier à traduire")
+ parser.add_option('-o','--outfile', dest="outfile", default='tutu.comm',
+ help="Le fichier traduit")
+
+ options, args = parser.parse_args()
+ traduc(options.infile,options.outfile)
+
+if __name__ == '__main__':
+ main()
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
#
+# ======================================================================
class AU_MOINS_UN:
- """
- La règle AU_MOINS_UN vérifie que l'on trouve au moins un des mots-clés
- de la règle parmi les arguments d'un OBJECT.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self,args):
- """
- La méthode verif vérifie que l'on trouve au moins un des mos-clés
- de la liste self.mcs parmi les éléments de args
+ """
+ La règle AU_MOINS_UN vérifie que l'on trouve au moins un des mots-clés
+ de la règle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text =''
- count=0
- args = self.liste_to_dico(args)
- for mc in self.mcs:
- if args.has_key(mc):count=count+1
- if count == 0:
- text = u"- Il faut au moins un mot-clé parmi : "+`self.mcs`+'\n'
- return text,0
- return text,1
+ def verif(self, args):
+ """
+ La méthode verif vérifie que l'on trouve au moins un des mos-clés
+ de la liste self.mcs parmi les éléments de args
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ''
+ count = 0
+ args = self.liste_to_dico(args)
+ for mc in self.mcs:
+ if args.has_key(mc):
+ count = count + 1
+ if count == 0:
+ text = u"- Il faut au moins un mot-clé parmi : " + `self.mcs`+'\n'
+ return text, 0
+ return text, 1
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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
+# 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.
+# ======================================================================
+
class AU_PLUS_UN:
- """
- La règle vérifie que l'on trouve 1 (au plus) des mots-clés
- de la règle parmi les arguments d'un OBJECT.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self, args):
- """
- La méthode verif vérifie que l'on trouve 1 (au plus) des mos-clés
- de la liste self.mcs parmi les éléments de args
+ """
+ La règle vérifie que l'on trouve 1 (au plus) des mots-clés
+ de la règle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
+
+ def verif(self, args):
+ """
+ La méthode verif vérifie que l'on trouve 1 (au plus) des mos-clés
+ de la liste self.mcs parmi les éléments de args
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text = ''
- count = 0
- args = self.liste_to_dico(args)
- for mc in self.mcs:
- count = count + args.get(mc, 0)
- if count > 1:
- text = u"- Il ne faut qu'un mot-clé (au plus) parmi : "+`self.mcs`+'\n'
- return text, 0
- return text, 1
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ''
+ count = 0
+ args = self.liste_to_dico(args)
+ for mc in self.mcs:
+ count = count + args.get(mc, 0)
+ if count > 1:
+ text = u"- Il ne faut qu'un mot-clé (au plus) parmi : " + \
+ `self.mcs`+'\n'
+ return text, 0
+ return text, 1
- def liste_to_dico(self, args) :
- if type(args) is dict:
- return args
- elif type(args) in (list, tuple):
- dico={}
- for arg in args:
- dico[arg] = dico.get(arg, 0) + 1
- return dico
- else :
- raise Exception("Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
+ def liste_to_dico(self, args):
+ if type(args) is dict:
+ return args
+ elif type(args) in (list, tuple):
+ dico = {}
+ for arg in args:
+ dico[arg] = dico.get(arg, 0) + 1
+ return dico
+ else:
+ raise Exception(
+ "Erreur ce n'est ni un dictionnaire ni une liste %s" % args)
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2012 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
#
+# ======================================================================
+
from Noyau.strfunc import convert, ufmt
-class A_CLASSER:
- """
- La règle A_CLASSER vérifie que ...
- """
- def __init__(self,*args):
- if len(args) > 2 :
- print convert(ufmt(_(u"Erreur à la création de la règle A_CLASSER(%s)"),
- args))
- return
- self.args=args
- if type(args[0]) == tuple:
- self.args0 = args[0]
- elif type(args[0]) == str:
- self.args0 = (args[0],)
- else :
- print convert(ufmt(_(u"Le premier argument de : %s doit etre un "
- u"tuple ou une chaine"), args))
- if type(args[1]) == tuple:
- self.args1 = args[1]
- elif type(args[1]) == str:
- self.args1 = (args[1],)
- else :
- print convert(ufmt(_(u"Le deuxième argument de :%s doit etre un "
- u"tuple ou une chaine"), args))
- # création de la liste des mcs
- liste = []
- liste.extend(self.args0)
- liste.extend(self.args1)
- self.mcs = liste
- self.init_couples_permis()
+class A_CLASSER:
- def init_couples_permis(self):
- """ Crée la liste des couples permis parmi les self.args, càd pour chaque élément
- de self.args0 crée tous les couples possibles avec un élément de self.args1"""
- liste = []
- for arg0 in self.args0:
- for arg1 in self.args1:
- liste.append((arg0,arg1))
- self.liste_couples = liste
+ """
+ La règle A_CLASSER vérifie que ...
- def verif(self,args):
- """
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # création de la liste des couples présents dans le fichier de commandes
- l_couples = []
- couple = []
- text = u''
- 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,]
- if len(couple) > 0 :
- l_couples.append(tuple(couple))
- # l_couples peut etre vide si l'on n'a pas réussi à trouver au moins un
- # élément de self.mcs
- if len(l_couples) == 0 :
- message = ufmt(_(u"- Il faut qu'au moins un objet de la liste : %r"
- u" soit suivi d'au moins un objet de la liste : %r"),
- self.args0, self.args1)
- return message,0
- # A ce stade, on a trouvé des couples : il faut vérifier qu'ils sont
- # tous licites
- num = 0
- for couple in l_couples :
- num = num+1
- if len(couple) == 1 :
- # on a un 'faux' couple
- if couple[0] not in self.args1:
- text = text + ufmt(_(u"- L'objet : %s doit être 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 + ufmt(_(u"- L'objet : %s doit être précédé d'un objet de la liste : %r\n"),
- couple[0], self.args0)
- test = 0
- elif couple not in self.liste_couples :
- text = text + ufmt(_(u"- L'objet : %s ne peut être suivi de : %s\n"),
- couple[0], couple[1])
- test = 0
- return text,test
+ """
+ def __init__(self, *args):
+ if len(args) > 2:
+ print convert(
+ ufmt(_(u"Erreur à la création de la règle A_CLASSER(%s)"),
+ args))
+ return
+ self.args = args
+ if type(args[0]) == tuple:
+ self.args0 = args[0]
+ elif type(args[0]) == str:
+ self.args0 = (args[0],)
+ else:
+ print convert(ufmt(_(u"Le premier argument de : %s doit etre un "
+ u"tuple ou une chaine"), args))
+ if type(args[1]) == tuple:
+ self.args1 = args[1]
+ elif type(args[1]) == str:
+ self.args1 = (args[1],)
+ else:
+ print convert(ufmt(_(u"Le deuxième argument de :%s doit etre un "
+ u"tuple ou une chaine"), args))
+ # création de la liste des mcs
+ liste = []
+ liste.extend(self.args0)
+ liste.extend(self.args1)
+ self.mcs = liste
+ self.init_couples_permis()
+ def init_couples_permis(self):
+ """ Crée la liste des couples permis parmi les self.args, càd pour chaque élément
+ de self.args0 crée tous les couples possibles avec un élément de self.args1"""
+ liste = []
+ for arg0 in self.args0:
+ for arg1 in self.args1:
+ liste.append((arg0, arg1))
+ self.liste_couples = liste
+ def verif(self, args):
+ """
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # création de la liste des couples présents dans le fichier de
+ # commandes
+ l_couples = []
+ couple = []
+ text = u''
+ 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, ]
+ if len(couple) > 0:
+ l_couples.append(tuple(couple))
+ # l_couples peut etre vide si l'on n'a pas réussi à trouver au moins un
+ # élément de self.mcs
+ if len(l_couples) == 0:
+ message = ufmt(_(u"- Il faut qu'au moins un objet de la liste : %r"
+ u" soit suivi d'au moins un objet de la liste : %r"),
+ self.args0, self.args1)
+ return message, 0
+ # A ce stade, on a trouvé des couples : il faut vérifier qu'ils sont
+ # tous licites
+ num = 0
+ for couple in l_couples:
+ num = num + 1
+ if len(couple) == 1:
+ # on a un 'faux' couple
+ if couple[0] not in self.args1:
+ text = text + ufmt(
+ _(u"- L'objet : %s doit être 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 + ufmt(
+ _(u"- L'objet : %s doit être précédé d'un objet de la liste : %r\n"),
+ couple[0], self.args0)
+ test = 0
+ elif couple not in self.liste_couples:
+ text = text + ufmt(
+ _(u"- L'objet : %s ne peut être suivi de : %s\n"),
+ couple[0], couple[1])
+ test = 0
+ return text, test
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
#
+# ======================================================================
class ENSEMBLE:
- """
- La règle vérifie que si un mot-clé de self.mcs est present
- parmi les elements de args tous les autres doivent etre presents.
-
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self,args):
- """
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on compte le nombre de mots cles presents, il doit etre egal a la liste
- # figurant dans la regle
- text = ''
- test = 1
- args = self.liste_to_dico(args)
- pivot = None
- for mc in self.mcs:
- if args.has_key(mc):
- pivot = mc
- break
- if pivot :
- for mc in self.mcs:
- if mc != pivot :
- if not args.has_key(mc):
- text = text + "- "+ pivot + u" étant présent, "+mc+ u" doit être présent"+'\n'
- test = 0
- return text,test
+ """
+ La règle vérifie que si un mot-clé de self.mcs est present
+ parmi les elements de args tous les autres doivent etre presents.
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique à la règle.
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents, il doit etre egal a la liste
+ # figurant dans la regle
+ text = ''
+ test = 1
+ args = self.liste_to_dico(args)
+ pivot = None
+ for mc in self.mcs:
+ if args.has_key(mc):
+ pivot = mc
+ break
+ if pivot:
+ for mc in self.mcs:
+ if mc != pivot:
+ if not args.has_key(mc):
+ text = text + "- " + pivot + u" étant présent, " + \
+ mc + u" doit être présent" + '\n'
+ test = 0
+ return text, test
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe mixin ETAPE qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type ETAPE
- dérivé de OBJECT.
+ Ce module contient la classe mixin ETAPE qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type ETAPE
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules Python
import types
# Modules EFICAS
import V_MCCOMPO
+from Noyau import MAXSIZE, MAXSIZE_MSGCHK
from Noyau.N_Exception import AsException
from Noyau.N_utils import AsType
from Noyau.strfunc import ufmt
-try :
- from Extensions.i18n import tr
-except :
- def tr(txt):
- return txt
-
class ETAPE(V_MCCOMPO.MCCOMPO):
- """
- """
-
- def valid_child(self):
- """ Cette methode teste la validite des mots cles de l'etape """
- for child in self.mc_liste :
- if not child.isvalid():
- return 0
- return 1
-
- def valid_regles(self,cr):
- """ Cette methode teste la validite des regles de l'etape """
- text_erreurs,test_regles = self.verif_regles()
- if not test_regles :
- if cr == 'oui' :
- self.cr.fatal(_(u"Règle(s) non respectée(s) : %s"), text_erreurs)
- return 0
- return 1
-
- def valid_sdnom(self,cr):
- """ Cette methode teste la validite du nom du concept produit par l'etape """
- valid=1
- if self.sd.nom != None :
- #if self.jdc and self.jdc.definition.code == 'ASTER' and len(self.sd.nom) > 8 :
- # le nom de la sd doit avoir une longueur <= 8 caractères pour ASTER
- # if cr == 'oui' :
- # self.cr.fatal(_(u"Le nom de concept %s est trop long (8 caractères maxi)"),
- # self.sd.nom)
- # valid = 0
- if self.sd.nom.find('sansnom') != -1 :
- # la SD est 'sansnom' : --> erreur
- if cr == 'oui' :
- self.cr.fatal(_(u"Pas de nom pour le concept retourné"))
- valid = 0
- elif re.search('^SD_[0-9]*$', self.sd.nom):
- # la SD est 'SD_' cad son nom = son id donc pas de nom donné par utilisateur : --> erreur
- if cr == 'oui' :
- self.cr.fatal(_(u"Nom de concept invalide ('SD_' est réservé)"))
- valid = 0
- return valid
-
- def get_valid(self):
- if hasattr(self,'valid'):
- return self.valid
- else:
- self.valid=None
- return None
-
- def set_valid(self,valid):
- old_valid=self.get_valid()
- self.valid = valid
- self.state = 'unchanged'
- if not old_valid or old_valid != self.valid :
- self.init_modif_up()
-
- def isvalid(self,sd='oui',cr='non'):
- """
- Methode pour verifier la validité de l'objet ETAPE. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
- de sd et de cr.
-
- Si cr vaut oui elle crée en plus un compte-rendu.
-
- Cette méthode a plusieurs fonctions :
-
- - mettre à jour l'état de self (update)
-
- - retourner un indicateur de validité 0=non, 1=oui
-
- - produire un compte-rendu : self.cr
-
- """
- if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
- if self.state == 'unchanged' :
- return self.valid
- else:
- valid=self.valid_child()
- valid=valid * self.valid_regles(cr)
-
- if self.reste_val != {}:
- if cr == 'oui' :
- self.cr.fatal(_(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
- valid=0
-
- if sd == "non":
- # Dans ce cas, on ne teste qu'une validité partielle (sans tests sur le concept produit)
- # Conséquence : on ne change pas l'état ni l'attribut valid, on retourne simplement
- # l'indicateur de validité valid
- return valid
-
- 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(_(u'Opérateur non réentrant : ne pas utiliser reuse'))
- valid=0
-
- if self.sd == None:
- # Le concept produit n'existe pas => erreur
- if cr == 'oui' :
- self.cr.fatal(_(u"Concept retourné non défini"))
- valid = 0
+
+ """
+ """
+
+ def valid_child(self):
+ """ Cette methode teste la validite des mots cles de l'etape """
+ for child in self.mc_liste:
+ if not child.isvalid():
+ return 0
+ return 1
+
+ def valid_regles(self, cr):
+ """ Cette methode teste la validite des regles de l'etape """
+ text_erreurs, test_regles = self.verif_regles()
+ if not test_regles:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Règle(s) non respectée(s) : %s"), text_erreurs)
+ return 0
+ return 1
+
+ def valid_sdnom(self, cr):
+ """ Cette methode teste la validite du nom du concept produit par l'etape """
+ valid = 1
+ if self.sd.nom != None:
+ if self.jdc and self.jdc.definition.code == 'ASTER' and len(self.sd.nom) > 8:
+ # le nom de la sd doit avoir une longueur <= 8 caractères pour
+ # ASTER
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Le nom de concept %s est trop long (8 caractères maxi)"),
+ self.sd.nom)
+ valid = 0
+ if self.sd.nom.find('sansnom') != -1:
+ # la SD est 'sansnom' : --> erreur
+ if cr == 'oui':
+ self.cr.fatal(_(u"Pas de nom pour le concept retourné"))
+ valid = 0
+ elif re.search('^SD_[0-9]*$', self.sd.nom):
+ # la SD est 'SD_' cad son nom = son id donc pas de nom donné
+ # par utilisateur : --> erreur
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Nom de concept invalide ('SD_' est réservé)"))
+ valid = 0
+ return valid
+
+ def get_valid(self):
+ if hasattr(self, 'valid'):
+ return self.valid
else:
- valid = valid * self.valid_sdnom(cr)
+ self.valid = None
+ return None
- if valid:
- valid = self.update_sdprod(cr)
+ def set_valid(self, valid):
+ old_valid = self.get_valid()
+ self.valid = valid
+ self.state = 'unchanged'
+ if not old_valid or old_valid != self.valid:
+ self.init_modif_up()
- self.set_valid(valid)
+ def isvalid(self, sd='oui', cr='non'):
+ """
+ Methode pour verifier la validité de l'objet ETAPE. Cette méthode
+ peut etre appelée selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
- return self.valid
+ Si cr vaut oui elle crée en plus un compte-rendu.
- def update_sdprod(self,cr='non'):
- """
- Cette méthode met à jour le concept produit en fonction des conditions initiales :
+ Cette méthode a plusieurs fonctions :
- 1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
+ - mettre à jour l'état de self (update)
- 2. Le concept retourné n existait pas (self.sd == None)
+ - retourner un indicateur de validité 0=non, 1=oui
- 3. Le concept retourné existait. On change alors son type ou on le supprime
+ - produire un compte-rendu : self.cr
- En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
- """
- sd_prod=self.definition.sd_prod
- if type(sd_prod) == types.FunctionType: # Type de concept retourné calculé
- d=self.cree_dict_valeurs(self.mc_liste)
- try:
- sd_prod= apply(sd_prod,(),d)
- except:
- # Erreur pendant le calcul du type retourné
- 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(_(u'Impossible d affecter un type au résultat\n %s'), ' '.join(l[2:]))
- return 0
- # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
- valid=1
- if self.reuse:
- if AsType(self.reuse) != sd_prod:
- if cr == 'oui' :
- self.cr.fatal(_(u'Type de concept réutilisé incompatible avec type produit'))
- valid= 0
- 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(_(u'Concept réutilisé : le nom de la variable de '
- u'retour devrait être %s et non %s'),
- self.reuse.nom, self.sdnom)
- valid= 0
- if valid:self.sd=self.reuse
- else:
- if sd_prod == None:# Pas de concept retourné
- # Que faut il faire de l eventuel ancien sd ?
- self.sd = None
+ """
+ if CONTEXT.debug:
+ print "ETAPE.isvalid ", self.nom
+ if self.state == 'unchanged':
+ return self.valid
else:
- if self.sd:
- # Un sd existe deja, on change son type
- if CONTEXT.debug:print "changement de type:",self.sd,sd_prod
- if self.sd.__class__ != sd_prod:
- self.sd.change_type(sd_prod)
- else:
- # Le sd n existait pas , on ne le crée pas
- if cr == 'oui' :
- self.cr.fatal(_(u"Concept retourné non défini"))
- valid=0
- if self.definition.reentrant == 'o':
- if cr == 'oui' :
- self.cr.fatal(_(u'Commande obligatoirement réentrante : spécifier reuse=concept'))
- valid=0
- return valid
-
-
- def report(self):
- """
- Methode pour generation d un rapport de validite
- """
- self.cr=self.CR(debut=tr('Etape : ')+tr(self.nom) +' ' \
- + tr(' ligne : ')+`self.appel[0]`\
- + tr(' fichier :')+`self.appel[1]`,
- fin = tr('Fin Etape : ')+tr(self.nom))
- self.state = 'modified'
- try:
- self.isvalid(cr='oui')
- except AsException,e:
- if CONTEXT.debug : traceback.print_exc()
- self.cr.fatal(tr('Etape : ')+tr(self.nom) \
- + tr(' ligne : ')+`self.appel[0]`\
- + tr(' fichier :')+`self.appel[1]`, +e)
- for child in self.mc_liste:
- self.cr.add(child.report())
- return self.cr
-
+ valid = self.valid_child()
+ valid = valid * self.valid_regles(cr)
+
+ if self.reste_val != {}:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
+ valid = 0
+
+ if sd == "non":
+ # Dans ce cas, on ne teste qu'une validité partielle (sans tests sur le concept produit)
+ # Conséquence : on ne change pas l'état ni l'attribut valid, on retourne simplement
+ # l'indicateur de validité valid
+ return valid
+
+ 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(
+ _(u'Opérateur non réentrant : ne pas utiliser reuse'))
+ valid = 0
+
+ if self.sd == None:
+ # Le concept produit n'existe pas => erreur
+ if cr == 'oui':
+ self.cr.fatal(_(u"Concept retourné non défini"))
+ valid = 0
+ else:
+ valid = valid * self.valid_sdnom(cr)
+
+ if valid:
+ valid = self.update_sdprod(cr)
+
+ self.set_valid(valid)
+
+ return self.valid
+
+ def update_sdprod(self, cr='non'):
+ """
+ Cette méthode met à jour le concept produit en fonction des conditions initiales :
+
+ 1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
+
+ 2. Le concept retourné n existait pas (self.sd == None)
+
+ 3. Le concept retourné existait. On change alors son type ou on le supprime
+
+ En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
+ """
+ sd_prod = self.definition.sd_prod
+ if type(sd_prod) == types.FunctionType: # Type de concept retourné calculé
+ d = self.cree_dict_valeurs(self.mc_liste)
+ try:
+ sd_prod = apply(sd_prod, (), d)
+ except:
+ # Erreur pendant le calcul du type retourné
+ 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(
+ _(u'Impossible d affecter un type au résultat\n %s'), ' '.join(l[2:]))
+ return 0
+ # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la
+ # cr\351er
+ valid = 1
+ if self.reuse:
+ if AsType(self.reuse) != sd_prod:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u'Type de concept réutilisé incompatible avec type produit'))
+ valid = 0
+ 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(_(u'Concept réutilisé : le nom de la variable de '
+ u'retour devrait être %s et non %s'),
+ self.reuse.nom, self.sdnom)
+ valid = 0
+ if valid:
+ self.sd = self.reuse
+ else:
+ if sd_prod == None: # Pas de concept retourné
+ # Que faut il faire de l eventuel ancien sd ?
+ self.sd = None
+ else:
+ if self.sd:
+ # Un sd existe deja, on change son type
+ if CONTEXT.debug:
+ print "changement de type:", self.sd, sd_prod
+ if self.sd.__class__ != sd_prod:
+ self.sd.change_type(sd_prod)
+ else:
+ # Le sd n existait pas , on ne le crée pas
+ if cr == 'oui':
+ self.cr.fatal(_(u"Concept retourné non défini"))
+ valid = 0
+ if self.definition.reentrant == 'o':
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u'Commande obligatoirement réentrante : spécifier reuse=concept'))
+ valid = 0
+ return valid
+
+ def report(self):
+ """
+ Methode pour generation d un rapport de validite
+ """
+ self.cr = self.CR(debut=u'Etape : ' + self.nom
+ + u' ligne : ' + `self.appel[0]`
+ + u' fichier : ' + `self.appel[1]`,
+ fin=u'Fin Etape : ' + self.nom)
+ self.state = 'modified'
+ try:
+ self.isvalid(cr='oui')
+ except AsException, e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal(_(u'Etape : %s ligne : %r fichier : %r %s'),
+ self.nom, self.appel[0], self.appel[1], e)
+ i = 0
+ for child in self.mc_liste:
+ i += 1
+ if i > MAXSIZE:
+ print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mc_liste)))
+ break
+ self.cr.add(child.report())
+ return self.cr
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
-#
-
+# ======================================================================
class EXCLUS:
- """
- La règle vérifie qu'un seul mot-clé de self.mcs est present
- parmi les elements de args.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self,args):
- """
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text =''
- count=0
- args = self.liste_to_dico(args)
- for mc in self.mcs:
- if args.has_key(mc):count=count+1
- if count > 1:
- text= u"- Il ne faut qu un mot clé parmi : "+`self.mcs`+'\n'
- return text,0
- return text,1
+ """
+ La règle vérifie qu'un seul mot-clé de self.mcs est present
+ parmi les elements de args.
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique à la règle.
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ''
+ count = 0
+ args = self.liste_to_dico(args)
+ for mc in self.mcs:
+ if args.has_key(mc):
+ count = count + 1
+ if count > 1:
+ text = u"- Il ne faut qu un mot clé parmi : " + `self.mcs`+'\n'
+ return text, 0
+ return text, 1
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe mixin JDC qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type JDC
- dérivé de OBJECT.
+ Ce module contient la classe mixin JDC qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type JDC
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules EFICAS
import V_MCCOMPO
from Noyau.strfunc import ufmt
-try :
- from Extensions.i18n import tr
-except :
- def tr(txt):
- return txt
-
-
class JDC(V_MCCOMPO.MCCOMPO):
- """
- """
- def report(self):
- """
- Methode pour generation d un rapport de validite
- """
- self.cr.purge()
- self.cr.debut=tr("DEBUT CR validation : ")+self.nom
- self.cr.fin=tr("FIN CR validation : ")+self.nom
- for e in self.etapes :
- if e.isactif():
- self.cr.add(e.report())
- self.state = 'modified'
- self.isvalid(cr='oui')
- return self.cr
+ """
+ """
- def isvalid(self,cr='non'):
- """
- Méthode booléenne qui retourne 0 si le JDC est invalide, 1 sinon
- """
- # FR : on prend en compte l'état du JDC ('unchanged','modified','undetermined')
- # afin d'accélérer le test de validité du JDC
- if self.state == 'unchanged':
- return self.valid
- else:
- valid = 1
- texte,test = self.verif_regles()
- if test == 0:
- if cr == 'oui':
- self.cr.fatal(' '.strip(texte))
- valid = 0
- if valid :
- for e in self.etapes:
- if not e.isactif() : continue
- if not e.isvalid():
- valid = 0
- break
- self.state="unchanged"
- self.valid = valid
- return self.valid
+ def report(self):
+ """
+ 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
+ for e in self.etapes:
+ if e.isactif():
+ self.cr.add(e.report())
+ self.state = 'modified'
+ self.isvalid(cr='oui')
+ return self.cr
- def verif_regles(self):
- """
- Effectue la vérification de validité des règles du jeu de commandes
- """
- noms_etapes = [etape.nom for etape in self.etapes]
- texte_global = ''
- test_global = 1
- for regle in self.regles:
- texte, test = regle.verif(noms_etapes)
- texte_global = texte_global + texte
- test_global = test_global*test
- return texte_global, test_global
+ def isvalid(self, cr='non'):
+ """
+ Méthode booléenne qui retourne 0 si le JDC est invalide, 1 sinon
+ """
+ # FR : on prend en compte l'état du JDC ('unchanged','modified','undetermined')
+ # afin d'accélérer le test de validité du JDC
+ if self.state == 'unchanged':
+ return self.valid
+ else:
+ valid = 1
+ texte, test = self.verif_regles()
+ if test == 0:
+ if cr == 'oui':
+ self.cr.fatal(' '.strip(texte))
+ valid = 0
+ if valid:
+ for e in self.etapes:
+ if not e.isactif():
+ continue
+ if not e.isvalid():
+ valid = 0
+ break
+ self.state = "unchanged"
+ self.valid = valid
+ return self.valid
+ def verif_regles(self):
+ """
+ Effectue la vérification de validité des règles du jeu de commandes
+ """
+ noms_etapes = [etape.nom for etape in self.etapes]
+ texte_global = ''
+ test_global = 1
+ for regle in self.regles:
+ texte, test = regle.verif(noms_etapes)
+ texte_global = texte_global + texte
+ test_global = test_global * test
+ return texte_global, test_global
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe mixin MACRO_ETAPE qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MACRO_ETAPE
- dérivé de OBJECT.
+ Ce module contient la classe mixin MACRO_ETAPE qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type MACRO_ETAPE
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules Python
import types
from Noyau.N_utils import AsType
from Noyau.strfunc import ufmt
+
class MACRO_ETAPE(V_ETAPE.ETAPE):
- """
- """
-
- def isvalid(self,sd='oui',cr='non'):
- """
- Methode pour verifier la validité de l'objet ETAPE. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
- de sd et de cr.
-
- Si cr vaut oui elle crée en plus un compte-rendu.
-
- Cette méthode a plusieurs fonctions :
-
- - mettre à jour l'état de self (update)
-
- - retourner un indicateur de validité 0=non, 1=oui
-
- - produire un compte-rendu : self.cr
-
- """
- if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
- if self.state == 'unchanged' :
- return self.valid
- else:
- valid=1
- # On marque les concepts CO pour verification ulterieure de leur bonne utilisation
- l = self.get_all_co()
- # On verifie que les concepts CO sont bien passes par type_sdprod
- for c in l:
- #if c.etape is self.parent:
- if c.is_typco() != 2:
- # le concept est propriete de l'etape parent
- # Il n'a pas ete transforme par type_sdprod
- # Cette situation est interdite
- # Pb: La macro-commande a passe le concept a une commande (macro ?) mal definie
- if cr =='oui':
- self.cr.fatal(_(u"Macro-commande mal définie : le concept n'a pas été typé par "
- u"un appel à type_sdprod pour %s"), c.nom)
- valid=0
-
- valid=valid * self.valid_child()
- valid=valid * self.valid_regles(cr)
-
- if self.reste_val != {}:
- if cr == 'oui' :
- self.cr.fatal(_(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
- valid=0
-
- if sd == "non":
- # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'état de self
- # on retourne simplement l'indicateur valid
- return valid
-
- if self.sd != None :
- valid = valid * self.valid_sdnom(cr)
-
- 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(_(u'Macro-commande non réentrante : ne pas utiliser reuse'))
- valid=0
-
- if valid:
- valid = self.update_sdprod(cr)
-
- # Si la macro comprend des etapes internes, on teste leur validite
- for e in self.etapes:
- if not e.isvalid():
- valid=0
- break
-
- self.set_valid(valid)
-
- return self.valid
-
- def update_sdprod(self,cr='non'):
- """
- Cette méthode met à jour le concept produit en fonction des conditions initiales :
-
- 1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
-
- 2. Le concept retourné n existait pas (self.sd == None)
-
- 3. Le concept retourné existait. On change alors son type ou on le supprime
-
- En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
- """
- sd_prod=self.definition.sd_prod
- # On memorise le type retourné dans l attribut typret
- self.typret=None
- if type(sd_prod) == types.FunctionType:
- # Type de concept retourné calculé
- d=self.cree_dict_valeurs(self.mc_liste)
- try:
- # la sd_prod d'une macro a l'objet lui meme en premier argument
- # contrairement à une ETAPE ou PROC_ETAPE
- # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
- # les concepts produits dans self.sdprods, il faut le mettre à zéro
- self.sdprods=[]
- sd_prod= apply(sd_prod,(self,),d)
- except:
- # Erreur pendant le calcul du type retourné
- 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(_(u'Impossible d affecter un type au résultat\n%s'), ' '.join(l[2:]))
- return 0
- # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
- valid=1
- if self.reuse:
- # Un concept reutilise a ete specifie
- if AsType(self.reuse) != sd_prod:
- if cr == 'oui' :
- self.cr.fatal(_(u'Type de concept réutilisé incompatible avec type produit'))
- valid=0
- 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(_(u'Concept réutilisé : le nom de la variable de '
- u'retour devrait être %s et non %s'),
- self.reuse.nom, self.sdnom)
- valid= 0
- if valid:self.sd=self.reuse
- else:
- #Cas d'un concept non reutilise
- if sd_prod == None:# Pas de concept retourné
- # Que faut il faire de l eventuel ancien sd ?
- self.sd = None
- else:
- if self.sd:
- # Un sd existe deja, on change son type
- if CONTEXT.debug:print "changement de type:",self.sd,sd_prod
- if self.sd.__class__ != sd_prod:
- self.sd.change_type(sd_prod)
- self.typret=sd_prod
- else:
- # Le sd n existait pas , on ne le crée pas
- self.typret=sd_prod
- if cr == 'oui' :
- self.cr.fatal(_(u"Concept retourné non défini"))
- valid=0
- if self.definition.reentrant == 'o':
- if cr == 'oui' :
- self.cr.fatal(_(u'Commande obligatoirement réentrante : spécifier reuse=concept'))
- valid=0
- return valid
-
- def report(self):
- """
- Methode pour la generation d un rapport de validation
- """
- V_ETAPE.ETAPE.report(self)
- for e in self.etapes :
- self.cr.add(e.report())
- return self.cr
+ """
+ """
+
+ def isvalid(self, sd='oui', cr='non'):
+ """
+ Methode pour verifier la validité de l'objet ETAPE. Cette méthode
+ peut etre appelée selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
+
+ Si cr vaut oui elle crée en plus un compte-rendu.
+
+ Cette méthode a plusieurs fonctions :
+
+ - mettre à jour l'état de self (update)
+
+ - retourner un indicateur de validité 0=non, 1=oui
+
+ - produire un compte-rendu : self.cr
+
+ """
+ if CONTEXT.debug:
+ print "ETAPE.isvalid ", self.nom
+ if self.state == 'unchanged':
+ return self.valid
+ else:
+ valid = 1
+ # On marque les concepts CO pour verification ulterieure de leur
+ # bonne utilisation
+ l = self.get_all_co()
+ # On verifie que les concepts CO sont bien passes par type_sdprod
+ for c in l:
+ # if c.etape is self.parent:
+ if c.is_typco() != 2:
+ # le concept est propriete de l'etape parent
+ # Il n'a pas ete transforme par type_sdprod
+ # Cette situation est interdite
+ # Pb: La macro-commande a passe le concept a une commande
+ # (macro ?) mal definie
+ if cr == 'oui':
+ self.cr.fatal(_(u"Macro-commande mal définie : le concept n'a pas été typé par "
+ u"un appel à type_sdprod pour %s"), c.nom)
+ valid = 0
+
+ valid = valid * self.valid_child()
+ valid = valid * self.valid_regles(cr)
+
+ if self.reste_val != {}:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
+ valid = 0
+
+ if sd == "non":
+ # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'état de self
+ # on retourne simplement l'indicateur valid
+ return valid
+
+ if self.sd != None:
+ valid = valid * self.valid_sdnom(cr)
+
+ 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(
+ _(u'Macro-commande non réentrante : ne pas utiliser reuse'))
+ valid = 0
+
+ if valid:
+ valid = self.update_sdprod(cr)
+
+ # Si la macro comprend des etapes internes, on teste leur validite
+ for e in self.etapes:
+ if not e.isvalid():
+ valid = 0
+ break
+
+ self.set_valid(valid)
+
+ return self.valid
+
+ def update_sdprod(self, cr='non'):
+ """
+ Cette méthode met à jour le concept produit en fonction des conditions initiales :
+
+ 1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
+
+ 2. Le concept retourné n existait pas (self.sd == None)
+
+ 3. Le concept retourné existait. On change alors son type ou on le supprime
+
+ En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
+ """
+ sd_prod = self.definition.sd_prod
+ # On memorise le type retourné dans l attribut typret
+ self.typret = None
+ if type(sd_prod) == types.FunctionType:
+ # Type de concept retourné calculé
+ d = self.cree_dict_valeurs(self.mc_liste)
+ try:
+ # la sd_prod d'une macro a l'objet lui meme en premier argument
+ # contrairement à une ETAPE ou PROC_ETAPE
+ # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
+ # les concepts produits dans self.sdprods, il faut le mettre à
+ # zéro
+ self.sdprods = []
+ sd_prod = apply(sd_prod, (self,), d)
+ except:
+ # Erreur pendant le calcul du type retourné
+ 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(
+ _(u'Impossible d affecter un type au résultat\n%s'), ' '.join(l[2:]))
+ return 0
+ # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la
+ # cr\351er
+ valid = 1
+ if self.reuse:
+ # Un concept reutilise a ete specifie
+ if AsType(self.reuse) != sd_prod:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u'Type de concept réutilisé incompatible avec type produit'))
+ valid = 0
+ 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(_(u'Concept réutilisé : le nom de la variable de '
+ u'retour devrait être %s et non %s'),
+ self.reuse.nom, self.sdnom)
+ valid = 0
+ if valid:
+ self.sd = self.reuse
+ else:
+ # Cas d'un concept non reutilise
+ if sd_prod == None: # Pas de concept retourné
+ # Que faut il faire de l eventuel ancien sd ?
+ self.sd = None
+ else:
+ if self.sd:
+ # Un sd existe deja, on change son type
+ if CONTEXT.debug:
+ print "changement de type:", self.sd, sd_prod
+ if self.sd.__class__ != sd_prod:
+ self.sd.change_type(sd_prod)
+ self.typret = sd_prod
+ else:
+ # Le sd n existait pas , on ne le crée pas
+ self.typret = sd_prod
+ if cr == 'oui':
+ self.cr.fatal(_(u"Concept retourné non défini"))
+ valid = 0
+ if self.definition.reentrant == 'o':
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u'Commande obligatoirement réentrante : spécifier reuse=concept'))
+ valid = 0
+ return valid
+
+ def report(self):
+ """
+ Methode pour la generation d un rapport de validation
+ """
+ V_ETAPE.ETAPE.report(self)
+ for e in self.etapes:
+ self.cr.add(e.report())
+ return self.cr
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe mixin MCBLOC qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCBLOC
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCBLOC qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type MCBLOC
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules EFICAS
import V_MCCOMPO
from Noyau.strfunc import ufmt
+
class MCBLOC(V_MCCOMPO.MCCOMPO):
- """
- Cette classe a un attribut de classe :
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
- """
+ """
+ Cette classe a un attribut de classe :
- txt_nat = u"Bloc :"
+ - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ """
- def isvalid(self,sd='oui',cr='non'):
- """
- Methode pour verifier la validité du MCBLOC. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
- de sd et de cr.
+ txt_nat = u"Bloc :"
- Si cr vaut oui elle crée en plus un compte-rendu
- sd est présent pour compatibilité de l'interface mais ne sert pas
- """
- if self.state == 'unchanged' :
- return self.valid
- else:
- valid = 1
- if hasattr(self,'valid'):
- old_valid = self.valid
- else:
- old_valid = None
- for child in self.mc_liste :
- if not child.isvalid():
- valid = 0
- break
- # Après avoir vérifié la validité de tous les sous-objets, on vérifie
- # la validité des règles
- text_erreurs,test_regles = self.verif_regles()
- if not test_regles :
- if cr == 'oui':
- self.cr.fatal(_(u"Règle(s) non respectée(s) : %s"), text_erreurs)
- valid = 0
- self.valid = valid
- self.state = 'unchanged'
- if not old_valid or old_valid != self.valid :
- self.init_modif_up()
- return self.valid
+ def isvalid(self, sd='oui', cr='non'):
+ """
+ Methode pour verifier la validité du MCBLOC. Cette méthode
+ peut etre appelée selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
+ Si cr vaut oui elle crée en plus un compte-rendu
+ sd est présent pour compatibilité de l'interface mais ne sert pas
+ """
+ if self.state == 'unchanged':
+ return self.valid
+ else:
+ valid = 1
+ if hasattr(self, 'valid'):
+ old_valid = self.valid
+ else:
+ old_valid = None
+ for child in self.mc_liste:
+ if not child.isvalid():
+ valid = 0
+ break
+ # Après avoir vérifié la validité de tous les sous-objets, on vérifie
+ # la validité des règles
+ text_erreurs, test_regles = self.verif_regles()
+ if not test_regles:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Règle(s) non respectée(s) : %s"), text_erreurs)
+ valid = 0
+ self.valid = valid
+ self.state = 'unchanged'
+ if not old_valid or old_valid != self.valid:
+ self.init_modif_up()
+ return self.valid
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe de base MCCOMPO qui sert à factoriser
+ Ce module contient la classe de base MCCOMPO qui sert à factoriser
les traitements des objets composites de type OBJECT
"""
# Modules Python
import traceback
# Modules EFICAS
+from Noyau import MAXSIZE, MAXSIZE_MSGCHK
from Noyau import N_CR
from Noyau.N_Exception import AsException
from Noyau.strfunc import ufmt, to_unicode
-class MCCOMPO:
- """
- L'attribut mc_liste a été créé par une classe dérivée de la
- classe MCCOMPO du Noyau
- """
-
- CR=N_CR.CR
-
- def __init__(self):
- self.state = 'undetermined'
- # défini dans les classes dérivées
- self.txt_nat = ''
-
- def init_modif_up(self):
- """
- Propage l'état modifié au parent s'il existe et n'est pas l'objet
- lui-meme
- """
- if self.parent and self.parent != self :
- self.parent.state = 'modified'
-
- def report(self):
- """
- Génère le rapport de validation de self
- """
- self.cr=self.CR()
- self.cr.debut = self.txt_nat+self.nom
- self.cr.fin = u"Fin "+self.txt_nat+self.nom
- for child in self.mc_liste:
- self.cr.add(child.report())
- self.state = 'modified'
- try:
- self.isvalid(cr='oui')
- except AsException,e:
- if CONTEXT.debug : traceback.print_exc()
- self.cr.fatal(' '.join((self.txt_nat, self.nom, str(e))))
- return self.cr
-
- def verif_regles(self):
- """
- A partir du dictionnaire des mots-clés présents, vérifie si les règles
- de self sont valides ou non.
-
- Retourne une chaine et un booléen :
-
- - texte = la chaine contient le message d'erreur de la (les) règle(s) violée(s) ('' si aucune)
-
- - testglob = booléen 1 si toutes les règles OK, 0 sinon
- """
- # On verifie les regles avec les defauts affectés
- dictionnaire = self.dict_mc_presents(restreint='non')
- texte = ['']
- testglob = 1
- for r in self.definition.regles:
- erreurs,test = r.verif(dictionnaire)
- testglob = testglob*test
- if erreurs != '':
- texte.append(to_unicode(erreurs))
- texte = os.linesep.join(texte)
- return texte, testglob
-
- def dict_mc_presents(self,restreint='non'):
- """
- Retourne le dictionnaire {mocle : objet} construit à partir de self.mc_liste
- Si restreint == 'non' : on ajoute tous les mots-clés simples du catalogue qui ont
- une valeur par défaut
- Si restreint == 'oui' : on ne prend que les mots-clés effectivement entrés par
- l'utilisateur (cas de la vérification des règles)
- """
- dico={}
- # on ajoute les couples {nom mot-clé:objet mot-clé} effectivement présents
- for v in self.mc_liste:
- if v == None : continue
- k=v.nom
- dico[k]=v
- if restreint == 'oui' : return dico
- # Si restreint != 'oui',
- # on ajoute les couples {nom mot-clé:objet mot-clé} des mots-clés simples
- # possibles pour peu qu'ils aient une valeur par défaut
- for k,v in self.definition.entites.items():
- if v.label != 'SIMP' : continue
- if not v.defaut : continue
- if not dico.has_key(k):
- 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)
- dico["self"]=self
- return dico
-
+class MCCOMPO:
+ """
+ L'attribut mc_liste a été créé par une classe dérivée de la
+ classe MCCOMPO du Noyau
+ """
+
+ CR = N_CR.CR
+
+ def __init__(self):
+ self.state = 'undetermined'
+ # défini dans les classes dérivées
+ self.txt_nat = ''
+
+ def init_modif_up(self):
+ """
+ Propage l'état modifié au parent s'il existe et n'est pas l'objet
+ lui-meme
+ """
+ if self.parent and self.parent != self:
+ self.parent.state = 'modified'
+
+ def report(self):
+ """
+ Génère le rapport de validation de self
+ """
+ self.cr = self.CR()
+ self.cr.debut = self.txt_nat + self.nom
+ self.cr.fin = u"Fin " + self.txt_nat + self.nom
+ i = 0
+ for child in self.mc_liste:
+ i += 1
+ if i > MAXSIZE:
+ print(MAXSIZE_MSGCHK.format(MAXSIZE, len(self.mc_liste)))
+ break
+ self.cr.add(child.report())
+ self.state = 'modified'
+ try:
+ self.isvalid(cr='oui')
+ except AsException, e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal(' '.join((self.txt_nat, self.nom, str(e))))
+ return self.cr
+
+ def verif_regles(self):
+ """
+ A partir du dictionnaire des mots-clés présents, vérifie si les règles
+ de self sont valides ou non.
+
+ Retourne une chaine et un booléen :
+
+ - texte = la chaine contient le message d'erreur de la (les) règle(s) violée(s) ('' si aucune)
+
+ - testglob = booléen 1 si toutes les règles OK, 0 sinon
+ """
+ # On verifie les regles avec les defauts affectés
+ dictionnaire = self.dict_mc_presents(restreint='non')
+ texte = ['']
+ testglob = 1
+ for r in self.definition.regles:
+ erreurs, test = r.verif(dictionnaire)
+ testglob = testglob * test
+ if erreurs != '':
+ texte.append(to_unicode(erreurs))
+ texte = os.linesep.join(texte)
+ return texte, testglob
+
+ def dict_mc_presents(self, restreint='non'):
+ """
+ Retourne le dictionnaire {mocle : objet} construit à partir de self.mc_liste
+ Si restreint == 'non' : on ajoute tous les mots-clés simples du catalogue qui ont
+ une valeur par défaut
+ Si restreint == 'oui' : on ne prend que les mots-clés effectivement entrés par
+ l'utilisateur (cas de la vérification des règles)
+ """
+ dico = {}
+ # on ajoute les couples {nom mot-clé:objet mot-clé} effectivement
+ # présents
+ for v in self.mc_liste:
+ if v == None:
+ continue
+ k = v.nom
+ dico[k] = v
+ if restreint == 'oui':
+ return dico
+ # Si restreint != 'oui',
+ # on ajoute les couples {nom mot-clé:objet mot-clé} des mots-clés simples
+ # possibles pour peu qu'ils aient une valeur par défaut
+ for k, v in self.definition.entites.items():
+ if v.label != 'SIMP':
+ continue
+ if not v.defaut:
+ continue
+ if not dico.has_key(k):
+ 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)
+ dico["self"] = self
+ return dico
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe mixin MCFACT qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCFACT
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCFACT qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type MCFACT
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules EFICAS
import V_MCCOMPO
from Noyau.strfunc import ufmt
+
class MCFACT(V_MCCOMPO.MCCOMPO):
- """
- Cette classe a un attribut de classe :
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
- """
+ """
+ Cette classe a un attribut de classe :
- txt_nat = u"Mot clé Facteur :"
+ - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ """
- def isvalid(self,sd='oui',cr='non'):
- """
- Methode pour verifier la validité du MCFACT. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
- de sd et de cr.
+ txt_nat = u"Mot clé Facteur :"
- Si cr vaut oui elle crée en plus un compte-rendu
- sd est présent pour compatibilité de l'interface mais ne sert pas
- """
- if self.state == 'unchanged' :
- return self.valid
- else:
- valid = 1
- if hasattr(self,'valid'):
- old_valid = self.valid
- else:
- old_valid = None
- for child in self.mc_liste :
- if not child.isvalid():
- valid = 0
- break
- # Après avoir vérifié la validité de tous les sous-objets, on vérifie
- # la validité des règles
- text_erreurs,test_regles = self.verif_regles()
- if not test_regles :
- if cr == 'oui' : self.cr.fatal(_(u"Règle(s) non respectée(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(_(u"Mot-clé : %s devrait avoir %s"),
- self.nom, self.definition.validators.info())
- valid=0
- # fin des validateurs
- #
- if self.reste_val != {}:
- if cr == 'oui' :
- self.cr.fatal(_(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
- valid=0
- self.valid = valid
- self.state = 'unchanged'
- if not old_valid or old_valid != self.valid :
- self.init_modif_up()
- return self.valid
+ def isvalid(self, sd='oui', cr='non'):
+ """
+ Methode pour verifier la validité du MCFACT. Cette méthode
+ peut etre appelée selon plusieurs modes en fonction de la valeur
+ de sd et de cr.
+ Si cr vaut oui elle crée en plus un compte-rendu
+ sd est présent pour compatibilité de l'interface mais ne sert pas
+ """
+ if self.state == 'unchanged':
+ return self.valid
+ else:
+ valid = 1
+ if hasattr(self, 'valid'):
+ old_valid = self.valid
+ else:
+ old_valid = None
+ for child in self.mc_liste:
+ if not child.isvalid():
+ valid = 0
+ break
+ # Après avoir vérifié la validité de tous les sous-objets, on vérifie
+ # la validité des règles
+ text_erreurs, test_regles = self.verif_regles()
+ if not test_regles:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Règle(s) non respectée(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(_(u"Mot-clé : %s devrait avoir %s"),
+ self.nom, self.definition.validators.info())
+ valid = 0
+ # fin des validateurs
+ #
+ if self.reste_val != {}:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
+ valid = 0
+ self.valid = valid
+ self.state = 'unchanged'
+ if not old_valid or old_valid != self.valid:
+ self.init_modif_up()
+ return self.valid
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe mixin MCList qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCList
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCList qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type MCList
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules Python
import traceback
# Modules EFICAS
+from Noyau import MAXSIZE, MAXSIZE_MSGCHK
from Noyau import N_CR
from Noyau.N_Exception import AsException
from Noyau.strfunc import ufmt
+
class MCList:
- """
- Cette classe a deux attributs de classe :
-
- - CR qui sert à construire l'objet compte-rendu
-
- - txt_nat qui sert pour les comptes-rendus liés à cette classe
- """
-
- CR = N_CR.CR
- txt_nat = u"Mot clé Facteur Multiple :"
-
- def isvalid(self,cr='non'):
- """
- Methode pour verifier la validité du MCList. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
- de cr.
-
- Si cr vaut oui elle crée en plus un compte-rendu.
-
- On n'utilise pas d'attribut pour stocker l'état et on ne remonte pas
- le changement d'état 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
-
- valid= 1
- definition=self.data[0].definition
- # 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(_(u"Nombre de mots clés facteurs insuffisant minimum : %s"),
- definition.min)
-
- if definition.max is not None and len(self.data) > definition.max :
- valid=0
- if cr == 'oui' :
- self.cr.fatal(_(u"Nombre de mots clés 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(_(u"L'occurrence numéro %d du mot-clé facteur : %s n'est pas valide"),
- num, self.nom)
- return valid
-
- def report(self):
- """
- Génère le rapport de validation de self
- """
- if len(self) > 1:
- # Mot cle facteur multiple
- self.cr=self.CR( debut = u"Mot-clé facteur multiple : "+self.nom,
- fin = u"Fin Mot-clé facteur multiple : "+self.nom)
- for i in self.data:
- 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 = u"Mot-clé facteur : "+self.nom,
- fin = u"Fin Mot-clé facteur : "+self.nom)
-
- try :
- self.isvalid(cr='oui')
- except AsException,e:
- if CONTEXT.debug : traceback.print_exc()
- self.cr.fatal(_(u"Mot-clé facteur multiple : %s, %s"), self.nom, e)
- return self.cr
+ """
+ Cette classe a deux attributs de classe :
+
+ - CR qui sert à construire l'objet compte-rendu
+
+ - txt_nat qui sert pour les comptes-rendus liés à cette classe
+ """
+
+ CR = N_CR.CR
+ txt_nat = u"Mot clé Facteur Multiple :"
+
+ def isvalid(self, cr='non'):
+ """
+ Methode pour verifier la validité du MCList. Cette méthode
+ peut etre appelée selon plusieurs modes en fonction de la valeur
+ de cr.
+
+ Si cr vaut oui elle crée en plus un compte-rendu.
+
+ On n'utilise pas d'attribut pour stocker l'état et on ne remonte pas
+ le changement d'état 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
+
+ valid = 1
+ definition = self.data[0].definition
+ # 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(
+ _(u"Nombre de mots clés facteurs insuffisant minimum : %s"),
+ definition.min)
+
+ if definition.max is not None and len(self.data) > definition.max:
+ valid = 0
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Nombre de mots clés 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(
+ _(u"L'occurrence numéro %d du mot-clé facteur : %s n'est pas valide"),
+ num, self.nom)
+ return valid
+
+ def report(self):
+ """
+ Génère le rapport de validation de self
+ """
+ if len(self) > 1:
+ # Mot cle facteur multiple
+ self.cr = self.CR(
+ debut=u"Mot-clé facteur multiple : " + self.nom,
+ fin=u"Fin Mot-clé facteur multiple : " + self.nom)
+ j = 0
+ for i in self.data:
+ j += 1
+ if j > MAXSIZE:
+ 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=u"Mot-clé facteur : " + self.nom,
+ fin=u"Fin Mot-clé facteur : " + self.nom)
+
+ try:
+ self.isvalid(cr='oui')
+ except AsException, e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal(_(u"Mot-clé facteur multiple : %s, %s"), self.nom, e)
+ return self.cr
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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 la classe mixin MCSIMP qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type MCSIMP
- dérivé de OBJECT.
+ Ce module contient la classe mixin MCSIMP qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type MCSIMP
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules Python
import traceback
# Modules EFICAS
from Noyau import N_CR
from Noyau.N_Exception import AsException
-from Noyau.N_VALIDATOR import ValError,TypeProtocol,CardProtocol,IntoProtocol
+from Noyau.N_VALIDATOR import ValError, TypeProtocol, CardProtocol, IntoProtocol
from Noyau.N_VALIDATOR import listProto
from Noyau.strfunc import ufmt
-try :
- from Extensions.i18n import tr
-except :
- def tr(txt):
- return txt
-#print '___________'
-#print (tr(u"None n'est pas une valeur autorisée"))
-#print '___________'
class MCSIMP:
- """
- COMMENTAIRE CCAR:
- Cette classe est quasiment identique à la classe originale d'EFICAS
- a part quelques changements cosmétiques et des chagements pour la
- faire fonctionner de facon plus autonome par rapport à l'environnement
- EFICAS
-
- A mon avis, il faudrait aller plus loin et réduire les dépendances
- amont au strict nécessaire.
-
- - Est il indispensable de faire l'évaluation de la valeur dans le contexte
- du jdc dans cette classe.
-
- - Ne pourrait on pas doter les objets en présence des méthodes suffisantes
- pour éviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
- d'ailleurs modifié la classe pour éviter l'import de GEOM
- """
-
- CR=N_CR.CR
-
- def __init__(self):
- 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)
- self.cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
-
- def get_valid(self):
- if hasattr(self,'valid'):
- return self.valid
- else:
- self.valid=None
- return None
-
- def set_valid(self,valid):
- old_valid=self.get_valid()
- self.valid = valid
- self.state = 'unchanged'
- if not old_valid or old_valid != self.valid :
- self.init_modif_up()
-
- def isvalid(self,cr='non'):
- """
- Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
-
- - 0 si l'objet est invalide
- - 1 si l'objet est valide
-
- Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
- la méthode construit également un comte-rendu de validation
- dans self.cr qui doit avoir été créé préalablement.
- """
- if self.state == 'unchanged':
- return self.valid
- else:
- valid = 1
- v=self.valeur
- # verification presence
- if self.isoblig() and v == None :
- if cr == 'oui' :
- self.cr.fatal(_(tr(u"Mot-clé : %s obligatoire non valorisé")), self.nom)
- valid = 0
-
- lval=listProto.adapt(v)
- #Pour tenir compte des Tuples
- if hasattr(self.definition.type[0],'ntuple') :
- try :
- if not (type(lval[0]) is tuple) : lval=(lval,)
- except :
- pass
- if lval is None:
- valid=0
- if cr == 'oui' :
- self.cr.fatal(_(tr(u"None n'est pas une valeur autorisée")))
- else:
- # type,into ...
- #typeProto=TypeProtocol("type",typ=self.definition.type)
- #intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
- #cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
- #typeProto=self.definition.typeProto
- #intoProto=self.definition.intoProto
- #cardProto=self.definition.cardProto
- typeProto=self.typeProto
- intoProto=self.intoProto
- cardProto=self.cardProto
- if cr == 'oui' :
- #un cr est demandé : on collecte tous les types d'erreur
- try:
- for val in lval:
- typeProto.adapt(val)
- except ValError,e:
- valid=0
- self.cr.fatal(*e)
- try:
- for val in lval:
- intoProto.adapt(val)
- except ValError,e:
- valid=0
- self.cr.fatal(*e)
- #self.cr.fatal(unicode(e))
- try:
- cardProto.adapt(lval)
- except ValError,e:
- valid=0
- self.cr.fatal(*e)
- #self.cr.fatal(unicode(e))
- #
- # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
- #
- if valid and self.definition.validators:
- try:
- self.definition.validators.convert(lval)
- except ValError,e:
- self.cr.fatal(_(tr(u"Mot-clé %s invalide : %s\nCritère de validité: %s")),
- self.nom, str(e), self.definition.validators.info())
- valid=0
- else:
- #si pas de cr demande, on sort a la toute premiere erreur
- try:
- for val in lval:
- typeProto.adapt(val)
- intoProto.adapt(val)
- cardProto.adapt(lval)
- if self.definition.validators:
- if hasattr(self.definition.validators,'set_MCSimp'):
- self.definition.validators.set_MCSimp(self)
- self.definition.validators.convert(lval)
- except ValError,e:
- valid=0
-
- self.set_valid(valid)
- return self.valid
-
- def isoblig(self):
- """ indique si le mot-clé est obligatoire
- """
- return self.definition.statut=='o'
-
- def init_modif_up(self):
- """
- Propage l'état modifié au parent s'il existe et n'est l'objet
- lui-meme
- """
- if self.parent and self.parent != self :
- self.parent.state = 'modified'
-
- def report(self):
- """ génère le rapport de validation de self """
- self.cr=self.CR()
- self.cr.debut = tr("Mot-clef simple : ")+tr(self.nom)
- self.cr.fin = tr(u"Fin Mot-clé simple : ")+tr(self.nom)
- self.state = 'modified'
- try:
- self.isvalid(cr='oui')
- except AsException,e:
- if CONTEXT.debug : traceback.print_exc()
- self.cr.fatal(_(tr(u"Mot-clé simple : %s %s")), self.nom, e)
- return self.cr
-
-
-
-
-
+ """
+ COMMENTAIRE CCAR:
+ Cette classe est quasiment identique à la classe originale d'EFICAS
+ a part quelques changements cosmétiques et des chagements pour la
+ faire fonctionner de facon plus autonome par rapport à l'environnement
+ EFICAS
+
+ A mon avis, il faudrait aller plus loin et réduire les dépendances
+ amont au strict nécessaire.
+
+ - Est il indispensable de faire l'évaluation de la valeur dans le contexte
+ du jdc dans cette classe.
+
+ - Ne pourrait on pas doter les objets en présence des méthodes suffisantes
+ pour éviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
+ d'ailleurs modifié la classe pour éviter l'import de GEOM
+ """
+
+ CR = N_CR.CR
+
+ def __init__(self):
+ 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)
+ self.cardProto = CardProtocol(
+ "card", min=self.definition.min, max=self.definition.max)
+
+ def get_valid(self):
+ if hasattr(self, 'valid'):
+ return self.valid
+ else:
+ self.valid = None
+ return None
+
+ def set_valid(self, valid):
+ old_valid = self.get_valid()
+ self.valid = valid
+ self.state = 'unchanged'
+ if not old_valid or old_valid != self.valid:
+ self.init_modif_up()
+
+ def isvalid(self, cr='non'):
+ """
+ Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
+
+ - 0 si l'objet est invalide
+ - 1 si l'objet est valide
+
+ Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
+ la méthode construit également un comte-rendu de validation
+ dans self.cr qui doit avoir été créé préalablement.
+ """
+ if self.state == 'unchanged':
+ return self.valid
+ else:
+ valid = 1
+ v = self.valeur
+ # verification presence
+ if self.isoblig() and v == None:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Mot-clé : %s obligatoire non valorisé"), 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) : lval=(lval,)
+ except :
+ pass
+
+ if lval is None:
+ valid = 0
+ if cr == 'oui':
+ self.cr.fatal(_(u"None n'est pas une valeur autorisée"))
+ else:
+ # type,into ...
+ # typeProto=TypeProtocol("type",typ=self.definition.type)
+ # intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
+ # cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
+ # typeProto=self.definition.typeProto
+ # intoProto=self.definition.intoProto
+ # cardProto=self.definition.cardProto
+ typeProto = self.typeProto
+ intoProto = self.intoProto
+ cardProto = self.cardProto
+ if cr == 'oui':
+ # un cr est demandé : on collecte tous les types d'erreur
+ try:
+ for val in lval:
+ typeProto.adapt(val)
+ except ValError, e:
+ valid = 0
+ self.cr.fatal(*e)
+ try:
+ for val in lval:
+ intoProto.adapt(val)
+ except ValError, e:
+ valid = 0
+ self.cr.fatal(*e)
+ try:
+ cardProto.adapt(lval)
+ except ValError, e:
+ valid = 0
+ self.cr.fatal(*e)
+ #
+ # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
+ #
+ if valid and self.definition.validators:
+ try:
+ self.definition.validators.convert(lval)
+ except ValError, e:
+ self.cr.fatal(
+ _(u"Mot-clé %s invalide : %s\nCritère de validité: %s"),
+ self.nom, str(e), self.definition.validators.info())
+ valid = 0
+ else:
+ # si pas de cr demande, on sort a la toute premiere erreur
+ try:
+ for val in lval:
+ typeProto.adapt(val)
+ intoProto.adapt(val)
+ cardProto.adapt(lval)
+ if self.definition.validators:
+ if hasattr(self.definition.validators, 'set_MCSimp'):
+ self.definition.validators.set_MCSimp(self)
+ self.definition.validators.convert(lval)
+ except ValError, e:
+ valid = 0
+
+ self.set_valid(valid)
+ return self.valid
+
+ def isoblig(self):
+ """ indique si le mot-clé est obligatoire
+ """
+ return self.definition.statut == 'o'
+
+ def init_modif_up(self):
+ """
+ Propage l'état modifié au parent s'il existe et n'est l'objet
+ lui-meme
+ """
+ if self.parent and self.parent != self:
+ self.parent.state = 'modified'
+
+ def report(self):
+ """ génère le rapport de validation de self """
+ self.cr = self.CR()
+ self.cr.debut = u"Mot-clé simple : " + self.nom
+ self.cr.fin = u"Fin Mot-clé simple : " + self.nom
+ self.state = 'modified'
+ try:
+ self.isvalid(cr='oui')
+ except AsException, e:
+ if CONTEXT.debug:
+ traceback.print_exc()
+ self.cr.fatal(_(u"Mot-clé simple : %s %s"), self.nom, e)
+ return self.cr
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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
+# 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.
+# ======================================================================
+# person_in_charge: mathieu.courtois at edf.fr
+
class MEME_NOMBRE:
- """
- La règle MEME_NOMBRE vérifie que l'on trouve au moins un des mots-clés
- de la règle parmi les arguments d'un OBJECT.
-
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self,args):
- """
- La méthode verif vérifie que l'on trouve au moins un des mos-clés
- de la liste self.mcs parmi les éléments de args
-
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text =''
- args = self.liste_to_dico(args)
- size = -1
-
- for mc in self.mcs:
- if mc not in args.keys():
- text = u"Une clé dans la règle n'existe pas %s" % mc
- return text,0
-
- val = args[mc].valeur
- len_val = 0
- if not isinstance(val,type([])):
- len_val = 1
- else:
- len_val = len(val)
-
- if size == -1:
- size = len_val
- elif size != len_val:
- text = u"Pas la même longeur"
- return text,0
- return text,1
+ """
+ La règle MEME_NOMBRE vérifie que l'on trouve au moins un des mots-clés
+ de la règle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
+
+ def verif(self, args):
+ """
+ La méthode verif vérifie que l'on trouve au moins un des mos-clés
+ de la liste self.mcs parmi les éléments de args
+
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ''
+ args = self.liste_to_dico(args)
+ size = -1
+
+ for mc in self.mcs:
+ if mc not in args.keys():
+ text = u"Une clé dans la règle n'existe pas %s" % mc
+ return text, 0
+
+ val = args[mc].valeur
+ len_val = 0
+ if not isinstance(val, type([])):
+ len_val = 1
+ else:
+ len_val = len(val)
+
+ if size == -1:
+ size = len_val
+ elif size != len_val:
+ text = u"Pas la même longeur"
+ return text, 0
+ return text, 1
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
+# ======================================================================
+class PRESENT_ABSENT:
-class PRESENT_ABSENT:
- """
- La règle vérifie que si le premier mot-clé de self.mcs est present
- parmi les elements de args les autres mots clés de self.mcs
- doivent etre absents
-
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self,args):
- """
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on verifie que si le premier de la liste est present,
- # les autres sont absents
- text=''
- test = 1
- args = self.liste_to_dico(args)
- mc0=self.mcs[0]
- if args.has_key(mc0):
- for mc in self.mcs[1:len(self.mcs)]:
- if args.has_key(mc):
- text = text + u"- Le mot clé "+`mc0`+ u" étant présent, il faut que : "+\
- mc+" soit absent"+'\n'
- test = 0
- return text,test
+ """
+ La règle vérifie que si le premier mot-clé de self.mcs est present
+ parmi les elements de args les autres mots clés de self.mcs
+ doivent etre absents
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique à la règle.
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on verifie que si le premier de la liste est present,
+ # les autres sont absents
+ text = ''
+ test = 1
+ args = self.liste_to_dico(args)
+ mc0 = self.mcs[0]
+ if args.has_key(mc0):
+ for mc in self.mcs[1:len(self.mcs)]:
+ if args.has_key(mc):
+ text = text + u"- Le mot clé " + `mc0`+ u" étant présent, il faut que : " +\
+ mc + " soit absent" + '\n'
+ test = 0
+ return text, test
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
#
+# ======================================================================
class PRESENT_PRESENT:
- """
- La règle vérifie que si le premier mot-clé de self.mcs est present
- parmi les elements de args les autres doivent l'etre aussi
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self,args):
- """
- La methode verif effectue la verification specifique à la règle.
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on verifie que si le premier de la liste est present,
- # les autres le sont aussi
- mc0=self.mcs[0]
- text=''
- test = 1
- args = self.liste_to_dico(args)
- if args.has_key(mc0):
- for mc in self.mcs[1:len(self.mcs)]:
- if not args.has_key(mc):
- text = text + u"- Le mot clé "+`mc0`+ u" étant présent, il faut que : "+mc+ u" soit présent"+'\n'
- test = 0
- return text,test
+ """
+ La règle vérifie que si le premier mot-clé de self.mcs est present
+ parmi les elements de args les autres doivent l'etre aussi
+
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
+ def verif(self, args):
+ """
+ La methode verif effectue la verification specifique à la règle.
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on verifie que si le premier de la liste est present,
+ # les autres le sont aussi
+ mc0 = self.mcs[0]
+ text = ''
+ test = 1
+ args = self.liste_to_dico(args)
+ if args.has_key(mc0):
+ for mc in self.mcs[1:len(self.mcs)]:
+ if not args.has_key(mc):
+ text = text + u"- Le mot clé " + `mc0`+ \
+ u" étant présent, il faut que : " + \
+ mc + u" soit présent" + '\n'
+ test = 0
+ return text, test
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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
+# 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.
+# ======================================================================
"""
- Ce module contient la classe mixin PROC_ETAPE qui porte les méthodes
- nécessaires pour réaliser la validation d'un objet de type PROC_ETAPE
- dérivé de OBJECT.
+ Ce module contient la classe mixin PROC_ETAPE qui porte les méthodes
+ nécessaires pour réaliser la validation d'un objet de type PROC_ETAPE
+ dérivé de OBJECT.
Une classe mixin porte principalement des traitements et est
- utilisée par héritage multiple pour composer les traitements.
+ utilisée par héritage multiple pour composer les traitements.
"""
# Modules EFICAS
import V_ETAPE
class PROC_ETAPE(V_ETAPE.ETAPE):
- """
- On réutilise les méthodes report,verif_regles
- de ETAPE par héritage.
- """
-
- def isvalid(self,sd='oui',cr='non'):
- """
- Methode pour verifier la validité de l'objet PROC_ETAPE. Cette méthode
- peut etre appelée selon plusieurs modes en fonction de la valeur
- de sd et de cr (sd n'est pas utilisé).
- Si cr vaut oui elle crée en plus un compte-rendu.
+ """
+ On réutilise les méthodes report,verif_regles
+ de ETAPE par héritage.
+ """
- Cette méthode a plusieurs fonctions :
+ def isvalid(self, sd='oui', cr='non'):
+ """
+ Methode pour verifier la validité de l'objet PROC_ETAPE. Cette méthode
+ peut etre appelée selon plusieurs modes en fonction de la valeur
+ de sd et de cr (sd n'est pas utilisé).
- - retourner un indicateur de validité 0=non, 1=oui
+ Si cr vaut oui elle crée en plus un compte-rendu.
- - produire un compte-rendu : self.cr
+ Cette méthode a plusieurs fonctions :
- - propager l'éventuel changement d'état au parent
- """
- if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
- if self.state == 'unchanged' :
- return self.valid
- else:
- valid=self.valid_child()
- valid=valid * self.valid_regles(cr)
- if self.reste_val != {}:
- if cr == 'oui' :
- self.cr.fatal(_(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
- valid=0
- self.set_valid(valid)
- return self.valid
+ - retourner un indicateur de validité 0=non, 1=oui
+ - produire un compte-rendu : self.cr
+ - propager l'éventuel changement d'état au parent
+ """
+ if CONTEXT.debug:
+ print "ETAPE.isvalid ", self.nom
+ if self.state == 'unchanged':
+ return self.valid
+ else:
+ valid = self.valid_child()
+ valid = valid * self.valid_regles(cr)
+ if self.reste_val != {}:
+ if cr == 'oui':
+ self.cr.fatal(
+ _(u"Mots clés inconnus : %s"), ','.join(self.reste_val.keys()))
+ valid = 0
+ self.set_valid(valid)
+ return self.valid
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2013 EDF R&D
+# coding=utf-8
+# person_in_charge: mathieu.courtois at edf.fr
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2015 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 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 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.
#
-# 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 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.
#
-# 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
#
+# ======================================================================
+
class UN_PARMI:
- """
- La règle vérifie que l'on trouve un des mots-clés
- de la règle parmi les arguments d'un OBJECT.
- Ces arguments sont transmis à la règle pour validation sous la forme
- d'une liste de noms de mots-clés ou d'un dictionnaire dont
- les clés sont des noms de mots-clés.
- """
- def verif(self,args):
- """
- La méthode verif vérifie que l'on trouve un des mos-clés
- de la liste self.mcs parmi les éléments de args
+ """
+ La règle vérifie que l'on trouve un des mots-clés
+ de la règle parmi les arguments d'un OBJECT.
+
+ Ces arguments sont transmis à la règle pour validation sous la forme
+ d'une liste de noms de mots-clés ou d'un dictionnaire dont
+ les clés sont des noms de mots-clés.
+ """
- args peut etre un dictionnaire ou une liste. Les éléments de args
- sont soit les éléments de la liste soit les clés du dictionnaire.
- """
- # on compte le nombre de mots cles presents
- text =''
- count=0
- args = self.liste_to_dico(args)
- for mc in self.mcs:
- if args.has_key(mc):count=count+1
- if count != 1:
- text = u"- Il faut un et un seul mot-clé parmi : "+`self.mcs`+'\n'
- return text,0
- return text,1
+ def verif(self, args):
+ """
+ La méthode verif vérifie que l'on trouve un des mos-clés
+ de la liste self.mcs parmi les éléments de args
+ args peut etre un dictionnaire ou une liste. Les éléments de args
+ sont soit les éléments de la liste soit les clés du dictionnaire.
+ """
+ # on compte le nombre de mots cles presents
+ text = ''
+ count = 0
+ args = self.liste_to_dico(args)
+ for mc in self.mcs:
+ if args.has_key(mc):
+ count = count + 1
+ if count != 1:
+ text = u"- Il faut un et un seul mot-clé parmi : " + \
+ `self.mcs`+'\n'
+ return text, 0
+ return text, 1
#commentaire double precede d'un nombre quelconque de blancs (pas multiligne)
pattern_2comments = re.compile(r"^\s*##.*")
+pattern_finComments = re.compile("^\s*##Fin Commentaire")
#commentaire standard precede d'un nombre quelconque de blancs (pas multiligne)
pattern_comment = re.compile(r"^\s*#.*")
#fin de ligne ; suivi d'un nombre quelconque de blancs (pas multiligne)
elif commande_commentarisee_courante :
# commande_commentarisee en cours : on ajoute la ligne
commande_commentarisee_courante.append_text(ligne)
+ # on a 2 commandes commentarisées de suite
+ if pattern_finComments.match(ligne) :
+ commande_commentarisee_courante = None
else:
# debut de commande commentarisée : on crée un objet commande_commentarisee_courante
commande_commentarisee_courante = COMMANDE_COMMENTARISEE(self)
txt = headerSTD % self.OpenTURNS_path
txt += "dist = %s\n" % apply( STDGenerateur.__dict__[ loi[ 'Kind' ] ], (self, loi) )
txt += "graph = dist.drawPDF()\n"
- txt += "graph.draw( '%s', '%s' , 640, 480, GraphImplementation.PNG)\n" % (chemin, fichier)
+ txt += "graph.draw( '%s/', '%s' , 640, 480, GraphImplementation.PNG)\n" % (chemin, fichier)
txt += footerSTD
return txt
data.setHessianDescription( self.HessianDefinition() )
data.setFileList( self.FileList() )
data.setParameters( self.Parameters() )
- data.setFrameworkData( self.FrameworkData() )
+ #data.setFrameworkData( self.FrameworkData() )
wrapper=openturns.WrapperFile()
wrapper.setWrapperData( data )
-# -*- coding: utf-8 -*-\r
-# Copyright (C) 2007-2013 EDF R&D\r
-#\r
-# This library is free software; you can redistribute it and/or\r
-# modify it under the terms of the GNU Lesser General Public\r
-# License as published by the Free Software Foundation; either\r
-# version 2.1 of the License.\r
-#\r
-# This library is distributed in the hope that it will be useful,\r
-# but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
-# Lesser General Public License for more details.\r
-#\r
-# You should have received a copy of the GNU Lesser General Public\r
-# License along with this library; if not, write to the Free Software\r
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
-#\r
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com\r
-#\r
-"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.\r
-"""\r
-\r
-import traceback\r
-import types,string,re,os\r
-from Extensions.i18n import tr\r
-from generator_python import PythonGenerator\r
-\r
-# Groupes de mailles dont les types sont definis par des prefixes dans leur nom\r
-usePrefix = False # les noms ont des prefixes (True) ou non (False)\r
-# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom\r
-# Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys\r
-listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",\r
- "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",\r
- "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",\r
- "PORT_OMEGA","POST_PHI","PB_GRID",\r
- "SCUTE","SCUTN","ZS","ZJ","ZT")\r
-# liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire\r
-dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'), \r
- 'CONDUCTOR':('COND',), \r
- 'STRANDED_INDUCTOR':('CURRENT', ), \r
- 'EPORT':('EPORT', ), \r
- 'HPORT':('HPORT', ), \r
- 'ZSURFACIC':('ZS', ), \r
- 'ZINSULATOR':('ZJ', ), \r
- 'NILMAT':('NILMAT', )}\r
-# separateur entre le prefixe et le reste du nom du groupe de maille\r
-sepNomGroupeMaille = '_'\r
-\r
-# types de problemes\r
-HARMONIC = 'HARMONIC' # probleme frequentiel\r
-TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel\r
-\r
-# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()\r
-nomPlugin = 'CARMEL3DFV0'\r
-\r
-def entryPoint():\r
- """\r
- Retourne les informations necessaires pour le chargeur de plugins\r
- Ces informations sont retournees dans un dictionnaire\r
- """\r
- return {\r
- # Le nom du plugin\r
- 'name' : nomPlugin,\r
- # La factory pour creer une instance du plugin\r
- 'factory' : CARMEL3DFV0Generator,\r
- }\r
-\r
-\r
-class CARMEL3DFV0Generator(PythonGenerator):\r
- """\r
- Ce generateur parcourt un objet de type JDC et produit\r
- un texte au format eficas et \r
- un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS') \r
-\r
- """\r
- # Les extensions de fichier permis?\r
- extensions=('.comm',)\r
-\r
-#----------------------------------------------------------------------------------------\r
- def gener(self,obj,format='brut',config=None):\r
- \r
- self.initDico()\r
- \r
- # Cette instruction genere le contenu du fichier de commandes (persistance)\r
- self.text=PythonGenerator.gener(self,obj,format)\r
-\r
- if self.debug:\r
- print "self.text = %s" % self.text\r
-\r
- # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D\r
- # si le jdc est valide (sinon cela n a pas de sens)\r
- if obj.isvalid() : \r
- try :\r
- # constitution du bloc VERSION du fichier PHYS (existe toujours)\r
- self.generBLOC_VERSION(obj)\r
- # constitution du bloc MATERIALS du fichier PHYS (existe toujours)\r
- self.generBLOC_MATERIALS()\r
- # constitution du bloc SOURCES du fichier PHYS (existe toujours)\r
- self.generBLOC_SOURCES()\r
- except ValueError, err:\r
- raise ValueError(str(err))\r
-\r
-# print "texte carmel3d :\n",self.texteCarmel3D\r
-# print "dictMaterDielectric : ",self.dictMaterDielectric\r
- if self.debug:\r
- print "dictMaterConductor : %s" % repr(self.dictMaterConductor)\r
- \r
- return self.text\r
-\r
-\r
-#----------------------------------------------------------------------------------------\r
-# initialisations\r
-#----------------------------------------------------------------------------------------\r
- \r
- def initDico(self) :\r
- \r
- self.texteCarmel3D=""\r
- self.debug = True # affichage de messages pour deboguage (.true.) ou non\r
- self.dicoEtapeCourant=None\r
- self.dicoMCFACTCourant=None\r
- self.dicoCourant=None\r
- self.dictGroupesMaillage = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources\r
- self.dictMaterConductor={}\r
- self.dictMaterDielectric={}\r
- self.dictMaterZsurfacic={}\r
- self.dictMaterEmIso={}\r
- self.dictMaterEmAnIso={}\r
- self.dictMaterNilmat={}\r
- self.dictMaterZinsulator={}\r
- self.dictSourceStInd={}\r
- self.dictSourceEport={}\r
- self.dictSourceHport={}\r
- # on force le probleme a etre frequentiel, seul possible en l'etat des choses\r
- self.problem = HARMONIC\r
-\r
-\r
-#----------------------------------------------------------------------------------------\r
-# ecriture\r
-#----------------------------------------------------------------------------------------\r
-\r
- def writeDefault(self,fn) :\r
- """Ecrit le fichier de parametres (PHYS) pour le code Carmel3D"""\r
- if self.debug: \r
- print "ecriture du fichier de parametres (PHYS)"\r
- filePHYS = fn[:fn.rfind(".")] + '.phys'\r
- f = open( str(filePHYS), 'wb')\r
- f.write( self.texteCarmel3D)\r
- f.close()\r
-\r
-#----------------------------------------------------------------------------------------\r
-# analyse de chaque noeud de l'arbre \r
-#----------------------------------------------------------------------------------------\r
-\r
- def generMCSIMP(self,obj) :\r
- """recuperation de l objet MCSIMP"""\r
- if self.debug: \r
- print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}\r
- s=PythonGenerator.generMCSIMP(self,obj)\r
- self.dicoCourant[obj.nom]=obj.valeurFormatee\r
- return s\r
-\r
- \r
-#----------------------------------------------------------------------------------------\r
- def generMCFACT(self,obj) :\r
- """recuperation de l objet MCFACT"""\r
- dico={}\r
- self.dicoMCFACTCourant=dico\r
- self.dicoCourant=self.dicoMCFACTCourant\r
- s=PythonGenerator.generMCFACT(self,obj)\r
- self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant\r
- self.dicoMCFACTCourant=None\r
- self.dicoCourant=self.dicoEtapeCourant\r
- return s\r
- \r
-#----------------------------------------------------------------------------------------\r
- def generPROC_ETAPE(self,obj):\r
- """analyse des PROC du catalogue ( VERSION )"""\r
- dico={}\r
- self.dicoEtapeCourant=dico\r
- self.dicoCourant=self.dicoEtapeCourant\r
- s=PythonGenerator.generPROC_ETAPE(self,obj)\r
- obj.valeur=self.dicoEtapeCourant\r
- if self.debug: \r
- print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}\r
- s=PythonGenerator.generPROC_ETAPE(self,obj)\r
- return s\r
- \r
-#----------------------------------------------------------------------------------------\r
- def generETAPE(self,obj):\r
- """analyse des OPER du catalogue"""\r
- dico={}\r
- self.dicoEtapeCourant=dico\r
- self.dicoCourant=self.dicoEtapeCourant\r
- s=PythonGenerator.generETAPE(self,obj)\r
- obj.valeur=self.dicoEtapeCourant\r
- if self.debug: \r
- print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}\r
- if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)\r
- if obj.nom=="MATERIAL" : self.generMATERIAL(obj)\r
- if obj.nom=="SOURCE" : self.generSOURCE(obj)\r
- s=PythonGenerator.generETAPE(self,obj)\r
- return s\r
-\r
-#----------------------------------------------------------------------------------------\r
- def generMACRO_ETAPE(self,obj):\r
- dico={}\r
- self.dicoEtapeCourant=dico\r
- self.dicoCourant=self.dicoEtapeCourant\r
- import generator\r
- monGenerateur=generator.plugins[nomPlugin]()\r
- jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)\r
- if self.debug: \r
- print "jdc_aux_texte : %s" % jdc_aux_texte\r
-\r
- for cle in monGenerateur.dictMaterConductor:\r
- self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]\r
- for cle in monGenerateur.dictMaterDielectric:\r
- self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]\r
- for cle in monGenerateur.dictMaterZsurfacic:\r
- self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]\r
- for cle in monGenerateur.dictMaterEmIso:\r
- self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]\r
- for cle in monGenerateur.dictMaterEmAnIso:\r
- self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]\r
- for cle in monGenerateur.dictMaterNilmat:\r
- self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]\r
- for cle in monGenerateur.dictMaterZinsulator:\r
- self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]\r
- \r
- print "________FIN MACRO______________________________________"\r
- s=PythonGenerator.generMACRO_ETAPE(self,obj)\r
- return s\r
-\r
-#----------------------------------------------------------------------------------------\r
-#----------------------------------------------------------------------------------------\r
- def generMESHGROUP(self,obj):\r
- """preparation de la ligne NAME referencant le groupe de mailles \r
- associe le groupe de mailles au materiau ou a la source utilisateur\r
- on sauvegarde aussi les noms des groupes de maillage\r
- """\r
- try:\r
- if usePrefix:\r
- nomGroupeMaillage = self.nomReelGroupeMaillage(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves\r
- else:\r
- nomGroupeMaillage = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept\r
- # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.\r
- # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.\r
- #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupeMaillage\r
- #\r
- # on utilise le fait que obj.valeur est un dictionnaire\r
- if self.debug: \r
- print "obj.valeur.keys()= %s" % obj.valeur.keys()\r
- if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois\r
- raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupeMaillage)\r
- # association a un materiau\r
- if 'MATERIAL' in obj.valeur.keys():\r
- self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source\r
- self.dictGroupesMaillage['ordreMateriauxJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC\r
- # association a une source\r
- elif 'SOURCE' in obj.valeur.keys():\r
- self.dictGroupesMaillage[nomGroupeMaillage] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source\r
- self.dictGroupesMaillage['ordreSourcesJdC'].append(nomGroupeMaillage) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC\r
- # erreur ni materiau ni source associee\r
- else:\r
- raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau ou source." % nomGroupeMaillage)\r
- if self.debug:\r
- print "self.dictGroupesMaillage= %s" % repr(self.dictGroupesMaillage)\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
-\r
- def generMATERIAL(self,obj):\r
- """preparation du bloc correspondant a un materiau du fichier PHYS"""\r
- texte=""\r
- if self.debug: \r
- print "generation material obj.valeur = %s" % obj.valeur\r
- try :\r
- nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL\r
- if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)\r
- if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)\r
- if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)\r
- if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)\r
- if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)\r
- if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)\r
- if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generMATERIAL_CONDUCTOR(self,obj):\r
- """preparation du sous bloc CONDUCTOR"""\r
- texte=""\r
- if self.debug: \r
- print "_____________cond_____________"\r
- # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)\r
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:\r
- print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()\r
- raise ValueError, tr("ERREUR! Le materiau conducteur (CONDUCTOR) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())\r
- else:\r
- # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)\r
- for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :\r
- # debut du sous bloc de propriete du DIELECTRIC\r
- texte+=" ["+keyN1+"\n"\r
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,\r
- # car sinon ces valeurs sont definies dans des fichiers annexes\r
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
- if homogeneous and isotropic:\r
- # loi (lineaire ou non)\r
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"\r
- # valeur de la loi lineaire\r
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"\r
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation\r
- # seuls les reels sont pris en compte\r
- if obj.valeur[keyN1]['LAW']=='NONLINEAR' :\r
- texte+=" [NONLINEAR \n"\r
- texte+=" ISOTROPY TRUE\n"\r
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"\r
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC\r
- for keyN2 in obj.valeur[keyN1] :\r
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :\r
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"\r
- # fin du sous-bloc NONLINEAR\r
- texte+=" ]"+"\n"\r
- # fin du sous bloc de propriete\r
- texte+=" ]"+"\n"\r
- if self.debug: \r
- print "texte = %s", texte\r
- self.dictMaterConductor[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc\r
-\r
- def generMATERIAL_DIELECTRIC(self,obj):\r
- """preparation du sous bloc DIELECTRIC"""\r
- texte=""\r
- if self.debug: \r
- print "______________nocond_____________"\r
- # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)\r
- if 'PERMEABILITY' not in obj.valeur or 'PERMITTIVITY' not in obj.valeur:\r
- print "ERREUR! Le matériau non conducteur (dielectric) de nom %s doit contenir les propriétés PERMEABILITY et PERMITTIVITY." % obj.get_sdname()\r
- raise ValueError, tr("ERREUR! Le materiau non conducteur (DIELECTRIC) de nom %s doit contenir les proprietes PERMEABILITY et PERMITTIVITY." % obj.get_sdname())\r
- else:\r
- # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)\r
- for keyN1 in ('PERMEABILITY','PERMITTIVITY') :\r
- # debut du sous bloc de propriete du DIELECTRIC\r
- texte+=" ["+keyN1+"\n"\r
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,\r
- # car sinon ces valeurs sont definies dans des fichiers annexes\r
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
- if homogeneous and isotropic:\r
- # loi (lineaire ou non)\r
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"\r
- # valeur de la loi lineaire\r
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"\r
- # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation\r
- # seuls les reels sont pris en compte\r
- if obj.valeur[keyN1]['LAW']=='NONLINEAR' :\r
- texte+=" [NONLINEAR \n"\r
- texte+=" ISOTROPY TRUE\n"\r
- texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"\r
- # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC\r
- for keyN2 in obj.valeur[keyN1] :\r
- if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :\r
- texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"\r
- # fin du sous-bloc NONLINEAR\r
- texte+=" ]"+"\n"\r
- # fin du sous bloc de propriete\r
- texte+=" ]"+"\n"\r
- if self.debug: \r
- print "texte = %s" % texte\r
- self.dictMaterDielectric[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc\r
-\r
- def generMATERIAL_ZSURFACIC(self,obj):\r
- """preparation du sous bloc ZSURFACIC"""\r
- texte=""\r
- if self.debug: \r
- print "______________zsurf_____________"\r
- # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)\r
- if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:\r
- print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()\r
- raise ValueError, tr("ERREUR! Le materiau impedance de surface (ZSURFACIC) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())\r
- else:\r
- # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)\r
- for keyN1 in obj.valeur :\r
- if keyN1=='TYPE': continue\r
- # print "type loi = ", obj.valeur[keyN1]['LAW']\r
- # debut du sous bloc de propriete du DIELECTRIC\r
- texte+=" ["+keyN1+"\n"\r
- texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"\r
- texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"\r
- # Ecriture des valeurs seulement pour un materiau homogene et isotrope,\r
- # car sinon ces valeurs sont definies dans des fichiers annexes\r
- homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'\r
- isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'\r
- if homogeneous and isotropic:\r
- # loi (lineaire ou non)\r
- texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"\r
- # valeur de la loi lineaire\r
- texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"\r
- # fin du sous bloc de propriete\r
- texte+=" ]"+"\n"\r
- if self.debug: \r
- print "texte = %s", texte\r
- self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc\r
-\r
- def generMATERIAL_EMISO(self,obj):\r
- """preparation du sous bloc EM_ISOTROPIC_FILES.\r
- Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,\r
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.\r
- """\r
- texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
- texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"\r
- # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut\r
- #from os.path import basename\r
- #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"\r
- #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"\r
- # print "obj get sdname= ", obj.get_sdname()\r
- # if obj.get_sdname() in self.dictMaterEmIso.keys() :\r
- # self.dictMaterEmIso[obj.get_sdname()].append(texte) \r
- # else :\r
- self.dictMaterEmIso[obj.get_sdname()]=texte\r
- \r
- def generMATERIAL_EMANISO(self,obj):\r
- """preparation du sous bloc EM_ANISOTROPIC_FILES.\r
- Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,\r
- ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.\r
- """\r
- texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"\r
- texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"\r
- # print "obj get sdname= ", obj.get_sdname()\r
- # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :\r
- # self.dictMaterEmAnIso[obj.get_sdname()].append(texte) \r
- # else :\r
- self.dictMaterEmAnIso[obj.get_sdname()]=texte\r
- \r
- def generMATERIAL_NILMAT(self,obj):\r
- """preparation du sous bloc NILMAT"""\r
- texte=""\r
- self.dictMaterNilmat[obj.get_sdname()]=texte\r
- \r
- def generMATERIAL_ZINSULATOR(self,obj):\r
- """"preparation du sous bloc ZINSULATOR"""\r
- texte=""\r
- self.dictMaterZinsulator[obj.get_sdname()]=texte\r
-\r
-#-------------------------------------------------------------------\r
-\r
- def generSOURCE(self,obj):\r
- """preparation du bloc correspondant a une source du fichier PHYS"""\r
- if self.debug: \r
- print "generation source obj valeur = %s" % obj.valeur\r
- texte=""\r
- try :\r
- # test de la presence des types de sources reconnus\r
- # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "STRANDED_INDUCTOR" in obj.valeur:\r
- self.generSOURCE_STRANDED_INDUCTOR(obj)\r
- elif "HPORT" in obj.valeur:\r
- self.generSOURCE_HPORT(obj)\r
- elif "EPORT" in obj.valeur:\r
- self.generSOURCE_EPORT(obj)\r
- else:\r
- print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generSOURCE_STRANDED_INDUCTOR(self,obj):\r
- """preparation du sous bloc STRANDED_INDUCTOR"""\r
- texte=""\r
- sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source\r
- try :\r
- texte+=" NTURNS %s\n" % str(sdict['NTURNS'])\r
- # test de la presence d'une forme de source reconnue\r
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "WAVEFORM_CONSTANT" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])\r
- print tr("ATTENTION! Une source constante \\r
- n'est possible qu'a frequence nulle \\r
- en regime frequentiel")\r
- elif "WAVEFORM_SINUS" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \\r
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}\r
- else:\r
- print tr("ERREUR! Une forme de la source du \\r
- type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")\r
- self.dictSourceStInd[obj.get_sdname()]=texte\r
- if self.debug: \r
- print texte\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generSOURCE_HPORT(self,obj):\r
- """preparation du sous bloc HPORT"""\r
- texte=""\r
- sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source\r
- try :\r
- texte+=" TYPE %s\n" % str(sdict['TYPE'])\r
- # test de la presence d'une forme de source reconnue\r
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "WAVEFORM_CONSTANT" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])\r
- print tr("ATTENTION! Une source constante n'est \\r
- possible qu'a frequence nulle en regime frequentiel")\r
- elif "WAVEFORM_SINUS" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \\r
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}\r
- else:\r
- print tr("ERREUR! Une forme de la source du type \\r
- WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")\r
- self.dictSourceHport[obj.get_sdname()]=texte\r
- if self.debug: \r
- print texte\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
- def generSOURCE_EPORT(self,obj):\r
- """preparation du sous bloc EPORT"""\r
- texte=""\r
- sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source\r
- try :\r
- texte+=" TYPE %s\n" % str(sdict['TYPE'])\r
- # test de la presence d'une forme de source reconnue\r
- # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,\r
- # la source ne peut contenir au plus qu'un type de source.\r
- if "WAVEFORM_CONSTANT" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])\r
- print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")\r
- elif "WAVEFORM_SINUS" in obj.valeur:\r
- wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source\r
- if self.problem == HARMONIC:\r
- texte+=" AMP POLAR %(ampli)s %(phase)s\n" \\r
- % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}\r
- else:\r
- print tr("ERREUR! Une forme de la source du type \\r
- WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")\r
- self.dictSourceEport[obj.get_sdname()]=texte\r
- if self.debug: \r
- print texte\r
- except ValueError, err:\r
- raise ValueError, str(err)\r
-\r
-#---------------------------------------------------------------------------------------\r
-# traitement fichier PHYS\r
-#---------------------------------------------------------------------------------------\r
-\r
- def generBLOC_VERSION(self,obj) :\r
- # constitution du bloc VERSION du fichier PHYS\r
- # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi\r
- # dans le du catalogue\r
- version=obj.addentite('VERSION',pos=None)\r
- self.generPROC_ETAPE(obj.etapes[0])\r
- self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"\r
- for cle in obj.etapes[0].valeur :\r
- self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"\r
- self.texteCarmel3D+="]\n"\r
- # destruction de l entite creee \r
- obj.suppentite(version)\r
- #print 'ERREUR : test erreur boite graphique BLOC_VERSION'\r
- #raise ValueError, 'test erreur boite graphique BLOC_VERSION'\r
-\r
-#----------------------------------------------------------------------------------------\r
- def generBLOC_MATERIALS(self) :\r
- """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).\r
- Le bloc MATERIALS existe toujours ! \r
- """\r
- if self.debug:\r
- print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()\r
- print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()\r
- # constitution du bloc MATERIALS du fichier PHYS\r
- self.texteCarmel3D+="[MATERIALS\n"\r
- # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)\r
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste\r
- nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels\r
- if self.debug:\r
- print "noms groupes de mailles associes a des materiaux \\r
- (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \\r
- {'v_1': self.dictGroupesMaillage['ordreMateriauxJdC'], \\r
- 'v_2': nomsGroupesMaillage}\r
- try: \r
- # constitution du bloc CONDUCTOR du fichier PHYS si existe\r
- if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupesMaillage)\r
- # constitution du bloc DIELECTRIC du fichier PHYS si exixte\r
- if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupesMaillage)\r
- # constitution du bloc ZSURFACIC du fichier PHYS si exixte\r
- if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupesMaillage)\r
- # constitution du bloc NILMAT du fichier PHYS si exixte\r
- if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupesMaillage)\r
- # constitution du bloc ZINSULATOR du fichier PHYS si exixte\r
- if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupesMaillage)\r
- # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS\r
- # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte\r
- if self.dictMaterEmIso != {} : self.creaBLOC_EMISO()\r
- # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte\r
- if self.dictMaterEmAnIso != {} : self.creaBLOC_EMANISO()\r
- except ValueError, err:\r
- raise ValueError(str(err))\r
-\r
- # fin du bloc MATERIALS du fichier PHYS\r
- self.texteCarmel3D+="]\n" \r
- \r
- def creaBLOC_CONDUCTOR(self, nomsGroupesMaillage) :\r
- """Constitution du bloc CONDUCTOR du fichier PHYS"""\r
- typeBloc = 'CONDUCTOR' # initialisation du type de bloc\r
- dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc\r
- if usePrefix:\r
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
- else:\r
- nomReel = nom\r
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
- def creaBLOC_DIELECTRIC(self, nomsGroupesMaillage) :\r
- """Constitution du bloc DIELECTRIC du fichier PHYS"""\r
- typeBloc = 'DIELECTRIC' # initialisation du type de bloc\r
- dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc\r
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
- def creaBLOC_ZSURFACIC(self, nomsGroupesMaillage) :\r
- """Constitution du bloc ZSURFACIC du fichier PHYS"""\r
- typeBloc = 'ZSURFACIC' # initialisation du type de bloc\r
- dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc\r
- if usePrefix:\r
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
- else:\r
- nomReel = nom\r
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
- def creaBLOC_EMISO(self) :\r
- """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""\r
- for cle in self.dictMaterEmIso.keys():\r
- self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"\r
- self.texteCarmel3D+= self.dictMaterEmIso[cle] \r
- self.texteCarmel3D+=" ]\n"\r
-\r
- def creaBLOC_EMANISO(self) :\r
- """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""\r
- for cle in self.dictMaterEmAnIso.keys():\r
- self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"\r
- self.texteCarmel3D+= self.dictMaterEmAnIso[cle] \r
- self.texteCarmel3D+=" ]\n"\r
-\r
- def creaBLOC_ZINSULATOR(self, nomsGroupesMaillage) :\r
- """Constitution du bloc ZINSULATOR du fichier PHYS"""\r
- typeBloc = 'ZINSULATOR' # initialisation du type de bloc\r
- dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc\r
- if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc\r
- if usePrefix:\r
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
- else:\r
- nomReel = nom\r
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
- def creaBLOC_NILMAT(self, nomsGroupesMaillage) :\r
- """Constitution du bloc NILMAT du fichier PHYS"""\r
- typeBloc = 'NILMAT' # initialisation du type de bloc\r
- dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc\r
- if self.debug: \r
- print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type\r
- # ecriture du bloc complet\r
- self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc\r
- if usePrefix:\r
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
- else:\r
- nomReel = nom\r
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= dictProprietes[self.dictGroupesMaillage[nom]] # ecriture des proprietes du type associe\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
-#----------------------------------------------------------------------------------------\r
- def generBLOC_SOURCES(self):\r
- """constitution du bloc SOURCES du fichier PHYS"""\r
- self.texteCarmel3D+="[SOURCES\n"\r
- # tri alphabetique de tous les groupes de maillage associes a des sources\r
- nomsGroupesMaillage = self.dictGroupesMaillage['ordreSourcesJdC'][:] # copie de l'original, qui est une liste\r
- nomsGroupesMaillage.sort() # tri alphabetique, avec les prefixes eventuels\r
- if self.debug:\r
- print 'noms groupes de mailles associes a des sources \\r
- (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \\r
- {'g_maillage_orig': self.dictGroupesMaillage['ordreSourcesJdC'], \\r
- 'g_maillage_trie': nomsGroupesMaillage}\r
- if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupesMaillage)\r
- if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupesMaillage)\r
- if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupesMaillage)\r
- # fin du bloc SOURCES du fichier PHYS\r
- self.texteCarmel3D+="]\n"\r
-\r
-\r
- def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupesMaillage) :\r
- """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""\r
- if self.debug: \r
- print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()\r
- typeBloc = 'STRANDED_INDUCTOR'\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine\r
- # ecriture du bloc de l'inducteur bobine\r
- self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc\r
- self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupesMaillage[nom]] # ecriture des proprietes de l'inducteur bobine\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
- \r
- def creaBLOC_EPORT(self, nomsGroupesMaillage) :\r
- """constitution du bloc EPORT du fichier PHYS"""\r
- if self.debug: \r
- print 'cles sources EPORT= %s' % self.dictSourceEport.keys()\r
- typeBloc = 'EPORT'\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique\r
- # ecriture du bloc du port electrique\r
- self.texteCarmel3D+=" [EPORT\n" # debut de bloc\r
- if usePrefix:\r
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
- else:\r
- nomReel = nom\r
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= self.dictSourceEport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port electrique\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
- def creaBLOC_HPORT(self, nomsGroupesMaillage) :\r
- """constitution du bloc HPORT du fichier PHYS"""\r
- if self.debug: \r
- print 'cles sources HPORT= %s' % self.dictSourceHport.keys()\r
- typeBloc = 'HPORT'\r
- for nom in nomsGroupesMaillage: # parcours des noms des groupes de maillage\r
- if self.dictGroupesMaillage[nom] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique\r
- # ecriture du bloc du port magnetique\r
- self.texteCarmel3D+=" [HPORT\n" # debut de bloc\r
- if usePrefix:\r
- nomReel = self.nomReelGroupeMaillage(nom, typeBloc)\r
- else:\r
- nomReel = nom\r
- self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage\r
- self.texteCarmel3D+= self.dictSourceHport[self.dictGroupesMaillage[nom]] # ecriture des proprietes du port magnetique\r
- self.texteCarmel3D+=" ]\n" # fin de bloc\r
-\r
-#-------------------------------------\r
-# Methodes utilitaires\r
-# ------------------------------------\r
- def formateCOMPLEX(self,nbC):\r
- """prise en compte des differentes formes de description d un nombre complexe\r
- 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe\r
- """\r
- if self.debug:\r
- print "formatage"\r
- print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}\r
- nbformate =""\r
- if isinstance(nbC,(tuple,list)):\r
- if nbC[0] == "'RI'" :\r
- nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2]) \r
- if nbC[0] == "'MP'" :\r
- nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2]) \r
- else:\r
- nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)\r
- if self.debug: \r
- print "nbformate : %s" % nbformate\r
- return nbformate\r
- \r
- def nomReelGroupeMaillage(self, nom, typeBloc=None):\r
- """Calcule et retourne le nom reel du groupe de maillage donne en entree,\r
- en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type\r
- de bloc du fichier PHYS specifie.\r
- Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.\r
- """\r
- from string import join\r
- if self.debug: \r
- print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \\r
- {'nom': nom, 'use_prefix': str(usePrefix)}\r
- nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori\r
- if usePrefix:\r
- # suppression du prefixe si present\r
- partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties\r
- # les tests suivants ne generent une erreur que si le prefixe est obligatoire\r
- if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur\r
- print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \\r
- indiquant le type de materiau ou de source associee", nom)\r
- elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini\r
- print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)\r
- else: \r
- # verification de l'adequation du prefixe avec le type de bloc demande, si fourni \r
- if typeBloc is not None:\r
- if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire\r
- print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))\r
- elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc\r
- print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \\r
- le prefixe correct pour etre associe a un type %(type_bloc)s", \\r
- {'nom': nom, 'type_bloc': str(typeBloc)})\r
- else: # c'est bon\r
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet\r
- if self.debug: \r
- print "ce groupe de maille (%(nom)s) a un prefixe qui \\r
- est supprime automatiquement pour devenir : %(nom_reel)s", \\r
- {'nom': nom, 'nom_reel': nomReel}\r
- else: # c'est bon\r
- nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet\r
- if self.debug: \r
- print "ce groupe de maille (%(nom)s) a un prefixe qui \\r
- est supprime automatiquement pour devenir : %(nom_reel)s", \\r
- {'nom': nom, 'nom_reel': nomReel}\r
- if self.debug: \r
- print "... %s", nomReel\r
- return nomReel\r
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2013 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
+import types,string,re,os
+from Extensions.i18n import tr
+from generator_python import PythonGenerator
+
+# Groupes de mailles dont les types sont definis par des prefixes dans leur nom
+usePrefix = False # les noms ont des prefixes (True) ou non (False)
+# liste des prefixes des groupes de mailles, sans le caractere _ separant le prefixe du reste du nom
+# Ce prefixe (et caractere _) doivent etre supprimes dans le fichier .phys
+listePrefixesGroupeMaille = ("DIEL","NOCOND","COND","CURRENT","EPORT","HPORT","TOPO","PB_MOBILE","NILMAT",
+ "VCUT","VCUTN","EWALL","HWALL","GAMMAJ","PERIODIC","APERIODIC",
+ "HPROBE","EPROBE","BFLUX","BFLUXN","JFLUX","JFLUXN",
+ "PORT_OMEGA","POST_PHI","PB_GRID",
+ "SCUTE","SCUTN","ZS","ZJ","ZT")
+# liste des prefixes des groupes de mailles, sans le separateur, par type de bloc du fichier PHYS sous la forme d'un dictionnaire
+dictPrefixesGroupeMaille = {'DIELECTRIC':('DIEL','NOCOND'),
+ 'CONDUCTOR':('COND',),
+ 'STRANDED_INDUCTOR':('CURRENT', ),
+ 'EPORT':('EPORT', ),
+ 'HPORT':('HPORT', ),
+ 'ZSURFACIC':('ZS', ),
+ 'ZINSULATOR':('ZJ', ),
+ 'NILMAT':('NILMAT', )}
+# separateur entre le prefixe et le reste du nom du groupe de maille
+sepNomGroupeMaille = '_'
+
+
+# types de problemes
+HARMONIC = 'HARMONIC' # probleme frequentiel
+TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
+
+# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
+nomPlugin = 'CARMEL3DFV0'
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : nomPlugin,
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMEL3DFV0Generator,
+ }
+
+
+
+class CARMEL3DFV0Generator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=None):
+
+ self.initDico()
+
+ #self.debug = True
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+
+ if self.debug:
+ print "self.text = %s" % self.text
+
+ # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
+ # si le jdc est valide (sinon cela n a pas de sens)
+ if obj.isvalid() :
+ try :
+ # constitution du bloc VERSION du fichier PHYS (existe toujours)
+ self.generBLOC_VERSION(obj)
+ # constitution du bloc MATERIALS du fichier PHYS (existe toujours)
+ self.generBLOC_MATERIALS()
+ # constitution du bloc SOURCES du fichier PHYS (existe toujours)
+ self.generBLOC_SOURCES()
+
+ except ValueError, err:
+ raise ValueError(str(err))
+
+# print "texte carmel3d :\n",self.texteCarmel3D
+# print "dictMaterDielectric : ",self.dictMaterDielectric
+ if self.debug:
+ print "dictMaterDielectric : %s" % repr(self.dictMaterDielectric)
+ print "dictMaterConductor : %s" % repr(self.dictMaterConductor)
+
+ return self.text
+
+
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+ self.texteCarmel3D=""
+ self.texteCarmel3D_PARAM=""
+ self.texteCarmel3D_PARAM_SOLV=""
+ self.texteCarmel3D_SH=""
+ self.texteCarmel3D_INFC=""
+ self.texteCarmel3D_CMD=""
+ self.texteCarmel3D_INGEND1=""
+ self.texteCarmel3D_INGEND2=""
+ self.texteCarmel3D_INGEND3=""
+ self.texteCarmel3D_INPOST=""
+ self.debug = True # affichage de messages pour deboguage (.true.) ou non
+ self.dicoEtapeCourant=None
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=None
+ self.dictGroupes = {'ordreMateriauxJdC':[], 'ordreSourcesJdC':[], 'ordreStrandJdC':[], 'ordreListeJdC':[], 'ordreDomaineJdC':[]} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
+ self.dictMaterConductor={}
+ self.dictMaterDielectric={}
+ self.dictMaterZsurfacic={}
+ self.dictMaterEmIso={}
+ self.dictMaterEmAnIso={}
+ self.dictMaterNilmat={}
+ self.dictMaterZinsulator={}
+ self.dictSourceStInd={}
+ self.dictSourceEport={}
+ self.dictSourceHport={}
+ self.dictStrand={}
+ self.dictDomaine={}
+ self.dictPort={}
+ self.repertory=""
+ self.frequency=""
+ self.domaine=""
+ self.direction=""
+ self.section=""
+ self.forme=""
+ self.centre=""
+ self.echelle=""
+ self.visu=False
+ self.post_global=False
+ self.visu_format=""
+ self.visu_type=""
+ self.gendof=""
+ self.fcarmel=""
+ self.postprocess=""
+ self.formulation=""
+ # on force le probleme a etre frequentiel, seul possible en l'etat des choses
+ self.problem = HARMONIC
+ self.fichierMaillage = "" # chemin absolu ou relatif du fichier contenant le maillage, défini dans PARAMETERS.Fichier_maillage.
+ self.nomFichierMaillage = "" # nom du fichier de maillage, sans le chemin
+ self.projet = "" # nom du projet, utilisé un peu partout, i.e., nom du fichier de maillage sans l'extension
+ self.materiauxGroupesTousHomogenes = True # Tous les groupes sont associés a priori à des matériaux tous homogènes mais pas forcément isotropes. On le vérifie ou modifie ci-dessous.
+ self.materiauxGroupesTousIsotropes = True # Tous les groupes sont associés a priori à des matériaux tous isotropes mais pas forcément homogènes. On le vérifie ou modifie ci-dessous.
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
+
+ # fn est le chemin complet du fichier de l'étude, e.g., /home/toto/foo.comm
+ #file = fn[:fn.rfind(".")] # chemin complet du fichier de l'étude sans l'extension, e.g., /home/toto/foo
+ repertory=os.path.dirname(fn) # répertoire de l'étude, e.g., /home/toto/
+ file = os.path.join(repertory, self.projet) # on crée le chemin complet des fichiers de configuration sans extension, à partir du nom du projet.
+ namefile=os.path.basename(file) # nom du projet e.g., foo
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (PHYS)"
+ filePHYS = file + '.phys'
+ typeBloc = 'PHYS_FILES'
+ f = open( str(filePHYS), 'w')
+ f.write( self.texteCarmel3D)
+ f.close()
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (PARAM)"
+ filePARAM = file + '.param'
+ f = open( str(filePARAM), 'w')
+ f.write('[VERSION \n'
+ ' NUM 1\n'
+ ' FILETYPE PARAM\n]\n'
+ '[PROBLEM\n'
+ ' NAME HARMONIC\n]\n'
+ )
+ typeBloc = 'CAR_FILES'
+ self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D_PARAM+=" NAME "+self.projet+".car"
+ self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
+ typeBloc = 'PHYS_FILES'
+ self.texteCarmel3D_PARAM+="["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D_PARAM+=" NAME "+self.projet+".phys"
+ self.texteCarmel3D_PARAM+="\n]\n" # fin de bloc
+ self.texteCarmel3D_PARAM+="[FREQUENCY\n"
+ self.texteCarmel3D_PARAM+=" SINGLE %g \n" % (self.frequency )
+ self.texteCarmel3D_PARAM+="] \n"
+ f.write( self.texteCarmel3D_PARAM)
+ f.write(self.texteCarmel3D_PARAM_SOLV)
+ f.close()
+
+ # ecriture du fichier de commandes du post-traitement (.cmd), à partir du texte self.textCarmel3D défini dans la routine generPOST_COMMANDS
+ if self.debug:
+ print "ecriture du fichier de parametres (CMD)"
+ fileCMD =file + '.cmd'
+ f = open( str(fileCMD), 'w')
+ f.write(self.texteCarmel3D_CMD)
+ f.close()
+
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INGENDOF)"
+ fileINGEND = file + '.ingendof'
+ f = open(fileINGEND, 'w')
+ self.texteCarmel3D_INGEND1+=""+self.nomFichierMaillage # nom du fichier de maillage (chemin relatif)
+
+ nomsGroupes = self.dictGroupes['ordreStrandJdC'][:]
+ nomsGroupes.sort()
+
+ #if self.dictDomaine !={}:
+ try:
+ self.creaBLOC_STRANDED_INDUCTOR_GEOMETRY(nomsGroupes)
+ except ValueError, err:
+ raise ValueError(str(err))
+ if self.dictPort != {} :
+ self.creaBLOC_PORTS_GEOMETRY(nomsGroupes)
+ if self.formulation=="APHI": self.texteCarmel3D_INGEND3+="\n1"
+ if self.formulation=="TOMEGA": self.texteCarmel3D_INGEND3+="\n2"
+ f.write(self.texteCarmel3D_INGEND1)
+ f.write(self.texteCarmel3D_INGEND2)
+ f.write(self.texteCarmel3D_INGEND3)
+ f.close()
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INFCARMEL) "
+ fileINFC = file + '.infcarmel'
+ f = open(fileINFC, 'w')
+ self.texteCarmel3D_INFC+= self.projet+".param"
+ f.write(self.texteCarmel3D_INFC)
+ f.close()
+
+ if self.debug:
+ print "ecriture du fichier de parametres (INPOSTPROCESS) "
+ fileINPOST = file + '.inpostprocess'
+ f = open(fileINPOST, 'w')
+ self.texteCarmel3D_INPOST+= self.projet+".param"
+ self.texteCarmel3D_INPOST+="\n"+self.projet+".xmat"
+ self.texteCarmel3D_INPOST+="\n"+self.projet+".cmd"
+ f.write(self.texteCarmel3D_INPOST)
+ f.close()
+
+ print "dictionnaire complet=%s" %self.dictGroupes
+ print "dictionnaire des ports =%s" %self.dictPort
+ if self.debug:
+ print "ecriture du fichier d'execution (SH)"
+ print"LISTE DES DOMAINES=%s" %(self.dictGroupes['ordreDomaineJdC'])
+ RepCarmel= os.path.join(repertory,"lancer.sh")
+ f = open( str(RepCarmel), 'wb')
+ self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
+ if self.gendof=="TRUE":
+ self.texteCarmel3D_SH+='echo "Debut execution gendof" \n'
+ if self.echelle=="Millimetre":
+ self.texteCarmel3D_SH+=self.repertory+"/gendof.exe -scale 0.001 < " + self.projet + ".ingendof\n"
+ else:
+ self.texteCarmel3D_SH+=self.repertory+"/gendof.exe < " + self.projet + ".ingendof\n"
+ if self.fcarmel=="TRUE":
+ self.texteCarmel3D_SH+='echo "Debut execution fcarmel" \n'
+ self.texteCarmel3D_SH+=self.repertory+"/fcarmel.exe < " + self.projet + ".infcarmel\n"
+ if self.postprocess=="TRUE":
+ self.texteCarmel3D_SH+= 'echo "Debut execution postprocess" \n'
+ self.texteCarmel3D_SH+= self.repertory+"/postprocess.exe < " + self.projet + ".inpostprocess\n"
+ f.write(self.texteCarmel3D_SH)
+ f.close()
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ if self.debug:
+ print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
+ s=PythonGenerator.generMCSIMP(self,obj)
+ self.dicoCourant[obj.nom]=obj.valeurFormatee
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generMCFACT(self,obj) :
+ """recuperation de l objet MCFACT"""
+ dico={}
+ self.dicoMCFACTCourant=dico
+ self.dicoCourant=self.dicoMCFACTCourant
+ s=PythonGenerator.generMCFACT(self,obj)
+ self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=self.dicoEtapeCourant
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generPROC_ETAPE(self,obj):
+ """analyse des PROC du catalogue ( VERSION )"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+
+ if self.debug:
+ print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
+ if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
+ if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
+ return s
+
+
+
+#----------------------------------------------------------------------------------------
+ def generETAPE(self,obj):
+ """analyse des OPER du catalogue"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+ if self.debug:
+ print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)
+ if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
+ if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
+ s=PythonGenerator.generETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generMACRO_ETAPE(self,obj):
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ import generator
+ monGenerateur=generator.plugins[nomPlugin]()
+ jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
+ if self.debug:
+ print "jdc_aux_texte : %s" % jdc_aux_texte
+
+ for cle in monGenerateur.dictMaterConductor:
+ self.dictMaterConductor[cle] = monGenerateur.dictMaterConductor[cle]
+ for cle in monGenerateur.dictMaterDielectric:
+ self.dictMaterDielectric[cle] = monGenerateur.dictMaterDielectric[cle]
+ for cle in monGenerateur.dictMaterZsurfacic:
+ self.dictMaterZsurfacic[cle] = monGenerateur.dictMaterZsurfacic[cle]
+ for cle in monGenerateur.dictMaterEmIso:
+ self.dictMaterEmIso[cle] = monGenerateur.dictMaterEmIso[cle]
+ for cle in monGenerateur.dictMaterEmAnIso:
+ self.dictMaterEmAnIso[cle] = monGenerateur.dictMaterEmAnIso[cle]
+ for cle in monGenerateur.dictMaterNilmat:
+ self.dictMaterNilMat[cle] = monGenerateur.dictMaterNilMat[cle]
+ for cle in monGenerateur.dictMaterZinsulator:
+ self.dictMaterZinsulator[cle] = monGenerateur.dictMaterZinsulator[cle]
+
+ print "________FIN MACRO______________________________________"
+ s=PythonGenerator.generMACRO_ETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+#----------------------------------------------------------------------------------------
+ def generMESHGROUP(self,obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des groupes de maillage
+ """
+ try:
+ if usePrefix:
+ nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ else:
+ nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+ #
+ # on utilise le fait que obj.valeur est un dictionnaire
+ self.dictGroupes[nomGroupe] = {}
+# nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
+ # association a un materiau
+ if 'MATERIAL' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['STRAND'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ if 'Domaine' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.get_sdname()]=texte
+ print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
+
+# else:
+# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMACRO_GROUPE(self, obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des macros groupes
+ """
+ try:
+ #nomGroupe={'SOURCE':[], 'MATERIAL':[], 'LISTE':[], 'STRAND':[], }
+ if usePrefix:
+ nomGroupe = self.nomReelGroupe(obj.get_sdname()) # nom du groupe de maillage, i.e. nom du concept, avec prefixes enleves
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ else:
+ nomGroupe = obj.get_sdname() # nom du macro groupe
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+ self.dictGroupes[nomGroupe] = {}
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+ #
+ # on utilise le fait que obj.valeur est un dictionnaire
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ raise ValueError,tr("Ce MACRO_GROUPE %s ne peut pas contenir a la fois un MATERIAL et une SOURCE." % nomGroupe)
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'LISTE_MESHGROUP' in obj.valeur.keys():
+ listeStrandedInductorGeometry = True # indicateur du fait que tous les groupes de la liste sont des inducteurs bobinés ou topologiques, en morceaux ou entier (True), ou non (False). Utilisé pour savoir si le Domaine est nécessaire ou non.
+ listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictGroupes[nomGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
+ groupe = groupe.replace("'", "") # suppression des guillement simpes
+ groupe = groupe.replace('"', "") # suppression des guillement doubles
+ self.dictGroupes[nomGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
+ if not self.dictGroupes[groupe].has_key('STRAND'): listeStrandedInductorGeometry = False # au moins un groupe de la liste n'est pas un inducteur bobiné ou topologique (morceau ou entier).
+ self.dictGroupes['ordreListeJdC'].append(nomGroupe) # sauvegarde du nom du macro groupe associe a une source, dans l'ordre du JdC
+ if not listeStrandedInductorGeometry: # Erreur en cas de liste ne définissant pas que des inducteurs bobinés ou topologiques en morceaux
+ raise ValueError, tr(u"Le MACRO_GROUPE %s ne doit contenir, dans LISTE_MESHGROUP, que des morceaux d'inducteurs bobines ou topologiques." % nomGroupe)
+ # test de présence du domaine pour les cas appropriés d'inducteur bobiné ou topologique en morceau.
+ if 'Domaine' in obj.valeur.keys():
+ if listeStrandedInductorGeometry: # Domaine seulement en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.get_sdname()]=texte
+ else: # Erreur si Domaine et macro-groupe pas complètement inducteur
+ raise ValueError, tr(u"Ce MACRO_GROUPE %s contient, dans LISTE_MESHGROUP, des groupes qui ne sont pas que des morceaux d'inducteurs bobines ou topologiques. Il ne doit pas contenir de Domaine." % nomGroupe)
+ else: # Domaine manquant
+ if listeStrandedInductorGeometry: # Erreur en cas de liste définissant des inducteurs bobinés ou topologiques en morceaux
+ raise ValueError, tr(u"Ce MACRO_GROUPE %s de morceaux d'inducteurs bobines ou topologiques doit contenir aussi un Domaine." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ print "self.dictDomaine=%s" %(self.dictDomaine)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+
+ def generSOLVEUR(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Type']
+ if nature == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOLVEUR_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Methode_lineaire']
+ if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
+ if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMETHODE_ITERATIVE_BICGCR(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________iter_____________"
+
+ self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NAME BICGCR\n"
+ self.texteCarmel3D_PARAM_SOLV+=" [ITERATIVE_PARAM \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NITERMAX "+str(obj.valeur["Nombre_iterations_max"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" EPSILON "+str(obj.valeur["Precision"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
+ if self.debug:
+ print "texte = %s", texte
+
+
+ def generMETHODE_DIRECTE_MUMPS(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________directe_____________"
+
+ self.texteCarmel3D_PARAM_SOLV+="[SOLVER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" NAME MUMPS\n"
+ self.texteCarmel3D_PARAM_SOLV+=" [MUMPS_PARAMETER \n"
+ self.texteCarmel3D_PARAM_SOLV+=" SYM "+str(obj.valeur["Type_de_matrice"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ICNTL "+str(obj.valeur["ICNTL_Control_Parameters"])+" "+str(obj.valeur["CNTL_Control_Parameters"])+"\n"
+ self.texteCarmel3D_PARAM_SOLV+=" ]\n] \n"
+ if self.debug:
+ print "texte = %s", texte
+
+
+
+ def generMATERIAL(self,obj):
+ """preparation du bloc correspondant a un materiau du fichier PHYS"""
+ texte=""
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['TYPE'] # la nature est le parametre TYPE du MATERIAL
+ if nature=="CONDUCTOR" : self.generMATERIAL_CONDUCTOR(obj)
+ if nature=="DIELECTRIC" : self.generMATERIAL_DIELECTRIC(obj)
+ if nature=="ZSURFACIC" : self.generMATERIAL_ZSURFACIC(obj)
+ if nature=="EM_ISOTROPIC" : self.generMATERIAL_EMISO(obj)
+ if nature=="EM_ANISOTROPIC" : self.generMATERIAL_EMANISO(obj)
+ if nature=="NILMAT" : self.generMATERIAL_NILMAT(obj)
+ if nature=="ZINSULATOR" : self.generMATERIAL_ZINSULATOR(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMATERIAL_CONDUCTOR(self,obj):
+ """preparation du sous bloc CONDUCTOR"""
+ texte=""
+ if self.debug:
+ print "_____________cond_____________"
+ # verification des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le matériau conducteur (CONDUCTOR) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
+ raise ValueError, tr("ERREUR! Le materiau conducteur (CONDUCTOR) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
+ else:
+ # parcours des proprietes du sous bloc CONDUCTOR (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in ('PERMEABILITY','CONDUCTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterConductor[obj.get_sdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
+
+ def generMATERIAL_DIELECTRIC(self,obj):
+ """preparation du sous bloc DIELECTRIC"""
+ texte=""
+ if self.debug:
+ print "______________nocond_____________"
+ # verification des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ if 'PERMITTIVITY' not in obj.valeur:
+ print "obj.valeur=%s" %obj.valeur
+ obj.valeur["PERMITTIVITY"]={'HOMOGENEOUS': 'TRUE', 'LAW': 'LINEAR', 'ISOTROPIC': 'TRUE', 'VALUE': 1}
+
+ # parcours des proprietes du sous bloc DIELECTRIC (PERMEABILITY, PERMITTIVITY)
+ for keyN1 in ('PERMEABILITY','PERMITTIVITY') :
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # loi non lineaire de nature spline, Marrocco ou Marrocco et Saturation
+ # seuls les reels sont pris en compte
+ if obj.valeur[keyN1]['LAW']=='NONLINEAR' :
+ texte+=" [NONLINEAR \n"
+ texte+=" ISOTROPY TRUE\n"
+ texte+=" NATURE "+str(obj.valeur[keyN1]['NATURE'])+"\n"
+ # ajout des autres parametres autres que ISOTROPY, NATURE, VALUE, LAW, HOMOGENEOUS, ISOTROPIC
+ for keyN2 in obj.valeur[keyN1] :
+ if keyN2 not in ('ISOTROPY','NATURE','VALUE','LAW','HOMOGENEOUS','ISOTROPIC') :
+ texte+=" "+keyN2+" "+str(obj.valeur[keyN1][keyN2])+"\n"
+ # fin du sous-bloc NONLINEAR
+ texte+=" ]"+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s" % texte
+ self.dictMaterDielectric[obj.get_sdname()]={'texte': texte, 'valeur': obj.valeur} # sauvegarde du texte pour ce bloc, ainsi que de toutes les valeurs pour analyse ultérieure
+
+ def generMATERIAL_ZSURFACIC(self,obj):
+ """preparation du sous bloc ZSURFACIC"""
+ texte=""
+ if self.debug:
+ print "______________zsurf_____________"
+ # verification des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ if 'PERMEABILITY' not in obj.valeur or 'CONDUCTIVITY' not in obj.valeur:
+ print "ERREUR! Le matériau impedance de surface (ZSURFACIC) de nom %s doit contenir les propriétés PERMEABILITY et CONDUCTIVITY." % obj.get_sdname()
+ raise ValueError, tr("ERREUR! Le materiau impedance de surface (ZSURFACIC) de nom %s doit contenir les proprietes PERMEABILITY et CONDUCTIVITY." % obj.get_sdname())
+ else:
+ # parcours des proprietes du sous bloc ZSURFACIC (PERMEABILITY, CONDUCTIVITY)
+ for keyN1 in obj.valeur :
+ if keyN1=='TYPE': continue
+ # print "type loi = ", obj.valeur[keyN1]['LAW']
+ # debut du sous bloc de propriete du DIELECTRIC
+ texte+=" ["+keyN1+"\n"
+ texte+=" HOMOGENEOUS "+str(obj.valeur[keyN1]["HOMOGENEOUS"])+"\n"
+ texte+=" ISOTROPIC "+str(obj.valeur[keyN1]["ISOTROPIC"])+"\n"
+ # Ecriture des valeurs seulement pour un materiau homogene et isotrope,
+ # car sinon ces valeurs sont definies dans des fichiers annexes
+ homogeneous = str(obj.valeur[keyN1]["HOMOGENEOUS"]) == 'TRUE'
+ isotropic = str(obj.valeur[keyN1]["ISOTROPIC"]) == 'TRUE'
+ if homogeneous and isotropic:
+ # loi (lineaire ou non)
+ texte+=" LAW "+str(obj.valeur[keyN1]["LAW"])+"\n"
+ # valeur de la loi lineaire
+ texte+=" VALUE "+self.formateCOMPLEX(obj.valeur[keyN1]["VALUE"])+"\n"
+ # fin du sous bloc de propriete
+ texte+=" ]"+"\n"
+ if self.debug:
+ print "texte = %s", texte
+ self.dictMaterZsurfacic[obj.get_sdname()]=texte # sauvegarde du texte pour ce bloc
+
+ def generMATERIAL_EMISO(self,obj):
+ """preparation du sous bloc EM_ISOTROPIC_FILES.
+ Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ if "CONDUCTIVITY_File" in obj.valeur:
+ texte =" CONDUCTIVITY MED "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ if "PERMEABILITY_File" in obj.valeur:
+ texte+=" PERMEABILITY MED "+str(obj.valeur["PERMEABILITY_File"])+"\n"
+ # Possibilite de forcer le chemin relatif (nom de fichier seulement) plutot que le chemin absolu par defaut
+ #from os.path import basename
+ #texte =" CONDUCTIVITY MED "+basename(str(obj.valeur["CONDUCTIVITY_File"]))+"\n"
+ #texte+=" PERMEABILITY MED "+basename(str(obj.valeur["PERMEABILITY_File"]))+"\n"
+ # print "obj get sdname= ", obj.get_sdname()
+ # if obj.get_sdname() in self.dictMaterEmIso.keys() :
+ # self.dictMaterEmIso[obj.get_sdname()].append(texte)
+ # else :
+ self.dictMaterEmIso[obj.get_sdname()]=texte
+
+ def generMATERIAL_EMANISO(self,obj):
+ """preparation du sous bloc EM_ANISOTROPIC_FILES.
+ Les fichiers sont indiques par le chemin absolu, i.e. le nom complet du JdC,
+ ce qui permet de deplacer les dossiers contenant le modele complet puisque le JdC permet les chemins relatifs.
+ """
+ if "CONDUCTIVITY_File" in obj.valeur:
+ texte =" CONDUCTIVITY MATER "+str(obj.valeur["CONDUCTIVITY_File"])+"\n"
+ if "PERMEABILITY_File" in obj.valeur:
+ texte+=" PERMEABILITY MATER "+str(obj.valeur["PERMEABILITY_File"])+"\n"
+ # print "obj get sdname= ", obj.get_sdname()
+ # if obj.get_sdname() in self.dictMaterEmAnIso.keys() :
+ # self.dictMaterEmAnIso[obj.get_sdname()].append(texte)
+ # else :
+ self.dictMaterEmAnIso[obj.get_sdname()]=texte
+
+ def generMATERIAL_NILMAT(self,obj):
+ """preparation du sous bloc NILMAT"""
+ texte=""
+ self.dictMaterNilmat[obj.get_sdname()]=texte
+
+ def generMATERIAL_ZINSULATOR(self,obj):
+ """"preparation du sous bloc ZINSULATOR"""
+ texte=""
+ self.dictMaterZinsulator[obj.get_sdname()]=texte
+
+#-------------------------------------------------------------------
+
+ def generSOURCE(self,obj):
+ """preparation du bloc correspondant a une source du fichier PHYS"""
+ if self.debug:
+ print "generation source obj valeur = %s" % obj.valeur
+ texte=""
+ try :
+ # test de la presence des types de sources reconnus
+ # commes ces sources sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "STRANDED_INDUCTOR" in obj.valeur:
+ self.generSOURCE_STRANDED_INDUCTOR(obj)
+ elif "HPORT" in obj.valeur:
+ self.generSOURCE_HPORT(obj)
+ elif "EPORT" in obj.valeur:
+ self.generSOURCE_EPORT(obj)
+ else:
+ print "ERREUR! Une source du type STRANDED_INDUCTOR, HPORT ou EPORT est attendue."
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_STRANDED_INDUCTOR(self,obj):
+ """preparation du sous bloc STRANDED_INDUCTOR"""
+ texte=""
+ sdict = obj.valeur['STRANDED_INDUCTOR'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ try :
+ texte+=" NTURNS %s\n" % str(sdict['NTURNS'])
+ self.nturns=sdict['NTURNS']
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante \
+ n'est possible qu'a frequence nulle \
+ en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" CURJ POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du \
+ type WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceStInd[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_HPORT(self,obj):
+ """preparation du sous bloc HPORT"""
+ texte=""
+ sdict = obj.valeur['HPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ nomPort = obj.get_sdname()
+ self.dictPort[nomPort] = {}
+ self.dictPort[nomPort]['HPORT']=str(sdict['TYPE'])
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante n'est \
+ possible qu'a frequence nulle en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du type \
+ WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceHport[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOURCE_EPORT(self,obj):
+
+
+ """preparation du sous bloc EPORT"""
+ texte=""
+ sdict = obj.valeur['EPORT'] # dictionnaire contenant les parametres de la source, outre la forme de la source
+ nomPort = obj.get_sdname()
+ self.dictPort[nomPort] = {}
+ self.dictPort[nomPort]['EPORT']=str(sdict['TYPE'])
+ print "sdict=%s" %(sdict)
+ try :
+ texte+=" TYPE %s\n" % str(sdict['TYPE'])
+ # test de la presence d'une forme de source reconnue
+ # commes ces formes sont des mot-cles facteurs, i.e. une cle de dictionnaire,
+ # la source ne peut contenir au plus qu'un type de source.
+ if "WAVEFORM_CONSTANT" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_CONSTANT'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %s 0\n" % str(wdict['AMPLITUDE'])
+ print tr("ATTENTION! Une source constante n'est possible qu'a frequence nulle en regime frequentiel")
+ elif "WAVEFORM_SINUS" in obj.valeur:
+ wdict = obj.valeur['WAVEFORM_SINUS'] # dictionnaire contenant les parametres de la forme de la source
+ if self.problem == HARMONIC:
+ texte+=" AMP POLAR %(ampli)s %(phase)s\n" \
+ % {'ampli': str(wdict['AMPLITUDE']), 'phase': str(wdict['PHASE'])}
+ else:
+ print tr("ERREUR! Une forme de la source du type \
+ WAVEFORM_CONSTANT ou WAVEFORM_SINUS est attendue.")
+ self.dictSourceEport[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+ except ValueError, err:
+ raise ValueError, str(err)
+
+#
+ def generPARAM_CIRCULAIRE(self, obj):
+ if self.debug:
+ print "generation stranded inductor geometry obj.valeur = %s" % obj.valeur
+ self.centre=obj.valeur["Centre"]
+
+ def generPOST_COMMANDS(self, obj):
+ """Création du texte de commandes de post-traitement toto.cmd"""
+ if self.debug:
+ print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
+
+ if obj.valeur.has_key('GLOBAL'):
+ self.texteCarmel3D_CMD+="[\nGLOBAL\n]\n"
+ if obj.valeur.has_key('VISU'):
+ self.texteCarmel3D_CMD+="[\nVISU"
+ # test de fichier de maillage bien lu
+ if self.fichierMaillage == "": raise ValueError, tr("ERREUR! Le fichier de maillage n'existe pas. Le bloc PARAMETERS doit etre defini au dessus du bloc POST_COMMANDS.")
+ self.texteCarmel3D_CMD+="\n"+self.projet+"\n"
+ self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Format"]+"\n"
+ self.texteCarmel3D_CMD+=obj.valeur["VISU"]["VISU_Type"]+"\n]\n"
+ if obj.valeur.has_key('CUTLINE'):
+ champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ self.texteCarmel3D_CMD+="[\nCUTLINE"
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["first_point"]))
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTLINE"]["last_point"]))
+ self.texteCarmel3D_CMD+="\n%d" % (obj.valeur["CUTLINE"]["number_of_points"], )
+ self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTLINE"]["name"]
+ # création du champ, renommé par rapport à l'interface
+ self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTLINE"]["field"]]
+ self.texteCarmel3D_CMD+="\n]\n"
+ if obj.valeur.has_key('CUTPLANE'):
+ champs = {'H':'HFIELD', 'B':'BFIELD', 'J':'JFIELD', 'E':'EFIELD'} # correspondance sur le nom du champ entre le catalogue (clé) et le fichier de configuration de Code_Carmel3D (valeur)
+ axes = {'Ox':1, 'Oy':2, 'Oz':3} # correspondance de l'axe normal entre le catalogue (clé) et le fichier de configuration Code_Carmel3D (valeur)
+ self.texteCarmel3D_CMD+="[\nCUTPLANE"
+ self.texteCarmel3D_CMD+="\n%d" % (axes[obj.valeur["CUTPLANE"]["normal_vector"]], )
+ self.texteCarmel3D_CMD+="\n%f" % (obj.valeur["CUTPLANE"]["plane_position"], )
+ self.texteCarmel3D_CMD+="\n%s" % ' '.join(map(str,obj.valeur["CUTPLANE"]["number_of_points"]))
+ self.texteCarmel3D_CMD+="\n" + obj.valeur["CUTPLANE"]["name"]
+ self.texteCarmel3D_CMD+="\n" + champs[obj.valeur["CUTPLANE"]["field"]]
+ self.texteCarmel3D_CMD+="\n]\n"
+
+
+#---------------------------------------------------------------------------------------
+# traitement fichier PHYS
+#---------------------------------------------------------------------------------------
+ def generBLOC_VERSION(self,obj) :
+ # constitution du bloc VERSION du fichier PHYS
+ # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
+ # dans le du catalogue
+ version=obj.addentite('VERSION',pos=None)
+ self.generPROC_ETAPE(obj.etapes[0])
+ self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
+ for cle in obj.etapes[0].valeur :
+ self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
+ self.texteCarmel3D+="]\n"
+ # destruction de l entite creee
+ obj.suppentite(version)
+ #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
+ #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
+
+
+ def generBLOC_PARAMETERS(self,obj):
+ if self.debug:
+ print "generation parameters obj.valeur = %s" % obj.valeur
+
+ self.frequency=obj.valeur["FREQUENCY"]
+ self.repertory=obj.valeur["RepCarmel"]
+ self.fichierMaillage=obj.valeur["Fichier_maillage"]
+ self.nomFichierMaillage = os.path.basename(self.fichierMaillage) # nom du fichier de maillage, sans le chemin
+ self.projet = self.nomFichierMaillage.split(".")[0] # nom du projet, utilisé un peu partout, équivalent au nom du fichier de maillage sans l'extension
+ self.echelle=obj.valeur["Echelle_du_maillage"]
+ self.gendof=obj.valeur["Realiser_topologie_gendof"]
+ self.fcarmel=obj.valeur["Resoudre_probleme"]
+ self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
+ self.formulation=obj.valeur["Formulation"]
+#----------------------------------------------------------------------------------------
+ def generBLOC_MATERIALS(self) :
+ """Prepare une partie du contenu du fichier de parametres (PHYS) pour le code Carmel3D (bloc MATERIALS).
+ Le bloc MATERIALS existe toujours !
+ """
+ if self.debug:
+ print "cle dictionnaire materconductor : %s" % self.dictMaterConductor.keys()
+ print "cle dictionnaire materdielectric : %s" % self.dictMaterDielectric.keys()
+ # constitution du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="[MATERIALS\n"
+ # tri alphabetique de tous les groupes de maillage associes a des sources (plus necessaire Code_Carmel3D V_2_3_1 et +, mais avant oui)
+ nomsGroupes = self.dictGroupes['ordreMateriauxJdC'][:] # copie de l'original, qui est une liste
+ nomsGroupes.sort() # tri alphabetique, avec les prefixes eventuels
+ if self.debug:
+ print "noms groupes de mailles associes a des materiaux \
+ (ordre JdC puis tri)= %(v_1)s %(v_2)s" % \
+ {'v_1': self.dictGroupes['ordreMateriauxJdC'], \
+ 'v_2': nomsGroupes}
+ try: # mise à jour du fichier .phys selon les matériaux trouvés
+ # constitution du bloc CONDUCTOR du fichier PHYS si existe
+ if self.dictMaterConductor != {} : self.creaBLOC_CONDUCTOR(nomsGroupes)
+ # constitution du bloc DIELECTRIC du fichier PHYS si exixte
+ if self.dictMaterDielectric != {} : self.creaBLOC_DIELECTRIC(nomsGroupes)
+ # constitution du bloc ZSURFACIC du fichier PHYS si exixte
+ if self.dictMaterZsurfacic != {} : self.creaBLOC_ZSURFACIC(nomsGroupes)
+ # constitution du bloc NILMAT du fichier PHYS si exixte
+ if self.dictMaterNilmat != {} : self.creaBLOC_NILMAT(nomsGroupes)
+ # constitution du bloc ZINSULATOR du fichier PHYS si exixte
+ if self.dictMaterZinsulator != {} : self.creaBLOC_ZINSULATOR(nomsGroupes)
+ # Les blocs EM_ISOTROPIC_FILES et EM_ANISOTROPIC_FILES sont places en dernier dans le fichier PHYS
+ # constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmIso != {} and self.materiauxGroupesTousIsotropes and not self.materiauxGroupesTousHomogenes : self.creaBLOC_EMISO() # bloc isotrope si au moins un matériau isotrope et non homogene
+ # constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS si exixte
+ if self.dictMaterEmAnIso != {} and not self.materiauxGroupesTousIsotropes : self.creaBLOC_EMANISO() # bloc non isotrope si au moins un matériau non isotrope
+ except ValueError, err:
+ raise ValueError(str(err))
+
+
+ # fin du bloc MATERIALS du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+
+
+ def creaBLOC_CONDUCTOR(self, nomsGroupes) :
+ """Constitution du bloc CONDUCTOR du fichier PHYS"""
+ typeBloc = 'CONDUCTOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterConductor # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s = %(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
+ print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
+ raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom))
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE' \
+ or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE' \
+ or dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['CONDUCTIVITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_DIELECTRIC(self, nomsGroupes) :
+ """Constitution du bloc DIELECTRIC du fichier PHYS"""
+ typeBloc = 'DIELECTRIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterDielectric # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ print "jdc materiaux= %s" %(self.dictGroupes['ordreMateriauxJdC'])
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['LAW'] == 'NONLINEAR': # Erreur si ce matériau est non-linéaire
+ print u"ERREUR! Le matériau de nom %s associé au groupe %s doit avoir sa perméabilité (PERMEABILITY) linéaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom)
+ raise ValueError, tr("ERREUR! Le materiau de nom %s associe au groupe %s doit avoir sa permeabilite (PERMEABILITY) lineaire (LINEAR) seulement." % (self.dictGroupes[nom]['MATERIAL'][:], nom))
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['HOMOGENEOUS'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousHomogenes = False # alors tous les matériaux ne sont pas homogènes
+ if dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['valeur']['PERMEABILITY']['ISOTROPIC'] == 'FALSE': # recherche si matériau non-homogène
+ self.materiauxGroupesTousIsotropes = False # alors tous les matériaux ne sont pas isotropes
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]]['texte'] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_ZSURFACIC(self, nomsGroupes) :
+ """Constitution du bloc ZSURFACIC du fichier PHYS"""
+ typeBloc = 'ZSURFACIC' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZsurfacic # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_EMISO(self) :
+ """constitution du bloc EM_ISOTROPIC_FILES du fichier PHYS"""
+ for cle in self.dictMaterEmIso.keys():
+ self.texteCarmel3D+=" [EM_ISOTROPIC_FILES\n"
+ self.texteCarmel3D+= self.dictMaterEmIso[cle]
+ self.texteCarmel3D+=" ]\n"
+
+ def creaBLOC_EMANISO(self) :
+ """constitution du bloc EM_ANISOTROPIC_FILES du fichier PHYS"""
+ for cle in self.dictMaterEmAnIso.keys():
+ self.texteCarmel3D+=" [EM_ANISOTROPIC_FILES\n"
+ self.texteCarmel3D+= self.dictMaterEmAnIso[cle]
+ self.texteCarmel3D+=" ]\n"
+
+ def creaBLOC_ZINSULATOR(self, nomsGroupes) :
+ """Constitution du bloc ZINSULATOR du fichier PHYS"""
+ typeBloc = 'ZINSULATOR' # initialisation du type de bloc
+ dictProprietes = self.dictMaterZinsulator # initialisation du dictionnaire des proprietes du bloc
+ if self.debug: print 'cles materiaux de type '+typeBloc+'=', dictProprietes.keys()
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:] ] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_NILMAT(self, nomsGroupes) :
+ """Constitution du bloc NILMAT du fichier PHYS"""
+ typeBloc = 'NILMAT' # initialisation du type de bloc
+ dictProprietes = self.dictMaterNilmat # initialisation du dictionnaire des proprietes du bloc
+ if self.debug:
+ print 'cles materiaux de type %(type_bloc)s=%(cle_bloc)s' % {'type_bloc': typeBloc, 'cle_bloc': dictProprietes.keys()}
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['MATERIAL'][:] in dictProprietes.keys(): # test si le nom du materiau associe est du bon type
+ # ecriture du bloc complet
+ self.texteCarmel3D+=" ["+typeBloc+"\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= dictProprietes[self.dictGroupes[nom]['MATERIAL'][:]] # ecriture des proprietes du type associe
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+#----------------------------------------------------------------------------------------
+ def generBLOC_SOURCES(self):
+ """constitution du bloc SOURCES du fichier PHYS"""
+ self.texteCarmel3D+="[SOURCES\n"
+# # tri alphabetique de tous les groupes de maillage associes a des sources
+ nomsGroupes = self.dictGroupes['ordreSourcesJdC'][:]
+ nomsGroupes.sort()
+ # print "RESULTAT APRES FUSION self.dictGroupes= %s" %(self.dictGroupesnomsGroupes)
+
+ if self.debug:
+ print 'noms groupes de mailles associes a des sources \
+ (ordre JdC puis tri)=%(g_maillage_orig)s %(g_maillage_trie)s' % \
+ {'g_maillage_orig': self.dictGroupes['ordreSourcesJdC'], \
+ 'g_maillage_trie': nomsGroupes}
+ if self.dictSourceStInd != {}: self.creaBLOC_STRANDED_INDUCTOR(nomsGroupes)
+ if self.dictSourceEport != {}: self.creaBLOC_EPORT(nomsGroupes)
+ if self.dictSourceHport != {}: self.creaBLOC_HPORT(nomsGroupes)
+ # fin du bloc SOURCES du fichier PHYS
+ self.texteCarmel3D+="]\n"
+
+
+ def creaBLOC_STRANDED_INDUCTOR(self, nomsGroupes) :
+ """constitution du bloc STRANDED_INDUCTOR du fichier PHYS"""
+ if self.debug:
+ print 'cles sources STRANDED_INDUCTOR= %s' % self.dictSourceStInd.keys()
+ typeBloc = 'STRANDED_INDUCTOR'
+# print "liste des NOM=%s" %(nom)
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceStInd.keys(): # test si le nom de la source associee est un inducteur bobine
+ # ecriture du bloc de l'inducteur bobine
+ self.texteCarmel3D+=" [STRANDED_INDUCTOR\n" # debut de bloc
+ self.texteCarmel3D+=" NAME "+nom+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceStInd[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes de l'inducteur bobine
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_EPORT(self, nomsGroupes) :
+ """constitution du bloc EPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources EPORT= %s' % self.dictSourceEport.keys()
+ typeBloc = 'EPORT'
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceEport.keys(): # test si le nom de la source associee est un port electrique
+ # ecriture du bloc du port electrique
+ self.texteCarmel3D+=" [EPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceEport[self.dictGroupes[nom]['SOURCE'][:] ] # ecriture des proprietes du port electrique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def creaBLOC_HPORT(self, nomsGroupes) :
+ """constitution du bloc HPORT du fichier PHYS"""
+ if self.debug:
+ print 'cles sources HPORT= %s' % self.dictSourceHport.keys()
+ typeBloc = 'HPORT'
+ for nom in nomsGroupes: # parcours des noms des groupes de maillage
+ if self.dictGroupes[nom]['SOURCE'][:] in self.dictSourceHport.keys(): # test si le nom de la source associee est un port magnetique
+ # ecriture du bloc du port magnetique
+ self.texteCarmel3D+=" [HPORT\n" # debut de bloc
+ if usePrefix:
+ nomReel = self.nomReelGroupe(nom, typeBloc)
+ else:
+ nomReel = nom
+ self.texteCarmel3D+=" NAME "+nomReel+"\n" # ecriture du nom (reel) du groupe du maillage
+ self.texteCarmel3D+= self.dictSourceHport[self.dictGroupes[nom]['SOURCE'][:]] # ecriture des proprietes du port magnetique
+ self.texteCarmel3D+=" ]\n" # fin de bloc
+
+ def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
+ """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
+
+ texte=""
+ self.direction=obj.valeur["Direction"]
+ self.section=obj.valeur["Section"]
+ self.forme=obj.valeur["Forme"]
+# texte+="\n%s" %(self.domaine)
+
+ if self.forme=="Circulaire" : self.generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(obj)
+ else:
+ texte+="\n1"
+ texte+="\n%s" % ' '.join(map(str, self.direction))
+ texte+="\n%g" % (self.section)
+ self.dictStrand[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+
+ def generCIRCULAR_STRANDED_INDUCTOR_GEOMETRY(self, obj):
+ texte=""
+ self.centre=obj.valeur["Centre"]
+ texte+="\n2"
+ texte+="\n%s" % ' '.join(map(str,self.direction))
+ texte+="\n%s" % ' '.join(map(str, self.centre))
+ texte+="\n%g" % (self.section)
+ self.dictStrand[obj.get_sdname()]=texte
+ if self.debug:
+ print texte
+
+
+ def creaBLOC_STRANDED_INDUCTOR_GEOMETRY(self, nomsGroupes):
+ """Ecriture de chaque inducteur bobiné dans le in.gendof. Gestion des inducteurs en un ou plusieurs morceaux, avec le domaine.
+ Attention! L'argument nomSGroupes n'est pas utile ici. A supprimer. Routine à renommer aussi.
+ """
+ if self.debug:
+ print 'dictGroupes=', self.dictGroupes
+ print 'cles sources STRANDED_INDUCTOR_GEOMETRY= %s' % self.dictStrand.keys()
+ print "nomsGroupes=%s" %(nomsGroupes)
+ nomsSources=self.dictGroupes['ordreDomaineJdC']
+ nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
+ if self.debug: print"nomsSources=%s" %nomsSources
+ for nom in nomsSources:
+ if self.debug: print "nomSource courant=",nom
+ if self.dictGroupes[nom].has_key('SOURCE'):
+ if self.dictGroupes[nom]['SOURCE'] not in self.dictPort :
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ else:
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ if self.dictGroupes[nom].has_key('STRAND'): # inducteur en un seul morceau
+ if not self.dictGroupes[nom].has_key('DOMAINE'): raise ValueError, tr("Il manque le Domaine à l'inducteur de nom : "+nom)
+ strand = self.dictGroupes[nom]['STRAND']
+ if self.debug: print "un seul morceau : nomStrand courant=", strand
+ self.texteCarmel3D_INGEND2+= self.dictStrand[strand]
+ if self.dictGroupes[nom].has_key('LISTE'): # inducteur en plusieurs morceaux
+ listeStrand = self.dictGroupes[nom]['LISTE'] # liste des groupes de maillage composant l'inducteur, ou groupe tout seul si inducteur en un seul morceau
+ for strand in listeStrand:
+ #strand = strand.replace("'", "") # suppression des guillemets simples
+ if self.debug: print "plusieurs morceaux : nomStrand courant=",strand
+ if self.debug: print "self.dictGroupes[strand]=", self.dictGroupes[strand]
+ self.texteCarmel3D_INGEND2+= self.dictStrand[self.dictGroupes[strand]['STRAND'] ]
+
+ def creaBLOC_PORTS_GEOMETRY(self, nomsGroupes):
+ if self.debug:
+ print "self.dictSourceEport=", self.dictSourceEport
+ print "self.dictSourceHport=", self.dictSourceHport
+ nomsSources=self.dictGroupes['ordreDomaineJdC']
+ nomsSources.sort() # tri alphabétique des inducteurs, réclamé par gendof.exe
+
+ for nom in nomsSources:
+ port=self.dictGroupes[nom]['SOURCE']
+ if self.dictGroupes[nom]['SOURCE'] in self.dictPort :
+ self.texteCarmel3D_INGEND2+="\n%s" %(self.dictGroupes[nom]['DOMAINE']) # écriture du nom de domaine
+ port=self.dictGroupes[nom]['SOURCE']
+
+ if self.dictPort[port].has_key('EPORT'):# inducteur en un seul morceau
+ if self.dictPort[port]['EPORT']=="VOLTAGE":
+ self.texteCarmel3D_INGEND2+= "\n1"
+ else:
+ self.texteCarmel3D_INGEND2+= "\n2"
+ if self.dictPort[port].has_key('HPORT'):# inducteur en un seul morceau
+ if self.dictPort[port]['HPORT']=="VOLTAGE":
+ self.texteCarmel3D_INGEND2+= "\n1"
+ else:
+ self.texteCarmel3D_INGEND2+= "\n2"
+
+#-------------------------------------
+# Methodes utilitaires
+# ------------------------------------
+ def formateCOMPLEX(self,nbC):
+ """prise en compte des differentes formes de description d un nombre complexe
+ 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
+ """
+ if self.debug:
+ print "formatage"
+ print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
+ nbformate =""
+ if isinstance(nbC,(tuple,list)):
+ if nbC[0] == "'RI'" :
+ nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
+ if nbC[0] == "'MP'" :
+ nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
+ else:
+ nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
+ if self.debug:
+ print "nbformate : %s" % nbformate
+ return nbformate
+
+ def nomReelGroupe(self, nom, typeBloc=None):
+ """Calcule et retourne le nom reel du groupe de maillage donne en entree,
+ en tenant compte de l'utilisation de prefixes ou pas, et cela pour le type
+ de bloc du fichier PHYS specifie.
+ Cette routine verifie aussi, en cas d'utilisation de prefixes, si le prefixe est en adequation avec le type du bloc.
+ """
+ from string import join
+ if self.debug:
+ print "nom groupe original : %(nom)s avec usePrefix=%(use_prefix)s devient...", \
+ {'nom': nom, 'use_prefix': str(usePrefix)}
+ nomReel= None # nom affiche dans le fichier PHYS, sans prefixe a priori
+ if usePrefix:
+ # suppression du prefixe si present
+ partiesNom = nom.split(sepNomGroupeMaille) # separation du nom du groupe en parties
+ # les tests suivants ne generent une erreur que si le prefixe est obligatoire
+ if len(partiesNom) < 2: # test d'erreur, pas de separateur donc nom incorrect, i.e. sans prefixe c'est sur
+ print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe \
+ indiquant le type de materiau ou de source associee", nom)
+ elif partiesNom[0] not in listePrefixesGroupeMaille: # prefixe non defini
+ print tr("ERREUR! ce groupe de maille (%s) n'a pas de prefixe valable", nom)
+ else:
+ # verification de l'adequation du prefixe avec le type de bloc demande, si fourni
+ if typeBloc is not None:
+ if typeBloc not in dictPrefixesGroupeMaille: # test validite de typeBloc, devant etre une cle du dictionnaire
+ print tr("ERREUR! ce type de bloc (%s) n'est pas valable", str(typeBloc))
+ elif partiesNom[0] not in dictPrefixesGroupeMaille[typeBloc]: # pas de prefixe correct pour ce type de bloc
+ print tr("ERREUR! ce groupe de maille (%(nom)s) n'a pas \
+ le prefixe correct pour etre associe a un type %(type_bloc)s", \
+ {'nom': nom, 'type_bloc': str(typeBloc)})
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ else: # c'est bon
+ nomReel = join(partiesNom[1:], sepNomGroupeMaille) # reconstruction du nom du groupe sans prefixe complet
+ if self.debug:
+ print "ce groupe de maille (%(nom)s) a un prefixe qui \
+ est supprime automatiquement pour devenir : %(nom_reel)s", \
+ {'nom': nom, 'nom_reel': nomReel}
+ if self.debug:
+ print "... %s", nomReel
+ return nomReel
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2013 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 xml.etree.cElementTree as ET
+import traceback
+import types,string,re,os
+from Extensions.i18n import tr
+from generator_python import PythonGenerator
+
+# types de problemes
+HARMONIC = 'HARMONIC' # probleme frequentiel
+TIME_DOMAIN = 'TIME_DOMAIN' # probleme temporel
+
+# nom du plugin, utilisé dans entryPoint et generMACRO_ETAPE()
+nomPlugin = 'CARMEL3DTV0'
+
+def entryPoint():
+ """
+ Retourne les informations necessaires pour le chargeur de plugins
+ Ces informations sont retournees dans un dictionnaire
+ """
+ return {
+ # Le nom du plugin
+ 'name' : nomPlugin,
+ # La factory pour creer une instance du plugin
+ 'factory' : CARMEL3DTV0Generator,
+ }
+
+
+
+class CARMEL3DTV0Generator(PythonGenerator):
+ """
+ Ce generateur parcourt un objet de type JDC et produit
+ un texte au format eficas et
+ un texte au format attendu par le code Code_Carmel3D (fichier '.PHYS')
+
+ """
+ # Les extensions de fichier permis?
+ extensions=('.comm',)
+
+#----------------------------------------------------------------------------------------
+ def gener(self,obj,format='brut',config=None):
+
+ self.initDico()
+
+ #self.debug = True
+
+ # Cette instruction genere le contenu du fichier de commandes (persistance)
+ self.text=PythonGenerator.gener(self,obj,format)
+
+ if self.debug:
+ print "self.text = %s" % self.text
+
+ # Cette instruction genere le contenu du fichier de parametres pour le code Carmel3D
+ # si le jdc est valide (sinon cela n a pas de sens)
+ if obj.isvalid() :
+ try :
+ # constitution du bloc VERSION du fichier PHYS (existe toujours)
+ self.generBLOC_VERSION(obj)
+
+ except ValueError, err:
+ raise ValueError(str(err))
+
+ return self.text
+
+
+
+
+#----------------------------------------------------------------------------------------
+# initialisations
+#----------------------------------------------------------------------------------------
+
+ def initDico(self) :
+ self.texteCarmel3D=""
+ self.texteCarmel3D_SH=""
+ self.debug = True # affichage de messages pour deboguage (.true.) ou non
+ self.dicoEtapeCourant=None
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=None
+ self.dictGroupes = {} # association des noms de groupes de maillage avec les noms de materiaux ou de sources, en sauvegardant l'ordre du JdC en separant les groupes associes a des materiaux de ceux associes a des sources
+ self.dictMacroGroupes = {} # macro-groupe et leurs propriétés
+ self.listSymetrie=[]
+ self.dictMouvement= {'ordre':[]} # dictionnaire contenant les mouvements, avec liste incluse pour l'ordre
+ self.nombreMouvements = 0 # nombre de mouvements définis, servant de compteur aussi
+ self.dictMaterial={}
+ self.dictSource={}
+ self.dictStrand={}
+ self.dictGroupeMilieux={"ordreSource":[], "ordreId":[]}
+ self.dictDomaine={}
+ # Parametre du maillage
+ self.identification = ""
+ self.fichierMaillage = ""
+ self.echelleMaillage = ""
+ # Parametre de Precision
+ self.precond=""
+ self.precisionLineaire=""
+ self.kEpsilonDistance=""
+ self.kdistanceRef=""
+ self.nbIterationMax=""
+ self.methodeNonLineaire = ""
+ self.kEpsilonNonLinearite=""
+ self.kCoefficientRelaxation=""
+ self.jauge=""
+ self.NBoucleTemps=""
+ self.dt=""
+ # Paramètres divers
+ self.typeSolveur = "" # type de solveur, linéaire (Solveur_lineaire) ou non-linéaire (Solveur_non_lineaire)
+ #Post traitement
+ self.carteChamp=""
+ self.carteCourantInduit=""
+ self.carteForce=""
+ self.perteJoule=""
+ self.fluxInducteur=""
+ self.courantInducteur=""
+ self.tensionInducteur=""
+ self.energie=""
+ self.ForceCouple=""
+ self.fluxSpire=""
+ self.fluxGroupe=""
+ self.ddpElect=""
+ self.ddpMagn=""
+ self.fluxMagn=""
+ self.fluxJinduitTotal=""
+ self.potFlottant = ""
+
+ # on force le probleme a etre frequentiel, seul possible en l'etat des choses
+ self.problem = HARMONIC
+
+ def indent(self, elem, level=0, more_sibs=False, espace=4*' '):
+ """Transformation du XML créé par le module interne xml.etree.ElementTree afin d'écrire les indentations et retours à la ligne corrects.
+ D'après un script original de Fredrik Lundh en 2004 (http://effbot.org/zone/element-lib.htm#prettyprint),
+ modifié par Joshua Richardson en 2012 (http://stackoverflow.com/questions/749796/pretty-printing-xml-in-python)
+ et par Loic Chevallier en 2014 (ajout du reglage de l'indentation).
+ L'indentation est de 4 espaces par défaut (cf. argument optionel : espace)
+ Utilisation : self.indent(root), avant écriture dans un fichier de root = ET.Element("configuration") ou de tree = ET.ElementTree(root)
+ où ET = xml.etree.ElementTree
+ """
+ i = "\n"
+ if level:
+ i += (level-1) * espace
+ num_kids = len(elem)
+ if num_kids:
+ if not elem.text or not elem.text.strip():
+ elem.text = i + espace
+ if level:
+ elem.text += espace
+ count = 0
+ for kid in elem:
+ self.indent(kid, level+1, count < num_kids - 1)
+ count += 1
+ if not elem.tail or not elem.tail.strip():
+ elem.tail = i
+ if more_sibs:
+ elem.tail += espace
+ else:
+ if level and (not elem.tail or not elem.tail.strip()):
+ elem.tail = i
+ if more_sibs:
+ elem.tail += espace
+
+#----------------------------------------------------------------------------------------
+# ecriture
+#----------------------------------------------------------------------------------------
+
+ def writeDefault(self,fn) :
+ """Ecrit les fichiers de parametres et le fichier d'execution pour le code Carmel3D"""
+
+ file = fn[:fn.rfind(".")] # emplacement du ficher .comm (chemin complet)
+ namefile=os.path.basename(file) # nom du fichier.comm
+ repertory=os.path.dirname(file) # répertoire contenant le fichier .comm (emplacement absolu)
+
+ # correspondances globales
+ correspondance_booleen = {'oui':'true', 'non':'false'}
+
+ fileXML = os.path.join(repertory, 'configuration.xml') # nom du fichier de configuration XML (chemin complet)
+ if self.debug:
+ print "\necriture du fichier XML : ", fileXML
+ print "self.dictMaterial = ",self.dictMaterial
+ print "self.dictSource = ",self.dictSource
+ print "self.dictGroupes = ",self.dictGroupes
+ print "self.dictMacroGroupes = ",self.dictMacroGroupes
+
+ root = ET.Element("configuration")
+
+ #Bloc <Maillage></Maillage>
+ Maillage = ET.SubElement(root, "Maillage")
+ identification = ET.SubElement(Maillage, "identification")
+ identification.text = self.identification
+ fichierMaillage = ET.SubElement(Maillage, "fichierMaillage")
+ fichierMaillage.text = self.fichierMaillage
+ echelleMaillage = ET.SubElement(Maillage, "echelleMaillage")
+ correspondance_echelleMaillage = {"Metre":1.0, "Millimetre":1.0e-3}
+ echelleMaillage.text = "%f" % (correspondance_echelleMaillage[self.echelleMaillage], )
+
+ #Bloc <ParametrePrecision></ParametrePrecision>
+ ParametrePrecision = ET.SubElement(root, "ParametrePrecision")
+ TypeSolveurLineaire = ET.SubElement(ParametrePrecision, "TypeSolveurLineaire")
+ if self.precond=="Crout":
+ TypeSolveurLineaire.text = "1"
+ if self.precond=="Jacobi":
+ TypeSolveurLineaire.text = "2"
+ if self.precond=="MUMPS":
+ TypeSolveurLineaire.text = "3"
+ kEpsilonGCP = ET.SubElement(ParametrePrecision, "kEpsilonGCP")
+ kEpsilonGCP.text = "%s" %(self.kEpsilonGCP)
+ nbIterationMax = ET.SubElement(ParametrePrecision, "nbIterationMax")
+ nbIterationMax.text = "%s" %(self.nbIterationMax)
+ if self.typeSolveur == 'Solveur_non_lineaire': # écriture des paramètres du solveur non-linéaire seulement si défini dans l'étude
+ methodeNonLineaire = ET.SubElement(ParametrePrecision, "methodeNonLineaire")
+ methodeNonLineaire.text = "%s" %(self.methodeNonLineaire)
+ kEpsilonNonLinearite = ET.SubElement(ParametrePrecision, "kEpsilonNonLinearite")
+ kEpsilonNonLinearite.text = "%s" %(self.kEpsilonNonLinearite)
+ kCoefficientRelaxation = ET.SubElement(ParametrePrecision, "kCoefficientRelaxation")
+ kCoefficientRelaxation.text = "%s" %(self.kCoefficientRelaxation)
+ kEpsilonDistance = ET.SubElement(ParametrePrecision, "kEpsilonDistance")
+ kEpsilonDistance.text = "%s" %(self.kEpsilonDistance)
+ kdistanceRef = ET.SubElement(ParametrePrecision, "kdistanceRef")
+ kdistanceRef.text = "%s" %(self.kdistanceRef)
+ jauge = ET.SubElement(ParametrePrecision, "jauge")
+ jauge.text = "%s" %(correspondance_booleen[self.jauge], )
+ NBoucleTemps = ET.SubElement(ParametrePrecision, "NBoucleTemps")
+ NBoucleTemps.text = "%s" %(self.NBoucleTemps)
+ dt = ET.SubElement(ParametrePrecision, "dt")
+ dt.text = "%s" %(self.dt)
+
+ #Bloc <Milieux></Milieux>
+ i=0
+ j=0
+ p=0
+ k=0
+ listeMilieux = [] # liste des milieux, dans l'ordre de création
+ Milieux=ET.SubElement(root, "Milieux") # création du bloc <Milieux>...</Milieux>
+ for nom in self.dictGroupes: # on parcoure tous les groupes MESHGROUP
+ if self.dictGroupes[nom].has_key('MATERIAL') \
+ or self.dictGroupes[nom].has_key('SOURCE') \
+ or self.dictGroupes[nom].has_key('AIMANT') \
+ or self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY') : # si MESHGROUP ou MACRO_GROUPE associé à au moins un matériau, source ou géométrie d'inducteur bobiné, c'est un milieu
+ milieu=ET.SubElement(Milieux,"milieu" ) # création d'un nouveau milieu
+ listeMilieux.append(nom) # mise à jour de la liste des milieux
+ i = i+1 # incrément du numéro de milieu
+ self.dictGroupes[nom]['idMilieu'] = i # affectation de l'id à ce groupe
+ milieu.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ milieu.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+ nomGroupeMaillage = ET.SubElement(milieu, "nomGroupeMaillage") # nom du groupe de maillage
+ nomGroupeMaillage.text = nom
+ if self.dictGroupes[nom].has_key('MATERIAL'): # matériau trouvé pour ce milieu
+ material = self.dictGroupes[nom]['MATERIAL'] # on récupère le nom de la propriété du matériau, clé de self.dictMaterial
+ permeabiliteLineaire=ET.SubElement(milieu, "permeabiliteLineaire")
+ permeabiliteLineaire.text="%s"%(self.dictMaterial[material]["PERMEABILITY"]["VALUE"])
+ if self.dictMaterial[material]["PERMEABILITY"]["LAW"]=="NONLINEAR":
+ coefficientsMarrocco=ET.SubElement(milieu, "coefficientsMarrocco")
+ epsilon = self.dictMaterial[material]["PERMEABILITY"]["EPSILON"]
+ c = self.dictMaterial[material]["PERMEABILITY"]["C"]
+ alpha = self.dictMaterial[material]["PERMEABILITY"]["ALPHA"]
+ tau = self.dictMaterial[material]["PERMEABILITY"]["TAU"]
+ coefficientsMarrocco.text = '%g, %g, %g, %g' % (epsilon, c, alpha, tau)
+ if self.dictMaterial[material].has_key('CONDUCTIVITY'):
+ conductivite=ET.SubElement(milieu, "conductivite")
+ conductivite.text="%s" %(self.dictMaterial[material]["CONDUCTIVITY"]["VALUE"])
+ if self.dictMaterial[material].has_key('AIMANT'):
+ norme=ET.SubElement(milieu, "norme")
+ norme.text="%s" %(self.dictMaterial[material]["AIMANT"]["VALUE"])
+ if self.dictGroupes[nom].has_key('STRANDED_INDUCTOR_GEOMETRY'): # géométrie d'inducteur bobiné trouvée pour ce milieu
+ strand=self.dictGroupes[nom]['STRANDED_INDUCTOR_GEOMETRY'] # on récupère le nom de la géométrie d'inducteur bobiné, clé de self.dictStrand
+ axe = ET.SubElement(milieu, "axe")
+ axe.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Direction"]))
+ if self.dictStrand[strand]["Forme"]=="Circulaire":
+ coordonneesPolaires=ET.SubElement(milieu, "coordonneesPolaires")
+ coordonneesPolaires.text="true"
+ origineReperePolaire=ET.SubElement(milieu, "origineReperePolaire")
+ origineReperePolaire.text= "%s" % ','.join(map(str,self.dictStrand[strand]["Centre"]))
+ section=ET.SubElement(milieu, "section")
+ section.text="%g" %(self.dictStrand[strand]["Section"], )
+ if self.dictGroupes[nom].has_key('SOURCE'): # source trouvée pour ce milieu
+ Source = self.dictGroupes[nom]['SOURCE'] # on récupère le nom de la source, clé de self.dictSource
+ self.dictSource[Source]['milieux'].append(nom) # ajout du nom du groupe à cette source
+ if self.dictSource[Source].has_key('STRANDED_INDUCTOR'):
+ nbSpires=ET.SubElement(milieu, "nbSpires")
+ nbSpires.text="%g" %(self.dictSource[Source]["STRANDED_INDUCTOR"]["NTURNS"])
+
+ #Bloc <ConditionsLimitesChamps>...</ConditionsLimitesChamps>
+ ConditionsLimitesChamps = ET.SubElement(root, "ConditionsLimitesChamps")
+ for nomCondition in self.dictGroupes:
+ if self.dictGroupes[nomCondition].has_key('CONDITION_LIMITE'): # condition aux limites associée à ce groupe, hors symétrie et mouvement
+ if self.dictGroupes[nomCondition].has_key('LISTE'): # MACRO_GROUPE
+ for i in range(len(self.dictGroupes[nomCondition]['LISTE'])):
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(self.dictGroupes[nomCondition]['LISTE'][i])
+ else: # MESHGROUP
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamps")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text=self.dictGroupes[nomCondition]["CONDITION_LIMITE"]
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(nomCondition)
+
+ for i in range(len(self.listSymetrie)): # symétries, définies dans le bloc des conditions aux limites
+ conditionLimite = ET.SubElement(ConditionsLimitesChamps, "conditionLimitesChamp")
+ Type=ET.SubElement(conditionLimite,"type" )
+ Type.text="%s" %(self.listSymetrie[i]["Type"])
+ GroupeNoeud=ET.SubElement(conditionLimite, "groupeNoeud")
+ GroupeNoeud.text="%s" %(self.listSymetrie[i]["Face1"])
+ if 'Face2' in self.listSymetrie[i] :
+ GroupeNoeud2=ET.SubElement(conditionLimite, "groupeNoeud2")
+ GroupeNoeud2.text="%s" %(self.listSymetrie[i]["Face2"])
+ if 'Mouvement_associe' in self.listSymetrie[i]:
+ MouvementAssocie=ET.SubElement(conditionLimite, "mouvementAssocie")
+ nomMouvementAssocie = self.listSymetrie[i]['Mouvement_associe'].nom # on récupère le nom du mouvement associé, car on a stocké le concept tout entier
+ MouvementAssocie.text="%i"%(self.dictMouvement[nomMouvementAssocie]['ordre'], )
+ if 'Groupe_Points' in self.listSymetrie[i] :
+ GroupePoints=ET.SubElement(conditionLimite, "groupePoints")
+ GroupePoints.text="%s" %(self.listSymetrie[i]['Groupe_Points'])
+
+ #Bloc <TermeSourceElectrique>...</TermeSourceElectrique>
+ TermeSourceElectrique=ET.SubElement(root, "TermeSourceElectrique")
+ i=0 # ?
+ if self.debug: print 'self.dictSource = ', self.dictSource
+ for source in self.dictSource.keys(): # parcours des sources
+ if len(self.dictSource[source]['milieux']) > 0: # on continue si au moins un groupe de maillage, i.e., milieux est associé à cette source
+ if self.dictSource[source].has_key('STRANDED_INDUCTOR'): # inducteur bobiné
+ inducteur=ET.SubElement(TermeSourceElectrique, "inducteur")
+ listeMilieux=ET.SubElement(inducteur, "listeMilieux") # création de la liste des milieux
+ idListeMilieux = [] # indices des milieux concernés
+ for milieu in self.dictSource[source]['milieux']: # construction de la liste des milieux
+ idListeMilieux.append(self.dictGroupes[milieu]['idMilieu'])
+ listeMilieux.text = "%s" % ','.join(map(str,idListeMilieux))
+ if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="CURRENT": # source de type courant imposé
+ couplageTension=ET.SubElement(inducteur, "couplageTension")
+ couplageTension.text = "false"
+ courant=ET.SubElement(inducteur, "courant")
+ if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
+ courant.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
+ if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
+ amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
+ frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
+ phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
+ courant.text="%g, %g, %g" % (amplitude, frequence, phase)
+ courant.set('forme', 'sinus') # attribut forme="sinus"
+ if self.dictSource[source]["STRANDED_INDUCTOR"]["TYPE"]=="VOLTAGE": # source de type tension imposée
+ couplageTension=ET.SubElement(inducteur, "couplageTension")
+ couplageTension.text = "true"
+ tension=ET.SubElement(inducteur, "tension")
+ if self.dictSource[source]["Signal"]=="WAVEFORM_CONSTANT":
+ tension.text="%g" %(self.dictSource[source]["WAVEFORM_CONSTANT"]["AMPLITUDE"])
+ if self.dictSource[source]["Signal"]=="WAVEFORM_SINUS": # écriture des 3 paramètres avec attribut spécial
+ amplitude = self.dictSource[source]["WAVEFORM_SINUS"]["AMPLITUDE"]
+ frequence = self.dictSource[source]["WAVEFORM_SINUS"]["FREQUENCY"]
+ phase = self.dictSource[source]["WAVEFORM_SINUS"]["PHASE"]
+ tension.text="%g, %g, %g" % (amplitude, frequence, phase)
+ tension.set('forme', 'sinus') # attribut forme="sinus"
+ if self.dictSource[source]["STRANDED_INDUCTOR"].has_key('Resistance'):
+ resistance=ET.SubElement(inducteur, "resistance")
+ resistance.text="%g" %(self.dictSource[source]["STRANDED_INDUCTOR"]['Resistance'])
+
+ #definir Terme Source Magnetique
+ #definirTermeSourceMagnetique=ET.SubElement(root, "definirTermeSourceMagnetique")
+ #nombreTermeSourceMagnetique=ET.SubElement(definirTermeSourceMagnetique, "nombreTermeSourceMagnetique")
+ #nombreTermeSourceMagnetique.text="0"
+
+ #definir Aimants
+ #definirAimants=ET.SubElement(root, "definirAimants")
+ #nombreAimants=ET.SubElement(definirAimants, "nombreAimants")
+ #nombreAimants.text="0"
+
+ #Bloc <Mouvements>...</Mouvements>
+ i = 0
+ Mouvements=ET.SubElement(root, "Mouvements")
+ for nom in self.dictMouvement['ordre']: # parcours de la liste des noms de mouvement définis, dans l'ordre
+ i = i+1
+ mouvement = ET.SubElement(Mouvements, "mouvement") # création de ce mouvement
+ mouvement.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ mouvement.set("name", nom ) # ajout de l'attribut name, inutilisé
+ milieuGlissement = ET.SubElement(mouvement, "milieuGlissement")
+ nomMilieuGlissement = self.dictMouvement[nom]['valeurs']['Milieu_glissement'].nom # concept stocké -> nom du concept
+ milieuGlissement.text="%i" % (self.dictGroupes[nomMilieuGlissement]['idMilieu'], ) # numéro du milieu défini par son nom, selon tableaux remplis précédemment
+ surfaceGlissement = ET.SubElement(mouvement, "surfaceGlissement")
+ surfaceGlissement.text= self.dictMouvement[nom]['valeurs']['Surface_glissement'].nom # concept stocké -> nom du concept
+ deltaMaillage = ET.SubElement(mouvement, "deltaMaillage")
+ deltaMaillage.text="%g" % (self.dictMouvement[nom]['valeurs']['Delta_maillage'], )
+ nbPermutPas = ET.SubElement(mouvement, "nbPermutPas")
+ nbPermutPas.text="%i" % (self.dictMouvement[nom]['valeurs']['Nombre_pas_permutation'], )
+ axeRotation = ET.SubElement(mouvement, "axeRotation")
+ axeRotation.text= self.dictMouvement[nom]['valeurs']['Axe_rotation']
+
+ #definir Force Couple
+ #definirForceCouple=ET.SubElement(root, "definirForceCouple")
+ #nombreForceCouple=ET.SubElement(definirForceCouple, "nombreForceCouple")
+ #nombreForceCouple.text="0"
+
+ #bloc <SpiresExploratrices></SpiresExploratrices>
+ i = 0 # compteur de spires
+ spiresExploratrices = False # pas de spires exploratrices a priori
+ for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
+ spiresExploratrices = True
+ if spiresExploratrices: # on a trouvé au moins une spire exploratrice
+ SpiresExploratrices=ET.SubElement(root, "SpiresExploratrices") # création du bloc XML adéquat
+ for nom in self.dictGroupes.keys(): # recherche des spires exploratrices définies dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Spire_Exploratrice'):
+ spire = ET.SubElement(SpiresExploratrices, "spireExploratrice") # création du bloc XML pour cette spire
+ spire.text = nom # le nom du groupe de noeud est directement écrit
+ i = i+1 # incrément du numéro de spire
+ spire.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ spire.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+
+ #bloc <PotentielsFlottants></PotentielsFlottants>
+ i = 0 # compteur de potentiels flottants
+ potentielsFlottants = False # pas de potentiel flottant a priori
+ for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
+ potentielsFlottants = True
+ if potentielsFlottants: # on a trouvé au moins un potentiel flottant
+ PotentielsFlottants=ET.SubElement(root, "PotentielsFlottants") # création du bloc XML adéquat
+ for nom in self.dictGroupes.keys(): # recherche des potentiels flottants définis dans les MESHGROUP
+ if self.dictGroupes[nom].has_key('Potentiel_Flottant'):
+ potentielFlottant = ET.SubElement(PotentielsFlottants, "potentielFlottant") # création du bloc XML pour ce potentiel flottant
+ potentielFlottant.text = nom # le nom du groupe de noeud est directement écrit
+ i = i+1 # incrément du numéro de spire
+ potentielFlottant.set("id", "%g" % (i, ) ) # ajout de l'attribut id, inutilisé
+ potentielFlottant.set("name", "%s" % (nom, ) ) # ajout de l'attribut name, inutilisé
+
+
+ #Definir Post traitement
+ postraitement=ET.SubElement(root, "postraitement")
+ carteChamp=ET.SubElement(postraitement, "carteChamp")
+ if type(self.carteChamp)==float:
+ carteChamp.text="%s" %(self.carteChamp)
+ else: carteChamp.text="%s" % ','.join(map(str,self.carteChamp))
+ carteCourantInduit=ET.SubElement(postraitement, "carteCourantInduit")
+ if type(self.carteCourantInduit)==float:
+ carteCourantInduit.text="%s" %(self.carteCourantInduit)
+ else: carteCourantInduit.text="%s" % ','.join(map(str,self.carteCourantInduit))
+ carteForce=ET.SubElement(postraitement, "carteForce")
+ if type(self.carteForce)==float:
+ carteForce.text="%s" %(self.carteForce)
+ else: carteForce.text="%s" % ','.join(map(str,self.carteForce))
+ perteJoule=ET.SubElement(postraitement, "perteJoule")
+ perteJoule.text="%s" %(correspondance_booleen[self.perteJoule])
+ fluxInducteur=ET.SubElement(postraitement, "fluxInducteur")
+ fluxInducteur.text="%s" %(correspondance_booleen[self.fluxInducteur])
+ courantInducteur=ET.SubElement(postraitement, "courantInducteur")
+ courantInducteur.text="%s" %(correspondance_booleen[self.courantInducteur])
+ tensionInducteur=ET.SubElement(postraitement, "tensionInducteur")
+ tensionInducteur.text="%s" %(correspondance_booleen[self.tensionInducteur])
+ energie=ET.SubElement(postraitement, "energie")
+ energie.text="%s" %(correspondance_booleen[self.energie])
+ ForceCouple=ET.SubElement(postraitement, "ForceCouple")
+ ForceCouple.text="%s" %(correspondance_booleen[self.ForceCouple])
+ fluxSpire=ET.SubElement(postraitement, "fluxSpire")
+ fluxSpire.text="%s" %(correspondance_booleen[self.fluxSpire])
+ fluxGroupe=ET.SubElement(postraitement, "fluxGroupe")
+ fluxGroupe.text="%s" %(correspondance_booleen[self.fluxGroupe])
+ ddpElect=ET.SubElement(postraitement, "ddpElect")
+ ddpElect.text="%s" %(correspondance_booleen[self.ddpElect])
+ ddpMagn=ET.SubElement(postraitement, "ddpMagn")
+ ddpMagn.text="%s" %(correspondance_booleen[self.ddpMagn])
+ fluxMagn=ET.SubElement(postraitement, "fluxMagn")
+ fluxMagn.text="%s" %(correspondance_booleen[self.fluxMagn])
+ fluxJinduitTotal=ET.SubElement(postraitement, "fluxJinduitTotal")
+ fluxJinduitTotal.text="%s" %(correspondance_booleen[self.fluxJinduitTotal])
+ potentielFlottant=ET.SubElement(postraitement, "potFlottant")
+ potentielFlottant.text="%s" %(correspondance_booleen[self.potFlottant])
+
+ self.indent(root) # indentations et retours à la ligne, à l'aide d'une fonction maison, car xml.etree.ElementTree ne sait pas faire et le module lxml n'est pas disponible dans Salomé
+
+ tree = ET.ElementTree(root)
+
+ tree.write(fileXML, encoding="UTF-8")
+
+ # print "le dico complet=%s" %(self.dictGroupes)
+
+ if self.debug:
+ print "ecriture du fichier d'execution (SH)"
+ RepCarmel=os.path.join(repertory,"lancer.sh")
+ f = open( RepCarmel, 'wb')
+ self.texteCarmel3D_SH+='cd ' + repertory + ' \n'
+ self.texteCarmel3D_SH+='./carmel << FIN\n'
+ correspondance_resolution = {"(T-)Omega seulement":"1\n","A(-Phi) seulement":"2\n", "(T-)Omega puis A(-Phi)":"1\n2\n", "A(-Phi) puis (T-)Omega":"2\n1\n"}
+ self.texteCarmel3D_SH+= correspondance_resolution[self.formulation]
+ self.texteCarmel3D_SH+='0\nFIN\n'
+ f.write(self.texteCarmel3D_SH)
+ f.close()
+
+
+#----------------------------------------------------------------------------------------
+# analyse de chaque noeud de l'arbre
+#----------------------------------------------------------------------------------------
+
+ def generMCSIMP(self,obj) :
+ """recuperation de l objet MCSIMP"""
+ if self.debug:
+ print "MCSIMP %(v_1)s %(v_2)s" % {'v_1': obj.nom, "v_2": obj.valeur}
+ s=PythonGenerator.generMCSIMP(self,obj)
+ self.dicoCourant[obj.nom]=obj.valeurFormatee
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generMCFACT(self,obj) :
+ """recuperation de l objet MCFACT"""
+ dico={}
+ self.dicoMCFACTCourant=dico
+ self.dicoCourant=self.dicoMCFACTCourant
+ s=PythonGenerator.generMCFACT(self,obj)
+ self.dicoEtapeCourant[obj.nom]=self.dicoMCFACTCourant
+ self.dicoMCFACTCourant=None
+ self.dicoCourant=self.dicoEtapeCourant
+ return s
+
+
+#----------------------------------------------------------------------------------------
+ def generPROC_ETAPE(self,obj):
+ """analyse des PROC du catalogue ( VERSION )"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+
+ if self.debug:
+ print "PROC_ETAPE %(v_1)s %(v_2)s" % {'v_1': unicode(obj.nom), "v_2": unicode(obj.valeur)}
+ s=PythonGenerator.generPROC_ETAPE(self,obj)
+ if obj.nom=="PARAMETERS" : self.generBLOC_PARAMETERS(obj)
+ if obj.nom=="SOLVEUR" : self.generSOLVEUR(obj)
+ if obj.nom=="POST_COMMANDS" : self.generPOST_COMMANDS(obj)
+ if obj.nom=="SYMETRIE" : self.generBLOC_SYMETRIE(obj)
+ if obj.nom=="POST_TRAITEMENT" : self.generPOST_TRAITEMENT(obj)
+ return s
+
+
+
+#----------------------------------------------------------------------------------------
+ def generETAPE(self,obj):
+ """analyse des OPER du catalogue"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ s=PythonGenerator.generETAPE(self,obj)
+ obj.valeur=self.dicoEtapeCourant
+ if self.debug:
+ print "ETAPE : obj.nom = %(v_1)s , obj.valeur= %(v_2)s" % {'v_1': obj.nom, 'v_2': obj.valeur}
+ if obj.nom=="MESHGROUP" : self.generMESHGROUP(obj)
+ if obj.nom=="MATERIAL" : self.generMATERIAL(obj)
+ if obj.nom=="SOURCE" : self.generSOURCE(obj)
+ if obj.nom=="STRANDED_INDUCTOR_GEOMETRY" : self.generSTRANDED_INDUCTOR_GEOMETRY(obj)
+ if obj.nom=="MACRO_GROUPE": self.generMACRO_GROUPE(obj)
+ if obj.nom=="MOUVEMENT" : self.generMOUVEMENT(obj)
+ s=PythonGenerator.generETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+ def generMACRO_ETAPE(self,obj):
+ """Utilisé par INCLUDE"""
+ dico={}
+ self.dicoEtapeCourant=dico
+ self.dicoCourant=self.dicoEtapeCourant
+ import generator
+ monGenerateur=generator.plugins[nomPlugin]()
+ jdc_aux_texte=monGenerateur.gener(obj.jdc_aux)
+ if self.debug:
+ print "jdc_aux_texte : %s" % jdc_aux_texte
+
+ # sauvegarde de tous les matériaux trouvés dans les bibliothèques INCLUDE
+ for cle in monGenerateur.dictMaterial:
+ self.dictMaterial[cle] = monGenerateur.dictMaterial[cle]
+ # sauvegarde de toutes les sources trouvées dans les bibliothèques INCLUDE
+ for cle in monGenerateur.dictSource:
+ self.dictSource[cle] = monGenerateur.dictSource[cle]
+
+ print "________FIN MACRO______________________________________"
+ s=PythonGenerator.generMACRO_ETAPE(self,obj)
+ return s
+
+#----------------------------------------------------------------------------------------
+#----------------------------------------------------------------------------------------
+ def generMESHGROUP(self,obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des groupes de maillage
+ """
+ try:
+ nomGroupe = obj.get_sdname() # nom du groupe de maillage, i.e. nom du concept
+ print "liste des noms sans prefixes %s" %(nomGroupe)
+
+ # test: un et un seul nom de materiau ou source doit etre associe a ce groupe de maillage, via les cles MATERIAL et SOURCE, respectivement.
+ # test sur un seul attribut, non pertinent car il peut y en avoir plusieurs.
+ #assert len(obj.valeur.keys())==1,"Un et un seul nom de materiau ou source doit etre associe a ce groupe du maillage :"+nomGroupe
+
+ # on utilise le fait que obj.valeur est un dictionnaire
+ self.dictGroupes[nomGroupe] = {}
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ #if 'MATERIAL' in obj.valeur.keys() and 'SOURCE' in obj.valeur.keys(): # test d'erreur lors de presence de materiau et source a la fois
+ # raise ValueError,tr(" ce groupe de maillage %s est associe a au moins un materiau et au moins une source." % nomGroupe)
+ # association a un materiau
+ if 'MATERIAL' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['MATERIAL'] = obj.valeur['MATERIAL'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreMateriauxJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a un materiau, dans l'ordre du JdC
+ # association a une source
+ if 'SOURCE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['SOURCE'] = obj.valeur['SOURCE'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreSourcesJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ # erreur ni materiau ni source associee
+ if 'STRANDED_INDUCTOR_GEOMETRY' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['STRANDED_INDUCTOR_GEOMETRY'] = obj.valeur['STRANDED_INDUCTOR_GEOMETRY'].nom # sauvegarde de l'association entre ce groupe de maillage et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ # self.dictGroupes['ordreStrandJdC'].append(nomGroupe) # sauvegarde du nom du groupe de maillage associe a une source, dans l'ordre du JdC
+ if 'CONDITION_LIMITE' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['CONDITION_LIMITE'] = obj.valeur['CONDITION_LIMITE']
+ # self.dictGroupes['ordreConditionJdC'].append(nomGroupe)
+ if 'Domaine' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['DOMAINE'] = obj.valeur['Domaine']
+ # self.dictGroupes['ordreDomaineJdC'].append(nomGroupe)
+ texte=""
+ texte+="%s"%(obj.valeur['Domaine'])
+ print"le texte=%s" %(texte)
+ self.dictDomaine[obj.get_sdname()]=texte
+ print "liste des domaines =%s" %(self.dictGroupes[nomGroupe]['DOMAINE'])
+ if 'Potentiel_Flottant' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['Potentiel_Flottant'] = True
+ if 'Spire_Exploratrice' in obj.valeur.keys():
+ self.dictGroupes[nomGroupe]['Spire_Exploratrice'] = True
+
+# else:
+# raise ValueError, tr("ce groupe de maillage %s n'est associe a aucun materiau, source ou stranded_inductor_geometry." % nomGroupe)
+ if self.debug:
+ print "self.dictGroupes= %s" % repr(self.dictGroupes)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMACRO_GROUPE(self, obj):
+ """preparation de la ligne NAME referencant le groupe de mailles
+ associe le groupe de mailles au materiau ou a la source utilisateur
+ on sauvegarde aussi les noms des macros groupes
+ """
+ try:
+ nomMacroGroupe = obj.get_sdname() # nom du macro groupe
+ print "liste des noms sans prefixes %s" %(nomMacroGroupe)
+ self.dictMacroGroupes[nomMacroGroupe] = obj.valeur # sauvegarde des propriétés du macro-groupe
+
+ if self.debug:
+ print "obj.valeur.keys()= %s" % obj.valeur.keys()
+ # association a une source
+ if 'LISTE_MESHGROUP' in obj.valeur.keys(): # test de liste définie dans la macro-groupe, sinon erreur
+ listeGroupesMauvaisFormat = obj.valeur['LISTE_MESHGROUP'] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ self.dictMacroGroupes[nomMacroGroupe]['LISTE'] = [] # sauvegarde de l'association entre ce macro groupe et un materiau ou source, par son nom, i.e. nom du concept du materiau ou de la source
+ for groupe in listeGroupesMauvaisFormat: # sauvegarde de la liste au format correct
+ groupe = groupe.replace("'", "") # suppression des guillement simples
+ groupe = groupe.replace('"', "") # suppression des guillement doubles
+ self.dictMacroGroupes[nomMacroGroupe]['LISTE'].append(groupe) # sauvegarde du nom au formatage correct
+ else:
+ raise ValueError, tr("Ce MACRO_GROUPE %s doit contenir une liste de groupes LISTE_MESHGROUP." % nomMacroGroupe)
+
+ for nomGroupe in self.dictMacroGroupes[nomMacroGroupe]['LISTE']: # liste des groupes MESHGROUP de ce macro-groupe. On leur associe les propriétés du MACRO_GROUPE
+ for propriete in ('SOURCE', 'MATERIAL', 'STRANDED_INDUCTOR_GEOMETRY'): # liste des propriétés automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
+ if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
+ if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete].nom: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
+ print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
+ raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete].nom, nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe ))
+ else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
+ self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete].nom # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
+ for propriete in ('CONDITION_LIMITE', ): # liste des propriétés définies à l'avance automatiques à copier du MACRO_GROUPE à chaque MESHGROUP de la liste
+ if propriete in obj.valeur.keys(): # ce macro-groupe est associé à cette propriété
+ if self.dictGroupes[nomGroupe].has_key(propriete) and self.dictGroupes[nomGroupe][propriete] != self.dictGroupes[nomGroupe][propriete]: # erreur, ce meshgroup a déjà une telle propriéte définie, différente
+ print u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe )
+ raise ValueError, tr(u"ERREUR! Conflit entre la %s : %s du MACRO_GROUPE %s et celle : %s du MESHGROUP associé à ce macro-groupe." % \
+ ( propriete, obj.valeur[propriete], nomMacroGroupe, self.dictGroupes[nomGroupe][propriete], nomGroupe ))
+ else : # pas de conflit de cette propriété, alors copie, meme si les propriétés sont les memes pour simplifier
+ self.dictGroupes[nomGroupe][propriete] = obj.valeur[propriete] # sauvegarde du nom de la propriété du macro-groupe dans le meshgroup
+ except ValueError, err:
+ raise ValueError, str(err)
+
+
+ def generSOLVEUR(self, obj):
+ if self.debug:
+ print "generation solveur obj.valeur = %s" % obj.valeur
+ try :
+ self.typeSolveur = obj.valeur['Type']
+ if self.typeSolveur == "Solveur_lineaire" : self.generSOLVEUR_LINEAIRE(obj)
+ if self.typeSolveur == "Solveur_non_lineaire" :
+ self.generSOLVEUR_LINEAIRE(obj)
+ self.generSOLVEUR_NON_LINEAIRE(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generSOLVEUR_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nature = obj.valeur['Methode_lineaire']
+ if nature =="Methode iterative BICGCR" : self.generMETHODE_ITERATIVE_BICGCR(obj)
+ if nature =="Methode directe MUMPS" : self.generMETHODE_DIRECTE_MUMPS(obj)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generMETHODE_ITERATIVE_BICGCR(self, obj):
+ if self.debug:
+ print "generation methode iterative BICGCR obj.valeur = %s" % obj.valeur
+ self.kEpsilonGCP = obj.valeur["Precision"]
+ self.precond=obj.valeur["Preconditionneur"]
+ self.nbIterationMax=obj.valeur["Nombre_iterations_max"]
+
+
+ def generMETHODE_DIRECTE_MUMPS(self, obj):
+ texte=""
+ if self.debug:
+ print "_____________directe_____________"
+
+ def generSOLVEUR_NON_LINEAIRE(self, obj):
+ if self.debug:
+ print "generation solveur_non_lineaire obj.valeur = %s" % obj.valeur
+ correspondance_methodeNonLineaire = {"Methode de Newton":2,"Methode de substitution":1} # correspondance sur la méthode non-linéaire entre le catalogue et le XML
+ self.methodeNonLineaire = correspondance_methodeNonLineaire[obj.valeur["Methode_non_lineaire"]]
+ self.kEpsilonNonLinearite=obj.valeur["PrecisionNonLineaire"]
+ self.kCoefficientRelaxation=obj.valeur["Coefficient_de_Relaxation"]
+
+ def generMATERIAL(self,obj):
+ """preparation du bloc correspondant a un materiau du fichier PHYS"""
+ texte=""
+ if self.debug:
+ print "generation material obj.valeur = %s" % obj.valeur
+ try :
+ nomMaterial = obj.get_sdname()
+ self.dictMaterial[nomMaterial]=obj.valeur
+ print"self.dictMaterial=%s" %(self.dictMaterial)
+ except ValueError, err:
+ raise ValueError, str(err)
+#-------------------------------------------------------------------
+
+ def generSOURCE(self,obj):
+ """preparation du bloc correspondant a une source du fichier PHYS"""
+ if self.debug:
+ print "generation source obj valeur = %s" % obj.valeur
+ texte=""
+ try :
+ nomSource = obj.get_sdname()
+ self.dictSource[nomSource]=obj.valeur # dictionnaire
+ self.dictSource[nomSource]['milieux'] = [] # liste ordonnée des groupes associés à cette source
+ print"mon dico des sources=%s" %(self.dictSource)
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generPOST_COMMANDS(self, obj):
+ if self.debug:
+ print "generation POST_COMMANDS obj.valeur = %s" % obj.valeur
+
+
+
+ self.visu = False
+ self.post_global = False
+ if obj.valeur.has_key('GLOBAL'):
+ self.post_global = True
+ if obj.valeur.has_key('VISU'):
+ self.visu = True
+ self.visu_format=obj.valeur["VISU"]["VISU_Format"]
+ # self.visu_type=obj.valeur["VISU"]["VISU_Type"]
+
+
+#---------------------------------------------------------------------------------------
+# traitement fichier PHYS
+#---------------------------------------------------------------------------------------
+ def generBLOC_VERSION(self,obj) :
+ # constitution du bloc VERSION du fichier PHYS
+ # creation d une entite VERSION ; elle sera du type PROC car decrit ainsi
+ # dans le du catalogue
+ version=obj.addentite('VERSION',pos=None)
+ self.generPROC_ETAPE(obj.etapes[0])
+ self.texteCarmel3D+="["+obj.etapes[0].nom+"\n"
+ for cle in obj.etapes[0].valeur :
+ self.texteCarmel3D+=" "+cle+" "+str(obj.etapes[0].valeur[cle])+"\n"
+ self.texteCarmel3D+="]\n"
+ # destruction de l entite creee
+ obj.suppentite(version)
+ #print 'ERREUR : test erreur boite graphique BLOC_VERSION'
+ #raise ValueError, 'test erreur boite graphique BLOC_VERSION'
+
+
+ def generBLOC_PARAMETERS(self,obj):
+ if self.debug:
+ print "generation parameters obj.valeur = %s" % obj.valeur
+
+ self.identification = obj.valeur["Identification_du_Modele"]
+ self.fichierMaillage = obj.valeur["Fichier_maillage"]
+ self.echelleMaillage = obj.valeur["Echelle_du_maillage"]
+
+ self.kEpsilonDistance=obj.valeur["kEpsilonDistance"]
+ self.kdistanceRef=obj.valeur["kdistanceRef"]
+ self.jauge=obj.valeur["Jauge"]
+ self.NBoucleTemps=obj.valeur["Nb_pas_de_temps"]
+ self.dt=obj.valeur["Pas_de_temps"]
+
+ self.repertory=obj.valeur["RepCarmel"]
+ self.fcarmel=obj.valeur["Resoudre_probleme"]
+ self.postprocess=obj.valeur["Realiser_post_traitement_aposteriori"]
+ self.formulation=obj.valeur["Formulation"]
+
+ def generBLOC_SYMETRIE(self, obj):
+ if self.debug:
+ print "generation de la symetrie obj.valeur = %s" % obj.valeur
+
+ try:
+ self.listSymetrie.append(obj.valeur)
+ print"ma liste symetrie =%s" %(self.listSymetrie)
+ except ValueError, err:
+ raise ValueError, str(err)
+#----------------------------------------------------------------------------------------
+
+ def generMOUVEMENT(self, obj):
+ if self.debug:
+ print "generation du mouvement obj.valeur = %s" % obj.valeur
+
+ try:
+ nom = obj.get_sdname()
+ self.nombreMouvements = self.nombreMouvements+1
+ self.dictMouvement[nom] = {'ordre': self.nombreMouvements, 'valeurs': obj.valeur}
+ self.dictMouvement['ordre'].append(nom)
+ if self.debug:
+ print "self.dictMouvement =%s" %(self.dictMouvement)
+ print "self.nombreMouvements =%i" %(self.nombreMouvements)
+ except ValueError, err:
+ raise valueError, str(err)
+#----------------------------------------------------------------------------------------
+ def generSTRANDED_INDUCTOR_GEOMETRY(self, obj):
+ """preparation du bloc STRANDED_INDUCTOR_GEOMETRY"""
+ if self.debug:
+ print "generation strand obj valeur = %s" % obj.valeur
+ try :
+ nomStrand = obj.get_sdname()
+ self.dictStrand[nomStrand]=obj.valeur
+ print"mon dico des stranded inductor geometry=%s" %(self.dictStrand)
+
+ except ValueError, err:
+ raise ValueError, str(err)
+
+ def generPOST_TRAITEMENT(self, obj):
+ if self.debug:
+ print "generation post traitement obj.valeur = %s" % obj.valeur
+ self.carteChamp=obj.valeur["Cartes_des_champs"]
+ self.carteCourantInduit=obj.valeur["Cartes_des_courants_induits"]
+ self.carteForce=obj.valeur["Cartes_des_forces"]
+ self.perteJoule=obj.valeur["Pertes_Joules"]
+ self.fluxInducteur=obj.valeur["Flux_par_inducteur"]
+ self.courantInducteur=obj.valeur["Courants_par_inducteur"]
+ self.tensionInducteur=obj.valeur["Tensions_par_inducteur"]
+ self.energie=obj.valeur["Energie"]
+ self.ForceCouple=obj.valeur["Forces_et_couple"]
+ self.fluxSpire=obj.valeur["Flux_par_spire"]
+ self.fluxGroupe=obj.valeur["Flux_par_groupe"]
+ self.ddpElect=obj.valeur["Tensions_electriques"]
+ self.ddpMagn=obj.valeur["DDP_magnetiques"]
+ self.fluxMagn=obj.valeur["Flux_magnetiques"]
+ self.fluxJinduitTotal=obj.valeur["Flux_J_induit"]
+ self.potFlottant=obj.valeur["Potentiel_Flottant"]
+
+#-------------------------------------
+# Methodes utilitaires
+# ------------------------------------
+ def formateCOMPLEX(self,nbC):
+ """prise en compte des differentes formes de description d un nombre complexe
+ 3 formats possibles : 2 listes (anciennement tuples?) et 1 nombre complexe
+ """
+ if self.debug:
+ print "formatage"
+ print "type : %(type_nb_c)s pour %(nb_c)s" % {'type_nb_c': type(nbC), 'nb_c': nbC}
+ nbformate =""
+ if isinstance(nbC,(tuple,list)):
+ if nbC[0] == "'RI'" :
+ nbformate = "COMPLEX " + str(nbC[1])+" "+str(nbC[2])
+ if nbC[0] == "'MP'" :
+ nbformate = "POLAR " + str(nbC[1])+" "+str(nbC[2])
+ else:
+ nbformate = "COMPLEX " + str(nbC.real)+" "+str(nbC.imag)
+ if self.debug:
+ print "nbformate : %s" % nbformate
+ return nbformate
+
+
self.textePhys+=debutTexteZs
self.textePhys+=str(self.dictMCVal[zs+"______ZS__Conductivite"])
self.textePhys+=texteZs2
- self.textePhys+=str(self.dictMCVal[zs+"______ZS__Permeabilite"])
+ self.textePhys+=str(self.dictMCVal[zs+"______ZS__PermeabiliteRelative"])
self.textePhys+=finTexteZs
self.textePhys+="]\n"
#
"""Ce module contient le plugin generateur de fichier au format Code_Carmel3D pour EFICAS.
"""
-
-texte_debut="int main() \n{ \n init_var();\n"
+import pickle
+texte_debut="#include <Zcracks_base.z7p> \n int main() \n{ \n init_var();\n"
texte_debut+=' format="med";\n'
import traceback
import types,string,re,os
from Extensions.i18n import tr
from generator_python import PythonGenerator
-ListeConcatene=('ridge_names','topo_names','geom_names','elset_names','faset_names','liset_names','nset_names','center','normal','dir')
+#ListeConcatene=('ridge_names','topo_names','geom_names','elset_names','faset_names','liset_names','nset_names','center','normal','dir')
+ListeConcatene=('ridge_names','topo_names','geom_names','elset_names','faset_names','liset_names','nset_names')
+ListeConcatene2=('center','normal','dir')
+ListeConcatene3=('ra','rb')
+if_ellipse=False
def entryPoint():
"""
def ajoutRun(self) :
self.textePourRun+=" write_mesh_crack();\n"
self.textePourRun+=" do_mesh_crack(0);\n"
- self.textePourRun+=" nice_cut(20.);\n"
+ self.textePourRun+=" write_refine_mesh();\n"
+ self.textePourRun+=" do_refine_mesh(0);\n"
+ self.textePourRun+=" write_cut_mesh();\n"
+ self.textePourRun+=" do_cut_mesh(0);\n"
+# self.textePourRun+=" nice_cut("+str(self.maximum_aspect_ratio)+");\n"
self.textePourRun+=' export_mesh("'+self.cracked_name+'","med");\n'
self.textePourRun+="}"
"""recuperation de l objet MCSIMP"""
#print dir(obj)
s=PythonGenerator.generMCSIMP(self,obj)
- if obj.nom in ListeConcatene :
+ if obj.nom=="sane_name" :
+ self.textePourRun+=' import_mesh("'+obj.val+'", "med");\n'
+ if obj.nom in ListeConcatene :
+# obj.val=obj.val+" "
stringListe=""
for val in obj.val:
- stringListe+=str(val)+" "
- self.textePourRun+=" "+obj.nom+ "='"+ stringListe[0:-1]+ "';\n"
+ stringListe+=val+""
+# pickle.dump( stringListe, open( "/home/H60874/test.pickle", "wb" ) )
+# self.textePourRun+=" "+obj.nom+ "='"+ stringListe[0:-1]+ "';\n"
+# self.textePourRun+=" "+obj.nom+ "='"+ stringListe+ "';\n"
+ return s
+ if obj.nom in ListeConcatene3 :
+ if (obj.nom=="ra") :
+ self.textePourRun+=" "+"if_ellipse=1;\n"
+ self.textePourRun+=" "+obj.nom+ "="+str(obj.val)+";\n"
+ if_ellipse_ellipse=True
return s
- if obj.nom=="elset_radius" :
+
+ if obj.nom in ListeConcatene2 :
+ stringListe=""
+# self.textePourRun+="GGGGGGG%"+obj.nom+"\n"
+# if (len(val)>1) :
+ for val in obj.val:
+ stringListe+=str(val)+","
+ self.textePourRun+=" "+obj.nom+ "=set_vector3("+ stringListe[0:-1]+ ");\n"
+# else :
+# self.textePourRun+=" "+obj.nom+ str(obj.val+ ";\n"
+# stringListe+=str(val)+" "
+# self.textePourRun+=" "+obj.nom+ "=set_vector3("+stringListe[0]+","+stringListe[1]+","+stringListe[2]+");\n"
+# self.textePourRun+=" "+obj.nom+ "=set_vector3("+obj.val+","+");\n"
+ return s
+# if obj.nom=="center" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+# if obj.nom=="center" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+# if obj.nom=="normal" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+# if obj.nom=="dir" :
+# self.textePourRun+=" set_vector3("+obj.val+'");\n"
+ if obj.nom=="elset_radius" :
self.textePourRun+=" if_must_define_elset=1;\n"
- if obj.nom=="sane_name" and obj.val!=None :
- self.textePourRun+=' import_mesh("'+obj.val+'");\n'
- if obj.nom=="cracked_name" and obj.val!=None : self.cracked_name=obj.val
+
+ if obj.nom=="cracked_name" : self.cracked_name=obj.val
+ if obj.nom=="maximum_aspect_ratio" : self.maximum_aspect_ratio=obj.val
if obj.nom=="repertoire" :
print "PNPNPN a traiter"
return s
for v in obj.mc_liste:
liste=self.generator(v)
+ def generMACRO_ETAPE(self,obj):
+ """
+ """
+ if obj.isvalid() == 0 :
+ #showerror("Element non valide","Salome ne sait pas traiter les elements non valides")
+ return
+ for v in obj.mc_liste:
+ liste=self.generator(v)
+
def generMCSIMP(self,obj) :
"""
