def prepare_input(self): """run prepare data""" matr_rigi = self.mat_gene_params['MATR_RIGI'] bamo = matr_rigi.getModalBasis() ddlgene = matr_rigi.getGeneralizedDOFNumbering() nom_bamo = bamo.getName() self.mat_gene_params['NUME_DDL'] = ddlgene self.mat_gene_params['BASE'] = bamo nom_mail = bamo.getDOFNumbering().getMesh().getName() self.cohe_params['MAILLAGE'] = nom_mail _, nbmodt, _ = aster.dismoi('NB_MODES_TOT', nom_bamo,'RESULTAT','F') _, nbmodd, _ = aster.dismoi('NB_MODES_DYN', nom_bamo,'RESULTAT','F') _, nbmods, _ = aster.dismoi('NB_MODES_STA', nom_bamo,'RESULTAT','F') self.mat_gene_params['NBMODD'] = nbmodd self.mat_gene_params['NBMODS'] = nbmods self.mat_gene_params['NBMODT'] = nbmodt _, noe_interf = get_group_nom_coord( self.interf_params['GROUP_NO_INTERF'], nom_mail) self.cohe_params['DIST'] = calc_dist2(noe_interf) self.cohe_params['NOEUDS_INTERF'] = noe_interf self.interf_params['NBNO'] = len(noe_interf) if self.INFO==2: texte1 = 'NOMBRE DE MODES: ' + str(nbmodt) texte2 = 'MODES DYNAMIQUES: ' + str(nbmodd) texte3 = 'MODES STATIQUES: ' + str(nbmods) aster.affiche('MESSAGE', texte1) aster.affiche('MESSAGE', texte2 + ' - ' + texte3) if self.case != 'TRANS': aster.affiche('MESSAGE', 'COMPOSANTE ' + self.NOM_CMP) else: aster.affiche('MESSAGE', 'COMPOSANTES ' + ','.join(self.list_NOM_CMP)) aster.affiche('MESSAGE', 'NBNO INTERFACE: ' + str(len(noe_interf)))
def char_grad_ini_ops(self, RESU_H2, GRMAVOL, DIME, INFO, **args): 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('chth', self.sd) grad = [] # On boucle sur les mailles du groupe de mailles GRMAVOL # 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()) nommai = __MAIL.sdj.NOMMAI.get() connex = __MAIL.sdj.CONNEX.get() groupma = __MAIL.sdj.GROUPEMA.get()[GRMAVOL.ljust(24)] for 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) # ajout dans le mot-cle facteur PRE_GRAD_TEMP nom_maille = nommai[ima - 1] mon_dico = {} mon_dico["MAILLE"] = nom_maille mon_dico["FLUX_X"] = 0. mon_dico["FLUX_Y"] = 0. if DIME == 3: mon_dico["FLUX_Z"] = 0. grad.append(mon_dico) chth = AFFE_CHAR_THER( MODELE=__MOTH, INFO=INFO, PRE_GRAD_TEMP=grad, )
def get_modele(self): """Recherche le modele associe au resultat. Routine generique pour les dyna_harmo et mode_meca""" if not self.modele: if aster.jeveux_exists(self.nom.ljust(19) + '.NOVA'): iret, ibid, modele_name = aster.dismoi('MODELE', self.nom, 'RESULTAT', 'F') modele_name = modele_name.rstrip() if modele_name[0:1] != "#": self.modele_name = modele_name self.modele = self.objects.modeles[self.modele_name] return # Si cela ne marche pas, on passe par le maillage if not self.modele: self.get_maillage() for m, _mod in self.objects.modeles.items(): if not _mod.maya_name: _mod.get_maillage() if _mod.maya_name == self.maya_name: self.modele_name = m self.modele = _mod if not self.modele: self.mess.disp_mess( "On ne trouve pas le modele associe au resultat " + self.nom) UTMESS('A', 'CALCESSAI0_8', valk=(self.nom))
def get_nom_maillage_sdfiss(FISS): """ retourne le nom du maillage associe au concept FISS""" import aster from Utilitai.Utmess import UTMESS iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', FISS.nom, 'FISS_XFEM', 'F') return nom_ma.strip()
def get_nume(self): """Recuperation de la numerotation et du nume_ddl""" indi = aster.getvectjev(self.nom.ljust(19) + '.INDI') if indi: iret, ibid, toto = aster.dismoi('NUME_DDL', self.nom, 'RESU_DYNA', 'C') self.nume_name = toto.strip() if self.nume_name: self.nume = self.objects.nume_ddl[self.nume_name]
def set_from_resu(self, what, resu): """Extract a parameter from a result""" assert what in ('mesh', 'model') key, typ = { 'mesh': ('NOM_MAILLA', maillage_sdaster), 'model': ('NOM_MODELE', modele_sdaster) }[what] nom_co = aster.dismoi(key, resu.nom, 'RESULTAT', 'F')[2].strip() return self.macro.get_concept_by_type(nom_co, typ)
def get_matrices(self): """ recuperation des matrices du REFD et du nume_ddl""" indi = aster.getvectjev(self.nom.ljust(19) + '.INDI') if indi: iret, ibid, self.kass_name = aster.dismoi('REF_RIGI_PREM', self.nom, 'RESU_DYNA', 'C') iret, ibid, self.mass_name = aster.dismoi('REF_MASS_PREM', self.nom, 'RESU_DYNA', 'C') iret, ibid, self.cass_name = aster.dismoi('REF_AMOR_PREM', self.nom, 'RESU_DYNA', 'C') try: self.kass = self.objects.matrices[self.kass_name] self.mass = self.objects.matrices[self.mass_name] self.cass = self.objects.matrices[self.cass_name] except KeyError: pass
def get_modele_support(self): """Recherche dans les resultats des objects CALC_ESSAI le modele mecanique du support. Remarque: ce resultat contient des modes mecaniques bidons. Une fois le modele trouve, la matrice de masse, ainsi que la caracteristique des elements et le champ de materiaux sont conserves en references. """ for name, resu in list(self.objects.resultats.items()): if aster.jeveux_exists(name.ljust(19) + '.NOVA'): iret, ibid, modele_name = aster.dismoi( 'MODELE', name, 'RESULTAT', 'F') modele_name = modele_name.rstrip() if modele_name[0:1] == "#": continue else: continue modllu = modele_name if modllu == self.support_modele.nom: support_modele = resu.obj iret, ibid, nom_raideur = aster.dismoi( 'REF_RIGI_PREM', support_modele.nom, 'RESU_DYNA', 'F') nom_raideur = nom_raideur.strip() if nom_raideur == self.matr_rig.nom: iret, ibid, nom_masse = aster.dismoi( 'REF_MASS_PREM', support_modele.nom, 'RESU_DYNA', 'F') nom_masse = nom_masse.strip() matr_masse = self.objects.get_matr(nom_masse) iret, ibid, nume_name = aster.dismoi( 'NUME_DDL', support_modele.nom, 'RESU_DYNA', 'F') nume_name = nume_name.strip() numesup = self.objects.nume_ddl[nume_name] iret, ibid, var_carelem = aster.dismoi( 'CARA_ELEM', name, 'RESULTAT', 'F') var_carelem = var_carelem.strip() iret, ibid, var_chmat = aster.dismoi( 'CHAM_MATER', name, 'RESULTAT', 'F') var_chmat = var_chmat.strip() break else: self.mess.disp_mess("Impossible de trouver le mode meca calcule " "du modele support") return self.support_modele_res = support_modele self.nume_support_modele = numesup self.matr_masse = matr_masse # Caracteristique de l'element et champ de materiaux # Utiliser pendant la condensation avec MACR_ELEM_STAT self.cara_elem = self.objects.get_cara_elem(var_carelem) self.cham_mater = self.objects.get_cham_mater(var_chmat)
def prepare_input(self): """run prepare data""" v_refa_rigi = self.mat_gene_params['MATR_RIGI'].sdj.REFA.get() nom_bamo = v_refa_rigi[0] nom_ddlgene = v_refa_rigi[1] self.mat_gene_params['NUME_DDL'] = self.macro.get_concept(nom_ddlgene) self.mat_gene_params['BASE'] = self.macro.get_concept(nom_bamo) ir, ib, nume_ddl = aster.dismoi('NUME_DDL', nom_bamo, 'RESU_DYNA', 'F') ir, ib, nom_mail = aster.dismoi('NOM_MAILLA', nume_ddl, 'NUME_DDL', 'F') self.cohe_params['MAILLAGE'] = nom_mail ir, nbmodt, ib = aster.dismoi('NB_MODES_TOT', nom_bamo, 'RESULTAT', 'F') ir, nbmodd, ib = aster.dismoi('NB_MODES_DYN', nom_bamo, 'RESULTAT', 'F') ir, nbmods, ib = aster.dismoi('NB_MODES_STA', nom_bamo, 'RESULTAT', 'F') self.mat_gene_params['NBMODD'] = nbmodd self.mat_gene_params['NBMODS'] = nbmods self.mat_gene_params['NBMODT'] = nbmodt l_nom, noe_interf = get_group_nom_coord( self.interf_params['GROUP_NO_INTERF'], nom_mail) self.cohe_params['DIST'] = calc_dist2(noe_interf) self.cohe_params['NOEUDS_INTERF'] = noe_interf self.interf_params['NBNO'] = len(noe_interf) if self.INFO == 2: texte1 = 'NOMBRE DE MODES: ' + str(nbmodt) texte2 = 'MODES DYNAMIQUES: ' + str(nbmodd) texte3 = 'MODES STATIQUES: ' + str(nbmods) aster.affiche('MESSAGE', texte1) aster.affiche('MESSAGE', texte2 + ' - ' + texte3) if self.case != 'TRANS': aster.affiche('MESSAGE', 'COMPOSANTE ' + self.NOM_CMP) else: aster.affiche('MESSAGE', 'COMPOSANTES ' + ','.join(self.list_NOM_CMP)) aster.affiche('MESSAGE', 'NBNO INTERFACE: ' + str(len(noe_interf)))
def __init__(self, UNITE_MED, MODELE, CARA_ELEM, CHAM_MATER, COMPORTEMENT, EXCIT, INFO): """ Initialisation """ import med_aster self.UNITE_MED = UNITE_MED self.MODELE = MODELE self.CARA_ELEM = CARA_ELEM self.CHAM_MATER = CHAM_MATER self.COMPORTEMENT = COMPORTEMENT self.EXCIT = EXCIT self.INFO = INFO self.fichier_med = 'fort.%s' % UNITE_MED dic_champ_med = med_aster.get_nom_champ_med(self.fichier_med) if type(dic_champ_med) is not dict: UTMESS('F', 'PLEXUS_50', vali=UNITE_MED) # Récuperation des concepts de la base macro = CONTEXT.get_current_step() # # Recherche dans le jdc la création du concept CARA_ELEM if (self.CARA_ELEM != None): FindEtape = False self.CARA_ELEM_CONCEPT = self.CARA_ELEM nomsd = self.CARA_ELEM.get_name() jdc = CONTEXT.get_current_step().jdc for UneEtape in jdc.etapes: if (UneEtape.nom == 'AFFE_CARA_ELEM') and (UneEtape.sdnom == nomsd): self.CARA_ELEM = UneEtape FindEtape = True break # if (not FindEtape): UTMESS('F', 'PLEXUS_20', valk=[nomsd, 'CARA_ELEM']) # else: self.CARA_ELEM_CONCEPT = None # # récuperation du maillage nom_MODELE = self.MODELE.get_name() iret, ibid, nomsd = aster.dismoi('NOM_MAILLA', nom_MODELE, 'MODELE', 'F') nomsd = nomsd.strip() self.MAILLAGE = macro.get_concept(nomsd)
def extr_matr_elim_lagr(self, matr_asse): import aster import numpy as NP matr_lagr=matr_asse.EXTR_MATR() # function EXTR_MATR available in the official source code #-----------------------------------------------------# #-- --# #-- Elimination des degres de libertes de Lagranges --# #-- --# #-- c.f. doc R4.06.02 - section 2.5 --# #-- + commentaires dans sdll123a.comm --# #-- --# #-----------------------------------------------------# iret,ibid,nom_nume = aster.dismoi('NOM_NUME_DDL',matr_asse.nom,'MATR_ASSE','F') Nume=aster.getvectjev(nom_nume.ljust(8)+' .NUME.DELG ' ) ind_lag1=[] ind_nolag=[] for i1 in range(len(Nume)) : if Nume[i1] > -0.5 : ind_nolag.append(i1) if (Nume[i1] < -0.5) & (Nume[i1] > -1.5): ind_lag1.append(i1) nlag1=len(ind_lag1) nnolag=len(ind_nolag) Z=NP.zeros((nnolag-nlag1,nnolag)) C=NP.vstack((matr_lagr[ind_lag1][:,ind_nolag],Z)) Q,R = NP.linalg.qr(NP.transpose(C)) dR=[] for i1 in range(len(R)) : dR.append(NP.abs(R[i1,i1])) mdR=NP.max(dR) indz=[] for i1 in range(len(R)) : if NP.abs(R[i1,i1]) <= mdR*1.e-16 : indz.append(i1) matr_sans_lagr=NP.dot(NP.transpose(Q[:][:,indz]),NP.dot(matr_lagr[ind_nolag][:,ind_nolag],Q[:][:,indz])) #-- Fin elimination return matr_sans_lagr
def CHAINAGE_INIT(self, args, motscles): MODELE_MECA = args['MODELE_MECA'] MODELE_HYDR = args['MODELE_HYDR'] # On importe les definitions des commandes a utiliser dans la macro CREA_MAILLAGE = self.get_cmd('CREA_MAILLAGE') PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') MATR_MH = PROJ_CHAMP(METHODE='COLLOCATION', MODELE_1=MODELE_MECA, MODELE_2=MODELE_HYDR, PROJECTION='NON', **motscles) iret, ibid, nom_mail = aster.dismoi('NOM_MAILLA', MODELE_HYDR.nom, 'MODELE', 'F') nom_mail = nom_mail.strip() __maillage_h = self.get_concept(nom_mail) _maillin = CREA_MAILLAGE(MAILLAGE=__maillage_h, QUAD_LINE=_F(TOUT='OUI', ), **motscles) MATR_HM1 = PROJ_CHAMP(METHODE='COLLOCATION', MODELE_1=MODELE_HYDR, MAILLAGE_2=_maillin, PROJECTION='NON', **motscles) MATR_HM2 = PROJ_CHAMP(METHODE='COLLOCATION', MAILLAGE_1=_maillin, MODELE_2=MODELE_MECA, PROJECTION='NON', **motscles) return MATR_MH, MATR_HM1, MATR_HM2
def get_matrices(self): """Recherche des nume_ddl qui dependent de ce modele NB : attention, si plusieurs nume_ddl en dependent, seul le premier deviendra self.nume_ddl. C'est utile pour les modeles experimentaux pour lesquels le ddl est pipo. """ if self.mass is None or self.kass is None: for matr_name, matr in list(self.objects.matrices.items()): iret, ibid, nom_modele = aster.dismoi('NOM_MODELE', matr_name, 'MATR_ASSE', 'F') if nom_modele.strip() == self.nom.strip(): if matr.sdj.REFA.get()[3].strip() == 'RIGI_MECA': self.kass = matr self.kass_name = matr_name if matr.sdj.REFA.get()[3].strip() == 'MASS_MECA': self.mass = matr self.mass_name = matr_name if self.mass is None or self.kass is None: self.mess.disp_mess( "On ne trouve pas de matrices associees au modele" + self.nom) self.mess.disp_mess( "Certains calculs ne seront pas realisables (MAC_MODE)") return
def post_newmark_ops(self, **args): """ Macro commande pour évaluer la stabilité d'un ouvrage en remblai (digue / barrage) au séisme par la méthode simplifiée de Newmark. Uniquement possible pour une modélisation 2D. """ MasquerAlarme('MODELE1_63') MasquerAlarme('MODELE1_64') ##sys.stdout.flush() pour vider les #prints args = _F(args) ONLY_FS = False if args['RESULTAT'] is not None: RESULTAT = args['RESULTAT'] __model = None ### RECUPERATION DU MAILLAGE DANS LE RESULTAT DYNAMIQUE try: __model = RESULTAT.getModel() except: raise NameError("No model") __mail = __model.getMesh() dim = __mail.getDimension() if dim == 3: UTMESS('F', 'POST0_51') ## possiblement à gérer par la suite le cas de plusieurs champs matériaux dans ## le RESULTAT __ch_mat = RESULTAT.getMaterialField() else: ONLY_FS = True if args['RESULTAT_PESANTEUR'] is not None: RESULTAT_PESANTEUR = args['RESULTAT_PESANTEUR'] __modST = None try: __modST = RESULTAT_PESANTEUR.getModel() except: raise NameError("No model") ### RECUPERATION DU MAILLAGE DANS LE RESULTAT STATIQUE if ONLY_FS: __mail = __modST.getMesh() dim = __mail.getDimension() if dim == 3: UTMESS('F', 'POST0_51') else: __mailST = __modST.getMesh() dim = __mailST.getDimension() if dim == 3: UTMESS('F', 'POST0_51') ### RECUPERATION COEFFICIENT KY if args['KY'] is not None: ky = args['KY'] ### gravité g = 9.81 ## accélération limite ay = ky * g ### GROUP_MA DANS LE MODELE grpma = args['GROUP_MA_CALC'] __mail = DEFI_GROUP( reuse=__mail, MAILLAGE=__mail, CREA_GROUP_MA=_F( NOM='ALL', #TYPE_MAILLE = '2D', UNION=grpma, ), ) ### RECUPERATION DES POSITIONS DU CERCLE DE GLISSEMENT if args['RAYON'] is not None: TYPE = 'CERCLE' r = args['RAYON'] posx = args['CENTRE_X'] posy = args['CENTRE_Y'] else: TYPE = "MAILLAGE" __mail_1 = args['MAILLAGE_GLIS'] __mail_1 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_MA=_F( NOM='ALL', #TYPE_MAILLE = '2D', TOUT='OUI', ), ) DEFI_GROUP(reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_NO=_F(NOM='DOMAIN_', OPTION='INCLUSION', MAILLAGE_INCL=__mail, GROUP_MA_INCL='ALL', GROUP_MA='ALL', CAS_FIGURE='2D')) DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_MA=_F( NOM='DOMAIN_', OPTION='APPUI', TYPE_APPUI='AU_MOINS_UN', GROUP_NO='DOMAIN_', ), ), if args['GROUP_MA_GLIS'] is not None: __mail_1 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_MA=_F( NOM='RUPTURE', UNION=args['GROUP_MA_GLIS'], ), ) else: __mail_1 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_MA=_F( NOM='RUPTURE', TYPE_MAILLE='2D', TOUT='OUI', ), ) if args['GROUP_MA_LIGNE'] is not None: ma_ligne = args['GROUP_MA_LIGNE'] #### Utlisateur n'a pas fournit GROUP_MA_LIGNE : On considere toutes les #### mailles SEG2 et SEG3 du maillage else: seg = [] _, _, yaseg2 = aster.dismoi('EXI_SEG2', __mail_1.getName(), 'MAILLAGE', 'F') if yaseg2 == 'OUI': seg.append('LIGNE_2') __mail_2 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_MA=_F( NOM='LIGNE_2', TYPE_MAILLE=('SEG2'), TOUT='OUI', ), ) _, _, yaseg3 = aster.dismoi('EXI_SEG3', __mail_1.getName(), 'MAILLAGE', 'F') if yaseg3 == 'OUI': seg.append('LIGNE_3') __mail_1 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_MA=_F( NOM='LIGNE_3', TYPE_MAILLE=('SEG3'), TOUT='OUI', ), ) ma_ligne = seg DEFI_GROUP(reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_NO=_F(NOM='LIGNE_', OPTION='INCLUSION', MAILLAGE_INCL=__mail, GROUP_MA_INCL='ALL', GROUP_MA=ma_ligne, CAS_FIGURE='2D')) DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, CREA_GROUP_MA=_F( NOM='LIGNE_', OPTION='APPUI', TYPE_APPUI='SOMMET', GROUP_NO='LIGNE_', ), ), # Orientation des mailles surfaciques __mail_1 = MODI_MAILLAGE( reuse=__mail_1, MAILLAGE=__mail_1, ORIE_PEAU_2D=_F(GROUP_MA=('LIGNE_', ), ), ) ##### ON RESTREINT LE MAILLAGE PATCH A LA ZONE COMMUNE AVEC LE MAILLAGE DU ##### RESULTAT A CONSIDERER __mail_2 = CREA_MAILLAGE( MAILLAGE=__mail_1, #INFO=2, RESTREINT=_F( GROUP_MA=('LIGNE_', 'DOMAIN_', 'RUPTURE'), GROUP_NO=( 'LIGNE_', 'DOMAIN_', ), ), ) #IMPR_RESU(RESU=_F(MAILLAGE = __mail_2,),FORMAT='MED',UNITE=23) __mail_L = CREA_MAILLAGE( MAILLAGE=__mail_2, #INFO=2, RESTREINT=_F( GROUP_MA=('LIGNE_', ), GROUP_NO=('LIGNE_', ), ), ) ############################################################################### #### #### CALCUL DU FACTEUR DE SECURITE STATIQUE #### ############################################################################### if args['RESULTAT_PESANTEUR'] is not None: #### ASSERT A CREER SI MODELE D'ORIGINE PLUS COMPLEXE QUE D_PLAN ##### MODELE SUR LE MAILLAGE PATCH __MODST = AFFE_MODELE( MAILLAGE=__mail_2, AFFE=(_F( TOUT='OUI', PHENOMENE='MECANIQUE', MODELISATION='D_PLAN', ), ), VERI_JACOBIEN='NON', ) __MODL = AFFE_MODELE( MAILLAGE=__mail_L, AFFE=(_F( TOUT='OUI', PHENOMENE='MECANIQUE', MODELISATION='D_PLAN', ), ), VERI_JACOBIEN='NON', ) # CREATION D'UN MATERIAU BIDON POUR CREA_RESU __MATBID = DEFI_MATERIAU(ELAS=_F(E=1., NU=0.3, RHO=1.)) __MATST = AFFE_MATERIAU( MAILLAGE=__mail_2, AFFE=_F( MATER=__MATBID, TOUT='OUI', ), ) # OBTENTION DU CHAMP DES CONTRAINTES STATIQUE SUR LE MODELE AUXILAIRE # CREATION D'UN RESULTAT AVEC MATERIAU BIDON POUR CALCUL DE SIRO_ELEM __instFS = RESULTAT_PESANTEUR.LIST_PARA()['INST'][-1] __CSTPGO = CREA_CHAMP( OPERATION='EXTR', NOM_CHAM='SIEF_ELGA', TYPE_CHAM='ELGA_SIEF_R', RESULTAT=RESULTAT_PESANTEUR, INST=__instFS, ) __CSTPGF = PROJ_CHAMP( METHODE='ECLA_PG', CHAM_GD=__CSTPGO, MODELE_1=__modST, MODELE_2=__MODST, CAS_FIGURE='2D', PROL_ZERO='OUI', # DISTANCE_MAX=0.1, ) #### CREATION DU RESULTAT STATIQUE AVEC CHAMP SIEF_ELGA PROJETE SUR LE MAILLAGE PATCH __recoST = CREA_RESU( OPERATION='AFFE', TYPE_RESU='DYNA_TRANS', NOM_CHAM='SIEF_ELGA', AFFE=(_F( MODELE=__MODST, CHAM_MATER=__MATST, CHAM_GD=__CSTPGF, INST=0., ), ), ) __recoST = CALC_CHAMP( reuse=__recoST, RESULTAT=__recoST, GROUP_MA='LIGNE_', MODELE=__MODST, CONTRAINTE=('SIRO_ELEM', ), ) #### EXTRACTION DES COMPOSANTES DE SIRO_ELEM DU CALCUL STATIQUE __CSIST = CREA_CHAMP( OPERATION='EXTR', NOM_CHAM='SIRO_ELEM', TYPE_CHAM='ELEM_SIEF_R', RESULTAT=__recoST, NUME_ORDRE=1, ) SIGN_stat = __CSIST.EXTR_COMP('SIG_N', []) SIGTN_stat = __CSIST.EXTR_COMP('SIG_TN', []) ##### CHAMPS PHI ET COHESION POUR CALCUL DE STABILITE STATIQUE __chPHNO = PROJ_CHAMP( METHODE='COLLOCATION', CHAM_GD=args['CHAM_PHI'], MAILLAGE_1=__mail, MAILLAGE_2=__mail_2, PROL_ZERO='OUI', # DISTANCE_MAX=0.1, ) __chPHEL = CREA_CHAMP( OPERATION='DISC', CHAM_GD=__chPHNO, MODELE=__MODST, TYPE_CHAM='ELEM_NEUT_R', PROL_ZERO='OUI', ) __chCONO = PROJ_CHAMP( METHODE='COLLOCATION', CHAM_GD=args['CHAM_COHESION'], MAILLAGE_1=__mail, MAILLAGE_2=__mail_2, PROL_ZERO='OUI', # DISTANCE_MAX=0.1, ) __chCOEL = CREA_CHAMP( OPERATION='DISC', CHAM_GD=__chCONO, MODELE=__MODST, TYPE_CHAM='ELEM_NEUT_R', PROL_ZERO='OUI', #INFO=2, ) __chCPEL = CREA_CHAMP( OPERATION='ASSE', TYPE_CHAM='ELEM_NEUT_R', MODELE=__MODST, PROL_ZERO='OUI', ASSE=( _F( GROUP_MA='LIGNE_', CHAM_GD=__chPHEL, CUMUL='OUI', COEF_R=1., ), _F( GROUP_MA='LIGNE_', CHAM_GD=__chCOEL, CUMUL='OUI', COEF_R=1., ), ), ) ##### CHAMP DES VALEURS PHI ET COHESION SUR LA LIGNE DE GLISSEMENT __chCPLG = PROJ_CHAMP( METHODE='COLLOCATION', CHAM_GD=__chCPEL, MODELE_1=__MODST, MODELE_2=__MODL, CAS_FIGURE='1.5D', PROL_ZERO='OUI', INFO=2, # DISTANCE_MAX=0.1, ) ##### CALCUL DU FACTEUR DE SECURITE STATIQUE LOCAL __FstS = FORMULE(VALE='get_local_FS(SIG_N,SIG_TN,X1,X2)', NOM_PARA=('SIG_N', 'SIG_TN', 'X1', 'X2'), get_local_FS=get_local_FS) __chSTSF = CREA_CHAMP( OPERATION='AFFE', TYPE_CHAM='ELEM_NEUT_F', MODELE=__MODST, PROL_ZERO='OUI', AFFE=_F( GROUP_MA='LIGNE_', NOM_CMP='X1', VALE_F=__FstS, ), ) __chSTSR = CREA_CHAMP( TYPE_CHAM='ELEM_NEUT_R', OPERATION='EVAL', CHAM_F=__chSTSF, CHAM_PARA=(__CSIST, __chCPEL), INFO=1, ) __chSTSL = PROJ_CHAMP( METHODE='COLLOCATION', CHAM_GD=__chSTSR, MODELE_1=__MODST, MODELE_2=__MODL, CAS_FIGURE='1.5D', PROL_ZERO='OUI', INFO=2, # DISTANCE_MAX=0.1, ) ####### CALCUL DU FACTEUR DE SECURITE STATIQUE GLOBAL phiL = __chCPLG.EXTR_COMP('X1', []) cohesionL = __chCPLG.EXTR_COMP('X2', []) available_shear, static_shear = get_static_shear( SIGN_stat.valeurs, SIGTN_stat.valeurs, phiL.valeurs, cohesionL.valeurs) available_shear_v, static_shear_v = get_static_shear_vector( SIGN_stat.valeurs, SIGTN_stat.valeurs, phiL.valeurs, cohesionL.valeurs) FSp = available_shear / (static_shear) FSpL = [] for k in range(len(available_shear_v)): try: FSpL.append(available_shear_v[k] / (static_shear_v[k])) except: FSpL.append(0.) #### PREPARATION TABLE DU FACTEUR DE SECURITE if args['RESULTAT'] is None: tabini = Table(para=["INST", "FS"], typ=["R", "R"]) if args['RESULTAT'] is None: tabini.append({'INST': 0.0, 'FS': FSp}) self.register_result(__chSTSL, args["CHAM_FS"]) dprod = tabini.dict_CREA_TABLE() tabout = CREA_TABLE(**dprod) ############################################################################### #### #### CALCUL POUR RESULTAT DYNAMIQUE #### ############################################################################### if args['RESULTAT'] is not None: ##### OPERATIONS SUR LE MAILLAGE DYNAMIQUE POUR CALCUL DU CENTRE DE MASSE DE LA ZONE ##### QUI GLISSE ### AJOUT DU GROUPE GLISSE DANS LE MAILLAGE if TYPE == 'CERCLE': __mail = DEFI_GROUP( reuse=__mail, MAILLAGE=__mail, CREA_GROUP_MA=_F( NOM='GLISSE_', #TYPE_MAILLE = '2D', OPTION='SPHERE', POINT=(posx, posy), RAYON=r), ) ### Si maillage de la zone de rupture fourni, il faut pouvoir trouver les mailles elif TYPE == 'MAILLAGE': DEFI_GROUP(reuse=__mail, MAILLAGE=__mail, CREA_GROUP_NO=_F(NOM='GLISSE_', OPTION='INCLUSION', MAILLAGE_INCL=__mail_2, GROUP_MA_INCL='RUPTURE', GROUP_MA='ALL', CAS_FIGURE='2D')) __mail = DEFI_GROUP(reuse=__mail, MAILLAGE=__mail, CREA_GROUP_MA=_F( NOM='GLISSE_', OPTION='APPUI', TYPE_APPUI='AU_MOINS_UN', GROUP_NO='GLISSE_', )) __mail = DEFI_GROUP( reuse=__mail, MAILLAGE=__mail, CREA_GROUP_MA=_F( NOM='GLISSE', #TYPE_MAILLE = '2D', INTERSEC=('GLISSE_', 'ALL'), ), ) __mail = DEFI_GROUP(reuse=__mail, MAILLAGE=__mail, CREA_GROUP_NO=_F(GROUP_MA='GLISSE')) #### Calcul de la masse de la zone qui glisse à partir du GROUP_MA 'GLISSE' __tabmas = POST_ELEM( RESULTAT=RESULTAT, MASS_INER=_F(GROUP_MA='GLISSE'), ) masse = __tabmas['MASSE', 1] cdgx = __tabmas['CDG_X', 1] cdgy = __tabmas['CDG_Y', 1] ############################################################################## ## METHODE : CALCUL DE L'ACCELERATION MOYENNE A PARTIR DE LA RESULTANTE ## LE LONG DE LA SURFACE DE GLISSEMENT ############################################################################## #### Il faut que SIEF_ELGA soit prélablement calculé par l'utilisateur __RESU3 = CALC_CHAMP( RESULTAT=RESULTAT, MODELE=__model, CHAM_MATER=__ch_mat, FORCE=('FORC_NODA'), #CONTRAINTE = ('SIEF_ELGA',), ) ##### Calcul de la résultante sur la ligne de glissement du calcul dynamique if TYPE == 'CERCLE': __tabFLI = MACR_LIGN_COUPE( RESULTAT=__RESU3, NOM_CHAM='FORC_NODA', LIGN_COUPE=_F(TYPE='ARC', OPERATION='EXTRACTION', RESULTANTE=('DX', 'DY'), NB_POINTS=1000, CENTRE=(posx, posy), COOR_ORIG=(posx - r, posy), ANGLE=360.), ) elif TYPE == 'MAILLAGE': ### CHAMP FORC_NODA POUR CALCUL RESULTANTE __recou = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT=__RESU3, MAILLAGE_1=__mail, MAILLAGE_2=__mail_2, TYPE_CHAM='NOEU', NOM_CHAM=('FORC_NODA'), PROL_ZERO='OUI', # DISTANCE_MAX=0.1, ) #### TABLE AVEC RESULTANTE CALCUL DYNAMIQUE DANS LE REPERE GLOBAL #### UTILISE POUR CALCUL DE L'ACCELERATION MOYENNE __tabitm = POST_RELEVE_T(ACTION=_F( INTITULE='RESU', OPERATION='EXTRACTION', GROUP_NO='LIGNE_', RESULTANTE=('DX', 'DY'), RESULTAT=__recou, NOM_CHAM='FORC_NODA', ), ) dictab = __tabitm.EXTR_TABLE() if 'RESU' in dictab.para: del dictab['RESU'] if 'NOEUD' in dictab.para: del dictab['NOEUD'] dprod = dictab.dict_CREA_TABLE() __tabFLI = CREA_TABLE(**dprod) # IMPR_TABLE(TABLE = __tabFLI,UNITE=10) ################################################################################ #### #### CALCUL FACTEUR DE SECURITE EN DYNAMIQUE (uniquemnt si RESULTAT_PESANTEUR est fourni) #### Dans ce cas, il faut qu'une phase statique prélable au calcul dynamique soit #### réalisé, afin que les contraintes du résultat dynamique intégrent les #### contraintes statiques #### ################################################################################ ##### CETTE PARTIE MARCHE UNIQUMENT AVEC MAILLAGE PATCH POUR L'INSTANT if args['RESULTAT_PESANTEUR'] is not None: ### BOUCLE POUR CREATION DU RESULTAT DYNAMIQUE PROJETE DANS LES PG ### DU MODELE AUXILIAIRE (MAILLAGE PATCH) __MODYN = AFFE_MODELE( MAILLAGE=__mail_2, AFFE=(_F( TOUT='OUI', PHENOMENE='MECANIQUE', MODELISATION='D_PLAN', ), ), VERI_JACOBIEN='NON', ) # CREATION D'UN MATERIAU BIDON POUR CREA_RESU __MATBIDD = DEFI_MATERIAU(ELAS=_F(E=1., NU=0.3, RHO=1.)) __MATDYN = AFFE_MATERIAU( MAILLAGE=__mail_2, AFFE=_F( MATER=__MATBIDD, TOUT='OUI', ), ) __instSD = RESULTAT.LIST_PARA()['INST'] __CSDPGI = CREA_CHAMP( OPERATION='EXTR', NOM_CHAM='SIEF_ELGA', TYPE_CHAM='ELGA_SIEF_R', RESULTAT=RESULTAT, INST=__instSD[0], ) __CSDPGF = PROJ_CHAMP( METHODE='ECLA_PG', CHAM_GD=__CSDPGI, MODELE_1=__model, MODELE_2=__MODYN, CAS_FIGURE='2D', PROL_ZERO='OUI', # DISTANCE_MAX=0.1, ) #### CREATION DU RESULTAT DYNAMIQUE AVEC CHAMP SIEF_ELGA PROJETE SUR LE MAILLAGE PATCH __recoSD = CREA_RESU( OPERATION='AFFE', TYPE_RESU='DYNA_TRANS', NOM_CHAM='SIEF_ELGA', AFFE=(_F( MODELE=__MODYN, CHAM_MATER=__MATDYN, CHAM_GD=__CSDPGF, INST=__instSD[0], ), ), ) DETRUIRE(INFO=1, CONCEPT=_F(NOM=(__CSDPGI, __CSDPGF))) for inst in __instSD[1:]: __CSDPGI = CREA_CHAMP( OPERATION='EXTR', NOM_CHAM='SIEF_ELGA', TYPE_CHAM='ELGA_SIEF_R', RESULTAT=RESULTAT, INST=inst, ) __CSDPGF = PROJ_CHAMP( METHODE='ECLA_PG', CHAM_GD=__CSDPGI, MODELE_1=__model, MODELE_2=__MODYN, CAS_FIGURE='2D', PROL_ZERO='OUI', # DISTANCE_MAX=0.1, ) __recoSD = CREA_RESU( reuse=__recoSD, RESULTAT=__recoSD, OPERATION='AFFE', TYPE_RESU='DYNA_TRANS', NOM_CHAM='SIEF_ELGA', AFFE=(_F( MODELE=__MODYN, CHAM_MATER=__MATDYN, CHAM_GD=__CSDPGF, INST=inst, ), ), ) DETRUIRE(INFO=1, CONCEPT=_F(NOM=(__CSDPGI, __CSDPGF))) #### CALCUL DES CHAMPS SIRO_ELEM DANS LA LIGNE DE RUPTURE #### UTILISE POUR ESTIMATION DES CONTRAINTES RESISTANTES ET MOBILISEES __recoSD = CALC_CHAMP( reuse=__recoSD, RESULTAT=__recoSD, GROUP_MA='LIGNE_', MODELE=__MODYN, CONTRAINTE=('SIRO_ELEM', ), ) #### TABLE AVEC CONTRAINTES CALCUL DYNAMIQUE DANS LA LIGNE DE RUPTURE DANS LE REPERE LOCAL #### UTILISE POUR CALCUL DE LA CONTRAINTE DE CISAILLEMENT MOBILISEE SIGN_dyn = [] SIGT_dyn = [] for inst in __instSD: #print ("Instant de calcul = "+str(inst)) __CSISD = CREA_CHAMP( OPERATION='EXTR', NOM_CHAM='SIRO_ELEM', TYPE_CHAM='ELEM_SIEF_R', RESULTAT=__recoSD, INST=inst, ) SIGN_dyna = __CSISD.EXTR_COMP('SIG_N', []) SIGTN_dyna = __CSISD.EXTR_COMP('SIG_TN', []) SIGN_dyn.append(SIGN_dyna) SIGT_dyn.append(SIGTN_dyna) DETRUIRE(INFO=1, CONCEPT=_F(NOM=(__CSISD, ))) #### CALCUL DE LA CONTRAINTE DE CISAILLEMENT MOBILISEE DU CALCUL DYNAMIQUE dynamic_shear = get_dynamic_shear(SIGT_dyn, __instSD) dynamic_shear_v = get_dynamic_shear_vector(SIGT_dyn, __instSD) ##### CALCUL DU FACTEUR DE SECURITE FSp = available_shear / (static_shear - dynamic_shear) FSpL = [] for k in range(len(available_shear_v)): try: FSpL.append(available_shear_v[k] / (static_shear_v[k] - dynamic_shear_v[k])) except: FSpL.append(0.) tabini = Table(para=["INST", "FS"], typ=["R", "R"]) #### PRPARATION TABLE DU FACTEUR DE SECURITE DYNAMIQUE for j in range(len(__instSD)): tabini.append({'INST': __instSD[j], 'FS': FSp[j]}) dprod = tabini.dict_CREA_TABLE() __TFS = CREA_TABLE(**dprod) ################################################################################ #### #### CACUL DE L'ACCELERATION MOYENNE A PARTIR DE LA RESULTANTE ET DE LA MASSE #### DE LA ZONE DE GLISSEMENT #### ################################################################################ fresu = __tabFLI.EXTR_TABLE() forcex = fresu.values()['DX'] forcey = fresu.values()['DY'] time = fresu.values()['INST'] accyFLI = np.array(forcey) / masse accxFLI = np.array(forcex) / masse __accyFL = DEFI_FONCTION(NOM_RESU='ACCE_MOY', NOM_PARA='INST', ABSCISSE=time, ORDONNEE=list(accyFLI)), __accxFL = DEFI_FONCTION(NOM_RESU='ACCE_MOY', NOM_PARA='INST', ABSCISSE=time, ORDONNEE=list(accxFLI)), ############################################################################### ## METHODE DE CORRECTION DE L'ACCELERATION POUR CALCUL DES DÉPLACEMENTS ## IRREVERSIBLES ############################################################################## acc = accyFLI ## Calcul de l'accéleration corrigée par ay ## on compte les valeurs de a>ay de manière à disposer ## du même nombre de valeurs a<ay. Cela servira pour calculer correctement ## les vitesses et les déplacements résiduels. ## Partie à modifier si kh variable accA = np.zeros(len(time)) count = 0 for i in range(len(time)): if acc[i] > ay: accA[i] = acc[i] - ay count = count + 1 else: if count > 0: accA[i] = acc[i] - ay count = count - 1 else: count = 0 # Accélération corigée par ay __accAF = DEFI_FONCTION(NOM_RESU='ACCE', NOM_PARA='INST', ABSCISSE=time, ORDONNEE=list(accA)), __vitAFa = CALC_FONCTION(INTEGRE=_F(FONCTION=__accAF, )) ### Etape de correction de la vitesse à partir de ### l'accéleration. Cette étape permet d'aboutir au signal en vitesse ### avec uniquement v >0 pour intégration vers les déplacements résiduels vitAFv = __vitAFa.Ordo() vitA = np.zeros(len(time)) ind = [False] * len(time) eps = 1e-9 for i in range(len(time) - 1): if (vitAFv[i + 1] - vitAFv[i]) > eps or (vitAFv[i + 1] - vitAFv[i]) < (-1.) * eps: vitA[i] = vitAFv[i] ind[i] = True initial = True vini = 0. for i in range(len(time)): if ind[i]: vitA[i] = vitA[i] - vini initial = False else: initial = True vini = vitAFv[i] ##print vini for i in range(len(time)): if vitA[i] < 0: vitA[i] = 0. __vitAF = DEFI_FONCTION(NOM_RESU='VITE', NOM_PARA='INST', ABSCISSE=time, ORDONNEE=list(vitA)), __deplAF = CALC_FONCTION(INTEGRE=_F(FONCTION=__vitAF, )) ## CREATION DE LA TABLE DE SORTIE __tabaAF = CREA_TABLE(FONCTION=_F(FONCTION=__accAF), ) __tabvAF = CREA_TABLE(FONCTION=_F(FONCTION=__vitAF), ) __tabdAF = CREA_TABLE(FONCTION=_F(FONCTION=__deplAF), ) tabout = CREA_TABLE(FONCTION=_F(FONCTION=__accyFL), ) act_table = [] act_table.append(_F(OPERATION='COMB', TABLE=__tabaAF, NOM_PARA='INST'), ) act_table.append(_F(OPERATION='COMB', TABLE=__tabvAF, NOM_PARA='INST'), ) act_table.append(_F(OPERATION='COMB', TABLE=__tabdAF, NOM_PARA='INST'), ) tabout = CALC_TABLE(reuse=tabout, TABLE=tabout, ACTION=act_table) if args['RESULTAT_PESANTEUR'] is not None: tabout = CALC_TABLE( TABLE=tabout, ACTION=_F(OPERATION='COMB', TABLE=__TFS, NOM_PARA='INST'), ) ##### NETTOYAGE DES GROUPES DE MAILLE GENERES __mail = DEFI_GROUP( reuse=__mail, MAILLAGE=__mail, DETR_GROUP_MA=_F(NOM=('ALL', ), ), ) if args['RESULTAT'] is not None: __mail = DEFI_GROUP( reuse=__mail, MAILLAGE=__mail, DETR_GROUP_MA=_F(NOM=( 'GLISSE_', 'GLISSE', ), ), DETR_GROUP_NO=_F(NOM=('GLISSE', ), ), ) if TYPE == 'MAILLAGE': __mail = DEFI_GROUP( reuse=__mail, MAILLAGE=__mail, DETR_GROUP_NO=_F(NOM=('GLISSE_'), ), ) __mail_1 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, DETR_GROUP_MA=_F(NOM=('RUPTURE', 'ALL'), ), ) __mail_1 = DEFI_GROUP(reuse=__mail_1, MAILLAGE=__mail_1, DETR_GROUP_NO=_F(NOM=( 'LIGNE_', 'DOMAIN_', ), ), DETR_GROUP_MA=_F(NOM=( 'LIGNE_', 'DOMAIN_', ), )) if args['GROUP_MA_LIGNE'] is None: if yaseg2 == 'OUI': __mail_1 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, DETR_GROUP_NO=_F(NOM=('LIGNE_2', ), ), ) if yaseg3 == 'OUI': __mail_1 = DEFI_GROUP( reuse=__mail_1, MAILLAGE=__mail_1, DETR_GROUP_NO=_F(NOM=('LIGNE_3', ), ), ) RetablirAlarme('MODELE1_63') RetablirAlarme('MODELE1_64') return tabout
def post_erreur_ops(self, OPTION, CHAM_GD, MODELE, GROUP_MA, **args): """ Macro POST_ERREUR permettant de calculer les erreurs en termes de norme en énergie, norme L2 du déplacement et norme L2 de la pression de contact """ # On importe les definitions des commandes a utiliser dans la macro # Le nom de la variable doit etre obligatoirement le nom de la commande # récupération du phenomene _, _, phenomene = aster.dismoi('PHENOMENE', MODELE.getName(), 'MODELE', 'F') # seul le phénomène mécanique est pris en charge if (phenomene != 'MECANIQUE'): UTMESS('F', 'PREPOST_11') # le modele comporte-t-il des fissures X-FEM ? _, nfismo, _ = aster.dismoi('NB_FISS_XFEM', MODELE.getName(), 'MODELE', 'F') lxfem = nfismo > 0 # récupération du maillage inclus dans le modele __MA = MODELE.getMesh() # récupération de la dimension géométrique dime = __MA.getDimension() # extraction des coordonnées des noeuds du maillage __CHXN = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_GEOM_R', NOM_CHAM='GEOMETRIE', MAILLAGE=__MA, INFO=1) # calcul des coordonnées des points d'intégration des éléments du maillage __CHXG = CREA_CHAMP( OPERATION='DISC', TYPE_CHAM='ELGA_GEOM_R', PROL_ZERO='OUI', CHAM_GD=__CHXN, MODELE=MODELE, ) # si un seul GROUP_MA, on le convertit en liste # if type(GROUP_MA) not in (list, tuple): # GROUP_MA = [GROUP_MA] # recuperation du nombre de groupes nb_group = len(GROUP_MA) # creation de la fonction nulle if (dime == 3): __ZERO = FORMULE(NOM_PARA=('X', 'Y', 'Z'), VALE='0.') else: __ZERO = FORMULE(NOM_PARA=('X', 'Y'), VALE='0.') if (OPTION == 'DEPL_RELA'): # 1. création du champ de fonctions solution analytiques au points d'intégration l_DDL = ('DX', 'DY', 'DZ') # récuparation de la liste des fonctions correspondant à DX, DY, DZ # si l'utilisateur n'a pas renseigné une fonction, on prend la fonction nulle # on associe chaque composantes du vecteur des deplacements (DX, DY, DZ) # a la liste de fonctions donnees par l'utlisateur. Si l'uilisateur n'a pas renseigné une # composante, elle sera pas prise en compte dans l'evaluation de la solution analytique # dictionnaire associant une composante a la liste de fonctions correspondantes ddl2func = {} # dictionnaire associant une composante a un indice pour avoir par exemple : # DX -> X1, DY -> X2 ddl2ind = {} i = 1 # boucle sur la liste des composantes (DX, DY, DZ) for ddl in l_DDL: # recuperation de la liste de fonctions associees a la composante courante l_ddl = None if ddl in args: l_ddl = args[ddl] # mise a jour des mappings si la liste existe if l_ddl is not None: # assertion : l'utilisateur associe une et une seule fonction pour chaque groupe if len(l_ddl) != nb_group: UTMESS('F', 'PREPOST_12', valk=ddl) ddl2func[ddl] = l_ddl ddl2ind[ddl] = i i = i + 1 # si l'utilisateur n'a fourni aucune composante, on construit un champ nul if not ddl2func: ddl = l_DDL[0] ddl2func[ddl] = [__ZERO] * nb_group ddl2ind[ddl] = 1 # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur la liste des composantes (DX, DY, DZ) for ddl in ddl2func: l_ddl = ddl2func[ddl] ind = ddl2ind[ddl] # boucle sur la liste des groupes for ig, group in enumerate(GROUP_MA): # creation du mot-clef facteur pour le groupe # et la composante courante d_affe = {} d_affe['GROUP_MA'] = group d_affe['NOM_CMP'] = 'X' + str(ind) d_affe['VALE_F'] = l_ddl[ig] # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_affe)) __UanaFG = CREA_CHAMP( OPERATION='AFFE', TYPE_CHAM='ELGA_NEUT_F', MODELE=MODELE, PROL_ZERO='OUI', AFFE=l_F, ) # 2. Evaluation de la solution analytique aux points d'intégration __UanaG = CREA_CHAMP( OPERATION='EVAL', TYPE_CHAM='ELGA_NEUT_R', CHAM_F=__UanaFG, CHAM_PARA=__CHXG, ) # 3. Conversion du champ solution analytique en champ de déplacement # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur la liste des composantes (DX, DY, DZ) for ddl in ddl2func: ind = ddl2ind[ddl] # boucle sur la liste des groupes for ig, group in enumerate(GROUP_MA): # creation du mot-clef facteur pour le groupe # et le ddl courants d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __UanaG d_asse['NOM_CMP'] = 'X' + str(ind) d_asse['NOM_CMP_RESU'] = ddl # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) __UanaR = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELGA_DEPL_R', MODELE=MODELE, PROL_ZERO='OUI', ASSE=l_F) # 4. création d'un champ contenant les déplacements calculés sur les groupes considérés # cette etape est facile a faire en FEM, mais parait plus delicate en X-FEM ; elle est # donc laisse de cote pour le moment # 5. discrétisation des déplacements calculés aux points d'intégration if not lxfem: __UcalG = CREA_CHAMP( OPERATION='DISC', TYPE_CHAM='ELGA_DEPL_R', MODELE=MODELE, PROL_ZERO='OUI', CHAM_GD=CHAM_GD, ) else: cham_mater = None if 'CHAM_MATER' in args: cham_mater = args['CHAM_MATER'] # dans le cas X-FEM, on assemble le champ de deplacement aux points de Gauss pour # se ramener un champ de la forme (DX, DY, H1X, H1Y, ..., E1X, E1Y, ...) a la forme # (DX, DY, DZ) if cham_mater is None: __UcalG = CREA_CHAMP( OPERATION='ASSE_DEPL', TYPE_CHAM='ELGA_DEPL_R', PROL_ZERO='OUI', CHAM_GD=CHAM_GD, MODELE=MODELE, ) else: __UcalG = CREA_CHAMP( OPERATION='ASSE_DEPL', TYPE_CHAM='ELGA_DEPL_R', PROL_ZERO='OUI', CHAM_MATER=cham_mater, CHAM_GD=CHAM_GD, MODELE=MODELE, ) # 6. création du champ différence entre les déplacements calculés et analytiques # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur les groupes for ig, group in enumerate(GROUP_MA): # boucles sur les ddl DX, DY et DZ for i in range(dime): # creation du mot-clef facteur pour le groupe # et le ddl courants # * traitement des déplacements calculés d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __UcalG d_asse['CUMUL'] = 'OUI' d_asse['COEF_R'] = 1. d_asse['NOM_CMP'] = l_DDL[i] d_asse['NOM_CMP_RESU'] = l_DDL[i] # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) # * traitement des déplacements analytiques d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __UanaR d_asse['CUMUL'] = 'OUI' d_asse['COEF_R'] = -1. d_asse['NOM_CMP'] = l_DDL[i] d_asse['NOM_CMP_RESU'] = l_DDL[i] # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) __UdiffG = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELGA_DEPL_R', MODELE=MODELE, PROL_ZERO='OUI', ASSE=l_F) # calcul de la norme L2 du deplacement pour la solution analytique et le champ difference, pour chaque groupe l_ref_norm = [] l_diff_norm = [] ref_norm_tot = 0. diff_norm_tot = 0. for group in GROUP_MA: # 8. calcul de la norme L2 du champ de déplacement analytique __TanaDEP = POST_ELEM(NORME=(_F( TYPE_NORM='L2', GROUP_MA=group, CHAM_GD=__UanaR, MODELE=MODELE, ), )) # extraction de la norme L2 du champ de déplacement analytique tab = __TanaDEP.EXTR_TABLE() col_ref = getattr(tab, 'VALE_NORM') l_ref = col_ref.values() ref = l_ref[0] # ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement analytiques l_ref_norm.append(ref) # ajout e la contribution du groupe courant a la norme L2 du deplacement analytique totale ref_norm_tot += ref**2 # 9. calcul de la norme L2 du champ de déplacement différence __TdiffDEP = POST_ELEM(NORME=(_F( TYPE_NORM='L2', GROUP_MA=group, CHAM_GD=__UdiffG, MODELE=MODELE, ), )) # extraction de la norme L2 du champ de déplacement difference tab = __TdiffDEP.EXTR_TABLE() col_diff = getattr(tab, 'VALE_NORM') l_diff = col_diff.values() diff = l_diff[0] # ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement difference l_diff_norm.append(diff) # ajout e la contribution du groupe courant a la norme L2 du deplacement difference totale diff_norm_tot += diff**2 # liberation des objets temporaires pour la prochaine iteration DETRUIRE(CONCEPT=_F(NOM=__TanaDEP), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__TdiffDEP), INFO=1) # ajout de normes en energie pour l'ensemble des groupes ref_norm_tot = math.sqrt(ref_norm_tot) l_ref_norm.append(ref_norm_tot) diff_norm_tot = math.sqrt(diff_norm_tot) l_diff_norm.append(diff_norm_tot) # creation de la variable TITRE TITRE = "ERREUR EN NORME L2 DU DEPLACEMENT" # destruction des objets temporaires pour le calcul de l'erreur en deplacement DETRUIRE(CONCEPT=_F(NOM=__UanaFG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__UanaG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__UanaR), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__UcalG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__UdiffG), INFO=1) if (OPTION == 'ENER_RELA'): #Extraction du nom de materiau CHAM_MATER = args['CHAM_MATER'] #Extraction du type de deformation DEFORMATION = args['DEFORMATION'] # 1. création du champ de fonctions solution analytiques au points d'intégration l_SIGM = ('SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ') # récuparation de la liste des fonctions correspondant à SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ # si l'utilisateur n'a pas renseigné une fonction, on prend la fonction nulle # on associe chaque composantes du tenseur des contraintes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ) # a la liste de fonxtions donnees par l'utlisateur. Si l'uilisateur n'a pas renseigné une # composante, elle sera pas prise en compte dans l'evaluation de la solution analytique # dictionnaire associant une composante a la liste de fonctions coreespondantes sig2func = {} # dictionnaire associant une composante a un indice pour avoir par exemple : # SIXX -> X1, SIYY -> X2 sig2ind = {} i = 1 # boucle sur la liste des composantes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ) for sig in l_SIGM: # recuperation de la liste de fonctions associees a la composante courante l_sig = None if sig in args: l_sig = args[sig] # mise a jour des mappings si la liste existe if l_sig is not None: # assertion : l'utilisateur associe une et une seule fonction pour chaque groupe if len(l_sig) != nb_group: UTMESS('F', 'PREPOST_12', valk=sig) sig2func[sig] = l_sig sig2ind[sig] = i i = i + 1 # si l'utilisateur n'a fourni aucune composante, on construit un champ nul if not sig2func: sig = l_SIGM[0] sig2func[sig] = [__ZERO] * nb_group sig2ind[sig] = 1 # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur la liste des composantes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ) for sig in sig2func: l_sig = sig2func[sig] ind = sig2ind[sig] # boucle sur la liste des groupes for ig, group in enumerate(GROUP_MA): # creation du mot-clef facteur pour le groupe # et la composante courante d_affe = {} d_affe['GROUP_MA'] = group d_affe['NOM_CMP'] = 'X' + str(ind) d_affe['VALE_F'] = l_sig[ig] # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_affe)) l_F = tuple(l_F) __SI_ana_F = CREA_CHAMP( OPERATION='AFFE', TYPE_CHAM='ELGA_NEUT_F', MODELE=MODELE, PROL_ZERO='OUI', AFFE=l_F, ) # 2. Evaluation de la solution analytique aux points d'intégration __SanaCHAM = CREA_CHAMP( OPERATION='EVAL', TYPE_CHAM='ELGA_NEUT_R', CHAM_F=__SI_ana_F, CHAM_PARA=__CHXG, ) # 3. Conversion du champ solution analytique en champ de contrainte # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur la liste des composantes (SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ) for sig in sig2func: ind = sig2ind[sig] # boucle sur la liste des groupes for ig, group in enumerate(GROUP_MA): # creation du mot-clef facteur pour le groupe # et le SIGM courants d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __SanaCHAM d_asse['NOM_CMP'] = 'X' + str(ind) d_asse['NOM_CMP_RESU'] = sig # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) __SI_ana_R = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELGA_SIEF_R', MODELE=MODELE, PROL_ZERO='OUI', ASSE=l_F) # 4. création du champ différence entre les contraintes calculés et analytiques # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur les groupes for ig, group in enumerate(GROUP_MA): # boucles sur les composantes: SIXX, SIYY, SIZZ, SIXY, SIXZ, SIYZ for i in range(2 * dime): # creation du mot-clef facteur pour le groupe # et le SIGM courants # * traitement des contraintes calculés d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = CHAM_GD d_asse['CUMUL'] = 'OUI' d_asse['COEF_R'] = 1. d_asse['NOM_CMP'] = l_SIGM[i] d_asse['NOM_CMP_RESU'] = l_SIGM[i] # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) # * traitement des contraintes analytiques d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __SI_ana_R d_asse['CUMUL'] = 'OUI' d_asse['COEF_R'] = -1. d_asse['NOM_CMP'] = l_SIGM[i] d_asse['NOM_CMP_RESU'] = l_SIGM[i] # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) __SI_diff = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELGA_SIEF_R', MODELE=MODELE, PROL_ZERO='OUI', ASSE=l_F) # 5. création d'un champ de deplacement nul partout # ce champ de deplacement est essentiel pour calculer les normes, mais n'aucun impact sur les resultats l_DDL = ('DX', 'DY', 'DZ') # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur les groupes for ig, group in enumerate(GROUP_MA): # boucles sur les ddl DX, DY et DZ for i in range(dime): # creation du mot-clef facteur pour le groupe # et le ddl courants d_affe = {} d_affe['GROUP_MA'] = group d_affe['NOM_CMP'] = l_DDL[i] d_affe['VALE'] = 0. # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_affe)) __U = CREA_CHAMP(OPERATION='AFFE', TYPE_CHAM='NOEU_DEPL_R', MAILLAGE=__MA, AFFE=l_F) # 6. création d'un champ resultat a partir de champ de contrainte analytique __SIanaRES = CREA_RESU( OPERATION='AFFE', TYPE_RESU='EVOL_NOLI', NOM_CHAM='SIEF_ELGA', COMPORTEMENT=(_F( RELATION='ELAS', DEFORMATION=DEFORMATION, ), ), AFFE=_F( CHAM_GD=__SI_ana_R, MODELE=MODELE, CHAM_MATER=CHAM_MATER, INST=(1.0), ), ) __SIanaRES = CREA_RESU( reuse=__SIanaRES, RESULTAT=__SIanaRES, OPERATION='AFFE', TYPE_RESU='EVOL_NOLI', NOM_CHAM='DEPL', COMPORTEMENT=(_F( RELATION='ELAS', DEFORMATION=DEFORMATION, ), ), AFFE=_F( CHAM_GD=__U, MODELE=MODELE, CHAM_MATER=CHAM_MATER, INST=(1.0), ), ) # 7. création d'un champ resultat a partir de champ de contrainte difference __SI_DIFFR = CREA_RESU( OPERATION='AFFE', TYPE_RESU='EVOL_NOLI', NOM_CHAM='SIEF_ELGA', COMPORTEMENT=(_F( RELATION='ELAS', DEFORMATION=DEFORMATION, ), ), AFFE=_F( CHAM_GD=__SI_diff, MODELE=MODELE, CHAM_MATER=CHAM_MATER, INST=(1.0), ), ) __SI_DIFFR = CREA_RESU( reuse=__SI_DIFFR, RESULTAT=__SI_DIFFR, OPERATION='AFFE', TYPE_RESU='EVOL_NOLI', NOM_CHAM='DEPL', COMPORTEMENT=(_F( RELATION='ELAS', DEFORMATION=DEFORMATION, ), ), AFFE=_F( CHAM_GD=__U, MODELE=MODELE, CHAM_MATER=CHAM_MATER, INST=(1.0), ), ) # 8. calcul de l'energie a partir du champ de contraintes analytique __TanaSIG = POST_ELEM( RESULTAT=__SIanaRES, ENER_ELAS=_F(GROUP_MA=GROUP_MA), ) # 9. calcul de l'energie a partir du champ de contraintes difference __TdiffSIG = POST_ELEM( RESULTAT=__SI_DIFFR, ENER_ELAS=_F(GROUP_MA=GROUP_MA), ) #creation de la table finale tab = __TanaSIG.EXTR_TABLE() col_ref = getattr(tab, 'TOTALE') l_ref = col_ref.values() tab = __TdiffSIG.EXTR_TABLE() col_diff = getattr(tab, 'TOTALE') l_diff = col_diff.values() # assertion: les longueurs de l_ref et l_diff sont egales au nombre de groupes ASSERT(len(l_ref) == nb_group and len(l_diff) == nb_group) # calcul des normes en energie pour chaque groupe l_ref_norm = [] l_diff_norm = [] for i in range(nb_group): l_ref_norm.append(math.sqrt(l_ref[i])) l_diff_norm.append(math.sqrt(l_diff[i])) # ajout de normes en energie pour l'ensemble des groupes ref_norm_tot = math.sqrt(sum(l_ref)) l_ref_norm.append(ref_norm_tot) diff_norm_tot = math.sqrt(sum(l_diff)) l_diff_norm.append(diff_norm_tot) # ajout des energies pour l'ensemble des groupes l_ref.append(sum(l_ref)) l_diff.append(sum(l_diff)) # creation de la variable TITRE TITRE = "ERREUR EN NORME ENERGIE" # destruction des objets temporaires pour le calcul de l'erreur en energie DETRUIRE(CONCEPT=_F(NOM=__SI_ana_F), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__SanaCHAM), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__SI_ana_R), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__SI_diff), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__U), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__SIanaRES), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__SI_DIFFR), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__TanaSIG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__TdiffSIG), INFO=1) if (OPTION == 'LAGR_RELA'): # le calcul de la norme L2 de la pression de contact sur une fissure XFEM n'est # pas encore diponible if lxfem: UTMESS('F', 'XFEM_14') # 1. création du champ de fonctions solution analytiques au points d'intégration # récuparation de la liste des fonctions correspondant à LAGS_C # si l'utilisateur n'a pas renseigné une fonction, on prend la fonction nulle l_LAGS = args['LAGS_C'] if l_LAGS is None: l_LAGS = [__ZERO] * nb_group # assertion : ici, on a une et une seule fonction LAGS_C pour chaque groupe if len(l_LAGS) != nb_group: UTMESS('F', 'PREPOST_12', valk="LAGS_C") # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur les groupes for ig, group in enumerate(GROUP_MA): # récupération de la fonction LAGS_C pour le groupe courant LAGS = l_LAGS[ig] # creation du mot-clef facteur pour le groupe # courant d_affe = {} d_affe['GROUP_MA'] = group d_affe['NOM_CMP'] = 'X3' d_affe['VALE_F'] = LAGS # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_affe)) __PanaFG = CREA_CHAMP( OPERATION='AFFE', TYPE_CHAM='ELGA_NEUT_F', MODELE=MODELE, PROL_ZERO='OUI', AFFE=l_F, ) # 2. Evaluation de la solution analytique aux points d'intégration __PanaG = CREA_CHAMP( OPERATION='EVAL', TYPE_CHAM='ELGA_NEUT_R', CHAM_F=__PanaFG, CHAM_PARA=__CHXG, ) # 3. Conversion du champ solution analytique en champ de déplacement # N.B.: L'intégration de la pression asocciée au ddl LAG_C donne 0 ! # On l'associe donc à un autre ddl choisi arbitrairement : DZ. # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur les groupes for ig, group in enumerate(GROUP_MA): # creation du mot-clef facteur pour le groupe # et le ddl courants d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __PanaG d_asse['NOM_CMP'] = 'X3' d_asse['NOM_CMP_RESU'] = 'DZ' # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) __PanaR = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELGA_DEPL_R', MODELE=MODELE, PROL_ZERO='OUI', ASSE=l_F) # 4. création d'un champ contenant les déplacements calculés sur les groupes considérés # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur les groupes for ig, group in enumerate(GROUP_MA): # creation du mot-clef facteur pour le groupe # et le ddl courants d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = CHAM_GD d_asse['NOM_CMP_RESU'] = 'X3' d_asse['NOM_CMP'] = 'LAGS_C' # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) __PcalN = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='NOEU_NEUT_R', MAILLAGE=__MA, ASSE=l_F) # 5. discrétisation des déplacements calculés aux points d'intégration __PcalG = CREA_CHAMP( OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R', MODELE=MODELE, PROL_ZERO='OUI', CHAM_GD=__PcalN, ) # 6. création du champ différence entre les déplacements calculés et analytiques # construction de la liste des mots-clefs facteur pour appeler CREA_CHAMP l_F = [] # boucle sur les groupes for ig, group in enumerate(GROUP_MA): # * traitement des déplacements calculés d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __PcalG d_asse['CUMUL'] = 'OUI' d_asse['COEF_R'] = 1. d_asse['NOM_CMP'] = 'X3' d_asse['NOM_CMP_RESU'] = 'DZ' # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) # * traitement des déplacements analytiques d_asse = {} d_asse['GROUP_MA'] = group d_asse['CHAM_GD'] = __PanaG d_asse['CUMUL'] = 'OUI' d_asse['COEF_R'] = -1. d_asse['NOM_CMP'] = 'X3' d_asse['NOM_CMP_RESU'] = 'DZ' # stockage du mot-clef facteur dans la liste l_F.append(_F(**d_asse)) __PdiffG = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELGA_DEPL_R', MODELE=MODELE, PROL_ZERO='OUI', ASSE=l_F) # calcul de la norme L2 du deplacement pour la solution analytique et le champ difference, pour chaque groupe l_ref_norm = [] l_diff_norm = [] ref_norm_tot = 0. diff_norm_tot = 0. for group in GROUP_MA: # 8. calcul de la norme L2 du champ de déplacement analytique __TanaP = POST_ELEM(NORME=(_F( TYPE_NORM='L2', GROUP_MA=group, CHAM_GD=__PanaR, MODELE=MODELE, ), )) # extraction de la norme L2 du champ de déplacement analytique tab = __TanaP.EXTR_TABLE() col_ref = getattr(tab, 'VALE_NORM') l_ref = col_ref.values() ref = l_ref[0] # ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement analytiques l_ref_norm.append(ref) # ajout e la contribution du groupe courant a la norme L2 du deplacement analytique totale ref_norm_tot += ref**2 # 9. calcul de la norme L2 du champ de déplacement différence __TdiffP = POST_ELEM(NORME=(_F( TYPE_NORM='L2', GROUP_MA=group, CHAM_GD=__PdiffG, MODELE=MODELE, ), )) # extraction de la norme L2 du champ de déplacement difference tab = __TdiffP.EXTR_TABLE() col_diff = getattr(tab, 'VALE_NORM') l_diff = col_diff.values() diff = l_diff[0] # ajout de la contribution du groupe courant a la liste des normes L2 des champs de déplacement difference l_diff_norm.append(diff) # ajout e la contribution du groupe courant a la norme L2 du deplacement difference totale diff_norm_tot += diff**2 # liberation des objets temporaires pour la prochaine iteration DETRUIRE(CONCEPT=_F(NOM=__TanaP), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__TdiffP), INFO=1) # ajout de normes en energie pour l'ensemble des groupes ref_norm_tot = math.sqrt(ref_norm_tot) l_ref_norm.append(ref_norm_tot) diff_norm_tot = math.sqrt(diff_norm_tot) l_diff_norm.append(diff_norm_tot) # creation de la variable TITRE TITRE = "ERREUR EN NORME L2 DE LA PRESSION" # destruction des objets temporaires pour le calcul de l'erreur en deplacement DETRUIRE(CONCEPT=_F(NOM=__PanaFG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__PanaG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__PanaR), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__PcalN), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__PcalG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__PdiffG), INFO=1) # ici, quelle que soit la norme considérée, les objets suivants sont définis : # * l_diff_norm : liste des normes du champ différence, pour chaque groupe + # norme du champ différence sur l'union des groupes # creation de la liste GROUP_MA + "TOTAL" l_group = list(GROUP_MA) l_group.append("TOTAL") if (OPTION == 'ENER_RELA'): tabout = CREA_TABLE( LISTE=( _F(LISTE_K=l_group, PARA="GROUP_MA"), _F( LISTE_R=l_diff, PARA="DIFFERENCE", ), _F( LISTE_R=l_ref, PARA="REFERENCE", ), ), TITRE=TITRE, ) else: tabout = CREA_TABLE( LISTE=( _F(LISTE_K=l_group, PARA="GROUP_MA"), _F( LISTE_R=l_diff_norm, PARA="DIFFERENCE", ), _F( LISTE_R=l_ref_norm, PARA="REFERENCE", ), ), TITRE=TITRE, ) # on ne calcule l'erreur relative que si la reference est non nulle if ref_norm_tot > 1.e-16: __Terr = CREA_TABLE(LISTE=( _F(LISTE_K=("TOTAL"), PARA="GROUP_MA"), _F(LISTE_R=(diff_norm_tot / ref_norm_tot), PARA="ERREUR RELATIVE"))) tabout = CALC_TABLE( reuse=tabout, TABLE=tabout, ACTION=_F(OPERATION="COMB", TABLE=__Terr, NOM_PARA="GROUP_MA"), TITRE=TITRE, ) # destruction des objets temporaires generiques # N.B.: __MA est une reference au maillage, il ne faut pas le detruire ! DETRUIRE(CONCEPT=_F(NOM=__CHXN), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__CHXG), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__ZERO), INFO=1) return tabout
if RESU_ET: self.DeclareOut("__resuet", RESU_ET) __resuet = REST_GENE_PHYS(RESU_GENE=__PROJ, TOUT_ORDRE='OUI', NOM_CHAM=NOM_CHAM) # Restriction des modes mesures etendus sur le maillage capteur # ------------------------------------------------------------- if RESU_RD: self.DeclareOut("__resurd", RESU_RD) nume = None if NUME_DDL: nume = NUME_DDL if not nume: iret, ibid, tmp = aster.dismoi('NUME_DDL', self.nom, 'RESU_DYNA', 'C') if iret == 0: tmp = tmp.strip() if tmp: nume = self.get_concept(tmp) else: UTMESS('A', 'CALCESSAI0_5') __resurd = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT=__resuet, MODELE_1=MOD_CALCUL, MODELE_2=MOD_MESURE, NOM_CHAM=NOM_CHAM, TOUT_ORDRE='OUI', NUME_DDL=nume, VIS_A_VIS=_F(
def check(self): """Vérification des règles impossible à écrire dans le .capy""" # tâches à la demande if self['TYPE_RESU'] in ('HARM_GENE', 'TRAN_GENE', 'TABLE', 'CHARGE'): self.set('_calc_impe', True) self.set('_calc_forc', True) elif self['TYPE_RESU'] in ('FICHIER', 'TABLE_CONTROL'): if self.get('UNITE_RESU_IMPE') is not None: self.set('_calc_impe', True) if self.get('UNITE_RESU_FORC') is not None: self.set('_calc_forc', True) else: if self['EXCIT_SOL'] is not None: self.set('_calc_forc', True) self.set('_hasPC', self.get('GROUP_MA_CONTROL') is not None) self.set('_hasSL', self.get('GROUP_MA_SOL_SOL') is not None) # unités logiques if self.get('UNITE_RESU_IMPE') is None: self.set('_exec_Miss', True) self['UNITE_RESU_IMPE'] = self.UL.Libre( action='ASSOCIER', ascii=self._keywords['TYPE'] == 'ASCII', new=True) elif self['TYPE_RESU'] in ('TABLE_CONTROL', ): self.set('_exec_Miss', True) if self.get('UNITE_RESU_FORC') is None: self.set('_exec_Miss', True) self['UNITE_RESU_FORC'] = self.UL.Libre(action='ASSOCIER', new=True) elif self['TYPE_RESU'] in ('TABLE_CONTROL', ): self.set('_exec_Miss', True) # fréquences if self['TYPE_RESU'] not in ('CHARGE', ): if (self['LIST_FREQ'] is not None and self['TYPE_RESU'] not in ('FICHIER', 'HARM_GENE', 'TABLE_CONTROL')): UTMESS('F', 'MISS0_17') # récupération des infos sur les modes if self['BASE_MODALE']: basemo = self['BASE_MODALE'].getName() elif self['MACR_ELEM_DYNA']: basemo = self['MACR_ELEM_DYNA'].sdj.MAEL_REFE.get()[0] else: ASSERT(False) res = aster.dismoi('NB_MODES_TOT', basemo, 'RESULTAT', 'C') ASSERT(res[0] == 0) self['NBM_TOT'] = res[1] res = aster.dismoi('NB_MODES_STA', basemo, 'RESULTAT', 'C') ASSERT(res[0] == 0) self['NBM_STA'] = res[1] res = aster.dismoi('NB_MODES_DYN', basemo, 'RESULTAT', 'C') ASSERT(res[0] == 0) self['NBM_DYN'] = res[1] # si base modale, vérifier/compléter les amortissements réduits if self['BASE_MODALE']: if self['AMOR_REDUIT']: self.set('AMOR_REDUIT', force_list(self['AMOR_REDUIT'])) nval = len(self['AMOR_REDUIT']) if nval < self['NBM_DYN']: # complète avec le dernier nadd = self['NBM_DYN'] - nval self._keywords['AMOR_REDUIT'].extend([ self['AMOR_REDUIT'][-1], ] * nadd) nval = self['NBM_DYN'] if nval < self['NBM_DYN'] + self['NBM_STA']: # on ajoute 0. self._keywords['AMOR_REDUIT'].append(0.) # la règle ENSEMBLE garantit que les 3 GROUP_MA_xxx sont tous absents # ou tous présents if self['ISSF'] != 'NON': if self['GROUP_MA_FLU_STR'] is None: UTMESS('F', 'MISS0_22') if self['MATER_FLUIDE'] is None: UTMESS('F', 'MISS0_23')
def macro_elas_mult_ops(self, MODELE, CHAM_MATER, CARA_ELEM, NUME_DDL, CHAR_MECA_GLOBAL, LIAISON_DISCRET, CAS_CHARGE, SOLVEUR, **args): """ Ecriture de la macro MACRO_ELAS_MULT """ ier = 0 import types import aster from code_aster.Cata.Syntax import _F from Utilitai.Utmess import UTMESS # On met le mot cle NUME_DDL dans une variable locale pour le proteger numeddl = NUME_DDL # On importe les definitions des commandes a utiliser dans la macro CALC_MATR_ELEM = self.get_cmd('CALC_MATR_ELEM') NUME_DDL = self.get_cmd('NUME_DDL') ASSE_MATRICE = self.get_cmd('ASSE_MATRICE') FACTORISER = self.get_cmd('FACTORISER') CALC_VECT_ELEM = self.get_cmd('CALC_VECT_ELEM') ASSE_VECTEUR = self.get_cmd('ASSE_VECTEUR') RESOUDRE = self.get_cmd('RESOUDRE') CREA_RESU = self.get_cmd('CREA_RESU') CALC_CHAMP = self.get_cmd('CALC_CHAMP') CALCUL = self.get_cmd('CALCUL') EXTR_TABLE = self.get_cmd('EXTR_TABLE') DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # Le concept sortant (de type mult_elas ou fourier_elas) est nommé # 'nomres' dans le contexte de la macro self.DeclareOut('nomres', self.sd) ielas = 0 ifour = 0 for m in CAS_CHARGE: if m['NOM_CAS']: ielas = 1 # mot clé NOM_CAS présent sous CAS_CHARGE tyresu = 'MULT_ELAS' else: ifour = 1 # mot clé MODE_FOURIER présent sous CAS_CHARGE tyresu = 'FOURIER_ELAS' if ielas == 1 and ifour == 1: UTMESS('F', 'ELASMULT0_1') if (numeddl in self.sdprods) or (numeddl == None): # Si le concept numeddl est dans self.sdprods ou n est pas nommé # il doit etre produit par la macro # il faudra donc appeler la commande NUME_DDL lnume = 1 else: lnume = 0 if ielas == 1: motscles = {} if CHAR_MECA_GLOBAL: motscles['CHARGE'] = CHAR_MECA_GLOBAL if CHAM_MATER: motscles['CHAM_MATER'] = CHAM_MATER if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM __nomrig = CALC_MATR_ELEM( OPTION='RIGI_MECA', MODELE=MODELE, **motscles) if lnume: # On peut passer des mots cles egaux a None. Ils sont ignores motscles = {} if numeddl != None: self.DeclareOut('num', numeddl) num = NUME_DDL(MATR_RIGI=__nomrig, **motscles) else: _num = NUME_DDL(MATR_RIGI=__nomrig, **motscles) num = _num else: num = numeddl __nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num) __nomras = FACTORISER(reuse=__nomras, MATR_ASSE=__nomras, NPREC =SOLVEUR['NPREC'], STOP_SINGULIER =SOLVEUR['STOP_SINGULIER'], METHODE =SOLVEUR['METHODE'], RENUM =SOLVEUR['RENUM'], ) # # boucle sur les items de CAS_CHARGE nomchn = [] lcharg = [] iocc = 0 for m in CAS_CHARGE: iocc = iocc + 1 # calcul de lcharg : liste des listes de char_meca (mots clé CHAR_MECA # et CHAR_MECA_GLOBAL) xx1 = m['CHAR_MECA'] if type(xx1) != type((1,)): xx1 = (xx1,) xx2 = CHAR_MECA_GLOBAL if type(xx2) != type((1,)): xx2 = (xx2,) lchar1 = [] for chargt in (xx1 + xx2): if chargt: lchar1.append(chargt) lcharg.append(lchar1) assert len(lchar1) > 0 if ifour: motscles = {} if CHAR_MECA_GLOBAL: motscles['CHARGE'] = CHAR_MECA_GLOBAL if CHAM_MATER: motscles['CHAM_MATER'] = CHAM_MATER if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM motscles['MODE_FOURIER'] = m['MODE_FOURIER'] __nomrig = CALC_MATR_ELEM( OPTION='RIGI_MECA', MODELE=MODELE, **motscles) if lnume: _num = NUME_DDL(MATR_RIGI=__nomrig, ) num = _num lnume = 0 __nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num) __nomras = FACTORISER(reuse=__nomras, MATR_ASSE=__nomras, NPREC =SOLVEUR['NPREC'], STOP_SINGULIER =SOLVEUR['STOP_SINGULIER'], METHODE =SOLVEUR['METHODE'], RENUM =SOLVEUR['RENUM'], ) if m['VECT_ASSE'] == None: motscles = {} l_calc_varc = False if CHAM_MATER: motscles['CHAM_MATER'] = CHAM_MATER iret, ibid, answer = aster.dismoi('EXI_VARC', CHAM_MATER.nom, 'CHAM_MATER', 'F') if answer == 'OUI': l_calc_varc = True if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM if ifour: motscles['MODE_FOURIER'] = m['MODE_FOURIER'] if len(lchar1) > 0: motscles['CHARGE'] = lchar1 __nomvel = CALC_VECT_ELEM(OPTION='CHAR_MECA', **motscles) # chargement du aux variables de commandes if l_calc_varc : motscles = {} if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM if ifour: motscles['MODE_FOURIER'] = m['MODE_FOURIER'] __list1=DEFI_LIST_REEL(DEBUT=0.0, INTERVALLE=_F(JUSQU_A=1.0, NOMBRE=1,),); if CHAR_MECA_GLOBAL : excit = [] for ch in CHAR_MECA_GLOBAL: excit.append({'CHARGE' : ch}) __cont1=CALCUL(OPTION=('FORC_VARC_ELEM_P'), MODELE=MODELE, CHAM_MATER = CHAM_MATER, INCREMENT=_F(LIST_INST=__list1, NUME_ORDRE=1), EXCIT=excit, COMPORTEMENT=_F(RELATION='ELAS',), **motscles ) else: __cont1=CALCUL(OPTION=('FORC_VARC_ELEM_P'), MODELE=MODELE, CHAM_MATER = CHAM_MATER, INCREMENT=_F(LIST_INST=__list1, NUME_ORDRE=1), COMPORTEMENT=_F(RELATION='ELAS',), **motscles ) __vvarcp=EXTR_TABLE(TYPE_RESU='VECT_ELEM_DEPL_R', TABLE=__cont1, NOM_PARA='NOM_SD', FILTRE=_F(NOM_PARA='NOM_OBJET', VALE_K='FORC_VARC_ELEM_P'),) __nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel,__vvarcp), NUME_DDL=num) else: __nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel,), NUME_DDL=num) else: __nomasv = m['VECT_ASSE'] __nomchn = RESOUDRE( MATR=__nomras, CHAM_NO=__nomasv, TITRE=m['SOUS_TITRE']) nomchn.append(__nomchn) # fin de la boucle sur les items de CAS_CHARGE # motscles = {} iocc = 0 motscle2 = {} if CHAM_MATER: motscle2['CHAM_MATER'] = CHAM_MATER iret, ibid, nom_ma = aster.dismoi('EXI_VARC', CHAM_MATER.nom, 'CHAM_MATER', 'F') print 'toto:',nom_ma if CARA_ELEM: motscle2['CARA_ELEM'] = CARA_ELEM if ielas: motscles['AFFE'] = [] for m in CAS_CHARGE: if len(lcharg[iocc]) > 0: motscles['AFFE'].append(_F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NOM_CAS=m['NOM_CAS'], CHARGE=lcharg[iocc], **motscle2)) else: motscles['AFFE'].append(_F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NOM_CAS=m['NOM_CAS'], **motscle2)) iocc = iocc + 1 else: motscles['AFFE'] = [] for m in CAS_CHARGE: if len(lcharg[iocc]) > 0: motscles['AFFE'].append(_F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NUME_MODE=m['MODE_FOURIER'], TYPE_MODE=m['TYPE_MODE'], CHARGE=lcharg[iocc], **motscle2)) else: motscles['AFFE'].append(_F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NUME_MODE=m['MODE_FOURIER'], TYPE_MODE=m['TYPE_MODE'], **motscle2)) iocc = iocc + 1 if self.reuse: motscles['reuse'] = self.reuse nomres = CREA_RESU( OPERATION='AFFE', TYPE_RESU=tyresu, NOM_CHAM='DEPL', **motscles) # # boucle sur les items de CAS_CHARGE pour SIEF_ELGA iocc = 0 for m in CAS_CHARGE: iocc = iocc + 1 if m['OPTION'] == 'SIEF_ELGA': motscles = {} if ielas: motscles['NOM_CAS'] = m['NOM_CAS'] else: motscles['NUME_MODE'] = m['MODE_FOURIER'] CALC_CHAMP(reuse=nomres, RESULTAT=nomres, CONTRAINTE='SIEF_ELGA', **motscles) # fin de la boucle sur les items de CAS_CHARGE # return ier
def calc_gp_ops(self, **args): """Corps de CALC_GP""" MasquerAlarme('CALCCHAMP_1') global DEFI_GROUP # On importe les definitions des commandes a utiliser dans la macro # # # RECUPERATION DU MODELE, DU MAILLAGE ET DU MATERIAU A PARTIR DU RESULTAT # __RESU = args['RESULTAT'] # modele __model = __RESU.getModel() # Dimension du modele ndim = __model.getMesh().getDimension() # # maillage __maillage = __model.getMesh() # __cham_mater = __RESU.getMaterialField() # # RECUPERATION DES DONNEES DE SYMETRIE ET DU FOND DE FISSURE # # mult=Coefficient multiplicatif suivant la symetrie du probleme mult = 1. if 'TRANCHE_2D' in args: TRANCHE_2D = args['TRANCHE_2D'] if ndim != 2: UTMESS('F', 'RUPTURE1_19', ['TRANCHE_2D', '2D']) # symetrie if args['SYME'] == 'OUI': mult = 2. else: TRANCHE_3D = args['TRANCHE_3D'] if ndim != 3: UTMESS('F', 'RUPTURE1_19', ['TRANCHE_3D', '3D']) # liste des noeuds du fond de fissure l_noeuds_fissure = args['FOND_FISS'].sdj.FOND_NOEU.get() # normale au plan de la fissure lnormale = args['FOND_FISS'].sdj.NORMALE.get() if (lnormale is None): UTMESS('F', 'POST0_39') # symetrie _, _, syme = aster.dismoi('SYME', args['FOND_FISS'].getName(), 'FOND_FISS', 'F') if syme == 'OUI': mult = 2 # # VERIFICATION DE LA LISTE DES INSTANTS # # Verification que les instants demandes sont bien dans le resultat # Construction des instants de calcul par la meme occasion list_inst = __RESU.LIST_VARI_ACCES()['INST'] l_inst_final = [] for inst in args['LIST_INST'].getValues(): if args['CRITERE'] == 'ABSOLU': prec = args['PRECISION'] elif args['CRITERE'] == 'RELATIF': prec = args['PRECISION'] * inst match = [ x for x in list_inst if ((x + prec >= inst) and (x - prec <= inst)) ] if len(match) == 0: UTMESS('F', 'RUPTURE0_38', valr=inst) if len(match) >= 2: UTMESS('F', 'RUPTURE0_39', valr=inst) l_inst_final.append(match[0]) nb_inst = len(l_inst_final) __linstr8 = DEFI_LIST_REEL(VALE=l_inst_final) # # PREPARATION DES SORTIES SI GPMAX # # Definition du concept sortant systematique dans le contexte de la macro # L'eventuel champ de copeaux est cree plus tard si besoin # Definition de la sortie facultative GP_MAX GPMAX = None if 'GPMAX' in args: GPMAX = args['GPMAX'] # Creation des colonnes de la table de sortie gpmax tabinstmax = [] tabcopmax = [] tabenelmax = [] tablcopmax = [] tabgpmax = [] # # # CALCUL DES GP # # # 1/ CAS 2D # if ndim == 2: # # 1.1/ CAS OU L UTILISATEUR A DEFINI DES GROUPES DE MAILLE COPEAU # IL SUFFIT ALORS DE CALCULER L ENERGIE DANS CES GROUPES ET D EN DEDUIRE LE GP # if TRANCHE_2D['ZONE_MAIL'] == 'OUI': lgroupma = TRANCHE_2D['GROUP_MA'] lcopeau = TRANCHE_2D['TAILLE'].getValues() if len(lgroupma) != len(lcopeau): UTMESS('F', 'RUPTURE1_21') nbcop = len(lcopeau) tabmax = [0] * nbcop * nb_inst tabcop = lgroupma * nb_inst tablcop = lcopeau * nb_inst __enertemp = POST_ELEM(MODELE=__model, RESULTAT=__RESU, LIST_INST=__linstr8, ENER_ELTR=_F(GROUP_MA=lgroupma)) enerel = __enertemp.EXTR_TABLE() enerel_TOTALE = createListFromTableWithoutUnion(enerel, "TOTALE") tabenel = [mult * x for x in enerel_TOTALE] tabgp = [tabenel[x] / tablcop[x] for x in range(len(tabenel))] tabinst = createListFromTableWithoutUnion(enerel, "INST") for i in range(nb_inst): maxinst = max(tabgp[i * nbcop:(i + 1) * nbcop]) index1 = tabgp[i * nbcop:(i + 1) * nbcop].index(maxinst) index = index1 + i * nbcop tabmax[index] = 1 if GPMAX is not None: tabinstmax.append(tabinst[index]) tabcopmax.append(tabcop[index]) tabenelmax.append(tabenel[index]) tablcopmax.append(tablcop[index]) tabgpmax.append(tabgp[index]) # # 1.2/ CAS OU L UTILISATEUR N A PAS DEFINI DES GROUPES DE MAILLE COPEAU # IL FAUT CREER UN DES COPEAUX PAR ENSEMBLE DE POINTS DE GAUSS ET JOUER AVEC # elif TRANCHE_2D['ZONE_MAIL'] == 'NON': nbcop = TRANCHE_2D['NB_ZONE'] theta = TRANCHE_2D['ANGLE'] taille = TRANCHE_2D['TAILLE'] nom_cmp = ['X%d' % k for k in range(1, nbcop + 1)] nom_cop = ['COPS_%d' % k for k in range(1, nbcop + 1)] # champ de geometrie et de points de gauss (coordonnees des points de gauss) __CHXN = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='NOEU_GEOM_R', NOM_CHAM='GEOMETRIE', MAILLAGE=__maillage) __CHXG = CREA_CHAMP(OPERATION='DISC', TYPE_CHAM='ELGA_GEOM_R', MODELE=__model, CHAM_GD=__CHXN) ccos = cos(theta * pi / 180.) ssin = sin(theta * pi / 180.) # construction du champ copeau pour visualisation par utilisateur s'il le # souhaite if TRANCHE_2D['CHAMP_VISU'] != 0: __seuil = [None for i in range(nbcop)] for cop in range(nbcop): __seuil[cop] = FORMULE( VALE= '''SEUIL(X,Y,origine[0],origine[1],rayon,taille,%d,ccos,ssin)''' % (cop + 1), NOM_PARA=('X', 'Y'), origine=TRANCHE_2D['CENTRE'], rayon=TRANCHE_2D['RAYON'], taille=taille, theta=theta, SEUIL=SEUIL, ccos=ccos, ssin=ssin, ) __formule_seuil = CREA_CHAMP( TYPE_CHAM='ELGA_NEUT_F', MODELE=__model, OPERATION='AFFE', PROL_ZERO='OUI', AFFE=_F( TOUT='OUI', NOM_CMP=nom_cmp, VALE_F=__seuil, ), ) chp_cop = CREA_CHAMP( TYPE_CHAM='ELGA_NEUT_R', OPERATION='EVAL', CHAM_F=__formule_seuil, CHAM_PARA=(__CHXG), ) self.register_result(chp_cop, TRANCHE_2D['CHAMP_VISU']) # calcul des energies et du gp __ener = [None for cop in range(nbcop)] for cop in range(nbcop): __ener[cop] = FORMULE( VALE= '''NRJ(TOTALE,X,Y,origine[0],origine[1],rayon,taille,%d,ccos,ssin)''' % (cop + 1), NOM_PARA=('TOTALE', 'X', 'Y'), origine=TRANCHE_2D['CENTRE'], rayon=TRANCHE_2D['RAYON'], taille=taille, NRJ=NRJ, ccos=ccos, ssin=ssin, ) __formule_ener = CREA_CHAMP( TYPE_CHAM='ELGA_NEUT_F', MODELE=__model, OPERATION='AFFE', PROL_ZERO='OUI', AFFE=_F( TOUT='OUI', NOM_CMP=nom_cmp, VALE_F=__ener, ), ) __RESU = CALC_CHAMP( reuse=__RESU, RESULTAT=__RESU, LIST_INST=__linstr8, ENERGIE=('ENEL_ELGA'), ) tabmax = [0] * nbcop * nb_inst tabcop = nom_cop * nb_inst tablcop = [taille * (cop + 1) for cop in range(nbcop)] * nb_inst tabinst = [] tabenel = [] tabgp = [] for i, inst in enumerate(l_inst_final): __energa = CREA_CHAMP(OPERATION='EXTR', TYPE_CHAM='ELGA_ENER_R', NOM_CHAM='ENEL_ELGA', RESULTAT=__RESU, INST=inst) __resinter = CREA_CHAMP( TYPE_CHAM='ELGA_NEUT_R', OPERATION='EVAL', CHAM_F=__formule_ener, CHAM_PARA=(__energa, __CHXG), ) __tabnrj = POST_ELEM( CHAM_GD=__resinter, MODELE=__model, CHAM_MATER=__cham_mater, INTEGRALE=_F(TOUT='OUI', NOM_CHAM='ENEL_ELGA', NOM_CMP=nom_cmp, DEJA_INTEGRE='NON', TYPE_MAILLE='2D'), ) tabenerel = __tabnrj.EXTR_TABLE().values() tabinst = tabinst + [inst] * nbcop enerel = [ mult * tabenerel['INTE_X%d' % (cop + 1)][0] for cop in range(nbcop) ] tabenel += enerel gp = [ enerel[cop] / (taille * (cop + 1)) for cop in range(nbcop) ] tabgp += gp maxinst = max(tabgp[i * nbcop:(i + 1) * nbcop]) index1 = tabgp[i * nbcop:(i + 1) * nbcop].index(maxinst) index = index1 + i * nbcop tabmax[index] = 1 if GPMAX is not None: tabinstmax.append(tabinst[index]) tabcopmax.append(tabcop[index]) tabenelmax.append(tabenel[index]) tablcopmax.append(tablcop[index]) tabgpmax.append(tabgp[index]) # # 2/ CAS 3D # elif ndim == 3: # type des mailles ltyma = aster.getvectjev("&CATA.TM.NOMTM") # liste des copeaux l_copo_tot = [] for tmpocc in TRANCHE_3D: dMCT = tmpocc.cree_dict_valeurs(tmpocc.mc_liste) l_copo_tot += dMCT['GROUP_MA'] # le nombre de copeaux est suppose identique sur toutes les tranches nbcoptot = len(l_copo_tot) nbcop = nbcoptot // len(TRANCHE_3D) # calcul de la surface des mailles appartenant au plan de symetrie de # l'entaille mesure = Calcul_mesure_3D(__maillage, nbcop, l_copo_tot, ltyma, l_noeuds_fissure[0], lnormale) # calcul des energies et du gp __enertemp = POST_ELEM( MODELE=__model, RESULTAT=__RESU, LIST_INST=__linstr8, ENER_ELTR=_F(GROUP_MA=l_copo_tot), TITRE='Energie elastique de traction', ) enerel = __enertemp.EXTR_TABLE() tabcop = createListFromTableWithoutUnion(enerel, "LIEU") enerel_TOTALE = createListFromTableWithoutUnion(enerel, "TOTALE") tabenel = [mult * x for x in enerel_TOTALE] tabinst = createListFromTableWithoutUnion(enerel, "INST") tablcop = mesure * nb_inst tabgp = [tabenel[x] / tablcop[x] for x in range(len(tabenel))] tabmax = [0] * nbcoptot * nb_inst for i in range(nb_inst): maxinst = max(tabgp[nbcoptot * i:nbcoptot * (i + 1)]) index1 = tabgp[nbcoptot * i:nbcoptot * (i + 1)].index(maxinst) index = index1 + i * nbcoptot tabmax[index] = 1 if GPMAX is not None: tabinstmax.append(tabinst[index]) tabcopmax.append(tabcop[index]) tabenelmax.append(tabenel[index]) tablcopmax.append(tablcop[index]) tabgpmax.append(tabgp[index]) # # # CREATION DE LA TABLE DE SORTIE # tabout = CREA_TABLE(LISTE=( _F(PARA='INST', LISTE_R=tabinst), _F( PARA='ZONE', LISTE_K=tabcop, ), _F( PARA='ENER ELAS', LISTE_R=tabenel, ), _F( PARA='DELTA L', LISTE_R=tablcop, ), _F( PARA='GP', LISTE_R=tabgp, ), _F( PARA='MAX_INST', LISTE_I=tabmax, ), ), ) if GPMAX is not None: tabgpmax = CREA_TABLE(LISTE=( _F(PARA='INST', LISTE_R=tabinstmax), _F( PARA='ZONE', LISTE_K=tabcopmax, ), _F( PARA='ENER ELAS', LISTE_R=tabenelmax, ), _F( PARA='DELTA L', LISTE_R=tablcopmax, ), _F( PARA='GP', LISTE_R=tabgpmax, ), ), ) self.register_result(tabgpmax, GPMAX) RetablirAlarme('CALCCHAMP_1') return tabout
def CHAINAGE_HYDR_MECA(self, args, motscles): CREA_CHAMP = self.get_cmd('CREA_CHAMP') CREA_RESU = self.get_cmd('CREA_RESU') PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') INST = None if args.has_key('INST'): if args['INST'] != None: INST = args['INST'] b_type_resu_cham_no = False TYPE_RESU = args['TYPE_RESU'] if (TYPE_RESU == "CHAM_NO"): b_type_resu_cham_no = True RESU_HYDR = args['RESU_HYDR'] MODELE_MECA = args['MODELE_MECA'] MATR_HM1 = args['MATR_HM1'] MATR_HM2 = args['MATR_HM2'] para = RESU_HYDR.LIST_PARA() smo = set(para['MODELE']) # normalement, il ne doit y avoir qu'un modèle ... if len(smo) <> 1: UTMESS('F', 'CHAINAGE_10') nom_mo_re = list(smo)[0] __modele = self.get_concept(nom_mo_re) # # Nom du modèle obtenu à partir du résultat : nom_modele_1 # iret, ibid, nom_modele_1 = aster.dismoi('MODELISATION', __modele.nom, 'MODELE', 'F') nom_modele_1 = nom_modele_1.strip() iret, ibid, yathm1 = aster.dismoi('EXI_THM', __modele.nom, 'MODELE', 'F') # # A l'heure actuelle, les modélisations autorisées pour # faire du chaînage sont : # # Pour la mécanique : # # => D_PLAN, D_PLAN_SI, D_PLAN_GRAD_SIGM # => 3D, 3D_SI # # Pour l'hydraulique : # # => D_PLAN_HS # => 3D_HS # => les modélisations HM saturées à intégration sélective : # D_PLAN_HMS, 3D_HMS # mod_mec_autorise = ['D_PLAN', 'D_PLAN_SI', 'D_PLAN_GRAD_SIGM'] mod_hyd_autorise = ['D_PLAN_HS', 'D_PLAN_HMS'] # # Nom du modèle 2 fourni en entrée : nom_modele_2 # iret, ibid, nom_modele_2 = aster.dismoi('MODELISATION', MODELE_MECA.nom, 'MODELE', 'F') nom_modele_2 = nom_modele_2.strip() linst_resultat = RESU_HYDR.LIST_VARI_ACCES()['INST'] # # INST est rentré en argument par l'utilisateur # instp et instm sont les 2 derniers instants présents dans # le résultat donné en entrée # instp = linst_resultat[-1] instm = None inst0 = linst_resultat[0] if (inst0 < instp): # Dans ce cas, on a au moins 2 "vrais" instants dans RESULTAT : instp et # instm instm = linst_resultat[-2] b_inst_initial = False else: # Dans ce cas, on a instp = 0 et instm n'existe pas # On particularise ce cas pour le chaînage HYDR_MECA, mais pas pour le chaînage # MECA_HYDR où le traitement est plus simple. En effet, cette situation correspond # à un chaînage HM au premier pas de temps. Il suffit de ne pas donner de variable de # commande ! b_inst_initial = True inst_coincident = False if (INST != None): if (INST < instp): UTMESS('F', 'CHAINAGE_6', valr=[INST], valk=[RESU_HYDR.nom]) if abs(instp - INST) < prec: inst_coincident = True # # On vérifie que le résultat donné en entrée # (hydraulique) est défini # sur un modèle pour lequel on sait faire du chaînage # # A l'heure actuelle, les modélisations autorisées sont : # => D_PLAN_HS # # On répondra plus tard aux demandes d'évolution pour l'insaturé # et pour le 3D # if not (nom_modele_1 in mod_hyd_autorise): UTMESS('F', 'CHAINAGE_3', valk=[nom_modele_1, 'de départ']) # # On récupère le nom du maillage hydraulique à partir du modèle # hydraulique # iret, ibid, nom_mail = aster.dismoi('NOM_MAILLA', __modele.nom, 'MODELE', 'F') nom_mail = nom_mail.strip() __maillage_h = self.get_concept(nom_mail) # # On vérifie que le résultat donné en sortie # (mécanique) est défini # sur un modèle pour lequel on sait faire du chaînage # # A l'heure actuelle, les modélisations autorisées sont : # => D_PLAN, D_PLAN_SI # => 3D, 3D_SI # if not (nom_modele_2 in mod_mec_autorise): UTMESS('F', 'CHAINAGE_4', valk=[nom_modele_2, 'd arrivée']) __prep = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='EXTR', RESULTAT=RESU_HYDR, NOM_CHAM='DEPL', INST=instp, **motscles) __prepmec = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='ASSE', MAILLAGE=__maillage_h, ASSE=(_F( TOUT='OUI', CHAM_GD=__prep, NOM_CMP='PRE1', NOM_CMP_RESU='PTOT', ), ), **motscles) if b_type_resu_cham_no: __proch = PROJ_CHAMP(CHAM_GD=__prepmec, MATR_PROJECTION=MATR_HM1, **motscles) nomres = PROJ_CHAMP(CHAM_GD=__proch, MATR_PROJECTION=MATR_HM2, **motscles) else: if not (b_inst_initial): __prem = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='EXTR', RESULTAT=RESU_HYDR, NOM_CHAM='DEPL', INST=instm, **motscles) __premmec = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='ASSE', MAILLAGE=__maillage_h, ASSE=(_F( TOUT='OUI', CHAM_GD=__prem, NOM_CMP='PRE1', NOM_CMP_RESU='PTOT', ), ), **motscles) else: __premmec = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='AFFE', MAILLAGE=__maillage_h, AFFE=(_F( TOUT='OUI', VALE=0., NOM_CMP='PTOT', ), ), **motscles) if inst_coincident: __ptotre = CREA_RESU( OPERATION='AFFE', TYPE_RESU='EVOL_VARC', NOM_CHAM='PTOT', AFFE=( _F( CHAM_GD=__premmec, INST=instm, ), _F( CHAM_GD=__prepmec, INST=instp, ), ), ) else: # # l'incrément de pression à l'instant t_i=INST est donné par # les valeurs à t_(i-2)=instm et t_(i-1)=instp # __ptotre = CREA_RESU( OPERATION='AFFE', TYPE_RESU='EVOL_VARC', NOM_CHAM='PTOT', AFFE=( _F( CHAM_GD=__premmec, INST=instp, ), _F( CHAM_GD=__prepmec, INST=INST, ), ), ) __projres = PROJ_CHAMP(RESULTAT=__ptotre, MATR_PROJECTION=MATR_HM1, **motscles) nomres = PROJ_CHAMP(RESULTAT=__projres, MATR_PROJECTION=MATR_HM2, **motscles)
def force_iss_vari(self, imod, MATR_GENE, NOM_CMP, ISSF, INFO, UNITE_RESU_FORC, UNITE_RESU_IMPE, PRECISION, INTERF, MATR_COHE, TYPE, fini, PAS, fmax): """Force sismique variable en ISS""" import os import numpy as NP from numpy import linalg from math import pi, ceil, sqrt, floor, log, tanh import aster_core import aster from code_aster.Cata.Syntax import _F from Utilitai.Table import Table from Utilitai.Utmess import UTMESS from Utilitai.signal_correlation_utils import (CALC_COHE, get_group_nom_coord, calc_dist2) from code_aster.Cata.Syntax import _F from code_aster.Cata.Commands import (DETRUIRE, LIRE_IMPE_MISS, LIRE_FORC_MISS, CREA_CHAMP, COMB_MATR_ASSE, DYNA_VIBRA) #-------------------------------------------------------------------------------- NB_FREQ = 1 + int((fmax - fini) / PAS) FREQ_INIT = fini from SD.sd_maillage import sd_maillage from SD.sd_nume_ddl_gd import sd_nume_ddl_gd from SD.sd_nume_ddl_gene import sd_nume_ddl_gene from SD.sd_mode_meca import sd_mode_meca from SD.sd_resultat import sd_resultat from SD.sd_cham_gene import sd_cham_gene GROUP_NO_INTER = INTERF['GROUP_NO_INTERF'] # MAILLAGE NUME_DDL nom_bamo = MATR_GENE['BASE'] resultat = MATR_GENE['BASE'] nom_bam2 = nom_bamo.nom #iret,ibid,nume_ddl = aster.dismoi('NUME_DDL',nom_bamo.nom,'RESU_DYNA','F') iret, ibid, nume_ddl = aster.dismoi('NUME_DDL', nom_bam2, 'RESU_DYNA', 'F') iret, ibid, nom_mail = aster.dismoi('NOM_MAILLA', nume_ddl, 'NUME_DDL', 'F') # MODELE, DDLGENE nume_ddlgene = MATR_GENE['NUME_DDL_GENE'] # iret,ibid,nom_modele = aster.dismoi('NOM_MODELE',nume_ddl,'NUME_DDL','F') # nbnot, nbl, nbma, nbsm, nbsmx, dime = maillage.DIME.get() # coordonnees des noeuds # l_coordo = maillage.COORDO.VALE.get() # t_coordo = NP.array(l_coordo) # t_coordo.shape = nbnot, 3 l_nom, noe_interf = get_group_nom_coord(GROUP_NO_INTER, nom_mail) # del nume_ddl, nom_mail, nom_modele # MODES iret, nbmodd, kbid = aster.dismoi('NB_MODES_DYN', nom_bam2, 'RESULTAT', 'F') iret, nbmods, kbid = aster.dismoi('NB_MODES_STA', nom_bam2, 'RESULTAT', 'F') iret, nbmodt, kbid = aster.dismoi('NB_MODES_TOT', nom_bam2, 'RESULTAT', 'F') FSIST = NP.zeros((NB_FREQ, nbmodt)) + 0j nbno, nbval = noe_interf.shape if INFO == 2: texte = 'NOMBRE DE MODES: ' + str( nbmodt) + ' MODES DYNAMIQUES: ' + str( nbmodd) + ' MODES STATIQUES: ' + str(nbmods) aster.affiche('MESSAGE', texte) aster.affiche('MESSAGE', 'COMPOSANTE ' + NOM_CMP) aster.affiche('MESSAGE', 'NBNO INTERFACE : ' + str(nbno)) # ----- boucle sur les modes statiques for mods in range(0, nbmods): nmo = nbmodd + mods + 1 __CHAM = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='EXTR', NUME_ORDRE=nmo, RESULTAT=resultat, NOM_CHAM='DEPL') MCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], 0).valeurs if mods == 0: NCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], topo=1).comp nddi = len(MCMP2) PHI = NP.zeros((nddi, nbmods)) PHI[:, mods] = MCMP2 PHIT = NP.transpose(PHI) PPHI = NP.dot(PHIT, PHI) # MODEL fonction de cohérence MODEL = MATR_COHE['TYPE'] print 'MODEL :', MODEL Data_Cohe = {} Data_Cohe['TYPE'] = MODEL Data_Cohe['MAILLAGE'] = nom_mail Data_Cohe['GROUP_NO_INTERF'] = GROUP_NO_INTER Data_Cohe['NOEUDS_INTERF'] = noe_interf Data_Cohe['DIST'] = calc_dist2(noe_interf) if MODEL == 'MITA_LUCO': Data_Cohe['VITE_ONDE'] = MATR_COHE['VITE_ONDE'] Data_Cohe['PARA_ALPHA'] = MATR_COHE['PARA_ALPHA'] #--------------------------------------------------------------------- # BOUCLE SUR LES FREQUENCES for k in range(NB_FREQ): freqk = FREQ_INIT + PAS * k if INFO == 2: aster.affiche('MESSAGE', 'FREQUENCE DE CALCUL: ' + str(freqk)) COHE = CALC_COHE(freqk * 2. * pi, **Data_Cohe) #--------------------------------------------------------- # On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas aster_core.matfpe(-1) eig, vec = linalg.eig(COHE) vec = NP.transpose(vec) # les vecteurs sont en colonne dans numpy aster_core.matfpe(1) eig = eig.real vec = vec.real # on rearrange selon un ordre decroissant eig = NP.where(eig < 1.E-10, 0.0, eig) order = (NP.argsort(eig)[::-1]) eig = NP.take(eig, order) vec = NP.take(vec, order, 0) #----------------------- # Nombre de modes POD a retenir etot = NP.sum(eig**2) ener = 0.0 nbme = 0 while nbme < nbno: ener = eig[nbme]**2 + ener prec = ener / etot nbme = nbme + 1 if INFO == 2: aster.affiche( 'MESSAGE', 'VALEUR PROPRE ' + str(nbme) + ' : ' + str(eig[nbme - 1])) if prec > PRECISION: break if INFO == 2: aster.affiche('MESSAGE', 'NOMBRE DE MODES POD RETENUS : ' + str(nbme)) aster.affiche('MESSAGE', 'PRECISION (ENERGIE RETENUE) : ' + str(prec)) PVEC = NP.zeros((nbme, nbno)) for k1 in range(0, nbme): PVEC[k1, 0:nbno] = NP.sqrt(eig[k1]) * vec[k1] #----Impedances + force sismique.----------------------------------------------------------------- if k > 0: DETRUIRE(CONCEPT=_F(NOM=(__impe, __fosi)), INFO=1) __impe = LIRE_IMPE_MISS( BASE=resultat, TYPE=TYPE, NUME_DDL_GENE=nume_ddlgene, UNITE_RESU_IMPE=UNITE_RESU_IMPE, ISSF=ISSF, FREQ_EXTR=freqk, ) # on cree __fosi pour RECU_VECT_GENE_C plus loin __fosi = LIRE_FORC_MISS( BASE=resultat, NUME_DDL_GENE=nume_ddlgene, NOM_CMP=NOM_CMP, NOM_CHAM='DEPL', UNITE_RESU_FORC=UNITE_RESU_FORC, ISSF=ISSF, FREQ_EXTR=freqk, ) # -------------- impedance-------------------------------- MIMPE = __impe.EXTR_MATR_GENE() # extraction de la partie modes interface KRS = MIMPE[nbmodd:nbmodt, nbmodd:nbmodt] # -------------- force sismique------------------------------- FSISM = __fosi.EXTR_VECT_GENE_C() FS0 = FSISM[ nbmodd:nbmodt][:] # extraction de la partie modes interface U0 = NP.dot(linalg.inv(KRS), FS0) # projection pour obtenir UO en base physique XI = NP.dot(PHI, U0) XPI = XI # # facteur de correction pour tous les modes (on somme) >> c'est faux SI0 = 0.0 for k1 in range(0, nbme): XOe = abs(NP.sum(PVEC[k1])) / nbno SI0 = SI0 + XOe**2 SI = sqrt(SI0) for idd in range(0, nddi): #nddi: nombre de ddl interface if NCMP2[idd][0:2] == NOM_CMP: XPI[idd] = SI * XI[idd] # retour en base modale QPI = NP.dot(PHIT, XPI) U0 = NP.dot(linalg.inv(PPHI), QPI) FS = NP.dot(KRS, U0) FSISM[nbmodd:nbmodt][:] = FS FSIST[k, nbmods:nbmodt] = FSISM[0:nbmodd][:] FSIST[k, 0:nbmods] = FS return FSIST
def calc_modes_amelioration(self, modes, TYPE_RESU, INFO, **args): """ Macro-command CALC_MODES, file for improving the quality of the eigenmodes """ args = _F(args) SOLVEUR = args.get("SOLVEUR") VERI_MODE = args.get("VERI_MODE") TITRE = args.get("TITRE") # import the definitions of the commands to use in the macro-command # The name of the variable has to be the name of the command ############################################################################## # 1. CHECK IF THE COMPUTATION WITH MODE_ITER_INV CAN BE PERFORMED if TYPE_RESU == 'DYNAMIQUE': type_vp = 'FREQ' matr_A = 'MATR_RIGI' matr_B = 'MATR_MASS' elif TYPE_RESU == 'MODE_FLAMB': type_vp = 'CHAR_CRIT' matr_A = 'MATR_RIGI' matr_B = 'MATR_RIGI_GEOM' elif TYPE_RESU == 'GENERAL': type_vp = 'CHAR_CRIT' matr_A = 'MATR_A' matr_B = 'MATR_B' # 1.1 check if the input matrices are symetric and real lsym = True lreel = True iret, ibid, type_matr_A = aster.dismoi('TYPE_MATRICE', args[matr_A].getName(), 'MATR_ASSE', 'F') if not type_matr_A == 'SYMETRI': lsym = False if isinstance(args[matr_A], AssemblyMatrixDisplacementComplex) or\ isinstance(args[matr_A], GeneralizedAssemblyMatrixComplex): lreel = False iret, ibid, type_matr_B = aster.dismoi('TYPE_MATRICE', args[matr_B].getName(), 'MATR_ASSE', 'F') if not type_matr_B == 'SYMETRI': lsym = False if TYPE_RESU == 'DYNAMIQUE': if args['MATR_AMOR'] is not None: iret, ibid, type_matr_C = aster.dismoi('TYPE_MATRICE', args['MATR_AMOR'].getName(), 'MATR_ASSE', 'F') if not type_matr_C == 'SYMETRI': lsym = False if not lsym: UTMESS('I', 'MODAL_15') return modes if not lreel: UTMESS('I', 'MODAL_16', valk=matr_A) return modes # 1.2 detect too closed eigen values (gap < CALC_* / SEUIL_*) list_vp = modes.LIST_PARA()[type_vp] # list of the eigen values seuil_vp = args['CALC_' + type_vp]['SEUIL_' + type_vp] # One reproduces here the detection performed in the routine vpgsmm.F90 seuilr = 100. * seuil_vp seuilp = seuil_vp ltest = False for k in range(0, len(list_vp) - 1): if (abs(list_vp[k]) < seuilr): ltest = abs(list_vp[k + 1]) < seuilr else: if (abs(list_vp[k + 1]) >= seuilr): ltest = abs(2. * (list_vp[k] - list_vp[k + 1]) / (list_vp[k] + list_vp[k + 1])) < seuilp if ltest: UTMESS('I', 'MODAL_17', valk=modes.getName()) return modes ############################################################################## # 2. PERFORM THE IMPROVEMENT OF THE MODES WITH MODE_ITER_INV / OPTION='PROCHE' DETRUIRE(CONCEPT=_F(NOM=modes), INFO=1) motcles = {} matrices = {} # read the input matrices if TYPE_RESU == 'DYNAMIQUE': type_vp = 'FREQ' matrices['MATR_RIGI'] = args['MATR_RIGI'] matrices['MATR_MASS'] = args['MATR_MASS'] if args['MATR_AMOR'] is not None: matrices['MATR_AMOR'] = args['MATR_AMOR'] elif TYPE_RESU == 'MODE_FLAMB': type_vp = 'CHAR_CRIT' matrices['MATR_RIGI'] = args['MATR_RIGI'] matrices['MATR_RIGI_GEOM'] = args['MATR_RIGI_GEOM'] elif TYPE_RESU == 'GENERAL': type_vp = 'CHAR_CRIT' matrices['MATR_A'] = args['MATR_A'] matrices['MATR_B'] = args['MATR_B'] motcles.update(matrices) ################################################################# motcles_calc_vp = {} motcles_calc_vp[type_vp] = list_vp motcles['CALC_' + type_vp] = _F(OPTION='PROCHE', **motcles_calc_vp) ################################################################# # read the keyword SOLVEUR (linear solver) solveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste) if 'TYPE_RESU' in solveur: # because TYPE_RESU is a keyword with a 'global' position solveur.pop('TYPE_RESU') if 'OPTION' in solveur: # because OPTION is a keyword with a 'global' position solveur.pop('OPTION') if 'FREQ' in solveur: # because FREQ can be a keyword with a 'global' position solveur.pop('FREQ') motcles['SOLVEUR'] = _F(**solveur) # if this line is commented, # one will use the default keywords for SOLVEUR ################################################################# # read the keyword VERI_MODE # sturm = VERI_MODE['STURM'] if sturm in ('GLOBAL', 'LOCAL', 'OUI'): # for MODE_ITER_INV, value for STURM can be only OUI or NON. Other # values are equivalent to OUI motveri = 'OUI' elif sturm in ('NON'): # for keyword AMELIORATION motveri = 'NON' else: assert (False) # Pb parametrage STURM ) motcles['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'], SEUIL=VERI_MODE['SEUIL'], STURM=motveri, PREC_SHIFT=VERI_MODE['PREC_SHIFT']) ################################################################# if TITRE is not None: motcles['TITRE'] = TITRE ################################################################# modes = MODE_ITER_INV(TYPE_RESU=TYPE_RESU, INFO=INFO, **motcles) return modes
def observation_ops(self, PROJECTION=None, MODELE_1=None, MODELE_2=None, RESULTAT=None, MATR_RIGI=None, MATR_MASS=None, MODI_REPERE=None, NOM_CHAM=None, FILTRE=None, EPSI_MOYENNE=None, **args): """ Ecriture de la macro MACRO_OBSERVATION """ ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # on transforme le mc MODI_REPERE pour ne pas le confondre avec l'operateur # du meme nom MODIF_REPERE = MODI_REPERE # importation de commandes import aster from code_aster.Cata.Syntax import _F from Utilitai.Utmess import UTMESS from code_aster.Cata.DataStructure import (mode_meca, dyna_harmo, evol_elas, dyna_trans) MODI_REPERE = self.get_cmd('MODI_REPERE') PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') CREA_CHAMP = self.get_cmd('CREA_CHAMP') CREA_RESU = self.get_cmd('CREA_RESU') POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') DETRUIRE = self.get_cmd('DETRUIRE') # dans **args, on range les options de PROJ_CHAMP facultatives, et dont on # ne sert pas par la suite mcfact = args if not isinstance(NOM_CHAM, tuple): NOM_CHAM = [NOM_CHAM] TYPE_CHAM = None RESU = None if isinstance(RESULTAT, evol_elas): TYPE_RESU = 'EVOL_ELAS' if isinstance(RESULTAT, dyna_trans): TYPE_RESU = 'DYNA_TRANS' if isinstance(RESULTAT, dyna_harmo): TYPE_RESU = 'DYNA_HARMO' if isinstance(RESULTAT, mode_meca): TYPE_RESU = 'MODE_MECA' self.DeclareOut('RESU', self.sd) # recuperation du maillage associe au modele numerique _maillag = aster.getvectjev(MODELE_1.nom.ljust(8) + '.MODELE .LGRF') maillage = _maillag[0].strip() mayanum = self.get_concept(maillage) # modele numerique 2D ou 3D typmod = mayanum.sdj.DIME.get() typmod = typmod[5] # recuperation du maillage associe au modele experimental _maillag = aster.getvectjev(MODELE_2.nom.ljust(8) + '.MODELE .LGRF') maillage = _maillag[0].strip() mayaexp = self.get_concept(maillage) # cham_mater et cara_elem pour le resultat a projeter iret, ibid, nom_cara_elem = aster.dismoi('CARA_ELEM', RESULTAT.nom, 'RESULTAT', 'F') if len(nom_cara_elem) > 0: assert nom_cara_elem.strip() != "#PLUSIEURS", nom_cara_elem if nom_cara_elem.strip() == "#AUCUN": cara_elem = None else: cara_elem = self.get_concept(nom_cara_elem.strip()) else: cara_elem = None iret, ibid, nom_cham_mater = aster.dismoi('CHAM_MATER', RESULTAT.nom, 'RESULTAT', 'F') if len(nom_cham_mater) > 0: assert nom_cham_mater.strip() != "#PLUSIEURS", nom_cham_mater if nom_cham_mater.strip() == "#AUCUN": cham_mater = None else: cham_mater = self.get_concept(nom_cham_mater.strip()) else: cham_mater = None # afreq pour les frequences propres if isinstance(RESULTAT, mode_meca): # frequences propres from code_aster.Cata.Commands import RECU_TABLE __freq = RECU_TABLE( CO=RESULTAT, NOM_PARA='FREQ', ) afreq = __freq.EXTR_TABLE().Array('NUME_ORDRE', 'FREQ') # noms des matrices if MATR_RIGI != None or MATR_MASS != None: # recherche du nume_ddl associe iret, ibid, nom_nume_ddl = aster.dismoi('NOM_NUME_DDL', MATR_RIGI.nom, 'MATR_ASSE', 'F') NUME_DDL = self.get_concept(nom_nume_ddl) # coherence avec le nom associe a MODELE_2 : iret, ibid, nom_modele = aster.dismoi('NOM_MODELE', nom_nume_ddl, 'NUME_DDL', 'F') if nom_modele.strip() != MODELE_2.nom.strip(): UTMESS('F', 'CALCESSAI0_10') else: UTMESS('A', 'CALCESSAI0_9') NUME_DDL = None else: afreq = None NUME_DDL = None indice = range(len(RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE'])) #*********************************************** # PHASE DE CALCUL DE LA DEFORMATION MOYENNE AUX NOEUDS # CHAMP CALCULE SUR LE MODELE NUMERIQUE #*********************************************** resu_epsi = None if EPSI_MOYENNE != None: for nomcham in NOM_CHAM: if nomcham == 'EPSI_NOEU': if isinstance(RESULTAT, dyna_harmo): TYPE_CHAM = 'NOEU_EPSI_C' else: TYPE_CHAM = 'NOEU_EPSI_R' if TYPE_CHAM == None: UTMESS('F', 'UTILITAI8_24', valk=['NOEU_EPSI', nomcham]) else: num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE'] if isinstance(RESULTAT, evol_elas): list_inst = RESULTAT.LIST_VARI_ACCES()['INST'] if isinstance(RESULTAT, dyna_trans): list_inst = RESULTAT.LIST_VARI_ACCES()['INST'] if isinstance(RESULTAT, dyna_harmo): list_freq = RESULTAT.LIST_VARI_ACCES()['FREQ'] liste = [] # il faut calculer le champ complet if typmod == 2: nom_cmps = [ 'EPXX', 'EPYY', 'EPZZ', 'EPXY', ] else: nom_cmps = [ 'EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ', ] argsi = { 'ACTION': [], } lnoeuds = {} nb_mcfact = 0 seuil = [] masque = [] for epsi_moye in EPSI_MOYENNE: mcfactr = {} mcfacti = {} l_noeud = None val_masque = [] seuil_lu = epsi_moye['SEUIL_VARI'] if type(seuil_lu) == tuple: val_seuil = seuil_lu[0] else: val_seuil = seuil_lu seuil.append(val_seuil) masque_lu = epsi_moye['MASQUE'] if type(masque_lu) != tuple: val_masque.append(masque_lu) else: val_masque = masque_lu masque.append(val_masque) for typ in ['NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA']: if epsi_moye[typ] != None: l_noeud = find_no(mayanum, {typ: epsi_moye[typ]}) nb_mcfact = nb_mcfact + 1 for i in range(len(l_noeud)): l_noeud[i] = l_noeud[i].strip() lnoeuds[str(nb_mcfact)] = l_noeud if l_noeud == None: UTMESS('F', 'MODELISA3_13', valk=['EPSI_MOYENNE']) if TYPE_CHAM[-1:] == 'C': mcfactr = { 'NOM_CMP': nom_cmps, 'OPERATION': 'EXTRACTION', 'INTITULE': str('R' + str(nb_mcfact)), 'FORMAT_C': 'REEL', 'NOEUD': l_noeud, 'NOM_CHAM': 'EPSI_NOEU', 'RESULTAT': RESULTAT, 'NUME_ORDRE': num_ordr, } argsi['ACTION'].append(mcfactr) mcfacti = { 'NOM_CMP': nom_cmps, 'OPERATION': 'EXTRACTION', 'INTITULE': str('I' + str(nb_mcfact)), 'FORMAT_C': 'IMAG', 'NOEUD': l_noeud, 'NOM_CHAM': 'EPSI_NOEU', 'RESULTAT': RESULTAT, 'NUME_ORDRE': num_ordr, } argsi['ACTION'].append(mcfacti) else: mcfactr = { 'NOM_CMP': nom_cmps, 'OPERATION': 'EXTRACTION', 'INTITULE': str(nb_mcfact), 'NOEUD': l_noeud, 'NOM_CHAM': 'EPSI_NOEU', 'RESULTAT': RESULTAT, 'NUME_ORDRE': num_ordr, } argsi['ACTION'].append(mcfactr) _tepsi = POST_RELEVE_T(**argsi) table = _tepsi.EXTR_TABLE() DETRUIRE(CONCEPT=_F(NOM=_tepsi), INFO=1) mcfact2 = {} __chame = [None] * len(indice) for ind in indice: argsa = { 'AFFE': [], } for mcfacta in range(nb_mcfact): l_noeud_mcfact = lnoeuds[str(mcfacta + 1)] l_vmoye = [] l_cmp_vari = [] seuil_mc = seuil[mcfacta] masque_mc = masque[mcfacta] for cmp in nom_cmps: lur = 0 lui = 0 l_valr = [] l_vali = [] l_valc = [] l_val = [] for row in table.rows: if TYPE_CHAM[-1:] == 'C': if row['INTITULE'].strip() == str('R' + str(mcfacta + 1)) \ and row['NUME_ORDRE'] == num_ordr[ind]: l_valr.append(row[cmp]) lur = 1 elif row['INTITULE'].strip() == str('I' + str(mcfacta + 1)) \ and row['NUME_ORDRE'] == num_ordr[ind]: l_vali.append(row[cmp]) lui = 1 else: if row['INTITULE'].strip() == str(mcfacta + 1) \ and row['NUME_ORDRE'] == num_ordr[ind]: l_val.append(row[cmp]) if TYPE_CHAM[-1:] == 'C': if lur and lui: if len(l_valr) != len(l_vali): UTMESS('F', 'POSTRELE_59') for i in range(len(l_valr)): l_valc.append(complex( l_valr[i], l_vali[i])) lur = 0 lui = 0 else: UTMESS('F', 'POSTRELE_59') # on regarde a la fois la partie reelle et la partie imag # pour les complexes vmoyer = sum(l_valr) / len(l_valr) vmoyei = sum(l_vali) / len(l_vali) vmoye = sum(l_valc) / len(l_valc) vminr = min(l_valr) vmini = min(l_vali) vmaxr = max(l_valr) vmaxi = max(l_vali) if vmoyer > 0: if (vmaxr > vmoyer * (1. + seuil_mc)) or (vminr < vmoyer * (1 - seuil_mc)): l_cmp_vari.append(cmp) if vmoyei > 0: if (vmaxi > vmoyei * (1. + seuil_mc)) or (vmini < vmoyei * (1 - seuil_mc)): l_cmp_vari.append(cmp) if vmoyer < 0: if (vminr > vmoyer * (1. - seuil_mc)) or (vmaxr < vmoyer * (1 + seuil_mc)): l_cmp_vari.append(cmp) if vmoyei < 0: if (vmini > vmoyei * (1. - seuil_mc)) or (vmaxi < vmoyei * (1 + seuil_mc)): l_cmp_vari.append(cmp) else: vmoye = sum(l_val) / len(l_val) vmin = min(l_val) vmax = max(l_val) if vmoye > 0: if (vmax > vmoye * (1. + seuil_mc)) or (vmin < vmoye * (1 - seuil_mc)): l_cmp_vari.append(cmp) if vmoye < 0: if (vmin > vmoye * (1. - seuil_mc)) or (vmax < vmoye * (1 + seuil_mc)): l_cmp_vari.append(cmp) l_vmoye.append(vmoye) if len(l_cmp_vari) > 0: for cmp in nom_cmps: vu = 0 for cmp_vari in l_cmp_vari: if cmp_vari not in masque_mc: if cmp == cmp_vari and not vu: if EPSI_MOYENNE[mcfacta][ 'MAILLE'] != None: entite = str( 'MAILLE : ' + str(EPSI_MOYENNE[mcfacta] ['MAILLE'])) if EPSI_MOYENNE[mcfacta][ 'GROUP_MA'] != None: entite = str( 'GROUP_MA : ' + str(EPSI_MOYENNE[mcfacta] ['GROUP_MA'])) UTMESS('A', 'OBSERVATION_8', vali=[num_ordr[ind]], valr=[seuil_mc], valk=[entite, cmp]) vu = 1 if TYPE_CHAM[-1:] == 'C': mcfactc = { 'NOM_CMP': nom_cmps, 'NOEUD': l_noeud_mcfact, 'VALE_C': l_vmoye, } else: mcfactc = { 'NOM_CMP': nom_cmps, 'NOEUD': l_noeud_mcfact, 'VALE': l_vmoye, } argsa['AFFE'].append(mcfactc) __chame[ind] = CREA_CHAMP(OPERATION='AFFE', MODELE=MODELE_1, TYPE_CHAM=TYPE_CHAM, OPTION='EPSI_NOEU', **argsa) if isinstance(RESULTAT, mode_meca): mcfact2 = { 'CHAM_GD': __chame[ind], 'MODELE': MODELE_1, 'NUME_MODE': int(afreq[ind, 0]), 'FREQ': afreq[ind, 1], } if isinstance(RESULTAT, evol_elas): mcfact2 = { 'CHAM_GD': __chame[ind], 'MODELE': MODELE_1, 'INST': list_inst[ind], } if isinstance(RESULTAT, dyna_trans): mcfact2 = { 'CHAM_GD': __chame[ind], 'MODELE': MODELE_1, 'INST': list_inst[ind], } if isinstance(RESULTAT, dyna_harmo): mcfact2 = { 'CHAM_GD': __chame[ind], 'MODELE': MODELE_1, 'FREQ': list_freq[ind], } if cham_mater is not None: mcfact2['CHAM_MATER'] = cham_mater if cara_elem is not None: mcfact2['CARA_ELEM'] = cara_elem liste.append(mcfact2) resu_epsi = 'EPSI_NOEU' RESU = CREA_RESU( OPERATION='AFFE', TYPE_RESU=TYPE_RESU, NOM_CHAM='EPSI_NOEU', AFFE=liste, ) #*********************************************** # BOUCLE SUR LES NOM_CHAM #*********************************************** for nomcham in NOM_CHAM: if nomcham == 'DEPL' or nomcham == 'VITE' or nomcham == 'ACCE': if isinstance(RESULTAT, dyna_harmo): TYPE_CHAM = 'NOEU_DEPL_C' else: TYPE_CHAM = 'NOEU_DEPL_R' elif nomcham == 'EPSI_NOEU': if isinstance(RESULTAT, dyna_harmo): TYPE_CHAM = 'NOEU_EPSI_C' else: TYPE_CHAM = 'NOEU_EPSI_R' else: UTMESS('F', 'ELEMENTS4_48', valk=[nomcham]) #*********************************************** # PHASE DE PROJECTION #*********************************************** if PROJECTION == 'OUI': if resu_epsi and nomcham == 'EPSI_NOEU': __proj = PROJ_CHAMP(METHODE='COLLOCATION', RESULTAT=RESU, MODELE_1=MODELE_1, MODELE_2=MODELE_2, NOM_CHAM=nomcham, **mcfact) else: __proj = PROJ_CHAMP(METHODE='COLLOCATION', RESULTAT=RESULTAT, MODELE_1=MODELE_1, MODELE_2=MODELE_2, NOM_CHAM=nomcham, **mcfact) modele = MODELE_2 else: if resu_epsi and nomcham == 'EPSI_NOEU': __proj = RESU else: __proj = RESULTAT modele = MODELE_1 #*********************************************** # PHASE DE CHANGEMENT DE REPERE #*********************************************** # Le changement de repere se fait dans les routines exterieures # crea_normale et crea_repere # On range dans le mcfact MODI_REPERE une liste de modifications. ex : # MODI_REPERE = ( _F( GROUP_NO = toto, # REPERE = 'NORMALE' ), # CONDITION = (1.0,0.0,0.0), # NOM_PARA = 'X') # _F( NOEUD = ('a','z','e'...), # REPERE = 'CYLINDRIQUE', # ORIGINE = (0.,0.,0.), # AXE_Z = (0.,1.,0.), ), # _F( GROUP_NO = titi, # REPERE = 'UTILISATEUR', # ANGL_NAUT = (alpha, beta, gamma), ) # ) if MODIF_REPERE != None: num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] for modif_rep in MODIF_REPERE: modi_rep = modif_rep.val type_cham = modif_rep['TYPE_CHAM'] nom_cmp = modif_rep['NOM_CMP'] if type_cham == 'TENS_2D': nomchamx = 'EPSI_NOEU' elif type_cham == 'TENS_3D': nomchamx = 'EPSI_NOEU' else: nomchamx = 'DEPL' if nomcham == nomchamx: mcfact1 = { 'NOM_CMP': nom_cmp, 'TYPE_CHAM': type_cham, 'NOM_CHAM': nomcham } mcfact2 = {} if modi_rep['REPERE'] == 'DIR_JAUGE': vect_x = None vect_y = None if modi_rep.has_key('VECT_X'): vect_x = modi_rep['VECT_X'] if modi_rep.has_key('VECT_Y'): vect_y = modi_rep['VECT_Y'] # il faut des mailles pour les tenseurs d'ordre 2 for typ in [ 'MAILLE', 'GROUP_MA', ]: if modi_rep.has_key(typ): if PROJECTION == 'OUI': maya = mayaexp else: maya = mayanum list_ma = find_ma(maya, {typ: modi_rep[typ]}) angl_naut = crea_repere_xy(vect_x, vect_y) mcfact2.update({ 'MAILLE': list_ma, 'ANGL_NAUT': angl_naut }) argsm = {'MODI_CHAM': mcfact1, 'AFFE': mcfact2} __bidon = MODI_REPERE(RESULTAT=__proj, REPERE='UTILISATEUR', NUME_ORDRE=num_ordr, **argsm) DETRUIRE(CONCEPT=_F(NOM=__proj), INFO=1) __proj = __bidon if modi_rep['REPERE'] == 'NORMALE': # Cas ou l'utilisateur choisit de creer les reperes locaux # selon la normale. On fait un changement de repere local # par noeud for option in [ 'VECT_X', 'VECT_Y', 'CONDITION_X', 'CONDITION_Y' ]: if modi_rep.has_key(option): vect = {option: modi_rep[option]} if len(vect) != 1: UTMESS('E', 'UTILITAI7_9') chnorm = crea_normale(self, MODELE_1, MODELE_2, NUME_DDL, cham_mater, cara_elem) modele = MODELE_2 chnormx = chnorm.EXTR_COMP('DX', [], 1) ind_noeuds = chnormx.noeud nom_allno = [ mayaexp.sdj.NOMNOE.get()[k - 1] for k in ind_noeuds ] # on met les noeuds conernes sous forme de liste et on va # chercher les noeuds des mailles pour 'MAILLE' et # 'GROUP_MA' for typ in ['NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA']: if modi_rep.has_key(typ): list_no_exp = find_no(mayaexp, {typ: modi_rep[typ]}) # boucle sur les noeuds pour modifier les reperes. __bid = [None] * (len(list_no_exp) + 1) __bid[0] = __proj k = 0 for nomnoe in list_no_exp: ind_no = nom_allno.index(nomnoe) angl_naut = crea_repere(chnorm, ind_no, vect) mcfact2.update({ 'NOEUD': nomnoe, 'ANGL_NAUT': angl_naut }) argsm = {'MODI_CHAM': mcfact1, 'AFFE': mcfact2} __bid[k + 1] = MODI_REPERE(RESULTAT=__bid[k], REPERE='UTILISATEUR', TOUT_ORDRE='OUI', CRITERE='RELATIF', **argsm) k = k + 1 __proj = __bid[-1:][0] if modi_rep['REPERE'] == 'UTILISATEUR' or modi_rep[ 'REPERE'] == 'CYLINDRIQUE': if type_cham == 'TENS_2D' or type_cham == 'TENS_3D': for typ in [ 'MAILLE', 'GROUP_MA', ]: if modi_rep.has_key(typ): mcfact2.update({typ: modi_rep[typ]}) else: for typ in [ 'NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA' ]: if modi_rep.has_key(typ): mcfact2.update({typ: modi_rep[typ]}) if modi_rep['REPERE'] == 'CYLINDRIQUE': origine = modi_rep['ORIGINE'] axe_z = modi_rep['AXE_Z'] mcfact2.update({ 'ORIGINE': origine, 'AXE_Z': axe_z }) elif modi_rep['REPERE'] == 'UTILISATEUR': angl_naut = modi_rep['ANGL_NAUT'] mcfact2.update({'ANGL_NAUT': angl_naut}) argsm = { 'MODI_CHAM': mcfact1, 'REPERE': modi_rep['REPERE'], 'AFFE': mcfact2 } __bidon = MODI_REPERE(RESULTAT=__proj, CRITERE='RELATIF', **argsm) DETRUIRE(CONCEPT=_F(NOM=__proj), INFO=1) __proj = __bidon #************************************************* # Phase de selection des DDL de mesure #************************************************* resu_filtre = None if FILTRE != None: num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] __chamf = [None] * len(indice) if isinstance(RESULTAT, evol_elas): list_inst = __proj.LIST_VARI_ACCES()['INST'] if isinstance(RESULTAT, dyna_trans): list_inst = __proj.LIST_VARI_ACCES()['INST'] if isinstance(RESULTAT, dyna_harmo): list_freq = __proj.LIST_VARI_ACCES()['FREQ'] liste = [] for ind in indice: mcfact2 = {} filtres = [] __chamex = CREA_CHAMP( TYPE_CHAM=TYPE_CHAM, OPERATION='EXTR', RESULTAT=__proj, NOM_CHAM=nomcham, NUME_ORDRE=num_ordr[ind], ) for mcfiltre in FILTRE: filtre = mcfiltre.val try: nomchamx = filtre['NOM_CHAM'] except KeyError: nomchamx = None if nomchamx == None or nomchamx == nomcham: mcfact1 = {} atraiter = None if filtre['DDL_ACTIF'][0][ 0] == 'E' and nomcham == 'EPSI_NOEU': atraiter = nomcham elif filtre['DDL_ACTIF'][0][ 0] == 'D' and nomcham == 'DEPL': atraiter = nomcham elif filtre['DDL_ACTIF'][0][ 0] == 'D' and nomcham == 'VITE': atraiter = nomcham elif filtre['DDL_ACTIF'][0][ 0] == 'D' and nomcham == 'ACCE': atraiter = nomcham if atraiter: for typ in [ 'NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA' ]: if filtre.has_key(typ): mcfact1.update({typ: filtre[typ]}) mcfact1.update({ 'NOM_CMP': filtre['DDL_ACTIF'], 'CHAM_GD': __chamex }) filtres.append(mcfact1) if len(filtres) > 0: if nomcham == 'DEPL' or nomcham == 'VITE' or nomcham == 'ACCE': __chamf[ind] = CREA_CHAMP(TYPE_CHAM=TYPE_CHAM, OPERATION='ASSE', MODELE=modele, ASSE=filtres) elif nomcham == 'EPSI_NOEU': __chamf[ind] = CREA_CHAMP( TYPE_CHAM=TYPE_CHAM, OPERATION='ASSE', MODELE=modele, ASSE=filtres, ) else: valk = [] valk.append(nomcham) valk.append('DEPL VITE ACCE') valk.append('EPSI_NOEU') UTMESS('F', 'OBSERVATION_6', valk) argsr = {} if isinstance(RESULTAT, mode_meca): mcfact2 = { 'CHAM_GD': __chamf[ind], 'MODELE': modele, 'NUME_MODE': int(afreq[ind, 0]), 'FREQ': afreq[ind, 1], } # on recopie les matrices associees au MODELE_2 dans le resultat final # NB : ce n'est peut-etre pas propre, car ces matrices ne # veulent plus rien dire si on a filtre des DDL !!!!! argsr = { 'MATR_RIGI': MATR_RIGI, 'MATR_MASS': MATR_MASS } if isinstance(RESULTAT, evol_elas): mcfact2 = { 'CHAM_GD': __chamf[ind], 'MODELE': modele, 'INST': list_inst[ind], } if isinstance(RESULTAT, dyna_trans): mcfact2 = { 'CHAM_GD': __chamf[ind], 'MODELE': modele, 'INST': list_inst[ind], } if isinstance(RESULTAT, dyna_harmo): mcfact2 = { 'CHAM_GD': __chamf[ind], 'MODELE': MODELE_2, 'FREQ': list_freq[ind], } if cham_mater is not None: mcfact2['CHAM_MATER'] = cham_mater if cara_elem is not None: mcfact2['CARA_ELEM'] = cara_elem liste.append(mcfact2) DETRUIRE(CONCEPT=_F(NOM=__chamex), INFO=1) if len(filtres) > 0 and len(liste) > 0: resu_filtre = nomcham if RESU: RESU = CREA_RESU(reuse=RESU, OPERATION='AFFE', TYPE_RESU=TYPE_RESU, NOM_CHAM=nomcham, AFFE=liste, **argsr) else: RESU = CREA_RESU(OPERATION='AFFE', TYPE_RESU=TYPE_RESU, NOM_CHAM=nomcham, AFFE=liste, **argsr) #************************************************* # Recopie de __proj dans RESU si celle-ci # n'a pas encore ete faite via FILTRE #************************************************* if resu_filtre == None: RESU = PROJ_CHAMP(METHODE='COLLOCATION', RESULTAT=__proj, MODELE_1=modele, MODELE_2=modele, NUME_DDL=NUME_DDL, NOM_CHAM=nomcham, **mcfact) return ier
def post_czm_fiss_ops(self, OPTION, RESULTAT, **args): """Corps de POST_CZM_FISS""" ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # # calcul de la longueur d'une fissure cohesive 2D # if OPTION == "LONGUEUR": # Nom de la sortie self.DeclareOut('TABLE_OUT', self.sd) # Mots cles specifiques au bloc "LONGUEUR" GROUP_MA = args['GROUP_MA'] POINT_ORIG = args['POINT_ORIG'] VECT_TANG = args['VECT_TANG'] # On importe les definitions des commandes a utiliser dans la macro CALC_CHAM_ELEM = self.get_cmd('CALC_CHAM_ELEM') CREA_CHAMP = self.get_cmd('CREA_CHAMP') CREA_TABLE = self.get_cmd('CREA_TABLE') EXTR_COMP = self.get_cmd('EXTR_COMP') DETRUIRE = self.get_cmd('DETRUIRE') # Recuperation du nom du modele iret, ibid, n_modele = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT', 'F') n_modele = n_modele.rstrip() if len(n_modele) == 0: UTMESS('F', 'RUPTURE0_18') __MODEL = self.get_concept(n_modele) # Calcul des coordonnees des points de Gauss __CHAMEL = CALC_CHAM_ELEM(MODELE=__MODEL, GROUP_MA=GROUP_MA, OPTION='COOR_ELGA') __CORX = __CHAMEL.EXTR_COMP('X', list(GROUP_MA), 1) __CORY = __CHAMEL.EXTR_COMP('Y', list(GROUP_MA), 1) xg = __CORX.valeurs yg = __CORY.valeurs nbpg = len(xg) xmin = min(xg) ymin = min(yg) xmax = max(xg) ymax = max(yg) # A = coef dir et B=ordo orig de la droite des pg A = (ymax - ymin) / (xmax - xmin) B = ymax - A * xmax # Vecteur des points de gauss (qui va du point min au point max) et sa # norme vx = xmax - xmin vy = ymax - ymin nv = (vx**2 + vy**2)**0.5 # vecteur directeur dans la direction ou l'on calcule la longueur xdir = VECT_TANG[0] ydir = VECT_TANG[1] ndir = (xdir**2 + ydir**2)**0.5 # point de reference a partir duquel on calcule la longueur xref = POINT_ORIG[0] yref = POINT_ORIG[1] # angle entre le vecteur des points de gauss et le vecteur donne par # l'utilisateur alpha = acos((xdir * vx + ydir * vy) / (ndir * nv)) # petit parametre de tolerence eps = 0.0001 # cas ou le point de reference n'est pas aligne avec les points de # Gauss if (abs(yref - A * xref - B) >= eps): UTMESS('F', 'POST0_45', valk=list(GROUP_MA), valr=(xmin, xmax, ymin, ymax)) # cas ou le vecteur n'est pas colineaire a la droite des points de # Gauss if (abs(alpha) >= eps) and (abs(alpha - pi) >= eps): UTMESS('F', 'POST0_46', valk=list(GROUP_MA), valr=(xmin, xmax, ymin, ymax)) # Calcul de la distance signee des points de Gauss au point de # reference disg = distance(xg, yg, xref, yref, xdir, ydir) ming = min(disg) maxg = max(disg) __INST = RESULTAT.LIST_VARI_ACCES()['INST'] nbinst = len(__INST) Lfis = [0] * (nbinst) Ltot = [0] * (nbinst) Lcoh = [0] * (nbinst) __VI = [0] * (nbinst) for j in range(0, nbinst): __VI[j] = CREA_CHAMP( TYPE_CHAM='ELGA_VARI_R', OPERATION='EXTR', RESULTAT=RESULTAT, NOM_CHAM='VARI_ELGA', NUME_ORDRE=j, ) __VI3 = __VI[j].EXTR_COMP('V3', list(GROUP_MA), 1) mat_v3 = __VI3.valeurs nbpg = len(mat_v3) # Evaluation du nombre de points de gauss dans chaque etat cpt0 = 0 cpt1 = 0 cpt2 = 0 max0 = ming min0 = maxg max1 = ming min1 = maxg max2 = ming min2 = maxg for i in range(0, nbpg): if (disg[i] >= 0.0): if mat_v3[i] == 1.: # si c'est un pdg en zone cohesive cpt1 = cpt1 + 1 max1 = max(max1, disg[i]) min1 = min(min1, disg[i]) else: if mat_v3[i] == 2.: # si c'est un pdg en fissure cpt2 = cpt2 + 1 max2 = max(max2, disg[i]) min2 = min(min2, disg[i]) else: if mat_v3[i] == 0.: # si c'est un pdg sain cpt0 = cpt0 + 1 max0 = max(max0, disg[i]) min0 = min(min0, disg[i]) # verification qu'entre min1 et max1 on a que des mailles 1 for i in range(0, nbpg): if (cpt1 != 0): if (disg[i] >= min1) and (disg[i] <= max1): if (mat_v3[i] != 1.): UTMESS('A', 'POST0_48') # Verification qu'il y a bien des points de Gauss sur la # demi-droite definie par l'utilisateur if (cpt0 + cpt1 + cpt2 == 0): UTMESS('F', 'POST0_47', valk=list(GROUP_MA), valr=(xmin, xmax, ymin, ymax)) # Verification de la taille de la zone cohesive if (cpt2 != 0) and (cpt1 <= 3): UTMESS('A', 'POST0_49') # Evaluation des longueurs if (cpt1 == 0) and (cpt2 == 0): Ltot[j] = min0 Lfis[j] = min0 else: if (cpt1 != 0) and (cpt2 == 0): Ltot[j] = (min0 + max1) / 2.0 Lfis[j] = min1 else: if (cpt1 == 0) and (cpt2 != 0): Ltot[j] = (min0 + max2) / 2.0 Lfis[j] = (min0 + max2) / 2.0 else: Ltot[j] = (min0 + max1) / 2.0 Lfis[j] = (min1 + max2) / 2.0 Lcoh[j] = Ltot[j] - Lfis[j] DETRUIRE(CONCEPT=_F(NOM=__VI[j])) TABLE_OUT = CREA_TABLE(LISTE=( _F(LISTE_R=__INST, PARA='INST'), _F(LISTE_R=Lfis, PARA='LONG_FIS'), _F(LISTE_R=Ltot, PARA='LONG_TOT'), _F(LISTE_R=Lcoh, PARA='LONG_COH'), ), ) # # calcul de la triaxialite dans les elements massifs voisins de l'interface cohesive # elif OPTION == "TRIAXIALITE": self.DeclareOut('CARTE_OUT', self.sd) CARTE_OUT = POST_VOISIN_CZM(RESULTAT=RESULTAT) return ier
def raff_xfem_ops(self, FISSURE, TYPE, **args): """ Macro RAFF_XFEM Calcule un indicateur permettant de caracteriser une zone qui sera raffinee. L'indicateur est soit la distance (au fond de fissure pour les fissures, a l'interface pour les interfaces), soit un indicateur binaire qui vaut 1 dans la zone d'interet """ import aster import string import copy import math from types import ListType, TupleType from code_aster.Cata.Syntax import _F from SD.sd_xfem import sd_fiss_xfem EnumTypes = (ListType, TupleType) macro = 'RAFF_XFEM' from code_aster.Cata.Syntax import _F from Utilitai.Utmess import UTMESS # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # Le concept sortant self.DeclareOut('chamout', self.sd) # On importe les definitions des commandes a utiliser dans la macro # Le nom de la variable doit etre obligatoirement le nom de la commande FORMULE = self.get_cmd('FORMULE') CREA_CHAMP = self.get_cmd('CREA_CHAMP') DETRUIRE = self.get_cmd('DETRUIRE') from Contrib.raff_xfem_zone import RAFF_XFEM_ZONE IMPR_CO = self.get_cmd('IMPR_CO') assert (TYPE in ('DISTANCE', 'ZONE')) # recuperation de la liste des fissures/interfaces nbfiss = len(FISSURE) # on recupere le concept maillage "associe a la sd" nom_ma = get_nom_maillage_sdfiss(FISSURE[0]) MA = self.get_concept(nom_ma) # on verifie que toutes les fissures/interfaces sont rattachees au meme # maillage for i in range(1, nbfiss): nom_ma_i = get_nom_maillage_sdfiss(FISSURE[i]) if nom_ma_i != nom_ma: UTMESS('F', 'XFEM2_10', valk=(FISSURE[0].nom, nom_ma, FISSURE[i].nom, nom_ma_i)) # indicateur de type 'DISTANCE' if TYPE == 'DISTANCE': # formule distance pour une fissure: -r __MDISTF = FORMULE(NOM_PARA=('X1', 'X2'), VALE='-1.*sqrt(X1**2+X2**2)') # formule distance pour une interface: -r = -|lsn| __MDISTI = FORMULE(NOM_PARA=('X1'), VALE='-1.*sqrt(X1**2)') __CERR = [None] * nbfiss list_err = [] list_nom_cmp = [] for_max = 'max(' for i in range(0, nbfiss): fiss = FISSURE[i] # recuperation du type de discontinuite :'FISSURE' ou 'INTERFACE' # si FISSURE : l'erreur est la distance au fond de fissure # si INTERFACE : l'erreur est la distance a l'interface iret, ibid, typ_ds = aster.dismoi('TYPE_DISCONTINUITE', fiss.nom, 'FISS_XFEM', 'F') typ_ds = typ_ds.rstrip() # extraction des champs level sets __CHLN = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R', OPERATION='EXTR', NOM_CHAM='LNNO', FISSURE=fiss) if typ_ds == 'FISSURE': __CHLTB = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R', OPERATION='EXTR', NOM_CHAM='LTNO', FISSURE=fiss) # on renomme le composante X1 en X2 __CHLT = CREA_CHAMP( TYPE_CHAM='NOEU_NEUT_R', OPERATION='ASSE', MAILLAGE=MA, ASSE=_F( TOUT='OUI', CHAM_GD=__CHLTB, NOM_CMP='X1', NOM_CMP_RESU='X2', ), ) DETRUIRE(CONCEPT=_F(NOM=__CHLTB), INFO=1) # On affecte à chaque noeud du maillage MA la formule __MDISTF ou # __MDISTI if typ_ds == 'FISSURE': __CHFOR = CREA_CHAMP( TYPE_CHAM='NOEU_NEUT_F', OPERATION='AFFE', MAILLAGE=MA, AFFE=_F( TOUT='OUI', NOM_CMP='X1', VALE_F=__MDISTF, ), ) elif typ_ds == 'INTERFACE': __CHFOR = CREA_CHAMP( TYPE_CHAM='NOEU_NEUT_F', OPERATION='AFFE', MAILLAGE=MA, AFFE=_F( TOUT='OUI', NOM_CMP='X1', VALE_F=__MDISTI, ), ) # on evalue en tout noeud le champ de formules if typ_ds == 'FISSURE': __CERRB = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R', OPERATION='EVAL', CHAM_F=__CHFOR, CHAM_PARA=( __CHLN, __CHLT, )) DETRUIRE(CONCEPT=_F(NOM=__CHLT), INFO=1) elif typ_ds == 'INTERFACE': __CERRB = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R', OPERATION='EVAL', CHAM_F=__CHFOR, CHAM_PARA=(__CHLN, )) DETRUIRE(CONCEPT=_F(NOM=__CHLN), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__CHFOR), INFO=1) # champ d'Erreur de la fissure i __CERR[i] = CREA_CHAMP( TYPE_CHAM='NOEU_NEUT_R', OPERATION='ASSE', MAILLAGE=MA, ASSE=_F( TOUT='OUI', CHAM_GD=__CERRB, NOM_CMP='X1', NOM_CMP_RESU='X' + str(i + 1), ), ) list_err.append(__CERR[i]) list_nom_cmp.append('X' + str(i + 1)) for_max = for_max + 'X' + str(i + 1) + ',' DETRUIRE(CONCEPT=_F(NOM=__CERRB), INFO=1) # si nbfiss = 1, c'est directement X1 # si nbfiss > 1 : on prend le max des erreurs de chaque fissure for_max = for_max + ')' if nbfiss == 1: __Erreur = FORMULE(NOM_PARA=(list_nom_cmp), VALE='X1') else: __Erreur = FORMULE(NOM_PARA=(list_nom_cmp), VALE=for_max) # Définition de l'erreur en chaque noeud du maillage __CHFORM = CREA_CHAMP( TYPE_CHAM='NOEU_NEUT_F', OPERATION='AFFE', MAILLAGE=MA, AFFE=_F( TOUT='OUI', NOM_CMP='X1', VALE_F=__Erreur, ), ) # champ de sortie chamout = CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R', OPERATION='EVAL', CHAM_F=__CHFORM, CHAM_PARA=(list_err)) for i in range(0, nbfiss): DETRUIRE(CONCEPT=_F(NOM=__CERR[i]), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__MDISTF), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__MDISTI), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__Erreur), INFO=1) DETRUIRE(CONCEPT=_F(NOM=__CHFORM), INFO=1) # indicateur de type 'ZONE' elif TYPE == 'ZONE': __CERR = [None] * nbfiss list_asse = [] for i in range(0, nbfiss): __CERR[i] = RAFF_XFEM_ZONE(FISSURE=FISSURE[i], RAYON=args['RAYON']) list_asse.append({ 'CHAM_GD': __CERR[i], 'COEF_R': 1., 'CUMUL': 'OUI', 'TOUT': 'OUI' }) # champ de sortie chamout = CREA_CHAMP(TYPE_CHAM='CART_NEUT_R', OPERATION='ASSE', MAILLAGE=MA, ASSE=list_asse) return
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)
def post_bordet_ops(self, TOUT, GROUP_MA, INST, PRECISION, CRITERE, NUME_ORDRE, PROBA_NUCL, RESULTAT, PARAM, TEMP, COEF_MULT, **args): """Corps de POST_BORDET""" import numpy as NP import aster from code_aster.Cata.Syntax import _F from code_aster.Cata.DataStructure import fonction_sdaster, nappe_sdaster from Utilitai.Utmess import UTMESS ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # On importe les definitions des commandes a utiliser dans la macro CREA_CHAMP = self.get_cmd('CREA_CHAMP') CALC_CHAM_ELEM = self.get_cmd('CALC_CHAM_ELEM') CALC_CHAMP = self.get_cmd('CALC_CHAMP') CREA_TABLE = self.get_cmd('CREA_TABLE') FORMULE = self.get_cmd('FORMULE') CALC_TABLE = self.get_cmd('CALC_TABLE') # # Definition du concept sortant dans le contexte de la macro self.DeclareOut('tabout', self.sd) # # Recuperation du modele a partir du resultat iret, ibid, n_modele = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT', 'F') n_modele = n_modele.rstrip() if len(n_modele) == 0 or n_modele == "#PLUSIEURS": UTMESS('F', 'RUPTURE1_58') model = self.get_concept(n_modele) # Dimension du modele iret, ndim, rbid = aster.dismoi('DIM_GEOM', model.nom, 'MODELE', 'F') if iret == 1 or ndim == 23: UTMESS('F', 'RUPTURE1_57') # # Definition des formules pour le calcul de sigy plus tard # __MAXI = FORMULE(NOM_PARA=('T1'), VALE="""max(T1,0.)""") # # Calcul des grandeurs dont on a besoin : contrainte principale, def plastique et volume du pt de gauss # # Volume point de gauss __VOL_PG = CALC_CHAM_ELEM( MODELE=model, TOUT='OUI', OPTION='COOR_ELGA', ) if GROUP_MA: GROUP_MA = list(GROUP_MA) vol = __VOL_PG.EXTR_COMP('W', GROUP_MA) elif TOUT: vol = __VOL_PG.EXTR_COMP('W', []) # contrainte principale max et deformation plastique __RESU = CALC_CHAMP( RESULTAT=self['RESULTAT'], CRITERES='SIEQ_ELGA', DEFORMATION='EPSP_ELGA', ) # Recuperation de la liste des instants et des ordres de calcul list_ordre = __RESU.LIST_VARI_ACCES()['NUME_ORDRE'] list_inst = __RESU.LIST_VARI_ACCES()['INST'] # # On va travailler en ordre ; si l'utilisateur entre un instant, on va le # transformer en ordre entree_instant = None if INST: if CRITERE == 'ABSOLU': prec = PRECISION elif CRITERE == 'RELATIF': prec = PRECISION * INST entree_instant = True n = 0 trouv = None while (n < len(list_inst) and not trouv): if (list_inst[n] + prec >= INST) and (list_inst[n] - prec <= INST): instant = list_inst[n] trouv = True n = n + 1 if not trouv: UTMESS('F', 'RUPTURE1_53', valr=INST, valk='utilise pour le calcul de Bordet') if entree_instant == True: index_ordre = list_inst.index(instant) nume_ordre = list_ordre[index_ordre] elif NUME_ORDRE: nume_ordre = NUME_ORDRE if nume_ordre not in list_ordre: UTMESS('F', 'RUPTURE0_51', vali=int(nume_ordre), valk='utilise pour le calcul de Bordet') # # Pour Bordet, il nous faut les champs a tous les instants jusqu'a # l'instant considere EP = [[None for j in range(6)] for i in range(nume_ordre + 1) ] # tenseur des deformations plastiques EPEQ = [[None for j in range(0)] for i in range(nume_ordre + 1) ] # deformation plastique equivalente EPEQM = [0.] * (nume_ordre + 1) #deformation plastique equivalente a l'instant precedent PRIN = [None] * (nume_ordre + 1) EQ_BAR = [None] * (nume_ordre + 1) EQ_PT = [None] * (nume_ordre + 1) EQ_PT2 = [None] * (nume_ordre + 1) PR_BAR = [None] * (nume_ordre + 1) DEP = [None] * (nume_ordre + 1) BORDTI = 0. # valeur sans l'exposant final, sommee sur les instants BORDTT = [0.] * (nume_ordre + 1) # valeur avec l'exposant, que l'on stocke dans la table a # chaque instant PROBA = [0.] * (nume_ordre + 1) # Probabilite de rupture par clivage # LISTE DES PARAMETRES sig0 = PARAM['SEUIL_REFE'] sigth = PARAM['SIG_CRIT'] sigref = PARAM['SIGM_REFE'] m = PARAM['M'] V0 = PARAM['VOLU_REFE'] if PROBA_NUCL == 'OUI': ep0 = PARAM['DEF_PLAS_REFE'] elif PROBA_NUCL == 'NON': ep0 = 0 c_mult = COEF_MULT # # On va constuire des champs a chaque instant # if list_ordre[0] == 0: fin_ordre = nume_ordre + 1 elif list_ordre[0] != 0: fin_ordre = nume_ordre for ordre in range(list_ordre[0], fin_ordre): # # Temperature a extraire : soit une fonction du temps, soit un reel # if type(TEMP) == fonction_sdaster: tempe = TEMP(list_inst[ordre]) elif type(TEMP) != fonction_sdaster: tempe = TEMP def fseuil(epsi): return PARAM['SEUIL_CALC'](epsi, tempe) self.update_const_context({'fseuil': fseuil}) __NPY = FORMULE(NOM_PARA=('EPSI'), VALE="""fseuil(EPSI)""") # # On met ces grandeurs dans des champs specifiques # __S_TOT = CREA_CHAMP( TYPE_CHAM='ELGA_SIEF_R', RESULTAT=__RESU, OPERATION='EXTR', NUME_ORDRE=ordre, NOM_CHAM='SIEQ_ELGA', ) __EPSP = CREA_CHAMP( TYPE_CHAM='ELGA_EPSI_R', RESULTAT=__RESU, OPERATION='EXTR', NUME_ORDRE=ordre, NOM_CHAM='EPSP_ELGA', ) # On recupere la valeur des champs au niveau des groupes qui nous # interessent if GROUP_MA: PRIN[ordre] = __S_TOT.EXTR_COMP('PRIN_3', GROUP_MA, 0).valeurs # Pour la deformation plastique, on construit de quoi calculer sa # norme de VMises EP[ordre][0] = __EPSP.EXTR_COMP('EPXX', GROUP_MA, 0).valeurs EP[ordre][1] = __EPSP.EXTR_COMP('EPYY', GROUP_MA, 0).valeurs EP[ordre][2] = __EPSP.EXTR_COMP('EPZZ', GROUP_MA, 0).valeurs EP[ordre][3] = __EPSP.EXTR_COMP('EPXY', GROUP_MA, 0).valeurs if ndim == 3: EP[ordre][4] = EPSP[ordre].EXTR_COMP('EPXZ', GROUP_MA, 0).valeurs EP[ordre][5] = EPSP[ordre].EXTR_COMP('EPYZ', GROUP_MA, 0).valeurs elif TOUT: PRIN[ordre] = __S_TOT.EXTR_COMP('PRIN_3', [], 0).valeurs EP[ordre][0] = __EPSP.EXTR_COMP('EPXX', [], 0).valeurs EP[ordre][1] = __EPSP.EXTR_COMP('EPYY', [], 0).valeurs EP[ordre][2] = __EPSP.EXTR_COMP('EPZZ', [], 0).valeurs EP[ordre][3] = __EPSP.EXTR_COMP('EPXY', [], 0).valeurs if ndim == 3: EP[ordre][4] = __EPSP.EXTR_COMP('EPXZ', [], 0).valeurs EP[ordre][5] = __EPSP.EXTR_COMP('EPYZ', [], 0).valeurs nval = len(PRIN[ordre]) nval2 = len(EP[ordre][0]) if nval2 != nval: UTMESS('F', 'RUPTURE1_54') if ndim == 3: EPEQ[ordre] = NP.sqrt( 2. / 3. * (EP[ordre][0]**2 + EP[ordre][1]**2 + EP[ordre][2]**2 + 2. * EP[ordre][3]**2 + 2. * EP[ordre][4]**2 + 2. * EP[ordre][5]**2)) elif ndim == 2: EPEQ[ordre] = NP.sqrt(2. / 3. * (EP[ordre][0]**2 + EP[ordre][1]**2 + EP[ordre][2]**2 + 2. * EP[ordre][3]**2)) # Construction des champs barre et des champs de vitesse EQ_PT2[list_ordre[0]] = NP.zeros([nval]) EPEQ[ordre] = NP.array(EPEQ[ordre]) if ordre != list_ordre[0]: dt = list_inst[ordre] - list_inst[ordre - 1] if dt == 0: UTMESS('F', 'RUPTURE1_55') EPEQM[ordre] = EPEQ[ordre - 1] EQ_BAR[ordre] = (EPEQ[ordre] + EPEQ[ordre - 1]) / 2. EQ_PT2[ordre] = (EPEQ[ordre] - EPEQ[ordre - 1]) / (2 * dt) EQ_PT[ordre] = EQ_PT2[ordre - 1] + EQ_PT2[ordre] DEP[ordre] = EPEQ[ordre] - EPEQ[ordre - 1] PR_BAR[ordre] = (PRIN[ordre] + PRIN[ordre - 1]) / 2. if type(PARAM['SEUIL_CALC']) == fonction_sdaster: sigy = PARAM['SEUIL_CALC'](tempe) elif type(PARAM['SEUIL_CALC']) == nappe_sdaster: EQ_PT[ordre] = list(EQ_PT[ordre]) __TAB = CREA_TABLE(LISTE=(_F( PARA='EPSI', LISTE_R=EQ_PT[ordre], ), ), ) __TAB = CALC_TABLE( TABLE=__TAB, reuse=__TAB, ACTION=_F(OPERATION='OPER', FORMULE=__NPY, NOM_PARA='TSIGY'), ) sigy = __TAB.EXTR_TABLE().values()['TSIGY'] sigy = NP.array(sigy) T1 = sigy / sig0 * (PR_BAR[ordre]**m - sigth**m) T1 = list(T1) __TABT1 = CREA_TABLE(LISTE=(_F( PARA='T1', LISTE_R=T1, ), )) __TABT1 = CALC_TABLE( TABLE=__TABT1, reuse=__TABT1, ACTION=_F(OPERATION='OPER', FORMULE=__MAXI, NOM_PARA='T1BIS'), ) T1 = __TABT1.EXTR_TABLE().values()['T1BIS'] T1 = NP.array(T1) if PROBA_NUCL == 'OUI': T2 = NP.exp(-sigy / sig0 * EQ_BAR[ordre] / ep0) elif PROBA_NUCL == 'NON': T2 = 1. T3 = DEP[ordre] T4 = vol.valeurs / V0 BORDTI = BORDTI + NP.cumsum(T1 * T2 * T3 * T4)[-1] BORDTT[ordre] = (c_mult * BORDTI)**(1 / m) if sigref(tempe) != 0.: PROBA[ordre] = 1 - NP.exp(-(BORDTT[ordre] / sigref(tempe))**m) elif sigref(tempe) == 0.: UTMESS('F', 'RUPTURE1_56', valr=list_inst[ordre]) tabout = CREA_TABLE(LISTE=( _F(PARA='INST', LISTE_R=list_inst[0:nume_ordre + 1]), _F( PARA='SIG_BORDET', LISTE_R=BORDTT, ), _F( PARA='PROBA_BORDET', LISTE_R=PROBA, ), ), ) return ier
def char_grad_impo_ops(self, RESU_H2, TINIT, TFIN, RESUMECA, GRMAVOL, DIME, Ctot0, CHARGRD0, Vh, R, T, 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('chth', self.sd) # On importe les definitions des commandes a utiliser dans la macro CREA_CHAMP = self.get_cmd('CREA_CHAMP') AFFE_CHAR_THER = self.get_cmd('AFFE_CHAR_THER') CALC_CHAMP = self.get_cmd('CALC_CHAMP') CALC_CHAM_ELEM = self.get_cmd('CALC_CHAM_ELEM') dt = TFIN - TINIT # 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) # 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=__MAIL, 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.nom.ljust(8) + '.CHTH.GRAIN.VALE' nomlima = CHARGRD0.nom.ljust(8) + '.CHTH.GRAIN.LIMA' nomdesc = CHARGRD0.nom.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) nommai = __MAIL.sdj.NOMMAI.get() connex = __MAIL.sdj.CONNEX.get() groupma = __MAIL.sdj.GROUPEMA.get()[GRMAVOL.ljust(24)] nbzone = tabdesc[1] # print "tabdesc",tabdesc # print "tablima",dicolima for izone in 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 macro_elas_mult_ops(self, MODELE, CAS_CHARGE, CHAM_MATER=None, CARA_ELEM=None, NUME_DDL=None, CHAR_MECA_GLOBAL=None, LIAISON_DISCRET=None, SOLVEUR=None, **args): """ Ecriture de la macro MACRO_ELAS_MULT """ args = _F(args) if args['reuse'] is not None: changed = args.get('RESULTAT') if changed is None: UTMESS('F', 'SUPERVIS2_79', valk='RESULTAT') ielas = 0 ifour = 0 for m in CAS_CHARGE: if m['NOM_CAS']: ielas = 1 # mot clé NOM_CAS présent sous CAS_CHARGE tyresu = 'MULT_ELAS' else: ifour = 1 # mot clé MODE_FOURIER présent sous CAS_CHARGE tyresu = 'FOURIER_ELAS' if ielas == 1 and ifour == 1: UTMESS('F', 'ELASMULT0_1') if NUME_DDL in self.sdprods or NUME_DDL is None: # Si le concept NUME_DDL est dans self.sdprods ou n est pas nommé # il doit etre produit par la macro # il faudra donc appeler la commande NUME_DDL lnume = 1 else: lnume = 0 if ielas == 1: motscles = {} if CHAR_MECA_GLOBAL: motscles['CHARGE'] = CHAR_MECA_GLOBAL if CHAM_MATER: motscles['CHAM_MATER'] = CHAM_MATER if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM __nomrig = CALC_MATR_ELEM(OPTION='RIGI_MECA', MODELE=MODELE, **motscles) if lnume: # On peut passer des mots cles egaux a None. Ils sont ignores motscles = {} if NUME_DDL is not None: num = NUME_DDL_CMD(MATR_RIGI=__nomrig, **motscles) self.register_result(num, NUME_DDL) else: _num = NUME_DDL_CMD(MATR_RIGI=__nomrig, **motscles) num = _num else: num = NUME_DDL __nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num) if (SOLVEUR['METHODE'] == "MUMPS"): __nomras = FACTORISER( reuse=__nomras, MATR_ASSE=__nomras, NPREC=SOLVEUR['NPREC'], STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'], METHODE="MUMPS", PCENT_PIVOT=SOLVEUR['PCENT_PIVOT'], RENUM=SOLVEUR['RENUM'], TYPE_RESOL=SOLVEUR['TYPE_RESOL'], PRETRAITEMENTS=SOLVEUR['PRETRAITEMENTS'], ELIM_LAGR=SOLVEUR['ELIM_LAGR'], GESTION_MEMOIRE=SOLVEUR['GESTION_MEMOIRE'], ACCELERATION=SOLVEUR['ACCELERATION'], LOW_RANK_SEUIL=SOLVEUR['LOW_RANK_SEUIL'], ) else: __nomras = FACTORISER( reuse=__nomras, MATR_ASSE=__nomras, NPREC=SOLVEUR['NPREC'], STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'], METHODE=SOLVEUR['METHODE'], RENUM=SOLVEUR['RENUM'], ) # # boucle sur les items de CAS_CHARGE nomchn = [] lcharg = [] iocc = 0 for m in CAS_CHARGE: iocc = iocc + 1 # calcul de lcharg : liste des listes de char_meca (mots clé CHAR_MECA # et CHAR_MECA_GLOBAL) xx1 = m['CHAR_MECA'] if type(xx1) not in (tuple, list): xx1 = (xx1, ) xx2 = CHAR_MECA_GLOBAL if type(xx2) not in (tuple, list): xx2 = (xx2, ) lchar1 = [] for chargt in (tuple(xx1) + tuple(xx2)): if chargt: lchar1.append(chargt) lcharg.append(lchar1) assert len(lchar1) > 0 if ifour: motscles = {} if CHAR_MECA_GLOBAL: motscles['CHARGE'] = CHAR_MECA_GLOBAL if CHAM_MATER: motscles['CHAM_MATER'] = CHAM_MATER if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM motscles['MODE_FOURIER'] = m['MODE_FOURIER'] __nomrig = CALC_MATR_ELEM(OPTION='RIGI_MECA', MODELE=MODELE, **motscles) if lnume: _num = NUME_DDL_CMD(MATR_RIGI=__nomrig, ) num = _num lnume = 0 __nomras = ASSE_MATRICE(MATR_ELEM=__nomrig, NUME_DDL=num) if (SOLVEUR['METHODE'] == "MUMPS"): __nomras = FACTORISER( reuse=__nomras, MATR_ASSE=__nomras, NPREC=SOLVEUR['NPREC'], STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'], METHODE="MUMPS", PCENT_PIVOT=SOLVEUR['PCENT_PIVOT'], RENUM=SOLVEUR['RENUM'], TYPE_RESOL=SOLVEUR['TYPE_RESOL'], PRETRAITEMENTS=SOLVEUR['PRETRAITEMENTS'], ELIM_LAGR=SOLVEUR['ELIM_LAGR'], GESTION_MEMOIRE=SOLVEUR['GESTION_MEMOIRE'], ACCELERATION=SOLVEUR['ACCELERATION'], LOW_RANK_SEUIL=SOLVEUR['LOW_RANK_SEUIL'], ) else: __nomras = FACTORISER( reuse=__nomras, MATR_ASSE=__nomras, NPREC=SOLVEUR['NPREC'], STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'], METHODE=SOLVEUR['METHODE'], RENUM=SOLVEUR['RENUM'], ) if m['VECT_ASSE'] is None: motscles = {} l_calc_varc = False if CHAM_MATER: motscles['CHAM_MATER'] = CHAM_MATER iret, ibid, answer = aster.dismoi('EXI_VARC', CHAM_MATER.getName(), 'CHAM_MATER', 'F') if answer == 'OUI': l_calc_varc = True if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM if ifour: motscles['MODE_FOURIER'] = m['MODE_FOURIER'] if len(lchar1) > 0: motscles['CHARGE'] = lchar1 __nomvel = CALC_VECT_ELEM(OPTION='CHAR_MECA', **motscles) # chargement du aux variables de commandes if l_calc_varc: motscles = {} if CARA_ELEM: motscles['CARA_ELEM'] = CARA_ELEM if ifour: motscles['MODE_FOURIER'] = m['MODE_FOURIER'] __list1 = DEFI_LIST_REEL( DEBUT=0.0, INTERVALLE=_F( JUSQU_A=1.0, NOMBRE=1, ), ) if CHAR_MECA_GLOBAL: excit = [] for ch in CHAR_MECA_GLOBAL: excit.append({'CHARGE': ch}) __cont1 = CALCUL(OPTION=('FORC_VARC_ELEM_P'), MODELE=MODELE, CHAM_MATER=CHAM_MATER, INCREMENT=_F(LIST_INST=__list1, NUME_ORDRE=1), EXCIT=excit, COMPORTEMENT=_F(RELATION='ELAS', ), **motscles) else: __cont1 = CALCUL(OPTION=('FORC_VARC_ELEM_P'), MODELE=MODELE, CHAM_MATER=CHAM_MATER, INCREMENT=_F(LIST_INST=__list1, NUME_ORDRE=1), COMPORTEMENT=_F(RELATION='ELAS', ), **motscles) __vvarcp = EXTR_TABLE( TYPE_RESU='VECT_ELEM_DEPL_R', TABLE=__cont1, NOM_PARA='NOM_SD', FILTRE=_F(NOM_PARA='NOM_OBJET', VALE_K='FORC_VARC_ELEM_P'), ) __nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel, __vvarcp), NUME_DDL=num) else: __nomasv = ASSE_VECTEUR(VECT_ELEM=(__nomvel, ), NUME_DDL=num) else: __nomasv = m['VECT_ASSE'] if (SOLVEUR['METHODE'] == "MUMPS"): __nomchn = RESOUDRE(MATR=__nomras, CHAM_NO=__nomasv, TITRE=m['SOUS_TITRE'], RESI_RELA=SOLVEUR['RESI_RELA'], POSTTRAITEMENTS=SOLVEUR['POSTTRAITEMENTS']) else: __nomchn = RESOUDRE(MATR=__nomras, CHAM_NO=__nomasv, TITRE=m['SOUS_TITRE']) nomchn.append(__nomchn) # fin de la boucle sur les items de CAS_CHARGE # motscles = {} iocc = 0 motscle2 = {} if CHAM_MATER: motscle2['CHAM_MATER'] = CHAM_MATER if CARA_ELEM: motscle2['CARA_ELEM'] = CARA_ELEM if ielas: motscles['AFFE'] = [] for m in CAS_CHARGE: if len(lcharg[iocc]) > 0: motscles['AFFE'].append( _F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NOM_CAS=m['NOM_CAS'], CHARGE=lcharg[iocc], **motscle2)) else: motscles['AFFE'].append( _F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NOM_CAS=m['NOM_CAS'], **motscle2)) iocc = iocc + 1 else: motscles['AFFE'] = [] for m in CAS_CHARGE: if len(lcharg[iocc]) > 0: motscles['AFFE'].append( _F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NUME_MODE=m['MODE_FOURIER'], TYPE_MODE=m['TYPE_MODE'], CHARGE=lcharg[iocc], **motscle2)) else: motscles['AFFE'].append( _F(MODELE=MODELE, CHAM_GD=nomchn[iocc], NUME_MODE=m['MODE_FOURIER'], TYPE_MODE=m['TYPE_MODE'], **motscle2)) iocc = iocc + 1 if args.get("reuse"): motscles['reuse'] = args.get("reuse") motscles['RESULTAT'] = args.get("reuse") nomres = CREA_RESU(OPERATION='AFFE', TYPE_RESU=tyresu, NOM_CHAM='DEPL', **motscles) # # boucle sur les items de CAS_CHARGE pour SIEF_ELGA iocc = 0 for m in CAS_CHARGE: iocc = iocc + 1 if m['OPTION'] == 'SIEF_ELGA': motscles = {} if ielas: motscles['NOM_CAS'] = m['NOM_CAS'] else: motscles['NUME_MODE'] = m['MODE_FOURIER'] CALC_CHAMP(reuse=nomres, RESULTAT=nomres, CONTRAINTE='SIEF_ELGA', **motscles) # fin de la boucle sur les items de CAS_CHARGE # return nomres
def post_decollement_ops(self, RESULTAT, NOM_CHAM, NOM_CMP, GROUP_MA, INFO, **args): """ Corps de la macro POST_DECOLLEMENT """ ier = 0 import aster import os import string import types from code_aster.Cata.Syntax import _F from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme # On importe les definitions des commandes a utiliser dans la macro CREA_CHAMP = self.get_cmd('CREA_CHAMP') POST_ELEM = self.get_cmd('POST_ELEM') CREA_TABLE = self.get_cmd('CREA_TABLE') POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') DEFI_GROUP = self.get_cmd('DEFI_GROUP') DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU') CREA_RESU = self.get_cmd('CREA_RESU') AFFE_MODELE = self.get_cmd('AFFE_MODELE') AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU') IMPR_TABLE = self.get_cmd('IMPR_TABLE') # Comptage commandes + déclaration concept sortant self.set_icmd(1) self.DeclareOut('C_out', self.sd) # on recupere le concept maillage iret, ibid, nom_mo = aster.dismoi('MODELE', RESULTAT.nom, 'RESULTAT', 'F') if nom_mo == '#AUCUN' : iret, ibid, numddl = aster.dismoi('NUME_DDL', RESULTAT.nom, 'RESU_DYNA', 'F') iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', numddl, 'NUME_DDL', 'F') else : iret, ibid, nom_ma = aster.dismoi('NOM_MAILLA', nom_mo.strip(), 'MODELE', 'F') MAILLAGE = self.get_concept(nom_ma.strip()) # Creation du groupe de noeuds 'PDECOL' DEFI_GROUP(reuse=MAILLAGE, MAILLAGE=MAILLAGE, DETR_GROUP_NO=_F(NOM='PDECOL',), CREA_GROUP_NO=_F(GROUP_MA=GROUP_MA, NOM='PDECOL'), ALARME='NON',) # le modele 3D ne va contenir que des mailles de peau : on masque les # alarmes MasquerAlarme('CALCULEL2_63') MasquerAlarme('CALCULEL2_64') # model restreint au GROUP_MA __model = AFFE_MODELE(MAILLAGE=MAILLAGE, AFFE=_F(GROUP_MA=GROUP_MA, PHENOMENE='MECANIQUE', MODELISATION='3D'),) # le modele 3D ne va contenir que des mailles de peau : on retablit les # alarmes RetablirAlarme('CALCULEL2_63') RetablirAlarme('CALCULEL2_64') # Calcul de la surface du GROUP_MA : __surf __unit = CREA_CHAMP( OPERATION='AFFE', TYPE_CHAM='NOEU_NEUT_R', MODELE=__model, AFFE=_F(GROUP_NO='PDECOL', NOM_CMP='X1', VALE=1.0),) __chpg0 = CREA_CHAMP( PROL_ZERO='OUI', MODELE=__model, OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R', CHAM_GD=__unit) __mater0 = DEFI_MATERIAU(ELAS=_F(E=210000000.0, NU=0.3),) __chmat0 = AFFE_MATERIAU( MODELE=__model, MAILLAGE=MAILLAGE, AFFE=_F(TOUT='OUI', MATER=__mater0),) __resu0 = CREA_RESU( OPERATION='AFFE', TYPE_RESU='EVOL_ELAS', NOM_CHAM='VARI_ELGA', AFFE=_F(CHAM_MATER=__chmat0, MODELE=__model, CHAM_GD=__chpg0, INST=0.0),) __tbSurf0 = POST_ELEM(RESULTAT=__resu0, INST=0.0, MODELE=__model, INTEGRALE=_F(NOM_CHAM='VARI_ELGA', NOM_CMP='X1', GROUP_MA=GROUP_MA, TYPE_MAILLE='2D'),) __surf = __tbSurf0.EXTR_TABLE().values()['INTE_X1'][0] __linst = RESULTAT.LIST_VARI_ACCES()['INST'] # Calcul de la surface des noeuds décollés __pct = [] for inst in __linst: __dep = CREA_CHAMP( OPERATION='EXTR', RESULTAT=RESULTAT, TYPE_CHAM='NOEU_' + NOM_CHAM[:4] + '_R', INST=inst, NOM_CHAM=NOM_CHAM) __tb1 = POST_RELEVE_T( ACTION=_F( OPERATION='EXTRACTION', GROUP_NO='PDECOL', INTITULE=GROUP_MA, CHAM_GD=__dep, NOM_CMP=NOM_CMP),) __col = fctZeroUn(__tb1.EXTR_TABLE().values()[NOM_CMP]) __tb2 = CREA_TABLE( LISTE=( _F(LISTE_K=__tb1.EXTR_TABLE().values()['NOEUD'], PARA='NOEUD'), _F(LISTE_R=__col, PARA='X1'),),) __ch = CREA_CHAMP( OPERATION='EXTR', TYPE_CHAM='NOEU_NEUT_R', TABLE=__tb2, MAILLAGE=MAILLAGE) __chg = CREA_CHAMP( MODELE=__model, OPERATION='DISC', TYPE_CHAM='ELGA_NEUT_R', PROL_ZERO='OUI', CHAM_GD=__ch) __resu = CREA_RESU( OPERATION='AFFE', TYPE_RESU='EVOL_ELAS', NOM_CHAM='VARI_ELGA', AFFE=_F(CHAM_MATER=__chmat0, MODELE=__model, CHAM_GD=__chg, INST=0.0),) __tb3 = POST_ELEM(RESULTAT=__resu, INST=0.0, MODELE=__model, INTEGRALE=_F(NOM_CHAM='VARI_ELGA', NOM_CMP='X1', GROUP_MA=GROUP_MA, TYPE_MAILLE='2D'),) __su2 = __tb3.EXTR_TABLE().values()['INTE_X1'][0] __pct.append(100.0 * __su2 / __surf) C_out = CREA_TABLE(LISTE=(_F(LISTE_R=__linst, PARA='INST'), _F(LISTE_R=__pct, PARA='%DECOL'),),) if INFO > 1: IMPR_TABLE(UNITE=6, TABLE=C_out) return ier