def export_DEBUT(self):
"""
Ecrit les mot-clés d'initialisation du calcul dans la fausse
directive DEBUT.
Active la directive FIN
"""
from Calc_epx.calc_epx_struc import BLOC_DONNEES
epx = self.epx
directive = 'DEBUT'
vale = ''
for mcle in ['TITRE', 'ECHO', 'TRID']:
bloc = BLOC_DONNEES(mcle)
epx[directive].add_bloc(bloc)
# lecture fichier MED
bloc = BLOC_DONNEES('MEDL', cle='28')
epx[directive].add_bloc(bloc)
# écriture des résultats EPX en MED
champ_fact = self.ARCHIVAGE
if champ_fact is not None:
bloc = BLOC_DONNEES('MEDE')
epx[directive].add_bloc(bloc)
# on traite la directive fin maintenant car elle est toujours présente
# à la fin
directive = 'FIN'
epx[directive].add_void()
def write_all_gr(self,):
"""
Renvoie deux blocs de données indiquand que la commande
s'applique à tous les noeuds et mailles du modèle.
"""
from Calc_epx.calc_epx_struc import BLOC_DONNEES
entite_geo = {}
entite_geo['ELEM'] = []
for model in self.dic_epx_geom.keys():
if self.dic_epx_geom[model]['RESU_ELEM']:
entite_geo['ELEM'].extend(self.dic_epx_geom[model]
['GROUP_MA'])
entite_geo['POIN'] = []
for model in self.dic_epx_geom.keys():
if self.dic_epx_geom[model]['RESU_POIN']:
entite_geo['POIN'].extend(self.dic_epx_geom[model]
['GROUP_MA'])
li_blocs = []
for cle in ['POIN', 'ELEM']:
if entite_geo[cle] != []:
bloc = BLOC_DONNEES(cle, l_group=entite_geo[cle],)
else:
bloc = None
li_blocs.append(bloc)
return li_blocs
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 ctime(fact):
"""
Renvoie un bloc de données indiquant les instants à imprimer selon
les différentes possibilités d'EPX (correspond à /CTIME/ de EPX)
"""
from Calc_epx.calc_epx_struc import BLOC_DONNEES
cata_inst = {
'PAS_NBRE': 'FREQ',
'PAS_INST': 'TFREQ',
'INST': 'TIME',
'NUME_ORDRE': 'NUPA',
}
blocs_ctime = []
for cle in cata_inst.keys():
val = get_motcle(fact, cle, code_mess=None)
if val is not None:
cle_epx = cata_inst[cle]
if cle_epx == 'TIME':
bloc_ctime = BLOC_DONNEES(cle_epx,
l_group=val,
cle_l_group='PROG',
dispo_group='hori')
elif cle_epx == 'NUPA':
bloc_ctime = BLOC_DONNEES(cle_epx,
l_group=val,
dispo_group='hori')
else:
bloc_ctime = BLOC_DONNEES(cle_epx, cle=val)
blocs_ctime.append(bloc_ctime)
return blocs_ctime
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 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 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_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)