def asseChamp(self, depl1, depl2):
from code_aster.Cata.Commands import CREA_CHAMP
_depl = CREA_CHAMP(
TYPE_CHAM='NOEU_DEPL_R',
OPERATION='ASSE',
MODELE=self.model,
ASSE=(
_F(
TOUT='OUI',
CHAM_GD=depl1,
NOM_CMP=('DY', 'DZ'),
CUMUL='NON',
),
_F(
TOUT='OUI',
CHAM_GD=depl2,
NOM_CMP=('DY', 'DZ'),
CUMUL='OUI',
),
_F(TOUT='OUI',
CHAM_GD=depl2,
NOM_CMP=('DX', ),
CUMUL='NON',
COEF_R=0.0),
),
)
return _depl
def mcf_archimede_nodal(self):
"""Retourne les mots-clés facteurs pour AFFE_CHAR_MECA/FORCE_NODALE
dans la prise en compte de la poussée d Archimede."""
from code_aster.Cata.Syntax import _F
mcf = []
mcf.append(_F(
GROUP_NO='PS_' + self.idAST,
FX=self.AFEBSU_1,
), )
mcf.append(_F(
GROUP_NO='PI_' + self.idAST,
FX=self.AFEBIN_1,
), )
mcf.append(
_F(
GROUP_NO='G_' + self.idAST + '_' + str(1),
FX=self.AFGRE_1 / 4.,
), )
for igr in range(1, self.NBGR - 1):
mcf.append(
_F(
GROUP_NO='G_' + self.idAST + '_' + str(igr + 1),
FX=self.AFGRM_1 / 4.,
), )
mcf.append(
_F(
GROUP_NO='G_' + self.idAST + '_' + str(self.NBGR),
FX=self.AFGRE_1 / 4.,
), )
return mcf
def __add__(self, other):
from SD.sd_nume_equa import sd_nume_equa
from code_aster.Cata.Syntax import _F
from code_aster.Cata.Commands.crea_champ import CREA_CHAMP
# on recupere le type
__nume_ddl = sd_nume_equa(self.sdj.REFE.get()[1])
__gd = __nume_ddl.REFN.get()[1].strip()
__type = 'NOEU_' + __gd
# on recupere le nom du maillage
__nomMaillage = self.sdj.REFE.get()[0].strip()
# on recupere l'objet du maillage
__maillage = self.parent.get_concept(__nomMaillage)
__CHAM = CREA_CHAMP(OPERATION='ASSE',
MAILLAGE=__maillage,
TYPE_CHAM=__type,
INFO=1,
ASSE=(
_F(CHAM_GD=self,
TOUT='OUI',
CUMUL='OUI',
COEF_R=1.),
_F(CHAM_GD=other,
TOUT='OUI',
CUMUL='OUI',
COEF_R=1.),
))
return __CHAM
def LIRE_GMSH(self,
UNITE_GMSH=19,
UNITE_MAILLAGE=20,
MODI_QUAD='NON',
CREA_GROUP_NO='OUI'):
"""
Lecture du maillage (format Aster) a partir de sa definition
(format sup_gmsh)
UNITE_GMSH = Numero d'unite logique pour le fichier msh
UNITE_MAILLAGE = Numero d'unite logique pour le fichier mail
MODI_QUAD = 'OUI' si line->quad, 'NON' sinon
CREA_GROUP_NO = 'OUI' si on cree les group_no, 'NON' sinon
"""
nom_gmsh = 'fort.' + repr(UNITE_GMSH)
self.Create(nom_gmsh)
PRE_GMSH(UNITE_GMSH=UNITE_GMSH, UNITE_MAILLAGE=UNITE_MAILLAGE)
_SMESH00 = LIRE_MAILLAGE(FORMAT='ASTER', UNITE=UNITE_MAILLAGE)
DEFI_FICHIER(ACTION='LIBERER', UNITE=UNITE_GMSH)
DEFI_FICHIER(ACTION='LIBERER', UNITE=UNITE_MAILLAGE)
if MODI_QUAD == 'OUI' and self.order == 2:
raise Exception('The finite elements are already of second order')
if MODI_QUAD == 'OUI' and self.order <> 2:
_SMESH01 = CREA_MAILLAGE(MAILLAGE=_SMESH00,
LINE_QUAD=_F(TOUT='OUI'))
DETRUIRE(CONCEPT=_F(NOM=_SMESH00), INFO=1)
_SMESH00 = _SMESH01
_SMESH00 = self.Name(_SMESH00, CREA_GROUP_NO)
return _SMESH00
def thyc_load(self):
"""Return the loading due to the fluid flow"""
coeur = self.coeur
thyc = read_thyc(coeur, self.model, self.mcf['UNITE_THYC'])
fmult_ax = coeur.definition_temp_hydro_axiale()
fmult_tr = coeur.definition_effort_transverse()
load_ax = [
_F(
CHARGE=thyc.chax_nodal,
FONC_MULT=fmult_ax,
),
_F(
CHARGE=thyc.chax_poutre,
FONC_MULT=fmult_ax,
),
]
load_tr = [
_F(
CHARGE=thyc.chtr_nodal,
FONC_MULT=fmult_tr,
),
_F(
CHARGE=thyc.chtr_poutre,
FONC_MULT=fmult_tr,
),
]
self._thyc_ax = (thyc.chax_nodal, thyc.chax_poutre)
self._thyc_tr = (thyc.chtr_nodal, thyc.chtr_poutre)
return (load_ax, load_tr)
def TEST_ECART(self, ch_param2, label_cal, N_pas, Ncal, ch_param, __RSI,
prec_ecart, prec_zero):
from code_aster.Cata.Syntax import _F
DETRUIRE = self.get_cmd('DETRUIRE')
FORMULE = self.get_cmd('FORMULE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
# Exploitations
CH_V1 = ['INST']
C_Pa = 1.e6
ersi = []
for ch in ch_param2:
# CALCUL des ecarts relatifs
i = ch_param2.index(ch)
chref1 = ch + label_cal[4] + str(N_pas[4])
chref2 = ch + label_cal[Ncal - 1] + str(N_pas[Ncal - 1])
chref = [chref1, chref2]
preczero = prec_zero[i]
__ersi = None
for j in range(Ncal):
coef = 1.
ch_cal = ch + label_cal[j] + str(N_pas[j])
ch_err = 'ER_' + ch_cal
if j < 4:
if (j == 0 and i > 0 and i < 9):
coef = 1 / C_Pa
iref = 0
else:
iref = 1
if (i == 0):
CH_V1.append(ch_cal)
# calcul de l'erreur (ecart relatif)
valfor = 'ERREUR(%s,%s,%e,%f)' % (ch_cal, chref[iref], preczero,
coef)
nompar1 = '%s' % (ch_cal)
nompar2 = '%s' % (chref[iref])
__errrel = FORMULE(NOM_PARA=(nompar1, nompar2), VALE=valfor)
if __ersi == None:
__ersi = CALC_TABLE(
TABLE=__RSI[i],
TITRE='__RSI' + str(j),
ACTION=(_F(OPERATION='OPER',
NOM_PARA=ch_err,
FORMULE=__errrel), ),
)
else:
__ersi = CALC_TABLE(
TABLE=__ersi,
reuse=__ersi,
TITRE='__RSI' + str(j),
ACTION=(_F(OPERATION='OPER',
NOM_PARA=ch_err,
FORMULE=__errrel), ),
)
DETRUIRE(CONCEPT=_F(NOM=__errrel, ), INFO=1)
ersi.append(__ersi)
return ersi
def TEST_ECART(ch_param2, label_cal, N_pas, Ncal, ch_param, R_SI, prec_ecart,
prec_zero, C_Pa):
# Exploitations
CH_V1 = ['INST']
for ch in ch_param2:
# CALCUL des ecarts relatifs
i = ch_param2.index(ch)
chref1 = ch + label_cal[4] + str(N_pas[4])
chref2 = ch + label_cal[Ncal - 1] + str(N_pas[Ncal - 1])
chref = [chref1, chref2]
for j in range(Ncal):
coef = 1.
ch_cal = ch + label_cal[j] + str(N_pas[j])
ch_err = 'ER_' + ch_cal
if j < 4:
if (j == 0 and i > 0 and i < 9):
coef = 1 / C_Pa
iref = 0
else:
iref = 1
if (i == 0):
CH_V1.append(ch_cal)
# calcul de l'erreur (ecart relatif)
preczero = prec_zero[i]
ch_for = 'relative_error(' + ch_cal + ',' + chref[
iref] + ',' + str(coef) + ',' + str(preczero) + ')'
ERR_REL = FORMULE(NOM_PARA=(ch_cal, chref[iref]),
VALE=ch_for,
relative_error=relative_error)
R_SI[i] = CALC_TABLE(
TABLE=R_SI[i],
reuse=R_SI[i],
TITRE='R_SI' + str(j),
ACTION=(_F(OPERATION='OPER', NOM_PARA=ch_err,
FORMULE=ERR_REL), ),
)
DETRUIRE(CONCEPT=_F(NOM=ERR_REL, ), )
for j in range(Ncal):
ch_cal = ch + label_cal[j] + str(N_pas[j])
ch_err = 'ER_' + ch_cal
TEST_TABLE(
TABLE=R_SI[i],
NOM_PARA=ch_err,
TYPE_TEST='MAX',
VALE_CALC=0.,
TOLE_MACHINE=prec_ecart[j],
VALE_REFE=0.,
CRITERE='ABSOLU',
PRECISION=prec_ecart[j],
REFERENCE='ANALYTIQUE',
)
return
def get_filtres(grp_no, grp_ma):
filtres = []
for grp in grp_no:
filtres.append(_F(GROUP_NO=grp["NOM"],
DDL_ACTIF=grp["NOM_CMP"],
NOM_CHAM='DEPL'))
for grp in grp_ma:
filtres.append(_F(GROUP_MA=grp["NOM"],
DDL_ACTIF=grp["NOM_CMP"],
NOM_CHAM='DEPL'))
return filtres
def TEST_ECART(ch_param2, label_cal, N_pas, Ncal, nbequi, R_SI, prec_ecart,
prec_zero, coef_para):
# CALCUL des ecarts relatifs
CH_V1 = ['INST']
for ch in ch_param2:
i = ch_param2.index(ch)
chref1 = ch + label_cal[nbequi] + str(N_pas[nbequi])
chref2 = ch + \
label_cal[Ncal - nbequi + 1] + str(N_pas[Ncal - nbequi + 1])
chref = [chref1, chref2]
# chref1 utilisé pour les calculs équivalents, chref2 pour la
# discretisation en temps
for j in range(Ncal):
coef = 1.0
ch_cal = ch + label_cal[j] + str(N_pas[j])
ch_err = 'ER_' + ch_cal
if j < nbequi:
if (j == 0):
coef = 1 / coef_para[i]
iref = 0
else:
iref = 1
if (i == 0):
CH_V1.append(ch_cal)
# calcul de l'erreur (ecart relatif)
preczero = prec_zero[i]
ch_for = 'relative_error(' + ch_cal + ',' + chref[
iref] + ',' + str(coef) + ',' + str(preczero) + ')'
ERR_REL = FORMULE(NOM_PARA=(ch_cal, chref[iref]),
VALE=ch_for,
relative_error=relative_error)
R_SI[i] = CALC_TABLE(
TABLE=R_SI[i],
reuse=R_SI[i],
TITRE='R_SI' + str(j),
ACTION=(_F(OPERATION='OPER', NOM_PARA=ch_err,
FORMULE=ERR_REL), ),
)
DETRUIRE(CONCEPT=_F(NOM=ERR_REL, ), )
for j in range(Ncal):
ch_cal = ch + label_cal[j] + str(N_pas[j])
ch_err = 'ER_' + ch_cal
TEST_TABLE(
TABLE=R_SI[i],
NOM_PARA=ch_err,
REFERENCE='ANALYTIQUE',
TYPE_TEST='MAX',
VALE_CALC=0,
VALE_REFE=0,
CRITERE='ABSOLU',
TOLE_MACHINE=prec_ecart[j],
PRECISION=prec_ecart[j],
)
return
def mcf_geom_fibre(self):
"""Retourne les mots-clés facteurs pour DEFI_GEOM_FIBRE."""
from code_aster.Cata.Syntax import _F
def vale_4fibres(surf, iner):
"""Retourne les triplets (y, z, val) pour les 4 fibres."""
squart = surf / 4.
excent = (iner / (2 * squart))**0.5
return (0., excent, squart, 0., -excent, squart, excent, 0.,
squart, -excent, 0., squart)
mcf = (
# crayon
_F(
GROUP_FIBRE='CR_' + self.idAST,
COOR_AXE_POUTRE=(0., 0.),
CARA="SURFACE",
VALE=vale_4fibres(
self.S_CR,
self.I_CR,
),
),
# partie courante des tubes-guides
_F(
GROUP_FIBRE='LG_' + self.idAST,
COOR_AXE_POUTRE=(0., 0.),
CARA="SURFACE",
VALE=vale_4fibres(
self.S_TG_C,
self.I_TG_C,
),
),
# biais des tubes-guides
_F(
GROUP_FIBRE='BI_' + self.idAST,
COOR_AXE_POUTRE=(0., 0.),
CARA="SURFACE",
VALE=vale_4fibres(
self.S_TG_B,
self.I_TG_B,
),
),
# retreint des tubes-guides
_F(
GROUP_FIBRE='RE_' + self.idAST,
COOR_AXE_POUTRE=(0., 0.),
CARA="SURFACE",
VALE=vale_4fibres(
self.S_TG_R,
self.I_TG_R,
),
),
)
return mcf
def get_chgt_repere(grp_no, grp_ma):
chgt_reps = []
for grp in grp_no:
if grp["CHGT_REP"]:
chgt_reps.append(_F(GROUP_NO=grp["NOM"],
**grp["CHGT_REP"]))
for grp in grp_ma:
if grp["CHGT_REP"]:
chgt_reps.append(_F(GROUP_MA=grp["NOM"],
**grp["CHGT_REP"]))
return chgt_reps
def macr_ecla_pg_ops(self, RESULTAT, MAILLAGE, RESU_INIT, MODELE_INIT,
TOUT, GROUP_MA, MAILLE,
SHRINK, TAILLE_MIN,
NOM_CHAM, TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, INST, LIST_INST, PRECISION, CRITERE,
**args):
"""
Ecriture de la macro macr_ecla_pg
"""
import os
import string
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
CREA_MAILLAGE = self.get_cmd('CREA_MAILLAGE')
CREA_RESU = self.get_cmd('CREA_RESU')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Appel à CREA_MAILLAGE :
motscles = {}
if TOUT:
motscles['TOUT'] = TOUT
if GROUP_MA:
motscles['GROUP_MA'] = GROUP_MA
if MAILLE:
motscles['MAILLE'] = MAILLE
self.DeclareOut('ma2', MAILLAGE)
ma2 = CREA_MAILLAGE(ECLA_PG=_F(MODELE=MODELE_INIT, NOM_CHAM=NOM_CHAM,
SHRINK=SHRINK, TAILLE_MIN=TAILLE_MIN, **motscles))
# Appel à CREA_RESU :
typ2 = AsType(RESU_INIT).__name__
if TOUT_ORDRE:
motscles['TOUT_ORDRE'] = TOUT_ORDRE
if NUME_ORDRE != None:
motscles['NUME_ORDRE'] = NUME_ORDRE
if LIST_ORDRE:
motscles['LIST_ORDRE'] = LIST_ORDRE
if LIST_INST:
motscles['LIST_INST'] = LIST_INST
if INST != None:
motscles['INST'] = INST
self.DeclareOut('resu2', RESULTAT)
resu2 = CREA_RESU(OPERATION='ECLA_PG', TYPE_RESU=string.upper(typ2),
ECLA_PG=_F(
MODELE_INIT=MODELE_INIT, RESU_INIT=RESU_INIT, NOM_CHAM=NOM_CHAM,
MAILLAGE=ma2, **motscles))
return ier
def deform_mesh_inverse(self, depl):
"""Use the displacement of the result to deform the mesh"""
from code_aster.Cata.Commands import CREA_CHAMP, MODI_MAILLAGE
_depl_inv = CREA_CHAMP(OPERATION='COMB',
TYPE_CHAM='NOEU_DEPL_R',
COMB=_F(CHAM_GD=depl, COEF_R=-1.))
_debug(_depl_inv, "mesh deformation")
_mesh = MODI_MAILLAGE(reuse=self.mesh,
MAILLAGE=self.mesh,
DEFORME=_F(OPTION='TRAN', DEPL=_depl_inv))
del self.mesh
self.mesh = _mesh
def archimede_load(self):
"""Compute the Archimede loadings"""
fmult_arch = self.coeur.definition_temp_archimede(self.use_archimede)
load = [
_F(
CHARGE=self.coeur.definition_archimede_nodal(self.model),
FONC_MULT=fmult_arch,
),
_F(
CHARGE=self.coeur.definition_archimede_poutre(self.model),
FONC_MULT=fmult_arch,
),
]
return load
def mcf_archimede_poutre(self, FXTG, FXCR):
"""Retourne les mots-clés facteurs pour AFFE_CHAR_MECA_F/FORCE_POUTRE
dans la prise en compte de la poussée d Archimede."""
from code_aster.Cata.Syntax import _F
mcf = (
_F(
GROUP_MA='TG_' + self.idAST,
FX=FXTG,
),
_F(
GROUP_MA='CR_' + self.idAST,
FX=FXCR,
),
)
return mcf
def extr_temps(self):
"""Extraction des instants d'etude dans la Tempo qui contient
les temporels mesures"""
from code_aster.Cata.Commands import RECU_FONCTION
from code_aster.Cata.Commands import DETRUIRE
tabl_py = self.obj.EXTR_TABLE()
toto = tabl_py['FONCTION']
nom_fonc = toto.values()['FONCTION'][0]
__FONC = RECU_FONCTION(TABLE=self.obj,
NOM_PARA_TABL='FONCTION',
FILTRE=_F(NOM_PARA='FONCTION', VALE_K=nom_fonc))
temps = __FONC.Absc()
DETRUIRE(CONCEPT=_F(NOM=__FONC), INFO=1)
self.t = temps
self.tempo = 1
def Name(self, MA, CREA_GROUP_NO):
l_gma = []
l_mcf = []
for gma in self.physicals.keys():
l_gma.append(_F(NOM=gma))
l_mcf.append(_F(GROUP_MA=self.physicals[gma], NOM=gma))
_SMESH02 = COPIER(CONCEPT=MA)
DEFI_GROUP(
reuse=_SMESH02,
MAILLAGE=_SMESH02,
CREA_GROUP_MA=tuple(l_mcf),
DETR_GROUP_MA=tuple(l_gma),
)
DETRUIRE(CONCEPT=_F(NOM=MA), INFO=1)
if CREA_GROUP_NO == 'OUI':
DEFI_GROUP(
reuse=_SMESH02,
MAILLAGE=_SMESH02,
CREA_GROUP_NO=_F(TOUT_GROUP_MA='OUI'),
)
else:
# Traitement des GROUP_NO qui sont des points
info_gno = _SMESH02.LIST_GROUP_NO()
l_gno = []
for gno in info_gno:
if gno[1] == 1:
l_gno.append(gno[0])
l_gma = []
for gma in self.physicals.keys():
nom_gmsh = self.physicals[gma]
if nom_gmsh in l_gno:
l_gma.append(gma)
if l_gma:
DEFI_GROUP(
reuse=_SMESH02,
MAILLAGE=_SMESH02,
CREA_GROUP_NO=_F(GROUP_MA=tuple(l_gma)),
)
return _SMESH02
def create_host_sd(self):
# on cree la SD resultat - factice
# (le champ ACCE sera remplace dans la suite par celui calcule)
__impe = LIRE_IMPE_MISS(
BASE=self.mat_gene_params['BASE'],
TYPE=self.calc_params['TYPE'],
NUME_DDL_GENE=self.mat_gene_params['NUME_DDL'],
UNITE_RESU_IMPE=self.calc_params['UNITE_RESU_IMPE'],
ISSF=self.calc_params['ISSF'],
FREQ_EXTR=self.FREQ_PAS,
)
__rito = COMB_MATR_ASSE(
COMB_C=(
_F(
MATR_ASSE=__impe,
COEF_C=1.0 + 0.j,
),
_F(
MATR_ASSE=self.mat_gene_params['MATR_RIGI'],
COEF_C=1.0 + 0.j,
),
),
SANS_CMP='LAGR',
)
# on fixe la composante car sa valeur n'a pas d'importance
__fosi = LIRE_FORC_MISS(
BASE=self.mat_gene_params['BASE'],
NUME_DDL_GENE=self.mat_gene_params['NUME_DDL'],
NOM_CMP='DX',
NOM_CHAM='DEPL',
ISSF=self.calc_params['ISSF'],
UNITE_RESU_FORC=self.calc_params['UNITE_RESU_FORC'],
FREQ_EXTR=self.FREQ_PAS,
)
__dyge0 = DYNA_VIBRA(
TYPE_CALCUL='HARM',
BASE_CALCUL='GENE',
MATR_MASS=self.mat_gene_params['MATR_MASS'],
MATR_RIGI=__rito,
TOUT_CHAM='OUI',
FREQ=self.liste_freq_sig,
EXCIT=_F(
VECT_ASSE_GENE=__fosi,
COEF_MULT_C=1.,
),
)
return __dyge0
def compute_mecmode(NOM_CMP, GROUP_NO_INTER, resultat, nbmods, nbmodd):
dict_modes = {}
dict_modes['NUME_MODE'] = range(nbmods)
dict_modes['MCMP'] = []
dict_modes['som'] = []
dict_modes['maxm'] = []
for mods in range(nbmods):
nmo = nbmodd + mods + 1
__CHAM = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
NUME_ORDRE=nmo,
RESULTAT=resultat,
NOM_CHAM='DEPL')
MCMP = __CHAM.EXTR_COMP(NOM_CMP, [GROUP_NO_INTER]).valeurs
#on recupere la composante COMP (dx,dy,dz) des modes
MCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], 0).valeurs
if mods == 0:
NCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], topo=1).comp
nddi = len(MCMP2)
dict_modes['NCMP2'] = NCMP2
dict_modes['nddi'] = nddi
PHI = NP.zeros((nddi, nbmods))
PHI[:, mods] = MCMP2
som = NP.sum(MCMP)
max1 = NP.max(MCMP)
min1 = NP.min(MCMP)
maxm = NP.max([abs(max1), abs(min1)])
dict_modes['som'].append(som)
dict_modes['maxm'].append(maxm)
dict_modes['MCMP'].append(MCMP)
DETRUIRE(CONCEPT=_F(NOM=(__CHAM)), INFO=1)
dict_modes['PHI'] = PHI
return dict_modes
def test_table(self, obj):
""" test si la table est composee de fonctions et si ces
fonctions sont temporelles ou frequentielles"""
from code_aster.Cata.Commands import RECU_FONCTION
table_py = obj.EXTR_TABLE()
paras = table_py.para
if 'FONCTION_C' in paras:
type_fonc = 'FONCTION_C'
elif 'FONCTION' in paras:
type_fonc = 'FONCTION'
else:
return
toto = table_py[type_fonc]
try:
nom_fonc = toto.values()[type_fonc][0]
except IndexError:
return # deja vu : des tables avec lacolonne fonction vide...
__FONC = RECU_FONCTION(TABLE=obj,
NOM_PARA_TABL=type_fonc,
FILTRE=_F(NOM_PARA=type_fonc, VALE_K=nom_fonc))
nom_para = __FONC.Parametres()['NOM_PARA']
if nom_para == 'INST':
return 'tempo'
elif nom_para == 'FREQ':
return 'intespec'
else:
return
def lance_modif_struct_calcul(macro, ce_objects,
MODIFSTRUCT,
GROUP_NO_CAPTEURS,
GROUP_NO_EXTERIEUR,
out_modifstru):
"""Démarre le calcul CALC_ESSAI sur la structure modifiée.
:param macro: la macro étape CALC_ESSAI.
:param ce_objects: les objects, utilisés par le module CALC_ESSAI,
présents dans la mémoire JEVEUX au moment
de la macro étape.
:param MODIFSTRUCT: la macro étape permettant le calcul de la structure
modifiée depuis le fichier de commande Aster.
:param CAPTEURS: dictionaire (ou FACT) contenant les choix
de groupes de noeuds et leurs degrés de liberté
pour les capteurs.
:param EXTERIEUR: dictionaire (ou FACT) contenant les choix
de groupes de noeuds et leurs degrés de liberté
pour les ddl exterieurs.
:param out_modifstru: dictionaire (ou FACT) utilisé pour les résultats."""
from code_aster.Cata.Syntax import _F
from Calc_essai.ce_calcul_modifstruct import CalcEssaiModifStruct
modif_struct = CalcEssaiModifStruct(macro, ce_objects,
ce_objects.mess, out_modifstru)
modif_struct.find_experimental_result_from(MODIFSTRUCT["MESURE"].nom)
modif_struct.find_support_modele_from(MODIFSTRUCT["MODELE_SUP"].nom)
modif_struct.set_stiffness_matrix(MODIFSTRUCT["MATR_RIGI"])
modif_struct.set_method_name(MODIFSTRUCT["RESOLUTION"])
modif_struct.set_sensor_groups(to_dict_lst(GROUP_NO_CAPTEURS))
modif_struct.set_interface_groups(to_dict_lst(GROUP_NO_EXTERIEUR))
modif_struct.set_modes_ide(MODIFSTRUCT["NUME_MODE_MESU"])
modif_struct.set_modes_expansion(MODIFSTRUCT["NUME_MODE_CALCUL"])
modif_struct.set_sumail_name("SUMAIL") # nom super-maille par defaut
modif_struct.find_modele_modif_from(MODIFSTRUCT["MODELE_MODIF"].nom)
modif_struct.find_maillage_modif_from(MODIFSTRUCT["MODELE_MODIF"].nom)
modif_struct.get_modele_support()
modif_struct.calc_base_proj()
modif_struct.set_param_condens(
{'METHODE': 'SVD', 'EPS': 1.0E-5, 'REGUL': 'NON'})
modif_struct.creation_modele_couple()
mode_simult = 1 # methode utilisee : MODE_ITER_SIMULT
calc_freq = _F(OPTION='PLUS_PETITE',
NMAX_FREQ=20,
SEUIL_FREQ=1.E-4,)
calc_freq['SEUIL_FREQ'] = 1e-4
modif_struct.calc_modes_modele_couple(mode_simult, calc_freq)
def temps_CPU(restant_old, temps_iter_old):
"""
Fonction controlant le temps restant
"""
__cpu = INFO_EXEC_ASTER(LISTE_INFO=("TEMPS_RESTANT",))
TEMPS = __cpu['TEMPS_RESTANT', 1]
DETRUIRE(CONCEPT=_F(NOM=__cpu), INFO=1)
err = 0
# Indique une execution interactive
if (TEMPS > 1.E+9):
return 0., 0., 0
# Indique une execution en batch
else:
restant = TEMPS
# Initialisation
if (restant_old == 0.):
temps_iter = -1.
else:
# Première mesure
if (temps_iter_old == -1.):
temps_iter = (restant_old - restant)
# Mesure courante
else:
temps_iter = (temps_iter_old + (restant_old - restant)) / 2.
if ((temps_iter > 0.96 * restant)or(restant < 0.)):
err = 1
msg = MessageLog.GetText('F', 'RECAL0_53')
raise CPU_Exception, msg
return restant, temps_iter, err
def cree_resultat_aster(self):
"""Produit le(s) fichier(s) issu(s) d'Aster."""
self._dbg_trace("Start")
ulaster = self.param.UL.Libre(action='ASSOCIER')
mael = self.param['MACR_ELEM_DYNA']
if mael is None:
opts = {}
if self.param['MATR_RIGI']:
opts['MATR_RIGI'] = self.param['MATR_RIGI']
if self.param['MATR_MASS']:
opts['MATR_MASS'] = self.param['MATR_MASS']
__mael = MACR_ELEM_DYNA(BASE_MODALE=self.param['BASE_MODALE'],
**opts)
mael = __mael
if self.param['_hasPC']:
grma = self.param['GROUP_MA_CONTROL']
self.param.set('_nbPC', get_number_PC(self.parent, mael, grma))
other_groups = {}
if self.param['ISSF'] == 'OUI':
other_groups = _F(
GROUP_MA_FLU_STR=self.param['GROUP_MA_FLU_STR'],
GROUP_MA_FLU_SOL=self.param['GROUP_MA_FLU_SOL'],
GROUP_MA_SOL_SOL=self.param['GROUP_MA_SOL_SOL'],)
IMPR_MACR_ELEM(MACR_ELEM_DYNA=mael,
FORMAT='MISS_3D',
GROUP_MA_INTERF=self.param['GROUP_MA_INTERF'],
GROUP_MA_CONTROL=self.param.get('GROUP_MA_CONTROL'),
FORMAT_R='1PE16.9',
SOUS_TITRE='PRODUIT PAR CALC_MISS',
UNITE=ulaster,
**other_groups)
self.param.UL.EtatInit(ulaster)
copie_fichier(self.param.UL.Nom(ulaster), self._fichier_tmp("aster"))
self.data = self.resu_aster_reader.read(self._fichier_tmp("aster"))
self._dbg_trace("Stop")
def nume_ddl_phy(resu):
"""Fabrication d'une numerotation des DDL actifs associes a une sd resultat
retourne ['N1_DX','N1_DY','N1_DZ','N2_DZ','N3_DZ'...] dans l'ordre alpha-numerique"""
from code_aster.Cata.Commands import CREA_CHAMP, DETRUIRE
__CHAMP0 = CREA_CHAMP(RESULTAT=resu.obj,
OPERATION='EXTR',
NUME_ORDRE=1,
TYPE_CHAM='NOEU_DEPL_R',
NOM_CHAM='DEPL')
champy0 = __CHAMP0.EXTR_COMP(topo=1)
num_no = champy0.noeud
comp = champy0.comp
nb_ddl = len(comp)
# Recherche des noms des noeuds associes a leur numero
maya = resu.maya
nume = []
for ind in range(nb_ddl):
nom_no = maya.sdj.NOMNOE.get()[num_no[ind] - 1]
nume.append(nom_no.strip() + '_' + comp[ind].strip())
DETRUIRE(
CONCEPT=_F(NOM=(__CHAMP0, ), ),
INFO=1,
)
return nume
def periodic_cond(self):
"""Define the boundary conditions of periodicity"""
from code_aster.Cata.Commands import AFFE_CHAR_MECA
def equal(ddl, grno1, grno2):
"""Return keyword to set ddl(grno1) = ddl(grno2)"""
return _F(GROUP_NO_1=grno1,
GROUP_NO_2=grno2,
SOMMET='OUI',
DDL_1=ddl,
DDL_2=ddl,
COEF_MULT_1=1.,
COEF_MULT_2=-1.,
COEF_IMPO=0.)
liaison_group = [
equal('DY', 'PMNT_S', 'PEBO_S'),
equal('DZ', 'PMNT_S', 'PEBO_S'),
equal('DY', 'PSUP', 'PEBO_S'),
equal('DZ', 'PSUP', 'PEBO_S'),
equal('DY', 'PINF', 'FIX'),
equal('DZ', 'PINF', 'FIX'),
]
_excit = AFFE_CHAR_MECA(MODELE=self.model, LIAISON_GROUP=liaison_group)
return [
_F(CHARGE=_excit),
]
def _debug(arg, label, dest='RESULTAT'):
"""Generic function for debugging
:param arg: object to print
:type arg: ASSD, string or iterable
:param dest: output 'MESSAGE' or 'RESULTAT'
:type dest: string
"""
if not DEBUG:
return
from code_aster.Cata.Commands import IMPR_CO
from code_aster.Cata.Syntax import _F, ASSD, MCFACT
show = partial(aster.affiche, dest)
if isinstance(arg, ASSD):
show("#DEBUG: {} >>> {} <{}>".format(label, arg.nom, arg.__class__))
IMPR_CO(UNITE=8 if dest == 'RESULTAT' else 6,
CONCEPT=_F(NOM=arg),
NIVEAU=-1)
else:
if type(arg) in (str, unicode):
arg = convert(arg)
else:
try:
if isinstance(arg, _F):
arg = [arg[i] for i in arg]
for obj in arg:
_debug(obj, label, dest)
except TypeError:
arg = repr(arg)
else:
return
show("#DEBUG: {} >>> {}".format(label, arg))
def vessel_dilatation_load(self):
"""Return the loading due to the vessel dilatation"""
char_dilat = self.coeur.dilatation_cuve(self.model, self.mesh,
(self.char_init != None))
return [
_F(CHARGE=char_dilat, ),
]
def dechargePSC(self, RESU):
from code_aster.Cata.Commands import (CALC_CHAMP, POST_RELEVE_T,
DEFI_FONCTION, AFFE_CHAR_MECA)
coeur = self.coeur
CALC_CHAMP(
reuse=RESU,
RESULTAT=RESU,
INST=coeur.temps_simu['T8'],
FORCE=('FORC_NODA', ),
)
__SPRING = POST_RELEVE_T(ACTION=_F(
INTITULE='FORCES',
GROUP_NO=('PMNT_S'),
RESULTAT=RESU,
NOM_CHAM='FORC_NODA',
NOM_CMP=('DX', ),
REPERE='GLOBAL',
OPERATION='EXTRACTION',
), )
tab2 = __SPRING.EXTR_TABLE()
valeurs = tab2.values()
inst = valeurs['INST'][-1]
fx = valeurs['DX']
noeuds = valeurs['NOEUD']
listarg = []
for el in zip(fx, noeuds):
listarg.append(_F(NOEUD=el[1], FX=el[0]))
assert (inst == coeur.temps_simu['T8'])
_LI2 = DEFI_FONCTION(
NOM_PARA='INST',
PROL_DROITE='CONSTANT',
VALE=(coeur.temps_simu['T8'], 1., coeur.temps_simu['T8b'], 0.),
)
_F_EMB2 = AFFE_CHAR_MECA(
MODELE=self.model,
FORCE_NODALE=listarg,
)
return (_LI2, _F_EMB2)
def build_result(self):
"""Create the result function"""
macr = self.macro
DEFI_FONCTION = macr.get_cmd('DEFI_FONCTION')
IMPR_FONCTION = macr.get_cmd('IMPR_FONCTION')
DEFI_NAPPE = macr.get_cmd('DEFI_NAPPE')
macr.DeclareOut('result', macr.sd)
# common keywords to DEFI_FONCTION & DEFI_NAPPE
para = self.resu.para
for p in ('NOM_PARA', 'NOM_RESU', 'PROL_DROITE', 'PROL_GAUCHE',
'INTERPOL'):
if self.args[p] is not None:
para[p] = self.args[p]
if self.typres is not nappe_sdaster:
if self.typres is fonction_c:
mcval = 'VALE_C'
else:
mcval = 'VALE'
para[mcval] = self.resu.tabul()
result = DEFI_FONCTION(**para)
else:
intf = self.args['INTERPOL_FONC']
prdf = self.args['PROL_DROITE_FONC']
prgf = self.args['PROL_GAUCHE_FONC']
def_fonc = []
for f_i in self.resu.l_fonc:
def_fonc.append(
_F(
VALE=f_i.tabul(),
INTERPOL=intf or f_i.para['INTERPOL'],
PROL_DROITE=prdf or f_i.para['PROL_DROITE'],
PROL_GAUCHE=prgf or f_i.para['PROL_GAUCHE'],
))
npf = 'NOM_PARA_FONC'
if self.args[npf] is not None:
para[npf] = self.args[npf]
result = DEFI_NAPPE(PARA=self.resu.vale_para.tolist(),
DEFI_FONCTION=def_fonc,
**para)
if self.args['INFO'] > 1:
IMPR_FONCTION(
FORMAT='TABLEAU',
UNITE=6,
COURBE=_F(FONCTION=result),
)
def Recup_Noeuds_Copeaux(maya, Copeau_k):
# Recuperation des noeuds appartenant a la surface de symetrie
# et aux copeaux
from code_aster.Cata.Syntax import _F
dicno = []
dicno.append(_F(NOM=Copeau_k))
dicno.append(_F(NOM='Cop_Pl'))
DEFI_GROUP(reuse=maya, MAILLAGE=maya, DETR_GROUP_NO=dicno)
dicno = []
dicno.append(_F(NOM=Copeau_k, GROUP_MA=Copeau_k))
dicno.append(_F(NOM='Cop_Pl', INTERSEC=(
Copeau_k,
'Nds_Plan',
)))
DEFI_GROUP(reuse=maya, MAILLAGE=maya, CREA_GROUP_NO=dicno)