def ecri_rela_cine(cabl_precont, cle_epx, type_epx):
"""
Recherche des mots-clés de DEFI_CABLE_BP pour traduction en EPX (LCAB)
"""
from Calc_epx.calc_epx_struc import BLOC_DONNEES, BLOC_DONNEES_SUP
defi_cable_bp = recupere_structure(cabl_precont)
# BETON COQUE
gr_ma_bet = defi_cable_bp['GROUP_MA_BETON']
bloc_betc = BLOC_DONNEES('BETC', l_group=gr_ma_bet)
# CABLES
defi_cable = defi_cable_bp['DEFI_CABLE']
gr_ma_cab =[]
for insta in defi_cable:
gr_ma_cab.append(insta['GROUP_MA'])
bloc_cabl = BLOC_DONNEES('CABL', l_group=gr_ma_cab)
bloc_lcab = BLOC_DONNEES_SUP(cle_epx,[bloc_betc, bloc_cabl], cle=type_epx)
return bloc_lcab
def get_para_all(loi, relation, l_para, l_vale, l_bs,
nom_mater, donnees, liste_fonc):
"""
Lecture des parametres de la loi 'loi'
+ traitement des parametres facteurs
"""
rel_loi = relation + '/' + loi
l_posi = True
l_para1 = []
l_vale1 = []
if not cata_lois[rel_loi].has_key('POSI_PARA'):
posi_para = 0
l_posi = False
for ipar, para in enumerate(cata_lois[rel_loi]['PARA']):
if donnees.has_key(para):
type_para = cata_lois[rel_loi]['TYPE'][ipar]
para_epx = cata_lois[rel_loi]['PARA_EPX'][ipar]
if l_posi:
posi_para = cata_lois[rel_loi]['POSI_PARA'][ipar]
if type(para_epx) is list:
if rel_loi == 'VMIS_ISOT_TRAC/TRACTION':
l_para, l_vale = vmis_isot_trac(donnees, para, para_epx,
type_para, l_para, l_vale)
else:
raise Exception("""
Pas de traitement special présent pour le couple relation/loi %s."""
% rel_loi)
elif type_para == 'fonc':
car_temp = donnees[para]
nom_fonc = car_temp.get_name()
ifonc = len(liste_fonc) + 1
for dic_fonc in liste_fonc:
if type(dic_fonc) is dict:
nom = dic_fonc['NOM_FONC']
if nom == nom_fonc:
ifonc = dic_fonc['NUME']
break
if ifonc > len(liste_fonc):
val = car_temp.Valeurs()
dic_fonc = {'VALE': val,
'NUME': ifonc,
'NOM_FONC': nom_fonc
}
liste_fonc.append(dic_fonc)
vale = 'FONC %i' % ifonc
if posi_para == 0:
l_para.append(para_epx)
l_vale.append(vale)
else:
l_para1.append(para_epx)
l_vale1.append(vale)
elif type_para == 'reel':
vale = donnees[para]
if type(para_epx) == float or type(para_epx) == int:
if vale != para_epx:
UTMESS('F', 'PLEXUS_49', valk=(para, loi, nom_mater),
valr=(para_epx, vale))
if posi_para == 0:
l_para.append(para_epx)
l_vale.append(vale)
else:
l_para1.append(para_epx)
l_vale1.append(vale)
elif type_para == 'mfac':
concept2 = donnees[para]
nom_concept2 = concept2.get_name()
for i, loi2 in enumerate(cata_compor[loi]['LOI']):
besoin = cata_compor[loi]['BESOIN'][i]
donnees2 = recupere_structure(concept2, loi2)
if not donnees2:
if besoin == 'o':
UTMESS('F', 'PLEXUS_33',
valk=(loi2, nom_concept2, loi))
else:
continue
l_para, l_vale, l_para1, l_vale1, liste_fonc = get_para_loi(
loi2, loi, l_para,
l_vale, l_para1, l_vale1,
nom_concept2, donnees2,
liste_fonc)
else:
raise Exception(
'Erreur de programmation, TYPE = %s est interdit' % type_para)
else:
bes_para = cata_lois[rel_loi]['BESOIN'][ipar]
if bes_para == 'o':
UTMESS('F', 'PLEXUS_31', valk=(para, loi, nom_mater))
# vérifcation que l'on utilise pas de mot-clé non pris en charge
for para in donnees.keys():
if para not in cata_lois[rel_loi]['PARA']:
UTMESS('A', 'PLEXUS_46', valk=(para, loi, nom_mater))
if cata_lois[rel_loi].has_key('NOM_EPX'):
nom_epx = cata_lois[rel_loi]['NOM_EPX']
bloc_s = BLOC_DONNEES(nom_epx, cara=l_para1, vale=l_vale1)
l_bs.append(bloc_s)
return l_para, l_vale, l_bs, liste_fonc
def export_mate(epx, CHAM_MATER, COMPORTEMENT, INTERFACES, dicOrthotropie):
"""
Traitement des données matériaux et comportements
Traitement des interfaces
"""
directive = 'MATE'
# Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MATER
affe_mater = recupere_structure(CHAM_MATER, 'AFFE')
affe_mater = tolist(affe_mater)
# RELATTIONS AUTORISEES
relations_autorisees = []
for rela in cata_compor.keys():
if cata_compor[rela].has_key('NOM_EPX'):
relations_autorisees.append(rela)
# ETAPE 1 : Recherche de la relation pour les GROUP_MA déclaré
# dans COMPORTEMENT
dic_comportement = {}
gmaGLRC = []
mode_from_compor = {}
# dic_compor_gr : pour les transformations des variables internes
# aster -> epx
dic_compor_gr = {}
for comp in COMPORTEMENT:
if comp['RELATION'] not in relations_autorisees:
raise Exception("""La relation %s n'est pas programmée"""
% (comp['RELATION']))
if not comp in dic_compor_gr.keys():
dic_compor_gr[comp['RELATION']] = []
for gr in comp['GROUP_MA']:
dic_compor_gr[comp['RELATION']].append(gr)
# EC refonte : on peut supprimer cela si on considère la loi
# des surcharges
if gr in dic_comportement:
raise Exception('Une relation existe déjà pour le groupe %s'
% gr)
# FIN EC
dic_comportement[gr] = {'RELATION': comp['RELATION'],
'MATER': None,
'NOM_MATER': None,
}
# info complementaire sur la modelisation epx
if cata_compor[comp['RELATION']].has_key('MODE_EPX'):
mode_from_compor[gr] = cata_compor[comp['RELATION']]['MODE_EPX']
if comp['RELATION'] == 'GLRC_DAMAGE':
# GLRC impose de définir l'orientation :
# on stocke dans gmaGLRC les GMA dont il faudra retrouver
# l'orientation dans MODI_MAILLAGE/ORIE_NORM_COQUE
gmaGLRC.append(gr)
# ETAPE 2 : Recherche du materiau
for affe in affe_mater:
# Recuperer le concept du materiau defini par DEFI_MATERIAU
concept_mater = affe['MATER']
nom_mater = concept_mater.get_name()
# Recuperer les group_ma concernes
group_ma = get_group_ma(affe, mcfact='AFFE_MATERIAU/AFFE')
for gr in group_ma:
if gr in dic_comportement:
dic_comportement[gr]['MATER'] = concept_mater
dic_comportement[gr]['NOM_MATER'] = nom_mater
# else :
# EC : emet-on un message d'alarme ?
# ETAPE 3 : Verification que tous les GROUP_MA ont un materiau
# creation des couples MATERIAU/RELATION et des group_ma associés
dic_mate_rela = {}
for gr in dic_comportement.keys():
if dic_comportement[gr]['MATER'] == None:
UTMESS('F', 'PLEXUS_32', gr)
relation = dic_comportement[gr]['RELATION']
nom_mater = dic_comportement[gr]['NOM_MATER']
nom_mate_rela = nom_mater + '/' + relation
if not dic_mate_rela.has_key(nom_mate_rela):
dic_mate_rela[nom_mate_rela] = dic_comportement[gr]
dic_mate_rela[nom_mate_rela]['GROUP_MA'] = []
dic_mate_rela[nom_mate_rela]['GROUP_MA'].append(gr)
# ETAPE 4 :
nb_fonc = epx['FONC'].len_mcs()
# EC : pas trop joli, sert a savoir le nombre de fonction deja declarees
# en evitant de passer un argument supplémentaire
liste_fonc = [' '] * nb_fonc
mate_ordo = dic_mate_rela.keys()
mate_ordo.sort()
for mate_rela in mate_ordo:
relation = dic_mate_rela[mate_rela]['RELATION']
nom_mater = dic_mate_rela[mate_rela]['NOM_MATER']
concept_mater = dic_mate_rela[mate_rela]['MATER']
l_group = dic_mate_rela[mate_rela]['GROUP_MA']
mate_epx = cata_compor[relation]['NOM_EPX']
if cata_compor[relation].has_key('MC_FACT'):
cle_bs = cata_compor[relation]['MC_FACT']
else:
cle_bs = None
l_para = []
l_vale = []
l_bs = []
l_cisail = False
for i_loi, loi in enumerate(cata_compor[relation]['LOI']):
besoin = cata_compor[relation]['BESOIN'][i_loi]
donnees_loi = recupere_structure(concept_mater, loi)
if not donnees_loi:
if besoin == 'o':
UTMESS('F', 'PLEXUS_33', valk=(loi, nom_mater, relation))
else:
continue
donnees_loi = tolist(donnees_loi)
if relation == 'GLRC_DAMAGE' and loi == 'RELATION':
rela = donnees_loi[0]
if relation != rela:
UTMESS('F', 'PLEXUS_22', valk=(loi, nom_mater, relation))
continue
rel_loi = relation + '/' + loi
if cata_lois[rel_loi].has_key('NOM_EPX'):
mot_cle_fact = True
mot_cle_epx = cata_lois[rel_loi]['NOM_EPX']
else:
mot_cle_fact = False
if (cata_compor[relation]['REPEAT'][i_loi] == 'n'
and len(donnees_loi) > 1):
raise Exception(
'Erreur de programmation, le mot cle ne peut pas etre repete')
elif (cata_compor[relation]['REPEAT'][i_loi] == 'y'
and not mot_cle_fact):
raise Exception(
'Erreur dev : un motclé repetable doit avoir NOM_EPX dans sa loi')
# lecture des parametres
if relation == 'GLRC_DAMAGE' and loi == 'CISAIL_NL':
l_cisail = True
for donnees in donnees_loi:
l_para, l_vale, l_bs, liste_fonc = get_para_all(loi, relation,
l_para, l_vale, l_bs,
nom_mater, donnees,
liste_fonc)
if cata_ordre_para.has_key(relation):
ordre_para = cata_ordre_para[relation]
else:
ordre_para = None
# ETAPE 5 : Construction du bloc de données
titre = mate_rela
if mate_epx == 'GLRC DAMA' and l_cisail:
mate_epx += ' SHEA'
bloc = BLOC_MATE(mate_epx, l_group, cara=l_para, vale=l_vale,
cle_bs=cle_bs, l_bs=l_bs, ordre_para=ordre_para,
titre=titre)
epx[directive].add_bloc(bloc)
# traiter les fonctions
for dic_fonc in liste_fonc:
if type(dic_fonc) is not dict:
continue
val = dic_fonc['VALE']
ifo = dic_fonc['NUME']
nom_aster = dic_fonc['NOM_FONC']
cle_fonc = '%i LSQU 2 TABL' % (ifo)
bloc_fonc = FONCTION(cle_fonc, val[0], val[1], nom_aster=nom_aster)
epx['FONC'].add_bloc(bloc_fonc)
# INTERFACES
listInterfaces = INTERFACES
gmaInterfaces = []
if listInterfaces:
for interface in listInterfaces:
Lgma1 = tolist(interface['GROUP_MA_1'])
Lgma2 = tolist(interface['GROUP_MA_2'])
gmaInterfaces.extend(Lgma1)
gmaInterfaces.extend(Lgma2)
mot_cle_epx = 'FANTOME'
val_cle = 0.
titre = 'INTERFACES'
bloc = BLOC_DONNEES(mot_cle_epx, l_group=gmaInterfaces,
val_cle=val_cle, titre=titre)
epx[directive].add_bloc(bloc)
# traitement des orientations pour GLRC
# on le fait ici car cela depend du materiau
# DEFINITION REPERES ORTHOTROPIE QUI DOIT ETRE APRES MATE
directive2 = 'ORIENTATION'
for gma in gmaGLRC:
if gma not in dicOrthotropie:
UTMESS('F', 'PLEXUS_36', valk=(gma))
vale = dicOrthotropie[gma]
mot_cle_epx = 'COMP ORTS'
val_cle = '%s %s %s' % (vale[0], vale[1], vale[2])
bloc = BLOC_DONNEES(mot_cle_epx, l_group=gma, val_cle=val_cle,)
epx[directive2].add_bloc(bloc)
return epx, dic_compor_gr, mode_from_compor, gmaInterfaces
def export_modele(epx, MAILLAGE, MODELE, gmaInterfaces, info_mode_compl):
"""
Traitement du concept MODELE et traduction pour EPX
"""
directive = 'GEOM'
# Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MODELE
affe_modele = recupere_structure(MODELE, 'AFFE')
affe_modele = tolist(affe_modele)
# initialisation du dictionnaire qui contient les group_ma en fonction
# de la modelisation
epx_geom = {}
MApyt = MAIL_PY()
MApyt.FromAster(MAILLAGE)
len_str_gr_med_max = 24
gr_cr_noms_coupes = []
veri_gr_from_compl = []
ltyma = aster.getvectjev("&CATA.TM.NOMTM")
modi_repere = {'COQUE': False}
etat_init_cont = []
for affe in affe_modele:
modelisation = affe['MODELISATION']
phenomene = affe['PHENOMENE']
if phenomene != 'MECANIQUE':
UTMESS('A', 'PLEXUS_24', valk=phenomene)
if modelisation not in cata_modelisa.keys():
UTMESS('A', 'PLEXUS_6', valk=modelisation)
if affe.has_key('TOUT'):
if not MApyt.gma.has_key(string.rstrip('TOUT')):
DEFI_GROUP(reuse=MAILLAGE,
MAILLAGE=MAILLAGE,
CREA_GROUP_MA=(_F(
NOM='TOUT',
TOUT='OUI',
), ))
else:
UTMESS('A', 'PLEXUS_3')
group_ma = ['TOUT']
else:
group_ma = get_group_ma(affe, mcfact='AFFE_MODELE/AFFE')
if not cata_modelisa[modelisation]['ETAT_INIT']:
etat_init_cont.append(modelisation)
if cata_modelisa[modelisation].has_key('MODI_REPERE'):
type_modi = cata_modelisa[modelisation]['MODI_REPERE']
modi_repere[type_modi] = True
li_ty_ma_mode = cata_modelisa[modelisation]['MODE_EPX'].keys()
nb_type_ma = len(li_ty_ma_mode)
ltyma_maya = MAILLAGE.sdj.TYPMAIL.get()
# vérification de la présence des différents type de mailles possibles
# dans le groupe
for gr in group_ma:
lgeom = [False] * nb_type_ma
l_ma_gr = MAILLAGE.sdj.GROUPEMA.get()[gr.ljust(24)]
for m in l_ma_gr:
typ_ok = False
typ_m = ltyma[ltyma_maya[m - 1] - 1].strip()
for i_typ, typma in enumerate(li_ty_ma_mode):
if typ_m == typma:
lgeom[i_typ] = True
typ_ok = True
break
if not typ_ok:
UTMESS('F', 'PLEXUS_23', valk=(typ_m, gr, modelisation))
if lgeom.count(True) == 0:
UTMESS('F', 'PLEXUS_25', valk=(gr, modelisation))
l_gr = len(gr)
for i_typ, typma in enumerate(li_ty_ma_mode):
if lgeom[i_typ] and lgeom.count(True) > 1:
ll = len(typma)
if l_gr <= len_str_gr_med_max - ll:
nom_gr = gr + typma
else:
nom_gr = gr[:len_str_gr_med_max - ll] + typma
num = 1
# traitement d'un cas vraiment peu probable mais pas
# impossible
while nom_gr in gr_cr_noms_coupes:
suffi = typma + "%s" % num
nom_gr = gr[:len_str_gr_med_max -
len(suffi)] + suffi
num += 1
if num == 20:
raise Exception(
'Problème de noms de groupes de mailles')
gr_cr_noms_coupes.append(nom_gr)
if not MApyt.gma.has_key(string.rstrip(nom_gr)):
DEFI_GROUP(reuse=MAILLAGE,
MAILLAGE=MAILLAGE,
CREA_GROUP_MA=(_F(NOM=nom_gr,
GROUP_MA=gr,
TYPE_MAILLE=typma), ))
elif lgeom[i_typ]:
nom_gr = gr
else:
continue
if len(cata_modelisa[modelisation]['MODE_EPX'][typma]) == 1:
mode_epx = cata_modelisa[modelisation]['MODE_EPX'][typma][
0]
elif len(cata_modelisa[modelisation]['MODE_EPX'][typma]) == 0:
# elements a ne pas inclure dans GEOM
# face de 3D par exemple
continue
else:
# cas ou la modelisation dépend du CARA_ELEM
mode_epx_dispo = cata_modelisa[modelisation]['MODE_EPX'][
typma]
if not gr in info_mode_compl.keys():
UTMESS('F', 'PLEXUS_26', valk=gr)
else:
veri_gr_from_compl.append(gr)
mode_epx = info_mode_compl[gr]
if mode_epx not in mode_epx_dispo:
raise Exception(
"Modélisation epx %s non permise pour la modélidation %s"
% (mode_epx, modelisation))
if not epx_geom.has_key(mode_epx):
if cata_modelisa[modelisation].has_key('RESU_POIN'):
resu_poin = cata_modelisa[modelisation]['RESU_POIN']
else:
resu_poin = True
epx_geom[mode_epx] = {
'GROUP_MA': [],
'RESU_ELEM': cata_modelisa[modelisation]['RESU_ELEM'],
'RESU_POIN': resu_poin,
}
epx_geom[mode_epx]['GROUP_MA'].append(nom_gr)
# verif info_mode_compl
for gr in info_mode_compl:
if gr not in veri_gr_from_compl:
UTMESS('F', 'PLEXUS_34', valk=gr)
# liste comportant les modelisations definis dans le module GEOMETRIE
# Ecriture sous format europlexus
for mode_epx in epx_geom.keys():
if mode_epx in mode_epx_fin:
continue
len_groups = len(epx_geom[mode_epx]['GROUP_MA'])
if len_groups == 0:
raise Exception('Erreur de programmation : liste de groupe vide')
bloc_simple = BLOC_DONNEES(mode_epx,
cara=epx_geom[mode_epx]['GROUP_MA'])
epx[directive].add_bloc(bloc_simple)
for mode_epx in mode_epx_fin:
if mode_epx in epx_geom.keys():
len_groups = len(epx_geom[mode_epx]['GROUP_MA'])
if len_groups == 0:
raise Exception(
'Erreur de programmation : liste de groupe vide')
bloc_simple = BLOC_DONNEES(mode_epx,
cara=epx_geom[mode_epx]['GROUP_MA'])
epx[directive].add_bloc(bloc_simple)
# INTERFACES
if gmaInterfaces:
bloc_simple = BLOC_DONNEES('CL3L', cara=gmaInterfaces)
epx[directive].add_bloc(bloc_simple)
return epx, epx_geom, modi_repere, etat_init_cont
def prep_cont2effo(self, ):
"""
Construction des champs pour le passage des contraintes aux efforts
Complète dic_mc_cara avec ces infos.
"""
from code_aster.Cata.Commands import FORMULE, CREA_CHAMP
from Calc_epx.calc_epx_utils import recupere_structure, tolist
from Calc_epx.calc_epx_utils import get_group_ma
from Calc_epx.calc_epx_cara import export_cara
from Calc_epx.calc_epx_struc import DIRECTIVE
# 1- RECUPERATION DES INFOS
dic_mc_cara = self.dic_mc_cara
if self.CARA_ELEM is None:
return
cara_elem_struc = recupere_structure(self.CARA_ELEM)
for mc_cara in dic_mc_cara.keys():
if not cara_elem_struc.has_key(mc_cara):
continue
donnees_cara = tolist(cara_elem_struc[mc_cara])
epx = {}
epx['COMPLEMENT'] = DIRECTIVE('COMPLEMENT', ' ', 2)
mode_from_cara = {}
dic_gr_cara_supp = {}
# analyse du cara_elem
[epx, mode_from_cara
] = export_cara(mc_cara, epx, cara_elem_struc[mc_cara], None,
None, dic_gr_cara_supp, mode_from_cara)
# COQUE -------------------------------------------------------
if mc_cara == 'COQUE':
if len(dic_mc_cara[mc_cara]['INSTANCE']) == 0:
nbcomp = len(dic_mc_cara[mc_cara]['NOM_CMP'])
__FO_CO = [None] * nbcomp
nume_X = [1, 1, 1, 2, 2, 2, 1, 1]
vale_f = []
nom_cmp_f = []
for i, comp in enumerate(dic_mc_cara[mc_cara]['NOM_CMP']):
xnum_i = 'X%s' % (nume_X[i])
xi = 'X%s' % (i + 1)
val_fonc = comp + '*' + xnum_i
nom_para = (comp, xnum_i)
__FO_CO[i] = FORMULE(VALE=val_fonc, NOM_PARA=nom_para)
vale_f.append(__FO_CO[i])
nom_cmp_f.append(xi)
dic_mc_cara[mc_cara]['VALE_F'] = vale_f
dic_mc_cara[mc_cara]['NOM_CMP_F'] = nom_cmp_f
for instance in donnees_cara:
epais = instance['EPAIS']
gr = get_group_ma(instance)
dic_mc_cara[mc_cara]['GROUP_MA'].extend(gr)
dic_mc_cara[mc_cara]['INSTANCE'].append({
'VALE': epais,
'GROUP_MA': gr,
'NOM_CMP': 'X1'
})
dic_mc_cara[mc_cara]['INSTANCE'].append({
'VALE': epais**2 / 6.,
'GROUP_MA': gr,
'NOM_CMP': 'X2'
})
# BARRE -------------------------------------------------------
elif mc_cara == 'BARRE':
if len(dic_mc_cara[mc_cara]['INSTANCE']) == 0:
nbcomp = len(dic_mc_cara[mc_cara]['NOM_CMP'])
__FO_BA = [None] * nbcomp
nume_X = [
1,
]
vale_f = []
nom_cmp_f = []
for i, comp in enumerate(dic_mc_cara[mc_cara]['NOM_CMP']):
xnum_i = 'X%s' % (nume_X[i])
xi = 'X%s' % (i + 1)
val_fonc = comp + '*' + xnum_i
nom_para = (comp, xnum_i)
__FO_BA[i] = FORMULE(VALE=val_fonc, NOM_PARA=nom_para)
vale_f.append(__FO_BA[i])
nom_cmp_f.append(xi)
# creation du champ de fonction
dic_mc_cara[mc_cara]['VALE_F'] = vale_f
dic_mc_cara[mc_cara]['NOM_CMP_F'] = nom_cmp_f
for instance in donnees_cara:
cara = instance['CARA']
cara = tolist(cara)
if len(cara) != 1 or cara[0] != 'A':
raise Exception("""si on tombe la on utilise LIRE_EPX
en dehors de CALC_EPX.
Il faut ajouter une analyse du CARA_ELEM.
""")
aire_sect = tolist(instance['VALE'])[0]
gr = get_group_ma(instance)
dic_mc_cara[mc_cara]['GROUP_MA'].extend(gr)
dic_mc_cara[mc_cara]['INSTANCE'].append({
'VALE': aire_sect,
'GROUP_MA': gr,
'NOM_CMP': 'X1'
})
# CAS NON DEVELOPPES ------------------------------------------
elif mc_cara in dic_mc_cara.keys():
raise Exception("""
Le passage des contraintes aux efforts n'est pas programmé pour
le mot-clé %s""" % mc_cara)
# 2- CREATION DES CHAMPS DE CARACTERISTIQUES ET DE FONCTIONS
# POUR CONTRAINTES
nb_cara = len(dic_mc_cara.keys())
__CH_CAR = [None] * nb_cara
__CH_FON = [None] * nb_cara
for icar, mc_cara in enumerate(dic_mc_cara.keys()):
if len(dic_mc_cara[mc_cara]['INSTANCE']) > 0:
__CH_CAR[icar] = CREA_CHAMP(
INFO=self.INFO,
TYPE_CHAM='ELGA_NEUT_R',
OPERATION='AFFE',
MODELE=self.MODELE,
PROL_ZERO='OUI',
AFFE=dic_mc_cara[mc_cara]['INSTANCE'],
)
dic_mc_cara[mc_cara]['CH_CARA'] = __CH_CAR[icar]
nom_cmp_f = dic_mc_cara[mc_cara]['NOM_CMP_F']
vale_f = dic_mc_cara[mc_cara]['VALE_F']
gr = dic_mc_cara[mc_cara]['GROUP_MA']
__CH_FON[icar] = CREA_CHAMP(
INFO=self.INFO,
TYPE_CHAM='ELGA_NEUT_F',
OPERATION='AFFE',
MODELE=self.MODELE,
PROL_ZERO='OUI',
AFFE=_F(GROUP_MA=gr, NOM_CMP=nom_cmp_f, VALE_F=vale_f),
)
dic_mc_cara[mc_cara]['CH_FONC'] = __CH_FON[icar]
def export_CARA_ELEM(self):
"""
Traduction des caractéristiques élémentaires de Code_Aster dans
les directives EPX correspondantes.
"""
from Calc_epx.calc_epx_cata import cata_cara_elem
from Calc_epx.calc_epx_cara import export_cara, get_FONC_PARASOL
from Calc_epx.calc_epx_utils import recupere_structure, angle2vectx
from Calc_epx.calc_epx_utils import get_group_ma, tolist
from Calc_epx.calc_epx_poutre import POUTRE
epx = self.epx
dic_gr_cara_supp = {}
# Récuperer s'il a lieu les fonctions de ressorts de sol et discrets
if self.FONC_PARASOL is not None:
dic_gr_cara_supp = get_FONC_PARASOL(epx, self.FONC_PARASOL,
dic_gr_cara_supp)
# récupérer les orientations des poutres
if self.CARA_ELEM:
class_poutre = POUTRE(MAILLAGE=self.MAILLAGE, CARA_ELEM=self.CARA_ELEM)
dic_gr_cara_supp = class_poutre.get_orie_poutre(dic_gr_cara_supp)
mode_from_cara = {}
self.dicOrthotropie = None
# Recuperer la structure du concept sorti de AFFE_CARA_ELEM
if self.CARA_ELEM is not None:
cara_elem_struc = recupere_structure(self.CARA_ELEM)
for cle in cara_elem_struc.keys():
if cle in ['INFO', 'MODELE']:
continue
if not cata_cara_elem.has_key(cle):
UTMESS('F', 'PLEXUS_18', valk=cle)
if cata_cara_elem[cle] == None:
continue
[epx, mode_from_cara] = export_cara(cle, epx,
cara_elem_struc[cle],
self.MAILLAGE, self.CARA_ELEM_CONCEPT,
dic_gr_cara_supp, mode_from_cara)
if cle == 'COQUE':
# récupérer les orientations des coques
# utilisées pour GLRC_DAMAGE
dicOrthotropie = {}
donnees_coque = tolist(cara_elem_struc[cle])
for elem in donnees_coque:
l_group = get_group_ma(elem, mcfact='AFFE_CARA_ELEM/COQUE')
if elem.has_key('VECTEUR'):
for group in l_group:
dicOrthotropie[group] = elem['VECTEUR']
elif elem.has_key('ANGL_REP'):
alpha, beta = elem['ANGL_REP']
vect = angle2vectx(alpha, beta)
for group in l_group:
dicOrthotropie[group] = vect
self.dicOrthotropie = dicOrthotropie
self.info_mode_compl.update(mode_from_cara)
def export_charge(epx, EXCIT, MAILLAGE):
"""
Analyse et traduction pour EPX des données de chargement
contenues dans l'objet EXCIT.
"""
from Calc_epx.calc_epx_struc import FONCTION, BLOC_DONNEES
from Calc_epx.calc_epx_cata import cata_charge, cata_liais
excit_list = EXCIT.List_F()
ifonc = epx['FONC'].len_mcs()
for excit in excit_list:
concept_charge = excit['CHARGE']
if excit.has_key('FONC_MULT'):
fonction = excit['FONC_MULT']
nom_fonc_aster = fonction.get_name()
else:
fonction = None
l_char_fact = False
l_link_fonc = False
list_char = recupere_structure(concept_charge)
list_char = list_char.keys()
# mots-clé de AFFE_CHAR_MECA
for char in list_char:
if char in ['INFO', 'MODELE']:
continue
elif char in cata_charge.keys():
directive = 'CHARGE'
cata = cata_charge
l_char_fact = True
type_char = recu_val('o', cata, char, 'TYPE_CHAR', None)
if type_char[:4] == 'FACT':
l_char_fact = True
if fonction is None:
UTMESS('F', 'PLEXUS_7', valk=char)
elif type_char[:4] == 'CONS':
raise Exception("""Type de charge pas encore testé
des aménagements sont certainement à faire.
Cette exeption peut être supprimée suite à cela.
""")
if fonction:
UTMESS('F', 'PLEXUS_5', valk=char)
else:
raise Exception("""Type de charge EPX non pris en
compte : %s""" % type_char)
if not epx[directive].get_mcfact(type_char):
objet = epx[directive].add_mcfact(type_char)
else:
objet = epx[directive].get_mcfact(type_char)
elif char in cata_liais.keys():
directive = 'LINK'
cata = cata_liais
objet = epx[directive]
else:
UTMESS('F', 'PLEXUS_19', char)
char_list = recupere_structure(concept_charge, char)
char_list = tolist(char_list)
mot_cle_epx = recu_val('o', cata, char, 'MOT_CLE_EPX', None)
if len(mot_cle_epx) > 1:
# choix du mot-clé :
if char == 'DDL_IMPO':
if fonction:
mot_cle_epx = mot_cle_epx[1]
else:
mot_cle_epx = mot_cle_epx[0]
else:
raise Exception('cas non traité')
else:
mot_cle_epx = mot_cle_epx[0]
if directive == 'LINK':
l_fonc = False
if recu_val('o', cata, char, 'FONC_MULT', mot_cle_epx):
l_link_fonc = True
l_fonc = True
if fonction is None:
UTMESS('F', 'PLEXUS_7', valk=char)
cle_aster = recu_val('o', cata, char, 'ASTER', mot_cle_epx)
cle_epx = recu_val('o', cata, char, 'EPX', mot_cle_epx)
if cle_epx is False and len(cle_aster) != 1:
raise Exception("""Préciser EPX dans %s car la liste ASTER
possède plusieurs éléments.
""")
entite = recu_val('f', cata, char, 'ENTITE', mot_cle_epx)
if not entite:
entite = []
vale_impo = recu_val('f', cata, char, 'VALE_IMPO', mot_cle_epx)
coef_mult = recu_val('f', cata, char, 'COEF_MULT', mot_cle_epx)
mot_cle_verif = recu_val(
'f', cata, char, 'MOT_CLE_VERIF', mot_cle_epx)
if not mot_cle_verif:
mot_cle_verif = []
vale_verif = False
else:
vale_verif = recu_val(
'o', cata, char, 'VALE_VERIF', mot_cle_epx)
nb_cle_max = recu_val('f', cata, char, 'NB_CLE_MAX', mot_cle_epx)
if not nb_cle_max:
nb_cle_max = 1
# occurrences des mots-clé facteurs
for ch in char_list:
# EC pour l'instant on a que des cas a une valeur
# li_vale = []
info_epx = ''
l_group = None
l_cara = []
l_vale = []
nb_cle = 0
for cle in ch.keys():
if cle in mot_cle_verif:
ind = mot_cle_verif.index(cle)
if ch[cle] not in tolist(vale_verif[ind]):
UTMESS('F', 'PLEXUS_30', valk=(cle, char, ch[cle],
' '.join(tolist(vale_verif[ind]))))
continue
if cle in entite:
l_group = get_group_ma(ch, cle, mcfact='AFFE_CHAR_MECA/' + char)
continue
if not cle in cle_aster:
UTMESS('F', 'PLEXUS_27', valk=(cle, char))
if char == 'RELA_CINE_BP':
if cle != cle_aster[0]:
raise Exception('Erreur avec RELA_CINE_BP')
cable_bp = ch[cle]
if ch.has_key('TYPE_EPX'):
type_epx = ch['TYPE_EPX']
else:
type_epx = 'ADHE'
# info_epx, l_cara = ecri_rela_cine(cable_bp, MAILLAGE,)
# l_vale = [''] * len(l_cara)
bloc_donnees = ecri_rela_cine(cable_bp, mot_cle_epx, type_epx)
else:
vale_tmp = ch[cle]
nb_cle += 1
if nb_cle > nb_cle_max:
UTMESS(
'F', 'PLEXUS_29', valk=(char, ','.join(cle_aster)),
vali=(nb_cle, nb_cle_max))
ind = cle_aster.index(cle)
vale = ''
if vale_impo is not False:
if vale_tmp != vale_impo:
UTMESS('F', 'PLEXUS_28', valk=(cle, char),
valr=(vale_tmp, vale_impo))
else:
vale = vale_tmp
if coef_mult:
vale = coef_mult * vale
if cle_epx:
info_epx += cle_epx[ind]
if directive == 'LINK' and l_fonc:
l_cara.append('FONC')
l_vale.append(ifonc + 1)
if char != 'RELA_CINE_BP':
bloc_donnees = BLOC_DONNEES(mot_cle_epx, l_group=l_group,
cle=info_epx, val_cle=vale,
cara=l_cara, vale=l_vale)
objet.add_bloc(bloc_donnees)
if l_char_fact:
# ajout de la fonction
(temps, valeurs) = fonction.Valeurs()
bloc_fonc = FONCTION('TABLE', temps, valeurs,
nom_aster=nom_fonc_aster)
objet.add_bloc(bloc_fonc)
if l_link_fonc:
ifonc += 1
(temps, valeurs) = fonction.Valeurs()
bloc_fonc = FONCTION('%s TABL' % ifonc, temps, valeurs,
nom_aster=nom_fonc_aster)
epx['FONC'].add_bloc(bloc_fonc)