aster = None
aster_exists = False
-# Le catalogue est constitué par concaténation des fichiers .capy
+# Le catalogue est constitue par concatenation des fichiers .capy
# de catapy/{entete,commun,commande}.
-# Tous les imports globaux devraient être faits ici dans accas.capy.
-# Veillez à limiter les imports dans la définition des concepts (co_*.capy)
-# au strict nécessaire et les faire sous les méthodes qui en ont
-# expressément besoin.
+# Tous les imports globaux devraient etre faits ici dans accas.capy.
+# Veillez a limiter les imports dans la definition des concepts (co_*.capy)
+# au strict necessaire et les faire sous les methodes qui en ont
+# expressement besoin.
JdC = JDC_CATA(code='ASTER',
execmodul=None,
# A_CLASSER(('DEBUT', 'POURSUITE'), 'FIN'))
)
-# Types géométriques
+# Types geometriques
class no(GEOM):
"""
- Classe servant à définir le nom d'un noeud dans le fichier de commande
+ Classe servant a definir le nom d'un noeud dans le fichier de commande
En clair : un chaine de longueur 8.
"""
pass
class grno(GEOM):
"""
- Classe servant à définir le nom d'un groupe de noeuds dans le fichier de commande
+ Classe servant a definir le nom d'un groupe de noeuds dans le fichier de commande
En clair : un chaine de longueur 24.
"""
def __convert__(cls,valeur):
"""
if isinstance(valeur, (str,unicode)) and len(valeur.strip()) <= 24:
return valeur.strip()
- raise ValueError(_(u'On attend une chaine de caractères (de longueur <= 24).'))
+ raise ValueError(_(u'On attend une chaine de caracteres (de longueur <= 24).'))
__convert__ = classmethod(__convert__)
class ma(GEOM):
"""
- Classe servant à définir le nom d'une maille dans le fichier de commande
+ Classe servant a definir le nom d'une maille dans le fichier de commande
En clair : un chaine de longueur 8.
"""
pass
class grma(GEOM):
"""
- Classe servant à définir le nom d'un groupe de mailles dans le fichier de commande
+ Classe servant a definir le nom d'un groupe de mailles dans le fichier de commande
En clair : un chaine de longueur 24.
"""
def __convert__(cls,valeur):
"""
if isinstance(valeur, (str,unicode)) and len(valeur.strip()) <= 24:
return valeur.strip()
- raise ValueError(_(u'On attend une chaine de caractères (de longueur <= 24).'))
+ raise ValueError(_(u'On attend une chaine de caracteres (de longueur <= 24).'))
__convert__ = classmethod(__convert__)
# ======================================================================
lenEPXval = len(EPXval)
lenEPXnoeud = len(EPXnoeud)*6
except:
- # s'il y a un problème sur la structure de données ==> <F>
+ # s'il y a un probleme sur la structure de donnees ==> <F>
from Utilitai.Utmess import UTMESS
UTMESS('F','MODELISA9_98')
- # Vérification de la déclaration qui est faite dans 'acearp'
+ # Verification de la declaration qui est faite dans 'acearp'
if ( lenEPXval != lenEPXnoeud ):
from Utilitai.Utmess import UTMESS
UTMESS('F','MODELISA9_97')
lenEPXval = len(EPXval)
lenEPXnoeud = len(EPXnoeud)*6
except:
- # s'il y a un problème sur la structure de données ==> <F>
+ # s'il y a un probleme sur la structure de donnees ==> <F>
from Utilitai.Utmess import UTMESS
UTMESS('F','MODELISA9_98')
- # Vérification de la déclaration qui est faite dans 'acearp'
+ # Verification de la declaration qui est faite dans 'acearp'
if ( lenEPXval != lenEPXnoeud ):
from Utilitai.Utmess import UTMESS
UTMESS('F','MODELISA9_97')
cata_sdj = "SD.sd_cham_mater.sd_cham_mater"
def get_vale_ref(self, nom_varc):
- """Retourne la valeur de référence de `nom_varc`."""
+ """Retourne la valeur de reference de `nom_varc`."""
from SD.sd_carte import sd_carte
nom_varc = nom_varc.strip()
varc = self.sdj.varc
novarc = [sv for sv in varc.CVRCVARC.get()]
assert len(novarc) > idx, novarc
nomch = novarc[idx]
- # accès à la carte
+ # acces a la carte
cartref = sd_carte("%-8s.%-8s.1" % (self.nom, nomch))
valref = cartref.VALE.get()[0]
return valref
def __adapt__(self, validator):
if validator.name == "list":
- # validateur liste,cardinalité
+ # validateur liste,cardinalite
return (self, )
elif validator.name == "type":
# validateur type
return dico
def Trace(self,FORMAT='TABLEAU',**kargs):
- """Tracé d'une fonction"""
+ """Trace d'une fonction"""
if not self.accessible() :
raise Accas.AsException("Erreur dans fonction.Trace en PAR_LOT='OUI'")
from Utilitai.Graph import Graph
def convert(self, arg='real'):
"""
Retourne un objet de la classe t_fonction
- représentation python de la fonction
+ representation python de la fonction
"""
from Cata_Utils.t_fonction import t_fonction, t_fonction_c
class_fonction = t_fonction
return self.Valeurs()[0]
def Ordo(self):
- """Retourne la liste des ordonnées"""
+ """Retourne la liste des ordonnees"""
return self.Valeurs()[1]
def __call__(self, val, tol=1.e-6):
def convert(self,arg='real'):
"""
Retourne un objet de la classe t_fonction ou t_fonction_c,
- représentation python de la fonction complexe
+ representation python de la fonction complexe
"""
import numpy
from Cata_Utils.t_fonction import t_fonction, t_fonction_c
return self.Valeurs()[0]
def Ordo(self):
- """Retourne la liste des parties réelles des ordonnées"""
+ """Retourne la liste des parties reelles des ordonnees"""
return self.Valeurs()[1]
def OrdoImg(self):
- """Retourne la liste des parties imaginaires des ordonnées"""
+ """Retourne la liste des parties imaginaires des ordonnees"""
return self.Valeurs()[2]
def Trace(self,FORMAT='TABLEAU',**kargs):
- """Tracé d'une fonction complexe"""
+ """Trace d'une fonction complexe"""
if not self.accessible():
raise Accas.AsException("Erreur dans fonction_c.Trace en PAR_LOT='OUI'")
from Utilitai.Graph import Graph
def convert(self):
"""
- Retourne un objet de la classe t_nappe, représentation python de la nappe
+ Retourne un objet de la classe t_nappe, representation python de la nappe
"""
from Cata_Utils.t_fonction import t_fonction, t_nappe
para = self.Parametres()
return self.Valeurs()[0]
def Trace(self,FORMAT='TABLEAU',**kargs):
- """Tracé d'une nappe"""
+ """Trace d'une nappe"""
if not self.accessible():
raise Accas.AsException("Erreur dans nappe.Trace en PAR_LOT='OUI'")
from Utilitai.Graph import Graph
cata_sdj = "SD.sd_mater.sd_mater"
def RCVALE(self, phenomene, nompar=(), valpar=(), nomres=(), stop=1):
- """Appel à la routine fortran RCVALE pour récupérer les valeurs des
- propriétés du matériau.
+ """Appel a la routine fortran RCVALE pour recuperer les valeurs des
+ proprietes du materiau.
"""
if not self.accessible():
raise Accas.AsException("Erreur dans mater.RCVALE en PAR_LOT='OUI'")
from Utilitai.Utmess import UTMESS
- # vérification des arguments
+ # verification des arguments
if not type(nompar) in (list, tuple):
nompar = [nompar,]
if not type(valpar) in (list, tuple):
UTMESS('F','SDVERI_4',valk=[vk1,vk2])
if len(nomres) < 1:
UTMESS('F', 'SDVERI_5')
- # appel à l'interface Python/C
+ # appel a l'interface Python/C
return aster.rcvale(self.nom, phenomene, nompar, valpar, nomres, stop)
# ======================================================================
def __adapt__(self, validator):
if validator.name == "list":
- # validateur liste,cardinalité
+ # validateur liste,cardinalite
return (self, )
elif validator.name == "type":
# validateur type
return aster.GetResu(self.get_name(), "PARAMETRES")
class resultat_jeveux(resultat_sdaster):
- """Classe permettant d'accéder à un resultat jeveux qui n'a pas d'ASSD associée,
- c'est le cas des concepts résultats (table, evol_xxxx) dérivés."""
+ """Classe permettant d'acceder a un resultat jeveux qui n'a pas d'ASSD associee,
+ c'est le cas des concepts resultats (table, evol_xxxx) derives."""
def __init__(self, nom_jeveux):
resultat_sdaster.__init__(self)
self.set_name(nom_jeveux)
class dyna_phys(resultat_sdaster):
cata_sdj="SD.sd_dyna_phys.sd_dyna_phys"
-# Concepts généralisés
+# Concepts generalises
class harm_gene (dyna_gene) : pass
class tran_gene (dyna_gene) : pass
class mode_meca (dyna_phys) : pass
class mode_meca_c(mode_meca) : pass
-# TODO : convertir mode_gene en format généralisé
+# TODO : convertir mode_gene en format generalise
class mode_gene (dyna_phys) : pass
# ======================================================================
# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG
def __getitem__(self, key):
"""Retourne la valeur d'une cellule de la table.
- Exemple : TAB['INST', 1] retourne la 1ère valeur de la colonne 'INST'."""
+ Exemple : TAB['INST', 1] retourne la 1ere valeur de la colonne 'INST'."""
from Utilitai.Utmess import UTMESS
if not self.accessible():
raise Accas.AsException("Erreur dans table.__getitem__ en PAR_LOT='OUI'")
def TITRE(self):
"""Retourne le titre d'une table Aster
- (Utile pour récupérer le titre et uniquement le titre d'une table dont
- on souhaite manipuler la dérivée).
+ (Utile pour recuperer le titre et uniquement le titre d'une table dont
+ on souhaite manipuler la derivee).
"""
if not self.accessible():
raise Accas.AsException("Erreur dans table.TITRE en PAR_LOT='OUI'")
return titr
def EXTR_TABLE(self, para=None) :
- """Produit un objet Table à partir du contenu d'une table Aster.
- On peut limiter aux paramètres listés dans 'para'.
+ """Produit un objet Table a partir du contenu d'une table Aster.
+ On peut limiter aux parametres listes dans 'para'.
"""
def Nonefy(l1,l2) :
if l2 == 0:
from Utilitai.Table import Table
# titre
titr = self.TITRE()
- # récupération des paramètres
+ # recuperation des parametres
#v_tblp = aster.getvectjev('%-19s.TBLP' % self.get_name())
v_tblp = self.sdj.TBLP.get()
if v_tblp == None:
tabnom=list(v_tblp)
nparam=len(tabnom)/4
lparam=[tabnom[4*i:4*i+4] for i in range(nparam)]
- # restriction aux paramètres demandés
+ # restriction aux parametres demandes
if para is not None:
if type(para) not in (list, tuple):
para = [para, ]
restr.append(ip)
lparam = restr
dval={}
- # liste des paramètres et des types
+ # liste des parametres et des types
lpar=[]
ltyp=[]
for i in lparam :
valeurs des cellules sont des noms de fonction_sdaster ou fonction_c."""
class table_jeveux(table_sdaster):
- """Classe permettant d'accéder à une table jeveux qui n'a pas d'ASSD associée,
- c'est le cas des concepts résultats (table, evol_xxxx) dérivés."""
+ """Classe permettant d'acceder a une table jeveux qui n'a pas d'ASSD associee,
+ c'est le cas des concepts resultats (table, evol_xxxx) derives."""
def __init__(self, nom_jeveux):
table_sdaster.__init__(self)
self.set_name(nom_jeveux)
fr="Comportement utilisateur de type UMAT",
NB_VARI =SIMP(statut='o',typ='I',max=1,fr="Nombre de variables internes"),
LIBRAIRIE = SIMP(statut='o', typ='TXM',validators=LongStr(1,128),
- fr="Chemin vers la bibliothèque dynamique définissant le comportement UMAT"),
+ fr="Chemin vers la bibliotheque dynamique definissant le comportement UMAT"),
NOM_ROUTINE = SIMP(statut='o', typ='TXM',
- fr="Nom de la routine UMAT dans la bibliothèque"),),
+ fr="Nom de la routine UMAT dans la bibliotheque"),),
b_mfront = BLOC(condition = "RELATION == 'MFRONT' ",
fr="Comportement utilisateur de type MFRONT",
NB_VARI =SIMP(statut='o',typ='I',max=1,fr="Nombre de variables internes"),
LIBRAIRIE = SIMP(statut='o', typ='TXM',validators=LongStr(1,128),
- fr="Chemin vers la bibliothèque dynamique définissant le comportement MFRONT"),
+ fr="Chemin vers la bibliotheque dynamique definissant le comportement MFRONT"),
NOM_ROUTINE = SIMP(statut='o', typ='TXM',
- fr="Nom de la routine MFRONT dans la bibliothèque"),),
+ fr="Nom de la routine MFRONT dans la bibliotheque"),),
# KITs
b_kit_ddi = BLOC(condition = "RELATION == 'KIT_DDI' ",
DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT",
into=("PETIT","PETIT_REAC","GROT_GDEP","SIMO_MIEHE","GDEF_HYPO_ELAS","GDEF_LOG")),
- # gestion des contraintes planes par la méthode itérative
+ # gestion des contraintes planes par la methode iterative
RESI_CPLAN_MAXI =SIMP(statut='f',typ='R',
- fr="Critère d'arret absolu pour assurer la condition de contraintes planes"),
+ fr="Critere d'arret absolu pour assurer la condition de contraintes planes"),
b_resi_cplan =BLOC(condition = " RESI_CPLAN_MAXI == None ",
RESI_CPLAN_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6,
- fr="Critère d'arret relatif pour assurer la condition de contraintes planes"),
+ fr="Critere d'arret relatif pour assurer la condition de contraintes planes"),
),
ITER_CPLAN_MAXI =SIMP(statut='f',typ='I',defaut= 1,
- fr="Nombre d'itérations maxi pour assurer la condition de contraintes planes"),
+ fr="Nombre d'iterations maxi pour assurer la condition de contraintes planes"),
#
RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6),
ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 20 ),
b_redec_local = BLOC(condition = "DEFORMATION in ('PETIT','PETIT_REAC','GROT_GDEP')",
- fr="Nombre de redécoupages internes du pas de temps",
+ fr="Nombre de redecoupages internes du pas de temps",
ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ),
),
regles=(AU_MOINS_UN('SIGM_REFE','EPSI_REFE','FLUX_THER_REFE','FORC_REFE',
'FLUX_HYD1_REFE','FLUX_HYD2_REFE','VARI_REFE','DEPL_REFE','LAGR_REFE'),),
FORC_REFE =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Force et Moment de référence pour les éléments de structure."),
+ fr="Force et Moment de reference pour les elements de structure."),
SIGM_REFE =SIMP(statut='f',typ='R'),
DEPL_REFE =SIMP(statut='f',typ='R'),
EPSI_REFE =SIMP(statut='f',typ='R'),
d = {}
d['CONTRAINTE'] = {
"EFGE_ELGA": ( ("lin", "nonlin",),
- _(u"Efforts généralisés aux points de Gauss"), ),
+ _(u"Efforts generalises aux points de Gauss"), ),
"EFGE_ELNO": ( ("lin", "nonlin",),
- _(u"Efforts généralisés aux noeuds par élément"), ),
+ _(u"Efforts generalises aux noeuds par element"), ),
"EFGE_NOEU": ( ("lin", "nonlin",),
- _(u"Efforts généralisés aux noeuds"), ),
+ _(u"Efforts generalises aux noeuds"), ),
"SIEF_ELGA": ( ("lin",),
_(u"Contraintes et efforts aux points de Gauss"), ),
"SIEF_ELNO": ( ("lin", "nonlin",),
- _(u"Contraintes et efforts aux noeuds par élément"), ),
+ _(u"Contraintes et efforts aux noeuds par element"), ),
"SIEF_NOEU": ( ("lin", "nonlin",),
_(u"Contraintes et efforts aux noeuds"), ),
"SIGM_ELGA": ( ("lin", "nonlin",),
_(u"Contraintes aux points de Gauss"), ),
"SIGM_ELNO": ( ("lin", "nonlin",),
- _(u"Contraintes aux noeuds par élément"), ),
+ _(u"Contraintes aux noeuds par element"), ),
"SIGM_NOEU": ( ("lin", "nonlin",),
_(u"Contraintes aux noeuds"), ),
"SIPM_ELNO": ( ("lin","nonlin"),
- _(u"Contraintes aux noeuds par élément pour les éléments de poutre"), ),
+ _(u"Contraintes aux noeuds par element pour les elements de poutre"), ),
"SIPO_ELNO": ( ("lin", "nonlin",),
- _(u"Contraintes aux noeuds par élément pour les éléments de poutre"), ),
+ _(u"Contraintes aux noeuds par element pour les elements de poutre"), ),
"SIPO_NOEU": ( ("lin", "nonlin",),
- _(u"Contraintes aux noeuds pour les éléments de poutre"), ),
+ _(u"Contraintes aux noeuds pour les elements de poutre"), ),
"SIRO_ELEM": ( ("lin", "nonlin",),
- _(u"Contraintes de rosette par élément"), ),
+ _(u"Contraintes de rosette par element"), ),
}
d['DEFORMATION'] = {
"DEGE_ELGA": ( ("lin", "nonlin",),
- _(u"Déformations généralisées aux points de Gauss"), ),
+ _(u"Deformations generalisees aux points de Gauss"), ),
"DEGE_ELNO": ( ("lin", "nonlin",),
- _(u"Déformations généralisées aux noeuds par élément"), ),
+ _(u"Deformations generalisees aux noeuds par element"), ),
"DEGE_NOEU": ( ("lin", "nonlin",),
- _(u"Déformations généralisées aux noeuds"), ),
+ _(u"Deformations generalisees aux noeuds"), ),
"EPFD_ELGA": ( ("nonlin",),
- _(u"Déformations de fluage de déssication aux points de Gauss"), ),
+ _(u"Deformations de fluage de dessication aux points de Gauss"), ),
"EPFD_ELNO": ( ("nonlin",),
- _(u"Déformations de fluage de déssication aux noeuds par élément"), ),
+ _(u"Deformations de fluage de dessication aux noeuds par element"), ),
"EPFD_NOEU": ( ("nonlin",),
- _(u"Déformations de fluage de déssication aux noeuds"), ),
+ _(u"Deformations de fluage de dessication aux noeuds"), ),
"EPFP_ELGA": ( ("nonlin",),
- _(u"Déformations de fluage propre aux points de Gauss"), ),
+ _(u"Deformations de fluage propre aux points de Gauss"), ),
"EPFP_ELNO": ( ("nonlin",),
- _(u"Déformations de fluage propre aux noeuds par élément"), ),
+ _(u"Deformations de fluage propre aux noeuds par element"), ),
"EPFP_NOEU": ( ("nonlin",),
- _(u"Déformations de fluage propre aux noeuds"), ),
+ _(u"Deformations de fluage propre aux noeuds"), ),
"EPME_ELGA": ( ("lin", "nonlin",),
- _(u"Déformations mécaniques en petits déplacements aux points de Gauss"), ),
+ _(u"Deformations mecaniques en petits deplacements aux points de Gauss"), ),
"EPME_ELNO": ( ("lin", "nonlin",),
- _(u"Déformations mécaniques en petits déplacements aux noeuds par élément"), ),
+ _(u"Deformations mecaniques en petits deplacements aux noeuds par element"), ),
"EPME_NOEU": ( ("lin", "nonlin",),
- _(u"Déformations mécaniques en petits déplacements aux noeuds"), ),
+ _(u"Deformations mecaniques en petits deplacements aux noeuds"), ),
"EPMG_ELGA": ( ("nonlin",),
- _(u"Déformations mécaniques en grands déplacements aux points de Gauss"), ),
+ _(u"Deformations mecaniques en grands deplacements aux points de Gauss"), ),
"EPMG_ELNO": ( ("nonlin",),
- _(u"Déformations mécaniques en grands déplacements aux noeuds par élément"), ),
+ _(u"Deformations mecaniques en grands deplacements aux noeuds par element"), ),
"EPMG_NOEU": ( ("nonlin",),
- _(u"Déformations mécaniques en grands déplacements aux noeuds"), ),
+ _(u"Deformations mecaniques en grands deplacements aux noeuds"), ),
"EPSG_ELGA": ( ("lin","nonlin",),
- _(u"Déformations de Green-Lagrange aux points de Gauss"), ),
+ _(u"Deformations de Green-Lagrange aux points de Gauss"), ),
"EPSG_ELNO": ( ("lin","nonlin",),
- _(u"Déformations de Green-Lagrange aux noeuds par élément"), ),
+ _(u"Deformations de Green-Lagrange aux noeuds par element"), ),
"EPSG_NOEU": ( ("lin","nonlin",),
- _(u"Déformations de Green-Lagrange aux noeuds"), ),
+ _(u"Deformations de Green-Lagrange aux noeuds"), ),
"EPSI_ELGA": ( ("lin", "nonlin",),
- _(u"Déformations aux points de Gauss"), ),
+ _(u"Deformations aux points de Gauss"), ),
"EPSI_ELNO": ( ("lin", "nonlin",),
- _(u"Déformations aux noeuds par élément"), ),
+ _(u"Deformations aux noeuds par element"), ),
"EPSI_NOEU": ( ("lin", "nonlin",),
- _(u"Déformations aux noeuds"), ),
+ _(u"Deformations aux noeuds"), ),
"EPSP_ELGA": ( ("nonlin",),
- _(u"Déformations anélastique aux points de Gauss"), ),
+ _(u"Deformations anelastique aux points de Gauss"), ),
"EPSP_ELNO": ( ("nonlin",),
- _(u"Déformations anélastique aux noeuds par élément"), ),
+ _(u"Deformations anelastique aux noeuds par element"), ),
"EPSP_NOEU": ( ("nonlin",),
- _(u"Déformations anélastique aux noeuds"), ),
+ _(u"Deformations anelastique aux noeuds"), ),
"EPVC_ELGA": ( ("lin", "nonlin",),
- _(u"Déformations dues aux variables de commande aux points de Gauss"), ),
+ _(u"Deformations dues aux variables de commande aux points de Gauss"), ),
"EPVC_ELNO": ( ("lin", "nonlin",),
- _(u"Déformations dues aux variables de commande aux noeuds par élément"), ),
+ _(u"Deformations dues aux variables de commande aux noeuds par element"), ),
"EPVC_NOEU": ( ("lin", "nonlin",),
- _(u"Déformations dues aux variables de commande aux noeuds"), ),
+ _(u"Deformations dues aux variables de commande aux noeuds"), ),
}
d['ENERGIE'] = {
"DISS_ELEM": ( ("lin", "nonlin",),
- _(u"Énergie de dissipation par élément"), ),
+ _(u"energie de dissipation par element"), ),
"DISS_ELGA": ( ("lin", "nonlin",),
- _(u"Densité d'énergie de dissipation aux points de Gauss"), ),
+ _(u"Densite d'energie de dissipation aux points de Gauss"), ),
"DISS_ELNO": ( ("lin", "nonlin",),
- _(u"Densité d'énergie de dissipation aux noeuds par élément"), ),
+ _(u"Densite d'energie de dissipation aux noeuds par element"), ),
"DISS_NOEU": ( ("lin", "nonlin",),
- _(u"Densité d'énergie de dissipation aux noeuds"), ),
+ _(u"Densite d'energie de dissipation aux noeuds"), ),
"ECIN_ELEM": ( ("lin",),
- _(u"Énergie cinétique par élément"), ),
+ _(u"energie cinetique par element"), ),
"ENEL_ELEM": ( ("lin", "nonlin",),
- _(u"Énergie élastique par élément"), ),
+ _(u"energie elastique par element"), ),
"ENEL_ELGA": ( ("lin", "nonlin",),
- _(u"Densité d'énergie élastique aux points de Gauss"), ),
+ _(u"Densite d'energie elastique aux points de Gauss"), ),
"ENEL_ELNO": ( ("lin", "nonlin",),
- _(u"Densité d'énergie élastique aux noeuds par élément"), ),
+ _(u"Densite d'energie elastique aux noeuds par element"), ),
"ENEL_NOEU": ( ("lin", "nonlin",),
- _(u"Densité d'énergie élastique aux noeuds"), ),
+ _(u"Densite d'energie elastique aux noeuds"), ),
"EPOT_ELEM": ( ("lin",),
- _(u"Énergie potentielle de déformation élastique par élément"), ),
+ _(u"energie potentielle de deformation elastique par element"), ),
"ETOT_ELEM": ( ("lin", "nonlin",),
- _(u"Incrément d'énergie de déformation totale par élément"), ),
+ _(u"Increment d'energie de deformation totale par element"), ),
"ETOT_ELGA": ( ("lin", "nonlin",),
- _(u"Incrément de densité d'énergie de déformation totale aux points de Gauss"), ),
+ _(u"Increment de densite d'energie de deformation totale aux points de Gauss"), ),
"ETOT_ELNO": ( ("lin", "nonlin",),
- _(u"Incrément de densité d'énergie de déformation totale aux noeuds par élément"), ),
+ _(u"Increment de densite d'energie de deformation totale aux noeuds par element"), ),
"ETOT_NOEU": ( ("lin", "nonlin",),
- _(u"Incrément de densité d'énergie de déformation totale aux noeuds"), ),
+ _(u"Increment de densite d'energie de deformation totale aux noeuds"), ),
}
d['CRITERES'] = {
"DERA_ELGA": ( ("nonlin",),
- _(u"Indicateur local de décharge et de perte de radialité aux points de Gauss"), ),
+ _(u"Indicateur local de decharge et de perte de radialite aux points de Gauss"), ),
"DERA_ELNO": ( ("nonlin",),
- _(u"Indicateur local de décharge et de perte de radialité aux noeuds par élément"), ),
+ _(u"Indicateur local de decharge et de perte de radialite aux noeuds par element"), ),
"DERA_NOEU": ( ("nonlin",),
- _(u"Indicateur local de décharge et de perte de radialité aux noeuds"), ),
+ _(u"Indicateur local de decharge et de perte de radialite aux noeuds"), ),
"ENDO_ELGA": ( ("nonlin",),
- _(u"Dommage de Lemaître-Sermage aux points de Gauss"), ),
+ _(u"Dommage de Lemaitre-Sermage aux points de Gauss"), ),
"ENDO_ELNO": ( ("nonlin",),
- _(u"Dommage de Lemaître-Sermage aux noeuds par élément"), ),
+ _(u"Dommage de Lemaitre-Sermage aux noeuds par element"), ),
"ENDO_NOEU": ( ("nonlin",),
- _(u"Dommage de Lemaître-Sermage aux noeuds"), ),
+ _(u"Dommage de Lemaitre-Sermage aux noeuds"), ),
"EPEQ_ELGA": ( ("lin", "nonlin",),
- _(u"Déformations équivalentes aux points de Gauss"), ),
+ _(u"Deformations equivalentes aux points de Gauss"), ),
"EPEQ_ELNO": ( ("lin", "nonlin",),
- _(u"Déformations équivalentes aux noeuds par élément"), ),
+ _(u"Deformations equivalentes aux noeuds par element"), ),
"EPEQ_NOEU": ( ("lin", "nonlin",),
- _(u"Déformations équivalentes aux noeuds"), ),
+ _(u"Deformations equivalentes aux noeuds"), ),
"EPMQ_ELGA": ( ("lin", "nonlin",),
- _(u"Déformations mécaniques équivalentes aux points de Gauss"), ),
+ _(u"Deformations mecaniques equivalentes aux points de Gauss"), ),
"EPMQ_ELNO": ( ("lin", "nonlin",),
- _(u"Déformations mécaniques équivalentes aux noeuds par élément"), ),
+ _(u"Deformations mecaniques equivalentes aux noeuds par element"), ),
"EPMQ_NOEU": ( ("lin", "nonlin",),
- _(u"Déformations mécaniques équivalentes aux noeuds"), ),
+ _(u"Deformations mecaniques equivalentes aux noeuds"), ),
"INDL_ELGA": ( ("nonlin",),
_(u"Indicateur de localisation aux points de Gauss"), ),
"PDIL_ELGA": ( ("nonlin",),
- _(u"Module de rigidité de micro-dilatation"), ),
+ _(u"Module de rigidite de micro-dilatation"), ),
"SIEQ_ELGA": ( ("lin", "nonlin",),
- _(u"Contraintes équivalentes aux points de Gauss"), ),
+ _(u"Contraintes equivalentes aux points de Gauss"), ),
"SIEQ_ELNO": ( ("lin", "nonlin",),
- _(u"Contraintes équivalentes aux noeuds par élément"), ),
+ _(u"Contraintes equivalentes aux noeuds par element"), ),
"SIEQ_NOEU": ( ("lin", "nonlin",),
- _(u"Contraintes équivalentes aux noeuds"), ),
+ _(u"Contraintes equivalentes aux noeuds"), ),
}
d['VARI_INTERNE'] = {
"VAEX_ELGA": ( ("nonlin",),
_(u"Extraction d'une variable interne aux points de Gauss"), ),
"VAEX_ELNO": ( ("nonlin",),
- _(u"Extraction d'une variable interne aux noeuds pas élément"), ),
+ _(u"Extraction d'une variable interne aux noeuds pas element"), ),
"VAEX_NOEU": ( ("nonlin",),
_(u"Extraction d'une variable interne aux noeuds"), ),
"VARC_ELGA": ( ("lin", "nonlin",),
_(u"Variables de commande aux points de Gauss"), ),
"VARI_ELNO": ( ("nonlin",),
- _(u"Variables internes aux noeuds pas élément"), ),
+ _(u"Variables internes aux noeuds pas element"), ),
"VARI_NOEU": ( ("nonlin",),
_(u"Variables internes aux noeuds"), ),
}
}
d['THERMIQUE'] = {
"TEMP_ELGA": ( (),
- _(u"Température aux points de Gauss"), ),
+ _(u"Temperature aux points de Gauss"), ),
"FLUX_ELGA": ( (),
_(u"Flux thermique aux points de Gauss"), ),
"FLUX_ELNO": ( (),
- _(u"Flux thermique aux noeuds par élément"), ),
+ _(u"Flux thermique aux noeuds par element"), ),
"FLUX_NOEU": ( (),
_(u"Flux thermique aux noeuds"), ),
"HYDR_NOEU": ( (),
_(u"Hydratation aux noeuds"), ),
"SOUR_ELGA": ( (),
- _(u"Source de chaleur à partir d'un potentiel électrique"), ),
+ _(u"Source de chaleur a partir d'un potentiel electrique"), ),
"ETHE_ELEM": ( (),
- _(u"Énergie dissipée thermiquement"), ),
+ _(u"energie dissipee thermiquement"), ),
}
d['ACOUSTIQUE'] = {
"PRAC_ELNO": ( (),
- _(u"Pression acoustique aux noeuds par élément"), ),
+ _(u"Pression acoustique aux noeuds par element"), ),
"PRAC_NOEU": ( (),
_(u"Pression acoustique aux noeuds"), ),
"PRME_ELNO": ( (),
- _(u"Pression aux noeuds par élément pour les éléments FLUIDE"), ),
+ _(u"Pression aux noeuds par element pour les elements FLUIDE"), ),
"INTE_ELNO": ( (),
- _(u"Intensité acoustique aux noeuds par élément"), ),
+ _(u"Intensite acoustique aux noeuds par element"), ),
"INTE_NOEU": ( (),
- _(u"Intensité acoustique aux noeuds"), ),
+ _(u"Intensite acoustique aux noeuds"), ),
}
d['FORCE'] = {
"FORC_NODA": ( (),
_(u"Forces nodales"), ),
"REAC_NODA": ( (),
- _(u"Réactions nodales"), ),
+ _(u"Reactions nodales"), ),
}
d['ERREUR'] = {
"SIZ1_NOEU": ( (),
- _(u"Contraintes lissées de Zhu-Zienkiewicz version 1 aux noeuds"), ),
+ _(u"Contraintes lissees de Zhu-Zienkiewicz version 1 aux noeuds"), ),
"ERZ1_ELEM": ( (),
- _(u"Indicateur d'erreur de Zhu-Zienkiewicz version 1 par élément"), ),
+ _(u"Indicateur d'erreur de Zhu-Zienkiewicz version 1 par element"), ),
"SIZ2_NOEU": ( (),
- _(u"Contraintes lissées de Zhu-Zienkiewicz version 2 aux noeuds"), ),
+ _(u"Contraintes lissees de Zhu-Zienkiewicz version 2 aux noeuds"), ),
"ERZ2_ELEM": ( (),
- _(u"Indicateur d'erreur de Zhu-Zienkiewicz version 2 par élément"), ),
+ _(u"Indicateur d'erreur de Zhu-Zienkiewicz version 2 par element"), ),
"ERME_ELEM": ( (),
- _(u"Indicateur d'erreur en résidu en mécanique par élément"), ),
+ _(u"Indicateur d'erreur en residu en mecanique par element"), ),
"ERME_ELNO": ( (),
- _(u"Indicateur d'erreur en résidu en mécanique aux noeuds par élément"), ),
+ _(u"Indicateur d'erreur en residu en mecanique aux noeuds par element"), ),
"ERME_NOEU": ( (),
- _(u"Indicateur d'erreur en résidu en mécanique aux noeuds"), ),
+ _(u"Indicateur d'erreur en residu en mecanique aux noeuds"), ),
"QIRE_ELEM": ( (),
- _(u"Indicateur d'erreur en quantités d'intérêt en résidu par élément"), ),
+ _(u"Indicateur d'erreur en quantites d'interet en residu par element"), ),
"QIRE_ELNO": ( (),
- _(u"Indicateur d'erreur en quantités d'intérêt en résidu aux noeuds par élément"), ),
+ _(u"Indicateur d'erreur en quantites d'interet en residu aux noeuds par element"), ),
"QIRE_NOEU": ( (),
- _(u"Indicateur d'erreur en quantités d'intérêt en résidu aux noeuds"), ),
+ _(u"Indicateur d'erreur en quantites d'interet en residu aux noeuds"), ),
"QIZ1_ELEM": ( (),
- _(u"Indicateur d'erreur en quantités d'intérêt de Zhu-Zienkiewicz version 1 par élément"), ),
+ _(u"Indicateur d'erreur en quantites d'interet de Zhu-Zienkiewicz version 1 par element"), ),
"QIZ2_ELEM": ( (),
- _(u"Indicateur d'erreur en quantités d'intérêt de Zhu-Zienkiewicz version 2 par élément"), ),
+ _(u"Indicateur d'erreur en quantites d'interet de Zhu-Zienkiewicz version 2 par element"), ),
"SING_ELEM": ( (),
- _(u"Degré de singularité par élément"), ),
+ _(u"Degre de singularite par element"), ),
"SING_ELNO": ( (),
- _(u"Degré de singularité aux noeuds par élément"), ),
+ _(u"Degre de singularite aux noeuds par element"), ),
"ERTH_ELEM": ( (),
- _(u"Indicateur d'erreur en résidu en thermique par élément"), ),
+ _(u"Indicateur d'erreur en residu en thermique par element"), ),
"ERTH_ELNO": ( (),
- _(u"Indicateur d'erreur en résidu en thermique aux noeuds par élément"), ),
+ _(u"Indicateur d'erreur en residu en thermique aux noeuds par element"), ),
"ERTH_NOEU": ( (),
- _(u"Indicateur d'erreur en résidu en thermique aux noeuds"), ),
+ _(u"Indicateur d'erreur en residu en thermique aux noeuds"), ),
}
d['METALLURGIE'] = {
"DURT_ELNO": ( (),
- _(u"Dureté aux noeuds par élément"), ),
+ _(u"Durete aux noeuds par element"), ),
"DURT_NOEU": ( (),
- _(u"Dureté aux noeuds"), ),
+ _(u"Durete aux noeuds"), ),
"META_ELNO": ( (),
- _(u"Proportion de phases métallurgiques aux noeuds par élément"), ),
+ _(u"Proportion de phases metallurgiques aux noeuds par element"), ),
"META_NOEU": ( (),
- _(u"Proportion de phases métallurgiques aux noeuds"), ),
+ _(u"Proportion de phases metallurgiques aux noeuds"), ),
}
d['DEPLACEMENT'] = {
"ACCE": ( (),
- _(u"Accélération aux noeuds"), ),
+ _(u"Acceleration aux noeuds"), ),
"ACCE_ABSOLU": ( (),
- _(u"Accélération absolue aux noeuds"), ),
+ _(u"Acceleration absolue aux noeuds"), ),
"DEPL": ( (),
- _(u"Déplacements aux noeuds"), ),
+ _(u"Deplacements aux noeuds"), ),
"DEPL_ABSOLU": ( (),
- _(u"Déplacements absolus aux noeuds"), ),
+ _(u"Deplacements absolus aux noeuds"), ),
"STRX_ELGA": ( (),
- _(u"Efforts généralisés à partir des déplacements en linéaire aux points de Gauss"), ),
+ _(u"Efforts generalises a partir des deplacements en lineaire aux points de Gauss"), ),
"TEMP": ( (),
- _(u"Température aux noeuds"), ),
+ _(u"Temperature aux noeuds"), ),
"VITE": ( (),
_(u"Vitesse aux noeuds"), ),
"VALE_CONT": ( (),
}
d['AUTRES'] = {
"COMPORTEMENT": ( (),
- _(u"Carte de comportement mécanique"), ),
+ _(u"Carte de comportement mecanique"), ),
"COMPORTHER": ( (),
_(u"Carte de comportement thermique"), ),
"DEPL_VIBR": ( (),
- _(u"Déplacement pour mode vibratoire"), ),
+ _(u"Deplacement pour mode vibratoire"), ),
"DIVU": ( (),
- _(u"Déformation volumique en THM"), ),
+ _(u"Deformation volumique en THM"), ),
"EPSA_ELNO": ( (),
- _(u"Déformations anélastique aux noeuds par élément"), ),
+ _(u"Deformations anelastique aux noeuds par element"), ),
"EPSA_NOEU": ( (),
- _(u"Déformations anélastique aux noeuds"), ),
+ _(u"Deformations anelastique aux noeuds"), ),
"FERRAILLAGE": ( ("lin",),
- _(u"Densité de ferraillage"), ),
+ _(u"Densite de ferraillage"), ),
"FSUR_2D": ( (),
_(u"Chargement de force surfacique en 2D"), ),
"FSUR_3D": ( (),
"FVOL_3D": ( (),
_(u"Chargement de force volumique en 3D"), ),
"HYDR_ELNO": ( (),
- _(u"Hydratation aux noeuds par élément"), ),
+ _(u"Hydratation aux noeuds par element"), ),
"IRRA": ( (),
_(u"Irradition aux noeuds"), ),
"MODE_FLAMB": ( (),
_(u"Mode de flambement"), ),
"MODE_STAB": ( (),
- _(u"Mode de stabilité"), ),
+ _(u"Mode de stabilite"), ),
"NEUT": ( (),
_(u"Variable de commande 'neutre'"), ),
"PRES": ( (),
"PTOT": ( (),
_(u"Pression totale de fluide en THM"), ),
"SISE_ELNO": ( (),
- _(u"Contraintes aux noeuds par sous-élément"), ),
+ _(u"Contraintes aux noeuds par sous-element"), ),
"SPMX_ELGA": ( (),
_(u"Valeurs maximum sur un sous-point"), ),
"THETA": ( (),
for typ in ('ELGA', 'ELNO', 'ELEM', 'NOEU', 'CART'):
for i in range(1, 11):
d['AUTRES']['UT%02d_%s' % (i, typ)]=( (),
- _(u"Champ utilisateur numéro %02d_%s" % (i, typ)), )
+ _(u"Champ utilisateur numero %02d_%s" % (i, typ)), )
self.d_all = d
return
def CheckPhenom(self):
- """ Vérification de la cohérence entre les phenomènes et les clés
+ """ Verification de la coherence entre les phenomenes et les cles
"""
l_keys = list(self.d_all.keys())
l_phen = list(self.all_phenomenes)
def CheckField(self):
- """ Vérification des doublons dans les noms des champs
+ """ Verification des doublons dans les noms des champs
"""
l_cham = []
for phen in self.all_phenomenes:
self.CheckField()
def __call__(self, *l_typ_cham, **kwargs):
- """Cette fonction retourne la liste des "into" possibles pour le mot-clé NOM_CHAM.
- C'est à dire les noms de champs des SD RESULTAT (DATA de la routine RSCRSD).
+ """Cette fonction retourne la liste des "into" possibles pour le mot-cle NOM_CHAM.
+ C'est a dire les noms de champs des SD RESULTAT (DATA de la routine RSCRSD).
l_typ_cham : rien ou un ou plusieurs parmi 'ELGA', 'ELNO', 'NOEU', 'ELEM'.
kwargs : un dictionnaire de mot-cles, les cles parmis :
'phenomene' : retourne la liste des champs en filtrant par le phenomene (eventuellement mixe avec le suivant)
#
# CLASSIFICATION EN 3 CATEGORIES :
# - solveurs directs uniquement
-# - solveurs pour le linéaire
-# - solveurs pour le non-linéaire
+# - solveurs pour le lineaire
+# - solveurs pour le non-lineaire
#
# GESTION DES EXCEPTIONS
#
_gene = False
_ldlt = False
-# Avec des matrices généralisées, MULT_FRONT n'est pas permis, LDLT est donc par défaut
+# Avec des matrices generalisees, MULT_FRONT n'est pas permis, LDLT est donc par defaut
if BASE == 'GENE':
_gene = True
_ldlt = True
-# LDLT est le solveur par défaut dans DYNA_TRAN_MODAL (systèmes linéaires petits)
+# LDLT est le solveur par defaut dans DYNA_TRAN_MODAL (systemes lineaires petits)
if COMMAND == 'DYNA_TRAN_MODAL':
_ldlt = True
_syme = False
-# Seuls les opérateurs non-linéaires produisent des matrices non-symétriques
+# Seuls les operateurs non-lineaires produisent des matrices non-symetriques
if _type == 'NL':
_syme = True
if COMMAND == 'THER_NON_LINE_MO':
_singu_non = False
-# Dans DEFI_BASE_MODALE, NON est le défaut de STOP_SINGULIER
+# Dans DEFI_BASE_MODALE, NON est le defaut de STOP_SINGULIER
if COMMAND == 'DEFI_BASE_MODALE':
_singu_non = True
#
# ----------------------------------------------------------------------------------------------------------------------------------
-# Mot-clés simples
+# Mot-cles simples
_MotCleSimples={}
# Solveurs
_BlocGC={}
_BlocPE={}
-# Préconditionneurs
+# Preconditionneurs
_BlocGC_INC={}
_BlocPE_INC={}
_BlocXX_SP={}
mcfact = FACT(statut='d',
b_mult_front = BLOC(condition = "METHODE == 'MULT_FRONT' ",
- fr="Paramètres de la méthode multi frontale",
+ fr="Parametres de la methode multi frontale",
**_BlocMF
),
b_ldlt = BLOC(condition = "METHODE == 'LDLT' ",
- fr="Paramètres de la méthode LDLT",
+ fr="Parametres de la methode LDLT",
**_BlocLD
),
b_mumps = BLOC(condition = "METHODE == 'MUMPS' ",
- fr="Paramètres de la méthode MUMPS",
+ fr="Parametres de la methode MUMPS",
**_BlocMU
),
b_gcpc = BLOC(condition = "METHODE == 'GCPC' ",
- fr="Paramètres de la méthode du gradient conjugué",
+ fr="Parametres de la methode du gradient conjugue",
b_ldltinc = BLOC(condition = "PRE_COND == 'LDLT_INC' ",
- fr="Paramètres de la factorisation incomplète",
+ fr="Parametres de la factorisation incomplete",
**_BlocGC_INC
),
b_simple = BLOC(condition = "PRE_COND == 'LDLT_SP' ",
- fr="Paramètres de la factorisation simple précision",
+ fr="Parametres de la factorisation simple precision",
**_BlocXX_SP
),
**_BlocGC
),
b_petsc = BLOC(condition = "METHODE == 'PETSC' ",
- fr="Paramètres de la méthode PETSC",
+ fr="Parametres de la methode PETSC",
b_ldltinc = BLOC(condition = "PRE_COND == 'LDLT_INC' ",
- fr="Paramètres de la factorisation incomplète",
+ fr="Parametres de la factorisation incomplete",
**_BlocPE_INC
),
b_simple = BLOC(condition = "PRE_COND == 'LDLT_SP' ",
- fr="Paramètres de la factorisation simple précision",
+ fr="Parametres de la factorisation simple precision",
**_BlocXX_SP
),
b_ml = BLOC(condition = "PRE_COND == 'ML' ",
- fr="Paramètres du multigrille algébrique ML",
+ fr="Parametres du multigrille algebrique ML",
**_BlocPE_ML
),
b_boomer = BLOC(condition = "PRE_COND == 'BOOMER' ",
- fr="Paramètres du multigrille algébrique HYPRE",
+ fr="Parametres du multigrille algebrique HYPRE",
**_BlocPE_BOOMER
),
b_autres = BLOC(condition = "PRE_COND == 'JACOBI' or \
# ======================================================================
# person_in_charge: mathieu.courtois at edf.fr
def C_TEST_REFERENCE(keyword, max=1): #COMMUN#
- """Mots-clés communs pour TEST_RESU, TEST_TABLE, TEST_FONCTION.
- On retourne un bloc pour ajouter la règle UN_PARMI."""
+ """Mots-cles communs pour TEST_RESU, TEST_TABLE, TEST_FONCTION.
+ On retourne un bloc pour ajouter la regle UN_PARMI."""
assert keyword in ('CHAM_NO', 'CHAM_ELEM', 'CARTE', 'RESU', 'GENE', 'OBJET',
'TABLE', 'FONCTION', 'FICHIER')
with_int = keyword not in ('FONCTION', 'FICHIER')
AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem,
fr="Affectation de caracteristiques a des elements de structure",
reentrant='n',
- UIinfo ={"groupes":("Modélisation",)},
+ UIinfo ={"groupes":("Modelisation",)},
regles = (AU_MOINS_UN('POUTRE','BARRE','COQUE','CABLE','DISCRET','DISCRET_2D','MASSIF',
'GRILLE','MEMBRANE','MULTIFIBRE','RIGI_PARASOL'),
PRESENT_PRESENT('MULTIFIBRE','GEOM_FIBRE'),
TABLE_CARA = SIMP(statut= 'f',typ=table_sdaster),
NOM_SEC = SIMP(statut= 'f',typ= 'TXM'),
CARA = SIMP(statut= 'f',typ= 'TXM',validators= NoRepeat(),min= 4 ,max= 15,
- fr= "A,IY,IZ,JX sont des paramètres obligatoires",
+ fr= "A,IY,IZ,JX sont des parametres obligatoires",
into= ("A","IY","IZ","AY","AZ","EY","EZ","JX","RY","RZ","RT",
"JG","IYR2","IZR2","AI") ),
VALE = SIMP(statut= 'f',typ= 'R',min= 4 ,max= 15), ),
b_homothetique = BLOC(condition = "VARI_SECT == 'HOMOTHETIQUE'",
CARA = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 8 ,max= 30,
- fr= "A1,A2,IY1,IY2,IZ1,IZ2,JX1,JX2 sont des paramètres obligatoires",
+ fr= "A1,A2,IY1,IY2,IZ1,IZ2,JX1,JX2 sont des parametres obligatoires",
into= ("A1","IY1","IZ1","AY1","AZ1","EY1","EZ1","JX1","RY1",
"RZ1","RT1","JG1","IYR21","IZR21","AI1",
"A2","IY2","IZ2","AY2","AZ2","EY2","EZ2","JX2","RY2",
VARI_SECT = SIMP(statut= 'f',typ= 'TXM',into= ("CONSTANT","HOMOTHETIQUE"),defaut= "CONSTANT"),
b_constant = BLOC(condition = "VARI_SECT == 'CONSTANT'",
CARA = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 1 ,max= 2,
- fr= "R est un paramètre obligatoire",
+ fr= "R est un parametre obligatoire",
into= ("R","EP") ),
VALE = SIMP(statut= 'o',typ= 'R',min= 1 ,max= 2), ),
b_homothetique = BLOC(condition = "VARI_SECT == 'HOMOTHETIQUE'",
CARA = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 2 ,max= 4,
- fr= "R1, R2 sont des paramètres obligatoires",
+ fr= "R1, R2 sont des parametres obligatoires",
into= ("R1","R2","EP1","EP2") ),
VALE = SIMP(statut= 'o',typ= 'R',min= 2 ,max= 4), ),
MODI_METRIQUE = SIMP(statut= 'f',typ= 'TXM',defaut= "NON",into= ("OUI","NON") ),
SYME = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),),
b_SYME_OUI = BLOC(condition="SYME=='OUI'",
- fr="SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+ fr="SYMETRIQUE: Affectation de matrices de rigidite, de masse ou d'amortissement a des mailles ou noeuds",
CARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
into=("K_T_D_N", "K_T_D_L", "K_TR_D_N", "K_TR_D_L", "K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
"M_T_D_N", "M_T_D_L", "M_TR_D_N", "M_TR_D_L", "M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
"A_T_D_N", "A_T_D_L", "A_TR_D_N", "A_TR_D_L", "A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
- # Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE
+ # Affection des caracteristiques de RIGIDITE/AMORTISSEMENT/MASSE
b_AK_T_D_N = BLOC(condition = "((CARA=='K_T_D_N')or(CARA=='A_T_D_N'))",
- fr="NOEUD: 3 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 3 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=3 ,max=3 ),),
b_AK_T_D_L = BLOC(condition = "((CARA=='K_T_D_L')or(CARA=='A_T_D_L'))",
- fr="SEGMENT: 3 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 3 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=3 ,max=3 ),),
b_AK_TR_D_N = BLOC(condition = "((CARA=='K_TR_D_N')or(CARA=='A_TR_D_N'))",
- fr="NOEUD: 6 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 6 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=6 ,max=6 ),),
b_AK_TR_D_L = BLOC(condition = "((CARA=='K_TR_D_L')or(CARA=='A_TR_D_L'))",
- fr="SEGMENT: 6 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 6 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=6 ,max=6 ),),
b_MAK_T_N = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
- fr="NOEUD: 6 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 6 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=6 ,max=6 ),),
b_MAK_T_L = BLOC(condition = "((CARA=='K_T_L')or(CARA=='A_T_L')or(CARA=='M_T_L'))",
- fr="SEGMENT: 21 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 21 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=21,max=21),),
b_MAK_TR_N = BLOC(condition = "((CARA=='K_TR_N')or(CARA=='A_TR_N')or(CARA=='M_TR_N'))",
- fr="NOEUD: 21 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 21 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=21,max=21),),
b_MAK_TR_L = BLOC(condition = "((CARA=='K_TR_L')or(CARA=='A_TR_L')or(CARA=='M_TR_L'))",
- fr="SEGMENT: 78 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 78 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=78,max=78),),
- # Affection des caractéristiques de MASSE
+ # Affection des caracteristiques de MASSE
b_M_T_D_N = BLOC(condition = "(CARA=='M_T_D_N')",
fr="NOEUD: 1 valeur de masse",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=4,max=4),),
),
- # éléments à matrice non-symétrique
+ # elements a matrice non-symetrique
# b_MAK_T_N_NS 'K_T_N' 'A_T_N' 'M_T_N'
# b_MAK_T_L_NS 'K_T_L' 'A_T_L' 'M_T_L'
# b_MAK_TR_N_NS 'K_TR_N' 'A_TR_N' 'M_TR_N'
# b_MAK_TR_L_NS 'K_TR_L' 'A_TR_L' 'M_TR_L'
b_SYME_NON = BLOC(condition="SYME=='NON'",
- fr="NON-SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+ fr="NON-SYMETRIQUE: Affectation de matrices de rigidite, de masse ou d'amortissement a des mailles ou noeuds",
CARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
into=("K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
"M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
"A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
- # Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE : NON-SYMETRIQUE
+ # Affection des caracteristiques de RIGIDITE/AMORTISSEMENT/MASSE : NON-SYMETRIQUE
b_MAK_T_N_NS = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
fr="NOEUD: 9 valeurs (matrice pleine par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
AMOR_HYST = SIMP(statut='f',typ='R' ),
SYME = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),),
b_SYME_OUI = BLOC(condition="SYME=='OUI'",
- fr="SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+ fr="SYMETRIQUE: Affectation de matrices de rigidite, de masse ou d'amortissement a des mailles ou noeuds",
CARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
into=("K_T_D_N", "K_T_D_L", "K_TR_D_N", "K_TR_D_L", "K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
"M_T_D_N", "M_T_D_L", "M_TR_D_N", "M_TR_D_L", "M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
"A_T_D_N", "A_T_D_L", "A_TR_D_N", "A_TR_D_L", "A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
- # Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE
+ # Affection des caracteristiques de RIGIDITE/AMORTISSEMENT/MASSE
b_AK_T_D_N = BLOC(condition = "((CARA=='K_T_D_N')or(CARA=='A_T_D_N'))",
- fr="NOEUD: 2 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 2 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=2 ,max=2 ),),
b_AK_T_D_L = BLOC(condition = "((CARA=='K_T_D_L')or(CARA=='A_T_D_L'))",
- fr="SEGMENT: 2 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 2 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=2 ,max=2 ),),
b_AK_TR_D_N = BLOC(condition = "((CARA=='K_TR_D_N')or(CARA=='A_TR_D_N'))",
- fr="NOEUD: 3 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 3 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=3 ,max=3 ),),
b_AK_TR_D_L = BLOC(condition = "((CARA=='K_TR_D_L')or(CARA=='A_TR_D_L'))",
- fr="SEGMENT: 3 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 3 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=3 ,max=3 ),),
b_MAK_T_N = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
- fr="NOEUD: 3 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 3 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=3 ,max=3 ),),
b_MAK_T_L = BLOC(condition = "((CARA=='K_T_L')or(CARA=='A_T_L')or(CARA=='M_T_L'))",
- fr="SEGMENT: 10 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 10 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=10,max=10),),
b_MAK_TR_N = BLOC(condition = "((CARA=='K_TR_N')or(CARA=='A_TR_N')or(CARA=='M_TR_N'))",
- fr="NOEUD: 6 valeurs (triangulaire supérieure par colonne)",
+ fr="NOEUD: 6 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=6 ,max=6),),
b_MAK_TR_L = BLOC(condition = "((CARA=='K_TR_L')or(CARA=='A_TR_L')or(CARA=='M_TR_L'))",
- fr="SEGMENT: 21 valeurs (triangulaire supérieure par colonne)",
+ fr="SEGMENT: 21 valeurs (triangulaire superieure par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA'),),
MAILLE = SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=21,max=21),),
- # Affection des caractéristiques de MASSE
+ # Affection des caracteristiques de MASSE
b_M_T_D_N = BLOC(condition = "(CARA=='M_T_D_N')",
fr="NOEUD: 1 valeur de masse",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
VALE = SIMP(statut='o',typ='R',min=2 ,max=2 ),),
),
- # éléments à matrice non-symétrique
+ # elements a matrice non-symetrique
# b_MAK_T_N_NS 'K_T_N' 'A_T_N' 'M_T_N'
# b_MAK_T_L_NS 'K_T_L' 'A_T_L' 'M_T_L'
# b_MAK_TR_N_NS 'K_TR_N' 'A_TR_N' 'M_TR_N'
# b_MAK_TR_L_NS 'K_TR_L' 'A_TR_L' 'M_TR_L'
b_SYME_NON = BLOC(condition="SYME=='NON'",
- fr="NON-SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+ fr="NON-SYMETRIQUE: Affectation de matrices de rigidite, de masse ou d'amortissement a des mailles ou noeuds",
CARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
into=("K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
"M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
"A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
- # Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE : NON-SYMETRIQUE
+ # Affection des caracteristiques de RIGIDITE/AMORTISSEMENT/MASSE : NON-SYMETRIQUE
b_MAK_T_N_NS = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
fr="NOEUD: 4 valeurs (matrice pleine par colonne)",
regles = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
UN_PARMI('COOR_CENTRE','NOEUD_CENTRE','GROUP_NO_CENTRE'),
EXCLUS('GROUP_MA_POI1','GROUP_MA_SEG2'),),
GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**',
- fr="Surface servant à répartir les caractéristiques des discrets"),
+ fr="Surface servant a repartir les caracteristiques des discrets"),
GROUP_MA_POI1 = SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1,
fr="Mailles de type point correspondant aux discrets"),
GROUP_MA_SEG2 = SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1,
#============================================================================
MASS_AJOU = FACT(statut='f',max='**',
GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**',
- fr="Surface servant à répartir les caractéristiques des discrets"),
+ fr="Surface servant a repartir les caracteristiques des discrets"),
GROUP_MA_POI1 = SIMP(statut='o',typ=grma,validators=NoRepeat(),max=1,
fr="Mailles de type point correspondant aux discrets"),
FONC_GROUP = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
UIinfo={"groupes":("Chargements","Acoustique",)},
regles=(AU_MOINS_UN('PRES_IMPO','VITE_FACE','IMPE_FACE','LIAISON_UNIF' ),),
MODELE =SIMP(statut='o',typ=modele_sdaster ),
- METHODE =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les pressions imposées",
+ METHODE =SIMP(statut='c',typ='TXM',fr="Strategie de resolution pour les pressions imposees",
into=('DUALISATION',),defaut='DUALISATION',),
- # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+ # METHODE='ELIMINATION' est traite dans le fortran mais dangereux actuellement
PRES_IMPO =FACT(statut='f',max='**',
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
elif AsType(EVOL_IMPO) in (evol_ther,) :
return char_cine_ther
else :
- raise AsException("Extension à faire ...")
+ raise AsException("Extension a faire ...")
raise AsException("type de concept resultat non prevu")
AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod
- ,fr="Affectation de conditions aux limites cinématiques (U=U0) pour un traitement sans dualisation",
+ ,fr="Affectation de conditions aux limites cinematiques (U=U0) pour un traitement sans dualisation",
reentrant='n',
- UIinfo={"groupes":("Chargements","Mécanique",)},
+ UIinfo={"groupes":("Chargements","Mecanique",)},
regles=(UN_PARMI('MECA_IMPO','THER_IMPO','ACOU_IMPO','EVOL_IMPO'),
),
MODELE =SIMP(statut='o',typ=modele_sdaster ),
EVOL_IMPO =SIMP(statut='f',typ=(evol_noli,evol_elas,evol_ther),fr="Pour imposer les ddls d'un evol_xxx"),
b_evol_impo = BLOC ( condition = "EVOL_IMPO != None",
- NOM_CMP =SIMP(statut='f',typ='TXM',max='**',), # pour n'imposer que certaines CMPS (par défaut : toutes)
+ NOM_CMP =SIMP(statut='f',typ='TXM',max='**',), # pour n'imposer que certaines CMPS (par defaut : toutes)
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
raise AsException("type de concept resultat non prevu")
AFFE_CHAR_CINE_F=OPER(nom="AFFE_CHAR_CINE_F",op= 101,sd_prod=affe_char_cine_f_prod,
- fr="Affectation de conditions aux limites cinématiques fonction d'un (ou plusieurs) paramètres"
+ fr="Affectation de conditions aux limites cinematiques fonction d'un (ou plusieurs) parametres"
+" pour un traitement sans dualisation",
reentrant='n',
- UIinfo={"groupes":("Chargements","Mécanique",)},
+ UIinfo={"groupes":("Chargements","Mecanique",)},
regles=(UN_PARMI('MECA_IMPO','THER_IMPO')),
MODELE =SIMP(statut='o',typ=modele_sdaster ),
MECA_IMPO =FACT(statut='f',max='**',
# ======================================================================
# person_in_charge: mickael.abbas at edf.fr
AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca,
- fr="Affectation de charges et conditions aux limites mécaniques constantes",
+ fr="Affectation de charges et conditions aux limites mecaniques constantes",
reentrant='n',
- UIinfo={"groupes":("Chargements","Mécanique",)},
+ UIinfo={"groupes":("Chargements","Mecanique",)},
regles=(AU_MOINS_UN('EVOL_CHAR','PESANTEUR','ROTATION','DDL_IMPO','DDL_POUTRE','FACE_IMPO',
'CHAMNO_IMPO','ARETE_IMPO',
'LIAISON_DDL','LIAISON_OBLIQUE','LIAISON_GROUP','LIAISON_MAIL',
GRAVITE =SIMP(statut='o',typ='R',min=1,max=1),
DIRECTION =SIMP(statut='o',typ='R',min=3,max=3),),
- METHODE =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les déplacements imposés",
+ METHODE =SIMP(statut='c',typ='TXM',fr="Strategie de resolution pour les deplacements imposes",
into=('DUALISATION',),defaut='DUALISATION',),
- # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+ # METHODE='ELIMINATION' est traite dans le fortran mais dangereux actuellement
ROTATION =FACT(statut='f', max=1,
- fr="Définition d'un chargement de rotation",
+ fr="Definition d'un chargement de rotation",
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(), max='**'),
MAILLE =SIMP(statut='f',typ=ma, validators=NoRepeat(),max='**'),
SANS_GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
TOUT = SIMP(statut='f',typ='TXM',into=("OUI",),defaut="OUI",),),),
DDL_IMPO =FACT(statut='f',max='**',
- fr="Impose à des noeuds une ou plusieurs valeurs de déplacement (ou de certaines grandeurs asscociées)",
+ fr="Impose a des noeuds une ou plusieurs valeurs de deplacement (ou de certaines grandeurs asscociees)",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
'TEMP','PRE1','PRE2','UI2','UI3','VI2','VI3','WI2','WI3','UO2',
DDL_POUTRE =FACT(statut='f',max='**',
- fr="Bloque des DDLs dans un repère local d'une poutre",
+ fr="Bloque des DDLs dans un repere local d'une poutre",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ'),
UN_PARMI('VECT_Y','ANGL_VRIL'),),
DRX =SIMP(statut='f',typ='R' ),
DRY =SIMP(statut='f',typ='R' ),
DRZ =SIMP(statut='f',typ='R' ),
-# définition du repère local
+# definition du repere local
VECT_Y =SIMP(statut='f',typ='R',min=3,max=3),
ANGL_VRIL =SIMP(statut='f',typ='R',),
-# restriction sur les mailles servant à définir le repère local
+# restriction sur les mailles servant a definir le repere local
GROUP_MA_REPE =SIMP(statut='f',typ=grma,),
MAILLE_REPE =SIMP(statut='f',typ=ma,),
),
FACE_IMPO =FACT(statut='f',max='**',
- fr="Impose à tous les noeuds d'une face une ou plusieurs valeurs de déplacement (ou de certaines grandeurs associées)",
+ fr="Impose a tous les noeuds d'une face une ou plusieurs valeurs de deplacement (ou de certaines grandeurs associees)",
regles=(UN_PARMI('GROUP_MA','MAILLE',),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
'TEMP','PRE1','PRE2','DNOR','DTAN'),
EXCLUS('DTAN','DRX'),
EXCLUS('DTAN','DRY'),
EXCLUS('DTAN','DRZ'),),
-# rajout d'un mot clé REPERE :/ LOCAL /GLOBAL
+# rajout d'un mot cle REPERE :/ LOCAL /GLOBAL
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
SANS_GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
ARETE_IMPO =FACT(statut='f',max='**',
- fr="Impose à tous les noeuds d'une arete des elements 3D une ou plusieurs valeurs de déplacement",
+ fr="Impose a tous les noeuds d'une arete des elements 3D une ou plusieurs valeurs de deplacement",
regles=(UN_PARMI('GROUP_MA','MAILLE',),
AU_MOINS_UN('DX','DY','DZ','DTAN','PRES','PHI','TEMP','PRE1','PRE2'),
EXCLUS('DTAN','DX'),
),
LIAISON_DDL =FACT(statut='f',max='**',
- fr="Définit une relation linéaire entre des DDLs de deux ou plusieurs noeuds",
+ fr="Definit une relation lineaire entre des DDLs de deux ou plusieurs noeuds",
regles=(UN_PARMI('GROUP_NO','NOEUD'),),
GROUP_NO =SIMP(statut='f',typ=grno ,max='**'),
NOEUD =SIMP(statut='f',typ=no ,max='**'),
),
LIAISON_OBLIQUE =FACT(statut='f',max='**',
- fr="Applique à des noeuds la meme valeur de déplacement définie composante par composante"
- +" dans un repère oblique quelconque",
+ fr="Applique a des noeuds la meme valeur de deplacement definie composante par composante"
+ +" dans un repere oblique quelconque",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ'),),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
),
LIAISON_GROUP =FACT(statut='f',max='**',
- fr="Définit la meme relation linéaire entre certains DDLs de couples de noeuds",
+ fr="Definit la meme relation lineaire entre certains DDLs de couples de noeuds",
regles=(UN_PARMI('GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
UN_PARMI('GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),
EXCLUS('GROUP_MA_1','GROUP_NO_2'),
),
LIAISON_MAIL =FACT(statut='f',max='**',
- fr="Définit des relations linéaires permettant de recoller deux bords d'une structure",
+ fr="Definit des relations lineaires permettant de recoller deux bords d'une structure",
regles=(AU_MOINS_UN('GROUP_MA_MAIT','MAILLE_MAIT'),
AU_MOINS_UN('GROUP_MA_ESCL','MAILLE_ESCL','GROUP_NO_ESCL','NOEUD_ESCL')),
GROUP_MA_MAIT =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
LIAISON_CYCL =FACT(statut='f',max='**',
- fr="Définit des relations linéaires permettant de recoller les bords de deux parties symétriquement cycliques",
+ fr="Definit des relations lineaires permettant de recoller les bords de deux parties symetriquement cycliques",
regles=(AU_MOINS_UN('GROUP_MA_MAIT1','MAILLE_MAIT1'),
AU_MOINS_UN('GROUP_MA_ESCL','MAILLE_ESCL','GROUP_NO_ESCL','NOEUD_ESCL'),
PRESENT_PRESENT('DDL_MAIT','DDL_ESCL'),
LIAISON_SOLIDE =FACT(statut='f',max='**',
- fr="Modélise une partie indéformable d'une structure."
- +" Le mot clé TRAN permettent d'imposer le déplacement de la partie indéformable.",
+ fr="Modelise une partie indeformable d'une structure."
+ +" Le mot cle TRAN permettent d'imposer le deplacement de la partie indeformable.",
regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
),
LIAISON_ELEM =FACT(statut='f',max='**',
- fr="Modélise le raccord : d'une partie massive 3D avec une poutre ou avec un tuyau, d'une coque"
+ fr="Modelise le raccord : d'une partie massive 3D avec une poutre ou avec un tuyau, d'une coque"
+" avec une poutre ou avec un tuyau, d'une plaque avec une poutre",
regles =(UN_PARMI('GROUP_MA_1','MAILLE_1'), UN_PARMI('GROUP_NO_2','NOEUD_2'),),
OPTION =SIMP(statut='o',typ='TXM',into=("3D_TUYAU","3D_POU","2D_POU","COQ_POU","COQ_TUYAU","PLAQ_POUT_ORTH") ),
),
LIAISON_UNIF =FACT(statut='f',max='**',
- fr="Impose une meme valeur (inconnue) à des DDLs d'un ensemble de noeuds",
+ fr="Impose une meme valeur (inconnue) a des DDLs d'un ensemble de noeuds",
regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
),
LIAISON_CHAMNO =FACT(statut='f',max='**',
- fr="Définit une relation linéaire entre tous les DDLs présents dans un concept CHAM_NO",
+ fr="Definit une relation lineaire entre tous les DDLs presents dans un concept CHAM_NO",
# type de cham_no_sdaster CO()
CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), #CO()
COEF_IMPO =SIMP(statut='o',typ='R' ),
),
LIAISON_RBE3 =FACT(statut='f',max='**',
- fr="""Modélise des relations linéaires de type RBE3 entre
- les degrés de liberté d'un noeud maître et des noeuds esclaves.""",
+ fr="""Modelise des relations lineaires de type RBE3 entre
+ les degres de liberte d'un noeud maitre et des noeuds esclaves.""",
regles =(UN_PARMI('GROUP_NO_MAIT','NOEUD_MAIT'), UN_PARMI('GROUP_NO_ESCL','NOEUD_ESCL'),),
GROUP_NO_MAIT =SIMP(statut='f',typ=grno,max=1),
NOEUD_MAIT =SIMP(statut='f',typ=no ,max=1),
),
LIAISON_INTERF =FACT(statut='f',max='**',
- fr="Définit une relation linéaire entre les DDLs d'interface à partir d'un MACRELEM",
+ fr="Definit une relation lineaire entre les DDLs d'interface a partir d'un MACRELEM",
MACR_ELEM_DYNA =SIMP(statut='o',typ=macr_elem_dyna),
TYPE_LIAISON =SIMP(statut='f',typ='TXM',defaut="RIGIDE",into=("RIGIDE","SOUPLE") ),
),
#
# FORCES
#
- FORCE_NODALE =FACT(statut='f',fr="Applique à des noeuds des forces nodales",max='**',
+ FORCE_NODALE =FACT(statut='f',fr="Applique a des noeuds des forces nodales",max='**',
regles=(AU_MOINS_UN('GROUP_NO','NOEUD'),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ' ),),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
),
FORCE_FACE =FACT(statut='f',max='**',
- fr="Applique des forces surfaciques sur une face d'élément volumique",
+ fr="Applique des forces surfaciques sur une face d'element volumique",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
FORCE_ARETE =FACT(statut='f',max='**',
- fr="Applique des forces linéiques à une arete d'élément volumique ou de coque",
+ fr="Applique des forces lineiques a une arete d'element volumique ou de coque",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ' ),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
FORCE_CONTOUR =FACT(statut='f',max='**',
- fr="Applique des forces linéiques au bord d'un domaine 2D ou AXIS ou AXIS_FOURIER",
+ fr="Applique des forces lineiques au bord d'un domaine 2D ou AXIS ou AXIS_FOURIER",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
FORCE_INTERNE =FACT(statut='f',max='**',
- fr="Applique des forces volumiques (2D ou 3D) à un domaine volumique",
+ fr="Applique des forces volumiques (2D ou 3D) a un domaine volumique",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ' ),),
),
PRE_SIGM =FACT(statut='f',max='**',
- fr="Applique des contraintes volumiques (2D ou 3D) à un domaine volumique",
+ fr="Applique des contraintes volumiques (2D ou 3D) a un domaine volumique",
#INST =SIMP(statut='f',typ='R' ),
SIGM =SIMP(statut='o',typ=(cham_elem,carte_sdaster)),
),
PRES_REP =FACT(statut='f',max='**',
- fr="Applique une pression à un domaine de milieu continu 2D ou 3D, ou à un domaine de coques et tuyaux",
+ fr="Applique une pression a un domaine de milieu continu 2D ou 3D, ou a un domaine de coques et tuyaux",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','FISSURE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE','FISSURE'),
AU_MOINS_UN('PRES','CISA_2D' ),),
),
EFFE_FOND =FACT(statut='f',max='**',
- fr="Calcul l'effet de fond sur une branche de tuyauterie (modélisation 3D) soumise à une pression",
+ fr="Calcul l'effet de fond sur une branche de tuyauterie (modelisation 3D) soumise a une pression",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
GROUP_MA_INT =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
PRE_EPSI =FACT(statut='f',max='**',
- fr="Applique un chargement de déformation initiale à un élément 2D, 3D ou de structure",
+ fr="Applique un chargement de deformation initiale a un element 2D, 3D ou de structure",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ','EPX',
),
FORCE_POUTRE =FACT(statut='f',max='**',
- fr="Applique des forces linéiques sur des éléments de type poutre",
+ fr="Applique des forces lineiques sur des elements de type poutre",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FORCE",into=("VENT","FORCE",) ),
-# rajour d'un mot clé REPERE :/ LOCAL /GLOBAL
+# rajour d'un mot cle REPERE :/ LOCAL /GLOBAL
b_force = BLOC(condition = "TYPE_CHARGE == 'FORCE'",
regles=(
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ','N','VY','VZ','MT','MFY','MFZ'),
),
FORCE_TUYAU =FACT(statut='f',max='**',
- fr="Applique une pression sur des éléments TUYAU",
+ fr="Applique une pression sur des elements TUYAU",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
),
FORCE_COQUE =FACT(statut='f',max='**',
- fr="Applique des forces surfaciques sur des éléments de types coques",
+ fr="Applique des forces surfaciques sur des elements de types coques",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ','PRES','F1','F2','F3','MF1','MF2'),
PRESENT_ABSENT('MF1','FX','FY','FZ','MX','MY','MZ','PRES'),
PRESENT_ABSENT('MF2','FX','FY','FZ','MX','MY','MZ','PRES'),
PRESENT_ABSENT('PRES','FX','FY','FZ','MX','MY','MZ','F1','F2','F3','MF1','MF2'),),
-# rajour d'un mot clé REPERE :/ LOCAL /GLOBAL
+# rajour d'un mot cle REPERE :/ LOCAL /GLOBAL
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
),
LIAISON_COQUE =FACT(statut='f',max='**',
- fr="Permet de représenter le raccord entre des éléments de coques au moyen des relations linéaires",
+ fr="Permet de representer le raccord entre des elements de coques au moyen des relations lineaires",
regles=(AU_MOINS_UN('GROUP_MA_1','MAILLE_1','GROUP_MA_2','MAILLE_2',
'GROUP_NO_1','NOEUD_1','GROUP_NO_2','NOEUD_2',),),
GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
RELA_CINE_BP =FACT(statut='f',max='**',
- fr="Etablir des relations cinématiques permettant de relier les noeuds cable aux noeuds du béton, et spécifier"
+ fr="Etablir des relations cinematiques permettant de relier les noeuds cable aux noeuds du beton, et specifier"
+" la prise en compte des contraintes initiales dans les cables",
CABLE_BP =SIMP(statut='o',typ=cabl_precont ),
SIGM_BPEL =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
),
FORCE_ELEC =FACT(statut='f',max='**',
- fr="Appliquer la force de LAPLACE agissant sur un conducteur principal, due à la présence d'un conducteur"
+ fr="Appliquer la force de LAPLACE agissant sur un conducteur principal, due a la presence d'un conducteur"
+" secondaire droit",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
- POSITION =SIMP(statut='f',typ='TXM',fr="Direction prédéfinie",into=("PARA","INFI","FINI",) ),
+ POSITION =SIMP(statut='f',typ='TXM',fr="Direction predefinie",into=("PARA","INFI","FINI",) ),
b_fxyz =BLOC ( condition = "POSITION == None",
FX =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
FY =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
INTE_ELEC =FACT(statut='f',max='**',
- fr="Appliquer la force de LAPLACE agissant sur un conducteur principal, due à la présence d'un conducteur"
- +" secondaire non nécessairement droit",
+ fr="Appliquer la force de LAPLACE agissant sur un conducteur principal, due a la presence d'un conducteur"
+ +" secondaire non necessairement droit",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('GROUP_MA_2','MAILLE_2','TRANS','SYME'),
),
- IMPE_FACE =FACT(statut='f',fr="Applique une impédance acoustique à une face",max='**',
+ IMPE_FACE =FACT(statut='f',fr="Applique une impedance acoustique a une face",max='**',
regles=(AU_MOINS_UN('GROUP_MA','MAILLE' ),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
IMPE =SIMP(statut='o',typ='R' ),
),
- VITE_FACE =FACT(statut='f',fr="Impose des vitesses normales à une face (phénomène ACOUSTIQUE), ",max='**',
+ VITE_FACE =FACT(statut='f',fr="Impose des vitesses normales a une face (phenomene ACOUSTIQUE), ",max='**',
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
ONDE_FLUI =FACT(statut='f',max='**',
- fr="Applique une amplitude de pression d'onde incidente sinusoidale arrivant normalement à une face",
+ fr="Applique une amplitude de pression d'onde incidente sinusoidale arrivant normalement a une face",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
),
FLUX_THM_REP =FACT(statut='f',max='**',
- fr="Applique à un domaine de milieu continu 2D ou 3D un flux de chaleur et/ou un apport de masse fluide"
+ fr="Applique a un domaine de milieu continu 2D ou 3D un flux de chaleur et/ou un apport de masse fluide"
+" (flux hydraulique)",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
FLUN_HYDR2 =SIMP(statut='f',typ='R' ),
),
FORCE_SOL =FACT(statut='f',max=1,
- fr="Définition des impédances et forces de sol temporelles",
+ fr="Definition des impedances et forces de sol temporelles",
regles=(UN_PARMI('GROUP_NO_INTERF','SUPER_MAILLE'),
AU_MOINS_UN('UNITE_RESU_MASS','UNITE_RESU_RIGI','UNITE_RESU_AMOR'),),
GROUP_NO_INTERF =SIMP(statut='f',typ=grno,),
# ======================================================================
# person_in_charge: mickael.abbas at edf.fr
AFFE_CHAR_MECA_C=OPER(nom="AFFE_CHAR_MECA_C",op= 7,sd_prod=char_meca,
- fr="Affectation de charges et conditions aux limites mécaniques complexes",
+ fr="Affectation de charges et conditions aux limites mecaniques complexes",
reentrant='n',
- UIinfo={"groupes":("Chargements","Mécanique",)},
+ UIinfo={"groupes":("Chargements","Mecanique",)},
regles=(AU_MOINS_UN('DDL_IMPO','FORCE_POUTRE','LIAISON_DDL', ),),
MODELE =SIMP(statut='o',typ=modele_sdaster ),
- METHODE =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les déplacements imposés",
+ METHODE =SIMP(statut='c',typ='TXM',fr="Strategie de resolution pour les deplacements imposes",
into=('DUALISATION',),defaut='DUALISATION',),
- # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+ # METHODE='ELIMINATION' est traite dans le fortran mais dangereux actuellement
DDL_IMPO =FACT(statut='f',max='**',
- fr="Impose à des noeuds une ou plusieurs valeurs de déplacement (ou de certaines grandeurs asscociées)",
+ fr="Impose a des noeuds une ou plusieurs valeurs de deplacement (ou de certaines grandeurs asscociees)",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD',),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI','LIAISON','GLIS' ),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GLIS =SIMP(statut='f',typ='C' ),
),
FORCE_POUTRE =FACT(statut='f',max='**',
- fr="Applique des forces linéiques sur des éléments de type poutre",
+ fr="Applique des forces lineiques sur des elements de type poutre",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ','N','VY','VZ',),
VZ =SIMP(statut='f',typ='C' ),
),
LIAISON_DDL =FACT(statut='f',max='**',
- fr="Définit une relation linéaire entre les DDLs de deux ou plusieurs noeuds",
+ fr="Definit une relation lineaire entre les DDLs de deux ou plusieurs noeuds",
regles=(UN_PARMI('GROUP_NO','NOEUD', ),),
GROUP_NO =SIMP(statut='f',typ=grno,max='**'),
NOEUD =SIMP(statut='f',typ=no ,max='**'),
# ======================================================================
# person_in_charge: mickael.abbas at edf.fr
AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca,
- fr="Affectation de charges et conditions aux limites mécaniques fonction d'un (ou plusieurs) paramètres",
+ fr="Affectation de charges et conditions aux limites mecaniques fonction d'un (ou plusieurs) parametres",
reentrant='n',
- UIinfo={"groupes":("Chargements","Mécanique",)},
+ UIinfo={"groupes":("Chargements","Mecanique",)},
regles=(AU_MOINS_UN('DDL_IMPO','FACE_IMPO','LIAISON_DDL','FORCE_NODALE',
'FORCE_FACE','FORCE_ARETE','FORCE_CONTOUR','FORCE_INTERNE',
'PRES_REP','FORCE_POUTRE','VITE_FACE','IMPE_FACE','ONDE_PLANE',
'EFFE_FOND','FLUX_THM_REP',),),
VERI_NORM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
MODELE =SIMP(statut='o',typ=modele_sdaster),
- METHODE =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les déplacements imposés",
+ METHODE =SIMP(statut='c',typ='TXM',fr="Strategie de resolution pour les deplacements imposes",
into=('DUALISATION',),defaut='DUALISATION',),
- # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+ # METHODE='ELIMINATION' est traite dans le fortran mais dangereux actuellement
DDL_IMPO =FACT(statut='f',max='**',
- fr="Impose à des noeuds une ou plusieurs valeurs de déplacement (ou de certaines grandeurs asscociées) fournies"
- +" par l'intermédiaire d'un concept fonction ",
+ fr="Impose a des noeuds une ou plusieurs valeurs de deplacement (ou de certaines grandeurs asscociees) fournies"
+ +" par l'intermediaire d'un concept fonction ",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
'TEMP','PRE1','PRE2','GONF','LIAISON','H1X',
),
FACE_IMPO =FACT(statut='f',max='**',
- fr="Impose à tous les noeuds d'une face une ou plusieurs valeurs de déplacement (ou de certaines grandeurs associées)"
- +" fournies par l'intérmédiaire d'un concept fonction",
+ fr="Impose a tous les noeuds d'une face une ou plusieurs valeurs de deplacement (ou de certaines grandeurs associees)"
+ +" fournies par l'intermediaire d'un concept fonction",
regles=(UN_PARMI('GROUP_MA','MAILLE'),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI','TEMP','PRE1','PRE2','DNOR','DTAN'),
EXCLUS('DNOR','DX'),
),
LIAISON_DDL =FACT(statut='f',max='**',
- fr="Définit une relation linéaire entre des DDLs de deux ou plusieurs noeuds, les valeurs sont fournies par"
+ fr="Definit une relation lineaire entre des DDLs de deux ou plusieurs noeuds, les valeurs sont fournies par"
+" l'intermediaire d'un concept de type fonction",
regles=(UN_PARMI('GROUP_NO','NOEUD'),UN_PARMI('COEF_MULT','COEF_MULT_FONC'),),
GROUP_NO =SIMP(statut='f',typ=grno,max='**'),
),
LIAISON_OBLIQUE =FACT(statut='f',max='**',
- fr="Applique à des noeuds la meme valeur de déplacement définie composante par composante dans un repère oblique"
- +" quelconque, les valeurs sont fournis par l'intermédiaire d'un concept fonction",
+ fr="Applique a des noeuds la meme valeur de deplacement definie composante par composante dans un repere oblique"
+ +" quelconque, les valeurs sont fournis par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ'),),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
),
LIAISON_GROUP =FACT(statut='f',max='**',
- fr="Définit la meme relation linéaire entre certains DDLs de couples de noeuds, les valeurs sont fournies par"
- +" l'intermédiaire de concept fonction",
+ fr="Definit la meme relation lineaire entre certains DDLs de couples de noeuds, les valeurs sont fournies par"
+ +" l'intermediaire de concept fonction",
regles=(UN_PARMI('GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
UN_PARMI('GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),
EXCLUS('GROUP_MA_1','GROUP_NO_2'),
),
LIAISON_UNIF =FACT(statut='f',max='**',
- fr="Impose une meme valeur (inconnue) à des DDLs d'un ensemble de noeuds",
+ fr="Impose une meme valeur (inconnue) a des DDLs d'un ensemble de noeuds",
regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
LIAISON_SOLIDE =FACT(statut='f',max='**',
- fr="Modélise une partie indéformable d'une structure."
- +" Le mot clé TRAN permettent d'imposer le déplacement de la partie indéformable.",
+ fr="Modelise une partie indeformable d'une structure."
+ +" Le mot cle TRAN permettent d'imposer le deplacement de la partie indeformable.",
regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
FORCE_NODALE =FACT(statut='f',max='**',
- fr="Applique à des noeuds des forces nodales dont les valeurs des composantes sont fournies par l'intermédiaire"
+ fr="Applique a des noeuds des forces nodales dont les valeurs des composantes sont fournies par l'intermediaire"
+" d'un concept fonction",
regles=(UN_PARMI('GROUP_NO','NOEUD'),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
),
FORCE_FACE =FACT(statut='f',max='**',
- fr="Applique des forces surfaciques sur une face d'élément volumique dont les valeurs des composantes sont fournies"
- +" par l'intermédiaire d'un concept fonction",
+ fr="Applique des forces surfaciques sur une face d'element volumique dont les valeurs des composantes sont fournies"
+ +" par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
FZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
),
FORCE_ARETE =FACT(statut='f',max='**',
- fr="Applique des forces linéiques à une arete d'élément volumique ou de coque dont les valeurs des composantes sont"
- +" fournies par l'intermédiaire d'un concept fonction",
+ fr="Applique des forces lineiques a une arete d'element volumique ou de coque dont les valeurs des composantes sont"
+ +" fournies par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
),
FORCE_CONTOUR =FACT(statut='f',max='**',
- fr="Applique des forces linéiques au bord d'un domaine 2D ou AXIS ou AXIS_FOURIER, dont les valeurs des composantes"
- +" sont fournies par l'intermédiaire d'un concept fonction",
+ fr="Applique des forces lineiques au bord d'un domaine 2D ou AXIS ou AXIS_FOURIER, dont les valeurs des composantes"
+ +" sont fournies par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
FORCE_INTERNE =FACT(statut='f',max='**',
- fr="Applique des forces volumiques (2D ou 3D) à un domaine volumique, dont les valeurs des composantes sont fournies"
- +" par l'intermédiaire d'un concept fonction",
+ fr="Applique des forces volumiques (2D ou 3D) a un domaine volumique, dont les valeurs des composantes sont fournies"
+ +" par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ'),),
),
PRES_REP =FACT(statut='f',max='**',
- fr="Applique une pression à un domaine de milieu continu 2D ou 3D ou à un domaine de coques et tuyaux, dont les"
- +" valeurs imposées (pression et/ou cisaillement) sont fournies par l'intermédiaire d'un concept fonction",
+ fr="Applique une pression a un domaine de milieu continu 2D ou 3D ou a un domaine de coques et tuyaux, dont les"
+ +" valeurs imposees (pression et/ou cisaillement) sont fournies par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','FISSURE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE','FISSURE'),
AU_MOINS_UN('PRES','CISA_2D'),),
),
EFFE_FOND =FACT(statut='f',max='**',
- fr="Calcul l'effet de fond sur une branche de tuyauterie (modélisation 3D) soumise"
- +" à une pression dont la valeur est fournie par l'intermédiaire d'un concept fonction",
+ fr="Calcul l'effet de fond sur une branche de tuyauterie (modelisation 3D) soumise"
+ +" a une pression dont la valeur est fournie par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
GROUP_MA_INT =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
PRE_EPSI =FACT(statut='f',max='**',
- fr="Applique un chargement de déformation initiale à un élément 2D, 3D ou de structure dont les composantes"
- +" du tenseur de déformation sont fournies par l'intermédiaire d'un concept fonction",
+ fr="Applique un chargement de deformation initiale a un element 2D, 3D ou de structure dont les composantes"
+ +" du tenseur de deformation sont fournies par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),),
),
FORCE_POUTRE =FACT(statut='f',max='**',
- fr="Applique des forces linéiques sur des éléments de type poutre dont les valeurs sont fournies par"
- +" l'intermédiaire d'un concept fonction",
+ fr="Applique des forces lineiques sur des elements de type poutre dont les valeurs sont fournies par"
+ +" l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
),
FORCE_TUYAU =FACT(statut='f',max='**',
- fr="Applique une pression sur des éléments TUYAU, la valeur est fournie par l'intermédiaire d'un concept fonction",
+ fr="Applique une pression sur des elements TUYAU, la valeur est fournie par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
),
FORCE_COQUE =FACT(statut='f',max='**',
- fr="Applique des forces surfaciques sur des éléments de types coques dont les valeurs sont fournies par"
- +" l'intermédiaires d'un concept fonction",
+ fr="Applique des forces surfaciques sur des elements de types coques dont les valeurs sont fournies par"
+ +" l'intermediaires d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ','PRES','F1','F2','F3','MF1','MF2'),
),
LIAISON_COQUE =FACT(statut='f',max='**',
- fr="Permet de représenter le raccord entre des éléments de coques au moyen des relations linéaires",
+ fr="Permet de representer le raccord entre des elements de coques au moyen des relations lineaires",
regles=(AU_MOINS_UN('GROUP_MA_1','MAILLE_1','GROUP_MA_2','MAILLE_2',
'GROUP_NO_1','NOEUD_1','GROUP_NO_2','NOEUD_2',),),
GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VITE_FACE =FACT(statut='f',max='**',
- fr="Impose des vitesses normales à une face (phénomène ACOUSTIQUE) dont les valeurs sont fournies par"
- +" l'intermédiaire d'un concept fonction",
+ fr="Impose des vitesses normales a une face (phenomene ACOUSTIQUE) dont les valeurs sont fournies par"
+ +" l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
PRESENT_ABSENT('GROUP_MA','MAILLE'),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
VNOR =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
),
IMPE_FACE =FACT(statut='f',max='**',
- fr="Applique à une face une impédance acoustique dont la valeur est fournie par l'intermédiaire"
+ fr="Applique a une face une impedance acoustique dont la valeur est fournie par l'intermediaire"
+" d'un concept fonction",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
PRESENT_ABSENT('GROUP_MA','MAILLE'),),
IMPE =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
),
ONDE_PLANE =FACT(statut='f',max=1,
- fr="Impose un chargement sismique par onde plane dont la valeur est fournie par l'intermédiaire"
+ fr="Impose un chargement sismique par onde plane dont la valeur est fournie par l'intermediaire"
+" d'un concept fonction",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
PRESENT_ABSENT('GROUP_MA','MAILLE'),),
FLUX_THM_REP =FACT(statut='f',max='**',
- fr="Applique à un domaine continue 2D ou 3D un flux de chaleur et/ou un apport de masse fluide (flux hydraulique)"
- +" dont les valeurs des flux sont fournies par l'intermédiaire d'un concept fonction",
+ fr="Applique a un domaine continue 2D ou 3D un flux de chaleur et/ou un apport de masse fluide (flux hydraulique)"
+ +" dont les valeurs des flux sont fournies par l'intermediaire d'un concept fonction",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
AU_MOINS_UN('FLUN','FLUN_HYDR1','FLUN_HYDR2'),),
'ECHANGE_PAROI','PRE_GRAD_TEMP','LIAISON_DDL','LIAISON_GROUP',
'LIAISON_UNIF','LIAISON_CHAMNO','RAYONNEMENT','LIAISON_MAIL' ),),
MODELE =SIMP(statut='o',typ=(modele_sdaster) ),
- METHODE =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les températures imposées",
+ METHODE =SIMP(statut='c',typ='TXM',fr="Strategie de resolution pour les temperatures imposees",
into=('DUALISATION',),defaut='DUALISATION',),
- # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+ # METHODE='ELIMINATION' est traite dans le fortran mais dangereux actuellement
TEMP_IMPO =FACT(statut='f',max='**',
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
RAYONNEMENT =FACT(statut='f',max='**',
- fr="Attention, exprimer les températures en Celsius si rayonnement",
+ fr="Attention, exprimer les temperatures en Celsius si rayonnement",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
# person_in_charge: mickael.abbas at edf.fr
AFFE_CHAR_THER_F=OPER(nom="AFFE_CHAR_THER_F",op=34,sd_prod=char_ther,
fr="Affectation de charges et conditions aux limites thermiques fonction d'un (ou plusieurs)"
- +" paramètres (temps, ...)",
+ +" parametres (temps, ...)",
reentrant='n',
UIinfo={"groupes":("Chargements","Thermique",)},
regles=(AU_MOINS_UN('TEMP_IMPO','SOURCE','SOUR_NL','FLUX_REP','FLUX_NL','ECHANGE',
RAYONNEMENT =FACT(statut='f',max='**',
- fr="Attention, exprimer les températures en Celsius si rayonnement",
+ fr="Attention, exprimer les temperatures en Celsius si rayonnement",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
# ======================================================================
# person_in_charge: jacques.pellet at edf.fr
AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater,
- fr="Affecter des matériaux à des zones géométriques d'un maillage",
+ fr="Affecter des materiaux a des zones geometriques d'un maillage",
reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
+ UIinfo={"groupes":("Modelisation",)},
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster),
MODELE =SIMP(statut='f',typ=modele_sdaster),
- # affectation du nom du matériau (par mailles):
+ # affectation du nom du materiau (par mailles):
# ----------------------------------------------
AFFE =FACT(statut='o',max='**',
regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE'),),
# affectation des variables de commande :
# --------------------------------------------------
- # un mot clé caché qui ne sert qu'à boucler sur les VARC possibles :
+ # un mot cle cache qui ne sert qu'a boucler sur les VARC possibles :
LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP","GEOM","CORR","IRRA","HYDR","SECH","EPSA",
"M_ACIER","M_ZIRC","NEUT1","NEUT2","PTOT","DIVU",)),
regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
PRESENT_ABSENT('GROUP_MA','TOUT'),
PRESENT_ABSENT('MAILLE','TOUT'),
- # La règle suivante permet de donner VALE_REF sans donner EVOL ni CHAM_GD
- # Elle est nécessaire pour la THM (voir doc U4.43.03)
- # Mais on ne peut plus l'écrire depuis de VALE_REF est dans un bloc
+ # La regle suivante permet de donner VALE_REF sans donner EVOL ni CHAM_GD
+ # Elle est necessaire pour la THM (voir doc U4.43.03)
+ # Mais on ne peut plus l'ecrire depuis de VALE_REF est dans un bloc
# AU_MOINS_UN('EVOL','CHAM_GD','VALE_REF'),
EXCLUS('EVOL','CHAM_GD'),
),
- TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), # [défaut]
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), # [defaut]
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
FONC_INST =SIMP(statut='f',typ=(fonction_sdaster,formule)),
),
- # VALE_REF est nécessaire pour certaines VARC :
+ # VALE_REF est necessaire pour certaines VARC :
B_VALE_REF =BLOC(condition="NOM_VARC in ('TEMP','SECH')",
VALE_REF =SIMP(statut='o',typ='R'),
),
),
- # mots clés cachés pour les variables de commande NEUT1/NEUT2 :
+ # mots cles caches pour les variables de commande NEUT1/NEUT2 :
# --------------------------------------------------------------
VARC_NEUT1 =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="NEUT1"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("NEUT2")),
),
- # mots clés cachés pour variable de commande TEMP :
+ # mots cles caches pour variable de commande TEMP :
# --------------------------------------------------
VARC_TEMP =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="TEMP"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=4,min=4,defaut=("TEMP","TEMP_MIL","TEMP_INF","TEMP_SUP",)),
),
- # mots clés cachés pour variable de commande GEOM :
+ # mots cles caches pour variable de commande GEOM :
# --------------------------------------------------
VARC_GEOM =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="GEOM"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=3,min=3,defaut=("X","Y","Z",)),
),
- # mots clés cachés pour variable de commande PTOT :
+ # mots cles caches pour variable de commande PTOT :
# -------------------------------------------------
VARC_PTOT =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="PTOT"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("PTOT",)),
),
- # mots clés cachés pour variable de commande SECH :
+ # mots cles caches pour variable de commande SECH :
# --------------------------------------------------
VARC_SECH =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="SECH"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("SECH",)),
),
- # mots clés cachés pour variable de commande HYDR :
+ # mots cles caches pour variable de commande HYDR :
# --------------------------------------------------
VARC_HYDR =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="HYDR"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("HYDR",)),
),
- # mots clés cachés pour variable de commande CORR :
+ # mots cles caches pour variable de commande CORR :
# --------------------------------------------------
VARC_CORR =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="CORR"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("CORR",)),
),
- # mots clés cachés pour variable de commande IRRA :
+ # mots cles caches pour variable de commande IRRA :
# --------------------------------------------------
VARC_IRRA =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="IRRA"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("IRRA",)),
),
- # mots clés cachés pour variable de commande DIVU :
+ # mots cles caches pour variable de commande DIVU :
# --------------------------------------------------
VARC_DIVU =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="DIVU"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("DIVU",)),
),
- # mots clés cachés pour variable de commande EPSA :
+ # mots cles caches pour variable de commande EPSA :
# --------------------------------------------------
VARC_EPSA =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="EPSA"),
CMP_GD =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPXX","EPYY","EPZZ","EPXY","EPXZ","EPYZ",)),
CMP_VARC =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPSAXX","EPSAYY","EPSAZZ","EPSAXY","EPSAXZ","EPSAYZ",)),
),
- # mots clés cachés pour variable de commande metallurgique ACIER :
+ # mots cles caches pour variable de commande metallurgique ACIER :
# -----------------------------------------------------------------
VARC_M_ACIER =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="M_ACIER"),
CMP_VARC =SIMP(statut='c',typ='TXM',max=7,min=7,defaut=("PFERRITE","PPERLITE","PBAINITE",
"PMARTENS","TAUSTE","TRANSF","TACIER",)),
),
- # mots clés cachés pour variable de commande metallurgique ZIRCALOY :
+ # mots cles caches pour variable de commande metallurgique ZIRCALOY :
# --------------------------------------------------------------------
VARC_M_ZIRC =FACT(statut='d',
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="M_ZIRC"),
# ======================================================================
# person_in_charge: jacques.pellet at edf.fr
AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
- UIinfo={"groupes":("Modélisation",)},
- fr="Définir le phénomène physique modélisé et le type d'éléments finis sur le maillage",reentrant='n',
+ UIinfo={"groupes":("Modelisation",)},
+ fr="Definir le phenomene physique modelise et le type d'elements finis sur le maillage",reentrant='n',
regles=(AU_MOINS_UN('AFFE','AFFE_SOUS_STRUC'),UN_PARMI('MAILLAGE','GRILLE')),
MAILLAGE =SIMP(statut='f',typ=maillage_sdaster),
GRILLE =SIMP(statut='f',typ=grille_sdaster),
VERIF =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2,into=("MAILLE","NOEUD") ),
#
#====
-# Définition des grandeurs caractéristiques
+# Definition des grandeurs caracteristiques
#====
#
GRANDEUR_CARA =FACT(statut='f',max=1,
- fr="Grandeurs caractéristiques pour l'adimensionnement des indicateurs d'erreur HM",
+ fr="Grandeurs caracteristiques pour l'adimensionnement des indicateurs d'erreur HM",
ang="Characteristic data for HM error estimators adimensionalisation",
#
LONGUEUR =SIMP(statut='f',typ='R',val_min=0,
- fr ="Longueur caractéristique",
+ fr ="Longueur caracteristique",
ang="Characteristic length",),
PRESSION =SIMP(statut='f',typ='R',val_min=0,
- fr ="Pression caractéristique",
+ fr ="Pression caracteristique",
ang="Characteristic pressure",),
TEMPERATURE =SIMP(statut='f',typ='R',val_min=0,
- fr ="Température caractéristique",
+ fr ="Temperature caracteristique",
ang="Characteristic temperature",),),
#
AFFE_SOUS_STRUC =FACT(statut='f',
PHENOMENE =SIMP(statut='o',typ='TXM',
into=("MECANIQUE","THERMIQUE","ACOUSTIQUE") ),
b_mecanique =BLOC( condition = "PHENOMENE=='MECANIQUE'",
- fr="modélisations mécaniques",
+ fr="modelisations mecaniques",
MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
"2D_DIS_T", # RESP. : FLEJOU J.L.FLEJOU
"2D_DIS_TR", # RESP. : FLEJOU J.L.FLEJOU
) ) ),
b_thermique =BLOC( condition = "PHENOMENE=='THERMIQUE'",
- fr="modélisations thermiques",
+ fr="modelisations thermiques",
MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
"3D", # RESP. : DURAND C.DURAND
"3D_DIAG", # RESP. : DURAND C.DURAND
),),),
b_acoustique =BLOC( condition = "PHENOMENE=='ACOUSTIQUE'",
- fr="modélisations acoustiques",
+ fr="modelisations acoustiques",
MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
"3D", # RESP. : None
"PLAN" # RESP. : None
),
VERI_JACOBIEN =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI',
- fr ="Vérification de la forme des mailles (jacobiens tous de meme signe).",),
+ fr ="Verification de la forme des mailles (jacobiens tous de meme signe).",),
) ;
# ======================================================================
raise AsException("type de concept resultat non prevu")
APPL_CINE_MATR=OPER(nom="APPL_CINE_MATR",op=158,sd_prod=appl_cine_matr_prod,
- fr="Appliquer les C.L. cinématiques sur la matrice",
- reentrant='f', UIinfo={"groupes":("Résolution",)},
+ fr="Appliquer les C.L. cinematiques sur la matrice",
+ reentrant='f', UIinfo={"groupes":("Resolution",)},
MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,
matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
# person_in_charge: jacques.pellet at edf.fr
APPL_CINE_SCMB=OPER(nom="APPL_CINE_SCMB",op=159,sd_prod=cham_no_sdaster,reentrant='f',
- fr="Application des C.L. cinématiques au second membre",
- UIinfo={"groupes":("Résolution",)},
+ fr="Application des C.L. cinematiques au second membre",
+ UIinfo={"groupes":("Resolution",)},
CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster),
MATR =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,
matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ),
else : return matr_asse_gene_r
ASSE_MATR_GENE=OPER(nom="ASSE_MATR_GENE",op= 128,sd_prod=asse_matr_gene_prod,
- fr="Assemblage des matrices généralisées de macro éléments pour construction de la matrice globale généralisée",
+ fr="Assemblage des matrices generalisees de macro elements pour construction de la matrice globale generalisee",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
raise AsException("type de concept resultat non prevu")
ASSE_MATRICE=OPER(nom="ASSE_MATRICE",op=12,sd_prod=asse_matrice_prod,
- fr="Construction d'une matrice assemblée",reentrant='n',
+ fr="Construction d'une matrice assemblee",reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
MATR_ELEM =SIMP(statut='o',
typ=(matr_elem_depl_r,matr_elem_depl_c,matr_elem_temp_r,matr_elem_pres_c) ),
# person_in_charge: jacques.pellet at edf.fr
ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster,
- fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n',
+ fr="Construire un champ aux noeuds par assemblage de vecteurs elementaires",reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
VECT_ELEM =SIMP(statut='o',typ=vect_elem,max='**'),
NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
UIinfo={"groupes":("Matrices et vecteurs",)},
sd_prod=assemblage_prod,
regles=(AU_MOINS_UN('MATR_ASSE','VECT_ASSE'),),
- fr="Calcul des matrices et vecteurs assemblés ",
+ fr="Calcul des matrices et vecteurs assembles ",
MODELE =SIMP(statut='o',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='f',typ=cham_mater),
INST =SIMP(statut='f',typ='R',defaut=0.),
NUME_DDL =SIMP(statut='o',typ=(nume_ddl_sdaster,CO)),
SOLVEUR =FACT(statut='d',
METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
- b_mult_front =BLOC(condition="METHODE=='MULT_FRONT'",fr="Paramètres associés à la méthode multifrontale",
+ b_mult_front =BLOC(condition="METHODE=='MULT_FRONT'",fr="Parametres associes a la methode multifrontale",
RENUM =SIMP(statut='f',typ='TXM',into=("MD","MDA","METIS"),defaut="METIS" ),
),
- b_ldlt =BLOC(condition="METHODE=='LDLT'",fr="Paramètres associés à la méthode LDLT",
+ b_ldlt =BLOC(condition="METHODE=='LDLT'",fr="Parametres associes a la methode LDLT",
RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Parametres de la methode MUMPS",
RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
),
- b_gcpc =BLOC(condition="METHODE=='GCPC'",fr="Paramètres associés à la méthode gradient conjugué",
+ b_gcpc =BLOC(condition="METHODE=='GCPC'",fr="Parametres associes a la methode gradient conjugue",
RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ),
),
- b_petsc =BLOC(condition = "METHODE == 'PETSC'",fr="Paramètres de la méthode PETSC",
+ b_petsc =BLOC(condition = "METHODE == 'PETSC'",fr="Parametres de la methode PETSC",
RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
),
),
VECT_ASSE =FACT(statut='f',max='**',
VECTEUR =SIMP(statut='o',typ=CO),
OPTION =SIMP(statut='o',typ='TXM',into=("CHAR_MECA","CHAR_ACOU","CHAR_THER") ),
- b_char_meca =BLOC(condition = "OPTION == 'CHAR_MECA'", fr="chargement mécanique",
+ b_char_meca =BLOC(condition = "OPTION == 'CHAR_MECA'", fr="chargement mecanique",
CHARGE =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
MODE_FOURIER =SIMP(statut='f',typ='I',defaut= 0 ),
),
# ======================================================================
# person_in_charge: Georges-cc.devesa at edf.fr
CALC_AMOR_MODAL=OPER(nom="CALC_AMOR_MODAL",op= 172,sd_prod=listr8_sdaster,
- fr="Création d'une liste d'amortissements modaux calculés selon la règle du RCC-G",
+ fr="Creation d'une liste d'amortissements modaux calcules selon la regle du RCC-G",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
regles=(EXCLUS('AMOR_RAYLEIGH','ENER_SOL',),
EXCLUS('AMOR_RAYLEIGH','AMOR_INTERNE',),
EXCLUS('AMOR_RAYLEIGH','AMOR_SOL',),
ENER_SOL =FACT(statut='f',
regles=(UN_PARMI('GROUP_NO_RADIER','GROUP_MA_RADIER'),
PRESENT_ABSENT('COEF_GROUP','FONC_GROUP'),
-# Peut-on remplacer les deux règles suivantes par un ENSEMBLE_('KRX','KRY','KRZ')
+# Peut-on remplacer les deux regles suivantes par un ENSEMBLE_('KRX','KRY','KRZ')
PRESENT_PRESENT('KRX','KRY'),
PRESENT_PRESENT('KRX','KRZ'),
PRESENT_ABSENT('COOR_CENTRE','NOEUD_CENTRE'),
# person_in_charge: josselin.delmas at edf.fr
CALC_CHAM_ELEM=OPER(nom="CALC_CHAM_ELEM",op=38,sd_prod=cham_elem,
- fr="Calculer un champ élémentaire en thermique et en accoustique à partir de champs déjà calculés",
+ fr="Calculer un champ elementaire en thermique et en accoustique a partir de champs deja calcules",
reentrant='n',
- UIinfo={"groupes":("Résultats et champs","Post-traitements",)},
+ UIinfo={"groupes":("Resultats et champs","Post-traitements",)},
MODELE =SIMP(statut='o',typ=modele_sdaster),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
CHAM_UTIL = FACT(statut='f', max='**',
regles = (UN_PARMI('FORMULE', 'CRITERE', 'NORME'), ),
NOM_CHAM = SIMP(statut='o', typ='TXM',
- fr="Nom du champ utilisé en donnée",),
+ fr="Nom du champ utilise en donnee",),
FORMULE = SIMP(statut='f', typ=formule, max='**',
- fr="Formule permet d'obtenir le critère",),
+ fr="Formule permet d'obtenir le critere",),
CRITERE = SIMP(statut='f', typ='TXM', max=1,
into=('TRACE', 'VMIS', 'INVA_2'),
- fr="Calcul d'un critère pré-défini",),
+ fr="Calcul d'un critere pre-defini",),
NORME = SIMP(statut='f', typ='TXM', max=1,
into=('L2', 'FROBENIUS', ),
- fr="Calcul d'une norme pré-définie",),
+ fr="Calcul d'une norme pre-definie",),
NUME_CHAM_RESU = SIMP(statut='o', typ='I', val_min=1, val_max=20,
- fr="Numéro du champ produit. Exemple: 6 produit le champ UT06",),
+ fr="Numero du champ produit. Exemple: 6 produit le champ UT06",),
),
INFO = SIMP(statut='f',typ='I',defaut= 1,into=(1,2)),
# person_in_charge: jacques.pellet at edf.fr
CALC_CHAR_CINE=OPER(nom="CALC_CHAR_CINE",op= 102,sd_prod=cham_no_sdaster,
- fr="Calcul des seconds membres associés à des charges cinématiques (conditions aux limites non dualisées)",
+ fr="Calcul des seconds membres associes a des charges cinematiques (conditions aux limites non dualisees)",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(UN_PARMI('MONO_APPUI','MODE_STAT' ),),
MATR_MASS =SIMP(statut='o',typ=matr_asse_depl_r,fr="Matrice de masse" ),
- DIRECTION =SIMP(statut='o',typ='R',max=6,fr="Directions du séisme imposé"),
+ DIRECTION =SIMP(statut='o',typ='R',max=6,fr="Directions du seisme impose"),
MONO_APPUI =SIMP(statut='f',typ='TXM',into=("OUI",) ),
MODE_STAT =SIMP(statut='f',typ=(mode_meca,) ),
b_mode_stat =BLOC ( condition = "MODE_STAT != None",
op=OPS('Macro.calc_ecrevisse_ops.calc_ecrevisse_ops'),
sd_prod=calc_ecrevisse_prod,
reentrant='n',
- UIinfo={"groupes":("Outils-métier",)},fr="Procedure de couplage avec Ecrevisse",
+ UIinfo={"groupes":("Outils-metier",)},fr="Procedure de couplage avec Ecrevisse",
regles = (UN_PARMI('LOGICIEL','VERSION'),),
# CONCEPTS SORTANTS : 2 CHARGEMENTS THERMIQUE + 1 MECANIQUE + 2 TABLES POUR LE POST-TRAITEMENT
raise AsException("type de concept resultat non prevu")
CALC_ERREUR=OPER(nom="CALC_ERREUR",op=42,sd_prod=calc_erreur_prod,reentrant='f',
- UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
- fr="Compléter ou créer un résultat en calculant des champs d'erreur",
+ UIinfo={"groupes":("Post-traitements","Resultats et champs",)},
+ fr="Completer ou creer un resultat en calculant des champs d'erreur",
MODELE =SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='f',typ=cham_mater),
RESULTAT =SIMP(statut='o',typ=resultat_sdaster,
- fr="Résultat d'une commande globale"),
+ fr="Resultat d'une commande globale"),
regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",),defaut="OUI"),
#-----------------------------------------------------------------------
-# pour conserver la compatibilité mais ne sert à rien
+# pour conserver la compatibilite mais ne sert a rien
#-----------------------------------------------------------------------
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
EXCIT =FACT(statut='f',max='**',
- fr="Charges contenant les températures, les efforts répartis pour les poutres...",
+ fr="Charges contenant les temperatures, les efforts repartis pour les poutres...",
regles=(EXCLUS('FONC_MULT','COEF_MULT',),),
CHARGE =SIMP(statut='o',typ=(char_meca,char_cine_meca),),
FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),),
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(phenomene='ERREUR',),),
b_erre_qi =BLOC(condition = "au_moins_un(OPTION, ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM','QIRE_ELNO','QIRE_NOEU'))",
- RESU_DUAL=SIMP(statut='o',typ=resultat_sdaster,fr="Résultat du problème dual"),),
+ RESU_DUAL=SIMP(statut='o',typ=resultat_sdaster,fr="Resultat du probleme dual"),),
b_sing =BLOC(condition= "au_moins_un(OPTION, 'SING_ELEM')",
PREC_ERR=SIMP(statut='o',typ='R',val_min= 0.,
- fr="Précision demandée pour calculer la carte de taille des éléments"),
+ fr="Precision demandee pour calculer la carte de taille des elements"),
TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM",
"QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",),
fr="Choix de l'estimateur d'erreur"),),
#-------------------------------------------------------------------
-# Catalogue commun SOLVEUR (utilisé actuellement pour estimateur d'erreur ZZ1)
+# Catalogue commun SOLVEUR (utilise actuellement pour estimateur d'erreur ZZ1)
SOLVEUR =C_SOLVEUR('CALC_ERREUR'),
#-------------------------------------------------------------------
op = OPS('Macro.calc_essai_ops.calc_essai_ops'),
sd_prod = calc_essai_prod,
reentrant = 'n',
- UIinfo = {"groupes":("Outils-métier","Dynamique",)},
+ UIinfo = {"groupes":("Outils-metier","Dynamique",)},
fr = "Outil de post-traitement interactif pour Meidee ",
INTERACTIF = SIMP( statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI' ),
RESU_IDENTIFICATION = FACT( statut='f',max='**',
op=OPS('Macro.calc_europlexus_ops.calc_europlexus_ops'),
sd_prod=calc_europlexus_prod,
reentrant='n',
- UIinfo={"groupes":("Outils-métier","Dynamique",)},
+ UIinfo={"groupes":("Outils-metier","Dynamique",)},
fr="Chainage Code_Aster-Europlexus",
regles=(PRESENT_ABSENT('ETAT_INIT','MODELE'),
PRESENT_ABSENT('ETAT_INIT','CARA_ELEM'),
raise AsException("type de calcul non prevu")
CALC_FATIGUE=OPER(nom="CALC_FATIGUE",op= 151,sd_prod=calc_fatigue_prod,reentrant='n',
- fr="Calculer un champ de dommage de fatigue subit par une structure et déterminer le plan critique"
+ fr="Calculer un champ de dommage de fatigue subit par une structure et determiner le plan critique"
+" dans lequel le cisaillement est maximal.",
UIinfo={"groupes":("Post-traitements","Rupture",)},
),
),
b_epsi =BLOC(condition = "OPTION != 'DOMA_ELNO_SIGM' and OPTION != 'DOMA_ELGA_SIGM'",
- fr="Calcul a partir d un champ de déformations.",
+ fr="Calcul a partir d un champ de deformations.",
HISTOIRE =FACT(statut='o',
RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,
evol_noli) ),
),
b_fatigue_multi =BLOC(condition = "TYPE_CALCUL == 'FATIGUE_MULTI'",
- fr="Plan critique dans le cas de la fatigue multiaxiale à grand nombre de cycles.",
+ fr="Plan critique dans le cas de la fatigue multiaxiale a grand nombre de cycles.",
TYPE_CHARGE =SIMP(statut='o',typ='TXM',into=("PERIODIQUE","NON_PERIODIQUE") ),
OPTION =SIMP(statut='o',typ='TXM',into=("DOMA_ELGA","DOMA_NOEUD") ),
RESULTAT =SIMP(statut='o',typ=(evol_elas, evol_noli) ),
CALC_FERRAILLAGE=OPER(nom="CALC_FERRAILLAGE",op=175,sd_prod=calc_ferraillage_prod, reentrant='o',
- UIinfo={"groupes":("Post-traitements","Outils-métier",)},
- fr="calcul de cartes de densité de ferraillage ",
+ UIinfo={"groupes":("Post-traitements","Outils-metier",)},
+ fr="calcul de cartes de densite de ferraillage ",
RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,) ),
#====
-# Sélection des numéros d'ordre pour lesquels on fait le calcul :
+# Selection des numeros d'ordre pour lesquels on fait le calcul :
#====
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
#
#====
-# Définition des grandeurs caractéristiques
+# Definition des grandeurs caracteristiques
#====
#
TYPE_COMB =SIMP(statut='o',typ='TXM',into=('ELU','ELS')),
-# mot clé facteur répétable pour assigner les caractéristiques locales par zones topologiques (GROUP_MA)
+# mot cle facteur repetable pour assigner les caracteristiques locales par zones topologiques (GROUP_MA)
AFFE =FACT(statut='o',max='**',
regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
ENROBG =SIMP(statut='o',typ='R'), # enrobage
- CEQUI =SIMP(statut='f',typ='R'), # coefficient d'équivalence acier/béton (pour ELS)
+ CEQUI =SIMP(statut='f',typ='R'), # coefficient d'equivalence acier/beton (pour ELS)
SIGM_ACIER =SIMP(statut='o',typ='R'), # contrainte admissible dans l'acier
- SIGM_BETON =SIMP(statut='o',typ='R'), # contrainte admissible dans le béton
+ SIGM_BETON =SIMP(statut='o',typ='R'), # contrainte admissible dans le beton
PIVA =SIMP(statut='f',typ='R'), # valeur du pivot a (pour ELU)
PIVB =SIMP(statut='f',typ='R'), # valeur du pivot b (pour ELU)
ES =SIMP(statut='f',typ='R'), # valeur du Module d'Young de l'acier (pour ELU)
##############################################################################################################
# Remarques :
#-----------
-# l'épaisseur des coques sera récupérée automatiquement
-# via le cara_elem sous-jacent au résultat
+# l'epaisseur des coques sera recuperee automatiquement
+# via le cara_elem sous-jacent au resultat
-# Le résultat produit est un champ constant par éléments associé à la grandeur FER2_R
+# Le resultat produit est un champ constant par elements associe a la grandeur FER2_R
# qui comporte les composantes :
#
-# DNSXI densité d'acier longitudinal suivant X, peau inf
-# DNSXS densité d'acier longitudinal suivant X, peau sup
-# DNSYI densité d'acier longitudinal suivant Y, peau inf
-# DNSYS densité d'acier longitudinal suivant Y, peau sup
-# DNST densité d'acier transversal à l'ELU
+# DNSXI densite d'acier longitudinal suivant X, peau inf
+# DNSXS densite d'acier longitudinal suivant X, peau sup
+# DNSYI densite d'acier longitudinal suivant Y, peau inf
+# DNSYS densite d'acier longitudinal suivant Y, peau sup
+# DNST densite d'acier transversal a l'ELU
# SIGMBE contrainte beton
-# EPSIBE deformation béton
+# EPSIBE deformation beton
-# arrêt en erreur si:
-# - EFGE_ELNO n'a pas été précédemment calculé et n'est donc pas présent dans la structure de données RESULTAT
-# - si aucun CARA_ELEM n'est récupérable via la structure de données RESULTAT
+# arret en erreur si:
+# - EFGE_ELNO n'a pas ete precedemment calcule et n'est donc pas present dans la structure de donnees RESULTAT
+# - si aucun CARA_ELEM n'est recuperable via la structure de donnees RESULTAT
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# person_in_charge: andre.adobes at edf.fr
CALC_FLUI_STRU=OPER(nom="CALC_FLUI_STRU",op= 144,sd_prod=melasflu_sdaster,
reentrant='n',
- fr="Calculer les paramètres modaux d'une structure soumise à un écoulement",
+ fr="Calculer les parametres modaux d'une structure soumise a un ecoulement",
UIinfo={"groupes":("Matrices et vecteurs",)},
VITE_FLUI =FACT(statut='f',
- fr="Définir la plage de vitesse fluide étudiée",
+ fr="Definir la plage de vitesse fluide etudiee",
VITE_MIN =SIMP(statut='f',typ='R' ),
VITE_MAX =SIMP(statut='f',typ='R' ),
NB_POIN =SIMP(statut='f',typ='I' ),
),
TYPE_FLUI_STRU =SIMP(statut='o',typ=type_flui_stru ),
IMPRESSION =FACT(statut='f',
- fr="Choix des informations à imprimer dans le fichier RESULTAT",
+ fr="Choix des informations a imprimer dans le fichier RESULTAT",
PARA_COUPLAGE =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
DEFORMEE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
),
CALC_FONC_INTERP=OPER(nom="CALC_FONC_INTERP",op= 134,sd_prod=calc_fonc_interp_prod,
docu="U4.32.01",reentrant='n',
- fr="Définit une fonction (ou une nappe) à partir d'une fonction FORMULE à 1 ou 2 variables",
+ fr="Definit une fonction (ou une nappe) a partir d'une fonction FORMULE a 1 ou 2 variables",
UIinfo={"groupes":("Fonctions",)},
regles=(UN_PARMI('VALE_PARA','LIST_PARA'),),
FONCTION =SIMP(statut='o',typ=(formule,fonction_sdaster,nappe_sdaster,fonction_c) ),
type_vale=AsType(COMB[0]['FONCTION'])
for mcfact in COMB :
if(AsType(mcfact['FONCTION'])!=type_vale):
- raise AsException("CALC_FONCTION/COMB : pas de types hétérogènes nappe/fonction")
+ raise AsException("CALC_FONCTION/COMB : pas de types heterogenes nappe/fonction")
return type_vale
if (COMB_C != None):
vale=COMB_C[0]['FONCTION']
if(AsType(vale) == nappe_sdaster):
for mcfact in COMB_C[1:] :
if(AsType(mcfact['FONCTION'])!=nappe_sdaster):
- raise AsException("CALC_FONCTION/COMB_C : pas de types hétérogènes nappe/fonction")
+ raise AsException("CALC_FONCTION/COMB_C : pas de types heterogenes nappe/fonction")
return nappe_sdaster
else:
for mcfact in COMB_C :
if(AsType(mcfact['FONCTION'])==nappe_sdaster):
- raise AsException("CALC_FONCTION/COMB_C : pas de types hétérogènes nappe/fonction")
+ raise AsException("CALC_FONCTION/COMB_C : pas de types heterogenes nappe/fonction")
return fonction_c
if (ENVELOPPE != None): return AsType(ENVELOPPE[0]['FONCTION'])
if (FRACTILE != None): return AsType(FRACTILE[0] ['FONCTION'])
type_vale = AsType(MULT[0]['FONCTION'])
for mcfact in MULT:
if(AsType(mcfact['FONCTION']) != type_vale):
- raise AsException("CALC_FONCTION/MULT : pas de types hétérogènes nappe/fonction")
+ raise AsException("CALC_FONCTION/MULT : pas de types heterogenes nappe/fonction")
return type_vale
if (FFT != None):
vale=FFT[0]['FONCTION']
CALC_FONCTION=MACRO(nom="CALC_FONCTION",
op=OPS('Macro.calc_fonction_ops.calc_fonction_ops'),
sd_prod=calc_fonction_prod,
- fr="Effectue des opérations mathématiques sur des concepts de type fonction",
+ fr="Effectue des operations mathematiques sur des concepts de type fonction",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
regles=(UN_PARMI('DERIVE', 'INTEGRE', 'SPEC_OSCI', 'DSP', 'FFT', 'CORR_ACCE',
'COMB', 'COMB_C', 'MULT', 'ASSE', 'INVERSE', 'ABS',
'ENVELOPPE', 'COMPOSE', 'EXTRACTION', 'PUISSANCE',
'LISS_ENVELOP', 'FRACTILE', 'REGR_POLYNOMIALE'),),
- FFT =FACT(statut='f',fr="Transformée de Fourier ou de son inverse",
+ FFT =FACT(statut='f',fr="Transformee de Fourier ou de son inverse",
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,fonction_c) ),
METHODE =SIMP(statut='f',typ='TXM',defaut="PROL_ZERO",into=("PROL_ZERO","TRONCATURE","COMPLET") ),
b_syme =BLOC ( condition = " AsType(FONCTION)==fonction_c ",
SYME =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI' ),
),
),
- DERIVE =FACT(statut='f',fr="Dérivée d une fonction",
+ DERIVE =FACT(statut='f',fr="Derivee d une fonction",
METHODE =SIMP(statut='f',typ='TXM',defaut="DIFF_CENTREE",into=("DIFF_CENTREE",) ),
FONCTION =SIMP(statut='o',typ=fonction_sdaster ),
),
- INTEGRE =FACT(statut='f',fr="Intégrale d'une fonction",
+ INTEGRE =FACT(statut='f',fr="Integrale d'une fonction",
METHODE =SIMP(statut='f',typ='TXM',defaut="TRAPEZE",into=("SIMPSON","TRAPEZE") ),
FONCTION =SIMP(statut='o',typ=fonction_sdaster),
- COEF =SIMP(statut='f',typ='R',defaut= 0.E+0,fr="Valeur de la constante d intégration" ),
+ COEF =SIMP(statut='f',typ='R',defaut= 0.E+0,fr="Valeur de la constante d integration" ),
),
LISS_ENVELOP = FACT(statut='f',fr="Lissage d une enveloppe",
NAPPE =SIMP(statut='o',typ=nappe_sdaster ),
ELARG =SIMP(statut='f',typ='R',defaut =0.1 ),
TOLE_LISS =SIMP(statut='f',typ='R',defaut =0.25 ),
),
- REGR_POLYNOMIALE = FACT(statut='f',fr="Régression polynomiale d'une fonction",
+ REGR_POLYNOMIALE = FACT(statut='f',fr="Regression polynomiale d'une fonction",
FONCTION =SIMP(statut='o',typ=fonction_sdaster),
DEGRE =SIMP(statut='o',typ='I'),
),
NATURE_FONC =SIMP(statut='f', typ='TXM', defaut="ACCE", into=("ACCE",),),),
b_rice =BLOC(condition = "METHODE =='RICE' ",
DUREE =SIMP(statut='o', typ='R', val_min=0.,
- fr="durée de la phase forte pour facteur de pic"),
+ fr="duree de la phase forte pour facteur de pic"),
NATURE_FONC =SIMP(statut='f', typ='TXM', defaut="DSP", into=("DSP",),),),
),
- DSP =FACT(statut='f', fr="Densité spectrale",
+ DSP =FACT(statut='f', fr="Densite spectrale",
FONCTION =SIMP(statut='o', typ=fonction_sdaster ),
AMOR_REDUIT =SIMP(statut='o', typ='R', val_min=0., val_max=1.),
NORME =SIMP(statut='o', typ='R'),
LIST_FREQ =SIMP(statut='f', typ=listr8_sdaster ),
FREQ_PAS =SIMP(statut='f', typ='R'),
regles=(UN_PARMI('FREQ_PAS','LIST_FREQ'),),
- FREQ_COUP =SIMP(statut='o', typ='R', fr="fréquence de coupure" ),
+ FREQ_COUP =SIMP(statut='o', typ='R', fr="frequence de coupure" ),
DUREE =SIMP(statut='o', typ='R', val_min=0.,
- fr="durée de la phase forte pour facteur de peak"),
+ fr="duree de la phase forte pour facteur de peak"),
FRACT =SIMP(statut='o', typ='R', defaut=0.5, val_min=0., val_max=1., fr="fractile" ),
),
ABS =FACT(statut='f',fr="Valeur absolue d'une fonction",
FONCTION =SIMP(statut='o',typ=fonction_sdaster,),
),
- COMB =FACT(statut='f',max='**',fr="Combinaison linéaire réelle de fonctions",
+ COMB =FACT(statut='f',max='**',fr="Combinaison lineaire reelle de fonctions",
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster) ),
- COEF =SIMP(statut='o',typ='R',fr="Coefficient réel de la combinaison linéaire associée à la fonction" ),
+ COEF =SIMP(statut='o',typ='R',fr="Coefficient reel de la combinaison lineaire associee a la fonction" ),
),
- COMB_C =FACT(statut='f',max='**',fr="Combinaison linéaire complexe de fonctions",
+ COMB_C =FACT(statut='f',max='**',fr="Combinaison lineaire complexe de fonctions",
regles=(UN_PARMI('COEF_R','COEF_C'),),
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,fonction_c,nappe_sdaster) ),
- COEF_R =SIMP(statut='f',typ='R',fr="Coefficient réel de la combinaison linéaire associée à la fonction" ),
- COEF_C =SIMP(statut='f',typ='C',fr="Coefficient complexe de la combinaison linéaire associée à la fonction" ),
+ COEF_R =SIMP(statut='f',typ='R',fr="Coefficient reel de la combinaison lineaire associee a la fonction" ),
+ COEF_C =SIMP(statut='f',typ='C',fr="Coefficient complexe de la combinaison lineaire associee a la fonction" ),
),
- MULT =FACT(statut='f',max='**',fr="Produit de fonctions réelles",
+ MULT =FACT(statut='f',max='**',fr="Produit de fonctions reelles",
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,fonction_c,nappe_sdaster) ),
),
b_comb =BLOC ( condition = "COMB != None or COMB_C != None " \
),
EXTRACTION =FACT(statut='f',fr="Extraction sur une fonction complexe",
FONCTION =SIMP(statut='o',typ=fonction_c),
- PARTIE =SIMP(statut='o',typ='TXM',into=("REEL","IMAG","MODULE","PHASE"),fr="Partie à extraire"),
+ PARTIE =SIMP(statut='o',typ='TXM',into=("REEL","IMAG","MODULE","PHASE"),fr="Partie a extraire"),
),
ENVELOPPE =FACT(statut='f',fr="Enveloppe d une famille de fonctions",
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster),max='**' ),
CORR_DEPL =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
FONCTION =SIMP(statut='o',typ=fonction_sdaster ),
),
- PUISSANCE =FACT(statut='f',fr="Fonction élevée à une puissance",
+ PUISSANCE =FACT(statut='f',fr="Fonction elevee a une puissance",
FONCTION =SIMP(statut='o', typ=(fonction_sdaster,nappe_sdaster) ),
EXPOSANT =SIMP(statut='f', typ='I', defaut=1 ),
),
NOM_PARA =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ),
NOM_RESU =SIMP(statut='f',typ='TXM' ),
INTERPOL =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG"),
- fr="Type d'interpolation pour les abscisses et les ordonnées de la " \
- "fonction ou bien pour le paramètre de la nappe."),
+ fr="Type d'interpolation pour les abscisses et les ordonnees de la " \
+ "fonction ou bien pour le parametre de la nappe."),
PROL_DROITE =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
PROL_GAUCHE =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
NOM_PARA_FONC =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ),
INTERPOL_FONC =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG"),
- fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction"),
+ fr="Type d'interpolation pour les abscisses et les ordonnees de la fonction"),
PROL_DROITE_FONC=SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
PROL_GAUCHE_FONC=SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
# person_in_charge: Georges-cc.devesa at edf.fr
CALC_FORC_NONL=OPER(nom="CALC_FORC_NONL",op= 183,sd_prod=dyna_trans,reentrant='n',
- fr="Créer un dyna_trans contenant des champs nommés 'DEPL' correspondant à 'FONL_NOEU' ",
- UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
+ fr="Creer un dyna_trans contenant des champs nommes 'DEPL' correspondant a 'FONL_NOEU' ",
+ UIinfo={"groupes":("Post-traitements","Resultats et champs",)},
RESULTAT =SIMP(statut='o',typ=resultat_sdaster),
regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
# ======================================================================
# person_in_charge: samuel.geniaut at edf.fr
CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster,
- fr="Calcul du taux de restitution d'énergie par la méthode theta en thermo-élasticité"
- +" et les facteurs d'intensité de contraintes.",
+ fr="Calcul du taux de restitution d'energie par la methode theta en thermo-elasticite"
+ +" et les facteurs d'intensite de contraintes.",
reentrant='f',
UIinfo={"groupes":("Post-traitements","Rupture",)},
op=OPS('Macro.calc_gp_ops.calc_gp_ops'),
sd_prod=calc_gp_prod,
# sd_prod=table_sdaster,
- UIinfo={"groupes":("Outils-métier","Rupture",)},
+ UIinfo={"groupes":("Outils-metier","Rupture",)},
reentrant='n',
fr="calcul du parametre de clivage energetique Gp en 2D et en 3D",
regles=UN_PARMI('TRANCHE_2D','TRANCHE_3D'),
op=OPS("Macro.calc_ifs_dnl_ops.calc_ifs_dnl_ops"),
sd_prod=evol_noli,
reentrant='f',
- fr="Calcul de l'évolution dynamique d'une structure couplée à un "\
- "domaine fluide (résolu avec le code Saturne) via YACS",
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ fr="Calcul de l'evolution dynamique d'une structure couplee a un "\
+ "domaine fluide (resolu avec le code Saturne) via YACS",
+ UIinfo={"groupes":("Resolution","Dynamique",)},
#IFS
#=>
RIGI_GEOM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
b_char_crit=BLOC(condition="(RIGI_GEOM=='OUI')",
CHAR_CRIT =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Valeur des deux charges critiques délimitant la bande de recherche en HPP"),),
+ fr="Valeur des deux charges critiques delimitant la bande de recherche en HPP"),),
MODI_RIGI =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
TYPE =SIMP(statut='f',typ='TXM',defaut="FLAMBEMENT",into=("FLAMBEMENT","STABILITE")),
PREC_INSTAB =SIMP(statut='f',typ='R',defaut=1.E-6,max=1,),
MODE_VIBR =FACT(statut='f',min=1,max=1,
MATR_RIGI =SIMP(statut='f',typ='TXM',defaut="ELASTIQUE",into=("ELASTIQUE","TANGENTE","SECANTE",) ),
NB_FREQ =SIMP(statut='f',typ='I',max=1,val_min=1,defaut=3,
- fr="Nombre de fréquences propres à calculer"),
+ fr="Nombre de frequences propres a calculer"),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I',max=1,val_min=2,defaut=5),
BANDE =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Valeur des deux fréquences délimitant la bande de recherche",),
+ fr="Valeur des deux frequences delimitant la bande de recherche",),
regles = (EXCLUS('PAS_CALC','LIST_INST','INST'),),
LIST_INST = SIMP(statut='f',typ=(listr8_sdaster) ),
INST = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
b_info=BLOC(condition="(INFO==2)",
- fr="filtre les messages émis dans le .mess selon le type de message demandé",
+ fr="filtre les messages emis dans le .mess selon le type de message demande",
INFO_DBG = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(),
into=("CONTACT",
"MECA_NON_LINE",
# ======================================================================
# person_in_charge: irmela.zentner at edf.fr
CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=interspectre,
- fr="Calcul d'une matrice interspectrale à partir d'une fonction du temps",
+ fr="Calcul d'une matrice interspectrale a partir d'une fonction du temps",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
INST_INIT =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
TYPE_MAINTIEN = SIMP(statut='o',typ='TXM',into=("FORCE","DEPL_PSC"), ),
b_maintien_mono_force = BLOC(condition = "TYPE_MAINTIEN == 'FORCE'",
- fr="valeur de l'effort de maintien imposée",
+ fr="valeur de l'effort de maintien imposee",
FORCE_MAINTIEN =SIMP(statut='o',typ='R', max=1),),
),
- # choix du maintien dans le cas d'un coeur à plusieurs assemblages
+ # choix du maintien dans le cas d'un coeur a plusieurs assemblages
b_maintien_coeur = BLOC(condition = "TYPE_COEUR != 'MONO'",
TYPE_MAINTIEN = SIMP(statut='f',typ='TXM',into=("DEPL_PSC",),defaut="DEPL_PSC" ),
# ======================================================================
# person_in_charge: nicolas.greffet at edf.fr
CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r,
- fr="Calcul des matrices de masse, d'amortissement ou de rigidité ajoutés",
+ fr="Calcul des matrices de masse, d'amortissement ou de rigidite ajoutes",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(EXCLUS('MODE_MECA','CHAM_NO','MODELE_GENE'),
raise AsException("type de concept resultat non prevu")
CALC_MATR_ELEM=OPER(nom="CALC_MATR_ELEM",op= 9,sd_prod=calc_matr_elem_prod
- ,fr="Calcul des matrices élémentaires",reentrant='n',
+ ,fr="Calcul des matrices elementaires",reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
OPTION =SIMP(statut='o',typ='TXM',
"MASS_ACOU","AMOR_ACOU","RIGI_MECA_HYST") ),
MODELE =SIMP(statut='o',typ=modele_sdaster ),
- # mots clés facultatifs que l'on a du mal à mettre dans les blocs
+ # mots cles facultatifs que l'on a du mal a mettre dans les blocs
# sans gener MACRO_MATR_ASSE :
#------------------------------------------------------------------
INST=SIMP(statut='f',typ='R',defaut= 0.E+0 ),
# person_in_charge: renaud.bargellini at edf.fr
CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o',
UIinfo={"groupes":("Post-traitements","Thermique",)},
- fr="Calcule l'évolution métallurgique à partir du résultat d'un calcul thermique",
+ fr="Calcule l'evolution metallurgique a partir du resultat d'un calcul thermique",
regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="le calcul ne sera effectué que sur ces mailles là"),
+ fr="le calcul ne sera effectue que sur ces mailles la"),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**',
- fr="le calcul ne sera effectué que sur ces mailles là"),
+ fr="le calcul ne sera effectue que sur ces mailles la"),
b_meta =BLOC(condition= "au_moins_un(OPTION, ('META_ELNO','META_NOEU'))",
ETAT_INIT =FACT(statut='o',
# person_in_charge: mathieu.courtois at edf.fr
def calc_miss_sdprod(self, TYPE_RESU, **kwargs):
- """Typage des structures de données produites"""
+ """Typage des structures de donnees produites"""
if TYPE_RESU in ('TABLE', 'TABLE_CONTROL'):
return table_sdaster
elif TYPE_RESU == 'HARM_GENE':
CALC_MISS = MACRO(nom="CALC_MISS",
op=OPS('Macro.calc_miss_ops.calc_miss_ops'),
sd_prod=calc_miss_sdprod,
- fr="Préparation des données, exécution du logiciel Miss3D, et post-traitement",
- UIinfo={"groupes":("Résolution","Outils-métier",)},
+ fr="Preparation des donnees, execution du logiciel Miss3D, et post-traitement",
+ UIinfo={"groupes":("Resolution","Outils-metier",)},
TYPE_RESU = SIMP(statut='o', typ='TXM',
into=('HARM_GENE', 'TRAN_GENE', 'TABLE', 'TABLE_CONTROL',
'FICHIER', 'FICHIER_TEMPS'),
- fr="Type de résultat produit en post-traitement. FICHIER : pas de post-traitement"),
+ fr="Type de resultat produit en post-traitement. FICHIER : pas de post-traitement"),
PROJET = SIMP(statut='f', typ='TXM', defaut='MODELE',
- fr="Nom de l'étude Miss"),
+ fr="Nom de l'etude Miss"),
REPERTOIRE = SIMP(statut='f', typ='TXM',
- fr="Répertoire de travail de Miss"),
+ fr="Repertoire de travail de Miss"),
VERSION = SIMP(statut='f', typ='TXM', into=("V6.6","V6.5"), defaut="V6.6",
- fr="Version de Miss utilisée"),
+ fr="Version de Miss utilisee"),
TABLE_SOL = SIMP(statut='o', typ=table_sdaster,
- fr="Table des propriétés du sol"),
+ fr="Table des proprietes du sol"),
# pas de post-traitement
b_basic = BLOC(condition="TYPE_RESU in ('FICHIER', 'TABLE_CONTROL')",
regles=(UN_PARMI('MACR_ELEM_DYNA', 'BASE_MODALE'),
ENSEMBLE('GROUP_MA_FLU_STR', 'GROUP_MA_FLU_SOL', 'GROUP_MA_SOL_SOL'),),
MACR_ELEM_DYNA = SIMP(statut='f', typ=macr_elem_dyna,
- fr="Macro élément produit en amont"),
+ fr="Macro element produit en amont"),
BASE_MODALE = SIMP(statut='f', typ=mode_meca,
fr="Base de modes"),
b_base_modale = BLOC(condition="BASE_MODALE is not None",
GROUP_MA_SOL_SOL = SIMP(statut='f', typ=grma, max='**',
fr="Groupe de mailles sol-sol"),
UNITE_IMPR_ASTER = SIMP(statut='f', typ='I',
- fr="Unité des résultats transmis par Code_Aster à Miss"),
+ fr="Unite des resultats transmis par Code_Aster a Miss"),
UNITE_RESU_IMPE = SIMP(statut='f', typ='I',
- fr="Unité logique des impédances écrites par Miss"),
+ fr="Unite logique des impedances ecrites par Miss"),
UNITE_RESU_FORC = SIMP(statut='f', typ='I',
- fr="Unité logique des forces sismiques écrites par Miss"),
+ fr="Unite logique des forces sismiques ecrites par Miss"),
),
# post-traitement : passage du domaine de Laplace au domaine temporel
b_fichier_temps = BLOC(condition="TYPE_RESU == 'FICHIER_TEMPS'",
PRESENT_PRESENT('UNITE_RESU_AMOR', 'MATR_GENE'),
PRESENT_PRESENT('UNITE_RESU_MASS', 'MATR_GENE'),),
MACR_ELEM_DYNA = SIMP(statut='f', typ=macr_elem_dyna,
- fr="Macro élément produit en amont"),
+ fr="Macro element produit en amont"),
BASE_MODALE = SIMP(statut='f', typ=mode_meca,
fr="Base de modes"),
b_base_modale = BLOC(condition="BASE_MODALE is not None",
GROUP_MA_INTERF = SIMP(statut='o', typ=grma, max='**',
fr="Groupe de mailles de l'interface"),
UNITE_IMPR_ASTER = SIMP(statut='f', typ='I',
- fr="Unité des résultats transmis par Code_Aster à Miss"),
+ fr="Unite des resultats transmis par Code_Aster a Miss"),
UNITE_RESU_RIGI =SIMP(statut='f',typ='I'),
UNITE_RESU_AMOR =SIMP(statut='f',typ='I'),
UNITE_RESU_MASS =SIMP(statut='f',typ='I'),
EXCIT_SOL =FACT(statut='f', max = 1,
regles = (AU_MOINS_UN('CHAM_X','CHAM_Y','CHAM_Z'),),
UNITE_RESU_FORC =SIMP(statut='o',typ='I',
- fr="Unité logique des forces sismiques écrites par Miss"),
+ fr="Unite logique des forces sismiques ecrites par Miss"),
NOM_CHAM =SIMP(statut='f',typ='TXM',defaut='DEPL',
into=('ACCE','VITE','DEPL') ),
CHAM_X = SIMP(statut='f', typ=fonction_sdaster,),
regles=(ENSEMBLE('GROUP_MA_FLU_STR', 'GROUP_MA_FLU_SOL', 'GROUP_MA_SOL_SOL'),
UN_PARMI('MATR_AMOR', 'AMOR_REDUIT'),),
MACR_ELEM_DYNA = SIMP(statut='f', typ=macr_elem_dyna,
- fr="Macro élément produit en amont"),
+ fr="Macro element produit en amont"),
BASE_MODALE = SIMP(statut='o', typ=mode_meca,
fr="Base de modes"),
MATR_RIGI = SIMP(statut='o', typ=(matr_asse_depl_r, matr_asse_depl_c),),
GROUP_MA_SOL_SOL = SIMP(statut='f', typ=grma, max='**',
fr="Groupe de mailles sol-sol"),
UNITE_IMPR_ASTER = SIMP(statut='f', typ='I',
- fr="Unité des résultats transmis par Code_Aster à Miss"),
+ fr="Unite des resultats transmis par Code_Aster a Miss"),
UNITE_RESU_IMPE = SIMP(statut='f', typ='I',
- fr="Unité logique des impédances à relire."),
+ fr="Unite logique des impedances a relire."),
UNITE_RESU_FORC = SIMP(statut='f', typ='I',
- fr="Unité logique des forces sismiques à relire"),
+ fr="Unite logique des forces sismiques a relire"),
),
- # Paramètres du calcul Miss
+ # Parametres du calcul Miss
PARAMETRE = FACT(statut='o',
regles=(PRESENT_PRESENT('OFFSET_MAX', 'OFFSET_NB'),
PRESENT_PRESENT('FREQ_MIN', 'FREQ_MAX','FREQ_PAS'),
DEPL_Z = SIMP(statut='f', typ=fonction_sdaster,),
INST_FIN = SIMP(statut='f', typ='R', fr="Instant final du calcul"),
PAS_INST = SIMP(statut='f', typ='R', fr="Pas de temps du calcul"),
- # identique à EXCIT de DYNA_LINE_HARM au type attendu pour VECT_ASSE près
+ # identique a EXCIT de DYNA_LINE_HARM au type attendu pour VECT_ASSE pres
EXCIT_HARMO = FACT(statut='f', max='**',
regles=(UN_PARMI('VECT_ASSE', 'CHARGE'),
UN_PARMI('FONC_MULT', 'FONC_MULT_C', 'COEF_MULT', 'COEF_MULT_C'),),
AMOR_SPEC_OSCI = SIMP(statut='o', typ='R', max='**',
fr="Amortissement du spectre d'oscillateur"),
LIST_FREQ_SPEC_OSCI = SIMP(statut='f', typ=listr8_sdaster,
- fr="Fréquences utilisées pour le calcul du spectre d'oscillateur"),
+ fr="Frequences utilisees pour le calcul du spectre d'oscillateur"),
),
# Post-traitement type 3 - points de controle
PRESENT_PRESENT('ACCE_Z', 'INST_FIN'),
ENSEMBLE('INST_FIN', 'PAS_INST', 'NORME', 'AMOR_SPEC_OSCI'),),
GROUP_MA_CONTROL = SIMP(statut='f', typ=grma, max='**',
- fr="Groupe de mailles des points de contrôle"),
+ fr="Groupe de mailles des points de controle"),
ACCE_X = SIMP(statut='f', typ=fonction_sdaster,),
ACCE_Y = SIMP(statut='f', typ=fonction_sdaster,),
ACCE_Z = SIMP(statut='f', typ=fonction_sdaster,),
AMOR_SPEC_OSCI = SIMP(statut='f', typ='R', max='**',
fr="Amortissement du spectre d'oscillateur"),
LIST_FREQ_SPEC_OSCI = SIMP(statut='f', typ=listr8_sdaster,
- fr="Fréquences utilisées pour le calcul du spectre d'oscillateur"),
+ fr="Frequences utilisees pour le calcul du spectre d'oscillateur"),
),
INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2)),
CALC_MODAL=MACRO(nom="CALC_MODAL",
op=OPS('Macro.calc_modal_ops.calc_modal_ops'),
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
sd_prod=calc_modal_prod,
fr="Calcul des modes propres reels ou complexes dans une seule commande",
MODELE =SIMP(statut='o',typ=modele_sdaster),
TYPE_QZ =SIMP(statut='f',typ='TXM',defaut="QZ_SIMPLE",into=("QZ_QR","QZ_SIMPLE","QZ_EQUI") ),
),
MODE_RIGIDE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
- fr="Calcul des modes de corps rigide, uniquement pour la méthode TRI_DIAG" ),
+ fr="Calcul des modes de corps rigide, uniquement pour la methode TRI_DIAG" ),
CALC_FREQ =FACT(statut='d',min=0,
OPTION =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","PLUS_GRANDE","BANDE","CENTRE","TOUT"),
- fr="Choix de l option et par conséquent du shift du problème modal" ),
- b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites fréquences propres",
+ fr="Choix de l option et par consequent du shift du probleme modal" ),
+ b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites frequences propres",
NMAX_FREQ =SIMP(statut='f',typ='I',defaut=10,val_min=0 ),
),
- b_plus_grande =BLOC(condition = "OPTION == 'PLUS_GRANDE'",fr="Recherche des plus grandes fréquences propres",
+ b_plus_grande =BLOC(condition = "OPTION == 'PLUS_GRANDE'",fr="Recherche des plus grandes frequences propres",
NMAX_FREQ =SIMP(statut='f',typ='I',defaut=1,val_min=0 ),
),
b_centre =BLOC(condition = "OPTION == 'CENTRE'",
- fr="Recherche des fréquences propres les plus proches d une valeur donnée",
+ fr="Recherche des frequences propres les plus proches d une valeur donnee",
FREQ =SIMP(statut='o',typ='R',
- fr="Fréquence autour de laquelle on cherche les fréquences propres"),
+ fr="Frequence autour de laquelle on cherche les frequences propres"),
AMOR_REDUIT =SIMP(statut='f',typ='R',),
NMAX_FREQ =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
),
b_bande =BLOC(condition = "(OPTION == 'BANDE')",
- fr="Recherche des fréquences propres dans une bande donnée",
+ fr="Recherche des frequences propres dans une bande donnee",
FREQ =SIMP(statut='o',typ='R',min=2,validators=NoRepeat(),max=2,
- fr="Valeurs des deux fréquences délimitant la bande de recherche"),
+ fr="Valeurs des deux frequences delimitant la bande de recherche"),
),
APPROCHE =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG","COMPLEXE"),
- fr="Choix du pseudo-produit scalaire pour la résolution du problème quadratique" ),
+ fr="Choix du pseudo-produit scalaire pour la resolution du probleme quadratique" ),
regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
op=OPS('Macro.calc_mode_rotation_ops.calc_mode_rotation_ops'),
sd_prod=table_container,
reentrant='n',
- fr="calculer les fréquences et modes d'un système en fonction des " \
+ fr="calculer les frequences et modes d'un systeme en fonction des " \
"vitesses de rotation",
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
MATR_RIGI =SIMP(statut='o',typ=matr_asse_depl_r ),
MATR_MASS =SIMP(statut='o',typ=matr_asse_depl_r ),
CALC_FREQ =FACT(statut='d',min=0,
OPTION =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","CENTRE",),
- fr="Choix de l option et par conséquent du shift du problème modal" ),
+ fr="Choix de l option et par consequent du shift du probleme modal" ),
b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites valeurs propres",
NMAX_FREQ =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
),
b_centre =BLOC(condition = "OPTION == 'CENTRE'",
- fr="Recherche des valeurs propres les plus proches d une valeur donnée",
+ fr="Recherche des valeurs propres les plus proches d une valeur donnee",
FREQ =SIMP(statut='o',typ='R',
- fr="Fréquence autour de laquelle on cherche les fréquences propres"),
+ fr="Frequence autour de laquelle on cherche les frequences propres"),
AMOR_REDUIT =SIMP(statut='f',typ='R',),
NMAX_FREQ =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
),
# ======================================================================
# person_in_charge: jean-michel.proix at edf.fr
CALC_POINT_MAT=OPER(nom="CALC_POINT_MAT",op=33,sd_prod=table_sdaster,reentrant='f',
- UIinfo={"groupes":("Résolution",)},
- fr="Intégrer une loi de comportement",
+ UIinfo={"groupes":("Resolution",)},
+ fr="Integrer une loi de comportement",
MATER =SIMP(statut='o',typ=mater_sdaster,max=1),
COMPORTEMENT =C_COMPORTEMENT('CALC_POINT_MAT'),
INCREMENT =C_INCREMENT('MECANIQUE'),
ANGL_REP =SIMP(statut='f',typ='R',min=1,max=3),
ANGL_EULER =SIMP(statut='f',typ='R',min=1,max=3),
),
- ## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations imposées.
+ ## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les deformations imposees.
ANGLE =SIMP(statut='f',typ='R',max=1, defaut=0.),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2)),
),
- # on permet certaines variables de commandes scalaires, définies par une fonction du temps
- # un mot clé caché qui ne sert qu'à boucler sur les VARC possibles :
+ # on permet certaines variables de commandes scalaires, definies par une fonction du temps
+ # un mot cle cache qui ne sert qu'a boucler sur les VARC possibles :
LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP","CORR","IRRA","HYDR","SECH","EPSA",
"M_ACIER","M_ZIRC","NEUT1","NEUT2")),
"EPSA","NEUT1","NEUT2")),
VALE_FONC = SIMP(statut='o',typ=(fonction_sdaster,formule) ),
- # VALE_REF est nécessaire pour certaines VARC :
+ # VALE_REF est necessaire pour certaines VARC :
B_VALE_REF =BLOC(condition="NOM_VARC in ('TEMP', 'SECH')",
VALE_REF =SIMP(statut='o',typ='R'),
),
CALC_PRECONT=MACRO(nom="CALC_PRECONT",
op=OPS('Macro.calc_precont_ops.calc_precont_ops'),
sd_prod=evol_noli,
- fr="Imposer la tension définie par le BPEL dans les cables",
- reentrant='f',UIinfo={"groupes":("Modélisation",)},
+ fr="Imposer la tension definie par le BPEL dans les cables",
+ reentrant='f',UIinfo={"groupes":("Modelisation",)},
reuse =SIMP(statut='f',typ='evol_noli'),
MODELE =SIMP(statut='o',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='o',typ=cham_mater),
# ======================================================================
CALC_STABILITE=MACRO(nom="CALC_STABILITE",sd_prod=table_container,
op=OPS('Macro.calc_stabilite_ops.calc_stabilite_ops'),
- fr="post-traitement modes non-linéaires : filtre resultats et calcul de stabilité",
+ fr="post-traitement modes non-lineaires : filtre resultats et calcul de stabilite",
reentrant='f',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
reuse =SIMP(statut='f',typ='table_container'),
dmc = mcf.cree_dict_valeurs(mcf.mc_liste)
if dmc.get('TABLE') != None:
l_typ.append(AsType(dmc['TABLE']))
- # une table_fonction étant une table
+ # une table_fonction etant une table
if table_fonction in l_typ:
return table_fonction
elif table_container in l_typ:
CALC_TABLE=MACRO(nom="CALC_TABLE",
op=OPS('Macro.calc_table_ops.calc_table_ops'),
sd_prod=calc_table_prod,
- fr="Opérations sur une table",
+ fr="Operations sur une table",
UIinfo={"groupes":("Tables",)},
reentrant='f',
TABLE = SIMP(statut='o',typ=table_sdaster),
ACTION = FACT(statut='o', max='**',
- fr = "Suite des opérations à effectuer sur la table",
+ fr = "Suite des operations a effectuer sur la table",
OPERATION = SIMP(statut='o', typ='TXM',
into=('FILTRE', 'EXTR', 'RENOMME', 'TRI', 'COMB', 'AJOUT_LIGNE',
'OPER', 'SUPPRIME', 'AJOUT_COLONNE')),
b_filtre = BLOC(condition="OPERATION == 'FILTRE'",
- fr="Sélectionne les lignes de la table vérifiant un critère",
+ fr="Selectionne les lignes de la table verifiant un critere",
NOM_PARA = SIMP(statut='o',typ='TXM'),
CRIT_COMP = SIMP(statut='f',typ='TXM',defaut="EQ",
into=('EQ','NE','GT','LT','GE','LE','REGEXP',
b_extr = BLOC(condition="OPERATION == 'EXTR'",
fr="Extrait une ou plusieurs colonnes de la table",
NOM_PARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
- fr="Noms des colonnes à extraire"),
+ fr="Noms des colonnes a extraire"),
),
b_suppr = BLOC(condition="OPERATION == 'SUPPRIME'",
fr="Supprime une ou plusieurs colonnes de la table",
NOM_PARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
- fr="Noms des colonnes à supprimer"),
+ fr="Noms des colonnes a supprimer"),
),
b_renomme = BLOC(condition="OPERATION == 'RENOMME'",
- fr="Renomme un ou plusieurs paramètres de la table",
+ fr="Renomme un ou plusieurs parametres de la table",
NOM_PARA = SIMP(statut='o', typ='TXM', validators=NoRepeat(), min=2, max=2,
- fr="Couple (ancien nom du paramètre, nouveau nom du paramètre)",),
+ fr="Couple (ancien nom du parametre, nouveau nom du parametre)",),
),
b_tri = BLOC(condition="OPERATION == 'TRI'",
- fr="Ordonne les lignes de la table selon les valeurs d'un ou plusieurs paramètres",
+ fr="Ordonne les lignes de la table selon les valeurs d'un ou plusieurs parametres",
NOM_PARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
ORDRE = SIMP(statut='f',typ='TXM',defaut="CROISSANT",
into=("CROISSANT","DECROISSANT") ),
),
b_comb = BLOC(condition="OPERATION == 'COMB'",
- fr="Combine deux tables ayant éventuellement des paramètres communs",
+ fr="Combine deux tables ayant eventuellement des parametres communs",
TABLE = SIMP(statut='o',typ=table_sdaster,
fr="Table dont les colonnes vont venir surcharger la table initiale"),
NOM_PARA = SIMP(statut='f',typ='TXM',max='**',
- fr="Noms des paramètres dont les valeurs doivent etre identiques dans les deux tables "\
- "pour que les colonnes soient combinées"),
+ fr="Noms des parametres dont les valeurs doivent etre identiques dans les deux tables "\
+ "pour que les colonnes soient combinees"),
RESTREINT = SIMP(statut='f', typ='TXM', into=('OUI', 'NON'), defaut='NON',
- fr="Restreint la fusion uniquement aux lignes où les NOM_PARA sont communs"),
+ fr="Restreint la fusion uniquement aux lignes ou les NOM_PARA sont communs"),
FORMAT_R =SIMP(statut='f',typ='TXM'),
),
b_ajout_lig = BLOC(condition="OPERATION == 'AJOUT_LIGNE'",
- fr="Ajoute une ligne à la table initiale",
+ fr="Ajoute une ligne a la table initiale",
NOM_PARA = SIMP(statut='o',typ='TXM',max='**',
- fr="Noms des paramètres dont les valeurs sont fournies sous VALE"),
- VALE = SIMP(statut='o',typ=not_checked,max='**', fr='Valeurs des paramètres'),
+ fr="Noms des parametres dont les valeurs sont fournies sous VALE"),
+ VALE = SIMP(statut='o',typ=not_checked,max='**', fr='Valeurs des parametres'),
),
b_ajout_col = BLOC(condition="OPERATION == 'AJOUT_COLONNE'",
- fr="Ajoute une colonne constante à la table initiale",
+ fr="Ajoute une colonne constante a la table initiale",
NOM_PARA = SIMP(statut='o',typ='TXM',max='**',
- fr="Noms des paramètres des colonnes à ajouter"),
+ fr="Noms des parametres des colonnes a ajouter"),
VALE = SIMP(statut='o', typ=not_checked, max='**',
fr="Valeur constante pour chaque colonne"),
),
b_oper = BLOC(condition="OPERATION == 'OPER'",
- fr="Applique une formule dans laquelle les variables sont les paramètres de la table",
+ fr="Applique une formule dans laquelle les variables sont les parametres de la table",
FORMULE = SIMP(statut='o',typ=formule,
- fr="Formule à appliquer aux colonnes de la table"),
+ fr="Formule a appliquer aux colonnes de la table"),
NOM_PARA = SIMP(statut='o',typ='TXM',
fr="Nom de la nouvelle colonne"),
NOM_COLONNE = SIMP(statut='f',typ='TXM', max='**',
- fr="Nom des colonnes à utiliser en tant que paramètres de la formule"),
+ fr="Nom des colonnes a utiliser en tant que parametres de la formule"),
),
),
CALC_THETA=OPER(nom="CALC_THETA",op=54,sd_prod=theta_geom,reentrant='n',
UIinfo={"groupes":("Post-traitements","Rupture",)},
- fr="Définir un champ theta pour le calcul du taux de restitution d'énergie"
- +" ou des facteurs d'intensité de contraintes",
+ fr="Definir un champ theta pour le calcul du taux de restitution d'energie"
+ +" ou des facteurs d'intensite de contraintes",
regles=(UN_PARMI('THETA_2D','THETA_3D'),
PRESENT_ABSENT('THETA_2D','DIRE_THETA'),
EXCLUS('DIRECTION','DIRE_THETA'),),
CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
- fr="Calcul des seconds membres élémentaires",
+ fr="Calcul des seconds membres elementaires",
OPTION =SIMP(statut='o',typ='TXM',into=("CHAR_MECA","CHAR_THER","CHAR_ACOU") ),
b_char_meca =BLOC(condition = "OPTION=='CHAR_MECA'",
regles=(AU_MOINS_UN('CHARGE','MODELE'),),
CHARGE =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
MODELE =SIMP(statut='f',typ=modele_sdaster),
- b_charge =BLOC(condition = "CHARGE != None", fr="modèle ne contenant pas de sous-structure",
+ b_charge =BLOC(condition = "CHARGE != None", fr="modele ne contenant pas de sous-structure",
CHAM_MATER =SIMP(statut='f',typ=cham_mater),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
INST =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
MODE_FOURIER =SIMP(statut='f',typ='I',defaut= 0 ),
),
- b_modele =BLOC(condition = "(MODELE != None)",fr="modèle contenant une sous-structure",
+ b_modele =BLOC(condition = "(MODELE != None)",fr="modele contenant une sous-structure",
SOUS_STRUC =FACT(statut='o',min=01,
regles=(UN_PARMI('TOUT','SUPER_MAILLE'),),
CAS_CHARGE =SIMP(statut='o',typ='TXM' ),
# person_in_charge: mickael.abbas at edf.fr
CALCUL=OPER(nom="CALCUL",op=26,sd_prod=table_container,reentrant='f',
- UIinfo={"groupes":("Résolution",)},
- fr="Calculer des objets élémentaires comme une matrice tangente, intégrer une loi de comportement, etc...",
+ UIinfo={"groupes":("Resolution",)},
+ fr="Calculer des objets elementaires comme une matrice tangente, integrer une loi de comportement, etc...",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="COMPORTEMENT",
into=( "COMPORTEMENT","MATR_TANG_ELEM","FORC_INTE_ELEM","FORC_NODA_ELEM"),),
MODELE =SIMP(statut='o',typ=modele_sdaster),
op=OPS('Macro.chainage_thm_ops.chainage_thm_ops'),
sd_prod=chainage_thm_prod,
reentrant='n',
- UIinfo={"groupes":("Résultats et champs",)},
+ UIinfo={"groupes":("Resultats et champs",)},
docu="Ux.xx.xx",
- fr="Calcul des variables de commande pour le chaînage THM",
+ fr="Calcul des variables de commande pour le chainage THM",
TYPE_CHAINAGE = SIMP(statut='o',typ='TXM',
into=("HYDR_MECA","MECA_HYDR","INIT",),
- fr="Sens du chaînage ou initialisation des matrices de projection"),
+ fr="Sens du chainage ou initialisation des matrices de projection"),
# Cas HYDR_MECA :
- b_hydr_meca = BLOC(condition = "TYPE_CHAINAGE == 'HYDR_MECA'",fr="Chaînage hydraulique vers mécanique",
+ b_hydr_meca = BLOC(condition = "TYPE_CHAINAGE == 'HYDR_MECA'",fr="Chainage hydraulique vers mecanique",
- RESU_HYDR = SIMP(statut='o',typ=resultat_sdaster,fr="Résultat hydraulique à chaîner" ),
- MODELE_MECA = SIMP(statut='o',typ=modele_sdaster ,fr="Modèle d'arrivée mécanique"),
+ RESU_HYDR = SIMP(statut='o',typ=resultat_sdaster,fr="Resultat hydraulique a chainer" ),
+ MODELE_MECA = SIMP(statut='o',typ=modele_sdaster ,fr="Modele d'arrivee mecanique"),
TYPE_RESU = SIMP(statut='f',typ='TXM',into=("EVOL_VARC","CHAM_NO"),defaut="EVOL_VARC", ),
MATR_HM1 = SIMP(statut='o',typ=corresp_2_mailla,),
MATR_HM2 = SIMP(statut='o',typ=corresp_2_mailla,),
# Cas MECA_HYDR :
- b_meca_hydr = BLOC(condition = "TYPE_CHAINAGE == 'MECA_HYDR'",fr="Chaînage mécanique vers hydraulique",
+ b_meca_hydr = BLOC(condition = "TYPE_CHAINAGE == 'MECA_HYDR'",fr="Chainage mecanique vers hydraulique",
- RESU_MECA = SIMP(statut='o',typ=resultat_sdaster,fr="Résultat mécanique à chaîner" ),
- MODELE_HYDR = SIMP(statut='o',typ=modele_sdaster ,fr="Modèle d'arrivée hydraulique"),
+ RESU_MECA = SIMP(statut='o',typ=resultat_sdaster,fr="Resultat mecanique a chainer" ),
+ MODELE_HYDR = SIMP(statut='o',typ=modele_sdaster ,fr="Modele d'arrivee hydraulique"),
MATR_MH = SIMP(statut='o',typ=corresp_2_mailla,),
INST = SIMP(statut='o',typ='R',validators=NoRepeat(),min=1,max=1),
b_init = BLOC(condition = "TYPE_CHAINAGE == 'INIT'",fr="Calcul des matrices de projection",
- MODELE_MECA = SIMP(statut='o',typ=modele_sdaster ,fr="Modèle mécanique"),
- MODELE_HYDR = SIMP(statut='o',typ=modele_sdaster ,fr="Modèle hydraulique"),
+ MODELE_MECA = SIMP(statut='o',typ=modele_sdaster ,fr="Modele mecanique"),
+ MODELE_HYDR = SIMP(statut='o',typ=modele_sdaster ,fr="Modele hydraulique"),
MATR_MH = SIMP(statut='o',typ=CO,),
MATR_HM1 = SIMP(statut='o',typ=CO,),
# ======================================================================
# person_in_charge: xavier.desroches at edf.fr
COMB_FOURIER=OPER(nom="COMB_FOURIER",op= 161,sd_prod=comb_fourier,
- reentrant='n',fr="Recombiner les modes de Fourier d'une SD Résultat dans des directions particulières",
+ reentrant='n',fr="Recombiner les modes de Fourier d'une SD Resultat dans des directions particulieres",
UIinfo={"groupes":("Post-traitements",)},
RESULTAT =SIMP(statut='o',typ=(fourier_elas,fourier_ther),),
ANGLE =SIMP(statut='o',typ='R',max='**'),
raise AsException("type de concept resultat non prevu")
COMB_MATR_ASSE=OPER(nom="COMB_MATR_ASSE",op= 31,sd_prod=comb_matr_asse_prod,
- fr="Effectuer la combinaison linéaire de matrices assemblées",
+ fr="Effectuer la combinaison lineaire de matrices assemblees",
reentrant='f',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(UN_PARMI('COMB_R','COMB_C','CALC_AMOR_GENE' ),),
# ======================================================================
# person_in_charge: sylvie.audebert at edf.fr
COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca,
- fr="Réponse sismique par recombinaison modale par une méthode spectrale",
+ fr="Reponse sismique par recombinaison modale par une methode spectrale",
reentrant='n',
UIinfo={"groupes":("Post-traitements","Dynamique",)},
regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','FREQ','NUME_MODE','LIST_FREQ','LIST_ORDRE'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),)
),
MONO_APPUI =SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="excitation imposée unique" ),
+ fr="excitation imposee unique" ),
MULTI_APPUI =SIMP(statut='f',typ='TXM',position='global',into=("DECORRELE","CORRELE"),
- fr="excitation imposée unique" ),
+ fr="excitation imposee unique" ),
b_decorrele =BLOC(condition = "MULTI_APPUI == 'DECORRELE' ",
GROUP_APPUI =FACT(statut='f',max='**',
regles=(UN_PARMI('NOEUD','GROUP_NO' ),),
CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod,
- fr="Création d'un champ ",reentrant='f',
- UIinfo={"groupes":("Résultats et champs",)},
+ fr="Creation d'un champ ",reentrant='f',
+ UIinfo={"groupes":("Resultats et champs",)},
# TYPE_CHAM doit etre de la forme : CART_xx, NOEU_xx, ELEM_xx, ELGA_xx ou ELNO_xx
- # ou xx est le nom d'une grandeur définie dans le catalogue des grandeurs
+ # ou xx est le nom d'une grandeur definie dans le catalogue des grandeurs
TYPE_CHAM =SIMP(statut='o',typ='TXM',into=C_TYPE_CHAM_INTO()),
# SI CREATION D'UN CHAM_NO, POUR IMPOSER LA NUMEROTATION DES DDLS :
),
# ------------------------------------------------------------------
b_comb =BLOC(condition = "OPERATION == 'COMB'",
- fr="Pour faire une combinaison linéaire de cham_no ayant meme profil",
+ fr="Pour faire une combinaison lineaire de cham_no ayant meme profil",
COMB =FACT(statut='o',max='**',
CHAM_GD =SIMP(statut='o',typ=cham_no_sdaster),
COEF_R =SIMP(statut='o',typ='R'),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO()),
TYPE_MAXI =SIMP(statut='f',typ='TXM',into=("MAXI","MINI","MAXI_ABS","MINI_ABS","NORM_TRAN",) ),
- # si TYPE_MAXI, on spécifie en général plusieurs numéros d'ordre :
+ # si TYPE_MAXI, on specifie en general plusieurs numeros d'ordre :
b_type_maxi =BLOC(condition = "TYPE_MAXI != None",
TYPE_RESU =SIMP(statut='o',typ='TXM',defaut="VALE",into=("VALE","INST",) ),
ANGLE =SIMP(statut='f',typ='R',max='**'),
),
- # si .not. TYPE_MAXI, on ne doit spécifier qu'un seul numéro d'ordre :
+ # si .not. TYPE_MAXI, on ne doit specifier qu'un seul numero d'ordre :
b_non_type_maxi =BLOC(condition = "TYPE_MAXI == None",
regles=(EXCLUS('NUME_ORDRE','INST','FREQ','NUME_MODE','NOEUD_CMP','NOM_CAS','ANGLE'),),
NUME_ORDRE =SIMP(statut='f',typ='I'),
# ======================================================================
# person_in_charge: jacques.pellet at edf.fr
CREA_MAILLAGE=OPER(nom="CREA_MAILLAGE",op= 167,sd_prod=maillage_sdaster,
- reentrant='n',fr="Crée un maillage à partir d'un maillage existant",
+ reentrant='n',fr="Cree un maillage a partir d'un maillage existant",
UIinfo={"groupes":("Maillage",)},
regles=(UN_PARMI('COQU_VOLU', 'CREA_FISS', 'CREA_GROUP_MA', 'CREA_MAILLE', 'CREA_POI1',
'DETR_GROUP_MA', 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE',
MAILLAGE =SIMP(statut='f',typ=maillage_sdaster ),
GEOM_FIBRE = SIMP(statut='f',max=1,typ=gfibre_sdaster),
- CREA_POI1 =FACT(statut='f',max='**',fr="Création de mailles de type POI1 à partir de noeuds",
+ CREA_POI1 =FACT(statut='f',max='**',fr="Creation de mailles de type POI1 a partir de noeuds",
regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD' ),),
NOM_GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
PREF_MAILLE =SIMP(statut='o',typ='TXM' ),
PREF_NUME =SIMP(statut='f',typ='I' ),
),
- CREA_GROUP_MA =FACT(statut='f',max='**',fr="Duplication de mailles et création de groupes de mailles",
+ CREA_GROUP_MA =FACT(statut='f',max='**',fr="Duplication de mailles et creation de groupes de mailles",
regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
NOM =SIMP(statut='o',typ='TXM'),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
DETR_GROUP_MA =FACT(statut='f',fr="Destruction de groupes de mailles",
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
NB_MAILLE =SIMP(statut='f',typ='I',defaut= 0,
- fr="Nombre minimal de mailles que doit contenir le groupe pour etre détruit", ),
+ fr="Nombre minimal de mailles que doit contenir le groupe pour etre detruit", ),
),
- RESTREINT =FACT(statut='f',fr="Restreindre un maillage à des groupes de mailles",max=1,
+ RESTREINT =FACT(statut='f',fr="Restreindre un maillage a des groupes de mailles",max=1,
regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
TOUT_GROUP_NO =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
),
COQU_VOLU =FACT(statut='f',
- fr="Creation de mailles volumiques à partir de mailles surfaciques",
+ fr="Creation de mailles volumiques a partir de mailles surfaciques",
NOM =SIMP(statut='o',typ='TXM'),
GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max ='**'),
EPAIS =SIMP(statut='o',typ='R' ),
PREF_NUME =SIMP(statut='f',typ='I',defaut= 1 ),
),
),
- CREA_FISS = FACT(statut='f',max='**',fr="Creation d'une fissure potentielle avec elts de joint ou elts à disc",
+ CREA_FISS = FACT(statut='f',max='**',fr="Creation d'une fissure potentielle avec elts de joint ou elts a disc",
NOM =SIMP(statut='o',typ='TXM'),
GROUP_NO_1 =SIMP(statut='o',typ=grno),
GROUP_NO_2 =SIMP(statut='o',typ=grno),
PREF_MAILLE =SIMP(statut='o',typ='TXM'),
PREF_NUME =SIMP(statut='f',typ='I',defaut=1 ),
),
- LINE_QUAD =FACT(statut='f',fr="Passage linéaire -> quadratique",
+ LINE_QUAD =FACT(statut='f',fr="Passage lineaire -> quadratique",
regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
PREF_NOEUD =SIMP(statut='f',typ='TXM',defaut="NS"),
PREF_NUME =SIMP(statut='f',typ='I',defaut= 1 ),
),
- QUAD_LINE =FACT(statut='f',fr="Passage quadratique -> linéaire",
+ QUAD_LINE =FACT(statut='f',fr="Passage quadratique -> lineaire",
regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
),
REPERE =FACT(statut='f',max='**',
- fr="changement de repère servant à déterminer les caractéristiques d'une section de poutre",
+ fr="changement de repere servant a determiner les caracteristiques d'une section de poutre",
TABLE =SIMP(statut='o',typ=table_sdaster,
- fr="Nom de la table contenant les caractéristiques de la section de poutre" ),
- NOM_ORIG =SIMP(statut='f',typ='TXM',into=("CDG","TORSION"),fr="Origine du nouveau repère" ),
- NOM_ROTA =SIMP(statut='f',typ='TXM',into=("INERTIE",),fr="Direction du repére" ),
+ fr="Nom de la table contenant les caracteristiques de la section de poutre" ),
+ NOM_ORIG =SIMP(statut='f',typ='TXM',into=("CDG","TORSION"),fr="Origine du nouveau repere" ),
+ NOM_ROTA =SIMP(statut='f',typ='TXM',into=("INERTIE",),fr="Direction du repere" ),
b_cdg =BLOC(condition = "NOM_ORIG == 'CDG'",
GROUP_MA =SIMP(statut='f',typ=grma,
- fr="Nom du groupe de mailles dont le centre de gravité sera l origine du nouveau repère"),
+ fr="Nom du groupe de mailles dont le centre de gravite sera l origine du nouveau repere"),
),
),
ECLA_PG =FACT(statut='f',
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- SHRINK =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de réduction" ),
- TAILLE_MIN =SIMP(statut='f',typ='R',defaut= 0.0, fr="Taille minimale d'un coté" ),
+ SHRINK =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de reduction" ),
+ TAILLE_MIN =SIMP(statut='f',typ='R',defaut= 0.0, fr="Taille minimale d'un cote" ),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),),
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
# person_in_charge: mathieu.courtois at edf.fr
def crea_table_prod(TYPE_TABLE, **args):
- """Typage du concept résultat
+ """Typage du concept resultat
"""
if TYPE_TABLE == 'TABLE_FONCTION':
return table_fonction
return table_sdaster
CREA_TABLE=OPER(nom="CREA_TABLE",op=36,sd_prod=crea_table_prod,
- fr="Création d'une table à partir d'une fonction ou de deux listes",
+ fr="Creation d'une table a partir d'une fonction ou de deux listes",
reentrant='f',
UIinfo={"groupes":("Tables",)},
UIinfo={"groupes":("Utilitaires",)},
fr="Permettre de changer entre 2 commandes quelques variables globales de debug",
- SDVERI =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+ SDVERI =SIMP(fr="verifie la conformite des SD produites par les commandes",
statut='f',typ='TXM',into=('OUI','NON')),
- JXVERI =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
+ JXVERI =SIMP(fr="verifie l integrite de la segmentation memoire",
statut='f',typ='TXM',into=('OUI','NON')),
- JEVEUX =SIMP(fr="force les déchargement sur disque",
+ JEVEUX =SIMP(fr="force les dechargement sur disque",
statut='f',typ='TXM',into=('OUI','NON')),
IMPR_MACRO =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess",
statut='f',typ='TXM',into=("OUI","NON")),
op=OPS("Cata.ops.build_debut"),
repetable='n',
UIinfo={"groupes":("Gestion du travail",)},
- fr="Ouverture d'une étude. Allocation des ressources mémoire et disque et fichiers",
+ fr="Ouverture d'une etude. Allocation des ressources memoire et disque et fichiers",
sd_prod=ops.DEBUT,
PAR_LOT =SIMP(fr="mode de traitement des commandes",statut='f',typ='TXM',
statut='f',typ='TXM',into=("OUI","NON"),defaut="NON"),
# FORMAT_HDF =SIMP(fr="sauvegarde de la base GLOBALE au format HDF",statut='f',
# typ='TXM',defaut="NON",into=("OUI","NON",) ),
- BASE =FACT(fr="définition des paramètres associés aux bases JEVEUX",
+ BASE =FACT(fr="definition des parametres associes aux bases JEVEUX",
statut='f',min=1,max=2,
FICHIER =SIMP(fr="nom de la base",statut='o',typ='TXM',
into=('GLOBALE','VOLATILE'),),
CAS =SIMP(statut='f',typ='TXM'),
NMAX_ENRE =SIMP(fr="nombre maximum d enregistrements",statut='f',typ='I'),
LONG_ENRE =SIMP(fr="longueur des enregistrements",statut='f',typ='I'),
- LONG_REPE =SIMP(fr="longueur du répertoire",statut='f',typ='I'),
+ LONG_REPE =SIMP(fr="longueur du repertoire",statut='f',typ='I'),
),
CATALOGUE =FACT(statut='f',min=1,max=10,
UNITE =SIMP(statut='f',typ='I'),
),
- CODE =FACT(fr="paramètres réservés aux cas-tests",
+ CODE =FACT(fr="parametres reserves aux cas-tests",
statut='f',min=1,max=1,
NIV_PUB_WEB =SIMP(statut='o',typ='TXM',into=('INTERNET','INTRANET')),
VISU_EFICAS =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI'),
ERREUR_F =SIMP(statut='f',typ='TXM',into=('ABORT','EXCEPTION'),),
),
- DEBUG =FACT(fr="option de déboggage reservée aux développeurs",
+ DEBUG =FACT(fr="option de deboggage reservee aux developpeurs",
statut='f',min=1,max=1,
- JXVERI =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
+ JXVERI =SIMP(fr="verifie l integrite de la segmentation memoire",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
- SDVERI =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+ SDVERI =SIMP(fr="verifie la conformite des SD produites par les commandes",
statut='f',typ='TXM',into=('OUI','NON')),
- JEVEUX =SIMP(fr="force les déchargement sur disque",
+ JEVEUX =SIMP(fr="force les dechargement sur disque",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
- ENVIMA =SIMP(fr="imprime les valeurs définies dans ENVIMA",
+ ENVIMA =SIMP(fr="imprime les valeurs definies dans ENVIMA",
statut='f',typ='TXM',into=('TEST',)),
- HIST_ETAPE = SIMP(fr="permet de conserver toutes les étapes du jeu de commandes",
+ HIST_ETAPE = SIMP(fr="permet de conserver toutes les etapes du jeu de commandes",
statut='f', typ='TXM', into=('OUI', 'NON'), defaut='NON'),
),
- MESURE_TEMPS =FACT(fr="Pour afficher le temps des principales étapes de calcul",
+ MESURE_TEMPS =FACT(fr="Pour afficher le temps des principales etapes de calcul",
statut='d',min=1,max=1,
- NIVE_DETAIL =SIMP(fr="niveau de détail des impressions",
+ NIVE_DETAIL =SIMP(fr="niveau de detail des impressions",
statut='f',typ='I',into=(0,1,2,3),defaut=1),
# 0 : rien
# 1 : impression en fin de commande des mesures principales
# 2 : impression en fin de commande des mesures principales et secondaires
# 3 : impression des mesures principales et secondaires pour chaque pas de temps
- MOYENNE =SIMP(fr="affichage des moyennes et écart-types en parallèle",
+ MOYENNE =SIMP(fr="affichage des moyennes et ecart-types en parallele",
statut='f',typ='TXM',into=('OUI','NON',),defaut='NON'),
),
- MEMOIRE =FACT(fr="mode de gestion mémoire utilisé",statut='d',min=1,max=1,
+ MEMOIRE =FACT(fr="mode de gestion memoire utilise",statut='d',min=1,max=1,
TAILLE_BLOC =SIMP(statut='f',typ='R',defaut=800.),
TAILLE_GROUP_ELEM =SIMP(statut='f',typ='I',defaut=1000),
),
RESERVE_CPU =FACT(fr="reserve de temps pour terminer une execution",statut='d',max=1,
regles=(EXCLUS('VALE','POURCENTAGE'),),
-# par défaut VALE fixée à 10. dans le FORTRAN si CODE présent
+# par defaut VALE fixee a 10. dans le FORTRAN si CODE present
VALE =SIMP(statut='f',typ='I',val_min=0,),
-# par défaut 10% dans le FORTRAN
+# par defaut 10% dans le FORTRAN
POURCENTAGE =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0),
-# valeur en secondes de la réserve maximum bornée à 900 secondes
+# valeur en secondes de la reserve maximum bornee a 900 secondes
BORNE =SIMP(statut='f',typ='I',val_min=0,defaut=900),),
- IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"),
+ IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite deliberement ignorer"),
LANG = SIMP(statut='f', typ='TXM',
- fr="Permet de choisir la langue utilisée pour les messages (si disponible)",
+ fr="Permet de choisir la langue utilisee pour les messages (si disponible)",
ang="Allows to choose the language used for messages (if available)"),
INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2),),
# person_in_charge: nicolas.brie at edf.fr
DEFI_BASE_MODALE=OPER(nom="DEFI_BASE_MODALE",op= 99,sd_prod=mode_meca,
reentrant='f',
- fr="Définit la base d'une sous-structuration dynamique ou d'une recombinaison modale",
+ fr="Definit la base d'une sous-structuration dynamique ou d'une recombinaison modale",
UIinfo={"groupes":("Matrices et vecteurs","Dynamique",)},
regles=(UN_PARMI('CLASSIQUE','RITZ','DIAG_MASS','ORTHO_BASE'),),
CLASSIQUE =FACT(statut='f',
op=OPS('Macro.defi_cable_bp_ops.defi_cable_bp_ops'),
sd_prod=cabl_precont,
fr="Calculer les profils initiaux de tension le long des cables " \
- "de précontrainte d'une structure en béton",
- reentrant='n',UIinfo={"groupes":("Modélisation",)},
+ "de precontrainte d'une structure en beton",
+ reentrant='n',UIinfo={"groupes":("Modelisation",)},
MODELE =SIMP(statut='o',typ=modele_sdaster ),
CHAM_MATER =SIMP(statut='o',typ=cham_mater ),
CARA_ELEM =SIMP(statut='o',typ=cara_elem ),
# person_in_charge: sylvie.michel-ponnelle at edf.fr
DEFI_CABLE_OP=OPER(nom="DEFI_CABLE_OP",op= 180,sd_prod=cabl_precont,reentrant='n',
- fr="Définit les profils initiaux de tension d'une structure en béton le long des cables de précontrainte"
- +" (utilisée par la macro DEFI_CABLE_BP)",
- UIinfo={"groupes":("Modélisation",)},
+ fr="Definit les profils initiaux de tension d'une structure en beton le long des cables de precontrainte"
+ +" (utilisee par la macro DEFI_CABLE_BP)",
+ UIinfo={"groupes":("Modelisation",)},
MODELE =SIMP(statut='o',typ=modele_sdaster ),
CHAM_MATER =SIMP(statut='o',typ=cham_mater ),
CARA_ELEM =SIMP(statut='o',typ=cara_elem ),
# ======================================================================
# person_in_charge: jean-michel.proix at edf.fr
DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster,
- fr="Définir le comportement d'un monocristal, d'un polycristal ou de groupes de fibres",
+ fr="Definir le comportement d'un monocristal, d'un polycristal ou de groupes de fibres",
reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
-# on exclut MULTIFBRE de MONOCRISTAL ou POLYCRISTAL car la structure de données n'est pas organisée pareil pour ces cas
+ UIinfo={"groupes":("Modelisation",)},
+# on exclut MULTIFBRE de MONOCRISTAL ou POLYCRISTAL car la structure de donnees n'est pas organisee pareil pour ces cas
regles=(UN_PARMI('MONOCRISTAL','POLYCRISTAL','MULTIFIBRE'),
PRESENT_PRESENT('MULTIFIBRE','GEOM_FIBRE','MATER_SECT'),
),
ECOULEMENT =SIMP(statut='o', typ='TXM', max=1,
into=('MONO_VISC1', 'MONO_VISC2', 'MONO_DD_KR', 'MONO_DD_CFC', 'MONO_DD_CFC_IRRA',
'MONO_DD_CC', 'MONO_DD_CC_IRRA', 'MONO_DD_FAT',),
- fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écoulement viscoplastique"),
+ fr="Donner le nom du mot-cle facteur de DEFI_MATERIAU precisant le type d'ecoulement viscoplastique"),
ELAS =SIMP(statut='f', typ='TXM', max=1,
- fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le comportement élastique (un et un seul)"),
+ fr="Donner le nom du mot-cle facteur de DEFI_MATERIAU precisant le comportement elastique (un et un seul)"),
b_non_dd =BLOC(condition="ECOULEMENT=='MONO_VISC1' or ECOULEMENT=='MONO_VISC2'",
ECRO_ISOT =SIMP(statut='o', typ='TXM', max=1,
- fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage isotrope"),
+ fr="Donner le nom du mot-cle facteur de DEFI_MATERIAU precisant le type d'ecrouissage isotrope"),
ECRO_CINE =SIMP(statut='o', typ='TXM', max=1,
- fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage cinématique"),
+ fr="Donner le nom du mot-cle facteur de DEFI_MATERIAU precisant le type d'ecrouissage cinematique"),
FAMI_SYST_GLIS =SIMP(statut='f',typ='TXM', max=1,
into=('OCTAEDRIQUE','BCC24','CUBIQUE1','CUBIQUE2','ZIRCONIUM','UNIAXIAL','UTILISATEUR'),
),
regles=(UN_PARMI('ANGL_REP','ANGL_EULER'),),
MONOCRISTAL =SIMP(statut='o', typ=compor_sdaster, max=1),
FRAC_VOL =SIMP(statut='o', typ='R', max=1,fr="fraction volumique de la phase correspondant au monocristal"),
- ANGL_REP =SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles nautiques en degrés"),
- ANGL_EULER=SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles d'Euler en degrés"),
+ ANGL_REP =SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles nautiques en degres"),
+ ANGL_EULER=SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles d'Euler en degres"),
),
b_poly =BLOC( condition = "POLYCRISTAL!='None'",
LOCALISATION =SIMP(statut='f', typ='TXM', max=1, into=('BZ', 'BETA', 'RL',),
- fr="Donner le nom de la règle de localisation"),
+ fr="Donner le nom de la regle de localisation"),
b_beta =BLOC( condition = "LOCALISATION=='BETA'",
DL =SIMP(statut='o',typ='R',max=1),
# ======================================================================
# person_in_charge: xavier.desroches at edf.fr
DEFI_COMPOSITE=OPER(nom="DEFI_COMPOSITE",op=56,sd_prod=mater_sdaster,reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
- fr="Déterminer les caractéristiques matériaux homogénéisées d'une coque multicouche à partir"
- +" des caractéristiques de chaque couche",
+ UIinfo={"groupes":("Modelisation",)},
+ fr="Determiner les caracteristiques materiaux homogeneisees d'une coque multicouche a partir"
+ +" des caracteristiques de chaque couche",
COUCHE =FACT(statut='o',max='**',
EPAIS =SIMP(statut='o',typ='R',val_min=0.E+0 ),
MATER =SIMP(statut='o',typ=(mater_sdaster) ),
# ======================================================================
# person_in_charge: mathieu.courtois at edf.fr
DEFI_CONSTANTE=OPER(nom="DEFI_CONSTANTE",op= 2,sd_prod=fonction_sdaster,
- fr="Définir la valeur d'une grandeur invariante",
+ fr="Definir la valeur d'une grandeur invariante",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
NOM_RESU =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"),
DEFI_CONTACT=OPER(nom = "DEFI_CONTACT",
op = 30,
sd_prod = char_contact,
- fr = "Définit les zones soumises à des conditions de contact unilatéral avec ou sans frottement",
+ fr = "Definit les zones soumises a des conditions de contact unilateral avec ou sans frottement",
#en = "Allows the definition of contact surfaces as well as unilateral conditions",
reentrant = 'n',
- UIinfo = {"groupes":("Modélisation",)},
+ UIinfo = {"groupes":("Modelisation",)},
# MODELE
FORMULATION =SIMP(statut='o',
position='global',
typ='TXM',
- fr="Choix d'une formulation de contact ou de liaisons unilatérales",
+ fr="Choix d'une formulation de contact ou de liaisons unilaterales",
defaut="DISCRETE",
into=("DISCRETE","CONTINUE","XFEM","LIAISON_UNIL",),),
FROTTEMENT =SIMP(statut='f',
position='global',
typ='TXM',
- fr="Choix d'un modèle de frottement (uniquement pour les formulations de contact)",
+ fr="Choix d'un modele de frottement (uniquement pour les formulations de contact)",
defaut="SANS",
into=("COULOMB","SANS",)),
# ARRET DU CALCUL POUR LE MODE SANS RESOLUTION DU CONTACT
STOP_INTERP = SIMP(statut='f',
typ='TXM',
- fr="Arrête le calcul dès qu'une interpénétration est détectée en mode RESOLUTION='NON'",
+ fr="Arrete le calcul des qu'une interpenetration est detectee en mode RESOLUTION='NON'",
defaut="NON",
into=("OUI","NON")),
# LISSAGE DES NORMALES PAR MOYENNATION AUX NOEUDS
# VERIFICATION DE L'ORIENTATION ET DE LA COHERENCE DES NORMALES
VERI_NORM =SIMP(statut='f',
typ='TXM',
- fr="Vérification de l'orientation (sortante) des normales aux surfaces",
+ fr="Verification de l'orientation (sortante) des normales aux surfaces",
defaut="OUI",
into=("OUI","NON"),),
),
# ## METHODES DE DUALISATION ##
STOP_SINGULIER= SIMP(statut='f',
typ='TXM',
- fr="Tient compte de la singularité de la matrice de contact",
+ fr="Tient compte de la singularite de la matrice de contact",
defaut="OUI",
into=("OUI","NON"),),
NB_RESOL = SIMP(statut='f',
typ='I',
- fr="Nombre de résolutions simultanées pour la construction du complément de Schur",
+ fr="Nombre de resolutions simultanees pour la construction du complement de Schur",
defaut=10,),
# ## GCP ##
RESI_ABSO = SIMP(statut='f',
typ='R',
- fr="Critère de convergence (niveau d'interpénétration autorisé pour 'GCP')",),
+ fr="Critere de convergence (niveau d'interpenetration autorise pour 'GCP')",),
ITER_GCP_MAXI = SIMP(statut='f',
typ='I',
- fr="Nombre d'itérations maximal ('GCP')",
+ fr="Nombre d'iterations maximal ('GCP')",
defaut=0,),
RECH_LINEAIRE = SIMP(statut='f',
typ='TXM',
- fr="Autorisation de sortie du domaine admissible lors de la recherche linéaire",
+ fr="Autorisation de sortie du domaine admissible lors de la recherche lineaire",
defaut="ADMISSIBLE",
into=("ADMISSIBLE","NON_ADMISSIBLE"),),
PRE_COND = SIMP(statut='f',
typ='TXM',
- fr="Choix d'un préconditionneur (accélère la convergence de 'GCP')",
+ fr="Choix d'un preconditionneur (accelere la convergence de 'GCP')",
defaut="SANS",
into=("DIRICHLET","SANS"),),
b_dirichlet = BLOC (condition = "PRE_COND == 'DIRICHLET'",
COEF_RESI = SIMP(statut='f',
typ='R',
- fr="Activation du préconditionneur quand le résidu a été divisé par COEF_RESI",
+ fr="Activation du preconditionneur quand le residu a ete divise par COEF_RESI",
defaut = -1.0,),
ITER_PRE_MAXI = SIMP(statut='f',
typ='I',
- fr="Nombre d'itérations maximal pour le préconditionneur ('GCP')",
+ fr="Nombre d'iterations maximal pour le preconditionneur ('GCP')",
defaut=0,),
),
),
b_affe_unil = BLOC(condition = "FORMULATION == 'LIAISON_UNIL'",
ZONE=FACT(statut='o',
max='**',
-# -- Liaison unilatérale
+# -- Liaison unilaterale
regles=(UN_PARMI('GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
NOM_CMP =SIMP(statut='o',typ='TXM',max='**'),
COEF_IMPO =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule),),
COEF_MULT =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
-# -- Incompatibilité avec CL
+# -- Incompatibilite avec CL
SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
#
TOLE_APPA =SIMP(statut='f',typ='R' ,defaut=-1.0),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
-# -- Incompatibilité avec CL
+# -- Incompatibilite avec CL
SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
SANS_MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
b_verif=BLOC(condition = "RESOLUTION == 'NON' ",
TOLE_INTERP = SIMP(statut='f',typ='R',defaut = 0.),
),
-# -- Résolution
+# -- Resolution
ALGO_CONT =SIMP(statut='o',typ='TXM',defaut="CONTRAINTE",
into=("CONTRAINTE","LAGRANGIEN","PENALISATION","GCP"),),
b_active=BLOC(condition = "ALGO_CONT == 'CONTRAINTE' ",
- fr="Paramètres de la méthode des contraintes actives (contact uniquement)",
+ fr="Parametres de la methode des contraintes actives (contact uniquement)",
GLISSIERE=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
b_glissiere=BLOC(condition = "GLISSIERE == 'OUI' ",
ALARME_JEU =SIMP(statut='f',typ='R',defaut=0.),
),
#
b_penal_contact=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
- fr="Paramètres de la méthode pénalisée (contact)",
+ fr="Parametres de la methode penalisee (contact)",
E_N=SIMP(statut='o',typ='R'),
),
#
b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",
- fr="Paramètres du frottement de Coulomb",
+ fr="Parametres du frottement de Coulomb",
COULOMB =SIMP(statut='o',typ='R',),
COEF_MATR_FROT=SIMP(statut='f',typ='R',defaut=0.E+0),
ALGO_FROT =SIMP(statut='o',typ='TXM',defaut="PENALISATION",
into=("PENALISATION","LAGRANGIEN"),),
#
b_penal_frot=BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
- fr="Paramètres de la méthode pénalisée (frottement)",
+ fr="Parametres de la methode penalisee (frottement)",
E_T=SIMP(statut='o',typ='R'),
),
),
- ), #fin mot-clé facteur ZONE
+ ), #fin mot-cle facteur ZONE
), #fin bloc b_affe_discret
# AFFECTATION - CAS CONTINUE
#
TOLE_APPA =SIMP(statut='f',typ='R' ,defaut=-1.0),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
-# -- Incompatibilité avec CL
+# -- Incompatibilite avec CL
SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
SANS_MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
b_verif=BLOC(condition = "RESOLUTION == 'NON' ",
TOLE_INTERP = SIMP(statut='f',typ='R',defaut = 0.),
),
-# -- Fonctionnalités spécifiques 'CONTINUE'
+# -- Fonctionnalites specifiques 'CONTINUE'
INTEGRATION =SIMP(statut='f',typ='TXM',defaut="AUTO",
into=("AUTO","GAUSS","SIMPSON","NCOTES",),),
b_gauss =BLOC(condition = "INTEGRATION == 'GAUSS' ",
- fr="Degré du polynôme de Legendre donnant les points de Gauss",
+ fr="Degre du polynome de Legendre donnant les points de Gauss",
ORDRE_INT = SIMP(statut='f',typ='I',defaut=3,val_min=1,val_max=6),
),
b_simpson =BLOC(condition = "INTEGRATION == 'SIMPSON' ",
ORDRE_INT = SIMP(statut='f',typ='I',defaut=1,val_min=1,val_max=4),
),
b_ncotes =BLOC(condition = "INTEGRATION == 'NCOTES' ",
- fr="Degré du polynôme interpolateur",
+ fr="Degre du polynome interpolateur",
ORDRE_INT = SIMP(statut='f',typ='I',defaut=3,val_min=3,val_max=8),
),
#
into=("STANDARD","PENALISATION"),),
b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD' ",
- fr="Paramètres de la formulation Lagrangienne",
+ fr="Parametres de la formulation Lagrangienne",
COEF_CONT = SIMP(statut='f',typ='R',defaut=100.E+0),
),
b_cont_pena=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
- fr="Paramètres de la méthode pénalisée",
+ fr="Parametres de la methode penalisee",
COEF_PENA_CONT =SIMP(statut='o',typ='R'),
),
#
b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",
- fr="Paramètres du frottement de Coulomb",
+ fr="Parametres du frottement de Coulomb",
COULOMB = SIMP(statut='o',typ='R',),
SEUIL_INIT = SIMP(statut='f',typ='R',defaut=0.E+0),
#
SANS_GROUP_NO_FR =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
b_sans_group_no_frot=BLOC(condition = " SANS_GROUP_NO_FR != None or \
SANS_NOEUD_FR != None ",
- fr="Direction de frottement à exclure (uniquement dans le cas 3D)",
+ fr="Direction de frottement a exclure (uniquement dans le cas 3D)",
DIRE_EXCL_FROT=SIMP(statut='f',typ='R',min=3,max=3),
),
ALGO_FROT =SIMP(statut='f',typ='TXM',defaut="STANDARD",
into=("STANDARD","PENALISATION"),),
b_frot_std =BLOC(condition = "ALGO_FROT == 'STANDARD' ",
- fr="Paramètres de la formulation Lagrangienne",
+ fr="Parametres de la formulation Lagrangienne",
COEF_FROT =SIMP(statut='f',typ='R',defaut=100.E+0),
),
b_frot_pena =BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
- fr="Paramètres de la méthode pénalisée",
+ fr="Parametres de la methode penalisee",
COEF_PENA_FROT =SIMP(statut='o',typ='R'),
),
), #fin bloc b_frottement
- ), #fin mot-clé facteur ZONE
+ ), #fin mot-cle facteur ZONE
), #fin bloc b_affe_continue
FISS_MAIT = SIMP(statut='o',typ=fiss_xfem,max=1),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
-# -- Fonctionnalités spécifiques 'XFEM'
+# -- Fonctionnalites specifiques 'XFEM'
INTEGRATION = SIMP(statut='f',
typ='TXM',
defaut="GAUSS",
into=("NOEUD","GAUSS","SIMPSON","NCOTES",),),
b_gauss =BLOC(condition = "INTEGRATION == 'GAUSS' ",
- fr="Dégré du polynôme de Legendre donnant les points de Gauss",
+ fr="Degre du polynome de Legendre donnant les points de Gauss",
ORDRE_INT = SIMP(statut='f',typ='I',defaut=6,val_min=1,val_max=6),
),
b_simpson =BLOC(condition = "INTEGRATION == 'SIMPSON' ",
ORDRE_INT = SIMP(statut='f',typ='I',defaut=1,val_min=1,val_max=4),
),
b_ncotes =BLOC(condition = "INTEGRATION == 'NCOTES' ",
- fr="Dégré du polynôme interpolateur",
+ fr="Degre du polynome interpolateur",
ORDRE_INT = SIMP(statut='f',typ='I',defaut=3,val_min=3,val_max=8),
),
),
b_cont_pen=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
- fr="Paramètre de la méthode pénalisée",
+ fr="Parametre de la methode penalisee",
COEF_PENA_CONT =SIMP(statut='o',typ='R'),
),
),
b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' and ALGO_CONT != 'CZM' ",
- fr="Paramètres du frottement",
+ fr="Parametres du frottement",
COULOMB =SIMP(statut='o',typ='R',),
SEUIL_INIT =SIMP(statut='f',typ='R',defaut=0.E+0),
ALGO_FROT =SIMP(statut='f',typ='TXM',defaut="STANDARD",
COEF_FROT =SIMP(statut='f',typ='R',defaut=100.E+0),
),
b_frot_pen=BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
- fr="Paramètre de la méthode pénalisée",
+ fr="Parametre de la methode penalisee",
COEF_PENA_FROT =SIMP(statut='o',typ='R'),
),
), #fin bloc b_frottement
- ), #fin mot-clé facteur ZONE
+ ), #fin mot-cle facteur ZONE
), #fin bloc b_affe_xfem
) #fin OPER
sd_prod=DEFIC_prod,
reentrant='n',
UIinfo={"groupes":("Gestion du travail",)},
- fr="Ouvre ou ferme un fichier associé à un numéro d'unité logique",
+ fr="Ouvre ou ferme un fichier associe a un numero d'unite logique",
ACTION =SIMP(statut='f',typ='TXM',into=("ASSOCIER","LIBERER","RESERVER"),defaut="ASSOCIER"),
b_associer =BLOC(condition = "ACTION == 'ASSOCIER'",
- fr="Paramètres pour l'ouverture du fichier",
+ fr="Parametres pour l'ouverture du fichier",
regles=(AU_MOINS_UN('FICHIER','UNITE'),),
UNITE =SIMP(statut='f',typ='I' ,val_min=1),
FICHIER =SIMP(statut='f',typ='TXM',validators=LongStr(1,255)),
TYPE =SIMP(statut='f',typ='TXM',into=("ASCII","BINARY","LIBRE"),defaut="ASCII"),
- b_type_ascii =BLOC(condition = "TYPE == 'ASCII'",fr="Paramètres pour le type ASCII",
+ b_type_ascii =BLOC(condition = "TYPE == 'ASCII'",fr="Parametres pour le type ASCII",
ACCES =SIMP(statut='f',typ='TXM',into=("NEW","APPEND","OLD"),defaut="NEW"),
),
- b_type_autre =BLOC(condition = "TYPE != 'ASCII'",fr="Paramètres pour les types BINARY et LIBRE",
+ b_type_autre =BLOC(condition = "TYPE != 'ASCII'",fr="Parametres pour les types BINARY et LIBRE",
ACCES =SIMP(statut='f',typ='TXM',into=("NEW","OLD"),defaut="NEW"),
),
),
b_reserver =BLOC(condition = "ACTION == 'RESERVER'",
- fr="Paramètres pour la réservation de l'unité du fichier",
+ fr="Parametres pour la reservation de l'unite du fichier",
regles=(AU_MOINS_UN('FICHIER','UNITE'),),
UNITE =SIMP(statut='f',typ='I' ,val_min=1),
FICHIER =SIMP(statut='f',typ='TXM',validators=LongStr(1,255)),
),
b_liberer =BLOC(condition = "ACTION == 'LIBERER'",
- fr="Paramètres pour la fermeture du fichier",
+ fr="Parametres pour la fermeture du fichier",
regles=(UN_PARMI('FICHIER','UNITE'),),
UNITE =SIMP(statut='f',typ='I' ,val_min=1),
FICHIER =SIMP(statut='f',typ='TXM',validators=LongStr(1,255)),
# person_in_charge: samuel.geniaut at edf.fr
DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op= 41,sd_prod=fiss_xfem,reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
- fr="Définition des caratéristiques d'une fissure ou d'une interface avec X-FEM",
+ UIinfo={"groupes":("Modelisation",)},
+ fr="Definition des carateristiques d'une fissure ou d'une interface avec X-FEM",
regles = EXCLUS('MODELE_GRILLE','FISS_GRILLE'),
# ------------------------------------------------------------------------------------------------------------------------
GROUP_MA_FOND =SIMP(statut='f',typ=grma,min=1,max=1),
FORM_FISS =SIMP(statut='f',typ='TXM',into=("ELLIPSE","RECTANGLE","CYLINDRE","DEMI_PLAN",
"SEGMENT","DEMI_DROITE","DROITE","ENTAILLE") ),
- b_ellipse =BLOC(condition = "FORM_FISS == 'ELLIPSE' ",fr="Paramètres de la fissure/interface elliptique",
+ b_ellipse =BLOC(condition = "FORM_FISS == 'ELLIPSE' ",fr="Parametres de la fissure/interface elliptique",
DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),
COTE_FISS =SIMP(statut='f',typ='TXM',defaut="IN",into=("IN","OUT",) ), ),
- b_rectangle =BLOC(condition = "FORM_FISS == 'RECTANGLE' ",fr="Paramètres de la fissure/interface rectangulaire",
+ b_rectangle =BLOC(condition = "FORM_FISS == 'RECTANGLE' ",fr="Parametres de la fissure/interface rectangulaire",
DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
RAYON_CONGE =SIMP(statut='f',typ='R',val_min=0.,defaut=0.),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),
COTE_FISS =SIMP(statut='f',typ='TXM',defaut="IN",into=("IN","OUT",) ), ),
- b_entaille =BLOC(condition = "FORM_FISS == 'ENTAILLE' ",fr="Paramètres de l'interface entaille",
+ b_entaille =BLOC(condition = "FORM_FISS == 'ENTAILLE' ",fr="Parametres de l'interface entaille",
DEMI_LONGUEUR =SIMP(statut='o',typ='R',val_min=0.),
RAYON_CONGE =SIMP(statut='o',typ='R',val_min=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), ),
- b_cylindre =BLOC(condition = "FORM_FISS == 'CYLINDRE' ",fr="Paramètres de la fissure cylindrique",
+ b_cylindre =BLOC(condition = "FORM_FISS == 'CYLINDRE' ",fr="Parametres de la fissure cylindrique",
DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),),
- b_demiplan =BLOC(condition = "FORM_FISS == 'DEMI_PLAN' ",fr="Paramètres de la fissure plane à front droit",
+ b_demiplan =BLOC(condition = "FORM_FISS == 'DEMI_PLAN' ",fr="Parametres de la fissure plane a front droit",
PFON =SIMP(statut='o',typ='R',min=3,max=3),
NORMALE =SIMP(statut='o',typ='R',min=3,max=3),
DTAN =SIMP(statut='o',typ='R',min=3,max=3),),
- b_segment =BLOC(condition = "FORM_FISS == 'SEGMENT' ",fr="Paramètres de la fissure 2D segment",
+ b_segment =BLOC(condition = "FORM_FISS == 'SEGMENT' ",fr="Parametres de la fissure 2D segment",
PFON_ORIG =SIMP(statut='o',typ='R',min=3,max=3),
PFON_EXTR =SIMP(statut='o',typ='R',min=3,max=3),),
- b_demidroite =BLOC(condition = "FORM_FISS == 'DEMI_DROITE' ",fr="Paramètres de la fissure 2D demi-droite",
+ b_demidroite =BLOC(condition = "FORM_FISS == 'DEMI_DROITE' ",fr="Parametres de la fissure 2D demi-droite",
PFON =SIMP(statut='o',typ='R',min=3,max=3),
DTAN =SIMP(statut='o',typ='R',min=3,max=3),),
- b_droite =BLOC(condition = "FORM_FISS == 'DROITE' ",fr="Paramètres de l'interface 2D (fissure traversante)",
+ b_droite =BLOC(condition = "FORM_FISS == 'DROITE' ",fr="Parametres de l'interface 2D (fissure traversante)",
POINT =SIMP(statut='o',typ='R',min=3,max=3),
DTAN =SIMP(statut='o',typ='R',min=3,max=3),),
),
CHAM_DISCONTINUITE =SIMP(statut='f',typ='TXM',into=("DEPL",),defaut="DEPL" ),
TYPE_ENRI_FOND =SIMP(statut='f',typ='TXM',into=("TOPOLOGIQUE","GEOMETRIQUE"),defaut="TOPOLOGIQUE" ),
- b_enri_geom =BLOC(condition = "TYPE_ENRI_FOND == 'GEOMETRIQUE' ",fr="Paramètres de l enrichissement geometrique",
+ b_enri_geom =BLOC(condition = "TYPE_ENRI_FOND == 'GEOMETRIQUE' ",fr="Parametres de l enrichissement geometrique",
RAYON_ENRI =SIMP(statut='f',typ='R',val_min=0.E+0),
- b_enri_couches =BLOC(condition = "(RAYON_ENRI == None) ",fr="Paramètres de l enrichissement à n couches",
+ b_enri_couches =BLOC(condition = "(RAYON_ENRI == None) ",fr="Parametres de l enrichissement a n couches",
NB_COUCHES =SIMP(statut='f',typ='I',defaut=4,val_min=1),
),
# ======================================================================
# person_in_charge: andre.adobes at edf.fr
DEFI_FLUI_STRU=OPER(nom="DEFI_FLUI_STRU",op= 143,sd_prod=type_flui_stru,
- reentrant='n',fr="Définit les caractéristiques nécessaires à l'étude dynamique d'une structure sous écoulement",
- UIinfo={"groupes":("Modélisation",)},
+ reentrant='n',fr="Definit les caracteristiques necessaires a l'etude dynamique d'une structure sous ecoulement",
+ UIinfo={"groupes":("Modelisation",)},
regles=( UN_PARMI('FAISCEAU_TRANS','GRAPPE','FAISCEAU_AXIAL','COQUE_COAX',),),
FAISCEAU_TRANS =FACT(statut='f',max='**',
regles=( ENSEMBLE('CSTE_CONNORS','NB_CONNORS','RHO_TUBE'),),
GRAPPE =FACT(statut='f',
regles=(ENSEMBLE('GRAPPE_2','NOEUD','CARA_ELEM','MODELE','RHO_FLUI',),
PRESENT_PRESENT('COEF_MASS_AJOU','GRAPPE_2', ),),
-# peut on créer un bloc a partir de la valeur de couplage
+# peut on creer un bloc a partir de la valeur de couplage
COUPLAGE =SIMP(statut='o',typ='TXM',into=("OUI","NON") ),
GRAPPE_2 =SIMP(statut='f',typ='TXM',
into=("ASC_CEN","ASC_EXC","DES_CEN","DES_EXC") ),
op=OPS('Macro.defi_fonc_elec_ops.defi_fonc_elec_ops'),
sd_prod=fonction_sdaster,
reentrant='n',
- UIinfo={"groupes":("Outils-métier",)},
- fr="Définir une fonction du temps intervenant dans le calcul des " \
+ UIinfo={"groupes":("Outils-metier",)},
+ fr="Definir une fonction du temps intervenant dans le calcul des " \
"forces de LAPLACE",
regles=(UN_PARMI('COUR_PRIN','COUR'),
EXCLUS('COUR','COUR_SECO'), ),
FREQ =SIMP(statut='f',typ='R',defaut= 50.),
SIGNAL =SIMP(statut='f',typ='TXM',defaut="COMPLET",into=("COMPLET","CONTINU") ),
COUR =FACT(statut='f',max='**',
- fr="Définition du courant de court-circuit",
+ fr="Definition du courant de court-circuit",
regles=(UN_PARMI('PHI_CC_1','INTC_CC_1'),
UN_PARMI('PHI_CC_2','INTC_CC_2'),),
INTE_CC_1 =SIMP(statut='o',typ='R'),
INST_CC_FIN =SIMP(statut='o',typ='R'),
),
COUR_PRIN =FACT(statut='f',
- fr="Définition du courant de court-circuit avec réenclenchement",
+ fr="Definition du courant de court-circuit avec reenclenchement",
regles=(UN_PARMI('PHI_CC_1','INTC_CC_1'),),
INTE_CC_1 =SIMP(statut='o',typ='R'),
TAU_CC_1 =SIMP(statut='o',typ='R'),
INST_RENC_FIN =SIMP(statut='f',typ='R',defaut= 0.0E+0),
),
COUR_SECO =FACT(statut='f',max='**',
- fr="Définition du courant de court-circuit avec un intervalle de temps différent de celui de COUR_PRIN",
+ fr="Definition du courant de court-circuit avec un intervalle de temps different de celui de COUR_PRIN",
regles=(UN_PARMI('PHI_CC_2','INTC_CC_2'),),
INTE_CC_2 =SIMP(statut='o',typ='R'),
TAU_CC_2 =SIMP(statut='o',typ='R'),
# person_in_charge: andre.adobes at edf.fr
DEFI_FONC_FLUI=OPER(nom="DEFI_FONC_FLUI",op= 142,sd_prod=fonction_sdaster,
reentrant='n',
- fr="Définit un profil de vitesse d'écoulement fluide le long d'une poutre",
- UIinfo={"groupes":("Modélisation","Fonctions",)},
+ fr="Definit un profil de vitesse d'ecoulement fluide le long d'une poutre",
+ UIinfo={"groupes":("Modelisation","Fonctions",)},
MAILLAGE =SIMP(statut='o',typ=(maillage_sdaster) ),
NOEUD_INIT =SIMP(statut='o',typ=no),
NOEUD_FIN =SIMP(statut='o',typ=no),
raise AsException("type de concept resultat non prevu")
DEFI_FONCTION=OPER(nom="DEFI_FONCTION",op=3,sd_prod=defi_fonction_prod
- ,fr="Définit une fonction réelle ou complexe d'une variable réelle",
+ ,fr="Definit une fonction reelle ou complexe d'une variable reelle",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
regles=(UN_PARMI('VALE','VALE_C','VALE_PARA','NOEUD_PARA','ABSCISSE'),),
NOM_PARA =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ),
NOM_RESU =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"),
VALE =SIMP(statut='f',typ='R',min=2,max='**',
- fr ="Fonction réelle définie par une liste de couples "
- "(abscisse,ordonnée)"),
+ fr ="Fonction reelle definie par une liste de couples "
+ "(abscisse,ordonnee)"),
ABSCISSE =SIMP(statut='f',typ='R',min=2,max='**',
- fr ="Liste d abscisses d une fonction réelle"),
+ fr ="Liste d abscisses d une fonction reelle"),
VALE_C =SIMP(statut='f',typ='R',min=2,max='**',
- fr ="Fonction complexe définie par une liste de triplets "
- "(absc, partie réelle, partie imaginaire)"),
+ fr ="Fonction complexe definie par une liste de triplets "
+ "(absc, partie reelle, partie imaginaire)"),
VALE_PARA =SIMP(statut='f',typ=listr8_sdaster,
- fr ="Fonction réelle définie par deux concepts de type listr8" ),
+ fr ="Fonction reelle definie par deux concepts de type listr8" ),
b_vale_para =BLOC(condition = "VALE_PARA != None",
VALE_FONC =SIMP(statut='o',typ=listr8_sdaster ),
),
b_abscisse =BLOC(condition = "ABSCISSE != None",
ORDONNEE =SIMP(statut='o',typ='R',min=2,max='**',
- fr ="Liste d ordonnées d une fonction réelle"),
+ fr ="Liste d ordonnees d une fonction reelle"),
),
NOEUD_PARA =SIMP(statut='f',typ=no,max='**',
- fr ="Fonction réelle définie par une liste de noeuds et un maillage"),
+ fr ="Fonction reelle definie par une liste de noeuds et un maillage"),
b_noeud_para =BLOC(condition = "NOEUD_PARA != None",
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster ),
VALE_Y =SIMP(statut='o',typ='R',max='**'),
op=55,
sd_prod=fond_fiss,
reentrant='n',
- UIinfo={"groupes":("Modélisation",)},fr="Définition de lèvres et d'un fond de fissure",
+ UIinfo={"groupes":("Modelisation",)},fr="Definition de levres et d'un fond de fissure",
MAILLAGE = SIMP(statut='o',typ=maillage_sdaster ),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
DEFI_GEOM_FIBRE=OPER(nom="DEFI_GEOM_FIBRE",op= 119, sd_prod=gfibre_sdaster,
fr="Definition des groupes de fibres pour les elements multifibres",
reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
+ UIinfo={"groupes":("Modelisation",)},
regles=(AU_MOINS_UN('SECTION','FIBRE'),),
INFO =SIMP(statut='f',typ='I', defaut= 1 ,into=(1,2) ),
# ======================================================================
# person_in_charge: sebastien.fayolle at edf.fr
DEFI_GLRC=OPER(nom="DEFI_GLRC",op=57,sd_prod=mater_sdaster,reentrant='f',
- UIinfo={"groupes":("Modélisation",)},
- fr="Déterminer les caractéristiques homogenéisées du béton armé à partir des propriétés du béton et des "
+ UIinfo={"groupes":("Modelisation",)},
+ fr="Determiner les caracteristiques homogeneisees du beton arme a partir des proprietes du beton et des "
+" armatures",
reuse = SIMP(statut='f',typ=mater_sdaster),
RELATION = SIMP(statut='o',typ='TXM',defaut="GLRC_DAMAGE",
into=("GLRC_DM","GLRC_DAMAGE"),),
b_glrc_dm=BLOC(condition = "RELATION == 'GLRC_DM'",
- fr="Paramètres de la loi GLRC_DM",
+ fr="Parametres de la loi GLRC_DM",
BETON = FACT(statut='o',max=1,
MATER = SIMP(statut='o',typ=(mater_sdaster),),
EPAIS = SIMP(statut='o',typ='R',val_min=0.E+0 ),),
COMPR = SIMP(statut='o',typ='TXM',defaut="GAMMA",
into=("GAMMA","SEUIL")),
b_gamma=BLOC(condition = "COMPR == 'GAMMA'",
- fr="Paramètre d'endommagement en compression ",
+ fr="Parametre d'endommagement en compression ",
GAMMA_C = SIMP(statut='o',typ='R',defaut=1.0E+0,val_min=0.0E+0, val_max=1.0E+0),),
b_seuil=BLOC(condition = "COMPR == 'SEUIL'",
fr="Seuil d'endommagement en compression ",
PENTE = SIMP(statut='o',typ='TXM',defaut="RIGI_ACIER",
into=("PLAS_ACIER","UTIL","RIGI_ACIER")),
b_util = BLOC(condition = "PENTE == 'UTIL'",
- fr="Valeur de la déformation maximale de l'élément",
+ fr="Valeur de la deformation maximale de l'element",
EPSI_MEMB = SIMP(statut='o',typ='R',defaut=0.E+0),
KAPPA_FLEX = SIMP(statut='o',typ='R',defaut=0.E+0),),
CISAIL = SIMP(statut='o',typ='TXM',defaut="NON",
INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2),),
),
b_glrc_damage=BLOC(condition = "RELATION == 'GLRC_DAMAGE'",
- fr="Paramètres de la loi GLRC_DAMAGE",
+ fr="Parametres de la loi GLRC_DAMAGE",
CISAIL_NL =FACT(statut='f',max=1,
BTD1 =SIMP(statut='o',typ='R'),
BTD2 =SIMP(statut='o',typ='R'),
# ======================================================================
# person_in_charge: samuel.geniaut at edf.fr
DEFI_GRILLE=OPER(nom="DEFI_GRILLE",op=82,sd_prod=grille_sdaster,reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
- fr="Définition d'une grille",
+ UIinfo={"groupes":("Modelisation",)},
+ fr="Definition d'une grille",
MAILLAGE = SIMP(statut='o',typ=maillage_sdaster),
raise AsException("type de concept resultat non prevu")
DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod,
- fr="Définition de nouveaux groupes de noeuds et/ou de mailles dans un concept maillage",
+ fr="Definition de nouveaux groupes de noeuds et/ou de mailles dans un concept maillage",
reentrant='o',
UIinfo={"groupes":("Maillage",)},
regles=(AU_MOINS_UN('CREA_GROUP_MA','CREA_GROUP_NO','DETR_GROUP_NO','DETR_GROUP_MA'),
NOM =SIMP(statut='o',typ=grno),
GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
# si le groupe de mailles forme une ligne ouverte, on peut choisir le sens de parcours en choissant l'origine:
- # si le groupe de mailles forme une ligne fermée, il FAUT choisir l'origine et l'extrémité (= origine):
+ # si le groupe de mailles forme une ligne fermee, il FAUT choisir l'origine et l'extremite (= origine):
NOEUD_ORIG =SIMP(statut='f',typ=no),
GROUP_NO_ORIG =SIMP(statut='f',typ=grno),
NOEUD_EXTR =SIMP(statut='f',typ=no),
GROUP_NO_EXTR =SIMP(statut='f',typ=grno),
- # si le groupe de mailles forme une ligne fermée, on peut choisir le sens de parcours :
- VECT_ORIE =SIMP(statut='f',typ='R',max=3), # utilisé seulement si NOEUD_ORIG=NOEUD_EXTR
+ # si le groupe de mailles forme une ligne fermee, on peut choisir le sens de parcours :
+ VECT_ORIE =SIMP(statut='f',typ='R',max=3), # utilise seulement si NOEUD_ORIG=NOEUD_EXTR
),
b_tunnel =BLOC(condition = "OPTION == 'TUNNEL'",
LONGUEUR =SIMP(statut='f',typ='R'),
),
b_inclusion =BLOC(condition = "OPTION == 'INCLUSION'",
- fr="""crée le groupe des noeuds des mailles de GROUP_MA inclus géométriquement
+ fr="""cree le groupe des noeuds des mailles de GROUP_MA inclus geometriquement
dans les mailles de GROUP_MA_INCL""",
NOM =SIMP(statut='o',typ=grma),
CAS_FIGURE =SIMP(statut='o',typ='TXM',into=("2D","3D","2.5D",)),
DEFI_INTE_SPEC=OPER(nom="DEFI_INTE_SPEC",op= 115,
sd_prod=interspectre,
reentrant='n',
- fr="Définit une matrice interspectrale",
+ fr="Definit une matrice interspectrale",
UIinfo={"groupes":("Fonctions",)},
DIMENSION =SIMP(statut='f',typ='I',defaut= 1 ),
DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas,
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs","Dynamique",)},
- fr="Définir les interfaces d'une structure et leur affecter un type",
+ fr="Definir les interfaces d'une structure et leur affecter un type",
NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
INTERFACE =FACT(statut='o',max='**',
regles=(ENSEMBLE('NOM','TYPE'),
# ======================================================================
# person_in_charge: mathieu.courtois at edf.fr
DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster,
- fr="Définir une liste d'entiers strictement croissante",
+ fr="Definir une liste d'entiers strictement croissante",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
OPERATION =SIMP(statut='o',typ='TXM',defaut='DEFI',into=('DEFI','NUME_ORDRE',)),
- # définition d'une liste d'entiers
+ # definition d'une liste d'entiers
#----------------------------------
b_defi =BLOC(condition = "OPERATION == 'DEFI'",
regles=(UN_PARMI('VALE','DEBUT'),
DEFI_LIST_FREQ=MACRO(nom="DEFI_LIST_FREQ",
op=OPS('Macro.defi_list_freq_ops.defi_list_freq_ops'),
sd_prod=listr8_sdaster,
- fr="Définir une liste de fréquences strictement croissante",
+ fr="Definir une liste de frequences strictement croissante",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
regles=(UN_PARMI('VALE','DEBUT',),
# Bloc pour decoupe du pas de temps
bloc_deco =BLOC(fr = "Action de decoupe du pas temps",
condition = "ACTION == 'DECOUPE' or ACTION == 'REAC_PRECOND' or ACTION == 'AUTRE_PILOTAGE'",
- SUBD_METHODE = SIMP(fr = "Méthode de subdivision des pas de temps en cas de divergence",
+ SUBD_METHODE = SIMP(fr = "Methode de subdivision des pas de temps en cas de divergence",
statut = 'f',
typ = 'TXM',
max = 1,
# Bloc pour decoupe du pas de temps - special pour collision
bloc_deco2 =BLOC(fr = "Action de decoupe du pas temps",
condition = "ACTION == 'DECOUPE'",
- SUBD_METHODE = SIMP(fr = "Méthode de subdivision des pas de temps en cas de collision",
+ SUBD_METHODE = SIMP(fr = "Methode de subdivision des pas de temps en cas de collision",
statut = 'f',
typ = 'TXM',
max = 1,
# Bloc pour extrapolation du nombre d'iterations de Newton
bloc_supp =BLOC(fr = "Action d'extrapolation du nombre d'iterations de Newton",
condition = "ACTION == 'ITER_SUPPL'",
- PCENT_ITER_PLUS = SIMP(fr = "Pourcentage d'itérations autorisées en plus",
+ PCENT_ITER_PLUS = SIMP(fr = "Pourcentage d'iterations autorisees en plus",
statut = 'f',
typ = 'I',
val_min = 20,
max = 1,
defaut = 50,
),
- SUBD_METHODE = SIMP(fr = "Méthode de subdivision des pas de temps en cas de divergence",
+ SUBD_METHODE = SIMP(fr = "Methode de subdivision des pas de temps en cas de divergence",
statut = 'f',
typ = 'TXM',
max = 1,
DEFI_LIST_INST = OPER(nom="DEFI_LIST_INST",op= 28,sd_prod=list_inst,reentrant='n',
UIinfo={"groupes":("Fonctions",)},
- fr="Définition de la gestion de la liste d'instants",
+ fr="Definition de la gestion de la liste d'instants",
# ----------------------------------------------------------------------------------------------------------------------------------
# mot-cle pour la definition a priori de la liste d'instant
into = ("MANUEL","AUTO",),
defaut = "MANUEL",
),
- b_manuel = BLOC(fr = "Liste d'instants donnée par l'utilisateur",
+ b_manuel = BLOC(fr = "Liste d'instants donnee par l'utilisateur",
condition = "METHODE == 'MANUEL' ",
regles=(UN_PARMI('LIST_INST','VALE','RESULTAT'),
PRESENT_PRESENT('RESULTAT','SUBD_PAS'),),
# ======================================================================
# person_in_charge: mathieu.courtois at edf.fr
DEFI_LIST_REEL=OPER(nom="DEFI_LIST_REEL",op=24,sd_prod=listr8_sdaster,
- fr="Définir une liste de réels strictement croissante",
+ fr="Definir une liste de reels strictement croissante",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
regles=(UN_PARMI('VALE','DEBUT',),
# ======================================================================
# person_in_charge: jacques.pellet at edf.fr
DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster,
- fr="Définition d'un nouveau maillage à partir de macro-éléments",
+ fr="Definition d'un nouveau maillage a partir de macro-elements",
reentrant='n',
UIinfo={"groupes":("Maillage",)},
DEFI_SUPER_MAILLE =FACT(statut='o',max='**',
ENSEMBLE('GROUP_NO_INIT','GROUP_NO_FIN'),),
# la regle ancien catalogue AU_MOINS_UN__: ( INDEX , GROUP_NO_FIN ) incoherente avec doc U
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="Création de plusieurs groupes de noeuds" ),
+ fr="Creation de plusieurs groupes de noeuds" ),
SUPER_MAILLE =SIMP(statut='f',typ=ma,
- fr="Création de plusieurs groupes de noeuds"),
+ fr="Creation de plusieurs groupes de noeuds"),
GROUP_NO_INIT =SIMP(statut='f',typ=grno,
- fr="Création d un seul groupe de noeuds"),
+ fr="Creation d un seul groupe de noeuds"),
PREFIXE =SIMP(statut='f',typ='TXM' ),
INDEX =SIMP(statut='f',typ='I',max='**'),
GROUP_NO_FIN =SIMP(statut='f',typ=grno),
op=OPS('Macro.defi_mater_gc_ops.defi_mater_gc_ops'),
sd_prod=mater_sdaster,
reentrant='n',
- UIinfo={"groupes":("Modélisation",) },
- fr="Définir des lois matériaux spécifique au Génie Civil",
+ UIinfo={"groupes":("Modelisation",) },
+ fr="Definir des lois materiaux specifique au Genie Civil",
#
regles = (UN_PARMI('MAZARS','ACIER','ENDO_FISS_EXP'), ),
#
REGLE =SIMP(statut='f',typ='TXM', into=('EC2',), defaut='EC2'),
# ============================================================================
MAZARS =FACT(statut= 'f',max= 1,
- fr="Paramètres matériaux de MAZARS unilatéral en 1D à partir des caractéristiques du béton",
+ fr="Parametres materiaux de MAZARS unilateral en 1D a partir des caracteristiques du beton",
UNITE_LONGUEUR =SIMP(statut='o',typ='TXM', into=("M","MM"),
- fr="Unité de longueur du problème [M|MM]"),
+ fr="Unite de longueur du probleme [M|MM]"),
FCJ =SIMP(statut='o',typ='R', val_min=0.0E+0,
- fr="Contrainte au pic en compression [Unité]"),
+ fr="Contrainte au pic en compression [Unite]"),
EIJ =SIMP(statut='f',typ='R', val_min=0.0E+0,
- fr="Module d'Young [Unité]"),
+ fr="Module d'Young [Unite]"),
EPSI_C =SIMP(statut='f',typ='R', val_min=0.0E+0,
- fr="Déformation au pic en compression"),
+ fr="Deformation au pic en compression"),
FTJ =SIMP(statut='f',typ='R', val_min=0.0E+0,
- fr="Contrainte au pic en traction [Unité]"),
+ fr="Contrainte au pic en traction [Unite]"),
NU =SIMP(statut='f',typ='R', val_min=0.0E+0, val_max=0.5E+0,
fr="Coefficient de poisson"),
EPSD0 =SIMP(statut='f',typ='R', val_min=0.0E+0,
- fr="Déformation, seuil d'endommagement"),
+ fr="Deformation, seuil d'endommagement"),
K =SIMP(statut='f',typ='R', val_min=0.0E+0,
fr="Asymptote en cisaillement pur"),
AC =SIMP(statut='f',typ='R', val_min=0.E+0,
- fr="Paramètre de décroissance post-pic en compression"),
+ fr="Parametre de decroissance post-pic en compression"),
BC =SIMP(statut='f',typ='R', val_min=0.0E+0,
- fr="Paramètre de décroissance post-pic en compression"),
+ fr="Parametre de decroissance post-pic en compression"),
AT =SIMP(statut='f',typ='R', val_min=0.0E+0, val_max=1.0E+0,
- fr="Paramètre de décroissance post-pic en traction"),
+ fr="Parametre de decroissance post-pic en traction"),
BT =SIMP(statut='f',typ='R', val_min=0.0E+0,
- fr="Paramètre de décroissance post-pic en traction"),
+ fr="Parametre de decroissance post-pic en traction"),
# Pour post-traitement ELS et ELU
SIGM_LIM =SIMP(statut='f',typ='R', fr="Contrainte limite, post-traitement"),
- EPSI_LIM =SIMP(statut='f',typ='R', fr="Déformation limite, post-traitement"),
+ EPSI_LIM =SIMP(statut='f',typ='R', fr="Deformation limite, post-traitement"),
),
# ============================================================================
ACIER =FACT(statut= 'f',max= 1,
- fr="Définir les paramètres matériaux de l'acier pour le Génie Civil",
+ fr="Definir les parametres materiaux de l'acier pour le Genie Civil",
E =SIMP(statut='o',typ='R', val_min=0.0E+0, fr="Module d'Young"),
- SY =SIMP(statut='o',typ='R', fr="Limite élastique"),
+ SY =SIMP(statut='o',typ='R', fr="Limite elastique"),
NU =SIMP(statut='f',typ='R', val_min=0.0E+0, val_max=0.5E+0, fr="Coefficient de poisson"),
D_SIGM_EPSI =SIMP(statut='f',typ='R', fr="Module plastique"),
# Pour post-traitement ELS et ELU
SIGM_LIM =SIMP(statut='f',typ='R', fr="Contrainte limite, post-traitement"),
- EPSI_LIM =SIMP(statut='f',typ='R', fr="Déformation limite, post-traitement"),
+ EPSI_LIM =SIMP(statut='f',typ='R', fr="Deformation limite, post-traitement"),
),
# ============================================================================
ENDO_FISS_EXP =FACT(statut= 'f',max= 1,
- fr="Définir les paramètres matériaux du béton pour la loi ENDO_FISS_EXP",
+ fr="Definir les parametres materiaux du beton pour la loi ENDO_FISS_EXP",
regles = (
UN_PARMI('FT','FT_FENDAGE'),
UN_PARMI('P','DSIG_DU'),
E =SIMP(statut='o',typ='R', val_min=0.0E+0, fr="Module d'Young"),
NU =SIMP(statut='o',typ='R', val_min=0.0E+0, val_max=0.5E+0, fr="Coefficient de poisson"),
FT =SIMP(statut='f',typ='R', val_min=0.0E+0 , fr="Limite en traction simple"),
- FT_FENDAGE =SIMP(statut='f',typ='R', val_min=0.0E+0 , fr="Limite en traction obtenue via un essai brésilien"),
+ FT_FENDAGE =SIMP(statut='f',typ='R', val_min=0.0E+0 , fr="Limite en traction obtenue via un essai bresilien"),
FC =SIMP(statut='o',typ='R', val_min=0.0E+0 , fr="Limite en compression simple"),
GF =SIMP(statut='o',typ='R', val_min=0.0E+0 , fr="Energie de fissuration"),
- P =SIMP(statut='f',typ='R', val_min=1.0E+0 , fr="Parametre dominant de la loi cohésive asymptotique"),
+ P =SIMP(statut='f',typ='R', val_min=1.0E+0 , fr="Parametre dominant de la loi cohesive asymptotique"),
DSIG_DU =SIMP(statut='f',typ='R', val_min=1.102658 , fr="Pente initiale (au signe pres) de la loi cohesive asymptotique"),
Q =SIMP(statut='f',typ='R', val_min=0.0E+0 , fr="Parametre secondaire de la loi cohesive asymptotique"),
Q_REL =SIMP(statut='f',typ='R', val_min=0.0E+0, val_max=1.0 , fr="Parametre Q exprime de maniere relative par rapport a Qmax(P)"),
# ======================================================================
# person_in_charge: j-pierre.lefebvre at edf.fr
DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
- fr="Définition des paramètres décrivant le comportement d un matériau",
+ fr="Definition des parametres decrivant le comportement d un materiau",
reentrant='f',
- UIinfo={"groupes":("Modélisation",)},
+ UIinfo={"groupes":("Modelisation",)},
regles=(EXCLUS('ELAS','ELAS_FO','ELAS_FLUI','ELAS_ISTR','ELAS_ISTR_FO','ELAS_ORTH',
'ELAS_ORTH_FO','ELAS_COQUE','ELAS_COQUE_FO',
'ELAS_HYPER','ELAS_2NDG','ELAS_GLRC'),
),
MATER =SIMP(statut='f',typ=mater_sdaster),
#
-# comportement élastique
+# comportement elastique
#
ELAS =FACT(statut='f',
E =SIMP(statut='o',typ='R',val_min=0.E+0),
ELAS_HYPER =FACT(statut='f',
regles=(UN_PARMI('K','NU'),),
C10 =SIMP(statut='o',typ='R',
- fr="Si C10 est le seul coefficient fourni, alors le matériau est Néo-Hookéen."),
+ fr="Si C10 est le seul coefficient fourni, alors le materiau est Neo-Hookeen."),
C01 =SIMP(statut='f',typ='R',defaut=0.0,
- fr="Si l'on fournit C01 en plus de C10, on obtient un matériau de type Mooney-Rivlin."),
+ fr="Si l'on fournit C01 en plus de C10, on obtient un materiau de type Mooney-Rivlin."),
C20 =SIMP(statut='f',typ='R',defaut=0.0,
- fr="Si l'on fournit C20 en plus de C10 et C01, on obtient un matériau de type Signorini."),
- K =SIMP(statut='f',typ='R',fr="Module de compressibilité."),
+ fr="Si l'on fournit C20 en plus de C10 et C01, on obtient un materiau de type Signorini."),
+ K =SIMP(statut='f',typ='R',fr="Module de compressibilite."),
NU =SIMP(statut='f',typ='R',val_min=-1.E+0,val_max=0.5E+0,fr="Coefficient de Poisson."),
RHO =SIMP(statut='f',typ='R',defaut=0.0,fr="Masse volumique."),
),
EC_SUR_E =SIMP(statut='f',typ='R',defaut= 1.E-4 ),
),
#
-# comportements mécanique non linéaire
-# vérification du domaine de validité
+# comportements mecanique non lineaire
+# verification du domaine de validite
VERI_BORNE =FACT(statut='f',
regles=(ENSEMBLE('TEMP_MAXI','TEMP_MINI'),
),
PENA_LAGR =SIMP(statut='o',typ='R',val_min=0.E+0),
),
-# Discrets non-linéaires : début
+# Discrets non-lineaires : debut
DIS_ECRO_CINE =FACT(statut='f',
- fr="Loi pour les discrets avec écrouissage cinématique.",
+ fr="Loi pour les discrets avec ecrouissage cinematique.",
regles=(PRESENT_PRESENT('LIMY_DX','KCIN_DX',),PRESENT_PRESENT('PUIS_DX','LIMU_DX',),
PRESENT_PRESENT('LIMY_DY','KCIN_DY',),PRESENT_PRESENT('PUIS_DY','LIMU_DY',),
PRESENT_PRESENT('LIMY_DZ','KCIN_DZ',),PRESENT_PRESENT('PUIS_DZ','LIMU_DZ',),
PRESENT_PRESENT('LIMY_RY','KCIN_RY',),PRESENT_PRESENT('PUIS_RY','LIMU_RY',),
PRESENT_PRESENT('LIMY_RZ','KCIN_RZ',),PRESENT_PRESENT('PUIS_RZ','LIMU_RZ',),),
LIMY_DX =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Effort limite élastique suivant l'axe local x de l'élément."),
+ fr="Effort limite elastique suivant l'axe local x de l'element."),
LIMY_DY =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Effort limite élastique suivant l'axe local y de l'élément."),
+ fr="Effort limite elastique suivant l'axe local y de l'element."),
LIMY_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Effort limite élastique suivant l'axe local z de l'élément."),
+ fr="Effort limite elastique suivant l'axe local z de l'element."),
LIMY_RX =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Moment limite élastique suivant l'axe local x de l'élément."),
+ fr="Moment limite elastique suivant l'axe local x de l'element."),
LIMY_RY =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Moment limite élastique suivant l'axe local y de l'élément."),
+ fr="Moment limite elastique suivant l'axe local y de l'element."),
LIMY_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Moment limite élastique suivant l'axe local z de l'élément."),
+ fr="Moment limite elastique suivant l'axe local z de l'element."),
KCIN_DX =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Raideur suivant l'axe local x de l'élément."),
+ fr="Raideur suivant l'axe local x de l'element."),
KCIN_DY =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Raideur suivant l'axe local y de l'élément."),
+ fr="Raideur suivant l'axe local y de l'element."),
KCIN_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Raideur suivant l'axe local z de l'élément."),
+ fr="Raideur suivant l'axe local z de l'element."),
KCIN_RX =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Raideur suivant l'axe local Rx de l'élément."),
+ fr="Raideur suivant l'axe local Rx de l'element."),
KCIN_RY =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Raideur suivant l'axe local Ry de l'élément."),
+ fr="Raideur suivant l'axe local Ry de l'element."),
KCIN_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Raideur suivant l'axe local Rz de l'élément."),
+ fr="Raideur suivant l'axe local Rz de l'element."),
LIMU_DX =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Effort limite suivant l'axe local x de l'élément."),
+ fr="Effort limite suivant l'axe local x de l'element."),
LIMU_DY =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Effort limite suivant l'axe local y de l'élément."),
+ fr="Effort limite suivant l'axe local y de l'element."),
LIMU_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Effort limite suivant l'axe local z de l'élément."),
+ fr="Effort limite suivant l'axe local z de l'element."),
LIMU_RX =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Moment limite suivant l'axe local x de l'élément."),
+ fr="Moment limite suivant l'axe local x de l'element."),
LIMU_RY =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Moment limite suivant l'axe local y de l'élément."),
+ fr="Moment limite suivant l'axe local y de l'element."),
LIMU_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Moment limite suivant l'axe local z de l'élément."),
+ fr="Moment limite suivant l'axe local z de l'element."),
PUIS_DX =SIMP(statut='f',typ='R',val_min = 1.0,
- fr="Coefficient de non-linéarité suivant l'axe local x de l'élément."),
+ fr="Coefficient de non-linearite suivant l'axe local x de l'element."),
PUIS_DY =SIMP(statut='f',typ='R',val_min = 1.0,
- fr="Coefficient de non-linéarité suivant l'axe local y de l'élément."),
+ fr="Coefficient de non-linearite suivant l'axe local y de l'element."),
PUIS_DZ =SIMP(statut='f',typ='R',val_min = 1.0,
- fr="Coefficient de non-linéarité suivant l'axe local z de l'élément."),
+ fr="Coefficient de non-linearite suivant l'axe local z de l'element."),
PUIS_RX =SIMP(statut='f',typ='R',val_min = 1.0,
- fr="Coefficient de non-linéarité suivant l'axe local Rx de l'élément."),
+ fr="Coefficient de non-linearite suivant l'axe local Rx de l'element."),
PUIS_RY =SIMP(statut='f',typ='R',val_min = 1.0,
- fr="Coefficient de non-linéarité suivant l'axe local Ry de l'élément."),
+ fr="Coefficient de non-linearite suivant l'axe local Ry de l'element."),
PUIS_RZ =SIMP(statut='f',typ='R',val_min = 1.0,
- fr="Coefficient de non-linéarité suivant l'axe local Rz de l'élément."),
+ fr="Coefficient de non-linearite suivant l'axe local Rz de l'element."),
),
DIS_VISC =FACT(statut='f',
- fr="Loi pour un discret de type visqueux : Zener Généralisé.",
+ fr="Loi pour un discret de type visqueux : Zener Generalise.",
regles=(UN_PARMI('K1','UNSUR_K1'),
UN_PARMI('K2','UNSUR_K2'),
UN_PARMI('K3','UNSUR_K3'), ),
K1 =SIMP(statut='f',typ='R',val_min = 1.0E-08,
- fr="Raideur en série avec les 2 autres branches."),
+ fr="Raideur en serie avec les 2 autres branches."),
K2 =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Raideur en parallèle de la branche visqueuse."),
+ fr="Raideur en parallele de la branche visqueuse."),
K3 =SIMP(statut='f',typ='R',val_min = 1.0E-08,
fr="Raideur dans la branche visqueuse."),
UNSUR_K1 =SIMP(statut='f',typ='R',val_min = 0.0,
- fr="Souplesse en série avec les 2 autres branches."),
+ fr="Souplesse en serie avec les 2 autres branches."),
UNSUR_K2 =SIMP(statut='f',typ='R',val_min = 1.0E-08,
- fr="Souplesse en parallèle de la branche visqueuse."),
+ fr="Souplesse en parallele de la branche visqueuse."),
UNSUR_K3 =SIMP(statut='f',typ='R',val_min = 0.0,
fr="Souplesse dans la branche visqueuse."),
C =SIMP(statut='o',typ='R',val_min = 1.0E-08,
fr="Puissance de la loi visqueuse ]0.0, 1.0] ."),
),
DIS_BILI_ELAS =FACT(statut='f',
- fr="Loi bi-linéaire pour les discrets.",
+ fr="Loi bi-lineaire pour les discrets.",
regles=(PRESENT_PRESENT('KDEB_DX','KFIN_DX','FPRE_DX',),
PRESENT_PRESENT('KDEB_DY','KFIN_DY','FPRE_DY',),
PRESENT_PRESENT('KDEB_DZ','KFIN_DZ','FPRE_DZ',),),
KDEB_DX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
- fr="Raideur début suivant l'axe local x de l'élément."),
+ fr="Raideur debut suivant l'axe local x de l'element."),
KDEB_DY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
- fr="Raideur début suivant l'axe local y de l'élément."),
+ fr="Raideur debut suivant l'axe local y de l'element."),
KDEB_DZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
- fr="Raideur début suivant l'axe local z de l'élément."),
+ fr="Raideur debut suivant l'axe local z de l'element."),
KFIN_DX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
- fr="Raideur fin l'axe local x de l'élément."),
+ fr="Raideur fin l'axe local x de l'element."),
KFIN_DY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
- fr="Raideur fin l'axe local y de l'élément."),
+ fr="Raideur fin l'axe local y de l'element."),
KFIN_DZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
- fr="Raideur fin l'axe local z de l'élément."),
+ fr="Raideur fin l'axe local z de l'element."),
FPRE_DX =SIMP(statut='f',typ='R',
- fr="Effort de préserrage suivant l'axe local x de l'élément."),
+ fr="Effort de preserrage suivant l'axe local x de l'element."),
FPRE_DY =SIMP(statut='f',typ='R',
- fr="Effort de préserrage suivant l'axe local y de l'élément."),
+ fr="Effort de preserrage suivant l'axe local y de l'element."),
FPRE_DZ =SIMP(statut='f',typ='R',
- fr="Effort de préserrage suivant l'axe local z de l'élément."),
+ fr="Effort de preserrage suivant l'axe local z de l'element."),
),
-# Discrets non-linéaires : fin
+# Discrets non-lineaires : fin
#
# comportement thermique
#
FONCTION =SIMP(statut='o',typ=(nappe_sdaster,formule)),
),
#
-# comportement métallurgique
+# comportement metallurgique
#
META_ACIER =FACT(statut='f',
TRC =SIMP(statut='o',typ=(table_sdaster) ),
# --- THM_INIT, THM_DIFFU, THM_LIQU -----------------------------------------------
# =================================================================================
b_liqusatu = BLOC(condition = "COMP_THM == 'LIQU_SATU' ",
- fr="Paramètres nécessaires pour une loi de couplage de type LIQU_SATU",
+ fr="Parametres necessaires pour une loi de couplage de type LIQU_SATU",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ --------------------------------------
# =================================================================================
b_liqugaz = BLOC(condition = "COMP_THM == 'LIQU_GAZ' ",
- fr="Paramètres nécessaires pour une loi de couplage de type LIQU_GAZ",
+ fr="Parametres necessaires pour une loi de couplage de type LIQU_GAZ",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
# --- THM_INIT, THM_DIFFU, THM_GAZ ------------------------------------------------
# =================================================================================
b_gaz = BLOC(condition = "COMP_THM == 'GAZ' ",
- fr="Paramètres nécessaires pour une loi de couplage de type GAZ",
+ fr="Parametres necessaires pour une loi de couplage de type GAZ",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ --------------------------------------
# =================================================================================
b_liqugazatm = BLOC(condition = "COMP_THM == 'LIQU_GAZ_ATM' ",
- fr="Paramètres nécessaires pour une loi de couplage de type LIQU_GAZ_ATM",
+ fr="Parametres necessaires pour une loi de couplage de type LIQU_GAZ_ATM",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ, THM_AIR_DISSOUS---------
# =================================================================================
b_liquadgaz = BLOC(condition = "COMP_THM == 'LIQU_AD_GAZ' ",
- fr="Paramètres nécessaires pour une loi de couplage de type LIQU_AD_GAZ",
+ fr="Parametres necessaires pour une loi de couplage de type LIQU_AD_GAZ",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ, THM_VAPE_GAZ ------------------------
# =================================================================================
b_liquvapegaz = BLOC(condition = "COMP_THM == 'LIQU_VAPE_GAZ' ",
- fr="Paramètres nécessaires pour une loi de couplage de type LIQU_VAPE_GAZ",
+ fr="Parametres necessaires pour une loi de couplage de type LIQU_VAPE_GAZ",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ, THM_VAPE_GAZ THM_AIR_DISSOUS---------
# =================================================================================
b_liquadvape = BLOC(condition = "COMP_THM == 'LIQU_AD_GAZ_VAPE' ",
- fr="Paramètres nécessaires pour une loi de couplage de type LIQU_AD_GAZ_VAPE",
+ fr="Parametres necessaires pour une loi de couplage de type LIQU_AD_GAZ_VAPE",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_VAPE_GAZ ---------------------------------
# =================================================================================
b_liquvape = BLOC(condition = "COMP_THM == 'LIQU_VAPE' ",
- fr="Paramètres nécessaires pour une loi de couplage de type LIQU_VAPE",
+ fr="Parametres necessaires pour une loi de couplage de type LIQU_VAPE",
# =================================================================================
# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
# =================================================================================
D_VISC_TEMP =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
),
),
-# courbes et coefficients associés à la fatigue et au dommage
+# courbes et coefficients associes a la fatigue et au dommage
#
FATIGUE =FACT(statut='f',
regles=(PRESENT_ABSENT('WOHLER','A_BASQUIN','BETA_BASQUIN'),
) ),
b_critere_matake =BLOC(condition="CRITERE=='MATAKE_MODI_AC' or CRITERE=='MATAKE_MODI_AV'",
- fr="Cisaillement plan critique critère de matake pour les cas amplitude constante et amplitude variable",
+ fr="Cisaillement plan critique critere de matake pour les cas amplitude constante et amplitude variable",
MATAKE_A =SIMP(statut='o',typ='R'),
MATAKE_B =SIMP(statut='o',typ='R'),
COEF_FLEX_TORS =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
),
b_critere_dang_van =BLOC(condition="(CRITERE=='DANG_VAN_MODI_AC' or CRITERE=='DANG_VAN_MODI_AV')",
- fr="Critère de Dang Van modifié pour les cas amplitude constante et amplitude variable",
+ fr="Critere de Dang Van modifie pour les cas amplitude constante et amplitude variable",
D_VAN_A =SIMP(statut='o',typ='R'),
D_VAN_B =SIMP(statut='o',typ='R'),
COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
),
b_critere_fate_soci =BLOC(condition="CRITERE=='FATESOCI_MODI_AV'",
- fr="Critère de Fatemi et Socie, en élasticité ou élastoplasticité, pour le cas amplitude variable",
+ fr="Critere de Fatemi et Socie, en elasticite ou elastoplasticite, pour le cas amplitude variable",
FATSOC_A =SIMP(statut='o',typ='R'),
COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
),
LETK =FACT(statut='f',
PA =SIMP(statut='o',typ='R',fr="pression atmospherique"),
NELAS =SIMP(statut='o',typ='R',fr="exposant de la loi de variation des modules K et G"),
- SIGMA_C =SIMP(statut='o',typ='R',fr="résistance en compression simple "),
- H0_EXT =SIMP(statut='o',typ='R',fr="parametre pilotant la résistance en extension"),
- GAMMA_CJS =SIMP(statut='o',typ='R',fr="parametre de forme du critere ds le plan déviatoire entre 0 et 1."),
- XAMS =SIMP(statut='o',typ='R',fr="parametre non nul intervenant dans les lois d'écrouissage pre pic"),
- ETA =SIMP(statut='o',typ='R',fr="parametre non nul intervenant dans les lois d'écrouissage post pic"),
- A_0 =SIMP(statut='o',typ='R',fr="a de la limite d'élasticité initiale"),
- A_E =SIMP(statut='o',typ='R',fr="a de la limite de clivage ou seuil intermédiaire"),
+ SIGMA_C =SIMP(statut='o',typ='R',fr="resistance en compression simple "),
+ H0_EXT =SIMP(statut='o',typ='R',fr="parametre pilotant la resistance en extension"),
+ GAMMA_CJS =SIMP(statut='o',typ='R',fr="parametre de forme du critere ds le plan deviatoire entre 0 et 1."),
+ XAMS =SIMP(statut='o',typ='R',fr="parametre non nul intervenant dans les lois d'ecrouissage pre pic"),
+ ETA =SIMP(statut='o',typ='R',fr="parametre non nul intervenant dans les lois d'ecrouissage post pic"),
+ A_0 =SIMP(statut='o',typ='R',fr="a de la limite d'elasticite initiale"),
+ A_E =SIMP(statut='o',typ='R',fr="a de la limite de clivage ou seuil intermediaire"),
A_PIC =SIMP(statut='o',typ='R',fr="a du seuil de pic"),
- S_0 =SIMP(statut='o',typ='R',fr="s de la limite d'élasticité initiale"),
- M_0 =SIMP(statut='o',typ='R',fr="m de la limite d'élasticité initiale"),
- M_E =SIMP(statut='o',typ='R',fr="m de la limite de clivage ou seuil intermédiaire"),
+ S_0 =SIMP(statut='o',typ='R',fr="s de la limite d'elasticite initiale"),
+ M_0 =SIMP(statut='o',typ='R',fr="m de la limite d'elasticite initiale"),
+ M_E =SIMP(statut='o',typ='R',fr="m de la limite de clivage ou seuil intermediaire"),
M_PIC =SIMP(statut='o',typ='R',fr="m du seuil de pic"),
M_ULT =SIMP(statut='o',typ='R',fr="m du seuil residuel"),
- XI_ULT =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil résiduel"),
- XI_E =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil de clivage"),
- XI_PIC =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil de pic"),
+ XI_ULT =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil residuel"),
+ XI_E =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil de clivage"),
+ XI_PIC =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil de pic"),
MV_MAX =SIMP(statut='o',typ='R',fr="m du seuil viscoplastique maximal"),
- XIV_MAX =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil viscoplastique maximal"),
+ XIV_MAX =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil viscoplastique maximal"),
A =SIMP(statut='o',typ='R',fr="parametre carcaterisant l amplitude de la vitesse de fluage"),
N =SIMP(statut='o',typ='R',fr="parametre intervenant dans la formule pilotant la cinetique de fluage"),
SIGMA_P1 =SIMP(statut='o',typ='R',fr="SIG min de l intersection du seuil de pic et intermediaire "),
- MU0_V =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance des mecanismes pre pic et viscoplastique"),
- XI0_V =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance des mecanismes pre pic et viscoplastique"),
- MU1 =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance du mecanisme post pic "),
- XI1 =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance du mecanisme post pic "),
+ MU0_V =SIMP(statut='o',typ='R',fr="relatif a l angle de dilatance des mecanismes pre pic et viscoplastique"),
+ XI0_V =SIMP(statut='o',typ='R',fr="relatif a l angle de dilatance des mecanismes pre pic et viscoplastique"),
+ MU1 =SIMP(statut='o',typ='R',fr="relatif a l angle de dilatance du mecanisme post pic "),
+ XI1 =SIMP(statut='o',typ='R',fr="relatif a l angle de dilatance du mecanisme post pic "),
),
DRUCK_PRAGER =FACT(statut='f',
ALPHA =SIMP(statut='o',typ='R'),
N =SIMP(statut='o',typ='R',fr="parametre intervenant dans la formule pilotant la cinetique de fluage"),
P_PIC =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil de pic"),
P_ULT =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil utime"),
- ALPHA_0 =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la cohesion au seuil d elasticite"),
- ALPHA_PIC =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la cohesion au seuil de pic"),
- ALPHA_ULT =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la cohesion au seuil ultime"),
+ ALPHA_0 =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif a la cohesion au seuil d elasticite"),
+ ALPHA_PIC =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif a la cohesion au seuil de pic"),
+ ALPHA_ULT =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif a la cohesion au seuil ultime"),
R_0 =SIMP(statut='o',typ='R',fr="parametre d ecrouissage correspondant au seuil d'elasticite"),
R_PIC =SIMP(statut='o',typ='R',fr="parametre d ecrouissage correspondant au seuil de pic"),
R_ULT =SIMP(statut='o',typ='R',fr="parametre d ecrouissage correspondant au seuil ultime"),
- BETA_0 =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la dilatance au seuil d elasticite"),
- BETA_PIC =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la dilatance au seuil de pic"),
- BETA_ULT =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la dilatance au seuil ultime"),
+ BETA_0 =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif a la dilatance au seuil d elasticite"),
+ BETA_PIC =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif a la dilatance au seuil de pic"),
+ BETA_ULT =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif a la dilatance au seuil ultime"),
),
HOEK_BROWN =FACT(statut='f',
GAMMA_RUP =SIMP(statut='o',typ='R'),
),
# TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
K =SIMP(statut='o',typ='R',fr="Constante de Boltzmann, en eV/K"),
- TAUR =SIMP(statut='o',typ='R',fr="Contraintes de cisaillement à T=0K, en unite de contraintes"),
+ TAUR =SIMP(statut='o',typ='R',fr="Contraintes de cisaillement a T=0K, en unite de contraintes"),
TAU0 =SIMP(statut='o',typ='R',fr="Contraintes critique initiale de cisaillement, en unite de contraintes"),
GAMMA0 =SIMP(statut='o',typ='R',fr="Vitesse d ecoulement initiale"),
DELTAG0 =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"),
BSD =SIMP(statut='o',typ='R',fr="fonction de la taille du grain B/D"),
GCB =SIMP(statut='o',typ='R',fr="distance critique d'annihilation GC/B"),
- KDCS =SIMP(statut='o',typ='R',fr="Parametre relatif à la direction principale de la dislocation"),
- P =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"),
- Q =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"),
+ KDCS =SIMP(statut='o',typ='R',fr="Parametre relatif a la direction principale de la dislocation"),
+ P =SIMP(statut='o',typ='R',fr="Parametre materiau dependant de la forme de l'obstacle"),
+ Q =SIMP(statut='o',typ='R',fr="Parametre materiau dependant de la forme de l'obstacle"),
H =SIMP(statut='f',typ='R'),
H1 =SIMP(statut='f',typ='R'),
H2 =SIMP(statut='f',typ='R'),
#TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
GAMMA0 =SIMP(statut='f',typ='R',defaut=0.001,fr="Vitesse d ecoulement initiale en s**-1"),
TAU_F =SIMP(statut='o',typ='R',fr="Contraintes , en unite de contraintes ex 20 MPa"),
- A =SIMP(statut='f',typ='R',defaut=0.13,fr="paramètre A, sans unité"),
- B =SIMP(statut='f',typ='R',defaut=0.005,fr="paramètre B, sans unité"),
- N =SIMP(statut='f',typ='R',defaut=200.,fr="paramètre n, sans unité"),
- Y =SIMP(statut='o',typ='R',fr="paramète Y, en unité de longueur ex 2.5 A"),
- ALPHA =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, paramètre alpha"),
- BETA =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre b, en unite de longueur"),
- RHO_REF =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre rho_ref, en unité de longueur **-2"),
+ A =SIMP(statut='f',typ='R',defaut=0.13,fr="parametre A, sans unite"),
+ B =SIMP(statut='f',typ='R',defaut=0.005,fr="parametre B, sans unite"),
+ N =SIMP(statut='f',typ='R',defaut=200.,fr="parametre n, sans unite"),
+ Y =SIMP(statut='o',typ='R',fr="paramete Y, en unite de longueur ex 2.5 A"),
+ ALPHA =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, parametre alpha"),
+ BETA =SIMP(statut='o',typ='R',fr="ecrouissage, parametre b, en unite de longueur"),
+ RHO_REF =SIMP(statut='o',typ='R',fr="ecrouissage, parametre rho_ref, en unite de longueur **-2"),
H =SIMP(statut='f',typ='R'),
H1 =SIMP(statut='f',typ='R',defaut=0.124,fr="matrice d'interaction, terme a*",),
H2 =SIMP(statut='f',typ='R',defaut=0.625,fr="matrice d'interaction, terme a_colineaire",),
#TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
GAMMA0 =SIMP(statut='f',typ='R',defaut=0.001,fr="Vitesse d ecoulement initiale en s**-1"),
TAU_F =SIMP(statut='o',typ='R',fr="Contraintes , en unite de contraintes ex 20 MPa"),
- A =SIMP(statut='f',typ='R',defaut=0.13,fr="paramètre A, sans unité"),
- B =SIMP(statut='f',typ='R',defaut=0.005,fr="paramètre B, sans unité"),
- N =SIMP(statut='f',typ='R',defaut=200.,fr="paramètre n, sans unité"),
- Y =SIMP(statut='o',typ='R',fr="paramète Y, en unité de longueur ex 2.5 A"),
- ALPHA =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, paramètre alpha"),
- BETA =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre b, en unite de longueur"),
- RHO_REF =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre rho_ref, en unité de longueur **-2"),
+ A =SIMP(statut='f',typ='R',defaut=0.13,fr="parametre A, sans unite"),
+ B =SIMP(statut='f',typ='R',defaut=0.005,fr="parametre B, sans unite"),
+ N =SIMP(statut='f',typ='R',defaut=200.,fr="parametre n, sans unite"),
+ Y =SIMP(statut='o',typ='R',fr="paramete Y, en unite de longueur ex 2.5 A"),
+ ALPHA =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, parametre alpha"),
+ BETA =SIMP(statut='o',typ='R',fr="ecrouissage, parametre b, en unite de longueur"),
+ RHO_REF =SIMP(statut='o',typ='R',fr="ecrouissage, parametre rho_ref, en unite de longueur **-2"),
H =SIMP(statut='f',typ='R'),
H1 =SIMP(statut='f',typ='R',defaut=0.124,fr="matrice d'interaction, terme a*",),
H2 =SIMP(statut='f',typ='R',defaut=0.625,fr="matrice d'interaction, terme a_colineaire",),
#TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
GAMMA0 =SIMP(statut='o',typ='R',fr="Vitesse d ecoulement initiale en s**-1"),
TAU_F =SIMP(statut='o',typ='R',fr="Contraintes , en unite de contraintes ex 20 MPa"),
- BETA =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre b, en unite de longueur"),
- N =SIMP(statut='o',typ='R',fr="paramètre n, sans unite"),
- UN_SUR_D =SIMP(statut='o',typ='R',fr="paramètre 1/D, en unite de 1/longueur"),
- GC0 =SIMP(statut='o',typ='R',fr="paramètre GC0, en unite de longueur"),
- K =SIMP(statut='o',typ='R',fr="paramètre K, sans unite"),
+ BETA =SIMP(statut='o',typ='R',fr="ecrouissage, parametre b, en unite de longueur"),
+ N =SIMP(statut='o',typ='R',fr="parametre n, sans unite"),
+ UN_SUR_D =SIMP(statut='o',typ='R',fr="parametre 1/D, en unite de 1/longueur"),
+ GC0 =SIMP(statut='o',typ='R',fr="parametre GC0, en unite de longueur"),
+ K =SIMP(statut='o',typ='R',fr="parametre K, sans unite"),
H =SIMP(statut='f',typ='R'),
H1 =SIMP(statut='f',typ='R',defaut=0.124,fr="matrice d'interaction, terme a*",),
H2 =SIMP(statut='f',typ='R',defaut=0.625,fr="matrice d'interaction, terme a_colineaire",),
# person_in_charge: mathieu.corus at edf.fr
DEFI_MODELE_GENE=OPER(nom="DEFI_MODELE_GENE",op= 126,sd_prod=modele_gene,
reentrant='n',
- fr="Créer la structure globale à partir des sous-structures en sous-structuration dynamique",
+ fr="Creer la structure globale a partir des sous-structures en sous-structuration dynamique",
UIinfo={"groupes":("Matrices et vecteurs",)},
SOUS_STRUC =FACT(statut='o',max='**',
NOM =SIMP(statut='o',typ='TXM' ),
# ======================================================================
# person_in_charge: mathieu.courtois at edf.fr
DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op=4,sd_prod=nappe_sdaster,
- fr="Définir une fonction réelle de deux variables réelles",
+ fr="Definir une fonction reelle de deux variables reelles",
reentrant='n',UIinfo={"groupes":("Fonctions",)},
regles=(UN_PARMI('FONCTION','DEFI_FONCTION'),
EXCLUS('FONCTION','NOM_PARA_FONC',),
DEFI_FONCTION =FACT(statut='f',max='**',
VALE =SIMP(statut='o',typ='R',max='**'),
INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
- fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction."),
+ fr="Type d'interpolation pour les abscisses et les ordonnees de la fonction."),
PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
),
INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
- fr="Type d'interpolation pour le paramètre de la nappe"),
+ fr="Type d'interpolation pour le parametre de la nappe"),
PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1, 2) ),
# ======================================================================
# person_in_charge: marc.kham at edf.fr
DEFI_OBSTACLE=OPER(nom="DEFI_OBSTACLE",op= 73,sd_prod=table_fonction,
- fr="Définition d'un obstacle plan perpendiculaire à une structure filaire",
+ fr="Definition d'un obstacle plan perpendiculaire a une structure filaire",
reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
+ UIinfo={"groupes":("Modelisation",)},
TYPE =SIMP(statut='o',typ='TXM',defaut="CERCLE",
into=("CERCLE","PLAN_Y","PLAN_Z","DISCRET",
"BI_CERCLE","BI_PLAN_Y","BI_PLAN_Z","BI_CERC_INT",
DEFI_PART_OPS=OPER(nom="DEFI_PART_OPS",op=21,sd_prod=sd_partit,
fr="Creation partitionnement en sous-domaines",
docu="U4.23.05",reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
+ UIinfo={"groupes":("Modelisation",)},
MODELE =SIMP(statut='o',typ=(modele_sdaster) ),
MAILLAGE =SIMP(statut='f',typ=(maillage_sdaster) ),
NOM =SIMP(statut='f',typ='TXM',defaut='SD'),
DEFI_PART_PA_OPS=PROC(nom="DEFI_PART_PA_OPS",op=29,
fr="Creation partitionnement en sous-domaines",
docu="U4.00.00",
- UIinfo={"groupes":("Modélisation",)},
+ UIinfo={"groupes":("Modelisation",)},
MAILLAGE =SIMP(statut='o',typ=(maillage_sdaster,squelette) ),
MODELE =SIMP(statut='f',typ=(modele_sdaster)),
NB_PART =SIMP(statut='o',typ='I',),
# Traiter les mailles de bords (elles sont enlevees du graphe puis reinjectees)
TRAITER_BORDS =SIMP(statut='f',typ='TXM',defaut='OUI',into=('OUI','NON') ),
- # Si le mot-clé suivant est renseigné, crée de nouveau group_ma a partir des bords
- b_traiter_bords =BLOC(condition="TRAITER_BORDS == 'OUI'", fr="Crée t on des nouveaux group_ma",
+ # Si le mot-cle suivant est renseigne, cree de nouveau group_ma a partir des bords
+ b_traiter_bords =BLOC(condition="TRAITER_BORDS == 'OUI'", fr="Cree t on des nouveaux group_ma",
NOM_GROUP_MA_BORD =SIMP(statut='f',typ='TXM'),
),
DEFI_PARTITION=MACRO(nom="DEFI_PARTITION",
op=OPS('Macro.defi_partition_ops.defi_partition_ops'),
sd_prod=sd_partit,
- reentrant='n',UIinfo={"groupes":("Modélisation",)},
+ reentrant='n',UIinfo={"groupes":("Modelisation",)},
fr="Creation partitionnement en sous-domaines",
regles=(UN_PARMI('MAILLAGE','MODELE'),PRESENT_PRESENT('MODELE','EXCIT'),),
# Traiter les mailles de bords (elles sont enlevees du graphe puis reinjectees)
TRAITER_BORDS =SIMP(statut='f',typ='TXM',defaut='OUI',into=('OUI','NON') ),
- # Si le mot-clé suivant est renseigné, crée de nouveau group_ma a partir des bords
- b_traiter_bords =BLOC(condition="TRAITER_BORDS == 'OUI'", fr="Crée t on des nouveaux group_ma",
+ # Si le mot-cle suivant est renseigne, cree de nouveau group_ma a partir des bords
+ b_traiter_bords =BLOC(condition="TRAITER_BORDS == 'OUI'", fr="Cree t on des nouveaux group_ma",
NOM_GROUP_MA_BORD =SIMP(statut='f',typ='TXM'),
),
DEFI_SOL_MISS = MACRO(nom="DEFI_SOL_MISS",
op=OPS('Macro.defi_sol_miss_ops.defi_sol_miss_ops'),
sd_prod=table_sdaster,
- fr="Définition des données de sol pour Miss",
+ fr="Definition des donnees de sol pour Miss",
reentrant='n',
- UIinfo={"groupes":("Modélisation","Outils-métier",)},
+ UIinfo={"groupes":("Modelisation","Outils-metier",)},
MATERIAU = FACT(statut='o', max='**',
- fr="Définition des matériaux",
+ fr="Definition des materiaux",
E = SIMP(statut='o', typ='R', fr="Module d'Young"),
NU = SIMP(statut='o', typ='R', fr="Coefficient de Poisson"),
RHO = SIMP(statut='o', typ='R', fr="Masse volumique"),
AMOR_HYST = SIMP(statut='o', typ='R', fr="Coefficient d'amortissement"),
),
COUCHE = FACT(statut='o', max='**',
- fr="Définition des couches",
+ fr="Definition des couches",
regles=(AU_MOINS_UN('EPAIS','SUBSTRATUM'),),
SUBSTRATUM= SIMP(statut='f', typ='TXM', into=("OUI","NON"),),
EPAIS = SIMP(statut='f', typ='R', fr="Epaisseur de la couche"),
RECEPTEUR = SIMP(statut='f', typ='TXM', defaut="NON", into=("OUI", "NON"),),
SOURCE = SIMP(statut='f', typ='TXM', defaut="NON", into=("OUI", "NON"),),
- NUME_MATE = SIMP(statut='o', typ='I', fr="Numéro du matériau"),
+ NUME_MATE = SIMP(statut='o', typ='I', fr="Numero du materiau"),
),
TITRE = SIMP(statut='f', typ='TXM', max='**',
fr="Titre de la table produite"),
# ======================================================================
# person_in_charge: mathieu.corus at edf.fr
DEFI_SQUELETTE=OPER(nom="DEFI_SQUELETTE",op= 110,sd_prod=squelette,
- fr="Définit un maillage pour visualiser les résultats d'une sous-structuration dynamique",
+ fr="Definit un maillage pour visualiser les resultats d'une sous-structuration dynamique",
reentrant='n',
UIinfo={"groupes":("Maillage","Dynamique",)},
regles=(UN_PARMI('CYCLIQUE','MODELE_GENE','MAILLAGE'),
# ======================================================================
# person_in_charge: renaud.bargellini at edf.fr
DEFI_TRC=OPER(nom="DEFI_TRC",op=94,sd_prod=table_sdaster,reentrant='n',
- UIinfo={"groupes":("Modélisation","Thermique",)},
- fr="Définir d'un diagramme de transformations en refroidissement continu (TRC) de référence d'un acier"
- +" pour les calculs métallurgiques.",
+ UIinfo={"groupes":("Modelisation","Thermique",)},
+ fr="Definir d'un diagramme de transformations en refroidissement continu (TRC) de reference d'un acier"
+ +" pour les calculs metallurgiques.",
HIST_EXP =FACT(statut='o',max='**',
VALE =SIMP(statut='o',typ='R',max='**'),
),
DEPL_INTERNE=OPER(nom="DEPL_INTERNE",op=89,sd_prod=depl_interne_prod,reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
- fr="Calculer le champ de déplacement à l'intérieur d'une sous-structure statique",
+ fr="Calculer le champ de deplacement a l'interieur d'une sous-structure statique",
DEPL_GLOBAL =SIMP(statut='o',typ=(cham_no_sdaster,mode_meca,mode_meca_c,evol_elas,dyna_trans,dyna_harmo),),
SUPER_MAILLE =SIMP(statut='o',typ=ma,),
NOM_CAS =SIMP(statut='f',typ='TXM',defaut=" "),
DETRUIRE=MACRO(nom="DETRUIRE",
op=OPS("Cata.ops.DETRUIRE"),
UIinfo={"groupes":("Gestion du travail",)},
- fr="Détruit des concepts utilisateurs dans la base GLOBALE ou des objets JEVEUX",
+ fr="Detruit des concepts utilisateurs dans la base GLOBALE ou des objets JEVEUX",
op_init=ops.build_detruire,
regles=(UN_PARMI('CONCEPT', 'OBJET',),),
# ======================================================================
# person_in_charge: irmela.zentner at edf.fr
DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=interspectre,
- fr="Calcul de la réponse spectrale d'une structure linéaire sous une excitation connue par sa DSP",
+ fr="Calcul de la reponse spectrale d'une structure lineaire sous une excitation connue par sa DSP",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
BASE_MODALE =FACT(statut='o',
regles=(UN_PARMI('NUME_ORDRE','BANDE'),),
MODE_MECA =SIMP(statut='o',typ=mode_meca ),
DYNA_ISS_VARI=MACRO(nom="DYNA_ISS_VARI",
op=OPS('Macro.dyna_iss_vari_ops.dyna_iss_vari_ops'),
sd_prod=dyna_iss_vari_prod,
- fr="Calcul du spectre de réponse ou de la reponse temporelle " \
+ fr="Calcul du spectre de reponse ou de la reponse temporelle " \
"sismique incoherente par decomposition spectrale",
reentrant='n',
- UIinfo={"groupes":("Outils métier",)},
+ UIinfo={"groupes":("Outils metier",)},
regles=(UN_PARMI('FONC_SIGNAL','NB_FREQ'),),
FONC_SIGNAL =SIMP(statut='f',typ=(fonction_sdaster) ),
NB_FREQ =SIMP(statut='f',typ='I' ),
raise AsException("type de concept resultat non prevu")
DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op= 60,sd_prod=dyna_line_harm_prod,
- fr="Calcul de la réponse dynamique complexe d'un système à une excitation harmonique",
+ fr="Calcul de la reponse dynamique complexe d'un systeme a une excitation harmonique",
reentrant='f',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
regles=(PRESENT_ABSENT('MATR_AMOR','AMOR_MODAL'),
UN_PARMI('FREQ','LIST_FREQ'),),
CHAM_MATER =SIMP(statut='f',typ=cham_mater ),
# ======================================================================
# person_in_charge: emmanuel.boyere at edf.fr
DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans,
- fr="Calcul de la réponse dynamique transitoire à une excitation temporelle quelconque",
+ fr="Calcul de la reponse dynamique transitoire a une excitation temporelle quelconque",
reentrant='f',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
MODELE =SIMP(statut='f',typ=modele_sdaster ),
CHAM_MATER =SIMP(statut='f',typ=cham_mater ),
CARA_ELEM =SIMP(statut='f',typ=cara_elem ),
# person_in_charge: nicolas.greffet at edf.fr
#
DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f',
- fr="Calcul de l'évolution dynamique d'une structure dont le matériau ou la géométrie ont un comportement non linéaire",
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ fr="Calcul de l'evolution dynamique d'une structure dont le materiau ou la geometrie ont un comportement non lineaire",
+ UIinfo={"groupes":("Resolution","Dynamique",)},
MODELE =SIMP(statut='o',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='o',typ=cham_mater),
MODE_STAT =SIMP(statut='f',typ=mode_meca),
MODI_RIGI =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
bloc_char_crit=BLOC(condition="(RIGI_GEOM=='OUI')",
CHAR_CRIT =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Valeur des deux charges critiques délimitant la bande de recherche en HPP"),),
+ fr="Valeur des deux charges critiques delimitant la bande de recherche en HPP"),),
TYPE =SIMP(statut='f',typ='TXM',defaut="FLAMBEMENT",into=("FLAMBEMENT","STABILITE")),
PREC_INSTAB =SIMP(statut='f',typ='R',defaut=1.E-6,max=1,),
SIGNE =SIMP(statut='f',typ='TXM',defaut=("POSITIF_NEGATIF"),into=("NEGATIF","POSITIF","POSITIF_NEGATIF"),max=1,),
MODE_VIBR =FACT(statut='f',min=1,max=1,
MATR_RIGI =SIMP(statut='f',typ='TXM',defaut="ELASTIQUE",into=("ELASTIQUE","TANGENTE","SECANTE",) ),
NB_FREQ =SIMP(statut='f',typ='I',max=1,val_min=1,defaut=3,
- fr="Nombre de fréquences propres à calculer"),
+ fr="Nombre de frequences propres a calculer"),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I',max=1,val_min=2,defaut=5),
BANDE =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Valeur des deux fréquences délimitant la bande de recherche",),
+ fr="Valeur des deux frequences delimitant la bande de recherche",),
regles = (EXCLUS('PAS_CALC','LIST_INST','INST'),),
LIST_INST = SIMP(statut='f',typ=(listr8_sdaster) ),
INST = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
#-------------------------------------------------------------------
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
b_info=BLOC(condition="(INFO==2)",
- fr="filtre les messages émis dans le .mess selon le type de message demandé",
+ fr="filtre les messages emis dans le .mess selon le type de message demande",
INFO_DBG = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(),
into=("CONTACT",
"MECA_NON_LINE",
# ======================================================================
# person_in_charge: andre.adobes at edf.fr
DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=interspectre,
- fr="Calcul de la réponse par recombinaison modale d'une structure linéaire pour une excitation aléatoire",
+ fr="Calcul de la reponse par recombinaison modale d'une structure lineaire pour une excitation aleatoire",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
BASE_ELAS_FLUI =SIMP(statut='o',typ=melasflu_sdaster ),
VITE_FLUI =SIMP(statut='o',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
raise AsException("type de concept resultat non prevu")
ELIM_LAGR=OPER(nom="ELIM_LAGR",op=69,sd_prod=elim_lagr_prod,
- fr="Créer une matrice en ayant éliminé les condition cinématiques dualisées.",
- reentrant='f', UIinfo={"groupes":("Résolution",)},
+ fr="Creer une matrice en ayant elimine les condition cinematiques dualisees.",
+ reentrant='f', UIinfo={"groupes":("Resolution",)},
- # Matrice de "rigidité" (celle qui contient les équations dualisées) :
+ # Matrice de "rigidite" (celle qui contient les equations dualisees) :
MATR_RIGI =SIMP(statut='o',typ=(matr_asse_depl_r,) ),
- # Matrice à réduire (si ce n'est pas la matrice de rigidité) :
+ # Matrice a reduire (si ce n'est pas la matrice de rigidite) :
MATR_ASSE =SIMP(statut='f',typ=(matr_asse_depl_r,) ),
# person_in_charge: jacques.pellet at edf.fr
ENGENDRE_TEST=PROC(nom="ENGENDRE_TEST",op=178,
UIinfo={"groupes":("Impression","Utilitaires",)},
- fr="Engendre des tests pour la non régression du code (pour développeurs)",
+ fr="Engendre des tests pour la non regression du code (pour developpeurs)",
UNITE =SIMP(statut='f',typ='I',defaut=8),
FORMAT =SIMP(statut='f',typ='TXM',into=("OBJET",) ),
FORMAT_R =SIMP(statut='f',typ='TXM',defaut="1PE20.13"),
#
ENV_CINE_YACS=PROC(nom = "ENV_CINE_YACS",
op = 111,
- UIinfo = {"groupes":("Résultats et champs",)},
+ UIinfo = {"groupes":("Resultats et champs",)},
fr = "Envoi des champs de deplacement et vitesse via YACS pour Couplage de Code_Aster et Saturne",
regles = (EXCLUS('ETAT_INIT','RESULTAT',),),
MATR_PROJECTION = SIMP(statut='o', typ=corresp_2_mailla,),
EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",
op=OPS('Macro.exec_logiciel_ops.exec_logiciel_ops'),
sd_prod=exec_logiciel_prod,
- fr="Exécute un logiciel ou une commande système depuis Aster",
- UIinfo={"groupes":("Gestion du travail","Outils-métier",)},
+ fr="Execute un logiciel ou une commande systeme depuis Aster",
+ UIinfo={"groupes":("Gestion du travail","Outils-metier",)},
regles = ( AU_MOINS_UN('LOGICIEL', 'MAILLAGE', 'SALOME'),
EXCLUS('MACHINE_DISTANTE','MAILLAGE'),
MACHINE_DISTANTE = FACT(statut='f',
SSH_ADRESSE = SIMP(statut='o', typ='TXM', val_min=1, val_max=255,
- fr="Adresse IP ou nom de la machine sur laquelle le logiciel/script sera exécuté via SSH"),
+ fr="Adresse IP ou nom de la machine sur laquelle le logiciel/script sera execute via SSH"),
SSH_LOGIN = SIMP(statut='f', typ='TXM', val_min=1, val_max=255,
fr="Nom d'utilisateur sur la machine distante"),
SSH_PORT = SIMP(statut='f', typ='I', val_min=1, val_max=65535, defaut=22,
MAILLAGE = FACT(statut='f',
FORMAT = SIMP(statut='o', typ='TXM', into=("GMSH", "GIBI", "SALOME")),
UNITE_GEOM = SIMP(statut='f', typ='I', val_min=10, val_max=90, defaut=16,
- fr="Unité logique définissant le fichier (fort.N) contenant les données géométriques (datg)"),
+ fr="Unite logique definissant le fichier (fort.N) contenant les donnees geometriques (datg)"),
UNITE = SIMP(statut='f', typ='I', val_min=10, val_max=90, defaut=19,
- fr="Unité logique définissant le fichier (fort.N) produit par le mailleur"),
+ fr="Unite logique definissant le fichier (fort.N) produit par le mailleur"),
MAILLAGE = SIMP(statut='o', typ=CO),
),
CHEMIN_SCRIPT = SIMP(statut='f', typ='TXM',
fr="Chemin du script Salome"),
UNITE_SCRIPT = SIMP(statut='f', typ='I', val_min=80, val_max=99,
- fr="Unité logique du script Salome"),
+ fr="Unite logique du script Salome"),
SALOME_HOST = SIMP(statut='f', typ='TXM', defaut='localhost',
fr="Machine sur laquelle tourne Salome"),
SALOME_PORT = SIMP(statut='f', typ='I', val_min=2800, val_max=2900, defaut=2810,
- fr="Port de l'instance Salome (2810 ou supérieur)"),
+ fr="Port de l'instance Salome (2810 ou superieur)"),
SALOME_RUNAPPLI = SIMP(statut='f', typ='TXM',
fr="Chemin vers le script de lancement runAppli de Salome"),
FICHIERS_ENTREE = SIMP(statut='f', typ='TXM', validators=NoRepeat(),max='**',
- fr="Liste des fichiers d'entrée du script Salome"),
+ fr="Liste des fichiers d'entree du script Salome"),
FICHIERS_SORTIE = SIMP(statut='f', typ='TXM', validators=NoRepeat(),max='**',
- fr="Liste des fichiers générés par le script Salome"),
+ fr="Liste des fichiers generes par le script Salome"),
NOM_PARA = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(),
- fr="Liste des noms des paramètres à modifier dans le script Salome"),
+ fr="Liste des noms des parametres a modifier dans le script Salome"),
VALE = SIMP(statut='f',typ='TXM',max='**',
- fr="Valeur des paramètres à) modifier dans le script Salome"),
+ fr="Valeur des parametres a) modifier dans le script Salome"),
),
CODE_RETOUR_MAXI = SIMP(statut='f', typ='I', defaut=0, val_min=-1,
- fr="Valeur maximale du code retour toléré (-1 pour l'ignorer)"),
+ fr="Valeur maximale du code retour tolere (-1 pour l'ignorer)"),
INFO = SIMP(statut='f', typ='I', defaut=2, into=(1,2),),
)
raise AsException("type de concept resultat non prevu")
EXTR_MODE=OPER(nom="EXTR_MODE",op= 168,sd_prod=extr_mode_prod,
- reentrant='n',fr="Extraire séléctivement des modes des structures de données modales",
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ reentrant='n',fr="Extraire selectivement des modes des structures de donnees modales",
+ UIinfo={"groupes":("Resolution","Dynamique",)},
FILTRE_MODE =FACT(statut='o',max='**',
regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','NUME_MODE','NUME_MODE_EXCLU','FREQ_MIN','CRIT_EXTR',),),
MODE =SIMP(statut='o',typ=(mode_meca,mode_meca_c,mode_gene ) ),
raise AsException("type de concept resultat non prevu")
EXTR_RESU=OPER(nom="EXTR_RESU",op=176,sd_prod=extr_resu_prod,reentrant='f',
- UIinfo={"groupes":("Résultats et champs",)},
- fr="Extraire des champs au sein d'une SD Résultat",
+ UIinfo={"groupes":("Resultats et champs",)},
+ fr="Extraire des champs au sein d'une SD Resultat",
RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,acou_harmo,mode_meca,
mode_acou,evol_ther,evol_noli,evol_varc,
mult_elas,fourier_elas,fourier_ther ) ),
),
RESTREINT =FACT(statut='f', max=1,
- fr="Pour réduire une ou plusieurs sd_resultat sur un maillage ou un modèle réduit",
+ fr="Pour reduire une ou plusieurs sd_resultat sur un maillage ou un modele reduit",
regles=(UN_PARMI('MAILLAGE','MODELE'),),
MAILLAGE =SIMP(statut='f',typ=maillage_sdaster),
MODELE =SIMP(statut='f',typ=modele_sdaster),
op=173,
sd_prod=extr_table_prod,
reentrant='n',
- UIinfo={"groupes":("Résultats et champs","Tables")},
+ UIinfo={"groupes":("Resultats et champs","Tables")},
fr="Extraire d'une table des concepts Code_Aster",
TYPE_RESU =SIMP(statut='o',typ='TXM',
into=('MATR_ASSE_GENE_R', 'MATR_ELEM_DEPL_R',
raise AsException("type de concept resultat non prevu")
FACTORISER=OPER(nom="FACTORISER",op=14,sd_prod=factoriser_prod,
- fr="Factoriser une matrice assemblée en un produit de deux matrices triangulaires"+
- "ou construire une matrice de préconditionnement pour une résolution par gradient conjugué",
- reentrant='f', UIinfo={"groupes":("Résolution",)},
+ fr="Factoriser une matrice assemblee en un produit de deux matrices triangulaires"+
+ "ou construire une matrice de preconditionnement pour une resolution par gradient conjugue",
+ reentrant='f', UIinfo={"groupes":("Resolution",)},
regles=(EXCLUS('BLOC_DEBUT','DDL_DEBUT'),
EXCLUS('BLOC_FIN','DDL_FIN'),),
MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,
matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ),
- # mots clés pour solveur LDLT et MULT_FRONT et MUMPS:
+ # mots cles pour solveur LDLT et MULT_FRONT et MUMPS:
STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
NPREC =SIMP(statut='f',typ='I',defaut=8),
- # mots clés pour solveur LDLT :
+ # mots cles pour solveur LDLT :
BLOC_DEBUT =SIMP(statut='f',typ='I',val_min=1,),
DDL_DEBUT =SIMP(statut='f',typ='I',val_min=1,),
BLOC_FIN =SIMP(statut='f',typ='I',val_min=1,),
DDL_FIN =SIMP(statut='f',typ='I',val_min=1,),
- # mots clés pour solveur MUMPS :
+ # mots cles pour solveur MUMPS :
TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
ELIM_LAGR =SIMP(statut='f',typ='TXM',defaut="LAGR2",into=("LAGR2","NON")),
GESTION_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="IN_CORE",into=("IN_CORE","OUT_OF_CORE","EVAL")),
- # mots clés pour solveur GCPC et PETSc :
+ # mots cles pour solveur GCPC et PETSc :
PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
),
- b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
+ b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Parametres de la factorisation simple precision",
REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ),
),
b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'",
- fr="Paramètres des préconditionneurs JACOBI et SOR",
+ fr="Parametres des preconditionneurs JACOBI et SOR",
RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
),
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
# person_in_charge: j-pierre.lefebvre at edf.fr
-FIN=PROC(nom="FIN",op=9999,repetable='n',fr="Fin d'une étude, fin du travail engagé par une des commandes DEBUT ou POURSUITE",
+FIN=PROC(nom="FIN",op=9999,repetable='n',fr="Fin d'une etude, fin du travail engage par une des commandes DEBUT ou POURSUITE",
UIinfo={"groupes":("Gestion du travail",)},
#
-# FIN est appelé prématurément en cas d'exception ("SIGUSR1", ArretCPUError,
-# NonConvergenceError..., erreurs <S> ou erreurs <F> récupérées).
-# En cas d'ArretCPUError, on limite au maximum le travail à faire dans FIN.
-# Pour cela, on force certains mots-clés dans Execution/E_JDC.py.
+# FIN est appele prematurement en cas d'exception ("SIGUSR1", ArretCPUError,
+# NonConvergenceError..., erreurs <S> ou erreurs <F> recuperees).
+# En cas d'ArretCPUError, on limite au maximum le travail a faire dans FIN.
+# Pour cela, on force certains mots-cles dans Execution/E_JDC.py.
#
FORMAT_HDF =SIMP(fr="sauvegarde de la base GLOBALE au format HDF",statut='f',
typ='TXM',defaut="NON",into=("OUI","NON",) ),
RETASSAGE =SIMP(fr="provoque le retassage de la base GLOBALE",
statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
- INFO_RESU =SIMP(fr="provoque l'impression des informations sur les structures de données",
+ INFO_RESU =SIMP(fr="provoque l'impression des informations sur les structures de donnees",
statut='f',typ='TXM',defaut="OUI",into=("OUI","NON",) ),
UNITE =SIMP(statut='f',typ='I',defaut=6),
) ;
# ======================================================================
# person_in_charge: andre.adobes at edf.fr
FONC_FLUI_STRU=OPER(nom="FONC_FLUI_STRU",op= 169,sd_prod=fonction_sdaster,
- reentrant='n',fr="Crée une fonction constante paramétrée par l'abscisse curviligne",
+ reentrant='n',fr="Cree une fonction constante parametree par l'abscisse curviligne",
UIinfo={"groupes":("Fonctions",)},
TYPE_FLUI_STRU =SIMP(statut='o',typ=(type_flui_stru) ),
) ;
op=-5,
sd_prod=formule_prod,
UIinfo={"groupes":("Fonctions",)},
- fr="Définit une formule réelle ou complexe à partir de son expression mathématique",
+ fr="Definit une formule reelle ou complexe a partir de son expression mathematique",
regles = (UN_PARMI('VALE', 'VALE_C',),),
VALE = SIMP(statut='f', typ='TXM'),
VALE_C = SIMP(statut='f', typ='TXM'),
PAS_INST =SIMP(statut='o',typ='R' ),
NB_POIN =SIMP(statut='f',typ='I',fr="nombre de points" ),
PESANTEUR =SIMP(statut='o', typ='R', fr="constante de normalisation de ACCE_MAX, ECART_TYPE et INTE_ARIAS (g) ou le spectre" ),
- DUREE_PHASE_FORTE =SIMP(statut='o',typ='R',fr="durée phase forte du signal" ),
+ DUREE_PHASE_FORTE =SIMP(statut='o',typ='R',fr="duree phase forte du signal" ),
NB_TIRAGE =SIMP(statut='f',typ='I',defaut= 1,fr="nombre accelerogrammes" ),
FREQ_FILTRE =SIMP(statut='f',typ='R',fr="frequence du filtre: corner frequency"),
#
# ======================================================================
# person_in_charge: irmela.zentner at edf.fr
GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table_fonction,
- fr="Génération de la fonction temporelle à partir d une matrice interspectrale",
+ fr="Generation de la fonction temporelle a partir d une matrice interspectrale",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
INTE_SPEC =SIMP(statut='o',typ=interspectre),
GENE_MATR_ALEA=OPER(nom="GENE_MATR_ALEA",op= 27,
#sd_prod=matr_asse_gene_r,
sd_prod=gene_matr_alea_prod,
- fr="Générer une réalisation d'une matrice aléatoire réelle sym. déf. positive ou d'un macro élément dynamique",
+ fr="Generer une realisation d'une matrice aleatoire reelle sym. def. positive ou d'un macro element dynamique",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
MATR_MOYEN = SIMP(statut='o', typ=(matr_asse_gene_r,macr_elem_dyna)),
op=EMPTY_OPS,
sd_prod=reel,
reentrant='n',
- fr="Générer une réalisation d'une variable aléatoire réelle " \
- "de loi de probabilité donnée (Gamma ou Exponentielle)",
+ fr="Generer une realisation d'une variable aleatoire reelle " \
+ "de loi de probabilite donnee (Gamma ou Exponentielle)",
UIinfo={"groupes":("Fonctions",)},
TYPE = SIMP(statut='f', typ='TXM', into=("EXP_TRONQUEE", "EXPONENTIELLE", "GAMMA"), defaut="GAMMA"),
b_gamma =BLOC(condition = "TYPE == 'GAMMA' ",fr="Parametres loi gamma",
# person_in_charge: j-pierre.lefebvre at edf.fr
IMPR_CO=PROC(nom="IMPR_CO",op=17,
UIinfo={"groupes":("Impression","Utilitaires",)},
- fr="Imprimer tous les objets JEVEUX qui constituent un concept utilisateur existant (pour les développeurs)",
+ fr="Imprimer tous les objets JEVEUX qui constituent un concept utilisateur existant (pour les developpeurs)",
regles=(UN_PARMI('CONCEPT','CHAINE','TOUT' ),),
UNITE =SIMP(statut='f',typ='I',defaut=8),
IMPR_DIAG_CAMPBELL=MACRO(nom="IMPR_DIAG_CAMPBELL",
op=OPS('Macro.impr_diag_campbell_ops.impr_diag_campbell_ops'),
- fr="Tracé du Diagramme de Campbell",
- UIinfo={"groupes":("Impression","Outils-métier",)},
+ fr="Trace du Diagramme de Campbell",
+ UIinfo={"groupes":("Impression","Outils-metier",)},
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster),
MODES =SIMP(statut='o',typ=table_container),
NFREQ_CAMP =SIMP(statut='o',typ='I' ),
op=OPS('Macro.impr_fonction_ops.impr_fonction_ops'),
sd_prod=None,
fr="Imprime le contenu d'objets de type fonction ou liste de " \
- "réels dans un fichier destiné à un traceur de courbe",
+ "reels dans un fichier destine a un traceur de courbe",
UIinfo={"groupes":("Impression","Fonctions",)},
FORMAT =SIMP(statut='o',typ='TXM',position='global',defaut='TABLEAU',
into=("TABLEAU","AGRAF","XMGRACE",),),
b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'",
- fr="Mots-clés propres à XMGRACE",
+ fr="Mots-cles propres a XMGRACE",
PILOTE =SIMP(statut='f',typ='TXM',defaut='',
into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),
fr="Pilote de sortie, PNG/JPEG/PDF ne sont pas disponibles sur toutes les installations de xmgrace"),
UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit"),
),
b_agraf = BLOC(condition = "FORMAT == 'AGRAF'",
- fr="Mots-clés propres à AGRAF",
+ fr="Mots-cles propres a AGRAF",
UNITE =SIMP(statut='o',typ='I',defaut=25,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit"),
UNITE_DIGR =SIMP(statut='o',typ='I',defaut=26,
- fr="Unité logique définissant le fichier dans lequel on écrit les directives Agraf"),
+ fr="Unite logique definissant le fichier dans lequel on ecrit les directives Agraf"),
),
- # unite pour TABLEAU dans le bloc de mise en forme spécifique
+ # unite pour TABLEAU dans le bloc de mise en forme specifique
- COURBE =FACT(statut='o',max='**',fr="Définition de la fonction à tracer",
+ COURBE =FACT(statut='o',max='**',fr="Definition de la fonction a tracer",
regles=(UN_PARMI('FONCTION','LIST_RESU','FONC_X','ABSCISSE'),),
FONCTION =SIMP(statut='f',typ=(fonction_sdaster, formule, fonction_c, nappe_sdaster),
- fr="Fonction réelle ou complexe", ),
+ fr="Fonction reelle ou complexe", ),
LIST_RESU =SIMP(statut='f',typ=listr8_sdaster,
- fr="Liste des ordonnees d'une fonction réelle définie par deux listes", ),
+ fr="Liste des ordonnees d'une fonction reelle definie par deux listes", ),
FONC_X =SIMP(statut='f',typ=(fonction_sdaster,formule),
- fr="Fonction abscisses d'une fonction paramétrique",),
+ fr="Fonction abscisses d'une fonction parametrique",),
ABSCISSE =SIMP(statut='f',typ='R',max='**',
fr="Valeurs des abscisses", ),
b_fonction =BLOC(condition = "FONCTION != None",
LIST_PARA =SIMP(statut='f',typ=listr8_sdaster ),
),
b_fonction_c =BLOC(condition = "AsType(FONCTION) in (fonction_c, formule_c)",
- fr="Fonction complexe définie par le mot-clé fonction",
+ fr="Fonction complexe definie par le mot-cle fonction",
PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ),
),
b_list_resu =BLOC(condition = "LIST_RESU != None",
LIST_PARA =SIMP(statut='o',typ=listr8_sdaster ),
),
b_fonc_x =BLOC(condition = "FONC_X != None",
- FONC_Y =SIMP(statut='o',typ=(fonction_sdaster,formule),fr="Fonction ordonnées d une fonction paramétrique" ),
+ FONC_Y =SIMP(statut='o',typ=(fonction_sdaster,formule),fr="Fonction ordonnees d une fonction parametrique" ),
LIST_PARA =SIMP(statut='f',typ=listr8_sdaster ),
),
b_vale_resu =BLOC(condition = "ABSCISSE != None",
ORDONNEE =SIMP(statut='o',typ='R',max='**',
- fr="Valeurs des ordonnées"),
+ fr="Valeurs des ordonnees"),
),
- # mots-clés utilisant uniquement aux formats autres que TABLEAU
- # mais ce serait trop pénible de devoir les supprimer quand on change de format
+ # mots-cles utilisant uniquement aux formats autres que TABLEAU
+ # mais ce serait trop penible de devoir les supprimer quand on change de format
# donc on ne les met pas dans un bloc
# "pseudo" bloc mise en forme :
LEGENDE =SIMP(statut='f',typ='TXM',
- fr="Légende associée à la fonction" ),
+ fr="Legende associee a la fonction" ),
STYLE =SIMP(statut='f',typ='I',val_min=0,
- fr="Style de la ligne représentant la fonction",),
+ fr="Style de la ligne representant la fonction",),
COULEUR =SIMP(statut='f',typ='I',val_min=0,
- fr="Couleur associée à la fonction",),
+ fr="Couleur associee a la fonction",),
MARQUEUR =SIMP(statut='f',typ='I',val_min=0,
- fr="Type du marqueur associé à la fonction",),
+ fr="Type du marqueur associe a la fonction",),
FREQ_MARQUEUR =SIMP(statut='f',typ='I',defaut=0,
- fr="Fréquence d impression du marqueur associé à la fonction", ),
+ fr="Frequence d impression du marqueur associe a la fonction", ),
# fin bloc mise en forme
TRI =SIMP(statut='f',typ='TXM',defaut="N",
- fr="Choix du tri effectué sur les abscisses ou sur les ordonnées",
+ fr="Choix du tri effectue sur les abscisses ou sur les ordonnees",
into=("N","X","Y","XY","YX") ),
),
# Mise en page du tableau ou du graphique
b_tableau = BLOC(condition = "FORMAT == 'TABLEAU'",
- fr="Mots-clés propres au format Tableau",
+ fr="Mots-cles propres au format Tableau",
UNITE =SIMP(statut='o',typ='I',defaut=8,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit"),
TITRE =SIMP(statut='f',typ='TXM',
- fr="Titre associé au graphique" ),
+ fr="Titre associe au graphique" ),
SOUS_TITRE =SIMP(statut='f',typ='TXM',
fr="Sous-titre du graphique" ),
SEPARATEUR =SIMP(statut='f',typ='TXM',defaut=' ',
- fr="Séparateur des colonnes du tableau (ex : ' ', ';'...)"),
+ fr="Separateur des colonnes du tableau (ex : ' ', ';'...)"),
COMMENTAIRE =SIMP(statut='f',typ='TXM',defaut='#',
- fr="Caractère indiquant au traceur de fonction que la ligne peut etre ignorée"),
+ fr="Caractere indiquant au traceur de fonction que la ligne peut etre ignoree"),
COMM_PARA =SIMP(statut='f',typ='TXM',defaut='',
- fr="Caractère utilisé pour commentariser la ligne des labels de colonnes"),
+ fr="Caractere utilise pour commentariser la ligne des labels de colonnes"),
DEBUT_LIGNE =SIMP(statut='f',typ='TXM',defaut='',
- fr="Caractère de debut de ligne"),
+ fr="Caractere de debut de ligne"),
FIN_LIGNE =SIMP(statut='f',typ='TXM',defaut='\n',
- fr="Caractère de fin de ligne"),
+ fr="Caractere de fin de ligne"),
),
b_graphique = BLOC(condition = "FORMAT != 'TABLEAU'",
fr="Mise en page du graphique",
TITRE =SIMP(statut='f',typ='TXM',
- fr="Titre associé au graphique" ),
+ fr="Titre associe au graphique" ),
SOUS_TITRE =SIMP(statut='f',typ='TXM',
fr="Sous-titre du graphique" ),
BORNE_X =SIMP(statut='f',typ='R',min=2,max=2,
fr="Intervalles de variation des abscisses"),
BORNE_Y =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Intervalles de variation des ordonnées"),
+ fr="Intervalles de variation des ordonnees"),
ECHELLE_X =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
- fr="Type d'échelle pour les abscisses" ),
+ fr="Type d'echelle pour les abscisses" ),
ECHELLE_Y =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
- fr="Type d'échelle pour les ordonnées" ),
+ fr="Type d'echelle pour les ordonnees" ),
GRILLE_X =SIMP(statut='f',typ='R',max=1,val_min=0.,
fr="Pas du quadrillage vertical" ),
GRILLE_Y =SIMP(statut='f',typ='R',max=1,val_min=0.,
fr="Pas du quadrillage horizontal" ),
LEGENDE_X =SIMP(statut='f',typ='TXM',
- fr="Légende associée à l'axe des abscisses" ),
+ fr="Legende associee a l'axe des abscisses" ),
LEGENDE_Y =SIMP(statut='f',typ='TXM',
- fr="Légende associée à l'axe des ordonnées" ),
+ fr="Legende associee a l'axe des ordonnees" ),
),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
) ;
# ======================================================================
# person_in_charge: emmanuel.boyere at edf.fr
IMPR_GENE=PROC(nom="IMPR_GENE",op= 157,
- fr="Imprimer le résultat d'un calcul dynamique en variables généralisées au format RESULTAT",
+ fr="Imprimer le resultat d'un calcul dynamique en variables generalisees au format RESULTAT",
UIinfo={"groupes":("Impression","Dynamique",)},
FORMAT =SIMP(statut='f',typ='TXM',defaut="RESULTAT",into=("RESULTAT",) ),
UNITE =SIMP(statut='f',typ='I',defaut=8),
# person_in_charge: j-pierre.lefebvre at edf.fr
IMPR_JEVEUX=PROC(nom="IMPR_JEVEUX",op=16,
UIinfo={"groupes":("Impression","Utilitaires",)},
- fr="Imprimer le contenu des objets créés par JEVEUX (pour développeur)",
+ fr="Imprimer le contenu des objets crees par JEVEUX (pour developpeur)",
ENTITE =SIMP(fr="choix de l'observation",statut='o',typ='TXM',
into=("DISQUE","MEMOIRE","REPERTOIRE",
"OBJET","ATTRIBUT","SYSTEME","ENREGISTREMENT") ),
b_objet =BLOC(condition = "(ENTITE=='OBJET')",
NOMOBJ =SIMP(fr="nom d'objet",statut='f',typ='TXM' ),
- NUMOC =SIMP(fr="numéro d objet de collection",statut='f',typ='I' ),
+ NUMOC =SIMP(fr="numero d objet de collection",statut='f',typ='I' ),
NOMOC =SIMP(fr="nom d'objet de collection",statut='f',typ='TXM' ),
),
b_attribut =BLOC(condition = "(ENTITE=='ATTRIBUT')",
# person_in_charge: mathieu.corus at edf.fr
IMPR_MACR_ELEM=PROC(nom="IMPR_MACR_ELEM",op= 160,
- UIinfo={"groupes":("Impression","Outils-métier",)},
- fr="Impression d'une structure de données MACR_ELEM_DYNA au format IDEAS MISS3D",
+ UIinfo={"groupes":("Impression","Outils-metier",)},
+ fr="Impression d'une structure de donnees MACR_ELEM_DYNA au format IDEAS MISS3D",
MACR_ELEM_DYNA =SIMP(statut='o',typ=macr_elem_dyna ),
FORMAT =SIMP(statut='f',typ='TXM',defaut="IDEAS",
into=("MISS_3D","IDEAS") ),
op=OPS('Macro.impr_oar_ops.impr_oar_ops'),
sd_prod=None,
fr="Impression au format OAR",
- UIinfo={"groupes":("Impression","Outils-métier",)},
+ UIinfo={"groupes":("Impression","Outils-metier",)},
TYPE_CALC = SIMP(statut='o', typ='TXM',into=('COMPOSANT', 'MEF', 'TUYAUTERIE')),
b_composant =BLOC(condition = "TYPE_CALC == 'COMPOSANT' ",
regles = (AU_MOINS_UN('RESU_MECA','RESU_THER')),
# ======================================================================
# person_in_charge: nicolas.sellenet at edf.fr
IMPR_RESU=PROC(nom="IMPR_RESU",op=39,
- UIinfo={"groupes":("Impression","Résultats et champs",)},
- fr="Imprimer un maillage et/ou les résultats d'un calcul (différents formats)",
+ UIinfo={"groupes":("Impression","Resultats et champs",)},
+ fr="Imprimer un maillage et/ou les resultats d'un calcul (differents formats)",
FORMAT =SIMP(statut='f',typ='TXM',position='global',defaut="RESULTAT",
into=("RESULTAT","IDEAS","ASTER","CASTEM","MED","GMSH") ),
- b_modele =BLOC(condition="FORMAT!='MED'",fr="Modèle",
+ b_modele =BLOC(condition="FORMAT!='MED'",fr="Modele",
MODELE =SIMP(statut='f',typ=modele_sdaster),
),
- b_format_resultat =BLOC(condition="FORMAT=='RESULTAT'",fr="unité logique d'impression au format RESULTAT",
+ b_format_resultat =BLOC(condition="FORMAT=='RESULTAT'",fr="unite logique d'impression au format RESULTAT",
UNITE =SIMP(statut='f',typ='I',defaut=8),
),
- b_format_ideas =BLOC(condition="FORMAT=='IDEAS'",fr="unité logique d'impression et version IDEAS",
+ b_format_ideas =BLOC(condition="FORMAT=='IDEAS'",fr="unite logique d'impression et version IDEAS",
UNITE =SIMP(statut='f',typ='I',defaut=30),
VERSION =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
),
- b_format_aster =BLOC(condition="FORMAT=='ASTER'",fr="unité logique d'impression au format ASTER",
+ b_format_aster =BLOC(condition="FORMAT=='ASTER'",fr="unite logique d'impression au format ASTER",
UNITE =SIMP(statut='f',typ='I',defaut=26),
),
- b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="unité logique d'impression et version CASTEM",
+ b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="unite logique d'impression et version CASTEM",
UNITE =SIMP(statut='f',typ='I',defaut=37),
NIVE_GIBI =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
),
- b_format_med =BLOC(condition="FORMAT=='MED'",fr="unité logique d'impression au format MED",
+ b_format_med =BLOC(condition="FORMAT=='MED'",fr="unite logique d'impression au format MED",
UNITE =SIMP(statut='f',typ='I',defaut=80),
),
- b_format_gmsh =BLOC(condition="FORMAT=='GMSH'",fr="unité logique d'impression et version GMSH",
+ b_format_gmsh =BLOC(condition="FORMAT=='GMSH'",fr="unite logique d'impression et version GMSH",
UNITE =SIMP(statut='f',typ='I',defaut=37),
VERSION =SIMP(statut='f',typ='R',defaut=1.2,into=(1.0,1.2)),
),
b_restreint =BLOC(condition="FORMAT=='MED'",fr="Seulement pour les fichiers MED",
RESTREINT =FACT(statut='f', max=1,
- fr="Pour réduire une ou plusieurs sd_resultat sur un ensemble de mailles",
+ fr="Pour reduire une ou plusieurs sd_resultat sur un ensemble de mailles",
regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
),
CONCEPT =FACT(statut='f',max='**',
- fr='Pour imprimer les champs de "données" à des fins de visualisation (controle des affectations).',
+ fr='Pour imprimer les champs de "donnees" a des fins de visualisation (controle des affectations).',
# (valide pour les format RESULTAT et MED)
regles=(UN_PARMI('CHAM_MATER','CARA_ELEM','CHARGE'),),
CHAM_MATER =SIMP(statut='f',typ=cham_mater),
###
b_cmp=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and\
((FORMAT == 'CASTEM')or(FORMAT == 'RESULTAT')or(FORMAT == 'IDEAS')or(FORMAT == 'MED'))""",
- fr="sélection des composantes",
+ fr="selection des composantes",
regles=(EXCLUS('TOUT_CMP','NOM_CMP'),),
TOUT_CMP =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NOM_CMP =SIMP(statut='f',typ='TXM',max='**'),
),
###
b_gmsh=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and((FORMAT == 'GMSH'))""",
- fr="sélection des composantes et des entités toplogiques",
+ fr="selection des composantes et des entites toplogiques",
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
TYPE_CHAM =SIMP(statut='f',typ='TXM',defaut="SCALAIRE",
###
b_topologie=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and\
((FORMAT == 'RESULTAT')or(FORMAT == 'IDEAS')or(FORMAT == 'MED'))""",
- fr="sélection des entités topologiques",
+ fr="selection des entites topologiques",
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
),
###
b_valeurs=BLOC(condition="(FORMAT == 'RESULTAT')",
- fr="sélection sur les valeurs",
+ fr="selection sur les valeurs",
VALE_MAX =SIMP(statut='f',typ='TXM',into=("OUI",) ),
VALE_MIN =SIMP(statut='f',typ='TXM',into=("OUI",) ),
BORNE_SUP =SIMP(statut='f',typ='R'),
),
b_format_r=BLOC(condition="""((FORMAT == 'RESULTAT')or(FORMAT == 'ASTER'))""",
- fr="Format des nombres réels",
+ fr="Format des nombres reels",
FORMAT_R =SIMP(statut='f',typ='TXM',defaut="1PE21.14"),
),
FORMAT =SIMP(statut='f',typ='TXM',defaut="TABLEAU",
into=("TABLEAU","ASTER","TABLEAU_CROISE","AGRAF","XMGRACE",),),
b_pilote =BLOC(condition = "FORMAT == 'XMGRACE'",
- fr="Mots-clés propres à XMGRACE",
+ fr="Mots-cles propres a XMGRACE",
PILOTE =SIMP(statut='f',typ='TXM',defaut='',
into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),
fr="Pilote de sortie, PNG/JPEG/PDF ne sont pas disponibles sur toutes les installations de xmgrace"),
UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit"),
),
b_unite =BLOC(condition = "FORMAT != 'XMGRACE'",
UNITE =SIMP(statut='f',typ='I',defaut=8,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit"),
),
FILTRE =FACT(statut='f',max='**',
NOM_PARA =SIMP(statut='o',typ='TXM'),
# Mise en page du tableau ou du graphique
b_tableau = BLOC(condition = "FORMAT == 'TABLEAU'",
- fr="Mots-clés propres au format Tableau",
+ fr="Mots-cles propres au format Tableau",
SEPARATEUR =SIMP(statut='f',typ='TXM',defaut=' ',
- fr="Séparateur des colonnes du tableau (ex : ' ', ';'...)"),
+ fr="Separateur des colonnes du tableau (ex : ' ', ';'...)"),
COMMENTAIRE =SIMP(statut='f',typ='TXM',defaut='#',
- fr="Caractère indiquant au traceur de fonction que la ligne peut etre ignorée"),
+ fr="Caractere indiquant au traceur de fonction que la ligne peut etre ignoree"),
COMM_PARA =SIMP(statut='f',typ='TXM',defaut='',
- fr="Caractère utilisé pour commentariser la ligne des labels de colonnes"),
+ fr="Caractere utilise pour commentariser la ligne des labels de colonnes"),
DEBUT_LIGNE =SIMP(statut='f',typ='TXM',defaut='',
- fr="Caractère de debut de ligne"),
+ fr="Caractere de debut de ligne"),
FIN_LIGNE =SIMP(statut='f',typ='TXM',defaut='\n',
- fr="Caractère de fin de ligne"),
+ fr="Caractere de fin de ligne"),
),
# mise en forme pour les formats qui passent par Graph
b_forme =BLOC(condition = "FORMAT == 'XMGRACE'",
- fr="Données de mise en forme du graphique",
+ fr="Donnees de mise en forme du graphique",
# pour la courbe
LEGENDE =SIMP(statut='f',typ='TXM',
- fr="Légende associée à la fonction" ),
+ fr="Legende associee a la fonction" ),
STYLE =SIMP(statut='f',typ='I',val_min=0,
- fr="Style de la ligne représentant la fonction",),
+ fr="Style de la ligne representant la fonction",),
COULEUR =SIMP(statut='f',typ='I',val_min=0,
- fr="Couleur associée à la fonction",),
+ fr="Couleur associee a la fonction",),
MARQUEUR =SIMP(statut='f',typ='I',val_min=0,
- fr="Type du marqueur associé à la fonction",),
+ fr="Type du marqueur associe a la fonction",),
FREQ_MARQUEUR =SIMP(statut='f',typ='I',defaut=0,
- fr="Fréquence d impression du marqueur associé à la fonction", ),
+ fr="Frequence d impression du marqueur associe a la fonction", ),
# format du graphique
BORNE_X =SIMP(statut='f',typ='R',min=2,max=2,
fr="Intervalles de variation des abscisses"),
BORNE_Y =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Intervalles de variation des ordonnées"),
+ fr="Intervalles de variation des ordonnees"),
ECHELLE_X =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
- fr="Type d'échelle pour les abscisses" ),
+ fr="Type d'echelle pour les abscisses" ),
ECHELLE_Y =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
- fr="Type d'échelle pour les ordonnées" ),
+ fr="Type d'echelle pour les ordonnees" ),
GRILLE_X =SIMP(statut='f',typ='R',max=1,val_min=0.,
fr="Pas du quadrillage vertical" ),
GRILLE_Y =SIMP(statut='f',typ='R',max=1,val_min=0.,
fr="Pas du quadrillage horizontal" ),
LEGENDE_X =SIMP(statut='f',typ='TXM',
- fr="Légende associée à l'axe des abscisses" ),
+ fr="Legende associee a l'axe des abscisses" ),
LEGENDE_Y =SIMP(statut='f',typ='TXM',
- fr="Légende associée à l'axe des ordonnées" ),
+ fr="Legende associee a l'axe des ordonnees" ),
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INCLUDE=MACRO(nom="INCLUDE",
op=OPS("Cata.ops.build_include"),
UIinfo={"groupes":("Gestion du travail",)},
- fr="Débranchement vers un fichier de commandes secondaires",
+ fr="Debranchement vers un fichier de commandes secondaires",
sd_prod=ops.INCLUDE,
op_init=ops.INCLUDE_context,
fichier_ini=1,
regles=(UN_PARMI('UNITE', 'DONNEE')),
UNITE = SIMP(statut='f', typ='I',
- fr="Unité logique à inclure"),
+ fr="Unite logique a inclure"),
DONNEE = SIMP(statut='f', typ='Fichier',
- fr="Nom du fichier de données à inclure"),
+ fr="Nom du fichier de donnees a inclure"),
INFO = SIMP(statut='f', typ='I', defaut=1, into=(1, 2)),
);
INCLUDE_MATERIAU = MACRO(nom="INCLUDE_MATERIAU",
op=OPS("Macro.include_materiau_ops.include_materiau_ops"),
sd_prod=mater_sdaster,
- UIinfo={"groupes":("Modélisation", "Gestion du travail", )},
- fr="Récupérer les caractéristiques d'un matériau dans le Catalogue Materiaux d'Aster ",
+ UIinfo={"groupes":("Modelisation", "Gestion du travail", )},
+ fr="Recuperer les caracteristiques d'un materiau dans le Catalogue Materiaux d'Aster ",
NOM_AFNOR = SIMP(statut='o', typ='TXM',),
TYPE_MODELE = SIMP(statut='o', typ='TXM', into=("REF", "PAR"),),
# ======================================================================
# person_in_charge: j-pierre.lefebvre at edf.fr
INFO_EXEC_ASTER=OPER(nom="INFO_EXEC_ASTER",op=35,sd_prod=table_sdaster,
- fr="Récupère différentes informations propres à l'exécution en cours",
+ fr="Recupere differentes informations propres a l'execution en cours",
reentrant='n',
UIinfo={"groupes":("Gestion du travail",)},
b_etat_unite =BLOC(condition = "au_moins_un(LISTE_INFO, 'ETAT_UNITE')",
regles=(UN_PARMI('UNITE','FICHIER'),),
UNITE =SIMP(statut='f',typ='I',val_min=1,val_max=99,max=1,
- fr="Unité logique dont on veut obtenir l'état",),
+ fr="Unite logique dont on veut obtenir l'etat",),
FICHIER =SIMP(statut='f',typ='TXM',validators=LongStr(1,255),
- fr="Nom du fichier dont on veut obtenir l'état",),
+ fr="Nom du fichier dont on veut obtenir l'etat",),
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
INFO_FONCTION=MACRO(nom="INFO_FONCTION",
op=OPS('Macro.info_fonction_ops.info_fonction_ops'),
sd_prod=info_fonction_prod,
- fr="Opérations mathématiques sur des concepts de type fonction, " \
+ fr="Operations mathematiques sur des concepts de type fonction, " \
"fonction_c ou nappe",
reentrant='n',
UIinfo={"groupes":("Fonctions",)},
RMS =FACT(statut='f',fr="Valeur RMS d'une fonction",max='**',
METHODE =SIMP(statut='f',typ='TXM',defaut="TRAPEZE",into=("SIMPSON","TRAPEZE") ),
FONCTION =SIMP(statut='o',typ=fonction_sdaster ),
- INST_INIT =SIMP(statut='f',typ='R',fr="Instant initial définissant le début du signal" ),
- INST_FIN =SIMP(statut='f',typ='R',fr="Instant final définissant la fin du signal" ),
+ INST_INIT =SIMP(statut='f',typ='R',fr="Instant initial definissant le debut du signal" ),
+ INST_FIN =SIMP(statut='f',typ='R',fr="Instant final definissant la fin du signal" ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ),
b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,val_min=0.E+0),),
PRECISION =SIMP(statut='o',typ='R'),),
),
),
- MAX =FACT(statut='f',fr="Extrémas locaux d'une fonction",
+ MAX =FACT(statut='f',fr="Extremas locaux d'une fonction",
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster),max='**' ),
INTERVALLE =SIMP(statut='f',typ='R',min=2,max='**',
- fr ="définition des bornes des intervalles sous forme de couples (xi_i1,xs_i1,xi_i2,xs_i2)"),
+ fr ="definition des bornes des intervalles sous forme de couples (xi_i1,xs_i1,xi_i2,xs_i2)"),
),
NORME =FACT(statut='f',fr="Norme L2 d'une fonction",
FONCTION =SIMP(statut='o', typ=nappe_sdaster),
ECART_TYPE =FACT(statut='f',fr="Ecart-type d'une fonction",
METHODE =SIMP(statut='f',typ='TXM',defaut="TRAPEZE",into=("SIMPSON","TRAPEZE") ),
FONCTION =SIMP(statut='o',typ=fonction_sdaster),
- INST_INIT =SIMP(statut='f',typ='R',fr="Instant initial définissant le début du signal" ),
- INST_FIN =SIMP(statut='f',typ='R',fr="Instant final définissant la fin du signal" ),
+ INST_INIT =SIMP(statut='f',typ='R',fr="Instant initial definissant le debut du signal" ),
+ INST_FIN =SIMP(statut='f',typ='R',fr="Instant final definissant la fin du signal" ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ),
b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,val_min=0.E+0),),
# ======================================================================
# person_in_charge: olivier.boiteau at edf.fr
INFO_MODE=OPER(nom="INFO_MODE",op=32,sd_prod=table_sdaster,
- fr="Calculer, imprimer, et sauvegarder le nombre de valeurs propres dans un contour donné",
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ fr="Calculer, imprimer, et sauvegarder le nombre de valeurs propres dans un contour donne",
+ UIinfo={"groupes":("Resolution","Dynamique",)},
TYPE_MODE =SIMP(statut='f',typ='TXM',defaut="DYNAMIQUE",into=("MODE_COMPLEXE","DYNAMIQUE",
"MODE_FLAMB", "GENERAL"),
fr="Type d analyse" ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
- b_dynamique =BLOC(condition = "TYPE_MODE == 'DYNAMIQUE'",fr="Recherche du nombre de fréquences propres",
+ b_dynamique =BLOC(condition = "TYPE_MODE == 'DYNAMIQUE'",fr="Recherche du nombre de frequences propres",
MATR_RIGI =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r,
matr_asse_depl_c,matr_asse_gene_c) ),
MATR_MASS =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r) ),
),
),
- b_complexe =BLOC(condition = "TYPE_MODE == 'MODE_COMPLEXE'",fr="Recherche du nombre de fréquences propres",
+ b_complexe =BLOC(condition = "TYPE_MODE == 'MODE_COMPLEXE'",fr="Recherche du nombre de frequences propres",
MATR_RIGI =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r,
matr_asse_depl_c,matr_asse_gene_c) ),
MATR_MASS =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r) ),
# person_in_charge: nicolas.sellenet at edf.fr
INFO_RESU=PROC(nom="INFO_RESU",op=40,
UIinfo={"groupes":("Impression","Utilitaires",)},
- fr="Imprimer tous les champs présents dans une structure de données résultat",
+ fr="Imprimer tous les champs presents dans une structure de donnees resultat",
RESULTAT=SIMP(statut='f',typ=resultat_sdaster),
UNITE=SIMP(statut='f',typ='I',defaut=6),
);
# person_in_charge: xavier.desroches at edf.fr
INTE_MAIL_2D=OPER(nom="INTE_MAIL_2D",op=50,sd_prod=courbe_sdaster,
UIinfo={"groupes":("Post-traitements",)},
- fr="Définition d'une courbe dans un maillage 2D",reentrant='n',
+ fr="Definition d'une courbe dans un maillage 2D",reentrant='n',
MAILLAGE =SIMP(statut='o',typ=(maillage_sdaster) ),
# person_in_charge: xavier.desroches at edf.fr
INTE_MAIL_3D=OPER(nom="INTE_MAIL_3D",op=96,sd_prod=surface_sdaster,
UIinfo={"groupes":("Post-traitements",)},
- fr="Définir un chemin de type segment de droite dans un maillage 3D",reentrant='n',
+ fr="Definir un chemin de type segment de droite dans un maillage 3D",reentrant='n',
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
# ======================================================================
# person_in_charge: nicolas.sellenet at edf.fr
def lire_champ_prod(TYPE_CHAM=None,**args):
-# Remarque : si cette liste évolue, il faut penser à mettre à jour son
+# Remarque : si cette liste evolue, il faut penser a mettre a jour son
# homologue dans macr_adap_mail
if TYPE_CHAM[0:5] == "NOEU_" : return cham_no_sdaster
if TYPE_CHAM[0:5] == "CART_" : return carte_sdaster
raise AsException("type de concept resultat non prevu")
LIRE_CHAMP=OPER(nom="LIRE_CHAMP",op= 192,sd_prod=lire_champ_prod,
- UIinfo={"groupes":("Lecture","Résultats et champs",)},
+ UIinfo={"groupes":("Lecture","Resultats et champs",)},
fr="Lire un champ dans un fichier au format MED et le stocker dans un concept.",
reentrant='n',
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster,),
fr="Affecte des valeurs nulles la ou le champ n'est pas defini (sinon il y a NaN)"),
NUME_PT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**',),
NUME_ORDRE =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**',
- fr="Numero d ordre du champ à lire",ang="Rank of the field to be read" ),
- INST =SIMP(statut='f',typ='R',fr="Instant associé",ang="Instant" ),
+ fr="Numero d ordre du champ a lire",ang="Rank of the field to be read" ),
+ INST =SIMP(statut='f',typ='R',fr="Instant associe",ang="Instant" ),
#
b_precision =BLOC(condition="(INST != None)",
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),
- fr="Critère de précision sur le choix de l'instant associé",
+ fr="Critere de precision sur le choix de l'instant associe",
ang="Accuracy criterium over instant choice" ),
b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,
- fr="Précision sur le choix de l'instant associé",ang="Accuracy over instant choice" ),),
+ fr="Precision sur le choix de l'instant associe",ang="Accuracy over instant choice" ),),
b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
PRECISION =SIMP(statut='o',typ='R',
- fr="Précision sur le choix de l'instant associé",ang="Accuracy over instant choice" ),),),
+ fr="Precision sur le choix de l'instant associe",ang="Accuracy over instant choice" ),),),
#
NOM_MAIL_MED =SIMP(statut='f',typ='TXM',),
),
-# Remarque : si cette liste évolue, il faut penser à mettre à jour son
+# Remarque : si cette liste evolue, il faut penser a mettre a jour son
# homologue dans macr_adap_mail
TYPE_CHAM =SIMP(statut='o',typ='TXM',into=C_TYPE_CHAM_INTO()),
b_modele =BLOC(condition = "TYPE_CHAM!=None and (TYPE_CHAM[0:2] == 'EL')",
LIRE_FONCTION=MACRO(nom="LIRE_FONCTION",
op=OPS('Macro.lire_fonction_ops.lire_fonction_ops'),
sd_prod=lire_fonction_prod,
- fr="Lit les valeurs réelles dans un fichier de données représentant une " \
- "fonction et crée un concept de type fonction ou nappe",
+ fr="Lit les valeurs reelles dans un fichier de donnees representant une " \
+ "fonction et cree un concept de type fonction ou nappe",
reentrant='n',
UIinfo={"groupes":("Lecture","Fonctions",)},
FORMAT =SIMP(statut='f',typ='TXM',into=("LIBRE",),defaut="LIBRE" ),
NOM_PARA_FONC =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ),
INDIC_ABSCISSE =SIMP(statut='o',typ='I',min=2,max=2,),
INTERPOL_FONC =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
- fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction"),
+ fr="Type d'interpolation pour les abscisses et les ordonnees de la fonction"),
PROL_DROITE_FONC=SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
PROL_GAUCHE_FONC=SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
DEFI_FONCTION =FACT(statut='f',max='**',
NOM_PARA =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ),
NOM_RESU =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"),
INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
- fr="Type d'interpolation pour les abscisses et les ordonnées de la " \
- "fonction ou bien pour le paramètre de la nappe."),
+ fr="Type d'interpolation pour les abscisses et les ordonnees de la " \
+ "fonction ou bien pour le parametre de la nappe."),
PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
VERIF =SIMP(statut='f',typ='TXM',defaut="CROISSANT",into=("CROISSANT","NON") ),
# ======================================================================
# person_in_charge: Georges-cc.devesa at edf.fr
LIRE_FORC_MISS=OPER(nom="LIRE_FORC_MISS",op= 179,sd_prod=vect_asse_gene,
- fr="Création d'un vecteur assemblé à partir d'une base modale",
+ fr="Creation d'un vecteur assemble a partir d'une base modale",
reentrant='n',
- UIinfo={"groupes":("Matrices et vecteurs","Outils-métier",)},
+ UIinfo={"groupes":("Matrices et vecteurs","Outils-metier",)},
BASE =SIMP(statut='o',typ=mode_meca),
NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
FREQ_EXTR =SIMP(statut='o',typ='R',max=1),
# ======================================================================
# person_in_charge: Georges-cc.devesa at edf.fr
LIRE_IMPE_MISS=OPER(nom="LIRE_IMPE_MISS",op= 164,sd_prod=matr_asse_gene_c,
- fr="Création d une matrice assemblée à partir de base modale",
+ fr="Creation d une matrice assemblee a partir de base modale",
reentrant='n',
- UIinfo={"groupes":("Matrices et vecteurs","Outils-métier",)},
+ UIinfo={"groupes":("Matrices et vecteurs","Outils-metier",)},
BASE =SIMP(statut='o',typ=mode_meca ),
NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
FREQ_EXTR =SIMP(statut='f',typ='R',max=1),
op=OPS('Macro.lire_inte_spec_ops.lire_inte_spec_ops'),
sd_prod=interspectre,
fr="Lecture sur un fichier externe de fonctions complexes pour " \
- "créer une matrice interspectrale",
+ "creer une matrice interspectrale",
reentrant='n',
UIinfo={"groupes":("Lecture","Fonctions",)},
UNITE =SIMP(statut='o',typ='I' ),
# ======================================================================
# person_in_charge: jacques.pellet at edf.fr
LIRE_MAILLAGE=OPER(nom="LIRE_MAILLAGE",op= 1,sd_prod=maillage_sdaster,
- fr="Crée un maillage par lecture d'un fichier au format Aster ou Med",
+ fr="Cree un maillage par lecture d'un fichier au format Aster ou Med",
ang="Readings of a mesh file",
reentrant='n',
UIinfo={"groupes":("Lecture","Maillage",)},
),
b_format_med =BLOC( condition = " ( FORMAT == 'MED' ) " ,
- fr="Informations complémentaires pour la lecture MED.",
+ fr="Informations complementaires pour la lecture MED.",
ang="Further information for MED readings.",
-# Pour une lecture dans un fichier MED, on peut préciser le nom sous lequel
-# le maillage y a été enregistré. Par défaut, on va le chercher sous le nom du concept à créer.
+# Pour une lecture dans un fichier MED, on peut preciser le nom sous lequel
+# le maillage y a ete enregistre. Par defaut, on va le chercher sous le nom du concept a creer.
NOM_MED = SIMP(statut='f',typ='TXM',
fr="Nom du maillage dans le fichier MED.",
ang="Name of the mesh into the MED file.",),
# person_in_charge: serguei.potapov at edf.fr
LIRE_PLEXUS=OPER(nom="LIRE_PLEXUS",op= 184,sd_prod=evol_char,
- fr="Lire le fichier de résultats au format IDEAS produit par le logiciel EUROPLEXUS",
+ fr="Lire le fichier de resultats au format IDEAS produit par le logiciel EUROPLEXUS",
reentrant='n',
- UIinfo={"groupes":("Lecture","Outils-métier",)},
+ UIinfo={"groupes":("Lecture","Outils-metier",)},
regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),),
UNITE =SIMP(statut='f',typ='I',defaut= 19 ),
FORMAT =SIMP(statut='f',typ='TXM',defaut="IDEAS",into=("IDEAS",)),
if TYPE_RESU == "EVOL_VARC" : return evol_varc
raise AsException("type de concept resultat non prevu")
-# pour éviter d'écrire 3 fois cette liste :
+# pour eviter d'ecrire 3 fois cette liste :
def l_nom_cham_pas_elga() :
return list(set(C_NOM_CHAM_INTO())-set(C_NOM_CHAM_INTO('ELGA',)))
LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n',
UIinfo={"groupes":("Lecture","Resultats et champs",)},
fr="Lire dans un fichier, soit format IDEAS, soit au format ENSIGHT soit au format MED,"
- +" des champs et les stocker dans une SD résultat",
+ +" des champs et les stocker dans une SD resultat",
# 0) mots cles generaux :
MAC_MODES=OPER(nom="MAC_MODES",op= 141,sd_prod=table_sdaster,
fr="Critere orthogonalite de modes propres",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
regles=(PRESENT_PRESENT('IERI','MATR_ASSE'),),
BASE_1 =SIMP(statut='o',typ=(mode_meca,mode_meca_c,mode_flamb) ),
BASE_2 =SIMP(statut='o',typ=(mode_meca,mode_meca_c,mode_flamb) ),
#
#print "MAJ_CHAM =", MAJ_CHAM
if MAJ_CHAM is not None :
-# Remarque : la liste qui suit doit etre conforme à son homologue de LIRE_CHAMP
+# Remarque : la liste qui suit doit etre conforme a son homologue de LIRE_CHAMP
for ch in MAJ_CHAM:
t=ch['TYPE_CHAM']
if t[0:5] == "NOEU_":self.type_sdprod(ch['CHAM_MAJ'],cham_no_sdaster)
# 2.2.1. Le concept du maillage final (sortie)
#
MAILLAGE_NP1 = SIMP(statut='o',typ=CO,
- fr="Maillage après adaptation",
+ fr="Maillage apres adaptation",
ang="Mesh after adaptation" ),
#
# 2.2.2. Eventuellement, on peut produire un maillage annexe
-# Actuellement, c'est le maillage n+1, mais de degré différent.
+# Actuellement, c'est le maillage n+1, mais de degre different.
#
MAILLAGE_NP1_ANNEXE = SIMP(statut='f',typ=CO,
- fr="Maillage annexe après adaptation",
+ fr="Maillage annexe apres adaptation",
ang="Additional mesh after adaptation" ),
#
) ,
# . Raffinement seul, selon un champ
# . Deraffinement seul, selon un champ
# . Raffinement et deraffinement, selon des zones geometriques
-# . Raffinement uniforme : toutes les mailles sont divisées
-# . Deraffinement uniforme : toutes les mailles sont regroupées
+# . Raffinement uniforme : toutes les mailles sont divisees
+# . Deraffinement uniforme : toutes les mailles sont regroupees
# . Modification : le maillage subit des transformations specifiques
# . Rien : le maillage est le meme a la sortie et a l'entree
#
b_champ = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
(ADAPTATION == 'RAFFINEMENT') or \
(ADAPTATION == 'DERAFFINEMENT') " ,
- fr="Pour une adaptation libre, choix du champ définissant la région à raffiner/déraffiner",
+ fr="Pour une adaptation libre, choix du champ definissant la region a raffiner/deraffiner",
ang="For a free adaptation, selection of the field that defines the area for refinment/unrefinement",
#
regles=(UN_PARMI('CHAM_GD','RESULTAT_N')),
#
-# 4.1. Reperage de la région a raffiner a l'aide d'un champ
+# 4.1. Reperage de la region a raffiner a l'aide d'un champ
#
# 4.1.1. Sous forme de champ de grandeur
#
# 4.1.2. Sous forme de concept resultat_sdaster
#
RESULTAT_N = SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther) ,
- fr="Concept résultat Code_Aster contenant le champ",
+ fr="Concept resultat Code_Aster contenant le champ",
ang="The Code_Aster result with the field" ),
#
b_champ_adaptation = BLOC(condition="(RESULTAT_N != None)",
NOM_CHAM = SIMP(statut='o',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO(),
- fr="Champ dans le résultat",
+ fr="Champ dans le resultat",
ang="The field in the result structure" ),
),
#
fr="Liste des composante(s) retenue(s) pour le champ.",
ang="List of the selected component(s) for the field." ),
#
-# 4.1.5. Le paramètre temporel pour le champ
+# 4.1.5. Le parametre temporel pour le champ
#
b_parametre_temporel = BLOC(condition="(RESULTAT_N != None)",
- fr="Choix éventuel du paramètre temporel pour le champ",
+ fr="Choix eventuel du parametre temporel pour le champ",
ang="Time selection for the field (option)",
#
regles=(EXCLUS('NUME_ORDRE','INST'),),
# 4.1.5.1. Soit le numero d'ordre
#
NUME_ORDRE = SIMP(statut='f',typ='I',
- fr="Numéro d ordre",
+ fr="Numero d ordre",
ang="Rank" ),
#
# 4.1.5.2. Soit l'instant
# 4.1.5.2.1. Sa valeur
#
INST = SIMP(statut='f',typ='R',
- fr="Instant associé",
+ fr="Instant associe",
ang="Instant" ),
#
-# 4.1.5.2.2. La précision du choix de l'instant
+# 4.1.5.2.2. La precision du choix de l'instant
#
b_precision = BLOC(condition="(INST != None)",
- fr="Choix de la précision du choix de l'instant",
+ fr="Choix de la precision du choix de l'instant",
ang="Precision for the choice of the instant",
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF", "ABSOLU",),
- fr="Critère de précision sur le choix de l'instant associé",
+ fr="Critere de precision sur le choix de l'instant associe",
ang="Accuracy criterium over the choice of the instant"),
b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,
- fr="Précision relative sur le choix de l'instant associé",
+ fr="Precision relative sur le choix de l'instant associe",
ang="Relative accuracy over the choice of the instant"),),
b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
PRECISION =SIMP(statut='o',typ='R',
- fr="Précision absolue sur le choix de l'instant associé",
+ fr="Precision absolue sur le choix de l'instant associe",
ang="Absolute accuracy over the choice of the instant"),),
),
#
fr="Usage du champ : la valeur par maille ou le saut entre mailles voisines",
ang="Use of the field: value over every mesh or jump between the neighbours" ),
#
-# 4.1.8. Initialisation de l'adaptation : raffinement ou déraffinement
+# 4.1.8. Initialisation de l'adaptation : raffinement ou deraffinement
#
ADAP_INIT = SIMP(statut='f',typ='TXM',defaut="GARDER",into=("GARDER", "DERAFFINER"),
- fr="Initialisation de l'adaptation dans les régions sans indicateur : garder ou déraffiner",
+ fr="Initialisation de l'adaptation dans les regions sans indicateur : garder ou deraffiner",
ang="Initialization of the adaptation in the areas without indicator: keep or unrefine" ),
#
) ,
#
b_critere_de_raffinement = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
(ADAPTATION == 'RAFFINEMENT') " ,
- fr="Critère de raffinement.",
+ fr="Critere de raffinement.",
ang="Refinement threshold.",
#
regles=(UN_PARMI ( 'CRIT_RAFF_ABS', 'CRIT_RAFF_REL', 'CRIT_RAFF_PE', 'CRIT_RAFF_MS' ),),
#
CRIT_RAFF_ABS = SIMP(statut='f',typ='R',
- fr="Critère absolu",
+ fr="Critere absolu",
ang="Absolute threshold" ),
CRIT_RAFF_REL = SIMP(statut='f',typ='R',val_min=0.0,val_max=1.0,
- fr="Critère relatif : fraction réelle entre 0. et 1.",
+ fr="Critere relatif : fraction reelle entre 0. et 1.",
ang="Relative threshold : ratio between 0. and 1." ),
CRIT_RAFF_PE = SIMP(statut='f',typ='R',val_min=0.0,val_max=1.0,
- fr="Pourcentage de mailles : fraction réelle entre 0. et 1.",
+ fr="Pourcentage de mailles : fraction reelle entre 0. et 1.",
ang="Percentage of meshes: ratio between 0. and 1." ),
CRIT_RAFF_MS = SIMP(statut='f',typ='R',
- fr="Critère absolu valant moyenne + n*sigma, n étant > 0",
+ fr="Critere absolu valant moyenne + n*sigma, n etant > 0",
ang="Absolute threshold: mean + n*sigma, with n > 0" ),
) ,
#
#
b_critere_de_deraffinement = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
(ADAPTATION == 'DERAFFINEMENT') " ,
- fr="Critère de déraffinement.",
+ fr="Critere de deraffinement.",
ang="Unrefinement threshold.",
#
regles=(UN_PARMI ( 'CRIT_DERA_ABS', 'CRIT_DERA_REL', 'CRIT_DERA_PE', 'CRIT_DERA_MS' ),),
#
CRIT_DERA_ABS = SIMP(statut='f',typ='R' ,
- fr="Critère absolu",
+ fr="Critere absolu",
ang="Absolute threshold" ),
CRIT_DERA_REL = SIMP(statut='f',typ='R',val_min=0.0,val_max=1.0,
- fr="Critère relatif : fraction réelle entre 0. et 1.",
+ fr="Critere relatif : fraction reelle entre 0. et 1.",
ang="Relative threshold: ratio between 0. and 1." ),
CRIT_DERA_PE = SIMP(statut='f',typ='R',val_min=0.0,val_max=1.0,
- fr="Pourcentage de mailles : fraction réelle entre 0. et 1.",
+ fr="Pourcentage de mailles : fraction reelle entre 0. et 1.",
ang="Percentage of meshes: ratio between 0. and 1." ),
CRIT_DERA_MS = SIMP(statut='f',typ='R',
- fr="Critère absolu valant moyenne - n*sigma, n étant > 0",
+ fr="Critere absolu valant moyenne - n*sigma, n etant > 0",
ang="Absolute threshold: mean - n*sigma, with n > 0" ),
) ,
#
-# 6. Pour de l'adaptation par zone, définitions des zones
+# 6. Pour de l'adaptation par zone, definitions des zones
#
b_zone = BLOC( condition = " (ADAPTATION == 'RAFF_DERA_ZONE') " ,
- fr="Pour une adaptation selon une zone à raffiner",
+ fr="Pour une adaptation selon une zone a raffiner",
ang="For adaptation among a zone",
#
ZONE = FACT(statut='o',min=1,max='**',
- fr="Définition de zones à raffiner.",
+ fr="Definition de zones a raffiner.",
ang="Refined zone definition.",
#
# 6.1. Type de la zone
fr="Abscisse maximum de la boite",
ang="Maximum X for the box"),
Y_MINI = SIMP(statut='f',typ='R',
- fr="Ordonnée minimum de la boite",
+ fr="Ordonnee minimum de la boite",
ang="Minimum Y for the box"),
Y_MAXI = SIMP(statut='f',typ='R',
fr="Abscisse maximum de la boite",
##gn fr="X et Y du centre d'un disque plein ou perce, d'une sphere.",
##gn ang="X and Y of the centre of a disk or of a sphere.",
X_CENTRE = SIMP(statut='f',typ='R',
- fr="Abscisse du centre du disque ou de la sphère",
+ fr="Abscisse du centre du disque ou de la sphere",
ang="X for the center of the disk or of the sphere"),
Y_CENTRE = SIMP(statut='f',typ='R',
- fr="Ordonnée du centre du disque ou de la sphère",
+ fr="Ordonnee du centre du disque ou de la sphere",
ang="Y for the center of the disk or of the sphere"),
##gn ) ,
#
##gn fr="Cote du centre de la sphere.",
##gn ang="Z for the center of the sphere.",
Z_CENTRE = SIMP(statut='f',typ='R',
- fr="Cote du centre de la sphère",
+ fr="Cote du centre de la sphere",
ang="Z for the center of the sphere"),
##gn ) ,
#
##gn fr="Le rayon d'un disque perce ou d'un tuyau.",
##gn ang="The radius of a holed disk or of a pipe.",
RAYON_INT = SIMP(statut='f',typ='R',
- fr="Rayon intérieur",
+ fr="Rayon interieur",
ang="Internal radius"),
RAYON_EXT = SIMP(statut='f',typ='R',
- fr="Rayon extérieur",
+ fr="Rayon exterieur",
ang="External radius"),
##gn ) ,
#
fr="Abscisse du vecteur directeur de l'axe",
ang="X for the axial vector"),
Y_AXE = SIMP(statut='f',typ='R',
- fr="Ordonnée du vecteur directeur de l'axe",
+ fr="Ordonnee du vecteur directeur de l'axe",
ang="Y for the axial vector"),
Z_AXE = SIMP(statut='f',typ='R',
fr="Cote du vecteur directeur de l'axe",
fr="Abscisse d'un point de la base, sur l'axe",
ang="X for the basis, on the axis"),
Y_BASE = SIMP(statut='f',typ='R',
- fr="Ordonnée d'un point de la base, sur l'axe",
+ fr="Ordonnee d'un point de la base, sur l'axe",
ang="Y for the basis, on the axis"),
Z_BASE = SIMP(statut='f',typ='R',
fr="Cote d'un point de la base, sur l'axe",
ang="Maximum level for the refinement"),
#
DIAM_MIN = SIMP(statut='f',typ='R',
- fr="Diamètre minimal des mailles",
+ fr="Diametre minimal des mailles",
ang="Minimal diameter for the meshes" ),
#
) ,
b_niveau_minimum = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
(ADAPTATION == 'DERAFFINEMENT') or \
(ADAPTATION == 'DERAFFINEMENT_UNIFORME') " ,
- fr="Niveau minimum de profondeur de déraffinement",
+ fr="Niveau minimum de profondeur de deraffinement",
ang="Minimum level for the unrefinement",
NIVE_MIN = SIMP(statut='f',typ='I',
- fr="Niveau minimum de profondeur de déraffinement",
+ fr="Niveau minimum de profondeur de deraffinement",
ang="Minimum level for the unrefinement"),
) ,
#
ang="List of the groups of nodes for filtering of the adaptation." ),
) ,
#
-# 9. Suivi d'une frontière
+# 9. Suivi d'une frontiere
#
-# 9.1. Definition d'une frontière par un maillage (valable seulement pour des frontières 1D)
+# 9.1. Definition d'une frontiere par un maillage (valable seulement pour des frontieres 1D)
#
MAILLAGE_FRONTIERE = SIMP(statut='f',typ=maillage_sdaster,
- fr="Maillage de la frontière discrète à suivre",
+ fr="Maillage de la frontiere discrete a suivre",
ang="Discrete boundary mesh" ),
#
b_FRONTIERE = BLOC( condition = " MAILLAGE_FRONTIERE != None " ,
- fr="Information complémentaire sur la frontière discrète",
+ fr="Information complementaire sur la frontiere discrete",
ang="Further information about discrete boundary",
#
GROUP_MA_FRONT = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="Liste des groupes de mailles définissant la frontière discrète",
+ fr="Liste des groupes de mailles definissant la frontiere discrete",
ang="Mesh groups which define the discrete boundary" ),
#
) ,
#
-# 9.2. Definition analytique d'une frontière
+# 9.2. Definition analytique d'une frontiere
#
FRONTIERE_ANALYTIQUE = FACT(statut='f',max='**',
- fr="Definition analytique de frontières a suivre.",
+ fr="Definition analytique de frontieres a suivre.",
ang="Analytical definition of a boundary.",
#
-# 9.2.1. Nom de la frontière
+# 9.2.1. Nom de la frontiere
#
NOM = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
- fr="Nom de la frontière analytique",
+ fr="Nom de la frontiere analytique",
ang="Name of the analytic boundary" ),
#
-# 9.2.2. Type de la frontière
+# 9.2.2. Type de la frontiere
#
TYPE = SIMP(statut='o',typ='TXM',into=("SPHERE", "CYLINDRE"),
- fr="Type de la frontière analytique",
+ fr="Type de la frontiere analytique",
ang="Type of the analytic boundary" ),
#
# 9.2.3. Pour une sphere, un cylindre par ses rayons : rayon et centre
#
b_fr_rayon = BLOC( condition = " (TYPE == 'SPHERE') or (TYPE == 'CYLINDRE') " ,
- fr="Le rayon et le centre d'une sphère ou d'un cylindre.",
+ fr="Le rayon et le centre d'une sphere ou d'un cylindre.",
ang="The radius and the centre of a sphere or of a cylinder.",
RAYON = SIMP(statut='o',typ='R',
fr="Rayon",
fr="Abscisse du centre",
ang="X for the center"),
Y_CENTRE = SIMP(statut='o',typ='R',
- fr="Ordonnée du centre",
+ fr="Ordonnee du centre",
ang="Y for the center"),
Z_CENTRE = SIMP(statut='o',typ='R',
fr="Cote du centre",
fr="Abscisse du vecteur directeur de l'axe",
ang="X for the axial vector"),
Y_AXE = SIMP(statut='o',typ='R',
- fr="Ordonnée du vecteur directeur de l'axe",
+ fr="Ordonnee du vecteur directeur de l'axe",
ang="Y for the axial vector"),
Z_AXE = SIMP(statut='o',typ='R',
fr="Cote du vecteur directeur de l'axe",
ang="Z for the axial vector"),
) ,
#
-# 9.2.7. Groupe(s) lie(s) a la frontière
+# 9.2.7. Groupe(s) lie(s) a la frontiere
#
GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**',
- fr="Liste des groupes de mailles placées sur la frontière",
+ fr="Liste des groupes de mailles placees sur la frontiere",
ang="Groups of meshes which are located on the boundary" ),
#
) ,
#
-# 10. mise à jour de champs sur le nouveau maillage
+# 10. mise a jour de champs sur le nouveau maillage
#
MAJ_CHAM = FACT(statut='f',max='**',
- fr="Mise à jour de champs sur le nouveau maillage.",
+ fr="Mise a jour de champs sur le nouveau maillage.",
ang="Updating of the fields over the new mesh.",
#
# 10.1. Le nom du champ de grandeur qui contiendra le resultat de la mise a jour
#
CHAM_MAJ = SIMP(statut='o',typ=CO,
- fr="Nom du champ de grandeur qui contiendra le champ mis à jour",
+ fr="Nom du champ de grandeur qui contiendra le champ mis a jour",
ang="Name of the field for the updated field"),
#
# 10.2. Le type du champ qui contiendra le resultat de la mise a jour
#
TYPE_CHAM = SIMP(statut='o',typ='TXM',into=C_TYPE_CHAM_INTO( ('NOEU', 'ELEM', 'ELNO', 'ELGA') ),
- fr="Type du champ qui contiendra le champ mis à jour",
+ fr="Type du champ qui contiendra le champ mis a jour",
ang="Type of the field for the updated field" ),
#
# 10.3. Le champ a interpoler
# 10.3.1. Sous forme de champ de grandeur
#
CHAM_GD = SIMP(statut='f',typ=cham_gd_sdaster,
- fr="Champ de grandeur Code_Aster contenant le champ à mettre à jour",
+ fr="Champ de grandeur Code_Aster contenant le champ a mettre a jour",
ang="Champ de grandeur with the field to be updated" ),
#
# 10.3.2. Sous forme de champ dans un resultat
#
RESULTAT = SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther),
- fr="Résultat contenant le champ à mettre à jour",
+ fr="Resultat contenant le champ a mettre a jour",
ang="Result with the field to be updated" ),
#
b_nom_du_champ = BLOC(condition="(RESULTAT != None)",
- fr="Choix éventuel du nom du champ à interpoler",
+ fr="Choix eventuel du nom du champ a interpoler",
ang="Selection for the name of the field (option)",
#
NOM_CHAM = SIMP(statut='o',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO(),
- fr="Nom du champ à mettre à jour",
+ fr="Nom du champ a mettre a jour",
ang="Name of the field to be updated" ),
#
),
fr="Liste des composante(s) retenue(s) pour le champ.",
ang="List of the selected component(s) for the field." ),
#
-# 10.5. Le paramètre temporel pour le champ a interpoler
+# 10.5. Le parametre temporel pour le champ a interpoler
#
b_parametre_temporel = BLOC(condition="(RESULTAT != None)",
- fr="Choix éventuel du paramètre temporel pour le champ à interpoler",
+ fr="Choix eventuel du parametre temporel pour le champ a interpoler",
ang="Time selection for the field (option)",
#
regles=(EXCLUS('NUME_ORDRE','INST'),),
# 10.5.1. Soit le numero d'ordre
#
NUME_ORDRE = SIMP(statut='f',typ='I',
- fr="Numéro d ordre du champ à mettre à jour",
+ fr="Numero d ordre du champ a mettre a jour",
ang="Rank of the field to be updated" ),
#
# 10.5.2. Soit l'instant
# 10.5.2.1. Sa valeur
#
INST = SIMP(statut='f',typ='R',
- fr="Instant associé",
+ fr="Instant associe",
ang="Instant" ),
#
-# 10.5.2.2. La précision du choix de l'instant
+# 10.5.2.2. La precision du choix de l'instant
#
b_precision = BLOC(condition="(INST != None)",
- fr="Choix de la précision du choix de l'instant",
+ fr="Choix de la precision du choix de l'instant",
ang="Selection for the choice of the instant",
#
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF", "ABSOLU",),
- fr="Critère de précision sur le choix de l'instant associé",
+ fr="Critere de precision sur le choix de l'instant associe",
ang="Accuracy criterium over the choice of the instant"),
b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,
- fr="Précision relative sur le choix de l'instant associé",
+ fr="Precision relative sur le choix de l'instant associe",
ang="Relative accuracy over the choice of the instant"),),
b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
PRECISION =SIMP(statut='o',typ='R',
- fr="Précision absolue sur le choix de l'instant associé",
+ fr="Precision absolue sur le choix de l'instant associe",
ang="Absolute accuracy over the choice of the instant"),),
#
),
#
TYPE_MAJ = SIMP(statut='f',typ='TXM',defaut="AUTO",
into=("AUTO", "ISOP2"),
- fr="Type de mise à jour : automatique ou iso-P2",
+ fr="Type de mise a jour : automatique ou iso-P2",
ang="Type of the updating" ),
),
#
# 11.1. Changement de degre
#
DEGRE = SIMP(statut='o',typ='TXM',into=("OUI",),
- fr="Changement de degré du maillage",
+ fr="Changement de degre du maillage",
ang="Modification of the degree of the mesh" ),
#
) ,
ang="Readings of the fields over the Gauss points.",
#
MODELE = SIMP(statut='o',typ=modele_sdaster,
- fr="Modèle",
+ fr="Modele",
ang="Model" ),
#
) ,
fr="Nombre de noeuds et de mailles du maillage",
ang="Number of nodes and meshes in the mesh" ),
#
-# 13.2. Determination de la qualité des mailles du maillage
+# 13.2. Determination de la qualite des mailles du maillage
#
QUALITE = SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="Qualité du maillage",
+ fr="Qualite du maillage",
ang="Quality of the mesh" ),
#
# 13.3. Connexite du maillage
#
CONNEXITE = SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="Connexité du maillage.",
+ fr="Connexite du maillage.",
ang="Connexity of the mesh." ),
#
# 13.4. Taille des sous-domaines du maillage
# 13.5. Controle de la non-interpenetration des mailles
#
INTERPENETRATION=SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="Controle de la non interpénétration des mailles.",
+ fr="Controle de la non interpenetration des mailles.",
ang="Overlapping checking." ),
#
-# 13.6. Propriétés du maillage de calcul
+# 13.6. Proprietes du maillage de calcul
#
PROP_CALCUL = SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="Propriétés du maillage de calcul.",
+ fr="Proprietes du maillage de calcul.",
ang="Properties of the calculation mesh." ),
#
# 13.7. Determination des diametres des mailles du maillage
#
DIAMETRE = SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="Diamètre du maillage",
+ fr="Diametre du maillage",
ang="Diameters of the mesh" ),
#
) ,
#
) ,
#
-# 15. Les options avancées
+# 15. Les options avancees
# 15.1. Langue des messages issus de HOMARD
#
LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS",
#
# 15.2. Gestion des mailles acceptees dans le maillage initial
# "HOMARD" : exclusivement les mailles pouvant etre decoupees (defaut)
-# "IGNORE_PYRA" : elles sont ignorées
+# "IGNORE_PYRA" : elles sont ignorees
#
b_autres_mailles = BLOC( condition = " (ADAPTATION != 'LECTURE') " ,
fr="Gestion des pyramides.",
fr="Version de HOMARD",
ang="HOMARD release"),
#
-# 15.4. Exécutable pilotant HOMARD
+# 15.4. Executable pilotant HOMARD
#
LOGICIEL = SIMP(statut='f',typ='TXM',
fr="Logiciel pilotant HOMARD",
ang="HOMARD software"),
#
-# 15.5. Unite logique d'un fichier à ajouter a HOMARD.Configuration
+# 15.5. Unite logique d'un fichier a ajouter a HOMARD.Configuration
#
b_unite = BLOC( condition = " (VERSION_HOMARD == 'V10_N') or \
(VERSION_HOMARD == 'V10_N_PERSO') " ,
MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",
op=OPS('Macro.macr_ascouf_calc_ops.macr_ascouf_calc_ops'),
sd_prod=macr_ascouf_calc_prod,
- fr="Réalise l'analyse thermomécanique du coude dont le maillage a " \
- "été concu par MACR_ASCOUF_MAIL",
+ fr="Realise l'analyse thermomecanique du coude dont le maillage a " \
+ "ete concu par MACR_ASCOUF_MAIL",
reentrant='n',
- UIinfo={"groupes":("Résolution","Outils-métier",)},
+ UIinfo={"groupes":("Resolution","Outils-metier",)},
TYPE_MAILLAGE =SIMP(statut='o',typ='TXM',
into=("SAIN",
MACR_ASCOUF_MAIL=MACRO(nom="MACR_ASCOUF_MAIL",
op=OPS('Macro.macr_ascouf_mail_ops.macr_ascouf_mail_ops'),
sd_prod=maillage_sdaster,
- fr="Engendre le maillage d'un coude sain ou comportant une fissure ou une (ou plusieurs) sous-épaisseur(s)",
- UIinfo={"groupes":("Maillage","Outils-métier",)},
+ fr="Engendre le maillage d'un coude sain ou comportant une fissure ou une (ou plusieurs) sous-epaisseur(s)",
+ UIinfo={"groupes":("Maillage","Outils-metier",)},
reentrant='n',
regles=(EXCLUS('SOUS_EPAIS_COUDE','FISS_COUDE','SOUS_EPAIS_MULTI'),),
MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",
op=OPS('Macro.macr_aspic_calc_ops.macr_aspic_calc_ops'),
sd_prod=macr_aspic_calc_prod,
- fr="Réalise un calcul prédéfini de piquages sains ou fissurés " \
- "ainsi que les post-traitements associés ",
- UIinfo={"groupes":("Résolution","Outils-métier",)},
+ fr="Realise un calcul predefini de piquages sains ou fissures " \
+ "ainsi que les post-traitements associes ",
+ UIinfo={"groupes":("Resolution","Outils-metier",)},
reentrant='n',
TYPE_MAILLAGE =SIMP(statut='o',typ='TXM',
sd_prod=maillage_sdaster,
reentrant='n',
fr="Engendre le maillage d'un piquage sain ou avec fissure (longue ou courte)",
- UIinfo={"groupes":("Maillage","Outils-métier",)},
+ UIinfo={"groupes":("Maillage","Outils-metier",)},
EXEC_MAILLAGE =FACT(statut='o',
LOGICIEL =SIMP(statut='o',typ='TXM',defaut="GIBI2000",into=("GIBI98","GIBI2000")),
op=OPS('Macro.macr_cara_poutre_ops.macr_cara_poutre_ops'),
sd_prod=table_sdaster,
reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
- fr="Calculer les caractéristiques d'une section transversale de " \
- "poutre à partir d'un maillage 2D de la section",
+ UIinfo={"groupes":("Modelisation",)},
+ fr="Calculer les caracteristiques d'une section transversale de " \
+ "poutre a partir d'un maillage 2D de la section",
regles=(
EXCLUS('SYME_Y','GROUP_MA_BORD'),
EXCLUS('SYME_Z','GROUP_MA_BORD'),
),
ORIG_INER =SIMP(statut='f',typ='R',max=3,defaut=(0.E+0,0.E+0),
- fr="Point par rapport auquel sont calculées les inerties"),
+ fr="Point par rapport auquel sont calculees les inerties"),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
TABLE_CARA =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",),
SYME_Z =SIMP(statut='f',typ='TXM',into=("OUI",), fr="demi maillage par rapport a z=0"),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="Calcul des caractéristiques équivalentes à plusieurs sections disjointes"),
+ fr="Calcul des caracteristiques equivalentes a plusieurs sections disjointes"),
GROUP_MA_BORD =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="Groupe(s) de mailles linéiques, bord(s) de(s) section(s)"),
+ fr="Groupe(s) de mailles lineiques, bord(s) de(s) section(s)"),
b_nom =BLOC(
condition = """(TABLE_CARA == 'OUI') and (GROUP_MA == None)""",
NOM =SIMP(statut='f',typ='TXM',max=1,validators=LongStr(1,8),
- fr="Nom de la section, 8 caractères maximum.")
+ fr="Nom de la section, 8 caracteres maximum.")
),
b_gma_bord =BLOC(
fr="Simplement pour empecher des pivots nuls le cas echeant. "
"Fournir un noeud quelconque par GROUP_MA"),
GROUP_MA_INTE =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="groupes de mailles linéiques bordant des trous dans la section"),
+ fr="groupes de mailles lineiques bordant des trous dans la section"),
),
b_reseau = BLOC(
condition ="""(GROUP_MA_BORD != None) and (GROUP_MA != None)""",
- fr=" calcul des coef de cisaillement équivalents a un reseau de poutres",
+ fr=" calcul des coef de cisaillement equivalents a un reseau de poutres",
regles=(ENSEMBLE('LONGUEUR','LIAISON','MATERIAU') ,),
LONGUEUR =SIMP(statut='f',typ='R',
- fr="Longueur du réseau de poutres"),
+ fr="Longueur du reseau de poutres"),
MATERIAU =SIMP(statut='f',typ=mater_sdaster,
fr="Materiau elastique lineaire du reseau"),
LIAISON =SIMP(statut='f',typ='TXM',into=("ROTULE","ENCASTREMENT"),
- fr="type de conditions aux limites sur le plancher supérieur" ),
+ fr="type de conditions aux limites sur le plancher superieur" ),
),
)
op=OPS('Macro.macr_ecla_pg_ops.macr_ecla_pg_ops'),
sd_prod=macr_ecla_pg_prod,
reentrant='n',
- UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
+ UIinfo={"groupes":("Post-traitements","Resultats et champs",)},
fr="Permettre la visualisation des champs aux points de Gauss d'une " \
"SD_RESULTAT sans lissage ni interpolation",
- # SD résultat ,modèle et champs à "éclater" :
- RESU_INIT =SIMP(statut='o',typ=resultat_sdaster,fr="RESULTAT à éclater",),
- MODELE_INIT =SIMP(statut='o',typ=modele_sdaster,fr="MODELE à éclater"),
+ # SD resultat ,modele et champs a "eclater" :
+ RESU_INIT =SIMP(statut='o',typ=resultat_sdaster,fr="RESULTAT a eclater",),
+ MODELE_INIT =SIMP(statut='o',typ=modele_sdaster,fr="MODELE a eclater"),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),),
- # paramètres numériques de la commande :
- SHRINK =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de réduction" ),
- TAILLE_MIN =SIMP(statut='f',typ='R',defaut= 0.0, fr="Taille minimale d'un coté" ),
+ # parametres numeriques de la commande :
+ SHRINK =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de reduction" ),
+ TAILLE_MIN =SIMP(statut='f',typ='R',defaut= 0.0, fr="Taille minimale d'un cote" ),
# concepts produits par la commande :
- RESULTAT =SIMP(statut='o',typ=CO,fr="SD_RESULTAT résultat de la commande"),
- MAILLAGE =SIMP(statut='o',typ=CO,fr="MAILLAGE associé aux cham_no de la SD_RESULTAT"),
+ RESULTAT =SIMP(statut='o',typ=CO,fr="SD_RESULTAT resultat de la commande"),
+ MAILLAGE =SIMP(statut='o',typ=CO,fr="MAILLAGE associe aux cham_no de la SD_RESULTAT"),
- # Sélection éventuelle d'un sous-ensemble des éléments à visualiser :
+ # Selection eventuelle d'un sous-ensemble des elements a visualiser :
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- # Sélection des numéros d'ordre :
+ # Selection des numeros d'ordre :
regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),),
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
op=OPS('Macro.macr_ecre_calc_ops.macr_ecre_calc_ops'),
sd_prod=macr_ecre_calc_prod,
reentrant='n',
- UIinfo={"groupes":("Résolution","Outils-métier",)},
+ UIinfo={"groupes":("Resolution","Outils-metier",)},
fr="Procedure de couplage avec Ecrevisse",
regles = (UN_PARMI('LOGICIEL','VERSION'),),
op=OPS('Macro.macr_ecrevisse_ops.macr_ecrevisse_ops'),
sd_prod=macr_ecrevisse_prod,
reentrant='f',
- UIinfo={"groupes":("Résolution","Outils-métier",)},
+ UIinfo={"groupes":("Resolution","Outils-metier",)},
fr="Procedure de couplage avec Ecrevisse",
reuse = SIMP(statut='f',typ='evol_noli'),
# person_in_charge: jacques.pellet at edf.fr
MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant='f',
UIinfo={"groupes":("Matrices et vecteurs",)},
- fr="Définition d'un macro-élément pour l'analyse statique par sous-structuration",
+ fr="Definition d'un macro-element pour l'analyse statique par sous-structuration",
regles=(AU_MOINS_UN('DEFINITION','RIGI_MECA','MASS_MECA','CAS_CHARGE'),
ENSEMBLE('DEFINITION','EXTERIEUR'),),
DEFINITION =FACT(statut='f',
# 2. Le nom du maillage a analyser
#
MAILLAGE = SIMP(statut='o',typ=maillage_sdaster,
- fr="Maillage à analyser.",
+ fr="Maillage a analyser.",
ang="Mesh to be checked." ),
#
# 3. Suivi d'une frontiere
#
MAILLAGE_FRONTIERE = SIMP(statut='f',typ=maillage_sdaster,
- fr="Maillage de la frontiere à suivre",
+ fr="Maillage de la frontiere a suivre",
ang="Boundary mesh" ),
#
b_frontiere = BLOC( condition = " MAILLAGE_FRONTIERE != None " ,
- fr="Information complémentaire sur la frontière",
+ fr="Information complementaire sur la frontiere",
ang="Further information about boundary",
#
GROUP_MA_FRONT = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="Groupes de mailles définissant la frontière",
+ fr="Groupes de mailles definissant la frontiere",
ang="Mesh groups which define the boundary" ),
#
) ,
#
-# 4. Les options ; par defaut, on controle tout, sauf l'interpénétration
+# 4. Les options ; par defaut, on controle tout, sauf l'interpenetration
# 4.1. Nombre de noeuds et mailles
#
NOMBRE = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI",),
# 4.2. Determination de la qualite des mailles du maillage
#
QUALITE = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI",),
- fr="Qualité du maillage",
+ fr="Qualite du maillage",
ang="Quality of the mesh" ),
#
# 4.3. Connexite du maillage
#
CONNEXITE = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI",),
- fr="Connexité du maillage.",
+ fr="Connexite du maillage.",
ang="Connexity of the mesh." ),
#
# 4.4. Taille des sous-domaines du maillage
fr="Tailles des sous-domaines du maillage.",
ang="Sizes of mesh sub-domains." ),
#
-# 4.5. Controle de la non-interpénétration des mailles
+# 4.5. Controle de la non-interpenetration des mailles
#
INTERPENETRATION=SIMP(statut='f',typ='TXM',into=("OUI",),
- fr="Controle de la non interpénétration des mailles.",
+ fr="Controle de la non interpenetration des mailles.",
ang="Overlapping checking." ),
#
-# 4.6. Propriétés du maillage de calcul
+# 4.6. Proprietes du maillage de calcul
#
PROP_CALCUL = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI",),
- fr="Propriétés du maillage de calcul.",
+ fr="Proprietes du maillage de calcul.",
ang="Properties of the calculation mesh." ),
#
# 4.7. Determination des diametres des mailles du maillage
#
DIAMETRE = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI",),
- fr="Diamètre du maillage",
+ fr="Diametre du maillage",
ang="Diameters of the mesh" ),
#
-# 5. Les options avancées
+# 5. Les options avancees
# 5.1. Langue des messages issus de HOMARD
#
LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS",
#
# 5.2. Gestion des mailles acceptees dans le maillage initial
# "HOMARD" : exclusivement les mailles pouvant etre decoupees (defaut)
-# "IGNORE_PYRA" : elles sont ignorées
+# "IGNORE_PYRA" : elles sont ignorees
#
ELEMENTS_ACCEPTES = SIMP(statut='f',typ='TXM',defaut="HOMARD",into=("HOMARD", "IGNORE_PYRA"),
fr="Acceptation des mailles dans le maillage initial",
fr="Version de HOMARD",
ang="HOMARD release"),
#
-# 5.4. Exécutable pilotant HOMARD
+# 5.4. Executable pilotant HOMARD
#
LOGICIEL = SIMP(statut='f',typ='TXM',
fr="Logiciel pilotant HOMARD",
ang="HOMARD software"),
#
-# 5.5. Unite logique d'un fichier à ajouter a HOMARD.Configuration
+# 5.5. Unite logique d'un fichier a ajouter a HOMARD.Configuration
#
b_unite = BLOC( condition = " (VERSION_HOMARD == 'V10_N') or \
(VERSION_HOMARD == 'V10_N_PERSO') " ,
op=OPS('Macro.macr_lign_coupe_ops.macr_lign_coupe_ops'),
sd_prod=table_sdaster,
reentrant='n',
- UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
- fr="Extraction des valeurs d'un résultat dans une ou plusieurs tables sur " \
- "des lignes de coupe définies par deux points et un intervalle",
+ UIinfo={"groupes":("Post-traitements","Resultats et champs",)},
+ fr="Extraction des valeurs d'un resultat dans une ou plusieurs tables sur " \
+ "des lignes de coupe definies par deux points et un intervalle",
regles=(UN_PARMI("RESULTAT","CHAM_GD"),),
RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther,mode_meca) ),
CHAM_GD =SIMP(statut='f',typ=(cham_gd_sdaster)),
- b_extrac =BLOC(condition = "RESULTAT != None",fr="extraction des résultats",
+ b_extrac =BLOC(condition = "RESULTAT != None",fr="extraction des resultats",
regles=(EXCLUS('NUME_ORDRE','NUME_MODE','LIST_ORDRE','INST','LIST_INST',), ),
NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
PRECISION =SIMP(statut='o',typ='R',),),
),
-# extraction des résultats
- b_meca =BLOC(condition = "AsType(RESULTAT) in (evol_elas,evol_noli,mode_meca)",fr="résultat mécanique",
+# extraction des resultats
+ b_meca =BLOC(condition = "AsType(RESULTAT) in (evol_elas,evol_noli,mode_meca)",fr="resultat mecanique",
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),defaut='SIGM_NOEU',into=C_NOM_CHAM_INTO(),),
),
- b_ther =BLOC(condition = "AsType(RESULTAT) in (evol_ther,)",fr="résultat thermique",
+ b_ther =BLOC(condition = "AsType(RESULTAT) in (evol_ther,)",fr="resultat thermique",
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),defaut='TEMP',into=("TEMP",
"FLUX_ELGA","FLUX_ELNO","FLUX_NOEU",
"META_ELNO","META_NOEU",
GROUP_MA =SIMP(statut='o',typ=grma, max=1),
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster),
# si le groupe de mailles forme une ligne ouverte, on peut choisir le sens de parcours en choissant l'origine:
- # si le groupe de mailles forme une ligne fermée, il FAUT choisir l'origine et l'extrémité (= origine):
+ # si le groupe de mailles forme une ligne fermee, il FAUT choisir l'origine et l'extremite (= origine):
NOEUD_ORIG =SIMP(statut='f',typ=no),
GROUP_NO_ORIG =SIMP(statut='f',typ=grno),
NOEUD_EXTR =SIMP(statut='f',typ=no),
GROUP_NO_EXTR =SIMP(statut='f',typ=grno),
- # si le groupe de mailles forme une ligne fermée, on peut choisir le sens de parcours
- VECT_ORIE =SIMP(statut='f',typ='R',max=3), # utilisé seulement si NOEUD_ORIG=NOEUD_EXTR
+ # si le groupe de mailles forme une ligne fermee, on peut choisir le sens de parcours
+ VECT_ORIE =SIMP(statut='f',typ='R',max=3), # utilise seulement si NOEUD_ORIG=NOEUD_EXTR
),
b_segment =BLOC(condition = "TYPE=='SEGMENT'",
AXE_Z =SIMP(statut='f',typ='R',min=3,max=3),),
DISTANCE_MAX =SIMP(statut='f',typ='R',defaut=0.,
- fr="Si la distance entre un noeud de la ligne de coupe et le maillage coupé "
- +"est > DISTANCE_MAX, ce noeud sera ignoré."),
+ fr="Si la distance entre un noeud de la ligne de coupe et le maillage coupe "
+ +"est > DISTANCE_MAX, ce noeud sera ignore."),
),
) ;
MACR_RECAL = MACRO(nom="MACR_RECAL",
op=OPS('Macro.macr_recal_ops.macr_recal_ops'),
sd_prod=macr_recal_prod,
- UIinfo={"groupes":("Résolution","Résultats et champs",)},
- fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux" \
- " ou sur d'autres résultats de calculs",
+ UIinfo={"groupes":("Resolution","Resultats et champs",)},
+ fr="Realise le recalage des calculs Aster sur des resultats experimentaux" \
+ " ou sur d'autres resultats de calculs",
regles=(UN_PARMI('PARA_OPTI','LIST_PARA'),
PRESENT_PRESENT('PARA_OPTI','COURBE'),
PRESENT_PRESENT('LIST_PARA','RESU_EXP'),
AFFICHAGE =SIMP(statut='f',typ='TXM',defaut='TOUTE_ITERATION',into=("TOUTE_ITERATION","ITERATION_FINALE"),),
UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
- b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", fr="Mots-clés propres à XMGRACE",
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit"),
+ b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", fr="Mots-cles propres a XMGRACE",
PILOTE =SIMP(statut='f',typ='TXM',defaut='',
into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),
fr="Pilote de sortie, PNG/JPEG/PDF ne sont pas disponibles sur toutes les installations de xmgrace"),
op=OPS('Macro.macr_spectre_ops.macr_spectre_ops'),
sd_prod=table_sdaster,
reentrant='n',
- UIinfo={"groupes":("Post-traitements","Outils-métier",)},
- fr="Calcul de spectre, post-traitement de séisme",
+ UIinfo={"groupes":("Post-traitements","Outils-metier",)},
+ fr="Calcul de spectre, post-traitement de seisme",
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster,),
PLANCHER =FACT(statut='o',max='**',
regles=(AU_MOINS_UN('NOEUD','GROUP_NO' ),),
TRI =SIMP(statut='f',typ='TXM',defaut='AMOR_SPEC',into=("AMOR_SPEC","DIRECTION",),),
FORMAT =SIMP(statut='f',typ='TXM',defaut='TABLEAU',into=("TABLEAU","XMGRACE",),),
UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit"),
b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'",
PILOTE =SIMP(statut='f',typ='TXM',defaut='',
into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),),),
op=OPS('Macro.macro_elas_mult_ops.macro_elas_mult_ops'),
sd_prod=macro_elas_mult_prod,
reentrant='f',
- UIinfo={"groupes":("Résolution",)},
- fr="Calculer les réponses statiques linéaires pour différents cas " \
+ UIinfo={"groupes":("Resolution",)},
+ fr="Calculer les reponses statiques lineaires pour differents cas " \
"de charges ou modes de Fourier",
regles=(UN_PARMI('CHAR_MECA_GLOBAL','LIAISON_DISCRET', ),),
MODELE =SIMP(statut='o',typ=modele_sdaster),
SOLVEUR =FACT(statut='d',
METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT") ),
b_mult_front = BLOC ( condition = "METHODE == 'MULT_FRONT' ",
- fr="Paramètres de la méthode multi frontale",
+ fr="Parametres de la methode multi frontale",
RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
),
- b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+ b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Parametres de la methode LDLT",
RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
),
b_ldlt_mult =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' ",
- fr="Paramètres relatifs à la non inversibilité de la matrice à factorise",
+ fr="Parametres relatifs a la non inversibilite de la matrice a factorise",
NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
),
op=OPS('Macro.macro_expans_ops.macro_expans_ops'),
sd_prod=macro_expans_prod,
reentrant='n',
- UIinfo={"groupes":("Outils-métier","Dynamique",)},
+ UIinfo={"groupes":("Outils-metier","Dynamique",)},
fr="Outil d'expansion de resultats exprimentaux sur une base definie sur un modele numerique",
MODELE_CALCUL = FACT(statut='o',
MODELE = SIMP(statut='o',typ=(modele_sdaster) ),
MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",
op=OPS('Macro.macro_matr_ajou_ops.macro_matr_ajou_ops'),
sd_prod=macro_matr_ajou_prod,
- UIinfo={"groupes":("Résolution","Matrices et vecteurs",)},
- fr="Calculer de facon plus condensée qu'avec CALC_MATR_AJOU des " \
- "matrices de masse, d'amortissement ou de rigidité ajoutés",
+ UIinfo={"groupes":("Resolution","Matrices et vecteurs",)},
+ fr="Calculer de facon plus condensee qu'avec CALC_MATR_AJOU des " \
+ "matrices de masse, d'amortissement ou de rigidite ajoutes",
regles=(AU_MOINS_UN('MODE_MECA','DEPL_IMPO','MODELE_GENE'),
AU_MOINS_UN('MATR_MASS_AJOU','MATR_AMOR_AJOU','MATR_RIGI_AJOU'),
EXCLUS('MODE_MECA','DEPL_IMPO','MODELE_GENE'),
if ( AsType(MATR_MASS) == matr_asse_gene_r ):
return mode_gene
else:
- raise AsException("Matrices d'entrée de types différents : physique / généralisée.")
+ raise AsException("Matrices d'entree de types differents : physique / generalisee.")
return mode_meca
MACRO_MODE_MECA=MACRO(nom="MACRO_MODE_MECA",
op=OPS('Macro.macro_mode_meca_ops.macro_mode_meca_ops'),
sd_prod=macro_mode_meca_prod,
- reentrant='n',fr="Lancer une succession de calculs de modes propres réels",
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ reentrant='n',fr="Lancer une succession de calculs de modes propres reels",
+ UIinfo={"groupes":("Resolution","Dynamique",)},
MATR_RIGI =SIMP(statut='o',typ=(matr_asse_depl_r, matr_asse_gene_r) ),
MATR_MASS =SIMP(statut='o',typ=(matr_asse_depl_r, matr_asse_gene_r) ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
#
MAJ_CATA=PROC(nom="MAJ_CATA",op=20,
UIinfo={"groupes":("Gestion du travail",)},
- fr="Compilation des catalogues d'éléments et couverture des calculs élémentaires",
+ fr="Compilation des catalogues d'elements et couverture des calculs elementaires",
regles=(UN_PARMI('ELEMENT','TYPE_ELEM', ),),
ELEMENT =FACT(statut='f',),
# ======================================================================
# person_in_charge: jacques.pellet at edf.fr
MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas,
- fr="Résoudre un problème de mécanique statique linéaire",reentrant='f',
- UIinfo={"groupes":("Résolution","Mécanique",)},
+ fr="Resoudre un probleme de mecanique statique lineaire",reentrant='f',
+ UIinfo={"groupes":("Resolution","Mecanique",)},
regles=(EXCLUS("INST","LIST_INST"),
AU_MOINS_UN('CHAM_MATER','CARA_ELEM',),),
MODELE =SIMP(statut='o',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='f',typ=cham_mater,
- fr="le CHAM_MATER est nécessaire, sauf si le modèle ne contient que des éléments discrets (modélisations DIS_XXX)",
+ fr="le CHAM_MATER est necessaire, sauf si le modele ne contient que des elements discrets (modelisations DIS_XXX)",
ang="CHAM_MATER is compulsory, except if the model contains only discret elements (modelizations DIS_XXX)"),
CARA_ELEM =SIMP(statut='f',typ=cara_elem,
- fr="le CARA_ELEM est nécessaire dès que le modèle contient des éléments de structure : coques, poutres, ...",
+ fr="le CARA_ELEM est necessaire des que le modele contient des elements de structure : coques, poutres, ...",
ang="CARA_ELEM is compulsory as soon as the model contains structural elements : plates, beams, ..."),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
EXCIT =FACT(statut='o',max='**',
# ======================================================================
# person_in_charge: mathieu.corus at edf.fr
MODE_ITER_CYCL=OPER(nom="MODE_ITER_CYCL",op= 80,sd_prod=mode_cycl,
- fr="Calcul des modes propres d'une structure à répétitivité cyclique à partir"
- +" d'une base de modes propres réels",
+ fr="Calcul des modes propres d'une structure a repetitivite cyclique a partir"
+ +" d'une base de modes propres reels",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
BASE_MODALE =SIMP(statut='o',typ=mode_meca ),
NB_MODE =SIMP(statut='f',typ='I',defaut= 999 ),
NB_SECTEUR =SIMP(statut='o',typ='I' ),
return ASSD
if TYPE_RESU == "MODE_FLAMB" : return mode_flamb
if TYPE_RESU == "GENERAL" : return mode_flamb
- # sinon on est dans le cas 'DYNAMIQUE' donc **args doit contenir les mots-clés
- # MATR_RIGI et (faculativement) MATR_AMOR, et on peut y accéder
+ # sinon on est dans le cas 'DYNAMIQUE' donc **args doit contenir les mots-cles
+ # MATR_RIGI et (faculativement) MATR_AMOR, et on peut y acceder
vale_rigi = args['MATR_RIGI']
- if (vale_rigi== None) : # si MATR_RIGI non renseigné
+ if (vale_rigi== None) : # si MATR_RIGI non renseigne
# on retourne un type fictif pour que le plantage aie lieu dans la lecture du catalogue
return ASSD
vale_amor = args['MATR_AMOR']
raise AsException("type de concept resultat non prevu")
MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op= 44,sd_prod=mode_iter_inv_prod
- ,fr="Calcul des modes propres par itérations inverses ; valeurs propres et modes réels ou complexes",
+ ,fr="Calcul des modes propres par iterations inverses ; valeurs propres et modes reels ou complexes",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
TYPE_RESU =SIMP(statut='f',typ='TXM',defaut="DYNAMIQUE",
into=("MODE_FLAMB","DYNAMIQUE","GENERAL"),
MATR_RIGI =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ) ),
MATR_MASS =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ) ),
MATR_AMOR =SIMP(statut='f',typ=matr_asse_depl_r ),
- CALC_FREQ =FACT(statut='o',fr="Choix des paramètres pour le calcul des valeurs propres",
+ CALC_FREQ =FACT(statut='o',fr="Choix des parametres pour le calcul des valeurs propres",
OPTION =SIMP(statut='f',typ='TXM',defaut="AJUSTE",into=("SEPARE","AJUSTE","PROCHE"),
fr="Choix de l option pour estimer les valeurs propres" ),
),
b_flamb_general =BLOC(condition = "(TYPE_RESU == 'MODE_FLAMB') or (TYPE_RESU == 'GENERAL')",
- CALC_CHAR_CRIT =FACT(statut='o',fr="Choix des paramètres pour le calcul des valeurs propres",
+ CALC_CHAR_CRIT =FACT(statut='o',fr="Choix des parametres pour le calcul des valeurs propres",
OPTION =SIMP(statut='f',typ='TXM',defaut="AJUSTE",into=("SEPARE","AJUSTE","PROCHE"),
fr="Choix de l option pour estimer les valeurs propres" ),
SOLVEUR =C_SOLVEUR('MODE_ITER_INV'),
#-------------------------------------------------------------------
- CALC_MODE =FACT(statut='d',min=0,fr="Choix des paramètres pour le calcul des vecteurs propres",
+ CALC_MODE =FACT(statut='d',min=0,fr="Choix des parametres pour le calcul des vecteurs propres",
OPTION =SIMP(statut='f',typ='TXM',defaut="DIRECT",into=("DIRECT","RAYLEIGH") ),
- PREC =SIMP(statut='f',typ='R',defaut= 1.E-5,val_min=1.E-70,fr="Précision de convergence" ),
+ PREC =SIMP(statut='f',typ='R',defaut= 1.E-5,val_min=1.E-70,fr="Precision de convergence" ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 30,val_min=1 ),
),
VERI_MODE =FACT(statut='d',min=0,
return ASSD
if TYPE_RESU == "MODE_FLAMB" : return mode_flamb
if TYPE_RESU == "GENERAL" : return mode_flamb
- # sinon on est dans le cas 'DYNAMIQUE' donc **args doit contenir les mots-clés
- # MATR_RIGI et (faculativement) MATR_AMOR, et on peut y accéder
+ # sinon on est dans le cas 'DYNAMIQUE' donc **args doit contenir les mots-cles
+ # MATR_RIGI et (faculativement) MATR_AMOR, et on peut y acceder
vale_rigi = args['MATR_RIGI']
- if (vale_rigi== None) : # si MATR_RIGI non renseigné
+ if (vale_rigi== None) : # si MATR_RIGI non renseigne
# on retourne un type fictif pour que le plantage aie lieu dans la lecture du catalogue
return ASSD
vale_amor = args['MATR_AMOR']
MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op= 45, sd_prod= mode_iter_simult_prod,
- fr="Calcul des modes propres par itérations simultanées ; valeurs propres et"
- +" modes propres réels ou complexes",
+ fr="Calcul des modes propres par iterations simultanees ; valeurs propres et"
+ +" modes propres reels ou complexes",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
METHODE =SIMP(statut='f',typ='TXM',defaut="SORENSEN",
into=("TRI_DIAG","JACOBI","SORENSEN","QZ") ),
b_tri_diag =BLOC(condition = "METHODE == 'TRI_DIAG'",
into=("DYNAMIQUE","MODE_FLAMB","GENERAL"),
fr="Type d analyse" ),
OPTION =SIMP(statut='f',typ='TXM',defaut="SANS",into=("MODE_RIGIDE","SANS"),
- fr="Calcul des modes de corps rigide, uniquement pour la méthode TRI_DIAG" ),
+ fr="Calcul des modes de corps rigide, uniquement pour la methode TRI_DIAG" ),
b_dynam =BLOC(condition = "TYPE_RESU == 'DYNAMIQUE'",
MATR_AMOR =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_gene_r) ),
CALC_FREQ =FACT(statut='d',min=0,
OPTION =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","PLUS_GRANDE","BANDE","CENTRE","TOUT"),
- fr="Choix de l option et par conséquent du shift du problème modal" ),
- b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites fréquences propres",
+ fr="Choix de l option et par consequent du shift du probleme modal" ),
+ b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites frequences propres",
NMAX_FREQ =SIMP(statut='f',typ='I',defaut=10,val_min=0 ),
),
- b_plus_grande =BLOC(condition = "OPTION == 'PLUS_GRANDE'",fr="Recherche des plus grandes fréquences propres",
+ b_plus_grande =BLOC(condition = "OPTION == 'PLUS_GRANDE'",fr="Recherche des plus grandes frequences propres",
NMAX_FREQ =SIMP(statut='f',typ='I',defaut=1,val_min=0 ),
),
b_centre =BLOC(condition = "OPTION == 'CENTRE'",
- fr="Recherche des fréquences propres les plus proches d'une valeur donnée",
+ fr="Recherche des frequences propres les plus proches d'une valeur donnee",
FREQ =SIMP(statut='o',typ='R',
- fr="Fréquence autour de laquelle on cherche les fréquences propres"),
+ fr="Frequence autour de laquelle on cherche les frequences propres"),
AMOR_REDUIT =SIMP(statut='f',typ='R',),
NMAX_FREQ =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
),
b_bande =BLOC(condition = "(OPTION == 'BANDE')",
- fr="Recherche des fréquences propres dans une bande donnée",
+ fr="Recherche des frequences propres dans une bande donnee",
FREQ =SIMP(statut='o',typ='R',min=2,max=2,
validators=AndVal((OrdList('croissant'), NoRepeat())),
- fr="Valeur des deux fréquences délimitant la bande de recherche"),
+ fr="Valeur des deux frequences delimitant la bande de recherche"),
TABLE_FREQ =SIMP(statut= 'f',typ=table_sdaster),
),
APPROCHE =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG","COMPLEXE"),
- fr="Choix du pseudo-produit scalaire pour la résolution du problème quadratique" ),
+ fr="Choix du pseudo-produit scalaire pour la resolution du probleme quadratique" ),
regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
b_flamb_general =BLOC(condition = "(TYPE_RESU == 'MODE_FLAMB') or (TYPE_RESU == 'GENERAL')",
CALC_CHAR_CRIT =FACT(statut='d',min=0,
OPTION =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","BANDE","CENTRE","TOUT"),
- fr="Choix de l option et par conséquent du shift du problème modal" ),
+ fr="Choix de l option et par consequent du shift du probleme modal" ),
b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites valeurs propres",
NMAX_CHAR_CRIT =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
),
b_centre =BLOC(condition = "OPTION == 'CENTRE'",
- fr="Recherche des valeurs propres les plus proches d une valeur donnée",
+ fr="Recherche des valeurs propres les plus proches d une valeur donnee",
CHAR_CRIT =SIMP(statut='o',typ='R',
fr="Charge critique autour de laquelle on cherche les charges critiques propres"),
NMAX_CHAR_CRIT =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
),
b_bande =BLOC(condition = "(OPTION == 'BANDE')",
- fr="Recherche des valeurs propres dans une bande donnée",
+ fr="Recherche des valeurs propres dans une bande donnee",
CHAR_CRIT =SIMP(statut='o',typ='R',min=2,max=2,
validators=AndVal((OrdList('croissant'), NoRepeat())),
- fr="Valeur des deux charges critiques délimitant la bande de recherche"),
+ fr="Valeur des deux charges critiques delimitant la bande de recherche"),
TABLE_CHAR_CRIT =SIMP(statut= 'f',typ=table_sdaster),
),
APPROCHE =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG"),
- fr="Choix du pseudo-produit scalaire pour la résolution du problème quadratique" ),
+ fr="Choix du pseudo-produit scalaire pour la resolution du probleme quadratique" ),
regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
MODE_NON_LINE=OPER(nom="MODE_NON_LINE",op= 61,sd_prod=table_container,
- fr="Calcul des modes non-linéaires",
+ fr="Calcul des modes non-lineaires",
reentrant='f',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
reuse =SIMP(statut='f',typ='table_container'),
# person_in_charge: georges-cc.devesa at edf.fr
MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca,
- fr="Calcul de déformées statiques pour un déplacement, une force ou une accélération unitaire imposé",
+ fr="Calcul de deformees statiques pour un deplacement, une force ou une acceleration unitaire impose",
reentrant='n',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
regles=(UN_PARMI('MODE_STAT','FORCE_NODALE','PSEUDO_MODE','MODE_INTERF'),
PRESENT_PRESENT('MODE_INTERF','MATR_MASS'),
# person_in_charge: andre.adobes at edf.fr
MODI_BASE_MODALE=OPER(nom="MODI_BASE_MODALE",op= 149,sd_prod=mode_meca,
reentrant='f',
- fr="Définir la base modale d'une structure sous écoulement",
+ fr="Definir la base modale d'une structure sous ecoulement",
UIinfo={"groupes":("Matrices et vecteurs",)},
# la commande modi_base _modale : reentrant = f ou o
regles=(EXCLUS('AMOR_UNIF','AMOR_REDUIT', ),),
op = 112,
sd_prod = char_meca,
reentrant = 'o',
- UIinfo = {"groupes":("Résultats et champs",)},
+ UIinfo = {"groupes":("Resultats et champs",)},
fr = "Reception des forces nodales via YACS lors du couplage de Code_Aster et Saturne",
CHAR_MECA = SIMP(statut ='o', typ = char_meca),
MATR_PROJECTION = SIMP(statut ='o', typ = corresp_2_mailla,),
# ======================================================================
# person_in_charge: jacques.pellet at edf.fr
MODI_MAILLAGE=OPER(nom="MODI_MAILLAGE",op= 154,sd_prod=maillage_sdaster,
- fr="Effectuer des modifications sur un maillage existant: réorienter des mailles servant,"
- +" à l'application d'une pression, à la modélisation du contact,...",
+ fr="Effectuer des modifications sur un maillage existant: reorienter des mailles servant,"
+ +" a l'application d'une pression, a la modelisation du contact,...",
reentrant='o',
UIinfo={"groupes":("Maillage",)},
regles=(AU_MOINS_UN('ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D',
DIR =SIMP(statut='f',typ='R',min=2,max=3),
),
SYMETRIE =FACT(statut='f',max='**',
- fr = "Symétrie du maillage par rapport à un plan en 3D ou à une droite en 2D.",
+ fr = "Symetrie du maillage par rapport a un plan en 3D ou a une droite en 2D.",
POINT =SIMP(statut='o',typ='R',min=2,max=3,
- fr="Point appartenant à la droite ou au plan."),
+ fr="Point appartenant a la droite ou au plan."),
AXE_1 =SIMP(statut='o',typ='R',min=2,max=3,
fr="Vecteur directeur de la droite ou 1er vecteur appartenant au plan."),
AXE_2 =SIMP(statut='f',typ='R',min=3,max=3,
# person_in_charge: jacques.pellet at edf.fr
MODI_MODELE=OPER(nom="MODI_MODELE",op= 103,sd_prod=modele_sdaster,reentrant='o',
- UIinfo={"groupes":("Modélisation",)},
- fr="Modifier la partition d'un modèle (parallélisme) ",
+ UIinfo={"groupes":("Modelisation",)},
+ fr="Modifier la partition d'un modele (parallelisme) ",
MODELE =SIMP(statut='o',typ=modele_sdaster,min=1,max=1,),
# person_in_charge: samuel.geniaut at edf.fr
MODI_MODELE_XFEM=OPER(nom="MODI_MODELE_XFEM",op= 113,sd_prod=modele_sdaster,docu="U4.44.12-e",reentrant='f',
- UIinfo={"groupes":("Modélisation","Rupture",)},
+ UIinfo={"groupes":("Modelisation","Rupture",)},
fr="Engendrer ou enrichir une structure de donnees en affectant les cham_gd associes",
MODELE_IN =SIMP(statut='o',typ=modele_sdaster,min=1,max=1,),
if AsType(RESULTAT) != None : return AsType(RESULTAT)
MODI_REPERE=OPER(nom="MODI_REPERE",op=191,sd_prod=modi_repere_prod,reentrant='f',
- UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
- fr="Calcule des résultats dans le repère cylindrique",
+ UIinfo={"groupes":("Post-traitements","Resultats et champs",)},
+ fr="Calcule des resultats dans le repere cylindrique",
RESULTAT =SIMP(statut='o',typ=resultat_sdaster),
regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
raise AsException("type de concept resultat non prevu")
NORM_MODE=OPER(nom="NORM_MODE",op= 37,sd_prod=norm_mode_prod,
- fr="Normer des modes propres en fonction d'un critère choisi par l'utilisateur",
+ fr="Normer des modes propres en fonction d'un critere choisi par l'utilisateur",
reentrant='f',
- UIinfo={"groupes":("Résolution","Dynamique",)},
+ UIinfo={"groupes":("Resolution","Dynamique",)},
regles=(UN_PARMI('NORME','GROUP_NO','NOEUD','AVEC_CMP','SANS_CMP'),),
MODE =SIMP(statut='o',typ=(mode_meca,mode_flamb) ),
- NORME =SIMP(statut='f',typ='TXM',fr="Norme prédéfinie : masse généralisée, euclidienne,...",
+ NORME =SIMP(statut='f',typ='TXM',fr="Norme predefinie : masse generalisee, euclidienne,...",
into=("MASS_GENE","RIGI_GENE","EUCL","EUCL_TRAN","TRAN","TRAN_ROTA") ),
- NOEUD =SIMP(statut='f',typ=no, fr="Composante donnée d'un noeud spécifié égale à 1"),
- GROUP_NO =SIMP(statut='f',typ=grno,fr="Composante donnée d'un groupe contenant un seul noeud spécifié égale à 1"),
+ NOEUD =SIMP(statut='f',typ=no, fr="Composante donnee d'un noeud specifie egale a 1"),
+ GROUP_NO =SIMP(statut='f',typ=grno,fr="Composante donnee d'un groupe contenant un seul noeud specifie egale a 1"),
b_noeud =BLOC(condition = "NOEUD != None or GROUP_NO != None",
NOM_CMP =SIMP(statut='o',typ='TXM' ),
),
SANS_CMP =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
MODE_SIGNE =FACT(statut='f',fr="Imposer un signe sur une des composantes des modes",
regles=(UN_PARMI('GROUP_NO','NOEUD'),),
- NOEUD =SIMP(statut='f',typ=no,fr="Noeud où sera imposé le signe"),
- GROUP_NO =SIMP(statut='f',typ=grno,fr="Groupe d'un seul noeud où sera imposé le signe"),
- NOM_CMP =SIMP(statut='o',typ='TXM',fr="Composante du noeud où sera imposé le signe" ),
+ NOEUD =SIMP(statut='f',typ=no,fr="Noeud ou sera impose le signe"),
+ GROUP_NO =SIMP(statut='f',typ=grno,fr="Groupe d'un seul noeud ou sera impose le signe"),
+ NOM_CMP =SIMP(statut='o',typ='TXM',fr="Composante du noeud ou sera impose le signe" ),
SIGNE =SIMP(statut='f',typ='TXM',defaut="POSITIF",into=("NEGATIF","POSITIF"),
fr="Choix du signe" ),
),
# person_in_charge: jacques.pellet at edf.fr
NUME_DDL=OPER(nom="NUME_DDL",op=11,sd_prod=nume_ddl_sdaster,reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
- fr="Etablissement de la numérotation des ddl avec ou sans renumérotation et du stockage de la matrice",
+ fr="Etablissement de la numerotation des ddl avec ou sans renumerotation et du stockage de la matrice",
regles=(UN_PARMI('MATR_RIGI','MODELE'),),
MATR_RIGI =SIMP(statut='f',validators=NoRepeat(),max=100,
typ=(matr_elem_depl_r ,matr_elem_depl_c,matr_elem_temp_r ,matr_elem_pres_c) ),
CHARGE =SIMP(statut='f',validators=NoRepeat(),max='**',typ=(char_meca,char_ther,char_acou, ),),
),
METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","PETSC","MUMPS") ),
- b_mult_front =BLOC(condition="METHODE=='MULT_FRONT'",fr="paramètres associés à la méthode multifrontale",
+ b_mult_front =BLOC(condition="METHODE=='MULT_FRONT'",fr="parametres associes a la methode multifrontale",
RENUM =SIMP(statut='f',typ='TXM',into=("MD","MDA","METIS"),defaut="METIS" ),
),
- b_ldlt =BLOC(condition="METHODE=='LDLT'",fr="paramètres associés à la méthode LDLT",
+ b_ldlt =BLOC(condition="METHODE=='LDLT'",fr="parametres associes a la methode LDLT",
RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Parametres de la methode MUMPS",
RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
),
- b_gcpc =BLOC(condition="METHODE=='GCPC' or METHODE=='PETSC'",fr="paramètres associés à la GCPC ou PETSc",
+ b_gcpc =BLOC(condition="METHODE=='GCPC' or METHODE=='PETSC'",fr="parametres associes a la GCPC ou PETSc",
RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ),
),
INFO =SIMP(statut='f',typ='I',into=(1,2)),
# ======================================================================
# person_in_charge: mathieu.corus at edf.fr
NUME_DDL_GENE=OPER(nom="NUME_DDL_GENE",op= 127,sd_prod=nume_ddl_gene,
- fr="Etablissement de la numérotation des ddl d'un modèle etabli en coordonnées généralisees",
+ fr="Etablissement de la numerotation des ddl d'un modele etabli en coordonnees generalisees",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=UN_PARMI('MODELE_GENE','BASE'),
PROJECTION =SIMP(statut='f',max=1,typ='TXM',into=("OUI","NON"),defaut="OUI"),
CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
DISTANCE_MAX =SIMP(statut='f',typ='R',
- fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."),
+ fr="Distance maximale entre le noeud et l'element le plus proche, lorsque le noeud n'est dans aucun element."),
ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
TYPE_CHAM =SIMP(statut='f',typ='TXM',into=("NOEU",),
- fr="Pour forcer le type des champs projetés. NOEU -> cham_no"),
+ fr="Pour forcer le type des champs projetes. NOEU -> cham_no"),
# PROL_ZERO =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
-# fr="Si le résultat est un mode_xxx ou une base_xxx, on peut prolonger"
-# +" les champs par zéro la ou la projection ne donne pas de valeurs."),
+# fr="Si le resultat est un mode_xxx ou une base_xxx, on peut prolonger"
+# +" les champs par zero la ou la projection ne donne pas de valeurs."),
MATR_RIGI =SIMP(statut='f',typ=(matr_asse_depl_r) ),
MATR_MASS =SIMP(statut='f',typ=(matr_asse_depl_r) ),
POST_BORDET =MACRO(nom="POST_BORDET",
op=OPS('Macro.post_bordet_ops.post_bordet_ops'),
sd_prod=table_sdaster,
- UIinfo={"groupes":("Outils-métier","Rupture",)},
+ UIinfo={"groupes":("Outils-metier","Rupture",)},
reentrant='n',
fr="calcul de la probabilite de clivage via le modele de Bordet",
regles=(UN_PARMI('TOUT','GROUP_MA'),
),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",)),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="le calcul ne sera effectué que sur ces mailles"),
+ fr="le calcul ne sera effectue que sur ces mailles"),
INST =SIMP(statut='f',typ='R',validators=NoRepeat(),),
PRECISION =SIMP(statut='f',typ='R',validators=NoRepeat(),val_min=0.,val_max=1E-3,defaut=1E-6),
CRITERE =SIMP(statut='f',typ='TXM',defaut="ABSOLU",into=("RELATIF","ABSOLU") ),
POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=post_cham_xfem_prod,
reentrant='n',UIinfo={"groupes":("Post-traitements","Rupture",)},
- fr="Calcul des champs DEPL, SIEF_ELGA et VARI_ELGA sur le maillage de visualisation (fissuré)",
+ fr="Calcul des champs DEPL, SIEF_ELGA et VARI_ELGA sur le maillage de visualisation (fissure)",
RESULTAT = SIMP(statut='o',typ=resultat_sdaster),
MODELE_VISU = SIMP(statut='o',typ=modele_sdaster,),
INFO = SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
raise AsException("type de concept resultat non prevu")
-# liste des options possibles pour les 4 mots clés EXTR_COQUE, EXTR_TUYAY, EXTR_PMF et MIN_MAX_SP :
+# liste des options possibles pour les 4 mots cles EXTR_COQUE, EXTR_TUYAY, EXTR_PMF et MIN_MAX_SP :
liste_option_extr=("EPEQ_ELGA","EPEQ_ELNO","EPSI_ELGA","EPSI_ELNO",
"SIEF_ELGA","SIEF_ELNO",
"SIEQ_ELGA","SIEQ_ELNO","SIGM_ELGA","SIGM_ELNO",
POST_CHAMP=OPER(nom="POST_CHAMP",op=155,sd_prod=post_champ_prod, reentrant='n',
- UIinfo={"groupes":("Post-traitements","Eléments de structure",)},
+ UIinfo={"groupes":("Post-traitements","Elements de structure",)},
fr="extraction de champs sur un sous-point. ",
regles=(UN_PARMI('EXTR_COQUE','EXTR_TUYAU','EXTR_PMF','MIN_MAX_SP','COQU_EXCENT'),
#====
-# Sélection des numéros d'ordre pour lesquels on fait le calcul :
+# Selection des numeros d'ordre pour lesquels on fait le calcul :
#====
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
#====
-# Sélection de la zone géométrique:
+# Selection de la zone geometrique:
#====
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=liste_option_extr,),
NUME_COUCHE =SIMP(statut='o',typ='I',val_min=1,
- fr="numero de couche dans l'épaisseur de la coque" ),
+ fr="numero de couche dans l'epaisseur de la coque" ),
NIVE_COUCHE =SIMP(statut='o',typ='TXM',into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la couche" ),
+ fr="position dans l'epaisseur de la couche" ),
),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=liste_option_extr ,),
NUME_COUCHE =SIMP(statut='o',typ='I',val_min=1,
- fr="numero de couche dans l'épaisseur du tuyau" ),
+ fr="numero de couche dans l'epaisseur du tuyau" ),
NIVE_COUCHE =SIMP(statut='o',typ='TXM',into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la couche" ),
+ fr="position dans l'epaisseur de la couche" ),
ANGLE =SIMP(statut='o',typ='I',val_min=0,val_max=360,
- fr="angle de dépouillement pour les tuyaux, en degrés à partir de la génératrice" ),
+ fr="angle de depouillement pour les tuyaux, en degres a partir de la generatrice" ),
),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=liste_option_extr,),
NUME_FIBRE =SIMP(statut='o',typ='I',val_min=1,
- fr="numéro de la fibre dans la poutre multifibre" ),
+ fr="numero de la fibre dans la poutre multifibre" ),
),
NOM_CMP =SIMP(statut='o',typ='TXM',fr="nom de la composante", ),
TYPE_MAXI =SIMP(statut='o',typ='TXM',into=("MAXI","MINI","MAXI_ABS","MINI_ABS",) ),
NUME_CHAM_RESU = SIMP(statut='o', typ='I', val_min=1, val_max=20,
- fr="Numéro du champ produit. Exemple: 6 produit le champ UT06",),
+ fr="Numero du champ produit. Exemple: 6 produit le champ UT06",),
),
#====
-# Calcul des efforts des coques "excentrées" sur le feuillet moyen de la coque :
+# Calcul des efforts des coques "excentrees" sur le feuillet moyen de la coque :
#====
- COQU_EXCENT =FACT(statut='f', max=2, fr="Calcul des efforts d'une coque 'excentrée' sur le feuillet moyen de la coque",
+ COQU_EXCENT =FACT(statut='f', max=2, fr="Calcul des efforts d'une coque 'excentree' sur le feuillet moyen de la coque",
NOM_CHAM =SIMP(statut='o',typ='TXM',into=("EFGE_ELNO","EFGE_ELGA",),),
MODI_PLAN =SIMP(statut='o',typ='TXM',into=("OUI",),),
),
sd_prod=table_sdaster,
reentrant='n',
UIinfo={"groupes":("Post-traitements",)},
- fr="Calcul des efforts et déformations en un point et une cote " \
+ fr="Calcul des efforts et deformations en un point et une cote " \
"quelconque de la coque",
regles=(EXCLUS('INST','NUME_ORDRE'),),
- # SD résultat et champ à posttraiter :
- RESULTAT =SIMP(statut='o',typ=resultat_sdaster,fr="RESULTAT à posttraiter",),
+ # SD resultat et champ a posttraiter :
+ RESULTAT =SIMP(statut='o',typ=resultat_sdaster,fr="RESULTAT a posttraiter",),
CHAM =SIMP(statut='o',typ='TXM',into=("EFFORT","DEFORMATION",)),
NUME_ORDRE =SIMP(statut='f',typ='I'),
INST =SIMP(statut='f',typ='R'),
# points de post-traitement :
- COOR_POINT =FACT(statut='o',max='**',fr="coordonnées et position dans l'épaisseur",
+ COOR_POINT =FACT(statut='o',max='**',fr="coordonnees et position dans l'epaisseur",
COOR=SIMP(statut='o',typ='R',min=3,max=4),),
)
POST_DYNA_ALEA=MACRO(nom="POST_DYNA_ALEA",
op=OPS('Macro.post_dyna_alea_ops.post_dyna_alea_ops'),
sd_prod=table_sdaster,
- fr="Traitements statistiques de résultats de type interspectre " \
+ fr="Traitements statistiques de resultats de type interspectre " \
"et impression sur fichiers",
reentrant='n',
UIinfo={"groupes":("Post-traitements","Dynamique",)},
NOM_CMP_J =SIMP(statut='o',typ='TXM',max='**' ),
),
MOMENT =SIMP(statut='f',typ='I',max='**',fr="Moments spectraux "\
- "en complément des cinq premiers" ),
- DUREE =SIMP(statut='f',typ='R',fr="durée de la phase forte "\
+ "en complement des cinq premiers" ),
+ DUREE =SIMP(statut='f',typ='R',fr="duree de la phase forte "\
"pour facteur de peak" ),
),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
# ======================================================================
# person_in_charge: emmanuel.boyere at edf.fr
POST_DYNA_MODA_T=OPER(nom="POST_DYNA_MODA_T",op= 130,sd_prod=table_sdaster,
- fr="Post-traiter les résultats en coordonnées généralisées produit par DYNA_TRAN_MODAL",
+ fr="Post-traiter les resultats en coordonnees generalisees produit par DYNA_TRAN_MODAL",
reentrant='n',
UIinfo={"groupes":("Post-traitements","Dynamique",)},
regles=(UN_PARMI('CHOC','RELA_EFFO_DEPL', ),),
RESU_GENE =SIMP(statut='o',typ=tran_gene ),
CHOC =FACT(statut='f',max='**',
- fr="Analyse des non linéarités de choc",
+ fr="Analyse des non linearites de choc",
INST_INIT =SIMP(statut='f',typ='R',defaut= -1. ),
INST_FIN =SIMP(statut='f',typ='R',defaut= 999. ),
NB_BLOC =SIMP(statut='f',typ='I',defaut= 1 ),
NB_CLASSE =SIMP(statut='f',typ='I',defaut= 10 ),
),
RELA_EFFO_DEPL =FACT(statut='f',
- fr="Analyse des relationsnon linéaires effort-déplacement",
+ fr="Analyse des relationsnon lineaires effort-deplacement",
NOEUD =SIMP(statut='o',typ=no),
NOM_CMP =SIMP(statut='o',typ='TXM' ),
),
# person_in_charge: josselin.delmas at edf.fr
POST_ELEM=OPER(nom="POST_ELEM",op=107,sd_prod=table_sdaster,reentrant='n',
- UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
- fr="Calcul de quantités globales (masse, inerties, énergie, ...) sur tout ou partie du modèle",
+ UIinfo={"groupes":("Post-traitements","Resultats et champs",)},
+ fr="Calcul de quantites globales (masse, inerties, energie, ...) sur tout ou partie du modele",
regles=(UN_PARMI('MASS_INER', 'ENER_POT', 'ENER_CIN','TRAV_EXT','MINMAX',
'WEIBULL', 'RICE_TRACEY', 'CARA_GEOM','CHAR_LIMITE','NORME',
ORIG_INER = SIMP(statut='f',typ='R',min=3,max=3 ),
),
b_mass_iner = BLOC(condition = "( MASS_INER != None )",
- fr="calcul de la masse, les inerties et le centre de gravité",
+ fr="calcul de la masse, les inerties et le centre de gravite",
regles=(EXCLUS('CHAM_GD','RESULTAT'),
EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
'NOEUD_CMP','LIST_ORDRE','LIST_INST','LIST_FREQ','NOM_CAS'),),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
b_ener_pot = BLOC(condition = "( ENER_POT != None )",
- fr="calcul de l'énergie potentielle de déformation",
+ fr="calcul de l'energie potentielle de deformation",
regles=(UN_PARMI('CHAM_GD','RESULTAT'),
EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
'NOEUD_CMP','LIST_ORDRE','LIST_INST','LIST_FREQ','NOM_CAS'),),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
b_ener_cin = BLOC(condition = "( ENER_CIN != None )",
- fr="calcul de l'énergie cinétique",
+ fr="calcul de l'energie cinetique",
regles=(UN_PARMI('CHAM_GD','RESULTAT'),
EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
'NOEUD_CMP','LIST_ORDRE','LIST_INST','LIST_FREQ','NOM_CAS'),),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
b_ener_diss = BLOC(condition = "( ENER_DISS != None )",
- fr="calcul de l'énergie dissipée",
+ fr="calcul de l'energie dissipee",
MODELE = SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER = SIMP(statut='f',typ=cham_mater),
CARA_ELEM = SIMP(statut='f',typ=cara_elem),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
b_ener_elas = BLOC(condition = "( ENER_ELAS != None )",
- fr="calcul de l'énergie de déformation élastique",
+ fr="calcul de l'energie de deformation elastique",
MODELE = SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER = SIMP(statut='f',typ=cham_mater),
CARA_ELEM = SIMP(statut='f',typ=cara_elem),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
b_ener_totale = BLOC(condition = "( ENER_TOTALE != None )",
- fr="calcul de l'énergie de déformation totale",
+ fr="calcul de l'energie de deformation totale",
MODELE = SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER = SIMP(statut='f',typ=cham_mater),
CARA_ELEM = SIMP(statut='f',typ=cara_elem),
NORME = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
),
b_volumogramme = BLOC(condition = "( VOLUMOGRAMME != None )",
- fr="calcul de la distribution du volume d'une structure vis-à-vis d'une composante",
+ fr="calcul de la distribution du volume d'une structure vis-a-vis d'une composante",
regles=(UN_PARMI('CHAM_GD','RESULTAT'),
EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_ORDRE','LIST_INST'),),
MODELE = SIMP(statut='f',typ=modele_sdaster),
),
NORME = FACT(statut='f',max=1,
- fr="calcul des extrema en espace d'une CMP d'un champ, pour tous les instants spécifiés",
+ fr="calcul des extrema en espace d'une CMP d'un champ, pour tous les instants specifies",
regles=(UN_PARMI('TOUT','GROUP_MA'),
UN_PARMI('CHAM_GD','RESULTAT'),
PRESENT_PRESENT('CHAM_GD','MODELE'),
MINMAX = FACT(statut='f',max=1,
- fr="calcul des extrema en espace d'une CMP d'un champ, pour tous les instants spécifiés",
+ fr="calcul des extrema en espace d'une CMP d'un champ, pour tous les instants specifies",
regles=(UN_PARMI('CHAM_GD','RESULTAT'),
PRESENT_PRESENT('CHAM_GD','MODELE'),
PRESENT_PRESENT('RESULTAT','NOM_CHAM'),
COEF_MULT = SIMP(statut='f',typ='R',defaut=1.),
),
b_weibull = BLOC(condition = "( WEIBULL != None )",
- fr="calcul du champ élémentaire de la puissance m-ième de la contrainte de Weibull",
+ fr="calcul du champ elementaire de la puissance m-ieme de la contrainte de Weibull",
regles=(UN_PARMI('CHAM_GD','RESULTAT'),
EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
MODELE = SIMP(statut='f',typ=modele_sdaster),
LOCAL = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
),
b_rice_tracey = BLOC(condition = "( RICE_TRACEY != None )",
- fr="calcul du taux de croissance d'une cavité sphérique par rapport à un domaine",
+ fr="calcul du taux de croissance d'une cavite spherique par rapport a un domaine",
regles=(UN_PARMI('CHAM_GD','RESULTAT'),
EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
MODELE = SIMP(statut='f',typ=modele_sdaster),
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
b_indic_ener = BLOC(condition = "( INDIC_ENER != None )",
- fr="calcul un indicateur global de perte de proportionnalité du chargement",
+ fr="calcul un indicateur global de perte de proportionnalite du chargement",
MODELE = SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER = SIMP(statut='f',typ=cham_mater),
CHARGE = SIMP(statut='f',typ=(char_meca,char_cine_meca,
GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
),
b_indic_seuil = BLOC(condition = "( INDIC_SEUIL != None )",
- fr="calcul un indicateur global de perte de proportionnalité du chargement",
+ fr="calcul un indicateur global de perte de proportionnalite du chargement",
MODELE = SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER = SIMP(statut='f',typ=cham_mater),
CHARGE = SIMP(statut='f',typ=(char_meca,char_cine_meca,
ORIG_INER = SIMP(statut='f',typ='R',min=2,max=2),
),
b_cara_geom = BLOC(condition = "( CARA_GEOM != None )",
- fr="calcul des caractéristiques géométriques d'un section de poutre",
+ fr="calcul des caracteristiques geometriques d'un section de poutre",
MODELE = SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER = SIMP(statut='f',typ=cham_mater),
CHARGE = SIMP(statut='f',typ=(char_meca,char_cine_meca,
into=("CARA_TORSION","CARA_CISAILLEMENT","CARA_GAUCHI") ),
),
b_cara_poutre = BLOC(condition = "( CARA_POUTRE != None )",
- fr="calcul des caractéristiques mécaniques d'un section de poutre",
+ fr="calcul des caracteristiques mecaniques d'un section de poutre",
MODELE = SIMP(statut='f',typ=modele_sdaster),
CHAM_MATER = SIMP(statut='f',typ=cham_mater),
CHARGE = SIMP(statut='f',typ=(char_meca,char_cine_meca,
TRAV_EXT = FACT(statut='f',),
b_trav_ext = BLOC(condition = "( TRAV_EXT != None )",
- fr="calcul du travail des efforts extérieurs",
+ fr="calcul du travail des efforts exterieurs",
RESULTAT = SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans) ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),),
b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
op=OPS('Macro.post_endo_fiss_ops.post_endo_fiss_ops'),
sd_prod=post_endo_fiss_prod,
reentrant='n',
- UIinfo={"groupes":("Post-traitements","Outils-métier",)},
+ UIinfo={"groupes":("Post-traitements","Outils-metier",)},
fr="Individuation du trace d'une fissure a partir d'un champ scalaire pertinant",
TABLE = SIMP(statut = 'o', typ = CO,),
# person_in_charge: irmela.zentner at edf.fr
POST_FATI_ALEA=OPER(nom="POST_FATI_ALEA",op=170,sd_prod=table_sdaster,reentrant='n',
UIinfo={"groupes":("Post-traitements","Rupture",)},
- fr="Calculer le dommage de fatigue subi par une structure soumise à une sollicitation de type aléatoire",
+ fr="Calculer le dommage de fatigue subi par une structure soumise a une sollicitation de type aleatoire",
regles=(ENSEMBLE('MOMENT_SPEC_0','MOMENT_SPEC_2'),
PRESENT_PRESENT( 'MOMENT_SPEC_4','MOMENT_SPEC_0'),
UN_PARMI('TABL_POST_ALEA','MOMENT_SPEC_0'), ),
# person_in_charge: van-xuan.tran at edf.fr
POST_FATIGUE=OPER(nom="POST_FATIGUE",op=136,sd_prod=table_sdaster,reentrant='n',
UIinfo={"groupes":("Post-traitements","Rupture",)},
- fr="Calculer en un point, le dommage de fatigue subi par une structure soumise à une histoire de chargement",
+ fr="Calculer en un point, le dommage de fatigue subi par une structure soumise a une histoire de chargement",
CHARGEMENT = SIMP(statut='o',typ='TXM',into=("UNIAXIAL","MULTIAXIAL","QUELCONQUE")),
POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",
op=OPS('Macro.post_k1_k2_k3_ops.post_k1_k2_k3_ops'),
sd_prod=table_sdaster,
- fr="Calcul des facteurs d'intensité de contraintes en 2D et en 3D par "\
- "extrapolation des sauts de déplacements sur les lèvres de la fissure",
+ fr="Calcul des facteurs d'intensite de contraintes en 2D et en 3D par "\
+ "extrapolation des sauts de deplacements sur les levres de la fissure",
reentrant='n',
UIinfo={"groupes":("Post-traitements","Rupture",)},
MODELISATION =SIMP(statut='o',typ='TXM',
into=("3D","AXIS","D_PLAN","C_PLAN"),position='global',
- fr="Modélisation cohérente avec celle utilisée pour le calcul des déplacements"),
+ fr="Modelisation coherente avec celle utilisee pour le calcul des deplacements"),
FOND_FISS =SIMP(statut='f',typ=fond_fiss),
FISSURE =SIMP(statut='f',typ=fiss_xfem),
RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,mode_meca),position='global',
- fr="Déplacement des noeuds de la lèvre supérieure et inférieure"),
+ fr="Deplacement des noeuds de la levre superieure et inferieure"),
NB_NOEUD_COUPE=SIMP(statut='f',typ='I',defaut=5,val_min = 3),
# bloc correspondant a la donnee du fond de fissure pour les fissures maillees
b_no_mod =BLOC (condition="AsType(RESULTAT)!= mode_meca",
- EVOL_THER = SIMP(statut='f',typ=(evol_ther),fr="Température sur le fond de fissure"),
+ EVOL_THER = SIMP(statut='f',typ=(evol_ther),fr="Temperature sur le fond de fissure"),
b_ref_3D = BLOC (condition="MODELISATION=='3D' ",
TYPE_MAILLAGE = SIMP(statut='f',typ='TXM',into=("LIBRE","REGLE"),defaut="REGLE"),
),
SANS_GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
TOUT = SIMP(statut='f',typ='TXM',into=("OUI",) ),
ABSC_CURV_MAXI=SIMP(statut='f',typ='R',
- fr="Distance maximum à partir du fond de fissure à utiliser pour le calcul"),
+ fr="Distance maximum a partir du fond de fissure a utiliser pour le calcul"),
),
# bloc correspondant a la donnee de la fissure pour les fissures X-FEM
NB_POINT_FOND = SIMP(statut='f',typ='I' ,),
NUME_FOND = SIMP(statut='f',typ='I',defaut=1),
ABSC_CURV_MAXI=SIMP(statut='f',typ='R',
- fr="Distance maximum à partir du fond de fissure à utiliser pour le calcul"),
+ fr="Distance maximum a partir du fond de fissure a utiliser pour le calcul"),
),
MATER =SIMP(statut='o',typ=mater_sdaster,
- fr="Matériau homogène et isotrope cohérent avec celui utilisé pour le calcul des déplacements"),
+ fr="Materiau homogene et isotrope coherent avec celui utilise pour le calcul des deplacements"),
PREC_VIS_A_VIS=SIMP(statut='f',typ='R',defaut=0.1),
# person_in_charge: aurore.parrot at edf.fr
#
POST_K_BETA=OPER(nom="POST_K_BETA",op=198,sd_prod=table_sdaster,
- fr="Calcul des facteurs d'intensité de contraintes par la méthode K_BETA",
+ fr="Calcul des facteurs d'intensite de contraintes par la methode K_BETA",
reentrant='n',
UIinfo={"groupes":("Post-traitements","Rupture",)},
MAILLAGE = SIMP(statut='o',typ=maillage_sdaster),
UNITE = SIMP(statut='o',typ='I', max=1),
FORMAT = SIMP(statut='o',typ='TXM',into=("GRACE","TABLE")),
- b_def_grace = BLOC(condition = "FORMAT == 'GRACE' ",fr="Paramètres pour le format GRACE",
+ b_def_grace = BLOC(condition = "FORMAT == 'GRACE' ",fr="Parametres pour le format GRACE",
regles=UN_PARMI('NUME_GRILLE','TYPE_RESU','POSITION'),
TYPE_VISU = SIMP(statut='o',typ='TXM',into=("AMPLITUDE","MODULE","VECTEUR","DEFORME")),
TYPE_RESU = SIMP(statut='f',typ='TXM',into=("MINI","MAXI")),
CONCEPTION = SIMP(statut='f',typ='TXM', max=1),
),
- b_def_table = BLOC(condition = "FORMAT == 'TABLE' ",fr="Paramètres pour le format TABLE",
+ b_def_table = BLOC(condition = "FORMAT == 'TABLE' ",fr="Parametres pour le format TABLE",
NOM_CMP = SIMP(statut='o',typ='TXM',into=("DY","DZ","NORME")),
),
# person_in_charge: samuel.geniaut at edf.fr
POST_MAIL_XFEM=OPER(nom="POST_MAIL_XFEM",op= 187,sd_prod=maillage_sdaster,
reentrant='n',UIinfo={"groupes":("Maillage","Rupture",)},
- fr="Crée un maillage se conformant à la fissure pour le post-traitement des éléments XFEM",
+ fr="Cree un maillage se conformant a la fissure pour le post-traitement des elements XFEM",
MODELE = SIMP(statut='o',typ=modele_sdaster),
PREF_NOEUD_X =SIMP(statut='f',typ='TXM',defaut="NX",validators=LongStr(1,2),),
PREF_NOEUD_M =SIMP(statut='f',typ='TXM',defaut="NM",validators=LongStr(1,2),),
# person_in_charge: samuel.geniaut at edf.fr
POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster,
- fr="Vérification des critères de niveau 0 et certains critères de niveau A du RCC-M-B3200 (Edition 1991)",
+ fr="Verification des criteres de niveau 0 et certains criteres de niveau A du RCC-M-B3200 (Edition 1991)",
reentrant='n',
UIinfo={"groupes":("Post-traitements","Rupture",)},
TYPE_RESU =SIMP(statut='f',typ='TXM',defaut="VALE_MAX",into=("VALE_MAX","DETAILS") ),
into=("PM_PB","SN","FATIGUE_ZH210","AMORCAGE") ),
MATER =SIMP(statut='o',typ=mater_sdaster ),
SY_MAX =SIMP(statut='f',typ='R',
- fr="limite élastique utilisée pour le calcul du rochet thermique" ),
+ fr="limite elastique utilisee pour le calcul du rochet thermique" ),
TYPE_KE =SIMP(statut='f',typ='TXM',defaut="KE_MECA",into=("KE_MECA","KE_MIXTE"),
fr="Ke meca seul ou partition mecanique + thermique" ),
- TRANSITOIRE =FACT(statut='o',max='**',fr="transitoire à dépouiller",
+ TRANSITOIRE =FACT(statut='o',max='**',fr="transitoire a depouiller",
regles=(EXCLUS('TOUT_ORDRE','INST','LIST_INST'),
UN_PARMI('TABL_RESU_MECA','TABL_SIGM_THETA'),),
NB_OCCUR =SIMP(statut='f',typ='I',defaut= 1,
- fr="nombre d occurences réelles de ce transitoire" ),
+ fr="nombre d occurences reelles de ce transitoire" ),
TABL_RESU_MECA =SIMP(statut='f',typ=table_sdaster,
- fr="relevé des contraintes sur le chemin"),
+ fr="releve des contraintes sur le chemin"),
TABL_SIGM_THER =SIMP(statut='f',typ=table_sdaster,
- fr="résultat sous chargement thermique seul" ),
+ fr="resultat sous chargement thermique seul" ),
TABL_RESU_PRES =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes sous chargement de pression" ),
+ fr="table releve des contraintes sous chargement de pression" ),
TABL_SIGM_THETA =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes a la distance d de la singularité pour chacun des angles THETA" ),
+ fr="table releve des contraintes a la distance d de la singularite pour chacun des angles THETA" ),
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
LIST_INST =SIMP(statut='f',typ=listr8_sdaster ),
into=("PM_PB","SN","FATIGUE") ),
MATER =SIMP(statut='o',typ=mater_sdaster ),
SY_MAX =SIMP(statut='f',typ='R',
- fr="limite élastique utilisée pourle calcul du rochet thermique" ),
+ fr="limite elastique utilisee pourle calcul du rochet thermique" ),
TYPE_KE =SIMP(statut='f',typ='TXM',defaut="KE_MECA",into=("KE_MECA","KE_MIXTE"),
fr="Ke meca seul ou partition mecanique + thermique" ),
- CHAR_MECA =FACT(statut='o',max='**',fr="Chargements mécaniques",
+ CHAR_MECA =FACT(statut='o',max='**',fr="Chargements mecaniques",
regles=(UN_PARMI('MX','MX_TUBU'),),
- NUME_CHAR =SIMP(statut='o',typ='I',fr="numéro du chargement" ),
+ NUME_CHAR =SIMP(statut='o',typ='I',fr="numero du chargement" ),
NOM_CHAR =SIMP(statut='f',typ='TXM',fr="nom du chargement" ),
MX =SIMP(statut='f',typ='R',fr="moment suivant x", ),
MX_TUBU =SIMP(statut='f',typ='R',fr="moment suivant x, tubulure", ),
),
),
- RESU_MECA_UNIT =FACT(statut='o',fr="resultats mécaniques unitaires",
+ RESU_MECA_UNIT =FACT(statut='o',fr="resultats mecaniques unitaires",
regles=(UN_PARMI('TABL_MX','TABL_MX_TUBU'),),
TABL_MX =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MX"),
+ fr="table releve des contraintes pour chargement unitaire MX"),
TABL_MX_TUBU =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MX_TUBU"),
+ fr="table releve des contraintes pour chargement unitaire MX_TUBU"),
b_1_tenseur =BLOC( condition = "TABL_MX != None",
TABL_FX =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FX"),
+ fr="table releve des contraintes pour chargement unitaire FX"),
TABL_FY =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FY"),
+ fr="table releve des contraintes pour chargement unitaire FY"),
TABL_FZ =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FZ"),
+ fr="table releve des contraintes pour chargement unitaire FZ"),
TABL_MY =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MY"),
+ fr="table releve des contraintes pour chargement unitaire MY"),
TABL_MZ =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MZ"),
+ fr="table releve des contraintes pour chargement unitaire MZ"),
),
b_2_tenseurs =BLOC( condition = "TABL_MX_TUBU != None",
TABL_FX_TUBU =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FX_TUBU"),
+ fr="table releve des contraintes pour chargement unitaire FX_TUBU"),
TABL_FY_TUBU =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FY_TUBU"),
+ fr="table releve des contraintes pour chargement unitaire FY_TUBU"),
TABL_FZ_TUBU =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FZ_TUBU"),
+ fr="table releve des contraintes pour chargement unitaire FZ_TUBU"),
TABL_MY_TUBU =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MY_TUBU"),
+ fr="table releve des contraintes pour chargement unitaire MY_TUBU"),
TABL_MZ_TUBU =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MZ_TUBU"),
+ fr="table releve des contraintes pour chargement unitaire MZ_TUBU"),
TABL_FX_CORP =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FX_CORP"),
+ fr="table releve des contraintes pour chargement unitaire FX_CORP"),
TABL_FY_CORP =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FY_CORP"),
+ fr="table releve des contraintes pour chargement unitaire FY_CORP"),
TABL_FZ_CORP =SIMP(statut='f',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire FZ_CORP"),
+ fr="table releve des contraintes pour chargement unitaire FZ_CORP"),
TABL_MX_CORP =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MX_CORP"),
+ fr="table releve des contraintes pour chargement unitaire MX_CORP"),
TABL_MY_CORP =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MY_CORP"),
+ fr="table releve des contraintes pour chargement unitaire MY_CORP"),
TABL_MZ_CORP =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire MZ_CORP"),
+ fr="table releve des contraintes pour chargement unitaire MZ_CORP"),
),
TABL_PRES =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes pour chargement unitaire de pression"),
+ fr="table releve des contraintes pour chargement unitaire de pression"),
),
RESU_THER =FACT(statut='f',max='**',fr="resultats thermiques",
- NUME_RESU_THER =SIMP(statut='o',typ='I',fr="numéro de la table de résultat thermique" ),
+ NUME_RESU_THER =SIMP(statut='o',typ='I',fr="numero de la table de resultat thermique" ),
TABL_RESU_THER =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des contraintes sous chargement thermique seul" ),
+ fr="table releve des contraintes sous chargement thermique seul" ),
),
- SEISME =FACT(statut='f',max='**',fr="Situation séisme",ang="situation_ang",
+ SEISME =FACT(statut='f',max='**',fr="Situation seisme",ang="situation_ang",
NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
- NB_CYCL_SEISME =SIMP(statut='o',typ='I',fr="nombre de cycles associé au séisme" ),
- NUME_SITU =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+ NB_CYCL_SEISME =SIMP(statut='o',typ='I',fr="nombre de cycles associe au seisme" ),
+ NUME_SITU =SIMP(statut='o',typ='I',fr="numero de la situation" ),
NOM_SITU =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
- NUME_GROUPE =SIMP(statut='o',typ='I',fr="numéros du groupe de la situation" ),
+ NUME_GROUPE =SIMP(statut='o',typ='I',fr="numeros du groupe de la situation" ),
CHAR_ETAT =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
),
SITUATION =FACT(statut='o',max='**',fr="Situation",ang="situation_ang",
NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
- NUME_SITU =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+ NUME_SITU =SIMP(statut='o',typ='I',fr="numero de la situation" ),
NOM_SITU =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
COMBINABLE =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ),
NUME_PASSAGE =SIMP(statut='f',typ='I',min=2,max=2,
- fr="numéro des situations de passage" ),
+ fr="numero des situations de passage" ),
NUME_GROUPE =SIMP(statut='o',typ='I',
- fr="numéros des groupes de la situation" ),
+ fr="numeros des groupes de la situation" ),
NUME_RESU_THER =SIMP(statut='f',typ='I',max=1,fr="numeros de transitoires thermiques" ),
CHAR_ETAT_A =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
CHAR_ETAT_B =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat B" ),
PRES_A =SIMP(statut='o',typ='R',fr="pression etat A"),
PRES_B =SIMP(statut='o',typ='R',fr="pression etat B"),
- TEMP_REF_A =SIMP(statut='f',typ='R',fr="temperature référence etat A"),
- TEMP_REF_B =SIMP(statut='f',typ='R',fr="temperature référence etat B"),
+ TEMP_REF_A =SIMP(statut='f',typ='R',fr="temperature reference etat A"),
+ TEMP_REF_B =SIMP(statut='f',typ='R',fr="temperature reference etat B"),
),
),
fr="Ke meca seul ou partition mecanique + thermique" ),
MODELE =SIMP(statut='o',typ=modele_sdaster),
CARA_ELEM =SIMP(statut='o',typ=cara_elem),
- ZONE_ANALYSE =FACT(statut='o',fr="liste des mailles ou des noeuds analysés",
+ ZONE_ANALYSE =FACT(statut='o',fr="liste des mailles ou des noeuds analyses",
regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
),
- RESU_MECA =FACT(statut='o',max='**',fr="Chargements mécaniques",
+ RESU_MECA =FACT(statut='o',max='**',fr="Chargements mecaniques",
regles=(UN_PARMI('CHAM_GD','RESULTAT'),),
- NUME_CHAR =SIMP(statut='o',typ='I',fr="numéro du chargement" ),
+ NUME_CHAR =SIMP(statut='o',typ='I',fr="numero du chargement" ),
NOM_CHAR =SIMP(statut='f',typ='TXM',fr="nom du chargement" ),
CHAM_GD =SIMP(statut='f',typ=cham_gd_sdaster),
RESULTAT =SIMP(statut='f',typ=resultat_sdaster),
K3 =SIMP(statut='f',typ='R',defaut=1.0,fr="indice de contraintes K3 du RCCM"),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",),),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="groupe(s) de mailles ou sont affectés les indices de contraintes"),
+ fr="groupe(s) de mailles ou sont affectes les indices de contraintes"),
MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',
- fr="liste des mailles ou sont affectés les indices de contraintes"),
+ fr="liste des mailles ou sont affectes les indices de contraintes"),
b_grma =BLOC(condition="(GROUP_MA != None)or(MAILLE != None)",
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
),
TYPE_ELEM_STANDARD =SIMP(statut='f',typ='TXM',into=("DRO","COU","TRN","TEE"),
- fr="type d'élément de tuyauterie ou sont affectés les indices de contraintes"),
+ fr="type d'element de tuyauterie ou sont affectes les indices de contraintes"),
),
RESU_THER =FACT(statut='f',max='**',fr="resultats thermiques",
regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
- NUME_RESU_THER =SIMP(statut='o',typ='I',fr="numéro de la table de résultat thermique" ),
+ NUME_RESU_THER =SIMP(statut='o',typ='I',fr="numero de la table de resultat thermique" ),
TABL_RESU_THER =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des températures sur la section"),
+ fr="table releve des temperatures sur la section"),
TABL_MOYE_THER =SIMP(statut='o',typ=table_sdaster,
- fr="table relevé des moyennes sur la section"),
+ fr="table releve des moyennes sur la section"),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
),
),
- SEISME =FACT(statut='f',max='**',fr="Situation séisme",ang="situation_ang",
+ SEISME =FACT(statut='f',max='**',fr="Situation seisme",ang="situation_ang",
NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
- NB_CYCL_SEISME =SIMP(statut='o',typ='I',fr="nombre de cycles associé au séisme" ),
- NUME_SITU =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+ NB_CYCL_SEISME =SIMP(statut='o',typ='I',fr="nombre de cycles associe au seisme" ),
+ NUME_SITU =SIMP(statut='o',typ='I',fr="numero de la situation" ),
NOM_SITU =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
- NUME_GROUPE =SIMP(statut='o',typ='I',fr="numéros du groupe de la situation" ),
+ NUME_GROUPE =SIMP(statut='o',typ='I',fr="numeros du groupe de la situation" ),
CHAR_ETAT =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
- TEMP_REF =SIMP(statut='f',typ='R',fr="temperature référence"),
+ TEMP_REF =SIMP(statut='f',typ='R',fr="temperature reference"),
),
SITUATION =FACT(statut='o',max='**',fr="Situation",ang="situation_ang",
NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
- NUME_SITU =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+ NUME_SITU =SIMP(statut='o',typ='I',fr="numero de la situation" ),
NOM_SITU =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
COMBINABLE =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ),
NUME_GROUPE =SIMP(statut='o',typ='I',
- fr="numéros des groupes de la situation" ),
+ fr="numeros des groupes de la situation" ),
NUME_PASSAGE =SIMP(statut='f',typ='I',min=2,max=2,
- fr="numéro des situations de passage" ),
+ fr="numero des situations de passage" ),
NUME_RESU_THER =SIMP(statut='f',typ='I',max='**',fr="numeros de transitoires thermiques" ),
CHAR_ETAT_A =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
CHAR_ETAT_B =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat B" ),
PRES_A =SIMP(statut='o',typ='R',fr="pression etat A"),
PRES_B =SIMP(statut='o',typ='R',fr="pression etat B"),
- TEMP_REF_A =SIMP(statut='f',typ='R',fr="temperature référence etat A"),
- TEMP_REF_B =SIMP(statut='f',typ='R',fr="temperature référence etat B"),
+ TEMP_REF_A =SIMP(statut='f',typ='R',fr="temperature reference etat A"),
+ TEMP_REF_B =SIMP(statut='f',typ='R',fr="temperature reference etat B"),
),
),
) ;
# person_in_charge: xavier.desroches at edf.fr
POST_RELEVE_T=OPER(nom="POST_RELEVE_T",op=51,sd_prod=table_sdaster,reentrant='f',
fr="Extraire des valeurs de composantes de champs de grandeurs pour y effectuer des calculs (moyenne,invariants,..)"
- +" ou pour les exprimer dans d'autres repères",
- docu="U4.81.21",UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
+ +" ou pour les exprimer dans d'autres reperes",
+ docu="U4.81.21",UIinfo={"groupes":("Post-traitements","Resultats et champs",)},
ACTION =FACT(statut='o',max='**',
regles=(UN_PARMI('RESULTAT','CHAM_GD'),),
cham_elem,),),
RESULTAT =SIMP(statut='f',typ=resultat_sdaster),
- b_extrac =BLOC(condition = "RESULTAT != None",fr="extraction des résultats",
+ b_extrac =BLOC(condition = "RESULTAT != None",fr="extraction des resultats",
regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','NUME_MODE','LIST_MODE',
'INST','LIST_INST','FREQ','LIST_FREQ','NOEUD_CMP','NOM_CAS'), ),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO(),),
sd_prod=table_sdaster,
fr="post-traitements en Rupture",
reentrant='f',
- UIinfo={"groupes":("Résultats et champs","Rupture",)},
+ UIinfo={"groupes":("Resultats et champs","Rupture",)},
TABLE = SIMP(statut='o',typ=table_sdaster,max='**'),
b_Comptage = BLOC(condition="OPERATION == 'COMPTAGE_CYCLES' ",fr="Comptage des cycles",
NOM_PARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
- fr="Nom des quantités sur lesquelles s'effectuent le comptage"),
+ fr="Nom des quantites sur lesquelles s'effectuent le comptage"),
COMPTAGE = SIMP(statut='o',typ='TXM',into=("RAINFLOW","RCCM","NATUREL","UNITAIRE")),
DELTA_OSCI = SIMP(statut='f',typ='R',defaut= 0.0E+0),
# 'LOI_PROPA'
#-----------------------------------------------------------------------------------------------------------------------------------
- b_Loi_Propa = BLOC(condition="OPERATION == 'LOI_PROPA' ",fr="calcul de l'incrément d'avancée de fissure par cycle",
+ b_Loi_Propa = BLOC(condition="OPERATION == 'LOI_PROPA' ",fr="calcul de l'increment d'avancee de fissure par cycle",
NOM_PARA = SIMP(statut='f',typ='TXM',defaut="DELTA_A" ,max=1,fr="Nom de la nouvelle colonne"),
NOM_DELTA_K_EQ = SIMP(statut='f',typ='TXM',defaut="DELTA_K_EQ",max=1,
- fr="Nom de la quantité correspondant au Delta_K_eq"),
+ fr="Nom de la quantite correspondant au Delta_K_eq"),
LOI = SIMP(statut='o',typ='TXM',into=("PARIS",)),
b_paris = BLOC(condition = "LOI=='PARIS'",
b_cumul = BLOC(condition="OPERATION == 'CUMUL_CYCLES' ",fr="Cumul sur les cycles",
- NOM_PARA = SIMP(statut='f',typ='TXM',max=1,defaut="DELTA_A",fr="Nom de la colonne à traiter"),
+ NOM_PARA = SIMP(statut='f',typ='TXM',max=1,defaut="DELTA_A",fr="Nom de la colonne a traiter"),
CUMUL = SIMP(statut='f',typ='TXM',max=1,defaut="LINEAIRE",into=('LINEAIRE',)),
),
b_pilo_propa = BLOC(condition="OPERATION == 'PILO_PROPA' ",fr="Pilotage de la propagation",
regles = UN_PARMI('DELTA_A_MAX','DELTA_N'),
- DELTA_A_MAX = SIMP(statut='f',typ='R',max=1,val_min=0.,fr="Pilotage en incrément d'avancée max"),
- DELTA_N = SIMP(statut='f',typ='R',max=1,val_min=1 ,fr="Pilotage en incrément de nombre de blocs"),
+ DELTA_A_MAX = SIMP(statut='f',typ='R',max=1,val_min=0.,fr="Pilotage en increment d'avancee max"),
+ DELTA_N = SIMP(statut='f',typ='R',max=1,val_min=1 ,fr="Pilotage en increment de nombre de blocs"),
),
# person_in_charge: irmela.zentner at edf.fr
POST_USURE=OPER(nom="POST_USURE",op=153,sd_prod=table_sdaster,reentrant='f',
UIinfo={"groupes":("Post-traitements",)},
- fr="Calcul des volumes d'usure et des profondeurs d'usure d'après la puissance d'usure",
+ fr="Calcul des volumes d'usure et des profondeurs d'usure d'apres la puissance d'usure",
regles=(UN_PARMI('TUBE_NEUF','RESU_GENE','PUIS_USURE'),
PRESENT_PRESENT('RESU_GENE','NOEUD','LOI_USURE'),
PRESENT_PRESENT('PUIS_USURE','LOI_USURE'),),
POURSUITE=MACRO(nom="POURSUITE",
op=OPS("Cata.ops.build_poursuite"),
repetable='n',
- fr="Poursuite d'une étude à partir de la sauvegarde au format JEVEUX " \
+ fr="Poursuite d'une etude a partir de la sauvegarde au format JEVEUX " \
"ou HDF de sa base globale",
sd_prod = ops.POURSUITE,
UIinfo={"groupes":("Gestion du travail",)},
IMPR_MACRO =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess",
statut='f',typ='TXM',into=("OUI","NON"),defaut="NON"),
- BASE =FACT(fr="définition des paramètres associés aux bases JEVEUX",
+ BASE =FACT(fr="definition des parametres associes aux bases JEVEUX",
statut='f',min=1,max=2,
FICHIER =SIMP(fr="nom de la base",statut='o',typ='TXM'),
TITRE =SIMP(statut='f',typ='TXM'),
CAS =SIMP(statut='f',typ='TXM'),
NMAX_ENRE =SIMP(fr="nombre maximum d enregistrements",statut='f',typ='I'),
LONG_ENRE =SIMP(fr="longueur des enregistrements",statut='f',typ='I'),
- LONG_REPE =SIMP(fr="longueur du répertoire",statut='f',typ='I'),
+ LONG_REPE =SIMP(fr="longueur du repertoire",statut='f',typ='I'),
),
# Le mot cle CATALOGUE n'est jamais utilise en POURSUITE mais sa presence est necessaire au bon fonctionnement
ERREUR_F =SIMP(statut='f',typ='TXM',into=('ABORT','EXCEPTION'),defaut='ABORT'),
),
- DEBUG =FACT(fr="option de déboggage reservée aux développeurs",
+ DEBUG =FACT(fr="option de deboggage reservee aux developpeurs",
statut='f',min=1,max=1,
- JXVERI =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
+ JXVERI =SIMP(fr="verifie l integrite de la segmentation memoire",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
- SDVERI =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+ SDVERI =SIMP(fr="verifie la conformite des SD produites par les commandes",
statut='f',typ='TXM',into=('OUI','NON')),
- JEVEUX =SIMP(fr="force les déchargement sur disque",
+ JEVEUX =SIMP(fr="force les dechargement sur disque",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
- ENVIMA =SIMP(fr="imprime les valeurs définies dans ENVIMA",
+ ENVIMA =SIMP(fr="imprime les valeurs definies dans ENVIMA",
statut='f',typ='TXM',into=('TEST',)),
- HIST_ETAPE = SIMP(fr="permet de conserver toutes les étapes du jeu de commandes",
+ HIST_ETAPE = SIMP(fr="permet de conserver toutes les etapes du jeu de commandes",
statut='f', typ='TXM', into=('OUI', 'NON'), defaut='NON'),
),
- MESURE_TEMPS =FACT(fr="Pour choisir les mesures de temps consommé dans les commandes",
+ MESURE_TEMPS =FACT(fr="Pour choisir les mesures de temps consomme dans les commandes",
statut='d',min=1,max=1,
- NIVE_DETAIL =SIMP(fr="niveau de détail des impressions",
+ NIVE_DETAIL =SIMP(fr="niveau de detail des impressions",
statut='f',typ='I',into=(0,1,2,3),defaut=1),
# 0 : rien
# 1 : impression en fin de commande des mesures principales
# 2 : impression en fin de commande des mesures principales et secondaires
# 3 : impression des mesures principales et secondaires pour chaque pas de temps
- MOYENNE =SIMP(fr="affichage des moyennes et écart-types en parallèle",
+ MOYENNE =SIMP(fr="affichage des moyennes et ecart-types en parallele",
statut='f',typ='TXM',into=('OUI','NON',),defaut='NON'),
),
- MEMOIRE =FACT(fr="mode de gestion mémoire utilisé",statut='d',min=1,max=1,
+ MEMOIRE =FACT(fr="mode de gestion memoire utilise",statut='d',min=1,max=1,
TAILLE_BLOC =SIMP(statut='f',typ='R',defaut=800.),
TAILLE_GROUP_ELEM =SIMP(statut='f',typ='I',defaut=1000),
),
RESERVE_CPU =FACT(fr="reserve de temps pour terminer une execution",statut='d',max=1,
regles=(EXCLUS('VALE','POURCENTAGE'),),
VALE =SIMP(statut='f',typ='I',val_min=0),
-# valeur par défaut fixée à 10. dans le FORTRAN si CODE présent
+# valeur par defaut fixee a 10. dans le FORTRAN si CODE present
POURCENTAGE =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0),
-# valeur par défaut fixée à 10% dans le FORTRAN
+# valeur par defaut fixee a 10% dans le FORTRAN
BORNE =SIMP(statut='f',typ='I',val_min=0,defaut=900) ),
-# valeur en pourcentage du temps maximum bornée à 900 secondes
+# valeur en pourcentage du temps maximum bornee a 900 secondes
CODE =SIMP(statut='f',typ='TXM',into=('OUI', 'NON'),defaut='NON',
- fr="paramètre réservé aux cas-tests"),
+ fr="parametre reserve aux cas-tests"),
- IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"),
+ IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite deliberement ignorer"),
LANG = SIMP(statut='f', typ='TXM',
- fr="Permet de choisir la langue utilisée pour les messages (si disponible)",
+ fr="Permet de choisir la langue utilisee pour les messages (si disponible)",
ang="Allows to choose the language used for messages (if available)"),
INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2),),
PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f',
- UIinfo={"groupes":("Résultats et champs",)},
+ UIinfo={"groupes":("Resultats et champs",)},
fr="Projeter des champs d'un maillage sur un autre",
# faut-il projeter les champs ?
PROJECTION =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON",),),
- # pour projeter avec une sd_corresp_2_mailla deja calculée :
+ # pour projeter avec une sd_corresp_2_mailla deja calculee :
MATR_PROJECTION =SIMP(statut='f',typ=corresp_2_mailla,),
#--------------------------------------------
b_elem =BLOC(condition="METHODE in ('COLLOCATION','ECLA_PG','AUTO')",
CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",),
- fr="Pour indiquer au programme le type de projection souhaité"),
+ fr="Pour indiquer au programme le type de projection souhaite"),
DISTANCE_MAX =SIMP(statut='f',typ='R',
- fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."),
+ fr="Distance maximale entre le noeud et l'element le plus proche, lorsque le noeud n'est dans aucun element."),
TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_1 avant la projection."),
TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_2 avant la projection."),
ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
TYPE_CHAM =SIMP(statut='f',typ='TXM',into=("NOEU",),
- fr="Pour forcer le type des champs projetés. NOEU -> cham_no"),
+ fr="Pour forcer le type des champs projetes. NOEU -> cham_no"),
PROL_ZERO =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
- fr="Pour prolonger les champs par zéro là ou la projection ne donne pas de valeurs."),
+ fr="Pour prolonger les champs par zero la ou la projection ne donne pas de valeurs."),
),
# Cas de la projection SOUS_POINT :
b_sous_point =BLOC(condition="METHODE == 'SOUS_POINT'" ,
CARA_ELEM =SIMP(statut='o',typ=cara_elem),
PROL_ZERO =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
- fr="Pour prolonger les champs par zéro là ou la projection ne donne pas de valeurs."),
+ fr="Pour prolonger les champs par zero la ou la projection ne donne pas de valeurs."),
TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_1 avant la projection."),
TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_2 avant la projection."),
),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(),),
NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster),
- fr="Utile en dynamique pour pouvoir imoser la numérotation des cham_no."),
+ fr="Utile en dynamique pour pouvoir imoser la numerotation des cham_no."),
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
GROUP_NO_2 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
NOEUD_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
- # les mots clés suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le vérifier:
+ # les mots cles suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le verifier:
CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_1 avant la projection."),
TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_2 avant la projection."),
),
), # fin bloc b_1_et_2
#--------------------------------------------
b_elem =BLOC(condition="METHODE in ('COLLOCATION',)",
CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",),
- fr="Pour indiquer au programme le type de projection souhaité"),
+ fr="Pour indiquer au programme le type de projection souhaite"),
DISTANCE_MAX =SIMP(statut='f',typ='R',
- fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."),
+ fr="Distance maximale entre le noeud et l'element le plus proche, lorsque le noeud n'est dans aucun element."),
TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_1 avant la projection."),
TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_2 avant la projection."),
ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
GROUP_NO_2 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
NOEUD_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
- # les mots clés suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le vérifier:
+ # les mots cles suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le verifier:
CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_1 avant la projection."),
TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
- fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ fr="2 (ou 3) fonctions fx,fy,fz definissant la transformation geometrique a appliquer"+
" aux noeuds du MODELE_2 avant la projection."),
),
), # fin bloc b_1
#-----------------------------------------------------------------------------------------------------------
- # 3eme cas : on projette les champs avec une sd_corresp_2_mailla déjé calculée
+ # 3eme cas : on projette les champs avec une sd_corresp_2_mailla deje calculee
#-----------------------------------------------------------------------------------------------
b_2 =BLOC(condition="MATR_PROJECTION != None",
regles=(UN_PARMI('RESULTAT','CHAM_GD'),),
CHAM_GD =SIMP(statut='f',typ=(cham_no_sdaster,cham_elem)),
TYPE_CHAM =SIMP(statut='f',typ='TXM',into=("NOEU",),
- fr="Pour forcer le type des champs projetés. NOEU -> cham_no"),
+ fr="Pour forcer le type des champs projetes. NOEU -> cham_no"),
NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster),
- fr="Parfois utile en dynamique pour pouvoir imposer la numérotation des cham_no."),
+ fr="Parfois utile en dynamique pour pouvoir imposer la numerotation des cham_no."),
- # nécessaire si l'on projette des cham_elem :
+ # necessaire si l'on projette des cham_elem :
MODELE_2 =SIMP(statut='f',typ=modele_sdaster),
PROL_ZERO =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
- fr="Pour prolonger les champs par zéro là où la projection ne donne pas de valeurs."),
+ fr="Pour prolonger les champs par zero la ou la projection ne donne pas de valeurs."),
raise AsException("type de concept resultat non prevu")
PROJ_MATR_BASE=OPER(nom="PROJ_MATR_BASE",op= 71,sd_prod=matr_asse_gene_prod,
- fr="Projection d'une matrice assemblée sur une base (modale ou de RITZ)",
+ fr="Projection d'une matrice assemblee sur une base (modale ou de RITZ)",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(UN_PARMI('MATR_ASSE','MATR_ASSE_GENE'),),
PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193,
sd_prod=proj_mesu_modal_prod,
reentrant='n',
- UIinfo={"groupes":("Résultats et champs",)},
- fr="Calcul des coordonnees généralisees de mesure experimentale relatives a une base de projection",
+ UIinfo={"groupes":("Resultats et champs",)},
+ fr="Calcul des coordonnees generalisees de mesure experimentale relatives a une base de projection",
MODELE_CALCUL =FACT(statut='o',
MODELE =SIMP(statut='o',typ=(modele_sdaster) ),
# person_in_charge: emmanuel.boyere at edf.fr
PROJ_VECT_BASE=OPER(nom="PROJ_VECT_BASE",op= 72,sd_prod=vect_asse_gene,
- fr="Projection d'un vecteur assemblé sur une base (modale ou de RITZ)",
+ fr="Projection d'un vecteur assemble sur une base (modale ou de RITZ)",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(UN_PARMI('VECT_ASSE','VECT_ASSE_GENE'),),
RAFF_GP =MACRO(nom="RAFF_GP",
op=OPS('Macro.raff_gp_ops.raff_gp_ops'),
sd_prod=maillage_sdaster,
- UIinfo={"groupes":("Outils-métier","Rupture",)},
+ UIinfo={"groupes":("Outils-metier","Rupture",)},
reentrant='n',
fr="Preparation du maillage pour calcul du Gp en 2D",
MAILLAGE_N = SIMP(statut='o',typ=maillage_sdaster,
sd_prod=raff_xfem_prod,
fr="Calcul d'un indicateur pour le raffinement",
reentrant='n',
- UIinfo={"groupes":("Résultats et champs","Rupture",)},
+ UIinfo={"groupes":("Resultats et champs","Rupture",)},
TYPE =SIMP(statut='f',typ='TXM',into=('DISTANCE','ZONE'),defaut='DISTANCE'),
FISSURE=SIMP(statut='o',typ=fiss_xfem,min=1,max='**',),
- b_zone =BLOC(condition = "TYPE == 'ZONE' ",fr="Paramètres de la zone",
+ b_zone =BLOC(condition = "TYPE == 'ZONE' ",fr="Parametres de la zone",
RAYON =SIMP(statut='o',typ='R',val_min=0.),
),
sd_prod=carte_sdaster,
fr="Calcul d'un indicateur binaire pour le raffinement",
reentrant='n',
- UIinfo={"groupes":("Résultats et champs","Rupture",)},
+ UIinfo={"groupes":("Resultats et champs","Rupture",)},
FISSURE=SIMP(statut='o',typ=fiss_xfem,min=1,max=1),
RAYON =SIMP(statut='o',typ='R',val_min=0.),
# ======================================================================
# person_in_charge: aurore.parrot at edf.fr
RECA_WEIBULL=OPER(nom="RECA_WEIBULL",op= 197,sd_prod=table_sdaster,
- fr="Recaler les paramètres du modèle de WEIBULL sur des données expérimentales",reentrant='n',
+ fr="Recaler les parametres du modele de WEIBULL sur des donnees experimentales",reentrant='n',
UIinfo={"groupes":("Post-traitements",)},
LIST_PARA =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=2,into=("SIGM_REFE","M",) ),
RESU =FACT(statut='o',max='**',
return fonction_sdaster
RECU_FONCTION=OPER(nom="RECU_FONCTION",op=90,sd_prod=recu_fonction_prod,
- fr="Extraire sous forme d'une fonction, l'évolution d'une grandeur en fonction d'une autre",
+ fr="Extraire sous forme d'une fonction, l'evolution d'une grandeur en fonction d'une autre",
reentrant='f',
- UIinfo={"groupes":("Résultats et champs","Fonctions",)},
+ UIinfo={"groupes":("Resultats et champs","Fonctions",)},
regles=(UN_PARMI('CHAM_GD','RESULTAT','RESU_GENE','TABLE','BASE_ELAS_FLUI','NAPPE','INTE_SPEC'),),
CHAM_GD =SIMP(statut='f',typ=(cham_no_sdaster,cham_elem,),),
# ======= ACCES A LA SD RESULTAT =================================================
b_acces = BLOC ( condition = "(RESULTAT != None) or (RESU_GENE != None)",
- fr="acces a une SD résultat",
-# on ne peut pas mettre de regles, le défaut TOUT_ORDRE est pris en compte dans le fortran
+ fr="acces a une SD resultat",
+# on ne peut pas mettre de regles, le defaut TOUT_ORDRE est pris en compte dans le fortran
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster ),
),
# ======= BASE_ELAS_FLUI =================================================
b_base_elas_flui = BLOC ( condition = "BASE_ELAS_FLUI != None",
- fr="Récupération de la fonction à partir d un concept melasflu",
+ fr="Recuperation de la fonction a partir d un concept melasflu",
regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE'),),
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
# ======= INTERSPECTRE =================================================
b_inte_spec = BLOC ( condition = "INTE_SPEC != None",
- fr="Récupération de fonction dans un concept interspectre",
+ fr="Recuperation de fonction dans un concept interspectre",
regles=(UN_PARMI('NUME_ORDRE_I','NOEUD_I'),),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO()),
NOEUD_I =SIMP(statut='f',typ=no,max=1),
# ======= TABLE =================================================
b_table = BLOC ( condition = "TABLE != None",
- fr="Récupération de la fonction à partir d un concept table",
+ fr="Recuperation de la fonction a partir d un concept table",
regles=(UN_PARMI('PARA_X','NOM_PARA_TABL'),
PRESENT_PRESENT('PARA_X','PARA_Y'),),
PARA_X = SIMP(statut='f',typ='TXM',
- fr="1ère colonne de la table qui définit la fonction à récupérer", ),
+ fr="1ere colonne de la table qui definit la fonction a recuperer", ),
PARA_Y = SIMP(statut='f',typ='TXM',
- fr="2ème colonne de la table qui définit la fonction à récupérer", ),
+ fr="2eme colonne de la table qui definit la fonction a recuperer", ),
#b_tabl_fonc = BLOC(condition = "AsType(TABLE) == table_fonction",
NOM_PARA_TABL = SIMP(statut='f',typ='TXM',into=("FONCTION","FONCTION_C"),
- fr="Nom du paramètre de la table contenant la fonction" ),
+ fr="Nom du parametre de la table contenant la fonction" ),
#),
FILTRE = FACT(statut='f',max='**',
),
# ======= RESULTAT =================================================
- b_resu = BLOC ( condition = "RESULTAT != None", fr="Opérandes en cas de RESULTAT",
+ b_resu = BLOC ( condition = "RESULTAT != None", fr="Operandes en cas de RESULTAT",
regles=(UN_PARMI('NOM_CHAM','NOM_PARA_RESU'),),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO()),
NOM_PARA_RESU =SIMP(statut='f',typ='TXM' ),
# ======= RESU_GENE =================================================
b_tran_gene = BLOC ( condition = "AsType(RESU_GENE) == tran_gene",
- fr="Récupération d'une fonction à partir d un concept TRAN_GENE",
+ fr="Recuperation d'une fonction a partir d un concept TRAN_GENE",
regles=(UN_PARMI('NOM_CHAM','NOEUD_CHOC','GROUP_NO_CHOC'),),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),into=("DEPL","VITE","ACCE","PTEM") ),
NOEUD_CHOC =SIMP(statut='f',typ=no),
),
),
b_harm_gene = BLOC ( condition = "AsType(RESU_GENE)==harm_gene",
- fr="Récupération d'une fonction à partir d un concept HARM_GENE",
+ fr="Recuperation d'une fonction a partir d un concept HARM_GENE",
regles=(UN_PARMI('NOM_CMP','NUME_CMP_GENE'),
UN_PARMI('GROUP_NO','NOEUD','NUME_CMP_GENE',),),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),into=("DEPL","VITE","ACCE") ),
GROUP_NO =SIMP(statut='f',typ=grno),
),
# b_harm_gene = BLOC ( condition = "AsType(RESU_GENE)==harm_gene",
- # fr="Récupération d'une fonction à partir d un concept HARM_GENE",
+ # fr="Recuperation d'une fonction a partir d un concept HARM_GENE",
# regles=(UN_PARMI('NOM_CHAM','NOM_PARA_RESU'),),
# NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO()),
# NOM_PARA_RESU =SIMP(statut='f',typ='TXM' ),
# ),
# ),
b_mode_gene = BLOC ( condition = "AsType(RESU_GENE)==mode_gene",
- fr="Récupération d'une fonction à partir d un concept MODE_GENE",
+ fr="Recuperation d'une fonction a partir d un concept MODE_GENE",
regles=(UN_PARMI('NOM_CHAM','NOM_PARA_RESU'),),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO()),
NOM_PARA_RESU =SIMP(statut='f',typ='TXM' ),
),
# ======= CHAM_GD =================================================
- b_cham_gd = BLOC ( condition = "(CHAM_GD != None)", fr="Opérandes en cas de CHAM_GD",
+ b_cham_gd = BLOC ( condition = "(CHAM_GD != None)", fr="Operandes en cas de CHAM_GD",
regles=(AU_MOINS_UN('MAILLE','GROUP_MA','GROUP_NO','NOEUD'),
PRESENT_ABSENT('POINT','NOEUD','GROUP_NO'),
PRESENT_ABSENT('SOUS_POINT','NOEUD','GROUP_NO'),
),
# ======= NAPPE =================================================
- b_nappe = BLOC ( condition = "(NAPPE != None)", fr="Opérandes en cas de NAPPE",
+ b_nappe = BLOC ( condition = "(NAPPE != None)", fr="Operandes en cas de NAPPE",
VALE_PARA_FONC =SIMP(statut='o',typ='R' ),
PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
# ======================================================================
# person_in_charge: emmanuel.boyere at edf.fr
RECU_GENE=OPER(nom="RECU_GENE",op= 76,sd_prod=vect_asse_gene,reentrant='n',
- UIinfo={"groupes":("Résultats et champs",)},
- fr="Extraire d'un champ de grandeur (déplacements, vitesses ou accélérations) à partir de résultats"
- +" en coordonnées généralisées",
+ UIinfo={"groupes":("Resultats et champs",)},
+ fr="Extraire d'un champ de grandeur (deplacements, vitesses ou accelerations) a partir de resultats"
+ +" en coordonnees generalisees",
regles=(UN_PARMI('FREQ','INST',),),
RESU_GENE =SIMP(statut='o',typ=(tran_gene,harm_gene),),
INST =SIMP(statut='f',typ='R',),
# ======================================================================
# person_in_charge: mathieu.courtois at edf.fr
RECU_TABLE=OPER(nom="RECU_TABLE",op= 174,sd_prod=table_sdaster,
- fr="Récupérer dans une table les valeurs d'un paramètre d'une SD Résultat ou d'extraire une table contenue"
+ fr="Recuperer dans une table les valeurs d'un parametre d'une SD Resultat ou d'extraire une table contenue"
+" dans une autre SD pour celles qui le permettent",
- UIinfo={"groupes":("Résultats et champs","Tables",)},reentrant='n',
+ UIinfo={"groupes":("Resultats et champs","Tables",)},reentrant='n',
CO =SIMP(statut='o',typ=assd),
regles=(UN_PARMI('NOM_TABLE','NOM_PARA')),
NOM_TABLE =SIMP(statut='f',typ='TXM' ),
# person_in_charge: jacques.pellet at edf.fr
RESOUDRE=OPER(nom="RESOUDRE",op=15,sd_prod=cham_no_sdaster,reentrant='f',
- fr="Résolution par méthode directe un système d'équations linéaires préalablement factorisé par FACT_LDLT"+
- "ou Résolution d'un système linéaire par la méthode du gradient conjugué préconditionné",
- UIinfo={"groupes":("Résolution",)},
+ fr="Resolution par methode directe un systeme d'equations lineaires prealablement factorise par FACT_LDLT"+
+ "ou Resolution d'un systeme lineaire par la methode du gradient conjugue preconditionne",
+ UIinfo={"groupes":("Resolution",)},
MATR =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,
matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ),
CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster),
CHAM_CINE =SIMP(statut='f',typ=cham_no_sdaster),
- # mot-clé commun aux solveurs MUMPS, GCPC et PETSc:
+ # mot-cle commun aux solveurs MUMPS, GCPC et PETSc:
RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6),
- # mot-clé pour les posttraitements de la phase de solve de MUMPS
+ # mot-cle pour les posttraitements de la phase de solve de MUMPS
POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
- # mot-clé commun aux solveurs GCPC et PETSc:
+ # mot-cle commun aux solveurs GCPC et PETSc:
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
MATR_PREC =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ),
- # mots-clés pour solveur PETSc:
+ # mots-cles pour solveur PETSc:
ALGORITHME =SIMP(statut='f',typ='TXM',into=("CG", "CR", "GMRES", "GCR", ),defaut="GMRES" ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
raise AsException("type de concept resultat non prevu")
REST_COND_TRAN=OPER(nom="REST_COND_TRAN",op= 78,sd_prod=rest_cond_tran_prod,
- fr="Restituer dans la base physique des résultats issus d'un calcul"
+ fr="Restituer dans la base physique des resultats issus d'un calcul"
+"non-lineaire avec projection modale ou d'un calcul transitoire linear"
+"avec condensation dynamique",
reentrant='f',
raise AsException("type de concept resultat non prevu")
REST_GENE_PHYS=OPER(nom="REST_GENE_PHYS",op= 75,sd_prod=rest_gene_phys_prod,
- fr="Restituer dans la base physique des résultats en coordonnées généralisées",
+ fr="Restituer dans la base physique des resultats en coordonnees generalisees",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(
raise AsException("type de concept resultat non prevu")
REST_SOUS_STRUC=OPER(nom="REST_SOUS_STRUC",op= 77,sd_prod=rest_sous_struc_prod,
- fr="Restituer dans la base physique des résultats obtenus par sous-structuration",
+ fr="Restituer dans la base physique des resultats obtenus par sous-structuration",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(UN_PARMI('RESU_GENE','RESULTAT'),
#
EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','TOUT_INST','NUME_MODE',
'FREQ', 'LIST_FREQ'),
-# Doc U à revoir
+# Doc U a revoir
EXCLUS('NOEUD','GROUP_NO'),
EXCLUS('MAILLE','GROUP_MA'),
PRESENT_PRESENT('RESULTAT','SQUELETTE'),
# person_in_charge: andre.adobes at edf.fr
REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=interspectre,
reentrant='n',
- fr="Calculer la réponse d'une structure dans la base physique",
+ fr="Calculer la reponse d'une structure dans la base physique",
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=(AU_MOINS_UN('BASE_ELAS_FLUI','MODE_MECA'),),
BASE_ELAS_FLUI =SIMP(statut='f',typ=melasflu_sdaster ),
REST_SPEC_TEMP=OPER(nom="REST_SPEC_TEMP",op=181,sd_prod=rest_spec_temp_prod,
- fr="Transformée de Fourier d'un résultat",
+ fr="Transformee de Fourier d'un resultat",
reentrant='n',
UIinfo={"groupes":("Matrices et vecteurs",)},
regles=UN_PARMI('RESU_GENE','RESULTAT'),
SIMU_POINT_MAT=MACRO(nom="SIMU_POINT_MAT",
op=OPS('Macro.simu_point_mat_ops.simu_point_mat_ops'),
sd_prod=table_sdaster,
- UIinfo={"groupes":("Résolution",)},
- fr="Calcul de l'évolution mécanique, en quasi-statique," \
- " d'un point matériel en non linéaire",
+ UIinfo={"groupes":("Resolution",)},
+ fr="Calcul de l'evolution mecanique, en quasi-statique," \
+ " d'un point materiel en non lineaire",
COMPORTEMENT =C_COMPORTEMENT(),
MATER =SIMP(statut='o',typ=mater_sdaster,max=30),
-## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations imposées.
+## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les deformations imposees.
ANGLE =SIMP(statut='f',typ='R',max=1, defaut=0.),
# --MASSIF : orientation du materiau (monocristal, orthotropie)
MASSIF =FACT(statut='f',max='**',
SUPPORT= SIMP(statut='f',typ='TXM',max=1,into=("POINT","ELEMENT",),defaut=("POINT"),),
- b_PM = BLOC(condition="SUPPORT == 'POINT'",fr="Simulation sans élément fini",
+ b_PM = BLOC(condition="SUPPORT == 'POINT'",fr="Simulation sans element fini",
FORMAT_TABLE =SIMP(statut='f',typ='TXM',max=1,into=("CMP_COLONNE","CMP_LIGNE",),defaut=("CMP_COLONNE"),),
NB_VARI_TABLE =SIMP(statut='f',typ='I',max=1,),
OPER_TANGENT =SIMP(statut='f',typ='TXM',max=1,into=("OUI","NON",),defaut="NON",),
PAS_ARCH =SIMP(statut='f',typ='I' ),
PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-6),
),
- # on permet certaines variables de commandes scalaires, définies par une fonction du temps
+ # on permet certaines variables de commandes scalaires, definies par une fonction du temps
# on permet ici seulementn celles qui sont validees
AFFE_VARC = FACT(statut='f',max='**',
NOM_VARC =SIMP(statut='o',typ='TXM', into=("TEMP","IRRA","SECH")),
VALE_FONC = SIMP(statut='f',typ=(fonction_sdaster,formule) ),
- # VALE_REF est nécessaire pour certaines VARC :
+ # VALE_REF est necessaire pour certaines VARC :
B_VALE_REF =BLOC(condition="NOM_VARC in ('TEMP', 'SECH')",
VALE_REF =SIMP(statut='o',typ='R'),
),
),
- # un mot clé caché qui ne sert qu'à boucler sur les VARC possibles :
+ # un mot cle cache qui ne sert qu'a boucler sur les VARC possibles :
LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP","IRRA","SECH")),
),
- b_EF = BLOC(condition="SUPPORT == 'ELEMENT'",fr="Simulation sur un élément fini",
+ b_EF = BLOC(condition="SUPPORT == 'ELEMENT'",fr="Simulation sur un element fini",
MODELISATION =SIMP(statut='f',typ='TXM',max=1,into=("3D","C_PLAN","D_PLAN",)),
RECH_LINEAIRE =C_RECH_LINEAIRE(),
ARCHIVAGE =C_ARCHIVAGE(),
SUIVI_DDL =C_SUIVI_DDL(),
- # on permet certaines variables de commandes scalaires, définies par une fonction du temps
+ # on permet certaines variables de commandes scalaires, definies par une fonction du temps
# a priori toutes doivent fonctionner
AFFE_VARC = FACT(statut='f',max='**',
NOM_VARC =SIMP(statut='o',typ='TXM', into=("TEMP","CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC",
V7 = SIMP(statut='o',typ=(fonction_sdaster,formule) ),
),
),
- # un mot clé caché qui ne sert qu'à boucler sur les VARC possibles :
+ # un mot cle cache qui ne sert qu'a boucler sur les VARC possibles :
LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP","CORR","IRRA","HYDR","SECH","EPSA",
"M_ACIER","M_ZIRC","NEUT1","NEUT2")),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
DISPLAY =SIMP(statut='f',typ='TXM'),
UNITE_VALIDATION=SIMP(statut='f',typ='I',val_min=10,val_max=90,
- fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit les md5"),
+ fr="Unite logique definissant le fichier (fort.N) dans lequel on ecrit les md5"),
) ;
# person_in_charge: mickael.abbas at edf.fr
#
STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli,
- fr="Calcul de l'évolution mécanique ou thermo-hydro-mécanique couplée, en quasi-statique,"
- +" d'une structure en non linéaire",
+ fr="Calcul de l'evolution mecanique ou thermo-hydro-mecanique couplee, en quasi-statique,"
+ +" d'une structure en non lineaire",
reentrant='f',
- UIinfo={"groupes":("Résolution","Mécanique",)},
+ UIinfo={"groupes":("Resolution","Mecanique",)},
MODELE =SIMP(statut='o',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='o',typ=cham_mater),
#-------------------------------------------------------------------
CRIT_QUALITE =FACT(statut='f',max=1,
ERRE_TEMPS_THM =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
- fr="Adaptation temporelle pour les modélisations HM instationnaires",
+ fr="Adaptation temporelle pour les modelisations HM instationnaires",
ang="Time adaptation for unstationary HM models"),
),
#-------------------------------------------------------------------
MODI_RIGI =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
b_char_crit =BLOC(condition="(RIGI_GEOM=='OUI')",
CHAR_CRIT =SIMP(statut='f',typ='R',min=2,max=2,
- fr="Valeur des deux charges critiques délimitant la bande de recherche en HPP"),
+ fr="Valeur des deux charges critiques delimitant la bande de recherche en HPP"),
),
TYPE =SIMP(statut='f',typ='TXM',defaut="FLAMBEMENT",into=("FLAMBEMENT","STABILITE")),
PREC_INSTAB =SIMP(statut='f',typ='R',defaut=1.E-6,max=1,),
),
INFO =SIMP(statut='f',typ='I',into=(1,2) ),
b_info=BLOC(condition="INFO==2",
- fr="filtre les messages émis dans le .mess selon le type de message demandé",
+ fr="filtre les messages emis dans le .mess selon le type de message demande",
INFO_DBG = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(),
into=("CONTACT",
"MECA_NON_LINE",
# MACRO "TEST_THERMOPLASTIQUE"
# ----------------------------
# def test_compor_sdprod(self, COMPORTEMENT, **kwargs):
-# """Ne produit une table qu'en présence de COMPORTEMENT."""
+# """Ne produit une table qu'en presence de COMPORTEMENT."""
# if COMPORTEMENT:
# return table_sdaster
# return None
YOUNG =SIMP(statut='o',typ=fonction_sdaster,
fr="module d'Young fonction de la temperature"),
LIST_MATER =SIMP(statut='o',typ=mater_sdaster,max='**',
- fr="liste des materiaux constants interpolés à chaque température"),
+ fr="liste des materiaux constants interpoles a chaque temperature"),
TEMP_INIT =SIMP(statut='o',typ='R', fr="temperature initiale et de reference"),
TEMP_FIN =SIMP(statut='o',typ='R', fr="temperature finale"),
INST_FIN =SIMP(statut='f',typ='R',defaut=1.,fr="instant final"),
SUPPORT =SIMP(statut='f',typ='TXM',max=1,into=("POINT","ELEMENT",),defaut=("POINT"),),
- NB_VARI =SIMP(statut='o',typ='I', fr="nombre de variables internes - 0 en elasticité"),
+ NB_VARI =SIMP(statut='o',typ='I', fr="nombre de variables internes - 0 en elasticite"),
VARI_TEST =SIMP(statut='f',typ='TXM',max='**',
- fr="liste de variables internes à tester - par defaut, toutes"),
+ fr="liste de variables internes a tester - par defaut, toutes"),
# special ecrouissage cinematique
D_SIGM_EPSI =SIMP(statut='f',typ=fonction_sdaster,
LIST_TOLE =SIMP(statut='f',typ='R',max='**',),
PREC_ZERO =SIMP(statut='f',typ='R',max='**',),
VARI_TEST =SIMP(statut='f',typ='TXM',max='**',defaut=('V1','VMIS','TRACE'),
- fr="liste des CMP à tester "),
+ fr="liste des CMP a tester "),
SUPPORT =SIMP(statut='f',typ='TXM',max=1,into=("POINT","ELEMENT",)),
MODELISATION =SIMP(statut='f',typ='TXM',max=1,into=("3D","C_PLAN"),defaut="3D",),
ANGLE =SIMP(statut='f',typ='R',max=1, defaut=0.,
- fr='Rotation de ANGLE autour de Z uniquement, et seulement pour les déformations imposées',),
+ fr='Rotation de ANGLE autour de Z uniquement, et seulement pour les deformations imposees',),
MASSIF =FACT(statut='f',max='**',fr='orientation du materiau (monocristal, orthotropie)',
regles=(UN_PARMI('ANGL_REP','ANGL_EULER'),),
ANGL_REP =SIMP(statut='f',typ='R',min=1,max=3),
TEST_FICHIER=MACRO(nom="TEST_FICHIER",
op=OPS('Macro.test_fichier_ops.test_fichier_ops'),
UIinfo={"groupes":("Utilitaires",)},
- fr="Tester la non régression de fichiers produits par des commandes aster",
+ fr="Tester la non regression de fichiers produits par des commandes aster",
FICHIER =SIMP(statut='o',typ='TXM',validators=LongStr(1,255)),
EXPR_IGNORE =SIMP(statut='f',typ='TXM',max='**',
- fr="Liste d'expressions régulières permettant d'ignorer certaines lignes"),
+ fr="Liste d'expressions regulieres permettant d'ignorer certaines lignes"),
NB_VALE =SIMP(statut='o',typ='I',),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
TEST_FONCTION=MACRO(nom="TEST_FONCTION",
op=OPS('Macro.test_fonction_ops.test_fonction_ops'),
sd_prod=None,
- fr="Extraction d'une valeur numérique ou d'un attribut de fonction pour comparaison à une valeur de référence",
+ fr="Extraction d'une valeur numerique ou d'un attribut de fonction pour comparaison a une valeur de reference",
UIinfo={"groupes":("Fonctions","Utilitaires",)},
TEST_NOOK =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
VALEUR =FACT(statut='f',max='**',
# ======================================================================
# person_in_charge: j-pierre.lefebvre at edf.fr
TEST_RESU=PROC(nom="TEST_RESU",op=23,
- UIinfo={"groupes":("Résultats et champs","Utilitaires",)},
- fr="Extraction d'une valeur d'une structure de donnée et comparaison à une valeur de référence",
+ UIinfo={"groupes":("Resultats et champs","Utilitaires",)},
+ fr="Extraction d'une valeur d'une structure de donnee et comparaison a une valeur de reference",
regles=(AU_MOINS_UN('CHAM_NO','CHAM_ELEM','CARTE','RESU','GENE','OBJET','TEST_NAN',)),
CHAM_NO =FACT(statut='f',max='**',
TEST_TABLE=PROC(nom="TEST_TABLE",op= 177,
UIinfo={"groupes":("Tables","Utilitaires",)},
fr="Tester une cellule ou une colonne d'une table",
-# concept table_sdaster à tester
+# concept table_sdaster a tester
TABLE =SIMP(statut='o',typ=table_sdaster),
FILTRE =FACT(statut='f',max='**',
NOM_PARA =SIMP(statut='o',typ='TXM' ),
op=OPS('Macro.test_temps_ops.test_temps_ops'),
sd_prod=None,
UIinfo={"groupes":("Utilitaires",)},
- fr="Permet de vérifier le temps passé dans les commandes",
+ fr="Permet de verifier le temps passe dans les commandes",
reentrant='n',
RESU = FACT(statut='o',max='**',
NUME_ORDRE = SIMP(statut='f', typ='I', defaut=1, val_min=1,
fr="Numero de l'occurrence de la commande testee"),
MACHINE = SIMP(statut='o', typ='TXM', max='**',
- fr="Liste des machines dont on a la référence"),
+ fr="Liste des machines dont on a la reference"),
VALE = SIMP(statut='o', typ='R', max='**',
fr="Temps CPU sur les machines listees en secondes"),
CRITERE = SIMP(statut='f', typ='TXM', defaut='RELATIF', into=('ABSOLU', 'RELATIF')),
# ======================================================================
# person_in_charge: jessica.haelewyn at edf.fr
THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f',
- UIinfo={"groupes":("Résolution","Thermique",)},
- fr="Résoudre un problème thermique linéaire stationnaire ou transitoire",
+ UIinfo={"groupes":("Resolution","Thermique",)},
+ fr="Resoudre un probleme thermique lineaire stationnaire ou transitoire",
MODELE =SIMP(statut='o',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='o',typ=cham_mater),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
# ======================================================================
# person_in_charge: jessica.haelewyn at edf.fr
THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f',
- UIinfo={"groupes":("Résolution","Thermique",)},
- fr="Résoudre un problème thermique non linéaire (conditions limites ou comportement matériau)"
+ UIinfo={"groupes":("Resolution","Thermique",)},
+ fr="Resoudre un probleme thermique non lineaire (conditions limites ou comportement materiau)"
+" stationnaire ou transitoire" ,
MODELE =SIMP(statut='o',typ=(modele_sdaster) ),
CHAM_MATER =SIMP(statut='o',typ=(cham_mater) ),
# ======================================================================
# person_in_charge: jessica.haelewyn at edf.fr
THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther,
- fr="Résoudre un problème thermique non linéaire (conditions limites ou comportement matériau)"
+ fr="Resoudre un probleme thermique non lineaire (conditions limites ou comportement materiau)"
+" stationnaire avec chargement mobile",
reentrant='n',
- UIinfo={"groupes":("Résolution","Thermique",)},
+ UIinfo={"groupes":("Resolution","Thermique",)},
MODELE =SIMP(statut='o',typ=modele_sdaster ),
CHAM_MATER =SIMP(statut='o',typ=cham_mater ),
CARA_ELEM =SIMP(statut='c',typ=cara_elem ),
# ======================================================================
# person_in_charge: mathieu.courtois at edf.fr
-# Vérification des imports et définitions non autorisés dans le catalogue
+# Verification des imports et definitions non autorises dans le catalogue
UNAUTHORIZED = ("numpy", "UTMESS", "Table", "Graph")
for _name in UNAUTHORIZED:
