def Traite_value(self, valeur, leType): """ Classe : B_ETAPE.ETAPE Methode : Traite_value INTENTION : Traitement du cas ou la donnee est un faux entier ou reel (classe entier et reel) de accas.capy. L'attribut 'valeur' de la sd a été renseigné par la commande qui l'a produite. C'est cette valeur qui est donc renvoyée ici. """ if CONTEXT.debug: print "Traite_value: ", valeur if valeur[0] == 0: return valeur tup_avant = valeur[1] list_apres = [] for k in tup_avant: if isinstance(k, N_ASSD.ASSD): k = k.valeur if is_sequence(k): if leType == "C8" and k[0] in ("MP", "RI"): # on est en presence d'un complexe isolé list_apres.append(k) else: # on est en presence d'une liste de (R8, C8, IS, TX, LS) list_apres.extend(k) else: # on est en presence d'un (R8, C8, IS, TX, LS) isolé list_apres.append(k) if valeur[0] < 0: # la longueur initiale etait superieure a mxval. # Elle ne peut qu'augmenter valeur_apres = (-len(list_apres), tuple(list_apres)) else: valeur_apres = (len(list_apres), tuple(list_apres)) return valeur_apres
def check_values(self, func, values): """Vérifier que les éléments de 'values' sont du bon type (pour getvid, getvtx, getvr8). """ ok = True if not is_sequence(values): values = [ values, ] for v in values: if is_sequence(v): ok = self.check_values(func, v) continue ok = func(v) if not ok: break return ok
def transforme_valeur_nom(self, valeur): """ Cette méthode a pour but de retourner soit une chaine de caractères représentant valeur (dans le cas ou valeur n'est pas une instance retourne la string valeur, sinon retourne valeur.nom) Traite le cas ou valeur est un tuple d'instances et retourne alors le tuple des strings """ if isinstance(valeur, N_ASSD.ASSD): return valeur.nom elif is_sequence(valeur): l = [] for obj in valeur: l.append(self.transforme_valeur_nom(obj)) return tuple(l) else: return valeur
def homo_support_nappe(l_f): """Homogénéisation du support d'une liste de nappes. Retourne une liste de nappes. """ if not is_sequence(l_f): l_f = [ l_f, ] l_fres = [] for f in l_f: assert isinstance( f, t_nappe), 'Erreur : homo_support_nappe est réservé aux nappes !' __ff = f for g in l_f: __ff = __ff.homo_support(g) l_fres.append(__ff) return l_fres
def __init__(self, vale_para, l_fonc, para, nom=''): """Création d'un objet nappe - vale_para est la liste de valeur des parametres (mot clé PARA dans DEFI_NAPPE) - para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER) - l_fonc est la liste des fonctions, de cardinal égal à celui de vale_para """ self.nom = nom pk = para.keys() pk.sort() if pk != [ 'INTERPOL', 'NOM_PARA', 'NOM_PARA_FONC', 'NOM_RESU', 'PROL_DROITE', 'PROL_GAUCHE' ]: raise FonctionError, 'nappe : parametres incorrects' if para['INTERPOL'] not in [ 'NON', 'LIN', 'LOG', ['NON', 'NON'], ['LIN', 'LIN'], ['LIN', 'LOG'], ['LOG', 'LOG'], ['LOG', 'LIN'], ]: raise FonctionError, 'nappe : parametre INTERPOL incorrect : %s' % para[ 'INTERPOL'] if para['PROL_DROITE'] not in ['EXCLU', 'CONSTANT', 'LINEAIRE']: raise FonctionError, 'nappe : parametre PROL_DROITE incorrect : %s' % para[ 'PROL_DROITE'] if para['PROL_GAUCHE'] not in ['EXCLU', 'CONSTANT', 'LINEAIRE']: raise FonctionError, 'nappe : parametre PROL_GAUCHE incorrect : %s' % para[ 'PROL_GAUCHE'] self.vale_para = NP.array(vale_para) if not is_sequence(l_fonc): raise FonctionError, 'nappe : la liste de fonctions fournie n est pas une liste' if len(l_fonc) != len(vale_para): raise FonctionError, 'nappe : nombre de fonctions différent du nombre de valeurs du paramètre' for f in l_fonc: if not isinstance(f, t_fonction) and not isinstance( f, t_fonction_c): raise FonctionError, 'nappe : les fonctions fournies ne sont pas du bon type' self.l_fonc = l_fonc self.para = para
def erreur_de_type(code_erreur, X): """ code_erreur ==0 --> X est une liste code erreur ==1 --> X est un char code erreur ==2 --> X est un float test est un boolean (test = 0 défaut et 1 si un test if est verifier """ txt = "" if (code_erreur == 0): if not is_sequence(X): txt = "\nCette entrée: " + str(X) + " n'est pas une liste valide" if (code_erreur == 1): if not is_str(X): txt = "\nCette entrée: " + \ str(X) + \ " n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python" if (code_erreur == 2): if not is_float(X): txt = "\nCette entrée: " + \ str(X) + \ " n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python" return txt
def calc_precont_ops(self, reuse, MODELE, CHAM_MATER, CARA_ELEM, EXCIT, CABLE_BP, CABLE_BP_INACTIF, COMPORTEMENT, ETAT_INIT, METHODE, ENERGIE, RECH_LINEAIRE, CONVERGENCE, INCREMENT, SOLVEUR, INFO, TITRE, **args): """ Ecriture de la macro CALC_PRECONT """ import copy import aster import string import types from code_aster.Cata.Syntax import _F from code_aster.Cata.DataStructure import listr8_sdaster, list_inst from Noyau.N_utils import AsType from Noyau.N_types import is_sequence from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme ier = 0 # On importe les definitions des commandes a utiliser dans la macro AFFE_MODELE = self.get_cmd('AFFE_MODELE') CREA_CHAMP = self.get_cmd('CREA_CHAMP') AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA') DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') STAT_NON_LINE = self.get_cmd('STAT_NON_LINE') CALC_CHAMP = self.get_cmd('CALC_CHAMP') DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') RECU_TABLE = self.get_cmd('RECU_TABLE') DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU') AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU') IMPR_TABLE = self.get_cmd('IMPR_TABLE') DETRUIRE = self.get_cmd('DETRUIRE') # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # Le concept sortant (de type evol_noli) est nomme RES dans # le contexte de la macro self.DeclareOut('RES', self.sd) # alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes # a tort MasquerAlarme('COMPOR4_70') # ------------------------------------------------------------- # 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE # ------------------------------------------------------------ # 1.1 Recuperation de la liste d'instants, de l'instant initial et final # Creation de la nouvelle liste d'instants # ---------------------------------------------------------- dIncrement = INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste) __prec = dIncrement['PRECISION'] __L0 = dIncrement['LIST_INST'] if type(__L0) == listr8_sdaster: # cas où liste definie par DEFI_LIST_REEL __L1 = __L0.Valeurs() elif type(__L0) == list_inst: # cas où liste definie par DEFI_LIST_INST tmp = __L0.get_name().ljust(8) + '.LIST.' + 'DITR'.ljust(18) __L1 = aster.getvectjev(tmp) # Traitement de l'etat initial if ETAT_INIT: dEtatInit = ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste) for i in dEtatInit.keys(): if dEtatInit[i] == None: del dEtatInit[i] else: dEtatInit = None # Teste si INST_INIT est donné ou bien recalcule __TMIN if dIncrement['INST_INIT'] == None: if self.reuse == None: __TMIN = __L1[0] else: __dico = self.reuse.LIST_VARI_ACCES() __TMIN = __dico['INST'][-1] else: __TMIN = dIncrement['INST_INIT'] # Teste si INST_FIN est donné ou bien recalcule __TMAX if dIncrement['INST_FIN'] == None: __TMAX = __L1[-1] else: __TMAX = dIncrement['INST_FIN'] # Teste si INST_INIT est bien plus petit que INST_FIN if __TMAX <= __TMIN: UTMESS('F', 'CABLE0_1') # Preparation de la liste d'instant __L2 allant de __TMIN a __TMAX # et preparation des instants supplementaire __TINT et __TINT2 __L2 = [] for m in __L1: if m >= __TMIN and m <= __TMAX: __L2.append(m) if len(__L2) < 2: UTMESS('F', 'CABLE0_4') __TINT = (9. * __L2[-1] + __L2[-2]) / 10. __TINT2 = (9.5 * __L2[-1] + .5 * __L2[-2]) / 10. # cas ADHERENT ou non ii = 0 typ_ma = [] for mcabl in CABLE_BP: __TCAB1 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL') table_cable = __TCAB1.EXTR_TABLE() __adher = table_cable.ADHERENT.values()[0] __typ_ma = table_cable.TYPE_MAILLE.values()[0] typ_ma.append(__typ_ma) if ii == 0: adher = __adher elif ii != 0 and __adher != adher: UTMESS('F', 'CABLE0_3') ii += 1 # DETRUIRE(CONCEPT=_F(NOM=__TCAB1)) adher = adher.strip() if (adher == 'OUI'): # finalisation liste instants __L2[-1:-1] = [__TINT] # __LST0 est la liste d'instants utilisée pour l'etape 1 __LST0 = DEFI_LIST_REEL( DEBUT=__TMIN, INTERVALLE=_F(JUSQU_A=__TMAX, NOMBRE=1), ) # __LST et __FCT sont utilisés pour les etapes 2 et 3 __LST = DEFI_LIST_REEL(VALE=__L2, ) __FCT = DEFI_FONCTION( INTERPOL=('LIN', 'LIN'), NOM_PARA='INST', VALE=(__TMIN, 0.0, __TINT, 1.0, __TMAX, 1.0), ) for i in dIncrement.keys(): if dIncrement[i] == None: del dIncrement[i] dIncrement['LIST_INST'] = __LST dIncrement['INST_FIN'] = __TINT # 1.2 Recuperation des parametres pour STAT_NON_LINE # ------------------------------------------------------- motscle4 = {} motscle5 = {} if METHODE == 'NEWTON': motscle4['NEWTON'] = args['NEWTON'].List_F() motscle5['NEWTON'] = args['NEWTON'].List_F() # for j in dNewton.keys(): # if dNewton[j]==None : del dNewton[j] dConvergence = CONVERGENCE[0].cree_dict_valeurs( CONVERGENCE[0].mc_liste) for i in dConvergence.keys(): if dConvergence[i] == None: del dConvergence[i] dSolveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste) for i in dSolveur.keys(): if dSolveur[i] == None: del dSolveur[i] if RECH_LINEAIRE: dRech_lin = RECH_LINEAIRE[0].cree_dict_valeurs( RECH_LINEAIRE[0].mc_liste) for i in dRech_lin.keys(): if dRech_lin[i] == None: del dRech_lin[i] else: dRech_lin = None if ENERGIE: dEnergie = ENERGIE[0].cree_dict_valeurs(ENERGIE[0].mc_liste) motscle4['ENERGIE'] = dEnergie motscle5['ENERGIE'] = dEnergie # 1.3 Creation des mots-cles pour les 3 AFFE_CHAR_MECA # Recuperation des cables dans les concepts CABLE_BP # et CABLE_BP_INACTIF # ------------------------------------------------------ if type(CABLE_BP) is not types.NoneType: if not is_sequence(CABLE_BP): CABLE_BP0 = CABLE_BP CABLE_BP = [] CABLE_BP.append(CABLE_BP0) if type(CABLE_BP_INACTIF) is not types.NoneType: if not is_sequence(CABLE_BP_INACTIF): CABLE_BP_INACTIF0 = CABLE_BP_INACTIF CABLE_BP_INACTIF = [] CABLE_BP_INACTIF.append(CABLE_BP_INACTIF0) motscles = {} motscles['RELA_CINE_BP'] = [] motscle2 = {} motscle2['RELA_CINE_BP'] = [] motscle3 = {} motscle3['RELA_CINE_BP'] = [] set_GROUP_MA_A_SEG2 = set() set_GROUP_MA_A_SEG3 = set() for ica, mcabl in enumerate(CABLE_BP): # Creation de mots-cles pour les AFFE_CHAR_MECA motscles['RELA_CINE_BP'].append( _F( CABLE_BP=mcabl, SIGM_BPEL='OUI', RELA_CINE='NON', )) motscle2['RELA_CINE_BP'].append( _F( CABLE_BP=mcabl, SIGM_BPEL='NON', RELA_CINE='OUI', )) motscle3['RELA_CINE_BP'].append( _F( CABLE_BP=mcabl, SIGM_BPEL='OUI', RELA_CINE='OUI', )) # Creation de __GROUP_MA_A : liste des noms des cables contenus # dans chaque concept CABLE_BP = cables a activer __TCAB = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_BP') table_cable = __TCAB.EXTR_TABLE() col_nom_cable = table_cable.NOM_CABLE __typ_ma = typ_ma[ica] if __typ_ma.strip() == 'SEG2': set_GROUP_MA_A_SEG2.update(col_nom_cable.values()) elif __typ_ma.strip() == 'SEG3': set_GROUP_MA_A_SEG3.update(col_nom_cable.values()) else: raise Exception('type inconnu') __GROUP_MA_A_SEG2 = list(set_GROUP_MA_A_SEG2) __GROUP_MA_A_SEG3 = list(set_GROUP_MA_A_SEG3) # Creation de __GROUP_MA_I : liste des noms des cables contenus # dans chaque CABLE_BP_INACTIF # __GROUP_MA_CABLE = liste des cables actifs et inactifs set_GROUP_MA_I_SEG2 = set() set_GROUP_MA_I_SEG3 = set() if CABLE_BP_INACTIF: motscle6 = {} motscle6['RELA_CINE_BP'] = [] for mcabl in CABLE_BP_INACTIF: __TCA0 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_BP') __TCA2 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL') col_nom_cable = __TCA0.EXTR_TABLE().NOM_CABLE __typ_ma = __TCA2.EXTR_TABLE().TYPE_MAILLE.values()[0] if __typ_ma.strip() == 'SEG2': set_GROUP_MA_I_SEG2.update(col_nom_cable.values()) elif __typ_ma.strip() == 'SEG3': set_GROUP_MA_I_SEG3.update(col_nom_cable.values()) else: raise Exception('type inconnu') # Creation de mots-cles pour les AFFE_CHAR_MECA motscle6['RELA_CINE_BP'].append( _F( CABLE_BP=mcabl, SIGM_BPEL='NON', RELA_CINE='OUI', )) __GROUP_MA_I_SEG2 = list(set_GROUP_MA_I_SEG2) __GROUP_MA_I_SEG3 = list(set_GROUP_MA_I_SEG3) __GROUP_MA_CABLES_SEG2 = __GROUP_MA_A_SEG2 + __GROUP_MA_I_SEG2 __GROUP_MA_CABLES_SEG3 = __GROUP_MA_A_SEG3 + __GROUP_MA_I_SEG3 # 1.4 Creation des mots-clés facteurs COMPORTEMENT # pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1) # ------------------------------------------------------ dComp_incr = [] for j in COMPORTEMENT: dComp_incr.append(j.cree_dict_valeurs(j.mc_liste)) for i in dComp_incr[-1].keys(): if dComp_incr[-1][i] == None: del dComp_incr[-1][i] dComp_incr0 = copy.copy(dComp_incr) dComp_incr1 = copy.copy(dComp_incr) PARM_THETA = 0. for j in range(len(COMPORTEMENT)): if dComp_incr[j]['RELATION'] == 'ELAS': PARM_THETA = dComp_incr[j]['PARM_THETA'] if PARM_THETA == 0: PARM_THETA = dComp_incr[0]['PARM_THETA'] dComp_incrElas = [] affe_mo = [] if __GROUP_MA_A_SEG3 != []: comp_seg3 = { 'RELATION': 'KIT_CG', 'GROUP_MA': __GROUP_MA_A_SEG3, 'PARM_THETA': PARM_THETA } comp_seg3['RELATION_KIT'] = ( 'ELAS', 'CABLE_GAINE_FROT', ) dComp_incrElas.append(comp_seg3) affe_mo.append({ 'GROUP_MA': __GROUP_MA_A_SEG3, 'PHENOMENE': 'MECANIQUE', 'MODELISATION': 'CABLE_GAINE', }) if __GROUP_MA_A_SEG2 != []: dComp_incrElas.append({ 'RELATION': 'ELAS', 'TOUT': 'OUI', 'PARM_THETA': PARM_THETA }) affe_mo.append({ 'GROUP_MA': __GROUP_MA_A_SEG2, 'PHENOMENE': 'MECANIQUE', 'MODELISATION': 'BARRE', }) if __GROUP_MA_CABLES_SEG3 != []: dComp_incr0.append( _F( RELATION='KIT_CG', RELATION_KIT=( 'SANS', 'CABLE_GAINE_FROT', ), GROUP_MA=__GROUP_MA_CABLES_SEG3, )) if __GROUP_MA_I_SEG3: dComp_incr1.append( _F( RELATION='KIT_CG', RELATION_KIT=( 'SANS', 'CABLE_GAINE_FROT', ), GROUP_MA=__GROUP_MA_I_SEG3, )) if __GROUP_MA_CABLES_SEG2 != []: dComp_incr0.append( _F( RELATION='SANS', GROUP_MA=__GROUP_MA_CABLES_SEG2, )) if __GROUP_MA_I_SEG2: dComp_incr1.append( _F( RELATION='SANS', GROUP_MA=__GROUP_MA_I_SEG2, )) # 1.5 Modele contenant uniquement les cables de precontrainte # --------------------------------------------------------- __MOD = string.ljust(MODELE.nom, 8) __MOD1 = __MOD + '.MODELE .LGRF ' __LMAIL = aster.getvectjev(__MOD1) __MAIL = string.strip(__LMAIL[0]) objma = self.get_sd_avant_etape(__MAIL, self) __M_CA = AFFE_MODELE(MAILLAGE=objma, AFFE=affe_mo) # 1.6 Blocage de tous les noeuds des cables actifs # -------------------------------------------------- __GROUP_MA_A = __GROUP_MA_A_SEG2 + __GROUP_MA_A_SEG3 _B_CA = AFFE_CHAR_MECA( MODELE=__M_CA, DDL_IMPO=_F( GROUP_MA=__GROUP_MA_A, DX=0., DY=0., DZ=0., ), ) # 1.7 Chargements concernant les cables # ------------------------------------- _C_CN = AFFE_CHAR_MECA(MODELE=__M_CA, **motscles) _C_CA = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2) _C_CT = AFFE_CHAR_MECA(MODELE=MODELE, **motscle3) if CABLE_BP_INACTIF: _C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6) # ------------------------------------------------------------- # 2. CALCULS # ------------------------------------------------------------ #------------------------------------------------------------------- # 2.1 Premiere etape : calcul sur le(s) cable(s) et # recuperation des _F_CAs aux noeuds # on travaile entre tmin et tmax #------------------------------------------------------------------- __EV1 = STAT_NON_LINE( MODELE=__M_CA, CHAM_MATER=CHAM_MATER, CARA_ELEM=CARA_ELEM, EXCIT=( _F(CHARGE=_B_CA), _F(CHARGE=_C_CN), ), COMPORTEMENT=dComp_incrElas, INCREMENT=_F(LIST_INST=__LST0, PRECISION=__prec), SOLVEUR=dSolveur, INFO=INFO, TITRE=TITRE, ) __EV1 = CALC_CHAMP( reuse=__EV1, RESULTAT=__EV1, # GROUP_MA = __GROUP_MA_A, FORCE='FORC_NODA') __REA = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='EXTR', RESULTAT=__EV1, NOM_CHAM='FORC_NODA', INST=__TMAX) __REAC0 = CREA_CHAMP( TYPE_CHAM='NOEU_DEPL_R', OPERATION='AFFE', MODELE=MODELE, AFFE=_F(TOUT='OUI', NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'), VALE=(0., 0., 0., 0., 0., 0., 0., 0.)), ) __REAC = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='ASSE', MODELE=MODELE, ASSE=( _F(TOUT='OUI', CHAM_GD=__REAC0, COEF_R=1.), _F(GROUP_MA=__GROUP_MA_A, CHAM_GD=__REA, COEF_R=-1.), )) _F_CA = AFFE_CHAR_MECA(MODELE=MODELE, VECT_ASSE=__REAC) #----------------------------------------------------------------------- # 2.2 Deuxieme etape : application de la precontrainte sur le beton # en desactivant les cables #---------------------------------------------------------------------- # Regeneration des mots-cles EXCIT passés en argument de la macro dExcit = [] for j in EXCIT: dExcit.append(j.cree_dict_valeurs(j.mc_liste)) for i in dExcit[-1].keys(): if dExcit[-1][i] == None: del dExcit[-1][i] if CABLE_BP_INACTIF: dExcit.append(_F(CHARGE=_C_CI), ) # Creation du mots-cle EXCIT pour le STAT_NON_LINE dExcit1 = copy.copy(dExcit) dExcit1.append(_F(CHARGE=_C_CA), ) dExcit1.append(_F(CHARGE=_F_CA, FONC_MULT=__FCT), ) if self.reuse: motscle4['reuse'] = self.reuse RES = STAT_NON_LINE(MODELE=MODELE, CARA_ELEM=CARA_ELEM, CHAM_MATER=CHAM_MATER, COMPORTEMENT=dComp_incr0, INCREMENT=dIncrement, ETAT_INIT=dEtatInit, METHODE=METHODE, CONVERGENCE=dConvergence, RECH_LINEAIRE=dRech_lin, SOLVEUR=dSolveur, ARCHIVAGE=_F(INST=__TINT), INFO=INFO, TITRE=TITRE, EXCIT=dExcit1, **motscle4) # Recuperation du dernier numero d'ordre pour pouvoir l'écraser dans # RES __dico2 = RES.LIST_VARI_ACCES() __no = __dico2['NUME_ORDRE'][-1] #----------------------------------------------------------------------- # 2.2 Troisieme etape : on remet la tension dans les cables #---------------------------------------------------------------------- # Creation du mots-cles EXCIT pour le STAT_NON_LINE dExcit2 = copy.copy(dExcit) dExcit2.append(_F(CHARGE=_C_CT, )) # Calcul sur un seul pas (de __TINT a __TMAX) RES = STAT_NON_LINE( reuse=RES, ETAT_INIT=_F(EVOL_NOLI=RES), MODELE=MODELE, CHAM_MATER=CHAM_MATER, CARA_ELEM=CARA_ELEM, COMPORTEMENT=dComp_incr1, INCREMENT=_F(LIST_INST=__LST, PRECISION=__prec), METHODE=METHODE, # NEWTON =dNewton, # IMPLEX=dImplex, RECH_LINEAIRE=dRech_lin, CONVERGENCE=dConvergence, SOLVEUR=dSolveur, INFO=INFO, TITRE=TITRE, EXCIT=dExcit2, **motscle5) elif adher == 'NON': motscle4 = {} motscle2 = {} motscle2 = {} motscle2['DDL_IMPO'] = [] motscle2['RELA_CINE_BP'] = [] motscle2a = {} motscle2a['DDL_IMPO'] = [] motscle2a['RELA_CINE_BP'] = [] motscle2b = {} motscle2b['DDL_IMPO'] = [] motscle2b['RELA_CINE_BP'] = [] motscle5 = {} motscle5['DDL_IMPO'] = [] motscle5['RELA_CINE_BP'] = [] motscle3 = {} motscle3['AFFE'] = [ _F(TOUT='OUI', NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'), VALE=(0., 0., 0., 0., 0., 0., 0., 0.)) ] motscle3a = {} motscle3a['AFFE'] = [ _F(TOUT='OUI', NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'), VALE=(0., 0., 0., 0., 0., 0., 0., 0.)) ] motscle3b = {} motscle3b['AFFE'] = [ _F(TOUT='OUI', NOM_CMP=('DX', 'DY', 'DZ', 'DRX', 'DRY', 'DRZ', 'GLIS', 'SITY'), VALE=(0., 0., 0., 0., 0., 0., 0., 0.)) ] motscle6 = {} motscle6['DDL_IMPO'] = [] __ActifActif = False if self.reuse: motscle4['reuse'] = self.reuse # assert (len(CABLE_BP) == 1) # traitement des cables inactifs if type(CABLE_BP_INACTIF) is not types.NoneType: if not is_sequence(CABLE_BP_INACTIF): CABLE_BP_INACTIF0 = CABLE_BP_INACTIF CABLE_BP_INACTIF = [] CABLE_BP_INACTIF.append(CABLE_BP_INACTIF0) else: CABLE_BP_INACTIF = [] motscle6 = {} motscle6['RELA_CINE_BP'] = [] for mcabl in CABLE_BP_INACTIF: # Creation de mots-cles pour les AFFE_CHAR_MECA motscle6['RELA_CINE_BP'].append( _F( CABLE_BP=mcabl, SIGM_BPEL='NON', RELA_CINE='OUI', )) for mcabl in CABLE_BP: __TCAB1 = RECU_TABLE(CO=mcabl, NOM_TABLE='CABLE_GL') motscle2['RELA_CINE_BP'].append( _F( CABLE_BP=mcabl, SIGM_BPEL='NON', RELA_CINE='OUI', )) motscle5['RELA_CINE_BP'].append( _F( CABLE_BP=mcabl, SIGM_BPEL='NON', RELA_CINE='OUI', )) nb_cable = len(__TCAB1.EXTR_TABLE().NOM_ANCRAGE1.values()) table_cable = __TCAB1.EXTR_TABLE() for icable in xrange(nb_cable): __typ_ancr = (table_cable.TYPE_ANCRAGE1.values()[icable], table_cable.TYPE_ANCRAGE2.values()[icable]) __typ_noeu = (table_cable.TYPE_NOEUD1.values()[icable], table_cable.TYPE_NOEUD2.values()[icable]) __nom_noeu = (table_cable.NOM_ANCRAGE1.values()[icable], table_cable.NOM_ANCRAGE2.values()[icable]) __tension = table_cable.TENSION.values()[icable] __recul = table_cable.RECUL_ANCRAGE.values()[icable] __recul_exists = (__recul != 0) __sens = table_cable.SENS.values()[icable] actif = 0 ancr1_passif = 1 for j in range(2): if string.strip(__typ_ancr[j]) == 'PASSIF': if j == 0: ancr1_passif = -1 if string.strip(__typ_noeu[j]) == 'NOEUD': motscle2['DDL_IMPO'].append( _F(NOEUD=string.strip(__nom_noeu[j]), GLIS=0.)) if __recul_exists: motscle5['DDL_IMPO'].append( _F(NOEUD=string.strip(__nom_noeu[j]), GLIS=0.)) else: motscle2['DDL_IMPO'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), GLIS=0.)) if __recul_exists: motscle5['DDL_IMPO'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), GLIS=0.)) else: actif += 1 if string.strip(__typ_noeu[j]) == 'NOEUD': motscle3['AFFE'].append( _F(NOEUD=string.strip(__nom_noeu[j]), NOM_CMP='GLIS', VALE=ancr1_passif * __sens * __tension * (-1)**(j + 1))) if j == 0: motscle3b['AFFE'].append( _F(NOEUD=string.strip(__nom_noeu[j]), NOM_CMP='GLIS', VALE=__sens * __tension * (-1)**(j + 1))) motscle2a['DDL_IMPO'].append( _F(NOEUD=string.strip(__nom_noeu[j]), GLIS=0.)) else: motscle3a['AFFE'].append( _F(NOEUD=string.strip(__nom_noeu[j]), NOM_CMP='GLIS', VALE=ancr1_passif * __sens * __tension * (-1)**(j + 1))) motscle2b['DDL_IMPO'].append( _F(NOEUD=string.strip(__nom_noeu[j]), GLIS=0.)) if __recul_exists: motscle5['DDL_IMPO'].append( _F(NOEUD=string.strip(__nom_noeu[j]), GLIS=ancr1_passif * __sens * __recul * (-1)**(j))) else: motscle3['AFFE'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), NOM_CMP='GLIS', VALE=ancr1_passif * __sens * __tension * (-1)**(j + 1))) if j == 0: motscle3b['AFFE'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), NOM_CMP='GLIS', VALE=__sens * __tension * (-1)**(j + 1))) motscle2a['DDL_IMPO'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), GLIS=0.)) else: motscle3a['AFFE'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), NOM_CMP='GLIS', VALE=ancr1_passif * __sens * __tension * (-1)**(j + 1))) motscle2b['DDL_IMPO'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), GLIS=0.)) if __recul_exists: motscle5['DDL_IMPO'].append( _F(GROUP_NO=string.strip(__nom_noeu[j]), GLIS=ancr1_passif * __sens * __recul * (-1)**(j))) if (actif == 2): __ActifActif = True # DETRUIRE(CONCEPT=_F(NOM=__TCAB1)) dExcit = [] for j in EXCIT: dExcit.append(j.cree_dict_valeurs(j.mc_liste)) for i in dExcit[-1].keys(): if dExcit[-1][i] == None: del dExcit[-1][i] assert (len(motscle3) > 0) if __ActifActif: dExcit1a = copy.copy(dExcit) dExcit1b = copy.copy(dExcit) if CABLE_BP_INACTIF: _C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6) dExcit1a.append(_F(CHARGE=_C_CI, )) dExcit1b.append(_F(CHARGE=_C_CI, )) __CH1a = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='AFFE', MODELE=MODELE, **motscle3a) __CH1b = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='AFFE', MODELE=MODELE, **motscle3b) _C_CAc = AFFE_CHAR_MECA(MODELE=MODELE, VECT_ASSE=__CH1a, **motscle2) _C_CAd = AFFE_CHAR_MECA(MODELE=MODELE, VECT_ASSE=__CH1b, **motscle2) _C_CAa = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2a) _C_CAb = AFFE_CHAR_MECA(MODELE=MODELE, **motscle2b) dExcit1a.append(_F(CHARGE=_C_CAa, TYPE_CHARGE='DIDI')) dExcit1b.append(_F(CHARGE=_C_CAb, TYPE_CHARGE='DIDI')) dExcit1a.append(_F(CHARGE=_C_CAc)) dExcit1b.append(_F(CHARGE=_C_CAd)) __L2[-1:-1] = [__TINT] else: dExcit1 = copy.copy(dExcit) if CABLE_BP_INACTIF: _C_CI = AFFE_CHAR_MECA(MODELE=MODELE, **motscle6) dExcit1.append(_F(CHARGE=_C_CI, )) __CH1 = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R', OPERATION='AFFE', MODELE=MODELE, **motscle3) _C_CA = AFFE_CHAR_MECA(MODELE=MODELE, VECT_ASSE=__CH1, **motscle2) dExcit1.append(_F(CHARGE=_C_CA, TYPE_CHARGE='DIDI'), ) _C_RA = AFFE_CHAR_MECA(MODELE=MODELE, **motscle5) dExcit2 = copy.copy(dExcit) dExcit2.append(_F(CHARGE=_C_RA, TYPE_CHARGE='DIDI'), ) if CABLE_BP_INACTIF: dExcit2.append(_F(CHARGE=_C_CI, )) if __recul_exists: __L2[-1:-1] = [__TINT2] __LST = DEFI_LIST_REEL(VALE=__L2, ) for i in dIncrement.keys(): if dIncrement[i] == None: del dIncrement[i] dIncrement['LIST_INST'] = __LST else: if __ActifActif: __LST = DEFI_LIST_REEL(VALE=__L2, ) for i in dIncrement.keys(): if dIncrement[i] == None: del dIncrement[i] dIncrement['LIST_INST'] = __LST else: dIncrement = INCREMENT if __ActifActif: dIncrement['INST_FIN'] = __TINT RES = STAT_NON_LINE( MODELE=MODELE, CARA_ELEM=CARA_ELEM, CHAM_MATER=CHAM_MATER, COMPORTEMENT=COMPORTEMENT, # INCREMENT=INCREMENT, INCREMENT=dIncrement, NEWTON=_F(REAC_ITER=1), ETAT_INIT=ETAT_INIT, METHODE=METHODE, CONVERGENCE=CONVERGENCE, RECH_LINEAIRE=RECH_LINEAIRE, SOLVEUR=SOLVEUR, INFO=INFO, TITRE=TITRE, EXCIT=dExcit1a, **motscle4) if __recul_exists: dIncrement['INST_FIN'] = __TINT2 else: dIncrement['INST_FIN'] = __TMAX RES = STAT_NON_LINE( reuse=RES, ETAT_INIT=_F(EVOL_NOLI=RES), MODELE=MODELE, CARA_ELEM=CARA_ELEM, CHAM_MATER=CHAM_MATER, COMPORTEMENT=COMPORTEMENT, # INCREMENT=INCREMENT, INCREMENT=dIncrement, NEWTON=_F(REAC_ITER=1), METHODE=METHODE, CONVERGENCE=CONVERGENCE, RECH_LINEAIRE=RECH_LINEAIRE, SOLVEUR=SOLVEUR, INFO=INFO, TITRE=TITRE, EXCIT=dExcit1b, ) else: if __recul_exists: dIncrement['INST_FIN'] = __TINT2 RES = STAT_NON_LINE( MODELE=MODELE, CARA_ELEM=CARA_ELEM, CHAM_MATER=CHAM_MATER, COMPORTEMENT=COMPORTEMENT, # INCREMENT=INCREMENT, INCREMENT=dIncrement, NEWTON=_F(REAC_ITER=1), METHODE=METHODE, ETAT_INIT=ETAT_INIT, CONVERGENCE=CONVERGENCE, RECH_LINEAIRE=RECH_LINEAIRE, SOLVEUR=SOLVEUR, INFO=INFO, TITRE=TITRE, EXCIT=dExcit1, **motscle4) if __recul_exists: RES = STAT_NON_LINE( reuse=RES, ETAT_INIT=_F(EVOL_NOLI=RES), MODELE=MODELE, CARA_ELEM=CARA_ELEM, CHAM_MATER=CHAM_MATER, COMPORTEMENT=COMPORTEMENT, # INCREMENT=INCREMENT, INCREMENT=_F(LIST_INST=__LST, PRECISION=__prec), NEWTON=_F(REAC_ITER=1), # ETAT_INIT = ETAT_INIT, METHODE=METHODE, CONVERGENCE=CONVERGENCE, RECH_LINEAIRE=RECH_LINEAIRE, SOLVEUR=SOLVEUR, INFO=INFO, TITRE=TITRE, EXCIT=dExcit2, ) else: raise Exception( "erreur de programmation, adher different de OUI et NON") RetablirAlarme('COMPOR4_70') return ier
def getmjm(self, motfac, iocc, nbval): """ Retourne des informations sur le mot cle facteur motfac du catalogue de la commande nomcmd motfac : nom du mot cle facteur iocc : numero d occurence du mot cle facteur Retour: motcle : liste des sous mots cles typ : liste des types des sous mots cles nbarg : nombre total d arguments du mot cle facteur(a priori ne doit etre utilise que par le superviseur) """ motfac = motfac.strip() if motfac != '': mcfact = self.get_mocle(motfac) if mcfact == None: return ([], []) else: mcfact = mcfact[iocc] else: mcfact = self # On a trouvé le mot cle facteur dico_mcsimp = mcfact.cree_dict_valeurs(mcfact.mc_liste) if self.nom == 'TEST_RESU' and dico_mcsimp.get('VALE_C') != None: pass lmc = [] lty = [] for name, obj in dico_mcsimp.items(): if obj is None: continue lmc.append(name) if is_sequence(obj): obj = obj[0] # cas liste de complexes sous la forme RI/MP ! if is_sequence(obj): obj = obj[0] if isinstance(obj, (N_ASSD.ASSD, N_ENTITE.ENTITE, N_MCLIST.MCList)): lty.append(type(obj).__name__) if is_complex(obj): lty.append('C8') if is_float(obj): lty.append('R8') if is_str(obj): if obj.strip() in ('RI', 'MP'): lty.append('C8') else: lty.append('TX') if is_int(obj): # on gere le cas d un reel entre par l utilisateur sans le '.' distinctif d un entier # pour ca on teste la presence de R8 dans la liste des types # attendus cote catalogue child = mcfact.definition.get_entite(name) list_cata = B_utils.Typast(child.type) if ('IS ' not in list_cata) and ('R8 ' in list_cata): lty.append('R8') elif ('IS ' not in list_cata) and ('C8 ' in list_cata): lty.append('C8') else: lty.append('I') assert len(lmc) == len( lty), "cardinalité différente : \n%s\n%s" % (lmc, lty) return (lmc, lty)
def TesterValeur(nomPara, valPu, valRef, res, epsi, crit, sSigne): """ Teste de la valeur calculee par rapport a la valeur de reference """ import aster import cmath import math isTestOk = 0 vtc = valRef[0] if is_sequence(vtc): assert((vtc[0] == 'RI') | (vtc[0] == 'MP')), vtc[0] if vtc[0] == 'RI': vtc = vtc[1] + 1j * vtc[2] else: vtc = vtc[1] * cmath.exp(1j * math.pi * vtc[2] / 180) if sSigne == 'OUI': res = abs(res) if is_complex(valRef[0]): vtc = abs(vtc) # Recherche de la valeur la plus proche de la valeur calculee # dans le tableau valRef minTmp = abs(res - vtc) curI = 0 for i in range(len(valRef)): vtc = valRef[i] if is_sequence(vtc): assert((vtc[0] == 'RI') | (vtc[0] == 'MP')), vtc[0] if vtc[0] == 'RI': vtc = vtc[1] + 1j * vtc[2] else: vtc = vtc[1] * cmath.exp(1j * math.pi * vtc[2] / 180) if sSigne == 'OUI' and is_complex(vtc): vtc = abs(vtc) valTmp = abs(res - vtc) if valTmp < minTmp: valTmp = minTmp curI = i vtc = valRef[curI] if is_sequence(vtc): assert((vtc[0] == 'RI') | (vtc[0] == 'MP')), vtc[0] if vtc[0] == 'RI': vtc = vtc[1] + 1j * vtc[2] else: vtc = vtc[1] * cmath.exp(1j * math.pi * vtc[2] / 180) if sSigne == 'OUI' and is_complex(vtc): vtc = abs(vtc) testOk = 'NOOK' curEps = 0 err = 0 pourcent = ' ' # Calcul de l'erreur commise if crit[0:4] == 'RELA': isTestOk = (abs(res - vtc) <= epsi * abs(vtc)) if vtc != 0: if is_complex(res) or is_complex(vtc): err = abs(res - vtc) / abs(vtc) * 100 else: err = (res - vtc) / vtc * 100 else: err = 999.999999 if isTestOk: testOk = ' OK ' curEps = epsi * 100 pourcent = '%' else: isTestOk = (abs(res - vtc) <= epsi) if is_complex(res) or is_complex(vtc): err = abs(res - vtc) else: err = res - vtc if isTestOk: testOk = ' OK ' curEps = epsi return {'testOk': testOk, 'erreur': err, 'epsilon': curEps, 'valeurRef': vtc}
def test_fonction_ops(self, TEST_NOOK, VALEUR, ATTRIBUT, **args): """ Corps de la macro TEST_FONCTION """ macro = 'TEST_FONCTION' import aster from code_aster.Cata.Syntax import _F from Utilitai.Utmess import UTMESS from SD.sd_fonction import sd_fonction from Cata_Utils.t_fonction import t_fonction_c CALC_FONCTION = self.get_cmd('CALC_FONCTION') DETRUIRE = self.get_cmd('DETRUIRE') ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) # txt sert a l'affichage dans le fichier RESULTAT txt = ['', ] txt.append(ligne_separatrice) if VALEUR != None: # Boucle sur les VALEURS for val in VALEUR: dres = val.cree_dict_valeurs(val.mc_liste) # Recherche des mots-cles simples ssigne = dres['VALE_ABS'] epsi = dres['TOLE_MACHINE'] crit = dres['CRITERE'] fct = dres['FONCTION'] nompara = dres['NOM_PARA'] if nompara == None: nompara = '' ref = dres['REFERENCE'] or 'NON_REGRESSION' other_ref = ref != 'NON_REGRESSION' and dres['REFERENCE'] or None ver = None legende = dres['LEGENDE'] if legende == None: legende = 'XXXX' nomfct = fct.get_name() # Transformation de nompara en liste if (not is_sequence(nompara)) and nompara != None: nompara = [nompara, ] # La fonction est directement de dres['FONCTION'] lafonc = None titre = '' lafonc = fct res = 0. typeFct = '' valpu = dres['VALE_PARA'] if not is_sequence(valpu): valpu = [valpu, ] valref = get_valref(lafonc, dres, 'CALC') if other_ref: valoth = get_valref(lafonc, dres, 'REFE') epsoth = dres['PRECISION'] intervalle = dres['INTERVALLE'] ier = 0 # Distinction des cas # - "fonction" sur un intervalle # - "formule", # - "fonction" ou "nappe" if (type(lafonc) == fonction_sdaster) and intervalle != None: # XXX il faut utiliser lafonc.Parametres() ! # XXX ne sert à rien, CALC_FONCTION prend les paramètres de la fonction normalement fctProl = lafonc.sdj.PROL.get() prolG = 'rien' if fctProl[4][0:1] == 'C': prolG = 'CONSTANT' elif fctProl[4][0:1] == 'E': prolG = 'EXCLU' elif fctProl[4][0:1] == 'L': prolG = 'LINEAIRE' prolD = 'rien' if fctProl[4][1:2] == 'C': prolD = 'CONSTANT' elif fctProl[4][1:2] == 'E': prolD = 'EXCLU' elif fctProl[4][1:2] == 'L': prolD = 'LINEAIRE' curInterpol = [fctProl[1][0:3], fctProl[1][4:7]] __fInt = CALC_FONCTION(INTEGRE=_F(FONCTION=lafonc,), PROL_DROITE=prolD, PROL_GAUCHE=prolG, INTERPOL=curInterpol) res1 = __fInt(intervalle[0]) res2 = __fInt(intervalle[1]) DETRUIRE(CONCEPT=_F(NOM=__fInt), INFO=1) res = (res2 - res1) / (intervalle[1] - intervalle[0]) valpu[0] = intervalle[0] elif type(lafonc) in (formule, formule_c): # Lecture des valeurs de reference dans les mots-cles simples if type(lafonc) == formule_c: typeFct = 'formule_c' else: typeFct = 'formule' # On cherche les valeurs de reference passees a TEST_FONCTION et # on les trie grace a ceux de la formule paramFormule = lafonc.Parametres()['NOM_PARA'] if not is_sequence(paramFormule): paramFormule = [paramFormule, ] if nompara[0] == '': nompara = paramFormule # On verifie que la formule a bien le meme nombre de parametres # que ceux passes a la fonction TEST_FONCTION if len(nompara) != len(paramFormule): ier = 160 UTMESS('A+', 'FONCT0_9', valk=(lafonc.get_name())) UTMESS('A', 'FONCT0_14', vali=( len(nompara), len(paramFormule))) return 0. # Trie des parametres passes a la fonction TEST_FONCTION pour # correspondre a l'ordre de ceux de la formule nParamOrdo = [] vParamOrdo = [] for iPN in range(len(paramFormule)): nParamOrdo.append('') # vParamOrdo.append('') compteur = 0 for iPN in range(len(paramFormule)): i = 0 for iPU in range(len(nompara)): if paramFormule[iPN] == nompara[iPU]: if nParamOrdo[iPN] == '': vParamOrdo.append(valpu[iPU]) nParamOrdo[iPN] = paramFormule[iPN] compteur = compteur + 1 else: ier = 120 UTMESS( 'A+', 'FONCT0_9', valk=(lafonc.get_name())) UTMESS('A', 'FONCT0_15', valk=nompara) res = 0. i = i + 1 if nParamOrdo[iPN] == '': ier = 130 UTMESS('A+', 'FONCT0_9', valk=(lafonc.get_name())) UTMESS('A', 'FONCT0_16', valk=paramFormule) UTMESS('A', 'FONCT0_17', valk=nompara) return 0. # Si tout est Ok, on calcul la valeur de la formule if ier == 0: res = lafonc(*vParamOrdo) # Cas fonction et nappe elif type(lafonc) in (fonction_sdaster, fonction_c, nappe_sdaster): # XXX il faut utiliser lafonc.Parametres() ! # Recuperation du .PROL de la fonction fct_prol = lafonc.sdj.PROL.get_stripped() if fct_prol == None: UTMESS('F', 'PREPOST3_93') nompu = '' if nompara[0] != '': nompu = nompara[0] else: nompu = fct_prol[2] nompara = [nompu, ] # Une nappe a forcement 2 parametres if (fct_prol[0] == 'NAPPE') & (len(nompara) == 1): UTMESS('A', 'PREPOST3_94') break # Lecture de la valeur de reference if fct_prol[0] == 'FONCT_C': typeFct = 'fonction_c' else: if fct_prol[0] == 'NAPPE': typeFct = 'nappe' else: typeFct = 'fonction' # Calcul de la fonction res = 0 if type(lafonc) in (fonction_sdaster, fonction_c): res = lafonc(valpu[0]) else: # Remise dans l'ordre des param paramNappe = [fct_prol[2], fct_prol[6]] vParamOrdo = ['', ''] for iPN in range(len(paramNappe)): i = 0 for iPU in range(len(nompara)): if paramNappe[iPN] == nompara[iPU]: if vParamOrdo[iPN] != '': ier = 120 UTMESS( 'A+', 'FONCT0_9', valk=(lafonc.get_name())) UTMESS('A', 'FONCT0_15', valk=nompara) else: vParamOrdo[iPN] = valpu[iPU] i = i + 1 if vParamOrdo[iPN] == '': ier = 130 UTMESS('A+', 'FONCT0_9', valk=(lafonc.get_name())) UTMESS('A', 'FONCT0_16', valk=paramNappe) UTMESS('A', 'FONCT0_17', valk=nompara) res = lafonc(vParamOrdo[0], vParamOrdo[1]) else: ier = 150 # Construction de l'affiche du resultat current = {} nomLastPara = nompara[len(nompara) - 1] valLastPara = valpu[len(valpu) - 1] if (typeFct == 'nappe'): # ligne 1 nb_espace = 16 - len(str(nompu)) espace = nb_espace * ' ' current['nom_para_0'] = str(nompu) + espace nb_espace = 16 - len(str(nomLastPara)) espace = nb_espace * ' ' current['nom_para'] = str(nomLastPara) + espace txt.append(ligne_nap_1 % current) # ligne 2 current = {} nb_espace = 16 - len(nomfct) espace = nb_espace * ' ' current['nom_nap'] = nomfct + espace nb_espace = 16 - len(str(valpu[0])) espace = nb_espace * ' ' current['val_para_0'] = str(valpu[0]) + espace nb_espace = 16 - len(str(valLastPara)) espace = nb_espace * ' ' current['val_para'] = str(valLastPara) + espace txt.append(ligne_nap_2 % current) else: # ligne 1 nb_espace = 16 - len(str(nomLastPara)) espace = nb_espace * ' ' current['nom_para'] = str(nomLastPara) + espace if(len(titre) > 1): txt.append(ligne_fct_11 % current) else: txt.append(ligne_fct_1 % current) # ligne 2 current = {} nb_espace = 16 - len(nomfct) espace = nb_espace * ' ' current['nom_fct'] = nomfct + espace nb_espace = 16 - len(str(valLastPara)) espace = nb_espace * ' ' current['val_para'] = str(valLastPara) + espace if(len(titre) > 1): nb_espace = 33 - len(titre) espace = nb_espace * ' ' current['titre'] = titre txt.append(ligne_fct_22 % current) else: txt.append(ligne_fct_2 % current) # Test des valeurs calculees curDict = TesterValeur( nomLastPara, valLastPara, valref, res, epsi, crit, ssigne) if other_ref: DictRef = TesterValeur( nomLastPara, valLastPara, valoth, res, epsoth, crit, ssigne) if TEST_NOOK == 'OUI': if ier == 0: testOk = curDict['testOk'] if testOk == ' OK ': txt.append( 'NOOK PAS DE CHANCE LE TEST EST CORRECT !!!') else: AfficherResultat( curDict, nomLastPara, 'NON_REGRESSION', legende, crit, res, valLastPara, txt) if other_ref: AfficherResultat( DictRef, nomLastPara, ref, legende, crit, res, valLastPara, txt, label=False) elif ier == 120: txt.append(' OK PARAMETRE EN DOUBLE') elif ier == 130: txt.append(' OK PARAMETRE NON CORRECT') elif ier == 150: txt.append(' OK TYPE DE FONCTION NON TRAITE') elif ier == 160: txt.append(' OK PAS ASSEZ DE PARAMETRES') else: if ier != 0: txt.append('NOOK PB INTERPOLATION. VOIR MESSAGE CI-DESSUS') else: AfficherResultat( curDict, nomLastPara, 'NON_REGRESSION', legende, crit, res, valLastPara, txt) if other_ref: AfficherResultat(DictRef, nomLastPara, ref, legende, crit, res, valLastPara, txt, label=False) txt.append(' ') if ATTRIBUT != None: first_affiche_ligne1 = True resu_test_attr = ' OK ' # Boucle sur le mot-cle ATTRIBUT for attr in ATTRIBUT: dres = attr.cree_dict_valeurs(attr.mc_liste) # Lecture des mots-cles simples ref = dres['REFERENCE'] ver = None fonction = dres['FONCTION'] fctProl = fonction.sdj.PROL.get_stripped() typeFct = fctProl[0] para = dres['PARA'] fctPara = fonction.sdj.PARA.get() pos = 0 # Cas particulier d'une nappe qui a 2 dimensions if typeFct == 'NAPPE': if para != None: # Recherche de la fonction liee a para precPara = dres['PREC_PARA'] critPara = dres['CRIT_PARA'] LOK = 0 compteur = 0 for curPara in fctPara: if critPara[0:4] == 'RELA': LOK = ( abs(para - curPara) <= precPara * abs(curPara)) else: LOK = (abs(para - curPara) <= precPara) if LOK: pos = compteur break compteur = compteur + 1 if not LOK: UTMESS('A', 'PREPOST3_95') else: para = fctPara[0] # Lecture des parametres de reference nomAttr = dres['ATTR'] valAttrRef = dres['ATTR_REFE'] # Recherche de la valeur de l'attribut dans le .PROL nompu = '' testOk = 'NOOK' if nomAttr == 'INTERPOL_FONC': nompu = fctProl[7 + 2 * (pos)] + ' ' elif nomAttr == 'INTERPOL': nompu = fctProl[1] + ' ' elif nomAttr == 'NOM_PARA_FONC': nompu = fctProl[6] elif nomAttr == 'NOM_PARA': nompu = fctProl[2] elif nomAttr == 'NOM_RESU': nompu = fctProl[3] elif nomAttr == 'PROL_GAUCHE_FONC': prolFonc = fctProl[7 + 2 * (pos) + 1] nompu = prolFonc[0:1] if nompu == 'E': nompu = 'EXCLU' elif nompu == 'C': nompu = 'CONSTANT' elif nompu == 'L': nompu = 'LINEAIRE' elif nomAttr == 'PROL_DROITE_FONC': prolFonc = fctProl[7 + 2 * (pos) + 1] nompu = prolFonc[1:2] if nompu == 'E': nompu = 'EXCLU' elif nompu == 'C': nompu = 'CONSTANT' elif nompu == 'L': nompu = 'LINEAIRE' elif nomAttr == 'PROL_GAUCHE': prolFonc = fctProl[4] nompu = prolFonc[0:1] if nompu == 'E': nompu = 'EXCLU' elif nompu == 'C': nompu = 'CONSTANT' elif nompu == 'L': nompu = 'LINEAIRE' elif nomAttr == 'PROL_DROITE': prolFonc = fctProl[4] nompu = prolFonc[1:2] if nompu == 'E': nompu = 'EXCLU' elif nompu == 'C': nompu = 'CONSTANT' elif nompu == 'L': nompu = 'LINEAIRE' # Test de la valeur if (nompu == valAttrRef): testOk = ' OK ' if TEST_NOOK == 'OUI': if testOk == ' OK ': testOk = 'NOOK' else: testOk = ' OK ' if testOk == 'NOOK': resu_test_attr = 'NOOK' # Construction de l'affichage nomFct = fonction.get_name() # ligne 1 (affichée qu'à la première occurrence) current = {} if first_affiche_ligne1: first_affiche_ligne1 = False if typeFct == 'NAPPE': nb_espace = 16 - len('NAPPE') espace = nb_espace * ' ' current['nom'] = 'NAPPE' + espace else: nb_espace = 16 - len('FONCTION') espace = nb_espace * ' ' current['nom'] = 'FONCTION' + espace nb_espace = 16 - len(list_attr[0]) espace = nb_espace * ' ' current['nom_attr'] = list_attr[0] + espace if typeFct == 'NAPPE': nb_espace = 16 - len(list_attr[1]) espace = nb_espace * ' ' current['nom_para'] = list_attr[1] + espace nb_espace = 16 - len(list_attr[2]) espace = nb_espace * ' ' current['vale'] = list_attr[2] + espace if typeFct == 'NAPPE': txt.append(ligne_att_1 % current) else: txt.append(ligne_att_2 % current) # ligne 2 current = {} nb_espace = 16 - len(nomFct) espace = nb_espace * ' ' current['nom'] = nomFct + espace nb_espace = 16 - len(nomAttr) espace = nb_espace * ' ' current['nom_attr'] = nomAttr + espace if typeFct == 'NAPPE': nb_espace = 16 - len(str(para)) espace = nb_espace * ' ' current['nom_para'] = str(para) + espace nb_espace = 16 - len(nompu) espace = nb_espace * ' ' current['vale'] = nompu + espace if typeFct == 'NAPPE': txt.append(ligne_att_11 % current) else: txt.append(ligne_att_22 % current) current = {} current['testOk'] = resu_test_attr txt.append(ligne_att_3 % current) # On affiche txt dans le fichier RESULTAT aster.affiche('RESULTAT', os.linesep.join(txt)) return ier
def simu_point_mat_ops(self, MATER, INCREMENT, SIGM_IMPOSE, EPSI_IMPOSE, SIGM_INIT, EPSI_INIT, VARI_INIT, NEWTON, CONVERGENCE, MASSIF, ANGLE, COMPORTEMENT, INFO, ARCHIVAGE, SUPPORT, **args): """Simulation de la reponse d'un point materiel""" ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) import math # On importe les definitions des commandes a utiliser dans la macro # Le nom de la variable doit etre obligatoirement le nom de la commande AFFE_CARA_ELEM = self.get_cmd('AFFE_CARA_ELEM') AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA') AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU') AFFE_MODELE = self.get_cmd('AFFE_MODELE') CALC_CHAMP = self.get_cmd('CALC_CHAMP') CALC_TABLE = self.get_cmd('CALC_TABLE') CREA_CHAMP = self.get_cmd('CREA_CHAMP') CREA_RESU = self.get_cmd('CREA_RESU') DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') IMPR_TABLE = self.get_cmd('IMPR_TABLE') LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE') MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE') MODI_REPERE = self.get_cmd('MODI_REPERE') POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') STAT_NON_LINE = self.get_cmd('STAT_NON_LINE') IMPR_RESU = self.get_cmd('IMPR_RESU') from Contrib.calc_point_mat import CALC_POINT_MAT from code_aster.Cata.Syntax import _F from Utilitai.UniteAster import UniteAster from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme from Noyau.N_types import is_sequence # alarme de STAT_NON_LINE si les mot-cles de COMPORTEMENT sont renseignes # a tort MasquerAlarme('COMPOR4_70') # -- Tests de cohérence __fonczero = DEFI_FONCTION(NOM_PARA='INST', VALE=(0, 0, 10, 0), PROL_DROITE='CONSTANT', PROL_GAUCHE='CONSTANT') EPS = {} SIG = {} itetra = 0 CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ'] CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ'] if COMPORTEMENT: lcomp = COMPORTEMENT.List_F()[0] if SUPPORT != None: if SUPPORT == 'ELEMENT': itetra = 1 if itetra == 0: if lcomp['DEFORMATION'] != 'PETIT': if args.has_key('GRAD_IMPOSE'): if args['GRAD_IMPOSE'] != None: if lcomp['DEFORMATION'] != 'SIMO_MIEHE': UTMESS('F', 'COMPOR2_22', valk=lcomp['DEFORMATION']) itetra = 0 else: itetra = 1 UTMESS('A', 'COMPOR2_1', valk=lcomp['DEFORMATION']) #=============================================================== # cas ou il n'y a pas d'élement fini : appel à CALC_POINT_MAT #=============================================================== if itetra == 0: isig = 0 ieps = 0 igrd = 0 ic1c2 = 0 if SIGM_IMPOSE: SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste) isig = 1 if EPSI_IMPOSE: EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste) ieps = 1 if args.has_key('GRAD_IMPOSE'): if args['GRAD_IMPOSE'] != None: FIJ = args['GRAD_IMPOSE'][0].cree_dict_valeurs( args['GRAD_IMPOSE'][0].mc_liste) igrd = 1 if args.has_key('MATR_C1'): if args['MATR_C1'] != None: ic1c2 = 1 if args.has_key('MATR_C2'): if args['MATR_C2'] != None: ic1c2 = 1 motscles = {} if igrd: for i in FIJ.keys(): motscles[i] = FIJ[i] elif ic1c2: if args.has_key('MATR_C1'): if args['MATR_C1'] != None: motscles['MATR_C1'] = args['MATR_C1'].List_F() if args.has_key('MATR_C2'): if args['MATR_C2'] != None: motscles['MATR_C2'] = args['MATR_C2'].List_F() if args.has_key('VECT_IMPO'): if args['VECT_IMPO'] != None: motscles['VECT_IMPO'] = args['VECT_IMPO'].List_F() else: nbsig = 6 for index in range(nbsig): iks = CMP_SIG[index] ike = CMP_EPS[index] inds = 0 inde = 0 if ieps: if EPS[ike] != None: inde = 1 if isig: if SIG[iks] != None: inds = 1 if inde * inds != 0: UTMESS('F', 'COMPOR2_2', valk=iks) if inde == 1: motscles[ike] = EPS[ike] elif inds == 1: motscles[iks] = SIG[iks] else: motscles[iks] = __fonczero # Etat initial etatinit = 0 if SIGM_INIT != None: motscles['SIGM_INIT'] = SIGM_INIT.List_F() if EPSI_INIT != None: motscles['EPSI_INIT'] = EPSI_INIT.List_F() if VARI_INIT != None: motscles['VARI_INIT'] = VARI_INIT.List_F() if NEWTON != None: motscles['NEWTON'] = NEWTON.List_F() if CONVERGENCE != None: motscles['CONVERGENCE'] = CONVERGENCE.List_F() if MASSIF != None: motscles['MASSIF'] = MASSIF.List_F() if COMPORTEMENT: motscles['COMPORTEMENT'] = COMPORTEMENT.List_F() # -- Deroulement du calcul motscles['INCREMENT'] = INCREMENT.List_F() if args.has_key('FORMAT_TABLE'): if args['FORMAT_TABLE'] != None: motscles['FORMAT_TABLE'] = args['FORMAT_TABLE'] if args.has_key('OPER_TANGENT'): if args['OPER_TANGENT'] != None: motscles['OPER_TANGENT'] = args['OPER_TANGENT'] if args.has_key('NB_VARI_TABLE'): if args['NB_VARI_TABLE'] != None: motscles['NB_VARI_TABLE'] = args['NB_VARI_TABLE'] if ARCHIVAGE: motscles['ARCHIVAGE'] = ARCHIVAGE.List_F() # variables de commande if args.has_key('AFFE_VARC'): if args['AFFE_VARC'] != None: lvarc = args['AFFE_VARC'].List_F() nbvarc = len(lvarc) lmotcle = [] for ivarc in range(nbvarc): dico = {} if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'): dico['NOM_VARC'] = 'ALPHPUR' dico['VALE_FONC'] = lvarc[ivarc]['V1'] lmotcle.append(dico) dico = {} dico['NOM_VARC'] = 'ALPHBETA' dico['VALE_FONC'] = lvarc[ivarc]['V2'] lmotcle.append(dico) elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'): dico['NOM_VARC'] = 'PFERRITE' dico['VALE_FONC'] = lvarc[ivarc]['V1'] lmotcle.append(dico) dico = {} dico['NOM_VARC'] = 'PPERLITE' dico['VALE_FONC'] = lvarc[ivarc]['V2'] lmotcle.append(dico) dico = {} dico['NOM_VARC'] = 'PBAINITE' dico['VALE_FONC'] = lvarc[ivarc]['V3'] lmotcle.append(dico) dico = {} dico['NOM_VARC'] = 'PMARTENS' dico['VALE_FONC'] = lvarc[ivarc]['V4'] lmotcle.append(dico) else: dico['NOM_VARC'] = lvarc[ivarc]['NOM_VARC'] dico['VALE_FONC'] = lvarc[ivarc]['VALE_FONC'] if str(lvarc[ivarc]['NOM_VARC']) == 'TEMP' or str( lvarc[ivarc]['NOM_VARC']) == 'SECH': dico['VALE_REF'] = lvarc[ivarc]['VALE_REF'] lmotcle.append(dico) motscles['AFFE_VARC'] = lmotcle if lcomp['RELATION'] == 'META_LEMA_ANI': UTMESS('F', 'COMPOR2_91', valk=lcomp['RELATION']) self.DeclareOut('REPONSE', self.sd) Titre = 'CALC_POINT_MAT' if ARCHIVAGE != None: # on ne prend en compte que ARCHIVAGE / LIST_INST if ARCHIVAGE['LIST_INST'] != None: __REP1 = CALC_POINT_MAT(INFO=INFO, MATER=MATER, ANGLE=ANGLE, **motscles) lr8 = ARCHIVAGE['LIST_INST'] lr = lr8.Valeurs() REPONSE = CALC_TABLE( TABLE=__REP1, TITRE=Titre, ACTION=_F(OPERATION='FILTRE', NOM_PARA='INST', VALE=lr, PRECISION=ARCHIVAGE['PRECISION']), ) else: REPONSE = CALC_POINT_MAT(INFO=INFO, MATER=MATER, ANGLE=ANGLE, **motscles) else: REPONSE = CALC_POINT_MAT(INFO=INFO, MATER=MATER, ANGLE=ANGLE, **motscles) #=============================================================== # cas ou on fait le calcul sur un TETRA4 A UN SEUL POINT DE GAUSS #=============================================================== elif itetra == 1: EPS = {} SIG = {} MODELISATION = "3D" if args.has_key('MODELISATION'): if args['MODELISATION'] != None: MODELISATION = args['MODELISATION'] if MODELISATION == "3D": nbsig = 6 CMP_EPS = ['EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ'] CMP_SIG = ['SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ'] else: nbsig = 3 CMP_EPS = ['EPXX', 'EPYY', 'EPXY'] CMP_SIG = ['SIXX', 'SIYY', 'SIXY'] if SIGM_IMPOSE: SIG = SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste) for i in SIG.keys(): if SIG[i] == None: SIG[i] = __fonczero else: for i in range(nbsig): SIG[CMP_SIG[i]] = __fonczero if EPSI_IMPOSE: EPS = EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste) else: for i in range(nbsig): EPS[CMP_EPS[i]] = None for index in range(nbsig): iks = CMP_SIG[index] ike = CMP_EPS[index] if EPS[ike] != None and SIG[iks] != __fonczero: UTMESS('F', 'COMPOR2_3', valk=str(iks) + ' ' + str(ike)) # -- Definition du maillage if MODELISATION == "3D": texte_ma = """ COOR_3D P0 0.0 0.0 0.0 P1 1.0 0.0 0.0 P2 0.0 1.0 0.0 P3 0.0 0.0 1.0 FINSF TRIA3 F1 P0 P3 P2 F2 P0 P1 P3 F3 P0 P2 P1 F4 P1 P2 P3 FINSF TETRA4 VOLUME = P0 P1 P2 P3 FINSF GROUP_MA TOUT VOLUME FINSF GROUP_NO TOUT P1 P2 P0 P3 FINSF FIN """ else: texte_ma = """ COOR_2D P0 0.0 0.0 P1 1.0 0.0 P2 0.0 1.0 FINSF SEG2 S1 P2 P0 S2 P0 P1 S3 P1 P2 FINSF TRIA3 VOLUME = P0 P1 P2 FINSF GROUP_MA TOUT VOLUME FINSF GROUP_NO TOUT P1 P2 P0 FINSF FIN """ fi_mail = open('simu.mail', 'w') fi_mail.write(texte_ma) fi_mail.close() UL = UniteAster() umail = UL.Libre(action='ASSOCIER', nom='simu.mail') __MA = LIRE_MAILLAGE(FORMAT='ASTER', UNITE=umail) UL.EtatInit() if MODELISATION == "3D": __MO = AFFE_MODELE(MAILLAGE=__MA, AFFE=_F( MAILLE=('VOLUME', 'F1', 'F2', 'F3', 'F4'), PHENOMENE='MECANIQUE', MODELISATION='3D', )) # ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations # imposées. if ANGLE != 0.: __MA = MODI_MAILLAGE( reuse=__MA, MAILLAGE=__MA, ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE), ) c = math.cos(ANGLE * math.pi / 180.) s = math.sin(ANGLE * math.pi / 180.) __C_RIGIDE = AFFE_CHAR_MECA( MODELE=__MO, DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0., DZ=0.), LIAISON_DDL=( _F(NOEUD=('P1', 'P1', 'P2', 'P2'), DDL=('DX', 'DY', 'DX', 'DY'), COEF_MULT=(s, -c, c, s), COEF_IMPO=0), _F(NOEUD=('P1', 'P3', 'P3'), DDL=('DZ', 'DX', 'DY'), COEF_MULT=(-1.0, c, s), COEF_IMPO=0), _F(NOEUD=('P2', 'P3', 'P3'), DDL=('DZ', 'DX', 'DY'), COEF_MULT=(-1.0, -s, c), COEF_IMPO=0), ), ) else: # -- Mouvement de corps rigide __C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO, DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0, DZ=0), LIAISON_DDL=( _F(NOEUD=('P2', 'P1'), DDL=('DX', 'DY'), COEF_MULT=(1, -1), COEF_IMPO=0), _F(NOEUD=('P3', 'P1'), DDL=('DX', 'DZ'), COEF_MULT=(1, -1), COEF_IMPO=0), _F(NOEUD=('P3', 'P2'), DDL=('DY', 'DZ'), COEF_MULT=(1, -1), COEF_IMPO=0), )) else: # MODELISATION 2D __MO = AFFE_MODELE(MAILLAGE=__MA, AFFE=_F(MAILLE=('VOLUME', 'S1', 'S2', 'S3'), PHENOMENE='MECANIQUE', MODELISATION=MODELISATION)) # ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations # imposées. if ANGLE != 0.: __MA = MODI_MAILLAGE( reuse=__MA, MAILLAGE=__MA, ROTATION=_F(POIN_1=(0., 0.), ANGLE=ANGLE), ) c = math.cos(ANGLE * math.pi / 180.) s = math.sin(ANGLE * math.pi / 180.) __C_RIGIDE = AFFE_CHAR_MECA( MODELE=__MO, DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0.), LIAISON_DDL=(_F(NOEUD=('P1', 'P1', 'P2', 'P2'), DDL=('DX', 'DY', 'DX', 'DY'), COEF_MULT=(s, -c, c, s), COEF_IMPO=0), ), ) else: __C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO, DDL_IMPO=_F(NOEUD='P0', DX=0, DY=0), LIAISON_DDL=(_F(NOEUD=('P2', 'P1'), DDL=('DX', 'DY'), COEF_MULT=(1, -1), COEF_IMPO=0), )) # --MASSIF : orientation du materiau (monocristal, orthotropie) if MASSIF: ANGMAS = MASSIF[0].cree_dict_valeurs(MASSIF[0].mc_liste) if ANGMAS["ANGL_REP"] == None: __CARA = AFFE_CARA_ELEM( MODELE=__MO, MASSIF=_F(MAILLE='VOLUME', ANGL_EULER=ANGMAS["ANGL_EULER"]), ) else: __CARA = AFFE_CARA_ELEM( MODELE=__MO, MASSIF=_F(MAILLE='VOLUME', ANGL_REP=ANGMAS["ANGL_REP"]), ) # -- Chargement en deformation __E = [None] * nbsig __E[0] = AFFE_CHAR_MECA(MODELE=__MO, LIAISON_OBLIQUE=_F(NOEUD='P1', DX=1, ANGL_NAUT=ANGLE)) __E[1] = AFFE_CHAR_MECA(MODELE=__MO, LIAISON_OBLIQUE=_F(NOEUD='P2', DY=1, ANGL_NAUT=ANGLE)) if MODELISATION == "3D": __E[2] = AFFE_CHAR_MECA(MODELE=__MO, LIAISON_OBLIQUE=_F(NOEUD='P3', DZ=1, ANGL_NAUT=ANGLE)) __E[3] = AFFE_CHAR_MECA(MODELE=__MO, LIAISON_OBLIQUE=_F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE)) __E[4] = AFFE_CHAR_MECA(MODELE=__MO, LIAISON_OBLIQUE=_F(NOEUD='P1', DZ=1, ANGL_NAUT=ANGLE)) __E[5] = AFFE_CHAR_MECA(MODELE=__MO, LIAISON_OBLIQUE=_F(NOEUD='P2', DZ=1, ANGL_NAUT=ANGLE)) else: c = math.cos(ANGLE * math.pi / 180.) s = math.sin(ANGLE * math.pi / 180.) __E[2] = AFFE_CHAR_MECA( MODELE=__MO, LIAISON_OBLIQUE=_F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE), ) # -- Chargement en contrainte __S = [None] * nbsig if MODELISATION == "3D": r33 = 3**-0.5 __S[0] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_FACE=( _F(MAILLE='F1', FX=-1), _F(MAILLE='F4', FX=r33), )) __S[1] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_FACE=( _F(MAILLE='F2', FY=-1), _F(MAILLE='F4', FY=r33), )) __S[2] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_FACE=( _F(MAILLE='F3', FZ=-1), _F(MAILLE='F4', FZ=r33), )) __S[3] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_FACE=( _F(MAILLE='F1', FY=-1), _F(MAILLE='F2', FX=-1), _F(MAILLE='F4', FX=r33, FY=r33), )) __S[4] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_FACE=( _F(MAILLE='F1', FZ=-1), _F(MAILLE='F3', FX=-1), _F(MAILLE='F4', FX=r33, FZ=r33), )) __S[5] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_FACE=( _F(MAILLE='F2', FZ=-1), _F(MAILLE='F3', FY=-1), _F(MAILLE='F4', FY=r33, FZ=r33), )) else: r22 = 2**-0.5 __S[0] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_CONTOUR=( _F(MAILLE='S1', FX=-1), _F(MAILLE='S3', FX=r22), )) __S[1] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_CONTOUR=( _F(MAILLE='S2', FY=-1), _F(MAILLE='S3', FY=r22), )) __S[2] = AFFE_CHAR_MECA(MODELE=__MO, FORCE_CONTOUR=( _F(MAILLE='S1', FY=-1), _F(MAILLE='S2', FX=-1), _F(MAILLE='S3', FX=r22, FY=r22), )) # -- Construction de la charge l_char = [_F(CHARGE=__C_RIGIDE)] for i in xrange(nbsig): ike = CMP_EPS[i] if EPS[ike]: l_char.append(_F(CHARGE=__E[i], FONC_MULT=EPS[ike])) for i in xrange(nbsig): iks = CMP_SIG[i] l_char.append(_F(CHARGE=__S[i], FONC_MULT=SIG[iks])) # variables de commande mcvarc = [] if args.has_key('AFFE_VARC'): if args['AFFE_VARC'] != None: lvarc = args['AFFE_VARC'].List_F() nbvarc = len(lvarc) for ivarc in range(nbvarc): dico = {} if (str(lvarc[ivarc]['NOM_VARC']) == 'SECH'): typech = 'NOEU_TEMP_R' labsc = lvarc[ivarc]['VALE_FONC'].Absc() lordo = lvarc[ivarc]['VALE_FONC'].Ordo() l_affe_cham = [] __CHV = [None] * len(labsc) for it, time in enumerate(labsc): __CHV[it] = CREA_CHAMP( TYPE_CHAM=typech, OPERATION='AFFE', MAILLAGE=__MA, AFFE=_F( MAILLE='VOLUME', NOM_CMP='TEMP', VALE=lordo[it], ), ), dicoch = {} dicoch["CHAM_GD"] = __CHV[it] dicoch["INST"] = time l_affe_cham.append(dicoch) __EVOV = CREA_RESU(OPERATION='AFFE', TYPE_RESU='EVOL_VARC', NOM_CHAM='TEMP', AFFE=l_affe_cham) elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'): typech = 'ELNO_NEUT_R' labsc = lvarc[ivarc]['V1'].Absc() lordo1 = lvarc[ivarc]['V1'].Ordo() lordo2 = lvarc[ivarc]['V2'].Ordo() lordo3 = lvarc[ivarc]['V3'].Ordo() lordo4 = lvarc[ivarc]['V4'].Ordo() l_affe_cham = [] __CHV = [None] * len(labsc) __CHN = [None] * len(labsc) for it, time in enumerate(labsc): __CHN[it] = CREA_CHAMP( TYPE_CHAM=typech, OPERATION='AFFE', PROL_ZERO='OUI', MODELE=__MO, AFFE=( _F( MAILLE='VOLUME', NOM_CMP='X1', VALE=lordo1[it], ), _F( MAILLE='VOLUME', NOM_CMP='X2', VALE=lordo2[it], ), _F( MAILLE='VOLUME', NOM_CMP='X3', VALE=lordo3[it], ), _F( MAILLE='VOLUME', NOM_CMP='X4', VALE=lordo4[it], ), ), ), dicoch = {} __CHV[it] = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELNO_VARI_R', MODELE=__MO, PROL_ZERO='OUI', ASSE=( _F(CHAM_GD=__CHN[it], NOM_CMP='X1', NOM_CMP_RESU='V1', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X2', NOM_CMP_RESU='V2', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X3', NOM_CMP_RESU='V3', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X4', NOM_CMP_RESU='V4', GROUP_MA='TOUT'), )) dicoch["CHAM_GD"] = __CHV[it] dicoch["INST"] = time l_affe_cham.append(dicoch) __EVOV = CREA_RESU(OPERATION='AFFE', TYPE_RESU='EVOL_THER', NOM_CHAM=str('META_ELNO'), AFFE=l_affe_cham) IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV)) elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'): typech = 'ELNO_NEUT_R' labsc = lvarc[ivarc]['V1'].Absc() lordo1 = lvarc[ivarc]['V1'].Ordo() lordo2 = lvarc[ivarc]['V2'].Ordo() lordo3 = lvarc[ivarc]['V3'].Ordo() lordo4 = lvarc[ivarc]['V4'].Ordo() lordo5 = lvarc[ivarc]['V5'].Ordo() lordo6 = lvarc[ivarc]['V6'].Ordo() lordo7 = lvarc[ivarc]['V7'].Ordo() l_affe_cham = [] __CHV = [None] * len(labsc) __CHN = [None] * len(labsc) for it, time in enumerate(labsc): __CHN[it] = CREA_CHAMP( TYPE_CHAM=typech, OPERATION='AFFE', PROL_ZERO='OUI', MODELE=__MO, AFFE=( _F( MAILLE='VOLUME', NOM_CMP='X1', VALE=lordo1[it], ), _F( MAILLE='VOLUME', NOM_CMP='X2', VALE=lordo2[it], ), _F( MAILLE='VOLUME', NOM_CMP='X3', VALE=lordo3[it], ), _F( MAILLE='VOLUME', NOM_CMP='X4', VALE=lordo4[it], ), _F( MAILLE='VOLUME', NOM_CMP='X5', VALE=lordo5[it], ), _F( MAILLE='VOLUME', NOM_CMP='X6', VALE=lordo6[it], ), _F( MAILLE='VOLUME', NOM_CMP='X7', VALE=lordo7[it], ), ), ), dicoch = {} __CHV[it] = CREA_CHAMP(OPERATION='ASSE', TYPE_CHAM='ELNO_VARI_R', MODELE=__MO, PROL_ZERO='OUI', ASSE=( _F(CHAM_GD=__CHN[it], NOM_CMP='X1', NOM_CMP_RESU='V1', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X2', NOM_CMP_RESU='V2', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X3', NOM_CMP_RESU='V3', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X4', NOM_CMP_RESU='V4', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X5', NOM_CMP_RESU='V5', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X6', NOM_CMP_RESU='V6', GROUP_MA='TOUT'), _F(CHAM_GD=__CHN[it], NOM_CMP='X7', NOM_CMP_RESU='V7', GROUP_MA='TOUT'), )) dicoch["CHAM_GD"] = __CHV[it] dicoch["INST"] = time l_affe_cham.append(dicoch) __EVOV = CREA_RESU(OPERATION='AFFE', TYPE_RESU='EVOL_THER', NOM_CHAM=str('META_ELNO'), AFFE=l_affe_cham) IMPR_RESU(FORMAT='RESULTAT', RESU=_F(RESULTAT=__EVOV)) else: typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_R' labsc = lvarc[ivarc]['VALE_FONC'].Absc() lordo = lvarc[ivarc]['VALE_FONC'].Ordo() l_affe_cham = [] __CHV = [None] * len(labsc) for it, time in enumerate(labsc): __CHV[it] = CREA_CHAMP( TYPE_CHAM=typech, OPERATION='AFFE', MAILLAGE=__MA, AFFE=_F( MAILLE='VOLUME', NOM_CMP=lvarc[ivarc]['NOM_VARC'], VALE=lordo[it], ), ), dicoch = {} dicoch["CHAM_GD"] = __CHV[it] dicoch["INST"] = time l_affe_cham.append(dicoch) __EVOV = CREA_RESU(OPERATION='AFFE', TYPE_RESU='EVOL_VARC', NOM_CHAM=str( lvarc[ivarc]['NOM_VARC']), AFFE=l_affe_cham) dico["MAILLE"] = 'VOLUME' dico["EVOL"] = __EVOV if (str(lvarc[ivarc]['NOM_VARC']) == 'M_ZIRC'): dico["NOM_VARC"] = "M_ZIRC" elif (str(lvarc[ivarc]['NOM_VARC']) == 'M_ACIER'): dico["NOM_VARC"] = "M_ACIER" else: dico["NOM_VARC"] = lvarc[ivarc]['NOM_VARC'] if lvarc[ivarc]['VALE_REF'] != None: dico["VALE_REF"] = lvarc[ivarc]['VALE_REF'] mcvarc.append(dico) # -- Materiau et modele if len(mcvarc) > 0: __CHMAT = AFFE_MATERIAU( MAILLAGE=__MA, AFFE=_F(MAILLE='VOLUME', MATER=MATER), AFFE_VARC=mcvarc, ) else: __CHMAT = AFFE_MATERIAU(MAILLAGE=__MA, AFFE=_F(MAILLE='VOLUME', MATER=MATER)) # Etat initial SIGINI = {} VARINI = {} LCSIG = [] LVSIG = [] init_dico = {} etatinit = 0 # --contraintes initiales if SIGM_INIT: etatinit = 1 SIGINI = SIGM_INIT[0].cree_dict_valeurs(SIGM_INIT[0].mc_liste) for i in SIGINI.keys(): if SIGINI[i] != None: LCSIG.append(i) LVSIG.append(SIGINI[i]) __SIG_INIT = CREA_CHAMP(MAILLAGE=__MA, OPERATION='AFFE', TYPE_CHAM='CART_SIEF_R', AFFE=_F( TOUT='OUI', NOM_CMP=LCSIG, VALE=LVSIG, )) init_dico['SIGM'] = __SIG_INIT # --variables internes initiales if VARI_INIT: etatinit = 1 lnomneu = [] lnomvar = [] VARINI = VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste) if (not is_sequence(VARINI['VALE'])): VARINI['VALE'] = [ VARINI['VALE'], ] nbvari = len(VARINI['VALE']) for i in range(nbvari): lnomneu.append('X' + str(i + 1)) lnomvar.append('V' + str(i + 1)) __NEUT = CREA_CHAMP(OPERATION='AFFE', TYPE_CHAM='CART_N480_R', MAILLAGE=__MA, AFFE=_F(MAILLE='VOLUME', NOM_CMP=lnomneu, VALE=VARINI['VALE'])) __VAR_INIT = CREA_CHAMP(MODELE=__MO, OPERATION='ASSE', TYPE_CHAM='ELGA_VARI_R', ASSE=_F(TOUT='OUI', CHAM_GD=__NEUT, NOM_CMP=lnomneu, NOM_CMP_RESU=lnomvar)) init_dico['VARI'] = __VAR_INIT # --deformations initiales if EPSI_INIT: etatinit = 1 EPSINI = {} LCDEPL = [] LNDEPL = [] LVDEPL = [] LIST_AFFE = [] mon_dico = {} mon_dico["NOEUD"] = 'P0' mon_dico["NOM_CMP"] = ("DX", "DY", "DZ") mon_dico["VALE"] = (0., 0., 0.) LIST_AFFE.append(mon_dico) EPSINI = EPSI_INIT[0].cree_dict_valeurs(EPSI_INIT[0].mc_liste) mon_dico = {} mon_dico["NOEUD"] = 'P1' mon_dico["NOM_CMP"] = 'DX' mon_dico["VALE"] = EPSINI['EPXX'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P2' mon_dico["NOM_CMP"] = 'DY' mon_dico["VALE"] = EPSINI['EPYY'] LIST_AFFE.append(mon_dico) if MODELISATION == "3D": mon_dico = {} mon_dico["NOEUD"] = 'P3' mon_dico["NOM_CMP"] = 'DZ' mon_dico["VALE"] = EPSINI['EPZZ'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P1' mon_dico["NOM_CMP"] = 'DY' mon_dico["VALE"] = EPSINI['EPXY'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P2' mon_dico["NOM_CMP"] = 'DX' mon_dico["VALE"] = EPSINI['EPXY'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P1' mon_dico["NOM_CMP"] = 'DZ' mon_dico["VALE"] = EPSINI['EPXZ'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P3' mon_dico["NOM_CMP"] = 'DX' mon_dico["VALE"] = EPSINI['EPXZ'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P2' mon_dico["NOM_CMP"] = 'DZ' mon_dico["VALE"] = EPSINI['EPYZ'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P3' mon_dico["NOM_CMP"] = 'DY' mon_dico["VALE"] = EPSINI['EPYZ'] LIST_AFFE.append(mon_dico) else: mon_dico = {} mon_dico["NOEUD"] = 'P1', mon_dico["NOM_CMP"] = 'DY' mon_dico["VALE"] = EPSINI['EPXY'] LIST_AFFE.append(mon_dico) mon_dico = {} mon_dico["NOEUD"] = 'P2' mon_dico["NOM_CMP"] = 'DX' mon_dico["VALE"] = EPSINI['EPXY'] LIST_AFFE.append(mon_dico) __DEP_INI = CREA_CHAMP(MAILLAGE=__MA, OPERATION='AFFE', TYPE_CHAM='NOEU_DEPL_R', AFFE=LIST_AFFE) init_dico['DEPL'] = __DEP_INI # -- Deroulement du calcul motscles = {} if COMPORTEMENT: motscles['COMPORTEMENT'] = COMPORTEMENT.List_F() if lcomp['RELATION'] == 'META_LEMA_ANI': UTMESS('A', 'COMPOR2_92', valk=lcomp['RELATION']) motscles['CONVERGENCE'] = CONVERGENCE.List_F() motscles['NEWTON'] = NEWTON.List_F() if args.has_key('RECH_LINEAIRE'): if args['RECH_LINEAIRE'] != None: motscles['RECH_LINEAIRE'] = args['RECH_LINEAIRE'].List_F() motscles['INCREMENT'] = INCREMENT.List_F() if ARCHIVAGE: motscles['ARCHIVAGE'] = ARCHIVAGE.List_F() if args.has_key('SUIVI_DDL'): if args['SUIVI_DDL'] != None: motscles['SUIVI_DDL'] = args['SUIVI_DDL'].List_F() if etatinit == 1: if MASSIF: __EVOL1 = STAT_NON_LINE(INFO=INFO, CARA_ELEM=__CARA, MODELE=__MO, CHAM_MATER=__CHMAT, ETAT_INIT=init_dico, EXCIT=l_char, **motscles) else: __EVOL1 = STAT_NON_LINE(INFO=INFO, MODELE=__MO, CHAM_MATER=__CHMAT, ETAT_INIT=init_dico, EXCIT=l_char, **motscles) else: if MASSIF: __EVOL1 = STAT_NON_LINE(INFO=INFO, MODELE=__MO, CARA_ELEM=__CARA, CHAM_MATER=__CHMAT, EXCIT=l_char, **motscles) else: __EVOL1 = STAT_NON_LINE(INFO=INFO, MODELE=__MO, CHAM_MATER=__CHMAT, EXCIT=l_char, **motscles) if lcomp['DEFORMATION'] != 'PETIT': nomepsi = 'EPSG_ELNO' else: nomepsi = 'EPSI_ELNO' __EVOL1 = CALC_CHAMP( reuse=__EVOL1, RESULTAT=__EVOL1, CONTRAINTE='SIGM_ELNO', DEFORMATION=nomepsi, VARI_INTERNE='VARI_ELNO', ) if MODELISATION == "3D": angles = (ANGLE, 0, 0) __EVOL = MODI_REPERE( RESULTAT=__EVOL1, MODI_CHAM=( _F( NOM_CHAM='DEPL', NOM_CMP=('DX', 'DY', 'DZ'), TYPE_CHAM='VECT_3D', ), _F( NOM_CHAM='SIGM_ELNO', NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY', 'SIXZ', 'SIYZ'), TYPE_CHAM='TENS_3D', ), _F( NOM_CHAM=nomepsi, NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY', 'EPXZ', 'EPYZ'), TYPE_CHAM='TENS_3D', ), ), REPERE='UTILISATEUR', AFFE=_F(ANGL_NAUT=angles), ) else: angles = ANGLE __EVOL = MODI_REPERE( RESULTAT=__EVOL1, MODI_CHAM=( _F( NOM_CHAM='DEPL', NOM_CMP=('DX', 'DY'), TYPE_CHAM='VECT_2D', ), _F( NOM_CHAM='SIGM_ELNO', NOM_CMP=('SIXX', 'SIYY', 'SIZZ', 'SIXY'), TYPE_CHAM='TENS_2D', ), _F( NOM_CHAM=nomepsi, NOM_CMP=('EPXX', 'EPYY', 'EPZZ', 'EPXY'), TYPE_CHAM='TENS_2D', ), ), REPERE='UTILISATEUR', AFFE=_F(ANGL_NAUT=angles), ) # -- Recuperation des courbes __REP_VARI = POST_RELEVE_T(ACTION=(_F(INTITULE='VARI_INT', RESULTAT=__EVOL1, NOM_CHAM='VARI_ELNO', TOUT_CMP='OUI', OPERATION='EXTRACTION', NOEUD='P0'), )) __REP_EPSI = POST_RELEVE_T(ACTION=(_F(INTITULE='EPSILON', RESULTAT=__EVOL, NOM_CHAM=nomepsi, TOUT_CMP='OUI', OPERATION='EXTRACTION', NOEUD='P0'), )) __REP_SIGM = POST_RELEVE_T(ACTION=(_F(INTITULE='SIGMA', RESULTAT=__EVOL, NOM_CHAM='SIGM_ELNO', TOUT_CMP='OUI', OPERATION='EXTRACTION', NOEUD='P0'), )) __REP_INV = POST_RELEVE_T(ACTION=(_F(INTITULE='INV', RESULTAT=__EVOL, NOM_CHAM='SIGM_ELNO', INVARIANT='OUI', OPERATION='EXTRACTION', NOEUD='P0'), )) __REP_INV = CALC_TABLE(TABLE=__REP_INV, reuse=__REP_INV, ACTION=_F( OPERATION='EXTR', NOM_PARA=('INST', 'TRACE', 'VMIS'), )) self.DeclareOut('REPONSE', self.sd) REPONSE = CALC_TABLE(TABLE=__REP_EPSI, TITRE='TABLE ', ACTION=( _F( OPERATION='COMB', TABLE=__REP_SIGM, NOM_PARA=('INST'), ), _F( OPERATION='COMB', TABLE=__REP_INV, NOM_PARA=('INST'), ), _F( OPERATION='COMB', TABLE=__REP_VARI, NOM_PARA=('INST'), ), )) RetablirAlarme('COMPOR4_70') return ier