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)