def recu_coor_z(noma, group, typ_group, tole_r): import aster from Utilitai.Utmess import UTMESS collcnx = aster.getcolljev(noma.nom.ljust(8) + '.CONNEX') coord = aster.getvectjev(noma.nom.ljust(8) + '.COORDO .VALE') cnom = aster.getvectjev(noma.nom.ljust(8) + '.NOMNOE') coor_z = [] if typ_group == 'group_ma': nomgrma = group collgrma = aster.getcolljev(noma.nom.ljust(8) + '.GROUPEMA') if nomgrma.ljust(24) not in collgrma: UTMESS("F", "MISS0_26", valk=group) else: numa = collgrma[nomgrma.ljust(24)] for ima in numa: n = collcnx[ima][0] uzmin = round(coord[3 * (n - 1) + 2], tole_r) uzmax = round(coord[3 * (n - 1) + 2], tole_r) for i in range(len(collcnx[ima])): n = collcnx[ima][i] uzmin = min(uzmin, round(coord[3 * (n - 1) + 2], tole_r)) uzmax = max(uzmax, round(coord[3 * (n - 1) + 2], tole_r)) if uzmin not in coor_z: coor_z.append(uzmin) if uzmax not in coor_z: coor_z.append(uzmax) elif typ_group == 'group_no': collgrno = aster.getcolljev(noma.nom.ljust(8) + '.GROUPENO') nomgrno = group if nomgrno.ljust(24) not in collgrno: UTMESS("F", "MISS0_26", valk=group) else: grpn = collgrno[nomgrno.ljust(24)] l_coor_group = [] i = 0 for node in grpn: l_coor_group.append( aster.getvectjev( noma.nom.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3)) uz = round(l_coor_group[i][2], tole_r) i += 1 if uz not in coor_z: coor_z.append(uz) else: assert 0, 'recu_coor_z : erreur argument typ_group' prov = sorted(coor_z) coor_z = prov[::-1] return coor_z
def LIST_LIAIS_STRUCT(self): """ retourne la liste des liaisons entre sous structures du modele generalise sous la forme : [ (ss1, nom_liais1, ss2 , nom_liais2), ...] """ nommodgen = self.getName() ncham = nommodgen + (8 - len(nommodgen)) * ' ' lidf = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.LIDF') return [([(lidf[ind][indb]) for indb in range(4)]) for ind in lidf]
def LIST_SOUS_STRUCT(self): """ retourne la liste des sous structures du modele generalise la liste des macro-elements sous-jacents""" nommodgen = self.getName() ncham = nommodgen + (8 - len(nommodgen)) * ' ' ssno = aster.getvectjev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSNO') ssme = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSME') return [([ssno[ind], ssme[ind + 1]]) for ind in range(len(ssno))]
def LIST_LIAIS_STRUCT(self): """ retourne la liste des liaisons entre sous structures du modele generalise sous la forme : [ (ss1, nom_liais1, ss2 , nom_liais2), ...] """ if not self.accessible(): raise AsException( "Erreur dans modele_gene.LIST_LIAIS_STRUCT en PAR_LOT='OUI'") nommodgen = self.get_name() ncham = nommodgen + (8 - len(nommodgen)) * ' ' lidf = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.LIDF') return [([(lidf[ind][indb]) for indb in range(4)]) for ind in lidf]
def get(self): nomj = self.nomj() if aster.jeveux_exists(nomj): obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S' if obj_simple: return aster.getvectjev(nomj) else: return aster.getcolljev(nomj) else: return None
def LIST_SOUS_STRUCT(self): """ retourne la liste des sous structures du modele generalise la liste des macro-elements sous-jacents""" if not self.accessible(): raise AsException( "Erreur dans modele_gene.LIST_SOUS_STRUCT en PAR_LOT='OUI'") nommodgen = self.get_name() ncham = nommodgen + (8 - len(nommodgen)) * ' ' ssno = aster.getvectjev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSNO') ssme = aster.getcolljev(ncham + (14 - len(ncham)) * ' ' + '.MODG.SSME') return [([ssno[ind], ssme[ind + 1]]) for ind in range(len(ssno))]
def Valeurs(surface): # TODO : dirty workarround for this macro, until Surface.getValues() # implementaiton in c++ nsd = '%-19s' % surface.getName() dicv = aster.getcolljev(nsd + '.VALE') lpar = aster.getvectjev(nsd + '.PARA') lval = [] for k in range(len(dicv)): lbl = dicv[k + 1] dim = len(lbl) // 2 lval.append([lbl[0:dim], lbl[dim:2 * dim]]) return [list(lpar), lval]
def LIST_GROUP_MA(self) : """ retourne la liste des groupes de mailles sous la forme : [ (gma1, nb mailles gma1, dime max des mailles gma1), ...] """ if not self.accessible(): raise AsException("Erreur dans maillage.LIST_GROUP_MA en PAR_LOT='OUI'") ltyma = aster.getvectjev("&CATA.TM.NOMTM") catama = aster.getcolljev("&CATA.TM.TMDIM") dic_gpma = self.sdj.GROUPEMA.get() if dic_gpma is None: return [] dimama = [catama[ltyma[ma-1].ljust(24)][0] for ma in self.sdj.TYPMAIL.get()] ngpma = [] for grp in dic_gpma.keys(): dim = max([dimama[ma-1] for ma in dic_gpma[grp]]) ngpma.append((grp.strip(), len(dic_gpma[grp]),dim)) return ngpma
def LIST_GROUP_MA(self): """ retourne la liste des groupes de mailles sous la forme : [ (gma1, nb mailles gma1, dime max des mailles gma1), ...] """ ltyma = aster.getvectjev("&CATA.TM.NOMTM") catama = aster.getcolljev("&CATA.TM.TMDIM") dic_gpma = self.sdj.GROUPEMA.get() if dic_gpma is None: return [] dimama = [ catama[ltyma[ma - 1].ljust(24)][0] for ma in self.sdj.TYPMAIL.get() ] ngpma = [] for grp in list(dic_gpma.keys()): dim = max([dimama[ma - 1] for ma in dic_gpma[grp]]) ngpma.append((grp.strip(), len(dic_gpma[grp]), dim)) return ngpma
def Valeurs(self): """ Retourne la liste des valeurs du parametre, et une liste de couples (abscisses,ordonnees) de chaque fonction. """ from Utilitai.Utmess import UTMESS if not self.accessible(): raise AsException( "Erreur dans nappe.Valeurs en PAR_LOT='OUI'") nsd = '%-19s' % self.get_name() dicv = aster.getcolljev(nsd + '.VALE') # les cles de dicv sont 1,...,N (indice du parametre) lpar = aster.getvectjev(nsd + '.PARA') if lpar == None: UTMESS('F', 'SDVERI_2', valk=[nsd + '.PARA']) lval = [] for k in range(len(dicv)): lbl = dicv[k + 1] dim = len(lbl) / 2 lval.append([lbl[0:dim], lbl[dim:2 * dim]]) return [list(lpar), lval]
def char_grad_impo_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, CHARGRD0, Vh, R, T, **args): # macro pour calculer le chargement thermique specfique a la diffusion H2 INFO = args.get('INFO') # On importe les definitions des commandes a utiliser dans la macro # Recuperation du modele a partir du resultat moth = RESU_H2.getModel() # Recuperation du maillage a partir du resultat mesh = moth.getMesh() # Recuperation du modele mecanique a partir du resultat mome = RESUMECA.getModel() # extraction du champ de cl instant - __C20 = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_TEMP_R', RESULTAT=RESU_H2, NOM_CHAM='TEMP', INST=TINIT, INFO=INFO) # on suppose que les noeuds du maillage thermique et mecaniqeu sont les # memes (pour eviter un PROJ_CHAMP) lc_t0 = __C20.EXTR_COMP('TEMP', [], 1) c_t0 = lc_t0.valeurs node_th = lc_t0.noeud nbnode = len(node_th) # contruction du terme Grad SigmaH # trace de sigma aux noeuds __SIEQN2 = CALC_CHAMP( INST=TFIN, RESULTAT=RESUMECA, CRITERES='SIEQ_NOEU', INFO=INFO) __SIEQN = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT=__SIEQN2, MODELE_1=mome, MODELE_2=moth, NOM_CHAM='SIEQ_NOEU', TOUT_ORDRE='OUI') __SIEQ = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_SIEF_R', RESULTAT=__SIEQN, NOM_CHAM='SIEQ_NOEU', INST=TFIN, INFO=INFO) # on renome la CMP pour pouvoir calculer le flux "thermique" __TRSIG = CREA_CHAMP( OPERATION='ASSE', TYPE_CHAM='NOEU_TEMP_R', MODELE=moth, ASSE=(_F(CHAM_GD=__SIEQ, GROUP_MA=GRMAVOL, NOM_CMP='TRSIG', NOM_CMP_RESU='TEMP', COEF_R=1. / 3.),), INFO=INFO) # calcul du gradient de Trace(Sigma) __MAT1 = DEFI_MATERIAU(THER=_F(LAMBDA=-1., RHO_CP=0.)) __CMT1 = AFFE_MATERIAU( MAILLAGE=mesh, AFFE=_F(TOUT='OUI', MATER=__MAT1,),) __GRSH = CALC_CHAM_ELEM( MODELE=moth, CHAM_MATER=__CMT1, GROUP_MA=GRMAVOL, OPTION='FLUX_ELGA', TEMP=__TRSIG) gradsighe = __GRSH.EXTR_COMP('FLUX', [], 1) gradsighx = gradsighe.valeurs gradsighy = __GRSH.EXTR_COMP('FLUY', [], 0).valeurs if (DIME == 3): gradsighz = __GRSH.EXTR_COMP('FLUZ', [], 0).valeurs fx = NP.zeros(nbnode) fy = NP.zeros(nbnode) if (DIME == 3): fz = NP.zeros(nbnode) for ino, node in enumerate(node_th): cl = c_t0[ino] grsigx = gradsighx[ino] grsigy = gradsighy[ino] if (DIME == 3): grsigz = gradsighz[ino] fx[ino], fx[ino], fz[ino] = FLUX( cl, grsigx, grsigy, DIME, grsigz, Vh, R, T) else: grsigz = 0. fx[ino], fx[ino] = FLUX(cl, grsigx, grsigy, DIME, grsigz, Vh, R, T) # pour gagner du temps on evite la construction du mot-cle PRE_GRAD_TEMP nomvale = CHARGRD0.getName().ljust(8) + '.CHTH.GRAIN.VALE' nomlima = CHARGRD0.getName().ljust(8) + '.CHTH.GRAIN.LIMA' nomdesc = CHARGRD0.getName().ljust(8) + '.CHTH.GRAIN.DESC' tabvale = aster.getvectjev(nomvale) tabdesc = aster.getvectjev(nomdesc) dicolima = aster.getcolljev(nomlima) nbrvale = len(tabvale) champ = NP.zeros(nbrvale) bidon = NP.zeros(nbrvale) connex = mesh.sdj.CONNEX.get() groupma = mesh.sdj.GROUPEMA.get()[GRMAVOL.ljust(24)] # print "tabdesc",tabdesc # print "tablima",dicolima for izone in list(dicolima.keys()): # chaque maille du groupe est affectee for index, ima in enumerate(dicolima[izone]): if ima == 0: break if ima in groupma: # ATTENTION : dans Python, les tableaux commencent a 0 # mais dans la connectivite, les noeuds commencent a 1! lnoeu = NP.array(connex[ima]) - 1 nbno = len(lnoeu) # calcul de la moyenne par maille de fx lflux = fx[lnoeu] flux = NP.add.reduce(lflux) flux = flux / nbno lfluy = fy[lnoeu] fluy = NP.add.reduce(lfluy) fluy = fluy / nbno numa = index # print 'essai, numa, ima',numa, ima, groupma, lnoeu, nbno champ[9 * (numa - 1) + 1] = -flux champ[9 * (numa - 1) + 2] = -fluy aster.putvectjev(nomvale, nbrvale, tuple( range(1, nbrvale + 1)), tuple(champ), tuple(bidon), 1)
def extr_matr(matr): nommatr = str(matr.nom).strip() lenm = len(nommatr) nommatr = nommatr+' '*(8-lenm) nrefa = nommatr+' .REFA' vrefa = aster.getvectjev(nrefa) numeddl = str(vrefa[1]).strip() lenn = len(numeddl) numeddl = numeddl+' '*(14-lenn) typm = str(vrefa[8]).strip() # on recupere les valeurs de la matrice nvalm = nommatr+' .VALM' vvalm = aster.getcolljev(nvalm) # print(vvalm[1]) nsmdi = numeddl+'.SMOS.SMDI' nsmhc = numeddl+'.SMOS.SMHC' vsmdi = aster.getvectjev(nsmdi) vsmhc = aster.getvectjev(nsmhc) valm1 = vvalm[1] if(typm == 'MS'): # Si la matrice est symétrique valm2 = vvalm[1] else: # Si la matrice est non-symétrique valm2 = vvalm[2] # Taille de la matrice avec cdl neq = len(vsmdi) # print(neq) # Nombre de termes non-nuls nterm = len(vsmhc) # print(nterm) # Creation de la matrice AVEC cdl matriceg = zeros([neq, neq]) j = 0 for k in range(nterm): matriceg[vsmhc[k]-1][j] = valm1[k] matriceg[j][vsmhc[k]-1] = valm2[k] if((vsmdi[j]-1) == k): j = j+1 # print(matriceg) # Création du vecteur ind : 1 si ddl phys 0 sinon # Cas CDL = AFFE_CHAR_CINE nccid = nommatr+' .CCID' vccid = aster.getvectjev(nccid) # print(vccid) # Cas CDL = AFFE_CHAR_MECA ndeeq = numeddl+'.NUME.DEEQ' vdeeq = aster.getvectjev(ndeeq) # print('vdeeq') # print(vdeeq) ind = zeros(neq) # Cas CDL = AFFE_CHAR_CINE if(vccid is not None): ind = ones(neq)-vccid[0:neq] # print(ind) nd = neq-vccid[neq] # print(nd) # Cas CDL = AFFE_CHAR_MECA elif(vdeeq is not None): for k in range(neq): if(vdeeq[-1+2*k+2] > 0): ind[k] = 1 elif(vdeeq[-1+2*k+2] < 0): ind[k] = 0 j = 0 tcmp = -vdeeq[-1+2*k+2] while((vdeeq[-1+2*j+1] != vdeeq[-1+2*k+1]) or (vdeeq[-1+2*j+2] != tcmp)): j = j+1 ind[j] = 0 # print(ind) nd = 0 for k in range(neq): if(ind[k] == 1): nd = nd+1 # Creation de la matrice SANS cdl matrice = zeros([nd, nd]) ii = 0 for i in range(neq): jj = 0 if(ind[i] == 1): for j in range(neq): if(ind[j] == 1): # print(i,ind[i],ii) # print(j,ind[j],jj) matrice[ii][jj] = matriceg[i][j] jj = jj+1 ii = ii+1 # print(matrice) # Creation du vecteur [N1DX ... N?D?] de taille nd vectddl = ['']*nd comp = ['DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ',] i = 0 for k in range(neq): if(ind[k] == 1): vectddl[i] = 'N'+str(vdeeq[2*k]).strip()+comp[vdeeq[2*k+1]-1].strip() i = i+1 if(vccid is not None): inds = ind else: inds = zeros(len(ind)) i = 0 for k in range(neq): if(vdeeq[2*k+1] > 0): inds[i] = ind[i] i = i+1 inds = inds[0:i] return [vectddl, inds, matrice]
def macr_cara_poutre_ops(self, MAILLAGE, SYME_Y, SYME_Z, GROUP_MA_BORD, GROUP_MA, ORIG_INER, TABLE_CARA, **args): """ Ecriture de la macro MACR_CARA_POUTRE """ import types import string from code_aster.Cata.Syntax import _F import aster from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme # ier = 0 # On importe les definitions des commandes a utiliser dans la macro # Le nom de la variable doit etre obligatoirement le nom de la commande LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE') DEFI_GROUP = self.get_cmd('DEFI_GROUP') CREA_MAILLAGE = self.get_cmd('CREA_MAILLAGE') COPIER = self.get_cmd('COPIER') AFFE_MODELE = self.get_cmd('AFFE_MODELE') DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU') AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU') DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') DEFI_CONSTANTE = self.get_cmd('DEFI_CONSTANTE') AFFE_CHAR_THER = self.get_cmd('AFFE_CHAR_THER') AFFE_CHAR_THER_F = self.get_cmd('AFFE_CHAR_THER_F') THER_LINEAIRE = self.get_cmd('THER_LINEAIRE') CALC_VECT_ELEM = self.get_cmd('CALC_VECT_ELEM') CALC_MATR_ELEM = self.get_cmd('CALC_MATR_ELEM') NUME_DDL = self.get_cmd('NUME_DDL') ASSE_VECTEUR = self.get_cmd('ASSE_VECTEUR') POST_ELEM = self.get_cmd('POST_ELEM') CALC_CHAMP = self.get_cmd('CALC_CHAMP') MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE') IMPR_TABLE = self.get_cmd('IMPR_TABLE') CREA_TABLE = self.get_cmd('CREA_TABLE') CALC_TABLE = self.get_cmd('CALC_TABLE') DETRUIRE = self.get_cmd('DETRUIRE') # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # Le concept sortant (de type table_sdaster) est nommé 'nomres' dans le # contexte de la macro self.DeclareOut('nomres', self.sd) # ImprTable = False # if (MAILLAGE != None): __nomlma = COPIER(CONCEPT=MAILLAGE) elif (args.has_key('UNITE') and args.has_key('FORMAT')): __nomlma = LIRE_MAILLAGE(UNITE=args['UNITE'], FORMAT=args['FORMAT']) else: assert False, "Erreur dans les options UNITE, FORMAT, MAILLAGE" # # Dans les tables on retrouve une ligne avec __nomlma.nom. Soit : # - on remplace __nomlma.nom par NomMaillageNew. # - on supprime la ligne NomMaillage = (None, __nomlma.get_name()) if (args.has_key('NOM')): NomMaillage = (args['NOM'], __nomlma.get_name()) # # __nomamo = AFFE_MODELE( MAILLAGE=__nomlma, AFFE=_F( TOUT='OUI', PHENOMENE='MECANIQUE', MODELISATION='D_PLAN', ), ) __nomdma = DEFI_MATERIAU(ELAS=_F(E=1.0, NU=0., RHO=1.0), ) __nomama = AFFE_MATERIAU( MAILLAGE=__nomlma, AFFE=_F( TOUT='OUI', MATER=__nomdma, ), ) # # L'utilisateur ne peut rien faire pour éviter ces "Alarmes" donc pas d'impression MasquerAlarme('CHARGES2_87') MasquerAlarme('CALCULEL_40') # -------------------------------------------------------------- # --- CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION # -------------------------------------------------------------- motsimps = {} if GROUP_MA: motsimps['GROUP_MA'] = GROUP_MA if SYME_Y: motsimps['SYME_X'] = SYME_Y if SYME_Z: motsimps['SYME_Y'] = SYME_Z motsimps['ORIG_INER'] = ORIG_INER mfact = _F(TOUT='OUI', **motsimps) __cageo = POST_ELEM(MODELE=__nomamo, CHAM_MATER=__nomama, CARA_GEOM=mfact) # nb : si GROUP_MA n'existe pas, le mot clé est ignoré # # ===================================================================== # CALCUL DE LA CONSTANTE DE TORSION SUR TOUT LE MAILLAGE # OU DU CENTRE DE TORSION/CISAILLEMENT # DES COEFFICIENTS DE CISAILLEMENT # ET DE L INERTIE DE GAUCHISSEMENT # DU RAYON DE TORSION SUR TOUT LE MAILLAGE # ON CREE UN MODELE PLAN 2D THERMIQUE REPRESENTANT LA SECTION # DE LA POUTRE CAR ON A A RESOUDRE DES E.D.P. AVEC DES LAPLACIENS # ===================================================================== if GROUP_MA_BORD and not GROUP_MA: #------------------------------------------------------------ # TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS # ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE : motscles = {} if type(GROUP_MA_BORD) == types.StringType: motscles['CREA_GROUP_NO'] = _F(GROUP_MA=GROUP_MA_BORD, ) else: motscles['CREA_GROUP_NO'] = [] for grma in GROUP_MA_BORD: motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=grma, )) # __nomlma = DEFI_GROUP(reuse=__nomlma, MAILLAGE=__nomlma, **motscles) #------------------------------------------------------------ # CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES # QUE LES COORDONNEES SONT EXPRIMEES DANS LE REPERE PRINCIPAL # D INERTIE DONT L ORIGINE EST LE CENTRE DE GRAVITE DE LA SECTION : __nomapi = CREA_MAILLAGE( MAILLAGE=__nomlma, REPERE=_F( TABLE=__cageo, NOM_ORIG='CDG', ), ) #------------------------------------------------------------ # AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE # LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : __nomoth = AFFE_MODELE( MAILLAGE=__nomapi, AFFE=_F( TOUT='OUI', PHENOMENE='THERMIQUE', MODELISATION='PLAN', ), ) #------------------------------------------------------------ # POUR LA CONSTRUCTION DU LAPLACIEN, ON DEFINIT UN # PSEUDO-MATERIAU DONT LES CARACTERISTIQUES THERMIQUES SONT : # LAMBDA = 1, RHO*CP = 0 : __nomath = DEFI_MATERIAU(THER=_F( LAMBDA=1.0, RHO_CP=0., ), ) # --- DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : __chmath = AFFE_MATERIAU( MAILLAGE=__nomapi, AFFE=_F( TOUT='OUI', MATER=__nomath, ), ) #------------------------------------------------------------ # CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION # D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2 # L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION : # LAPLACIEN(PHI) = -2 DANS LA SECTION # PHI = 0 SUR LE CONTOUR : #------------------------------------------------------------ # # ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR DE LA SECTION # ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION #------------------------------------------------------------ motscles = {} if args.has_key('GROUP_MA_INTE'): if args['GROUP_MA_INTE'] != None: motscles['LIAISON_UNIF'] = _F(GROUP_MA=args['GROUP_MA_INTE'], DDL='TEMP'), __chart1 = AFFE_CHAR_THER(MODELE=__nomoth, TEMP_IMPO=_F(GROUP_NO=GROUP_MA_BORD, TEMP=0.), SOURCE=_F(TOUT='OUI', SOUR=2.0), **motscles) # POUR CHAQUE TROU DE LA SECTION : # ON A IMPOSE QUE PHI EST CONSTANT SUR LE CONTOUR INTERIEUR # EN FAISANT LE LIAISON_UNIF DANS LE AFFE_CHAR_THER PRECEDENT # ON IMPOSE EN PLUS D(PHI)/DN = 2*AIRE(TROU)/L(TROU) # OU D/DN DESIGNE LA DERIVEE PAR RAPPORT A LA # NORMALE ET L DESIGNE LA LONGUEUR DU BORD DU TROU : if args.has_key('GROUP_MA_INTE'): lgmaint = args['GROUP_MA_INTE'] if lgmaint != None: __tbaire = POST_ELEM( MODELE=__nomoth, AIRE_INTERNE=_F(GROUP_MA_BORD=args['GROUP_MA_INTE'], ), ) motscles = {} motscles['FLUX_REP'] = [] if type(lgmaint) == types.StringType: motscles['FLUX_REP'] = _F(GROUP_MA=args['GROUP_MA_INTE'], CARA_TORSION=__tbaire) else: motscles['FLUX_REP'] = [] for grma in lgmaint: motscles['FLUX_REP'].append( _F(GROUP_MA=grma, CARA_TORSION=__tbaire), ) __chart2 = AFFE_CHAR_THER(MODELE=__nomoth, **motscles) #------------------------------------------------------------ # RESOLUTION DE LAPLACIEN(PHI) = -2 # AVEC PHI = 0 SUR LE CONTOUR : motscles = {} motscles['EXCIT'] = [ _F(CHARGE=__chart1, ), ] if args.has_key('GROUP_MA_INTE'): if lgmaint != None: motscles['EXCIT'].append(_F(CHARGE=__chart2, )) __tempe1 = THER_LINEAIRE(MODELE=__nomoth, CHAM_MATER=__chmath, SOLVEUR=_F(STOP_SINGULIER='NON', ), **motscles) #------------------------------------------------------------ # CALCUL DU CENTRE DE TORSION/CISAILLEMENT - # ET DES COEFFICIENTS DE CISAILLEMENT : - # # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Y : __fnsec1 = DEFI_FONCTION( NOM_PARA='X', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) __fnsec0 = DEFI_CONSTANTE(VALE=0., ) #------------------------------------------------------------ # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION # DE LAPLACE EST PRIS EGAL A Y DANS TOUTE LA SECTION : mctimpo = {} if args['NOEUD'] != None: nthno = args['NOEUD'] if len(nthno) != 1: UTMESS('F', 'POUTRE0_3') mctimpo['TEMP_IMPO'] = (_F(NOEUD=nthno[0], TEMP=__fnsec0)) elif args['GROUP_NO'] != None: grthno = args['GROUP_NO'] if len(grthno) != 1: UTMESS('F', 'POUTRE0_3') grthno = grthno[0] collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomapi.nom) nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomapi.nom) l_no = collgrno[string.ljust(grthno, 24)] if len(l_no) != 1: UTMESS('F', 'POUTRE0_3') nthno = nomnoe[l_no[0] - 1] mctimpo['TEMP_IMPO'] = (_F(NOEUD=nthno, TEMP=__fnsec0)) # __chart2 = AFFE_CHAR_THER_F(MODELE=__nomoth, SOURCE=_F( TOUT='OUI', SOUR=__fnsec1, ), **mctimpo) #------------------------------------------------------------ # RESOLUTION DE LAPLACIEN(PHI) = -Y # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe2 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart2, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) #------------------------------------------------------------ # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Z : __fnsec2 = DEFI_FONCTION( NOM_PARA='Y', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) #------------------------------------------------------------ # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION # DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION : __chart3 = AFFE_CHAR_THER_F(MODELE=__nomoth, SOURCE=_F( TOUT='OUI', SOUR=__fnsec2, ), **mctimpo) #------------------------------------------------------------ # RESOLUTION DE LAPLACIEN(PHI) = -Z # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe3 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart3, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) #------------------------------------------------------------ # CALCUL DU RAYON DE TORSION : # CALCUL DU RAYON DE TORSION EXTERNE : rtext __tempe1 = CALC_CHAMP( reuse=__tempe1, RESULTAT=__tempe1, TOUT_ORDRE='OUI', THERMIQUE='FLUX_ELNO', ) __flun = MACR_LIGN_COUPE(RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=GROUP_MA_BORD, )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F(NOM=GROUP_MA_BORD, )) __m1 = abs(__flun['TRAC_NOR', 3]) __m2 = abs(__flun['TRAC_NOR', 4]) __rtext = max(__m1, __m2) # CALCUL DU RAYON DE TORSION : rt # rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) if args.has_key('GROUP_MA_INTE'): if args['GROUP_MA_INTE'] != None: if type(args['GROUP_MA_INTE']) == types.StringType: l_group_ma_inte = [ args['GROUP_MA_INTE'], ] else: l_group_ma_inte = args['GROUP_MA_INTE'] for i in range(0, len(l_group_ma_inte)): __flun = MACR_LIGN_COUPE(RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=l_group_ma_inte[i], )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F( NOM=l_group_ma_inte[i], )) __m1 = (abs(__flun['TRAC_NOR', 3]) + abs(__flun['TRAC_NOR', 4])) / 2. if __m1 > __rtext: __rtext = __m1 # __rt = __rtext #------------------------------------------------------------ # CALCUL DE LA CONSTANTE DE TORSION : motscles = {} if args.has_key('GROUP_MA_INTE'): lgmaint = args['GROUP_MA_INTE'] if lgmaint != None: motscles['CARA_POUTRE'] = _F( CARA_GEOM=__cageo, LAPL_PHI=__tempe1, RT=__rt, TOUT='OUI', OPTION='CARA_TORSION', GROUP_MA_INTE=args['GROUP_MA_INTE'], ) else: motscles['CARA_POUTRE'] = _F( CARA_GEOM=__cageo, LAPL_PHI=__tempe1, RT=__rt, TOUT='OUI', OPTION='CARA_TORSION', ) # __cator = POST_ELEM(MODELE=__nomoth, CHAM_MATER=__chmath, **motscles) #------------------------------------------------------------ # CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU # CENTRE DE CISAILLEMENT/TORSION : __cacis = POST_ELEM( MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F( CARA_GEOM=__cator, LAPL_PHI_Y=__tempe2, LAPL_PHI_Z=__tempe3, TOUT='OUI', OPTION='CARA_CISAILLEMENT', ), ) #------------------------------------------------------------ # CALCUL DE L INERTIE DE GAUCHISSEMENT PAR RESOLUTION DE - # LAPLACIEN(OMEGA) = 0 DANS LA SECTION - # AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ SUR LE - # CONTOUR DE LA SECTION - # NY ET NZ SONT LES COMPOSANTES DU VECTEUR N NORMAL - # A CE CONTOUR - # ET SOMME_S(OMEGA.DS) = 0 - # OMEGA EST LA FONCTION DE GAUCHISSEMENT - # L INERTIE DE GAUCHISSEMENT EST SOMME_S(OMEGA**2.DS) - # ----------------------------------------------------------- # # CREATION D UN MAILLAGE DONT LES COORDONNEES SONT EXPRIMEES # DANS LE REPERE PRINCIPAL D INERTIE MAIS AVEC COMME ORIGINE # LE CENTRE DE TORSION DE LA SECTION, ON VA DONC UTILISER # LE MAILLAGE DE NOM NOMAPI DONT LES COORDONNEES SONT # EXPRIMEES DANS LE REPERE PRINCIPAL D'INERTIE, L'ORIGINE # ETANT LE CENTRE DE GRAVITE DE LA SECTION (QUI EST DONC A CHANGER) __nomapt = CREA_MAILLAGE(MAILLAGE=__nomapi, REPERE=_F( TABLE=__cacis, NOM_ORIG='TORSION', )) #------------------------------------------------------------ # AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE # LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : __nomot2 = AFFE_MODELE(MAILLAGE=__nomapt, AFFE=_F( TOUT='OUI', PHENOMENE='THERMIQUE', MODELISATION='PLAN', )) # DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : __chmat2 = AFFE_MATERIAU( MAILLAGE=__nomapt, AFFE=_F( TOUT='OUI', MATER=__nomath, ), ) # POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR # LA COMPOSANTE SELON Y DU FLUX A IMPOSER SUR LE CONTOUR # PAR UNE FONCTION EGALE A -X : __fnsec3 = DEFI_FONCTION( NOM_PARA='X', VALE=(0., 0., 10., -10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) # POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR # LA COMPOSANTE SELON X DU FLUX A IMPOSER SUR LE CONTOUR # PAR UNE FONCTION EGALE A Y : __fnsec4 = DEFI_FONCTION( NOM_PARA='Y', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) # DANS LE BUT D IMPOSER LA RELATION LINEAIRE ENTRE DDLS # SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION # VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE # N = 0, N ETANT L EFFORT NORMAL) # ON CALCULE LE VECTEUR DE CHARGEMENT DU A UN TERME SOURCE EGAL # A 1., LES TERMES DE CE VECTEUR SONT EGAUX A # SOMME_SECTION(NI.DS) ET SONT DONC LES COEFFICIENTS DE # LA RELATION LINEAIRE A IMPOSER. # ON DEFINIT DONC UN CHARGEMENT DU A UN TERME SOURCE EGAL A 1 : __chart4 = AFFE_CHAR_THER( MODELE=__nomot2, SOURCE=_F(TOUT='OUI', SOUR=1.0), ) # ON CALCULE LE VECT_ELEM DU AU CHARGEMENT PRECEDENT # IL S AGIT DES VECTEURS ELEMENTAIRES DONT LE TERME # AU NOEUD COURANT I EST EGAL A SOMME_SECTION(NI.DS) : __vecel = CALC_VECT_ELEM(CHARGE=__chart4, OPTION='CHAR_THER') # ON CALCULE LE MATR_ELEM DES MATRICES ELEMENTAIRES # DE CONDUCTIVITE UNIQUEMENT POUR GENERER LE NUME_DDL # SUR-LEQUEL S APPUIERA LE CHAMNO UTILISE POUR ECRIRE LA # RELATION LINEAIRE ENTRE DDLS : __matel = CALC_MATR_ELEM( MODELE=__nomot2, CHAM_MATER=__chmat2, CHARGE=__chart4, OPTION='RIGI_THER', ) # ON DEFINIT LE NUME_DDL ASSOCIE AU MATR_ELEM DEFINI # PRECEDEMMENT POUR CONSTRUIRE LE CHAMNO UTILISE POUR ECRIRE LA # RELATION LINEAIRE ENTRE DDLS : __numddl = NUME_DDL(MATR_RIGI=__matel, ) # ON CONSTRUIT LE CHAMNO QUI VA ETRE UTILISE POUR ECRIRE LA # RELATION LINEAIRE ENTRE DDLS : __chamno = ASSE_VECTEUR( VECT_ELEM=__vecel, NUME_DDL=__numddl, ) # ON IMPOSE LA RELATION LINEAIRE ENTRE DDLS # SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION # VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE # N = 0, N ETANT L EFFORT NORMAL) # POUR IMPOSER CETTE RELATION ON PASSE PAR LIAISON_CHAMNO, # LES TERMES DU CHAMNO (I.E. SOMME_SECTION(NI.DS)) # SONT LES COEFFICIENTS DE LA RELATION LINEAIRE : __chart5 = AFFE_CHAR_THER( MODELE=__nomot2, LIAISON_CHAMNO=_F(CHAM_NO=__chamno, COEF_IMPO=0.), ) # LE CHARGEMENT EST UN FLUX REPARTI NORMAL AU CONTOUR # DONT LES COMPOSANTES SONT +Z (I.E. +Y) ET -Y (I.E. -X) # SELON LA DIRECTION NORMALE AU CONTOUR : __chart6 = AFFE_CHAR_THER_F( MODELE=__nomot2, FLUX_REP=_F( GROUP_MA=GROUP_MA_BORD, FLUX_X=__fnsec4, FLUX_Y=__fnsec3, ), ) # RESOLUTION DE LAPLACIEN(OMEGA) = 0 # AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ SUR LE CONTOUR DE LA SECTION # ET SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION # VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE # N = 0, N ETANT L EFFORT NORMAL) : __tempe4 = THER_LINEAIRE( MODELE=__nomot2, CHAM_MATER=__chmat2, EXCIT=( _F(CHARGE=__chart5, ), _F(CHARGE=__chart6, ), ), SOLVEUR=_F( STOP_SINGULIER='NON', METHODE='LDLT', ), ) # CALCUL DE L INERTIE DE GAUCHISSEMENT : nomres = POST_ELEM( MODELE=__nomot2, CHAM_MATER=__chmat2, CARA_POUTRE=_F(CARA_GEOM=__cacis, LAPL_PHI=__tempe4, TOUT='OUI', OPTION='CARA_GAUCHI'), ) # ================================================================== # = CALCUL DE LA CONSTANTE DE TORSION SUR CHAQUE GROUPE = # = ET DU RAYON DE TORSION SUR CHAQUE GROUPE = # = DU CENTRE DE TORSION/CISAILLEMENT = # = DES COEFFICIENTS DE CISAILLEMENT = # ================================================================== if GROUP_MA_BORD and GROUP_MA: # CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION : l_group_ma_bord = GROUP_MA_BORD l_group_ma = GROUP_MA l_noeud = None if args['NOEUD'] != None: l_noeud = args['NOEUD'] elif args['GROUP_NO'] != None: collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomlma.nom) nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.nom) l_nu_no = [] for grno in args['GROUP_NO']: l_nu_no.extend(collgrno[string.ljust(grno, 24)]) l_noeud = [nomnoe[no_i - 1] for no_i in l_nu_no] if len(l_group_ma) != len(l_group_ma_bord): UTMESS('F', 'POUTRE0_1') if l_noeud != None and (len(l_group_ma) != len(l_noeud)): UTMESS('F', 'POUTRE0_2') __catp2 = __cageo for i in range(0, len(l_group_ma_bord)): # TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS # ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE : __nomlma = DEFI_GROUP(reuse=__nomlma, MAILLAGE=__nomlma, DETR_GROUP_NO=_F(NOM=l_group_ma_bord[i], ), CREA_GROUP_NO=_F( GROUP_MA=l_group_ma_bord[i], )) # CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES # QUE LES COORDONNEES SONT EXPRIMEES DANS LE REPERE PRINCIPAL # D INERTIE DONT L ORIGINE EST LE CENTRE DE GRAVITE DE LA SECTION : __nomapi = CREA_MAILLAGE( MAILLAGE=__nomlma, REPERE=_F( TABLE=__cageo, NOM_ORIG='CDG', GROUP_MA=l_group_ma[i], ), ) # AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE # LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : __nomoth = AFFE_MODELE( MAILLAGE=__nomapi, AFFE=_F( GROUP_MA=l_group_ma[i], PHENOMENE='THERMIQUE', MODELISATION='PLAN', ), ) # POUR LA CONSTRUCTION DU LAPLACIEN, ON DEFINIT UN # PSEUDO-MATERIAU DONT LES CARACTERISTIQUES THERMIQUES SONT : # LAMBDA = 1, RHO*CP = 0 : __nomath = DEFI_MATERIAU(THER=_F( LAMBDA=1.0, RHO_CP=0.0, ), ) # DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : __chmath = AFFE_MATERIAU( MAILLAGE=__nomapi, AFFE=_F(TOUT='OUI', MATER=__nomath), ) # CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION - # D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2 - # L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION : - # LAPLACIEN(PHI) = -2 DANS LA SECTION - # PHI = 0 SUR LE CONTOUR : - # # ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR # DE LA SECTION # ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION : __chart1 = AFFE_CHAR_THER( MODELE=__nomoth, TEMP_IMPO=_F(GROUP_NO=l_group_ma_bord[i], TEMP=0.0), SOURCE=_F(TOUT='OUI', SOUR=2.0), ) # RESOLUTION DE LAPLACIEN(PHI) = -2 # AVEC PHI = 0 SUR LE CONTOUR : __tempe1 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart1, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) # ---------------------------------------------- # CALCUL DU CENTRE DE TORSION/CISAILLEMENT # ET DES COEFFICIENTS DE CISAILLEMENT : # # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Y : __fnsec1 = DEFI_FONCTION( NOM_PARA='X', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) __fnsec0 = DEFI_CONSTANTE(VALE=0.0, ) # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION # DE LAPLACE EST PRIS EGAL A Y DANS TOUTE LA SECTION : __chart2 = AFFE_CHAR_THER_F( MODELE=__nomoth, TEMP_IMPO=_F(NOEUD=l_noeud[i], TEMP=__fnsec0), SOURCE=_F( TOUT='OUI', SOUR=__fnsec1, ), ) # RESOLUTION DE LAPLACIEN(PHI) = -Y # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe2 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart2, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Z : __fnsec2 = DEFI_FONCTION( NOM_PARA='Y', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION # DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION : __chart3 = AFFE_CHAR_THER_F( MODELE=__nomoth, TEMP_IMPO=_F(NOEUD=l_noeud[i], TEMP=__fnsec0), SOURCE=_F( TOUT='OUI', SOUR=__fnsec2, ), ) # RESOLUTION DE LAPLACIEN(PHI) = -Z # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe3 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart3, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) # CALCUL DU RAYON DE TORSION : # CALCUL DU RAYON DE TORSION EXTERNE : rtext __tempe1 = CALC_CHAMP( reuse=__tempe1, RESULTAT=__tempe1, TOUT_ORDRE='OUI', THERMIQUE='FLUX_ELNO', ) __flun = MACR_LIGN_COUPE(RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=l_group_ma_bord[i], )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F(NOM=l_group_ma_bord[i], )) __m1 = abs(__flun['TRAC_NOR', 3]) __m2 = abs(__flun['TRAC_NOR', 4]) __rtext = max(__m1, __m2) # CALCUL DU RAYON DE TORSION : rt # rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) if args.has_key('GROUP_MA_INTE'): if args['GROUP_MA_INTE'] != None: if type(args['GROUP_MA_INTE']) == types.StringType: l_group_ma_inte = [ args['GROUP_MA_INTE'], ] else: l_group_ma_inte = args['GROUP_MA_INTE'] for j in range(0, len(l_group_ma_inte)): __flun = MACR_LIGN_COUPE( RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=l_group_ma_inte[i], )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F( NOM=l_group_ma_inte[i], )) __m1 = (abs(__flun['TRAC_NOR', 3]) + abs(__flun['TRAC_NOR', 4])) / 2.0 if __m1 > __rtext: __rtext = __m1 __rt = __rtext # CALCUL DE LA CONSTANTE DE TORSION : __catp1 = POST_ELEM( MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F(CARA_GEOM=__catp2, LAPL_PHI=__tempe1, RT=__rt, GROUP_MA=l_group_ma[i], OPTION='CARA_TORSION'), ) # CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU # CENTRE DE CISAILLEMENT/TORSION : __catp2 = POST_ELEM( MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F( CARA_GEOM=__catp1, LAPL_PHI_Y=__tempe2, LAPL_PHI_Z=__tempe3, GROUP_MA=l_group_ma[i], LONGUEUR=args['LONGUEUR'], MATERIAU=args['MATERIAU'], LIAISON=args['LIAISON'], OPTION='CARA_CISAILLEMENT', ), ) # # dprod = __catp2.EXTR_TABLE().dict_CREA_TABLE() # On remplace dans le TITRE le nom du concept __catp2.nom par # self.sd.nom if ('TITRE' in dprod.keys()): conceptOld = __catp2.nom conceptNew = self.sd.nom for ii in range(len(dprod['TITRE'])): zz = dprod['TITRE'][ii] if (conceptOld.strip() in zz): dprod['TITRE'][ii] = zz.replace(conceptOld.strip(), conceptNew.strip()) # nomres = CREA_TABLE(**dprod) # if not GROUP_MA_BORD: nomres = POST_ELEM(MODELE=__nomamo, CHAM_MATER=__nomama, CARA_GEOM=mfact) # # On retourne une table exploitable par AFFE_CARA_ELEM, avec seulement les # caractéristiques nécessaires if (TABLE_CARA == "OUI"): # si GROUP_MA : le concept NomMaillageOld ne fait plus partie de la table # si pas GROUP_MA : # si NOM : le nom du concept NomMaillageOld est remplacé par NomMaillageNew # si pas NOM : le nom du concept NomMaillageOld est gardé # On enlève la ligne avec LIEU='-' nomres = CALC_TABLE( reuse=nomres, TABLE=nomres, ACTION=_F(OPERATION='FILTRE', NOM_PARA='LIEU', CRIT_COMP='NON_VIDE'), ) # NomMaillageNew, NomMaillageOld = NomMaillage if (GROUP_MA): # Une ligne avec LIEU=NomMaillageOld ==> on la supprime nomres = CALC_TABLE( reuse=nomres, TABLE=nomres, ACTION=_F(OPERATION='FILTRE', NOM_PARA='LIEU', CRIT_COMP='NE', VALE_K=NomMaillageOld), ) TabTmp = nomres.EXTR_TABLE().dict_CREA_TABLE() else: # si NomMaillageNew est donné on remplace LIEU=NomMaillageOld par LIEU=NomMaillageNew if (NomMaillageNew != None): TabTmp = nomres.EXTR_TABLE() for ii in range(len(TabTmp.rows)): zz = TabTmp.rows[ii]['LIEU'] if (zz.strip() == NomMaillageOld): TabTmp.rows[ii]['LIEU'] = NomMaillageNew # TabTmp = TabTmp.dict_CREA_TABLE() else: TabTmp = nomres.EXTR_TABLE().dict_CREA_TABLE() # __catp2 = CREA_TABLE(**TabTmp) DETRUIRE(CONCEPT=_F(NOM=nomres), INFO=1) # if GROUP_MA_BORD and not GROUP_MA: nomres = CALC_TABLE( TABLE=__catp2, ACTION=(_F( OPERATION='EXTR', NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'AY', 'AZ', 'EY', 'EZ', 'JX', 'JG', 'IYR2', 'IZR2', 'RY', 'RZ', 'RT', 'ALPHA', 'CDG_Y', 'CDG_Z'), ), ), ) elif GROUP_MA_BORD and GROUP_MA: nomres = CALC_TABLE( TABLE=__catp2, ACTION=(_F( OPERATION='EXTR', NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'AY', 'AZ', 'EY', 'EZ', 'JX', 'IYR2', 'IZR2', 'RY', 'RZ', 'RT', 'ALPHA', 'CDG_Y', 'CDG_Z'), ), ), ) else: nomres = CALC_TABLE( TABLE=__catp2, ACTION=(_F( OPERATION='EXTR', NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'IYR2', 'IZR2', 'RY', 'RZ', 'ALPHA', 'CDG_Y', 'CDG_Z'), ), ), ) # # Validation des résultats qui doivent toujours être >=0 TabTmp = nomres.EXTR_TABLE() for ii in range(len(TabTmp.rows)): ligne = TabTmp.rows[ii] # on recherche la bonne ligne if (ligne['LIEU'].strip() == NomMaillageNew): paras = TabTmp.para # Vérification des grandeurs qui doivent toujours rester positive Lparas = ( 'A', 'IY', 'IZ', 'AY', 'AZ', 'JX', 'JG', ) iergd = 0 for unpara in Lparas: if (unpara in paras): if (ligne[unpara] <= 0): iergd += 1 if (iergd != 0): if (not ImprTable): IMPR_TABLE(TABLE=nomres) ImprTable = True for unpara in Lparas: if (unpara in paras): if (ligne[unpara] <= 0): UTMESS('E', 'POUTRE0_10', valk=unpara, valr=ligne[unpara]) UTMESS('F', 'POUTRE0_11') # # Vérification que le CDG est l'origine du maillage cdgy = ligne['CDG_Y'] cdgz = ligne['CDG_Z'] dcdg = (cdgy * cdgy + cdgz * cdgz) / ligne['A'] if (dcdg > 1.0E-08): if (not ImprTable): IMPR_TABLE(TABLE=nomres) ImprTable = True UTMESS('A', 'POUTRE0_12', valr=[cdgy, cdgz]) # Vérification que la section n'est pas tournée alpha = ligne['ALPHA'] if (abs(alpha) > 0.001): if (not ImprTable): IMPR_TABLE(TABLE=nomres) ImprTable = True UTMESS('A', 'POUTRE0_13', valr=[alpha, -alpha]) # # On retourne une table contenant toutes les caractéristiques calculées else: if GROUP_MA_BORD and not GROUP_MA: nomres = CALC_TABLE( reuse=nomres, TABLE=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=( 'LIEU', 'ENTITE', 'A_M', 'CDG_Y_M', 'CDG_Z_M', 'IY_G_M', 'IZ_G_M', 'IYZ_G_M', 'Y_MAX', 'Z_MAX', 'Y_MIN', 'Z_MIN', 'R_MAX', 'A', 'CDG_Y', 'CDG_Z', 'IY_G', 'IZ_G', 'IYZ_G', 'IY', 'IZ', 'ALPHA', 'Y_P', 'Z_P', 'IY_P', 'IZ_P', 'IYZ_P', 'JX', 'AY', 'AZ', 'EY', 'EZ', 'PCTY', 'PCTZ', 'JG', 'KY', 'KZ', 'IYR2_G', 'IZR2_G', 'IYR2', 'IZR2', 'IYR2_P', 'IZR2_P', 'RY', 'RZ', 'RT', ), ), ), ) elif GROUP_MA_BORD and GROUP_MA: nomres = CALC_TABLE( reuse=nomres, TABLE=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=( 'LIEU', 'ENTITE', 'A_M', 'CDG_Y_M', 'CDG_Z_M', 'IY_G_M', 'IZ_G_M', 'IYZ_G_M', 'Y_MAX', 'Z_MAX', 'Y_MIN', 'Z_MIN', 'R_MAX', 'A', 'CDG_Y', 'CDG_Z', 'IY_G', 'IZ_G', 'IYZ_G', 'IY', 'IZ', 'ALPHA', 'Y_P', 'Z_P', 'IY_P', 'IZ_P', 'IYZ_P', 'JX', 'AY', 'AZ', 'EY', 'EZ', 'PCTY', 'PCTZ', 'KY', 'KZ', 'IYR2_G', 'IZR2_G', 'IYR2', 'IZR2', 'IYR2_P', 'IZR2_P', 'RY', 'RZ', 'RT', ), ), ), ) else: nomres = CALC_TABLE( reuse=nomres, TABLE=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=( 'LIEU', 'ENTITE', 'A_M', 'CDG_Y_M', 'CDG_Z_M', 'IY_G_M', 'IZ_G_M', 'IYZ_G_M', 'Y_MAX', 'Z_MAX', 'Y_MIN', 'Z_MIN', 'R_MAX', 'A', 'CDG_Y', 'CDG_Z', 'IY_G', 'IZ_G', 'IYZ_G', 'IY', 'IZ', 'ALPHA', 'Y_P', 'Z_P', 'IY_P', 'IZ_P', 'IYZ_P', 'IYR2_G', 'IZR2_G', 'IYR2', 'IZR2', 'IYR2_P', 'IZR2_P', 'RY', 'RZ', ), ), ), ) # if (not ImprTable): IMPR_TABLE(TABLE=nomres) # RetablirAlarme('CHARGES2_87') RetablirAlarme('CALCULEL_40') return ier
def defi_sol_miss_ops(self, MATERIAU, COUCHE, COUCHE_AUTO, TITRE, INFO, **args): """Macro DEFI_SOL_MISS : définir les caractéristiques du sol pour un calcul MISS3D """ import aster from code_aster.Cata.Syntax import _F from Utilitai.Utmess import UTMESS from Utilitai.Table import Table CREA_TABLE = self.get_cmd("CREA_TABLE") ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # Le concept sortant (de type table_sdaster) est tabout self.DeclareOut("tabout", self.sd) # 1. Création des dictionnaires des MATERIAUX l_mate = [] for Mi in MATERIAU: dM = Mi.cree_dict_valeurs(Mi.mc_liste) l_mate.append(dM) nb_mate = len(l_mate) # 2. Création des dictionnaires des COUCHES l_couche = [] n_substr = 0 n_epais = 0 # Mode manuel : if COUCHE != None: for Ci in COUCHE: dC = Ci.cree_dict_valeurs(Ci.mc_liste) if dC.get("SUBSTRATUM") == "OUI": n_substr += 1 if dC.get("EPAIS") != None: n_epais += 1 l_couche.append(dC) if n_substr != 1: UTMESS("F", "MISS0_3") if n_epais == 0: UTMESS("F", "MISS0_21") nb_couche = len(l_couche) print 'l_couche=', l_couche # Mode automatique pour les couches : grma_interf = None arg_grno = False arg_grma = False if COUCHE_AUTO != None: ll_mate = [] l_epais = [] enfonce = False homogene = False l_z0 = False Z0 = 0. max_z_input = 0. min_z_input = 0. # tole_r sert à arrondir les valeurs pour les tests tole_r = 5 l_pt_ctrl = False coor_z_input = [] decalage_auto = False # Lecture des arguments : for Ci in COUCHE_AUTO: dC = Ci.cree_dict_valeurs(Ci.mc_liste) if dC.get("HOMOGENE") == "OUI": homogene = True if dC.get("MAILLAGE"): noma = dC.get("MAILLAGE") if dC.get("SURF") == "NON": enfonce = True if dC.get("GROUP_MA") or dC.get("GROUP_NO"): collcnx = aster.getcolljev(noma.nom.ljust(8) + '.CONNEX') coord = aster.getvectjev( noma.nom.ljust(8) + '.COORDO .VALE') cnom = aster.getvectjev(noma.nom.ljust(8) + '.NOMNOE') if dC.get("GROUP_MA"): arg_grma = True nomgrma = dC.get("GROUP_MA") coor_z_input = recu_coor_z(noma, nomgrma, 'group_ma', tole_r) else: arg_grno = True nomgrno = dC.get("GROUP_NO") coor_z_input = recu_coor_z(noma, nomgrno, 'group_no', tole_r) max_z_input = coor_z_input[0] min_z_input = coor_z_input[-1] if dC.get("NUME_MATE"): ll_mate = dC.get("NUME_MATE") if dC.get("EPAIS_PHYS"): if homogene: l_epais.append(dC.get("EPAIS_PHYS")[0]) else: l_epais = dC.get("EPAIS_PHYS") if dC.get("NUME_MATE_SUBSTRATUM"): nume_substr = dC.get("NUME_MATE_SUBSTRATUM") if dC.get("NOMBRE_RECEPTEUR"): nb_recept = dC.get("NOMBRE_RECEPTEUR") if (nb_recept % 2 <> 0): UTMESS("F", "MISS0_27") if dC.get("GROUP_MA_INTERF"): grma_interf = dC.get("GROUP_MA_INTERF") if dC.get("Z0"): Z0 = dC.get("Z0") l_z0 = True if not l_z0 and enfonce: Z0 = max_z_input if not enfonce: max_z_input = Z0 print 'La cote Z vaut : ', Z0 if dC.get("TOLERANCE"): tole_verif = dC.get("TOLERANCE") if dC.get("DECALAGE_AUTO") == "OUI": decalage_auto = True if dC.get("GROUP_MA_CONTROL"): nomgrmactrl = dC.get("GROUP_MA_CONTROL") l_pt_ctrl = True coor_z_ctrl = recu_coor_z(noma, nomgrmactrl, 'group_ma', tole_r) print 'Cotes verticales des points de controle=', coor_z_ctrl if coor_z_ctrl[0] > Z0: UTMESS("F", "MISS0_28", valr=Z0) if homogene: max_z_input = Z0 ll_mate.append(1) l_mate.append(l_mate[0]) nb_mate += 1 coor_z_sol = [ max_z_input, ] for ep in l_epais: coor_z_sol.append(coor_z_sol[-1] - ep) # Typage des couches : 1 si couche de sol, 2 si point de controle type_couche = [1] * len(coor_z_sol) if enfonce: # Verification si il y a vraiment enfoncement if len(coor_z_sol) == 1: UTMESS("F", "MISS0_29") # Verification entre base de l'interface et couches de sol print 'coor_z_sol=', coor_z_sol if len(l_epais) <> len(ll_mate): UTMESS("F", "MISS0_30") if l_pt_ctrl: if coor_z_ctrl[-1] < coor_z_sol[-1]: UTMESS("F", "MISS0_32") # Liste regroupant les cotes des points de controles et des couches de sol coor_z_sol_ctrl = [] for zz in coor_z_sol: coor_z_sol_ctrl.append(zz) for zz in coor_z_ctrl: if zz not in coor_z_sol_ctrl: coor_z_sol_ctrl.append(zz) prov = sorted(coor_z_sol_ctrl) coor_z_sol_ctrl = prov[::-1] type_couche = [1] l_epais = [] ll_mate2 = [] zz_sup = Z0 jj = 0 for zz in coor_z_sol_ctrl[1:]: if zz in coor_z_ctrl: if zz in coor_z_sol: UTMESS("F", "MISS0_33") else: type_couche.append(2) else: type_couche.append(1) pp = zz_sup - zz l_epais.append(pp) zz_sup = zz ll_mate2.append(ll_mate[jj]) if zz in coor_z_sol: jj += 1 ll_mate = ll_mate2 # Verification avec l'interface FEM-BEM nb_noeud = 0 verif = False if ((grma_interf != None) and enfonce and (COUCHE_AUTO != None)): coor_z_interf = recu_coor_z(noma, grma_interf, 'group_ma', tole_r) max_z_interf = coor_z_interf[0] min_z_interf = coor_z_interf[-1] l_z_sol = [ max_z_interf, ] for ep in l_epais: l_z_sol.append(l_z_sol[-1] - ep) nb_noeud = len(coor_z_input) if (max_z_input < max_z_interf) or (min_z_input > min_z_interf): UTMESS("F", "MISS0_34") verif = True denom = 1. for z_input in coor_z_input: verif1 = False for z_interf in coor_z_interf: if (abs(z_interf) > 1.): denom = abs(z_interf) if ((abs(z_input - z_interf) / denom) <= tole_verif): verif1 = True verif = (verif and verif1) if (not verif): if arg_grma: UTMESS("F", "MISS0_34") else: UTMESS("A", "MISS0_35") if l_pt_ctrl: for zz in coor_z_ctrl: if zz > min_z_input: UTMESS("F", "MISS0_36") #Generation table sol en mode auto if (COUCHE_AUTO != None): couche = {} nbc = 0 idc = 1 nbsscouche = 0 if enfonce: l_noeud = coor_z_input # Liste des epaisseurs de sol l_z_ep = [] for zz in l_z_sol: l_z_ep.append(Z0 - zz) for pt in range(nb_noeud - 1): idc += 1 enfonc_sup = l_noeud[0] - l_noeud[pt] if enfonc_sup > l_z_ep[len(l_z_ep) - 1]: UTMESS("F", "MISS0_37") ep_ss_couche = (l_noeud[pt] - l_noeud[pt + 1]) / nb_recept for nc in range(nb_recept): couche = {} enfonc_ss_c_haut = l_noeud[0] - l_noeud[pt] + ( nc * ep_ss_couche) enfonc_ss_c_bas = enfonc_ss_c_haut + ep_ss_couche i = 0 ind_mat_sup = 0 ind_mat_inf = 0 if not homogene: while enfonc_ss_c_haut > l_z_ep[i]: i += 1 while l_z_ep[ind_mat_sup] <= enfonc_ss_c_haut: ind_mat_sup += 1 ind_mat_inf = ind_mat_sup ind_mat_sup = ind_mat_sup - 1 while enfonc_ss_c_bas >= l_z_ep[ind_mat_inf]: ind_mat_inf += 1 nb_mat_couche = ind_mat_inf - ind_mat_sup if homogene: id_mate = ll_mate[0] elif ind_mat_sup < (ind_mat_inf - 2): #Cas plus de deux materiaux dans la sous-couche print ' Cas plus de deux materiaux dans la sous-couche' ep_mat_h = [] ep_mat_b = [] ep_mat = [ (l_z_ep[ind_mat_sup + 1] - enfonc_ss_c_haut), ] for ind_mat in range((ind_mat_sup + 1), (ind_mat_inf - 1)): zz1 = l_z_ep[ind_mat] - enfonc_ss_c_haut zz2 = enfonc_ss_c_bas - l_z_ep[ind_mat] ep_mat_h.append(zz1) ep_mat_b.append(zz2) ep_mat.append(enfonc_ss_c_bas - l_z_ep[ind_mat_inf - 1]) err_ep = abs(sum(ep_mat) - ep_ss_couche) / ep_ss_couche if (err_ep > tole_verif): UTMESS("F", "MISS0_38") ep1 = ep_mat[0] ii = 1 id_mate = ll_mate[ind_mat_sup] for ii in range(1, (len(ep_mat) - 1)): if (ep_mat[ii] > ep1): ep1 = ep_mat[ii] id_mate = ll_mate[ind_mat_sup + ii] elif ind_mat_sup == (ind_mat_inf - 2): #Cas deux materiaux dans la sous-couche zz1 = l_z_ep[ind_mat_sup + 1] - enfonc_ss_c_haut zz2 = enfonc_ss_c_bas - l_z_ep[ind_mat_sup + 1] if zz2 > zz1: id_mate = ll_mate[ind_mat_sup + 1] else: id_mate = ll_mate[ind_mat_sup] elif ind_mat_sup == (ind_mat_inf - 1): #Cas un seul materiau id_mate = ll_mate[ind_mat_sup] else: assert False, "Erreur dans la contruction des sous-couches" couche["SUBSTRATUM"] = None couche["NUME_MATE"] = id_mate couche["EPAIS"] = ep_ss_couche couche["RECEPTEUR"] = "OUI" couche["SOURCE"] = "NON" if nc == nb_recept / 2: couche["SOURCE"] = "OUI" l_couche.append(couche) idc += 1 enfonc_ss_c_bas = l_noeud[0] - l_noeud[pt + 1] # Fin des sous-couches # Couche a la base de l'interface ii = 0 epais = -1. if len(l_z_ep) > 1: while enfonc_ss_c_bas >= l_z_ep[ii]: ii += 1 epais = l_z_ep[ii] - enfonc_ss_c_bas else: if l_z_ep[ii] <= enfonc_ss_c_bas: UTMESS("F", "MISS0_39") else: epais = l_z_ep[ii] - enfonc_ss_c_bas couche = {} couche["EPAIS"] = epais couche["SUBSTRATUM"] = None if not homogene: couche["NUME_MATE"] = ll_mate[ii - 1] else: couche["NUME_MATE"] = ll_mate[0] couche["EPAIS"] = epais couche["SOURCE"] = "OUI" couche["RECEPTEUR"] = "OUI" idc += 1 l_couche.append(couche) # Couches strictement sous l'interface while ii < len(l_epais): couche = {} couche["SUBSTRATUM"] = None couche["NUME_MATE"] = ll_mate[ii] couche["EPAIS"] = l_epais[ii] couche["SOURCE"] = "NON" couche["RECEPTEUR"] = "NON" if type_couche[ii] == 2: # Cas des points de controle couche["RECEPTEUR"] = "OUI" couche["SOURCE"] = "OUI" l_couche.append(couche) idc += 1 ii += 1 # Substratum couche = {} couche["SUBSTRATUM"] = "OUI" couche["SOURCE"] = "NON" couche["RECEPTEUR"] = "NON" if homogene: couche["NUME_MATE"] = ll_mate[0] + 1 else: couche["NUME_MATE"] = nume_substr couche["EPAIS"] = None l_couche.append(couche) else: # Cas superficiel couche = {} ii = 0 couche["SOURCE"] = "OUI" couche["RECEPTEUR"] = "OUI" couche["NUME_MATE"] = ll_mate[ii] couche["EPAIS"] = l_epais[ii] couche["SUBSTRATUM"] = None l_couche.append(couche) ii = 1 for nc in range(1, len(l_epais)): couche = {} couche["SUBSTRATUM"] = None couche["NUME_MATE"] = ll_mate[ii] couche["EPAIS"] = l_epais[ii] couche["RECEPTEUR"] = "NON" couche["SOURCE"] = "NON" if type_couche[ii] == 2: # Cas des points de controle couche["RECEPTEUR"] = "OUI" couche["SOURCE"] = "OUI" l_couche.append(couche) idc += 1 ii += 1 couche = {} couche["SUBSTRATUM"] = "OUI" couche["SOURCE"] = "NON" couche["RECEPTEUR"] = "NON" if homogene: couche["NUME_MATE"] = ll_mate[0] + 1 else: couche["NUME_MATE"] = nume_substr couche["EPAIS"] = None l_couche.append(couche) if ((COUCHE_AUTO != None) and enfonce): # Verification entre base de l'interface et couches de sol min_z_input_r = round(min_z_input, tole_r) prof = Z0 ii = 0 for couche in l_couche[:-2]: prof = prof - couche["EPAIS"] prof = round(prof, tole_r) print 'ii=', ii print 'prof=', prof if prof == min_z_input_r: if decalage_auto: UTMESS("A", "MISS0_40", valr=(prof, couche["EPAIS"])) couche["NUME_MATE"] = l_couche[ii + 1]["NUME_MATE"] else: UTMESS("A", "MISS0_41") ii += 1 print 'l_couche mod=', l_couche # 3. définition de la table # para/typ pré-trie les colonnes tab = Table(para=[ "NUME_COUCHE", "EPAIS", "RHO", "E", "NU", "AMOR_HYST", "RECEPTEUR", "SOURCE", "NUME_MATE", "SUBSTRATUM" ], typ=["I", "R", "R", "R", "R", "R", "K8", "K8", "I", "K8"]) idc = 0 for couche in l_couche: idc += 1 id_mate = couche["NUME_MATE"] if id_mate > nb_mate: UTMESS("F", "MISS0_4", vali=(idc, nb_mate, id_mate)) id_mate = id_mate - 1 couche["NUME_COUCHE"] = idc couche.update(l_mate[id_mate]) if couche.get("SUBSTRATUM") is None: del couche["SUBSTRATUM"] if couche["EPAIS"] is None: couche["EPAIS"] = 0. tab.append(couche) # 4. surcharge par le titre fourni if TITRE != None: if type(TITRE) not in (list, tuple): TITRE = [TITRE] tab.titr = os.linesep.join(TITRE) if INFO == 2: print tab # 5. création de la table dprod = tab.dict_CREA_TABLE() tabout = CREA_TABLE(**dprod)
def sdu_nb_ec(numgd): """retourne le nombre d'entiers codés pour décrire les composantes de la grandeur (numgd)""" assert numgd > 0 and numgd < 1000, numgd descrigd = aster.getcolljev('&CATA.GD.DESCRIGD') return descrigd[numgd][-1 + 3]
def sdu_licmp_gd(numgd): """retourne la liste des cmps de la grandeur de numéro (numgd)""" nomgd = sdu_nom_gd(numgd) nocmp = aster.getcolljev('&CATA.GD.NOMCMP') return nocmp[nomgd.ljust(24)]
def macr_cara_poutre_ops(self, MAILLAGE=None, SYME_Y=None, SYME_Z=None, GROUP_MA_BORD=None, GROUP_MA=None, ORIG_INER=None, TABLE_CARA=None, **args): """ Ecriture de la macro MACR_CARA_POUTRE """ # # On importe les définitions des commandes a utiliser dans la macro # Le nom de la variable doit être obligatoirement le nom de la commande # ImprTable = False # UNITE = args.get("UNITE") or 20 if (MAILLAGE is not None): __nomlma = COPIER(CONCEPT=MAILLAGE) else: __nomlma = LIRE_MAILLAGE(UNITE=UNITE, FORMAT=args.get('FORMAT')) # # Dans les tables on retrouve une ligne avec __nomlma.nom. Soit : # - on remplace __nomlma.nom par NomMaillageNew. # - on supprime la ligne NomMaillage = (None, __nomlma.getName()) if ('NOM' in args): NomMaillage = (args.get('NOM'), __nomlma.getName()) # # __nomamo = AFFE_MODELE( MAILLAGE=__nomlma, AFFE=_F( TOUT='OUI', PHENOMENE='MECANIQUE', MODELISATION='D_PLAN', ), ) __nomdma = DEFI_MATERIAU(ELAS=_F(E=1.0, NU=0., RHO=1.0), ) __nomama = AFFE_MATERIAU( MAILLAGE=__nomlma, AFFE=_F( TOUT='OUI', MATER=__nomdma, ), ) # # L'utilisateur ne peut rien faire pour éviter ces "Alarmes" donc pas d'impression MasquerAlarme('CHARGES2_87') MasquerAlarme('CALCULEL_40') # # # calcul des caractéristiques géométriques de la section motsimps = {} if GROUP_MA: motsimps['GROUP_MA'] = GROUP_MA if SYME_Y: motsimps['SYME_X'] = SYME_Y if SYME_Z: motsimps['SYME_Y'] = SYME_Z motsimps['ORIG_INER'] = ORIG_INER mfact = _F(TOUT='OUI', **motsimps) __cageo = POST_ELEM(MODELE=__nomamo, CHAM_MATER=__nomama, CARA_GEOM=mfact) # # Création d'un modèle plan 2D thermique représentant la section # de la poutre car on doit résoudre des E.D.P. avec des laplaciens # # Calcul de la constante de torsion sur tout le maillage # du centre de torsion/cisaillement des coefficients de cisaillement # de l inertie de gauchissement # du rayon de torsion # if GROUP_MA_BORD and not GROUP_MA: # Transformation des GROUP_MA en GROUP_NO sur lesquels # on pourra appliquer des conditions de température imposée # # les groupes doivent exister collgrma = aster.getcolljev('%-8s.GROUPEMA' % __nomlma.getName()) collgrma = list(map(lambda x: x.strip(), collgrma)) if type(GROUP_MA_BORD) == str: l_group_ma_bord = [ GROUP_MA_BORD, ] else: l_group_ma_bord = GROUP_MA_BORD for igr in l_group_ma_bord: if (not igr.strip() in collgrma): UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_BORD']) if 'GROUP_MA_INTE' in args: if args.get('GROUP_MA_INTE') is not None: if type(args.get('GROUP_MA_INTE')) is str: l_group_ma_inte = [ args.get('GROUP_MA_INTE'), ] else: l_group_ma_inte = args.get('GROUP_MA_INTE') for igr in l_group_ma_inte: if (not igr.strip() in collgrma): UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_INTE']) # motscles = {} if type(GROUP_MA_BORD) == str: motscles['CREA_GROUP_NO'] = _F(GROUP_MA=GROUP_MA_BORD, ) else: motscles['CREA_GROUP_NO'] = [] for grma in GROUP_MA_BORD: motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=grma, )) # __nomlma = DEFI_GROUP(reuse=__nomlma, MAILLAGE=__nomlma, **motscles) # Création d'un maillage identique au premier a ceci près # que les coordonnées sont exprimées dans le repère principal # d'inertie dont l'origine est le centre de gravite de la section __nomapi = CREA_MAILLAGE( MAILLAGE=__nomlma, REPERE=_F( TABLE=__cageo, NOM_ORIG='CDG', ), ) # Affectation du phénomène 'thermique' au modèle en vue de # la construction d un opérateur laplacien sur ce modèle __nomoth = AFFE_MODELE( MAILLAGE=__nomapi, AFFE=_F( TOUT='OUI', PHENOMENE='THERMIQUE', MODELISATION='PLAN', ), ) # Pour la construction du laplacien, on définit un matériau dont les # caractéristiques thermiques sont : lambda = 1, rho*cp = 0 __nomath = DEFI_MATERIAU(THER=_F( LAMBDA=1.0, RHO_CP=0., ), ) # Définition d'un CHAM_MATER à partir du matériau précédent __chmath = AFFE_MATERIAU( MAILLAGE=__nomapi, AFFE=_F( TOUT='OUI', MATER=__nomath, ), ) # CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION # D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2 # L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION : # LAPLACIEN(PHI) = -2 DANS LA SECTION # PHI = 0 SUR LE CONTOUR : #------------------------------------------------------------ # # ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR DE LA SECTION # ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION #------------------------------------------------------------ motscles = {} if 'GROUP_MA_INTE' in args: if args.get('GROUP_MA_INTE') is not None: motscles['LIAISON_UNIF'] = _F( GROUP_MA=args.get('GROUP_MA_INTE'), DDL='TEMP'), __chart1 = AFFE_CHAR_THER(MODELE=__nomoth, TEMP_IMPO=_F(GROUP_NO=GROUP_MA_BORD, TEMP=0.), SOURCE=_F(TOUT='OUI', SOUR=2.0), **motscles) # POUR CHAQUE TROU DE LA SECTION : # ON A IMPOSE QUE PHI EST CONSTANT SUR LE CONTOUR INTERIEUR # EN FAISANT LE LIAISON_UNIF DANS LE AFFE_CHAR_THER PRECEDENT # ON IMPOSE EN PLUS D(PHI)/DN = 2*AIRE(TROU)/L(TROU) # OU D/DN DESIGNE LA DERIVEE PAR RAPPORT A LA # NORMALE ET L DESIGNE LA LONGUEUR DU BORD DU TROU : if 'GROUP_MA_INTE' in args: lgmaint = args.get('GROUP_MA_INTE') if lgmaint is not None: __tbaire = POST_ELEM( MODELE=__nomoth, AIRE_INTERNE=_F(GROUP_MA_BORD=args.get('GROUP_MA_INTE'), ), ) motscles = {} motscles['FLUX_REP'] = [] if type(lgmaint) == str: motscles['FLUX_REP'] = _F( GROUP_MA=args.get('GROUP_MA_INTE'), CARA_TORSION=__tbaire) else: motscles['FLUX_REP'] = [] for grma in lgmaint: motscles['FLUX_REP'].append( _F(GROUP_MA=grma, CARA_TORSION=__tbaire), ) __chart2 = AFFE_CHAR_THER(MODELE=__nomoth, **motscles) #------------------------------------------------------------ # RESOLUTION DE LAPLACIEN(PHI) = -2 # AVEC PHI = 0 SUR LE CONTOUR : motscles = {} motscles['EXCIT'] = [ _F(CHARGE=__chart1, ), ] if 'GROUP_MA_INTE' in args: if lgmaint is not None: motscles['EXCIT'].append(_F(CHARGE=__chart2, )) __tempe1 = THER_LINEAIRE(MODELE=__nomoth, CHAM_MATER=__chmath, SOLVEUR=_F(STOP_SINGULIER='NON', ), **motscles) #------------------------------------------------------------ # CALCUL DU CENTRE DE TORSION/CISAILLEMENT - # ET DES COEFFICIENTS DE CISAILLEMENT : - # # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Y : __fnsec1 = DEFI_FONCTION( NOM_PARA='X', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) __fnsec0 = DEFI_CONSTANTE(VALE=0., ) #------------------------------------------------------------ # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L ÉQUATION # DE LAPLACE EST PRIS ÉGAL A Y DANS TOUTE LA SECTION : mctimpo = {} if args.get('NOEUD') is not None: if len(args.get('NOEUD')) != 1: UTMESS('F', 'POUTRE0_3') nthno = args['NOEUD'][0].strip() # nthno est-il dans le maillage ? nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.getName()) nomnoe = list(map(lambda x: x.strip(), nomnoe)) if (not nthno in nomnoe): UTMESS('F', 'POUTRE0_9', valk=nthno) mctimpo['TEMP_IMPO'] = (_F(NOEUD=nthno, TEMP=__fnsec0)) elif args.get('GROUP_NO') is not None: if len(args.get('GROUP_NO')) != 1: UTMESS('F', 'POUTRE0_3') grthno = args.get('GROUP_NO')[0] #grthno = grthno[0] collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomapi.getName()) nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomapi.getName()) # Plantage si grthno n'existe pas dans le maillage try: l_no = collgrno[grthno.ljust(24)] except: UTMESS('F', 'POUTRE0_8', valk=grthno) if len(l_no) != 1: UTMESS('F', 'POUTRE0_3') nthno = nomnoe[l_no[0] - 1] mctimpo['TEMP_IMPO'] = (_F(NOEUD=nthno, TEMP=__fnsec0)) # __chart2 = AFFE_CHAR_THER_F(MODELE=__nomoth, SOURCE=_F( TOUT='OUI', SOUR=__fnsec1, ), **mctimpo) #------------------------------------------------------------ # RESOLUTION DE LAPLACIEN(PHI) = -Y # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe2 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart2, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) #------------------------------------------------------------ # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Z : __fnsec2 = DEFI_FONCTION( NOM_PARA='Y', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) #------------------------------------------------------------ # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION # DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION : __chart3 = AFFE_CHAR_THER_F(MODELE=__nomoth, SOURCE=_F( TOUT='OUI', SOUR=__fnsec2, ), **mctimpo) #------------------------------------------------------------ # RESOLUTION DE LAPLACIEN(PHI) = -Z # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe3 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart3, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) #------------------------------------------------------------ # CALCUL DU RAYON DE TORSION : # CALCUL DU RAYON DE TORSION EXTERNE : rtext __tempe1 = CALC_CHAMP( reuse=__tempe1, RESULTAT=__tempe1, TOUT_ORDRE='OUI', THERMIQUE='FLUX_ELNO', ) __flun = MACR_LIGN_COUPE(RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=GROUP_MA_BORD, )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F(NOM=GROUP_MA_BORD, )) __m1 = abs(__flun['TRAC_NOR', 3]) __m2 = abs(__flun['TRAC_NOR', 4]) __rtext = max(__m1, __m2) # CALCUL DU RAYON DE TORSION : rt # rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) if 'GROUP_MA_INTE' in args: if args.get('GROUP_MA_INTE') is not None: if type(args.get('GROUP_MA_INTE')) is str: l_group_ma_inte = [ args.get('GROUP_MA_INTE'), ] else: l_group_ma_inte = args.get('GROUP_MA_INTE') for i in range(0, len(l_group_ma_inte)): __flun = MACR_LIGN_COUPE(RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=l_group_ma_inte[i], )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F( NOM=l_group_ma_inte[i], )) __m1 = (abs(__flun['TRAC_NOR', 3]) + abs(__flun['TRAC_NOR', 4])) / 2. if __m1 > __rtext: __rtext = __m1 # __rt = __rtext #------------------------------------------------------------ # CALCUL DE LA CONSTANTE DE TORSION : motscles = {} lgmaint = args.get('GROUP_MA_INTE') if lgmaint is not None: motscles['CARA_POUTRE'] = _F( CARA_GEOM=__cageo, LAPL_PHI=__tempe1, RT=__rt, TOUT='OUI', OPTION='CARA_TORSION', GROUP_MA_INTE=args.get('GROUP_MA_INTE'), ) else: motscles['CARA_POUTRE'] = _F( CARA_GEOM=__cageo, LAPL_PHI=__tempe1, RT=__rt, TOUT='OUI', OPTION='CARA_TORSION', ) # __cator = POST_ELEM(MODELE=__nomoth, CHAM_MATER=__chmath, **motscles) #------------------------------------------------------------ # CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU # CENTRE DE CISAILLEMENT/TORSION : __cacis = POST_ELEM( MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F( CARA_GEOM=__cator, LAPL_PHI_Y=__tempe2, LAPL_PHI_Z=__tempe3, TOUT='OUI', OPTION='CARA_CISAILLEMENT', ), ) #------------------------------------------------------------ # CALCUL DE L INERTIE DE GAUCHISSEMENT PAR RESOLUTION DE - # LAPLACIEN(OMEGA) = 0 DANS LA SECTION - # AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ SUR LE - # CONTOUR DE LA SECTION - # NY ET NZ SONT LES COMPOSANTES DU VECTEUR N NORMAL - # A CE CONTOUR - # ET SOMME_S(OMEGA.DS) = 0 - # OMEGA EST LA FONCTION DE GAUCHISSEMENT - # L INERTIE DE GAUCHISSEMENT EST SOMME_S(OMEGA**2.DS) - # ----------------------------------------------------------- # # CREATION D UN MAILLAGE DONT LES COORDONNEES SONT EXPRIMEES # DANS LE REPERE PRINCIPAL D INERTIE MAIS AVEC COMME ORIGINE # LE CENTRE DE TORSION DE LA SECTION, ON VA DONC UTILISER # LE MAILLAGE DE NOM NOMAPI DONT LES COORDONNEES SONT # EXPRIMEES DANS LE REPERE PRINCIPAL D'INERTIE, L'ORIGINE # ETANT LE CENTRE DE GRAVITE DE LA SECTION (QUI EST DONC A CHANGER) __nomapt = CREA_MAILLAGE(MAILLAGE=__nomapi, REPERE=_F( TABLE=__cacis, NOM_ORIG='TORSION', )) #------------------------------------------------------------ # AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE # LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : __nomot2 = AFFE_MODELE(MAILLAGE=__nomapt, AFFE=_F( TOUT='OUI', PHENOMENE='THERMIQUE', MODELISATION='PLAN', )) # DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : __chmat2 = AFFE_MATERIAU( MAILLAGE=__nomapt, AFFE=_F( TOUT='OUI', MATER=__nomath, ), ) # POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR # LA COMPOSANTE SELON Y DU FLUX A IMPOSER SUR LE CONTOUR # PAR UNE FONCTION EGALE A -X : __fnsec3 = DEFI_FONCTION( NOM_PARA='X', VALE=(0., 0., 10., -10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) # POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR # LA COMPOSANTE SELON X DU FLUX A IMPOSER SUR LE CONTOUR # PAR UNE FONCTION EGALE A Y : __fnsec4 = DEFI_FONCTION( NOM_PARA='Y', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) # DANS LE BUT D IMPOSER LA RELATION LINEAIRE ENTRE DDLS # SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION # VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE # N = 0, N ETANT L EFFORT NORMAL) # ON CALCULE LE VECTEUR DE CHARGEMENT DU A UN TERME SOURCE EGAL # A 1., LES TERMES DE CE VECTEUR SONT EGAUX A # SOMME_SECTION(NI.DS) ET SONT DONC LES COEFFICIENTS DE # LA RELATION LINEAIRE A IMPOSER. # ON DEFINIT DONC UN CHARGEMENT DU A UN TERME SOURCE EGAL A 1 : __chart4 = AFFE_CHAR_THER( MODELE=__nomot2, SOURCE=_F(TOUT='OUI', SOUR=1.0), ) # ON CALCULE LE VECT_ELEM DU AU CHARGEMENT PRECEDENT # IL S AGIT DES VECTEURS ELEMENTAIRES DONT LE TERME # AU NOEUD COURANT I EST EGAL A SOMME_SECTION(NI.DS) : __vecel = CALC_VECT_ELEM(CHARGE=__chart4, OPTION='CHAR_THER') # ON CALCULE LE MATR_ELEM DES MATRICES ELEMENTAIRES # DE CONDUCTIVITE UNIQUEMENT POUR GENERER LE NUME_DDL # SUR-LEQUEL S APPUIERA LE CHAMNO UTILISE POUR ECRIRE LA # RELATION LINEAIRE ENTRE DDLS : __matel = CALC_MATR_ELEM( MODELE=__nomot2, CHAM_MATER=__chmat2, CHARGE=__chart4, OPTION='RIGI_THER', ) # ON DEFINIT LE NUME_DDL ASSOCIE AU MATR_ELEM DEFINI # PRECEDEMMENT POUR CONSTRUIRE LE CHAMNO UTILISE POUR ECRIRE LA # RELATION LINEAIRE ENTRE DDLS : __numddl = NUME_DDL(MATR_RIGI=__matel, ) # ON CONSTRUIT LE CHAMNO QUI VA ETRE UTILISE POUR ECRIRE LA # RELATION LINEAIRE ENTRE DDLS : __chamno = ASSE_VECTEUR( VECT_ELEM=__vecel, NUME_DDL=__numddl, ) # ON IMPOSE LA RELATION LINEAIRE ENTRE DDLS # SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION # VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE # N = 0, N ETANT L EFFORT NORMAL) # POUR IMPOSER CETTE RELATION ON PASSE PAR LIAISON_CHAMNO, # LES TERMES DU CHAMNO (I.E. SOMME_SECTION(NI.DS)) # SONT LES COEFFICIENTS DE LA RELATION LINEAIRE : __chart5 = AFFE_CHAR_THER( MODELE=__nomot2, LIAISON_CHAMNO=_F(CHAM_NO=__chamno, COEF_IMPO=0.), ) # LE CHARGEMENT EST UN FLUX REPARTI NORMAL AU CONTOUR # DONT LES COMPOSANTES SONT +Z (I.E. +Y) ET -Y (I.E. -X) # SELON LA DIRECTION NORMALE AU CONTOUR : __chart6 = AFFE_CHAR_THER_F( MODELE=__nomot2, FLUX_REP=_F( GROUP_MA=GROUP_MA_BORD, FLUX_X=__fnsec4, FLUX_Y=__fnsec3, ), ) # RESOLUTION DE LAPLACIEN(OMEGA) = 0 # AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ SUR LE CONTOUR DE LA SECTION # ET SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION # VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE # N = 0, N ETANT L EFFORT NORMAL) : __tempe4 = THER_LINEAIRE( MODELE=__nomot2, CHAM_MATER=__chmat2, EXCIT=( _F(CHARGE=__chart5, ), _F(CHARGE=__chart6, ), ), SOLVEUR=_F( STOP_SINGULIER='NON', METHODE='LDLT', ), ) # CALCUL DE L INERTIE DE GAUCHISSEMENT : __tabtmp = POST_ELEM( MODELE=__nomot2, CHAM_MATER=__chmat2, CARA_POUTRE=_F(CARA_GEOM=__cacis, LAPL_PHI=__tempe4, TOUT='OUI', OPTION='CARA_GAUCHI'), ) # ================================================================== # = CALCUL DE LA CONSTANTE DE TORSION SUR CHAQUE GROUPE = # = ET DU RAYON DE TORSION SUR CHAQUE GROUPE = # = DU CENTRE DE TORSION/CISAILLEMENT = # = DES COEFFICIENTS DE CISAILLEMENT = # ================================================================== if GROUP_MA_BORD and GROUP_MA: # CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION : l_group_ma_bord = GROUP_MA_BORD l_group_ma = GROUP_MA l_noeud = None # if len(l_group_ma) != len(l_group_ma_bord): UTMESS('F', 'POUTRE0_1') # # les groupes doivent exister collgrma = aster.getcolljev('%-8s.GROUPEMA' % __nomlma.getName()) collgrma = list(map(lambda x: x.strip(), collgrma)) for igr in l_group_ma_bord: if (not igr.strip() in collgrma): UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_BORD']) # for igr in GROUP_MA: if (not igr.strip() in collgrma): UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA']) # if 'GROUP_MA_INTE' in args: if args.get('GROUP_MA_INTE') is not None: if type(args.get('GROUP_MA_INTE')) is str: l_group_ma_inte = [ args.get('GROUP_MA_INTE'), ] else: l_group_ma_inte = args.get('GROUP_MA_INTE') for igr in l_group_ma_inte: if (not igr.strip() in collgrma): UTMESS('F', 'POUTRE0_20', valk=[igr, 'GROUP_MA_INTE']) if args.get('NOEUD') is not None: l_noeud = list(map(lambda x: x.strip(), args['NOEUD'])) if (len(l_group_ma) != len(l_noeud)): UTMESS('F', 'POUTRE0_2') # Les noeuds doivent faire partie du maillage nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.getName()) nomnoe = list(map(lambda x: x.strip(), nomnoe)) for ino in l_noeud: if (not ino in nomnoe): UTMESS('F', 'POUTRE0_9', valk=ino) elif args.get('GROUP_NO') is not None: collgrno = aster.getcolljev('%-8s.GROUPENO' % __nomlma.getName()) nomnoe = aster.getvectjev('%-8s.NOMNOE' % __nomlma.getName()) l_nu_no = [] for grno in args.get('GROUP_NO'): try: l_nu_no.extend(collgrno[grno.ljust(24)]) except: UTMESS('F', 'POUTRE0_8', valk=grno) l_noeud = [nomnoe[no_i - 1] for no_i in l_nu_no] if (len(l_group_ma) != len(l_noeud)): UTMESS('F', 'POUTRE0_5') # Si len(l_group_ma_bord) > 1, alors il faut donner : 'LONGUEUR', 'MATERIAU', 'LIAISON' if (len(l_group_ma_bord) > 1): if (not args.get('LONGUEUR') or not args.get('MATERIAU') or not args.get('LIAISON')): UTMESS('F', 'POUTRE0_6') else: if (args.get('LONGUEUR') or args.get('MATERIAU') or args.get('LIAISON')): UTMESS('A', 'POUTRE0_7') __catp2 = __cageo for i in range(0, len(l_group_ma_bord)): # TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS # ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE : __nomlma = DEFI_GROUP(reuse=__nomlma, MAILLAGE=__nomlma, DETR_GROUP_NO=_F(NOM=l_group_ma_bord[i], ), CREA_GROUP_NO=_F( GROUP_MA=l_group_ma_bord[i], )) # CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES # QUE LES COORDONNEES SONT EXPRIMEES DANS LE REPERE PRINCIPAL # D INERTIE DONT L ORIGINE EST LE CENTRE DE GRAVITE DE LA SECTION : __nomapi = CREA_MAILLAGE( MAILLAGE=__nomlma, REPERE=_F( TABLE=__cageo, NOM_ORIG='CDG', GROUP_MA=l_group_ma[i], ), ) # AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE # LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE : __nomoth = AFFE_MODELE( MAILLAGE=__nomapi, AFFE=_F( GROUP_MA=l_group_ma[i], PHENOMENE='THERMIQUE', MODELISATION='PLAN', ), ) # POUR LA CONSTRUCTION DU LAPLACIEN, ON DEFINIT UN # PSEUDO-MATERIAU DONT LES CARACTERISTIQUES THERMIQUES SONT : # LAMBDA = 1, RHO*CP = 0 : __nomath = DEFI_MATERIAU(THER=_F( LAMBDA=1.0, RHO_CP=0.0, ), ) # DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT : __chmath = AFFE_MATERIAU( MAILLAGE=__nomapi, AFFE=_F(TOUT='OUI', MATER=__nomath), ) # CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION - # D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2 - # L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION : - # LAPLACIEN(PHI) = -2 DANS LA SECTION - # PHI = 0 SUR LE CONTOUR : - # # ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR # DE LA SECTION # ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION : __chart1 = AFFE_CHAR_THER( MODELE=__nomoth, TEMP_IMPO=_F(GROUP_NO=l_group_ma_bord[i], TEMP=0.0), SOURCE=_F(TOUT='OUI', SOUR=2.0), ) # RESOLUTION DE LAPLACIEN(PHI) = -2 # AVEC PHI = 0 SUR LE CONTOUR : __tempe1 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart1, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) # ---------------------------------------------- # CALCUL DU CENTRE DE TORSION/CISAILLEMENT # ET DES COEFFICIENTS DE CISAILLEMENT : # # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Y : __fnsec1 = DEFI_FONCTION( NOM_PARA='X', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) __fnsec0 = DEFI_CONSTANTE(VALE=0.0, ) # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION # DE LAPLACE EST PRIS EGAL A Y DANS TOUTE LA SECTION : __chart2 = AFFE_CHAR_THER_F( MODELE=__nomoth, TEMP_IMPO=_F(NOEUD=l_noeud[i], TEMP=__fnsec0), SOURCE=_F( TOUT='OUI', SOUR=__fnsec1, ), ) # RESOLUTION DE LAPLACIEN(PHI) = -Y # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe2 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart2, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) # POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR # UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE # PAR UNE FONCTION EGALE A Z : __fnsec2 = DEFI_FONCTION( NOM_PARA='Y', VALE=(0., 0., 10., 10.), PROL_DROITE='LINEAIRE', PROL_GAUCHE='LINEAIRE', ) # LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION # DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION : __chart3 = AFFE_CHAR_THER_F( MODELE=__nomoth, TEMP_IMPO=_F(NOEUD=l_noeud[i], TEMP=__fnsec0), SOURCE=_F( TOUT='OUI', SOUR=__fnsec2, ), ) # RESOLUTION DE LAPLACIEN(PHI) = -Z # AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR : __tempe3 = THER_LINEAIRE( MODELE=__nomoth, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart3, ), SOLVEUR=_F(STOP_SINGULIER='NON', ), ) # CALCUL DU RAYON DE TORSION : # CALCUL DU RAYON DE TORSION EXTERNE : rtext __tempe1 = CALC_CHAMP( reuse=__tempe1, RESULTAT=__tempe1, TOUT_ORDRE='OUI', THERMIQUE='FLUX_ELNO', ) __flun = MACR_LIGN_COUPE(RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=l_group_ma_bord[i], )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F(NOM=l_group_ma_bord[i], )) __m1 = abs(__flun['TRAC_NOR', 3]) __m2 = abs(__flun['TRAC_NOR', 4]) __rtext = max(__m1, __m2) # CALCUL DU RAYON DE TORSION : rt # rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) if 'GROUP_MA_INTE' in args: if args.get('GROUP_MA_INTE') is not None: if type(args.get('GROUP_MA_INTE')) is str: l_group_ma_inte = [ args.get('GROUP_MA_INTE'), ] else: l_group_ma_inte = args.get('GROUP_MA_INTE') for j in range(0, len(l_group_ma_inte)): __flun = MACR_LIGN_COUPE( RESULTAT=__tempe1, NOM_CHAM='FLUX_ELNO', LIGN_COUPE=_F( TYPE='GROUP_MA', MAILLAGE=__nomapi, TRAC_NOR='OUI', NOM_CMP=('FLUX', 'FLUY'), OPERATION='MOYENNE', INTITULE='FLUX_NORM', GROUP_MA=l_group_ma_inte[i], )) __nomapi = DEFI_GROUP(reuse=__nomapi, MAILLAGE=__nomapi, DETR_GROUP_NO=_F( NOM=l_group_ma_inte[i], )) __m1 = (abs(__flun['TRAC_NOR', 3]) + abs(__flun['TRAC_NOR', 4])) / 2.0 if __m1 > __rtext: __rtext = __m1 __rt = __rtext # CALCUL DE LA CONSTANTE DE TORSION : __catp1 = POST_ELEM( MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F(CARA_GEOM=__catp2, LAPL_PHI=__tempe1, RT=__rt, GROUP_MA=l_group_ma[i], OPTION='CARA_TORSION'), ) # CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU # CENTRE DE CISAILLEMENT/TORSION : if (len(l_group_ma_bord) > 1): __catp2 = POST_ELEM( MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F( CARA_GEOM=__catp1, LAPL_PHI_Y=__tempe2, LAPL_PHI_Z=__tempe3, GROUP_MA=l_group_ma[i], LONGUEUR=args.get('LONGUEUR'), MATERIAU=args.get('MATERIAU'), LIAISON=args.get('LIAISON'), OPTION='CARA_CISAILLEMENT', ), ) else: __nomtmp = DEFI_MATERIAU(ELAS=_F(E=1.0, NU=0.123, RHO=1.0), ) __catp2 = POST_ELEM( MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F( CARA_GEOM=__catp1, LAPL_PHI_Y=__tempe2, LAPL_PHI_Z=__tempe3, GROUP_MA=l_group_ma[i], LONGUEUR=123.0, MATERIAU=__nomtmp, LIAISON='ENCASTREMENT', OPTION='CARA_CISAILLEMENT', ), ) # # dprod = __catp2.EXTR_TABLE().dict_CREA_TABLE() # On remplace dans le TITRE le nom du concept __catp2.getName() par self.sd.getName() if ('TITRE' in list(dprod.keys())): conceptOld = __catp2.getName() # FIXME conceptNew = conceptOld #self.sd.getName() for ii in range(len(dprod['TITRE'])): zz = dprod['TITRE'][ii] if (conceptOld.strip() in zz): dprod['TITRE'][ii] = zz.replace(conceptOld.strip(), conceptNew.strip()) # dprod['TYPE_TABLE'] = 'TABLE_CONTAINER' __tabtmp = CREA_TABLE(**dprod) # if not GROUP_MA_BORD: __tabtmp = POST_ELEM(MODELE=__nomamo, CHAM_MATER=__nomama, CARA_GEOM=mfact) # # mise au propre de la table # # On enlève la ligne avec LIEU='-' et donc les colonnes TYPE_OBJET, NOM_SD # on utilise TYPE_TABLE pour forcer le type à table_sdaster et plus table_container nomres = CALC_TABLE( TABLE=__tabtmp, TYPE_TABLE='TABLE', ACTION=_F(OPERATION='FILTRE', NOM_PARA='LIEU', CRIT_COMP='NON_VIDE'), ) NomMaillageNew, NomMaillageOld = NomMaillage # Suppression de la référence à NomMaillageOld, remplacé par NOM = NomMaillageNew # Si TABLE_CARA == "OUI" et GROUP_MA la ligne est supprimée if not (TABLE_CARA == "OUI" and GROUP_MA): TabTmp = nomres.EXTR_TABLE() for ii in range(len(TabTmp.rows)): zz = TabTmp.rows[ii]['LIEU'] if (zz.strip() == NomMaillageOld): TabTmp.rows[ii]['LIEU'] = NomMaillageNew # TabTmp = TabTmp.dict_CREA_TABLE() else: # Une ligne avec LIEU=NomMaillageOld ==> on la supprime nomres = CALC_TABLE( reuse=nomres, TABLE=nomres, ACTION=_F(OPERATION='FILTRE', NOM_PARA='LIEU', CRIT_COMP='NE', VALE_K=NomMaillageOld), ) TabTmp = nomres.EXTR_TABLE().dict_CREA_TABLE() DETRUIRE(CONCEPT=_F(NOM=nomres), INFO=1) nomres = CREA_TABLE(**TabTmp) # # On retourne une table exploitable par AFFE_CARA_ELEM, avec seulement les # caractéristiques nécessaires if (TABLE_CARA == "OUI"): # if GROUP_MA_BORD and not GROUP_MA: nomres = CALC_TABLE( TABLE=nomres, reuse=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'AY', 'AZ', 'EY', 'EZ', 'JX', 'JG', 'IYR2', 'IZR2', 'RY', 'RZ', 'RT', 'ALPHA', 'CDG_Y', 'CDG_Z'), ), ), ) elif GROUP_MA_BORD and GROUP_MA: nomres = CALC_TABLE( TABLE=nomres, reuse=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'AY', 'AZ', 'EY', 'EZ', 'JX', 'IYR2', 'IZR2', 'RY', 'RZ', 'RT', 'ALPHA', 'CDG_Y', 'CDG_Z'), ), ), ) else: nomres = CALC_TABLE( TABLE=nomres, reuse=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=('LIEU', 'A', 'IY', 'IZ', 'IYR2', 'IZR2', 'RY', 'RZ', 'ALPHA', 'CDG_Y', 'CDG_Z'), ), ), ) # # Validation des résultats qui doivent toujours être >=0 TabTmp = nomres.EXTR_TABLE() for ii in range(len(TabTmp.rows)): ligne = TabTmp.rows[ii] # on recherche la bonne ligne if (ligne['LIEU'].strip() == NomMaillageNew): paras = TabTmp.para # Vérification des grandeurs qui doivent toujours rester positive Lparas = ( 'A', 'IY', 'IZ', 'AY', 'AZ', 'JX', 'JG', ) iergd = 0 for unpara in Lparas: if (unpara in paras): if (ligne[unpara] <= 0): iergd += 1 if (iergd != 0): if (not ImprTable): IMPR_TABLE(TABLE=nomres) ImprTable = True for unpara in Lparas: if (unpara in paras): if (ligne[unpara] <= 0): UTMESS('E', 'POUTRE0_10', valk=unpara, valr=ligne[unpara]) UTMESS('F', 'POUTRE0_11') # # Vérification que le CDG est l'origine du maillage cdgy = ligne['CDG_Y'] cdgz = ligne['CDG_Z'] dcdg = (cdgy * cdgy + cdgz * cdgz) / ligne['A'] if (dcdg > 1.0E-08): if (not ImprTable): IMPR_TABLE(TABLE=nomres) ImprTable = True UTMESS('A', 'POUTRE0_12', valr=[cdgy, cdgz]) # Vérification que la section n'est pas tournée alpha = ligne['ALPHA'] if (abs(alpha) > 0.001): if (not ImprTable): IMPR_TABLE(TABLE=nomres) ImprTable = True UTMESS('A', 'POUTRE0_13', valr=[alpha, -alpha]) # # On retourne une table contenant toutes les caractéristiques calculées else: if GROUP_MA_BORD and not GROUP_MA: nomres = CALC_TABLE( TABLE=nomres, reuse=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=( 'LIEU', 'ENTITE', 'A_M', 'CDG_Y_M', 'CDG_Z_M', 'IY_G_M', 'IZ_G_M', 'IYZ_G_M', 'Y_MAX', 'Z_MAX', 'Y_MIN', 'Z_MIN', 'R_MAX', 'A', 'CDG_Y', 'CDG_Z', 'IY_G', 'IZ_G', 'IYZ_G', 'IY', 'IZ', 'ALPHA', 'Y_P', 'Z_P', 'IY_P', 'IZ_P', 'IYZ_P', 'JX', 'AY', 'AZ', 'EY', 'EZ', 'PCTY', 'PCTZ', 'JG', 'KY', 'KZ', 'IYR2_G', 'IZR2_G', 'IYR2', 'IZR2', 'IYR2_P', 'IZR2_P', 'RY', 'RZ', 'RT', ), ), ), ) elif GROUP_MA_BORD and GROUP_MA: nomres = CALC_TABLE( TABLE=nomres, reuse=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=( 'LIEU', 'ENTITE', 'A_M', 'CDG_Y_M', 'CDG_Z_M', 'IY_G_M', 'IZ_G_M', 'IYZ_G_M', 'Y_MAX', 'Z_MAX', 'Y_MIN', 'Z_MIN', 'R_MAX', 'A', 'CDG_Y', 'CDG_Z', 'IY_G', 'IZ_G', 'IYZ_G', 'IY', 'IZ', 'ALPHA', 'Y_P', 'Z_P', 'IY_P', 'IZ_P', 'IYZ_P', 'JX', 'AY', 'AZ', 'EY', 'EZ', 'PCTY', 'PCTZ', 'KY', 'KZ', 'IYR2_G', 'IZR2_G', 'IYR2', 'IZR2', 'IYR2_P', 'IZR2_P', 'RY', 'RZ', 'RT', ), ), ), ) else: nomres = CALC_TABLE( TABLE=nomres, reuse=nomres, ACTION=(_F( OPERATION='EXTR', NOM_PARA=( 'LIEU', 'ENTITE', 'A_M', 'CDG_Y_M', 'CDG_Z_M', 'IY_G_M', 'IZ_G_M', 'IYZ_G_M', 'Y_MAX', 'Z_MAX', 'Y_MIN', 'Z_MIN', 'R_MAX', 'A', 'CDG_Y', 'CDG_Z', 'IY_G', 'IZ_G', 'IYZ_G', 'IY', 'IZ', 'ALPHA', 'Y_P', 'Z_P', 'IY_P', 'IZ_P', 'IYZ_P', 'IYR2_G', 'IZR2_G', 'IYR2', 'IZR2', 'IYR2_P', 'IZR2_P', 'RY', 'RZ', ), ), ), ) # if (not ImprTable): IMPR_TABLE(TABLE=nomres) # RetablirAlarme('CHARGES2_87') RetablirAlarme('CALCULEL_40') return nomres
def calc_spectre_ipm_ops( self, EQUIPEMENT, CALCUL, RESU, MAILLAGE=None, RESULTAT=None, GROUP_NO=None, AMOR_SPEC=None, LIST_INST=None, FREQ=None, LIST_FREQ=None, NORME=None, TOLE_INIT=None, CORR_INIT=None, **args): EnumType = (list, tuple) # On importe les definitions des commandes a utiliser dans la macro if AMOR_SPEC is not None and type(AMOR_SPEC) not in EnumType: AMOR_SPEC = (AMOR_SPEC,) # construction de la liste des noeuds à traiter planch_nodes = {} planch_param = {} if (MAILLAGE): dic_gpno = aster.getcolljev(MAILLAGE.getName().ljust(8) + ".GROUPENO") l_nodes = aster.getvectjev(MAILLAGE.getName().ljust(8) + ".NOMNOE") l_plancher = [] # dplancher = [] for j in EQUIPEMENT: dplancher.append(j.cree_dict_valeurs(j.mc_liste)) # for plancher in dplancher: liste_no = [] clefs = list(plancher.keys()) if 'NOEUD' in clefs: if plancher['NOEUD'] is not None: if type(plancher['NOEUD']) is str: liste_no.append(plancher['NOEUD']) else: for noeud in plancher['NOEUD']: liste_no.append(noeud) if ('GROUP_NO' in clefs): if plancher['GROUP_NO'] is not None: assert (MAILLAGE is not None) if type(plancher['GROUP_NO']) is str: noms_no = [l_nodes[n - 1].strip() for n in dic_gpno[plancher['GROUP_NO'].ljust(24)]] liste_no = liste_no + noms_no else: for group_no in plancher['GROUP_NO']: noms_no = [l_nodes[n - 1].strip() for n in dic_gpno[group_no.ljust(24)]] liste_no = liste_no + noms_no planch_nodes[plancher['NOM']] = liste_no l_plancher.append(plancher['NOM']) if plancher['AMOR_EQUIP'] is not None and type(plancher['AMOR_EQUIP']) not in EnumType: AMOR_EQUI = (plancher['AMOR_EQUIP'],) else: AMOR_EQUI = plancher['AMOR_EQUIP'] if plancher['AMOR_SUPPORT'] is not None and type(plancher['AMOR_SUPPORT']) not in EnumType: AMOR_SUPP = (plancher['AMOR_SUPPORT'],) else: AMOR_SUPP = plancher['AMOR_SUPPORT'] if plancher['RAPPORT_MASSE_TOTALE'] is not None and type(plancher['RAPPORT_MASSE_TOTALE']) not in EnumType: RAP_MAS = (plancher['RAPPORT_MASSE_TOTALE'],) else: RAP_MAS = plancher['RAPPORT_MASSE_TOTALE'] if plancher['FREQ_SUPPORT'] is not None and type(plancher['FREQ_SUPPORT']) not in EnumType: FREQ_SUPP = (plancher['FREQ_SUPPORT'],) else: FREQ_SUPP = plancher['FREQ_SUPPORT'] FREQ_EQUI = plancher['FREQ_EQUIP'] RAP_MAS_COEF = plancher['COEF_MASS_EQUIP'] # verification de la longueur des listes if (len(AMOR_EQUI) != len(FREQ_EQUI) or len(AMOR_EQUI) != len(RAP_MAS_COEF)): UTMESS('F', 'SPECTRAL0_14') # verification somme des rapport de masses pi = math.pi sum = NP.sum(RAP_MAS_COEF) if abs(sum - 1) > 1e-4: UTMESS('F', 'SPECTRAL0_15') planch_param[plancher['NOM']] = {'AMOR_EQUI': AMOR_EQUI, 'AMOR_SUPP': AMOR_SUPP[ 0], 'FREQ_EQUI': FREQ_EQUI, 'FREQ_SUPP': FREQ_SUPP[0], 'RAP_MAS_COEF': RAP_MAS_COEF, 'RAP_MAS': RAP_MAS[0]} dico_global = {} # --------------------------------------------------------------------------------------------- # boucle 1 sur les planchers for plancher in l_plancher: AMOR_EQUI = planch_param[plancher]['AMOR_EQUI'] AMOR_SUPP = planch_param[plancher]['AMOR_SUPP'] FREQ_EQUI = planch_param[plancher]['FREQ_EQUI'] FREQ_SUPP = planch_param[plancher]['FREQ_SUPP'] RAP_MAS_COEF = planch_param[plancher]['RAP_MAS_COEF'] RAP_MAS = planch_param[plancher]['RAP_MAS'] # ----------------------------------------------------------------------------------------- # boucle 2 sur les noeuds du plancher for node in planch_nodes[plancher]: # --------------------------------------------------------------------------------- # boucle 3 sur les résultats for resu in RESU : if resu['TABLE'] is not None : # 2 formats de table possible. Avec les colonnes : # INST NOEUD NOM_CHAM NOM_CMP VALE # INST NOEUD NOM_CHAM DX DY DZ # récupération du nom des colonnes de la table nomcol = resu['TABLE'].get_nom_para() # lst1 = ('INST','NOEUD','NOM_CHAM','NOM_CMP','VALE') ok1 = True for para in lst1: ok1 = ok1 and (para in nomcol) # lst2 = ('INST','NOEUD','NOM_CHAM','DZ',) ok2 = True for para in lst2: ok2 = ok2 and (para in nomcol) # if ( not ok1 ^ ok2 ): print(nomcol) assert (ok1 ^ ok2) # if ( ok1 ): __ACCE_E=RECU_FONCTION( TABLE=resu['TABLE'], PARA_X = 'INST', PARA_Y = 'VALE', INTERPOL= 'LIN', FILTRE = ( _F(NOM_PARA='NOEUD', VALE_K=node), _F(NOM_PARA='NOM_CHAM', VALE_K='ACCE' ), _F(NOM_PARA='NOM_CMP', VALE_K='DZ' ),), ) # if ( ok2 ): __ACCE_E=RECU_FONCTION( TABLE=resu['TABLE'], PARA_X = 'INST', PARA_Y = 'DZ', INTERPOL= 'LIN', FILTRE = ( _F(NOM_PARA='NOEUD', VALE_K=node), _F(NOM_PARA='NOM_CHAM', VALE_K='ACCE' ),), ) # Etape 2: Combinaisons if CALCUL=='RELATIF' : # Combinaison avec fonction d'accélération motscles={} if LIST_INST is not None : motscles['LIST_PARA']=LIST_INST __ACCE_E=CALC_FONCTION( COMB=( _F(FONCTION=__ACCE_E, COEF= 1.0 ), _F(FONCTION=resu['ACCE_Z'], COEF= 1.0),), **motscles ) val_Acc = NP.array( __ACCE_E.Ordo() ) init = abs(val_Acc[0])/max(abs(val_Acc)) if init>TOLE_INIT: if CORR_INIT=="OUI": UTMESS('A','SPECTRAL0_16', valr=(init, TOLE_INIT)) val_Acc[0]=0 __ACCE_E = DEFI_FONCTION(ABSCISSE =__ACCE_E.Absc(),ORDONNEE =val_Acc, NOM_PARA='INST' ) else: UTMESS('F','SPECTRAL0_16', valr=(init, TOLE_INIT)) freq1 = FREQ_SUPP # frequence modèle A omega1=freq1*2.*pi # frequence modèle B omega1_=omega1*(1+RAP_MAS)**0.5 # calcul de la fft de l'accelero d entree # methode 2: CALC_FONCTION pour FFT _FFTE = CALC_FONCTION(FFT = _F(FONCTION = __ACCE_E, METHODE='COMPLET')) FFT = NP.array(_FFTE.Ordo()) +complex(0.,1.)*NP.array(_FFTE.OrdoImg()) X = NP.array(_FFTE.Valeurs()[0]) # RES=[] cNum = [0]*len(FFT) cDenom = [0]*len(FFT) # boucle 4 sur les equipements for i in range(len(FREQ_EQUI)): omega = FREQ_EQUI[i]*2.*pi Delta = -(2.*pi*X[0:len(FFT)])**2 + 2.*complex(0.,1.)*2.*pi*X[0:len(FFT)]*omega*AMOR_EQUI[i] + omega**2 cNum = cNum + RAP_MAS*RAP_MAS_COEF[i]*(Delta+(2.*pi*X[0:len(FFT)])**2)/Delta cDenom = cDenom + RAP_MAS*RAP_MAS_COEF[i]*(Delta+(2.*pi*X[0:len(FFT)])**2) - RAP_MAS*RAP_MAS_COEF[i]*(Delta+(2.*pi*X[0:len(FFT)])**2)**2/Delta # Modele B Delta1_ = -(2.*pi*X[0:len(FFT)])**2 + 2.*complex(0.,1.)*2.*pi*X[0:len(FFT)]*omega1_*AMOR_SUPP*(1+RAP_MAS)**0.5 + omega1_**2 # Modele A Delta1 = -(2.*pi*X[0:len(FFT)])**2 + 2.*complex(0.,1.)*2.*pi*X[0:len(FFT)]*omega1*AMOR_SUPP + omega1**2 # Calcul de la fonction de transfert c = (1.+(2.*pi*X[0:len(FFT)])**2*( 1 + cNum)/(Delta1_ + cDenom))/(1+(2.*pi*X[0:len(FFT)])**2/Delta1) RES = FFT*c # # methode 2: CALC_FONCTION pour FFT val_c=[] for i in range(len(X)//2): val_c+=[X[i],RES[i].real,RES[i].imag] __FRESULT = DEFI_FONCTION(VALE_C =val_c, NOM_PARA='FREQ' ) __ACCEAcor = CALC_FONCTION(FFT = _F(FONCTION = __FRESULT, METHODE='COMPLET', SYME='NON')) # # calcul de spectres corriges motscles={} if FREQ is not None : motscles['FREQ'] =FREQ if LIST_FREQ is not None : motscles['LIST_FREQ']=LIST_FREQ __Spec=[None]*len(AMOR_SPEC) for amor in range(len(AMOR_SPEC)): # eviter la boucle ?? __Spec[amor] = CALC_FONCTION( SPEC_OSCI = _F( FONCTION = __ACCEAcor, AMOR_REDUIT = AMOR_SPEC[amor], NORME = NORME , **motscles) , NOM_PARA='FREQ', ) #**************************************************** dico_global['FREQ ' + plancher] = Valeurs(__Spec[amor])[1][0][0] for amor in range(len(AMOR_SPEC)): if len(planch_nodes[plancher])>1: nom = 'IPM '+ plancher + ' ' +node + ' ' + str(int(AMOR_SPEC[amor]*100)) + '%' else: nom = 'IPM '+ plancher + ' ' + str(int(AMOR_SPEC[amor]*100)) + '%' dico_global[nom] = Valeurs(__Spec[amor])[1][0][1] lListe = [] lkeys = list(dico_global.keys()) lkeys.sort() for key in lkeys: lListe.append(_F(LISTE_R=dico_global[key], PARA=key)) tab = CREA_TABLE( LISTE=lListe, TITRE='Calcul des spectres avec IPM' + '\n #') return tab
def macr_lign_coupe_ops(self, RESULTAT, CHAM_GD, UNITE_MAILLAGE, LIGN_COUPE, NOM_CHAM, MODELE, **args): """ Ecriture de la macro MACR_LIGN_COUPE """ from code_aster.Cata.Syntax import _F from Noyau.N_utils import AsType import aster import math from Utilitai.UniteAster import UniteAster from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme ier = 0 # On importe les definitions des commandes a utiliser dans la macro LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE') DEFI_GROUP = self.get_cmd('DEFI_GROUP') AFFE_MODELE = self.get_cmd('AFFE_MODELE') PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') CREA_TABLE = self.get_cmd('CREA_TABLE') CREA_RESU = self.get_cmd('CREA_RESU') COPIER = self.get_cmd('COPIER') # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # MasquerAlarme('ALGORITH12_43') MasquerAlarme('CALCULEL2_63') MasquerAlarme('CALCULEL2_64') MasquerAlarme('MODELISA5_53') MasquerAlarme('MODELE1_58') MasquerAlarme('MODELE1_63') MasquerAlarme('MODELE1_64') mcORDR = {} l_mode_meca_sans_modele = False if RESULTAT != None: if args['NUME_ORDRE'] != None: mcORDR['NUME_ORDRE'] = args['NUME_ORDRE'] elif args['NUME_MODE'] != None: mcORDR['NUME_MODE'] = args['NUME_MODE'] elif args['LIST_ORDRE'] != None: mcORDR['LIST_ORDRE'] = args['LIST_ORDRE'] elif args['INST'] != None: mcORDR['INST'] = args['INST'] elif args['INST'] != None: mcORDR['INST'] = args['INST'] elif args['LIST_INST'] != None: mcORDR['LIST_INST'] = args['LIST_INST'] else: mcORDR['TOUT_ORDRE'] = 'OUI' nomresu = RESULTAT.nom type_resu = AsType(RESULTAT).__name__ iret, ibid, n_modele = aster.dismoi('MODELE', nomresu, 'RESULTAT', 'F') n_modele = n_modele.strip() if n_modele in ('', '#AUCUN'): if MODELE == None: if (type_resu != 'mode_meca'): UTMESS('F', 'POST0_9', valk=nomresu) # si le résultat en entrée est un mode_meca et qu'il ne contient pas de modèle (il est obtenu par sous-structuration, par exemple) # on passe le message fatal et on récupérera directement le # maillage (ou squelette) else: l_mode_meca_sans_modele = True UTMESS('I', 'POST0_23', valk=nomresu) else: n_modele = MODELE.nom iret, ibid, l_mailla = aster.dismoi( 'NOM_MAILLA', nomresu, 'RESULTAT', 'F') elif CHAM_GD != None: mcORDR['TOUT_ORDRE'] = 'OUI' if MODELE == None: UTMESS('F', 'POST0_10') else: n_modele = MODELE.nom # récupération de la grandeur du champ n_cham = CHAM_GD.nom catagd = aster.getvectjev("&CATA.GD.NOMGD") desc = aster.getvectjev('%-19s.DESC' % n_cham) if desc != None: nomgd = catagd[desc[0] - 1] else: celd = aster.getvectjev('%-19s.CELD' % n_cham) nomgd = catagd[celd[0] - 1] # détermination du type de résultat à créer if nomgd[:6] == 'TEMP_R': TYPE_RESU = 'EVOL_THER' if not NOM_CHAM: NOM_CHAM = 'TEMP' elif nomgd[:6] == 'DEPL_R': TYPE_RESU = 'EVOL_ELAS' if not NOM_CHAM: NOM_CHAM = 'DEPL' elif nomgd[:6] == 'NEUT_R': TYPE_RESU = 'EVOL_VARC' if not NOM_CHAM: NOM_CHAM = 'NEUT' elif nomgd[:6] == 'EPSI_R': TYPE_RESU = 'EVOL_ELAS' elif nomgd[:6] == 'VAR2_R': TYPE_RESU = 'EVOL_NOLI' elif nomgd[:6] == 'VARI_R': TYPE_RESU = 'EVOL_NOLI' elif nomgd[:6] == 'SIEF_R': if not NOM_CHAM: TYPE_RESU = 'EVOL_ELAS' NOM_CHAM = 'DEPL' elif NOM_CHAM[:4] == 'SIGM': TYPE_RESU = 'EVOL_ELAS' elif NOM_CHAM[:4] == 'SIEF': TYPE_RESU = 'EVOL_NOLI' else: assert 0, 'grandeur imprevue : ' + nomgf # création d'un concept résultat à partir du champ CHAM_GD __resuch = CREA_RESU(OPERATION='AFFE', NOM_CHAM=NOM_CHAM, TYPE_RESU=TYPE_RESU, AFFE=_F(CHAM_GD=CHAM_GD, INST=0.),) RESULTAT = __resuch iret, ibid, l_mailla = aster.dismoi('NOM_MAILLA', n_cham, 'CHAMP', 'F') # Maillage sur lequel s'appuie le résultat à projeter n_mailla = l_mailla.strip() # le maillage est-il 2D ou 3D ? iret, dime, kbid = aster.dismoi('DIM_GEOM', n_mailla, 'MAILLAGE', 'F') collgrma = aster.getcolljev(n_mailla.ljust(8) + '.GROUPEMA') typma = aster.getvectjev(n_mailla.ljust(8) + '.TYPMAIL') connex = aster.getcolljev(n_mailla.ljust(8) + '.CONNEX') ltyma = aster.getvectjev("&CATA.TM.NOMTM") lignes = [] groups = [] arcs = [] minidim = dime for m in LIGN_COUPE: if m['TYPE'] == 'SEGMENT': lignes.append((m['COOR_ORIG'], m['COOR_EXTR'], m['NB_POINTS'])) minidim = min(minidim, len(m['COOR_ORIG']), len(m['COOR_EXTR'])) if minidim != dime: UTMESS('F', 'POST0_11') elif m['TYPE'] == 'ARC': minidim = min(minidim, len(m['COOR_ORIG']), len(m['CENTRE'])) if minidim != dime: UTMESS('F', 'POST0_11') if dime == 2: arcs.append( (m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'],)) elif dime == 3: if str(m['DNOR']) == 'None': UTMESS('F', 'POST0_12') arcs.append( (m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'], m['DNOR'])) elif m['TYPE'] == 'GROUP_NO': ngrno = m['GROUP_NO'].ljust(24) collgrno = aster.getcolljev(n_mailla.ljust(8) + '.GROUPENO') if ngrno not in collgrno.keys(): UTMESS('F', 'POST0_13', valk=[ngrno, n_mailla]) grpn = collgrno[ngrno] l_coor_group = [ngrno, ] for node in grpn: l_coor_group.append( aster.getvectjev(n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3)) groups.append(l_coor_group) elif m['TYPE'] == 'GROUP_MA': ngrma = m['GROUP_MA'].ljust(24) if ngrma not in collgrma.keys(): UTMESS('F', 'POST0_14', valk=[ngrma, n_mailla]) grpm = collgrma[ngrma] for ma in grpm: if ltyma[typma[ma - 1] - 1][:3] != 'SEG': nomma = aster.getvectjev(n_mailla.ljust(8) + '.NOMMAI') UTMESS('F', 'POST0_15', valk=[ngrma, nomma[ma - 1]]) __mailla = COPIER(CONCEPT=m['MAILLAGE']) m2 = m.cree_dict_valeurs(m.mc_liste) argsup = {} if m2.get('GROUP_NO_ORIG'): argsup['GROUP_NO_ORIG'] = m2.get('GROUP_NO_ORIG') if m2.get('GROUP_NO_EXTR'): argsup['GROUP_NO_EXTR'] = m2.get('GROUP_NO_EXTR') if m2.get('NOEUD_ORIG'): argsup['NOEUD_ORIG'] = m2.get('NOEUD_ORIG') if m2.get('NOEUD_EXTR'): argsup['NOEUD_EXTR'] = m2.get('NOEUD_EXTR') if m2.get('VECT_ORIE'): argsup['VECT_ORIE'] = m2.get('VECT_ORIE') __mailla = DEFI_GROUP(reuse=__mailla, MAILLAGE=__mailla, DETR_GROUP_NO=_F(NOM=str(m['GROUP_MA'])), CREA_GROUP_NO=_F(OPTION='NOEUD_ORDO', NOM=str(m['GROUP_MA']), GROUP_MA=m['GROUP_MA'], ORIGINE='SANS', **argsup)) collgrno = aster.getcolljev(__mailla.nom.ljust(8) + '.GROUPENO') grpn = collgrno[str(m['GROUP_MA']).ljust(24)] l_coor_group = [ngrma, ] for node in grpn: l_coor_group.append( aster.getvectjev(n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3)) groups.append(l_coor_group) if arcs != [] and (lignes != [] or groups != []): UTMESS('F', 'POST0_16') # Création du maillage des NB_POINTS segments entre COOR_ORIG et COOR_EXTR # ainsi que des segments reliant les noeuds issus des group_no demandés # par appel au script python crea_mail_lig_coup # le maillage est ensuite recopié dans l unité logique UNITE_MAILLAGE resu_mail, arcgma, angles, nbno = crea_mail_lig_coup( dime, lignes, groups, arcs) UL = UniteAster() nomFichierSortie = UL.Nom(UNITE_MAILLAGE) fproc = open(nomFichierSortie, 'w') fproc.write(os.linesep.join(resu_mail)) fproc.close() UL.EtatInit(UNITE_MAILLAGE) # Lecture du maillage de seg2 contenant toutes les lignes de coupe __macou = LIRE_MAILLAGE(FORMAT='ASTER',UNITE=UNITE_MAILLAGE,) # distance min entre 2 points de la ligne de coupe (utile pour PROJ_CHAMP) dmin = dist_min_deux_points(__macou) motscles = {} iocc = 1 motscles['CREA_GROUP_NO'] = [] for m in LIGN_COUPE: if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'): motscles['CREA_GROUP_NO'].append( _F(GROUP_MA=m[m['TYPE']].ljust(24),)) else: motscles['CREA_GROUP_NO'].append(_F(GROUP_MA='LICOU' + str(iocc),)) iocc = iocc + 1 __macou = DEFI_GROUP(reuse=__macou, MAILLAGE=__macou, **motscles) if AsType(RESULTAT).__name__ in ('evol_elas', 'evol_noli', 'mode_meca', 'comb_fourier', 'mult_elas', 'fourier_elas'): __mocou = AFFE_MODELE(MAILLAGE=__macou, AFFE=_F(TOUT='OUI', PHENOMENE='MECANIQUE', MODELISATION='BARRE',), DISTRIBUTION=_F(METHODE='CENTRALISE'), ) elif AsType(RESULTAT).__name__ in ('evol_ther', 'evol_varc',): __mocou = AFFE_MODELE(MAILLAGE=__macou, AFFE=_F(TOUT='OUI', PHENOMENE='THERMIQUE', MODELISATION='PLAN',),) motscles = {} motscles['VIS_A_VIS'] = [] motscles[mcORDR.keys()[0]] = mcORDR.values()[0] if args['VIS_A_VIS'] != None: for v in args['VIS_A_VIS']: if v['GROUP_MA_1'] != None: motscles['VIS_A_VIS'].append( _F(GROUP_MA_1=v['GROUP_MA_1'], TOUT_2='OUI'),) elif v['MAILLE_1'] != None: motscles['VIS_A_VIS'].append( _F(MAILLE_1=v['MAILLE_1'], TOUT_2='OUI'),) if NOM_CHAM[5:9] == 'ELGA': UTMESS('A', 'POST0_18', valk=[NOM_CHAM, ]) if (l_mode_meca_sans_modele == False): # on utilise le modèle pour projeter le champ if n_modele in self.get_global_contexte().keys(): MODELE_1 = self.get_global_contexte()[n_modele] else: MODELE_1 = self.jdc.current_context[n_modele] __recou = PROJ_CHAMP(METHODE='COLLOCATION', RESULTAT=RESULTAT, MODELE_1=MODELE_1, DISTANCE_MAX=m['DISTANCE_MAX'], MODELE_2=__mocou, TYPE_CHAM='NOEU', NOM_CHAM=NOM_CHAM, **motscles) else: # on utilise directement le maillage (ou squelette) pour projeter le # champ if n_mailla in self.get_global_contexte().keys(): MAILLAGE_1 = self.get_global_contexte()[n_mailla] else: MAILLAGE_1 = self.jdc.current_context[n_mailla] __recou = PROJ_CHAMP(METHODE='COLLOCATION', RESULTAT=RESULTAT, MAILLAGE_1=MAILLAGE_1, DISTANCE_MAX=m['DISTANCE_MAX'], MODELE_2=__mocou, TYPE_CHAM='NOEU', NOM_CHAM=NOM_CHAM, **motscles) __remodr = __recou icham = 0 ioc2 = 0 mcACTION = [] angtab = [] if AsType(RESULTAT).__name__ in ('evol_ther', 'evol_elas', 'evol_noli', 'mode_meca', 'evol_varc', 'comb_fourier', 'mult_elas', 'fourier_elas'): if NOM_CHAM in ('DEPL', 'SIEF_ELNO', 'SIGM_NOEU', 'SIGM_ELNO', 'FLUX_ELNO', 'FLUX_NOEU'): icham = 1 iocc = 0 for m in LIGN_COUPE: iocc = iocc + 1 motscles = {} motscles['OPERATION'] = m['OPERATION'] if m['NOM_CMP'] != None: motscles['NOM_CMP'] = m['NOM_CMP'] if m['TRAC_NOR'] != None: motscles['TRAC_NOR'] = m['TRAC_NOR'] elif m['TRAC_DIR'] != None: motscles['TRAC_DIR'] = m['TRAC_DIR'] motscles['DIRECTION'] = m['DIRECTION'] elif m['INVARIANT'] != None: motscles['INVARIANT'] = m['INVARIANT'] elif m['RESULTANTE'] != None: motscles['RESULTANTE'] = m['RESULTANTE'] elif m['ELEM_PRINCIPAUX'] != None: motscles['ELEM_PRINCIPAUX'] = m['ELEM_PRINCIPAUX'] else: motscles['TOUT_CMP'] = 'OUI' # on définit le groupe de noeud pour post_releve_t if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'): groupe = m[m['TYPE']].ljust(8) nomgrma = groupe else: ioc2 = ioc2 + 1 groupe = 'LICOU' + str(ioc2) nomgrma = ' ' newgrp = 'LICOF' + str(ioc2) crea_grp_matiere( self, groupe, newgrp, iocc, m, __remodr, NOM_CHAM, LIGN_COUPE, __macou) groupe = newgrp # on definit l'intitulé if m['INTITULE'] != None: intitl = m['INTITULE'] elif m['TYPE'] in ('GROUP_NO', 'GROUP_MA'): intitl = groupe else: intitl = 'l.coupe' + str(ioc2) # Expression des contraintes aux noeuds ou des déplacements dans le # repere local if m['REPERE'] != 'GLOBAL': if icham == 1: if m['REPERE'] == 'POLAIRE': mcACTION.append(_F(INTITULE=intitl, RESULTAT=__remodr, REPERE=m['REPERE'], GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles),) else: __remodr = crea_resu_local( self, dime, NOM_CHAM, m, __recou, __macou, nomgrma) mcACTION.append(_F(INTITULE=intitl, RESULTAT=__remodr, GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles),) else: UTMESS('A', 'POST0_17', valk=[NOM_CHAM, m['REPERE']]) mcACTION.append(_F(INTITULE=intitl, RESULTAT=__recou, GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles),) # Expression des contraintes aux noeuds ou des déplacements dans le # repere global else: mcACTION.append(_F(INTITULE=intitl, RESULTAT=__recou, GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles),) else: assert 0 __tabitm = POST_RELEVE_T(ACTION=mcACTION,) # on repasse par les tables python pour supprimer les paramètres inutiles # NOEUD (car il est propre au maillage de la ligne) et RESU self.DeclareOut('nomres', self.sd) dictab = __tabitm.EXTR_TABLE() # Ajout de la colonne theta if len(arcgma) > 0: coltab = [] val = dictab['ABSC_CURV'].values()['ABSC_CURV'] nbi = len(val) / nbno nba = len(angles) tmp = [] for k in range(nba): for j in range(nbi): for i in range(len(angles[k])): tmp.append(angles[k][i]) dictab['ANGLE'] = tmp if 'RESU' in dictab.para: del dictab['RESU'] if 'NOEUD' in dictab.para: del dictab['NOEUD'] dprod = dictab.dict_CREA_TABLE() nomres = CREA_TABLE(**dprod) RetablirAlarme('ALGORITH12_43') RetablirAlarme('CALCULEL2_63') RetablirAlarme('CALCULEL2_64') RetablirAlarme('MODELISA5_53') RetablirAlarme('MODELE1_58') RetablirAlarme('MODELE1_63') RetablirAlarme('MODELE1_64') return ier
def crea_resu_local(self, dime, NOM_CHAM, m, resin, mail, nomgrma): from Utilitai.Utmess import UTMESS from math import pi, sqrt, atan2, asin import aster from code_aster.Cata.Syntax import _F MODI_REPERE = self.get_cmd('MODI_REPERE') epsi = 0.00000001 if NOM_CHAM == 'DEPL': if dime == 2: LCMP = ['DX', 'DY'] TYPE_CHAM = 'VECT_2D' elif dime == 3: LCMP = ['DX', 'DY', 'DZ'] TYPE_CHAM = 'VECT_3D' elif NOM_CHAM in ('SIGM_NOEU', 'SIEF_ELNO', 'SIGM_ELNO'): if dime == 2: LCMP = ['SIXX', 'SIYY', 'SIZZ', 'SIXY'] TYPE_CHAM = 'TENS_2D' elif dime == 3: LCMP = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ'] TYPE_CHAM = 'TENS_3D' elif NOM_CHAM in ('FLUX_ELNO', 'FLUX_NOEU',): if dime == 2: LCMP = ['FLUX', 'FLUY', ] TYPE_CHAM = 'VECT_2D' elif dime == 3: LCMP = ['FLUX', 'FLUY', 'FLUZ', ] TYPE_CHAM = 'VECT_3D' else: assert 0 else: assert 0 if m['TYPE'] == 'SEGMENT' and m['REPERE'] != 'CYLINDRIQUE': if m['REPERE'] == 'LOCAL': # --- determination des angles nautiques cx1 = m['COOR_EXTR'][0] - m['COOR_ORIG'][0] cx2 = m['COOR_EXTR'][1] - m['COOR_ORIG'][1] cx3 = 0. if dime == 3: cx3 = m['COOR_EXTR'][2] - m['COOR_ORIG'][2] nvx = sqrt(cx1 ** 2 + cx2 ** 2 + cx3 ** 2) if abs(nvx) < epsi: UTMESS('F', 'POST0_1') cx1 = cx1 / nvx cx2 = cx2 / nvx cx3 = cx3 / nvx if m['VECT_Y']: cy1 = m['VECT_Y'][0] cy2 = m['VECT_Y'][1] cy3 = 0. if dime == 3: cy3 = m['VECT_Y'][2] else: UTMESS('F', 'POST0_50') nvy = sqrt(cy1 ** 2 + cy2 ** 2 + cy3 ** 2) if abs(nvy) < epsi: UTMESS('F', 'POST0_2') cy1 = cy1 / nvy cy2 = cy2 / nvy cy3 = cy3 / nvy if ((abs(cx1 - cy1) < epsi and abs(cx2 - cy2) < epsi and abs(cx3 - cy3) < epsi) or (abs(cx1 + cy1) < epsi and abs(cx2 + cy2) < epsi and abs(cx3 + cy3) < epsi)): UTMESS('F', 'POST0_3') if abs(cx1 * cy1 + cx2 * cy2 + cx3 * cy3) > epsi: cz1 = cx2 * cy3 - cx3 * cy2 cz2 = cx3 * cy1 - cx1 * cy3 cz3 = cx1 * cy2 - cx2 * cy1 nvz = sqrt(cz1 ** 2 + cz2 ** 2 + cz3 ** 2) cz1 = cz1 / nvz cz2 = cz2 / nvz cz3 = cz3 / nvz cy1 = cz2 * cx3 - cz3 * cx2 cy2 = cz3 * cx1 - cz1 * cx3 cy3 = cz1 * cx2 - cz2 * cx1 nvy = sqrt(cy1 ** 2 + cy2 ** 2 + cy3 ** 2) cy1 = cy1 / nvy cy2 = cy2 / nvy cy3 = cy3 / nvy UTMESS('A', 'POST0_4', valr=[cy1, cy2, cy3]) else: cz1 = cx2 * cy3 - cx3 * cy2 cz2 = cx3 * cy1 - cx1 * cy3 cz3 = cx1 * cy2 - cx2 * cy1 beta = 0. gamma = 0. if dime == 2: alpha = atan2(cx2, cx1) else: if cx1 ** 2 + cx2 ** 2 > epsi: alpha = atan2(cx2, cx1) beta = -asin(cx3) gamma = atan2(cy3, cz3) else: alpha = atan2(-cy1, cy2) beta = -asin(cx3) gamma = 0. alpha = alpha * 180 / pi beta = beta * 180 / pi gamma = gamma * 180 / pi elif m['REPERE'] == 'UTILISATEUR': alpha = m['ANGL_NAUT'][0] beta = m['ANGL_NAUT'][1] gamma = m['ANGL_NAUT'][2] motscles = {} motscles['MODI_CHAM'] = [] motscles['AFFE'] = [] motscles['MODI_CHAM'].append( _F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM),) ANGL_NAUT = [] ANGL_NAUT.append(alpha) if dime == 3: ANGL_NAUT.append(beta) ANGL_NAUT.append(gamma) motscles['AFFE'].append(_F(ANGL_NAUT=ANGL_NAUT),) __remodr = MODI_REPERE( RESULTAT=resin, REPERE='UTILISATEUR', **motscles) if m['TYPE'] == 'ARC': if m['REPERE'] == 'CYLINDRIQUE': motscles = {} motscles['MODI_CHAM'] = [] motscles['AFFE'] = [] motscles['MODI_CHAM'].append( _F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM),) ORIGINE = [] ORIGINE.append(m['CENTRE'][0]) ORIGINE.append(m['CENTRE'][1]) if dime == 3: ORIGINE.append(m['CENTRE'][2]) AXE_Z = [] AXE_Z.append(m['DNOR'][0]) AXE_Z.append(m['DNOR'][1]) AXE_Z.append(m['DNOR'][2]) motscles['AFFE'].append(_F(ORIGINE=ORIGINE, AXE_Z=AXE_Z),) elif dime == 2: motscles['AFFE'].append(_F(ORIGINE=ORIGINE,),) __remodr = MODI_REPERE( RESULTAT=resin, REPERE='CYLINDRIQUE', **motscles) else: UTMESS('F', 'POST0_5', valk=[m['TYPE'], m['REPERE']]) if m['TYPE'][:5] == 'GROUP' or m['TYPE'] == 'SEGMENT': if m['TYPE'][:5] == 'GROUP' and m['REPERE'] == 'LOCAL': # determination du repère local (v1,v2,v3) # --------------------------------------- noma = mail.nom collgrma = aster.getcolljev(noma.ljust(8) + '.GROUPEMA') collcnx = aster.getcolljev(noma.ljust(8) + '.CONNEX') coord = aster.getvectjev(noma.ljust(8) + '.COORDO .VALE') cnom = aster.getvectjev(noma.ljust(8) + '.NOMNOE') numa = collgrma[nomgrma.ljust(24)] dictu = {} # initialisations for ima in numa: n1 = collcnx[ima][0] n2 = collcnx[ima][1] dictu[n1] = [] dictu[n2] = [] # determination du vecteur tangent (v1) + normalisation for ima in numa: vectu1 = [] vectu2 = [] n1 = collcnx[ima][0] n2 = collcnx[ima][1] ux = coord[3 * (n2 - 1)] - coord[3 * (n1 - 1)] uy = coord[3 * (n2 - 1) + 1] - coord[3 * (n1 - 1) + 1] vectu1.append(ux) vectu1.append(uy) vectu2.append(ux) vectu2.append(uy) if dime == 3: uz = coord[3 * (n2 - 1) + 2] - coord[3 * (n1 - 1) + 2] vectu1.append(uz) vectu2.append(uz) dictu[n1].append(vectu1) dictu[n2].append(vectu2) for i in dictu: if len(dictu[i]) == 2: dictu[i][0][0] = dictu[i][0][0] + dictu[i][1][0] dictu[i][0][1] = dictu[i][0][1] + dictu[i][1][1] if dime == 3: dictu[i][0][2] = dictu[i][0][2] + dictu[i][1][2] del dictu[i][1] for i in dictu: if dime == 2: norm = sqrt(dictu[i][0][0] ** 2 + dictu[i][0][1] ** 2) dictu[i][0][0] = dictu[i][0][0] / norm dictu[i][0][1] = dictu[i][0][1] / norm elif dime == 3: norm = sqrt( dictu[i][0][0] ** 2 + dictu[i][0][1] ** 2 + dictu[i][0][2] ** 2) dictu[i][0][0] = dictu[i][0][0] / norm dictu[i][0][1] = dictu[i][0][1] / norm dictu[i][0][2] = dictu[i][0][2] / norm # determination du vecteur normal (v2): # on projete VECT_Y sur le plan orthogonal au vecteur v1. # (ce vecteur normal est obtenu par 2 produits vectoriels successifs en 3D) if dime == 3: norm = sqrt(m['VECT_Y'][0] ** 2 + m[ 'VECT_Y'][1] ** 2 + m['VECT_Y'][2] ** 2) tmpy = [m['VECT_Y'][0] / norm, m[ 'VECT_Y'][1] / norm, m['VECT_Y'][2] / norm] j = 0 __resu = [None] * (len(dictu) + 1) __resu[0] = resin for i in dictu: j = j + 1 vecty = [] if dime == 2: vecty.append(-dictu[i][0][1]) vecty.append(dictu[i][0][0]) dictu[i].append(vecty) elif dime == 3: # v3= v1 vectoriel vect_y vectz = [] vectz.append( dictu[i][0][1] * tmpy[2] - dictu[i][0][2] * tmpy[1]) vectz.append( dictu[i][0][2] * tmpy[0] - dictu[i][0][0] * tmpy[2]) vectz.append( dictu[i][0][0] * tmpy[1] - dictu[i][0][1] * tmpy[0]) normz = sqrt(vectz[0] ** 2 + vectz[1] ** 2 + vectz[2] ** 2) vectz[0] = vectz[0] / normz vectz[1] = vectz[1] / normz vectz[2] = vectz[2] / normz vecty.append( vectz[1] * dictu[i][0][2] - vectz[2] * dictu[i][0][1]) vecty.append( vectz[2] * dictu[i][0][0] - vectz[0] * dictu[i][0][2]) vecty.append( vectz[0] * dictu[i][0][1] - vectz[1] * dictu[i][0][0]) normy = sqrt(vecty[0] ** 2 + vecty[1] ** 2 + vecty[2] ** 2) vecty[0] = vecty[0] / normy vecty[1] = vecty[1] / normy vecty[2] = vecty[2] / normy dictu[i].append(vecty) dictu[i].append(vectz) cx1 = dictu[i][0][0] cx2 = dictu[i][0][1] cy1 = dictu[i][1][0] cy2 = dictu[i][1][1] if dime == 3: cx3 = dictu[i][0][2] cy3 = dictu[i][1][2] cz1 = dictu[i][2][0] cz2 = dictu[i][2][1] cz3 = dictu[i][2][2] # determination des angles nautiques (alpha,beta,gamma) # ---------------------------------------------------- beta = 0. gamma = 0. if dime == 2: alpha = atan2(cx2, cx1) else: if cx1 ** 2 + cx2 ** 2 > epsi: alpha = atan2(cx2, cx1) beta = -asin(cx3) gamma = atan2(cy3, cz3) else: alpha = atan2(-cy1, cy2) beta = -asin(cx3) gamma = 0. alpha = alpha * 180 / pi beta = beta * 180 / pi gamma = gamma * 180 / pi motscles = {} motscles['MODI_CHAM'] = [] motscles['AFFE'] = [] noeu = dictu.keys() motscles['MODI_CHAM'].append( _F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM,),) ANGL_NAUT = [] ANGL_NAUT.append(alpha) if dime == 3: ANGL_NAUT.append(beta) ANGL_NAUT.append(gamma) motscles['AFFE'].append( _F(ANGL_NAUT=ANGL_NAUT, NOEUD=cnom[noeu[j - 1] - 1]),) __resu[j] = MODI_REPERE( RESULTAT=__resu[j - 1], REPERE='UTILISATEUR', **motscles) __remodr = __resu[j] motscles = {} motscles['MODI_CHAM'] = [] motscles['AFFE'] = [] motscles['MODI_CHAM'].append( _F(NOM_CHAM=NOM_CHAM, NOM_CMP=LCMP, TYPE_CHAM=TYPE_CHAM),) if m['REPERE'] == 'CYLINDRIQUE': if dime == 3: motscles['AFFE'].append( _F(ORIGINE=m['ORIGINE'], AXE_Z=m['AXE_Z']),) elif dime == 2: motscles['AFFE'].append(_F(ORIGINE=m['ORIGINE'],),) __remodr = MODI_REPERE( RESULTAT=resin, REPERE='CYLINDRIQUE', **motscles) elif m['REPERE'] == 'UTILISATEUR': alpha = m['ANGL_NAUT'][0] beta = m['ANGL_NAUT'][1] gamma = m['ANGL_NAUT'][2] ANGL_NAUT = [] ANGL_NAUT.append(alpha) if dime == 3: ANGL_NAUT.append(beta) ANGL_NAUT.append(gamma) motscles['AFFE'].append(_F(ANGL_NAUT=ANGL_NAUT),) __remodr = MODI_REPERE( RESULTAT=resin, REPERE='UTILISATEUR', **motscles) return __remodr
def macr_spectre_ops(self, **args): """ Ecriture de la macro MACR_SPECTRE """ MAILLAGE = args.get("MAILLAGE") PLANCHER = args.get("PLANCHER") NOM_CHAM = args.get("NOM_CHAM") CALCUL = args.get("CALCUL") RESU = args.get("RESU") IMPRESSION = args.get("IMPRESSION") FREQ = args.get("FREQ") LIST_FREQ = args.get("LIST_FREQ") LIST_INST = args.get("LIST_INST") AMOR_SPEC = args.get("AMOR_SPEC") EnumType = (list, tuple) # On importe les definitions des commandes a utiliser dans la macro # construction de la liste des noeuds à traiter planch_nodes = {} if (MAILLAGE): dic_gpno = aster.getcolljev(MAILLAGE.getName().ljust(8) + ".GROUPENO") l_nodes = aster.getvectjev(MAILLAGE.getName().ljust(8) + ".NOMNOE") l_plancher = [] l_batiment = [] l_commentaire = [] # dplancher = [] for j in PLANCHER: dplancher.append(j.cree_dict_valeurs(j.mc_liste)) # for plancher in dplancher: liste_no = [] clefs = list(plancher.keys()) if ('NOEUD' in clefs): if plancher['NOEUD'] is not None: if type(plancher['NOEUD']) == str: liste_no.append(plancher['NOEUD']) else: for noeud in plancher['NOEUD']: liste_no.append(noeud) if ('GROUP_NO' in clefs): if plancher['GROUP_NO'] is not None: assert (MAILLAGE is not None) if type(plancher['GROUP_NO']) == str: noms_no = [ l_nodes[n - 1].strip() for n in dic_gpno[plancher['GROUP_NO'].ljust(24)] ] liste_no = liste_no + noms_no else: for group_no in plancher['GROUP_NO']: noms_no = [ l_nodes[n - 1].strip() for n in dic_gpno[group_no.ljust(24)] ] liste_no = liste_no + noms_no planch_nodes[plancher['NOM']] = liste_no l_plancher.append(plancher['NOM']) l_batiment.append(plancher['BATIMENT']) l_commentaire.append(plancher['COMMENTAIRE']) if AMOR_SPEC is not None and type(AMOR_SPEC) not in EnumType: AMOR_SPEC = (AMOR_SPEC, ) # if NOM_CHAM == 'ACCE': dico_glob = {} if NOM_CHAM == 'DEPL': dico_glob = { 'DX_max': [], 'DY_max': [], 'DZ_max': [], 'DH_max': [], } # # --------------------------------------------------------------------------------------------- # boucle 1 sur les planchers for plancher in l_plancher: # if NOM_CHAM == 'ACCE': __moy_x = [None] * len(planch_nodes[plancher]) __moy_y = [None] * len(planch_nodes[plancher]) __moy_z = [None] * len(planch_nodes[plancher]) if NOM_CHAM == 'DEPL': dicDmax = {} # ----------------------------------------------------------------------------------------- # boucle 2 sur les noeuds du plancher indexn = 0 for node in planch_nodes[plancher]: # ------------------------------------------------------------------------------------- # boucle 3 sur les directions (X,Y,Z) for dd in ('X', 'Y', 'Z'): # --------------------------------------------------------------------------------- # boucle 4 sur les résultats l_fonc = [] for resu in RESU: # Etape 1: Récupération des fonctions motscles = {} if resu['RESU_GENE'] is not None: if CALCUL == 'ABSOLU' and args.get( 'MULT_APPUI') is not None: motscles['MULT_APPUI'] = args['MULT_APPUI'] # motscles['RESU_GENE'] = resu['RESU_GENE'] __spo = RECU_FONCTION(NOM_CHAM=NOM_CHAM, TOUT_ORDRE='OUI', NOM_CMP='D' + dd, INTERPOL='LIN', PROL_GAUCHE='CONSTANT', PROL_DROITE='CONSTANT', NOEUD=node, **motscles) elif args.get('MULT_APPUI') is not None: UTMESS('F', 'SPECTRAL0_13') # if resu['RESULTAT'] is not None: motscles['RESULTAT'] = resu['RESULTAT'] __spo = RECU_FONCTION(NOM_CHAM=NOM_CHAM, TOUT_ORDRE='OUI', NOM_CMP='D' + dd, INTERPOL='LIN', PROL_GAUCHE='CONSTANT', PROL_DROITE='CONSTANT', NOEUD=node, **motscles) # if resu['TABLE'] is not None: # 2 formats de table possible. Avec les colonnes : # INST NOEUD NOM_CHAM NOM_CMP VALE # INST NOEUD NOM_CHAM DX DY DZ # récupération du nom des colonnes de la table nomcol = resu['TABLE'].get_nom_para() # lst1 = ('INST', 'NOEUD', 'NOM_CHAM', 'NOM_CMP', 'VALE') ok1 = True for para in lst1: ok1 = ok1 and (para in nomcol) # lst2 = ( 'INST', 'NOEUD', 'NOM_CHAM', 'D' + dd, ) ok2 = True for para in lst2: ok2 = ok2 and (para in nomcol) # if (not ok1 ^ ok2): print(nomcol) assert (ok1 ^ ok2) # if (ok1): __spo = RECU_FONCTION( TABLE=resu['TABLE'], PARA_X='INST', PARA_Y='VALE', INTERPOL='LIN', FILTRE=( _F(NOM_PARA='NOEUD', VALE_K=node), _F(NOM_PARA='NOM_CHAM', VALE_K=NOM_CHAM), _F(NOM_PARA='NOM_CMP', VALE_K='D' + dd), ), ) # if (ok2): __spo = RECU_FONCTION( TABLE=resu['TABLE'], PARA_X='INST', PARA_Y='D' + dd, INTERPOL='LIN', FILTRE=( _F(NOM_PARA='NOEUD', VALE_K=node), _F(NOM_PARA='NOM_CHAM', VALE_K=NOM_CHAM), ), ) # # Etape 2: Combinaisons if NOM_CHAM == 'ACCE': # Accelerations relatives if CALCUL == 'RELATIF': # Combinaison avec fonction d'accélération motscles = {} if LIST_INST is not None: motscles['LIST_PARA'] = LIST_INST __spo = CALC_FONCTION(COMB=( _F(FONCTION=__spo, COEF=1.0), _F(FONCTION=resu['ACCE_' + dd], COEF=1.0), ), **motscles) # Etape 3: Calcul des spectres d'oscillateur motscles = {} if FREQ is not None: motscles['FREQ'] = FREQ if LIST_FREQ is not None: motscles['LIST_FREQ'] = LIST_FREQ __spo = CALC_FONCTION( SPEC_OSCI=_F(FONCTION=__spo, AMOR_REDUIT=AMOR_SPEC, NORME=args['NORME'], **motscles)) l_fonc.append(__spo) elif NOM_CHAM == 'DEPL': if CALCUL == 'ABSOLU': # On retranche les deplacements d entrainement motscles = {} if LIST_INST is not None: motscles['LIST_PARA'] = LIST_INST __spo = CALC_FONCTION(COMB=( _F(FONCTION=__spo, COEF=1.0), _F(FONCTION=resu['DEPL_' + dd], COEF=-1.0), ), **motscles) l_fonc.append(__spo) # fin boucle 4 sur les résultats # --------------------------------------------------------------------------------- # # calcul de la moyenne sur les resultats à noeud et direction # fixes nbresu = len(RESU) if NOM_CHAM == 'ACCE': mcfCMBx = [] mcfCMBy = [] mcfCMBz = [] for spo in l_fonc: mcfCMBx.append( _F( FONCTION=spo, COEF=1. / float(nbresu), )) mcfCMBy.append( _F( FONCTION=spo, COEF=1. / float(nbresu), )) mcfCMBz.append( _F( FONCTION=spo, COEF=1. / float(nbresu), )) motscles = {} if LIST_FREQ is not None: motscles['LIST_PARA'] = LIST_FREQ if dd == 'X': __moy_x[indexn] = CALC_FONCTION(COMB=mcfCMBx, **motscles) if dd == 'Y': __moy_y[indexn] = CALC_FONCTION(COMB=mcfCMBy, **motscles) if dd == 'Z': __moy_z[indexn] = CALC_FONCTION(COMB=mcfCMBz, **motscles) # elif NOM_CHAM == 'DEPL': moy = 0. for spo in l_fonc: fspo = spo.convert() aspo = fspo.abs() vmax = aspo.extreme()['max'] moy = moy + vmax[-1][-1] dicDmax[(node, dd)] = moy / nbresu # fin boucle 3 sur les directions # ------------------------------------------------------------------------------------- # # impressions en chaque noeud if NOM_CHAM == 'ACCE' and IMPRESSION is not None: if IMPRESSION['TOUT'] == 'OUI': __moyxa = [None] * len(AMOR_SPEC) __moyya = [None] * len(AMOR_SPEC) __moyza = [None] * len(AMOR_SPEC) for i in range(len(AMOR_SPEC)): __moyxa[i] = RECU_FONCTION(NAPPE=__moy_x[indexn], VALE_PARA_FONC=AMOR_SPEC[i]) __moyya[i] = RECU_FONCTION(NAPPE=__moy_y[indexn], VALE_PARA_FONC=AMOR_SPEC[i]) __moyza[i] = RECU_FONCTION(NAPPE=__moy_z[indexn], VALE_PARA_FONC=AMOR_SPEC[i]) motscles = {} dI = IMPRESSION[0].cree_dict_valeurs( IMPRESSION[0].mc_liste) if 'PILOTE' in dI: motscles['PILOTE'] = IMPRESSION['PILOTE'] if IMPRESSION['FORMAT'] != 'TABLEAU': motscles['ECHELLE_X'] = 'LOG' if IMPRESSION['TRI'] == 'AMOR_SPEC': for i in range(len(AMOR_SPEC)): TITRE = 'Spectres / Plancher = ' + plancher + \ ' / amor=' + \ str(AMOR_SPEC[i]) + ' / noeud=' + node IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'], UNITE=IMPRESSION['UNITE'], COURBE=( _F( FONCTION=__moyxa[i], LEGENDE='X', ), _F( FONCTION=__moyya[i], LEGENDE='Y', ), _F( FONCTION=__moyza[i], LEGENDE='Z', ), ), TITRE=TITRE, **motscles) elif IMPRESSION['TRI'] == 'DIRECTION': for dd in ('X', 'Y', 'Z'): TITRE = 'Spectres / Plancher = ' + plancher + \ ' / direction = ' + dd + ' / noeud = ' + node legende = 'amor=' + str(AMOR_SPEC[i]) if dd == 'X': l_fonc = [ _F( FONCTION=__moyxa[i], LEGENDE=legende, ) for i in range(len(AMOR_SPEC)) ] if dd == 'Y': l_fonc = [ _F( FONCTION=__moyya[i], LEGENDE=legende, ) for i in range(len(AMOR_SPEC)) ] if dd == 'Z': l_fonc = [ _F( FONCTION=__moyza[i], LEGENDE=legende, ) for i in range(len(AMOR_SPEC)) ] IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'], UNITE=IMPRESSION['UNITE'], COURBE=l_fonc, TITRE=TITRE, **motscles) # increment de l'indice de noeud indexn = indexn + 1 # fin boucle 2 sur les noeuds du plancher # ----------------------------------------------------------------------------------------- # # Etape 4: Calcul des enveloppes des spectres ou des deplacements max if NOM_CHAM == 'ACCE': mcslx = [] mcsly = [] mcslz = [] indexn = 0 for node in planch_nodes[plancher]: mcslx.append(__moy_x[indexn]) mcsly.append(__moy_y[indexn]) mcslz.append(__moy_z[indexn]) indexn = indexn + 1 __snx = CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslx)) __sny = CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcsly)) __snz = CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslz)) __snh = CALC_FONCTION(ENVELOPPE=_F(FONCTION=(__snx, __sny))) elif NOM_CHAM == 'DEPL': DRmX = max( [dicDmax[(node, 'X')] for node in planch_nodes[plancher]]) DRmY = max( [dicDmax[(node, 'Y')] for node in planch_nodes[plancher]]) DRmZ = max( [dicDmax[(node, 'Z')] for node in planch_nodes[plancher]]) DRmH = max([DRmX, DRmY]) # # Renseignement de la table finale des résultats if NOM_CHAM == 'ACCE': nbind = len(AMOR_SPEC) for i in range(nbind): dico_glob['FREQ'] = __snx.Valeurs()[1][i][0] dico_glob['eX_%d_%s' % (i, plancher)] = __snx.Valeurs()[1][i][1] dico_glob['eY_%d_%s' % (i, plancher)] = __sny.Valeurs()[1][i][1] dico_glob['eZ_%d_%s' % (i, plancher)] = __snz.Valeurs()[1][i][1] dico_glob['eH_%d_%s' % (i, plancher)] = __snh.Valeurs()[1][i][1] elif NOM_CHAM == 'DEPL': dico_glob['DX_max'].append(DRmX) dico_glob['DY_max'].append(DRmY) dico_glob['DZ_max'].append(DRmZ) dico_glob['DH_max'].append(DRmH) # # Etape 5: Impression des courbes if NOM_CHAM == 'ACCE' and IMPRESSION is not None: motscles = {} dI = IMPRESSION[0].cree_dict_valeurs(IMPRESSION[0].mc_liste) if 'PILOTE' in dI: motscles['PILOTE'] = IMPRESSION['PILOTE'] if IMPRESSION['FORMAT'] != 'TABLEAU': motscles['ECHELLE_X'] = 'LOG' __snxa = [None] * len(AMOR_SPEC) __snya = [None] * len(AMOR_SPEC) __snza = [None] * len(AMOR_SPEC) __snha = [None] * len(AMOR_SPEC) for i in range(nbind): __snxa[i] = RECU_FONCTION( NAPPE=__snx, VALE_PARA_FONC=AMOR_SPEC[i], ) __snya[i] = RECU_FONCTION( NAPPE=__sny, VALE_PARA_FONC=AMOR_SPEC[i], ) __snza[i] = RECU_FONCTION( NAPPE=__snz, VALE_PARA_FONC=AMOR_SPEC[i], ) __snha[i] = RECU_FONCTION( NAPPE=__snh, VALE_PARA_FONC=AMOR_SPEC[i], ) if IMPRESSION['TRI'] == 'AMOR_SPEC': for i in range(nbind): TITRE = 'Spectres moyens / Plancher = ' + \ plancher + ' / amor=' + str(AMOR_SPEC[i]) IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'], UNITE=IMPRESSION['UNITE'], COURBE=( _F( FONCTION=__snxa[i], LEGENDE='X', ), _F( FONCTION=__snya[i], LEGENDE='Y', ), _F( FONCTION=__snza[i], LEGENDE='Z', ), _F( FONCTION=__snha[i], LEGENDE='H', ), ), TITRE=TITRE, **motscles) elif IMPRESSION['TRI'] == 'DIRECTION': for dd in ('X', 'Y', 'Z', 'H'): TITRE = 'Spectres moyens / Plancher = ' + \ plancher + ' / direction = ' + dd legende = 'amor=' + str(AMOR_SPEC[i]) l_fonc = [] if dd == 'X': l_fonc = [ _F( FONCTION=__snxa[i], LEGENDE=legende, ) for i in range(len(AMOR_SPEC)) ] if dd == 'Y': l_fonc = [ _F( FONCTION=__snya[i], LEGENDE=legende, ) for i in range(len(AMOR_SPEC)) ] if dd == 'Z': l_fonc = [ _F( FONCTION=__snza[i], LEGENDE=legende, ) for i in range(len(AMOR_SPEC)) ] if dd == 'H': l_fonc = [ _F( FONCTION=__snha[i], LEGENDE=legende, ) for i in range(len(AMOR_SPEC)) ] IMPR_FONCTION(FORMAT=IMPRESSION['FORMAT'], UNITE=IMPRESSION['UNITE'], COURBE=l_fonc, TITRE=TITRE, **motscles) # fin boucle 1 sur les planchers # --------------------------------------------------------------------------------------------- # # Etape6 : Renseignement de la table finale des résultats lListe = [] nb_amor = 0 if NOM_CHAM == 'DEPL': titre = 'Calcul des spectres enveloppes' elif NOM_CHAM == 'ACCE': titre = 'Calcul des spectres enveloppes par planchers' infos_amor = {} infos_amor['NUME_AMOR'] = [] infos_amor['AMOR'] = [] nb_amor = len(AMOR_SPEC) for i in range(len(AMOR_SPEC)): infos_amor['NUME_AMOR'].append(i) infos_amor['AMOR'].append(AMOR_SPEC[i]) nb_plancher = len(l_plancher) lkeys = list(dico_glob.keys()) lkeys.sort() for key in lkeys: nb_lignes = len(dico_glob[key]) lListe.append( _F(LISTE_R=dico_glob[key], PARA=key, NUME_LIGN=list( range(nb_amor + nb_plancher + 1, nb_amor + nb_plancher + nb_lignes + 1)))) if NOM_CHAM == 'ACCE': lListe.append( _F(LISTE_I=infos_amor['NUME_AMOR'], PARA='NUME_AMOR', NUME_LIGN=list(range(nb_plancher + 1, nb_plancher + nb_amor + 1)))) lListe.append( _F(LISTE_R=infos_amor['AMOR'], PARA='AMOR', NUME_LIGN=list(range(nb_plancher + 1, nb_plancher + nb_amor + 1)))) lListe.append(_F(LISTE_K=l_plancher, TYPE_K='K24', PARA='NOM')) l_bat = [i for i in l_batiment if i is not None] l_com = [i for i in l_commentaire if i is not None] if l_bat != []: l_bat2 = ['-' if i is None else i for i in l_batiment] lListe.append(_F(LISTE_K=l_bat2, TYPE_K='K24', PARA='BATIMENT')) if l_com != []: l_com2 = ['-' if i is None else i for i in l_commentaire] lListe.append(_F(LISTE_K=l_com2, TYPE_K='K24', PARA='COMMENTAIRE')) tab = CREA_TABLE(LISTE=lListe, TITRE=titre) return tab
def macr_lign_coupe_ops(self, LIGN_COUPE, RESULTAT=None, CHAM_GD=None, NOM_CHAM=None, MODELE=None, **args): """ Ecriture de la macro MACR_LIGN_COUPE """ # La valeur par défaut n'est pas dans le catalogue, sinon le mot-clé devient # obligatoire dans AsterStudy UNITE_MAILLAGE = args.get("UNITE_MAILLAGE") if not UNITE_MAILLAGE: logical_unit = LogicalUnitFile.new_free(access=FileAccess.New) UNITE_MAILLAGE = logical_unit.unit # On importe les definitions des commandes a utiliser dans la macro # MasquerAlarme('ALGORITH12_43') MasquerAlarme('CALCULEL2_63') MasquerAlarme('CALCULEL2_64') MasquerAlarme('MODELISA5_53') MasquerAlarme('MODELE1_58') MasquerAlarme('MODELE1_63') MasquerAlarme('MODELE1_64') mcORDR = {} Model = MODELE Mesh = None l_mode_meca_sans_modele = False if RESULTAT is not None: if 'NUME_ORDRE' in args: mcORDR['NUME_ORDRE'] = args['NUME_ORDRE'] elif 'NUME_MODE' in args: mcORDR['NUME_MODE'] = args['NUME_MODE'] elif 'LIST_ORDRE' in args: mcORDR['LIST_ORDRE'] = args['LIST_ORDRE'] elif 'INST' in args: mcORDR['INST'] = args['INST'] mcORDR['CRITERE'] = args['CRITERE'] mcORDR['PRECISION'] = args['PRECISION'] elif 'LIST_INST' in args: mcORDR['LIST_INST'] = args['LIST_INST'] mcORDR['CRITERE'] = args['CRITERE'] mcORDR['PRECISION'] = args['PRECISION'] else: mcORDR['TOUT_ORDRE'] = 'OUI' type_resu = RESULTAT.getType().lower() model = RESULTAT.getModel() if (model is None) or (model.getName() in ('', '#AUCUN')): if MODELE is None: if (type_resu != 'mode_meca'): UTMESS('F', 'POST0_9', valk=RESULTAT.getName()) # si le résultat en entrée est un mode_meca et qu'il ne contient pas de modèle (il est obtenu par sous-structuration, par exemple) # on passe le message fatal et on récupérera directement le # maillage (ou squelette) else: l_mode_meca_sans_modele = True Mesh = RESULTAT.getMesh() UTMESS('I', 'POST0_23', valk=RESULTAT.getName()) else: Mesh = model.getMesh() if Model is None: Model = model if Mesh is None: raise Exception("Empty mesh") elif CHAM_GD is not None: mcORDR['TOUT_ORDRE'] = 'OUI' if Model is None: UTMESS('F', 'POST0_10') # récupération de la grandeur du champ n_cham = CHAM_GD.getName() catagd = aster.getvectjev("&CATA.GD.NOMGD") desc = aster.getvectjev('%-19s.DESC' % n_cham) if desc is not None: nomgd = catagd[desc[0] - 1] else: celd = aster.getvectjev('%-19s.CELD' % n_cham) nomgd = catagd[celd[0] - 1] # détermination du type de résultat à créer if nomgd[:6] == 'TEMP_R': TYPE_RESU = 'EVOL_THER' if not NOM_CHAM: NOM_CHAM = 'TEMP' elif nomgd[:6] == 'DEPL_R': TYPE_RESU = 'EVOL_ELAS' if not NOM_CHAM: NOM_CHAM = 'DEPL' elif nomgd[:6] == 'NEUT_R': TYPE_RESU = 'EVOL_VARC' if not NOM_CHAM: NOM_CHAM = 'NEUT' elif nomgd[:6] == 'EPSI_R': TYPE_RESU = 'EVOL_ELAS' elif nomgd[:6] == 'VAR2_R': TYPE_RESU = 'EVOL_NOLI' elif nomgd[:6] == 'VARI_R': TYPE_RESU = 'EVOL_NOLI' elif nomgd[:6] == 'SIEF_R': if not NOM_CHAM: TYPE_RESU = 'EVOL_ELAS' NOM_CHAM = 'DEPL' elif NOM_CHAM[:4] == 'SIGM': TYPE_RESU = 'EVOL_ELAS' elif NOM_CHAM[:4] == 'SIEF': TYPE_RESU = 'EVOL_NOLI' else: assert 0, 'grandeur imprevue : ' + nomgd # création d'un concept résultat à partir du champ CHAM_GD __resuch = CREA_RESU( OPERATION='AFFE', NOM_CHAM=NOM_CHAM, TYPE_RESU=TYPE_RESU, AFFE=_F(CHAM_GD=CHAM_GD, INST=0.), ) RESULTAT = __resuch # Maillage sur lequel s'appuie le résultat à projeter if Mesh is None: Mesh = Model.getMesh() # le maillage est-il 2D ou 3D ? n_mailla = Mesh.getName() dime = Mesh.getDimension() collgrma = aster.getcolljev(n_mailla.ljust(8) + '.GROUPEMA') collgrno = aster.getcolljev(n_mailla.ljust(8) + '.GROUPENO') typma = aster.getvectjev(n_mailla.ljust(8) + '.TYPMAIL') ltyma = aster.getvectjev("&CATA.TM.NOMTM") lignes = [] groups = [] arcs = [] minidim = dime for m in LIGN_COUPE: if m['TYPE'] == 'SEGMENT': coor_orig = get_coor(m, 'ORIG', collgrno, n_mailla) coor_extr = get_coor(m, 'EXTR', collgrno, n_mailla) lignes.append((coor_orig, coor_extr, m['NB_POINTS'])) minidim = min(minidim, len(coor_orig), len(coor_extr)) if minidim != dime: UTMESS('F', 'POST0_11') elif m['TYPE'] == 'ARC': minidim = min(minidim, len(m['COOR_ORIG']), len(m['CENTRE'])) if minidim != dime: UTMESS('F', 'POST0_11') if dime == 2: arcs.append(( m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'], )) elif dime == 3: if str(m['DNOR']) == 'None': UTMESS('F', 'POST0_12') arcs.append((m['COOR_ORIG'], m['CENTRE'], m['NB_POINTS'], m['ANGLE'], m['DNOR'])) elif m['TYPE'] == 'GROUP_NO': ngrno = m['GROUP_NO'].ljust(24) collgrno = aster.getcolljev(n_mailla.ljust(8) + '.GROUPENO') if ngrno not in list(collgrno.keys()): UTMESS('F', 'POST0_13', valk=[ngrno, n_mailla]) grpn = collgrno[ngrno] l_coor_group = [ ngrno, ] for node in grpn: l_coor_group.append( aster.getvectjev( n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3)) groups.append(l_coor_group) elif m['TYPE'] == 'GROUP_MA': ngrma = m['GROUP_MA'].ljust(24) if ngrma not in list(collgrma.keys()): UTMESS('F', 'POST0_14', valk=[ngrma, n_mailla]) grpm = collgrma[ngrma] for ma in grpm: if ltyma[typma[ma - 1] - 1][:3] != 'SEG': nomma = aster.getvectjev(n_mailla.ljust(8) + '.NOMMAI') UTMESS('F', 'POST0_15', valk=[ngrma, nomma[ma - 1]]) __mailla = COPIER(CONCEPT=m['MAILLAGE']) m2 = m.cree_dict_valeurs(m.mc_liste) argsup = {} if m2.get('GROUP_NO_ORIG'): argsup['GROUP_NO_ORIG'] = m2.get('GROUP_NO_ORIG') if m2.get('GROUP_NO_EXTR'): argsup['GROUP_NO_EXTR'] = m2.get('GROUP_NO_EXTR') if m2.get('NOEUD_ORIG'): argsup['NOEUD_ORIG'] = m2.get('NOEUD_ORIG') if m2.get('NOEUD_EXTR'): argsup['NOEUD_EXTR'] = m2.get('NOEUD_EXTR') if m2.get('VECT_ORIE'): argsup['VECT_ORIE'] = m2.get('VECT_ORIE') __mailla = DEFI_GROUP(reuse=__mailla, MAILLAGE=__mailla, DETR_GROUP_NO=_F(NOM=str(m['GROUP_MA'])), CREA_GROUP_NO=_F(OPTION='NOEUD_ORDO', NOM=str(m['GROUP_MA']), GROUP_MA=m['GROUP_MA'], ORIGINE='SANS', **argsup)) collgrno = aster.getcolljev(__mailla.getName().ljust(8) + '.GROUPENO') grpn = collgrno[str(m['GROUP_MA']).ljust(24)] l_coor_group = [ ngrma, ] for node in grpn: l_coor_group.append( aster.getvectjev( n_mailla.ljust(8) + '.COORDO .VALE', 3 * (node - 1), 3)) groups.append(l_coor_group) if arcs != [] and (lignes != [] or groups != []): UTMESS('F', 'POST0_16') # Création du maillage des NB_POINTS segments entre COOR_ORIG et COOR_EXTR # ainsi que des segments reliant les noeuds issus des group_no demandés # par appel au script python crea_mail_lig_coup # le maillage est ensuite recopié dans l unité logique UNITE_MAILLAGE resu_mail, arcgma, angles, nbno = crea_mail_lig_coup( dime, lignes, groups, arcs) nomFichierSortie = LogicalUnitFile.filename_from_unit(UNITE_MAILLAGE) with open(nomFichierSortie, 'w') as fproc: fproc.write(os.linesep.join(resu_mail)) # Lecture du maillage de seg2 contenant toutes les lignes de coupe __macou = LIRE_MAILLAGE( FORMAT='ASTER', UNITE=UNITE_MAILLAGE, ) LogicalUnitFile.release_from_number(UNITE_MAILLAGE) motscles = {} iocc = 1 motscles['CREA_GROUP_NO'] = [] for m in LIGN_COUPE: if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'): motscles['CREA_GROUP_NO'].append( _F(GROUP_MA=m[m['TYPE']].ljust(24), )) else: motscles['CREA_GROUP_NO'].append(_F(GROUP_MA='LICOU' + str(iocc), )) iocc = iocc + 1 __macou = DEFI_GROUP(reuse=__macou, MAILLAGE=__macou, **motscles) # issue27543 : l'utilisation d'un modèle n'est pas utile et elle # engendrait dans le cas thermique l'émission des alarmes MODELE1_3 et MODELE1_53 # Dans le cas où il y aurait besoin de réintroduire les modèles, j'ai remplacé # la modélisation PLAN par COQUE (laissée en commentaire) ce qui permet également # de supprimer les alarmes. motscles = {} motscles.update(mcORDR) motscles['VIS_A_VIS'] = [] if 'VIS_A_VIS' in args: for v in args['VIS_A_VIS']: if v['GROUP_MA_1'] is not None: motscles['VIS_A_VIS'].append( _F(GROUP_MA_1=v['GROUP_MA_1'], TOUT_2='OUI'), ) elif v['MAILLE_1'] is not None: motscles['VIS_A_VIS'].append( _F(MAILLE_1=v['MAILLE_1'], TOUT_2='OUI'), ) if NOM_CHAM[5:9] == 'ELGA': UTMESS('A', 'POST0_18', valk=[ NOM_CHAM, ]) if (l_mode_meca_sans_modele == False): __recou = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT=RESULTAT, MODELE_1=Model, DISTANCE_MAX=m['DISTANCE_MAX'], # issue27543 #MODELE_2=__mocou, MAILLAGE_2=__macou, TYPE_CHAM='NOEU', NOM_CHAM=NOM_CHAM, **motscles) else: __recou = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT=RESULTAT, MAILLAGE_1=Mesh, DISTANCE_MAX=m['DISTANCE_MAX'], # issue27543 #MODELE_2=__mocou, MAILLAGE_2=__macou, TYPE_CHAM='NOEU', NOM_CHAM=NOM_CHAM, **motscles) __remodr = __recou icham = 0 ioc2 = 0 mcACTION = [] if RESULTAT.getType().lower() in ('evol_ther', 'evol_elas', 'evol_noli', 'mode_meca', 'evol_varc', 'comb_fourier', 'mult_elas', 'fourier_elas', 'dyna_trans'): if NOM_CHAM in ('DEPL', 'SIEF_ELNO', 'SIGM_NOEU', 'SIGM_ELNO', 'FLUX_ELNO', 'FLUX_NOEU'): icham = 1 iocc = 0 for m in LIGN_COUPE: iocc = iocc + 1 motscles = {} motscles['OPERATION'] = m['OPERATION'] if m['NOM_CMP'] is not None: motscles['NOM_CMP'] = m['NOM_CMP'] if m['TRAC_NOR'] is not None: motscles['TRAC_NOR'] = m['TRAC_NOR'] elif m['TRAC_DIR'] is not None: motscles['TRAC_DIR'] = m['TRAC_DIR'] motscles['DIRECTION'] = m['DIRECTION'] elif m['INVARIANT'] is not None: motscles['INVARIANT'] = m['INVARIANT'] elif m['RESULTANTE'] is not None: motscles['RESULTANTE'] = m['RESULTANTE'] if m['MOMENT'] is not None: motscles['MOMENT'] = m['MOMENT'] motscles['POINT'] = m['POINT'] elif m['ELEM_PRINCIPAUX'] is not None: motscles['ELEM_PRINCIPAUX'] = m['ELEM_PRINCIPAUX'] else: motscles['TOUT_CMP'] = 'OUI' # on définit le groupe de noeud pour post_releve_t if m['TYPE'] in ('GROUP_NO', 'GROUP_MA'): groupe = m[m['TYPE']].ljust(8) nomgrma = groupe else: ioc2 = ioc2 + 1 groupe = 'LICOU' + str(ioc2) nomgrma = ' ' newgrp = 'LICOF' + str(ioc2) crea_grp_matiere(self, groupe, newgrp, iocc, m, __remodr, NOM_CHAM, LIGN_COUPE, __macou) groupe = newgrp # on definit l'intitulé if m['INTITULE'] is not None: intitl = m['INTITULE'] elif m['TYPE'] in ('GROUP_NO', 'GROUP_MA'): intitl = groupe else: intitl = 'l.coupe' + str(ioc2) # Expression des contraintes aux noeuds ou des déplacements dans le # repere local if m['REPERE'] != 'GLOBAL': if icham == 1: if m['REPERE'] == 'POLAIRE': mcACTION.append( _F(INTITULE=intitl, RESULTAT=__remodr, REPERE=m['REPERE'], GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles), ) else: __remodr = crea_resu_local(self, dime, NOM_CHAM, m, __recou, __macou, nomgrma) mcACTION.append( _F(INTITULE=intitl, RESULTAT=__remodr, GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles), ) else: UTMESS('A', 'POST0_17', valk=[NOM_CHAM, m['REPERE']]) mcACTION.append( _F(INTITULE=intitl, RESULTAT=__recou, GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles), ) # Expression des contraintes aux noeuds ou des déplacements dans le # repere global else: mcACTION.append( _F(INTITULE=intitl, RESULTAT=__recou, GROUP_NO=groupe, NOM_CHAM=NOM_CHAM, **motscles), ) else: assert 0 __tabitm = POST_RELEVE_T(ACTION=mcACTION, ) # on repasse par les tables python pour supprimer les paramètres inutiles # NOEUD (car il est propre au maillage de la ligne) et RESU dictab = __tabitm.EXTR_TABLE() # Ajout de la colonne theta if len(arcgma) > 0 and 'ABSC_CURV' in dictab.para: val = dictab['ABSC_CURV'].values()['ABSC_CURV'] nbi = len(val) // nbno nba = len(angles) tmp = [] for k in range(nba): for j in range(nbi): for i in range(len(angles[k])): tmp.append(angles[k][i]) dictab['ANGLE'] = tmp if 'RESU' in dictab.para: del dictab['RESU'] if 'NOEUD' in dictab.para: del dictab['NOEUD'] dprod = dictab.dict_CREA_TABLE() # Remove TITRE key from the dictionary so that the newly created table uses # the user-given concept name in its title dprod.pop('TITRE') nomres = CREA_TABLE(**dprod) RetablirAlarme('ALGORITH12_43') RetablirAlarme('CALCULEL2_63') RetablirAlarme('CALCULEL2_64') RetablirAlarme('MODELISA5_53') RetablirAlarme('MODELE1_58') RetablirAlarme('MODELE1_63') RetablirAlarme('MODELE1_64') return nomres