def __init__(self, macro, oper, ctxt, kwargs):
"""Initialization"""
self.macro = macro
self.oper = oper
self.ctxt = ctxt
self.args = kwargs
self.kw = self.args[self.oper]
self.resu = None
self._lf = []
self._dat = None
self.typres = AsType(macro.sd)
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 _build_list_fonc(self, arg='real', mcsimp='FONCTION'):
"""Return the list of functions under mcfact/mcsimp converted
as t_fonction objects.
nappe_sdaster objects are interpolated on the same abscissa."""
lf_in = self._get_mcsimp(mcsimp)
all_nap = min([int(AsType(i) is nappe_sdaster) for i in lf_in]) == 1
if all_nap:
list_fonc = [tf.convert() for tf in lf_in]
list_fonc = homo_support_nappe(list_fonc)
else:
list_fonc = [tf.convert(arg) for tf in lf_in]
self._lf = list_fonc
def putvrr(self, rval):
"""
Sorties:
indicateur sur le type ( 1 = le concept sortant est bien un 'reel',
0 = mauvais type de concept)
Fonction:
renvoyer une valeur entière depuis le fortran vers l'attribut
valeur de la sd 'entier'
"""
if B_utils.Typast(AsType(self.sd)) != 'R8 ':
raise AsException(
"Probleme dans putvrr: %s, n est pas de type reel !" %
(self.sd.nom))
return 0
self.sd.valeur = rval
return 1
def gcucon(self, resul, concep):
"""
Entrees:
resul nom du concept
concep type du concept
Sorties:
iexnum indicateur d existence ( 1 = existe du bon type,
0 = n'existe pas,
-1 = existe d un autre type)
Fonction:
Retourner l indicateur d existence du concept vid avant
la commande en cours
"""
objet_sd = self.parent.get_sd_avant_etape(resul.strip(), self)
if not objet_sd:
ret = 0
elif B_utils.Typast(AsType(objet_sd)).upper() == concep.strip():
ret = 1
else:
ret = -1
# message.debug(SUPERV, "gcucon(%s, '%s') returns %s", resul.strip(),
# concep.strip(), ret)
return ret
def update_sdprod(self, cr='non'):
"""
Cette méthode met à jour le concept produit en fonction des conditions initiales :
1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
2. Le concept retourné n existait pas (self.sd == None)
3. Le concept retourné existait. On change alors son type ou on le supprime
En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
"""
sd_prod = self.definition.sd_prod
# On memorise le type retourné dans l attribut typret
self.typret = None
if type(sd_prod) == types.FunctionType:
# Type de concept retourné calculé
d = self.cree_dict_valeurs(self.mc_liste)
try:
# la sd_prod d'une macro a l'objet lui meme en premier argument
# contrairement à une ETAPE ou PROC_ETAPE
# Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
# les concepts produits dans self.sdprods, il faut le mettre à
# zéro
self.sdprods = []
sd_prod = apply(sd_prod, (self, ), d)
except:
# Erreur pendant le calcul du type retourné
if CONTEXT.debug:
traceback.print_exc()
self.sd = None
if cr == 'oui':
l = traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2])
self.cr.fatal(
_(u'Impossible d affecter un type au résultat\n%s'),
' '.join(l[2:]))
return 0
# on teste maintenant si la SD est r\351utilis\351e ou s'il faut la
# cr\351er
valid = 1
if self.reuse:
# Un concept reutilise a ete specifie
if AsType(self.reuse) != sd_prod:
if cr == 'oui':
self.cr.fatal(
_(u'Type de concept réutilisé incompatible avec type produit'
))
valid = 0
if self.sdnom != '':
if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
# Le nom de la variable de retour (self.sdnom) doit etre le
# meme que celui du concept reutilise (self.reuse.nom)
if cr == 'oui':
self.cr.fatal(
_(u'Concept réutilisé : le nom de la variable de '
u'retour devrait être %s et non %s'),
self.reuse.nom, self.sdnom)
valid = 0
if valid:
self.sd = self.reuse
else:
# Cas d'un concept non reutilise
if sd_prod == None: # Pas de concept retourné
# Que faut il faire de l eventuel ancien sd ?
self.sd = None
else:
if self.sd:
# Un sd existe deja, on change son type
if CONTEXT.debug:
print "changement de type:", self.sd, sd_prod
if self.sd.__class__ != sd_prod:
self.sd.change_type(sd_prod)
self.typret = sd_prod
else:
# Le sd n existait pas , on ne le crée pas
self.typret = sd_prod
if cr == 'oui':
self.cr.fatal(_(u"Concept retourné non défini"))
valid = 0
if self.definition.reentrant == 'o':
if cr == 'oui':
self.cr.fatal(
_(u'Commande obligatoirement réentrante : spécifier reuse=concept'
))
valid = 0
return valid
def calc_modes_amelioration(self, modes, TYPE_RESU, SOLVEUR_MODAL, SOLVEUR,
VERI_MODE, INFO, TITRE, **args):
"""
Macro-command CALC_MODES, file for improving the quality of the eigenmodes
"""
import aster
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
from Utilitai.Utmess import UTMESS
# import the definitions of the commands to use in the macro-command
# The name of the variable has to be the name of the command
from Modal.mode_iter_inv import MODE_ITER_INV
DETRUIRE = self.get_cmd('DETRUIRE')
##############################################################################
# 1. CHECK IF THE COMPUTATION WITH MODE_ITER_INV CAN BE PERFORMED
if TYPE_RESU == 'DYNAMIQUE':
type_vp = 'FREQ'
matr_A = 'MATR_RIGI'
matr_B = 'MATR_MASS'
if args.has_key('MATR_AMOR'):
matr_C = 'MATR_AMOR'
elif TYPE_RESU == 'MODE_FLAMB':
type_vp = 'CHAR_CRIT'
matr_A = 'MATR_RIGI'
matr_B = 'MATR_RIGI_GEOM'
elif TYPE_RESU == 'GENERAL':
type_vp = 'CHAR_CRIT'
matr_A = 'MATR_A'
matr_B = 'MATR_B'
# 1.1 check if the input matrices are symetric and real
lsym = True
lreel = True
iret, ibid, type_matr_A = aster.dismoi('TYPE_MATRICE', args[matr_A].nom,
'MATR_ASSE', 'F')
if not type_matr_A == 'SYMETRI':
lsym = False
if AsType(args[matr_A]).__name__ in ('matr_asse_depl_c',
'matr_asse_gene_c'):
lreel = False
iret, ibid, type_matr_B = aster.dismoi('TYPE_MATRICE', args[matr_B].nom,
'MATR_ASSE', 'F')
if not type_matr_B == 'SYMETRI':
lsym = False
if TYPE_RESU == 'DYNAMIQUE':
if args['MATR_AMOR'] != None:
iret, ibid, type_matr_C = aster.dismoi('TYPE_MATRICE',
args['MATR_AMOR'].nom,
'MATR_ASSE', 'F')
if not type_matr_C == 'SYMETRI':
lsym = False
if not lsym:
UTMESS('I', 'MODAL_15')
return modes
if not lreel:
UTMESS('I', 'MODAL_16', valk=matr_A)
return modes
# 1.2 detect too closed eigen values (gap < CALC_* / SEUIL_*)
list_vp = modes.LIST_PARA()[type_vp] # list of the eigen values
seuil_vp = args['CALC_' + type_vp]['SEUIL_' + type_vp]
# One reproduces here the detection performed in the routine vpgsmm.F90
seuilr = 100. * seuil_vp
seuilp = seuil_vp
ltest = False
for k in range(0, len(list_vp) - 1):
if (abs(list_vp[k]) < seuilr):
ltest = abs(list_vp[k + 1]) < seuilr
else:
if (abs(list_vp[k + 1]) >= seuilr):
ltest = abs(2. * (list_vp[k] - list_vp[k + 1]) /
(list_vp[k] + list_vp[k + 1])) < seuilp
if ltest:
UTMESS('I', 'MODAL_17', valk=modes.nom)
return modes
##############################################################################
# 2. PERFORM THE IMPROVEMENT OF THE MODES WITH MODE_ITER_INV / OPTION='PROCHE'
DETRUIRE(CONCEPT=_F(NOM=modes), INFO=1)
motcles = {}
matrices = {}
# read the input matrices
if TYPE_RESU == 'DYNAMIQUE':
type_vp = 'FREQ'
matrices['MATR_RIGI'] = args['MATR_RIGI']
matrices['MATR_MASS'] = args['MATR_MASS']
if args['MATR_AMOR'] != None:
matrices['MATR_AMOR'] = args['MATR_AMOR']
elif TYPE_RESU == 'MODE_FLAMB':
type_vp = 'CHAR_CRIT'
matrices['MATR_RIGI'] = args['MATR_RIGI']
matrices['MATR_RIGI_GEOM'] = args['MATR_RIGI_GEOM']
elif TYPE_RESU == 'GENERAL':
type_vp = 'CHAR_CRIT'
matrices['MATR_A'] = args['MATR_A']
matrices['MATR_B'] = args['MATR_B']
motcles.update(matrices)
#################################################################
motcles_calc_vp = {}
motcles_calc_vp[type_vp] = list_vp
motcles['CALC_' + type_vp] = _F(OPTION='PROCHE', **motcles_calc_vp)
#################################################################
# read the keyword SOLVEUR (linear solver)
solveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
if solveur.has_key(
'TYPE_RESU'
): # because TYPE_RESU is a keyword with a 'global' position
solveur.pop('TYPE_RESU')
if solveur.has_key(
'OPTION'): # because OPTION is a keyword with a 'global' position
solveur.pop('OPTION')
if solveur.has_key(
'FREQ'): # because FREQ can be a keyword with a 'global' position
solveur.pop('FREQ')
#motcles['SOLVEUR']=_F(**solveur) # if this line is commented,
# one will use the default keywords for SOLVEUR
#################################################################
# read the keyword VERI_MODE
motcles['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'], )
#################################################################
if TITRE != None:
motcles['TITRE'] = TITRE
#################################################################
modes = MODE_ITER_INV(TYPE_RESU=TYPE_RESU, INFO=INFO, **motcles)
return modes
def macr_lign_coupe_ops(self, RESULTAT, CHAM_GD, UNITE_MAILLAGE, LIGN_COUPE,
NOM_CHAM, MODELE, **args):
"""
Ecriture de la macro MACR_LIGN_COUPE
"""
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
import aster
import math
from Utilitai.UniteAster import UniteAster
from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
ier = 0
# On importe les definitions des commandes a utiliser dans la macro
LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
DEFI_GROUP = self.get_cmd('DEFI_GROUP')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
CREA_TABLE = self.get_cmd('CREA_TABLE')
CREA_RESU = self.get_cmd('CREA_RESU')
COPIER = self.get_cmd('COPIER')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
#
MasquerAlarme('ALGORITH12_43')
MasquerAlarme('CALCULEL2_63')
MasquerAlarme('CALCULEL2_64')
MasquerAlarme('MODELISA5_53')
MasquerAlarme('MODELE1_58')
MasquerAlarme('MODELE1_63')
MasquerAlarme('MODELE1_64')
mcORDR = {}
l_mode_meca_sans_modele = False
if RESULTAT != None:
if args['NUME_ORDRE'] != None:
mcORDR['NUME_ORDRE'] = args['NUME_ORDRE']
elif args['NUME_MODE'] != None:
mcORDR['NUME_MODE'] = args['NUME_MODE']
elif args['LIST_ORDRE'] != None:
mcORDR['LIST_ORDRE'] = args['LIST_ORDRE']
elif args['INST'] != None:
mcORDR['INST'] = args['INST']
elif args['INST'] != None:
mcORDR['INST'] = args['INST']
elif args['LIST_INST'] != None:
mcORDR['LIST_INST'] = args['LIST_INST']
else:
mcORDR['TOUT_ORDRE'] = 'OUI'
nomresu = RESULTAT.nom
type_resu = AsType(RESULTAT).__name__
iret, ibid, n_modele = aster.dismoi('MODELE', nomresu, 'RESULTAT', 'F')
n_modele = n_modele.strip()
if n_modele in ('', '#AUCUN'):
if MODELE == None:
if (type_resu != 'mode_meca'):
UTMESS('F', 'POST0_9', valk=nomresu)
# si le résultat en entrée est un mode_meca et qu'il ne contient pas de modèle (il est obtenu par sous-structuration, par exemple)
# on passe le message fatal et on récupérera directement le
# maillage (ou squelette)
else:
l_mode_meca_sans_modele = True
UTMESS('I', 'POST0_23', valk=nomresu)
else:
n_modele = MODELE.nom
iret, ibid, l_mailla = aster.dismoi(
'NOM_MAILLA', nomresu, 'RESULTAT', 'F')
elif CHAM_GD != None:
mcORDR['TOUT_ORDRE'] = 'OUI'
if MODELE == None:
UTMESS('F', 'POST0_10')
else:
n_modele = MODELE.nom
# récupération de la grandeur du champ
n_cham = CHAM_GD.nom
catagd = aster.getvectjev("&CATA.GD.NOMGD")
desc = aster.getvectjev('%-19s.DESC' % n_cham)
if desc != None:
nomgd = catagd[desc[0] - 1]
else:
celd = aster.getvectjev('%-19s.CELD' % n_cham)
nomgd = catagd[celd[0] - 1]
# détermination du type de résultat à créer
if nomgd[:6] == 'TEMP_R':
TYPE_RESU = 'EVOL_THER'
if not NOM_CHAM:
NOM_CHAM = 'TEMP'
elif nomgd[:6] == 'DEPL_R':
TYPE_RESU = 'EVOL_ELAS'
if not NOM_CHAM:
NOM_CHAM = 'DEPL'
elif nomgd[:6] == 'NEUT_R':
TYPE_RESU = 'EVOL_VARC'
if not NOM_CHAM:
NOM_CHAM = 'NEUT'
elif nomgd[:6] == 'EPSI_R':
TYPE_RESU = 'EVOL_ELAS'
elif nomgd[:6] == 'VAR2_R':
TYPE_RESU = 'EVOL_NOLI'
elif nomgd[:6] == 'VARI_R':
TYPE_RESU = 'EVOL_NOLI'
elif nomgd[:6] == 'SIEF_R':
if not NOM_CHAM:
TYPE_RESU = 'EVOL_ELAS'
NOM_CHAM = 'DEPL'
elif NOM_CHAM[:4] == 'SIGM':
TYPE_RESU = 'EVOL_ELAS'
elif NOM_CHAM[:4] == 'SIEF':
TYPE_RESU = 'EVOL_NOLI'
else:
assert 0, 'grandeur imprevue : ' + nomgf
# création d'un concept résultat à partir du champ CHAM_GD
__resuch = CREA_RESU(OPERATION='AFFE',
NOM_CHAM=NOM_CHAM, TYPE_RESU=TYPE_RESU,
AFFE=_F(CHAM_GD=CHAM_GD, INST=0.),)
RESULTAT = __resuch
iret, ibid, l_mailla = aster.dismoi('NOM_MAILLA', n_cham, 'CHAMP', 'F')
# Maillage sur lequel s'appuie le résultat à projeter
n_mailla = l_mailla.strip()
# le maillage est-il 2D ou 3D ?
iret, dime, kbid = aster.dismoi('DIM_GEOM', n_mailla, 'MAILLAGE', 'F')
collgrma = aster.getcolljev(n_mailla.ljust(8) + '.GROUPEMA')
typma = aster.getvectjev(n_mailla.ljust(8) + '.TYPMAIL')
connex = aster.getcolljev(n_mailla.ljust(8) + '.CONNEX')
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
lignes = []
groups = []
arcs = []
minidim = dime
for m in LIGN_COUPE:
if m['TYPE'] == 'SEGMENT':
lignes.append((m['COOR_ORIG'], m['COOR_EXTR'], m['NB_POINTS']))
minidim = min(minidim, len(m['COOR_ORIG']), len(m['COOR_EXTR']))
if minidim != dime:
UTMESS('F', 'POST0_11')
elif m['TYPE'] == 'ARC':
minidim = min(minidim, len(m['COOR_ORIG']), len(m['CENTRE']))
if minidim != dime:
UTMESS('F', 'POST0_11')
if dime == 2:
arcs.append(
(m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'],))
elif dime == 3:
if str(m['DNOR']) == 'None':
UTMESS('F', 'POST0_12')
arcs.append(
(m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'], m['DNOR']))
elif m['TYPE'] == 'GROUP_NO':
ngrno = m['GROUP_NO'].ljust(24)
collgrno = aster.getcolljev(n_mailla.ljust(8) + '.GROUPENO')
if ngrno not in collgrno.keys():
UTMESS('F', 'POST0_13', valk=[ngrno, n_mailla])
grpn = collgrno[ngrno]
l_coor_group = [ngrno, ]
for node in grpn:
l_coor_group.append(
aster.getvectjev(n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3))
groups.append(l_coor_group)
elif m['TYPE'] == 'GROUP_MA':
ngrma = m['GROUP_MA'].ljust(24)
if ngrma not in collgrma.keys():
UTMESS('F', 'POST0_14', valk=[ngrma, n_mailla])
grpm = collgrma[ngrma]
for ma in grpm:
if ltyma[typma[ma - 1] - 1][:3] != 'SEG':
nomma = aster.getvectjev(n_mailla.ljust(8) + '.NOMMAI')
UTMESS('F', 'POST0_15', valk=[ngrma, nomma[ma - 1]])
__mailla = COPIER(CONCEPT=m['MAILLAGE'])
m2 = m.cree_dict_valeurs(m.mc_liste)
argsup = {}
if m2.get('GROUP_NO_ORIG'):
argsup['GROUP_NO_ORIG'] = m2.get('GROUP_NO_ORIG')
if m2.get('GROUP_NO_EXTR'):
argsup['GROUP_NO_EXTR'] = m2.get('GROUP_NO_EXTR')
if m2.get('NOEUD_ORIG'):
argsup['NOEUD_ORIG'] = m2.get('NOEUD_ORIG')
if m2.get('NOEUD_EXTR'):
argsup['NOEUD_EXTR'] = m2.get('NOEUD_EXTR')
if m2.get('VECT_ORIE'):
argsup['VECT_ORIE'] = m2.get('VECT_ORIE')
__mailla = DEFI_GROUP(reuse=__mailla, MAILLAGE=__mailla,
DETR_GROUP_NO=_F(NOM=str(m['GROUP_MA'])),
CREA_GROUP_NO=_F(OPTION='NOEUD_ORDO', NOM=str(m['GROUP_MA']),
GROUP_MA=m['GROUP_MA'], ORIGINE='SANS', **argsup))
collgrno = aster.getcolljev(__mailla.nom.ljust(8) + '.GROUPENO')
grpn = collgrno[str(m['GROUP_MA']).ljust(24)]
l_coor_group = [ngrma, ]
for node in grpn:
l_coor_group.append(
aster.getvectjev(n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3))
groups.append(l_coor_group)
if arcs != [] and (lignes != [] or groups != []):
UTMESS('F', 'POST0_16')
# Création du maillage des NB_POINTS segments entre COOR_ORIG et COOR_EXTR
# ainsi que des segments reliant les noeuds issus des group_no demandés
# par appel au script python crea_mail_lig_coup
# le maillage est ensuite recopié dans l unité logique UNITE_MAILLAGE
resu_mail, arcgma, angles, nbno = crea_mail_lig_coup(
dime, lignes, groups, arcs)
UL = UniteAster()
nomFichierSortie = UL.Nom(UNITE_MAILLAGE)
fproc = open(nomFichierSortie, 'w')
fproc.write(os.linesep.join(resu_mail))
fproc.close()
UL.EtatInit(UNITE_MAILLAGE)
# Lecture du maillage de seg2 contenant toutes les lignes de coupe
__macou = LIRE_MAILLAGE(FORMAT='ASTER',UNITE=UNITE_MAILLAGE,)
# distance min entre 2 points de la ligne de coupe (utile pour PROJ_CHAMP)
dmin = dist_min_deux_points(__macou)
motscles = {}
iocc = 1
motscles['CREA_GROUP_NO'] = []
for m in LIGN_COUPE:
if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
motscles['CREA_GROUP_NO'].append(
_F(GROUP_MA=m[m['TYPE']].ljust(24),))
else:
motscles['CREA_GROUP_NO'].append(_F(GROUP_MA='LICOU' + str(iocc),))
iocc = iocc + 1
__macou = DEFI_GROUP(reuse=__macou, MAILLAGE=__macou, **motscles)
if AsType(RESULTAT).__name__ in ('evol_elas', 'evol_noli', 'mode_meca',
'comb_fourier', 'mult_elas', 'fourier_elas'):
__mocou = AFFE_MODELE(MAILLAGE=__macou,
AFFE=_F(TOUT='OUI',
PHENOMENE='MECANIQUE',
MODELISATION='BARRE',),
DISTRIBUTION=_F(METHODE='CENTRALISE'),
)
elif AsType(RESULTAT).__name__ in ('evol_ther', 'evol_varc',):
__mocou = AFFE_MODELE(MAILLAGE=__macou,
AFFE=_F(TOUT='OUI',
PHENOMENE='THERMIQUE',
MODELISATION='PLAN',),)
motscles = {}
motscles['VIS_A_VIS'] = []
motscles[mcORDR.keys()[0]] = mcORDR.values()[0]
if args['VIS_A_VIS'] != None:
for v in args['VIS_A_VIS']:
if v['GROUP_MA_1'] != None:
motscles['VIS_A_VIS'].append(
_F(GROUP_MA_1=v['GROUP_MA_1'], TOUT_2='OUI'),)
elif v['MAILLE_1'] != None:
motscles['VIS_A_VIS'].append(
_F(MAILLE_1=v['MAILLE_1'], TOUT_2='OUI'),)
if NOM_CHAM[5:9] == 'ELGA':
UTMESS('A', 'POST0_18', valk=[NOM_CHAM, ])
if (l_mode_meca_sans_modele == False):
# on utilise le modèle pour projeter le champ
if n_modele in self.get_global_contexte().keys():
MODELE_1 = self.get_global_contexte()[n_modele]
else:
MODELE_1 = self.jdc.current_context[n_modele]
__recou = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MODELE_1=MODELE_1,
DISTANCE_MAX=m['DISTANCE_MAX'],
MODELE_2=__mocou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM, **motscles)
else:
# on utilise directement le maillage (ou squelette) pour projeter le
# champ
if n_mailla in self.get_global_contexte().keys():
MAILLAGE_1 = self.get_global_contexte()[n_mailla]
else:
MAILLAGE_1 = self.jdc.current_context[n_mailla]
__recou = PROJ_CHAMP(METHODE='COLLOCATION',
RESULTAT=RESULTAT,
MAILLAGE_1=MAILLAGE_1,
DISTANCE_MAX=m['DISTANCE_MAX'],
MODELE_2=__mocou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM, **motscles)
__remodr = __recou
icham = 0
ioc2 = 0
mcACTION = []
angtab = []
if AsType(RESULTAT).__name__ in ('evol_ther', 'evol_elas', 'evol_noli', 'mode_meca', 'evol_varc',
'comb_fourier', 'mult_elas', 'fourier_elas'):
if NOM_CHAM in ('DEPL', 'SIEF_ELNO', 'SIGM_NOEU', 'SIGM_ELNO', 'FLUX_ELNO', 'FLUX_NOEU'):
icham = 1
iocc = 0
for m in LIGN_COUPE:
iocc = iocc + 1
motscles = {}
motscles['OPERATION'] = m['OPERATION']
if m['NOM_CMP'] != None:
motscles['NOM_CMP'] = m['NOM_CMP']
if m['TRAC_NOR'] != None:
motscles['TRAC_NOR'] = m['TRAC_NOR']
elif m['TRAC_DIR'] != None:
motscles['TRAC_DIR'] = m['TRAC_DIR']
motscles['DIRECTION'] = m['DIRECTION']
elif m['INVARIANT'] != None:
motscles['INVARIANT'] = m['INVARIANT']
elif m['RESULTANTE'] != None:
motscles['RESULTANTE'] = m['RESULTANTE']
elif m['ELEM_PRINCIPAUX'] != None:
motscles['ELEM_PRINCIPAUX'] = m['ELEM_PRINCIPAUX']
else:
motscles['TOUT_CMP'] = 'OUI'
# on définit le groupe de noeud pour post_releve_t
if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
groupe = m[m['TYPE']].ljust(8)
nomgrma = groupe
else:
ioc2 = ioc2 + 1
groupe = 'LICOU' + str(ioc2)
nomgrma = ' '
newgrp = 'LICOF' + str(ioc2)
crea_grp_matiere(
self, groupe, newgrp, iocc, m, __remodr, NOM_CHAM, LIGN_COUPE, __macou)
groupe = newgrp
# on definit l'intitulé
if m['INTITULE'] != None:
intitl = m['INTITULE']
elif m['TYPE'] in ('GROUP_NO', 'GROUP_MA'):
intitl = groupe
else:
intitl = 'l.coupe' + str(ioc2)
# Expression des contraintes aux noeuds ou des déplacements dans le
# repere local
if m['REPERE'] != 'GLOBAL':
if icham == 1:
if m['REPERE'] == 'POLAIRE':
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__remodr,
REPERE=m['REPERE'],
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
__remodr = crea_resu_local(
self, dime, NOM_CHAM, m, __recou, __macou, nomgrma)
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__remodr,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
UTMESS('A', 'POST0_17', valk=[NOM_CHAM, m['REPERE']])
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__recou,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
# Expression des contraintes aux noeuds ou des déplacements dans le
# repere global
else:
mcACTION.append(_F(INTITULE=intitl,
RESULTAT=__recou,
GROUP_NO=groupe,
NOM_CHAM=NOM_CHAM, **motscles),)
else:
assert 0
__tabitm = POST_RELEVE_T(ACTION=mcACTION,)
# on repasse par les tables python pour supprimer les paramètres inutiles
# NOEUD (car il est propre au maillage de la ligne) et RESU
self.DeclareOut('nomres', self.sd)
dictab = __tabitm.EXTR_TABLE()
# Ajout de la colonne theta
if len(arcgma) > 0:
coltab = []
val = dictab['ABSC_CURV'].values()['ABSC_CURV']
nbi = len(val) / nbno
nba = len(angles)
tmp = []
for k in range(nba):
for j in range(nbi):
for i in range(len(angles[k])):
tmp.append(angles[k][i])
dictab['ANGLE'] = tmp
if 'RESU' in dictab.para:
del dictab['RESU']
if 'NOEUD' in dictab.para:
del dictab['NOEUD']
dprod = dictab.dict_CREA_TABLE()
nomres = CREA_TABLE(**dprod)
RetablirAlarme('ALGORITH12_43')
RetablirAlarme('CALCULEL2_63')
RetablirAlarme('CALCULEL2_64')
RetablirAlarme('MODELISA5_53')
RetablirAlarme('MODELE1_58')
RetablirAlarme('MODELE1_63')
RetablirAlarme('MODELE1_64')
return ier
def calc_modes_ops(self, TYPE_RESU, OPTION, SOLVEUR_MODAL, SOLVEUR, VERI_MODE,
AMELIORATION, INFO, TITRE, **args):
"""
Macro-command CALC_MODES, main file
"""
ier = 0
import aster
from code_aster.Cata.Syntax import _F
from Noyau.N_utils import AsType
from Modal.calc_modes_simult import calc_modes_simult
from Modal.calc_modes_inv import calc_modes_inv
from Modal.calc_modes_multi_bandes import calc_modes_multi_bandes
from Modal.calc_modes_amelioration import calc_modes_amelioration
from Modal.calc_modes_post import calc_modes_post
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
self.DeclareOut('modes', self.sd)
l_multi_bandes = False # logical indicating if the computation is performed
# for DYNAMICAL modes on several bands
if (TYPE_RESU == 'DYNAMIQUE'):
if (OPTION == 'BANDE'):
if len(args['CALC_FREQ']['FREQ']) > 2:
l_multi_bandes = True
# modes computation over several frequency bands,
# with optional parallelization of the bands
modes = calc_modes_multi_bandes(self, SOLVEUR_MODAL, SOLVEUR,
VERI_MODE, INFO, TITRE, **args)
if not l_multi_bandes:
if OPTION in ('PLUS_PETITE', 'PLUS_GRANDE', 'CENTRE', 'BANDE', 'TOUT'):
# call the MODE_ITER_SIMULT command
modes = calc_modes_simult(self, TYPE_RESU, OPTION, SOLVEUR_MODAL,
SOLVEUR, VERI_MODE, INFO, TITRE, **args)
elif OPTION in ('SEPARE', 'AJUSTE', 'PROCHE'):
# call the MODE_ITER_INV command
modes = calc_modes_inv(self, TYPE_RESU, OPTION, SOLVEUR_MODAL,
SOLVEUR, VERI_MODE, INFO, TITRE, **args)
if AMELIORATION == 'OUI':
# after a 1st modal computation, achieve a 2nd computation with MODE_ITER_INV
# and option 'PROCHE' to refine the modes
modes = calc_modes_amelioration(self, modes, TYPE_RESU, SOLVEUR_MODAL,
SOLVEUR, VERI_MODE, INFO, TITRE,
**args)
##################
# post-traitements
##################
if (TYPE_RESU == 'DYNAMIQUE'):
lmatphys = False # logical indicating if the matrices are physical or not (generalized)
iret, ibid, nom_matrrigi = aster.dismoi('REF_RIGI_PREM', modes.nom,
'RESU_DYNA', 'F')
matrrigi = self.get_concept(nom_matrrigi)
if AsType(matrrigi).__name__ == 'matr_asse_depl_r':
lmatphys = True
if lmatphys:
norme_mode = None
if args['NORM_MODE'] != None:
norme_mode = args['NORM_MODE']
filtre_mode = None
if args['FILTRE_MODE'] != None:
filtre_mode = args['FILTRE_MODE']
impression = None
if args['IMPRESSION'] != None:
impression = args['IMPRESSION']
if (norme_mode != None) or (filtre_mode != None) or (impression !=
None):
modes = calc_modes_post(self, modes, lmatphys, norme_mode,
filtre_mode, impression)
return ier
def calc_modes_multi_bandes( self, SOLVEUR_MODAL, SOLVEUR,
VERI_MODE, INFO, TITRE, **args):
"""
Macro-command CALC_MODES, case of the simultaneous iterations method
over several frequency bands, with optional parallelization.
Can be used only in the case of vibration modes (TYPE_RESU='DYNAMIQUE')
"""
MATR_RIGI = args['MATR_RIGI']
MATR_MASS = args['MATR_MASS']
CALC_FREQ = args['CALC_FREQ']
METHODE = SOLVEUR_MODAL['METHODE']
STOP_BANDE_VIDE = "NON"
# ----------------------------------------------------------------------
#
# 1a. INITIALISATIONS
#
# ----------------------------------------------------------------------
ier = 0
dbg = False # True si on souhaite faire un IMPR_CO intermediaire, False sinon
lmatphys = True # True si matrices d'entrée de type matr_asse_depl_r, False sinon
if (AsType(MATR_RIGI) != matr_asse_depl_r):
lmatphys = False
# On importe les definitions des commandes a utiliser dans la macro
from Modal.mode_iter_simult import MODE_ITER_SIMULT
EXTR_MODE = self.get_cmd('EXTR_MODE')
INFO_MODE = self.get_cmd('INFO_MODE')
MODI_MODELE = self.get_cmd('MODI_MODELE')
NUME_DDL = self.get_cmd('NUME_DDL')
if (dbg):
IMPR_CO = self.get_cmd('IMPR_CO')
# Recuperation parametres solveur lineaire
dSolveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
for i in dSolveur.keys():
if dSolveur[i] == None:
del dSolveur[i]
if dSolveur.has_key('TYPE_RESU'): # because TYPE_RESU is a keyword with a 'global' position
del dSolveur['TYPE_RESU']
if dSolveur.has_key('OPTION'): # because OPTION is a keyword with a 'global' position
del dSolveur['OPTION']
if dSolveur.has_key('FREQ'): # because FREQ can be a keyword with a 'global' position
del dSolveur['FREQ']
solveur_lineaire = dSolveur.get('METHODE').strip()
dSolveur_infomode = dSolveur
# pour INFO_MODE, le mot-clé facteur SOLVEUR ne doit pas contenir les
# mot-clés POSTTRAITEMENTS et RESI_RELA
if dSolveur_infomode.has_key('POSTTRAITEMENTS'):
del dSolveur_infomode['POSTTRAITEMENTS']
if dSolveur_infomode.has_key('RESI_RELA'):
del dSolveur_infomode['RESI_RELA']
nompro = None
iocc = 0
# Rang du processus MPI et taille du MPI_COMM_WORLD
# Lorsqu'on ne veut q'un niveau de parallelisme (celui du solveur lineaire)
# on bluffe l'algo en posant rang=0/nbproc=1 pour tous les procs.
# Cependant si le solveur est autre que MUMPS on s'arrete en erreur.
if CALC_FREQ['NIVEAU_PARALLELISME'] == 'COMPLET':
rang, nbproc = aster_core.MPI_CommRankSize()
niv_par = 'COMPLET'
elif CALC_FREQ['NIVEAU_PARALLELISME'] == 'PARTIEL':
rang = 0
nbproc = 1
niv_par = 'PARTIEL'
nbproc_real = aster_core.MPI_CommRankSize()[1]
if ((nbproc_real > 1) & (solveur_lineaire != 'MUMPS')):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('F', 'MODAL_14', vali=nbproc_real, valk=solveur_lineaire)
aster.affiche('MESSAGE', 72 * '-')
else:
assert(False) # Pb parametrage NIVEAU_PARALLELISME
# Construction de la liste de frequences
if CALC_FREQ['FREQ']:
lborne = []
nnfreq = len(CALC_FREQ['FREQ'])
for i in range(0, nnfreq):
lborne.append(CALC_FREQ['FREQ'][i])
else:
assert(False) # Pb parametrage CALC_FREQ
# ----------------------------------------------------------------------
#
# 1b. TRAVAUX PREPARATOIRES AU LANCEMENT DE LA BOUCLE
#
# ----------------------------------------------------------------------
# Modification de la sd_partition pour rendre compatible les niveaux de
# parallelisme: celui en frequence et celui des calculs ele/assemblage.
# Pour l'instant on fonctionne en mode 'CENTRALISE' au sein de la macro
# (ds les sous-communicateurs, les calculs elem/assemblages
# ne sont pas parallelises).
# On remettra le mode de fonctionnement initial en fin de Macro.
if (nbproc > 1):
nommod, old_prtk1 = recup_modele_partition(MATR_RIGI, dbg)
sd_modele = None
sd_modele = self.get_concept(nommod)
if (sd_modele == None):
assert(False) # Pb, on arrive pas a recuperer le nom du modele
if (old_prtk1 != None):
motdimo = {}
motdimo['reuse'] = sd_modele
motdimo['MODELE'] = sd_modele
motdimo['DISTRIBUTION'] = _F(METHODE='CENTRALISE')
__modimo = MODI_MODELE(**motdimo)
# INFO_MODE global sur la liste de frequences
# Parametres basiques
motfaci = {}
motfaci['COMPTAGE'] = _F(METHODE='AUTO',
SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_ITER_SHIFT=CALC_FREQ['NMAX_ITER_SHIFT'],
PREC_SHIFT=CALC_FREQ['PREC_SHIFT'],)
# Gestion des frequences
ier = gestion_frequence(solveur_lineaire, nnfreq, nbproc)
# Parametrage du parallelisme pour la couche FORTRAN/MPI
if (nbproc > 1):
motfaci['PARALLELISME_MACRO'] = _F(TYPE_COM=1)
__nbmodi = INFO_MODE(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
FREQ=lborne,
NIVEAU_PARALLELISME=niv_par,
SOLVEUR=dSolveur_infomode,
**motfaci)
# Gestion des sous-bandes de frequences et construction (si //) de l'objet
nbmodeth, nbsb_nonvide, proc_sb_nvide = gestion_sous_bande(
solveur_lineaire, __nbmodi, nnfreq, nbproc,
STOP_BANDE_VIDE == "OUI")
# ----------------------------------------------------------------------
#
# 2. BOUCLE DE MODE_ITER_SIMULT(OPTION=BANDE) + NORM_MODE/IMPR_RESU
#
# ----------------------------------------------------------------------
# On ne traite pas les sous-bandes vides (gain de temps et d'affichage!)
# On affiche un message a la place.
# Tous les processeurs font la meme chose pour ces sous-bandes vides, par
# contre, ils se repartissent bien sur les non-vides.
#
# RQ MPI:
# Les procs s'attendent via le MPI_COMM_SPLIT opere en fin de l'INFO_MODE
# precedent. Ce n'est pas la peine de commencer la boucle si un proc
# fait defaut.
# ----------------------------------------------------------------------
nbmodeef = None
freq_ini = 1.E+99
freq_fin = -1.E+99
motscles = {}
motscles['FILTRE_MODE'] = []
numsb_nonvide = 0
for i in range(0, nnfreq - 1):
#--------------------------------------------------------------------
#
# 2. SOUS-BANDE NON VIDE
#
#--------------------------------------------------------------------
sb_vide = None
do_loop = None
if (__nbmodi['NB_MODE', i + 1] == 0):
sb_vide = True
do_loop = False
else:
numsb_nonvide = numsb_nonvide + 1
sb_vide = False
if (((nbproc > 1) & (proc_sb_nvide[rang] == numsb_nonvide)) | (nbproc == 1)):
do_loop = True
else:
do_loop = False
if ((not sb_vide) & do_loop):
motscit = {}
motscfa = {}
if SOLVEUR_MODAL['DIM_SOUS_ESPACE']:
motscfa['DIM_SOUS_ESPACE'] = SOLVEUR_MODAL['DIM_SOUS_ESPACE']
if SOLVEUR_MODAL['COEF_DIM_ESPACE']:
motscfa['COEF_DIM_ESPACE'] = SOLVEUR_MODAL['COEF_DIM_ESPACE']
motscfa['FREQ'] = (lborne[i], lborne[i + 1])
motscfa['TABLE_FREQ'] = __nbmodi
motscit['CALC_FREQ'] = _F(OPTION='BANDE',
SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_ITER_SHIFT=CALC_FREQ[
'NMAX_ITER_SHIFT'],
PREC_SHIFT=CALC_FREQ['PREC_SHIFT'],
**motscfa)
if VERI_MODE['STURM'] == 'LOCAL':
motveri = 'OUI'
else:
motveri = 'NON'
motscit['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'],
SEUIL=VERI_MODE['SEUIL'],
STURM=motveri,
PREC_SHIFT=VERI_MODE['PREC_SHIFT'])
motscit['STOP_BANDE_VIDE'] = STOP_BANDE_VIDE
OPTION = 'SANS' # option for detecting rigid body modes
if METHODE == 'TRI_DIAG':
if args.has_key('NMAX_ITER_ORTHO'):
motscit['NMAX_ITER_ORTHO'] = SOLVEUR_MODAL[
'NMAX_ITER_ORTHO']
if args.has_key('PREC_ORTHO'):
motscit['PREC_ORTHO'] = SOLVEUR_MODAL['PREC_ORTHO']
if args.has_key('PREC_LANCZOS'):
motscit['PREC_LANCZOS'] = SOLVEUR_MODAL['PREC_LANCZOS']
if args.has_key('MAX_ITER_QR'):
motscit['NMAX_ITER_QR'] = SOLVEUR_MODAL['NMAX_ITER_QR']
if SOLVEUR_MODAL['MODE_RIGIDE'] == 'OUI':
OPTION = 'MODE_RIGIDE'
elif METHODE == 'JACOBI':
if args.has_key('NMAX_ITER_BATHE'):
motscit['NMAX_ITER_BATHE'] = SOLVEUR_MODAL[
'NMAX_ITER_BATHE']
if args.has_key('PREC_BATHE'):
motscit['PREC_BATHE'] = SOLVEUR_MODAL['PREC_BATHE']
if args.has_key('NMAX_ITER_JACOBI'):
motscit['NMAX_ITER_JACOBI'] = SOLVEUR_MODAL[
'NMAX_ITER_JACOBI']
if args.has_key('PREC_JACOBI'):
motscit['PREC_JACOBI'] = SOLVEUR_MODAL['PREC_JACOBI']
elif METHODE == 'SORENSEN':
if args.has_key('NMAX_ITER_SOREN'):
motscit['NMAX_ITER_SOREN'] = SOLVEUR_MODAL[
'NMAX_ITER_SOREN']
if args.has_key('PARA_ORTHO_SOREN'):
motscit['PARA_ORTHO_SOREN'] = SOLVEUR_MODAL[
'PARA_ORTHO_SOREN']
if args.has_key('PREC_SOREN'):
motscit['PREC_SOREN'] = SOLVEUR_MODAL['PREC_SOREN']
elif METHODE == 'QZ':
motscit['TYPE_QZ'] = SOLVEUR_MODAL['TYPE_QZ']
else:
assert(False) # Pb parametrage METHODE
# Parametrage du parallelisme pour la couche FORTRAN/MPI
# afin d'operer les comm des modes propres et des parametres
# modaux.
if (nbproc > 1):
motscit['PARALLELISME_MACRO'] = _F(TYPE_COM=1,
IPARA1_COM=numsb_nonvide,
IPARA2_COM=nbsb_nonvide,
)
#-----------------------------------------------------------------
#
# 2a. Calcul des modes
#
#----------------------------------------------------------------- )
__nomre0 = MODE_ITER_SIMULT(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
METHODE=METHODE,
OPTION=OPTION,
SOLVEUR=dSolveur,
**motscit)
#-----------------------------------------------------------------
#
# 2b. Preparation du test de Sturm de l'etape 3a.
#
#-----------------------------------------------------------------
if VERI_MODE['STURM'] in ('GLOBAL', 'OUI'): # in the case of CALC_MODES on several bands, OUI is reset to GLOBAL
dicomode = {}
dicomode = __nomre0.LIST_VARI_ACCES()
if (len(dicomode['FREQ']) != 0):
raux_ini = dicomode['FREQ'][0]
raux_fin = dicomode['FREQ'][-1]
if (raux_ini < freq_ini):
freq_ini = raux_ini
if (raux_fin > freq_fin):
freq_fin = raux_fin
else:
assert(False) # Ce test ne marche pas (PB LIST_VARI_ACCES)
#-----------------------------------------------------------------
#
# 2c. Préparation pour la concaténation de l'étape 3b.
#
#-----------------------------------------------------------------
motscles['FILTRE_MODE'].append(_F(MODE=__nomre0,
TOUT_ORDRE='OUI'))
# Pour verification
if (dbg):
IMPR_CO(CONCEPT=_F(NOM=__nomre0))
#--------------------------------------------------------------------
#
# 2. SOUS-BANDE VIDE
#
#--------------------------------------------------------------------
elif (sb_vide):
if (STOP_BANDE_VIDE == 'OUI'):
UTMESS('F', 'MODAL_6', vali=(i + 1,))
elif (STOP_BANDE_VIDE == 'NON'):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_6', vali=(i + 1,))
aster.affiche('MESSAGE', 72 * '-')
else:
assert(False) # Pb parametrage STOP_BANDE_VIDE
#-----------------------------------------------------------------------
#
# 3a. Test de sturm effectif
#
#-----------------------------------------------------------------------
if VERI_MODE['STURM'] == 'NON':
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_2')
aster.affiche('MESSAGE', 72 * '-')
elif VERI_MODE['STURM'] == 'LOCAL':
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_3')
aster.affiche('MESSAGE', 72 * '-')
elif VERI_MODE['STURM'] in ('GLOBAL', 'OUI'): # in the case of CALC_MODES on several bands, OUI is reset to GLOBAL
# Construction des 2 bornes de la bande a tester
if (nbmodeth != 0):
omecor = CALC_FREQ['SEUIL_FREQ']
precshift = VERI_MODE['PREC_SHIFT']
freq_ini = (1.0 - precshift) * freq_ini
freq_fin = (1.0 + precshift) * freq_fin
if (abs(freq_ini) < omecor):
freq_ini = -omecor
if (abs(freq_fin) < omecor):
freq_fin = omecor
# Parametrage du parallelisme pour la couche FORTRAN/MPI
if (nbproc > 1):
motfaci['PARALLELISME_MACRO'] = _F(TYPE_COM=2)
__nbmodf = INFO_MODE(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
FREQ=(freq_ini, freq_fin),
NIVEAU_PARALLELISME = niv_par,
SOLVEUR =dSolveur_infomode,
**motfaci)
# Recuperation du nbre de modes donnes par STURM global
nbmodesg = __nbmodf['NB_MODE', 1]
if (nbmodeth == nbmodesg):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_4', valr=(
freq_ini, freq_fin), vali=(nbmodesg, nbmodeth))
aster.affiche('MESSAGE', 72 * '-')
else:
# Message similaire a ALGELINE5_24 pour le FORTRAN
if (VERI_MODE['STOP_ERREUR'] == 'OUI'):
UTMESS('F', 'MODAL_5', valr=(
freq_ini, freq_fin, precshift), vali=(nbmodesg, nbmodeth))
elif (VERI_MODE['STOP_ERREUR'] == 'NON'):
UTMESS('A', 'MODAL_5', valr=(
freq_ini, freq_fin, precshift), vali=(nbmodesg, nbmodeth))
else:
assert(False) # Pb parametrage VERI_MODE
# La bande globale est vide
else:
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_7', valr=(lborne[0], lborne[nnfreq - 1]))
aster.affiche('MESSAGE', 72 * '-')
else:
assert(False) # Pb parametrage STURM
#-----------------------------------------------------------------------
#
# 3b. Concaténation des résultats
#
#-----------------------------------------------------------------------
self.DeclareOut('modes', self.sd)
modes = EXTR_MODE(**motscles)
# ----------------------------------------------------------------------
#
# 3c. Epilogue
#
# RQ MPI:
# Si la SD_PARTITION existait avant de rentrer ds la Macro on remet ses
# anciennes valeurs pour continuer la suite du fichier de commande.
#----------------------------------------------------------------------
if (nbproc > 1):
if (old_prtk1 != None):
motdimo = {}
motdimo['reuse'] = sd_modele
motdimo['MODELE'] = sd_modele
motdimo['DISTRIBUTION'] = _F(METHODE=old_prtk1)
__modimo = MODI_MODELE(**motdimo)
return modes
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