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'.
"""
def Nonefy(l1, l2):
if l2 == 0:
return None
else:
return l1
if not self.accessible():
raise AsException("Erreur dans table.EXTR_TABLE en PAR_LOT='OUI'")
from Utilitai.Table import Table
# titre
titr = self.TITRE()
# récupération des paramètres
#v_tblp = aster.getvectjev('%-19s.TBLP' % self.get_name())
v_tblp = self.sdj.TBLP.get()
if v_tblp == None:
# retourne une table vide
return Table(titr=titr, nom=self.nom)
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
if para is not None:
if type(para) not in (list, tuple):
para = [
para,
]
para = [p.strip() for p in para]
restr = []
for ip in lparam:
if ip[0].strip() in para:
restr.append(ip)
lparam = restr
dval = {}
# liste des paramètres et des types
lpar = []
ltyp = []
for i in lparam:
value = list(aster.getvectjev(i[2]))
exist = aster.getvectjev(i[3])
dval[i[0].strip()] = map(Nonefy, value, exist)
lpar.append(i[0].strip())
ltyp.append(i[1].strip())
n = len(dval[lpar[0]])
# contenu : liste de dict
lisdic = []
for i in range(n):
d = {}
for p in lpar:
d[p] = dval[p][i]
lisdic.append(d)
return Table(lisdic, lpar, ltyp, titr, self.nom)
def affiche(self, l_x, ll_y, couleur=None, titre="Courbes", l_legende=None,
legende_x="Abscisses", legende_y="Ordonnées",
unite_x="ua", unite_y="ua"):
if l_legende == None:
l_legende = [' toto '] * len(ll_y)
# Creation d'une table pour ranger les fonctions
titre1 = 'TITLE:' + titre
legende_x = legende_x.strip()
legende_x = legende_x.replace(' ', '')
legende_y = legende_y.strip()
legende_y = legende_y.replace(' ', '')
# Liste des noms des courbes, et titre des axes
l_colonnes = [legende_x]
titre2 = 'COLUMN_TITLES:' + legende_x + ' | '
for legende in l_legende:
legende = legende.strip()
legende = legende.replace(' ', '')
l_colonnes.append(legende)
titre2 = titre2 + legende + ' | '
# unite des axes
unite_x = unite_x.strip()
unite_x = unite_x.replace(' ', '')
unite_y = unite_y.strip()
unite_y = unite_y.replace(' ', '')
titre3 = 'COLUMN_UNITS:' + unite_x + ' ' + unite_y
TITRE = titre1 + '\n' + titre2 + '\n' + titre3
# Liste des noms des courbes
dico = []
for ind_absc in range(len(l_x)):
dico.append({legende_x: l_x[ind_absc]})
for ind_courb in range(len(ll_y)):
dico[ind_absc].update(
{l_colonnes[ind_courb + 1]: ll_y[ind_courb][ind_absc]})
table = Table(titr=TITRE)
table.extend(dico)
table = table[l_colonnes]
self.defi_fichier()
datafile = 'fort.%s' % self.unite_logique
table.Impr(FICHIER=datafile, FORMAT='TABLEAU', dform={'ccpara': '#'})
# recuperation des noms des etudes Salome ouvertes
if not self.study_name:
self.mess.disp_mess(
u"Sélectonner l'étude Salomé dans laquelle afficher les courbes")
return
self.Show('./fort.%s' % self.unite_logique)
self.libere_fichier()
def test01_ext(self):
"""test creation of the .ext file"""
from Utilitai.Table import Table
if not osp.isfile(self.fcsol):
return
reader = MissCsolReader(3, 201)
lfreq, values = reader.read(self.fcsol)
self.tab = tab = Table()
tab['FREQ'] = lfreq
for ipc, respc in enumerate(values):
for iddl, comp in enumerate(('X', 'Y', 'Z')):
lab = 'PC_{}_{}_REEL'.format(ipc + 1, comp)
tab[lab] = respc.comp[iddl][0]
lab = 'PC_{}_{}_IMAG'.format(ipc + 1, comp)
tab[lab] = respc.comp[iddl][1]
def read(self, nblock=None, check_para=None):
"""Read and create the Table.
'check_para' is a function to check the list of the parameters."""
block_stat = self.split_tab(nblock)
nbcol = self.extract_lines(block_stat)
line_para = self.lines.pop(0)
para = msplit(line_para, self.sep)
if len(para) != nbcol:
raise error('TABLE0_43', line_para, nbcol)
# if sep != ' ', parameter may contain a space (not valid in Table)
para = [p.replace(' ', '_') for p in para]
if callable(check_para):
para = check_para(para)
_printDBG("PARAMS:", para)
self.tab = Table(para=para, titr=self.title)
self.read_all_lines()
return self.tab
def read(self, nblock, check_para=None):
"""Read and create the Table.
'check_para' is a function to check the list of the parameters."""
self.split_tab(nblock)
self.set_title()
self.extract_lines()
# ligne des paramètres et des types
para = msplit(self.lines.pop(0), self.sep)
types = msplit(self.lines.pop(0), self.sep)
if callable(check_para):
para = check_para(para)
_printDBG("PARAMS:", para)
_printDBG("TYPES:", types)
self.tab = Table(para=para, typ=types, titr=self.title)
lfmt = [FMT[typ[0]] % {'len': typ[1:]} for typ in types]
self.re_line = ('%s+' % re.escape(self.sep)).join(lfmt)
_printDBG("REGEXP:", self.re_line)
self.read_all_lines()
return self.tab
def post_dyna_alea_ops(self, INTERSPECTRE, FRAGILITE, TITRE, INFO, **args):
import numpy as NP
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from Cata_Utils.t_fonction import t_fonction
from Utilitai.Table import Table
commande = 'POST_DYNA_ALEA'
ier = 0
# La macro compte pour 1 dans la numérotation des commandes
self.set_icmd(1)
# Le concept sortant (de type table_sdaster ou dérivé) est tab
self.DeclareOut('tabout', self.sd)
# On importe les définitions des commandes a utiliser dans la macro
# Le nom de la variable doit être obligatoirement le nom de la commande
CREA_TABLE = self.get_cmd('CREA_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
RECU_FONCTION = self.get_cmd('RECU_FONCTION')
IMPR_FONCTION = self.get_cmd('IMPR_FONCTION')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
CALC_FONCTION = self.get_cmd('CALC_FONCTION')
# ------------------------------------------------------------------
#---------algorithme d'optimisation pour le maximum de vraisemblance
def vrais(x):
am = x[0]
beta = x[1]
# assert am >0.000, 'optimize.py: beta negatif'
# assert am >0.000, 'optimize.py: am negatif'
if am <= 0.000:
am = 0.01
if beta <= 0.000:
beta = 0.001
res = 1.0
for k in range(Nbval):
ai = liste_indic[k]
xi = float(liste_def[k])
val = log(ai / am)
pfa = normcdf(val / beta)
f0 = pfa ** xi * (1. - pfa) ** (1 - xi)
res = res * f0
return -res
def boot_vrais(x):
am = x[0]
beta = x[1]
res = 1.0
for k in range(Nbval):
ai = liste_indic[list_rand[k]]
xi = float(liste_def[list_rand[k]])
val = log(ai / am)
pfa = normcdf(val / beta)
f0 = pfa ** xi * (1. - pfa) ** (1 - xi)
res = res * f0
return -res
def fonc_def(vale, seuil):
if vale >= seuil:
resu = 1
else:
resu = 0
return resu
# ------------------------------------------------------------------
# OPTION FRAGILITE
# ------------------------------------------------------------------
if FRAGILITE != None:
from Utilitai.optimize import fmin
from Utilitai.stats import normcdf, linregress
if FRAGILITE['LIST_PARA'] != None:
liste_a = FRAGILITE['LIST_PARA'].sdj.VALE.get()
elif FRAGILITE['VALE'] != None:
liste_a = FRAGILITE['VALE']
Nba = len(liste_a)
lpfa = []
tab2 = FRAGILITE['TABL_RESU'].EXTR_TABLE()
dicta = tab2.values()
if dicta.has_key('DEFA'):
liste_def = dicta['DEFA']
test2 = NP.equal(None, liste_def)
elif dicta.has_key('DEMANDE'):
liste_dem = dicta['DEMANDE']
test2 = NP.equal(None, liste_dem)
else:
UTMESS('F', 'TABLE0_1', valk=('DEFA,DEMANDE'))
if dicta.has_key('PARA_NOCI'):
liste_indic = dicta['PARA_NOCI']
else:
UTMESS('F', 'TABLE0_1', valk=('PARA_NOCI'))
Nbval = len(liste_indic)
test1 = NP.equal(None, liste_indic)
if test1.any() or test2.any():
if dicta.has_key('DEFA'):
UTMESS('F', 'TABLE0_14', valk=('DEFA', 'PARA_NOCI'))
elif dicta.has_key('DEMANDE'):
UTMESS('F', 'TABLE0_14', valk=('DEMANDE', 'PARA_NOCI'))
if FRAGILITE['METHODE'] == "EMV":
# 1) estimation paramètres maximum de vraisemblance
if not dicta.has_key('DEFA'):
if FRAGILITE['SEUIL'] != None:
liste_def = [fonc_def(vale, FRAGILITE['SEUIL'])
for vale in liste_dem]
else:
UTMESS('F', 'FONCT0_16', valk=('SEUIL'))
x0 = [FRAGILITE['AM_INI'], FRAGILITE['BETA_INI']]
xopt = fmin(vrais, x0)
elif FRAGILITE['METHODE'] == "REGRESSION":
# 2) estimation paramètres REGRESSION
para_b, para_a, sigma, = linregress(
NP.log(NP.array(liste_indic)), NP.log(NP.array(liste_dem)))
if INFO == 2:
texte = 'PARAMETRES REGRESSION : ' + str(para_b) + ' ' + str(exp(para_a)) + '\n'
aster.affiche('MESSAGE', texte)
Am = exp((log(FRAGILITE['SEUIL']) - para_a) / para_b)
beta = sigma / para_b
xopt = [Am, beta]
texte = 'PARAMETRES Am, beta ESTIMES : ' + str(xopt) + '\n'
aster.affiche('MESSAGE', texte)
#print 'parametres Am, beta estimes: ', xopt
# courbe de fragilité
vec_a = NP.array(liste_a)
vecval = (NP.log(vec_a / xopt[0])) / xopt[1]
for m in range(Nba):
lpfa.append(normcdf(vecval[m]))
# table sortie
mcfact = []
if TITRE != None:
mcfact.append(_F(PARA='TITRE', LISTE_K=TITRE))
mcfact.append(_F(PARA='AM', LISTE_R=xopt[0]))
mcfact.append(_F(PARA='BETA', LISTE_R=xopt[1]))
mcfact.append(_F(PARA='PARA_NOCI', LISTE_R=liste_a))
mcfact.append(_F(PARA='PFA', LISTE_R=lpfa))
# si calcul de fractiles (intervalles de confiance) par bootstrap
x0 = xopt
if FRAGILITE['METHODE'] == "EMV":
if FRAGILITE['FRACTILE'] != None:
if INFO == 2:
texte = 'FRACTILES A CALCULER PAR BOOTSTRAP ' + \
str(FRAGILITE['FRACTILE']) + '\n'
aster.affiche('MESSAGE', texte)
if FRAGILITE['NB_TIRAGE'] != None:
Nboot = FRAGILITE['NB_TIRAGE']
if Nboot > Nbval:
UTMESS('F', 'PROBA0_11')
# assert Nboot <= Nbval , 'ERREUR: nombre de
# tirages demandes trop grand'
else:
Nboot = Nbval
list_fonc = []
lfract = FRAGILITE['FRACTILE']
__F1 = [None] * Nbval
__ABS = [None] * Nbval
__ORDO = [None] * Nbval
for kb in range(Nboot): # in range(Nbval)
lpfa = []
list_rand = []
for kb2 in range(Nbval):
list_rand.append(random.randint(0, Nbval - 1))
xopt = fmin(boot_vrais, x0)
if INFO == 2:
texte1 = 'BOOTSTRAP TIRAGE ' + str(kb + 1)
texte2 = ' PARAMETRES Am, beta ESTIMES : ' + \
str(xopt) + '\n'
aster.affiche('MESSAGE', texte1)
aster.affiche('MESSAGE', texte2)
vecval = (NP.log(vec_a / xopt[0])) / xopt[1]
for m in range(Nba):
lpfa.append(normcdf(vecval[m]))
__ABS[kb] = DEFI_LIST_REEL(VALE=liste_a)
__ORDO[kb] = DEFI_LIST_REEL(VALE=lpfa)
__F1[kb] = DEFI_FONCTION(NOM_PARA='PGAZ',
NOM_RESU='PFA',
VALE_PARA=__ABS[kb],
VALE_FONC=__ORDO[kb],)
list_fonc.append(__F1[kb],)
#__FRACTILE = [None]*len(lfract)
liste = [None] * len(lfract)
for kb in range(len(lfract)):
__FRACTILE = CALC_FONCTION(
FRACTILE=_F(FONCTION=(list_fonc),
FRACT=lfract[kb]), )
liste[kb] = __FRACTILE.Ordo()
mcfact.append(
_F(PARA=str(lfract[kb]), LISTE_R=liste[kb]))
# fin FRAGILITE
tabout = CREA_TABLE(
LISTE=mcfact, TITRE='POST_DYNA_ALEA concept : ' + self.sd.nom)
# ------------------------------------------------------------------
# ------------------------------------------------------------------
# OPTION INTESPEC
# ------------------------------------------------------------------
if INTERSPECTRE != None:
INTE_SPEC = INTERSPECTRE['INTE_SPEC']
NUME_ORDRE_I = INTERSPECTRE['NUME_ORDRE_I']
NOEUD_I = INTERSPECTRE['NOEUD_I']
OPTION = INTERSPECTRE['OPTION']
MOMENT = INTERSPECTRE['MOMENT']
DUREE = INTERSPECTRE['DUREE']
# table résultat
tabres = Table(titr='POST_DYNA_ALEA concept : %s' % self.sd.nom)
# ------------------------------------------------------------------
# Liste des moments spectraux
# repérer le type de l'interspectre et son nom
# 1- concept interspectre
# 2- table de table d interspectre
intespec = INTE_SPEC.nom.ljust(8)
# ------------------------------------------------------------------
# Repérer les couples d'indices selectionnés
# vérification de l'égalité du nombre d indices en i et j
if NUME_ORDRE_I != None:
l_ind_i = NUME_ORDRE_I
if type(l_ind_i) not in EnumTypes:
l_ind_i = [l_ind_i]
l_ind_j = INTERSPECTRE['NUME_ORDRE_J']
if l_ind_j:
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
if len(l_ind_i) != len(l_ind_j):
UTMESS('F', 'PROBA0_8')
else:
l_ind_j = NUME_ORDRE_I
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
# paramètres fixes de la table
tabres.add_para(['NUME_ORDRE_I', 'NUME_ORDRE_J'], 'I')
elif NOEUD_I != None:
l_ind_i = NOEUD_I
l_cmp_i = INTERSPECTRE['NOM_CMP_I']
if type(l_ind_i) not in EnumTypes:
l_ind_i = [l_ind_i]
if type(l_cmp_i) not in EnumTypes:
l_cmp_i = [l_cmp_i]
l_ind_j = INTERSPECTRE['NOEUD_J']
if l_ind_j:
l_cmp_j = INTERSPECTRE['NOM_CMP_J']
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
if type(l_cmp_j) not in EnumTypes:
l_cmp_j = [l_cmp_j]
if len(l_ind_i) != len(l_ind_j):
UTMESS('F', 'PROBA0_8')
if len(l_cmp_i) != len(l_cmp_j):
UTMESS('F', 'PROBA0_9')
if len(l_ind_i) != len(l_cmp_i):
UTMESS('F', 'PROBA0_10')
else:
l_ind_j = NOEUD_I
l_cmp_j = INTERSPECTRE['NOM_CMP_I']
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
if type(l_cmp_j) not in EnumTypes:
l_cmp_j = [l_cmp_j]
# paramètres fixes de la table
tabres.add_para(
['NOEUD_I', 'NOEUD_J', 'NOM_CMP_I', 'NOM_CMP_J'], 'K8')
# ------------------------------------------------------------------
# Cas de tous les indices
elif OPTION == 'TOUT':
if aster.getvectjev(intespec + '.NUMI'):
l_ind_i = aster.getvectjev(intespec + '.NUMI')
l_ind_j = aster.getvectjev(intespec + '.NUMJ')
tabres.add_para(['NUME_ORDRE_I', 'NUME_ORDRE_J'], 'I')
if aster.getvectjev(intespec + '.NOEI'):
l_ind_i = aster.getvectjev(intespec + '.NOEI')
l_ind_j = aster.getvectjev(intespec + '.NOEJ')
l_cmp_i = aster.getvectjev(intespec + '.CMPI')
l_cmp_j = aster.getvectjev(intespec + '.CMPJ')
tabres.add_para(
['NOEUD_I', 'NOEUD_J', 'NOM_CMP_I', 'NOM_CMP_J'], 'K8')
# ------------------------------------------------------------------
# Cas de tous les indices centraux
elif OPTION == 'DIAG':
if aster.getvectjev(intespec + '.NUMI'):
l_ind_i_all = aster.getvectjev(intespec + '.NUMI')
l_ind_j_all = aster.getvectjev(intespec + '.NUMJ')
l_ind_i = [ind for i, ind in enumerate(
l_ind_i_all) if l_ind_j_all[i] == ind]
l_ind_j = l_ind_i
tabres.add_para(['NUME_ORDRE_I', 'NUME_ORDRE_J'], 'I')
if aster.getvectjev(intespec + '.NOEI'):
l_ind_i_all = aster.getvectjev(intespec + '.NOEI')
l_ind_j_all = aster.getvectjev(intespec + '.NOEJ')
l_ind_i = [ind for i, ind in enumerate(
l_ind_i_all) if l_ind_j_all[i] == ind]
l_ind_j = l_ind_i
l_cmp_i_all = aster.getvectjev(intespec + '.CMPI')
l_cmp_j_all = aster.getvectjev(intespec + '.CMPJ')
l_cmp_i = [cmpi for i, cmpi in enumerate(
l_cmp_i_all) if l_cmp_j_all[i] == cmpi]
l_cmp_j = l_cmp_i
tabres.add_para(
['NOEUD_I', 'NOEUD_J', 'NOM_CMP_I', 'NOM_CMP_J'], 'K8')
# ------------------------------------------------------------------
# Liste des moments spectraux
l_moments = [0, 1, 2, 3, 4]
if MOMENT != None:
l_moments.extend(list(MOMENT))
l_moments = list(set(l_moments))
# ------------------------------------------------------------------
# Boucle sur les fonctions
if aster.getvectjev(intespec + '.NOEI'):
l_ind = zip(l_ind_i, l_ind_j, l_cmp_i, l_cmp_j)
else:
l_ind = zip(l_ind_i, l_ind_j)
# pour la présentation de la table finale, on stocke le nbre de
# paramètres "initiaux"
nbpara0 = len(tabres.para)
if INFO == 2:
texte = 'POUR LA MATRICE INTERSPECTRALE ' + INTE_SPEC.nom + '\n'
aster.affiche('MESSAGE', texte)
for ind in l_ind:
dlign = {}
dlrecu = {}
if NOEUD_I:
i_foncstat = ind[0] == ind[1] and ind[2] == ind[3]
dlign['NOEUD_I'], dlign['NOEUD_J'], dlign['NOM_CMP_I'], dlign['NOM_CMP_J'] = \
ind[0], ind[1], ind[2], ind[3]
if ind[0] == ind[1] and ind[2] == ind[3]:
dlrecu['NOEUD_I'], dlrecu['NOM_CMP_I'] = ind[0], ind[2]
else:
dlrecu['NOEUD_I'], dlrecu['NOEUD_J'], dlrecu['NOM_CMP_I'], \
dlrecu['NOM_CMP_J'] = ind[0], ind[1], ind[2], ind[3]
if INFO == 2:
aster.affiche(
'MESSAGE', 'INDICES :' + ind[0] + ' - ' + ind[1])
aster.affiche(
'MESSAGE', 'INDICES :' + ind[2] + ' - ' + ind[3] + '\n')
elif NUME_ORDRE_I:
i_foncstat = ind[0] == ind[1]
dlign['NUME_ORDRE_I'], dlign['NUME_ORDRE_J'] = ind[0], ind[1]
if ind[0] == ind[1]:
dlrecu['NUME_ORDRE_I'] = ind[0]
else:
dlrecu['NUME_ORDRE_I'], dlrecu[
'NUME_ORDRE_J'] = ind[0], ind[1]
if INFO == 2:
aster.affiche('MESSAGE', 'INDICES :' + str(ind[0]) + ' - '
+ str(ind[1]) + '\n')
else: # TOUT_ORDRE
if aster.getvectjev(intespec + '.NUMI'):
i_foncstat = ind[0] == ind[1]
dlign['NUME_ORDRE_I'], dlign[
'NUME_ORDRE_J'] = ind[0], ind[1]
if ind[0] == ind[1]:
dlrecu['NUME_ORDRE_I'] = ind[0]
else:
dlrecu['NUME_ORDRE_I'], dlrecu[
'NUME_ORDRE_J'] = ind[0], ind[1]
if aster.getvectjev(intespec + '.NOEI'):
i_foncstat = ind[0] == ind[1] and ind[2] == ind[3]
dlign['NOEUD_I'], dlign['NOEUD_J'], dlign['NOM_CMP_I'], dlign['NOM_CMP_J'] = \
ind[0], ind[1], ind[2], ind[3]
if ind[0] == ind[1] and ind[2] == ind[3]:
dlrecu['NOEUD_I'], dlrecu['NOM_CMP_I'] = ind[0], ind[2]
else:
dlrecu['NOEUD_I'], dlrecu['NOEUD_J'], dlrecu['NOM_CMP_I'], \
dlrecu['NOM_CMP_J'] = ind[
0], ind[1], ind[2], ind[3]
__fon1 = RECU_FONCTION(INTE_SPEC=INTE_SPEC,
**dlrecu)
val = __fon1.Valeurs()
fvalx = NP.array(val[0])
fvaly = NP.array(val[1])
frez = fvalx[0]
# -- moments spectraux
val_mom = {}
for i_mom in l_moments:
n = len(fvaly)
trapz = NP.zeros(n)
trapz[0] = 0.
valy = fvaly * (2 * pi * fvalx) ** i_mom
trapz[1:n] = (valy[1:n] + valy[:-1]) / 2. * (
fvalx[1:n] - fvalx[:-1])
prim_y = NP.cumsum(trapz)
val_mom[i_mom] = prim_y[-1]
# -- cas si, seule la partie positive du spectre est utilisée
# -- Il faut donc doubler lambda pour calculer le bon écart type
if frez >= 0.:
val_mom[i_mom] = val_mom[i_mom] * 2.
for i_mom in l_moments:
chmo = 'LAMBDA_' + str(i_mom).zfill(2)
dlign[chmo] = val_mom[i_mom]
#--- si auto-spectre:
if i_foncstat:
# test si le spectre est bien à valeurs positives
if min(fvaly) < 0.0:
aster.affiche('MESSAGE', str(ind) + '\n')
UTMESS('F', 'MODELISA9_95')
# -- fonctions statistiques
dlign['ECART'] = sqrt(val_mom[0])
if DUREE != None:
Ts = DUREE
vop = sqrt(val_mom[2] / val_mom[0]) / (2. * pi)
Nu = Ts * vop / (-log(0.5))
deltau = sqrt(
1. - val_mom[1] ** 2 / (val_mom[2] * val_mom[0]))
valNd = 2. * Nu * \
(1 - exp(-(deltau) ** 1.2 * sqrt(pi * log(2. * Nu))))
val_peak = sqrt(2. * log(valNd))
dlign[
'FACT_PIC'] = val_peak # -- facteur de peak (oour max moyen)
dlign['MAX_MOY'] = val_peak * sqrt(
val_mom[0]) # -- max moyen
if abs(val_mom[2]) >= 1e-20:
dlign['NB_EXTREMA_P_S'] = 1. / \
pi * sqrt(val_mom[4] / val_mom[2])
if abs(val_mom[0]) >= 1e-20:
dlign['NB_PASS_ZERO_P_S'] = 1. / \
pi * sqrt(val_mom[2] / val_mom[0])
dlign['FREQ_APPAR'] = 0.5 * dlign['NB_PASS_ZERO_P_S']
if abs(val_mom[4]) >= 1e-20:
dlign['FACT_IRRE'] = sqrt(
val_mom[2] * val_mom[2] / val_mom[0] / val_mom[4])
# ajoute la ligne à la Table
tabres.append(dlign)
#--- construction de la table produite
# tri des paramètres
ord_para = tabres.para[nbpara0:]
ord_para.sort()
ord_para = tabres.para[:nbpara0] + ord_para
dprod = tabres[ord_para].dict_CREA_TABLE()
tabout = CREA_TABLE(**dprod)
return ier
def defi_sol_miss_ops(self, MATERIAU, COUCHE, COUCHE_AUTO, TITRE, INFO,
**args):
"""Macro DEFI_SOL_MISS :
définir les caractéristiques du sol pour un calcul MISS3D
"""
import aster
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
from Utilitai.Table import Table
CREA_TABLE = self.get_cmd("CREA_TABLE")
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type table_sdaster) est tabout
self.DeclareOut("tabout", self.sd)
# 1. Création des dictionnaires des MATERIAUX
l_mate = []
for Mi in MATERIAU:
dM = Mi.cree_dict_valeurs(Mi.mc_liste)
l_mate.append(dM)
nb_mate = len(l_mate)
# 2. Création des dictionnaires des COUCHES
l_couche = []
n_substr = 0
n_epais = 0
# Mode manuel :
if COUCHE != None:
for Ci in COUCHE:
dC = Ci.cree_dict_valeurs(Ci.mc_liste)
if dC.get("SUBSTRATUM") == "OUI":
n_substr += 1
if dC.get("EPAIS") != None:
n_epais += 1
l_couche.append(dC)
if n_substr != 1:
UTMESS("F", "MISS0_3")
if n_epais == 0:
UTMESS("F", "MISS0_21")
nb_couche = len(l_couche)
print 'l_couche=', l_couche
# Mode automatique pour les couches :
grma_interf = None
arg_grno = False
arg_grma = False
if COUCHE_AUTO != None:
ll_mate = []
l_epais = []
enfonce = False
homogene = False
l_z0 = False
Z0 = 0.
max_z_input = 0.
min_z_input = 0.
# tole_r sert à arrondir les valeurs pour les tests
tole_r = 5
l_pt_ctrl = False
coor_z_input = []
decalage_auto = False
# Lecture des arguments :
for Ci in COUCHE_AUTO:
dC = Ci.cree_dict_valeurs(Ci.mc_liste)
if dC.get("HOMOGENE") == "OUI":
homogene = True
if dC.get("MAILLAGE"):
noma = dC.get("MAILLAGE")
if dC.get("SURF") == "NON":
enfonce = True
if dC.get("GROUP_MA") or dC.get("GROUP_NO"):
collcnx = aster.getcolljev(noma.nom.ljust(8) + '.CONNEX')
coord = aster.getvectjev(
noma.nom.ljust(8) + '.COORDO .VALE')
cnom = aster.getvectjev(noma.nom.ljust(8) + '.NOMNOE')
if dC.get("GROUP_MA"):
arg_grma = True
nomgrma = dC.get("GROUP_MA")
coor_z_input = recu_coor_z(noma, nomgrma, 'group_ma',
tole_r)
else:
arg_grno = True
nomgrno = dC.get("GROUP_NO")
coor_z_input = recu_coor_z(noma, nomgrno, 'group_no',
tole_r)
max_z_input = coor_z_input[0]
min_z_input = coor_z_input[-1]
if dC.get("NUME_MATE"):
ll_mate = dC.get("NUME_MATE")
if dC.get("EPAIS_PHYS"):
if homogene:
l_epais.append(dC.get("EPAIS_PHYS")[0])
else:
l_epais = dC.get("EPAIS_PHYS")
if dC.get("NUME_MATE_SUBSTRATUM"):
nume_substr = dC.get("NUME_MATE_SUBSTRATUM")
if dC.get("NOMBRE_RECEPTEUR"):
nb_recept = dC.get("NOMBRE_RECEPTEUR")
if (nb_recept % 2 <> 0):
UTMESS("F", "MISS0_27")
if dC.get("GROUP_MA_INTERF"):
grma_interf = dC.get("GROUP_MA_INTERF")
if dC.get("Z0"):
Z0 = dC.get("Z0")
l_z0 = True
if not l_z0 and enfonce:
Z0 = max_z_input
if not enfonce:
max_z_input = Z0
print 'La cote Z vaut : ', Z0
if dC.get("TOLERANCE"):
tole_verif = dC.get("TOLERANCE")
if dC.get("DECALAGE_AUTO") == "OUI":
decalage_auto = True
if dC.get("GROUP_MA_CONTROL"):
nomgrmactrl = dC.get("GROUP_MA_CONTROL")
l_pt_ctrl = True
coor_z_ctrl = recu_coor_z(noma, nomgrmactrl, 'group_ma',
tole_r)
print 'Cotes verticales des points de controle=', coor_z_ctrl
if coor_z_ctrl[0] > Z0:
UTMESS("F", "MISS0_28", valr=Z0)
if homogene:
max_z_input = Z0
ll_mate.append(1)
l_mate.append(l_mate[0])
nb_mate += 1
coor_z_sol = [
max_z_input,
]
for ep in l_epais:
coor_z_sol.append(coor_z_sol[-1] - ep)
# Typage des couches : 1 si couche de sol, 2 si point de controle
type_couche = [1] * len(coor_z_sol)
if enfonce:
# Verification si il y a vraiment enfoncement
if len(coor_z_sol) == 1:
UTMESS("F", "MISS0_29")
# Verification entre base de l'interface et couches de sol
print 'coor_z_sol=', coor_z_sol
if len(l_epais) <> len(ll_mate):
UTMESS("F", "MISS0_30")
if l_pt_ctrl:
if coor_z_ctrl[-1] < coor_z_sol[-1]:
UTMESS("F", "MISS0_32")
# Liste regroupant les cotes des points de controles et des couches de sol
coor_z_sol_ctrl = []
for zz in coor_z_sol:
coor_z_sol_ctrl.append(zz)
for zz in coor_z_ctrl:
if zz not in coor_z_sol_ctrl:
coor_z_sol_ctrl.append(zz)
prov = sorted(coor_z_sol_ctrl)
coor_z_sol_ctrl = prov[::-1]
type_couche = [1]
l_epais = []
ll_mate2 = []
zz_sup = Z0
jj = 0
for zz in coor_z_sol_ctrl[1:]:
if zz in coor_z_ctrl:
if zz in coor_z_sol:
UTMESS("F", "MISS0_33")
else:
type_couche.append(2)
else:
type_couche.append(1)
pp = zz_sup - zz
l_epais.append(pp)
zz_sup = zz
ll_mate2.append(ll_mate[jj])
if zz in coor_z_sol:
jj += 1
ll_mate = ll_mate2
# Verification avec l'interface FEM-BEM
nb_noeud = 0
verif = False
if ((grma_interf != None) and enfonce and (COUCHE_AUTO != None)):
coor_z_interf = recu_coor_z(noma, grma_interf, 'group_ma', tole_r)
max_z_interf = coor_z_interf[0]
min_z_interf = coor_z_interf[-1]
l_z_sol = [
max_z_interf,
]
for ep in l_epais:
l_z_sol.append(l_z_sol[-1] - ep)
nb_noeud = len(coor_z_input)
if (max_z_input < max_z_interf) or (min_z_input > min_z_interf):
UTMESS("F", "MISS0_34")
verif = True
denom = 1.
for z_input in coor_z_input:
verif1 = False
for z_interf in coor_z_interf:
if (abs(z_interf) > 1.):
denom = abs(z_interf)
if ((abs(z_input - z_interf) / denom) <= tole_verif):
verif1 = True
verif = (verif and verif1)
if (not verif):
if arg_grma:
UTMESS("F", "MISS0_34")
else:
UTMESS("A", "MISS0_35")
if l_pt_ctrl:
for zz in coor_z_ctrl:
if zz > min_z_input:
UTMESS("F", "MISS0_36")
#Generation table sol en mode auto
if (COUCHE_AUTO != None):
couche = {}
nbc = 0
idc = 1
nbsscouche = 0
if enfonce:
l_noeud = coor_z_input
# Liste des epaisseurs de sol
l_z_ep = []
for zz in l_z_sol:
l_z_ep.append(Z0 - zz)
for pt in range(nb_noeud - 1):
idc += 1
enfonc_sup = l_noeud[0] - l_noeud[pt]
if enfonc_sup > l_z_ep[len(l_z_ep) - 1]:
UTMESS("F", "MISS0_37")
ep_ss_couche = (l_noeud[pt] - l_noeud[pt + 1]) / nb_recept
for nc in range(nb_recept):
couche = {}
enfonc_ss_c_haut = l_noeud[0] - l_noeud[pt] + (
nc * ep_ss_couche)
enfonc_ss_c_bas = enfonc_ss_c_haut + ep_ss_couche
i = 0
ind_mat_sup = 0
ind_mat_inf = 0
if not homogene:
while enfonc_ss_c_haut > l_z_ep[i]:
i += 1
while l_z_ep[ind_mat_sup] <= enfonc_ss_c_haut:
ind_mat_sup += 1
ind_mat_inf = ind_mat_sup
ind_mat_sup = ind_mat_sup - 1
while enfonc_ss_c_bas >= l_z_ep[ind_mat_inf]:
ind_mat_inf += 1
nb_mat_couche = ind_mat_inf - ind_mat_sup
if homogene:
id_mate = ll_mate[0]
elif ind_mat_sup < (ind_mat_inf - 2):
#Cas plus de deux materiaux dans la sous-couche
print ' Cas plus de deux materiaux dans la sous-couche'
ep_mat_h = []
ep_mat_b = []
ep_mat = [
(l_z_ep[ind_mat_sup + 1] - enfonc_ss_c_haut),
]
for ind_mat in range((ind_mat_sup + 1),
(ind_mat_inf - 1)):
zz1 = l_z_ep[ind_mat] - enfonc_ss_c_haut
zz2 = enfonc_ss_c_bas - l_z_ep[ind_mat]
ep_mat_h.append(zz1)
ep_mat_b.append(zz2)
ep_mat.append(enfonc_ss_c_bas -
l_z_ep[ind_mat_inf - 1])
err_ep = abs(sum(ep_mat) - ep_ss_couche) / ep_ss_couche
if (err_ep > tole_verif):
UTMESS("F", "MISS0_38")
ep1 = ep_mat[0]
ii = 1
id_mate = ll_mate[ind_mat_sup]
for ii in range(1, (len(ep_mat) - 1)):
if (ep_mat[ii] > ep1):
ep1 = ep_mat[ii]
id_mate = ll_mate[ind_mat_sup + ii]
elif ind_mat_sup == (ind_mat_inf - 2):
#Cas deux materiaux dans la sous-couche
zz1 = l_z_ep[ind_mat_sup + 1] - enfonc_ss_c_haut
zz2 = enfonc_ss_c_bas - l_z_ep[ind_mat_sup + 1]
if zz2 > zz1:
id_mate = ll_mate[ind_mat_sup + 1]
else:
id_mate = ll_mate[ind_mat_sup]
elif ind_mat_sup == (ind_mat_inf - 1):
#Cas un seul materiau
id_mate = ll_mate[ind_mat_sup]
else:
assert False, "Erreur dans la contruction des sous-couches"
couche["SUBSTRATUM"] = None
couche["NUME_MATE"] = id_mate
couche["EPAIS"] = ep_ss_couche
couche["RECEPTEUR"] = "OUI"
couche["SOURCE"] = "NON"
if nc == nb_recept / 2:
couche["SOURCE"] = "OUI"
l_couche.append(couche)
idc += 1
enfonc_ss_c_bas = l_noeud[0] - l_noeud[pt + 1]
# Fin des sous-couches
# Couche a la base de l'interface
ii = 0
epais = -1.
if len(l_z_ep) > 1:
while enfonc_ss_c_bas >= l_z_ep[ii]:
ii += 1
epais = l_z_ep[ii] - enfonc_ss_c_bas
else:
if l_z_ep[ii] <= enfonc_ss_c_bas:
UTMESS("F", "MISS0_39")
else:
epais = l_z_ep[ii] - enfonc_ss_c_bas
couche = {}
couche["EPAIS"] = epais
couche["SUBSTRATUM"] = None
if not homogene:
couche["NUME_MATE"] = ll_mate[ii - 1]
else:
couche["NUME_MATE"] = ll_mate[0]
couche["EPAIS"] = epais
couche["SOURCE"] = "OUI"
couche["RECEPTEUR"] = "OUI"
idc += 1
l_couche.append(couche)
# Couches strictement sous l'interface
while ii < len(l_epais):
couche = {}
couche["SUBSTRATUM"] = None
couche["NUME_MATE"] = ll_mate[ii]
couche["EPAIS"] = l_epais[ii]
couche["SOURCE"] = "NON"
couche["RECEPTEUR"] = "NON"
if type_couche[ii] == 2:
# Cas des points de controle
couche["RECEPTEUR"] = "OUI"
couche["SOURCE"] = "OUI"
l_couche.append(couche)
idc += 1
ii += 1
# Substratum
couche = {}
couche["SUBSTRATUM"] = "OUI"
couche["SOURCE"] = "NON"
couche["RECEPTEUR"] = "NON"
if homogene:
couche["NUME_MATE"] = ll_mate[0] + 1
else:
couche["NUME_MATE"] = nume_substr
couche["EPAIS"] = None
l_couche.append(couche)
else:
# Cas superficiel
couche = {}
ii = 0
couche["SOURCE"] = "OUI"
couche["RECEPTEUR"] = "OUI"
couche["NUME_MATE"] = ll_mate[ii]
couche["EPAIS"] = l_epais[ii]
couche["SUBSTRATUM"] = None
l_couche.append(couche)
ii = 1
for nc in range(1, len(l_epais)):
couche = {}
couche["SUBSTRATUM"] = None
couche["NUME_MATE"] = ll_mate[ii]
couche["EPAIS"] = l_epais[ii]
couche["RECEPTEUR"] = "NON"
couche["SOURCE"] = "NON"
if type_couche[ii] == 2:
# Cas des points de controle
couche["RECEPTEUR"] = "OUI"
couche["SOURCE"] = "OUI"
l_couche.append(couche)
idc += 1
ii += 1
couche = {}
couche["SUBSTRATUM"] = "OUI"
couche["SOURCE"] = "NON"
couche["RECEPTEUR"] = "NON"
if homogene:
couche["NUME_MATE"] = ll_mate[0] + 1
else:
couche["NUME_MATE"] = nume_substr
couche["EPAIS"] = None
l_couche.append(couche)
if ((COUCHE_AUTO != None) and enfonce):
# Verification entre base de l'interface et couches de sol
min_z_input_r = round(min_z_input, tole_r)
prof = Z0
ii = 0
for couche in l_couche[:-2]:
prof = prof - couche["EPAIS"]
prof = round(prof, tole_r)
print 'ii=', ii
print 'prof=', prof
if prof == min_z_input_r:
if decalage_auto:
UTMESS("A", "MISS0_40", valr=(prof, couche["EPAIS"]))
couche["NUME_MATE"] = l_couche[ii + 1]["NUME_MATE"]
else:
UTMESS("A", "MISS0_41")
ii += 1
print 'l_couche mod=', l_couche
# 3. définition de la table
# para/typ pré-trie les colonnes
tab = Table(para=[
"NUME_COUCHE", "EPAIS", "RHO", "E", "NU", "AMOR_HYST", "RECEPTEUR",
"SOURCE", "NUME_MATE", "SUBSTRATUM"
],
typ=["I", "R", "R", "R", "R", "R", "K8", "K8", "I", "K8"])
idc = 0
for couche in l_couche:
idc += 1
id_mate = couche["NUME_MATE"]
if id_mate > nb_mate:
UTMESS("F", "MISS0_4", vali=(idc, nb_mate, id_mate))
id_mate = id_mate - 1
couche["NUME_COUCHE"] = idc
couche.update(l_mate[id_mate])
if couche.get("SUBSTRATUM") is None:
del couche["SUBSTRATUM"]
if couche["EPAIS"] is None:
couche["EPAIS"] = 0.
tab.append(couche)
# 4. surcharge par le titre fourni
if TITRE != None:
if type(TITRE) not in (list, tuple):
TITRE = [TITRE]
tab.titr = os.linesep.join(TITRE)
if INFO == 2:
print tab
# 5. création de la table
dprod = tab.dict_CREA_TABLE()
tabout = CREA_TABLE(**dprod)
def info_fonction_ops(self, RMS, NOCI_SEISME, MAX, NORME, ECART_TYPE, INFO,
**args):
"""
Ecriture de la macro INFO_FONCTION
"""
ier = 0
from Cata_Utils.t_fonction import t_fonction, t_fonction_c, t_nappe
import math
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS
import numpy as NP
from Utilitai.Table import Table
# On importe les definitions des commandes a utiliser dans la macro
CREA_TABLE = self.get_cmd('CREA_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CALC_FONCTION = self.get_cmd('CALC_FONCTION')
# Comptage commandes + déclaration concept sortant
self.set_icmd(1)
self.DeclareOut('C_out', self.sd)
# type de traitement
#
if (MAX != None):
# liste des t_fonction
l_cofonc = MAX['FONCTION']
if type(l_cofonc) not in (list, tuple):
l_cofonc = [
l_cofonc,
]
l_fonc = [concept.convert() for concept in l_cofonc]
# intervalles
mc_interv = MAX['INTERVALLE']
with_intervalle = mc_interv is not None
interv = []
if with_intervalle:
nbv = len(mc_interv)
if nbv % 2 != 0:
UTMESS('F', 'FONCT0_55')
tint = NP.array(mc_interv)
tint.shape = (nbv / 2, 2)
dx = tint[:, 1] - tint[:, 0]
if min(dx) < 0.:
UTMESS('F', 'FONCT0_56')
interv = tint.tolist()
# vérifications de cohérence
typobj = set()
npara = set()
nparf = set()
nresu = set()
l_nom = []
for tf in l_fonc:
typobj.add(tf.__class__)
npara.add(tf.para['NOM_PARA'])
nparf.add(tf.para.get('NOM_PARA_FONC'))
nresu.add(tf.para['NOM_RESU'])
l_nom.append(tf.nom)
if len(typobj) > 1:
# types (fonction, fonction_c, nappe) non homogènes
UTMESS('F', 'FONCT0_37')
is_nappe = typobj.pop() is t_nappe
if len(npara) > 1:
# NOM_PARA non homogènes
UTMESS('F', 'FONCT0_38', valk=' '.join(npara))
if len(nparf) > 1:
# NOM_PARA_FONC non homogènes
UTMESS('F', 'FONCT0_38', valk=' '.join(nparf))
if len(nresu) > 1:
# NOM_RESU non homogènes
UTMESS('F', 'FONCT0_39', valk=' '.join(nresu))
# nom des paramètres et leurs types
k_para = npara.pop()
k_parf = nparf.pop()
k_ordo = nresu.pop()
k_min = k_para + "_MIN"
k_max = k_para + "_MAX"
ordered_params = ['FONCTION', 'TYPE']
ordered_type = ['K8', 'K8']
if with_intervalle:
ordered_params.extend(['INTERVALLE', k_min, k_max])
ordered_type.extend(['I', 'R', 'R'])
ordered_params.append(k_para)
ordered_type.append('R')
if is_nappe:
ordered_params.append(k_parf)
ordered_type.append('R')
ordered_params.append(k_ordo)
ordered_type.append('R')
# boucle sur les fonctions, intervalles, min/max, extrema
_type = {'min': 'MINI', 'max': 'MAXI'}
_PREC = 1.e-6
tab = Table(para=ordered_params, typ=ordered_type)
for tf in l_fonc:
if not with_intervalle:
if not is_nappe:
interv = [
[float(min(tf.vale_x)),
float(max(tf.vale_x))],
]
else:
interv = [
[-1.e-300, 1.e300],
]
for num_int, bornes in enumerate(interv):
x1, x2 = bornes
if not is_nappe:
stf = tf.cut(x1, x2, _PREC, nom=tf.nom)
else:
stf = tf
extrema = stf.extreme()
for key in ('min', 'max'):
nb = len(extrema[key])
for i in range(nb):
line = {
'FONCTION': tf.nom,
'TYPE': _type[key],
k_para: extrema[key][i][0]
}
if is_nappe:
line.update({
k_parf: extrema[key][i][1],
k_ordo: extrema[key][i][2]
})
else:
line.update({k_ordo: extrema[key][i][1]})
if with_intervalle:
line.update({
'INTERVALLE': num_int + 1,
k_min: x1,
k_max: x2
})
tab.append(line)
tab.titr = "Extrema de " + ', '.join(l_nom)
# table résultat
dprod = tab.dict_CREA_TABLE()
C_out = CREA_TABLE(**dprod)
#
if (ECART_TYPE != None):
__ff = ECART_TYPE['FONCTION'].convert()
if ECART_TYPE['INST_INIT'] != None:
tini = ECART_TYPE['INST_INIT']
else:
tini = __ff.vale_x[0]
if ECART_TYPE['INST_FIN'] != None:
tfin = ECART_TYPE['INST_FIN']
else:
tfin = __ff.vale_x[-1]
__ff = __ff.cut(tini, __ff.vale_x[-1], ECART_TYPE['PRECISION'],
ECART_TYPE['CRITERE'])
__ff = __ff.cut(__ff.vale_x[0], tfin, ECART_TYPE['PRECISION'],
ECART_TYPE['CRITERE'])
if ECART_TYPE['METHODE'] == 'SIMPSON':
__ex = __ff.simpson(0.)
if ECART_TYPE['METHODE'] == 'TRAPEZE':
__ex = __ff.trapeze(0.)
fmoy = __ex.vale_y[-1] / (__ff.vale_x[-1] - __ff.vale_x[0])
__ff = __ff + (-1 * fmoy)
__ff = __ff * __ff
if ECART_TYPE['METHODE'] == 'SIMPSON':
__ez = __ff.simpson(0.)
if ECART_TYPE['METHODE'] == 'TRAPEZE':
__ez = __ff.trapeze(0.)
sigma = math.sqrt(__ez.vale_y[-1] / (__ff.vale_x[-1] - __ff.vale_x[0]))
C_out = CREA_TABLE(LISTE=(
_F(LISTE_K=ECART_TYPE['FONCTION'].nom, PARA='FONCTION'),
_F(LISTE_K=ECART_TYPE['METHODE'], PARA='METHODE'),
_F(LISTE_R=fmoy, PARA='MOYENNE'),
_F(LISTE_R=sigma, PARA='ECART_TYPE'),
_F(LISTE_R=tini, PARA='INST_INIT'),
_F(LISTE_R=tfin, PARA='INST_FIN'),
))
#
if (RMS != None):
RMS = list(RMS)
sigm = []
tmpi = []
tmpf = []
nomf = []
meth = []
for i_rms in RMS:
__ff = i_rms['FONCTION'].convert()
if i_rms['INST_INIT'] != None:
tini = i_rms['INST_INIT']
else:
tini = __ff.vale_x[0]
if i_rms['INST_FIN'] != None:
tfin = i_rms['INST_FIN']
else:
tfin = __ff.vale_x[-1]
__ff = __ff.cut(tini, __ff.vale_x[-1], i_rms['PRECISION'],
i_rms['CRITERE'])
__ff = __ff.cut(__ff.vale_x[0], tfin, i_rms['PRECISION'],
i_rms['CRITERE'])
__ff = __ff * __ff
if i_rms['METHODE'] == 'SIMPSON':
__ez = __ff.simpson(0.)
if i_rms['METHODE'] == 'TRAPEZE':
__ez = __ff.trapeze(0.)
sigm.append(
math.sqrt(__ez.vale_y[-1] /
(__ff.vale_x[-1] - __ff.vale_x[0])))
tmpi.append(tini)
tmpf.append(tfin)
nomf.append(i_rms['FONCTION'].nom)
meth.append(i_rms['METHODE'])
C_out = CREA_TABLE(LISTE=(
_F(LISTE_K=nomf, PARA='FONCTION'),
_F(LISTE_K=meth, PARA='METHODE'),
_F(LISTE_R=tmpi, PARA='INST_INIT'),
_F(LISTE_R=tmpf, PARA='INST_FIN'),
_F(LISTE_R=sigm, PARA='RMS'),
))
#
if (NORME != None):
__ff = NORME['FONCTION'].convert()
norme = []
for __fi in __ff.l_fonc:
norme.append(__fi.normel2())
nom = [
NORME['FONCTION'].nom,
] * len(norme)
C_out = CREA_TABLE(LISTE=(
_F(LISTE_R=norme, PARA='NORME'),
_F(LISTE_K=nom, PARA='FONCTION'),
))
#
if (NOCI_SEISME != None):
l_table = []
if NOCI_SEISME['SPEC_OSCI'] != None:
# cas intensité spectrale d'une nappe de SRO
# la seule option licite est INTE_SPEC
# intensite spectrale, il est prudent de verifier la norme de la nappe sur laquelle \
# porte le calcul, ceci peut etre une source d erreurs.''')
UTMESS('I', 'FONCT0_40')
amor = NOCI_SEISME['AMOR_REDUIT']
fini = NOCI_SEISME['FREQ_INIT']
ffin = NOCI_SEISME['FREQ_FIN']
__sp = NOCI_SEISME['SPEC_OSCI'].convert()
vale_x = __sp.l_fonc[0].vale_x
vale_y = [__sp(amor, f) for f in vale_x]
para = __sp.l_fonc[0].para
__srov = t_fonction(vale_x, vale_y, para)
if NOCI_SEISME['NATURE'] == 'DEPL':
__srov.vale_y = (__srov.vale_y / __srov.vale_x) * 2. * math.pi
elif NOCI_SEISME['NATURE'] == 'VITE':
__srov.vale_y = __srov.vale_y / __srov.vale_x / __srov.vale_x
elif NOCI_SEISME['NATURE'] == 'ACCE':
__srov.vale_y = __srov.vale_y / __srov.vale_x / __srov.vale_x
__srov.vale_y = __srov.vale_y / __srov.vale_x / 2. / math.pi
__srov = __srov.cut(fini, ffin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
insp = __srov.trapeze(0.).vale_y[-1]
l_table.append(_F(LISTE_R=fini, PARA='FREQ_INIT'))
l_table.append(_F(LISTE_R=ffin, PARA='FREQ_FIN'))
l_table.append(_F(LISTE_R=amor, PARA='AMOR_REDUIT'))
l_table.append(_F(LISTE_R=insp, PARA='INTE_SPECT'))
if NOCI_SEISME['FONCTION'] != None:
# cas fonction
l_table.append(
_F(LISTE_K=NOCI_SEISME['FONCTION'].nom, PARA='FONCTION'))
__ac = NOCI_SEISME['FONCTION'].convert()
option = NOCI_SEISME['OPTION']
if NOCI_SEISME['INST_INIT'] != None:
tdeb = NOCI_SEISME['INST_INIT']
else:
tdeb = __ac.vale_x[0]
if NOCI_SEISME['INST_FIN'] != None:
tfin = NOCI_SEISME['INST_FIN']
else:
tfin = __ac.vale_x[-1]
# calcul de la vitesse :
__vi = __ac.trapeze(NOCI_SEISME['COEF'])
# calcul du déplacement :
__de = __vi.trapeze(NOCI_SEISME['COEF'])
# calcul de |acceleration| :
__aa = __ac.abs()
# calcul de integrale(|acceleration|) :
# on "coupe" la fonction entre tdeb et tfin
__ac = __ac.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__vi = __vi.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__de = __de.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__aa = __aa.cut(tdeb, tfin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
if NOCI_SEISME['FREQ'] != None:
l_freq = NOCI_SEISME['FREQ']
elif NOCI_SEISME['LIST_FREQ'] != None:
l_freq = NOCI_SEISME['LIST_FREQ'].Valeurs()
else:
# fréquences par défaut
l_freq = []
for i in range(56):
l_freq.append(0.2 + 0.050 * i)
for i in range(8):
l_freq.append(3.0 + 0.075 * i)
for i in range(14):
l_freq.append(3.6 + 0.100 * i)
for i in range(24):
l_freq.append(5.0 + 0.125 * i)
for i in range(28):
l_freq.append(8.0 + 0.250 * i)
for i in range(6):
l_freq.append(15.0 + 0.500 * i)
for i in range(4):
l_freq.append(18.0 + 1.000 * i)
for i in range(10):
l_freq.append(22.0 + 1.500 * i)
if option in ('TOUT', 'MAXI', 'ACCE_SUR_VITE'):
# calcul du max des valeurs absolues
maxa_ac = __ac.abs().extreme()['max'][0][1]
maxa_vi = __vi.abs().extreme()['max'][0][1]
maxa_de = __de.abs().extreme()['max'][0][1]
l_table.append(_F(LISTE_R=maxa_ac, PARA='ACCE_MAX'))
l_table.append(_F(LISTE_R=maxa_vi, PARA='VITE_MAX'))
l_table.append(_F(LISTE_R=maxa_de, PARA='DEPL_MAX'))
l_table.append(
_F(LISTE_R=maxa_ac / maxa_vi, PARA='ACCE_SUR_VITE'))
if option in ('TOUT', 'INTE_ARIAS'):
__a2 = __ac * __ac
inte_arias = __a2.trapeze(0.).vale_y[-1]
inte_arias = inte_arias * math.pi / \
NOCI_SEISME['PESANTEUR'] / 2.
l_table.append(_F(LISTE_R=inte_arias, PARA='INTE_ARIAS'))
if option in ('TOUT', 'POUV_DEST'):
__v2 = __vi * __vi
pouv_dest = __v2.trapeze(0.).vale_y[-1]
pouv_dest = pouv_dest * \
(math.pi) ** 3 / NOCI_SEISME['PESANTEUR'] / 2.
l_table.append(_F(LISTE_R=pouv_dest, PARA='POUV_DEST'))
if option in ('TOUT', 'VITE_ABSO_CUMU'):
__vc = __aa.trapeze(0.)
vite_abso = __vc.vale_y[-1]
l_table.append(_F(LISTE_R=vite_abso, PARA='VITE_ABSO_CUMU'))
if option in ('TOUT', 'ASA'):
amor = NOCI_SEISME['AMOR_REDUIT']
freq_osci = NOCI_SEISME['FREQ_FOND']
ratio = NOCI_SEISME['RATIO']
freq_pas = NOCI_SEISME['FREQ_PAS']
f_ini = (1 - ratio) * freq_osci
liste_freq = NP.arange(f_ini, freq_osci + freq_pas, freq_pas)
__so = CALC_FONCTION(SPEC_OSCI=_F(
NATURE='ACCE',
NATURE_FONC='ACCE',
FONCTION=NOCI_SEISME['FONCTION'],
METHODE='NIGAM',
NORME=NOCI_SEISME['NORME'],
FREQ=liste_freq,
AMOR_REDUIT=(amor, )), )
__srov = __so.convert().l_fonc[0]
ASA_R = 1. / \
(ratio * freq_osci) * NP.trapz(
__srov.vale_y, __srov.vale_x)
l_table.append(_F(LISTE_R=ASA_R, PARA='ASA'))
l_table.append(_F(LISTE_R=ratio, PARA='RATIO'))
if option == 'ASA':
l_table.append(_F(LISTE_R=amor, PARA='AMOR_REDUIT'))
if option in ('TOUT', 'INTE_SPEC'):
amor = NOCI_SEISME['AMOR_REDUIT']
fini = NOCI_SEISME['FREQ_INIT']
ffin = NOCI_SEISME['FREQ_FIN']
__so = CALC_FONCTION(SPEC_OSCI=_F(
NATURE='VITE',
NATURE_FONC='ACCE',
FONCTION=NOCI_SEISME['FONCTION'],
METHODE='NIGAM',
NORME=NOCI_SEISME['NORME'],
FREQ=l_freq,
AMOR_REDUIT=(amor, )), )
__srov = __so.convert().l_fonc[0]
__srov = __srov.cut(fini, ffin, NOCI_SEISME['PRECISION'],
NOCI_SEISME['CRITERE'])
__srov.vale_y = __srov.vale_y / __srov.vale_x / __srov.vale_x
insp = __srov.trapeze(0.).vale_y[-1]
l_table.append(_F(LISTE_R=fini, PARA='FREQ_INIT'))
l_table.append(_F(LISTE_R=ffin, PARA='FREQ_FIN'))
l_table.append(_F(LISTE_R=amor, PARA='AMOR_REDUIT'))
l_table.append(_F(LISTE_R=insp, PARA='INTE_SPECT'))
if option in ('TOUT', 'DUREE_PHAS_FORT'):
__a2 = __ac * __ac
__i2 = __a2.trapeze(0.)
arias = __i2.vale_y[-1] * math.pi / NOCI_SEISME[
'PESANTEUR'] / 2.
valinf = arias * NOCI_SEISME['BORNE_INF']
valsup = arias * NOCI_SEISME['BORNE_SUP']
for i in range(len(__i2.vale_x)):
ariask = __i2.vale_y[i] * math.pi / NOCI_SEISME[
'PESANTEUR'] / 2.
if ariask >= valinf:
break
for j in range(len(__i2.vale_x) - 1, -1, -1):
ariask = __i2.vale_y[j] * math.pi / NOCI_SEISME[
'PESANTEUR'] / 2.
if ariask <= valsup:
break
dphfor = __i2.vale_x[j] - __i2.vale_x[i]
l_table.append(_F(LISTE_R=dphfor, PARA='DUREE_PHAS_FORT'))
C_out = CREA_TABLE(LISTE=l_table)
if INFO > 1:
IMPR_TABLE(UNITE=6, TABLE=C_out)
return ier
def calc_mode_rotation_ops(self, MATR_RIGI, MATR_MASS, MATR_AMOR, MATR_GYRO,
VITE_ROTA, METHODE, CALC_FREQ, VERI_MODE, **args):
# Macro pour calculer les frequences et modes en fonction des vitesses de rotation
# MATR_RIGI, matrice de raideur
# MATR_MASS, matrice de masse
# MATR_AMOR, matrice d'amortissement
# MATR_GYRO, matrice de gyroscopie
# VITE_ROTA, liste de vitesses de rotation
# METHODE, methode de calcul, QZ par defaut ou SORENSEN
# CALC_FREQ
# VERI_MODE
from Utilitai.Table import Table
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
CALC_MODES = self.get_cmd('CALC_MODES')
COMB_MATR_ASSE = self.get_cmd('COMB_MATR_ASSE')
CREA_TABLE = self.get_cmd('CREA_TABLE')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
motscit = {}
if CALC_FREQ['OPTION'] == 'PLUS_PETITE':
motscit['CALC_FREQ'] = _F(SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_FREQ=CALC_FREQ['NMAX_FREQ'])
else:
motscit['CALC_FREQ'] = _F(SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_FREQ=CALC_FREQ['NMAX_FREQ'],
FREQ=CALC_FREQ['FREQ'])
motscit['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'],
SEUIL=VERI_MODE['SEUIL'],
STURM=VERI_MODE['STURM'],
PREC_SHIFT=VERI_MODE['PREC_SHIFT'])
self.DeclareOut('tab_out', self.sd)
NBV = len(VITE_ROTA)
_mod = [None] * NBV
tab = Table()
for ii in range(0, NBV):
OM = VITE_ROTA[ii]
# ----------------------------------
# Ajout des effets gyroscopiques w*G
# dans la matrice d amortissement C
# ----------------------------------
__gyom = COMB_MATR_ASSE(COMB_R=(
_F(
MATR_ASSE=MATR_GYRO,
COEF_R=OM,
),
_F(
MATR_ASSE=MATR_AMOR,
COEF_R=1.,
),
))
_mod[ii] = CALC_MODES(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
MATR_AMOR=__gyom,
OPTION=CALC_FREQ['OPTION'],
SOLVEUR_MODAL=_F(METHODE=METHODE),
**motscit)
tab.append({
'NUME_VITE': ii,
'VITE_ROTA': OM,
'NOM_OBJET': 'MODE_MECA',
'TYPE_OBJET': 'MODE_MECA',
'NOM_SD': _mod[ii].nom
})
motcles = tab.dict_CREA_TABLE()
tab_out = CREA_TABLE(TYPE_TABLE='TABLE_CONTENEUR', **motcles)
return ier
def calc_stabilite_ops(self, reuse, SCHEMA_TEMPS, FILTRE, **args):
"""
Filtre sur une table mode_non_line.
On evalue egalement la stabilite du systeme
"""
from code_aster.Cata.Syntax import _F
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant est une table_container
self.DeclareOut('t_resu', self.sd)
# On importe les definitions des commandes a utiliser dans la macro
EXTR_TABLE = self.get_cmd('EXTR_TABLE')
t_mnl = args['MODE_NON_LINE'].EXTR_TABLE()
nbord = len(t_mnl.rows)
rows_tab = []
t_res = Table(rows=rows_tab,
para=t_mnl.para,
typ= t_mnl.type,
titr='Table extraite')
if FILTRE:
if FILTRE[0]['NUME_ORDRE']:
l_ordre = FILTRE[0]['NUME_ORDRE']
else:
fmin = FILTRE[0]['FREQ_MIN']
fmax = FILTRE[0]['FREQ_MAX']
prec = FILTRE[0]['PRECISION']
l_ordre = []
for i in range(nbord):
frequence = t_mnl['FREQUENCE'].values()['FREQUENCE'][i]
if frequence > fmin-prec and frequence < fmax+prec:
l_ordre.append(
t_mnl['NUME_ORDRE'].values()['NUME_ORDRE'][i])
else:
l_ordre = t_mnl['NUME_ORDRE'].values()['NUME_ORDRE']
recup_para = 0
for num_ordr in l_ordre:
filtre = {}
filtre['FILTRE'] = _F(NOM_PARA= 'NUME_ORDRE',
VALE_I= num_ordr)
__sol_per = EXTR_TABLE(TABLE= args['MODE_NON_LINE'],
TYPE_RESU= 'MODE_MECA',
NOM_PARA= 'NOM_SD',
**filtre)
if not recup_para:
iret, ibid, kass_name = aster.dismoi(
'REF_RIGI_PREM', __sol_per.nom, 'RESU_DYNA', 'F')
iret, ibid, mass_name = aster.dismoi(
'REF_MASS_PREM', __sol_per.nom, 'RESU_DYNA', 'F')
ctx = CONTEXT.get_current_step().get_contexte_courant()
kass = ctx[kass_name]
masse = ctx[mass_name]
__choc = EXTR_TABLE(TABLE=args['MODE_NON_LINE'],
TYPE_RESU= 'TABLE_SDASTER',
NOM_PARA= 'CARA_CHOC',
**filtre)
t_choc = __choc.EXTR_TABLE()
typ = t_choc['TYPE_CHOC'].values()['TYPE_CHOC']
alpha = t_choc['RIGI_NOR'].values()['RIGI_NOR']
eta = t_choc['PARA_REGUL'].values()['PARA_REGUL']
jeu = t_choc['JEU'].values()['JEU']
noeud1 = t_choc['NOEUD_CHOC'].values()['NOEUD_CHOC']
ncmp1 = t_choc['NOM_CMP_1'].values()['NOM_CMP_1']
ncmp2 = t_choc['NOM_CMP_2'].values()['NOM_CMP_2']
orig1 = t_choc['ORIG_OBST_X'].values()['ORIG_OBST_X']
orig2 = t_choc['ORIG_OBST_Y'].values()['ORIG_OBST_Y']
orig3 = t_choc['ORIG_OBST_Z'].values()['ORIG_OBST_Z']
nchoc = len(t_choc.rows)
recup_para = 1
t_freq = t_mnl['FREQUENCE'].values()['FREQUENCE']
t_ordre = t_mnl['NUME_ORDRE'].values()['NUME_ORDRE']
t_modes = t_mnl['NB_COEF_FOURIER'].values()['NB_COEF_FOURIER']
for ilig in range(len(t_ordre)):
if t_ordre[ilig] == num_ordr:
freq = t_freq[ilig]
nbmod = t_modes[ilig]
hu = int((nbmod-1)/2)
omega = freq*(2*pi)
[pos1r, ind1, rig] = extr_matr(kass)
[pos2r, ind2, mass] = extr_matr(masse)
#
# ELIMINATION DES CONDITIONS AUX LIMITES DES COEFFICIENTS DE FOURIER
#
u_extend = []
for k in range(1, nbmod + 1):
champ = crea_champ(__sol_per, k)
u_extend.append(champ)
u_extend = transpose(array(u_extend))
u1 = zeros((len(rig), nbmod))
j = 0
for k in range(len(ind1)):
if(ind1[k] == 1):
u1[j,:] = u_extend[k,:]
j = j+1
u = u1/max(jeu)
#
# RECUPERATION DES INDICES OU SE TROUVENT LES DDLS DE CHOCS
#
poschoc = posnoeud(typ, noeud1, ncmp1, ncmp2, pos1r)
orig = zeros(3*nchoc)
for k in range(nchoc):
orig[3*k] = orig1[k]
orig[3*k+1] = orig2[k]
orig[3*k+2] = orig3[k]
# adimensionnement
nd = int(size(u)/(2*hu+1))
vect1 = zeros(nd)
vect1[poschoc[0]-1] = 1.E+00
adim = zeros(3)
rig1 = rig#/adim[0]
mass1 = mass#/adim[1]
alpha1 = alpha#/adim[0]
omega1 = omega#/adim[2]
jeu1 = zeros(nchoc)
for k in range(nchoc):
jeu1[k] = jeu[k]/max(jeu)
nbpas = SCHEMA_TEMPS[0]['NB_INST']
eps = args['TOLERANCE']
info = args['INFO']
UTMESS('I', 'MECANONLINE9_67', vali= num_ordr)
stab = main(u, hu, omega1, rig1, mass1, nchoc, poschoc, orig, typ, alpha1, eta, jeu1, nbpas, eps, info)
i = t_mnl['NUME_ORDRE'].values()['NUME_ORDRE'].index(num_ordr)
if(stab):
t_mnl.rows[i]['STABILITE'] = 'STABLE'
else:
t_mnl.rows[i]['STABILITE'] = 'INSTABLE'
t_res.rows.append(t_mnl.rows[i])
if self.reuse:
# surcharge de la table
t_res.rows = []
for i in range(nbord):
t_res.rows.append(t_mnl.rows[i])
DETRUIRE = self.get_cmd('DETRUIRE')
DETRUIRE(CONCEPT=_F(NOM=args['MODE_NON_LINE']), INFO=1)
CREA_TABLE = self.get_cmd('CREA_TABLE')
tab = t_res.dict_CREA_TABLE()
t_resu = CREA_TABLE(TYPE_TABLE='TABLE_CONTENEUR', **tab)
return
def post_coque_ops(self, RESULTAT, COOR_POINT, CHAM, NUME_ORDRE, INST, **args):
"""
macro post_coque
"""
import aster
import os
import string
import Accas
from code_aster.Cata.Syntax import _F
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Utilitai.Table import Table
from Noyau.N_utils import AsType
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_TABLE = self.get_cmd('CREA_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
CALC_CHAMP = self.get_cmd('CALC_CHAMP')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
MasquerAlarme('MODELISA4_9')
# Le concept sortant (de type table) est nomme
# 'tabout' dans le contexte de la macro
self.DeclareOut('tabout', self.sd)
assert AsType(RESULTAT).__name__ in (
'evol_elas',
'evol_noli',
)
dico = RESULTAT.LIST_CHAMPS()
dico2 = RESULTAT.LIST_VARI_ACCES()
# si ni INST ni NUME_ORDRE ne sont presents, on prend le premier
# instant calcule
if not INST and not NUME_ORDRE:
INST = dico2['INST'][0]
iret, ibid, n_modele = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT',
'F')
MODEL = self.get_concept(n_modele)
if NUME_ORDRE:
if not NUME_ORDRE in dico2['NUME_ORDRE']:
UTMESS('F', 'POST0_25', vali=NUME_ORDRE)
else:
if not INST in dico2['INST']:
UTMESS('F', 'POST0_26', valr=INST)
#
if NUME_ORDRE:
if CHAM == 'EFFORT':
if not NUME_ORDRE in dico['EFGE_ELNO']:
if NUME_ORDRE in dico['DEPL']:
CALC_CHAMP(RESULTAT=RESULTAT,
reuse=RESULTAT,
CONTRAINTE='EFGE_ELNO',
NUME_ORDRE=NUME_ORDRE)
else:
UTMESS('F', 'POST0_19', vali=NUME_ORDRE)
elif CHAM == 'DEFORMATION':
if not NUME_ORDRE in dico['DEGE_ELNO']:
if NUME_ORDRE in dico['DEPL']:
CALC_CHAMP(RESULTAT=RESULTAT,
reuse=RESULTAT,
DEFORMATION='DEGE_ELNO',
NUME_ORDRE=NUME_ORDRE)
else:
UTMESS('F', 'POST0_19', vali=NUME_ORDRE)
dico = RESULTAT.LIST_CHAMPS()
# Appel MACR_LIGN_COUPE :
motscles = {}
if CHAM == 'EFFORT':
motscles['NOM_CHAM'] = 'EFGE_ELNO'
if CHAM == 'DEFORMATION':
motscles['NOM_CHAM'] = 'DEGE_ELNO'
if CHAM == 'EFFORT':
motscles['LIGN_COUPE'] = []
iocc = 0
for m in COOR_POINT:
iocc = iocc + 1
lst = m['COOR']
if len(lst) == 4 and lst[3] != 0.:
UTMESS('A', 'POST0_21', vali=iocc, valr=lst[3])
lst = lst[0:3]
motscles['LIGN_COUPE'].append(
_F(
TYPE='SEGMENT',
NB_POINTS=2,
COOR_ORIG=lst,
COOR_EXTR=lst,
DISTANCE_MAX=10.0,
), )
__tabl = MACR_LIGN_COUPE(RESULTAT=RESULTAT, **motscles)
if CHAM == 'DEFORMATION':
motscles['LIGN_COUPE'] = []
iocc = 0
for m in COOR_POINT:
iocc = iocc + 1
lst = m['COOR']
if len(lst) != 4:
UTMESS('F', 'POST0_22', vali=iocc)
else:
lst = lst[0:3]
motscles['LIGN_COUPE'].append(
_F(
TYPE='SEGMENT',
NB_POINTS=2,
COOR_ORIG=lst,
COOR_EXTR=lst,
DISTANCE_MAX=10.0,
), )
__tabl = MACR_LIGN_COUPE(RESULTAT=RESULTAT, **motscles)
tab2 = __tabl.EXTR_TABLE()
if NUME_ORDRE:
tab3 = (tab2.NUME_ORDRE == NUME_ORDRE)
else:
tab3 = (tab2.INST == INST)
tab2 = tab3
tab4 = Table()
ilig = 0
for ligne in tab2:
ilig = ilig + 1
if (ilig % 2) == 0:
tab4.append(ligne)
tab4 = tab4[tab2.para]
#
# on cree une table(dege) bidon qu'on va surcharger
#
if CHAM == 'DEFORMATION':
motscles['NOM_CHAM'] = 'DEGE_ELNO'
motscles['LIGN_COUPE'] = []
tabz = []
iocc = 0
for m in COOR_POINT:
iocc = iocc + 1
lst = m['COOR']
z = lst[3]
tabz.append(z)
lst = lst[0:3]
motscles['LIGN_COUPE'].append(
_F(
TYPE='SEGMENT',
NB_POINTS=2,
COOR_ORIG=lst,
COOR_EXTR=lst,
DISTANCE_MAX=10.0,
), )
__tabeps = MACR_LIGN_COUPE(RESULTAT=RESULTAT, **motscles)
__teps = CALC_TABLE(
TABLE=__tabeps,
ACTION=(
_F(OPERATION='RENOMME', NOM_PARA=('EXX', 'EPXX')),
_F(OPERATION='RENOMME', NOM_PARA=('EYY', 'EPYY')),
_F(OPERATION='RENOMME', NOM_PARA=('EXY', 'EPZZ')),
_F(OPERATION='RENOMME', NOM_PARA=('KXX', 'EPXY')),
_F(OPERATION='RENOMME', NOM_PARA=('KYY', 'EPXZ')),
_F(OPERATION='RENOMME', NOM_PARA=('KXY', 'EPYZ')),
_F(OPERATION='EXTR',
NOM_PARA=(
'INTITULE',
'NOM_CHAM',
'NUME_ORDRE',
'INST',
'ABSC_CURV',
'COOR_X',
'COOR_Y',
'COOR_Z',
'EPXX',
'EPYY',
'EPZZ',
'EPXY',
'EPXZ',
'EPYZ',
)),
),
)
tabep2 = __teps.EXTR_TABLE()
if NUME_ORDRE:
tabep3 = (tabep2.NUME_ORDRE == NUME_ORDRE)
else:
tabep3 = (tabep2.INST == INST)
tabep2 = tabep3
tabep4 = Table()
ilig = 0
for ligne in tabep2:
ilig = ilig + 1
if (ilig % 2) == 0:
tabep4.append(ligne)
tabep4 = tabep4[tabep2.para]
iligout = 0
for ligout in tabep4:
iligout = iligout + 1
iligin = 0
for ligin in tab4:
iligin = iligin + 1
if (iligout == iligin):
ligout['EPXX'] = ligin['EXX'] + ligin['KXX'] * tabz[iligout
- 1]
ligout['EPYY'] = ligin['EYY'] + ligin['KYY'] * tabz[iligout
- 1]
ligout['EPXY'] = ligin['EXY'] + ligin['KXY'] * tabz[iligout
- 1]
ligout['EPZZ'] = 0.0
ligout['EPXZ'] = ligin['GAX'] * 0.5
ligout['EPYZ'] = ligin['GAY'] * 0.5
if CHAM == 'EFFORT':
dprod = tab4.dict_CREA_TABLE()
elif CHAM == 'DEFORMATION':
dprod = tabep4.dict_CREA_TABLE()
tabout = CREA_TABLE(TYPE_TABLE='TABLE', **dprod)
RetablirAlarme('MODELISA4_9')
return ier