def Traite_value(self, valeur, leType):
"""
Classe : B_ETAPE.ETAPE
Methode : Traite_value
INTENTION : Traitement du cas ou la donnee est un faux entier ou reel (classe entier et reel)
de accas.capy. L'attribut 'valeur' de la sd a été renseigné par la commande qui
l'a produite. C'est cette valeur qui est donc renvoyée ici.
"""
if CONTEXT.debug:
print "Traite_value: ", valeur
if valeur[0] == 0:
return valeur
tup_avant = valeur[1]
list_apres = []
for k in tup_avant:
if isinstance(k, N_ASSD.ASSD):
k = k.valeur
if is_sequence(k):
if leType == "C8" and k[0] in ("MP", "RI"):
# on est en presence d'un complexe isolé
list_apres.append(k)
else:
# on est en presence d'une liste de (R8, C8, IS, TX, LS)
list_apres.extend(k)
else:
# on est en presence d'un (R8, C8, IS, TX, LS) isolé
list_apres.append(k)
if valeur[0] < 0:
# la longueur initiale etait superieure a mxval.
# Elle ne peut qu'augmenter
valeur_apres = (-len(list_apres), tuple(list_apres))
else:
valeur_apres = (len(list_apres), tuple(list_apres))
return valeur_apres
def check_values(self, func, values):
"""Vérifier que les éléments de 'values' sont du bon type (pour getvid, getvtx, getvr8).
"""
ok = True
if not is_sequence(values):
values = [
values,
]
for v in values:
if is_sequence(v):
ok = self.check_values(func, v)
continue
ok = func(v)
if not ok:
break
return ok
def transforme_valeur_nom(self, valeur):
"""
Cette méthode a pour but de retourner soit une chaine de caractères représentant valeur
(dans le cas ou valeur n'est pas une instance retourne la string valeur, sinon retourne valeur.nom)
Traite le cas ou valeur est un tuple d'instances et retourne alors le tuple des strings
"""
if isinstance(valeur, N_ASSD.ASSD):
return valeur.nom
elif is_sequence(valeur):
l = []
for obj in valeur:
l.append(self.transforme_valeur_nom(obj))
return tuple(l)
else:
return valeur
def homo_support_nappe(l_f):
"""Homogénéisation du support d'une liste de nappes.
Retourne une liste de nappes.
"""
if not is_sequence(l_f):
l_f = [
l_f,
]
l_fres = []
for f in l_f:
assert isinstance(
f, t_nappe), 'Erreur : homo_support_nappe est réservé aux nappes !'
__ff = f
for g in l_f:
__ff = __ff.homo_support(g)
l_fres.append(__ff)
return l_fres
def __init__(self, vale_para, l_fonc, para, nom=''):
"""Création d'un objet nappe
- vale_para est la liste de valeur des parametres (mot clé PARA dans DEFI_NAPPE)
- para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER)
- l_fonc est la liste des fonctions, de cardinal égal à celui de vale_para
"""
self.nom = nom
pk = para.keys()
pk.sort()
if pk != [
'INTERPOL', 'NOM_PARA', 'NOM_PARA_FONC', 'NOM_RESU',
'PROL_DROITE', 'PROL_GAUCHE'
]:
raise FonctionError, 'nappe : parametres incorrects'
if para['INTERPOL'] not in [
'NON',
'LIN',
'LOG',
['NON', 'NON'],
['LIN', 'LIN'],
['LIN', 'LOG'],
['LOG', 'LOG'],
['LOG', 'LIN'],
]:
raise FonctionError, 'nappe : parametre INTERPOL incorrect : %s' % para[
'INTERPOL']
if para['PROL_DROITE'] not in ['EXCLU', 'CONSTANT', 'LINEAIRE']:
raise FonctionError, 'nappe : parametre PROL_DROITE incorrect : %s' % para[
'PROL_DROITE']
if para['PROL_GAUCHE'] not in ['EXCLU', 'CONSTANT', 'LINEAIRE']:
raise FonctionError, 'nappe : parametre PROL_GAUCHE incorrect : %s' % para[
'PROL_GAUCHE']
self.vale_para = NP.array(vale_para)
if not is_sequence(l_fonc):
raise FonctionError, 'nappe : la liste de fonctions fournie n est pas une liste'
if len(l_fonc) != len(vale_para):
raise FonctionError, 'nappe : nombre de fonctions différent du nombre de valeurs du paramètre'
for f in l_fonc:
if not isinstance(f, t_fonction) and not isinstance(
f, t_fonction_c):
raise FonctionError, 'nappe : les fonctions fournies ne sont pas du bon type'
self.l_fonc = l_fonc
self.para = para
def erreur_de_type(code_erreur, X):
"""
code_erreur ==0 --> X est une liste
code erreur ==1 --> X est un char
code erreur ==2 --> X est un float
test est un boolean (test = 0 défaut et 1 si un test if est verifier
"""
txt = ""
if (code_erreur == 0):
if not is_sequence(X):
txt = "\nCette entrée: " + str(X) + " n'est pas une liste valide"
if (code_erreur == 1):
if not is_str(X):
txt = "\nCette entrée: " + \
str(X) + \
" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python"
if (code_erreur == 2):
if not is_float(X):
txt = "\nCette entrée: " + \
str(X) + \
" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python"
return txt
def calc_precont_ops(self, reuse, MODELE, CHAM_MATER, CARA_ELEM, EXCIT,
CABLE_BP, CABLE_BP_INACTIF, COMPORTEMENT, ETAT_INIT,
METHODE, ENERGIE, RECH_LINEAIRE, CONVERGENCE, INCREMENT,
SOLVEUR, INFO, TITRE, **args):
"""
Ecriture de la macro CALC_PRECONT
"""
import copy
import aster
import string
import types
from code_aster.Cata.Syntax import _F
from code_aster.Cata.DataStructure import listr8_sdaster, list_inst
from Noyau.N_utils import AsType
from Noyau.N_types import is_sequence
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
RECU_TABLE = self.get_cmd('RECU_TABLE')
DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU')
AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
DETRUIRE = self.get_cmd('DETRUIRE')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type evol_noli) est nomme RES dans
# le contexte de la macro
self.DeclareOut('RES', self.sd)
# alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes
# a tort
MasquerAlarme('COMPOR4_70')
# -------------------------------------------------------------
# 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE
# ------------------------------------------------------------
# 1.1 Recuperation de la liste d'instants, de l'instant initial et final
# Creation de la nouvelle liste d'instants
# ----------------------------------------------------------
dIncrement = INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
__prec = dIncrement['PRECISION']
__L0 = dIncrement['LIST_INST']
if type(__L0) == listr8_sdaster:
# cas où liste definie par DEFI_LIST_REEL
__L1 = __L0.Valeurs()
elif type(__L0) == list_inst:
# cas où liste definie par DEFI_LIST_INST
tmp = __L0.get_name().ljust(8) + '.LIST.' + 'DITR'.ljust(18)
__L1 = aster.getvectjev(tmp)
# Traitement de l'etat initial
if ETAT_INIT:
dEtatInit = ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste)
for i in dEtatInit.keys():
if dEtatInit[i] == None:
del dEtatInit[i]
else:
dEtatInit = None
# Teste si INST_INIT est donné ou bien recalcule __TMIN
if dIncrement['INST_INIT'] == None:
if self.reuse == None:
__TMIN = __L1[0]
else:
__dico = self.reuse.LIST_VARI_ACCES()
__TMIN = __dico['INST'][-1]
else:
__TMIN = dIncrement['INST_INIT']
# Teste si INST_FIN est donné ou bien recalcule __TMAX
if dIncrement['INST_FIN'] == None:
__TMAX = __L1[-1]
else:
__TMAX = dIncrement['INST_FIN']
# Teste si INST_INIT est bien plus petit que INST_FIN
if __TMAX <= __TMIN:
UTMESS('F', 'CABLE0_1')
# Preparation de la liste d'instant __L2 allant de __TMIN a __TMAX
# et preparation des instants supplementaire __TINT et __TINT2
__L2 = []
for m in __L1:
if m >= __TMIN and m <= __TMAX:
__L2.append(m)
if len(__L2) < 2:
UTMESS('F', 'CABLE0_4')
__TINT = (9. * __L2[-1] + __L2[-2]) / 10.
__TINT2 = (9.5 * __L2[-1] + .5 * __L2[-2]) / 10.
# cas ADHERENT ou non
ii = 0
typ_ma = []
for mcabl in CABLE_BP:
__TCAB1 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL')
table_cable = __TCAB1.EXTR_TABLE()
__adher = table_cable.ADHERENT.values()[0]
__typ_ma = table_cable.TYPE_MAILLE.values()[0]
typ_ma.append(__typ_ma)
if ii == 0:
adher = __adher
elif ii != 0 and __adher != adher:
UTMESS('F', 'CABLE0_3')
ii += 1
# DETRUIRE(CONCEPT=_F(NOM=__TCAB1))
adher = adher.strip()
if (adher == 'OUI'):
# finalisation liste instants
__L2[-1:-1] = [__TINT]
# __LST0 est la liste d'instants utilisée pour l'etape 1
__LST0 = DEFI_LIST_REEL(
DEBUT=__TMIN,
INTERVALLE=_F(JUSQU_A=__TMAX, NOMBRE=1),
)
# __LST et __FCT sont utilisés pour les etapes 2 et 3
__LST = DEFI_LIST_REEL(VALE=__L2, )
__FCT = DEFI_FONCTION(
INTERPOL=('LIN', 'LIN'),
NOM_PARA='INST',
VALE=(__TMIN, 0.0, __TINT, 1.0, __TMAX, 1.0),
)
for i in dIncrement.keys():
if dIncrement[i] == None:
del dIncrement[i]
dIncrement['LIST_INST'] = __LST
dIncrement['INST_FIN'] = __TINT
# 1.2 Recuperation des parametres pour STAT_NON_LINE
# -------------------------------------------------------
motscle4 = {}
motscle5 = {}
if METHODE == 'NEWTON':
motscle4['NEWTON'] = args['NEWTON'].List_F()
motscle5['NEWTON'] = args['NEWTON'].List_F()
# for j in dNewton.keys():
# if dNewton[j]==None : del dNewton[j]
dConvergence = CONVERGENCE[0].cree_dict_valeurs(
CONVERGENCE[0].mc_liste)
for i in dConvergence.keys():
if dConvergence[i] == None:
del dConvergence[i]
dSolveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
for i in dSolveur.keys():
if dSolveur[i] == None:
del dSolveur[i]
if RECH_LINEAIRE:
dRech_lin = RECH_LINEAIRE[0].cree_dict_valeurs(
RECH_LINEAIRE[0].mc_liste)
for i in dRech_lin.keys():
if dRech_lin[i] == None:
del dRech_lin[i]
else:
dRech_lin = None
if ENERGIE:
dEnergie = ENERGIE[0].cree_dict_valeurs(ENERGIE[0].mc_liste)
motscle4['ENERGIE'] = dEnergie
motscle5['ENERGIE'] = dEnergie
# 1.3 Creation des mots-cles pour les 3 AFFE_CHAR_MECA
# Recuperation des cables dans les concepts CABLE_BP
# et CABLE_BP_INACTIF
# ------------------------------------------------------
if type(CABLE_BP) is not types.NoneType:
if not is_sequence(CABLE_BP):
CABLE_BP0 = CABLE_BP
CABLE_BP = []
CABLE_BP.append(CABLE_BP0)
if type(CABLE_BP_INACTIF) is not types.NoneType:
if not is_sequence(CABLE_BP_INACTIF):
CABLE_BP_INACTIF0 = CABLE_BP_INACTIF
CABLE_BP_INACTIF = []
CABLE_BP_INACTIF.append(CABLE_BP_INACTIF0)
motscles = {}
motscles['RELA_CINE_BP'] = []
motscle2 = {}
motscle2['RELA_CINE_BP'] = []
motscle3 = {}
motscle3['RELA_CINE_BP'] = []
set_GROUP_MA_A_SEG2 = set()
set_GROUP_MA_A_SEG3 = set()
for ica, mcabl in enumerate(CABLE_BP):
# Creation de mots-cles pour les AFFE_CHAR_MECA
motscles['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='OUI',
RELA_CINE='NON',
))
motscle2['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='NON',
RELA_CINE='OUI',
))
motscle3['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='OUI',
RELA_CINE='OUI',
))
# Creation de __GROUP_MA_A : liste des noms des cables contenus
# dans chaque concept CABLE_BP = cables a activer
__TCAB = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_BP')
table_cable = __TCAB.EXTR_TABLE()
col_nom_cable = table_cable.NOM_CABLE
__typ_ma = typ_ma[ica]
if __typ_ma.strip() == 'SEG2':
set_GROUP_MA_A_SEG2.update(col_nom_cable.values())
elif __typ_ma.strip() == 'SEG3':
set_GROUP_MA_A_SEG3.update(col_nom_cable.values())
else:
raise Exception('type inconnu')
__GROUP_MA_A_SEG2 = list(set_GROUP_MA_A_SEG2)
__GROUP_MA_A_SEG3 = list(set_GROUP_MA_A_SEG3)
# Creation de __GROUP_MA_I : liste des noms des cables contenus
# dans chaque CABLE_BP_INACTIF
# __GROUP_MA_CABLE = liste des cables actifs et inactifs
set_GROUP_MA_I_SEG2 = set()
set_GROUP_MA_I_SEG3 = set()
if CABLE_BP_INACTIF:
motscle6 = {}
motscle6['RELA_CINE_BP'] = []
for mcabl in CABLE_BP_INACTIF:
__TCA0 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_BP')
__TCA2 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL')
col_nom_cable = __TCA0.EXTR_TABLE().NOM_CABLE
__typ_ma = __TCA2.EXTR_TABLE().TYPE_MAILLE.values()[0]
if __typ_ma.strip() == 'SEG2':
set_GROUP_MA_I_SEG2.update(col_nom_cable.values())
elif __typ_ma.strip() == 'SEG3':
set_GROUP_MA_I_SEG3.update(col_nom_cable.values())
else:
raise Exception('type inconnu')
# Creation de mots-cles pour les AFFE_CHAR_MECA
motscle6['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='NON',
RELA_CINE='OUI',
))
__GROUP_MA_I_SEG2 = list(set_GROUP_MA_I_SEG2)
__GROUP_MA_I_SEG3 = list(set_GROUP_MA_I_SEG3)
__GROUP_MA_CABLES_SEG2 = __GROUP_MA_A_SEG2 + __GROUP_MA_I_SEG2
__GROUP_MA_CABLES_SEG3 = __GROUP_MA_A_SEG3 + __GROUP_MA_I_SEG3
# 1.4 Creation des mots-clés facteurs COMPORTEMENT
# pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1)
# ------------------------------------------------------
dComp_incr = []
for j in COMPORTEMENT:
dComp_incr.append(j.cree_dict_valeurs(j.mc_liste))
for i in dComp_incr[-1].keys():
if dComp_incr[-1][i] == None:
del dComp_incr[-1][i]
dComp_incr0 = copy.copy(dComp_incr)
dComp_incr1 = copy.copy(dComp_incr)
PARM_THETA = 0.
for j in range(len(COMPORTEMENT)):
if dComp_incr[j]['RELATION'] == 'ELAS':
PARM_THETA = dComp_incr[j]['PARM_THETA']
if PARM_THETA == 0:
PARM_THETA = dComp_incr[0]['PARM_THETA']
dComp_incrElas = []
affe_mo = []
if __GROUP_MA_A_SEG3 != []:
comp_seg3 = {
'RELATION': 'KIT_CG',
'GROUP_MA': __GROUP_MA_A_SEG3,
'PARM_THETA': PARM_THETA
}
comp_seg3['RELATION_KIT'] = (
'ELAS',
'CABLE_GAINE_FROT',
)
dComp_incrElas.append(comp_seg3)
affe_mo.append({
'GROUP_MA': __GROUP_MA_A_SEG3,
'PHENOMENE': 'MECANIQUE',
'MODELISATION': 'CABLE_GAINE',
})
if __GROUP_MA_A_SEG2 != []:
dComp_incrElas.append({
'RELATION': 'ELAS',
'TOUT': 'OUI',
'PARM_THETA': PARM_THETA
})
affe_mo.append({
'GROUP_MA': __GROUP_MA_A_SEG2,
'PHENOMENE': 'MECANIQUE',
'MODELISATION': 'BARRE',
})
if __GROUP_MA_CABLES_SEG3 != []:
dComp_incr0.append(
_F(
RELATION='KIT_CG',
RELATION_KIT=(
'SANS',
'CABLE_GAINE_FROT',
),
GROUP_MA=__GROUP_MA_CABLES_SEG3,
))
if __GROUP_MA_I_SEG3:
dComp_incr1.append(
_F(
RELATION='KIT_CG',
RELATION_KIT=(
'SANS',
'CABLE_GAINE_FROT',
),
GROUP_MA=__GROUP_MA_I_SEG3,
))
if __GROUP_MA_CABLES_SEG2 != []:
dComp_incr0.append(
_F(
RELATION='SANS',
GROUP_MA=__GROUP_MA_CABLES_SEG2,
))
if __GROUP_MA_I_SEG2:
dComp_incr1.append(
_F(
RELATION='SANS',
GROUP_MA=__GROUP_MA_I_SEG2,
))
# 1.5 Modele contenant uniquement les cables de precontrainte
# ---------------------------------------------------------
__MOD = string.ljust(MODELE.nom, 8)
__MOD1 = __MOD + '.MODELE .LGRF '
__LMAIL = aster.getvectjev(__MOD1)
__MAIL = string.strip(__LMAIL[0])
objma = self.get_sd_avant_etape(__MAIL, self)
__M_CA = AFFE_MODELE(MAILLAGE=objma, AFFE=affe_mo)
# 1.6 Blocage de tous les noeuds des cables actifs
# --------------------------------------------------
__GROUP_MA_A = __GROUP_MA_A_SEG2 + __GROUP_MA_A_SEG3
_B_CA = AFFE_CHAR_MECA(
MODELE=__M_CA,
DDL_IMPO=_F(
GROUP_MA=__GROUP_MA_A,
DX=0.,
DY=0.,
DZ=0.,
),
)
# 1.7 Chargements concernant les cables
# -------------------------------------
_C_CN = AFFE_CHAR_MECA(MODELE=__M_CA, **motscles)
_C_CA = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2)
_C_CT = AFFE_CHAR_MECA(MODELE=MODELE, **motscle3)
if CABLE_BP_INACTIF:
_C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6)
# -------------------------------------------------------------
# 2. CALCULS
# ------------------------------------------------------------
#-------------------------------------------------------------------
# 2.1 Premiere etape : calcul sur le(s) cable(s) et
# recuperation des _F_CAs aux noeuds
# on travaile entre tmin et tmax
#-------------------------------------------------------------------
__EV1 = STAT_NON_LINE(
MODELE=__M_CA,
CHAM_MATER=CHAM_MATER,
CARA_ELEM=CARA_ELEM,
EXCIT=(
_F(CHARGE=_B_CA),
_F(CHARGE=_C_CN),
),
COMPORTEMENT=dComp_incrElas,
INCREMENT=_F(LIST_INST=__LST0, PRECISION=__prec),
SOLVEUR=dSolveur,
INFO=INFO,
TITRE=TITRE,
)
__EV1 = CALC_CHAMP(
reuse=__EV1,
RESULTAT=__EV1,
# GROUP_MA = __GROUP_MA_A,
FORCE='FORC_NODA')
__REA = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
RESULTAT=__EV1,
NOM_CHAM='FORC_NODA',
INST=__TMAX)
__REAC0 = CREA_CHAMP(
TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
AFFE=_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS',
'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.)),
)
__REAC = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='ASSE',
MODELE=MODELE,
ASSE=(
_F(TOUT='OUI', CHAM_GD=__REAC0, COEF_R=1.),
_F(GROUP_MA=__GROUP_MA_A,
CHAM_GD=__REA,
COEF_R=-1.),
))
_F_CA = AFFE_CHAR_MECA(MODELE=MODELE, VECT_ASSE=__REAC)
#-----------------------------------------------------------------------
# 2.2 Deuxieme etape : application de la precontrainte sur le beton
# en desactivant les cables
#----------------------------------------------------------------------
# Regeneration des mots-cles EXCIT passés en argument de la macro
dExcit = []
for j in EXCIT:
dExcit.append(j.cree_dict_valeurs(j.mc_liste))
for i in dExcit[-1].keys():
if dExcit[-1][i] == None:
del dExcit[-1][i]
if CABLE_BP_INACTIF:
dExcit.append(_F(CHARGE=_C_CI), )
# Creation du mots-cle EXCIT pour le STAT_NON_LINE
dExcit1 = copy.copy(dExcit)
dExcit1.append(_F(CHARGE=_C_CA), )
dExcit1.append(_F(CHARGE=_F_CA, FONC_MULT=__FCT), )
if self.reuse:
motscle4['reuse'] = self.reuse
RES = STAT_NON_LINE(MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=dComp_incr0,
INCREMENT=dIncrement,
ETAT_INIT=dEtatInit,
METHODE=METHODE,
CONVERGENCE=dConvergence,
RECH_LINEAIRE=dRech_lin,
SOLVEUR=dSolveur,
ARCHIVAGE=_F(INST=__TINT),
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1,
**motscle4)
# Recuperation du dernier numero d'ordre pour pouvoir l'écraser dans
# RES
__dico2 = RES.LIST_VARI_ACCES()
__no = __dico2['NUME_ORDRE'][-1]
#-----------------------------------------------------------------------
# 2.2 Troisieme etape : on remet la tension dans les cables
#----------------------------------------------------------------------
# Creation du mots-cles EXCIT pour le STAT_NON_LINE
dExcit2 = copy.copy(dExcit)
dExcit2.append(_F(CHARGE=_C_CT, ))
# Calcul sur un seul pas (de __TINT a __TMAX)
RES = STAT_NON_LINE(
reuse=RES,
ETAT_INIT=_F(EVOL_NOLI=RES),
MODELE=MODELE,
CHAM_MATER=CHAM_MATER,
CARA_ELEM=CARA_ELEM,
COMPORTEMENT=dComp_incr1,
INCREMENT=_F(LIST_INST=__LST, PRECISION=__prec),
METHODE=METHODE,
# NEWTON =dNewton,
# IMPLEX=dImplex,
RECH_LINEAIRE=dRech_lin,
CONVERGENCE=dConvergence,
SOLVEUR=dSolveur,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit2,
**motscle5)
elif adher == 'NON':
motscle4 = {}
motscle2 = {}
motscle2 = {}
motscle2['DDL_IMPO'] = []
motscle2['RELA_CINE_BP'] = []
motscle2a = {}
motscle2a['DDL_IMPO'] = []
motscle2a['RELA_CINE_BP'] = []
motscle2b = {}
motscle2b['DDL_IMPO'] = []
motscle2b['RELA_CINE_BP'] = []
motscle5 = {}
motscle5['DDL_IMPO'] = []
motscle5['RELA_CINE_BP'] = []
motscle3 = {}
motscle3['AFFE'] = [
_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.))
]
motscle3a = {}
motscle3a['AFFE'] = [
_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.))
]
motscle3b = {}
motscle3b['AFFE'] = [
_F(TOUT='OUI',
NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'),
VALE=(0., 0., 0., 0., 0., 0., 0., 0.))
]
motscle6 = {}
motscle6['DDL_IMPO'] = []
__ActifActif = False
if self.reuse:
motscle4['reuse'] = self.reuse
# assert (len(CABLE_BP) == 1)
# traitement des cables inactifs
if type(CABLE_BP_INACTIF) is not types.NoneType:
if not is_sequence(CABLE_BP_INACTIF):
CABLE_BP_INACTIF0 = CABLE_BP_INACTIF
CABLE_BP_INACTIF = []
CABLE_BP_INACTIF.append(CABLE_BP_INACTIF0)
else:
CABLE_BP_INACTIF = []
motscle6 = {}
motscle6['RELA_CINE_BP'] = []
for mcabl in CABLE_BP_INACTIF:
# Creation de mots-cles pour les AFFE_CHAR_MECA
motscle6['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='NON',
RELA_CINE='OUI',
))
for mcabl in CABLE_BP:
__TCAB1 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL')
motscle2['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='NON',
RELA_CINE='OUI',
))
motscle5['RELA_CINE_BP'].append(
_F(
CABLE_BP=mcabl,
SIGM_BPEL='NON',
RELA_CINE='OUI',
))
nb_cable = len(__TCAB1.EXTR_TABLE().NOM_ANCRAGE1.values())
table_cable = __TCAB1.EXTR_TABLE()
for icable in xrange(nb_cable):
__typ_ancr = (table_cable.TYPE_ANCRAGE1.values()[icable],
table_cable.TYPE_ANCRAGE2.values()[icable])
__typ_noeu = (table_cable.TYPE_NOEUD1.values()[icable],
table_cable.TYPE_NOEUD2.values()[icable])
__nom_noeu = (table_cable.NOM_ANCRAGE1.values()[icable],
table_cable.NOM_ANCRAGE2.values()[icable])
__tension = table_cable.TENSION.values()[icable]
__recul = table_cable.RECUL_ANCRAGE.values()[icable]
__recul_exists = (__recul != 0)
__sens = table_cable.SENS.values()[icable]
actif = 0
ancr1_passif = 1
for j in range(2):
if string.strip(__typ_ancr[j]) == 'PASSIF':
if j == 0:
ancr1_passif = -1
if string.strip(__typ_noeu[j]) == 'NOEUD':
motscle2['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]), GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
motscle2['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
actif += 1
if string.strip(__typ_noeu[j]) == 'NOEUD':
motscle3['AFFE'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
if j == 0:
motscle3b['AFFE'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=__sens * __tension *
(-1)**(j + 1)))
motscle2a['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
motscle3a['AFFE'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
motscle2b['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(NOEUD=string.strip(__nom_noeu[j]),
GLIS=ancr1_passif * __sens * __recul *
(-1)**(j)))
else:
motscle3['AFFE'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
if j == 0:
motscle3b['AFFE'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=__sens * __tension *
(-1)**(j + 1)))
motscle2a['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
else:
motscle3a['AFFE'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
NOM_CMP='GLIS',
VALE=ancr1_passif * __sens * __tension *
(-1)**(j + 1)))
motscle2b['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=0.))
if __recul_exists:
motscle5['DDL_IMPO'].append(
_F(GROUP_NO=string.strip(__nom_noeu[j]),
GLIS=ancr1_passif * __sens * __recul *
(-1)**(j)))
if (actif == 2):
__ActifActif = True
# DETRUIRE(CONCEPT=_F(NOM=__TCAB1))
dExcit = []
for j in EXCIT:
dExcit.append(j.cree_dict_valeurs(j.mc_liste))
for i in dExcit[-1].keys():
if dExcit[-1][i] == None:
del dExcit[-1][i]
assert (len(motscle3) > 0)
if __ActifActif:
dExcit1a = copy.copy(dExcit)
dExcit1b = copy.copy(dExcit)
if CABLE_BP_INACTIF:
_C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6)
dExcit1a.append(_F(CHARGE=_C_CI, ))
dExcit1b.append(_F(CHARGE=_C_CI, ))
__CH1a = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
**motscle3a)
__CH1b = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
**motscle3b)
_C_CAc = AFFE_CHAR_MECA(MODELE=MODELE,
VECT_ASSE=__CH1a,
**motscle2)
_C_CAd = AFFE_CHAR_MECA(MODELE=MODELE,
VECT_ASSE=__CH1b,
**motscle2)
_C_CAa = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2a)
_C_CAb = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2b)
dExcit1a.append(_F(CHARGE=_C_CAa, TYPE_CHARGE='DIDI'))
dExcit1b.append(_F(CHARGE=_C_CAb, TYPE_CHARGE='DIDI'))
dExcit1a.append(_F(CHARGE=_C_CAc))
dExcit1b.append(_F(CHARGE=_C_CAd))
__L2[-1:-1] = [__TINT]
else:
dExcit1 = copy.copy(dExcit)
if CABLE_BP_INACTIF:
_C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6)
dExcit1.append(_F(CHARGE=_C_CI, ))
__CH1 = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='AFFE',
MODELE=MODELE,
**motscle3)
_C_CA = AFFE_CHAR_MECA(MODELE=MODELE, VECT_ASSE=__CH1, **motscle2)
dExcit1.append(_F(CHARGE=_C_CA, TYPE_CHARGE='DIDI'), )
_C_RA = AFFE_CHAR_MECA(MODELE=MODELE, **motscle5)
dExcit2 = copy.copy(dExcit)
dExcit2.append(_F(CHARGE=_C_RA, TYPE_CHARGE='DIDI'), )
if CABLE_BP_INACTIF:
dExcit2.append(_F(CHARGE=_C_CI, ))
if __recul_exists:
__L2[-1:-1] = [__TINT2]
__LST = DEFI_LIST_REEL(VALE=__L2, )
for i in dIncrement.keys():
if dIncrement[i] == None:
del dIncrement[i]
dIncrement['LIST_INST'] = __LST
else:
if __ActifActif:
__LST = DEFI_LIST_REEL(VALE=__L2, )
for i in dIncrement.keys():
if dIncrement[i] == None:
del dIncrement[i]
dIncrement['LIST_INST'] = __LST
else:
dIncrement = INCREMENT
if __ActifActif:
dIncrement['INST_FIN'] = __TINT
RES = STAT_NON_LINE(
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=dIncrement,
NEWTON=_F(REAC_ITER=1),
ETAT_INIT=ETAT_INIT,
METHODE=METHODE,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1a,
**motscle4)
if __recul_exists:
dIncrement['INST_FIN'] = __TINT2
else:
dIncrement['INST_FIN'] = __TMAX
RES = STAT_NON_LINE(
reuse=RES,
ETAT_INIT=_F(EVOL_NOLI=RES),
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=dIncrement,
NEWTON=_F(REAC_ITER=1),
METHODE=METHODE,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1b,
)
else:
if __recul_exists:
dIncrement['INST_FIN'] = __TINT2
RES = STAT_NON_LINE(
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=dIncrement,
NEWTON=_F(REAC_ITER=1),
METHODE=METHODE,
ETAT_INIT=ETAT_INIT,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit1,
**motscle4)
if __recul_exists:
RES = STAT_NON_LINE(
reuse=RES,
ETAT_INIT=_F(EVOL_NOLI=RES),
MODELE=MODELE,
CARA_ELEM=CARA_ELEM,
CHAM_MATER=CHAM_MATER,
COMPORTEMENT=COMPORTEMENT,
# INCREMENT=INCREMENT,
INCREMENT=_F(LIST_INST=__LST, PRECISION=__prec),
NEWTON=_F(REAC_ITER=1),
# ETAT_INIT = ETAT_INIT,
METHODE=METHODE,
CONVERGENCE=CONVERGENCE,
RECH_LINEAIRE=RECH_LINEAIRE,
SOLVEUR=SOLVEUR,
INFO=INFO,
TITRE=TITRE,
EXCIT=dExcit2,
)
else:
raise Exception(
"erreur de programmation, adher different de OUI et NON")
RetablirAlarme('COMPOR4_70')
return ier
def getmjm(self, motfac, iocc, nbval):
"""
Retourne des informations sur le mot cle facteur motfac du catalogue de la commande nomcmd
motfac : nom du mot cle facteur
iocc : numero d occurence du mot cle facteur
Retour:
motcle : liste des sous mots cles
typ : liste des types des sous mots cles
nbarg : nombre total d arguments du mot cle facteur(a priori ne doit etre utilise que par le superviseur)
"""
motfac = motfac.strip()
if motfac != '':
mcfact = self.get_mocle(motfac)
if mcfact == None:
return ([], [])
else:
mcfact = mcfact[iocc]
else:
mcfact = self
# On a trouvé le mot cle facteur
dico_mcsimp = mcfact.cree_dict_valeurs(mcfact.mc_liste)
if self.nom == 'TEST_RESU' and dico_mcsimp.get('VALE_C') != None:
pass
lmc = []
lty = []
for name, obj in dico_mcsimp.items():
if obj is None:
continue
lmc.append(name)
if is_sequence(obj):
obj = obj[0]
# cas liste de complexes sous la forme RI/MP !
if is_sequence(obj):
obj = obj[0]
if isinstance(obj,
(N_ASSD.ASSD, N_ENTITE.ENTITE, N_MCLIST.MCList)):
lty.append(type(obj).__name__)
if is_complex(obj):
lty.append('C8')
if is_float(obj):
lty.append('R8')
if is_str(obj):
if obj.strip() in ('RI', 'MP'):
lty.append('C8')
else:
lty.append('TX')
if is_int(obj):
# on gere le cas d un reel entre par l utilisateur sans le '.' distinctif d un entier
# pour ca on teste la presence de R8 dans la liste des types
# attendus cote catalogue
child = mcfact.definition.get_entite(name)
list_cata = B_utils.Typast(child.type)
if ('IS ' not in list_cata) and ('R8 ' in list_cata):
lty.append('R8')
elif ('IS ' not in list_cata) and ('C8 ' in list_cata):
lty.append('C8')
else:
lty.append('I')
assert len(lmc) == len(
lty), "cardinalité différente : \n%s\n%s" % (lmc, lty)
return (lmc, lty)
def TesterValeur(nomPara, valPu, valRef, res, epsi, crit, sSigne):
"""
Teste de la valeur calculee par rapport a la valeur de reference
"""
import aster
import cmath
import math
isTestOk = 0
vtc = valRef[0]
if is_sequence(vtc):
assert((vtc[0] == 'RI') | (vtc[0] == 'MP')), vtc[0]
if vtc[0] == 'RI':
vtc = vtc[1] + 1j * vtc[2]
else:
vtc = vtc[1] * cmath.exp(1j * math.pi * vtc[2] / 180)
if sSigne == 'OUI':
res = abs(res)
if is_complex(valRef[0]):
vtc = abs(vtc)
# Recherche de la valeur la plus proche de la valeur calculee
# dans le tableau valRef
minTmp = abs(res - vtc)
curI = 0
for i in range(len(valRef)):
vtc = valRef[i]
if is_sequence(vtc):
assert((vtc[0] == 'RI') | (vtc[0] == 'MP')), vtc[0]
if vtc[0] == 'RI':
vtc = vtc[1] + 1j * vtc[2]
else:
vtc = vtc[1] * cmath.exp(1j * math.pi * vtc[2] / 180)
if sSigne == 'OUI' and is_complex(vtc):
vtc = abs(vtc)
valTmp = abs(res - vtc)
if valTmp < minTmp:
valTmp = minTmp
curI = i
vtc = valRef[curI]
if is_sequence(vtc):
assert((vtc[0] == 'RI') | (vtc[0] == 'MP')), vtc[0]
if vtc[0] == 'RI':
vtc = vtc[1] + 1j * vtc[2]
else:
vtc = vtc[1] * cmath.exp(1j * math.pi * vtc[2] / 180)
if sSigne == 'OUI' and is_complex(vtc):
vtc = abs(vtc)
testOk = 'NOOK'
curEps = 0
err = 0
pourcent = ' '
# Calcul de l'erreur commise
if crit[0:4] == 'RELA':
isTestOk = (abs(res - vtc) <= epsi * abs(vtc))
if vtc != 0:
if is_complex(res) or is_complex(vtc):
err = abs(res - vtc) / abs(vtc) * 100
else:
err = (res - vtc) / vtc * 100
else:
err = 999.999999
if isTestOk:
testOk = ' OK '
curEps = epsi * 100
pourcent = '%'
else:
isTestOk = (abs(res - vtc) <= epsi)
if is_complex(res) or is_complex(vtc):
err = abs(res - vtc)
else:
err = res - vtc
if isTestOk:
testOk = ' OK '
curEps = epsi
return {'testOk': testOk, 'erreur': err, 'epsilon': curEps, 'valeurRef': vtc}
def test_fonction_ops(self, TEST_NOOK, VALEUR, ATTRIBUT, **args):
"""
Corps de la macro TEST_FONCTION
"""
macro = 'TEST_FONCTION'
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from SD.sd_fonction import sd_fonction
from Cata_Utils.t_fonction import t_fonction_c
CALC_FONCTION = self.get_cmd('CALC_FONCTION')
DETRUIRE = self.get_cmd('DETRUIRE')
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# txt sert a l'affichage dans le fichier RESULTAT
txt = ['', ]
txt.append(ligne_separatrice)
if VALEUR != None:
# Boucle sur les VALEURS
for val in VALEUR:
dres = val.cree_dict_valeurs(val.mc_liste)
# Recherche des mots-cles simples
ssigne = dres['VALE_ABS']
epsi = dres['TOLE_MACHINE']
crit = dres['CRITERE']
fct = dres['FONCTION']
nompara = dres['NOM_PARA']
if nompara == None:
nompara = ''
ref = dres['REFERENCE'] or 'NON_REGRESSION'
other_ref = ref != 'NON_REGRESSION' and dres['REFERENCE'] or None
ver = None
legende = dres['LEGENDE']
if legende == None:
legende = 'XXXX'
nomfct = fct.get_name()
# Transformation de nompara en liste
if (not is_sequence(nompara)) and nompara != None:
nompara = [nompara, ]
# La fonction est directement de dres['FONCTION']
lafonc = None
titre = ''
lafonc = fct
res = 0.
typeFct = ''
valpu = dres['VALE_PARA']
if not is_sequence(valpu):
valpu = [valpu, ]
valref = get_valref(lafonc, dres, 'CALC')
if other_ref:
valoth = get_valref(lafonc, dres, 'REFE')
epsoth = dres['PRECISION']
intervalle = dres['INTERVALLE']
ier = 0
# Distinction des cas
# - "fonction" sur un intervalle
# - "formule",
# - "fonction" ou "nappe"
if (type(lafonc) == fonction_sdaster) and intervalle != None:
# XXX il faut utiliser lafonc.Parametres() !
# XXX ne sert à rien, CALC_FONCTION prend les paramètres de la fonction normalement
fctProl = lafonc.sdj.PROL.get()
prolG = 'rien'
if fctProl[4][0:1] == 'C':
prolG = 'CONSTANT'
elif fctProl[4][0:1] == 'E':
prolG = 'EXCLU'
elif fctProl[4][0:1] == 'L':
prolG = 'LINEAIRE'
prolD = 'rien'
if fctProl[4][1:2] == 'C':
prolD = 'CONSTANT'
elif fctProl[4][1:2] == 'E':
prolD = 'EXCLU'
elif fctProl[4][1:2] == 'L':
prolD = 'LINEAIRE'
curInterpol = [fctProl[1][0:3], fctProl[1][4:7]]
__fInt = CALC_FONCTION(INTEGRE=_F(FONCTION=lafonc,),
PROL_DROITE=prolD,
PROL_GAUCHE=prolG,
INTERPOL=curInterpol)
res1 = __fInt(intervalle[0])
res2 = __fInt(intervalle[1])
DETRUIRE(CONCEPT=_F(NOM=__fInt), INFO=1)
res = (res2 - res1) / (intervalle[1] - intervalle[0])
valpu[0] = intervalle[0]
elif type(lafonc) in (formule, formule_c):
# Lecture des valeurs de reference dans les mots-cles simples
if type(lafonc) == formule_c:
typeFct = 'formule_c'
else:
typeFct = 'formule'
# On cherche les valeurs de reference passees a TEST_FONCTION et
# on les trie grace a ceux de la formule
paramFormule = lafonc.Parametres()['NOM_PARA']
if not is_sequence(paramFormule):
paramFormule = [paramFormule, ]
if nompara[0] == '':
nompara = paramFormule
# On verifie que la formule a bien le meme nombre de parametres
# que ceux passes a la fonction TEST_FONCTION
if len(nompara) != len(paramFormule):
ier = 160
UTMESS('A+', 'FONCT0_9', valk=(lafonc.get_name()))
UTMESS('A', 'FONCT0_14', vali=(
len(nompara), len(paramFormule)))
return 0.
# Trie des parametres passes a la fonction TEST_FONCTION pour
# correspondre a l'ordre de ceux de la formule
nParamOrdo = []
vParamOrdo = []
for iPN in range(len(paramFormule)):
nParamOrdo.append('')
# vParamOrdo.append('')
compteur = 0
for iPN in range(len(paramFormule)):
i = 0
for iPU in range(len(nompara)):
if paramFormule[iPN] == nompara[iPU]:
if nParamOrdo[iPN] == '':
vParamOrdo.append(valpu[iPU])
nParamOrdo[iPN] = paramFormule[iPN]
compteur = compteur + 1
else:
ier = 120
UTMESS(
'A+', 'FONCT0_9', valk=(lafonc.get_name()))
UTMESS('A', 'FONCT0_15', valk=nompara)
res = 0.
i = i + 1
if nParamOrdo[iPN] == '':
ier = 130
UTMESS('A+', 'FONCT0_9', valk=(lafonc.get_name()))
UTMESS('A', 'FONCT0_16', valk=paramFormule)
UTMESS('A', 'FONCT0_17', valk=nompara)
return 0.
# Si tout est Ok, on calcul la valeur de la formule
if ier == 0:
res = lafonc(*vParamOrdo)
# Cas fonction et nappe
elif type(lafonc) in (fonction_sdaster, fonction_c, nappe_sdaster):
# XXX il faut utiliser lafonc.Parametres() !
# Recuperation du .PROL de la fonction
fct_prol = lafonc.sdj.PROL.get_stripped()
if fct_prol == None:
UTMESS('F', 'PREPOST3_93')
nompu = ''
if nompara[0] != '':
nompu = nompara[0]
else:
nompu = fct_prol[2]
nompara = [nompu, ]
# Une nappe a forcement 2 parametres
if (fct_prol[0] == 'NAPPE') & (len(nompara) == 1):
UTMESS('A', 'PREPOST3_94')
break
# Lecture de la valeur de reference
if fct_prol[0] == 'FONCT_C':
typeFct = 'fonction_c'
else:
if fct_prol[0] == 'NAPPE':
typeFct = 'nappe'
else:
typeFct = 'fonction'
# Calcul de la fonction
res = 0
if type(lafonc) in (fonction_sdaster, fonction_c):
res = lafonc(valpu[0])
else:
# Remise dans l'ordre des param
paramNappe = [fct_prol[2], fct_prol[6]]
vParamOrdo = ['', '']
for iPN in range(len(paramNappe)):
i = 0
for iPU in range(len(nompara)):
if paramNappe[iPN] == nompara[iPU]:
if vParamOrdo[iPN] != '':
ier = 120
UTMESS(
'A+', 'FONCT0_9', valk=(lafonc.get_name()))
UTMESS('A', 'FONCT0_15', valk=nompara)
else:
vParamOrdo[iPN] = valpu[iPU]
i = i + 1
if vParamOrdo[iPN] == '':
ier = 130
UTMESS('A+', 'FONCT0_9', valk=(lafonc.get_name()))
UTMESS('A', 'FONCT0_16', valk=paramNappe)
UTMESS('A', 'FONCT0_17', valk=nompara)
res = lafonc(vParamOrdo[0], vParamOrdo[1])
else:
ier = 150
# Construction de l'affiche du resultat
current = {}
nomLastPara = nompara[len(nompara) - 1]
valLastPara = valpu[len(valpu) - 1]
if (typeFct == 'nappe'):
# ligne 1
nb_espace = 16 - len(str(nompu))
espace = nb_espace * ' '
current['nom_para_0'] = str(nompu) + espace
nb_espace = 16 - len(str(nomLastPara))
espace = nb_espace * ' '
current['nom_para'] = str(nomLastPara) + espace
txt.append(ligne_nap_1 % current)
# ligne 2
current = {}
nb_espace = 16 - len(nomfct)
espace = nb_espace * ' '
current['nom_nap'] = nomfct + espace
nb_espace = 16 - len(str(valpu[0]))
espace = nb_espace * ' '
current['val_para_0'] = str(valpu[0]) + espace
nb_espace = 16 - len(str(valLastPara))
espace = nb_espace * ' '
current['val_para'] = str(valLastPara) + espace
txt.append(ligne_nap_2 % current)
else:
# ligne 1
nb_espace = 16 - len(str(nomLastPara))
espace = nb_espace * ' '
current['nom_para'] = str(nomLastPara) + espace
if(len(titre) > 1):
txt.append(ligne_fct_11 % current)
else:
txt.append(ligne_fct_1 % current)
# ligne 2
current = {}
nb_espace = 16 - len(nomfct)
espace = nb_espace * ' '
current['nom_fct'] = nomfct + espace
nb_espace = 16 - len(str(valLastPara))
espace = nb_espace * ' '
current['val_para'] = str(valLastPara) + espace
if(len(titre) > 1):
nb_espace = 33 - len(titre)
espace = nb_espace * ' '
current['titre'] = titre
txt.append(ligne_fct_22 % current)
else:
txt.append(ligne_fct_2 % current)
# Test des valeurs calculees
curDict = TesterValeur(
nomLastPara, valLastPara, valref, res, epsi, crit, ssigne)
if other_ref:
DictRef = TesterValeur(
nomLastPara, valLastPara, valoth, res, epsoth, crit, ssigne)
if TEST_NOOK == 'OUI':
if ier == 0:
testOk = curDict['testOk']
if testOk == ' OK ':
txt.append(
'NOOK PAS DE CHANCE LE TEST EST CORRECT !!!')
else:
AfficherResultat(
curDict, nomLastPara, 'NON_REGRESSION', legende,
crit, res, valLastPara, txt)
if other_ref:
AfficherResultat(
DictRef, nomLastPara, ref, legende,
crit, res, valLastPara, txt, label=False)
elif ier == 120:
txt.append(' OK PARAMETRE EN DOUBLE')
elif ier == 130:
txt.append(' OK PARAMETRE NON CORRECT')
elif ier == 150:
txt.append(' OK TYPE DE FONCTION NON TRAITE')
elif ier == 160:
txt.append(' OK PAS ASSEZ DE PARAMETRES')
else:
if ier != 0:
txt.append('NOOK PB INTERPOLATION. VOIR MESSAGE CI-DESSUS')
else:
AfficherResultat(
curDict, nomLastPara, 'NON_REGRESSION', legende,
crit, res, valLastPara, txt)
if other_ref:
AfficherResultat(DictRef, nomLastPara, ref, legende,
crit, res, valLastPara, txt, label=False)
txt.append(' ')
if ATTRIBUT != None:
first_affiche_ligne1 = True
resu_test_attr = ' OK '
# Boucle sur le mot-cle ATTRIBUT
for attr in ATTRIBUT:
dres = attr.cree_dict_valeurs(attr.mc_liste)
# Lecture des mots-cles simples
ref = dres['REFERENCE']
ver = None
fonction = dres['FONCTION']
fctProl = fonction.sdj.PROL.get_stripped()
typeFct = fctProl[0]
para = dres['PARA']
fctPara = fonction.sdj.PARA.get()
pos = 0
# Cas particulier d'une nappe qui a 2 dimensions
if typeFct == 'NAPPE':
if para != None:
# Recherche de la fonction liee a para
precPara = dres['PREC_PARA']
critPara = dres['CRIT_PARA']
LOK = 0
compteur = 0
for curPara in fctPara:
if critPara[0:4] == 'RELA':
LOK = (
abs(para - curPara) <= precPara * abs(curPara))
else:
LOK = (abs(para - curPara) <= precPara)
if LOK:
pos = compteur
break
compteur = compteur + 1
if not LOK:
UTMESS('A', 'PREPOST3_95')
else:
para = fctPara[0]
# Lecture des parametres de reference
nomAttr = dres['ATTR']
valAttrRef = dres['ATTR_REFE']
# Recherche de la valeur de l'attribut dans le .PROL
nompu = ''
testOk = 'NOOK'
if nomAttr == 'INTERPOL_FONC':
nompu = fctProl[7 + 2 * (pos)] + ' '
elif nomAttr == 'INTERPOL':
nompu = fctProl[1] + ' '
elif nomAttr == 'NOM_PARA_FONC':
nompu = fctProl[6]
elif nomAttr == 'NOM_PARA':
nompu = fctProl[2]
elif nomAttr == 'NOM_RESU':
nompu = fctProl[3]
elif nomAttr == 'PROL_GAUCHE_FONC':
prolFonc = fctProl[7 + 2 * (pos) + 1]
nompu = prolFonc[0:1]
if nompu == 'E':
nompu = 'EXCLU'
elif nompu == 'C':
nompu = 'CONSTANT'
elif nompu == 'L':
nompu = 'LINEAIRE'
elif nomAttr == 'PROL_DROITE_FONC':
prolFonc = fctProl[7 + 2 * (pos) + 1]
nompu = prolFonc[1:2]
if nompu == 'E':
nompu = 'EXCLU'
elif nompu == 'C':
nompu = 'CONSTANT'
elif nompu == 'L':
nompu = 'LINEAIRE'
elif nomAttr == 'PROL_GAUCHE':
prolFonc = fctProl[4]
nompu = prolFonc[0:1]
if nompu == 'E':
nompu = 'EXCLU'
elif nompu == 'C':
nompu = 'CONSTANT'
elif nompu == 'L':
nompu = 'LINEAIRE'
elif nomAttr == 'PROL_DROITE':
prolFonc = fctProl[4]
nompu = prolFonc[1:2]
if nompu == 'E':
nompu = 'EXCLU'
elif nompu == 'C':
nompu = 'CONSTANT'
elif nompu == 'L':
nompu = 'LINEAIRE'
# Test de la valeur
if (nompu == valAttrRef):
testOk = ' OK '
if TEST_NOOK == 'OUI':
if testOk == ' OK ':
testOk = 'NOOK'
else:
testOk = ' OK '
if testOk == 'NOOK':
resu_test_attr = 'NOOK'
# Construction de l'affichage
nomFct = fonction.get_name()
# ligne 1 (affichée qu'à la première occurrence)
current = {}
if first_affiche_ligne1:
first_affiche_ligne1 = False
if typeFct == 'NAPPE':
nb_espace = 16 - len('NAPPE')
espace = nb_espace * ' '
current['nom'] = 'NAPPE' + espace
else:
nb_espace = 16 - len('FONCTION')
espace = nb_espace * ' '
current['nom'] = 'FONCTION' + espace
nb_espace = 16 - len(list_attr[0])
espace = nb_espace * ' '
current['nom_attr'] = list_attr[0] + espace
if typeFct == 'NAPPE':
nb_espace = 16 - len(list_attr[1])
espace = nb_espace * ' '
current['nom_para'] = list_attr[1] + espace
nb_espace = 16 - len(list_attr[2])
espace = nb_espace * ' '
current['vale'] = list_attr[2] + espace
if typeFct == 'NAPPE':
txt.append(ligne_att_1 % current)
else:
txt.append(ligne_att_2 % current)
# ligne 2
current = {}
nb_espace = 16 - len(nomFct)
espace = nb_espace * ' '
current['nom'] = nomFct + espace
nb_espace = 16 - len(nomAttr)
espace = nb_espace * ' '
current['nom_attr'] = nomAttr + espace
if typeFct == 'NAPPE':
nb_espace = 16 - len(str(para))
espace = nb_espace * ' '
current['nom_para'] = str(para) + espace
nb_espace = 16 - len(nompu)
espace = nb_espace * ' '
current['vale'] = nompu + espace
if typeFct == 'NAPPE':
txt.append(ligne_att_11 % current)
else:
txt.append(ligne_att_22 % current)
current = {}
current['testOk'] = resu_test_attr
txt.append(ligne_att_3 % current)
# On affiche txt dans le fichier RESULTAT
aster.affiche('RESULTAT', os.linesep.join(txt))
return ier
def simu_point_mat_ops(self, MATER, INCREMENT, SIGM_IMPOSE, EPSI_IMPOSE,
SIGM_INIT, EPSI_INIT, VARI_INIT, NEWTON, CONVERGENCE,
MASSIF, ANGLE, COMPORTEMENT, INFO, ARCHIVAGE, SUPPORT,
**args):
"""Simulation de la reponse d'un point materiel"""
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
import math
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
AFFE_CARA_ELEM = self.get_cmd('AFFE_CARA_ELEM')
AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA')
AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
CALC_TABLE = self.get_cmd('CALC_TABLE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_RESU = self.get_cmd('CREA_RESU')
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE')
MODI_REPERE = self.get_cmd('MODI_REPERE')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
IMPR_RESU = self.get_cmd('IMPR_RESU')
from Contrib.calc_point_mat import CALC_POINT_MAT
from code_aster.Cata.Syntax import _F
from Utilitai.UniteAster import UniteAster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Noyau.N_types import is_sequence
# alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes
# a tort
MasquerAlarme('COMPOR4_70')
# -- Tests de cohérence
__fonczero = DEFI_FONCTION(NOM_PARA='INST',
VALE=(0, 0, 10, 0),
PROL_DROITE='CONSTANT',
PROL_GAUCHE='CONSTANT')
EPS = {}
SIG = {}
itetra = 0
CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ']
CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
if COMPORTEMENT:
lcomp = COMPORTEMENT.List_F()[0]
if SUPPORT != None:
if SUPPORT == 'ELEMENT':
itetra = 1
if itetra == 0:
if lcomp['DEFORMATION'] != 'PETIT':
if args.has_key('GRAD_IMPOSE'):
if args['GRAD_IMPOSE'] != None:
if lcomp['DEFORMATION'] != 'SIMO_MIEHE':
UTMESS('F', 'COMPOR2_22', valk=lcomp['DEFORMATION'])
itetra = 0
else:
itetra = 1
UTMESS('A', 'COMPOR2_1', valk=lcomp['DEFORMATION'])
#===============================================================
# cas ou il n'y a pas d'élement fini : appel à CALC_POINT_MAT
#===============================================================
if itetra == 0:
isig = 0
ieps = 0
igrd = 0
ic1c2 = 0
if SIGM_IMPOSE:
SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
isig = 1
if EPSI_IMPOSE:
EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
ieps = 1
if args.has_key('GRAD_IMPOSE'):
if args['GRAD_IMPOSE'] != None:
FIJ = args['GRAD_IMPOSE'][0].cree_dict_valeurs(
args['GRAD_IMPOSE'][0].mc_liste)
igrd = 1
if args.has_key('MATR_C1'):
if args['MATR_C1'] != None:
ic1c2 = 1
if args.has_key('MATR_C2'):
if args['MATR_C2'] != None:
ic1c2 = 1
motscles = {}
if igrd:
for i in FIJ.keys():
motscles[i] = FIJ[i]
elif ic1c2:
if args.has_key('MATR_C1'):
if args['MATR_C1'] != None:
motscles['MATR_C1'] = args['MATR_C1'].List_F()
if args.has_key('MATR_C2'):
if args['MATR_C2'] != None:
motscles['MATR_C2'] = args['MATR_C2'].List_F()
if args.has_key('VECT_IMPO'):
if args['VECT_IMPO'] != None:
motscles['VECT_IMPO'] = args['VECT_IMPO'].List_F()
else:
nbsig = 6
for index in range(nbsig):
iks = CMP_SIG[index]
ike = CMP_EPS[index]
inds = 0
inde = 0
if ieps:
if EPS[ike] != None:
inde = 1
if isig:
if SIG[iks] != None:
inds = 1
if inde * inds != 0:
UTMESS('F', 'COMPOR2_2', valk=iks)
if inde == 1:
motscles[ike] = EPS[ike]
elif inds == 1:
motscles[iks] = SIG[iks]
else:
motscles[iks] = __fonczero
# Etat initial
etatinit = 0
if SIGM_INIT != None:
motscles['SIGM_INIT'] = SIGM_INIT.List_F()
if EPSI_INIT != None:
motscles['EPSI_INIT'] = EPSI_INIT.List_F()
if VARI_INIT != None:
motscles['VARI_INIT'] = VARI_INIT.List_F()
if NEWTON != None:
motscles['NEWTON'] = NEWTON.List_F()
if CONVERGENCE != None:
motscles['CONVERGENCE'] = CONVERGENCE.List_F()
if MASSIF != None:
motscles['MASSIF'] = MASSIF.List_F()
if COMPORTEMENT:
motscles['COMPORTEMENT'] = COMPORTEMENT.List_F()
# -- Deroulement du calcul
motscles['INCREMENT'] = INCREMENT.List_F()
if args.has_key('FORMAT_TABLE'):
if args['FORMAT_TABLE'] != None:
motscles['FORMAT_TABLE'] = args['FORMAT_TABLE']
if args.has_key('OPER_TANGENT'):
if args['OPER_TANGENT'] != None:
motscles['OPER_TANGENT'] = args['OPER_TANGENT']
if args.has_key('NB_VARI_TABLE'):
if args['NB_VARI_TABLE'] != None:
motscles['NB_VARI_TABLE'] = args['NB_VARI_TABLE']
if ARCHIVAGE:
motscles['ARCHIVAGE'] = ARCHIVAGE.List_F()
# variables de commande
if args.has_key('AFFE_VARC'):
if args['AFFE_VARC'] != None:
lvarc = args['AFFE_VARC'].List_F()
nbvarc = len(lvarc)
lmotcle = []
for ivarc in range(nbvarc):
dico = {}
if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
dico['NOM_VARC'] = 'ALPHPUR'
dico['VALE_FONC'] = lvarc[ivarc]['V1']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'ALPHBETA'
dico['VALE_FONC'] = lvarc[ivarc]['V2']
lmotcle.append(dico)
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
dico['NOM_VARC'] = 'PFERRITE'
dico['VALE_FONC'] = lvarc[ivarc]['V1']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PPERLITE'
dico['VALE_FONC'] = lvarc[ivarc]['V2']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PBAINITE'
dico['VALE_FONC'] = lvarc[ivarc]['V3']
lmotcle.append(dico)
dico = {}
dico['NOM_VARC'] = 'PMARTENS'
dico['VALE_FONC'] = lvarc[ivarc]['V4']
lmotcle.append(dico)
else:
dico['NOM_VARC'] = lvarc[ivarc]['NOM_VARC']
dico['VALE_FONC'] = lvarc[ivarc]['VALE_FONC']
if str(lvarc[ivarc]['NOM_VARC']) == 'TEMP' or str(
lvarc[ivarc]['NOM_VARC']) == 'SECH':
dico['VALE_REF'] = lvarc[ivarc]['VALE_REF']
lmotcle.append(dico)
motscles['AFFE_VARC'] = lmotcle
if lcomp['RELATION'] == 'META_LEMA_ANI':
UTMESS('F', 'COMPOR2_91', valk=lcomp['RELATION'])
self.DeclareOut('REPONSE', self.sd)
Titre = 'CALC_POINT_MAT'
if ARCHIVAGE != None:
# on ne prend en compte que ARCHIVAGE / LIST_INST
if ARCHIVAGE['LIST_INST'] != None:
__REP1 = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
lr8 = ARCHIVAGE['LIST_INST']
lr = lr8.Valeurs()
REPONSE = CALC_TABLE(
TABLE=__REP1,
TITRE=Titre,
ACTION=_F(OPERATION='FILTRE',
NOM_PARA='INST',
VALE=lr,
PRECISION=ARCHIVAGE['PRECISION']),
)
else:
REPONSE = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
else:
REPONSE = CALC_POINT_MAT(INFO=INFO,
MATER=MATER,
ANGLE=ANGLE,
**motscles)
#===============================================================
# cas ou on fait le calcul sur un TETRA4 A UN SEUL POINT DE GAUSS
#===============================================================
elif itetra == 1:
EPS = {}
SIG = {}
MODELISATION = "3D"
if args.has_key('MODELISATION'):
if args['MODELISATION'] != None:
MODELISATION = args['MODELISATION']
if MODELISATION == "3D":
nbsig = 6
CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ']
CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ']
else:
nbsig = 3
CMP_EPS = ['EPXX', 'EPYY', 'EPXY']
CMP_SIG = ['SIXX', 'SIYY', 'SIXY']
if SIGM_IMPOSE:
SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
for i in SIG.keys():
if SIG[i] == None:
SIG[i] = __fonczero
else:
for i in range(nbsig):
SIG[CMP_SIG[i]] = __fonczero
if EPSI_IMPOSE:
EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
else:
for i in range(nbsig):
EPS[CMP_EPS[i]] = None
for index in range(nbsig):
iks = CMP_SIG[index]
ike = CMP_EPS[index]
if EPS[ike] != None and SIG[iks] != __fonczero:
UTMESS('F', 'COMPOR2_3', valk=str(iks) + ' ' + str(ike))
# -- Definition du maillage
if MODELISATION == "3D":
texte_ma = """
COOR_3D
P0 0.0 0.0 0.0
P1 1.0 0.0 0.0
P2 0.0 1.0 0.0
P3 0.0 0.0 1.0
FINSF
TRIA3
F1 P0 P3 P2
F2 P0 P1 P3
F3 P0 P2 P1
F4 P1 P2 P3
FINSF
TETRA4
VOLUME = P0 P1 P2 P3
FINSF
GROUP_MA
TOUT VOLUME
FINSF
GROUP_NO
TOUT P1 P2 P0 P3
FINSF
FIN
"""
else:
texte_ma = """
COOR_2D
P0 0.0 0.0
P1 1.0 0.0
P2 0.0 1.0
FINSF
SEG2
S1 P2 P0
S2 P0 P1
S3 P1 P2
FINSF
TRIA3
VOLUME = P0 P1 P2
FINSF
GROUP_MA
TOUT VOLUME
FINSF
GROUP_NO
TOUT P1 P2 P0
FINSF
FIN
"""
fi_mail = open('simu.mail', 'w')
fi_mail.write(texte_ma)
fi_mail.close()
UL = UniteAster()
umail = UL.Libre(action='ASSOCIER', nom='simu.mail')
__MA = LIRE_MAILLAGE(FORMAT='ASTER', UNITE=umail)
UL.EtatInit()
if MODELISATION == "3D":
__MO = AFFE_MODELE(MAILLAGE=__MA,
AFFE=_F(
MAILLE=('VOLUME', 'F1', 'F2', 'F3', 'F4'),
PHENOMENE='MECANIQUE',
MODELISATION='3D',
))
# ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
# imposées.
if ANGLE != 0.:
__MA = MODI_MAILLAGE(
reuse=__MA,
MAILLAGE=__MA,
ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE),
)
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__C_RIGIDE = AFFE_CHAR_MECA(
MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0., DZ=0.),
LIAISON_DDL=(
_F(NOEUD=('P1', 'P1', 'P2', 'P2'),
DDL=('DX', 'DY', 'DX', 'DY'),
COEF_MULT=(s, -c, c, s),
COEF_IMPO=0),
_F(NOEUD=('P1', 'P3', 'P3'),
DDL=('DZ', 'DX', 'DY'),
COEF_MULT=(-1.0, c, s),
COEF_IMPO=0),
_F(NOEUD=('P2', 'P3', 'P3'),
DDL=('DZ', 'DX', 'DY'),
COEF_MULT=(-1.0, -s, c),
COEF_IMPO=0),
),
)
else:
# -- Mouvement de corps rigide
__C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0',
DX=0,
DY=0,
DZ=0),
LIAISON_DDL=(
_F(NOEUD=('P2', 'P1'),
DDL=('DX', 'DY'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
_F(NOEUD=('P3', 'P1'),
DDL=('DX', 'DZ'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
_F(NOEUD=('P3', 'P2'),
DDL=('DY', 'DZ'),
COEF_MULT=(1, -1),
COEF_IMPO=0),
))
else:
# MODELISATION 2D
__MO = AFFE_MODELE(MAILLAGE=__MA,
AFFE=_F(MAILLE=('VOLUME', 'S1', 'S2', 'S3'),
PHENOMENE='MECANIQUE',
MODELISATION=MODELISATION))
# ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
# imposées.
if ANGLE != 0.:
__MA = MODI_MAILLAGE(
reuse=__MA,
MAILLAGE=__MA,
ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE),
)
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__C_RIGIDE = AFFE_CHAR_MECA(
MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0.),
LIAISON_DDL=(_F(NOEUD=('P1', 'P1', 'P2', 'P2'),
DDL=('DX', 'DY', 'DX', 'DY'),
COEF_MULT=(s, -c, c, s),
COEF_IMPO=0), ),
)
else:
__C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO,
DDL_IMPO=_F(NOEUD='P0', DX=0,
DY=0),
LIAISON_DDL=(_F(NOEUD=('P2', 'P1'),
DDL=('DX', 'DY'),
COEF_MULT=(1, -1),
COEF_IMPO=0), ))
# --MASSIF : orientation du materiau (monocristal, orthotropie)
if MASSIF:
ANGMAS = MASSIF[0].cree_dict_valeurs(MASSIF[0].mc_liste)
if ANGMAS["ANGL_REP"] == None:
__CARA = AFFE_CARA_ELEM(
MODELE=__MO,
MASSIF=_F(MAILLE='VOLUME',
ANGL_EULER=ANGMAS["ANGL_EULER"]),
)
else:
__CARA = AFFE_CARA_ELEM(
MODELE=__MO,
MASSIF=_F(MAILLE='VOLUME', ANGL_REP=ANGMAS["ANGL_REP"]),
)
# -- Chargement en deformation
__E = [None] * nbsig
__E[0] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DX=1,
ANGL_NAUT=ANGLE))
__E[1] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P2',
DY=1,
ANGL_NAUT=ANGLE))
if MODELISATION == "3D":
__E[2] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P3',
DZ=1,
ANGL_NAUT=ANGLE))
__E[3] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DY=1,
ANGL_NAUT=ANGLE))
__E[4] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1',
DZ=1,
ANGL_NAUT=ANGLE))
__E[5] = AFFE_CHAR_MECA(MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P2',
DZ=1,
ANGL_NAUT=ANGLE))
else:
c = math.cos(ANGLE * math.pi / 180.)
s = math.sin(ANGLE * math.pi / 180.)
__E[2] = AFFE_CHAR_MECA(
MODELE=__MO,
LIAISON_OBLIQUE=_F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE),
)
# -- Chargement en contrainte
__S = [None] * nbsig
if MODELISATION == "3D":
r33 = 3**-0.5
__S[0] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FX=-1),
_F(MAILLE='F4', FX=r33),
))
__S[1] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F2', FY=-1),
_F(MAILLE='F4', FY=r33),
))
__S[2] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F3', FZ=-1),
_F(MAILLE='F4', FZ=r33),
))
__S[3] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FY=-1),
_F(MAILLE='F2', FX=-1),
_F(MAILLE='F4', FX=r33, FY=r33),
))
__S[4] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F1', FZ=-1),
_F(MAILLE='F3', FX=-1),
_F(MAILLE='F4', FX=r33, FZ=r33),
))
__S[5] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_FACE=(
_F(MAILLE='F2', FZ=-1),
_F(MAILLE='F3', FY=-1),
_F(MAILLE='F4', FY=r33, FZ=r33),
))
else:
r22 = 2**-0.5
__S[0] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S1', FX=-1),
_F(MAILLE='S3', FX=r22),
))
__S[1] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S2', FY=-1),
_F(MAILLE='S3', FY=r22),
))
__S[2] = AFFE_CHAR_MECA(MODELE=__MO,
FORCE_CONTOUR=(
_F(MAILLE='S1', FY=-1),
_F(MAILLE='S2', FX=-1),
_F(MAILLE='S3', FX=r22, FY=r22),
))
# -- Construction de la charge
l_char = [_F(CHARGE=__C_RIGIDE)]
for i in xrange(nbsig):
ike = CMP_EPS[i]
if EPS[ike]:
l_char.append(_F(CHARGE=__E[i], FONC_MULT=EPS[ike]))
for i in xrange(nbsig):
iks = CMP_SIG[i]
l_char.append(_F(CHARGE=__S[i], FONC_MULT=SIG[iks]))
# variables de commande
mcvarc = []
if args.has_key('AFFE_VARC'):
if args['AFFE_VARC'] != None:
lvarc = args['AFFE_VARC'].List_F()
nbvarc = len(lvarc)
for ivarc in range(nbvarc):
dico = {}
if (str(lvarc[ivarc]['NOM_VARC']) == 'SECH'):
typech = 'NOEU_TEMP_R'
labsc = lvarc[ivarc]['VALE_FONC'].Absc()
lordo = lvarc[ivarc]['VALE_FONC'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHV[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
MAILLAGE=__MA,
AFFE=_F(
MAILLE='VOLUME',
NOM_CMP='TEMP',
VALE=lordo[it],
),
),
dicoch = {}
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM='TEMP',
AFFE=l_affe_cham)
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
typech = 'ELNO_NEUT_R'
labsc = lvarc[ivarc]['V1'].Absc()
lordo1 = lvarc[ivarc]['V1'].Ordo()
lordo2 = lvarc[ivarc]['V2'].Ordo()
lordo3 = lvarc[ivarc]['V3'].Ordo()
lordo4 = lvarc[ivarc]['V4'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
__CHN = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHN[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
PROL_ZERO='OUI',
MODELE=__MO,
AFFE=(
_F(
MAILLE='VOLUME',
NOM_CMP='X1',
VALE=lordo1[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X2',
VALE=lordo2[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X3',
VALE=lordo3[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X4',
VALE=lordo4[it],
),
),
),
dicoch = {}
__CHV[it] = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELNO_VARI_R',
MODELE=__MO,
PROL_ZERO='OUI',
ASSE=(
_F(CHAM_GD=__CHN[it],
NOM_CMP='X1',
NOM_CMP_RESU='V1',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X2',
NOM_CMP_RESU='V2',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X3',
NOM_CMP_RESU='V3',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X4',
NOM_CMP_RESU='V4',
GROUP_MA='TOUT'),
))
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_THER',
NOM_CHAM=str('META_ELNO'),
AFFE=l_affe_cham)
IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV))
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
typech = 'ELNO_NEUT_R'
labsc = lvarc[ivarc]['V1'].Absc()
lordo1 = lvarc[ivarc]['V1'].Ordo()
lordo2 = lvarc[ivarc]['V2'].Ordo()
lordo3 = lvarc[ivarc]['V3'].Ordo()
lordo4 = lvarc[ivarc]['V4'].Ordo()
lordo5 = lvarc[ivarc]['V5'].Ordo()
lordo6 = lvarc[ivarc]['V6'].Ordo()
lordo7 = lvarc[ivarc]['V7'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
__CHN = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHN[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
PROL_ZERO='OUI',
MODELE=__MO,
AFFE=(
_F(
MAILLE='VOLUME',
NOM_CMP='X1',
VALE=lordo1[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X2',
VALE=lordo2[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X3',
VALE=lordo3[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X4',
VALE=lordo4[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X5',
VALE=lordo5[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X6',
VALE=lordo6[it],
),
_F(
MAILLE='VOLUME',
NOM_CMP='X7',
VALE=lordo7[it],
),
),
),
dicoch = {}
__CHV[it] = CREA_CHAMP(OPERATION='ASSE',
TYPE_CHAM='ELNO_VARI_R',
MODELE=__MO,
PROL_ZERO='OUI',
ASSE=(
_F(CHAM_GD=__CHN[it],
NOM_CMP='X1',
NOM_CMP_RESU='V1',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X2',
NOM_CMP_RESU='V2',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X3',
NOM_CMP_RESU='V3',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X4',
NOM_CMP_RESU='V4',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X5',
NOM_CMP_RESU='V5',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X6',
NOM_CMP_RESU='V6',
GROUP_MA='TOUT'),
_F(CHAM_GD=__CHN[it],
NOM_CMP='X7',
NOM_CMP_RESU='V7',
GROUP_MA='TOUT'),
))
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_THER',
NOM_CHAM=str('META_ELNO'),
AFFE=l_affe_cham)
IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV))
else:
typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_R'
labsc = lvarc[ivarc]['VALE_FONC'].Absc()
lordo = lvarc[ivarc]['VALE_FONC'].Ordo()
l_affe_cham = []
__CHV = [None] * len(labsc)
for it, time in enumerate(labsc):
__CHV[it] = CREA_CHAMP(
TYPE_CHAM=typech,
OPERATION='AFFE',
MAILLAGE=__MA,
AFFE=_F(
MAILLE='VOLUME',
NOM_CMP=lvarc[ivarc]['NOM_VARC'],
VALE=lordo[it],
),
),
dicoch = {}
dicoch["CHAM_GD"] = __CHV[it]
dicoch["INST"] = time
l_affe_cham.append(dicoch)
__EVOV = CREA_RESU(OPERATION='AFFE',
TYPE_RESU='EVOL_VARC',
NOM_CHAM=str(
lvarc[ivarc]['NOM_VARC']),
AFFE=l_affe_cham)
dico["MAILLE"] = 'VOLUME'
dico["EVOL"] = __EVOV
if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'):
dico["NOM_VARC"] = "M_ZIRC"
elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'):
dico["NOM_VARC"] = "M_ACIER"
else:
dico["NOM_VARC"] = lvarc[ivarc]['NOM_VARC']
if lvarc[ivarc]['VALE_REF'] != None:
dico["VALE_REF"] = lvarc[ivarc]['VALE_REF']
mcvarc.append(dico)
# -- Materiau et modele
if len(mcvarc) > 0:
__CHMAT = AFFE_MATERIAU(
MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME', MATER=MATER),
AFFE_VARC=mcvarc,
)
else:
__CHMAT = AFFE_MATERIAU(MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME', MATER=MATER))
# Etat initial
SIGINI = {}
VARINI = {}
LCSIG = []
LVSIG = []
init_dico = {}
etatinit = 0
# --contraintes initiales
if SIGM_INIT:
etatinit = 1
SIGINI = SIGM_INIT[0].cree_dict_valeurs(SIGM_INIT[0].mc_liste)
for i in SIGINI.keys():
if SIGINI[i] != None:
LCSIG.append(i)
LVSIG.append(SIGINI[i])
__SIG_INIT = CREA_CHAMP(MAILLAGE=__MA,
OPERATION='AFFE',
TYPE_CHAM='CART_SIEF_R',
AFFE=_F(
TOUT='OUI',
NOM_CMP=LCSIG,
VALE=LVSIG,
))
init_dico['SIGM'] = __SIG_INIT
# --variables internes initiales
if VARI_INIT:
etatinit = 1
lnomneu = []
lnomvar = []
VARINI = VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste)
if (not is_sequence(VARINI['VALE'])):
VARINI['VALE'] = [
VARINI['VALE'],
]
nbvari = len(VARINI['VALE'])
for i in range(nbvari):
lnomneu.append('X' + str(i + 1))
lnomvar.append('V' + str(i + 1))
__NEUT = CREA_CHAMP(OPERATION='AFFE',
TYPE_CHAM='CART_N480_R',
MAILLAGE=__MA,
AFFE=_F(MAILLE='VOLUME',
NOM_CMP=lnomneu,
VALE=VARINI['VALE']))
__VAR_INIT = CREA_CHAMP(MODELE=__MO,
OPERATION='ASSE',
TYPE_CHAM='ELGA_VARI_R',
ASSE=_F(TOUT='OUI',
CHAM_GD=__NEUT,
NOM_CMP=lnomneu,
NOM_CMP_RESU=lnomvar))
init_dico['VARI'] = __VAR_INIT
# --deformations initiales
if EPSI_INIT:
etatinit = 1
EPSINI = {}
LCDEPL = []
LNDEPL = []
LVDEPL = []
LIST_AFFE = []
mon_dico = {}
mon_dico["NOEUD"] = 'P0'
mon_dico["NOM_CMP"] = ("DX", "DY", "DZ")
mon_dico["VALE"] = (0., 0., 0.)
LIST_AFFE.append(mon_dico)
EPSINI = EPSI_INIT[0].cree_dict_valeurs(EPSI_INIT[0].mc_liste)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXX']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPYY']
LIST_AFFE.append(mon_dico)
if MODELISATION == "3D":
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPZZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P1'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPXZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DZ'
mon_dico["VALE"] = EPSINI['EPYZ']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P3'
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPYZ']
LIST_AFFE.append(mon_dico)
else:
mon_dico = {}
mon_dico["NOEUD"] = 'P1',
mon_dico["NOM_CMP"] = 'DY'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
mon_dico = {}
mon_dico["NOEUD"] = 'P2'
mon_dico["NOM_CMP"] = 'DX'
mon_dico["VALE"] = EPSINI['EPXY']
LIST_AFFE.append(mon_dico)
__DEP_INI = CREA_CHAMP(MAILLAGE=__MA,
OPERATION='AFFE',
TYPE_CHAM='NOEU_DEPL_R',
AFFE=LIST_AFFE)
init_dico['DEPL'] = __DEP_INI
# -- Deroulement du calcul
motscles = {}
if COMPORTEMENT:
motscles['COMPORTEMENT'] = COMPORTEMENT.List_F()
if lcomp['RELATION'] == 'META_LEMA_ANI':
UTMESS('A', 'COMPOR2_92', valk=lcomp['RELATION'])
motscles['CONVERGENCE'] = CONVERGENCE.List_F()
motscles['NEWTON'] = NEWTON.List_F()
if args.has_key('RECH_LINEAIRE'):
if args['RECH_LINEAIRE'] != None:
motscles['RECH_LINEAIRE'] = args['RECH_LINEAIRE'].List_F()
motscles['INCREMENT'] = INCREMENT.List_F()
if ARCHIVAGE:
motscles['ARCHIVAGE'] = ARCHIVAGE.List_F()
if args.has_key('SUIVI_DDL'):
if args['SUIVI_DDL'] != None:
motscles['SUIVI_DDL'] = args['SUIVI_DDL'].List_F()
if etatinit == 1:
if MASSIF:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
CARA_ELEM=__CARA,
MODELE=__MO,
CHAM_MATER=__CHMAT,
ETAT_INIT=init_dico,
EXCIT=l_char,
**motscles)
else:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CHAM_MATER=__CHMAT,
ETAT_INIT=init_dico,
EXCIT=l_char,
**motscles)
else:
if MASSIF:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CARA_ELEM=__CARA,
CHAM_MATER=__CHMAT,
EXCIT=l_char,
**motscles)
else:
__EVOL1 = STAT_NON_LINE(INFO=INFO,
MODELE=__MO,
CHAM_MATER=__CHMAT,
EXCIT=l_char,
**motscles)
if lcomp['DEFORMATION'] != 'PETIT':
nomepsi = 'EPSG_ELNO'
else:
nomepsi = 'EPSI_ELNO'
__EVOL1 = CALC_CHAMP(
reuse=__EVOL1,
RESULTAT=__EVOL1,
CONTRAINTE='SIGM_ELNO',
DEFORMATION=nomepsi,
VARI_INTERNE='VARI_ELNO',
)
if MODELISATION == "3D":
angles = (ANGLE, 0, 0)
__EVOL = MODI_REPERE(
RESULTAT=__EVOL1,
MODI_CHAM=(
_F(
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY', 'DZ'),
TYPE_CHAM='VECT_3D',
),
_F(
NOM_CHAM='SIGM_ELNO',
NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ',
'SIYZ'),
TYPE_CHAM='TENS_3D',
),
_F(
NOM_CHAM=nomepsi,
NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ',
'EPYZ'),
TYPE_CHAM='TENS_3D',
),
),
REPERE='UTILISATEUR',
AFFE=_F(ANGL_NAUT=angles),
)
else:
angles = ANGLE
__EVOL = MODI_REPERE(
RESULTAT=__EVOL1,
MODI_CHAM=(
_F(
NOM_CHAM='DEPL',
NOM_CMP=('DX', 'DY'),
TYPE_CHAM='VECT_2D',
),
_F(
NOM_CHAM='SIGM_ELNO',
NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY'),
TYPE_CHAM='TENS_2D',
),
_F(
NOM_CHAM=nomepsi,
NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY'),
TYPE_CHAM='TENS_2D',
),
),
REPERE='UTILISATEUR',
AFFE=_F(ANGL_NAUT=angles),
)
# -- Recuperation des courbes
__REP_VARI = POST_RELEVE_T(ACTION=(_F(INTITULE='VARI_INT',
RESULTAT=__EVOL1,
NOM_CHAM='VARI_ELNO',
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_EPSI = POST_RELEVE_T(ACTION=(_F(INTITULE='EPSILON',
RESULTAT=__EVOL,
NOM_CHAM=nomepsi,
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_SIGM = POST_RELEVE_T(ACTION=(_F(INTITULE='SIGMA',
RESULTAT=__EVOL,
NOM_CHAM='SIGM_ELNO',
TOUT_CMP='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_INV = POST_RELEVE_T(ACTION=(_F(INTITULE='INV',
RESULTAT=__EVOL,
NOM_CHAM='SIGM_ELNO',
INVARIANT='OUI',
OPERATION='EXTRACTION',
NOEUD='P0'), ))
__REP_INV = CALC_TABLE(TABLE=__REP_INV,
reuse=__REP_INV,
ACTION=_F(
OPERATION='EXTR',
NOM_PARA=('INST', 'TRACE', 'VMIS'),
))
self.DeclareOut('REPONSE', self.sd)
REPONSE = CALC_TABLE(TABLE=__REP_EPSI,
TITRE='TABLE ',
ACTION=(
_F(
OPERATION='COMB',
TABLE=__REP_SIGM,
NOM_PARA=('INST'),
),
_F(
OPERATION='COMB',
TABLE=__REP_INV,
NOM_PARA=('INST'),
),
_F(
OPERATION='COMB',
TABLE=__REP_VARI,
NOM_PARA=('INST'),
),
))
RetablirAlarme('COMPOR4_70')
return ier
