def orientation_cara_elem(self, ):
"""
Récupération des orientations des poutres
"""
dic_gma = {}
etapes = self.CARA_ELEM.etape.valeur
if not etapes.has_key('ORIENTATION'):
return dic_gma
orientation = tolist(etapes['ORIENTATION'])
for ll in orientation:
cara = ll['CARA']
if cara in ['ANGL_VRIL', 'ANGL_NAUT', 'VECT_Y']:
if ll.has_key('GROUP_MA'):
group_ma = tolist(ll['GROUP_MA'])
a = ll['VALE']
for gr in group_ma:
if not dic_gma.has_key(gr):
dic_gma[gr] = {}
dic_gma[gr][cara] = a
for gr in dic_gma.keys():
if not dic_gma[gr].has_key('VECT_Y'):
if not dic_gma[gr].has_key('ANGL_VRIL'):
dic_gma[gr]['ANGL_VRIL'] = 0.0
if dic_gma[gr].has_key('ANGL_NAUT'):
UTMESS('F', 'PLEXUS_10')
return dic_gma
def __init__(self,
mot_cle,
l_group,
cara=[],
vale=[],
cle_bs=None,
l_bs=[],
ordre_para=None,
titre=None):
"""
Création de l'objet
"""
l_group = tolist(l_group)
if len(l_group) == 0:
raise Exception('BLOC_MATE : l_group est vide')
if len(cara) != len(vale):
raise Exception("BLOC_MATE : len(cara)!= len(vale)")
self.groupes = l_group
self.mot_cle = mot_cle
self.cara = cara
self.vale = vale
if cle_bs and len(l_bs) == 0:
raise Exception(
'l_bs ne doit pas être de longueur nulle si cle_bs')
if cle_bs is None and len(l_bs) > 0:
raise Exception('l_bs est présent, il faut renseigner cle_bs')
if cle_bs and not ordre_para:
raise Exception('renseignez ordre_para si vous donnez cle_bs')
self.cle_bs = cle_bs
self.l_bs = l_bs
self.ordre_para = ordre_para
self.titre = titre
def __init__(self,
mot_cle,
l_group=None,
cle='',
val_cle='',
cara=[],
vale=[],
titre=None,
lect_term='fin',
cle_l_group='LECT',
dispo_group='verti'):
"""
Création de l'objet.
Seul mot_cle est obligatoire.
"""
if type(mot_cle) != str:
raise Exception("BLOC_DONNEES : 1er arg doit être de type string.")
elif mot_cle.strip() == '':
raise Exception("BLOC_DONNEES : 1er arg de doit pas être '' .")
if l_group is not None:
l_group = tolist(l_group)
if len(l_group) == 0:
l_group = None
cara = tolist(cara)
vale = tolist(vale)
if len(vale) != 0 and len(cara) != len(vale):
raise Exception("BLOC_DONNEES : len(cara)!=len(vale)")
self.groupes = l_group
self.mot_cle = mot_cle
self.cle = cle
self.val_cle = val_cle
self.cara = cara
self.vale = vale
self.titre = titre
self.cle_groupes = cle_l_group
if lect_term != 'fin' and lect_term != 'debut':
raise Exception('lect_term doit etre egal à debut ou fin')
self.lect_term = lect_term
if dispo_group != 'verti' and dispo_group != 'hori':
raise Exception('dispo_group doit etre egal à verti ou hori')
self.dispo_group = dispo_group
self.lenmax = 80
def __init__(self, mot_cle, l_BD, cle='', val_cle=''):
"""
Création de l'objet
"""
l_BD = tolist(l_BD)
if len(l_BD) == 0:
raise Exception("BLOC_DONNEES_SUP : liste de BLOC_DONNEES vide")
self.mot_cle = mot_cle
self.cle = cle
self.val_cle = val_cle
self.l_BD = l_BD
def get_FONC_PARASOL(epx, FONC_PARASOL, dic_gr_cara_supp):
"""
Récupère les fonctions présentes dans FONC_PARASOL
"""
from Calc_epx.calc_epx_struc import FONCTION
from Calc_epx.calc_epx_utils import tolist
directive = 'FONC'
# Cles de FONC_PARASOL dans l'ordre
cles = ['NFKT', 'NFKR', 'NFAT', 'NFAR']
# dictionnaire nom de la fonction : numero de fonction
dic_fonc = {}
ifonc = epx['FONC'].len_mcs()
list_FONC_PARASOL = FONC_PARASOL.List_F()
l_group = []
for inst_fonc in list_FONC_PARASOL:
dic_gr = {}
for cle in cles:
if inst_fonc.has_key(cle):
fonction = inst_fonc[cle]
nom_aster = fonction.get_name()
if not nom_aster in dic_fonc.keys():
ifonc += 1
dic_fonc[nom_aster] = ifonc
(temps, valeurs) = fonction.Valeurs()
cle_fonc = '%i TABL' % (ifonc)
bloc_fonc = FONCTION(cle_fonc, temps, valeurs, nom_aster)
epx[directive].add_bloc(bloc_fonc)
dic_gr[cle] = dic_fonc[nom_aster]
l_gr_ma = tolist(inst_fonc['GROUP_MA'])
for gr in l_gr_ma:
if gr in l_group:
UTMESS('F', 'PLEXUS_41', valk=gr)
if dic_gr_cara_supp.has_key(gr):
dic_gr_cara_supp[gr].update(dic_gr)
else:
dic_gr_cara_supp[gr] = dic_gr
return dic_gr_cara_supp
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 bloc_cara(typ_carel, l_elem, epx, group, select, directive, mot_cle_aster,
mot_cle_epx, cara_aster, cara_epx, coef_mult, is_vale_aster,
mode_epx, mode_from_cara, titre, verif,
dic_gr_cara_supp):
"""
Analyse les données contenues dans une liste d'instances 'l_elem' du
mot clé facteur 'typ_carel' de AFFE_CARA_ELEM.
'l_elem' contient la plupart du temps un seul élément, sauf dans le
cas de typ_carel='DISCRET'.
"""
l_elem = tolist(l_elem)
mot_cle_epx_select = None
l_cara = []
l_vale = []
mot_cle_ignor = ['GROUP_MA']
for elem in l_elem:
for i_dic, sele in enumerate(select):
# sélection de la bonne traduction
good_trad = True
for cle in sele.keys():
if elem.has_key(cle):
if sele[cle] is not None:
valcle = elem[cle]
if type(elem[cle]) is list or type(elem[cle]) is tuple:
if len(elem[cle]) == 1:
valcle = elem[cle][0]
if valcle != sele[cle]:
good_trad = False
break
if not good_trad:
continue
# la traduction est sélectionnée
mot_cle_ok = []
mot_cle_ok.extend(sele.keys())
if mot_cle_aster[i_dic]:
# le mot-clé est présent en tant que mot-clé
if elem.has_key(mot_cle_aster[i_dic]):
val_cle = elem[mot_cle_aster[i_dic]]*coef_mult[i_dic]
vale = []
cara = []
if not mot_cle_aster[i_dic] in mot_cle_ok:
mot_cle_ok.append(mot_cle_aster[i_dic])
# le mot-clé est la valeur de 'CARA'
else:
cara_in = tolist(elem['CARA'])
ASSERT(len(cara_in) == 1)
ASSERT(cara_in[0] == mot_cle_aster[i_dic])
if not 'CARA' in mot_cle_ok:
mot_cle_ok.append('CARA')
if not 'VALE' in mot_cle_ok:
mot_cle_ok.append('VALE')
valeur = tolist(elem['VALE'])
if cara_epx[i_dic]:
# is_vale_aster est obligatoire dans ce cas
ASSERT(is_vale_aster[i_dic])
cara = list(cara_epx[i_dic])
vale = [None] * len(cara)
k_valeur = 0
for i_log, logi in enumerate(is_vale_aster[i_dic]):
if logi:
vale[i_log] = valeur[k_valeur]*coef_mult[i_dic][i_log]
k_valeur += 1
val_cle = ''
else:
ASSERT(len(valeur) == 1)
val_cle = valeur[0]*coef_mult[i_dic]
vale = []
cara = []
# couple CARA/VALE avec plusieurs caractéristiques
else:
if not 'CARA' in mot_cle_ok:
mot_cle_ok.append('CARA')
if not 'VALE' in mot_cle_ok:
mot_cle_ok.append('VALE')
val_cle = ''
cara_in = tolist(elem['CARA'])
vale_in = tolist(elem['VALE'])
cara = cara_epx[i_dic]
vale = [None] * len(cara)
for i, car in enumerate(cara_in):
if not car in cara_aster[i_dic]:
UTMESS('F', 'PLEXUS_8', valk=(car, typ_carel))
val = vale_in[i]
index = cara_aster[i_dic].index(car)
vale[index] = val*coef_mult[i_dic][index]
# traitement des doublons (cas ou aster est plus riche qu'EPX
# on verifie que les doublons ont la meme valeur
i = 0
while i< len(cara):
car1 = cara[i]
while cara.count(car1)>1:
index = cara[i+1:].index(car1)
index+= i+1
if vale[i] == vale[index]:
cara.pop(index)
vale.pop(index)
else:
UTMESS('F','PLEXUS_16', valk = [typ_carel, mot_cle_aster[i_dic]],
vali = [i+1, index+1])
i+=1
# verif des mots-clés autorisés
mc_verif = []
if verif[i_dic]:
mc_verif = verif[i_dic].keys()
for key in elem.keys():
if key in mot_cle_ok:
continue
elif key in mot_cle_ignor:
continue
elif key in mc_verif:
continue
else:
UTMESS('F', 'PLEXUS_45', valk=[key, typ_carel])
# on complete VALE avec des donnees provenant d'ailleurs
if None in vale:
for i, val in enumerate(vale):
if val is None:
car = cara[i]
# s'il y a en même temps K_T_D_L et A_T_D_L sur des DISCRET en repère local
# VX, VY et VZ vont être présents deux fois : on ne les ajoutes pas dans ce cas
if car in l_cara:
cara[i] = None
continue
if not dic_gr_cara_supp.has_key(group):
UTMESS(
'F', 'PLEXUS_12', valk=(car, typ_carel, group))
if not car in dic_gr_cara_supp[group]:
UTMESS(
'F', 'PLEXUS_12', valk=(car, typ_carel, group))
if type(dic_gr_cara_supp[group][car]) == int:
vale[i] = dic_gr_cara_supp[group][car]*int(coef_mult[i_dic][i])
else:
vale[i] = dic_gr_cara_supp[group][car]*coef_mult[i_dic][i]
while None in cara:
cara.remove(None)
vale.remove(None)
#
if verif[i_dic]:
for mc_aster in verif[i_dic].keys():
if verif[i_dic][mc_aster] is None:
continue
elif elem.has_key(mc_aster):
if elem[mc_aster] not in verif[i_dic][mc_aster]:
liste_ok = ', '.join(verif[i_dic][mc_aster])
UTMESS('F', 'PLEXUS_4', valk=(typ_carel, mc_aster,
elem[mc_aster], liste_ok))
else:
UTMESS('F', 'PLEXUS_56', valk=(typ_carel, mc_aster))
if mot_cle_epx_select == None:
mot_cle_epx_select = mot_cle_epx[i_dic]
directive_select = directive[i_dic]
val_cle_select = val_cle
titre_select = titre[i_dic]
mode_epx_select = mode_epx[i_dic]
else:
if (mot_cle_epx_select != mot_cle_epx[i_dic] or
directive_select != directive[i_dic] or
val_cle_select != val_cle or
titre_select != titre[i_dic] or
mode_epx_select != mode_epx[i_dic]):
raise Exception('Erreur dev : Incohérence des donnees')
l_cara.extend(cara)
l_vale.extend(vale)
if mot_cle_epx_select == None:
UTMESS('F','PLEXUS_52',valk = [typ_carel])
bloc_donnees = BLOC_DONNEES(mot_cle_epx_select, l_group=group,
val_cle=val_cle_select,
cara=l_cara, vale=l_vale, titre=titre_select)
epx[directive_select].add_bloc(bloc_donnees)
if mode_epx_select is not None:
if not mode_from_cara.has_key(group):
mode_from_cara[group] = mode_epx_select
else:
if mode_from_cara[group] != mode_epx_select:
UTMESS('F', 'PLEXUS_9', valk=(mode_from_cara[group],
mode_epx_select, group))
return epx, mode_from_cara
def export_cara(cle, epx, donnees_cle, MAILLAGE, CARA_ELEM,
dic_gr_cara_supp, mode_from_cara):
"""
Traite les données 'donnes_cle' contenues dans le mot clé facteur 'cle'
de l'objet CARA_ELEM
"""
from code_aster.Cata.Commands import DEFI_GROUP
donnees_cle = tolist(donnees_cle)
# recuperation des parametres
[select, titre, directive, mot_cle_epx, mot_cle_aster, cara_aster,
cara_epx, coef_mult, is_vale_aster, mode_epx, verif] = recu_cara_cata(cle)
if cle != 'RIGI_PARASOL':
dic_gr_donnees = {}
# recuperation des données pour chaque groupe (nécessaire pour le
# mot-clé DISCRET)
for elem in donnees_cle:
l_group = get_group_ma(elem, mcfact='AFFE_CARA_ELEM/' + cle)
for group in l_group:
if not group in dic_gr_donnees.keys():
dic_gr_donnees[group] = []
dic_gr_donnees[group].append(elem)
for group in dic_gr_donnees.keys():
l_elem = dic_gr_donnees[group]
epx, mode_from_cara = bloc_cara(cle, l_elem, epx, group,
select, directive, mot_cle_aster, mot_cle_epx,
cara_aster, cara_epx, coef_mult, is_vale_aster,
mode_epx, mode_from_cara, titre, verif,
dic_gr_cara_supp)
else:
MApyt = MAIL_PY()
MApyt.FromAster(MAILLAGE)
cara_parasol = None
if len(donnees_cle) > 1:
UTMESS('F', 'PLEXUS_42')
for elem in donnees_cle:
group_ma_poi1 = get_group_ma(elem, 'GROUP_MA_POI1')
if len(group_ma_poi1) != 1:
UTMESS('F', 'PLEXUS_43')
cara_in = tolist(elem['CARA'])
if cara_parasol is not None:
if cara_in != cara_parasol:
UTMESS('F', 'PLEXUS_15')
else:
cara_parasol = cara_in
# verif des caractéristiques
group_ma_poi1 = group_ma_poi1[0]
l_cara = []
for car in cara_parasol:
if car not in mot_cle_aster[0]:
UTMESS('F', 'PLEXUS_8',
valk=(car, cle))
l_cara.extend(cata_cara_elem[cle][0][car])
# info complementaire de modelisation
index = mot_cle_aster[0].index(car)
if mode_epx[0][index] is not None:
if not mode_from_cara.has_key(group_ma_poi1):
mode_from_cara[group_ma_poi1] = mode_epx[0][index]
else:
if mode_from_cara[group_ma_poi1] != mode_epx[0][index]:
raise Exception(
'Une modélisation existe déjà pour le groupe %s dans mode_from_cara' % group_ma_poi1)
if not dic_gr_cara_supp.has_key(group_ma_poi1):
UTMESS('F', 'PLEXUS_12', valk=('NKFT ou NFAT', cle, group_ma_poi1))
for car in l_cara:
if car.startswith('NF'):
if car not in dic_gr_cara_supp[group_ma_poi1]:
UTMESS('F', 'PLEXUS_12', valk=(car, cle, group_ma_poi1))
ressorts, amorts = CARA_ELEM.toEPX()
crea_gr_ma = []
li_mailles = []
li_mailles.extend(ressorts.keys())
li_mailles.extend(amorts.keys())
li_mailles = list(set(li_mailles))
for maille in li_mailles:
# attention si pas d'amortissement (ou pas de raideurs)
# amorts = {' ': (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)}
# on supprime cela de la liste li_mailles
if maille.strip() == '':
continue
#
group_ma = 'G_%s' % maille
if not MApyt.gma.has_key(string.rstrip(group_ma)):
crea_gr_ma.append({"MAILLE": maille, "NOM": group_ma})
else:
UTMESS('A', 'PLEXUS_35', valk=(group_ma, maille))
l_vale = []
for car in cara_parasol:
if car.startswith('K_'):
val_raid = [float2str(x) for x in ressorts[maille]]
l_vale.extend(val_raid[:3])
l_vale.append(dic_gr_cara_supp[group_ma_poi1]['NFKT'])
if car == 'K_TR_D_N':
l_vale.extend(val_raid[3:6])
l_vale.append(dic_gr_cara_supp[group_ma_poi1]['NFKR'])
if car.startswith('A_'):
val_amor = [float2str(x) for x in amorts[maille]]
l_vale.extend(val_amor[:3])
l_vale.append(dic_gr_cara_supp[group_ma_poi1]['NFAT'])
if car == 'A_TR_D_N':
l_vale.extend(val_amor[3:6])
l_vale.append(dic_gr_cara_supp[group_ma_poi1]['NFAR'])
bloc_donnees = BLOC_DONNEES(mot_cle_epx[0], l_group=group_ma,
cara=l_cara, vale=l_vale,
titre=titre[0])
epx[directive[0]].add_bloc(bloc_donnees)
if crea_gr_ma != []:
DEFI_GROUP(reuse=MAILLAGE,
MAILLAGE=MAILLAGE,
CREA_GROUP_MA=crea_gr_ma
)
return epx, mode_from_cara
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_CALCUL(self):
"""
Traduit les informations de lancement du calcul.
"""
from Calc_epx.calc_epx_struc import BLOC_DONNEES, BLOC_DONNEES_SUP
from Calc_epx.calc_epx_cata import cata_calcul
epx = self.epx
liste_mots_cles_CALCUL = self.CALCUL.List_F()[0]
# ETAT_INIT
if self.ETAT_INIT is not None:
directive = 'INIT'
epx[directive].add_info_dir('MEDL')
if self.ETAT_INIT['CONTRAINTE'] == 'OUI':
bloc = BLOC_DONNEES('CONT')
epx[directive].add_bloc(bloc)
if self.ETAT_INIT['VARI_INT'] == 'OUI':
bloc = BLOC_DONNEES('ECRO')
epx[directive].add_bloc(bloc)
else:
niter = self.ETAT_INIT['NITER']
bloc = BLOC_DONNEES('NITER', cle=niter)
epx[directive].add_bloc(bloc)
if self.ETAT_INIT['EQUILIBRE'] == 'OUI':
bloc = BLOC_DONNEES('EQUI')
epx[directive].add_bloc(bloc)
# OPTION
directive = 'OPTION'
type_discr = liste_mots_cles_CALCUL['TYPE_DISCRETISATION']
bloc = BLOC_DONNEES('PAS', cle=type_discr)
epx[directive].add_bloc(bloc)
if type_discr == 'AUTO':
cstab = liste_mots_cles_CALCUL['CSTAB']
bloc = BLOC_DONNEES('CSTAB', cle=cstab)
epx[directive].add_bloc(bloc)
if self.AMORTISSEMENT is not None:
liste_mots_cles_AMOR = self.AMORTISSEMENT.List_F()[0]
type_amor = liste_mots_cles_AMOR['TYPE_AMOR']
if type_amor == 'QUASI_STATIQUE':
freq = liste_mots_cles_AMOR['FREQUENCE']
coef = liste_mots_cles_AMOR['COEF_AMOR']
if liste_mots_cles_AMOR.has_key('INST_DEB_AMOR'):
deb_amor = liste_mots_cles_AMOR['INST_DEB_AMOR']
fin_amor = liste_mots_cles_AMOR['INST_FIN_AMOR']
cara = ['FROM', 'UPTO']
vale = [deb_amor, fin_amor]
else:
cara = []
vale = []
coef = liste_mots_cles_AMOR['COEF_AMOR']
bloc = BLOC_DONNEES('QUASI STATIQUE', cle=freq, val_cle=coef,
cara=cara, vale=vale)
epx[directive].add_bloc(bloc)
else:
raise Exception("Type d'amortissement non programmé")
# STRUCTURE
directive = 'STRUCTURE'
listInterfaces = self.INTERFACES
listDomaines = self.DOMAINES
domaineInterfaces = {}
if listDomaines:
epx[directive].add_info_dir(len(listDomaines))
for interface in listInterfaces:
Lgma1 = tolist(interface['GROUP_MA_1'])
Lgma2 = tolist(interface['GROUP_MA_2'])
idS1 = interface['IDENT_DOMAINE_1']
idS2 = interface['IDENT_DOMAINE_2']
if not domaineInterfaces.has_key(idS1):
domaineInterfaces[idS1] = []
if not domaineInterfaces.has_key(idS2):
domaineInterfaces[idS2] = []
domaineInterfaces[idS1].extend(Lgma1)
domaineInterfaces[idS2].extend(Lgma2)
else:
listDomaines = []
for domaine in listDomaines:
Lgma = tolist(domaine['GROUP_MA'])
id = domaine['IDENTIFIANT']
Lgma.extend(domaineInterfaces[id])
mot_cle = 'DOMA'
cara = 'IDENTIFIANT'
vale = id
bloc = BLOC_DONNEES(mot_cle, l_group=Lgma, cara=cara, vale=vale,
lect_term='debut')
epx[directive].add_bloc(bloc)
# INTERFACE
directive = 'INTERFACE'
if listInterfaces:
epx[directive].add_info_dir(len(listInterfaces))
else:
listInterfaces = []
for interface in listInterfaces:
Lgma1 = tolist(interface['GROUP_MA_1'])
Lgma2 = tolist(interface['GROUP_MA_2'])
idS1 = interface['IDENT_DOMAINE_1']
idS2 = interface['IDENT_DOMAINE_2']
tole = interface['TOLE']
mot_cle = 'DOMA'
bloc1 = BLOC_DONNEES(mot_cle, l_group=Lgma1, val_cle=idS1)
bloc2 = BLOC_DONNEES(mot_cle, l_group=Lgma2, val_cle=idS2)
mot_cle = 'MORTAR'
cle = 'TOLE'
bloc_sup = BLOC_DONNEES_SUP(mot_cle, cle=cle, val_cle=tole,
l_BD=[bloc1, bloc2])
epx[directive].add_bloc(bloc_sup)
# CALCUL
directive = 'CALCUL'
for cle in cata_calcul.keys():
if liste_mots_cles_CALCUL.has_key(cle):
vale = liste_mots_cles_CALCUL[cle]
bloc = BLOC_DONNEES(cata_calcul[cle], cle=vale)
epx[directive].add_bloc(bloc)
def export_POST_COURBE(self):
"""
Traitement du mot-clé COURBE dans la directive SORTIE.
"""
from Calc_epx.calc_epx_struc import BLOC_DONNEES
from Calc_epx.calc_epx_cata import cata_champs, cata_compo
# Suite de postraitement permettant d'ecrire des fichiers ASCII
# des grandeurs demandees
# Tester si le mot_cle facteur COURBE a ete renseigne
courbe_fact = self.COURBE
if courbe_fact is None:
return
courbe_fact = courbe_fact.List_F()
self.nb_COURBE = len(courbe_fact)
epx = self.epx
# SUITE
directive = 'SUITE'
epx[directive].add_void()
# INFO_SORTIE
directive = 'INFO_SORTIE'
if self.UNITE_COURBE:
fichier_courbes = os.path.join(self.REPE_epx, 'fort.%s'
% str(self.UNITE_COURBE))
else:
fichier_courbes = self.nom_fichiers['PUN']
bloc = BLOC_DONNEES('RESULTAT', cara='ALICE TEMPS', vale='11')
epx[directive].add_bloc(bloc)
bloc = BLOC_DONNEES('OPNF', cara=['FORMAT', "'%s'"%fichier_courbes],
vale=['17', ''])
epx[directive].add_bloc(bloc)
# SORTIE
directive = 'SORTIE'
objet = epx[directive].add_mcfact('GRAPHIQUES')
bloc = BLOC_DONNEES('AXTEMPS', cle="1. 'TEMPS(s)'")
objet.add_bloc(bloc)
# Dictionnaire décrivant les légendes des abscisses et ordodonnees
# des courbes imprimées et utilisées dans get_tables.
self.legend_courbes = {}
dic_entite = {'GROUP_NO' : 'NOEUD', 'GROUP_MA' : 'ELEM'}
nb_courbe = 0
lnoeuds = []
nb_char_lim_pun = 16
for i_courbe,courbe in enumerate(courbe_fact):
for entite_type in dic_entite.keys():
if courbe.has_key(entite_type):
entite = courbe[entite_type]
cham_aster = courbe['NOM_CHAM']
cmp_aster = courbe['NOM_CMP']
cham_epx = cata_champs[cham_aster]
if not cata_compo[cham_aster].has_key(cmp_aster):
UTMESS('F', 'PLEXUS_38', valk=[cham_aster, cmp_aster])
cmp_epx = cata_compo[cham_aster][cmp_aster]
label = courbe['NOM_COURBE']
entite = tolist(entite)
ll = len(label)
if ll > nb_char_lim_pun:
UTMESS('A', 'PLEXUS_21', vali = [i_courbe+1, nb_char_lim_pun])
# on laisse la boucle meme s'il ne peut y avoir qu'un seul groupe
for el in entite:
# COURBE
nb_courbe += 1
mot_cle = 'COURBE'
cara = [cham_epx, 'COMP', ]
vale = ['', cmp_epx, ]
if entite_type == 'GROUP_MA':
cara.append('GAUSS')
num_gauss = courbe['NUM_GAUSS']
if type(num_gauss) is tuple:
num_gauss = num_gauss[0]
vale.append(num_gauss)
cara.append(dic_entite[entite_type])
vale.append('')
val_cle = "'%s'"%label
bloc_courbe = BLOC_DONNEES(mot_cle, l_group=el,
cle=nb_courbe,
val_cle=val_cle, cara=cara,
vale=vale)
objet.add_bloc(bloc_courbe)
# LIST
mot_cle = 'LIST'
cara = 'AXES 1.'
vale = "'%s'"%label
bloc_liste = BLOC_DONNEES(mot_cle, val_cle=nb_courbe,
cara=cara, vale=vale)
objet.add_bloc(bloc_liste)
self.legend_courbes[nb_courbe] = ['TEMPS', label]
def export_ECRITURE(self):
"""
Gestion de l'écriture des résultats dans les différents formats
et fichiers.
"""
from Calc_epx.calc_epx_struc import BLOC_DONNEES
from Calc_epx.calc_epx_cata import cata_champs
from Calc_epx.calc_epx_utils import ctime
epx = self.epx
directive = 'ECRITURE'
# blocs d'écriture de tous les noeuds et toutes les mailles
[bloc_poin, bloc_elem] = self.write_all_gr()
# Traitement du mot-cle facteur OBSERVATION (EPX = LISTING)
# Ecriture LISTING
if self.OBSERVATION is not None:
listing_fact = self.OBSERVATION.List_F()[0]
nom_cham = tolist(listing_fact['NOM_CHAM'])
# champs
for cham_aster in nom_cham:
cham_epx = cata_champs[cham_aster]
bloc_champ = BLOC_DONNEES(cham_epx)
epx[directive].add_bloc(bloc_champ)
# instants
blocs_inst = ctime(listing_fact)
for bloc in blocs_inst:
epx[directive].add_bloc(bloc)
# noeuds
if listing_fact.has_key('TOUT_GROUP_NO'):
# tous les noeuds du modèle
if bloc_poin is not None:
epx[directive].add_bloc(bloc_poin)
else:
bloc = BLOC_DONNEES('NOPO')
epx[directive].add_bloc(bloc)
elif listing_fact.has_key('GROUP_NO'):
gr_no = tolist(listing_fact['GROUP_NO'])
bloc = BLOC_DONNEES('POIN', l_group=gr_no,)
epx[directive].add_bloc(bloc)
else:
bloc = BLOC_DONNEES('NOPO')
epx[directive].add_bloc(bloc)
# mailles
if listing_fact.has_key('TOUT_GROUP_MA'):
# toutes les mailles du modèle
if bloc_elem is not None:
epx[directive].add_bloc(bloc_elem)
else:
bloc = BLOC_DONNEES('NOEL')
epx[directive].add_bloc(bloc)
elif listing_fact.has_key('GROUP_MA'):
gr_ma = tolist(listing_fact['GROUP_MA'])
bloc = BLOC_DONNEES('ELEM', l_group=gr_ma,)
epx[directive].add_bloc(bloc)
else:
bloc = BLOC_DONNEES('NOEL')
epx[directive].add_bloc(bloc)
# Ecriture FICHIER ALICE utilisé par le mot-cle facteur COURBE
courbe_fact = self.COURBE
if courbe_fact is not None:
concept_bid = {}
if self.PAS_NBRE_COURBE:
concept_bid['PAS_NBRE'] = self.PAS_NBRE_COURBE
if self.PAS_INST_COURBE:
concept_bid['PAS_INST'] = self.PAS_INST_COURBE
if self.INST_COURBE:
concept_bid['INST'] = self.INST_COURBE
if self.NUME_ORDRE_COURBE:
concept_bid['NUME_ORDRE'] = self.NUME_ORDRE_COURBE
mot_cle = "FICHIER ALIT 11"
objet = epx[directive].add_mcfact(mot_cle)
# instants
blocs_inst = ctime(concept_bid)
for bloc in blocs_inst:
objet.add_bloc(bloc)
# Liste les noeuds a postraiter
lnoeuds = set()
lmailles = set()
for courbe in courbe_fact:
if courbe['GROUP_NO'] != None:
grno = courbe['GROUP_NO']
if type(grno) == tuple:
for el in grno:
lnoeuds.add(el)
else:
lnoeuds.add(grno)
elif courbe['GROUP_MA'] != None:
grma = courbe['GROUP_MA']
if type(grma) == tuple:
for el in grma:
lmailles.add(el)
else:
lmailles.add(grma)
else:
raise Exception('Erreur : ni noeud ni maille')
if lnoeuds:
bloc = BLOC_DONNEES('POIN', l_group=lnoeuds,)
objet.add_bloc(bloc)
if lmailles:
bloc = BLOC_DONNEES('ELEM', l_group=lmailles,)
objet.add_bloc(bloc)
# FICHIER MED
champ_fact = self.ARCHIVAGE
if champ_fact is not None:
mot_cle = "FICHIER MED"
objet = epx[directive].add_mcfact(mot_cle)
fichier_med = "'%s'"%(self.nom_fichiers['MED'])
bloc_fic = BLOC_DONNEES(fichier_med)
objet.add_bloc(bloc_fic)
# instants
blocs_inst = ctime(champ_fact)
for bloc in blocs_inst:
objet.add_bloc(bloc)
# tous les groupes de mailles du modèle
if bloc_poin is not None:
objet.add_bloc(bloc_poin)
if bloc_elem is not None:
objet.add_bloc(bloc_elem)
# FICHIER SAUV
mot_cle = 'FICHIER SAUV'
nom_fic = "'%s'"%(self.nom_fichiers['SAUV'])
data = [nom_fic, 'LAST']
bloc = BLOC_DONNEES(mot_cle, cara=data)
epx[directive].add_bloc(bloc)
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)
