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