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 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_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)