def RECU_VECT_GENE_C(self, vecteur): """ envoie les valeurs d'un tableau numpy dans un vecteur generalise complexe definie dans jeveux Attributs ne retourne rien """ if not self.accessible(): raise AsException( "Erreur dans vect_asse_gene_c.RECU_VECT_GENE en PAR_LOT='OUI'") import numpy numpy.asarray(vecteur) ncham = self.get_name() ncham = ncham + (8 - len(ncham)) * ' ' desc = self.sdj.DESC.get() # On teste si le DESC de la matrice existe if not desc: raise AsException("L'objet vecteur {0!r} n'existe pas".format( self.sdj.DESC.nomj())) desc = numpy.array(desc) # On teste si la taille de la matrice jeveux et python est identique if desc[1] != numpy.shape(vecteur)[0]: raise AsException("La taille du vecteur python est incorrecte") tmpr = vecteur.real tmpc = vecteur.imag aster.putvectjev(ncham + (19 - len(ncham)) * ' ' + '.VALE', len(tmpr), tuple(range(1, len(tmpr) + 1)), tuple(tmpr), tuple(tmpc), 1) return
def champ_detoile_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, Nl, Kt, a1, a2, a3, **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) __EPEQN2 = CALC_CHAMP( INST=(TINIT, TFIN), RESULTAT=RESUMECA, VARI_INTERNE='VARI_NOEU') __EPEQN = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT=__EPEQN2, MODELE_1=mome, MODELE_2=moth, NOM_CHAM='VARI_NOEU', TOUT_ORDRE='OUI') __VINT1 = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_VAR2_R', RESULTAT=__EPEQN, NOM_CHAM='VARI_NOEU', INST=TFIN, INFO=INFO) # recopie du champ C20 pour initialiser le futur champ source __chtmp = CREA_CHAMP( OPERATION='AFFE', TYPE_CHAM='NOEU_NEUT_R', MAILLAGE=mesh, AFFE=(_F(VALE=0., GROUP_MA=GRMAVOL, NOM_CMP='X1',),)) # 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 lp_t1 = __VINT1.EXTR_COMP('V1', [], 1) p_t1 = lp_t1.valeurs node_me = lp_t1.noeud nbnode = len(node_th) assert(nbnode == len(node_me)) detoile = NP.zeros(nbnode) bidon = NP.zeros(nbnode) for ino, node in enumerate(node_th): Cl = c_t0[ino] p1 = p_t1[ino] detoile[ino] = DETOILE(Cl, p1, Ctot0, Nl, Kt, a1, a2, a3) nomvect = '%-19s.VALE' % __chtmp.getName() aster.putvectjev(nomvect, nbnode, tuple( range(1, nbnode + 1)), tuple(detoile), tuple(bidon), 1) NEUTG = CREA_CHAMP(OPERATION='DISC', TYPE_CHAM='ELNO_NEUT_R', MODELE=moth, PROL_ZERO='OUI', CHAM_GD=__chtmp, INFO=INFO) return NEUTG
def changeJeveuxValues(self, nbval, indices, reel, imag, num=1): """Modify values of existing data structures""" nomj = self.nomj() if aster.jeveux_exists(nomj): obj_simple = aster.jeveux_getattr(nomj, 'XOUS')[1].strip() == 'S' if obj_simple: assert num == 1, """For vectors last argument must be set to 1""" # aster.putvectjev can be used for vectors (num=1) and collections aster.putvectjev(nomj, nbval, indices, reel, imag, num)
def RECU_MATR_GENE(self,matrice) : """ envoie les valeurs d'un tableau numpy dans des matrices generalisees reelles definies dans jeveux Attributs ne retourne rien """ import numpy if not self.accessible(): raise AsException("Erreur dans matr_asse_gene_c.RECU_MATR_GENE en PAR_LOT='OUI'") numpy.asarray(matrice) ncham=self.get_name() desc = self.sdj.DESC.get() # On teste si le DESC de la matrice existe if not desc: raise AsException("L'objet matrice {0!r} n'existe pas" .format(self.sdj.DESC.nomj())) desc = numpy.array(desc) numpy.asarray(matrice) # On teste si la dimension de la matrice python est 2 if (len(numpy.shape(matrice)) != 2) : raise AsException("La dimension de la matrice est incorrecte ") # On teste si la taille de la matrice jeveux et python est identique if (tuple([desc[1],desc[1]]) != numpy.shape(matrice)) : raise AsException("La taille de la matrice est incorrecte ") # Si le stockage est plein if desc[2]==2 : taille=desc[1]*desc[1]/2.0+desc[1]/2.0 tmpr=numpy.zeros([int(taille)]) tmpc=numpy.zeros([int(taille)]) for j in range(desc[1]+1): for i in range(j): k=j*(j-1)/2+i tmpr[k]=matrice[j-1,i].real tmpc[k]=matrice[j-1,i].imag aster.putvectjev('%-19s.VALM' % ncham, len(tmpr), tuple((\ range(1,len(tmpr)+1))),tuple(tmpr),tuple(tmpc),1) # Si le stockage est diagonal elif desc[2]==1 : tmpr=numpy.zeros(desc[1]) tmpc=numpy.zeros(desc[1]) for j in range(desc[1]): tmpr[j]=matrice[j,j].real tmpc[j]=matrice[j,j].imag aster.putvectjev('%-19s.VALM' % ncham,len(tmpr),tuple((\ range(1,len(tmpr)+1))),tuple(tmpr),tuple(tmpc),1) # Sinon on arrete tout else: raise KeyError return
def RECU_MATR_GENE(self, typmat, matrice): """ envoie les valeurs d'un tableau numpy dans des matrices generalisees reelles definies dans jeveux typmat='MASS_GENE' pour obtenir la matrice de masse generalisee typmat='RIGI_GENE' pour obtenir la matrice de raideur generalisee typmat='AMOR_GENE' pour obtenir la matrice d'amortissement generalisee Attributs ne retourne rien """ import numpy if not self.accessible(): raise AsException( "Erreur dans macr_elem_dyna.RECU_MATR_GENE en PAR_LOT='OUI'") nommacr = self.get_name() if (typmat == 'MASS_GENE'): macr_elem = self.sdj.MAEL_MASS elif (typmat == 'RIGI_GENE'): macr_elem = self.sdj.MAEL_RAID elif (typmat == 'AMOR_GENE'): macr_elem = self.sdj.MAEL_AMOR else: raise AsException("Le type de la matrice est incorrect") nom_vale = macr_elem.VALE.nomj() desc = macr_elem.DESC.get() # On teste si le DESC de la matrice existe if not desc: raise AsException("L'objet matrice {0!r} n'existe pas".format( macr_elem.DESC.nomj())) desc = numpy.array(desc) numpy.asarray(matrice) # On teste si la matrice python est de dimension 2 if (len(numpy.shape(matrice)) <> 2): raise AsException("La dimension de la matrice est incorrecte") # On teste si les tailles de la matrice jeveux et python sont identiques if (tuple([desc[1], desc[1]]) <> numpy.shape(matrice)): raise AsException("La dimension de la matrice est incorrecte") taille = desc[1] * desc[1] / 2.0 + desc[1] / 2.0 tmp = numpy.zeros([int(taille)]) for j in range(desc[1] + 1): for i in range(j): k = j * (j - 1) / 2 + i tmp[k] = matrice[j - 1, i] aster.putvectjev(nom_vale, len(tmp), tuple((range(1, len(tmp) + 1))), tuple(tmp), tuple(tmp), 1)
def RECU_MATR_GENE(self,matrice) : NP.asarray(matrice) ncham=self.getName() desc = self.sdj.DESC.get() # On teste si le DESC de la matrice existe if not desc: raise AsException("L'objet matrice {0!r} n'existe pas" .format(self.sdj.DESC.nomj())) desc = NP.array(desc) NP.asarray(matrice) # On teste si la dimension de la matrice python est 2 if (len(NP.shape(matrice)) != 2) : raise AsException("La dimension de la matrice est incorrecte ") # On teste si la taille de la matrice jeveux et python est identique if (tuple([desc[1],desc[1]]) != NP.shape(matrice)) : raise AsException("La taille de la matrice est incorrecte ") # Si le stockage est plein if desc[2]==2 : taille=desc[1]*desc[1]/2.0+desc[1]/2.0 tmpr=NP.zeros([int(taille)]) tmpc=NP.zeros([int(taille)]) for j in range(desc[1]+1): for i in range(j): k=j*(j-1) // 2+i tmpr[k]=matrice[j-1,i].real tmpc[k]=matrice[j-1,i].imag aster.putvectjev('%-19s.VALM' % ncham, len(tmpr), tuple((\ list(range(1,len(tmpr)+1)))),tuple(tmpr),tuple(tmpc),1) # Si le stockage est diagonal elif desc[2]==1 : tmpr=NP.zeros(desc[1]) tmpc=NP.zeros(desc[1]) for j in range(desc[1]): tmpr[j]=matrice[j,j].real tmpc[j]=matrice[j,j].imag aster.putvectjev('%-19s.VALM' % ncham,len(tmpr),tuple((\ list(range(1,len(tmpr)+1)))),tuple(tmpr),tuple(tmpc),1) # Sinon on arrete tout else: raise KeyError return
def RECU_VECT_GENE_C(self,vecteur): numpy.asarray(vecteur) ncham=self.getName() ncham=ncham+(8-len(ncham))*' ' desc = self.sdj.DESC.get() # On teste si le DESC de la matrice existe if not desc: raise AsException("L'objet vecteur {0!r} n'existe pas" .format(self.sdj.DESC.nomj())) desc = numpy.array(desc) # On teste si la taille de la matrice jeveux et python est identique if desc[1] != numpy.shape(vecteur)[0] : raise AsException("La taille du vecteur python est incorrecte") tmpr=vecteur.real tmpc=vecteur.imag aster.putvectjev(ncham+(19-len(ncham))*' '+'.VALE', len(tmpr), tuple(range(1, len(tmpr)+1)), tuple(tmpr), tuple(tmpc), 1) return
def RECU_MATR_GENE(self, typmat, matrice): nommacr = self.getName() if (typmat == 'MASS_GENE'): macr_elem = self.sdj.MAEL_MASS elif (typmat == 'RIGI_GENE'): macr_elem = self.sdj.MAEL_RAID elif (typmat == 'AMOR_GENE'): macr_elem = self.sdj.MAEL_AMOR else: raise AsException("Le type de la matrice est incorrect") nom_vale = macr_elem.VALE.nomj() desc = macr_elem.DESC.get() # On teste si le DESC de la matrice existe if not desc: raise AsException("L'objet matrice {0!r} n'existe pas".format( macr_elem.DESC.nomj())) desc = numpy.array(desc) numpy.asarray(matrice) # On teste si la matrice python est de dimension 2 if (len(numpy.shape(matrice)) != 2): raise AsException("La dimension de la matrice est incorrecte") # On teste si les tailles de la matrice jeveux et python sont identiques if (tuple([desc[1], desc[1]]) != numpy.shape(matrice)): raise AsException("La dimension de la matrice est incorrecte") taille = desc[1] * desc[1] / 2.0 + desc[1] / 2.0 tmp = numpy.zeros([int(taille)]) for j in range(desc[1] + 1): for i in range(j): k = j * (j - 1) // 2 + i tmp[k] = matrice[j - 1, i] aster.putvectjev(nom_vale, len(tmp), tuple((list(range(1, len(tmp) + 1)))), tuple(tmp), tuple(tmp), 1)
def compute_result(self): L_VEC = self.compute_harm_gene() __dyge0 = self.create_host_sd() nbmodt = self.mat_gene_params['NBMODT'] tup_re = [] tup_im = [] tup_re1 = [] tup_im1 = [] tup_re2 = [] tup_im2 = [] # boucle sur les 3 directions : sommation directionnelle n_dire = len(list(self.excit_params.keys())) for i, dire in enumerate(self.excit_params.keys()): VEC = L_VEC[i] # ATTENTION: on sort le champ en déplacement: # c'est équivalent au champ en acceleration # car on a applique un signal en ACCE pour fosi en acce # > cela evite de diviser par w2 pour integrer l'acceleration # (erreurs numeriques au point 0) # > on remplace donc le champ en acceleration # si tous les point on été calculés: pas d'interpolation _, vale_re, vale_im = self.excit_params[dire].Valeurs() if self.calc_params.get('FREQ_MAX') is None: inul = 0 for k, freqk in enumerate(self.liste_freq_sig): omegk = 2.0 * pi * freqk coef_a = (vale_re[k] + vale_im[k] * 1.j) VEC_comp = VEC[k] * coef_a if i == 0: tup_re.append(VEC_comp.real) tup_im.append(VEC_comp.imag) else: tup_re[k] += VEC_comp.real tup_im[k] += VEC_comp.imag # traitement des vitesses et déplacements apres sommation des directions pour l'acceleration if i == n_dire-1: if freqk > 1.e-6 : tup_re1.append((-1.0)*tup_re[k]/(omegk*omegk)) tup_im1.append((-1.0)*tup_im[k]/(omegk*omegk)) tup_re2.append(tup_im[k]/omegk) tup_im2.append((-1.0)*tup_re[k]/omegk) if inul == 1 : inul = 2 elif inul == 2 : tup_re1[k-2] = (2.0)*tup_re1[k-1]-tup_re1[k] tup_im1[k-2] = (2.0)*tup_im1[k-1]-tup_im1[k] tup_re2[k-2] = (2.0)*tup_re2[k-1]-tup_re2[k] tup_im2[k-2] = (2.0)*tup_im2[k-1]-tup_im2[k] inul = 0 else: inul = 1 tup_re1.append(VEC_comp.real*0.) tup_im1.append(VEC_comp.imag*0.) tup_re2.append(VEC_comp.real*0.) tup_im2.append(VEC_comp.imag*0.) else: inul = 0 for k, freqk in enumerate(self.liste_freq_sig): coef_a = (vale_re[k] + vale_im[k] * 1.j) omegk = 2.0 * pi * freqk if freqk >= self.calc_params.get('FREQ_MAX'): # interpolation du vecteur POD VEC(NB_FREQ, nbmodt) if i == 0: tup_re.append(VEC[-1].real * 0.0) tup_im.append(VEC[-1].imag * 0.0) else: vale_i = NP.searchsorted(self.liste_freq, freqk) if vale_i == 0: VEC_comp = VEC[0] * coef_a if i == 0: tup_re.append(VEC_comp.real) tup_im.append(VEC_comp.imag) else: tup_re[k] += VEC_comp.real tup_im[k] += VEC_comp.imag else: dfp = (freqk - self.liste_freq[vale_i - 1]) / ( self.liste_freq[vale_i] - self.liste_freq[vale_i - 1]) VEC_comp = coef_a * (VEC[vale_i - 1] + dfp * (VEC[vale_i] - VEC[vale_i - 1])) if i == 0: tup_re.append(VEC_comp.real) tup_im.append(VEC_comp.imag) else: tup_re[k] += VEC_comp.real tup_im[k] += VEC_comp.imag # traitement des vitesses et déplacements apres sommation des directions pour l'acceleration if i == n_dire-1: if freqk > 1.e-6 : tup_re1.append((-1.0)*tup_re[k]/(omegk*omegk)) tup_im1.append((-1.0)*tup_im[k]/(omegk*omegk)) tup_re2.append(tup_im[k]/omegk) tup_im2.append((-1.0)*tup_re[k]/omegk) if inul == 1 : inul = 2 elif inul == 2 : tup_re1[k-2] = (2.0)*tup_re1[k-1]-tup_re1[k] tup_im1[k-2] = (2.0)*tup_im1[k-1]-tup_im1[k] tup_re2[k-2] = (2.0)*tup_re2[k-1]-tup_re2[k] tup_im2[k-2] = (2.0)*tup_im2[k-1]-tup_im2[k] inul = 0 else: inul = 1 tup_re1.append(VEC_comp.real*0.) tup_im1.append(VEC_comp.imag*0.) tup_re2.append(VEC_comp.real*0.) tup_im2.append(VEC_comp.imag*0.) # il peut y avoir des blancs à la fin du noms qui ont été enlevés par le python resu_name = __dyge0.getName()+(19-len(__dyge0.getName()))*' ' # affectation des valeurs for k in range(len(self.liste_freq_sig)): # 1 2 3 # 8901234567890123456789012 aster.putvectjev(resu_name + '.DEPL ', nbmodt, tuple( range(nbmodt * k + 1, nbmodt * (k + 1) + 1)), tuple(tup_re1[k]), tuple(tup_im1[k]), 1) aster.putvectjev(resu_name + '.VITE ', nbmodt, tuple( range(nbmodt * k + 1, nbmodt * (k + 1) + 1)), tuple(tup_re2[k]), tuple(tup_im2[k]), 1) aster.putvectjev(resu_name + '.ACCE ', nbmodt, tuple( range(nbmodt * k + 1, nbmodt * (k + 1) + 1)), tuple(tup_re[k]), tuple(tup_im[k]), 1) if self.INFO == 2: aster.affiche('MESSAGE','START REST_SPEC_TEMP' ) dyha = REST_SPEC_TEMP(RESU_GENE = __dyge0, SYMETRIE='NON', #METHODE = 'PROL_ZERO' , TOUT_CHAM='OUI', #NOM_CHAM='ACCE' ) return dyha
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 char_source_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, Nl, Kt, a1, a2, a3, **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 dt = TFIN - TINIT # Recuperation du modele thermique 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) __EPEQN2 = CALC_CHAMP( INST=(TINIT, TFIN), RESULTAT=RESUMECA, VARI_INTERNE='VARI_NOEU', INFO=INFO) __EPEQN = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT=__EPEQN2, MODELE_1=mome, MODELE_2=moth, NOM_CHAM='VARI_NOEU', TOUT_ORDRE='OUI') __VINT0 = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_VAR2_R', RESULTAT=__EPEQN, NOM_CHAM='VARI_NOEU', INST=TINIT, INFO=INFO) __VINT1 = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_VAR2_R', RESULTAT=__EPEQN, NOM_CHAM='VARI_NOEU', INST=TFIN, INFO=INFO) # recopie du champ C20 pour initialiser le futur champ source __chtmp = CREA_CHAMP( OPERATION='AFFE', TYPE_CHAM='NOEU_NEUT_R', MAILLAGE=mesh, AFFE=(_F(VALE=0., GROUP_MA=GRMAVOL, NOM_CMP='X1',),)) # 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 # print 'node_th=',node_th lp_t0 = __VINT0.EXTR_COMP('V1', [], 1) p_t0 = lp_t0.valeurs node_me = lp_t0.noeud p_t1 = __VINT1.EXTR_COMP('V1', [], 0).valeurs nbnode = len(node_th) assert(nbnode == len(node_me)) source = NP.zeros(nbnode) bidon = NP.zeros(nbnode) for ino, node in enumerate(node_th): Cl = c_t0[ino] p0 = p_t0[ino] p1 = p_t1[ino] dpdt = (p1 - p0) / dt # avec INCLUDE : ne trouve pas SOURCE, mais en important la macro, # cela marche source[ino] = SOURCE(Cl, p1, dpdt, Ctot0, Nl, Kt, a1, a2, a3) nomvect = '%-19s.VALE' % __chtmp.getName() aster.putvectjev(nomvect, nbnode, tuple( range(1, nbnode + 1)), tuple(source), tuple(bidon), 1) __NEUTG = CREA_CHAMP(OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R', MODELE=moth, PROL_ZERO='OUI', CHAM_GD=__chtmp, INFO=INFO) __CHSOUR = CREA_CHAMP( OPERATION='ASSE', TYPE_CHAM='ELGA_SOUR_R', MODELE=moth, INFO=INFO, PROL_ZERO='OUI', ASSE=(_F(CHAM_GD=__NEUTG, GROUP_MA=GRMAVOL, NOM_CMP='X1', NOM_CMP_RESU='SOUR',),)) chth = AFFE_CHAR_THER(MODELE=moth, INFO=INFO, SOURCE=_F(SOUR_CALCULEE=__CHSOUR,), ) return chth
def champ_detoile_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, Nl, Kt, a1, a2, a3, INFO, **args): # macro pour calculer le chargement thermique specfique a la diffusion H2 import numpy as NP import aster from code_aster.Cata.Syntax import _F ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # Le concept sortant dans le contexte de la macro self.DeclareOut('NEUTG', self.sd) # On importe les definitions des commandes a utiliser dans la macro DETRUIRE = self.get_cmd('DETRUIRE') CREA_CHAMP = self.get_cmd('CREA_CHAMP') CALC_CHAMP = self.get_cmd('CALC_CHAMP') # Recuperation du modele a partir du resultat iret, ibid, __n_modele = aster.dismoi('MODELE', RESU_H2.nom, 'RESULTAT', 'F') __n_modele = __n_modele.rstrip() __MOTH = self.get_concept(__n_modele) # Recuperation du maillage a partir du resultat iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', RESU_H2.nom, 'RESULTAT', 'F') __MAIL = self.get_concept(nom_ma.strip()) # Recuperation du modele mecanique a partir du resultat iret, ibid, nom_momec = aster.dismoi('MODELE', RESUMECA.nom, 'RESULTAT', 'F') __MOME = self.get_concept(nom_momec.rstrip()) # 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) __EPEQN2 = CALC_CHAMP(INST=(TINIT, TFIN), RESULTAT=RESUMECA, VARI_INTERNE='VARI_NOEU') __EPEQN = PROJ_CHAMP(METHODE='COLLOCATION', RESULTAT=__EPEQN2, MODELE_1=__MOME, MODELE_2=__MOTH, NOM_CHAM='VARI_NOEU', TOUT_ORDRE='OUI') __VINT1 = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_VAR2_R', RESULTAT=__EPEQN, NOM_CHAM='VARI_NOEU', INST=TFIN, INFO=INFO) # recopie du champ C20 pour initialiser le futur champ source __chtmp = CREA_CHAMP(OPERATION='AFFE', TYPE_CHAM='NOEU_NEUT_R', MAILLAGE=__MAIL, AFFE=(_F( VALE=0., GROUP_MA=GRMAVOL, NOM_CMP='X1', ), )) nomcham = __chtmp.sdj.nomj() # 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 lp_t1 = __VINT1.EXTR_COMP('V1', [], 1) p_t1 = lp_t1.valeurs node_me = lp_t1.noeud nbnode = len(node_th) assert (nbnode == len(node_me)) detoile = NP.zeros(nbnode) bidon = NP.zeros(nbnode) for ino, node in enumerate(node_th): Cl = c_t0[ino] p1 = p_t1[ino] detoile[ino] = DETOILE(Cl, p1, Ctot0, Nl, Kt, a1, a2, a3) nomvect = '%-19s.VALE' % __chtmp.nom aster.putvectjev(nomvect, nbnode, tuple(range(1, nbnode + 1)), tuple(detoile), tuple(bidon), 1) NEUTG = CREA_CHAMP(OPERATION='DISC', TYPE_CHAM='ELNO_NEUT_R', MODELE=__MOTH, PROL_ZERO='OUI', CHAM_GD=__chtmp, INFO=INFO)