From: Renaud Barate Date: Fri, 13 May 2011 14:43:07 +0000 (+0000) Subject: Update from Aster NEW10 X-Git-Tag: V6_3_0rc1 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=2198d463f048075603461041eb6392ac0d4f24a0;p=tools%2Feficas.git Update from Aster NEW10 --- diff --git a/Aster/Cata/cataSTA10/Cata_Utils/__init__.py b/Aster/Cata/cataSTA10/Cata_Utils/__init__.py new file mode 100644 index 00000000..17af639e --- /dev/null +++ b/Aster/Cata/cataSTA10/Cata_Utils/__init__.py @@ -0,0 +1,26 @@ +#@ MODIF __init__ Cata_Utils DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +# +# Ce package ne doit contenir que les modules nécessaires au catalogue +# qui ne peuvent pas être dans Macro ou SD. +# Exemple : t_fonction permettant d'évaluer les fonctions dans le catalogue materiau. +# + diff --git a/Aster/Cata/cataSTA10/Cata_Utils/t_fonction.py b/Aster/Cata/cataSTA10/Cata_Utils/t_fonction.py new file mode 100644 index 00000000..82f41c3b --- /dev/null +++ b/Aster/Cata/cataSTA10/Cata_Utils/t_fonction.py @@ -0,0 +1,780 @@ +#@ MODIF t_fonction Cata_Utils DATE 22/03/2011 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +import copy +import types +from math import exp, log + +import numpy as NP +import numpy.fft as FFT + +from Noyau.N_types import is_float, is_float_or_int, is_complex, is_number, is_enum + + +# ----------------------------------------------------------------------------- +class FonctionError(Exception): pass + +class ParametreError(FonctionError): pass # probleme de NOM_PARA +class InterpolationError(FonctionError): pass +class ProlongementError(FonctionError): pass + +# ----------------------------------------------------------------------------- +def interp(typ_i,val,x1,x2,y1,y2,tol=1.e-6) : + """Interpolation linéaire/logarithmique entre un couple de valeurs + """ + if abs(val-x1) < tol : return y1 + if abs(val-x2) < tol : return y2 + if typ_i[0] == 'LOG' and (x1 <= 0. or x2 <= 0.): + raise InterpolationError("Interpolation LOG invalide sur l'intervalle [%g, %g]." % (x1, x2)) + if typ_i[1] == 'LOG' and (y1 <= 0. or y2 <= 0.): + raise InterpolationError("Interpolation LOG invalide sur les ordonnées [%g, %g]." % (y1, y2)) + if typ_i==['LIN','LIN']: return y1+(y2-y1)*(val-x1)/(x2-x1) + if typ_i==['LIN','LOG']: return exp(log(y1)+(val-x1)*(log(y2)-log(y1))/(x2-x1)) + if typ_i==['LOG','LOG']: return exp(log(y1)+(log(val)-log(x1))*(log(y2)-log(y1))/(log(x2)-log(x1))) + if typ_i==['LOG','LIN']: return y1+(log(val)-log(x1))*(y2-y1)/(log(x2)-log(x1)) + raise InterpolationError, "abscisse = %g, intervalle = [%g, %g]" % (val, x1, x2) + + +def is_ordo(liste): + if len(liste) > 1: + val = NP.array(liste, float) + return min(val[1:len(val)] - val[0:len(val)-1]) >= 0. + else: return True + +# ----------------------------------------------------------------------------- +class t_fonction : + """Classe pour fonctions réelles, équivalent au type aster = fonction_sdaster + """ + def __init__(self,vale_x,vale_y,para,nom='') : + """Création d'un objet fonction + - vale_x et vale_y sont des listes de réels de meme longueur + - para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER) + """ + self.nom=nom + pk=para.keys() + pk.sort() + if pk!=['INTERPOL','NOM_PARA','NOM_RESU','PROL_DROITE','PROL_GAUCHE'] : + raise FonctionError, 'fonction : parametres incorrects' + if para['INTERPOL'] not in [['NON','NON'],['LIN','LIN'],['LIN','LOG'],['LOG','LOG'],['LOG','LIN'],] : + raise FonctionError, 'fonction : parametre INTERPOL incorrect : %s' % para['INTERPOL'] + if para['PROL_DROITE'] not in ['EXCLU','CONSTANT','LINEAIRE'] : + raise FonctionError, 'fonction : parametre PROL_DROITE incorrect : %s' % para['PROL_DROITE'] + if para['PROL_GAUCHE'] not in ['EXCLU','CONSTANT','LINEAIRE'] : + raise FonctionError, 'fonction : parametre PROL_GAUCHE incorrect : %s' % para['PROL_GAUCHE'] + self.vale_x = NP.array(vale_x) + self.vale_y = NP.array(vale_y) + self.para = para + if len(self.vale_x)!=len(self.vale_y) : + raise FonctionError, 'fonction : longueur abscisse <> longueur ordonnées' + if not is_ordo(self.vale_x) : + raise FonctionError, 'fonction : abscisses non strictement croissantes' + + def __add__(self,other) : + """addition avec une autre fonction ou un nombre, par surcharge de l'opérateur + + """ + if isinstance(other,t_fonction): + para=copy.copy(self.para) + vale_x,para['PROL_GAUCHE'],para['PROL_DROITE']=self.homo_support(other) + fff=self.evalfonc(vale_x) + ggg=other.evalfonc(vale_x) + if isinstance(self,t_fonction_c): return t_fonction_c(vale_x,fff.vale_y+ggg.vale_y,para) + else : return t_fonction(vale_x,fff.vale_y+ggg.vale_y,para) + elif is_number(other): + if isinstance(self,t_fonction_c): return t_fonction_c(self.vale_x,self.vale_y+other,self.para) + else : return t_fonction(self.vale_x,self.vale_y+other,self.para) + else: raise FonctionError, 'fonctions : erreur de type dans __add__ : %s %s' % (self, type(other)) + + def __mul__(self,other) : + """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur * + """ + if isinstance(other,t_fonction): + para=copy.copy(self.para) + vale_x,para['PROL_GAUCHE'],para['PROL_DROITE']=self.homo_support(other) + fff=self.evalfonc(vale_x) + ggg=other.evalfonc(vale_x) + if isinstance(self,t_fonction_c): return t_fonction_c(vale_x,fff.vale_y*ggg.vale_y,para) + else : return t_fonction(vale_x,fff.vale_y*ggg.vale_y,para) + elif is_float_or_int(other): + return t_fonction(self.vale_x,self.vale_y*other,self.para) + elif is_complex(other): + return t_fonction_c(self.vale_x,self.vale_y*other,self.para) + else: raise FonctionError, 'fonctions : erreur de type dans __mul__%s %s' % (self, type(other)) + + def __repr__(self) : + """affichage de la fonction en double colonne + """ + texte=[] + for i in range(len(self.vale_x)) : + texte.append('%f %f' % (self.vale_x[i],self.vale_y[i])) + return '\n'.join(texte) + + def __getitem__(self,other) : + """composition de deux fonction F[G]=FoG=F(G(x)) + """ + para=copy.copy(self.para) + if other.para['NOM_RESU'] != self.para['NOM_PARA'] : + raise ParametreError,'''composition de fonctions : NOM_RESU1 et NOM_PARA2 incohérents ''' + para['NOM_PARA']==other.para['NOM_PARA'] + return t_fonction(other.vale_x,map(self,other.vale_y),para) + + def __call__(self,val,tol=1.e-6): + """méthode pour évaluer f(x) + - tolérance, par défaut 1.e-6 en relatif sur la longueur de l'intervalle + - adjacent, pour capter les erreurs d'arrondi en cas de prolongement exclu + """ + i=NP.searchsorted(self.vale_x, val) + n=len(self.vale_x) + if n == 1: + # Utilisation abusive de la tolérance relative mais ce cas est particulier + if (val-self.vale_x[0]) < tol: + return self.vale_y[0] + elif val-self.vale_x[0] > 0: + if (self.para['PROL_DROITE']=='CONSTANT') or (self.para['PROL_DROITE']=='LINEAIRE'): + return self.vale_y[0] + else: raise ProlongementError, 'fonction évaluée hors du domaine de définition' + elif val-self.vale_x[0] < 0: + if (self.para['PROL_GAUCHE']=='CONSTANT') or (self.para['PROL_GAUCHE']=='LINEAIRE'): + return self.vale_y[0] + else: raise ProlongementError, 'fonction évaluée hors du domaine de définition' + + if i==0 : + if self.para['PROL_GAUCHE']=='EXCLU' : + eps_g=(val-self.vale_x[0] )/(self.vale_x[1] -self.vale_x[0]) + if abs(eps_g)<=tol : return self.vale_y[0] + else : raise ProlongementError, 'fonction évaluée hors du domaine de définition' + else : + if self.para['PROL_GAUCHE']=='CONSTANT' : return self.vale_y[0] + if self.para['PROL_GAUCHE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val,self.vale_x[0], + self.vale_x[1], + self.vale_y[0], + self.vale_y[1]) + elif i==n : + if self.para['PROL_DROITE']=='EXCLU' : + eps_d=(val-self.vale_x[-1])/(self.vale_x[-1]-self.vale_x[-2]) + if abs(eps_d)<=tol : return self.vale_y[-1] + else : raise ProlongementError, 'fonction évaluée hors du domaine de définition' + else : + if self.para['PROL_DROITE']=='CONSTANT' : return self.vale_y[-1] + if self.para['PROL_DROITE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val,self.vale_x[-1], + self.vale_x[-2], + self.vale_y[-1], + self.vale_y[-2]) + else : + return interp(self.para['INTERPOL'],val,self.vale_x[i-1], + self.vale_x[i], + self.vale_y[i-1], + self.vale_y[i]) + + def homo_support(self,other) : + """Renvoie le support d'abscisses homogénéisé entre self et other + i.e. si prolongement exclu, on retient plus grand min ou plus petit max, selon + si prolongement autorisé, on conserve les abscisses d'une fonction, extrapolantes + sur l'autre. + Pour les points intermédiaires : union et tri des valeurs des vale_x réunis. + """ + if other.vale_x[0]>self.vale_x[0]: + if other.para['PROL_GAUCHE']!='EXCLU' : f_g=self + else : f_g=other + else : + if self.para['PROL_GAUCHE'] !='EXCLU' : f_g=other + else : f_g=self + val_min =f_g.vale_x[0] + prol_gauche=f_g.para['PROL_GAUCHE'] + if self.vale_x[-1]>other.vale_x[-1]: + if other.para['PROL_DROITE']!='EXCLU' : f_d=self + else : f_d=other + else : + if self.para['PROL_DROITE'] !='EXCLU' : f_d=other + else : f_d=self + val_max =f_d.vale_x[-1] + prol_droite=f_d.para['PROL_DROITE'] + vale_x=NP.concatenate((self.vale_x,other.vale_x)) + vale_x=NP.clip(vale_x,val_min,val_max) + vale_x=NP.sort(list(set(vale_x))) + return vale_x, prol_gauche, prol_droite + + def cut(self,rinf,rsup,prec,crit='RELATIF',nom='') : + """Renvoie la fonction self dont on a 'coupé' les extrémités en x=rinf et x=rsup + pour la recherche de rinf et rsup dans la liste d'abscisses : + prec=precision crit='absolu' ou 'relatif' + """ + para=copy.copy(self.para) + para['PROL_GAUCHE']='EXCLU' + para['PROL_DROITE']='EXCLU' + if crit=='ABSOLU' : rinf_tab=NP.greater(abs(self.vale_x-rinf),prec) + elif crit=='RELATIF': rinf_tab=NP.greater(abs(self.vale_x-rinf),prec*rinf) + else : raise FonctionError, 'fonction : cut : critère absolu ou relatif' + if crit=='ABSOLU' : rsup_tab=NP.greater(abs(self.vale_x-rsup),prec) + elif crit=='RELATIF': rsup_tab=NP.greater(abs(self.vale_x-rsup),prec*rsup) + else : raise FonctionError, 'fonction : cut : critère absolu ou relatif' + if NP.alltrue(rinf_tab) : i=NP.searchsorted(self.vale_x,rinf) + else : i=rinf_tab.tolist().index(0)+1 + if NP.alltrue(rsup_tab) : j=NP.searchsorted(self.vale_x,rsup) + else : j=rsup_tab.tolist().index(0) + vale_x=NP.array([rinf,]+self.vale_x.tolist()[i:j]+[rsup,]) + vale_y=NP.array([self(rinf),]+self.vale_y.tolist()[i:j]+[self(rsup),]) + return t_fonction(vale_x,vale_y,para,nom) + + def cat(self,other,surcharge) : + """renvoie une fonction concaténée avec une autre, avec règles de surcharge + """ + para=copy.copy(self.para) + if self.para['INTERPOL']!=other.para['INTERPOL'] : raise FonctionError, 'concaténation de fonctions à interpolations différentes' + if NP.min(self.vale_x)1.e-2 : + raise FonctionError, 'fonction réelle : FFT : la fonction doit etre à pas constant' + n = get_len_puis2(self.vale_x) + if methode=='TRONCATURE' : + vale_y=self.vale_y[:2**n] + elif methode=='PROL_ZERO' : + vale_y=self.vale_y + if len(self.vale_y) > 2**n: + vale_y=NP.array(self.vale_y) + vale_y = NP.concatenate( (vale_y, NP.zeros(2**(n+1)-len(self.vale_x))) ) + elif methode=='COMPLET' : + vale_y=self.vale_y + vect=FFT.fft(vale_y) + pasfreq =1./(pas*(len(vect))) + vale_x =[pasfreq*i for i in range(len(vect))] + vale_y =vect + return t_fonction_c(vale_x,vale_y,para) + + +# ----------------------------------------------------------------------------- +class t_fonction_c(t_fonction) : + """Classe pour fonctions complexes, équivalent au type aster = fonction_c + """ + def __add__(self,other) : + """addition avec une autre fonction ou un nombre, par surcharge de l'opérateur + + """ + if isinstance(other,t_fonction_c): + para=copy.copy(self.para) + vale_x, para['PROL_GAUCHE'], para['PROL_DROITE'] = self.homo_support(other) + fff = self.evalfonc(vale_x) + ggg = other.evalfonc(vale_x) + res = t_fonction_c(vale_x, fff.vale_y + ggg.vale_y, para) + elif is_number(other): + res = t_fonction_c(self.vale_x, self.vale_y + other, self.para) + else: + raise FonctionError, 'fonctions : erreur de type dans __add__ : %s %s' % (self, type(other)) + return res + + def __mul__(self,other) : + """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur * + """ + if isinstance(other,t_fonction_c): + para=copy.copy(self.para) + vale_x, para['PROL_GAUCHE'], para['PROL_DROITE'] = self.homo_support(other) + fff = self.evalfonc(vale_x) + ggg = other.evalfonc(vale_x) + res = t_fonction_c(vale_x, fff.vale_y * ggg.vale_y, self.para) + elif is_number(other): + res = t_fonction_c(self.vale_x, self.vale_y*other, self.para) + else: + raise FonctionError, 'fonctions : erreur de type dans __mul__%s %s' % (self, type(other)) + return res + + def tabul(self) : + """mise en forme de la fonction selon un vecteur unique (x1,yr1,yi1,x2,yr2,yr2,...) + """ + __tab=NP.array([self.vale_x,self.vale_y.real,self.vale_y.imag]) + return NP.ravel(NP.transpose(__tab)).tolist() + + def __repr__(self) : + """affichage de la fonction en double colonne + """ + texte=[] + for i in range(len(self.vale_x)) : + texte.append('%f %f + %f .j' % (self.vale_x[i],self.vale_y[i].real,self.vale_y[i].imag)) + return '\n'.join(texte) + + def fft(self,methode,syme) : + """renvoie la transformée de Fourier rapide FFT (sens inverse) + + Dans le cas syme == 'NON', on choisit de renvoyer + un vecteur de longueur 2N, ou N est la longueur du vecteur F de depart, + en faisant l'approximation que pour la vraie FFT, F(N+1) est fonction + de F(N) et F(N-1). + On effectue un prolongement a l'ordre 2 par continuite pour simplifier + l'analyse des pas de temps en post traitement + """ + para=copy.copy(self.para) + para['NOM_PARA']='INST' + if self.para['NOM_PARA']!='FREQ' : + raise ParametreError, 'fonction complexe : FFT : NOM_PARA=FREQ pour une transformée directe' + pas = self.vale_x[1]-self.vale_x[0] + for i in range(1,len(self.vale_x)) : + ecart = NP.abs(((self.vale_x[i]-self.vale_x[i-1])-pas)/pas) + if ecart>1.e-3 : + raise FonctionError, 'fonction complexe : FFT : la fonction doit etre à pas constant' + n = get_len_puis2(self.vale_x) + if syme=='OUI' : + vale_fonc=self.vale_y + else : + if methode=='PROL_ZERO' : + fonc_temp=self.vale_y + if len(self.vale_y) > 2**n: + fonc_temp = NP.concatenate( (self.vale_y, NP.zeros(2**(n+1)-len(self.vale_x))) ) + elif methode=='TRONCATURE' : + fonc_temp=self.vale_y[:2**n] + elif methode=='COMPLET' : + fonc_temp=self.vale_y + part1=fonc_temp.tolist() + + if NP.remainder(len(part1),2) == 0 : + # Si le nombre de point du spectre est pair, + # on prolonge en interpolant les 3 dernier points par un polynome de + # degre 2, en imposant une tangente horizontale au dernier point (celui + # dont on cherche l'ordonnee : + # on pose Y=a.w^2+b.w+C , ou Y est la partie reelle de la FFT, et + # w la frequence. On connait Y(N-1), Y(N), et on impose dY/dw(N+1)=0 + # pour la symetrie. On identifie a, b et c, pour calculer Y(N+1) + middle=[]; + middle.append((4*part1[-1].real-part1[len(part1)-2].real)/3); + part2=NP.conjugate(fonc_temp[1:len(part1)]) + part2=part2.tolist(); + part2.reverse(); + vale_fonc=NP.array(part1+middle+part2) + else : + # Si le dernier point est effectivement reel, on reconstruit theoriquement + if abs(part1[-1].imag) < abs(part1[-1].real*1e-6) : + part1[-1]=part1[-1].real + else : + # Sinon, on approxime comme dans le cas ou N est pair + part1[-1]=(4*part1[len(part1)-2].real-part1[len(part1)-3].real)/3 + part2=NP.conjugate(fonc_temp[1:len(part1)-1]) + part2=part2.tolist(); + part2.reverse(); + vale_fonc=NP.array(part1+part2) + + vect=FFT.ifft(vale_fonc) + vect=vect.real + pasfreq =1./(pas*(len(vect))) + vale_x =[pasfreq*i for i in range(len(vect))] + vale_y =vect + return t_fonction(vale_x,vale_y,para) + +# ----------------------------------------------------------------------------- +class t_nappe : + """Classe pour nappes, équivalent au type aster = nappe_sdaster + """ + 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_enum(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 __call__(self,val1,val2): + """méthode pour évaluer nappe(val1,val2) + """ + i=NP.searchsorted(self.vale_para,val1) + n=len(self.vale_para) + if i==0 : + if val1==self.vale_para[0] : return self.l_fonc[0](val2) + if val1 self.vale_para[-1] : + if self.para['PROL_DROITE']=='EXCLU' : raise ParametreError, 'nappe évaluée hors du domaine de définition' + if self.para['PROL_DROITE']=='CONSTANT' : return self.l_fonc[-1](val2) + if self.para['PROL_DROITE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val1, + self.vale_para[-1], + self.vale_para[-2], + self.l_fonc[-1](val2), + self.l_fonc[-2](val2)) + else : + return interp(self.para['INTERPOL'],val1,self.vale_para[i-1], + self.vale_para[i], + self.l_fonc[i-1](val2), + self.l_fonc[i](val2)) + + def evalfonc(self, liste_val) : + """Renvoie la mm nappe dont les fonctions sont interpolées aux points définis + par la liste 'liste_val'. + """ + l_fonc = [] + for f in self.l_fonc: + f2 = f.evalfonc(liste_val) + l_fonc.append(f2) + return t_nappe(self.vale_para, l_fonc, self.para) + + def __add__(self,other) : + """addition avec une autre nappe ou un nombre, par surcharge de l'opérateur + + """ + l_fonc=[] + if isinstance(other,t_nappe): + if NP.all(self.vale_para != other.vale_para): + raise ParametreError, 'nappes à valeurs de paramètres différentes' + for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]+other.l_fonc[i]) + elif is_float_or_int(other): + for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]+other) + else: raise FonctionError, 't_nappe : erreur de type dans __add__ : %s %s' % (other, type(other)) + return t_nappe(self.vale_para,l_fonc,self.para) + + def __mul__(self,other) : + """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur * + """ + l_fonc=[] + if isinstance(other,t_nappe): + if NP.all(self.vale_para != other.vale_para) : + raise ParametreError, 'nappes à valeurs de paramètres différentes' + for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]*other.l_fonc[i]) + elif is_float_or_int(other): + for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]*other) + else: raise FonctionError, 't_nappe : erreur de type dans __mul__ : %s %s' % (other, type(other)) + return t_nappe(self.vale_para,l_fonc,self.para) + + def __repr__(self) : + """affichage de la nappe en double colonne + """ + texte=[] + for i in range(len(self.vale_para)) : + texte.append('paramètre : %f' % self.vale_para[i]) + texte.append(repr(self.l_fonc[i])) + return '\n'.join(texte) + + def homo_support(self,other) : + """Renvoie la nappe self avec un support union de celui de self et de other + le support est la discrétisation vale_para et les discrétisations des fonctions + """ + if self==other: + return self + vale_para=self.vale_para.tolist()+other.vale_para.tolist() + vale_para=list(set(vale_para)) + vale_para.sort() + vale_para=NP.array(vale_para) + l_fonc=[] + for val in vale_para : + if val in self.vale_para: + l_fonc.append(self.l_fonc[NP.searchsorted(self.vale_para, val)]) + elif val in other.vale_para: + other_fonc=other.l_fonc[NP.searchsorted(other.vale_para, val)] + new_vale_x=other_fonc.vale_x + new_para =other_fonc.para + new_vale_y=[self(val,x) for x in new_vale_x] + if isinstance(other_fonc, t_fonction): + l_fonc.append(t_fonction(new_vale_x, new_vale_y, new_para)) + if isinstance(other_fonc, t_fonction_c): + l_fonc.append(t_fonction_c(new_vale_x, new_vale_y, new_para)) + else: + raise FonctionError, 'combinaison de nappes : incohérence' + return t_nappe(vale_para,l_fonc,self.para) + + def extreme(self) : + """renvoie un dictionnaire des valeurs d'ordonnées min et max + """ + val_min=min([min(fonc.vale_y) for fonc in self.l_fonc]) + val_max=max([max(fonc.vale_y) for fonc in self.l_fonc]) + vm={'min':[],'max':[]} + for i in range(len(self.vale_para)) : + for j in range(len(self.l_fonc[i].vale_y)) : + y = self.l_fonc[i].vale_y[j] + if y==val_min : vm['min'].append([y,self.l_fonc[i].vale_x[j],self.vale_para[i]]) + if y==val_max : vm['max'].append([y,self.l_fonc[i].vale_x[j],self.vale_para[i]]) + vm['min'].sort() + vm['max'].sort() + for item in vm['min'] : item.reverse() + for item in vm['max'] : item.reverse() + return vm + + +# ----------------------------------------------------------------------------- +def homo_support_nappe(l_f): + """Homogénéisation du support d'une liste de nappes. + Retourne une liste de nappes. + """ + if not is_enum(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 func_union(func,l_f) : + """Retourne la fonction x : func(y0=l_f[0](x), y1=l_f[1](x), ...) + sur la liste d'abscisses union de celles de self et de other. + """ + para = copy.copy(l_f[0].para) + # Pour les prolongements et l'interpolation, c'est la première fonction qui prime + vale_x=[] + for f in l_f : + vale_x = vale_x + f.vale_x.tolist() + # on ote les abscisses doublons + vale_x = list(set(vale_x)) + vale_x.sort() + vale_x = NP.array(vale_x) + # interpolation des fonctions sur l'union des abscisses + vale_y = [map(f,vale_x) for f in l_f] + # applique la fonction + vale_y = map(func, *vale_y) + return t_fonction(vale_x, vale_y, para) + + +def enveloppe(l_f, crit): + """renvoie l'enveloppe supérieure ou inférieure de self et other. + """ + if crit.upper() == 'SUP': + env = func_union(max, l_f) + elif crit.upper() == 'INF': + env = func_union(min, l_f) + else: + raise FonctionError, 'enveloppe : le critère doit etre SUP ou INF !' + return env + + +def fractile(l_f, fract): + """renvoie l'enveloppe supérieure ou inférieure de self et other. + """ + para = copy.copy(l_f[0].para) + # Pour les prolongements et l'interpolation, c'est la première fonction qui prime + vale_x=[] + for f in l_f : + vale_x = vale_x + f.vale_x.tolist() + # on ote les abscisses doublons + vale_x = list(set(vale_x)) + vale_x.sort() + vale_x = NP.array(vale_x) + # + l_vale_y=[] + for f in l_f : + vale_y = map(f,vale_x) + l_vale_y.append(vale_y) + tab_val=NP.transpose(NP.array(l_vale_y)) + tab_val=tab_val.tolist() + for l in tab_val : l.sort() + vale_y=[] + if fract>=1. : + for l_val in tab_val : + vale_y.append(l_val[-1]) + else : + indice=int((len(tab_val[0])-1)*fract) + reste =(len(tab_val[0])-1)*fract-indice + for l_val in tab_val : + vale_y.append(l_val[indice]*(1-reste)+l_val[indice+1]*reste) + return t_fonction(vale_x, vale_y, para) + + +def get_len_puis2(tab_in): + """Retourne N, la plus grande puissance de 2 telle que 2**N <= len(tab_in) + """ + return int( log(len(tab_in)) / log(2.) ) + + diff --git a/Aster/Cata/cataSTA10/Macro/asse_elem_ssd_ops.py b/Aster/Cata/cataSTA10/Macro/asse_elem_ssd_ops.py new file mode 100644 index 00000000..fa9d4942 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/asse_elem_ssd_ops.py @@ -0,0 +1,119 @@ +#@ MODIF asse_elem_ssd_ops Macro DATE 03/01/2011 AUTEUR ANDRIAM H.ANDRIAMBOLOLONA +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# ====================================================================== + +def asse_elem_ssd_ops(self, RESU_ASSE_SSD, SOUS_STRUC, LIAISON, VERIF, **args): + """ + Echainement des commandes : + DEFI_MODELE_GENE + NUME_DDL_GENE + ASSE_MATR_GENE + """ + + from Accas import _F + + # On importe les definitions des commandes a utiliser dans la macro + DEFI_MODELE_GENE = self.get_cmd('DEFI_MODELE_GENE') + NUME_DDL_GENE = self.get_cmd('NUME_DDL_GENE') + ASSE_MATR_GENE = self.get_cmd('ASSE_MATR_GENE') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + self.DeclareOut('modele', RESU_ASSE_SSD['MODELE']) + self.DeclareOut('nugene', RESU_ASSE_SSD['NUME_DDL_GENE']) + if RESU_ASSE_SSD['RIGI_GENE']: + self.DeclareOut('rigidite', RESU_ASSE_SSD['RIGI_GENE']) + if RESU_ASSE_SSD['MASS_GENE']: + self.DeclareOut('masse', RESU_ASSE_SSD['MASS_GENE']) + + modl_gene = {} + mcfact = [] + for i in range(len(SOUS_STRUC)): + arg_sstruc = {} + if SOUS_STRUC[i]['ANGL_NAUT'] : + arg_sstruc['ANGL_NAUT'] = SOUS_STRUC[i]['ANGL_NAUT'] + else: # on impose un angle nul + arg_sstruc['ANGL_NAUT'] = (0.,0.,0.,) + if SOUS_STRUC[i]['TRANS'] : + arg_sstruc['TRANS'] = SOUS_STRUC[i]['TRANS'] + else: # on impose une translation nulle + arg_sstruc['TRANS'] = (0.,0.,0.,) + mcfact.append( _F(NOM = SOUS_STRUC[i]['NOM'], + MACR_ELEM_DYNA = SOUS_STRUC[i]['MACR_ELEM_DYNA'], + **arg_sstruc)) + modl_gene['SOUS_STRUC'] = mcfact + + mcfact = [] + for i in range(len(LIAISON)): + arg_liaison = {} + if LIAISON[i]['GROUP_MA_MAIT_1'] : + arg_liaison['GROUP_MA_MAIT_1'] = LIAISON[i]['GROUP_MA_MAIT_1'] + if LIAISON[i]['MAILLE_MAIT_1'] : + arg_liaison['MAILLE_MAIT_1'] = LIAISON[i]['MAILLE_MAIT_1'] + if LIAISON[i]['GROUP_MA_MAIT_2'] : + arg_liaison['GROUP_MA_MAIT_2'] = LIAISON[i]['GROUP_MA_MAIT_2'] + if LIAISON[i]['MAILLE_MAIT_2'] : + arg_liaison['MAILLE_MAIT_2'] = LIAISON[i]['MAILLE_MAIT_2'] + if LIAISON[i]['OPTION'] : + arg_liaison['OPTION'] = LIAISON[i]['OPTION'] + if arg_liaison['OPTION'] == 'CLASSIQUE' and args['METHODE'] == 'ELIMINE': + print 'ALARME : methode ELIMINE non adaptee a OPTION : ', \ + arg_liaison['OPTION'] + mcfact.append( _F(SOUS_STRUC_1 = LIAISON[i]['SOUS_STRUC_1'], + INTERFACE_1 = LIAISON[i]['INTERFACE_1'], + SOUS_STRUC_2 = LIAISON[i]['SOUS_STRUC_2'], + INTERFACE_2 = LIAISON[i]['INTERFACE_2'], + **arg_liaison)) + modl_gene['LIAISON'] = mcfact + + if VERIF: + mcfact = [] + for i in range(len(VERIF)): + arg_verif = {} + if VERIF[i]['STOP_ERREUR'] : + arg_verif['STOP_ERREUR'] = VERIF[i]['STOP_ERREUR'] + if VERIF[i]['PRECISION'] : + arg_verif['PRECISION'] = VERIF[i]['PRECISION'] + if VERIF[i]['CRITERE'] : + arg_verif['CRITERE'] = VERIF[i]['CRITERE'] + mcfact.append( _F( **arg_verif)) + modl_gene['VERIF'] = mcfact + else: + modl_gene['VERIF'] = None + + modele = DEFI_MODELE_GENE( + SOUS_STRUC = modl_gene['SOUS_STRUC'], + LIAISON = modl_gene['LIAISON'], + VERIF = modl_gene['VERIF'], + ) + + nugene = NUME_DDL_GENE(MODELE_GENE = modele, + METHODE = args['METHODE'], + STOCKAGE = args['STOCKAGE'], + ) + + if RESU_ASSE_SSD['RIGI_GENE']: + rigidite = ASSE_MATR_GENE( NUME_DDL_GENE = nugene, + OPTION = 'RIGI_GENE') + if RESU_ASSE_SSD['MASS_GENE']: + masse = ASSE_MATR_GENE( NUME_DDL_GENE = nugene, + OPTION = 'MASS_GENE') + + return + diff --git a/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py b/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py index 749fa427..e2967d47 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py @@ -1,8 +1,8 @@ -#@ MODIF calc_essai_ops Macro DATE 28/01/2010 AUTEUR BODEL C.BODEL +#@ MODIF calc_essai_ops Macro DATE 14/12/2010 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21,31 +21,24 @@ ## \package calc_essai_ops Implémentation de la macro CALC_ESSAI # # Ce module contient la partie controle de la macro CALC_ESSAI -# l'implémetation de cette macro se trouve dans les modules -# meidee_help, meidee_mac, meidee_massamor, meidee_turbulent -# on utilise aussi une librairie de support -# pour la gestion de l'interface graphique dans meidee_iface +# les autres fichiers sources sont situes dans ../Calc_essai def calc_essai_ops( self, INTERACTIF = None, - #UNITE_FIMEN = None, UNITE_RESU = None, EXPANSION = None, - #MEIDEE_FLUDELA = None, - #MEIDEE_TURBULENT = None, IDENTIFICATION = None, MODIFSTRUCT = None, TRAITEMENTSIG = None, GROUP_NO_CAPTEURS = None, GROUP_NO_EXTERIEUR = None, - #RESU_FLUDELA = None, - #RESU_TURBULENT = None, RESU_IDENTIFICATION = None, RESU_MODIFSTRU = None, **args): + + from Calc_essai.cata_ce import CalcEssaiObjects import aster - from Meidee.meidee_cata import MeideeObjects ier = 0 # La macro compte pour 1 dans la numerotation des commandes @@ -75,60 +68,35 @@ def calc_essai_ops( self, "ComptTable" : 0, "TablesOut" : table_fonction} -## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS -## if not RESU_FLUDELA: -## RESU_FLUDELA = [] -## else: -## for res in RESU_FLUDELA: -## table.append(res['TABLE']) -## out_fludela = {"DeclareOut" : self.DeclareOut, -## "TypeTables" : 'TABLE', -## "ComptTable" : 0, -## "TablesOut" : table} -## -## if not RESU_TURBULENT: -## RESU_TURBULENT = [] -## else: -## for res in RESU_TURBULENT: -## table_fonction.append(res['FONCTION']) -## out_meideeturb = {"DeclareOut" : self.DeclareOut, -## "FoncOut" : table_fonction} # Mode interactif : ouverture d'une fenetre Tk if INTERACTIF == "OUI": aster.onFatalError('EXCEPTION') create_interactive_window(self, - #UNITE_FIMEN, - #out_fludela, - #out_meideeturb, out_identification, out_modifstru, ) else: - from Meidee.meidee_calcul import MessageBox - from Meidee.meidee_test import TestMeidee + from Calc_essai.ce_test import MessageBox + from Calc_essai.ce_test import TestCalcEssai mess = MessageBox(UNITE_RESU) mess.disp_mess("Mode non intéractif") - objects = MeideeObjects(self, mess) + objects = CalcEssaiObjects(self, mess) # importation des concepts aster existants de la memoire jeveux - TestMeidee(self, - mess, - #out_fludela, - #out_meideeturb, - out_identification, - out_modifstru, - objects, - EXPANSION, - #MEIDEE_FLUDELA, - #MEIDEE_TURBULENT, - IDENTIFICATION, - MODIFSTRUCT, - GROUP_NO_CAPTEURS, - GROUP_NO_EXTERIEUR - ) + TestCalcEssai(self, + mess, + out_identification, + out_modifstru, + objects, + EXPANSION, + IDENTIFICATION, + MODIFSTRUCT, + GROUP_NO_CAPTEURS, + GROUP_NO_EXTERIEUR + ) mess.close_file() aster.onFatalError(prev) @@ -136,28 +104,21 @@ def calc_essai_ops( self, -def create_tab_mess_widgets(tk): +def create_tab_mess_widgets(tk,tabskeys): """Construits les objects table et boîte à messages.""" try: from Pmw import PanedWidget except ImportError: PanedWidget = None - from Meidee.meidee_iface import MessageBoxInteractif, TabbedWindow + from Calc_essai.outils_ihm import MessageBoxInteractif, TabbedWindow tabsw = tk msgw = tk tk.rowconfigure(0, weight=2) tk.rowconfigure(1, weight=1) - tabs = TabbedWindow(tabsw, ["Expansion de modeles", - "Modification structurale", - #"MEIDEE mono-modal fludela", - #"MEIDEE mono-modal turbulent", - "Identification de chargement", - "Traitement du signal", - "Parametres de visualisation", - ]) + tabs = TabbedWindow(tabsw, tabskeys) tabs.grid(row=0, column=0, sticky='nsew') # pack(side='top',expand=1,fill='both') @@ -168,23 +129,6 @@ def create_tab_mess_widgets(tk): return tabs, mess -## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS -##def get_fimen_files(UNITE_FIMEN, FIMEN=None): -## """Fichiers fimen éventuels associés aux unités logiques en entrée""" -## # XXX FIMEN is not defined (should it be included in the macro) -## from Utilitai.UniteAster import UniteAster -## fichiers_fimen = [] -## print "FIMEN:", UNITE_FIMEN -## -## if UNITE_FIMEN: -## if type(FIMEN)==int: -## UNITE_FIMEN= [ UNITE_FIMEN ] -## for unit in UNITE_FIMEN: -## UL = UniteAster() -## fichiers_fimen.append( (unit, UL.Nom(unit)) ) -## -## return fichiers_fimen - class FermetureCallback: """Opérations à appliquer lors de la fermeture de la @@ -203,70 +147,60 @@ class FermetureCallback: def create_interactive_window(macro, - #UNITE_FIMEN, - #out_fludela, - #out_meideeturb, out_identification, out_modifstru, ): """Construit la fenêtre interactive comprenant une table pour - les 4 domaines de Meidee.""" + les 4 domaines de CALC_ESSAI.""" from Tkinter import Tk - from Meidee.meidee_cata import MeideeObjects - from Meidee.meidee_correlation import InterfaceCorrelation - from Meidee.meidee_modifstruct import InterfaceModifStruct - from Meidee.meidee_turbulent import InterfaceTurbulent - from Meidee.meidee_parametres import InterfaceParametres - from Meidee.meidee_calc_spec import InterfaceCalcSpec -## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS -## from Meidee.meidee_fludela import InterfaceFludela, InterfaceTurbMonomod + from Calc_essai.cata_ce import CalcEssaiObjects + from Calc_essai.ce_ihm_expansion import InterfaceCorrelation + from Calc_essai.ce_ihm_modifstruct import InterfaceModifStruct + from Calc_essai.ce_ihm_identification import InterfaceIdentification + from Calc_essai.ce_ihm_parametres import InterfaceParametres + from Calc_essai.ce_calc_spec import InterfaceCalcSpec # fenetre principale tk = Tk() - tk.rowconfigure(0, weight=1) - tk.columnconfigure(0,weight=1) tk.title("CALC_ESSAI") + tk.rowconfigure(0,weight=1) + tk.rowconfigure(1,weight=20) + tk.rowconfigure(2,weight=1) - tabs, mess = create_tab_mess_widgets(tk) + tabskeys = ["Expansion de modeles", + "Modification structurale", + "Identification de chargement", + "Traitement du signal", + "Parametres de visualisation" ] + + tabs, mess = create_tab_mess_widgets(tk, tabskeys) main = tabs.root() # importation des concepts aster de la memoire jeveux - objects = MeideeObjects(macro, mess) + objects = CalcEssaiObjects(macro, mess) tabs.set_objects(objects) param_visu = InterfaceParametres(main, mess) - iface = InterfaceCorrelation(main, objects, macro, mess, - param_visu) - imodifstruct = InterfaceModifStruct(main, objects, macro, - mess, out_modifstru, param_visu) - identification = InterfaceTurbulent(main, objects, mess, out_identification, param_visu) - + iface = InterfaceCorrelation(main, objects, macro, mess,param_visu) + imodifstruct = InterfaceModifStruct(main, objects, macro,mess, out_modifstru, param_visu) + identification = InterfaceIdentification(main, objects, mess, out_identification, param_visu) calc_spec= InterfaceCalcSpec(main,objects,mess,param_visu) -## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS -## fludelamonomod = InterfaceFludela(main, objects, -## get_fimen_files(UNITE_FIMEN), mess, out_fludela, param_visu) -## turbmonomod = InterfaceTurbMonomod(main, objects,get_fimen_files(UNITE_FIMEN) ,mess, out_meideeturb, param_visu) - - tabs.set_tab("Expansion de modeles", iface.main) - tabs.set_tab("Modification structurale", imodifstruct.main) - tabs.set_tab("Identification de chargement", identification) - tabs.set_tab("Traitement du signal", calc_spec) - tabs.set_tab("Parametres de visualisation", param_visu) -## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS -## tabs.set_tab("MEIDEE mono-modal fludela", fludelamonomod ) -## tabs.set_tab("MEIDEE mono-modal turbulent", turbmonomod ) - + tabs.set_tab(tabskeys[0], iface.main) + tabs.set_tab(tabskeys[1], imodifstruct.main) + tabs.set_tab(tabskeys[2], identification) + tabs.set_tab(tabskeys[3], calc_spec) + tabs.set_tab(tabskeys[4], param_visu) - tabs.set_current_tab("Expansion de modeles") + tabs.set_current_tab(tabskeys[4]) tk.protocol("WM_DELETE_WINDOW", FermetureCallback(tk, identification).apply) try: tk.mainloop() except : - print "MEIDEE : *ERREUR*" + print "CALC_ESSAI : *ERREUR*" diff --git a/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py index 95a09fff..7d2ac6d1 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py @@ -1,8 +1,8 @@ -#@ MODIF calc_europlexus_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF calc_europlexus_ops Macro DATE 15/02/2011 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -113,10 +113,13 @@ def calc_europlexus_ops(self,MODELE,CARA_ELEM,CHAM_MATER,EXCIT,FONC_PARASOL=None from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme MasquerAlarme('MED_1') MasquerAlarme('MED_54') + MasquerAlarme('MED_77') + MasquerAlarme('MED_37') + # Ligne de commande d'Europlexus if args.has_key('LOGICIEL'): EXEC = args['LOGICIEL'] - else: EXEC = '/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d' + else: EXEC = '/home/europlex/EPXD/bin/europlexus' if debug: print 'args_keys : %s'%args.keys() if args.has_key('PAS_NBRE_COURBE') : if debug: print 'PAS NBRE COURBE = ok (%s)'%args['PAS_NBRE_COURBE'] @@ -168,6 +171,8 @@ def calc_europlexus_ops(self,MODELE,CARA_ELEM,CHAM_MATER,EXCIT,FONC_PARASOL=None # Pour la gestion des alarmes RetablirAlarme('MED_1') RetablirAlarme('MED_54') + RetablirAlarme('MED_77') + RetablirAlarme('MED_37') return ier @@ -1815,7 +1820,7 @@ class EUROPLEXUS: # Dictionnaire permettant de traduire le champ epx en med au nom asscie dans aster # AA epx2aster = {'CONTRAINTE':'SIEF_ELGA','ECROUISSAGE':'VARI_ELGA'} - epx2aster = {'CONTRAINTE':'SIEF_ELGA','DEFORMATION':'EPSI_ELGA_DEPL','ECROUISSAGE':'VARI_ELGA'} + epx2aster = {'CONTRAINTE':'SIEF_ELGA','DEFORMATION':'EPSI_ELGA','ECROUISSAGE':'VARI_ELGA'} # AA : desactive pour le moment # # Enrichir la liste format_med par les champs aux pts de gauss @@ -1842,6 +1847,8 @@ class EUROPLEXUS: fort = 'fort.%i' %unite if os.path.isfile(fort) : os.remove(fort) + if not os.path.isfile(fichier_med): UTMESS('F','PLEXUS_14') + os.symlink(fichier_med,fort) # Regeneration des mots-cles EXCIT passés en argument de la macro @@ -1850,6 +1857,7 @@ class EUROPLEXUS: dExcit.append(j.cree_dict_valeurs(j.mc_liste)) for i in dExcit[-1].keys(): if dExcit[-1][i]==None : del dExcit[-1][i] + resu = LIRE_RESU(TYPE_RESU='EVOL_NOLI', # VERI_ELGA='NON', FORMAT='MED', @@ -2299,7 +2307,7 @@ class EUROPLEXUS: # resu = CREA_RESU(reuse=resu, # OPERATION = 'AFFE', # TYPE_RESU = 'EVOL_NOLI', - # NOM_CHAM = 'EPSI_ELGA_DEPL', + # NOM_CHAM = 'EPSI_ELGA', # AFFE = dicAffe2) resu = CREA_RESU(reuse=resu, OPERATION = 'AFFE', @@ -2316,7 +2324,11 @@ class EUROPLEXUS: def lancer_calcul(self,fichier_med='auto'): fichier_epx = self.nom_fichiers['COMMANDE'] - EXEC_LOGICIEL(LOGICIEL='cd %s ; unset TMPDIR ; %s -usetmpdir %s ; iret=$? ; cd %s ; echo "Code_Retour Europlexus : $iret" ; exit 0' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd), +# EXEC_LOGICIEL(LOGICIEL='cd %s ; unset TMPDIR ; %s -usetmpdir %s ; iret=$? ; cd %s ; echo "Code_Retour Europlexus : $iret" ; exit 0' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd), +# CODE_RETOUR_MAXI=-1, +# INFO=2) + + EXEC_LOGICIEL(LOGICIEL='cd %s ; unset TMPDIR ; unset PMI_RANK ; %s %s ; iret=$? ; cd %s ; echo "Code_Retour Europlexus : $iret" ; exit 0' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd), CODE_RETOUR_MAXI=-1, INFO=2) diff --git a/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py index 7afe34ed..baf97a61 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py @@ -1,8 +1,8 @@ -#@ MODIF calc_fonction_ops Macro DATE 11/10/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF calc_fonction_ops Macro DATE 22/03/2011 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,6 +17,7 @@ # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +# RESPONSABLE COURTOIS M.COURTOIS import os import copy @@ -304,7 +305,7 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP, # construction de la nappe vale_para = l_amor - para = { 'INTERPOL' : ['LIN','LOG'], + para = { 'INTERPOL' : ['LIN', 'LOG'], 'NOM_PARA_FONC' : 'FREQ', 'NOM_PARA' : 'AMOR', 'PROL_DROITE' : 'EXCLU', @@ -372,11 +373,11 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP, if isinstance(__ex,t_fonction) or isinstance(__ex,t_fonction_c): para=__ex.para - if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA - if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU - if PROL_DROITE!=None : para['PROL_DROITE']=PROL_DROITE - if PROL_GAUCHE!=None : para['PROL_GAUCHE']=PROL_GAUCHE - if INTERPOL !=None : para['INTERPOL'] =INTERPOL + if NOM_PARA != None: para['NOM_PARA'] = NOM_PARA + if NOM_RESU != None: para['NOM_RESU'] = NOM_RESU + if PROL_DROITE != None: para['PROL_DROITE'] = PROL_DROITE + if PROL_GAUCHE != None: para['PROL_GAUCHE'] = PROL_GAUCHE + if INTERPOL != None: para['INTERPOL'] = INTERPOL if isinstance(__ex,t_fonction_c): para['VALE_C'] = __ex.tabul() elif isinstance(__ex,t_fonction) : para['VALE'] = __ex.tabul() C_out=DEFI_FONCTION(**para) @@ -385,17 +386,20 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP, for f in __ex.l_fonc : para=f.para def_fonc.append(_F(VALE =f.tabul(), - INTERPOL =f.para['INTERPOL'], - PROL_DROITE=f.para['PROL_DROITE'], - PROL_GAUCHE=f.para['PROL_GAUCHE'],)) + INTERPOL =INTERPOL_FONC or f.para['INTERPOL'], + PROL_DROITE=PROL_DROITE_FONC or f.para['PROL_DROITE'], + PROL_GAUCHE=PROL_GAUCHE_FONC or f.para['PROL_GAUCHE'],)) para=__ex.para - if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA - if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU - if PROL_DROITE !=None : para['PROL_DROITE']=PROL_DROITE - if PROL_GAUCHE !=None : para['PROL_GAUCHE']=PROL_GAUCHE - if NOM_PARA_FONC !=None : para['NOM_PARA_FONC'] =INTERPOL - if INTERPOL_FONC !=None : para['INTERPOL'] =INTERPOL - C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(),DEFI_FONCTION=def_fonc,**para) + if NOM_PARA != None: para['NOM_PARA'] = NOM_PARA + if NOM_RESU != None: para['NOM_RESU'] = NOM_RESU + if PROL_DROITE != None: para['PROL_DROITE'] = PROL_DROITE + if PROL_GAUCHE != None: para['PROL_GAUCHE'] = PROL_GAUCHE + if NOM_PARA_FONC != None: para['NOM_PARA_FONC'] = NOM_PARA_FONC + if INTERPOL != None: para['INTERPOL'] = INTERPOL + print para + C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(), + DEFI_FONCTION=def_fonc, + **para) if INFO > 1: IMPR_FONCTION(FORMAT='TABLEAU', UNITE=6, diff --git a/Aster/Cata/cataSTA10/Macro/calc_ifs_dnl_ops.py b/Aster/Cata/cataSTA10/Macro/calc_ifs_dnl_ops.py new file mode 100644 index 00000000..0794c6a2 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/calc_ifs_dnl_ops.py @@ -0,0 +1,580 @@ +#@ MODIF calc_ifs_dnl_ops Macro DATE 14/02/2011 AUTEUR GREFFET N.GREFFET +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GREFFET N.GREFFET +# +# MACRO DE COUPLAGE IFS AVEC SATURNE VIA YACS +# +import os +def calc_ifs_dnl_ops(self,GROUP_MA_IFS,NOM_CMP_IFS,UNITE_NOEUD,UNITE_ELEM,MODELE,ETAT_INIT,EXCIT,PAS_INIT,**args): + #=================================================================# + # Initialisations # + # --------------------------------------------------------------- # + """ + Corps de la macro CALC_IFS_DNL + """ + ier=0 + import aster + import os,string,types + from Accas import _F + from Utilitai.Table import Table + from Utilitai.Utmess import UTMESS + # from Cata.cata import * + from Cata.cata import EXTR_RESU, DEFI_LIST_ENTI, IMPR_RESU + from SD.sd_maillage import sd_maillage + # + self.set_icmd(1) + #=================================================================# + # Liste des commandes ASTER utilisees # + # --------------------------------------------------------------- # + AFFE_CHAR_MECA=self.get_cmd('AFFE_CHAR_MECA') + DEFI_GROUP =self.get_cmd('DEFI_GROUP') + DEFI_LIST_REEL=self.get_cmd('DEFI_LIST_REEL') + DYNA_NON_LINE=self.get_cmd('DYNA_NON_LINE') + LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE') + PROJ_CHAMP =self.get_cmd('PROJ_CHAMP') + # Operateurs specifiques pour IFS + IMPR_MAIL_YACS =self.get_cmd('IMPR_MAIL_YACS') + ENV_CINE_YACS=self.get_cmd('ENV_CINE_YACS') + MODI_CHAR_YACS =self.get_cmd('MODI_CHAR_YACS') + RECU_PARA_YACS =self.get_cmd('RECU_PARA_YACS') + #=================================================================# + # Gestion des mots cles specifiques a CALC_IFS_DNL # + # --------------------------------------------------------------- # + motscles = {} + poidsMocle = {} + grpRefeMocle = {} + grpProjMocle = {} + ifsCharMocle = {} + tmpListe = [] + ifsCharList = [] + poidsMocle ['VIS_A_VIS'] = [] + grpRefeMocle['CREA_GROUP_NO'] = [] + grpProjMocle['CREA_GROUP_NO'] = [] + ifsCharMocle['GROUP_NO'] = [] + + ifsCharTuple = (GROUP_MA_IFS,) + #print "ifsCharTuple=",ifsCharTuple + ifsCharList = GROUP_MA_IFS + #print "len(ifsCharList)=",len(ifsCharList) + prefix="_" + for j in range(len(ifsCharTuple)): + poidsDico = {} + poidsDico['GROUP_MA_1']= ifsCharTuple[j] + poidsDico['GROUP_NO_2']= 'GN'+str(j+1) + poidsMocle['VIS_A_VIS'].append(poidsDico) + + grpProjDico ={} + grpProjDico['GROUP_MA'] ='GM'+str(j+1) + grpProjDico['NOM'] ='GN'+str(j+1) + grpProjMocle['CREA_GROUP_NO'].append(grpProjDico) + + if (not(ifsCharTuple[j] in tmpListe)): + tmpListe.append(ifsCharTuple[j]) + grpRefeNode = prefix + ifsCharTuple[j] + # ifsCharTuple = ifsCharTuple[1:] + (grpRefeNode,) + + grpRefeDico = {} + grpRefeDico['GROUP_MA'] = ifsCharTuple[j] + grpRefeDico['NOM'] = grpRefeNode + grpRefeMocle['CREA_GROUP_NO'].append(grpRefeDico) + + for j in range(len(tmpListe)): + tmpListe[j] = prefix + tmpListe[j] + ifsCharMocle['GROUP_NO']=tuple(tmpListe) + + for j in range(len(NOM_CMP_IFS)): + if (NOM_CMP_IFS[j] == 'FX'): + ifsCharMocle['FX'] = 0.0 + elif (NOM_CMP_IFS[j] == 'FY'): + ifsCharMocle['FY'] = 0.0 + elif (NOM_CMP_IFS[j] == 'FZ'): + ifsCharMocle['FZ'] = 0.0 + else: + raise AsException("MOT-CLE NON PERMIS : ",NOM_CMP_IFS[j]) + + #=================================================================# + # Gestion des mots cles de DYNA_NON_LINE # + # --------------------------------------------------------------- # + motCleSimpTuple= ('MODELE', + 'CHAM_MATER', + 'MODE_STAT', + 'CARA_ELEM', + 'MASS_DIAG', + 'SENSIBILITE', + 'INFO', + 'TITRE') + +# 'COMP_INCR' =C_COMP_INCR() : dans motCleFactTuple ? + motCleFactTuple= ('EXCIT', + 'EXCIT_GENE', + 'SOUS_STRUC', + 'AMOR_MODAL', + 'PROJ_MODAL', + 'COMP_INCR', + 'COMP_ELAS', + 'ETAT_INIT', + 'SCHEMA_TEMPS', + 'NEWTON', + 'SOLVEUR', + 'RECH_LINEAIRE', + 'PILOTAGE', + 'CONVERGENCE', + 'OBSERVATION', + 'AFFICHAGE', + 'ARCHIVAGE', + 'CRIT_FLAMB', + 'MODE_VIBR') + + for i in range(len(motCleSimpTuple)): + cle = motCleSimpTuple[i] + if args.has_key(cle): + motscles[cle]=args[cle] + + for i in range(len(motCleFactTuple)): + cle = motCleFactTuple[i] + if args.has_key(cle): + if args[cle] != None : + dMotCle=[] + for j in args[cle]: + dMotCle.append(j.cree_dict_valeurs(j.mc_liste)) + for k in dMotCle[-1].keys(): + if dMotCle[-1][k]==None : del dMotCle[-1][k] + motscles[cle]=dMotCle + #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~# + + #===============================# + # INITIALISATION DE LA SD MACRO # + # ----------------------------- # + self.DeclareOut('resdnl',self.sd) + + + #============================================================# + # GENERATION DES GROUPES DE NOEUDS SUR LE MAILLAGE STRUCTURE # + # ---------------------------------------------------------- # + ### on recupere le concept maillage + #print "MODELE=",MODELE + #print "MODELE.strip()=",MODELE.strip() + + iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',MODELE.nom,'MODELE') + _strucMesh = self.get_concept(nom_ma.strip()) + #print "MAILLAGE STRUCTURE=",_strucMesh + #print "DEFI_GROUP MAILLAGE STRUCTURE" + #print "grpRefeMocle=",grpRefeMocle + _strucMesh = DEFI_GROUP(reuse = _strucMesh, + MAILLAGE = _strucMesh, + **grpRefeMocle) + + #=============================================================================# + # RECUPERATION DU MAILLAGE COUPLE POUR LES DEPLACEMENTS (NOEUDS Code_Saturne) # !!! YACS COMMUNICATION !!! + # --------------------------------------------------------------------------- # + print "IMPR_MAIL_YACS MAILLAGE NOEUDS" + IMPR_MAIL_YACS(UNITE_MAILLAGE = UNITE_NOEUD,TYPE_MAILLAGE = 'SOMMET',), + print "LIRE_MAILLAGE MAILLAGE NOEUDS" + _fluidNodeMesh = LIRE_MAILLAGE(UNITE = UNITE_NOEUD) + print "DEFI_GROUP MAILLAGE NOEUDS" + #print "grpProjMocle=",grpProjMocle + _fluidNodeMesh = DEFI_GROUP(reuse = _fluidNodeMesh, + MAILLAGE = _fluidNodeMesh, + **grpProjMocle) + + #====================================================================================# + # RECUPERATION DU MAILLAGE COUPLE POUR LES FORCES (CENTRE DES ELEMENTS Code_Saturne) # !!! YACS COMMUNICATION !!! + # ---------------------------------------------------------------------------------- # + print "IMPR_MAIL_YACS MAILLAGE ELEMENTS" + IMPR_MAIL_YACS(UNITE_MAILLAGE = UNITE_ELEM,TYPE_MAILLAGE = 'MILIEU',) + print "LIRE_MAILLAGE MAILLAGE ELEMENTS" + _fluidElemMesh = LIRE_MAILLAGE(UNITE = UNITE_ELEM) + print "DEFI_GROUP MAILLAGE ELEMENTS" + #print "grpProjMocle=",grpProjMocle + _fluidElemMesh = DEFI_GROUP(reuse = _fluidElemMesh, + MAILLAGE = _fluidElemMesh, + **grpProjMocle) + + #==============================================# + # CALCUL DES PROJECTEURS POUR LES DEPLACEMENTS # + # ASTER -> CODE COUPLE # + # -------------------------------------------- # + print "PROJ_CHAMP MAILLAGE NOEUDS" + #print "MAILLAGE_1=",_strucMesh.nom + #print "MAILLAGE_2=",_fluidNodeMesh.nom + _fluidNodePoids = PROJ_CHAMP(PROJECTION = 'NON', + METHODE = 'COUPLAGE', + MAILLAGE_1 = _strucMesh, + MAILLAGE_2 = _fluidNodeMesh, + **poidsMocle) + + #========================================# + # CALCUL DES PROJECTEURS POUR LES FORCES # + # CODE COUPLE -> ASTER # + # -------------------------------------- # + print "PROJ_CHAMP MAILLAGE ELEMENTS" + #print "MAILLAGE_1=",_strucMesh + #print "MAILLAGE_2=",_fluidElemMesh + _fluidElemPoids = PROJ_CHAMP(PROJECTION = 'NON', + METHODE = 'COUPLAGE', + MAILLAGE_1 = _strucMesh, + MAILLAGE_2 = _fluidElemMesh, + **poidsMocle) + + #====================================================================================# + # CREATION DE LA CARTES DES FORCES NODALES AVEC UNE INITIALISATION DES FORCES A ZERO # + # ---------------------------------------------------------------------------------- # + print "AFFE_CHAR_MECA" + _ifsCharMeca = AFFE_CHAR_MECA(MODELE = MODELE, + FORCE_NODALE = _F(**ifsCharMocle),) + dExcit=[] + if (EXCIT != None): + 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] + dExcit.append(_F(CHARGE=_ifsCharMeca),) + + #====================================# + # ENVOIE DU MAILLAGE INITIAL DEFORME # !!! YACS COMMUNICATION !!! + # ---------------------------------- # + dEtatInit=[] + dExtrInit={} + if (ETAT_INIT != None): + if (ETAT_INIT['DEPL'] != None): + dExtrInit['DEPL']=ETAT_INIT['DEPL'] + if (ETAT_INIT['VITE'] != None): + dExtrInit['VITE']=ETAT_INIT['VITE'] + if (ETAT_INIT['ACCE'] != None): + dExtrInit['ACCE']=ETAT_INIT['ACCE'] + for j in ETAT_INIT: + dEtatInit.append(j.cree_dict_valeurs(j.mc_liste)) + for i in dEtatInit[-1].keys(): + if dEtatInit[-1][i]==None : del dEtatInit[-1][i] + + #======================================# + # RECUPERATION DES DONNEES TEMPORELLES # !!! YACS COMMUNICATION !!! + # ------------------------------------ # + print "Appel initialisation" + + _timeStepAster = PAS_INIT + print "PAS=",_timeStepAster + _timeV = RECU_PARA_YACS(DONNEES = 'INITIALISATION', + PAS = _timeStepAster,) + #print "__timeValues=",_timeV.Valeurs() + _timeValues = _timeV.Valeurs() + _nbTimeStep = int(_timeValues[0]) + +# Ancien nommage +# _timeStep = _timeValues[1] +# _tInitial = _timeValues[2] +# _nbSsIterMax = int(_timeValues[3]) +# _impEnsight = int(_timeValues[4]) +# _PeriodImp = int(_timeValues[5]) +# _StartImp = int(_timeValues[6]) + _nbSsIterMax = int(_timeValues[1]) + _Epsilo = _timeValues[2] + _impEnsight = int(_timeValues[3]) + _PeriodImp = int(_timeValues[4]) + _tInitial = _timeValues[5] + _timeStep = _timeValues[6] + _StartImp = _tInitial + print '_nbTimeStep = ',_nbTimeStep + print '_timeStep = ',_timeStep + print '_tInitial = ',_tInitial + print '_nbSsIterMax = ',_nbSsIterMax + print '_impEnsight = ',_impEnsight + print '_PeriodImp = ',_PeriodImp + print '_StartImp = ',_StartImp + if (_nbSsIterMax == 0): + _nbSsIterMax = 1 + +# _endValue = int(_timeValues[7]) +# _nbTimeStep = _endValue + #print '_nbTimeStep 2 = ',_nbTimeStep + +# Compteur de pas : + _numpas = 1 +# Compteur pour le couplage : CP_ITERATION + _ntcast = 0 +# Compteur de sous-itearation + _SousIterations = 1 + + ticv=[None]*(_nbTimeStep+1) ; + endv=[None]*(_nbTimeStep+1) ; + + +# +# Envoi des donnees initiales si besoin est +# +# print "ENV_CINE_YACS 1" +# ENV_CINE_YACS(ETAT_INIT = dExtrInit, +# MATR_PROJECTION = _fluidNodePoids, +# NUME_ORDRE_YACS = _numpas, +# INST = _tInitial, +# PAS = _timeStep, +# **poidsMocle) +# print "RETOUR ENV_CINE_YACS 1" + + #=================================# + # 1ER PASSAGE POUR L'ETAT INITIAL # + # ------------------------------- # + + # ------------------------------------- # + # CALCUL NON LINEAIRE AVEC ETAT INITIAL # + # ------------------------------------- # + if (_numpas <= _nbTimeStep): + # ---------------------------------- # + # Affectation de l'instant de calcul # + # ---------------------------------- # + print "RECU_PARA_YACS 1" + _tStart = _tInitial + _pastps = RECU_PARA_YACS(DONNEES = 'PAS', + NUME_ORDRE_YACS = _numpas, + INST = _tStart, + PAS = _timeStepAster, + ) + _pastps0 = _pastps.Valeurs() + print "_pastps0[0]=", _pastps0[0] + _timeStep = _pastps0[0] + print "DEFI_LIST_REEL" + _tEnd = _tInitial+_timeStep + print "_tStart=",_tStart," ; _tEnd=",_tEnd + _liste=DEFI_LIST_REEL(DEBUT = _tStart, + INTERVALLE = _F(JUSQU_A = _tEnd, + NOMBRE = 1,),) +# _iter = 1 + _SousIterations = 0 + icv = 0 + while (_SousIterations < _nbSsIterMax): + + # Increment des sous-iterations + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + _SousIterations = _SousIterations + 1 + _ntcast = _ntcast + 1 + + # Reception des forces nodales et projection !!! YACS COMMUNICATION !!! + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + print "MODI_CHAR_YACS" + _ifsCharMeca = MODI_CHAR_YACS(reuse = _ifsCharMeca, + CHAR_MECA = _ifsCharMeca, + MATR_PROJECTION = _fluidElemPoids, + NOM_CMP_IFS = NOM_CMP_IFS, + NUME_ORDRE_YACS = _ntcast, + INST = _tStart, + PAS = _timeStep, + **poidsMocle) + + # Resolution non-lineaire + # ~~~~~~~~~~~~~~~~~~~~~~~ + print "DYNA_NON_LINE NUMPAS=",_numpas + #__rescur=DYNA_NON_LINE( + __rescur=DYNA_NON_LINE( + # ETAT_INIT = dEtatInit, + MODELE = MODELE, + INCREMENT = _F(LIST_INST=_liste,), + EXCIT = dExcit, + **motscles) + # test de convergence + # ~~~~~~~~~~~~~~~~~~~ + _ticv = RECU_PARA_YACS(DONNEES = 'CONVERGENCE', + NUME_ORDRE_YACS = _ntcast, + INST = _tEnd, + PAS = _timeStep,) + __icv = _ticv.Valeurs() + icv = int(__icv[0]) + print "Convergence=",icv + if (icv == 1 or _SousIterations == _nbSsIterMax ): + # Envoi des deplacements + # ~~~~~~~~~~~~~~~~~~~~~~ + print "ENV_CINE_YACS ",_numpas + ENV_CINE_YACS(RESULTAT = _F(RESU = __rescur, + #ENV_CINE_YACS(RESULTAT = _F(RESU = resdnl, + NUME_ORDRE = _numpas), + MATR_PROJECTION = _fluidNodePoids, + NUME_ORDRE_YACS = _ntcast, + INST = _tEnd, + PAS = _timeStep, + **poidsMocle) + + _SousIterations = _nbSsIterMax + print "EXTR_RESU" + resdnl=EXTR_RESU(RESULTAT=__rescur, + ARCHIVAGE=_F(NUME_ORDRE = (0,1),)) + #resdnl = __rescur + +# endv[0] = RECU_PARA_YACS(DONNEES='FIN', +# NUME_ORDRE_YACS = _iter, +# INST = _tEnd, +# PAS = _timeStep,) +# __endv = endv[0].Valeurs() +# _endValue = __endv[0] +# _nbTimeStep = _endValue +# print "FIN=",_endValue + _numpas = _numpas + 1 + + #===============================# + # CALCUL NON-LINEAIRE PAS A PAS # + # ----------------------------- # + while (_numpas <= _nbTimeStep): + + # ------------------ # + # Increment du temps # + # ------------------ # + _tStart = _tStart + _timeStep + _tyacs = _tStart + _timeStep + _pastps = RECU_PARA_YACS(DONNEES = 'PAS', + NUME_ORDRE_YACS = _numpas, + INST = _tyacs, + PAS = _timeStepAster, + ) + _pastps0 = _pastps.Valeurs() + print "_pastps0[0]=", _pastps0[0] + _timeStep = _pastps0[0] + _tEnd = _tStart + _timeStep + print "_tStart=",_tStart," ; _tEnd=",_tEnd + _liste=DEFI_LIST_REEL(DEBUT = _tStart, + INTERVALLE = _F(JUSQU_A = _tEnd, + NOMBRE = 1,),) +# _iter = _iter + 1 + _SousIterations = 0 + icv = 0 + while (_SousIterations < _nbSsIterMax): + + # Increment des sous-iterations + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + _SousIterations = _SousIterations + 1 + _ntcast = _ntcast + 1 + + # Reception des forces nodales et projection !!! YACS COMMUNICATION !!! + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + print "MODI_CHAR_YACS_BOUCLE" + _ifsCharMeca = MODI_CHAR_YACS(reuse = _ifsCharMeca, + CHAR_MECA = _ifsCharMeca, + MATR_PROJECTION = _fluidElemPoids, + NOM_CMP_IFS = NOM_CMP_IFS, + NUME_ORDRE_YACS = _ntcast, + INST = _tStart, + PAS = _timeStep, + **poidsMocle) + + # Resolution non-lineaire + # ~~~~~~~~~~~~~~~~~~~~~~~ + print "DYNA_NON_LINE_BOUCLE" + resdnl=DYNA_NON_LINE(reuse = resdnl, + MODELE = MODELE, + ETAT_INIT = _F(EVOL_NOLI = resdnl,), + INCREMENT = _F(LIST_INST = _liste,), + EXCIT = dExcit, + **motscles) + + + # test de convergence + # ~~~~~~~~~~~~~~~~~~~ + print "CONVERGENCE ",_SousIterations + #icv = cocas_fonctions.CONVERGENCE() + _ticv = RECU_PARA_YACS(DONNEES = 'CONVERGENCE', + NUME_ORDRE_YACS = _ntcast, + INST = _tEnd, + PAS = _timeStep,) + __icv = _ticv.Valeurs() + icv = int(__icv[0]) + print "Convergence=",icv + _ntcat = _ntcast + 1 + if (icv == 1 or _SousIterations == _nbSsIterMax ): + _SousIterations = _nbSsIterMax + # Envoi des deplacements !!! YACS COMMUNICATION !!! + # ~~~~~~~~~~~~~~~~~~~~~~ + print "ENV_CINE_YACS_BOUCLE" + ENV_CINE_YACS(RESULTAT = _F(RESU = resdnl, + NUME_ORDRE = _numpas), + MATR_PROJECTION = _fluidNodePoids, + NUME_ORDRE_YACS = _ntcast, + INST = _tEnd, + PAS = _timeStep, + **poidsMocle) + + else: + _list2=DEFI_LIST_ENTI(DEBUT=0, + INTERVALLE=_F(JUSQU_A = _numpas-1, + PAS = 1,),); + resdnl=EXTR_RESU(RESULTAT = resdnl, + ARCHIVAGE = _F(LIST_ORDRE = _list2,)) + +# endv[_iter] = RECU_PARA_YACS(DONNEES='FIN', +# NUME_ORDRE_YACS = _iter, +# INST = _tEnd, +# PAS = _timeStep,) +# __endv = endv[_iter].Valeurs() +# _endValue = __endv[0] +# _nbTimeStep = _endValue + _numpas = _numpas + 1 + + print "NUMPAS : ",_numpas,"nbTimeStep=",_nbTimeStep + + + + #========================================================================# + # Impression Ensight si demandee # + # (premier et dernier pas d'impression pour coherence avec Code_Saturne) # + # ---------------------------------------------------------------------- # + print "impression ensight : ",_impEnsight + if (_impEnsight == 1): + + impEnsiMocle = {} + impEnsiMocle['INTERVALLE'] = [] + + if (_nbTimeStep < _PeriodImp): + _StartImp = 0 + impEnsiDico = {} + impEnsiDico['JUSQU_A'] = _nbTimeStep + impEnsiDico['PAS'] = 1 + impEnsiMocle['INTERVALLE'].append(impEnsiDico) + elif (_nbTimeStep == _PeriodImp and _nbTimeStep == _StartImp): + _StartImp = 0 + impEnsiDico = {} + impEnsiDico['JUSQU_A'] = _nbTimeStep + impEnsiDico['PAS'] = 1 + impEnsiMocle['INTERVALLE'].append(impEnsiDico) + elif (_PeriodImp == -1): + if (_nbTimeStep == _StartImp): + _StartImp = 0 + impEnsiDico = {} + impEnsiDico['JUSQU_A'] = _nbTimeStep + impEnsiDico['PAS'] = 1 + impEnsiMocle['INTERVALLE'].append(impEnsiDico) + else: + impEnsiDico = {} + _reste = (_nbTimeStep-_StartImp) % _PeriodImp + impEnsiDico['JUSQU_A'] = _nbTimeStep - _reste + impEnsiDico['PAS'] = _PeriodImp + impEnsiMocle['INTERVALLE'].append(impEnsiDico) + if (_reste != 0): + impEnsiDico = {} + impEnsiDico['JUSQU_A'] = _nbTimeStep + impEnsiDico['PAS'] = _reste + impEnsiMocle['INTERVALLE'].append(impEnsiDico) + + print "Liste impEnsiMocle=", impEnsiMocle + _listImp=DEFI_LIST_ENTI(DEBUT = _StartImp, + **impEnsiMocle); + print "Liste impression=", _listImp + IMPR_RESU(FORMAT='ENSIGHT', + RESU=_F(MAILLAGE=_strucMesh, + RESULTAT=resdnl, + LIST_ORDRE=_listImp,),); + + return ier + diff --git a/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py b/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py index bda3c3aa..3eb5034c 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py @@ -1,8 +1,8 @@ -#@ MODIF calc_miss_ops Macro DATE 29/09/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF calc_miss_ops Macro DATE 01/03/2011 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -19,10 +19,12 @@ # ====================================================================== # RESPONSABLE COURTOIS M.COURTOIS +import sys import os +import traceback -def calc_miss_ops(self, OPTION, **kwargs): +def calc_miss_ops(self, **kwargs): """Macro CALC_MISS : Préparation des données et exécution d'un calcul MISS3D """ @@ -39,8 +41,7 @@ def calc_miss_ops(self, OPTION, **kwargs): param = MISS_PARAMETER(initial_dir=os.getcwd(), **kwargs) # création de l'objet CALCUL_MISS_xxx - option_calcul = OPTION["MODULE"] - calcul = CalculMissFactory(option_calcul, self, param) + calcul = CalculMissFactory(self, param) try: calcul.prepare_donnees() @@ -48,4 +49,8 @@ def calc_miss_ops(self, OPTION, **kwargs): calcul.post_traitement() except aster.error, err: UTMESS('F', err.id_message, valk=err.valk, vali=err.vali, valr=err.valr) + except Exception, err: + trace = ''.join(traceback.format_tb(sys.exc_traceback)) + UTMESS('F', 'SUPERVIS2_5', valk=('CALC_MISS', trace, str(err))) + diff --git a/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py index 090b69e6..33d84765 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py @@ -1,8 +1,8 @@ -#@ MODIF calc_precont_ops Macro DATE 23/03/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF calc_precont_ops Macro DATE 21/03/2011 AUTEUR MICHEL S.MICHEL # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -23,8 +23,8 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, CABLE_BP,CABLE_BP_INACTIF, - COMP_INCR,ETAT_INIT,NEWTON,RECH_LINEAIRE, - CONVERGENCE,INCREMENT,SOLVEUR, + COMP_INCR,ETAT_INIT,METHODE, + RECH_LINEAIRE,CONVERGENCE,INCREMENT,SOLVEUR, INFO,TITRE,**args): @@ -69,12 +69,24 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, # 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'] + + +# import pdb ; pdb.set_trace() + __L0 = dIncrement['LIST_INST'] - __L1 = __L0.Valeurs() + from SD.co_listr8 import listr8_sdaster + from SD.co_list_inst import 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: @@ -135,10 +147,18 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, # 1.2 Recuperation des parametres pour STAT_NON_LINE # ------------------------------------------------------- + motscle4={} + motscle5={} - dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste) - for i in dNewton.keys(): - if dNewton[i]==None : del dNewton[i] + if METHODE=='IMPL_EX': + motscle4['IMPL_EX']=args['IMPL_EX'].List_F() + motscle5['IMPL_EX']=args['IMPL_EX'].List_F() + else: + 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(): @@ -351,7 +371,7 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, __EV1 = CALC_NO( reuse = __EV1, RESULTAT = __EV1, - GROUP_MA = __GROUP_MA_A, + # GROUP_MA = __GROUP_MA_A, OPTION = 'FORC_NODA' ) __REA = CREA_CHAMP ( @@ -394,7 +414,7 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, dExcit1.append(_F(CHARGE = _F_CA, FONC_MULT=__FCT ),) - motscle4={} + if self.reuse: motscle4['reuse'] = self.reuse @@ -405,14 +425,14 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, COMP_INCR=dComp_incr0, INCREMENT=dIncrement, ETAT_INIT = dEtatInit, - NEWTON =dNewton, + METHODE=METHODE, CONVERGENCE=dConvergence, RECH_LINEAIRE = dRech_lin, SOLVEUR = dSolveur, ARCHIVAGE = _F(INST = __TINT), INFO =INFO, TITRE = TITRE, - EXCIT = dExcit1, + EXCIT = dExcit1, **motscle4) # Recuperation du dernier numero d'ordre pour pouvoir l'écraser dans RES @@ -437,15 +457,19 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, COMP_INCR=dComp_incr1, INCREMENT=_F(LIST_INST = __LST, PRECISION = __prec), - NEWTON =dNewton, + METHODE=METHODE, +# NEWTON =dNewton, +# IMPL_EX=dImplex, + RECH_LINEAIRE = dRech_lin, CONVERGENCE=dConvergence, SOLVEUR = dSolveur, - ARCHIVAGE = _F(NUME_INIT = __no, + ARCHIVAGE = _F( DETR_NUME_SUIV = 'OUI' ), INFO =INFO, TITRE = TITRE, EXCIT =dExcit2, + **motscle5 ) return ier diff --git a/Aster/Cata/cataSTA10/Macro/crea_elem_ssd_ops.py b/Aster/Cata/cataSTA10/Macro/crea_elem_ssd_ops.py new file mode 100644 index 00000000..8b37f325 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/crea_elem_ssd_ops.py @@ -0,0 +1,265 @@ +#@ MODIF crea_elem_ssd_ops Macro DATE 03/01/2011 AUTEUR ANDRIAM H.ANDRIAMBOLOLONA +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# ====================================================================== + +def crea_elem_ssd_ops(self, NUME_DDL, INTERFACE, BASE_MODALE, + CALC_FREQ, SOLVEUR, **args): + """ + Enchainement des commandes : + CALC_MATR_ELEM + ASSE_MATRICE + MODE_ITER_SIMULT + MODE_STATIQUE + DEFI_INTERF_DYNA + DEFI_BASE_MODALE + MACR_ELEM_DYNA + """ + + from Accas import _F + + # On met le mot cle NUME_DDL dans une variable locale pour le proteger + numeddl=NUME_DDL + + if numeddl: + self.DeclareOut('_nume_ddl', numeddl) + + # 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') + EXTR_MODE = self.get_cmd('EXTR_MODE') + MODE_ITER_SIMULT = self.get_cmd('MODE_ITER_SIMULT') + MODE_STATIQUE = self.get_cmd('MODE_STATIQUE') + DEFI_INTERF_DYNA = self.get_cmd('DEFI_INTERF_DYNA') + DEFI_BASE_MODALE = self.get_cmd('DEFI_BASE_MODALE') + MACR_ELEM_DYNA = self.get_cmd('MACR_ELEM_DYNA') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + mSolveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste) + # SYME ne fait pas partie des mots cles lies a SOLVEUR + # dans MODE_STATIQUE et DEFI_BASE_MODALE + for i in mSolveur.keys(): + if mSolveur[i] == None or i == 'SYME' : + del mSolveur[i] + + _kelem = CALC_MATR_ELEM(CHARGE = args['CHARGE'], + OPTION = 'RIGI_MECA', + CARA_ELEM = args['CARA_ELEM'], + MODELE = args['MODELE'], + CHAM_MATER = args['CHAM_MATER'],) + + __melem = CALC_MATR_ELEM(CHARGE = args['CHARGE'], + OPTION = 'MASS_MECA', + CARA_ELEM = args['CARA_ELEM'], + MODELE = args['MODELE'], + CHAM_MATER = args['CHAM_MATER'],) + + _nume_ddl = NUME_DDL(MATR_RIGI = _kelem, + METHODE = SOLVEUR[0]['METHODE'], + RENUM = SOLVEUR[0]['RENUM'],) + + _matrigi = ASSE_MATRICE(NUME_DDL = _nume_ddl, + MATR_ELEM = _kelem,) + + __mmass = ASSE_MATRICE(NUME_DDL = _nume_ddl, + MATR_ELEM = __melem,) + + # recuperation des options de MODE_ITER_SIMULT (equivalent CALC_MODAL) + motscit = {} + motscfa = {} + + if CALC_FREQ['OPTION'] == 'PLUS_PETITE': + nbande = 1 + + if CALC_FREQ['OPTION'] == 'CENTRE': + nbande = 1 + + if CALC_FREQ['OPTION'] == 'BANDE': + nbande = len(CALC_FREQ['FREQ'])-1 + + motfilt = {} + motfilt['FILTRE_MODE'] = [] + for i in range(nbande): + if CALC_FREQ['OPTION'] == 'PLUS_PETITE': + motscfa['NMAX_FREQ'] = CALC_FREQ['NMAX_FREQ'] + + if CALC_FREQ['OPTION'] == 'CENTRE': + motscfa['FREQ'] = CALC_FREQ['FREQ'] + if CALC_FREQ['AMOR_REDUIT']: + motscfa['AMOR_REDUIT'] = CALC_FREQ['AMOR_REDUIT'] + motscfa['NMAX_FREQ'] = CALC_FREQ['NMAX_FREQ'] + + if CALC_FREQ['OPTION'] == 'BANDE': + motscfa['FREQ'] = (CALC_FREQ['FREQ'][i], CALC_FREQ['FREQ'][i+1]) + + motscit['CALC_FREQ'] = _F(OPTION =CALC_FREQ['OPTION'], + APPROCHE =CALC_FREQ['APPROCHE'], + **motscfa) + + __modes = MODE_ITER_SIMULT(MATR_A = _matrigi, + MATR_B = __mmass, + INFO = args['INFO'], + **motscit) + + motfilt['FILTRE_MODE'].append(_F(MODE=__modes, + TOUT_ORDRE='OUI',),) + + _mode_meca = EXTR_MODE(**motfilt) + + if BASE_MODALE[0]['TYPE'] == 'RITZ': + mcfactc = [] + mcfactm = [] + mcfacti = [] + arg_no = [] + arg_grno = [] + for i in range(len(INTERFACE)): + if BASE_MODALE[0]['NMAX_MODE_INTF']: + if INTERFACE[i]['TYPE'] == 'CRAIGB': + if INTERFACE[i]['NOEUD'] : + if isinstance(INTERFACE[i]['NOEUD'],(list,tuple)): + for noeu in INTERFACE[i]['NOEUD']: + arg_no.append(noeu) + else: + arg_no.append(INTERFACE[i]['NOEUD']) + if INTERFACE[i]['GROUP_NO'] : + if isinstance(INTERFACE[i]['GROUP_NO'],(list,tuple)): + for grno in INTERFACE[i]['GROUP_NO']: + arg_grno.append(grno) + else: + arg_grno.append(INTERFACE[i]['GROUP_NO']) + else: + arg_int = {} + if INTERFACE[i]['NOEUD'] : + arg_int['NOEUD'] = INTERFACE[i]['NOEUD'] + if INTERFACE[i]['GROUP_NO'] : + arg_int['GROUP_NO'] = INTERFACE[i]['GROUP_NO'] + arg_int['TOUT_CMP'] = 'OUI' + if INTERFACE[i]['TYPE'] == 'CRAIGB': + mcfactc.append( _F(**arg_int)) + elif INTERFACE[i]['TYPE'] == 'MNEAL': + mcfactm.append( _F(**arg_int)) + modstatc = {} + modstatm = {} + modstati = {} + lmodint = [] + if mcfactc: + modstatc['MODE_STAT'] = mcfactc + _mode_intf = MODE_STATIQUE(MATR_RIGI = _matrigi, + SOLVEUR = mSolveur, + **modstatc) + lmodint.append(_mode_intf) + if mcfactm: + modstatm['FORCE_NODALE'] = mcfactm + _mode_intf = MODE_STATIQUE(MATR_RIGI = _matrigi, + SOLVEUR = mSolveur, + **modstatm) + lmodint.append(_mode_intf) + if BASE_MODALE[0]['NMAX_MODE_INTF']: + arg_int = {} + if arg_no: + arg_int['NOEUD'] = arg_no + if arg_grno: + arg_int['GROUP_NO'] = arg_grno + arg_int['NBMOD'] = BASE_MODALE[0]['NMAX_MODE_INTF'] + arg_int['TOUT_CMP'] = 'OUI' + mcfacti.append( _F(**arg_int)) + modstati['MODE_INTERF'] = mcfacti + _mode_intf = MODE_STATIQUE(MATR_RIGI = _matrigi, + MATR_MASS = __mmass, + SOLVEUR = mSolveur, + **modstati) + lmodint.append(_mode_intf) + + interface = {} + mcfact = [] + freqnew = None + ifreq = INTERFACE[0]['FREQ'] + for i in range(len(INTERFACE)): + arg_int = {} + if INTERFACE[i]['NOEUD'] : + arg_int['NOEUD'] = INTERFACE[i]['NOEUD'] + if INTERFACE[i]['GROUP_NO'] : + arg_int['GROUP_NO'] = INTERFACE[i]['GROUP_NO'] + mcfact.append( _F(NOM = INTERFACE[i]['NOM'], + TYPE = INTERFACE[i]['TYPE'], + **arg_int)) + ifreq_i = INTERFACE[i]['FREQ'] + if ifreq != ifreq_i: + freqnew = ifreq_i + if freqnew: + UTMESS('A','SOUSTRUC2_12',valr=freqnew) + ifreq = freqnew + interface['INTERFACE'] = mcfact + + if args['INFO']: + interface['INFO'] = args['INFO'] + if ifreq: + interface['FREQ'] = ifreq + + _interf = DEFI_INTERF_DYNA(NUME_DDL = _nume_ddl, + **interface) + + base = {} + if args['INFO']: + base['INFO'] = args['INFO'] + mcfact = [] + + if BASE_MODALE[0]['TYPE'] == 'CLASSIQUE': + arg_base = {} + type_base = 'CLASSIQUE' + arg_base['NMAX_MODE'] = CALC_FREQ[0]['NMAX_FREQ'] + mcfact.append(_F(INTERF_DYNA = _interf, + MODE_MECA = _mode_meca, + **arg_base)) + + if BASE_MODALE[0]['TYPE'] == 'RITZ': + type_base = 'RITZ' + # il faut deux occurrences du mot cle facteur RITZ + arg_base = {} + if CALC_FREQ[0]['OPTION'] == 'PLUS_PETITE' or \ + CALC_FREQ[0]['OPTION'] == 'CENTRE': + arg_base['NMAX_MODE'] = CALC_FREQ[0]['NMAX_FREQ'] + + mcfact.append(_F(MODE_MECA = _mode_meca, + **arg_base)) + + arg_base = {} + if len(lmodint) > 0: # MODE_INTF ou MODE_STATIQUE doit etre a la 2 occ + if BASE_MODALE[0]['NMAX_MODE_INTF']: + arg_base['NMAX_MODE'] = BASE_MODALE[0]['NMAX_MODE_INTF'] + mcfact.append(_F(MODE_INTF = _mode_intf, + **arg_base)) + + if type_base == 'CLASSIQUE': + base['CLASSIQUE'] = mcfact + elif type_base == 'RITZ': + base['RITZ'] = mcfact + base['INTERF_DYNA'] = _interf + base['NUME_REF'] = _nume_ddl + + _base_modale = DEFI_BASE_MODALE( **base) + + elem = {} + elem['MATR_RIGI'] = _matrigi + elem['MATR_MASS'] = __mmass + + self.DeclareOut('macr_elem', self.sd) + macr_elem = MACR_ELEM_DYNA(BASE_MODALE = _base_modale, + **elem) + + return + diff --git a/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py index 761e1177..e182159d 100644 --- a/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py +++ b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py @@ -1,30 +1,30 @@ -#@ MODIF creation_donnees_homard Macro DATE 18/10/2010 AUTEUR GNICOLAS G.NICOLAS +#@ MODIF creation_donnees_homard Macro DATE 11/05/2011 AUTEUR SELLENET N.SELLENET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE GNICOLAS G.NICOLAS """ -Cette classe cree le fichier de configuration permettant de lancer HOMARD +Cette classe crée le fichier de configuration permettant de lancer HOMARD depuis Code_Aster. """ -__revision__ = "V1.7" +__revision__ = "V1.10" __all__ = [ ] - + import os import os.path from types import ListType, TupleType @@ -41,11 +41,11 @@ except ImportError: # ------------------------------------------------------------------------------ class creation_donnees_homard: - """Cette classe cree les donnees permettant de lancer HOMARD depuis Code_Aster. + """Cette classe crée les données permettant de lancer HOMARD depuis Code_Aster. Ce sont : . le fichier de configuration - . le fichier des donnees dans le cas d'information - + . le fichier des données dans le cas d'information + Arguments (stockes en tant qu'attribut) : . nom_macro : nom de la macro-commande qui appelle : 'MACR_ADAP_MAIL' pour une adaptation @@ -55,7 +55,7 @@ class creation_donnees_homard: Attributs : . Nom_Fichier_Configuration : nom du fichier de configuration (immuable) - . Nom_Fichier_Donnees : nom du fichier de donnees (immuable) + . Nom_Fichier_Donnees : nom du fichier de données (immuable) . mode_homard : le mode pour filtrer ici ("ADAP" ou "INFO") . mode_homard_texte : le mode d'utilisation, en francais ("ADAPTATION" ou "INFORMATION") . mailles_incompatibles : que faire des mailles incompatibles avec HOMARD @@ -76,7 +76,7 @@ class creation_donnees_homard: else : UTMESS("F", 'HOMARD0_1') # -# 2. Donnees generales de cette initialisation +# 2. Données generales de cette initialisation # #gn for mot_cle in mots_cles.keys() : #gn print "mots_cles[", mot_cle, "] = ", mots_cles[mot_cle] @@ -105,13 +105,13 @@ class creation_donnees_homard: # ------------------------------------------------------------------------------ def int_to_str2 (self, entier) : """ - Transforme un entier compris entre 0 et 99 en une chaine sur deux caracteres + Transforme un entier positif en une chaine d'au moins deux caracteres """ -# print "\nArguments a l'entree de", __name__, ":", entier +# print "\nArguments à l'entree de", __name__, ":", entier # - try: + if type(entier) == type(0) : la_chaine = '%02d' % entier - except TypeError: + else : la_chaine = None # return la_chaine @@ -124,14 +124,14 @@ class creation_donnees_homard: return # ------------------------------------------------------------------------------ def creation_configuration (self) : - """Cree les donnees necessaires e la configuration + """Cree les données necessaires à la configuration """ # message_erreur = None # while message_erreur is None : # -# 1. Les chaines liees aux numeros d'iteration +# 1. Les chaines liées aux numeros d'iteration # if self.mode_homard == "ADAP" : niter = self.dico_configuration["niter"] @@ -167,7 +167,7 @@ class creation_donnees_homard: self.critere_deraffinement = None self.niveau = [] # -# 4. Le type de bilan : il faut convertir la donnee textuelle en un entier, +# 4. Le type de bilan : il faut convertir la donnée textuelle en un entier, # produit de nombres premiers. # Si rien n'est demande, on met 1. # @@ -188,7 +188,7 @@ class creation_donnees_homard: aux = 0 self.TypeBila = aux # -# 5. Les entrees/sorties au format MED +# 5. Les entrées/sorties au format MED # self.CCNoMN__ = self.dico_configuration["NOM_MED_MAILLAGE_N"] if self.mode_homard == "ADAP" : @@ -198,7 +198,7 @@ class creation_donnees_homard: else : self.CCMaiAnn = None # -# 6. Les entrees/sorties au format HOMARD +# 6. Les entrées/sorties au format HOMARD # if self.mode_homard == "ADAP" : self.fic_homard_niter = "maill." + self.str_niter + ".hom.med" @@ -234,7 +234,7 @@ class creation_donnees_homard: #gn print "... self.TypeRaff = ",self.TypeRaff #gn print "... self.TypeDera = ",self.TypeDera # -# 7.2. L'eventuel seuil de raffinement +# 7.2. L'éventuel seuil de raffinement # if self.TypeRaff == "libre" and self.mots_cles["ADAPTATION"] != "RAFFINEMENT_ZONE" : d_aux = {} @@ -248,7 +248,7 @@ class creation_donnees_homard: self.critere_raffinement = (d_aux[mot_cle][0], aux) #gn print "... self.critere_raffinement = ", self.critere_raffinement # -# 7.3. L'eventuel seuil de deraffinement +# 7.3. L'éventuel seuil de deraffinement # if self.TypeDera == "libre" : d_aux = {} @@ -262,17 +262,29 @@ class creation_donnees_homard: self.critere_deraffinement = (d_aux[mot_cle][0], aux) #gn print "... self.critere_deraffinement = ", self.critere_deraffinement # -# 7.4. Les niveaux extremes +# 7.4. Les profondeurs extremes de raffinement/deraffinement # - for mot_cle in [ "NIVE_MIN", "NIVE_MAX" ] : + saux = " " + for mot_cle in [ "NIVE_MIN", "NIVE_MAX", "DIAM_MIN" ] : if self.mots_cles.has_key(mot_cle) : if self.mots_cles[mot_cle] is not None : if mot_cle == "NIVE_MIN" : aux = "NiveauMi" - else : + elif mot_cle == "NIVE_MAX" : aux = "NiveauMa" + else : + aux = "DiametMi" self.niveau.append((aux, self.mots_cles[mot_cle])) - if len(self.niveau) == 2 : + saux += aux +# + if ( "DiametMi" in saux ) : +#gn print self.mots_cles["DIAM_MIN"] + if self.mots_cles["DIAM_MIN"] < 0 : + message_erreur = "Le diametre mini doit etre strictement positif. "+\ + "La valeur "+str(self.mots_cles["DIAM_MIN"])+" est incorrecte." + break +# + if ( ( "NiveauMi" in saux ) and ( "NiveauMa" in saux ) ) : #gn print self.mots_cles["NIVE_MIN"] #gn print self.mots_cles["NIVE_MAX"] if self.mots_cles["NIVE_MIN"] >= self.mots_cles["NIVE_MAX"] : @@ -280,7 +292,7 @@ class creation_donnees_homard: ", doit etre < au niveau maxi, "+str(self.mots_cles["NIVE_MAX"])+"." break # -# 7.5. Les eventuelles zones de raffinement +# 7.5. Les éventuelles zones de raffinement # if self.dico_configuration.has_key("Zones_raffinement") : iaux = 0 @@ -341,7 +353,7 @@ class creation_donnees_homard: try : os.remove (nomfic) except os.error, codret_partiel : - print "Probleme au remove, erreur numero ", codret_partiel[0], ":", codret_partiel[1] + print "Probleme au remove, erreur numéro ", codret_partiel[0], ":", codret_partiel[1] UTMESS("F", 'HOMARD0_3', valk=nomfic) # fichier = open (nomfic,"w") @@ -380,7 +392,7 @@ class creation_donnees_homard: """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur Arguments : . motcle : le mot-cle HOMARD a ecrire - . valeur : la valeur associee + . valeur : la valeur associée """ # ligne = motcle + " " + str(valeur) + "\n" @@ -392,7 +404,7 @@ class creation_donnees_homard: """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur1 + valeur2 Arguments : . motcle : le mot-cle HOMARD a ecrire - . valeur : la valeur associee + . valeur : la valeur associée """ # ligne = motcle + " " + str(valeur1) + " " + str(valeur2) + "\n" @@ -466,7 +478,7 @@ class creation_donnees_homard: # self.ecrire_ligne_configuration_0("L'indicateur d'erreur") self.ecrire_ligne_configuration_2("CCIndica", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) - self.ecrire_ligne_configuration_2("CCNoChaI", self.dico_configuration["Indicateur"]["NOM_MED"]) + self.ecrire_ligne_configuration_2("CCNoChaI", self.dico_configuration["Indicateur"]["NOM_CHAM_MED"]) if self.dico_configuration["Indicateur"].has_key("COMPOSANTE") : for saux in self.dico_configuration["Indicateur"]["COMPOSANTE"] : self.ecrire_ligne_configuration_2("CCCoChaI", saux) @@ -518,7 +530,7 @@ class creation_donnees_homard: if zone.has_key(aux) : self.ecrire_ligne_configuration_3(dico_zone[aux], iaux, zone[aux]) # -# 5.4. Les niveaux extremes +# 5.4. Les profondeurs extremes de raffinement/deraffinement # for aux in self.niveau : self.ecrire_ligne_configuration_2(aux[0], aux[1]) @@ -554,17 +566,18 @@ class creation_donnees_homard: self.ecrire_ligne_configuration_2("CCNoMAnn", self.CCMaiAnn) self.ecrire_ligne_configuration_2("CCMaiAnn", self.dico_configuration["Fichier_HOMARD_vers_ASTER"]) # -# 6. Les eventuels champs e mettre e jour +# 6. Les eventuels champs a mettre a jour # if self.dico_configuration.has_key("Champs") : - self.ecrire_ligne_configuration_0("Champs e mettre e jour") + self.ecrire_ligne_configuration_0("Champs a mettre e jour") self.ecrire_ligne_configuration_2("CCSolN__", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) self.ecrire_ligne_configuration_2("CCSolNP1", self.dico_configuration["Fichier_HOMARD_vers_ASTER"]) iaux = 0 for maj_champ in self.dico_configuration["Champs"] : iaux = iaux + 1 - self.ecrire_ligne_configuration_0("Mise e jour du champ numero "+str(iaux)) - self.ecrire_ligne_configuration_3("CCChaNom", iaux, maj_champ["NOM_MED"]) + self.ecrire_ligne_configuration_0("Mise a jour du champ numero "+str(iaux)) + self.ecrire_ligne_configuration_3("CCChaNom", iaux, maj_champ["NOM_CHAM_MED"]) + self.ecrire_ligne_configuration_3("CCChaTIn", iaux, maj_champ["TYPE_MAJ"]) if maj_champ.has_key("NUME_ORDRE") : self.ecrire_ligne_configuration_3("CCChaNuO", iaux, maj_champ["NUME_ORDRE"]) self.ecrire_ligne_configuration_3("CCChaPdT", iaux, maj_champ["NUME_ORDRE"]) @@ -595,6 +608,7 @@ class creation_donnees_homard: if self.dico_configuration.has_key("Frontiere_analytique") : SuivFron = SuivFron * 3 dico_frontiere = {} + dico_frontiere["NOM"] = "FANom" dico_frontiere["RAYON"] = "FARayon" dico_frontiere["X_CENTRE"] = "FAXCen" dico_frontiere["Y_CENTRE"] = "FAYCen" @@ -603,25 +617,30 @@ class creation_donnees_homard: dico_frontiere["Y_AXE"] = "FAYAxe" dico_frontiere["Z_AXE"] = "FAZAxe" l_aux = dico_frontiere.keys() - dico_frontiere["GROUP_MA"] = "FAGroupe" + dico_frontiere["FGNomGro"] = "FGNomGro" + dico_frontiere["FGNomFro"] = "FGNomFro" dico_frontiere["TYPE"] = "FAType" dico_frontiere["CYLINDRE"] = 1 dico_frontiere["SPHERE"] = 2 iaux = 0 + kaux = 0 for frontiere in self.dico_configuration["Frontiere_analytique"] : + iaux += 1 + self.ecrire_ligne_configuration_0("Description de la frontiere analytique numero "+str(iaux)) + jaux = dico_frontiere[frontiere["TYPE"]] + self.ecrire_ligne_configuration_3(dico_frontiere["TYPE"], iaux, jaux) + for aux in l_aux : + if frontiere.has_key(aux) : + self.ecrire_ligne_configuration_3(dico_frontiere[aux], iaux, frontiere[aux]) + self.ecrire_ligne_configuration_0("Lien de la frontiere analytique numero "+str(iaux)+" avec les groupes") if not type(frontiere["GROUP_MA"]) in EnumTypes : lt_aux = [ frontiere["GROUP_MA"] ] else : lt_aux = frontiere["GROUP_MA"] for group_ma in lt_aux : - iaux = iaux + 1 - self.ecrire_ligne_configuration_0("Description de la frontiere analytique numero "+str(iaux)) - jaux = dico_frontiere[frontiere["TYPE"]] - self.ecrire_ligne_configuration_3(dico_frontiere["TYPE"], iaux, jaux) - self.ecrire_ligne_configuration_3(dico_frontiere["GROUP_MA"], iaux, group_ma) - for aux in l_aux : - if frontiere.has_key(aux) : - self.ecrire_ligne_configuration_3(dico_frontiere[aux], iaux, frontiere[aux]) + kaux += 1 + self.ecrire_ligne_configuration_3(dico_frontiere["FGNomGro"], kaux, group_ma) + self.ecrire_ligne_configuration_3(dico_frontiere["FGNomFro"], kaux, frontiere["NOM"]) # # 7.3. Activation de la fonction # @@ -637,7 +656,7 @@ class creation_donnees_homard: self.ecrire_ligne_configuration_2("MessInfo", self.MessInfo) if self.dico_configuration["version_perso"] : VERSION_HOMARD = self.dico_configuration["VERSION_HOMARD"] - self.ecrire_ligne_configuration_2("DicoOSGM", "$HOMARD_USER/"+VERSION_HOMARD+"/CONFIG/typobj.stu") + self.ecrire_ligne_configuration_2("DicoOSGM", "$HOMARD_USER/"+VERSION_HOMARD+"/src/CONFIG/typobj.stu") # # 9. L'usage des mailles incompatibles avec HOMARD # @@ -670,7 +689,7 @@ class creation_donnees_homard: return # ------------------------------------------------------------------------------ def ecrire_fichier_donnees (self) : - """Ecrit le fichier des donnees dans le cas d'une demande d'information + """Ecrit le fichier des données dans le cas d'une demande d'information """ message_erreur = None # diff --git a/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py b/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py index 8e5fa7cf..57edffc7 100644 --- a/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py +++ b/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py @@ -1,4 +1,4 @@ -#@ MODIF dyna_iss_vari_ops Macro DATE 18/10/2010 AUTEUR NISTOR I.NISTOR +#@ MODIF dyna_iss_vari_ops Macro DATE 08/12/2010 AUTEUR ZENTNER I.ZENTNER # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -17,11 +17,14 @@ # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== + +# RESPONSABLE ZENTNER I.ZENTNER import os -def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNITE_RESU_FORC, - NB_FREQ, PAS, UNITE_RESU_IMPE, TYPE, MATR_GENE , OPTION,INFO, +def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, UNITE_RESU_FORC, + UNITE_RESU_IMPE, TYPE, MATR_GENE ,INFO, +# NB_FREQ, FREQ_INIT, FREQ_PAS, FREQ_MAX, OPTION, **args): """ Macro DYNA_ISS_VARI @@ -29,37 +32,97 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT ier=0 import numpy as NP from numpy import linalg - import aster + from math import pi, ceil, sqrt, floor, log, tanh + import aster from Accas import _F from Utilitai.Table import Table from Utilitai.Utmess import UTMESS - + + #-------------------------------------------------------------------------------- def get_group_coord(group): """Retourne les coordonnees des noeuds du groupe 'group' """ l_ind = NP.array(coll_grno.get('%-8s' % group, [])) - 1 return NP.take(t_coordo, l_ind, axis=0) - - # On importe les definitions des commandes a utiliser dans la macro - + #-------------------------------------------------------------------------------- + # On importe les definitions des commandes a utiliser dans la macro + # COMB_MATR_ASSE = self.get_cmd('COMB_MATR_ASSE') LIRE_IMPE_MISS = self.get_cmd('LIRE_IMPE_MISS') LIRE_FORC_MISS = self.get_cmd('LIRE_FORC_MISS') COMB_MATR_ASSE = self.get_cmd('COMB_MATR_ASSE') - CREA_CHAMP = self.get_cmd('CREA_CHAMP') DYNA_LINE_HARM = self.get_cmd('DYNA_LINE_HARM') DETRUIRE= self.get_cmd('DETRUIRE') - + + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + CALC_FONCTION = self.get_cmd('CALC_FONCTION') CREA_TABLE = self.get_cmd('CREA_TABLE') - + REST_SPEC_TEMP = self.get_cmd('REST_SPEC_TEMP') + DEFI_LIST_REEL=self.get_cmd('DEFI_LIST_REEL') + # Comptage commandes + declaration concept sortant self.set_icmd(1) - self.DeclareOut('tab_out', self.sd) - macro='DYNA_ISS_VARI' -#-------------------------------------------------------- + macro='DYNA_ISS_VARI' + # Type de résultat + fonc_acce = args['FONC_SIGNAL'] + if fonc_acce !=None: + TYPE_RESU='TRANS' + self.DeclareOut('dyha', self.sd) + else: + TYPE_RESU='SPEC' + self.DeclareOut('tab_out', self.sd) + +#-------------------------------------------------------------------------------- + # -------- DISCRETISATION frequentielle ou temporelle -------- + + if TYPE_RESU=='SPEC': + FREQ_INIT= args['FREQ_INIT'] + NB_FREQ = args['NB_FREQ'] + PAS= args['FREQ_PAS'] + OPTION=args['OPTION'] + + if TYPE_RESU=='TRANS': + tt, vale_s=fonc_acce.Valeurs() + DT=tt[1]-tt[0] + + __foint=CALC_FONCTION( +# __foncaf=CALC_FONCTION( + FFT=_F( FONCTION =fonc_acce , +# METHODE='COMPLET', + METHODE='PROL_ZERO', + ), ); + + vale_fre, vale_re, vale_im =__foint.Valeurs() + NB_FREQ2= len(vale_fre) + PAS=1./(NB_FREQ2*DT) + NB_FREQ= int(floor(len(vale_fre)/2)) #signal nombre impair (floor(N/2)) ou signal nombre pair avec REST_SPEC_TEMP (prend N/2 pour N pair) +# NB_FREQ= int(floor(len(vale_fre)/2)+1) # signal nombre pair: N/2+1 + OMF =1./(2.*DT) + FREQ_INIT=0.0 + + # liste des frequences complete + l_freq_sig=[] + for k in range(NB_FREQ): + freqk=FREQ_INIT+PAS*k + l_freq_sig.append(freqk) + + + FREQ_FIN = args['FREQ_MAX'] + if FREQ_FIN !=None : + assert (FREQ_FIN > (NB_FREQ-1)*PAS), 'FREQ_FIN = ' + str(FREQ_FIN) +' < frequence de coupure: augmenter FREQ_FIN' + PAS = args['FREQ_PAS'] + NB_FREQ = int(ceil(FREQ_FIN/ PAS))+1 + FREQ_INIT =0.0 + +# NB_FREQ=NB_FREQ2 + print '', NB_FREQ, PAS, FREQ_INIT, (NB_FREQ-1)*PAS + # if INFO==2: + # aster.affiche('MESSAGE','DISCRETISATION UTILISATEUR : NB_FREQ, PAS, FREQ_FIN'+str(NB_FREQ)+' ,'+str(PAS)+' ,'+ str(NB_FREQ-1)*PAS)) +#--------------------------------------------------------------------------------------- +# -------------------------------------------------------------------------------------- dgene = MATR_GENE[0].cree_dict_valeurs(MATR_GENE[0].mc_liste) if dgene['MATR_AMOR'] != None: aster.affiche('MESSAGE',' MATR_AMOR existe') @@ -71,9 +134,7 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT ), ); aster.affiche('MESSAGE',' MATR_AMOR pas donnee, on prend AMOR_REDUIT=0.0,') -# dint = INTERF[0].cree_dict_valeurs(INTERF[0].mc_liste) -# dcoh = MATR_COHE[0].cree_dict_valeurs(MATR_COHE[0].mc_liste) - + 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 @@ -86,7 +147,6 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT # MAILLAGE nom_bamo = v_refa_rigi[0] nume_ddl = aster.getvectjev(nom_bamo[0:8] + ' .REFD ' )[3] - print 'nume ddl=',nume_ddl nom_mail = aster.getvectjev( nume_ddl[0:14] + '.NUME.REFN ' )[0] maillage = sd_maillage(nom_mail) # MODELE, DDLGENE @@ -112,14 +172,16 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT GROUP_NO_INTER=INTERF['GROUP_NO_INTERF'] noe_interf = get_group_coord(GROUP_NO_INTER) nbno, nbval = noe_interf.shape + + del nume_ddl, nom_mail, nom_modele if INFO==2: aster.affiche('MESSAGE','NBNO INTERFACE : '+str(nbno)) - # MODES - iret,nbmodt,kbid=aster.dismoi('F','NB_MODES_TOT',nom_bamo,'RESULTAT') - iret,nbmodd,kbid=aster.dismoi('F','NB_MODES_DYN',nom_bamo,'RESULTAT') - iret,nbmods,kbid=aster.dismoi('F','NB_MODES_STA',nom_bamo,'RESULTAT') + # MODES nbmodt2 = MATR_GENE['MATR_RIGI'].DESC.get()[1] + iret,nbmodd,kbid=aster.dismoi('F','NB_MODES_DYN', nom_bamo,'RESULTAT') + iret,nbmods,kbid=aster.dismoi('F','NB_MODES_STA', nom_bamo,'RESULTAT') + iret,nbmodt,kbid=aster.dismoi('F','NB_MODES_TOT',nom_bamo,'RESULTAT') if nbmodt2 != nbmodt: UTMESS('F','ALGORITH5_42') @@ -127,22 +189,47 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT texte = 'NOMBRE DE MODES: '+str(nbmodt)+' MODES DYNAMIQUES: '+str(nbmodd)+' MODES STATIQUES: '+str(nbmods) aster.affiche('MESSAGE',texte) aster.affiche('MESSAGE','COMPOSANTE '+NOM_CMP) - SPEC = NP.zeros((NB_FREQ,nbmodt,nbmodt)) + 1j -# -#--------------------------------------------------------------------- - # BOUCLE SUR LES FREQUENCES + + + if TYPE_RESU=="SPEC": + SPEC = NP.zeros((NB_FREQ,nbmodt,nbmodt))+1j + if TYPE_RESU=="TRANS": + VEC = NP.zeros((NB_FREQ,nbmodt))+1j + abscisse = [None]*NB_FREQ + + # PARAMETRES fonction de cohérence VITE_ONDE = MATR_COHE['VITE_ONDE'] alpha = MATR_COHE['PARA_ALPHA'] - abscisse = [None]*NB_FREQ + +# # PARAMETRE nom_champ +# cham_calc=NOM_CHAM +# print 'NOM_CHAMP ',cham_calc +# if cham_calc=='DEPL': +# ii_cham=1 +# elif cham_calc=='VITE': +# ii_cham=2 +# elif cham_calc=='ACCE': +# ii_cham=3 + + # POUR TRANS, on sort le champ en dépalcement: c'est équivalen du champ en deplacement si on applique un signal en ACCE + cham_calc='DEPL' + ii_cham=1 - for k in range(0,NB_FREQ): - freqk=FREQ_INIT+PAS*k - aster.affiche('MESSAGE','FREQUENCE DE CALCUL: '+str(freqk)) - # Matrice de coherence +#--------------------------------------------------------------------- +#--------------------------------------------------------------------- + # 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)) + +# #--------------------------------------------------------- +# # Matrice de coherence XX=noe_interf[:,0] YY=noe_interf[:,1] - +# +# # ----MITA & LUCO XN=NP.repeat(XX,nbno) YN=NP.repeat(YY,nbno) XR=NP.reshape(XN,(nbno,nbno)) @@ -152,8 +239,26 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT DX=XR-XRT DY=YR-YRT DIST=DX**2+DY**2 - COHE=NP.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.)) + COHE=NP.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.)) + +# #----ABRAHAMSON (EPRI) +# p_a1=1.647 +# p_a2=1.01 +# p_a3=0.4 +# p_n1=7.02 +# # p_n2=1.685 +# COHE=NP.zeros((nbno,nbno)) +# for no1 in range(nbno): +# for no2 in range(nbno): +# dist_xi=sqrt((XX[no1]-XX[no2])**2+(YY[no1]-YY[no2])**2) +# p_n2=5.1-0.51*log(dist_xi+10.) +# pfc=-1.886+2.221*log(4000./(dist_xi+1.)+1.5) +# term1=1.+(freqk*tanh(p_a3*dist_xi)/(p_a1*pfc))**p_n1 +# term2=1.+(freqk*tanh(p_a3*dist_xi)/(p_a2*pfc))**p_n2 +# COHE[no1,no2]=1./sqrt(term1* term2) +# + #--------------------------------------------------------- # On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas aster.matfpe(-1) eig, vec =linalg.eig(COHE) @@ -166,17 +271,15 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT 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(NP.diag(COHE)) + + etot=NP.sum(eig**2) ener=0.0 nbme=0 - - if INFO==2: - aster.affiche('MESSAGE','ETOT :'+str(etot)) while nbme < nbno: - ener= eig[nbme]+ener + ener= eig[nbme]**2+ener prec=ener/etot nbme=nbme+1 if INFO==2: @@ -184,12 +287,13 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT if prec > PRECISION : break - aster.affiche('MESSAGE','NOMBRE DE MODES POD RETENUS : '+str(nbme)) - aster.affiche('MESSAGE','PRECISION (ENERGIE RETENUE) : '+str(prec)) + 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] + PVEC[k1, 0:nbno]=NP.sqrt(eig[k1])*vec[k1] # CALCUL DE FS variable------------------------------- XO=NP.zeros((nbme,nbmods)) if NOM_CMP=='DX': @@ -198,7 +302,6 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT COMP = 2 elif NOM_CMP=='DZ': COMP = 3 - #---------MODES interface # ----- boucle sur les modes statiques for mods in range(0,nbmods): @@ -217,19 +320,20 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT som=NP.sum(MCMP) max1=NP.max(MCMP) min1=NP.min(MCMP) - maxm=NP.max([NP.abs(max1), NP.abs(min1)]) - #CALCUL DE XO + maxm=NP.max([abs(max1),abs(min1)]) + + #-------------CALCUL DE XO ------------- # on recupere la composante COMP (dx,dy,dz) des modes et on projete # CAS 1: MODES DE CORPS RIGIDE if INTERF['MODE_INTERF'] =='CORP_RIGI': for modp in range(0,nbme): #modes de translation if mods+1 <=3: - if NP.abs(som)<10.E-6: + if abs(som)<10.E-6: XO[modp,mods]=0.0 else : fact=1./som - XO[modp,mods]=fact*NP.inner(MCMP,PVEC[modp]) + XO[modp,mods]=fact*abs(NP.inner(MCMP,PVEC[modp])) #modes de rotation else: if maxm<10.E-6: @@ -244,19 +348,18 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT # CAS 2: MODES EF if INTERF['MODE_INTERF'] =='TOUT': for modp in range(0,nbme): - if NP.abs(som)<10.E-6: + if abs(som)<10.E-6: if maxm<10.E-6: XO[modp,mods]=0.0 else: UTMESS('F','UTILITAI5_89') else: fact=1./som - XO[modp,mods]=fact*NP.inner(MCMP,PVEC[modp]) + XO[modp,mods]=fact*abs(NP.inner(MCMP,PVEC[modp])) DETRUIRE(CONCEPT=_F(NOM=(__CHAM)),INFO=1) - #----Impedances etc.----------------------------------------------------------------- - + #----Impedances + force sismique.----------------------------------------------------------------- if k>0: DETRUIRE(CONCEPT=_F(NOM=(__impe,__fosi,__rito)),INFO=1) @@ -273,30 +376,35 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT COEF_C=1.0+0.j,), ), SANS_CMP='LAGR', - ); + ); + + # 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', + NOM_CHAM='DEPL', UNITE_RESU_FORC = UNITE_RESU_FORC, FREQ_EXTR=freqk,); + + # impedance MIMPE=__impe.EXTR_MATR_GENE() # extraction de la partie modes interface KRS = MIMPE[nbmodd:nbmodt,nbmodd:nbmodt] - - # force sismique pour verif -# FS0=__fosi.EXTR_VECT_GENE_C() -# FSE=FS0[nbmodd:nbmodt][:] - SP=NP.zeros((nbmodt,nbmodt)) - for k1 in range(0,nbme): - # calcul de la force sismique mode POD par mode POD - FS = NP.dot(KRS,XO[k1]) + + + if TYPE_RESU=="TRANS": + # force sismique resultante: somme des mode POD + XO_s=NP.sum(XO,0) + FS = NP.dot(KRS,XO_s) Fzero=NP.zeros((1,nbmodd)) FS2=NP.concatenate((Fzero,NP.reshape(FS,(1,nbmods))),1) - # Calcul harmonique - __fosi.RECU_VECT_GENE_C(FS2[0]) - __dyge = DYNA_LINE_HARM(MODELE=modele, + + # Calcul harmonique + __fosi.RECU_VECT_GENE_C(FS2[0]) + __dyge = DYNA_LINE_HARM( + MODELE=modele, MATR_MASS = MATR_GENE['MATR_MASS'], MATR_RIGI = __rito, FREQ = freqk, @@ -304,53 +412,177 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT EXCIT =_F ( VECT_ASSE = __fosi, COEF_MULT= 1.0, ), - ); - # recuperer le vecteur modal depl calcule par dyge + ); + # recuperer le vecteur modal depl calcule par dyge desc = __dyge.DESC.get() - assert desc[0].strip() == 'DEPL', 'Champ DEPL non trouvé' - nomcham = __dyge.TACH.get()[1][0].strip() + assert desc[ii_cham-1].strip() ==cham_calc , 'Champ'+cham_calc+ 'non trouvé' + + nomcham = __dyge.TACH.get()[ii_cham][0].strip() cham = sd_cham_gene(nomcham) - RS = NP.array(cham.VALE.get()) - SP=SP+RS*NP.conj(RS[:,NP.newaxis]) + RS = NP.array(cham.VALE.get()) DETRUIRE(CONCEPT=_F(NOM=(__dyge)),INFO=1) + + + if TYPE_RESU=="SPEC": + SP=NP.zeros((nbmodt,nbmodt)) + for k1 in range(0,nbme): + # calcul de la force sismique mode POD par mode POD + FS = NP.dot(KRS,XO[k1]) + Fzero=NP.zeros((1,nbmodd)) + FS2=NP.concatenate((Fzero,NP.reshape(FS,(1,nbmods))),1) + # Calcul harmonique + __fosi.RECU_VECT_GENE_C(FS2[0]) + __dyge = DYNA_LINE_HARM( + MODELE=modele, + MATR_MASS = MATR_GENE['MATR_MASS'], + MATR_RIGI = __rito, + FREQ = freqk, + MATR_AMOR = __ma_amort, + EXCIT =_F ( VECT_ASSE = __fosi, + COEF_MULT= 1.0, + ), + ); + # recuperer le vecteur modal depl calcule par dyge + desc = __dyge.DESC.get() + assert desc[ii_cham-1].strip() ==cham_calc , 'Champ'+cham_calc+ 'non trouvé' + + nomcham = __dyge.TACH.get()[ii_cham][0].strip() + cham = sd_cham_gene(nomcham) + RS = NP.array(cham.VALE.get()) + DETRUIRE(CONCEPT=_F(NOM=(__dyge)),INFO=1) + # stockage des matrices résultats: sum(s_q s_q* ) + SP=SP+RS*NP.conj(RS[:,NP.newaxis]) + + + +#-------------------------------------------- +# stockage de résultats pour toutes les fréquences calculées + + if TYPE_RESU=="SPEC": #SPEC = (NB_FREQ,nbmodt,nbmodt) + SPEC[k]=SP + if TYPE_RESU=="TRANS": #VEC (NB_FREQ,nbmodt) + VEC[k]=RS + + abscisse[k]= freqk - SPEC[k]=SP +# DETRUIRE(CONCEPT=_F(NOM=(__impe,__fosi,__rito)),INFO=1) - abscisse[k]= freqk +##------------------------------------------------------------------------------------------------------------------------- +##-------------------------------------------------------------------------------------------------------------------------- +# Creation des sorties : table_fonction pour SPEC ou dyna_trans pour TRANS +#-------------------------------------------------------------------------------------------------------------------------- +#- + aster.affiche('MESSAGE','TYPE_RESU : '+TYPE_RESU) ##--------------------------------------------------------------------- -# Ecriture des tables +# Si SPEC: Ecriture des tables #--------------------------------------------------------------------- + if TYPE_RESU=='SPEC': + # ------ CREATION DE L OBJET TABLE - tab = Table() - tab.append({'NOM_CHAM' : 'DSP', 'OPTION' : 'TOUT', 'DIMENSION' : nbmodt}) - for k2 in range(nbmodt): - if OPTION =='DIAG' : # on ecrit uniquement les termes diagonaux (autospectres) de la matrice - foncc=[] - for k in range(NB_FREQ) : - foncc.append(abscisse[k]) - foncc.append(SPEC[k][k2,k2].real) - foncc.append(SPEC[k][k2,k2].imag) - _f = DEFI_FONCTION(NOM_PARA='FREQ', - NOM_RESU='SPEC', - VALE_C = foncc ) - # Ajout d'une ligne dans la Table - tab.append({'NUME_ORDRE_I' : k2+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom}) - - else: # on ecrit tout - for k1 in range(k2+1): + tab = Table() + tab.append({'NOM_CHAM' : 'DSP', 'OPTION' : 'TOUT', 'DIMENSION' : nbmodt}) + for k2 in range(nbmodt): + if OPTION =='DIAG' : # on ecrit uniquement les termes diagonaux (autospectres) de la matrice foncc=[] for k in range(NB_FREQ) : - foncc.append(abscisse[k]) - foncc.append(SPEC[k][k1,k2].real) - foncc.append(SPEC[k][k1,k2].imag) + foncc.append(abscisse[k]) + foncc.append(SPEC[k][k2,k2].real) + foncc.append(SPEC[k][k2,k2].imag) _f = DEFI_FONCTION(NOM_PARA='FREQ', + NOM_RESU='SPEC', + VALE_C = foncc ) + # Ajout d'une ligne dans la Table + tab.append({'NUME_ORDRE_I' : k2+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom}) + + else: # on ecrit tout + for k1 in range(k2+1): + foncc=[] + for k in range(NB_FREQ) : + foncc.append(abscisse[k]) + foncc.append(SPEC[k][k1,k2].real) + foncc.append(SPEC[k][k1,k2].imag) + _f = DEFI_FONCTION(NOM_PARA='FREQ', NOM_RESU='SPEC', VALE_C = foncc ) # Ajout d'une ligne dans la Table - tab.append({'NUME_ORDRE_I' : k1+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom}) + tab.append({'NUME_ORDRE_I' : k1+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom}) # Creation du concept en sortie - dict_keywords = tab.dict_CREA_TABLE() - tab_out = CREA_TABLE(TYPE_TABLE='TABLE_FONCTION', + dict_keywords = tab.dict_CREA_TABLE() + tab_out = CREA_TABLE(TYPE_TABLE='TABLE_FONCTION', **dict_keywords) + +#- +##--------------------------------------------------------------------- +# Si TRANS: Ecriture de tran_gene +#--------------------------------------------------------------------- +# 1) on cree un concept harm_gene (factice) et le remplit a l'aide de putvectjev avec les bonnes valeurs, +# 2) On interpole les valeurs non calculés (l_freq_sig) +# 3) puis on fait la FFT pour obtenir le signal temporel + + elif TYPE_RESU=='TRANS': + + __lfre = DEFI_LIST_REEL( VALE = list(l_freq_sig), ) ; +# print ' creation SD DYNA_LINE_HARM' + # on cree la SD resultat - factice (le champ ACCE sera remplace dans la suit par celui calcule) + __dyge0 = DYNA_LINE_HARM( + MODELE=modele, + MATR_MASS = MATR_GENE['MATR_MASS'], + MATR_RIGI = __rito, + LIST_FREQ= __lfre, #tuple(l_freq_sig), + MATR_AMOR = __ma_amort, + EXCIT =_F ( VECT_ASSE = __fosi, + COEF_MULT_C=1., + ), + ); + +# ATTENTION: on sort le champ en dépalcement: c'est équivalent au champ en acceleration car on a applique un signal en ACCE pour fosi en acce + # # cela evite de diviser pr w2 pour intégrer l'acceleration (erreurs numeriques au point 0) + # # on remplace donc le champ en acceleration + cham_calc='ACCE' + ii_cham=3 + +# print ' putvectjev' +# si tous les point on été calculés: pas d'interpolation + if FREQ_FIN ==None : + for k,freqk in enumerate(l_freq_sig): + coef_a=(vale_re[k]+vale_im[k]*1.j) + VEC_comp=VEC[k]*coef_a + nomcham = __dyge0.TACH.get()[ii_cham][k].strip() + tup_re=tuple(VEC_comp.real) + tup_im=tuple(VEC_comp.imag) + aster.putvectjev( nomcham + '.VALE ', nbmodt,tuple(range(1,nbmodt+1)),tup_re,tup_im,1 ) + + else: + + for k,freqk in enumerate(l_freq_sig): + coef_a=(vale_re[k]+vale_im[k]*1.j) + # ------------ interpolation du vecteur POD VEC (NB_FREQ, nbmodt) + vale_i=NP.searchsorted(abscisse, freqk) +# print freqk, vale_i, abscisse[vale_i-1], abscisse[vale_i] + if vale_i ==0: + VEC_comp=VEC[0]*coef_a + VEC_real=VEC_comp.real + VEC_imag=VEC_comp.imag + else: + dfp=(freqk-abscisse[vale_i-1])/(abscisse[vale_i]-abscisse[vale_i-1]) + VEC_comp=(VEC[vale_i-1]+dfp*(VEC[vale_i]-VEC[vale_i-1]))*coef_a + VEC_real=VEC_comp.real + VEC_imag=VEC_comp.imag + nomcham = __dyge0.TACH.get()[ii_cham][k].strip() + tup_re=tuple(VEC_real) + tup_im=tuple(VEC_imag) + aster.putvectjev( nomcham + '.VALE ', nbmodt,tuple(range(1,nbmodt+1)),tup_re,tup_im,1 ) + + + print 'REST_SPEC_TEMP' + + dyha= REST_SPEC_TEMP( RESU_GENE = __dyge0 , +# METHODE = 'PROL_ZERO' , + SYMETRIE = 'NON' , # signal non symmétrique: a completer +# SYMETRIE = 'OUI' , # pas de prolongation + NOM_CHAM = 'ACCE' ); + + + return ier diff --git a/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py b/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py index f22b7551..1f81cdbe 100644 --- a/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py +++ b/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py @@ -1,8 +1,8 @@ -#@ MODIF exec_logiciel_ops Macro DATE 15/03/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF exec_logiciel_ops Macro DATE 15/03/2011 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -24,11 +24,71 @@ import os import os.path as osp import traceback import shutil +import tempfile from types import ListType, TupleType EnumTypes = (ListType, TupleType) +cmd_ssh = "%(ssh)s -p %(port)s -o BatchMode=yes -o ConnectTimeout=2 -o ChallengeResponseAuthentication=yes -o PasswordAuthentication=no -o StrictHostKeyChecking=no %(user_machine)s '%(cmd)s'" +cmd_scp = "%(scp)s -P %(port)s -o BatchMode=yes -o ConnectTimeout=2 -o ChallengeResponseAuthentication=yes -o PasswordAuthentication=no -o StrictHostKeyChecking=no %(src)s %(dst)s" + +#cmd_ssh = "%(ssh)s -p %(port)s %(user_machine)s '%(cmd)s'" +#cmd_scp = "%(scp)s -P %(port)s %(src)s %(dst)s" + +exe_ssh = 'ssh' +exe_scp = 'scp' + +tmpdir = '/tmp' + +debug = False + +# ------------------------------------------------------------------------------ +def ExecCommand_SSH(scmd, alt_comment='', verbose=False, separated_stderr=True): + """ Lance une commande distante via SSH + Recupere les differents problemes liés à SSH + """ + import aster + from Utilitai.Utmess import UTMESS + from Utilitai.System import ExecCommand + + iret, output, error = ExecCommand(scmd, alt_comment, verbose=False, separated_stderr=True) + + if debug: + print 'scmd=', scmd + print 'iret=', iret + print 'output=', output + print 'error=', error + + if iret != 0: + # on dump l'output et l'error + UTMESS('I', 'EXECLOGICIEL0_8', valk=scmd, print_as='E') + UTMESS('I', 'EXECLOGICIEL0_9', valk=output, print_as='E') + UTMESS('I', 'EXECLOGICIEL0_10', valk=error, print_as='E') + + # Probleme de cle SSH + if error.find("Permission denied")!=-1: + UTMESS('F', 'EXECLOGICIEL0_14', valk=scmd) + + # Probleme d'adresse IP ou de hostname + elif error.find("Name or service not known")!=-1: + UTMESS('F', 'EXECLOGICIEL0_15', valk=scmd) + + # Probleme de port SSH + elif error.find("Connection refused")!=-1: + UTMESS('F', 'EXECLOGICIEL0_16', valk=scmd) + + # Probleme d'acces au logiciel/script distant + elif error.find("Aucun fichier ou dossier de ce type")!=-1: + UTMESS('F', 'EXECLOGICIEL0_17', valk=scmd) + + # Autre probleme non determinable + else: + UTMESS('F', 'EXECLOGICIEL0_18', valk=scmd) + + return iret, output, error + + # ------------------------------------------------------------------------------ -def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO, **args): +def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MACHINE_DISTANTE, MAILLAGE, SALOME, CODE_RETOUR_MAXI, INFO, **args): """ Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions, colonnes de table... @@ -39,11 +99,13 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO from Utilitai.Utmess import UTMESS from Utilitai.System import ExecCommand from Utilitai.UniteAster import UniteAster - + from Stanley.salomeRunScript import MakeTempScript, DelTempScript, RunScript + from Noyau.N_types import is_enum + PRE_GMSH = self.get_cmd("PRE_GMSH") PRE_GIBI = self.get_cmd("PRE_GIBI") LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE") - + ier=0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) @@ -57,51 +119,247 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO # paramètres nécessaires pour écrire la ligne de commande # !! d_para['options'] est une liste !! d_para = {'prog' : '', 'options' : ''} - + l_args = [] if ARGUMENT != None: l_args = ARGUMENT[:] if type(l_args) not in EnumTypes: l_args = [l_args,] - + + + #---------------------------------------------- + # 0. Prepare les parametres dans le cas d'une execution sur une machine distante + + if MACHINE_DISTANTE != None: + mcf = MACHINE_DISTANTE[0] + dMCF = mcf.cree_dict_valeurs(mcf.mc_liste) + else: + dMCF = {'SSH_ADRESSE': 'localhost', 'SSH_PORT': 22} + + + #---------------------------------------------- + # 0. Prepare les parametres dans le cas d'une execution SALOME + if SALOME != None: + mcf = SALOME[0] + dMCFS = mcf.cree_dict_valeurs(mcf.mc_liste) + + # Cas ou SALOME_HOST est different de SSH_ADRESSE ou que MACHINE_DISTANTE / SSH_ADRESSE n'est pas defini + if not dMCFS['SALOME_HOST'] in [ 'localhost', dMCF['SSH_ADRESSE'] ]: + MACHINE_DISTANTE = True + dMCF['SSH_ADRESSE'] = dMCFS['SALOME_HOST'] + if dMCFS['SALOME_HOST'] != dMCF['SSH_ADRESSE']: + UTMESS('A','EXECLOGICIEL0_22') + + + #---------------------------------------------- + # 0. Prepare les parametres dans le cas d'une execution sur une machine distante + if MACHINE_DISTANTE != None: + + if dMCF.has_key('SSH_LOGIN') and dMCF['SSH_LOGIN'] != None: user_machine = '%s@%s' % (dMCF['SSH_LOGIN'], dMCF['SSH_ADRESSE']) + else: user_machine = '%s' % dMCF['SSH_ADRESSE'] + + if dMCF.has_key('SSH_PORT') and dMCF['SSH_PORT'] != None: port = dMCF['SSH_PORT'] + else: port = None + + #---------------------------------------------- # 1. Préparation des données # 1.1. EXEC_LOGICIEL standard - if MAILLAGE == None: + if MAILLAGE == None and SALOME == None: mode_lancement = CMD_EXTERNE cmd = '%(prog)s %(options)s' - + # 1.2. Cas "lancement d'un mailleur" - else: + elif MAILLAGE != None: mcf = MAILLAGE[0] dMCF = mcf.cree_dict_valeurs(mcf.mc_liste) d_para['fichIN'] = 'fort.%d' % dMCF['UNITE_GEOM'] d_para['fichOUT'] = 'fort.%d' % dMCF['UNITE'] if osp.exists(d_para['fichOUT']): os.remove(d_para['fichOUT']) - + if dMCF['FORMAT'] == 'GMSH': mode_lancement = CMD_EXTERNE cmd = '%(prog)s %(options)s -o %(fichOUT)s %(fichIN)s' d_para['prog'] = osp.join(aster.repout(), 'gmsh') d_para['options'] = ('-3',) - + elif dMCF['FORMAT'] == 'GIBI': mode_lancement = CMD_EXTERNE cmd = '%(prog)s %(options)s %(fichIN)s %(fichOUT)s' d_para['prog'] = osp.join(aster.repout(), 'gibi') - + elif dMCF['FORMAT'] == 'SALOME': mode_lancement = EXECFILE if len(l_args) < 1: UTMESS('F','EXECLOGICIEL0_1') else: d_para['fichMED'] = l_args[0] - + + + # Cas "lancement d'un script salome" + elif SALOME != None: + mode_lancement = CMD_EXTERNE + cmd = '%(prog)s %(options)s' + + mcf = SALOME[0] + dMCF = mcf.cree_dict_valeurs(mcf.mc_liste) + #print dMCF + + # Mot-cles + if dMCF.has_key('FICHIERS_ENTREE') and dMCF['FICHIERS_ENTREE'] != None: FICHIERS_ENTREE = dMCF['FICHIERS_ENTREE'] + else: FICHIERS_ENTREE = [] + + if dMCF.has_key('FICHIERS_SORTIE') and dMCF['FICHIERS_SORTIE'] != None: FICHIERS_SORTIE = dMCF['FICHIERS_SORTIE'] + else: FICHIERS_SORTIE = [] + + if dMCF.has_key('SALOME_RUNAPPLI') and dMCF['SALOME_RUNAPPLI'] != None: RUNAPPLI = dMCF['SALOME_RUNAPPLI'] + else: RUNAPPLI = os.path.join( aster.repout(), 'runSalomeScript' ) + + if MACHINE_DISTANTE is None: + if dMCF['SALOME_HOST']: RUNAPPLI += ' -m %s ' % dMCF['SALOME_HOST'] + + if dMCF['SALOME_PORT']: RUNAPPLI += ' -p %s ' % dMCF['SALOME_PORT'] + + # Chemin du script + if dMCF.has_key('CHEMIN_SCRIPT') and dMCF['CHEMIN_SCRIPT'] != None: CHEMIN_SCRIPT = dMCF['CHEMIN_SCRIPT'] + elif dMCF.has_key('UNITE_SCRIPT') and dMCF['UNITE_SCRIPT'] != None: CHEMIN_SCRIPT = 'fort.%s' % dMCF['UNITE_SCRIPT'] + else: CHEMIN_SCRIPT = '' + + + # dic = Dictionnaire a passer pour la creation du script temporaire + dic = { 'SALOMESCRIPT': CHEMIN_SCRIPT } + + + # Parametres a remplacer dans le script + if dMCF.has_key('NOM_PARA') and dMCF['NOM_PARA'] != None: NOM_PARA = dMCF['NOM_PARA'] + else: NOM_PARA = [] + if dMCF.has_key('VALE') and dMCF['VALE'] != None: VALE = dMCF['VALE'] + else: VALE = [] + if len(NOM_PARA) != len(VALE): UTMESS('F', 'EXECLOGICIEL0_23') + + for i in range(len(NOM_PARA)): + dic[ NOM_PARA[i] ] = VALE[i] + + + # Changement en liste s'il n'y a qu'un seul element + if (not is_enum(FICHIERS_ENTREE)): + FICHIERS_ENTREE = [FICHIERS_ENTREE,] + if (not is_enum(FICHIERS_SORTIE)): + FICHIERS_SORTIE = [FICHIERS_SORTIE,] + + + # On regenere des noms temporaires dans le repertoire temporaire distant + if MACHINE_DISTANTE != None: + FICHIERS_ENTREE_DIST = [] + FICHIERS_SORTIE_DIST = [] + + for i in range(len(FICHIERS_ENTREE)): + if MACHINE_DISTANTE != None: + fw = tempfile.NamedTemporaryFile(mode='w', suffix='.salome_input') + fname = os.path.join(tmpdir, os.path.basename(fw.name)) + fw.close() + FICHIERS_ENTREE_DIST.append( fname ) + else: + fname = FICHIERS_ENTREE[i] + #dic['INPUTFILE%s' % str(i+1)] = os.path.normpath(os.path.abspath(os.path.realpath(fname))) + dic['INPUTFILE%s' % str(i+1)] = fname + + for i in range(len(FICHIERS_SORTIE)): + if MACHINE_DISTANTE != None: + fw = tempfile.NamedTemporaryFile(mode='w', suffix='.salome_output') + fname = os.path.join(tmpdir, os.path.basename(fw.name)) + fw.close() + FICHIERS_SORTIE_DIST.append( fname ) + else: + fname = FICHIERS_SORTIE[i] + #dic['OUTPUTFILE%s' % str(i+1)] = os.path.normpath(os.path.abspath(os.path.realpath(fname))) + dic['OUTPUTFILE%s' % str(i+1)] = fname + + + # Creation du script de de la commande a executer + CHEMIN_SCRIPT = MakeTempScript( **dic ) + + # Ligne de commande + cmd_salome = [] + + if MACHINE_DISTANTE != None: + + # on recopie le script sur le serveur distant + d_scp = { 'scp': exe_scp, + 'port': port, + 'src': CHEMIN_SCRIPT, + 'dst': '%s:%s/' % (user_machine, tmpdir), + } + cmd_salome.append( cmd_scp % d_scp ) + + # Recopie les fichiers d'entrée sur le serveur distant + for i in range(len(FICHIERS_ENTREE)): + fsrc = FICHIERS_ENTREE[i] + fdst = FICHIERS_ENTREE_DIST[i] + d_scp = { 'scp': exe_scp, + 'port': port, + 'src': fsrc, + 'dst': '%s:%s' % (user_machine, fdst), + } + cmd_salome.append( cmd_scp % d_scp ) + + + # Execution du script + d_ssh = { 'ssh': exe_ssh, + 'user_machine': user_machine, + 'port': port, + 'cmd': '%s %s' % (RUNAPPLI, os.path.join(tmpdir, os.path.basename(CHEMIN_SCRIPT)) ), + } + cmd_salome.append( cmd_ssh % d_ssh ) + + + # Recopie des fichiers de sortie depuis le serveur distant + for i in range(len(FICHIERS_SORTIE)): + fsrc = FICHIERS_SORTIE_DIST[i] + fdst = FICHIERS_SORTIE[i] + d_scp = { 'scp': exe_scp, + 'port': port, + 'src': '%s:%s' % (user_machine, fsrc), + 'dst': fdst, + } + cmd_salome.append( cmd_scp % d_scp ) + + + # Effacement des fichiers distants + lst_src = [ os.path.join( tmpdir, os.path.basename(CHEMIN_SCRIPT) ) ] + if FICHIERS_ENTREE_DIST: lst_src.extend( FICHIERS_ENTREE_DIST ) + if FICHIERS_SORTIE_DIST: lst_src.extend( FICHIERS_SORTIE_DIST ) + + #print lst_src + d_ssh['cmd'] = ' '.join([ 'if [ -f "%s" ]; then \\rm %s; fi ; ' % (f,f) for f in lst_src ]) + cmd_salome.append( cmd_ssh % d_ssh ) + + else: - UTMESS('F', 'EXECLOGICIEL0_2', valk=dMCF['FORMAT']) + if not debug: cmd_salome.append( '%s %s ; if [ -f "%s" ]; then \\rm %s; fi ; ' % (RUNAPPLI, CHEMIN_SCRIPT, CHEMIN_SCRIPT, CHEMIN_SCRIPT) ) + else: cmd_salome.append( '%s %s ' % (RUNAPPLI, CHEMIN_SCRIPT) ) + + + if INFO>=2: + UTMESS('I', 'EXECLOGICIEL0_21', valk='\n\n'.join(cmd_salome)) + + f=open(CHEMIN_SCRIPT, 'r') + txt=f.read() + f.close() + UTMESS('I', 'EXECLOGICIEL0_20', valk=txt) + + + d_para['prog'] = ' ; ' .join(cmd_salome) + + + + #---------------------------------------------- + # Pas prevu.. + else: + UTMESS('F', 'EXECLOGICIEL0_2', valk=dMCF['FORMAT']) + - #---------------------------------------------- # 2. lecture des mots-clés if LOGICIEL != None: @@ -110,14 +368,48 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO if len(l_args) > 0: d_para['options'] = l_args d_para['options'] = ' '.join(d_para['options']) - + + #---------------------------------------------- # 3. Exécution # 3a. Lancement d'une commande externe if mode_lancement == CMD_EXTERNE: - scmd = cmd % d_para + + # Traite le cas d'une execution sur une machine distante + if MACHINE_DISTANTE != None: + + # Construit le dictionnaire des parametres de la ligne de commande SSH + d_ssh = { 'ssh': exe_ssh, + 'user_machine': user_machine, + 'port': port, + } + + # Teste la connection via SSH (remplace la commande par un pwd) + d_ssh['cmd'] = 'pwd' + scmd = cmd_ssh % d_ssh + ExecCommand_SSH(scmd) + + # Construit la commande SSH a partir de la commande initiale + if SALOME: + scmd = cmd % d_para # La commande Salome integre deja le SSH + else: + d_ssh['cmd'] = cmd % d_para + scmd = cmd_ssh % d_ssh # On encapsule la commande dans un SSH + + else: + scmd = cmd % d_para + + + # Lancement de la commande comment = "Lancement de la commande :\n%s" % scmd - iret, output, error = ExecCommand(scmd, alt_comment=comment, verbose=False, separated_stderr=True) + if debug: print comment + + if MACHINE_DISTANTE != None: +# iret, output, error = ExecCommand_SSH(scmd, alt_comment=comment, verbose=False, separated_stderr=True) # bizarrement les output/error ne suivent pas! + iret, output, error = ExecCommand(scmd, alt_comment=comment, verbose=False, separated_stderr=True) + else: + iret, output, error = ExecCommand(scmd, alt_comment=comment, verbose=False, separated_stderr=True) + erreur = iret > CODE_RETOUR_MAXI if CODE_RETOUR_MAXI == -1: erreur = False @@ -125,15 +417,16 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO if INFO > 0 or erreur: UTMESS('I', 'EXECLOGICIEL0_11', vali=(iret, CODE_RETOUR_MAXI)) UTMESS('I', 'EXECLOGICIEL0_9', valk=output) - + # en cas d'erreur, on dump tout dans le .resu + .erre if INFO == 2 or erreur: UTMESS('I', 'EXECLOGICIEL0_8', valk=scmd, print_as='E') UTMESS('I', 'EXECLOGICIEL0_10', valk=error, print_as='E') - + if erreur: UTMESS('F', 'EXECLOGICIEL0_3', vali=[CODE_RETOUR_MAXI, iret]) - + + #---------------------------------------------- # 3b. Exécution d'un fichier Python elif mode_lancement == EXECFILE: diff --git a/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py index 99000615..0bb940e1 100644 --- a/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py +++ b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py @@ -1,8 +1,8 @@ -#@ MODIF lire_fonction_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF lire_fonction_ops Macro DATE 22/03/2011 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17,6 +17,7 @@ # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +# RESPONSABLE COURTOIS M.COURTOIS import os.path as osp import numpy diff --git a/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py b/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py index 708dfef4..64d3f4da 100644 --- a/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py +++ b/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py @@ -1,8 +1,8 @@ -#@ MODIF lire_inte_spec_ops Macro DATE 26/03/2008 AUTEUR BODEL C.BODEL +#@ MODIF lire_inte_spec_ops Macro DATE 14/12/2010 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -145,7 +145,7 @@ def lire_inte_spec_ops(self, # Verification a posteriori de la dimension de l'inter-spectre tmp = 0.5*(-1+sqrt(1+8*len(l_fonc))) dim = int(tmp) - nb_fonc = 0.5*dim*(dim+1) + nb_fonc = dim*(dim+1)/2 if dim != tmp : UTMESS('F', 'SPECTRAL0_6') diff --git a/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py index 0ff39ac1..7578438b 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py @@ -1,28 +1,28 @@ -#@ MODIF macr_adap_mail_ops Macro DATE 04/10/2010 AUTEUR GNICOLAS G.NICOLAS +#@ MODIF macr_adap_mail_ops Macro DATE 11/05/2011 AUTEUR SELLENET N.SELLENET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE GNICOLAS G.NICOLAS # """ Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL """ -__revision__ = "V1.4" +__revision__ = "V1.6" # def macr_adap_mail_ops ( self, INFO, VERSION_HOMARD, MAILLAGE_FRONTIERE, @@ -46,14 +46,14 @@ def macr_adap_mail_ops ( self, # 2. Les caracteristiques d'un passage sont conservees dans un dictionnaire. Il y a autant de # dictionnaires que de sollicitations pour une serie d'adaptation. L'ensemble de ces dictionnaires # est conserve dans la liste Liste_Passages. Cette liste est necessairement globale pour pouvoir -# la retrouver e chaque nouveau passage. +# la retrouver a chaque nouveau passage. # Description du dictionnaire de passages : # dico["Maillage_0"] = o ; string ; nom du concept du maillage initial de la serie d'adaptation # dico["Maillage_NP1"] = o ; string ; nom du concept du dernier maillage adapte # dico["Rep_Calc_HOMARD_global"] = o ; string ; Nom global du repertoire de calcul pour HOMARD # dico["Rep_Calc_HOMARD_local"] = o ; string ; Nom local du repertoire de calcul pour HOMARD # depuis le repertoire de calcul pour ASTER -# dico["niter"] = o ; entier ; numero d'iteration +# dico["niter"] = o ; entier ; numero d'iteration de depart # # 3. Les caracteristiques d'un maillage sont conservees dans un dictionnaire. Il y a autant de # dictionnaires que de maillages manipules. L'ensemble de ces dictionnaires est conserve @@ -72,13 +72,13 @@ def macr_adap_mail_ops ( self, # dico["RESULTAT"] = f ; concept ASTER du resutat associe # dico["NOM_CHAM"] = f ; string ; Nom ASTER du champ # dico["CHAM_GD"] = f ; concept ASTER du champ de grandeur associee -# dico["COMPOSANTE"] = f ; liste ; Liste des noms ASTER des composante de l'indicateur +# dico["COMPOSANTE"] = f ; liste ; Liste des noms ASTER des composantes du champ # dico["NUME_ORDRE"] = f ; entier ; Numero d'ordre du champ # dico["INST"] = f ; entier ; Instant du champ # dico["PRECISION"] = f ; entier ; Precision sur l'instant du champ # dico["CRITERE"] = f ; entier ; Critere de precision sur l'instant du champ # dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpole sur le nouveau maillage -# dico["NOM_MED"] = o ; string ; Nom MED du champ +# dico["NOM_CHAM_MED"] = o ; string ; Nom MED du champ # dico["SENSIBILITE"] = f ; string ; Nom du parametre sensible associe # # 5. Signification de INFO @@ -90,16 +90,20 @@ def macr_adap_mail_ops ( self, # 2nd niveau de message pour l'execution de HOMARD # from Accas import _F - from Macro import creation_donnees_homard + from Macro import creation_donnees_homard from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme - import aster + import aster import string import os + import cPickle + from glob import glob + import tarfile from types import ListType, TupleType EnumTypes = (ListType, TupleType) #gn import shutil # global Liste_Passages + global numero_passage_fonction # #==================================================================== # 1. Prealables @@ -109,15 +113,64 @@ def macr_adap_mail_ops ( self, # self.set_icmd(1) # -# 1.2. ==> Numero du passage dans cette macro +# 1.2. ==> Initialisations de parametres Aster +# + repertoire_outils = aster.repout() + Rep_Calc_ASTER = os.getcwd() + if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER) +# +# Remarque : le nom pick.homard.tar est obligatoire car ASTK rapatrie dans la base tous les fichiers en pick.* + fichier_archive = os.path.join(Rep_Calc_ASTER, "pick.homard.tar") +#gn print "fichier_archive = ",fichier_archive +# +# 1.3. ==> Numero du passage dans cette macro # try : - self.jdc.indice_macro_homard = self.jdc.indice_macro_homard + 1 + numero_passage_fonction = numero_passage_fonction + 1 except : - self.jdc.indice_macro_homard = 1 + numero_passage_fonction = 1 +#gn print "numero_passage_fonction = ",numero_passage_fonction +# +# 1.4. ==> Au tout premier passage +# + if numero_passage_fonction == 1 : +# Liste_Passages = [] - numero_passage_fonction = self.jdc.indice_macro_homard -### print "numero_passage_fonction = ",numero_passage_fonction +# +# 1.4.2. ==> Avec un fichier de reprise : on recupere les repertoires archives +# + if os.path.isfile(fichier_archive) : +# +# Extraction de l'archive +# Remarque : a partir de python 2.5 on pourra utiliser extractall + if ( INFO >= 3 ) : print "Extraction de l'archive", fichier_archive + file = tarfile.open(fichier_archive, "r") + for tarinfo in file : + if ( INFO >= 3 ) : print tarinfo.name, "is", tarinfo.size, "bytes in size and is", + if tarinfo.isreg(): + if ( INFO >= 3 ) : print "a regular file." + file.extract(tarinfo.name) + elif tarinfo.isdir(): + if ( INFO >= 3 ) : print "a directory." + file.extract(tarinfo.name) + else: + if ( INFO >= 3 ) : print "something else." + if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER) +# Liste de tous les repertoires d'adaptation qui ont ete recuperes + laux = glob("*_ADAP_*") +# On prend le fichier pickle du 1er repertoire (ce sont tous les memes), +# puis on recupere la liste des passages + fic = os.path.join(Rep_Calc_ASTER, laux[0], "pick.1") + file = open(fic, "r") + laux = cPickle.load(file) + file.close() +# Pour chaque cas, mise a jour du repertoire global + for dico in laux : + Rep_Calc_HOMARD_local = dico["Rep_Calc_HOMARD_local"] + dico["Rep_Calc_HOMARD_global"] = os.path.join(Rep_Calc_ASTER, Rep_Calc_HOMARD_local) + Liste_Passages.append(dico) +# + if ( INFO >= 3 ) : print "Liste_Passages = ", Liste_Passages # # 1.3. ==> On importe les definitions des commandes a utiliser dans la macro # @@ -127,15 +180,11 @@ def macr_adap_mail_ops ( self, LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE") LIRE_CHAMP = self.get_cmd("LIRE_CHAMP") # -# 1.4. ==> Le nom du programme HOMARD a lancer -# - repertoire_outils = aster.repout() - homard = repertoire_outils + "homard" -# # 1.5. ==> Initialisations # codret_partiel = [0] - Rep_Calc_ASTER = os.getcwd() +# + homard = repertoire_outils + "homard" # liste_maillages = [] liste_champs = [] @@ -167,7 +216,6 @@ def macr_adap_mail_ops ( self, # 2.1.1. ==> Les concepts "maillage" # #gn print "\n.. Debut de 2.1.1" -# for mot_cle in ["MAILLAGE_N" , "MAILLAGE_NP1"] : for mot_cle in ["MAILLAGE_N" , "MAILLAGE_NP1" , "MAILLAGE_NP1_ANNEXE"] : #gn print "\nmot_cle = ",mot_cle dico = {} @@ -184,7 +232,7 @@ def macr_adap_mail_ops ( self, #gn print "dico = ",dico liste_maillages.append(dico) # -# 2.1.2. ==> L'eventuel indicateur d'erreur +# 2.1.2. ==> L'eventuel pilotage de l'adaptation # #gn print "\n.. Debut de 2.1.2" #gn print "args = ", args @@ -192,11 +240,8 @@ def macr_adap_mail_ops ( self, dico = {} dico["Type_Champ"] = "INDICATEUR" if ( args["RESULTAT_N"] != None ) : - lresu = 1 dico["RESULTAT"] = args["RESULTAT_N"] - noresu = dico["RESULTAT"].nom dico["NOM_CHAM"] = args["NOM_CHAM"] - nomsym = dico["NOM_CHAM"] if ( args["NUME_ORDRE"] != None ) : dico["NUME_ORDRE"] = args["NUME_ORDRE"] if ( args["INST"] != None ) : @@ -207,19 +252,13 @@ def macr_adap_mail_ops ( self, if ( args["SENSIBILITE"] != None ) : dico["SENSIBILITE"] = args["SENSIBILITE"] else : - lresu = 0 dico["CHAM_GD"] = args["CHAM_GD"] - noresu = dico["CHAM_GD"].nom - nomsym = " " #gn print "dico = ", dico # - if dico.has_key("SENSIBILITE") : - nopase = dico["SENSIBILITE"].nom - else : - nopase = " " -#gn print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase - dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase ) -#gn print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"] + nom_cham_med_fichier = "champ_de_pilotage" +# 12345678901234567890123456789012 + dico["NOM_CHAM_MED"] = nom_cham_med_fichier +#gn print "==> dico[\"NOM_CHAM_MED\"] = ", dico["NOM_CHAM_MED"] # if args.has_key("NOM_CMP") : if args["NOM_CMP"] is not None : @@ -237,7 +276,6 @@ def macr_adap_mail_ops ( self, ### print dico # # 2.1.3. ==> Les champs a mettre a jour -# #gn print "\n.. Debut de 2.1.3." # if args.has_key("MAJ_CHAM") : @@ -247,15 +285,19 @@ def macr_adap_mail_ops ( self, else : les_champs = args["MAJ_CHAM"] # + dico_interp = {} + dico_interp["AUTO"] = 0 + dico_interp["ISOP2"] = 3 +# + iaux = 0 for maj_cham in les_champs : -#gn print maj_cham +#gn print "maj_cham :", maj_cham #gn print type(maj_cham) # dico = {} dico["Type_Champ"] = "CHAMP_MAJ" l_aux = [ "CHAM_MAJ", "TYPE_CHAM" ] if ( maj_cham["RESULTAT"] != None ) : - lresu = 1 l_aux.append("RESULTAT") l_aux.append("NOM_CHAM") if ( maj_cham["NUME_ORDRE"] != None ) : @@ -265,28 +307,37 @@ def macr_adap_mail_ops ( self, for cle in [ "PRECISION", "CRITERE" ] : if ( maj_cham[cle] != None ) : dico[cle] = maj_cham[cle] - noresu = maj_cham["RESULTAT"].nom - nomsym = maj_cham["NOM_CHAM"] if ( maj_cham["SENSIBILITE"] != None ) : dico["SENSIBILITE"] = maj_cham["SENSIBILITE"] else : - lresu = 0 l_aux.append("CHAM_GD") - noresu = maj_cham["CHAM_GD"].nom - nomsym = " " for cle in l_aux : dico[cle] = maj_cham[cle] #gn print "dico = ", dico # - if dico.has_key("SENSIBILITE") : - nopase = dico["SENSIBILITE"].nom - else : - nopase = " " -#gn print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase - dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase ) -#gn print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"] + if maj_cham["NOM_CMP"] is not None : + if not type(maj_cham["NOM_CMP"]) in EnumTypes : + l_aux = [maj_cham["NOM_CMP"]] + else : + l_aux = [] + les_composantes = maj_cham["NOM_CMP"] + for composante in les_composantes : + l_aux.append(composante) + dico["COMPOSANTE"] = l_aux +#gn print "COMPOSANTEmaj_cham", dico["COMPOSANTE"] # -### print dico +#gn print "dico = ", dico + iaux += 1 + la_chaine = '%08d' % iaux + nom_cham_med_fichier = "champ_" + la_chaine +# 123456789012345678901234 56789012 + dico["NOM_CHAM_MED"] = nom_cham_med_fichier +#gn print "==> dico[\"NOM_CHAM_MED\"] = ", dico["NOM_CHAM_MED"] +# + dico["TYPE_MAJ"] = dico_interp[maj_cham["TYPE_MAJ"]] +#gn print "==> dico[\"TYPE_MAJ\"] = ", dico["TYPE_MAJ"] +# +#gn print "dico :", dico liste_champs.append(dico) # # 2.1.4. ==> Les zones de raffinement @@ -300,8 +351,7 @@ def macr_adap_mail_ops ( self, les_zones = args["ZONE"] # for zone in les_zones : -### print zone -### print type(zone) +### print zone, "de type", type(zone) dico = {} for aux in l_aux : if ( zone[aux] != None ) : @@ -348,7 +398,7 @@ def macr_adap_mail_ops ( self, les_front_analytiques = args["FRONTIERE_ANALYTIQUE"] # for frontiere in les_front_analytiques : - l_aux = [ "TYPE", "GROUP_MA", "RAYON", "X_CENTRE", "Y_CENTRE", "Z_CENTRE"] + l_aux = [ "NOM", "TYPE", "GROUP_MA", "RAYON", "X_CENTRE", "Y_CENTRE", "Z_CENTRE"] if ( frontiere["TYPE"] == "CYLINDRE" ) : l_aux.append("X_AXE") l_aux.append("Y_AXE") @@ -389,7 +439,6 @@ def macr_adap_mail_ops ( self, UTMESS('I','HOMARD0_6') else : UTMESS('A','HOMARD0_7') -# UTMESS('I','HOMARD0_6',valk='glop') # #==================================================================== # 3. Preparation du lancement des commandes @@ -399,7 +448,7 @@ def macr_adap_mail_ops ( self, # . Memorisation des noms ASTER du maillage en entree et en sortie (sous forme string) # # On cree une nouvelle liste des dictionnaires decrivant les maillages -# et e la fin on ecrase l'ancienne liste par cette nouvelle. +# et a la fin on ecrase l'ancienne liste par cette nouvelle. # #gn print "\n.. Debut de 3.1." # @@ -446,6 +495,7 @@ def macr_adap_mail_ops ( self, # le cas, cela veut dire que l'adaptation en cours est la suite d'une # precedente. On doit donc utiliser le meme repertoire. Le numero # d'iteration est celui de l'adaptation precedente augmente de 1. +# Si on n'a rien trouve, c'est que l'on demarre un nouveau cas. # #gn print "\.. Debut de 3.2.2.1." # @@ -459,16 +509,20 @@ def macr_adap_mail_ops ( self, # #gn print "\.. Debut de 3.2.2.2." # -# 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure +# 3.2.2.2.1. ==> Enregistrement d'un nouveau cas +# On emet une alarme si il existe deja un cas pour etre certain +# que l'utilisateur ne s'est pas trompe dans l'enchainement # if ( niter == 0 ) : + for dico in Liste_Passages : + UTMESS("A", 'HOMARD0_9', valk=(Nom_Concept_Maillage_N, Nom_Concept_Maillage_NP1, dico["Maillage_NP1"], dico["Maillage_0"]), vali=dico["niter"]+1 ) dico = {} - dico["Maillage_0"] = Nom_Concept_Maillage_N - dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1 - dico["Maillage_NP1_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE + dico["Maillage_0"] = Nom_Concept_Maillage_N + dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1 + dico["Maillage_NP1_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE dico["Rep_Calc_HOMARD_local"] = Rep_Calc_HOMARD_local dico["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global - dico["niter"] = niter + dico["niter"] = niter Liste_Passages.append(dico) # # 3.2.2.2.2. ==> Modification du cas en cours @@ -477,16 +531,20 @@ def macr_adap_mail_ops ( self, l_aux = [] for dico in Liste_Passages : if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) : - dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1 + dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1 dico["Maillage_NP1_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE - dico["niter"] = niter + dico["niter"] = niter l_aux.append(dico) - Liste_Passages = l_aux + Liste_Passages = [] + for dico in l_aux : + Liste_Passages.append(dico) +# +#gn print "Apres 3.2.2.2. Liste_Passages = ", Liste_Passages # ### print "niter = ", niter, ", Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global # -# 3.2.3. Creation du repertoire pour homard -# attention : on ne fait cette creation qu'une seule fois par cas +# 3.2.3. Le repertoire pour homard +# Attention : on ne fait cette creation qu'une seule fois par cas # d'adaptation ou d'information # #gn print "\.. Debut de 3.2.3." @@ -498,6 +556,11 @@ def macr_adap_mail_ops ( self, except os.error,codret_partiel : self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) UTMESS("F", 'HOMARD0_4', valk=Rep_Calc_HOMARD_global) +# + else : +# + if not os.path.isdir(Rep_Calc_HOMARD_global) : + UTMESS("F", 'HOMARD0_8', valk=Rep_Calc_HOMARD_global) # #==================================================================== # 4. Ecriture des commandes de creation des donnees MED @@ -506,20 +569,20 @@ def macr_adap_mail_ops ( self, #gn print "\.. Debut de 4." # # On doit ecrire : le maillage, -# le champ d'indicateur d'erreur -# les champs e convertir +# le champ de pilotage de l'adaptation +# les champs a convertir # Remarque : on met tout dans le meme fichier # # Chacune de ces ecritures est optionnelle selon le contexte. # # 4.1. ==> Noms des fichiers d'ASTER vers HOMARD et eventuellement de HOMARD vers ASTER -# Remarque : aujourd'hui, les ecritures ou les lectures au format MED se font obligatoirement sur -# un fichier de nom fort.n, place dans le repertoire de calcul +# Remarque : aujourd'hui, les ecritures ou les lectures au format MED se font obligatoirement +# dans un fichier de nom fort.n, place dans le repertoire de calcul ## # 4.1.1. ==> D'ASTER vers HOMARD # unite_fichier_aster_vers_homard = 1787 + 2*numero_passage_fonction - fichier_aster_vers_homard = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_aster_vers_homard)) + fichier_aster_vers_homard = os.path.join(Rep_Calc_ASTER, "fort." + str(unite_fichier_aster_vers_homard)) ### print "fichier_aster_vers_homard = ",fichier_aster_vers_homard # # 4.1.2. ==> De HOMARD vers ASTER @@ -552,33 +615,31 @@ def macr_adap_mail_ops ( self, motscfa["RESU"] = _F( INFO_MAILLAGE=infomail, **motscsi ) # - IMPR_RESU ( INFO = infocomm, + IMPR_RESU ( INFO = infocomm, FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard, **motscfa ) # # 4.4. Le(s) champ(s) -# Attention : il se peut que l'on demande la mise a jour du champ qui a servi comme -# indicateur d'erreur. Si c'est le cas, il ne faut pas demander son +# Attention : il se peut que l'on demande la mise à jour du champ qui a servi comme +# pilotage de l'adaptation. Si c'est le cas, il ne faut pas demander son # impression sinon il y a plantage d'IMPR_RESU qui ne sait pas substituer # deux champs. D'ailleurs, c'est plus economique ainsi ! -# Remarque : pour l'adaptation, on peut ne demander qu'un nombre reduit de composante du -# champ d'indicateur. -# s'il y a demande de mise a jour, toutes les composantes sont concernees. Il faut -# donc dans ce cas imprimer le champ total. +# Remarque : pour l'adaptation ou les champs a mettre a jour, on peut ne demander +# qu'un nombre reduit de composantes. # dico["Type_Champ"] = o ; string ; "INDICATEUR" ou "CHAMP_MAJ" # dico["RESULTAT"] = f ; concept ASTER du resutat associe # dico["NOM_CHAM"] = f ; string ; Nom ASTER du champ # dico["CHAM_GD"] = f ; concept ASTER du champ de grandeur associee -# dico["COMPOSANTE"] = f ; liste ; Liste des noms ASTER des composante de l'indicateur +# dico["COMPOSANTE"] = f ; liste ; Liste des noms ASTER des composante du champ # dico["NUME_ORDRE"] = f ; entier ; Numero d'ordre du champ # dico["INST"] = f ; entier ; Instant du champ # dico["PRECISION"] = f ; entier ; Precision sur l'instant du champ # dico["CRITERE"] = f ; entier ; Critere de precision sur l'instant du champ # dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpole sur le nouveau maillage -# dico["NOM_MED"] = o ; string ; Nom MED du champ +# dico["NOM_CHAM_MED"] = o ; string ; Nom MED du champ # dico["SENSIBILITE"] = f ; string ; Nom du parametre sensible associe # -# 4.4.1. Recherche d'un doublon eventuel sur le champ d'indicateur d'erreur +# 4.4.1. Recherche d'un doublon eventuel sur le champ de pilotage de l'adaptation # #gn print "dico_indi = ",dico_indi if len(dico_indi) > 0 : @@ -595,11 +656,11 @@ def macr_adap_mail_ops ( self, # liste_champs_imprime = [] for dico in liste_champs : -### print "\n.... dico = ",dico -# Pour un champ e mettre e jour, on a toujours impression +#gn print "\n.... dico = ",dico +# Pour un champ a mettre a jour, on a toujours impression if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : liste_champs_imprime.append(dico) -# Si le champ d'indicateur n'a toujours pas ete repere comme champ e mettre e jour : +# Si le champ de pilotage de l'adaptation n'a toujours pas ete repere comme champ a mettre a jour : if not indic_est_deja_imprime : # Est-ce le meme champ ? on_a_le_champ = 1 @@ -636,11 +697,14 @@ def macr_adap_mail_ops ( self, if ( dico_indi[cle] != dico[cle] ) : on_a_le_champ = 0 break +# Le champ de pilotage fait partie des champs mis a jour : on le note +# et on utilise le meme nom de champ MED if on_a_le_champ : + dico_indi["NOM_CHAM_MED"] = dico["NOM_CHAM_MED"] indic_est_deja_imprime = 1 -### print "\n\nFin de la boucle .. indic_est_deja_imprime = ",indic_est_deja_imprime -# Si le champ d'indicateur n'a pas ete repere comme champ e mettre e jour, il faut -# l'inclure dans les champs e imprimer +#gn print "\n\nFin de la boucle .. indic_est_deja_imprime = ",indic_est_deja_imprime +# Si le champ de pilotage de l'adaptation n'a pas ete repere comme champ a mettre a jour, +# il faut l'inclure dans les champs e imprimer if not indic_est_deja_imprime : liste_champs_imprime.append(dico_indi) # @@ -649,7 +713,7 @@ def macr_adap_mail_ops ( self, # for dico in liste_champs_imprime : motscsi = {} - for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] : + for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE", "NOM_CHAM_MED" ] : if dico.has_key(cle) : if ( dico[cle] != None ) : motscsi[cle] = dico[cle] @@ -666,7 +730,7 @@ def macr_adap_mail_ops ( self, ) #gn print ".. motscfa = ",motscfa # - IMPR_RESU ( INFO = infocomm, + IMPR_RESU ( INFO = infocomm, FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard, **motscfa ) # @@ -702,12 +766,12 @@ def macr_adap_mail_ops ( self, dico_configuration[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"] #gn print dico_configuration # -# 5.3. ==> Les caracteristiques de l'eventuel indicateur d'erreur +# 5.3. ==> Les caracteristiques de l'eventuel pilotage de l'adaptation # for dico in liste_champs : dico_aux = {} if ( dico["Type_Champ"] == "INDICATEUR" ) : - l_aux = [ "NOM_MED" ] + l_aux = [ "NOM_CHAM_MED" ] if dico.has_key("COMPOSANTE") : l_aux.append("COMPOSANTE") if dico.has_key("NUME_ORDRE") : @@ -733,13 +797,13 @@ def macr_adap_mail_ops ( self, ### if dico_configuration.has_key("Zones_raffinement") : ### print "dico_configuration[Zones_raffinement] = ", dico_configuration["Zones_raffinement"] # -# 5.5. ==> La mise a jour de champs +# 5.5. ==> Les eventuelles mises a jour de champs # prem = 1 for dico in liste_champs : dico_aux = {} if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : - l_aux = [ "NOM_MED", "COMPOSANTE" ] + l_aux = [ "NOM_CHAM_MED", "COMPOSANTE", "TYPE_MAJ" ] if dico.has_key("NUME_ORDRE") : l_aux.append("NUME_ORDRE") else : @@ -789,7 +853,6 @@ def macr_adap_mail_ops ( self, # 5.8. ==> Impression eventuelle des fichiers crees # #gn print "Repertoire ",Rep_Calc_HOMARD_global -#gn os.system("ls -la "+Rep_Calc_HOMARD_global) if ( INFO >= 4 ) : l_aux = ["HOMARD.Donnees" , "HOMARD.Configuration"] else : @@ -814,13 +877,7 @@ def macr_adap_mail_ops ( self, #==================================================================== # 6. Ecriture de la commande d'execution de homard #==================================================================== -# -# #gn print "\.. Debut de 6." -#gn os.system("cp " + Rep_Calc_HOMARD_global + "/../fort.17* $HOME/aster") -#gn os.system("cp " + Rep_Calc_HOMARD_global + "/HOMARD.Configuration $HOME/aster/HOMARD.Configuration"+str(niter)) -#gn fichier_aster_vers_homard_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_aster_vers_homard)) -#gn shutil.copyfile(fichier_aster_vers_homard, fichier_aster_vers_homard_2) # if ( INFO == 1 ) : iaux = INFO @@ -838,25 +895,18 @@ def macr_adap_mail_ops ( self, #gn import time #gn time.sleep(3600) # -#gn if ( mode_homard == "ADAP" ) : -#gn fichier_homard_vers_aster_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)) -#gn shutil.copyfile(fichier_homard_vers_aster, fichier_homard_vers_aster_2) -#gn fichier_homard_vers_aster_2_1 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".1") -#gn os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_1+""+fichier_homard_vers_aster_2_2+" Ecriture de la commande de lecture des resultats med # Remarque : # La fonction self.DeclareOut(a,b) fonctionne ainsi : # a est une chaine de caracteres # b est la variable declaree dans la commande -# le but est de associer le contenu de b e la variable locale qui sera designee par a +# le but est de associer le contenu de b a la variable locale qui sera designee par a # Exemple : -# self.DeclareOut("maillage_a_lire",args["MAILLAGE_NP1"]) -# ==> la variable maillage_a_lire est identifiee e l'argument "MAILLAGE_NP1" +# self.DeclareOut("maillage_a_lire", args["MAILLAGE_NP1"]) +# ==> la variable maillage_a_lire est identifiee a l'argument "MAILLAGE_NP1" #==================================================================== +#gn print "\.. Debut de 7." # if ( mode_homard in [ "ADAP", "MODI" ] ) : # @@ -891,7 +941,6 @@ def macr_adap_mail_ops ( self, for dico in liste_champs : if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : #gn print dico - self.DeclareOut("champ_maj", dico["CHAM_MAJ"]) motscsi = {} for cle in [ "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] : if dico.has_key(cle) : @@ -901,11 +950,12 @@ def macr_adap_mail_ops ( self, motscsi["NUME_PT"] = dico["NUME_ORDRE"] #gn print "MAILLAGE = ",maillage_np1 #gn print "NOM_MAIL_MED = ",maillage_np1_nom_med -#gn print "NOM_MED = ",dico["NOM_MED"] +#gn print "NOM_CHAM_MED = ",dico["NOM_CHAM_MED"] #gn print "TYPE_CHAM =", dico["TYPE_CHAM"] + self.DeclareOut("champ_maj", dico["CHAM_MAJ"]) champ_maj = LIRE_CHAMP ( UNITE = unite_fichier_homard_vers_aster, FORMAT = "MED", MAILLAGE = maillage_np1, NOM_MAIL_MED=maillage_np1_nom_med, - NOM_MED = dico["NOM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"], + NOM_MED = dico["NOM_CHAM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"], INFO = infocomm, **motscsi ) # #==================================================================== @@ -915,6 +965,7 @@ def macr_adap_mail_ops ( self, # On doit imperativement garder le dernier fichier homard produit # En mode d'information, on garde egalement les fichiers textes #==================================================================== +#gn print "\.. Debut de 8." # l_aux = [fichier_aster_vers_homard] if ( mode_homard in [ "ADAP", "MODI" ] ) : @@ -929,7 +980,6 @@ def macr_adap_mail_ops ( self, if ( mode_homard == "ADAP" ) : fic = os.path.join(Rep_Calc_HOMARD_global, fic_homard_niterp1) l_aux_bis.append(fic) -#gn os.system("cp " + Rep_Calc_HOMARD_global + "/* $HOME/aster") # for fic in l_aux : if ( INFO >= 3 ) : @@ -944,12 +994,46 @@ def macr_adap_mail_ops ( self, self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) UTMESS("F", 'HOMARD0_5', valk=fic) # +# Liberation du fichier de ASTER vers HOMARD +# + DEFI_FICHIER ( ACTION= "LIBERER", + UNITE = unite_fichier_aster_vers_homard, + INFO = infocomm ) #gn print "Repertoire ",Rep_Calc_HOMARD_global #gn print os.listdir(Rep_Calc_HOMARD_global) #gn print "Repertoire ",Rep_Calc_ASTER #gn print os.listdir(Rep_Calc_ASTER) # #==================================================================== +# 9. Archivage des repertoires d'adaptation en vue de poursuite +#==================================================================== +#gn print "\.. Debut de 9." +# +# + if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER) + if ( INFO >= 3 ) : print "Archivage dans", fichier_archive + laux = [] + for dico in Liste_Passages : +# Memorisation du nom du repertoire local pour ce cas d'adaptation + Rep_Calc_HOMARD_local = dico["Rep_Calc_HOMARD_local"] + laux.append(Rep_Calc_HOMARD_local) +# Memorisation de la liste des passages +# Remarque : c'est fait a chaque repertoire pour faciliter le decodage ensuite + Rep_Calc_HOMARD_global = dico["Rep_Calc_HOMARD_global"] + fic = os.path.join(Rep_Calc_HOMARD_global, "pick.1") + file = open(fic, "w") + cPickle.dump(Liste_Passages, file) + file.close() +# Si on a au moins un cas d'adaptation, archivage + if len(laux) > 0 : + file = tarfile.open(fichier_archive, "w") + for rep in laux : + if ( INFO >= 3 ) : print ".. Insertion de", rep + file.add(rep) + file.close() + if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER) +# +#==================================================================== # C'est fini ! #==================================================================== # @@ -959,3 +1043,6 @@ def macr_adap_mail_ops ( self, #gn time.sleep(3600) # return + + + diff --git a/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py index 1931bda3..d9677c14 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macr_ascouf_calc_ops Macro DATE 14/09/2010 AUTEUR ABBAS M.ABBAS +#@ MODIF macr_ascouf_calc_ops Macro DATE 02/02/2011 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21,7 +21,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM, FOND_FISS,RESU_THER,AFFE_MATERIAU, - PRES_REP,ECHANGE,TORS_P1,COMP_INCR,COMP_ELAS, + PRES_REP,ECHANGE,TORS_P1,COMP_ELAS, SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE, INCREMENT,THETA_3D,IMPR_TABLE,IMPRESSION,INFO,TITRE ,**args): """ @@ -347,10 +347,8 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA contact = _chcont motscles['EXCIT'] =mcfex # - mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets - if COMP_INCR!=None : - mcfci.append(_F(TOUT='OUI' ,RELATION=COMP_INCR['RELATION'])) - elif COMP_ELAS!=None : + mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets dans STAT_NON_LINE + if COMP_ELAS!=None : motscles['COMP_ELAS'] =_F(GROUP_MA='COUDE',RELATION=COMP_ELAS['RELATION']) if TORS_P1!=None : mcfci.append( _F(GROUP_MA='P1',RELATION='ELAS')) if CL_BOL_P2_GV==None: mcfci.append( _F(GROUP_MA='P2',RELATION='ELAS')) @@ -404,7 +402,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA nomres = CALC_ELEM( reuse = nomres, RESULTAT = nomres , TOUT_ORDRE = 'OUI' , - OPTION = ('SIEF_ELNO_ELGA','EQUI_ELNO_SIGM') , + OPTION = ('SIEF_ELNO','SIEQ_ELNO') , INFO = INFO ,) # # --- post-traitements --- @@ -442,7 +440,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA motscles['ACTION']=[] for grno in lgrno : motscles['ACTION'].append(_F(RESULTAT=nomres, - NOM_CHAM='SIEF_ELNO_ELGA', + NOM_CHAM='SIEF_ELNO', TOUT_CMP='OUI', INTITULE=grno, GROUP_NO=grno, @@ -458,7 +456,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA motscles['ACTION']=[] for tgrno in lgrno : motscles['ACTION'].append(_F(RESULTAT=nomres, - NOM_CHAM='SIEF_ELNO_ELGA', + NOM_CHAM='SIEF_ELNO', INTITULE=tgrno, GROUP_NO=tgrno, INVARIANT='OUI', @@ -496,7 +494,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA ANGSEC = atan2(VSIN,VCOS) vecty=(sin(ANGSEC),0.,cos(ANGSEC)) motscles['ACTION'].append(_F(RESULTAT=nomres, - NOM_CHAM='SIEF_ELNO_ELGA', + NOM_CHAM='SIEF_ELNO', INTITULE=tgrno, GROUP_NO=tgrno, NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ',), @@ -529,7 +527,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA motscles['ACTION']=[] for j in range(8) : motscles['ACTION'].append(_F(RESULTAT=nomres, - NOM_CHAM='SIEF_ELNO_ELGA', + NOM_CHAM='SIEF_ELNO', TOUT_CMP='OUI', INTITULE=LIG[j]+SECT[i], GROUP_NO=LIG[j]+SECT[i], @@ -549,7 +547,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA for j in range(8) : motscles['ACTION'].append(_F(INTITULE =LIG[j]+SECT[i], GROUP_NO =LIG[j]+SECT[i], RESULTAT =nomres, - NOM_CHAM ='SIEF_ELNO_ELGA', + NOM_CHAM ='SIEF_ELNO', INVARIANT='OUI', OPERATION='EXTRACTION')) secinv[i] = POST_RELEVE_T(**motscles) @@ -564,7 +562,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA VECT_Y =vecty, GROUP_NO =LIG[j]+SECT[i], RESULTAT =nomres, - NOM_CHAM ='SIEF_ELNO_ELGA', + NOM_CHAM ='SIEF_ELNO', NOM_CMP =('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'), OPERATION='MOYENNE')) secmoy[i] = POST_RELEVE_T(**motscles) @@ -721,7 +719,6 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA R_SUP = thet['R_SUP'],), ); motscles = {} - if COMP_INCR!=None : motscles['COMP_INCR']=_F(RELATION=COMP_INCR['RELATION']) if COMP_ELAS!=None : motscles['COMP_ELAS']=_F(RELATION=COMP_ELAS['RELATION']) _nogthe=CALC_G( RESULTAT =nomres, OPTION='CALC_G_GLOB', @@ -732,7 +729,6 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA # for thet in THETA_3D: motscles = {} - if COMP_INCR!=None : motscles['COMP_INCR']=_F(RELATION=COMP_INCR['RELATION']) if COMP_ELAS!=None : motscles['COMP_ELAS']=_F(RELATION=COMP_ELAS['RELATION']) if TYPE_MAILLAGE =='FISS_COUDE' : motscles['LISSAGE']=_F(LISSAGE_THETA='LEGENDRE', diff --git a/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py index 0355d1c4..d56cc8d6 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macr_aspic_calc_ops Macro DATE 14/09/2010 AUTEUR ABBAS M.ABBAS +#@ MODIF macr_aspic_calc_ops Macro DATE 02/02/2011 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21,7 +21,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM, FOND_FISS_1,FOND_FISS_2,RESU_THER,AFFE_MATERIAU,EQUILIBRE, - PRES_REP,ECHANGE,TORS_CORP,TORS_TUBU,COMP_INCR,COMP_ELAS, + PRES_REP,ECHANGE,TORS_CORP,TORS_TUBU,COMP_ELAS, THETA_3D,OPTION,SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE, INCREMENT,PAS_AZIMUT,IMPRESSION,INFO,TITRE,BORNES ,**args): """ @@ -346,9 +346,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C motscles['EXCIT'] =mcfex # - mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets - if COMP_INCR!=None : - mcfci.append(_F(TOUT ='OUI' ,RELATION=COMP_INCR['RELATION'])) + mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets dans STAT_NON_LINE mcfci.append( _F(GROUP_MA=NOMNOE,RELATION='ELAS')) motscles['COMP_INCR'] =mcfci # @@ -405,7 +403,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C nomres = CALC_ELEM( reuse = nomres, RESULTAT = nomres , TOUT_ORDRE = 'OUI' , - OPTION = ('SIEF_ELNO_ELGA','VARI_ELNO_ELGA','EQUI_ELNO_SIGM') , + OPTION = ('SIEF_ELNO','VARI_ELNO','SIEQ_ELNO') , INFO = INFO ,) # #----------------------------------------------------------------------- @@ -438,7 +436,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C mcsimp['GROUP_NO' ]='LD'+str(i) mcfact.append( _F( RESULTAT = nomres, TOUT_ORDRE ='OUI', - NOM_CHAM ='SIEF_ELNO_ELGA', + NOM_CHAM ='SIEF_ELNO', PRECISION =55.E-1, TOUT_CMP ='OUI', OPERATION ='EXTRACTION',**mcsimp)) @@ -465,7 +463,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C mcsimp['GROUP_NO' ]='LD'+str(i) mcsimp['RESULTAT' ]=nomres mcsimp['TOUT_ORDRE' ]='OUI' - mcsimp['NOM_CHAM' ]='SIEF_ELNO_ELGA' + mcsimp['NOM_CHAM' ]='SIEF_ELNO' mcsimp['PRECISION' ]=55.E-1 mcsimp['TOUT_CMP' ]='OUI' mcsimp['OPERATION' ]='EXTRACTION' @@ -532,7 +530,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C mcsimp['GROUP_NO' ]='LI'+str(i) mcsimp['RESULTAT' ]=nomres mcsimp['TOUT_ORDRE' ]='OUI' - mcsimp['NOM_CHAM' ]='SIEF_ELNO_ELGA' + mcsimp['NOM_CHAM' ]='SIEF_ELNO' mcsimp['PRECISION' ]=55.E-1 mcsimp['TOUT_CMP' ]='OUI' mcsimp['REPERE' ]='LOCAL' @@ -555,7 +553,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C mcsimp['GROUP_NO' ]='LI'+str(i) mcsimp['RESULTAT' ]=nomres mcsimp['TOUT_ORDRE' ]='OUI' - mcsimp['NOM_CHAM' ]='SIEF_ELNO_ELGA' + mcsimp['NOM_CHAM' ]='SIEF_ELNO' mcsimp['PRECISION' ]=55.E-1 mcsimp['TOUT_CMP' ]='OUI' mcsimp['OPERATION' ]='EXTRACTION' @@ -754,7 +752,6 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C motscles={} if COMP_ELAS!=None: motscles['COMP_ELAS']= _F(TOUT = 'OUI', RELATION = COMP_ELAS['RELATION'],) - if COMP_INCR!=None: motscles['COMP_INCR']= _F(RELATION = COMP_INCR['RELATION'],) __gtheta = CALC_G ( THETA = _F(THETA=__theta), OPTION = 'CALC_G_GLOB', RESULTAT = nomres, @@ -783,7 +780,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C # # --- commande CALC_G (3D LOCAL) --- # - montit = 'G_LOCAL AVEC R_INF = '+str(tht3d['R_INF'])+' ET R_SUP = '+str(tht3d['R_SUP']) + montit = 'G AVEC R_INF = '+str(tht3d['R_INF'])+' ET R_SUP = '+str(tht3d['R_SUP']) motscles={} if COMP_ELAS!=None: motscles['COMP_ELAS' ]= _F(TOUT = 'OUI', RELATION = COMP_ELAS['RELATION'],) @@ -834,7 +831,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C if IMPRESSION['NOM_CHAM']!=None : if type(IMPRESSION['NOM_CHAM']) in (types.TupleType,types.ListType) : ncham= IMPRESSION['NOM_CHAM'] else : ncham=[IMPRESSION['NOM_CHAM'],] - if len(ncham)==3 : motscles['NOM_CHAM' ]=('DEPL','EQUI_ELNO_SIGM') + if len(ncham)==3 : motscles['NOM_CHAM' ]=('DEPL','SIEQ_ELNO') elif (len(ncham)==1) and (ncham[0][:4]!='TEMP') : motscles['NOM_CHAM' ]= ncham[0] elif (len(ncham)==2) and (ncham[0][:4]!='TEMP') and (ncham[1][:4]!='TEMP') : diff --git a/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py b/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py index 6f082892..053d4d0a 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macr_cara_poutre_ops Macro DATE 13/09/2010 AUTEUR PELLET J.PELLET +#@ MODIF macr_cara_poutre_ops Macro DATE 13/01/2011 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -317,7 +317,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, __tempe1=CALC_ELEM(reuse=__tempe1, RESULTAT=__tempe1, TOUT_ORDRE='OUI', - OPTION='FLUX_ELNO_TEMP', + OPTION='FLUX_ELNO', ) __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, @@ -327,7 +327,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', CHEMIN=__chem, RESULTAT=__tempe1, - NOM_CHAM='FLUX_ELNO_TEMP', + NOM_CHAM='FLUX_ELNO', TRAC_NOR='OUI', NOM_CMP=('FLUX','FLUY'), OPERATION='MOYENNE')) @@ -352,7 +352,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', CHEMIN=__chem, RESULTAT=__tempe1, - NOM_CHAM='FLUX_ELNO_TEMP', + NOM_CHAM='FLUX_ELNO', TRAC_NOR='OUI', NOM_CMP=('FLUX','FLUY'), OPERATION='MOYENNE')) @@ -762,7 +762,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, __tempe1=CALC_ELEM(reuse=__tempe1, RESULTAT=__tempe1, TOUT_ORDRE='OUI', - OPTION='FLUX_ELNO_TEMP', + OPTION='FLUX_ELNO', ) __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, @@ -772,7 +772,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', CHEMIN=__chem, RESULTAT=__tempe1, - NOM_CHAM='FLUX_ELNO_TEMP', + NOM_CHAM='FLUX_ELNO', TRAC_NOR='OUI', NOM_CMP=('FLUX','FLUY'), OPERATION='MOYENNE')) @@ -797,7 +797,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', CHEMIN=__chem, RESULTAT=__tempe1, - NOM_CHAM='FLUX_ELNO_TEMP', + NOM_CHAM='FLUX_ELNO', TRAC_NOR='OUI', NOM_CMP=('FLUX','FLUY'), OPERATION='MOYENNE')) diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py index 3f81fc79..581e3dee 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macr_ecre_calc_ops Macro DATE 21/04/2010 AUTEUR BOTTONI M.BOTTONI +#@ MODIF macr_ecre_calc_ops Macro DATE 28/02/2011 AUTEUR BOTTONI M.BOTTONI # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -52,7 +52,8 @@ def macr_ecre_calc_ops( # PARAMETRES DEBUG - debug = True + debug = False + @@ -554,6 +555,7 @@ Choix des correlations de frottement et de transfert de chaleur $V[70] ifrot : frottement (avec : ifrot=1 ou -1 ; sans : ifrot=0 ) $V[71] cas ifrot=-1 : relim = Re limite $V[72] cas ifrot=-1 : frtlim = coeff frottement si Re > relim + $V[73] ichal : transfert de chaleur (-2 <= ichal <= 2 ichal=0 ==> Pas d'echange de chaleur) $V[74] cas ichal < 0 : xminch = titre m. gaz avec corr. Chen ou liq pour xxmaxch diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py index d2c4d359..14a6f80b 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macr_ecrevisse_ops Macro DATE 12/07/2010 AUTEUR BERARD A.BERARD +#@ MODIF macr_ecrevisse_ops Macro DATE 21/02/2011 AUTEUR ABBAS M.ABBAS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -300,12 +300,12 @@ def macr_ecrevisse_ops(self,reuse, CHAM_MATER = CHAM_MATER, EXCIT = _dEXCIT_THER, INCREMENT = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,), - ARCHIVAGE = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'), + ARCHIVAGE = _F(DETR_NUME_SUIV='OUI'), INFO = InfoAster, **motclefs ) RTHERMPJ=PROJ_CHAMP(RESULTAT=__THINIT, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA, - METHODE='COLOCATION', + METHODE='COLLOCATION', VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',), INFO=2, ) @@ -316,14 +316,14 @@ def macr_ecrevisse_ops(self,reuse, CHAM_MATER = CHAM_MATER, EXCIT = _dEXCIT_THER, INCREMENT = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,), - ARCHIVAGE = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'), + ARCHIVAGE = _F(DETR_NUME_SUIV='OUI'), INFO = InfoAster, **motclefs ) # Projection du champ thermique, a tous les instants sinon pas de deformations thermiques RTHERMPJ=PROJ_CHAMP(RESULTAT=RTHERM, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA, - METHODE='COLOCATION', + METHODE='COLLOCATION', VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',), INFO=2, ) @@ -408,7 +408,7 @@ def macr_ecrevisse_ops(self,reuse, NEWTON = _F(**dNEWTON), CONVERGENCE = _F(**dCONVERGENCE), SOLVEUR = _F(SYME='OUI'), - ARCHIVAGE = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'), + ARCHIVAGE = _F(DETR_NUME_SUIV='OUI'), INFO = InfoAster, **motclefs ) diff --git a/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py index 6c66718d..ff38e2dd 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macr_lign_coupe_ops Macro DATE 15/11/2010 AUTEUR PELLET J.PELLET +#@ MODIF macr_lign_coupe_ops Macro DATE 02/02/2011 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -133,7 +133,7 @@ def crea_resu_local(self,dime,NOM_CHAM,m,resin,mail,nomgrma): elif dime ==3 : LCMP=['DX','DY','DZ'] TYPE_CHAM='VECT_3D' - elif NOM_CHAM in ('SIGM_NOEU_DEPL','SIEF_ELNO_ELGA','SIGM_NOEU_SIEF','SIGM_NOEU_ELGA','SIGM_NOEU_COQU','SIGM_ELNO_DEPL'): + elif NOM_CHAM in ('SIGM_NOEU','SIEF_ELNO','SIGM_NOEU_ELGA','SICO_NOEU','SIGM_ELNO'): if dime == 2: LCMP=['SIXX','SIYY','SIZZ','SIXY'] TYPE_CHAM='TENS_2D' @@ -815,7 +815,7 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, if NOM_CHAM[5:9]=='ELGA' : UTMESS('F','POST0_18',valk=[NOM_CHAM,]) - __recou=PROJ_CHAMP(METHODE='COLOCATION', + __recou=PROJ_CHAMP(METHODE='COLLOCATION', RESULTAT=RESULTAT, MODELE_1=MODELE_1, DISTANCE_MAX=m['DISTANCE_MAX'], @@ -831,7 +831,7 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, if AsType(RESULTAT).__name__ in ('evol_elas','evol_noli') : - if NOM_CHAM in ('DEPL','SIEF_ELNO_ELGA','SIGM_NOEU_DEPL','SIGM_NOEU_SIEF','SIGM_NOEU_ELGA','SIGM_NOEU_COQU','SIGM_ELNO_DEPL'):icham=1 + if NOM_CHAM in ('DEPL','SIEF_ELNO','SIGM_NOEU','SIGM_NOEU_ELGA','SICO_NOEU','SIGM_ELNO'):icham=1 iocc=0 for m in LIGN_COUPE : diff --git a/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py index 6d74951f..7c5850d9 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macr_recal_ops Macro DATE 16/11/2010 AUTEUR ASSIRE A.ASSIRE +#@ MODIF macr_recal_ops Macro DATE 28/03/2011 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -179,13 +179,15 @@ def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC, TOLE_FONC = args['TOLE_FONC'] # Pour les calculs esclaves - CALCUL_ESCLAVE = {}.fromkeys( ['LANCEMENT', 'MODE', 'CLASSE', 'ACTUALISATION', 'memjeveux', 'memjob', 'mem_aster', 'tpmax', 'tpsjob', 'NMAX_SIMULT', ] ) + CALCUL_ESCLAVE = {}.fromkeys( ['LANCEMENT', 'MODE', 'UNITE_SUIVI', 'CLASSE', 'ACTUALISATION', 'memjeveux', 'memjob', 'mem_aster', 'tpmax', 'tpsjob', 'NMAX_SIMULT', ] ) dESCLAVE=args['CALCUL_ESCLAVE'][0].cree_dict_valeurs(args['CALCUL_ESCLAVE'][0].mc_liste) for i in dESCLAVE.keys(): if dESCLAVE[i]==None : del dESCLAVE[i] CALCUL_ESCLAVE['LANCEMENT'] = dESCLAVE['LANCEMENT'] + if dESCLAVE.has_key('UNITE_SUIVI'): CALCUL_ESCLAVE['UNITE_SUIVI'] = dESCLAVE['UNITE_SUIVI'] + else: CALCUL_ESCLAVE['UNITE_SUIVI'] = None if dESCLAVE.has_key('MODE'): CALCUL_ESCLAVE['MODE'] = dESCLAVE['MODE'] else: CALCUL_ESCLAVE['MODE'] = prof['mode'][0].upper() @@ -231,11 +233,12 @@ def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC, if LANCEMENT == 'DISTRIBUTION': - print prof.param['tpsjob'][0] - print prof.args['tpmax'] - print prof.param['mem_aster'][0] - print prof.args['memjeveux'] - print prof.param['memjob'][0] + if debug: + print prof.param['tpsjob'][0] + print prof.args['tpmax'] + print prof.param['mem_aster'][0] + print prof.args['memjeveux'] + print prof.param['memjob'][0] # Pour la conversion mega-mots / mega-octets from asrun.common.sysutils import on_64bits @@ -366,6 +369,8 @@ def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC, CALCUL_ASTER.RESU_CALC = RESU_CALC CALCUL_ASTER.LIST_PARA = LIST_PARA + if CALCUL_ESCLAVE['UNITE_SUIVI']: CALCUL_ASTER.unity_follow = CALCUL_ESCLAVE['UNITE_SUIVI'] + # Instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim Dim = reca_algo.Dimension(copy.copy(val_init)) diff --git a/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py b/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py index 6e05cae2..719b42d8 100644 --- a/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macro_elas_mult_ops Macro DATE 23/03/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF macro_elas_mult_ops Macro DATE 02/02/2011 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -219,8 +219,8 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, liste_option=m['OPTION'] for option in liste_option : if option in ( 'FORC_NODA','REAC_NODA', - 'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL', - 'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI',): + 'EPSI_NOEU','SIGM_NOEU','EFGE_NOEU', + 'SIEQ_NOEU','EPEQ_NOEU',): nbno=nbno+1 liste_no.append(option) else: diff --git a/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py index 17004981..63b4dd73 100644 --- a/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macro_expans_ops Macro DATE 12/07/2010 AUTEUR BERARD A.BERARD +#@ MODIF macro_expans_ops Macro DATE 14/12/2010 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -30,7 +30,7 @@ def macro_expans_ops( self, MODES_NUM=None, MODES_EXP=None, RESOLUTION=None, - *args + **args ): """!macro MACRO_EXPANS """ from Accas import _F @@ -47,6 +47,13 @@ def macro_expans_ops( self, NORM_MODE = self.get_cmd('NORM_MODE') + RESU_NUM = MODELE_CALCUL['BASE'] + RESU_EXP = MODELE_MESURE['MESURE'] + MOD_CALCUL = MODELE_CALCUL['MODELE'] + MOD_MESURE = MODELE_MESURE['MODELE'] + NOM_CHAM = MODELE_MESURE['NOM_CHAM'] + + # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) @@ -56,20 +63,18 @@ def macro_expans_ops( self, is_nume_num = 1 else: if RESU_NX: - UTMESS('A','MEIDEE0_6',valk=['MODELE_MESURE','RESU_EX']) + UTMESS('A','CALCESSAI0_6',valk=['MODELE_MESURE','RESU_EX']) + if MODELE_MESURE['NUME_MODE'] or MODELE_MESURE['NUME_ORDRE']: # On cree un RESU_EX par extraction de NUME_ORDREs is_nume_exp = 1 + if isinstance(RESU_NUM,dyna_harmo): + # on ne peut pas faire de EXTR_MODE sur un DYNA_HARMO + is_nume_exp = 0 + UTMESS('A','CALCESSAI0_13') else: - if RESU_EX: UTMESS('A','MEIDEE0_6',valk=['MODELE_CALCUL','RESU_NX']) + if RESU_EX: UTMESS('A','CALCESSAI0_6',valk=['MODELE_CALCUL','RESU_NX']) - RESU_NUM = MODELE_CALCUL['BASE'] - RESU_EXP = MODELE_MESURE['MESURE'] - - MOD_CALCUL = MODELE_CALCUL['MODELE'] - MOD_MESURE = MODELE_MESURE['MODELE'] - - NOM_CHAM = MODELE_MESURE['NOM_CHAM'] # Extraction des modes numériques # ------------------------------- @@ -133,7 +138,7 @@ def macro_expans_ops( self, else: paras = None #"LE MODELE MEDURE DOIT ETRE UN CONCEPT DE TYPE DYNA_HARMO OU MODE_MECA") - UTMESS('A','MEIDEE0_1') + UTMESS('A','CALCESSAI0_1') try: @@ -167,15 +172,16 @@ def macro_expans_ops( self, self.DeclareOut( "RESU_RD", RESU_RD ) nume=None - if resu_ex.REFD.get(): - tmp = resu_ex.REFD.get()[3] - if tmp.strip() : - nume = self.get_concept(tmp) - elif NUME_DDL: + if NUME_DDL: nume = NUME_DDL if not nume : - UTMESS('A','MEIDEE0_5') - RESU_RD = PROJ_CHAMP( METHODE = 'COLOCATION', + if resu_ex.REFD.get(): + tmp = resu_ex.REFD.get()[3] + if tmp.strip() : + nume = self.get_concept(tmp) + else: + UTMESS('A','CALCESSAI0_5') + RESU_RD = PROJ_CHAMP( METHODE = 'COLLOCATION', RESULTAT = RESU_ET, MODELE_1 = MOD_CALCUL, MODELE_2 = MOD_MESURE, diff --git a/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py index 30984e88..91da1619 100644 --- a/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py @@ -1,8 +1,8 @@ -#@ MODIF macro_miss_3d_ops Macro DATE 30/08/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF macro_miss_3d_ops Macro DATE 14/03/2011 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -74,7 +74,17 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, MODUL2='MISS_PTAS' elif OPTION['MODULE']=='PRE_MISS': MODUL2='GTASTER' - + + alarm16 = False + typ15 = 'A' + if OPTION['MODULE'] == 'MISS_IMPE' \ + and PARAMETRE != None and PARAMETRE['ISSF'] == 'NON': + alarm16 = True + typ15 = 'A+' + + UTMESS(typ15, 'MISS0_15') + if alarm16: + UTMESS('A', 'MISS0_16') ETUDE = PROJET BASE = REPERTOIRE diff --git a/Aster/Cata/cataSTA10/Macro/observation_ops.py b/Aster/Cata/cataSTA10/Macro/observation_ops.py index 8ab60659..cc924ff9 100644 --- a/Aster/Cata/cataSTA10/Macro/observation_ops.py +++ b/Aster/Cata/cataSTA10/Macro/observation_ops.py @@ -1,8 +1,8 @@ -#@ MODIF observation_ops Macro DATE 12/07/2010 AUTEUR BERARD A.BERARD +#@ MODIF observation_ops Macro DATE 13/01/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -19,15 +19,15 @@ # ====================================================================== - - +# RESPONSABLE BODEL C.BODEL def observation_ops(self, PROJECTION = None, MODELE_1 = None, MODELE_2 = None, RESULTAT = None, - NUME_DDL = None, + MATR_A = None, + MATR_B = None, MODI_REPERE = None, NOM_CHAM = None, FILTRE = None, @@ -50,9 +50,7 @@ def observation_ops(self, # importation de commandes import aster from Accas import _F - from Utilitai.UniteAster import UniteAster from Utilitai.Utmess import UTMESS - from Utilitai.Table import Table from Cata.cata import mode_meca, dyna_harmo, evol_elas,dyna_trans MODI_REPERE = self.get_cmd('MODI_REPERE') PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') @@ -65,18 +63,11 @@ def observation_ops(self, # ne sert pas par la suite mcfact = args - if NOM_CHAM == 'DEPL': - if isinstance( RESULTAT, dyna_harmo): - TYPE_CHAM = 'NOEU_DEPL_C' - else: - TYPE_CHAM = 'NOEU_DEPL_R' - elif NOM_CHAM == 'EPSI_NOEU_DEPL': - if isinstance( RESULTAT, dyna_harmo): - TYPE_CHAM = 'NOEU_EPSI_C' - else: - TYPE_CHAM = 'NOEU_EPSI_R' - else: - UTMESS('F','ELEMENTS4_48',valk=[NOM_CHAM]) + 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' @@ -84,7 +75,6 @@ def observation_ops(self, if isinstance( RESULTAT, mode_meca): TYPE_RESU='MODE_MECA' self.DeclareOut( 'RESU', self.sd) - jdc = CONTEXT.get_current_step().jdc # recuperation du maillage associe au modele numerique _maillag = aster.getvectjev( MODELE_1.nom.ljust(8) + '.MODELE .LGRF' ) @@ -123,34 +113,48 @@ def observation_ops(self, # afreq pour les frequences propres if isinstance( RESULTAT, mode_meca): + # frequences propres from Cata.cata import RECU_TABLE __freq = RECU_TABLE(CO=RESULTAT, NOM_PARA='FREQ',); afreq = __freq.EXTR_TABLE().Array('NUME_ORDRE','FREQ') + # noms des matrices + if MATR_A !=None or MATR_B !=None: + # recherche du nume_ddl associe + iret,ibid,nom_nume_ddl = aster.dismoi('F','NOM_NUME_DDL',MATR_A.nom,'MATR_ASSE') + NUME_DDL = self.get_concept(nom_nume_ddl) + # coherence avec le nom associe a MODELE_2 : + iret,ibid,nom_modele = aster.dismoi('F','NOM_MODELE',nom_nume_ddl,'NUME_DDL') + 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 - nume_ordr_demande = mcfact['NUME_ORDRE'] - if type(nume_ordr_demande) != tuple : - nume_ordr_demande = [nume_ordr_demande] - - num_max = len(RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']) + 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 NOM_CHAM != 'EPSI_NOEU_DEPL': - __proj= RESULTAT - UTMESS('F','UTILITAI8_24',valk=['NOEU_EPSI',NOM_CHAM]) + if TYPE_CHAM == None: + UTMESS('F', 'UTILITAI8_24', valk = ['NOEU_EPSI', nomcham]) else: - if nume_ordr_demande[0]: - num_ordr = nume_ordr_demande - else: - num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE'] + num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE'] if isinstance( RESULTAT, evol_elas): list_inst = RESULTAT.LIST_VARI_ACCES()['INST'] @@ -202,34 +206,34 @@ def observation_ops(self, 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_DEPL', - 'RESULTAT' : RESULTAT, - 'NUME_ORDRE' : num_ordr, - } + '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_DEPL', - 'RESULTAT' : RESULTAT, - 'NUME_ORDRE' : num_ordr, - } + '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_DEPL', - 'RESULTAT' : RESULTAT, - 'NUME_ORDRE' : num_ordr, - } + '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( @@ -240,8 +244,8 @@ def observation_ops(self, DETRUIRE( CONCEPT= _F( NOM = _tepsi ), INFO=1) mcfact2 = { } - __chame = [None]*num_max - for ind in num_ordr: + __chame = [None]*len(indice) + for ind in indice: argsa = {'AFFE' : [], } for mcfacta in range(nb_mcfact): l_noeud_mcfact = lnoeuds[str(mcfacta+1)] @@ -259,17 +263,17 @@ def observation_ops(self, for row in table.rows: if TYPE_CHAM[-1:] == 'C': if row['INTITULE'].strip() == str('R'+str(mcfacta+1)) \ - and row['NUME_ORDRE'] == ind : + 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'] == ind : + 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'] == ind: + and row['NUME_ORDRE'] == num_ordr[ind]: l_val.append(row[cmp]) if TYPE_CHAM[-1:] == 'C': @@ -288,8 +292,8 @@ def observation_ops(self, 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) + vminr = min(l_valr) + vmini = min(l_vali) vmaxr = max(l_valr) vmaxi = max(l_vali) if vmoyer > 0: @@ -324,10 +328,10 @@ def observation_ops(self, if cmp_vari not in masque_mc: if cmp == cmp_vari and not vu: if EPSI_MOYENNE[mcfacta]['MAILLE'] != None: - entite = str('MAILLE : '+str(PSI_MOYENNE[mcfacta]['MAILLE'])) + 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=[ind],valr=[seuil_mc],valk=[entite,cmp]) + UTMESS('A','OBSERVATION_8',vali=[num_ordr[ind]],valr=[seuil_mc],valk=[entite,cmp]) vu = 1 @@ -344,38 +348,38 @@ def observation_ops(self, argsa['AFFE'].append(mcfactc) - __chame[ind-1] = CREA_CHAMP( OPERATION = 'AFFE', + __chame[ind] = CREA_CHAMP( OPERATION = 'AFFE', MODELE = MODELE_1, PROL_ZERO = 'OUI', - TYPE_CHAM = TYPE_CHAM, - OPTION = NOM_CHAM, + TYPE_CHAM = TYPE_CHAM, + OPTION = 'EPSI_NOEU', **argsa ); if isinstance( RESULTAT, mode_meca): - mcfact2 = {'CHAM_GD' : __chame[ind-1], + mcfact2 = {'CHAM_GD' : __chame[ind], 'MODELE' : MODELE_1, - 'NUME_MODE' : int(afreq[ind-1,0]), - 'FREQ' : afreq[ind-1,1], + 'NUME_MODE' : int(afreq[ind,0]), + 'FREQ' : afreq[ind,1], } if isinstance( RESULTAT, evol_elas): - mcfact2 = {'CHAM_GD' : __chame[ind-1], + mcfact2 = {'CHAM_GD' : __chame[ind], 'MODELE' : MODELE_1, - 'INST' : list_inst[ind-1], + 'INST' : list_inst[ind], } if isinstance( RESULTAT, dyna_trans): - mcfact2 = {'CHAM_GD' : __chame[ind-1], + mcfact2 = {'CHAM_GD' : __chame[ind], 'MODELE' : MODELE_1, 'INST' : list_inst[ind], } if isinstance( RESULTAT, dyna_harmo): - mcfact2 = {'CHAM_GD' : __chame[ind-1], - 'MODELE' : MODELE_1, - 'FREQ' : list_freq[ind-1], - } + mcfact2 = {'CHAM_GD' : __chame[ind], + 'MODELE' : MODELE_1, + 'FREQ' : list_freq[ind], + } if cham_mater is not None: mcfact2['CHAM_MATER'] = cham_mater @@ -384,33 +388,62 @@ def observation_ops(self, liste.append(mcfact2) - __proj = CREA_RESU( + resu_epsi = 'EPSI_NOEU' + RESU = CREA_RESU( OPERATION = 'AFFE', TYPE_RESU = TYPE_RESU, - NOM_CHAM = NOM_CHAM, + NOM_CHAM = 'EPSI_NOEU', AFFE = liste, ); - else: - __proj= RESULTAT +#*********************************************** +# 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': - __proj=PROJ_CHAMP(METHODE='COLOCATION', - RESULTAT = __proj, + 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, - NUME_DDL = NUME_DDL, - NOM_CHAM = NOM_CHAM, + NOM_CHAM = nomcham, **mcfact - ); - - modele = MODELE_2 - else: - modele = MODELE_1 + ) + 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 #*********************************************** @@ -433,26 +466,27 @@ def observation_ops(self, # ) - if MODIF_REPERE != None : - if nume_ordr_demande[0]: - num_ordr = nume_ordr_demande - else: - num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] + if MODIF_REPERE != None : + num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] for modif_rep in MODIF_REPERE : - type_cham = modif_rep['TYPE_CHAM'] - if type_cham == 'TENS_2D': - nom_cmp = ['EPXX','EPYY','EPZZ','EPXY',] - elif type_cham == 'TENS_3D': - nom_cmp = ['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ',] - else: - nom_cmp = modif_rep['NOM_CMP'] + 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' : NOM_CHAM } + 'NOM_CHAM' : nomcham } mcfact2 = { } - modi_rep = modif_rep.val if modi_rep['REPERE'] == 'DIR_JAUGE' : vect_x = None @@ -463,7 +497,6 @@ def observation_ops(self, vect_y = modi_rep['VECT_Y'] # il faut des mailles pour les tenseurs d'ordre 2 - taille = 0 for typ in ['MAILLE','GROUP_MA',]: if modi_rep.has_key(typ) : if PROJECTION == 'OUI': @@ -471,7 +504,6 @@ def observation_ops(self, else: maya = mayanum list_ma = find_ma(maya, {typ : modi_rep[typ]}) - taille = len(list_ma) mcfact1.update({ 'MAILLE' : list_ma }) angl_naut = crea_repere_xy(vect_x, vect_y) @@ -479,12 +511,14 @@ def observation_ops(self, mcfact2.update({ 'REPERE' : 'UTILISATEUR', 'ANGL_NAUT' : angl_naut }) - args = {'MODI_CHAM' : mcfact1, + argsm = {'MODI_CHAM' : mcfact1, 'DEFI_REPERE' : mcfact2 } - __proj = MODI_REPERE( RESULTAT = __proj, - NUME_ORDRE = num_ordr, - **args) + __bidon = MODI_REPERE( RESULTAT = __proj, + 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 @@ -497,7 +531,7 @@ def observation_ops(self, UTMESS('E','UTILITAI7_9') chnorm = crea_normale(self, MODELE_1, MODELE_2, NUME_DDL, - cham_mater, cara_elem) + cham_mater, cara_elem) modele = MODELE_2 chnormx = chnorm.EXTR_COMP('DX',[],1) ind_noeuds = chnormx.noeud @@ -520,12 +554,12 @@ def observation_ops(self, mcfact1.update({ 'NOEUD' : nomnoe }) mcfact2.update({ 'REPERE' : 'UTILISATEUR', 'ANGL_NAUT' : angl_naut}) - args = {'MODI_CHAM' : mcfact1, + argsm = {'MODI_CHAM' : mcfact1, 'DEFI_REPERE' : mcfact2 } __bid[k+1] = MODI_REPERE( RESULTAT = __bid[k], TOUT_ORDRE = 'OUI', CRITERE = 'RELATIF', - **args) + **argsm) k = k + 1 __proj = __bid[-1:][0] @@ -554,12 +588,12 @@ def observation_ops(self, mcfact2.update({ 'REPERE' : 'UTILISATEUR', 'ANGL_NAUT' : angl_naut }) - args = {'MODI_CHAM' : mcfact1, - 'DEFI_REPERE' : mcfact2 } + argsm = {'MODI_CHAM' : mcfact1, + 'DEFI_REPERE' : mcfact2 } __bidon = MODI_REPERE( RESULTAT = __proj, CRITERE = 'RELATIF', - **args) + **argsm) DETRUIRE( CONCEPT= _F( NOM = __proj ), INFO=1) __proj = __bidon @@ -568,199 +602,157 @@ def observation_ops(self, # Phase de selection des DDL de mesure #************************************************* - if FILTRE != None: - if nume_ordr_demande[0]: - num_ordr = nume_ordr_demande - else: - num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] + resu_filtre = None + if FILTRE != None: + num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] - __chamf = [None]*num_max - if isinstance( RESULTAT, evol_elas): - list_inst_ini = RESULTAT.LIST_VARI_ACCES()['INST'] - if isinstance( RESULTAT, dyna_trans): - list_inst_ini = RESULTAT.LIST_VARI_ACCES()['INST'] - if isinstance( RESULTAT, dyna_harmo): - list_freq_ini = RESULTAT.LIST_VARI_ACCES()['FREQ'] + __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 num_ordr: - mcfact2 = { } - filtres = [] - __chamex = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, + liste = [] + + for ind in indice: + mcfact2 = { } + filtres = [] + __chamex = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, OPERATION = 'EXTR', RESULTAT = __proj, - NOM_CHAM = NOM_CHAM, - NUME_ORDRE = ind,); + 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: - for mcfiltre in FILTRE : mcfact1 = {} - filtre = mcfiltre.val - for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA']: + + 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'], + mcfact1.update({'NOM_CMP' : filtre['DDL_ACTIF'], 'CHAM_GD' : __chamex }) - filtres.append(mcfact1) + filtres.append(mcfact1) - if NOM_CHAM == 'DEPL': - __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, + 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 NOM_CHAM == 'EPSI_NOEU_DEPL': - __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, + elif nomcham == 'EPSI_NOEU': + __chamf[ind] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, OPERATION = 'ASSE', PROL_ZERO = 'OUI', MODELE = modele, ASSE = filtres, ); - - else: + else: valk = [] - valk.append(NOM_CHAM) - valk.append('DEPL') - valk.append('EPSI_NOEU_DEPL') - UTMESS('F','OBSERVATION_6',valk) - - if isinstance( RESULTAT, mode_meca): - mcfact2 = {'CHAM_GD' : __chamf[ind-1], - 'MODELE' : modele, - 'NUME_MODE' : int(afreq[ind-1,0]), - 'FREQ' : afreq[ind-1,1], + 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], } - - if isinstance( RESULTAT, evol_elas): - mcfact2 = {'CHAM_GD' : __chamf[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_A' : MATR_A, + 'MATR_B' : MATR_B + } + + if isinstance( RESULTAT, evol_elas): + mcfact2 = {'CHAM_GD' : __chamf[ind], 'MODELE' : modele, - 'INST' : list_inst_ini[ind-1], + 'INST' : list_inst[ind], } - if isinstance( RESULTAT, dyna_trans): - mcfact2 = {'CHAM_GD' : __chamf[ind-1], + if isinstance( RESULTAT, dyna_trans): + mcfact2 = {'CHAM_GD' : __chamf[ind], 'MODELE' : modele, - 'INST' : list_inst_ini[ind-1], + 'INST' : list_inst[ind], } - if isinstance( RESULTAT, dyna_harmo): - mcfact2 = {'CHAM_GD' : __chamf[ind-1], + if isinstance( RESULTAT, dyna_harmo): + mcfact2 = {'CHAM_GD' : __chamf[ind], 'MODELE' : MODELE_2, - 'FREQ' : list_freq_ini[ind-1], + 'FREQ' : list_freq[ind], } - - if cham_mater is not None: + if cham_mater is not None: mcfact2['CHAM_MATER'] = cham_mater - if cara_elem is not None: + if cara_elem is not None: mcfact2['CARA_ELEM'] = cara_elem - liste.append(mcfact2) - DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1) + liste.append(mcfact2) + + DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1) - __proj = CREA_RESU( + 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 = NOM_CHAM, + NOM_CHAM = nomcham, AFFE = liste, + **argsr ); + else: + RESU = CREA_RESU( + OPERATION = 'AFFE', + TYPE_RESU = TYPE_RESU, + NOM_CHAM = nomcham, + AFFE = liste, + **argsr + ) + #************************************************* -# Recopie des resultats (__proj) dans RESU +# Recopie de __proj dans RESU si celle-ci +# n'a pas encore ete faite via FILTRE #************************************************* - if nume_ordr_demande[0]: - num_ordr = nume_ordr_demande - else: - num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] - - __chamf = [None]*num_max - 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 num_ordr: - mcfact2 = { } - filtres = [] - __chamex = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, - OPERATION = 'EXTR', - RESULTAT = __proj, - NOM_CHAM = NOM_CHAM, - NUME_ORDRE = ind,); - - mcfact1 = {} - mcfact1.update({'TOUT' : 'OUI', - 'CHAM_GD' : __chamex }) - filtres.append(mcfact1) - - if NOM_CHAM == 'DEPL': - __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, - OPERATION = 'ASSE', - MODELE = modele, - ASSE = filtres - ); - - elif NOM_CHAM == 'EPSI_NOEU_DEPL': - __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, - OPERATION = 'ASSE', - PROL_ZERO = 'OUI', - MODELE = modele, - ASSE = filtres, - ); - - else: - valk = [] - valk.append(NOM_CHAM) - valk.append('DEPL') - valk.append('EPSI_NOEU_DEPL') - UTMESS('F','OBSERVATION_6',valk) - - if isinstance( RESULTAT, mode_meca): - mcfact2 = {'CHAM_GD' : __chamf[ind-1], - 'MODELE' : modele, - 'NUME_MODE' : int(afreq[ind-1,0]), - 'FREQ' : afreq[ind-1,1], - } - - if isinstance( RESULTAT, evol_elas): - mcfact2 = {'CHAM_GD' : __chamf[ind-1], - 'MODELE' : modele, - 'INST' : list_inst[ind-1], - } - - if isinstance( RESULTAT, dyna_trans): - mcfact2 = {'CHAM_GD' : __chamf[ind-1], - 'MODELE' : modele, - 'INST' : list_inst[ind-1], - } - - if isinstance( RESULTAT, dyna_harmo): - mcfact2 = {'CHAM_GD' : __chamf[ind-1], - 'MODELE' : MODELE_2, - 'FREQ' : list_freq[ind-1], - } - - - 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 resu_filtre == None: + RESU = PROJ_CHAMP(METHODE = 'COLLOCATION', + RESULTAT = __proj, + MODELE_1 = modele, + MODELE_2 = modele, + NUME_DDL = NUME_DDL, + NOM_CHAM = nomcham, + **mcfact + ) - RESU = CREA_RESU( - OPERATION = 'AFFE', - TYPE_RESU = TYPE_RESU, - NOM_CHAM = NOM_CHAM, - AFFE = liste, - ); return ier @@ -787,7 +779,6 @@ def crea_normale(self, modele_1, modele_2, nom_modele_num = modele_1.nom _maillag = aster.getvectjev( nom_modele_num.ljust(8) + '.MODELE .LGRF' ) maillage = _maillag[0].strip() - jdc = CONTEXT.get_current_step().jdc mayanum = self.get_concept(maillage) @@ -834,7 +825,7 @@ def crea_normale(self, modele_1, modele_2, ); - __norm4 = PROJ_CHAMP( METHODE='COLOCATION', + __norm4 = PROJ_CHAMP( METHODE='COLLOCATION', RESULTAT = __norm3, MODELE_1 = modele_1, MODELE_2 = modele_2, @@ -868,7 +859,6 @@ def crea_repere(chnorm, ind_no, vect): import numpy nom_para = vect.keys()[0] # nom_para = 'VECT_X' ou 'VECT_Y' - condition = list(vect[nom_para]) # 1) pour tous les noeuds du maillage experimental, recuperer la normale # calculee a partir du maillage numerique @@ -876,9 +866,6 @@ def crea_repere(chnorm, ind_no, vect): chnormy = chnorm.EXTR_COMP('DY',[],1) chnormz = chnorm.EXTR_COMP('DZ',[],1) - noeuds = chnormx.noeud - nbno = len(noeuds) - normale = [chnormx.valeurs[ind_no], chnormy.valeurs[ind_no], chnormz.valeurs[ind_no]] @@ -913,7 +900,6 @@ def crea_repere(chnorm, ind_no, vect): return angl_naut - #********************************************************************** # Calcul des angles nautiques pour le repere associe a VECT_X et VECT_Y #********************************************************************** @@ -985,7 +971,7 @@ def crea_repere_xy(vect_x, vect_y): vect2 = vy vect1 = numpy.cross(vect2, vect3) - + norm12=numpy.dot(vect1,vect1) norm22=numpy.dot(vect2,vect2) norm32=numpy.dot(vect3,vect3) @@ -1093,7 +1079,6 @@ def norm(x): tmp = numpy.sqrt(numpy.dot(x,x)) return tmp - def anglnaut(P): @@ -1105,9 +1090,7 @@ def anglnaut(P): import copy import numpy # expression des coordonnees globales des 3 vecteurs de base locale - x = numpy.array([1.,0.,0.]) y = numpy.array([0.,1.,0.]) - z = numpy.array([0.,0.,1.]) xg = P[:,0] yg = P[:,1] diff --git a/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py b/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py index df4b1533..6773ec43 100644 --- a/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py @@ -1,21 +1,21 @@ -#@ MODIF post_bordet_ops Macro DATE 09/08/2010 AUTEUR BARGELLINI R.BARGELLINI +#@ MODIF post_bordet_ops Macro DATE 23/02/2011 AUTEUR BARGELLI R.BARGELLINI # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== #definition des fonctions python pour les passer en formule plus tard @@ -33,11 +33,11 @@ def post_bordet_ops(self, TOUT, GROUP_MA, INST, +PRECISION, +CRITERE, NUME_ORDRE, PROBA_NUCL, RESULTAT, -MODELE, -CHAM_MATER, PARAM, TEMP, COEF_MULT,**args): @@ -52,7 +52,7 @@ COEF_MULT,**args): # 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') @@ -61,13 +61,32 @@ COEF_MULT,**args): 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 champ materiau compris dans le resultat + # + iret,ibid,__nom_cham_mater = aster.dismoi('F','CHAM_MATER',RESULTAT.nom,'RESULTAT') +# if (len(__nom_cham_mater) == 0) or (len(__nom_cham_mater) > 1) : + if (__nom_cham_mater.strip() == "#PLUSIEURS") or (__nom_cham_mater.strip() == "#AUCUN") : + print 'ON EST LA' + UTMESS('F','RUPTURE1_58') + else : + __cham_mater = self.get_concept(__nom_cham_mater.strip()) +# +#Recuperation du modele a partir du resultat + iret,ibid,__n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT') + __n_modele=__n_modele.rstrip() + if len(__n_modele)==0 or __n_modele=="#PLUSIEURS": + UTMESS('F','RUPTURE1_58') + __model = self.get_concept(__n_modele) +# + +# # Creation du dictionnaire des parametres materiau de l'utilisateur # __DPARAM=PARAM[0].cree_dict_valeurs(PARAM[0].mc_liste) @@ -78,7 +97,7 @@ COEF_MULT,**args): # #Dimension du modele # - iret,ndim,rbid = aster.dismoi('F','DIM_GEOM',self['MODELE'].nom,'MODELE') + iret,ndim,rbid = aster.dismoi('F','DIM_GEOM',__model.nom,'MODELE') if (iret==1) or (ndim==23): UTMESS('F','RUPTURE1_57') @@ -98,8 +117,8 @@ COEF_MULT,**args): # #Volume point de gauss - __VOL_PG=CALC_CHAM_ELEM(MODELE=self['MODELE'], - CHAM_MATER=self['CHAM_MATER'], + __VOL_PG=CALC_CHAM_ELEM(MODELE=__model, + CHAM_MATER=__cham_mater, TOUT='OUI', OPTION='COOR_ELGA',); if GROUP_MA: @@ -110,8 +129,8 @@ COEF_MULT,**args): #contrainte principale max __RESU=CALC_ELEM( RESULTAT=self['RESULTAT'], - OPTION='EQUI_ELGA_SIGM', - NOM_CMP='PRIN3',); + OPTION='SIEQ_ELGA'); +# NOM_CMP='PRIN3',); #deformation plastique __RESU=CALC_ELEM( reuse=__RESU, @@ -127,14 +146,23 @@ COEF_MULT,**args): #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 - __instant=INST + __n=0 + __trouv=None + while (__n=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: - if __instant not in __list_inst : - UTMESS('F','RUPTURE1_53',valr=__instant,valk='utilise pour le calcul de Bordet') - elif __instant in __list_inst : - index_ordre=__list_inst.index(__instant) - nume_ordre=__list_ordre[index_ordre] + 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 : @@ -153,7 +181,7 @@ COEF_MULT,**args): __EQ_PT=[[None] for i in range(nume_ordre+1)] __EQ_PT2=[[None] for i in range(nume_ordre+1)] __PR_BAR=[[None]for i in range(nume_ordre+1)] - __DEP=[[None] for i in range(nume_ordre+1)] + __DEP=[[None] for i in range(nume_ordre+1)] __BORDTO=0.#valeur sans l'exposant final, que l'on va sommer sur les instants __BORDTI=0.#valeur sans l'exposant final, sommee sur les instants __BORDTT=[0. for i in range(nume_ordre+1)]#valeur avec l'exposant, que l'on stocke dans la table a chaque instant @@ -178,7 +206,7 @@ COEF_MULT,**args): 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: @@ -195,7 +223,7 @@ COEF_MULT,**args): RESULTAT=__RESU, OPERATION='EXTR', NUME_ORDRE=ordre, - NOM_CHAM='EQUI_ELGA_SIGM',); + NOM_CHAM='SIEQ_ELGA',); __EPSP[ordre]=CREA_CHAMP(TYPE_CHAM='ELGA_EPSI_R', RESULTAT=__RESU, @@ -204,7 +232,7 @@ COEF_MULT,**args): NOM_CHAM='EPSP_ELGA',); # #On recupere la valeur des champs au niveau des groupes qui nous interessent -# +# if GROUP_MA: __PRIN[ordre]=__S_TOT[ordre].EXTR_COMP('PRIN_3',[GROUP_MA],0).valeurs; diff --git a/Aster/Cata/cataSTA10/Macro/post_coque_ops.py b/Aster/Cata/cataSTA10/Macro/post_coque_ops.py index 8c1015ed..7392f73c 100644 --- a/Aster/Cata/cataSTA10/Macro/post_coque_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_coque_ops.py @@ -1,8 +1,8 @@ -#@ MODIF post_coque_ops Macro DATE 11/10/2010 AUTEUR DESROCHES X.DESROCHES +#@ MODIF post_coque_ops Macro DATE 02/02/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -60,9 +60,9 @@ def post_coque_ops(self,RESULTAT,COOR_POINT,CHAM,NUME_ORDRE,INST, if not INST in dico2['INST'] : UTMESS('F','POST0_20',valr=INST) else : - if not NUME_ORDRE in dico['SIEF_ELNO_ELGA'] : + if not NUME_ORDRE in dico['SIEF_ELNO'] : if NUME_ORDRE in dico['DEPL'] : - CALC_ELEM(RESULTAT=RESULTAT,reuse=RESULTAT,OPTION='SIEF_ELNO_ELGA', + CALC_ELEM(RESULTAT=RESULTAT,reuse=RESULTAT,OPTION='SIEF_ELNO', NUME_ORDRE=NUME_ORDRE) else : UTMESS('F','POST0_19',vali=NUME_ORDRE) @@ -72,36 +72,36 @@ def post_coque_ops(self,RESULTAT,COOR_POINT,CHAM,NUME_ORDRE,INST, if CHAM=='DEFORMATION': if NUME_ORDRE: __ressup=CALC_ELEM(RESULTAT=RESULTAT, - OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='SUP'), + OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='SUP'), NUME_ORDRE=NUME_ORDRE) __resinf=CALC_ELEM(RESULTAT=RESULTAT, - OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='INF'), + OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='INF'), NUME_ORDRE=NUME_ORDRE) __epssup=CREA_CHAMP(RESULTAT=__ressup,TYPE_CHAM='ELNO_EPSI_R', - OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO', NUME_ORDRE=NUME_ORDRE) __epsinf=CREA_CHAMP(RESULTAT=__resinf,TYPE_CHAM='ELNO_EPSI_R', - OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO', NUME_ORDRE=NUME_ORDRE) else : __ressup=CALC_ELEM(RESULTAT=RESULTAT, - OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='SUP'), + OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='SUP'), INST=INST) __resinf=CALC_ELEM(RESULTAT=RESULTAT, - OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='INF'), + OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='INF'), INST=INST) __epssup=CREA_CHAMP(RESULTAT=__ressup,TYPE_CHAM='ELNO_EPSI_R', - OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO', INST=INST) __epsinf=CREA_CHAMP(RESULTAT=__resinf,TYPE_CHAM='ELNO_EPSI_R', - OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO', INST=INST) # Appel MACR_LIGN_COUPE : motscles={} - if CHAM=='EFFORT' : motscles['NOM_CHAM'] ='SIEF_ELNO_ELGA' - if CHAM=='DEFORMATION' : motscles['NOM_CHAM'] ='EPSI_ELNO_DEPL' + if CHAM=='EFFORT' : motscles['NOM_CHAM'] ='SIEF_ELNO' + if CHAM=='DEFORMATION' : motscles['NOM_CHAM'] ='EPSI_ELNO' if CHAM=='EFFORT' : motscles['LIGN_COUPE']=[] diff --git a/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py b/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py index 0f0d1bf7..20867c67 100644 --- a/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py @@ -1,8 +1,8 @@ -#@ MODIF post_decollement_ops Macro DATE 04/10/2010 AUTEUR GREFFET N.GREFFET +#@ MODIF post_decollement_ops Macro DATE 14/03/2011 AUTEUR TARDIEU N.TARDIEU # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -36,7 +36,7 @@ def post_decollement_ops(self,RESULTAT,NOM_CHAM,NOM_CMP,GROUP_MA,INFO,**args): import aster import os,string,types from Accas import _F - from Utilitai.Utmess import UTMESS + from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme ### On importe les definitions des commandes a utiliser dans la macro @@ -66,10 +66,19 @@ def post_decollement_ops(self,RESULTAT,NOM_CHAM,NOM_CMP,GROUP_MA,INFO,**args): 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 = 'DKT'),) + 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, diff --git a/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py b/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py index 167322e3..6004fa97 100644 --- a/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py @@ -1,8 +1,8 @@ -#@ MODIF post_endo_fiss_ops Macro DATE 12/07/2010 AUTEUR BERARD A.BERARD +#@ MODIF post_endo_fiss_ops Macro DATE 02/02/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -236,7 +236,7 @@ def post_endo_fiss_ops(self, # TEST SUR LE TYPE DE CHAMP # ltyP_cham = ['NOEU_DEPL_R','ELGA_EPSI_R','ELNO_EPSI_R','NOEU_SIEF_R','ELGA_VARI_R','ELNO_VARI_R','ELNO_VARI_R','NOEU_VAR2_R'] - lnoM_cham = ['DEPL','EPSI_ELGA_DEPL','EPSI_ELNO_DEPL','EPSI_NOEU_DEPL','VARI_ELGA','VARI_ELNO','VARI_ELNO_ELGA','VARI_NOEU_ELGA'] + lnoM_cham = ['DEPL','EPSI_ELGA','EPSI_ELNO','EPSI_NOEU','VARI_ELGA','VARI_ELNO','VARI_ELNO','VARI_NOEU'] if NOM_CHAM in lnoM_cham : Xtype_cham = ltyP_cham[lnoM_cham.index(NOM_CHAM)] @@ -423,7 +423,7 @@ def post_endo_fiss_ops(self, PHENOMENE = 'MECANIQUE', MODELISATION = 'BARRE'),) - __YBARPR = PROJ_CHAMP(METHODE = 'COLOCATION', + __YBARPR = PROJ_CHAMP(METHODE = 'COLLOCATION', RESULTAT = __resu, MODELE_1 = __modtot, MODELE_2 = __MO, @@ -537,7 +537,7 @@ def post_endo_fiss_ops(self, PHENOMENE = 'MECANIQUE', MODELISATION = 'BARRE'),) - __YBARPR = PROJ_CHAMP(METHODE = 'COLOCATION', + __YBARPR = PROJ_CHAMP(METHODE = 'COLLOCATION', RESULTAT = __resu, MODELE_1 = __modtot, MODELE_2 = __MO, @@ -683,7 +683,7 @@ def post_endo_fiss_ops(self, try: # on essaie de projeter, exception: il n'y a pas des points "dans la matiere" - __YBARPR = PROJ_CHAMP(METHODE = 'COLOCATION', + __YBARPR = PROJ_CHAMP(METHODE = 'COLLOCATION', RESULTAT = __resu, MODELE_1 = __modtot, MODELE_2 = __MO, diff --git a/Aster/Cata/cataSTA10/Macro/post_gp_ops.py b/Aster/Cata/cataSTA10/Macro/post_gp_ops.py index 4a02d8f6..7cf700e8 100644 --- a/Aster/Cata/cataSTA10/Macro/post_gp_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_gp_ops.py @@ -1,8 +1,8 @@ -#@ MODIF post_gp_ops Macro DATE 30/08/2010 AUTEUR MACOCCO K.MACOCCO +#@ MODIF post_gp_ops Macro DATE 29/03/2011 AUTEUR MACOCCO K.MACOCCO # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -48,52 +48,54 @@ def post_gp_ops(self, **args): CALC_ELEM = self.get_cmd('CALC_ELEM') RECU_FONCTION = self.get_cmd('RECU_FONCTION') DEFI_GROUP = self.get_cmd('DEFI_GROUP') + EXTR_RESU = self.get_cmd('EXTR_RESU') DETRUIRE = self.get_cmd('DETRUIRE') FIN = self.get_cmd('FIN') tmp_liste_inst_postgp = [] + #---------------------------------------------------------- # ----- Comptage, commandes + déclaration concept sortant + #---------------------------------------------------------- self.set_icmd(1) self.DeclareOut('result', self.sd) self.DeclareOut('tabresult', self['TABL_GPMAX']) if (self['TABL_GP']!= None ): - self.DeclareOut('tabgp', self['TABL_GP']) - if (self['LIST_INST']!=None) : - LIST_INST = self['LIST_INST'] - tmp_list_inst1 = aster.getvectjev(string.ljust(LIST_INST.nom,19)+'.VALE') - for itmp in tmp_list_inst1 : - tmp_liste_inst_postgp.append(itmp) - if (self['INST']!=None) : - tmp_INST = self['INST'] - for jtmp in tmp_INST : - tmp_liste_inst_postgp.append(jtmp) - - liste_inst_postgp = list(set(tmp_liste_inst_postgp)) - liste_inst_postgp.sort() + self.DeclareOut('tabgp', self['TABL_GP']) + + liste_inst_post = self['LIST_INST'] + Resultat = EXTR_RESU(RESULTAT=self['RESULTAT'],ARCHIVAGE=_F(LIST_INST=liste_inst_post)) + liste_inst_postgp = aster.getvectjev(string.ljust(liste_inst_post.nom,19)+'.VALE') + + #---------------------------------------------------------- # ---- Recuperation du nombre d'instants deja calculés - num_ord = len(NP.nonzero(aster.getvectjev(string.ljust(self['RESULTAT'].nom,19)+'.ORDR '))[0]) + #---------------------------------------------------------- + if aster.getvectjev(string.ljust(Resultat.nom,19)+'.ORDR ').__contains__(0):UTMESS('F','POST0_37') + num_ord = len(aster.getvectjev(string.ljust(Resultat.nom,19)+'.ORDR ')) + liste_ord = aster.getvectjev(string.ljust(Resultat.nom,19)+'.ORDR ') + # Cas 2D if self['THETA_2D'] is not None: is_2D = True else: is_2D = False + UTMESS('A','POST0_38') + # TABLE GP à remplier pour 3D + liste_3d_inst = [] + liste_3d_lieu = [] + liste_3d_icop = [] + liste_3d_deltal = [] + liste_3d_gp = [] info = self['INFO'] type_def = self['TYPE_DEF'] - # TABLE GP à remplier pour 3D - liste_3d_inst = [] - liste_3d_lieu = [] - liste_3d_icop = [] - liste_3d_deltal = [] - liste_3d_gp = [] - - + #---------------------------------------------------------- # 0. ----- Type de calcul + #---------------------------------------------------------- identification = self['IDENTIFICATION'] != None if identification: # 0.1. --- identification : on boucle sur les valeurs de TEMP. @@ -120,19 +122,25 @@ def post_gp_ops(self, **args): l_crit = [l_crit,] + #---------------------------------------------------------- # Maillage associe au modele + #---------------------------------------------------------- __MAIL = aster.getvectjev( self['MODELE'].nom.ljust(8) + '.MODELE .LGRF ' ) nom_maillage = __MAIL[0].strip() maya = self.get_concept(nom_maillage) ltyma =aster.getvectjev("&CATA.TM.NOMTM") + #---------------------------------------------------------- # Excitation + #---------------------------------------------------------- args={} if self['EXCIT']:args={'EXCIT' : self['EXCIT'].List_F()} + #---------------------------------------------------------- # 1. ----- calcul de G-theta + #---------------------------------------------------------- if is_2D: nbcour = len(self['THETA_2D']) @@ -148,7 +156,7 @@ def post_gp_ops(self, **args): R_SUP=dMC['R_SUP']),) __gtheta = CALC_G(THETA=_F(THETA=__theta), - RESULTAT=self['RESULTAT'], + RESULTAT=Resultat, TOUT_ORDRE='OUI', SYME_CHAR=self['SYME_CHAR'], COMP_ELAS=self['COMP_ELAS'].List_F(), @@ -158,21 +166,22 @@ def post_gp_ops(self, **args): # une Table par couronne l_tab.append(tab) - + else: #Cas 3D nbcour = len(self['THETA_3D']) l_tab = [] l_noeuds_fissure, pas = getFondFissInfo(self['FOND_FISS']) nb_noeuds_fissure = len(l_noeuds_fissure) + FOND_FISS = self['FOND_FISS'] + lnormale = aster.getvectjev(FOND_FISS.nom.ljust(8)+'.NORMALE ') + if (lnormale==None):UTMESS('F','POST0_39') for occ in self['THETA_3D']: dMC = occ.cree_dict_valeurs(occ.mc_liste) # on met les mots-clés facultatifs dans des dictionnaires dpar_theta = {} - if self['DIRECTION'] is not None: - dpar_theta['DIRECTION'] = self['DIRECTION'] __gtheta = CALC_G( THETA=_F(R_INF=dMC['R_INF'], @@ -180,7 +189,7 @@ def post_gp_ops(self, **args): MODULE=1.0, FOND_FISS=self['FOND_FISS'], **dpar_theta), - RESULTAT=self['RESULTAT'], + RESULTAT=Resultat, TOUT_ORDRE='OUI', SYME_CHAR=self['SYME_CHAR'], COMP_ELAS=self['COMP_ELAS'].List_F(), @@ -193,8 +202,11 @@ def post_gp_ops(self, **args): # une Table par couronne l_tab.append(tab) - # 1.1.----- calcul de la mesure des mailles appartenant à l'axe de symétrie - # ou au plan de symétrie + #---------------------------------------------------------- + # 1.1.----- calcul de la mesure des mailles + # appartenant à l'axe de symétrie + # ou au plan de symétrie + #---------------------------------------------------------- l_copo_tot = [] l_ep_copeaux_tot_3D = [] for tmpocc in self['TRANCHE']: @@ -210,36 +222,34 @@ def post_gp_ops(self, **args): if is_2D: # Récupération des noeuds appartenant à la droite de symétrie # le vecteur normal est construit comme étant perpendiculaire au vecteur direction - if (self['DIRECTION'][0]==1.): - ldirection = (0.,1.) - elif (self['DIRECTION'][1]==1.): - ldirection = (1.,0.) + # La commande CALC_THETA/THETA_2D suppose que la composante suivant z est nulle + lnormale = (self['DIRECTION'][1],self['DIRECTION'][0]) Nds_fdfiss = dMC['GROUP_NO'] - Recup_Noeuds_Surf(is_2D,maya,Nds_fdfiss,ldirection) - mesure = Calcul_mesure_2D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,self['RESULTAT'],type_def) + Recup_Noeuds_Surf(is_2D,maya,Nds_fdfiss,lnormale) + mesure = Calcul_mesure_2D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,Resultat,type_def) else: # Récupération des noeuds appartenant à la surface de symétrie # le vecteur normal est récuperé dans FOND_FISS FOND_FISS = self['FOND_FISS'] - ldirection = aster.getvectjev(FOND_FISS.nom.ljust(8)+'.NORMALE ') - Recup_Noeuds_Surf(is_2D,maya,l_noeuds_fissure[0],ldirection,l_noeuds_fissure) - mesure, l_ep_copeaux_tot_3D = Calcul_mesure_3D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,self['RESULTAT'],type_def) - Supr_mano(maya) + Recup_Noeuds_Surf(is_2D,maya,l_noeuds_fissure[0],lnormale,l_noeuds_fissure) + mesure, l_ep_copeaux_tot_3D = Calcul_mesure_3D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,Resultat,type_def) + l_ep_copeaux_tot_3D = l_ep_copeaux_tot_3D*num_ord + + #---------------------------------------------------------- # 2. ----- Calcul de l'energie élastique en exploitant les groupes de # mailles fournis par la procedure de maillage + #---------------------------------------------------------- l_ep_copeaux_tot = [] - for it in range(num_ord): - for k in range(0,len(l_copo_tot)) : - Copeau_k = l_copo_tot[k] + for it in range(len(liste_ord)): + for Copeau_k in l_copo_tot : l_ep_copeaux_tot.append(mesure[Copeau_k][it]) - l_ep_copeaux_tot_3D=l_ep_copeaux_tot_3D*num_ord l_t_enel = [] if self['TRAC_COMP']=='OUI': # prise en compte de la traction-compression dans le calcul de l'energie - resu2=CALC_ELEM(OPTION=('EQUI_ELNO_SIGM'), - RESULTAT=self['RESULTAT'], + resu2=CALC_ELEM(OPTION=('SIEQ_ELNO'), + RESULTAT=Resultat, ) # indices des mailles du dernier group_ma @@ -305,7 +315,7 @@ def post_gp_ops(self, **args): d_nomma[id_elem]=elem E_el[kk] = POST_ELEM(MODELE=self['MODELE'], - RESULTAT=self['RESULTAT'], + RESULTAT=Resultat, TOUT_ORDRE='OUI', ENER_ELAS=_F(MAILLE=elem), TITRE='Energie élastique', @@ -315,7 +325,7 @@ def post_gp_ops(self, **args): l_enel = T_el[kk].TOTALE.values() - # signe de la trace <=> signe de la composante VMIS_SG du tenseur EQUI_ELNO_SIGM, + # signe de la trace <=> signe de la composante VMIS_SG du tenseur SIEQ_ELNO, # mais E_enel est par element => on fait une moyenne sur les noeuds de l'element list_no = [] @@ -335,7 +345,7 @@ def post_gp_ops(self, **args): __VM=RECU_FONCTION(RESULTAT=resu2, TOUT_INST='OUI', - NOM_CHAM='EQUI_ELNO_SIGM', + NOM_CHAM='SIEQ_ELNO', NOM_CMP='VMIS_SG', MAILLE=elem, NOEUD=noeud); @@ -420,7 +430,7 @@ def post_gp_ops(self, **args): # calcul classique de l'energie elastique __ener = POST_ELEM(MODELE=self['MODELE'], - RESULTAT=self['RESULTAT'], + RESULTAT=Resultat, TOUT_ORDRE='OUI', ENER_ELAS=_F(GROUP_MA=l_copo), TITRE='Energie élastique', @@ -466,15 +476,6 @@ def post_gp_ops(self, **args): # 2.3. ----- Tableau de Gp = f(icop) pour chaque instant -############################################################################################### -# BESOIN D4AFFICHE TABLEAU GP pour chque instant dans fichier mess -# print "####Dana_tGp_t_icop####" -# Dana_tGp_t_icop = t_enel['INST', 'LIEU', 'ICOP', 'DELTAL', 'GP'] -# Dana_tGp_t_icop.titr = "Dana Gp à chaque instant en fonction de la distance au " \ -# "fond d'entaille" -# Dana_tGp_t_icop.ImprTableau() -############################################################################################### - if info >= 2: tGp_t_icop = t_enel['INST', 'DELTAL', 'GP'] tGp_t_icop.titr = "Gp à chaque instant en fonction de la distance au " \ @@ -502,7 +503,7 @@ def post_gp_ops(self, **args): if len(t.GP.values())>1: t = t.DELTAL.MINI() - if j == 1: + if l_numord.index(j) == 0: tb_Gpmax_i = t else: tb_Gpmax_i = tb_Gpmax_i | t @@ -639,8 +640,8 @@ def post_gp_ops(self, **args): tab=mergeLineInTable(tab, t_relev, nb_noeuds_fissure) # en 3D, le paramètre R n'intervient pas - tab.fromfunction(new_para, fKj, ('G_LOCAL', 'YOUNG', 'NU')) - tab.Renomme('G_LOCAL', 'G_%d' % (k + 1)) + tab.fromfunction(new_para, fKj, ('G', 'YOUNG', 'NU')) + tab.Renomme('G', 'G_%d' % (k + 1)) l_tabi.append(tab) @@ -710,12 +711,24 @@ def post_gp_ops(self, **args): d_para.update({ 'NOM_PARA' : 'KMOY', 'NOM_RESU' : 'INST', }) valkmoy = tabres.KMOY.values() - # temps en fonction de Kmoy - finv = t_fonction(valkmoy, tabres.INST.values(), d_para) + if len(liste_inst_postgp) == 1 : + # si un seul instant alors + ti = liste_inst_postgp[0] + else: - # valeurs à mettre dans la table - # temps correspondant à KJ_CRIT - ti = finv(KJ_CRIT) + # temps en fonction de Kmoy + finv = t_fonction(valkmoy, tabres.INST.values(), d_para) + + # valeurs à mettre dans la table + # temps correspondant à KJ_CRIT + ti = finv(KJ_CRIT) + ind_instant_plus = [x > ti for x in liste_inst_postgp].index(True) + if (abs(liste_inst_postgp[ind_instant_plus-1]-ti)/ti) <= 1e-4: + ti = liste_inst_postgp[ind_instant_plus-1] + elif (abs(liste_inst_postgp[ind_instant_plus]-ti)/ti) <= 1e-4: + ti = liste_inst_postgp[ind_instant_plus] + else: + UTMESS('A','POST0_36',valr =tuple(liste_inst_postgp[ind_instant_plus-1:ind_instant_plus+1])) # GP correspondant au temps critique if (message_kjcritique_non_atteint == 1) : @@ -746,46 +759,55 @@ def post_gp_ops(self, **args): else: - l_i_noeuds_sommets = range(0,len(l_noeuds_fissure),pas) - t_noeud_Kcrit = Table(para=tabres.para) - - # On determine quel noeud sommet maximise KMOY au cours du temps: - row_KMOY_max = tabres.KMOY.MAXI() noeud_KMOY_max = row_KMOY_max.NOEUD.values()[0] - - # avec le noeud ou KJ_CRIT est atteint, on regarde GP a gauche et a droite. - # le GP le plus grand correspond au GPmax - # on garde la tranche ou GP est le plus grand - - id_noeud_KMOY_max = list(l_noeuds_fissure).index(noeud_KMOY_max) - if id_noeud_KMOY_max==0: - # "Gpmax sur la 1ere tranche" - nume_tranche_Gpmax = 1 - elif id_noeud_KMOY_max==(len(l_noeuds_fissure)-1): - # "Gpmax sur la derniere tranche" - nume_tranche_Gpmax = nb_tranches - else: - # "Gpmax sur une tranche intermediaire" - Gpi_tot = Table(para=tb_Gpmax.para) - Gpi_gauche = tb_Gpmax.NUME_TRANCHE==(id_noeud_KMOY_max/pas) - Gpi_tot.append(Gpi_gauche.rows[0]) - Gpi_droite = tb_Gpmax.NUME_TRANCHE==(id_noeud_KMOY_max/pas+1) - Gpi_tot.append(Gpi_droite.rows[0]) - Gpi_tab = Gpi_tot.GPMAX.MAXI() - nume_tranche_Gpmax = Gpi_tab.NUME_TRANCHE.values()[0] - - # tb_Gpmax_TrancheCrit est une table de la meme nature que la table 2D tb_Gpmax - # i.e. valeurs sur la seule tranche qui nous interesse (ou on sait - # que KJ_CRIT sera atteint) - - tb_Gpmax_TrancheCrit = tb_Gpmax.NUME_TRANCHE==nume_tranche_Gpmax - - # avec le noeud ou KJ_CRIT est atteint, on determine le temps - # critique par interpolation + Gpi = 0.0 + nume_tranche_kjcrit = 0 + # On determine par interpolation le temps critique ou KJ_CRIT est atteint tabres_NoeudCrit = tabres.NOEUD==noeud_KMOY_max - - # la suite est idem 2D, seuls les noms des tables changent + d_para.update({ 'NOM_PARA' : 'KMOY', + 'NOM_RESU' : 'INST', }) + valkmoy = tabres_NoeudCrit.KMOY.values() + if len(liste_inst_postgp) == 1 : + # si un seul instant alors + ti = liste_inst_postgp[0] + else: + + # temps en fonction de Kmoy + finv = t_fonction(valkmoy, tabres_NoeudCrit.INST.values(), d_para) + + # valeurs à mettre dans la table + # temps correspondant a KJ_CRIT + ti = finv(KJ_CRIT) + ind_instant_plus = [x > ti for x in liste_inst_postgp].index(True) + if abs(liste_inst_postgp[ind_instant_plus-1]-ti)/ti < 1e-4: + ti = liste_inst_postgp[ind_instant_plus-1] + elif abs(liste_inst_postgp[ind_instant_plus]-ti)/ti < 1e-4: + ti = liste_inst_postgp[ind_instant_plus] + else: + UTMESS('A','POST0_36',valr =tuple(liste_inst_postgp[ind_instant_plus-1:ind_instant_plus+1])) + + # Gpmax fonction du temps + d_para.update({ 'NOM_PARA' : 'INST','NOM_RESU' : 'GPMAX' }) + for id_noeud_KMOY_max in range(len( tb_Gpmax.NUME_TRANCHE)): + if id_noeud_KMOY_max==0: + # "Gpmax sur la 1ere tranche" + nume_tranche_Gpmax = 1 + elif id_noeud_KMOY_max==(len(l_noeuds_fissure)-1): + # "Gpmax sur la derniere tranche" + nume_tranche_Gpmax = nb_tranches + else: + # "Gpmax sur une tranche intermediaire" + Gpi_tot = Table(para=tb_Gpmax.para) + nume_tranche_Gpmax = tb_Gpmax.NUME_TRANCHE[id_noeud_KMOY_max] + + tb_Gpmax_TrancheCrit = tb_Gpmax.NUME_TRANCHE==nume_tranche_Gpmax + fGp = t_fonction(tb_Gpmax_TrancheCrit.INST.values(), + tb_Gpmax_TrancheCrit.GPMAX.values(), + d_para) + if (Gpi 1e-15: + for j in range(index): + err[j,i] = (kmax[j] - kmin[j]) / kmaxmax + + # filter method 1 line + imeth = 1 + __tabi = CALC_TABLE(TABLE=__tabi, + reuse=__tabi, + ACTION=_F(OPERATION='FILTRE', + CRIT_COMP='EQ', + VALE = imeth, + NOM_PARA='METHODE') + ) + + # rename k parameters + __tabi = CALC_TABLE(TABLE=__tabi, + reuse=__tabi, + ACTION=(_F(OPERATION='RENOMME',NOM_PARA=('K1_MAX','K1')), + _F(OPERATION='RENOMME',NOM_PARA=('K2_MAX','K2')), + _F(OPERATION='RENOMME',NOM_PARA=('G_MAX','G'))) + ) + if ndim == 3: + __tabi = CALC_TABLE(TABLE=__tabi, + reuse=__tabi, + ACTION=_F(OPERATION='RENOMME',NOM_PARA=('K3_MAX','K3')) + ) + + # create error + if ndim != 3: + tab_int = CREA_TABLE(LISTE=(_F(LISTE_R=(tuple(__tabi.EXTR_TABLE().values()['G_MIN'])), PARA='G_MIN'), + _F(LISTE_R=(tuple(err[0].tolist())), PARA='ERR_K1'), + _F(LISTE_R=(tuple(err[1].tolist())), PARA='ERR_K2'))) + else: + tab_int = CREA_TABLE(LISTE=(_F(LISTE_R=(tuple(__tabi.EXTR_TABLE().values()['G_MIN'])), PARA='G_MIN'), + _F(LISTE_R=(tuple(err[0].tolist())), PARA='ERR_K1'), + _F(LISTE_R=(tuple(err[1].tolist())), PARA='ERR_K2'), + _F(LISTE_R=(tuple(err[2].tolist())), PARA='ERR_K3'))) + + # add error + __tabi = CALC_TABLE(TABLE=__tabi,reuse=__tabi,ACTION=(_F(OPERATION='COMB',NOM_PARA='G_MIN',TABLE=tab_int)),INFO=1) + DETRUIRE(CONCEPT=(_F(NOM=tab_int)),INFO=1) + + # remove kj_min + sort data + params = () + if ('INST' in __tabi.EXTR_TABLE().para) : params = ('INST',) + if ('NOEUD_FOND' in __tabi.EXTR_TABLE().para) : + params = params + ('NOEUD_FOND',) + elif ('PT_FOND' in __tabi.EXTR_TABLE().para) : + params = params + ('PT_FOND',) + + if ('ABSC_CURV' in __tabi.EXTR_TABLE().para) : + params = params + ('ABSC_CURV',) + + params = params + ('K1', 'ERR_K1', 'K2', 'ERR_K2',) + if ndim == 3: params = params + ('K3', 'ERR_K3', 'G',) + else: params = params + ('G',) + + __tabi = CALC_TABLE(TABLE=__tabi, + reuse=__tabi,ACTION=(_F(OPERATION='EXTR',NOM_PARA=tuple(params))), + TITRE="CALCUL DES FACTEURS D'INTENSITE DES CONTRAINTES PAR LA METHODE POST_K1_K2_K3") + + return __tabi + +#--------------------------------------------------------------------------------------------------------------- + def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord, Lnofon,dicoF,absfon,Nnoff,tabout) : @@ -1460,7 +1563,7 @@ def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord, CREA_TABLE = self.get_cmd('CREA_TABLE') DETRUIRE = self.get_cmd('DETRUIRE') CALC_TABLE = self.get_cmd('CALC_TABLE') - + mcfact=[] @@ -1496,19 +1599,22 @@ def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord, if (ino==0 and iord==0) and inst==None : tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre) + get_erreur(self,ndim,tabout) elif iord==0 and ino==0 and inst!=None : mcfact=[_F(PARA='INST' ,LISTE_R=[inst,]*3 )]+mcfact tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre) + get_erreur(self,ndim,tabout) else : if inst!=None : mcfact=[_F(PARA='INST' ,LISTE_R=[inst,]*3 )]+mcfact __tabi=CREA_TABLE(LISTE=mcfact,) - npara = ['K1_MAX','METHODE'] + npara = ['K1'] if inst!=None : npara.append('INST') if FOND_FISS and MODELISATION=='3D' : npara.append('NOEUD_FOND') + get_erreur(self,ndim,__tabi) tabout=CALC_TABLE(reuse = tabout, TABLE = tabout, TITRE = titre, @@ -1520,9 +1626,9 @@ def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord, -#--------------------------------------------------------------------------------------------------------------- +#--------------------------------------------------------------------------------------------------------------- # CORPS DE LA MACRO POST_K1_K2_K3 -#--------------------------------------------------------------------------------------------------------------- +#--------------------------------------------------------------------------------------------------------------- def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, TABL_DEPL_SUP,TABL_DEPL_INF,ABSC_CURV_MAXI,PREC_VIS_A_VIS, @@ -1567,7 +1673,6 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE') AFFE_MODELE = self.get_cmd('AFFE_MODELE') PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') - # ------------------------------------------------------------------ # CARACTERISTIQUES MATERIAUX # ------------------------------------------------------------------ @@ -1658,7 +1763,12 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, if FOND_FISS : - MAILLAGE = args['MAILLAGE'] + if RESULTAT : + iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',RESULTAT.nom,'RESULTAT') + MAILLAGE = self.get_concept(nom_ma.strip()) + else: + MAILLAGE = args['MAILLAGE'] + NB_NOEUD_COUPE = args['NB_NOEUD_COUPE'] # Verification du type des mailles de FOND_FISS @@ -1701,7 +1811,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, d_coorf = get_coor_libre(self,Lnoff,RESULTAT,ndim) # Coordonnee d un pt quelconque des levres pour determination sens de propagation - Plev = get_Plev(self,MAILLAGE,ListmaS,RESULTAT) + Plev = get_Plev(self,ListmaS,RESULTAT) # Calcul des normales a chaque noeud du fond if ndim == 3 : @@ -1720,7 +1830,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, MODEL = self.get_concept(n_modele) dmax = PREC_VIS_A_VIS * ABSC_CURV_MAXI - (TlibS,TlibI) = get_tab_dep(self,Lnocal,Nnocal,Nnoff,d_coorf,Lnoff,DTANOR,DTANEX,ABSC_CURV_MAXI,dicVN,sens,RESULTAT,MODEL, + (__TlibS,__TlibI) = get_tab_dep(self,Lnocal,Nnocal,Nnoff,d_coorf,Lnoff,DTANOR,DTANEX,ABSC_CURV_MAXI,dicVN,sens,RESULTAT,MODEL, ListmaS,ListmaI,NB_NOEUD_COUPE,dmax,SYME_CHAR) @@ -1757,7 +1867,12 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, elif FISSURE : - MAILLAGE = args['MAILLAGE'] + if RESULTAT : + iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',RESULTAT.nom,'RESULTAT') + MAILLAGE = self.get_concept(nom_ma.strip()) + else: + MAILLAGE = args['MAILLAGE'] + DTAN_ORIG = args['DTAN_ORIG'] DTAN_EXTR = args['DTAN_EXTR'] dmax = PREC_VIS_A_VIS * ABSC_CURV_MAXI @@ -1768,7 +1883,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, UTMESS('F','RUPTURE0_4') # Recuperation du resultat - __RESX = get_resxfem(self,xcont,RESULTAT,MAILLAGE,MODELISATION,MODEL) + __RESX = get_resxfem(self,xcont,RESULTAT,MODELISATION,MODEL) # Recuperation des coordonnees des points du fond de fissure (x,y,z,absc_curv) (Coorfo, Vpropa, Nnoff) = get_coor_xfem(args,FISSURE,ndim) @@ -1808,8 +1923,8 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, # creation des objets vides s'ils n'existent pas # de maniere a pouvoir les passer en argument des fonctions # c'est pas terrible : il faudrait harmoniser les noms entre les différents cas - if 'TlibS' not in locals() : TlibS = [] - if 'TlibI' not in locals() : TlibI = [] + if '__TlibS' not in locals() : __TlibS = [] + if '__TlibI' not in locals() : __TlibI = [] if 'Lnosup' not in locals() : Lnosup = [] if 'Lnoinf' not in locals() : Lnoinf = [] if 'TTSo' not in locals() : TTSo = [] @@ -1847,9 +1962,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, affiche_traitement(FOND_FISS,INFO,FISSURE,Lnofon,ino) # table 'depsup' et 'depinf' - tabsup = get_tab(self,'sup',ino,TlibS,Lnosup,TTSo, + tabsup = get_tab(self,'sup',ino,__TlibS,Lnosup,TTSo, FOND_FISS,FISSURE,TYPE_MAILLAGE,RESULTAT,SYME_CHAR,TABL_DEPL_SUP,ndim) - tabinf = get_tab(self,'inf',ino,TlibI,Lnoinf,TTSo, + tabinf = get_tab(self,'inf',ino,__TlibI,Lnoinf,TTSo, FOND_FISS,FISSURE,TYPE_MAILLAGE,RESULTAT,SYME_CHAR,TABL_DEPL_INF,ndim) # les instants de post-traitement : creation de l_inst @@ -1925,9 +2040,8 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, tabout=CALC_TABLE(reuse=tabout, TABLE=tabout, ACTION=_F(OPERATION = 'TRI', - NOM_PARA=('INST','ABSC_CURV','METHODE'), + NOM_PARA=('INST','ABSC_CURV'), ORDRE='CROISSANT')) - return ier diff --git a/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py b/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py index d0a3b890..3fbdf989 100644 --- a/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py @@ -1,8 +1,8 @@ -#@ MODIF post_k_trans_ops Macro DATE 07/10/2008 AUTEUR PELLET J.PELLET +#@ MODIF post_k_trans_ops Macro DATE 25/01/2011 AUTEUR MACOCCO K.MACOCCO # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -186,9 +186,9 @@ def post_k_trans_ops(self,RESU_TRANS,K_MODAL,TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, if F3D : K3mod = [None]*n_mode*nbno K3t = [None]*nbarch*nbno - k1 = 'K1_LOCAL' - k2 = 'K2_LOCAL' - k3 = 'K3_LOCAL' + k1 = 'K1' + k2 = 'K2' + k3 = 'K3' else : k1 = 'K1' k2 = 'K2' diff --git a/Aster/Cata/cataSTA10/Macro/post_miss_ops.py b/Aster/Cata/cataSTA10/Macro/post_miss_ops.py new file mode 100644 index 00000000..ee4aac36 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/post_miss_ops.py @@ -0,0 +1,52 @@ +#@ MODIF post_miss_ops Macro DATE 01/03/2011 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE COURTOIS M.COURTOIS + +import sys +import os +import traceback + + +def post_miss_ops(self, **kwargs): + """Macro POST_MISS : + Post-traitement d'un calcul MISS3D + """ + import aster + from Utilitai.Utmess import UTMESS + from Miss.miss_post import PostMissFactory + + ier = 0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # création de l'objet POST_MISS_xxx + post = PostMissFactory(kwargs['OPTION'], self, kwargs) + + try: + post.argument() + post.execute() + post.sortie() + except aster.error, err: + UTMESS('F', err.id_message, valk=err.valk, vali=err.vali, valr=err.valr) + except Exception, err: + trace = ''.join(traceback.format_tb(sys.exc_traceback)) + UTMESS('F', 'SUPERVIS2_5', valk=('POST_MISS', trace, str(err))) + + diff --git a/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py index 04b333fb..34943b92 100644 --- a/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py +++ b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py @@ -1,8 +1,8 @@ -#@ MODIF propa_fiss_ops Macro DATE 24/11/2010 AUTEUR MICOL A.MICOL +#@ MODIF propa_fiss_ops Macro DATE 08/03/2011 AUTEUR MASSIN P.MASSIN # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -18,7 +18,7 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -from math import atan, atan2, cos, sin +from math import atan, atan2, cos, sin, log import numpy as NP from Accas import _F @@ -106,6 +106,7 @@ def betaf(k1,k2) : return beta def recup_Elas(LOI): + from SD.sd_mater import sd_compor1 if LOI == None : UTMESS('F','RUPTURE1_50') dLoi=LOI[0].cree_dict_valeurs(LOI[0].mc_liste) @@ -133,6 +134,29 @@ def recup_Elas(LOI): e = dicmat['E'] nu = dicmat['NU'] return e,nu,dLoi + +def nom_points_fonds(n_taille): + """ + Construction des noms des points en fond de fissure + """ + alphabet = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']; + if n_taille <= 26: + return alphabet[:n_taille] + else: + tab_alphabet = alphabet + taille_tab_alphabet = int(log(n_taille,26)) + for l_let1 in range(1,taille_tab_alphabet): + for l_let2 in range(26): + for l_let3 in range(26): + tab_alphabet = tab_alphabet + [tab_alphabet[(l_let1-1)*26+l_let2]+alphabet[l_let3]] + reste1 = int(n_taille-len(tab_alphabet))/26 + for l_let2 in range(reste1): + for l_let3 in range(26): + tab_alphabet = tab_alphabet + [tab_alphabet[(taille_tab_alphabet-1)*26+l_let2]+alphabet[l_let3]] + reste2 = int(n_taille-len(tab_alphabet)) + for l_let3 in range(reste2): + tab_alphabet = tab_alphabet + [tab_alphabet[(taille_tab_alphabet-1)*26+reste1]+alphabet[l_let3]] + return tab_alphabet #def propa_fiss_ops(self,METHODE_PROPA,TEST_MAIL,INFO,**args): def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): @@ -147,7 +171,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): from Accas import _F from Utilitai.Utmess import UTMESS from Utilitai.partition import MAIL_PY - from SD.sd_mater import sd_compor1 EnumTypes = (ListType, TupleType) @@ -208,10 +231,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): NbPointFond = [] for Fiss in Fissures : - if Fiss['GRILLE_AUX']!=None : - GrilleAux.append(Fiss['GRILLE_AUX']) - else : - GrilleAux.append(args['MODELE']) FissAct.append(Fiss['FISS_ACTUELLE']) FissNou.append(Fiss['FISS_PROPAGEE']) if TEST_MAIL == 'NON': @@ -242,11 +261,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): # propagating crack. for NumFiss in range(0,len(FissAct)) : mcsimp['FISS_PROP'] = FissAct[NumFiss] - mcsimp['GRILLE_AUX'] = 123 - if GrilleAux[NumFiss]!=args['MODELE'] : - mcsimp['GRILLE_AUX'] = GrilleAux[NumFiss] - else : - del mcsimp['GRILLE_AUX'] self.DeclareOut('nomfiss',FissNou[NumFiss]) nomfiss = PROPA_XFEM(METHODE=METHODE_PROPA,INFO=INFO,**mcsimp ) @@ -282,11 +296,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): mcsimp['MODELE'] = __Mod[NumStep-1] mcsimp['FISS_PROP'] = __Fis[(NumStep-1)*len(FissAct)+NumFiss] mcsimp['FISS_INITIALE'] = FissAct[NumFiss] - mcsimp['GRILLE_AUX'] = 123 - if GrilleAux[NumFiss]!=args['MODELE'] : - mcsimp['GRILLE_AUX'] = GrilleAux[NumFiss] - else : - del mcsimp['GRILLE_AUX'] if NumStep==StepTot-1 : self.DeclareOut('nomfiss',FissNou[NumFiss]) nomfiss = PROPA_XFEM(METHODE=METHODE_PROPA,INFO=INFO,**mcsimp ) @@ -308,9 +317,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): #------------------------------------------------------------------ # CAS 2 : METHODE_PROPA = 'MAILLAGE' # -# il faudrait rendre cela plus automatique pour lever la limite a 52 points - ALPHABET=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']; -# 'AA','AB','AC','AD','AE','AF','AG','AH','AI','AJ','AK','AL','AM','AN','AO','AP','AQ','AR','AS','AT','AU','AV','AW','AX','AY','AZ']; if METHODE_PROPA == 'MAILLAGE' : Fissures = args['FISSURE'] @@ -359,146 +365,98 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): UTMESS('F','RUPTURE1_48',vali=Nbfiss) # Recuperation des K et calcul de DeltaK - Nmeth = Fiss['METHODE_POSTK'] SIF = Fiss['TABLE'] nbinst = 1 -# A- TABLEAU ISSSU DE POST_K1_K2_K3 - if (Nmeth != None) : - __TABN = CALC_TABLE(TABLE=SIF,ACTION=_F(OPERATION='FILTRE', - NOM_PARA='METHODE',VALE_I=Nmeth),); - __tabp = __TABN.EXTR_TABLE() - if ('K1_MAX' not in __tabp.para) or ('G_MAX' not in __tabp.para): - UTMESS('F','RUPTURE1_44') - __tab1 = __tabp.values() - nbinst = 1 - if 'INST' in __tabp.para : - l_inst_tab=__tabp['INST'].values()['INST'] - l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() - nbinst = len(l_inst_tab) - nbptfon = len(__tab1['K1_MAX']) / nbinst - R[numfis] = [None]*nbptfon - RmM[numfis] = [None]*nbptfon - DKeq[numfis] = [None]*nbptfon - BETA[numfis] = [None]*nbptfon - absc = [0.]*nbptfon - if nbinst > 1 : - for k in range(nbptfon) : - if (dime == 2) : __tmp = __tabp - if (dime == 3) : __tmp = __tabp.PT_FOND==(k+1) - if (dime == 3) : absc[k]=__tmp['ABSC_CURV'][k] - ddkeq = NP.sqrt(YOUNG)*(NP.sqrt(max(__tmp.values()['G_MAX'])) - - NP.sqrt(min(__tmp.values()['G_MAX']))) - rminmax = NP.sqrt(min(__tmp.values()['G_MAX'])) / NP.sqrt(max(__tmp.values()['G_MAX'])) - DKeq[numfis][k] = [absc[k], ddkeq ] - RmM[numfis][k] = [absc[k], rminmax ] - k1 = __tmp.values()['K1_MAX'] - k2 = __tmp.values()['K2_MAX'] - betat = [0.]*nbinst - for jt in range(nbinst) : - betat[jt] = betaf(k1[jt],k2[jt]) + __tabp = SIF.EXTR_TABLE() + if ('K1' not in __tabp.para) or ('G' not in __tabp.para): + UTMESS('F','RUPTURE1_44') + + __tab1 = __tabp.values() + + if 'INST' in __tabp.para : + l_inst_tab=__tabp['INST'].values()['INST'] + l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() + nbinst = len(l_inst_tab) + nbptfon = len(__tab1['K1']) / nbinst + RmM[numfis] = [None]*nbptfon + DKeq[numfis] = [None]*nbptfon + BETA[numfis] = [None]*nbptfon + +# Lorsque le calcul porte sur plusieurs instants + if nbinst > 1 : + for k in range(nbptfon) : + if (dime == 2) : __tmp = __tabp + if (dime == 3) : + if __tabp.PT_FOND : + __tmp = __tabp.PT_FOND==(k+1) + indice_k = k + else: + __tmp = __tabp.NUM_PT==(k+1) + indice_k = 0 + if ('ABSC_CURV' in __tmp.values()): + abscisse_curv_courante = __tmp.values()['ABSC_CURV'][indice_k] + else: + abscisse_curv_courante = 0. + ddkeq = NP.sqrt(YOUNG)*(NP.sqrt(max(__tmp.values()['G'])) + - NP.sqrt(min(__tmp.values()['G']))) + rminmax = NP.sqrt(min(__tmp.values()['G'])) / NP.sqrt(max(__tmp.values()['G'])) + DKeq[numfis][k] = [abscisse_curv_courante, ddkeq ] + RmM[numfis][k] = [abscisse_curv_courante, rminmax ] + if ('BETA' in __tmp.values()): + dbeta = max(__tmp.values()['BETA'])-min(__tmp.values()['BETA']) + if dbeta > (5./180.*3.1415) : + UTMESS('F','XFEM2_72') + BETA[numfis][k] = [abscisse_curv_courante, __tmp.values()['BETA'][0] ] + else: + if (dime == 2) : + k1 = __tmp.values()['K1'][k] + k2 = __tmp.values()['K2'][k] + BETA[numfis][k]=[0., betaf(k1,k2)] + else: + k1 = __tmp.values()['K1'] + k2 = __tmp.values()['K2'] + betat = [0.]*nbinst + for jt in range(nbinst) : + betat[jt] = betaf(k1[jt],k2[jt]) # ANGLE BETA NE DOIT PAS TROP VARIER ENTRE LES PAS DE TEMPS - dbeta = max(betat) - min(betat) - if dbeta > (5./180.*3.1415) : - UTMESS('F','XFEM2_72') - BETA[numfis][k] = [absc[k], betat[0] ] - VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) - VMAX = max(VMAX,VMAX0 ) - else : - if COMP_LINE == None : - UTMESS('A','XFEM2_76') - CMIN = 0. - CMAX = 1. - else : - CMIN = COMP_LINE['COEF_MULT_MINI'] - CMAX = COMP_LINE['COEF_MULT_MAXI'] - if (min(__tab1['G_MAX']) < 0.) : - UTMESS('F','RUPTURE1_46') - DKmax0 = max(NP.sqrt(__tab1['G_MAX'])) - DKmax = max(DKmax,DKmax0) - for k in range(nbptfon) : - k1 = __tab1['K1_MAX'][k] - k2 = __tab1['K2_MAX'][k] - if (dime == 3) : absc[k]=__tab1['ABSC_CURV'][k] - BETA[numfis][k] = [absc[k] , betaf(k1,k2)] - DKeq[numfis][k] = [absc[k],NP.sqrt(YOUNG)*NP.sqrt(__tab1['G_MAX'][k])] - RmM[numfis][k] = [absc[k], CMIN/CMAX] - VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) - VMAX = max(VMAX,VMAX0 ) -# B- TABLEAU ISSSU DE CALC_G (option CALC_K_G) + dbeta = max(betat) - min(betat) + if dbeta > (5./180.*3.1415) : + UTMESS('F','XFEM2_72') + VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) + VMAX = max(VMAX,VMAX0 ) +# Lorsque le calcul porte un seul instant else : - __tabp = SIF.EXTR_TABLE() - if (dime == 3) and (('K1_LOCAL' not in __tabp.para) or ('G_LOCAL' not in __tabp.para) or ('BETA_LOCAL' not in __tabp.para)): - UTMESS('F','RUPTURE1_45') - if (dime == 2) and (('K1' not in __tabp.para) or ('G' not in __tabp.para)) : - UTMESS('F','RUPTURE1_45') - __tab1= __tabp.values() - if 'INST' in __tabp.para : - l_inst_tab=__tabp['INST'].values()['INST'] - l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() - nbinst = len(l_inst_tab) - if (dime == 2) : nbptfon = 1 - if (dime == 3) : nbptfon = len(__tab1['G_LOCAL']) / nbinst - RmM[numfis] = [None]*nbptfon - DKeq[numfis] = [None]*nbptfon - BETA[numfis] = [None]*nbptfon - if nbinst > 1 : - for k in range(nbptfon) : - if (dime == 3) : - __tmp = __tabp.NUM_PT==(k+1) - if (min(__tmp['G_LOCAL']) < 0.) : - UTMESS('F','RUPTURE1_46') - absc = __tmp.values()['ABSC_CURV'][0] - DKeq[numfis][k]=[absc, NP.sqrt(YOUNG)*(NP.sqrt(max(__tmp.values()['G_LOCAL']))-NP.sqrt(min(__tmp.values()['G_LOCAL'])))] - RmM[numfis][k] = [absc, NP.sqrt(min(__tmp.values()['G_LOCAL'])) / NP.sqrt(max(__tmp.values()['G_LOCAL']))] - dbeta = max(__tmp.values()['BETA_LOCAL'])-min(__tmp.values()['BETA_LOCAL']) - if dbeta > (5./180.*3.1415) : - UTMESS('F','XFEM2_72') - BETA[numfis][k] = [absc, __tmp.values()['BETA_LOCAL'][0] ] - else : - if (min(__tabp.values()['G']) < 0.) : - UTMESS('F','RUPTURE1_46') - DKeq[numfis][k]=[0.,NP.sqrt(YOUNG)*(NP.sqrt(max(__tabp.values()['G']))-NP.sqrt(min(__tabp.values()['G'])))] - RmM[numfis][k] = [0., NP.sqrt(min(__tabp.values()['G'])) / NP.sqrt(max(__tabp.values()['G'])) ] - k1 = __tabp.values()['K1'][0] - k2 = __tabp.values()['K2'][0] - BETA[numfis][k]=[0., betaf(k1,k2)] - VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) - VMAX = max(VMAX,VMAX0 ) - elif dime == 3 : - nbptfon = len(__tab1['G_LOCAL']) - if COMP_LINE == None : - UTMESS('A','XFEM2_76') - CMIN = 0. - CMAX = 1. - else : - CMIN = COMP_LINE['COEF_MULT_MINI'] - CMAX = COMP_LINE['COEF_MULT_MAXI'] - if (min(__tab1['G_LOCAL']) < 0.) : - UTMESS('F','RUPTURE1_46') - DKeq[numfis] = [[__tab1['ABSC_CURV'][i],NP.sqrt(__tab1['G_LOCAL'][i])*NP.sqrt(YOUNG) ] for i in range(nbptfon)] - RmM[numfis] = [[__tab1['ABSC_CURV'][i], CMIN/CMAX] for i in range(nbptfon)] - BETA[numfis] = [[__tab1['ABSC_CURV'][i],__tab1['BETA_LOCAL'][i]] for i in range(nbptfon)] - for i in range(nbptfon) : - VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][i][1],RmM[numfis][i][1]) - VMAX = max(VMAX,VMAX0 ) - else : - nbptfon = 1 - if COMP_LINE == None : - UTMESS('A','XFEM2_76') - CMIN = 0. - CMAX = 1. - else : - CMIN = COMP_LINE['COEF_MULT_MINI'] - CMAX = COMP_LINE['COEF_MULT_MAXI'] - if (min(__tab1['G']) < 0.) : - UTMESS('F','RUPTURE1_46') - DKeq[numfis][0] = [0.,NP.sqrt(YOUNG)*max(NP.sqrt(__tab1['G']))] - k1 = __tab1['K1'][0] - k2 = __tab1['K2'][0] - BETA[numfis][0] = [0.,betaf(k1,k2)] - RmM[numfis][0] = [0.,CMIN/CMAX] - VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][0][1],RmM[numfis][0][1]) - VMAX = max(VMAX,VMAX0 ) + if COMP_LINE == None : + UTMESS('A','XFEM2_76') + CMIN = 0. + CMAX = 1. + else : + CMIN = COMP_LINE['COEF_MULT_MINI'] + CMAX = COMP_LINE['COEF_MULT_MAXI'] + if (min(__tab1['G']) < 0.) : + UTMESS('F','RUPTURE1_46') + + for k in range(nbptfon) : + if (dime == 3) : + if __tabp.PT_FOND : + indice_k = k + else: + indice_k = 0 + if ('ABSC_CURV' in __tabp.para) : + abscisse_curv_courante = __tab1['ABSC_CURV'][k] + else: + abscisse_curv_courante = 0. + DKeq[numfis][k] = [abscisse_curv_courante, NP.sqrt(YOUNG)*NP.sqrt(__tab1['G'][k]) ] + RmM[numfis][k] = [abscisse_curv_courante, CMIN/CMAX ] + if ('BETA' in __tab1.values()): + BETA[numfis][k] = [abscisse_curv_courante, __tab1['BETA'][0] ] + else: + k1 = __tab1['K1'][indice_k] + k2 = __tab1['K2'][indice_k] + BETA[numfis][indice_k]=[abscisse_curv_courante, betaf(k1,k2)] + VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) + VMAX = max(VMAX,VMAX0 ) + numfis = numfis + 1 @@ -576,6 +534,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): DKmax = 1 if (coef_C ==None) : coef_C = Damax + ALPHABET = nom_points_fonds(nbnofo) for ifond in range(nbnofo) : Xf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][0] Yf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][1] @@ -705,6 +664,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): NomNoeudsEnPlus = ['NXA%i' %(it+1)] mm[numfis].cn = NP.concatenate((mm[numfis].cn,LesNoeudsEnPlus)) mm[numfis].correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus ) + ALPHABET = nom_points_fonds(1) # Ajout Maille levre (SEG2) NomMaillesEnPlus = ['MX%s%i' %(ALPHABET[0], it+1)] @@ -783,6 +743,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): NomNoeudsEnPlus = ['NXA0','NXA1'] mm.cn = LesNoeudsEnPlus mm.correspondance_noeuds = tuple( NomNoeudsEnPlus ) + ALPHABET = nom_points_fonds(1) # Ajout Maille levre (SEG2) it = 1 @@ -816,6 +777,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): P1 = args['POINT_EXTR'] dpropa = args['DTAN'] nbpt = args['NB_POINT_FOND'] + ALPHABET = nom_points_fonds(nbpt) Q0 = NP.array([[P0[0]-dpropa[0],P0[1]-dpropa[1],P0[2]-dpropa[2]]]) mm = MAIL_PY() @@ -906,6 +868,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): if abs(verif) > 0.01: UTMESS('F','RUPTURE1_52') nbpt = args['NB_POINT_FOND'] + ALPHABET = nom_points_fonds(nbpt) mm = MAIL_PY() mm.__init__() diff --git a/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py index 000bcb68..eebe3f0c 100644 --- a/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py +++ b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py @@ -1,8 +1,8 @@ -#@ MODIF raff_xfem_ops Macro DATE 12/10/2010 AUTEUR GENIAUT S.GENIAUT +#@ MODIF raff_xfem_ops Macro DATE 03/01/2011 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -32,7 +32,6 @@ def raff_xfem_ops(self,FISSURE,INFO,**args): from types import ListType, TupleType from Accas import _F from SD.sd_xfem import sd_fiss_xfem - from Execution.E_JDC import JDC EnumTypes = (ListType, TupleType) macro = 'RAFF_XFEM' diff --git a/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py index 9effd679..e0dd202e 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py +++ b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py @@ -1,9 +1,9 @@ -#@ MODIF reca_calcul_aster Macro DATE 16/11/2010 AUTEUR ASSIRE A.ASSIRE +#@ MODIF reca_calcul_aster Macro DATE 28/03/2011 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -91,6 +91,8 @@ class CALCUL_ASTER: self.UNITE_GRAPHIQUE = None self.export = None self.follow_output = None + self.unity_follow = None + self.GRADIENT = GRADIENT self.DYNAMIQUE = DYNAMIQUE #self.LANCEMENT = LANCEMENT @@ -194,6 +196,8 @@ class CALCUL_ASTER: export = self.new_export C.follow_output = self.follow_output + C.unity_follow = self.unity_follow + # Lancement des calculs fonctionnelle, gradient = C.run( diff --git a/Aster/Cata/cataSTA10/Macro/reca_mac.py b/Aster/Cata/cataSTA10/Macro/reca_mac.py index f7bf786f..69853c79 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_mac.py +++ b/Aster/Cata/cataSTA10/Macro/reca_mac.py @@ -1,8 +1,8 @@ -#@ MODIF reca_mac Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF reca_mac Macro DATE 03/01/2011 AUTEUR BODEL C.BODEL # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -24,9 +24,6 @@ recalage en dynamique ''' import numpy as NP -from Tkinter import Tk, Frame, StringVar, Entry, Label, Button -from Meidee.modes import MacWindowFrame - def extract_mac_array( mac_mode ): data1 = mac_mode.EXTR_TABLE().Array('NUME_MODE_1','MAC') @@ -52,6 +49,9 @@ def get_modes(resu): class fenetre_mac: def __init__(self,resu1,resu2,mac): + from Calc_essai.outils_ihm import MacWindowFrame + from Tkinter import Tk, Frame, StringVar, Entry, Label, Button + self.resu1 = resu1 self.resu2 = resu2 self.mac = mac diff --git a/Aster/Cata/cataSTA10/Macro/recal.py b/Aster/Cata/cataSTA10/Macro/recal.py index ec128ecb..9a878761 100644 --- a/Aster/Cata/cataSTA10/Macro/recal.py +++ b/Aster/Cata/cataSTA10/Macro/recal.py @@ -1,8 +1,8 @@ -#@ MODIF recal Macro DATE 16/11/2010 AUTEUR ASSIRE A.ASSIRE +#@ MODIF recal Macro DATE 28/03/2011 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -76,6 +76,40 @@ except: if code=='F': sys.exit() +# ------------------------------------------------------------------------------- +def affiche(unity, filename, label='', filetype='stderr'): + """ Affiche un fichier dans l'output courant (methode utilisee pour l'affichage + du stdout et/ou du stderr + """ + try: + f=open(filename, 'r') + txt = f.read() + txt = """ + +============================ %s (%s) ============================= + + +%s + + +====================================================================== +====================================================================== + +""" % (label, filetype, txt) + + f.close() + + if unity: + fw=open('fort.%s' % str(unity), 'a') + fw.write( txt ) + fw.close() + else: + print txt + except Exception, e: + print e + return + + # # ------------------------------------------------------------------------------- # def find_parameter(content, param): # """ @@ -135,7 +169,7 @@ def make_include_files(UNITE_INCLUDE, calcul, parametres): sys.path.append(os.path.join(ASTER_ROOT, 'lib', 'python%s.%s' % (sys.version_info[0], sys.version_info[1] ) , 'site-packages')) except: pass try: - from asrun.utils import find_command, search_enclosed + from asrun.common.utils import find_command, search_enclosed except Exception, e: print e UTMESS('F','RECAL0_99') @@ -365,6 +399,10 @@ class CALCULS_ASTER: self.jdc = jdc + self.follow_output = False + self.unity_follow = None + + self.list_params = [x[0] for x in parametres] self.list_params.sort() @@ -676,8 +714,7 @@ class CALCULS_ASTER: try: from asrun.run import AsRunFactory from asrun.profil import ASTER_PROFIL - from asrun.common_func import get_hostrc - from asrun.utils import get_timeout + from asrun.repart import get_hostrc from asrun.parametric import is_list_of_dict from asrun.thread import Dispatcher from asrun.distrib import DistribParametricTask @@ -694,7 +731,9 @@ class CALCULS_ASTER: # ---------------------------------------------------------------------------- sys.argv = [''] run = AsRunFactory() - if info<=2: run.options['debug_stderr'] = False # pas d'output d'executions des esclaves dans l'output maitre + #if info<=2: run.options['debug_stderr'] = False # pas d'output d'executions des esclaves dans l'output maitre + if self.unity_follow and info==2: run.options['debug_stderr'] = True + else: run.options['debug_stderr'] = False # pas d'output d'executions des esclaves dans l'output maitre # Master profile prof = ASTER_PROFIL(filename=export) @@ -755,7 +794,7 @@ class CALCULS_ASTER: hostrc = get_hostrc(run, prof) # timeout before rejected a job - timeout = get_timeout(prof) + timeout = prof.get_timeout() # Ajout des impressions de tables a la fin du .comm @@ -816,22 +855,29 @@ class CALCULS_ASTER: else: output_filename = '' d_diag[label] = diag + # Affichage de l'output de l'esclave dans l'output du maitre + if self.unity_follow: + affiche(unity=self.unity_follow, filename=output_filename, label=label, filetype='stdout') + + # Calcul esclave NOOK if not diag[0:2] in ['OK', '_NOT_RUN', '_NOT_SUBMITTED']: UTMESS('F', 'RECAL0_86', valk=(label, diag)) else: UTMESS('A', 'RECAL0_83', valk=(label, output_filename)) -# # Affichage de l'output -# try: -# f=open(output_filename, 'r') -# print f.read() -# f.close() -# except: pass - if not d_diag: - UTMESS('F', 'RECAL0_84', valk=resudir) + UTMESS('F', 'RECAL0_84', valk=resudir) self.list_diag = [ d_diag[label] for label in labels ] # ---------------------------------------------------------------------------- diff --git a/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py index 4085050a..4f6f9cbc 100644 --- a/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py +++ b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py @@ -1,8 +1,8 @@ -#@ MODIF simu_point_mat_ops Macro DATE 05/07/2010 AUTEUR PROIX J-M.PROIX +#@ MODIF simu_point_mat_ops Macro DATE 28/02/2011 AUTEUR PROIX J-M.PROIX # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -50,6 +50,7 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT, from Accas import _F from Utilitai.UniteAster import UniteAster from Utilitai.Utmess import UTMESS + from Noyau.N_types import is_enum # -- Tests de cohérence __fonczero = DEFI_FONCTION(NOM_PARA = 'INST', @@ -60,12 +61,16 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT, CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'] CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'] + if COMP_INCR : + lcomp = COMP_INCR.List_F()[0] + if COMP_ELAS : + lcomp = COMP_ELAS.List_F()[0] + if SUPPORT != None : if SUPPORT=='ELEMENT': itetra=1 if itetra==0 : if COMP_INCR != None : - lcomp = COMP_INCR.List_F()[0] if lcomp['DEFORMATION'] != 'PETIT' : itetra=1 UTMESS('A','COMPOR2_1',valk=lcomp['DEFORMATION'] ) @@ -436,26 +441,33 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT, lvarc = args['AFFE_VARC'].List_F() nbvarc=len(lvarc) for ivarc in range(nbvarc) : - typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_F' dico={} - __CHVARC=CREA_CHAMP(TYPE_CHAM=typech, - OPERATION='AFFE', - MAILLAGE=__MA, - AFFE=_F(MAILLE='VOLUME', + 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_F=lvarc[ivarc]['VALE_FONC'], + VALE=lordo[it], ), - ), - __LIST2 = INCREMENT.List_F()[0]['LIST_INST'] - __TEMP=CREA_RESU(OPERATION='AFFE',TYPE_RESU='EVOL_THER',NOM_CHAM='TEMP', - AFFE = _F(CHAM_GD = __CHVARC,LIST_INST = __LIST2,), - ) + ), + 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"]=__TEMP + dico["EVOL"]=__EVOV dico["NOM_VARC"]=lvarc[ivarc]['NOM_VARC'] if lvarc[ivarc]['VALE_REF'] != None: dico["VALE_REF"]=lvarc[ivarc]['VALE_REF'] - mcvarc.append(dico) + mcvarc.append(dico) # -- Materiau et modele if len(mcvarc) > 0 : __CHMAT=AFFE_MATERIAU(MAILLAGE=__MA,AFFE = _F(MAILLE='VOLUME',MATER=MATER), @@ -491,6 +503,8 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT, lnomneu=[] lnomvar=[] VARINI=VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste) + if (not is_enum(VARINI['VALE'])) : + VARINI['VALE'] = [VARINI['VALE'],] nbvari=len(VARINI['VALE']) for i in range(nbvari): lnomneu.append('X'+str(i+1)) @@ -617,43 +631,48 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT, EXCIT = l_char,**motscles) + if lcomp['DEFORMATION'] != 'PETIT' : + nomepsi='EPSG_ELNO' + else : + nomepsi='EPSI_ELNO' + __EVOL1 = CALC_ELEM(reuse = __EVOL1,RESULTAT = __EVOL1, - OPTION = ('SIEF_ELNO_ELGA','EPSI_ELNO_DEPL','VARI_ELNO_ELGA')) + OPTION = ('SIEF_ELNO',nomepsi,'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='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),TYPE_CHAM='TENS_3D',), - _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),TYPE_CHAM='TENS_3D',), + _F(NOM_CHAM='SIEF_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',), ), DEFI_REPERE=_F(REPERE='UTILISATEUR',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='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY'),TYPE_CHAM='TENS_2D',), - _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY'),TYPE_CHAM='TENS_2D',), + _F(NOM_CHAM='SIEF_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',), ), DEFI_REPERE=_F(REPERE='UTILISATEUR',ANGL_NAUT=angles),); # -- Recuperation des courbes __REP_VARI = POST_RELEVE_T(ACTION = ( - _F(INTITULE='VARI_INT',RESULTAT=__EVOL1,NOM_CHAM='VARI_ELNO_ELGA', + _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='EPSI_ELNO_DEPL', + _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 = 'SIEF_ELNO_ELGA', + _F(INTITULE = 'SIGMA',RESULTAT = __EVOL,NOM_CHAM = 'SIEF_ELNO', TOUT_CMP = 'OUI',OPERATION = 'EXTRACTION',NOEUD = 'P0'),)) __REP_INV = POST_RELEVE_T(ACTION = ( - _F(INTITULE = 'INV',RESULTAT = __EVOL,NOM_CHAM = 'SIEF_ELNO_ELGA', + _F(INTITULE = 'INV',RESULTAT = __EVOL,NOM_CHAM = 'SIEF_ELNO', INVARIANT = 'OUI',OPERATION = 'EXTRACTION',NOEUD = 'P0'),)) __REP_INV=CALC_TABLE( TABLE=__REP_INV,reuse=__REP_INV, diff --git a/Aster/Cata/cataSTA10/Macro/test_compor_ops.py b/Aster/Cata/cataSTA10/Macro/test_compor_ops.py new file mode 100644 index 00000000..62b22ff4 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/test_compor_ops.py @@ -0,0 +1,783 @@ +#@ MODIF test_compor_ops Macro DATE 21/02/2011 AUTEUR ABBAS M.ABBAS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +# MACRO "TEST_COMPOR" +# ---------------------------- + +####################################################################### +# utilitaires +####################################################################### +def PROD_ROT(X1,X2): + # calcul Produit de 2 vecteurs pour les coef de rotations + # dimension de X1 et X2 liste de 3 scalaire resultat liste de 6 scalaires + if (len(X1)==len(X2)==3) : + Y=[None]*6 + V_ind=[[0,0,0.5],[1,1,0.5],[2,2,0.5],[0,1,1.0],[0,2,1.0],[1,2,1.0]] + for ind in V_ind: + i=V_ind.index(ind) + ind1,ind2,coef=ind[0],ind[1],ind[2] + Y[i]=coef*(X1[ind1]*X2[ind2]+X1[ind2]*X2[ind1]) + return Y + else : + print "CALCUL PROD_ROT IMPOSSIBLE, dimensions innatendues" + return None +####################################################################### +def RENOMME(self,i,N_pas,label_cal,ch_param,_RES,_RSI): +# On renomme les composantes en fonction de l'ordre de discrétisation + from Accas import _F + DETRUIRE = self.get_cmd('DETRUIRE') + CALC_TABLE = self.get_cmd('CALC_TABLE') + N = N_pas[i] + chN=label_cal[i]+str(N) + for ch in ch_param: + j=ch_param.index(ch) + chnew=ch+chN + ##Extraction par type de variable + if _RSI[j] == None: + _RSI[j]=CALC_TABLE( TABLE=_RES[i], + TITRE = ' ', + ACTION=( _F(OPERATION='EXTR', + NOM_PARA=('INST',ch,),), + _F(OPERATION='RENOMME', + NOM_PARA=(ch,chnew,),), + ),); + else: + TMP_S=CALC_TABLE( TABLE=_RES[i], + TITRE = ' ', + ACTION=( _F(OPERATION='EXTR', + NOM_PARA=('INST',ch,),), + _F(OPERATION='RENOMME', + NOM_PARA=(ch,chnew,),), + ),); + _RSI[j]=CALC_TABLE( reuse=_RSI[j], TABLE=_RSI[j], + TITRE = ' ', + ACTION=( _F(OPERATION='COMB', + TABLE=TMP_S,NOM_PARA='INST',), + ),); + DETRUIRE ( CONCEPT = _F (NOM = TMP_S,),INFO=1) + + + return _RSI +####################################################################### + +def ERREUR(X,Xref,prec_zero,coef): + "calcul erreur relative entre deux nombres" + if (abs(Xref)0 and i<9) : coef = 1/C_Pa + iref = 0 + else : + iref =1 + if (i==0) : CH_V1.append(ch_cal) +# calcul de l'erreur (ecart relatif) + valfor='ERREUR(%s,%s,%e,%f)' % (ch_cal,chref[iref],preczero,coef) + nompar1='%s' % (ch_cal ) + nompar2='%s' % (chref[iref] ) + ERR_REL = FORMULE(NOM_PARA=(nompar1,nompar2),VALE=valfor) + if _ERSI[i] == None : + _ERSI[i] = CALC_TABLE(TABLE =_RSI[i], + TITRE = '_RSI'+str(j), + ACTION = (_F(OPERATION='OPER',NOM_PARA=ch_err, + FORMULE=ERR_REL), + ),); + else : + _ERSI[i] = CALC_TABLE(TABLE =_ERSI[i], reuse=_ERSI[i], + TITRE = '_RSI'+str(j), + ACTION = (_F(OPERATION='OPER',NOM_PARA=ch_err, + FORMULE=ERR_REL), + ),); + DETRUIRE ( CONCEPT = _F (NOM = ERR_REL,),INFO=1) + return _ERSI + +####################################################################### + +def CHAR3D(self,POISSON,YOUNG,_tempsar,INFO): + CALC_FONCTION = self.get_cmd('CALC_FONCTION') + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') + IMPR_FONCTION = self.get_cmd('IMPR_FONCTION') + from Accas import _F + import numpy as NP + + ################################################################################## + + # definition du trajet de chargement 3D + + ####################################################################### + #fonctions chargement + calibrage = 3.5; + Ctau = ((2 * calibrage) * ((1 + POISSON) / (2 * YOUNG))); + Ctrac = (calibrage * (1 / YOUNG)); + _Ytrace=DEFI_LIST_REEL( VALE = (0., 150., 150., -50, 0., 50., -150., -150., 0.),) + _Trace=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= _Ytrace, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + _YDevi_1=DEFI_LIST_REEL( VALE = (0., 75., 150., 150, 0., -150., -150., -75., 0.),) + _Devi_1=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= _YDevi_1, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + _YDevi_2=DEFI_LIST_REEL( VALE = (0., 75., -50., 100, 0., -100., 50., -75., 0.),) + _Devi_2=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= _YDevi_2, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + _Ytauxy=DEFI_LIST_REEL( VALE = (0., 200., 100., 300, 0., -300., -100., -200., 0.),) + _TAU_xy=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= _Ytauxy, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + _Ytauxz=DEFI_LIST_REEL( VALE = (0., -100., 100., 200, 0., -200., -100., 100., 0.),) + _TAU_xz=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= _Ytauxz, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + _Ytauyz=DEFI_LIST_REEL( VALE = (0., 0., 200., -100, 0., 100., -200., 0., 0.),) + _TAU_yz=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= _Ytauyz, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + _eps_xy=CALC_FONCTION(COMB=_F(FONCTION=_TAU_xy, + COEF=Ctau,),); + + _eps_xz=CALC_FONCTION(COMB=_F(FONCTION=_TAU_xz, + COEF=Ctau,),); + + _eps_yz=CALC_FONCTION(COMB=_F(FONCTION=_TAU_yz, + COEF=Ctau,),); + + _eps_xx=CALC_FONCTION(COMB=(_F(FONCTION=_Trace, + COEF=Ctrac,), + _F(FONCTION=_Devi_1, + COEF=Ctrac,),),); + + _eps_yy=CALC_FONCTION(COMB=(_F(FONCTION=_Trace, + COEF=Ctrac,), + _F(FONCTION=_Devi_1, + COEF=-(Ctrac),), + _F(FONCTION=_Devi_2, + COEF=Ctrac,),),); + + _eps_zz=CALC_FONCTION(COMB=(_F(FONCTION=_Trace, + COEF=Ctrac,), + _F(FONCTION=_Devi_2, + COEF=-(Ctrac),),),); + eps_imp = [_eps_xx, _eps_yy, _eps_zz, _eps_xy, _eps_xz, _eps_yz] + #rotation tenseur des def + #angle de precession, nutation, rotation propre + psi,teta,phi=0.9,0.7,0.4 + cps,cte,cph=NP.cos(psi),NP.cos(teta),NP.cos(phi) + sps,ste,sph=NP.sin(psi),NP.sin(teta),NP.sin(phi) + #matrice de passage + p11,p21,p31 = cph*cps-sph*cte*sps,cph*sps+sph*cte*cps,sph*ste + p12,p22,p32 = -sph*cps-cph*cte*sps,-sph*sps+cph*cte*cps,cph*ste + p13,p23,p33 = ste*sps,-ste*cps,cte + V1= [p11, p21, p31] + V2= [p12, p22, p32] + V3= [p13, p23, p33] + #eps apres rotation + VI = [[V1,V1],[V2,V2],[V3,V3],[V1,V2],[V1,V3],[V2,V3]] + _eps_rot = [None]*6 + for vect_i in VI: + i = VI.index(vect_i) + V_COEF = PROD_ROT(vect_i[0],vect_i[1]) + _eps_rot[i] =CALC_FONCTION(COMB=( + _F(FONCTION=_eps_xx,COEF=V_COEF[0],), + _F(FONCTION=_eps_yy,COEF=V_COEF[1],), + _F(FONCTION=_eps_zz,COEF=V_COEF[2],), + _F(FONCTION=_eps_xy,COEF=V_COEF[3],), + _F(FONCTION=_eps_xz,COEF=V_COEF[4],), + _F(FONCTION=_eps_yz,COEF=V_COEF[5],), + ),); + #eps apres symetrie + eps_sym = [_eps_zz,_eps_xx,_eps_yy,_eps_xz,_eps_yz,_eps_xy] + + V_EPS = [eps_imp,eps_sym,_eps_rot] + #trace chargement + if INFO == 2 : + IMPR_FONCTION(#FORMAT='XMGRACE',PILOTE='INTERACTIF', + COURBE=(_F(FONCTION=eps_imp[0],), + _F(FONCTION=eps_imp[1],), + _F(FONCTION=eps_imp[2],), + _F(FONCTION=eps_imp[3],), + _F(FONCTION=eps_imp[4],), + _F(FONCTION=eps_imp[5],), + ), + UNITE=29,); + return eps_imp + +####################################################################### +def CHAR2D(self,POISSON,YOUNG,_tempsar,INFO): + CALC_FONCTION = self.get_cmd('CALC_FONCTION') + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') + IMPR_FONCTION = self.get_cmd('IMPR_FONCTION') + ####################################################################### + # definition du trajet de chargement 2D + ####################################################################### + from Accas import _F + import numpy as NP + + #fonctions chargement + calibrage = 4.5; + Ctau = ((2 * calibrage) * ((1 + POISSON) / (2 * YOUNG))); + Ctrac = (calibrage * (1 / YOUNG)); + YTrace2d=DEFI_LIST_REEL( VALE = (0., 150., 200., 300., 0., -300., -200., -150., 0.),) + Trace2d=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= YTrace2d, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + Y_Devi2=DEFI_LIST_REEL( VALE = (0., 0., 100., 0., 0., 0., -100., 0., 0.),) + Devi1_2d=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= Y_Devi2, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + Y_tauxy2=DEFI_LIST_REEL( VALE = (0., 100., 40., 0., 0., 0., -40., -100., 0.0),) + TAU_xy2=DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA= _tempsar, + VALE_FONC= Y_tauxy2, + PROL_DROITE='EXCLU', + PROL_GAUCHE='EXCLU',); + + eps_xy2=CALC_FONCTION(COMB=_F(FONCTION=TAU_xy2, + COEF=Ctau,),); + + eps_xx2=CALC_FONCTION(COMB=(_F(FONCTION=Trace2d, + COEF=Ctrac,), + _F(FONCTION=Devi1_2d, + COEF=Ctrac,),),); + + eps_yy2=CALC_FONCTION(COMB=(_F(FONCTION=Trace2d, + COEF=Ctrac,), + _F(FONCTION=Devi1_2d, + COEF=-(Ctrac),),),); + #rotation tenseur des def + angle = 0.9 + c,s = NP.cos(0.9) , NP.sin(0.9) + c2,s2,cs = c*c, s*s, c*s + eps_rr2=CALC_FONCTION(COMB=(_F(FONCTION=eps_xx2, + COEF=c2,), + _F(FONCTION=eps_yy2, + COEF=s2,), + _F(FONCTION=eps_xy2, + COEF=2*cs,),),); + + eps_tt2=CALC_FONCTION(COMB=(_F(FONCTION=eps_xx2, + COEF=s2,), + _F(FONCTION=eps_yy2, + COEF=c2,), + _F(FONCTION=eps_xy2, + COEF=-2*cs,),),); + + eps_rt2=CALC_FONCTION(COMB=(_F(FONCTION=eps_xx2, + COEF=-cs,), + _F(FONCTION=eps_yy2, + COEF=cs,), + _F(FONCTION=eps_xy2, + COEF=c2-s2,),),); + eps_imp = [eps_xx2 , eps_yy2, eps_xy2, eps_rr2,eps_tt2, eps_rt2] + + #Trace2d chargement + if INFO==2 : + IMPR_FONCTION(#FORMAT='XMGRACE',PILOTE='INTERACTIF', + COURBE=(_F(FONCTION=eps_imp[0],), + _F(FONCTION=eps_imp[1],), + _F(FONCTION=eps_imp[2],), + _F(FONCTION=eps_imp[3],), + _F(FONCTION=eps_imp[4],), + _F(FONCTION=eps_imp[5],), + ), + UNITE=29,); + return eps_imp + + +####################################################################### + + + +def test_compor_ops(self,OPTION,NEWTON,CONVERGENCE,COMP_INCR,COMP_ELAS,LIST_MATER,VARI_TEST,INFO, + **args): + # seule l'option "THER", c'est à dire le test thermomecanique est programme a ce jour + # ajouter l'option MECA (tests comp001,002), l'option HYDR, etc.. + from Accas import _F + import numpy as NP + from Utilitai.veri_matr_tang import VERI_MATR_TANG + self.update_const_context({'ERREUR' : ERREUR}) + + ier=0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type fonction) est nomme U dans + # le contexte de la macro + + self.DeclareOut('U',self.sd) + + # On importe les definitions des commandes a utiliser dans la macro + CALC_FONCTION = self.get_cmd('CALC_FONCTION') + CALC_TABLE = self.get_cmd('CALC_TABLE') + DEFI_CONSTANTE = self.get_cmd('DEFI_CONSTANTE') + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + DEFI_LIST_INST = self.get_cmd('DEFI_LIST_INST') + DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') + DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU') + DETRUIRE = self.get_cmd('DETRUIRE') + FORMULE = self.get_cmd('FORMULE') + IMPR_FONCTION = self.get_cmd('IMPR_FONCTION') + SIMU_POINT_MAT = self.get_cmd('SIMU_POINT_MAT') + TEST_TABLE = self.get_cmd('TEST_TABLE') + IMPR_TABLE = self.get_cmd('IMPR_TABLE') + CALC_TABLE = self.get_cmd('CALC_TABLE') + + motscles={} + if COMP_INCR : + motscles['COMP_INCR'] = COMP_INCR.List_F() + if COMP_ELAS : + motscles['COMP_ELAS'] = COMP_ELAS.List_F() + motscles['CONVERGENCE'] = CONVERGENCE.List_F() + motscles['NEWTON'] = NEWTON.List_F() + + if OPTION=="THER" : + epsi = 1.E-10 + MATER=args['MATER'] + ALPHA=args['ALPHA'] + YOUNG=args['YOUNG'] + TEMP_INIT=args['TEMP_INIT'] + TEMP_FIN=args['TEMP_FIN'] + NB_VARI=args['NB_VARI'] + + if args['INST_FIN'] != None : INST_FIN=args['INST_FIN'] + + NCAL=len(LIST_MATER) + + _LINST0=DEFI_LIST_REEL(DEBUT=0., + INTERVALLE=(_F(JUSQU_A=INST_FIN, + NOMBRE=NCAL,), + ), + ); + + _LINST=DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST=_LINST0, + METHODE='MANUEL', + # PAS_MINI=1.0E-12 + ), + ECHEC=_F(SUBD_PAS=10), + # ADAPTATION=_F(EVENEMENT='SEUIL'), + ); + _TIMP=DEFI_FONCTION(NOM_PARA='INST', NOM_RESU='TEMP', + VALE=( 0. , TEMP_INIT, INST_FIN , TEMP_FIN) + ) + + _zero=DEFI_CONSTANTE(VALE=0.) + + + _U=SIMU_POINT_MAT(MATER=MATER,INFO=INFO, + SUPPORT='ELEMENT', + AFFE_VARC=( + _F( NOM_VARC='TEMP', + VALE_FONC=_TIMP, + VALE_REF=TEMP_INIT), + ), + INCREMENT=_F(LIST_INST=_LINST,), + EPSI_IMPOSE=_F(EPXX=_zero,), + **motscles); + + # On ne garde pas les valeurs initiales (NUME_ORDRE = 0 exclu) + + _U = CALC_TABLE(reuse =_U, + TABLE=_U, + ACTION=(_F( + OPERATION = 'FILTRE', + NOM_PARA = 'NUME_ORDRE', + CRIT_COMP = 'GT', + VALE = 0, + ),),); + + SXM = 0. + EXM = 0. + time = 0. + + _RES = [None]*(NCAL) + if (NB_VARI > 0): + Vim = NP.zeros(NB_VARI) + + for i in range(NCAL): + + timem = time + + time = timem + INST_FIN/NCAL + + Ti = TEMP_INIT + time/INST_FIN * (TEMP_FIN - TEMP_INIT) + + Tm = TEMP_INIT + timem/INST_FIN * (TEMP_FIN - TEMP_INIT) + + # deformation mecanique imposee correspondant a la deformation thermique du premier calcul + + _epsimp =DEFI_CONSTANTE(VALE=-ALPHA(Ti)*(Ti - TEMP_INIT)); + + # variation des coef du COMPORtement avec la temperature + # correction eventuelle des valeurs initiales du temps ti + + if i > 0 : + + SXM = SXM *(YOUNG(Ti)/YOUNG(Tm)) + # cas particuliers + if COMP_INCR.List_F()[0]['RELATION'] == 'VMIS_CINE_LINE' : + + if args['D_SIGM_EPSI'] != None : + D_SIGM_EPSI=args['D_SIGM_EPSI'] + else : + raise 'erreur' + + Vim[0:5] = Vim[0:5]*D_SIGM_EPSI(Ti)/D_SIGM_EPSI(Tm) + + if COMP_INCR.List_F()[0]['RELATION']== 'VMIS_ECMI_LINE' : + if args['C_PRAG'] != None : + C_PRAG=args['C_PRAG'] + else : + raise 'erreur' + Vim[2:7] = Vim[2:7]*C_PRAG(Ti)/C_PRAG(Tm) + + if COMP_INCR.List_F()[0]['RELATION']== 'VMIS_ECMI_TRAC' : + if args['C_PRAG'] != None : + C_PRAG=args['C_PRAG'] + else : + raise 'erreur' + Vim[2:7] = Vim[2:7]*C_PRAG(Ti)/C_PRAG(Tm) + + + _list0 = DEFI_LIST_REEL(DEBUT=timem, + INTERVALLE=(_F(JUSQU_A=time,NOMBRE=1,),),); + + _list=DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST=_list0, + METHODE='MANUEL', + # PAS_MINI=1.0E-12 + ), + ECHEC=_F(SUBD_PAS=10), + # ADAPTATION=_F(EVENEMENT='SEUIL'), + ); + if (NB_VARI > 0): + _RES[i]=SIMU_POINT_MAT(INFO=INFO, + MATER=LIST_MATER[i], + SUPPORT='ELEMENT', + INCREMENT=_F(LIST_INST = _list, ), + EPSI_IMPOSE=_F(EPXX=_epsimp), + SIGM_INIT=_F(SIXX=SXM), + VARI_INIT=_F(VALE=[Vim[j] for j in range(NB_VARI)]), + EPSI_INIT=_F(EPXX=EXM, EPYY=0.,EPZZ=0.,EPXY=0.,EPXZ=0.,EPYZ=0.), + **motscles); + + else : + _RES[i]=SIMU_POINT_MAT(INFO=INFO, + MATER=LIST_MATER[i], + SUPPORT='ELEMENT', + INCREMENT=_F(LIST_INST = _list, ), + EPSI_IMPOSE=_F(EPXX=_epsimp), + SIGM_INIT=_F(SIXX=SXM), + EPSI_INIT=_F(EPXX=EXM, EPYY=0.,EPZZ=0.,EPXY=0.,EPXZ=0.,EPYZ=0.), + **motscles); + + # On ne teste pas les valeurs initiales (NUME_ORDRE = 0 exclu) + + _RES[i] = CALC_TABLE(reuse =_RES[i], + TABLE=_RES[i], + ACTION=(_F( + OPERATION = 'FILTRE', + NOM_PARA = 'NUME_ORDRE', + CRIT_COMP = 'GT', + VALE = 0, + ),),); + + # recuperation des valeurs initiales du futur pas de temps dans la table resultat + + EXM = _RES[i]['EPXX',1] + + SXM = _RES[i]['SIXX',1] + + if (NB_VARI > 0): + for j in range(NB_VARI): + Vim[j] = _RES[i]['V'+str(j+1),1] + + DETRUIRE ( CONCEPT = _F (NOM =_epsimp),INFO=1); + DETRUIRE ( CONCEPT = _F (NOM =_list),INFO=1); + + + + TEST_TABLE(TABLE=_RES[i], + NOM_PARA='VMIS',VALE=_U['VMIS',i+1], + FILTRE=_F(NOM_PARA='INST',VALE=time), + REFERENCE='AUTRE_ASTER',); + + TEST_TABLE(TABLE=_RES[i], + NOM_PARA='TRACE',VALE=_U['TRACE',i+1], + FILTRE=_F(NOM_PARA='INST',VALE=time), + REFERENCE='AUTRE_ASTER',); + if (NB_VARI > 0): + if VARI_TEST <> None : + for j in range(len(VARI_TEST)): + nomvari=VARI_TEST[j] + if abs(_U[nomvari,i+1]) > epsi : + TEST_TABLE(TABLE=_RES[i], + NOM_PARA=nomvari,VALE=_U[nomvari,i+1], + FILTRE=_F(NOM_PARA='INST',VALE=time), + REFERENCE='AUTRE_ASTER',); + else : + for j in range(NB_VARI): + nomvari='V'+str(j+1) + if abs(_U[nomvari,i+1]) > epsi : + TEST_TABLE(TABLE=_RES[i], + NOM_PARA=nomvari,VALE=_U[nomvari,i+1], + FILTRE=_F(NOM_PARA='INST',VALE=time), + REFERENCE='AUTRE_ASTER',); + for i in range(NCAL): + DETRUIRE ( CONCEPT = _F (NOM =_RES[i]),INFO=1) + + elif OPTION=="MECA" : + + LIST_NPAS=args['LIST_NPAS'] + YOUNG=args['YOUNG'] + POISSON=args['POISSON'] + + #Discretisation du calcul + if args['LIST_NPAS'] != None : + LIST_NPAS=args['LIST_NPAS'] + else : + LIST_NPAS=4*[1] + [1, 5, 25] + Ncal = len(LIST_NPAS) + + # les differents calculs effectues et les precisions sur chaque TEST_RESU + label_cal=['_Pa_','_Th_','_sym_','_rot_'] + 6* ['_N'] + if args['LIST_TOLE'] != None : + LIST_TOLE=args['LIST_TOLE'] + else : + LIST_TOLE=4*[1.E-10] + [1.E-1] + (Ncal-5)*[1.E-2] + [1.E-8] + + if args['PREC_ZERO'] != None : + PREC_ZERO=args['PREC_ZERO'] + else : + PREC_ZERO=len(VARI_TEST)*[1.E-10] + + prec_tgt=LIST_TOLE[-1] + + #parametres vitesse de sollicitation + t_0 = 1.0 + if COMP_INCR : + if COMP_INCR.List_F()[0]['RELATION'][0:4]== 'VISC' : + vitesse = 1.e-5 + t_0 = 5.e-2/(8.0*vitesse) + # liste d'archivage + _tempsar=DEFI_LIST_REEL( VALE =[t_0*i for i in range(9)],) + + if args['MODELISATION'] != None : + modelisation=args['MODELISATION'] + else : + modelisation= "3D" + if modelisation == "3D" : + + ################################################################################## + # TEST 3D + ################################################################################## + + eps_imp = CHAR3D(self,POISSON,YOUNG,_tempsar,INFO) + + ch_param2 = list(VARI_TEST) + ch_param=ch_param2+['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'] + + elif modelisation == "C_PLAN" : + + ################################################################################## + # TEST 2D C_PLAN + ################################################################################## + + eps_imp = CHAR2D(self,POISSON,YOUNG,_tempsar,INFO) + + # les quantites (invariants...) sur lequels portent les calculs d'erreur et les test_resu + ch_param2 = list(VARI_TEST) + ch_param=ch_param2+['SIXX','SIYY','SIZZ','SIXY'] + + + ############################################################################### + #Discretisation et calcul + ############################################################################### + + _RES=[None]*Ncal + _RSI=[None]*len(ch_param) + TMP_S=[None] + + #pointeur materiau + P_imat = [0] + [1] + (Ncal-2)*[1] + #pointeur deformation + nomdef, symdef, rotdef = [0, 1, 2], [1, 0, 2], [3, 4, 5] + P_idef = [nomdef, nomdef,symdef, rotdef] + for i in range(6): P_idef.append(nomdef) + + ldicoeps=[] + dicoeps={} + dicoeps['EPXX']=eps_imp[0] + dicoeps['EPYY']=eps_imp[1] + dicoeps['EPZZ']=eps_imp[2] + dicoeps['EPXY']=eps_imp[3] + if modelisation == "3D" : + dicoeps['EPXZ']=eps_imp[4] + dicoeps['EPYZ']=eps_imp[5] + ldicoeps.append(dicoeps) + motscles['EPSI_IMPOSE']=ldicoeps + + if args['SUPPORT'] != None : + if modelisation == "C_PLAN" : + motscles['MODELISATION']='C_PLAN' + motscles['SUPPORT']='ELEMENT' + else : + motscles['SUPPORT']=args['SUPPORT'] + + #Boucle sur l'ensemble des calculs + for i in range(Ncal): + N = LIST_NPAS[i] + imat = P_imat[i] + idef = P_idef[i] + temps=DEFI_LIST_REEL(DEBUT=0.0, + INTERVALLE=(_F(JUSQU_A=t_0,NOMBRE=N,), + _F(JUSQU_A=2.0*t_0,NOMBRE=N,), + _F(JUSQU_A=3.0*t_0,NOMBRE=N,), + _F(JUSQU_A=4.0*t_0,NOMBRE=N,), + _F(JUSQU_A=5.0*t_0,NOMBRE=N,), + _F(JUSQU_A=6.0*t_0,NOMBRE=N,), + _F(JUSQU_A=7.0*t_0,NOMBRE=N,), + _F(JUSQU_A=8.0*t_0,NOMBRE=N,),),); + + _DEFLIST =DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST = temps,), + ECHEC=_F(SUBD_METHODE='EXTRAPOLE', + SUBD_PAS=10, + SUBD_NIVEAU=10,),) + # Resout le pb a deformation imposee + _RES[i]=SIMU_POINT_MAT(INFO=INFO, + MATER = LIST_MATER[imat], + ARCHIVAGE = _F(LIST_INST = _tempsar), + INCREMENT=_F(LIST_INST=_DEFLIST,), + **motscles + ); + + # On renomme les composantes en fonction de l'ordre de discretisation + _RSI=RENOMME(self,i,LIST_NPAS,label_cal,ch_param,_RES,_RSI) + + DETRUIRE ( CONCEPT = _F (NOM = temps,),INFO=1) + + # TEST_RESU sur les erreurs relatives + # les quantites (invariants...) sur lequels portent les calculs d'erreur et les test_resu + _RSI=TEST_ECART(self,ch_param2,label_cal,LIST_NPAS,Ncal,ch_param,_RSI,LIST_TOLE,PREC_ZERO) + + for ch in ch_param2 : + i=ch_param2.index(ch) + if INFO==2 : IMPR_TABLE(TABLE=_RSI[i]); + for j in range(Ncal) : + ch_cal = ch + label_cal[j] + str(LIST_NPAS[j]) + ch_err = 'ER_' + ch_cal + TEST_TABLE(TABLE=_RSI[i],NOM_PARA=ch_err, + TYPE_TEST='MAX',VALE=0.,CRITERE='ABSOLU',PRECISION=LIST_TOLE[j],REFERENCE='ANALYTIQUE',); + + ############################################################################### + # Test de la matrice tangente sur le calcul le plus fin + ############################################################################### + + N = LIST_NPAS[Ncal-1] + _Linst=DEFI_LIST_REEL(DEBUT=0.0, + INTERVALLE=(_F(JUSQU_A=t_0,NOMBRE=N,), + _F(JUSQU_A=2.0*t_0,NOMBRE=N,), + _F(JUSQU_A=3.0*t_0,NOMBRE=N,), + _F(JUSQU_A=4.0*t_0,NOMBRE=N,), + _F(JUSQU_A=5.0*t_0,NOMBRE=N,), + _F(JUSQU_A=6.0*t_0,NOMBRE=N,), + _F(JUSQU_A=7.0*t_0,NOMBRE=N,), + _F(JUSQU_A=8.0*t_0,NOMBRE=N,),),); + + if COMP_INCR : + motscles['COMP_INCR'][0]['TYPE_MATR_TANG'] = 'VERIFICATION' + + _DEFLIS2 =DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST = _Linst,), + ECHEC=_F(SUBD_METHODE='EXTRAPOLE', + SUBD_PAS=10, + SUBD_NIVEAU=10,),) + # Resout le pb a deformation imposee + U=SIMU_POINT_MAT(INFO=INFO, + MATER = LIST_MATER[imat], + ARCHIVAGE = _F(LIST_INST = _tempsar), + INCREMENT=_F(LIST_INST=_DEFLIS2,), + **motscles + ); + + _DIFFMAT=VERI_MATR_TANG() + + TEST_TABLE(TABLE=_DIFFMAT, + NOM_PARA='MAT_DIFF', + TYPE_TEST='MAX', + VALE=0., + CRITERE='ABSOLU', + PRECISION=prec_tgt, + REFERENCE='ANALYTIQUE',); + + if INFO==2 : IMPR_TABLE(TABLE=_DIFFMAT) + + return ier + diff --git a/Aster/Cata/cataSTA10/SD/co_cham_no.py b/Aster/Cata/cataSTA10/SD/co_cham_no.py index 76496815..59e4c636 100644 --- a/Aster/Cata/cataSTA10/SD/co_cham_no.py +++ b/Aster/Cata/cataSTA10/SD/co_cham_no.py @@ -1,8 +1,8 @@ -#@ MODIF co_cham_no SD DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +#@ MODIF co_cham_no SD DATE 14/12/2010 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -28,13 +28,14 @@ import numpy # ----------------------------------------------------------------------------- # post-traitement : class post_comp_cham_no : - def __init__(self,valeurs,noeud=None) : + def __init__(self,valeurs,noeud=None,comp=None) : self.valeurs=valeurs self.noeud=noeud + self.comp=comp # ----------------------------------------------------------------------------- class cham_no_sdaster(cham_gd_sdaster, sd_cham_no): - def EXTR_COMP(self,comp,lgno,topo=0) : + def EXTR_COMP(self,comp=' ',lgno=[],topo=0) : """ retourne les valeurs de la composante comp du champ sur la liste de groupes de noeuds lgno avec eventuellement l'info de la topologie si topo>0. Si lgno est une liste vide, c'est equivalent @@ -42,7 +43,10 @@ class cham_no_sdaster(cham_gd_sdaster, sd_cham_no): Attributs retourne - self.valeurs : numpy.array contenant les valeurs Si on a demande la topo (i.e. self.topo = 1) : - - self.noeud : numero de noeud """ + - self.noeud : numero de noeud + Si on demande toutes les composantes (comp = ' ') : + - self.comp : les composantes associees a chaque grandeur pour chaque noeud + """ if not self.accessible() : raise Accas.AsException("Erreur dans cham_no.EXTR_COMP en PAR_LOT='OUI'") @@ -50,7 +54,7 @@ class cham_no_sdaster(cham_gd_sdaster, sd_cham_no): ncham=ncham+(8-len(ncham))*' ' nchams=ncham[0:7]+'S' ncmp=comp+(8-len(comp))*' ' - + aster.prepcompcham(ncham,nchams,ncmp,"NO ",topo,lgno) valeurs=numpy.array(aster.getvectjev(nchams+(19-len(ncham))*' '+'.V')) @@ -60,9 +64,13 @@ class cham_no_sdaster(cham_gd_sdaster, sd_cham_no): else : noeud=None - aster.prepcompcham("__DETR__",nchams,ncmp,"NO ",topo,lgno) - - return post_comp_cham_no(valeurs,noeud) + if comp[:1] == ' ': + comp=(aster.getvectjev(nchams+(19-len(ncham))*' '+'.C')) + aster.prepcompcham("__DETR__",nchams,ncmp,"NO ",topo,lgno) + return post_comp_cham_no(valeurs,noeud,comp) + else: + aster.prepcompcham("__DETR__",nchams,ncmp,"NO ",topo,lgno) + return post_comp_cham_no(valeurs,noeud) def __add__(self, other): from SD.sd_nume_equa import sd_nume_equa diff --git a/Aster/Cata/cataSTA10/SD/co_corresp_2_mailla.py b/Aster/Cata/cataSTA10/SD/co_corresp_2_mailla.py new file mode 100644 index 00000000..27586889 --- /dev/null +++ b/Aster/Cata/cataSTA10/SD/co_corresp_2_mailla.py @@ -0,0 +1,25 @@ +#@ MODIF co_corresp_2_mailla SD DATE 14/12/2010 AUTEUR PELLET J.PELLET +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +from SD import * +from SD.sd_corresp_2_mailla import sd_corresp_2_mailla + +class corresp_2_mailla(ASSD, sd_corresp_2_mailla): + pass diff --git a/Aster/Cata/cataSTA10/SD/co_grille.py b/Aster/Cata/cataSTA10/SD/co_grille.py new file mode 100644 index 00000000..724b7b0e --- /dev/null +++ b/Aster/Cata/cataSTA10/SD/co_grille.py @@ -0,0 +1,29 @@ +#@ MODIF co_grille SD DATE 08/03/2011 AUTEUR MASSIN P.MASSIN + +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GENIAUT S.GENIAUT + +from SD import * +from co_maillage import maillage_sdaster +from sd_grille import sd_grille + +# ----------------------------------------------------------------------------- +class grille_sdaster(maillage_sdaster,sd_grille): + pass + diff --git a/Aster/Cata/cataSTA10/SD/co_matr_asse.py b/Aster/Cata/cataSTA10/SD/co_matr_asse.py index b57e3846..46858f22 100644 --- a/Aster/Cata/cataSTA10/SD/co_matr_asse.py +++ b/Aster/Cata/cataSTA10/SD/co_matr_asse.py @@ -1,27 +1,75 @@ -#@ MODIF co_matr_asse SD DATE 13/02/2007 AUTEUR PELLET J.PELLET +#@ MODIF co_matr_asse SD DATE 07/12/2010 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== from SD import * from sd_matr_asse import sd_matr_asse +from sd_nume_ddl import sd_nume_ddl +from SD.sd_stoc_morse import sd_stoc_morse +import numpy # ----------------------------------------------------------------------------- class matr_asse(ASSD, sd_matr_asse): - pass - + + + def EXTR_MATR(self) : + """ retourne les valeurs de la matrice dans un format numpy + Attributs retourne + - self.valeurs : numpy.array contenant les valeurs """ + + if not self.accessible(): + raise Accas.AsException("Erreur dans matr_asse.EXTR_MATR en PAR_LOT='OUI'") + + refa = numpy.array(self.REFA.get()) + ma=refa[0] + nu=refa[1] + smos = sd_stoc_morse(nu[:14]+'.SMOS') + + valm=self.VALM.get() + smhc=smos.SMHC.get() + smdi=smos.SMDI.get() + + sym=len(valm)==1 + dim=len(smdi) + nnz=smdi[dim-1] + + triang_sup = numpy.array(valm[1]) + print "AJACOT triang_sup=",triang_sup + if sym: + triang_inf = triang_sup + else: + triang_inf = numpy.array(valm[2]) + + if type(valm[1][0]) == type(1.j) : + dtype=complex + else : + dtype=float + valeur=numpy.zeros([dim, dim], dtype=dtype) + + jcol=1 + for kterm in range(1,nnz+1): + ilig=smhc[kterm-1] + if (smdi[jcol-1] < kterm) : jcol=jcol+1 + + valeur[jcol-1,ilig-1]=triang_inf[kterm-1] + valeur[ilig-1,jcol-1]=triang_sup[kterm-1] + + + + return valeur diff --git a/Aster/Cata/cataSTA10/SD/sd_compor.py b/Aster/Cata/cataSTA10/SD/sd_compor.py index df847589..892d47dd 100644 --- a/Aster/Cata/cataSTA10/SD/sd_compor.py +++ b/Aster/Cata/cataSTA10/SD/sd_compor.py @@ -1,8 +1,8 @@ -#@ MODIF sd_compor SD DATE 08/12/2009 AUTEUR PROIX J-M.PROIX +#@ MODIF sd_compor SD DATE 14/12/2010 AUTEUR PROIX J-M.PROIX # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -82,15 +82,14 @@ class sd_compor(AsBase): famil =cprk[5*k+0] mater =cprk[5*k+1] ecoul =cprk[5*k+2] - ecro_isot =cprk[5*k+3] - ecro_cine =cprk[5*k+4] + MONO_isot =cprk[5*k+3] + MONO_cine =cprk[5*k+4] sd2=sd_mater(mater) ; sd2.check(checker) assert famil in ('BASAL','BCC24','PRISMATIQUE','OCTAEDRIQUE','PYRAMIDAL1', - 'PYRAMIDAL2','CUBIQUE1','CUBIQUE2','MACLAGE','JOINT_GRAIN', - 'RL','UNIAXIAL') - assert ecoul in ('ECOU_VISC1','ECOU_VISC2','ECOU_VISC3') - assert ecro_isot in ('ECRO_ISOT1','ECRO_ISOT2') - assert ecro_cine in ('ECRO_CINE1','ECRO_CINE2') + 'PYRAMIDAL2','CUBIQUE1','CUBIQUE2','MACLAGE','UNIAXIAL') + assert ecoul in ('MONO_VISC1','MONO_VISC2','MONO_VISC3') + assert MONO_isot in ('MONO_ISOT1','MONO_ISOT2') + assert MONO_cine in ('MONO_CINE1','MONO_CINE2') diff --git a/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py b/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py index 340ca74f..400182ed 100644 --- a/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py +++ b/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py @@ -1,26 +1,28 @@ -#@ MODIF sd_corresp_2_mailla SD DATE 02/02/2010 AUTEUR PELLET J.PELLET +#@ MODIF sd_corresp_2_mailla SD DATE 08/03/2011 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== from SD import * +from SD.sd_titre import sd_titre -class sd_corresp_2_mailla(AsBase): + +class sd_corresp_2_mailla(sd_titre): nomj = SDNom(fin=16) PJXX_K1 = AsVK24(lonmax=5) @@ -34,7 +36,6 @@ class sd_corresp_2_mailla(AsBase): PJEF_M1 = Facultatif(AsVI()) PJEF_CF = Facultatif(AsVR()) PJEF_TR = Facultatif(AsVI()) - PJEF_AM = Facultatif(AsVI()) PJEF_CO = Facultatif(AsVR()) PJNG_I1 = Facultatif(AsVI()) diff --git a/Aster/Cata/cataSTA10/SD/sd_grille.py b/Aster/Cata/cataSTA10/SD/sd_grille.py new file mode 100644 index 00000000..82f2fa7d --- /dev/null +++ b/Aster/Cata/cataSTA10/SD/sd_grille.py @@ -0,0 +1,29 @@ +#@ MODIF sd_grille SD DATE 08/03/2011 AUTEUR MASSIN P.MASSIN + +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GENIAUT S.GENIAUT + +from SD import * +from SD.sd_maillage import sd_maillage + +class sd_grille(sd_maillage): + nomj = SDNom(fin=8) + + GRLR = AsVR() + GRLI = AsVI() diff --git a/Aster/Cata/cataSTA10/SD/sd_maillage.py b/Aster/Cata/cataSTA10/SD/sd_maillage.py index 2ac6be12..b1fd54a1 100644 --- a/Aster/Cata/cataSTA10/SD/sd_maillage.py +++ b/Aster/Cata/cataSTA10/SD/sd_maillage.py @@ -1,8 +1,8 @@ -#@ MODIF sd_maillage SD DATE 06/05/2008 AUTEUR PELLET J.PELLET +#@ MODIF sd_maillage SD DATE 11/05/2011 AUTEUR SELLENET N.SELLENET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -68,7 +68,6 @@ class sd_maillage(sd_titre): VGE = Facultatif(sd_voisinage()) ADAPTATION = Facultatif(AsVI(lonmax=1, )) - FORM = Facultatif(AsVK32(SDNom(debut=19), lonmax=2, )) def u_dime(self): diff --git a/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py b/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py index eb8e7443..62a7126d 100644 --- a/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py +++ b/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py @@ -1,8 +1,8 @@ -#@ MODIF sd_proj_mesu SD DATE 15/01/2008 AUTEUR PELLET J.PELLET +#@ MODIF sd_proj_mesu SD DATE 14/12/2010 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -53,7 +53,7 @@ class sd_proj_mesu(AsBase): # vérifications communes : assert self.PJMRG.lonmax >= nbutil - n1=self.PJMBP.lonmax + n1=self.PJMBP.lonuti nbmode=n1/nbutil assert n1==nbutil*nbmode , (nbmode,nbutil,n1) assert self.PJMRF.exists diff --git a/Aster/Cata/cataSTA10/SD/sd_solveur.py b/Aster/Cata/cataSTA10/SD/sd_solveur.py index 3d732810..d3837f9e 100644 --- a/Aster/Cata/cataSTA10/SD/sd_solveur.py +++ b/Aster/Cata/cataSTA10/SD/sd_solveur.py @@ -1,8 +1,8 @@ -#@ MODIF sd_solveur SD DATE 05/10/2009 AUTEUR BOITEAU O.BOITEAU +#@ MODIF sd_solveur SD DATE 18/01/2011 AUTEUR BOITEAU O.BOITEAU # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -22,7 +22,7 @@ from SD import * class sd_solveur(AsBase): nomj = SDNom(fin=19) - SLVK = AsVK24(SDNom(debut=19), lonmax=11, ) + SLVK = AsVK24(SDNom(debut=19), lonmax=12, ) SLVR = AsVR(SDNom(debut=19), lonmax=4, ) SLVI = AsVI(SDNom(debut=19), lonmax=7, ) @@ -34,7 +34,7 @@ class sd_solveur(AsBase): if method == 'MUMPS' : assert slvk[1] in ('AUTO', 'SANS'), slvk assert slvk[2] in ('NONSYM', 'SYMGEN', 'SYMDEF', 'AUTO'), slvk - assert slvk[3] in ('AMD','AMF','PORD','METIS','QAMD','AUTO'), slvk + assert slvk[3] in ('AMD','AMF','PORD','METIS','QAMD','AUTO','SCOTCH'), slvk assert slvk[4] in ('OUI', 'NON'), slvk assert slvk[5] in ('OUI', 'NON'), slvk else : diff --git a/Aster/Cata/cataSTA10/SD/sd_xfem.py b/Aster/Cata/cataSTA10/SD/sd_xfem.py index 120fcb20..092eb782 100644 --- a/Aster/Cata/cataSTA10/SD/sd_xfem.py +++ b/Aster/Cata/cataSTA10/SD/sd_xfem.py @@ -1,8 +1,8 @@ -#@ MODIF sd_xfem SD DATE 28/09/2010 AUTEUR MASSIN P.MASSIN +#@ MODIF sd_xfem SD DATE 08/03/2011 AUTEUR MASSIN P.MASSIN # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -24,6 +24,7 @@ from SD.sd_cham_no import sd_cham_no from SD.sd_cham_elem import sd_cham_elem from SD.sd_carte import sd_carte from SD.sd_util import * +from SD.sd_l_table import sd_l_table @@ -48,6 +49,14 @@ class sd_fiss_xfem(AsBase): BASEFOND = Facultatif(AsVR()) FONDMULT = Facultatif(AsVI()) CARAFOND = Facultatif(AsVR(lonmax=12,)) + JONFISS = Facultatif(AsVK8()) + JONCOEF = Facultatif(AsVI()) +# objets relatifs a la grille auxiliaire + GRILLE_MODELE = Facultatif(AsVK8(SDNom(nomj='.GRI.MODELE'),lonmax=1,)) + GRILLE_LNNO = Facultatif(sd_cham_no(SDNom(nomj='.GRI.LNNO'))) + GRILLE_LTNO = Facultatif(sd_cham_no(SDNom(nomj='.GRI.LTNO'))) + GRILLE_GRLNNO = Facultatif(sd_cham_no(SDNom(nomj='.GRI.GRLNNO'))) + GRILLE_GRLTNO = Facultatif(sd_cham_no(SDNom(nomj='.GRI.GRLTNO'))) # I.2) objets relatifs a l'enrichissement @@ -65,9 +74,9 @@ class sd_fiss_xfem(AsBase): PRO_MES_EL = Facultatif(sd_cham_elem(SDNom(nomj='.PRO.MES_EL'))) PRO_NORMAL = Facultatif(sd_cham_elem(SDNom(nomj='.PRO.NORMAL'))) +# objets relatifs a la localisation du domaine de calcul PRO_RAYON_TORE = Facultatif(AsVR(SDNom(nomj='.PRO.RAYON_TORE'),lonmax=1,)) PRO_NOEUD_TORE = Facultatif(AsVL(SDNom(nomj='.PRO.NOEUD_TORE'))) - PRO_MOD_GRILLE = Facultatif(AsVK8(SDNom(nomj='.PRO.MOD_GRILLE'),lonmax=1,)) # I.4) objets relatifs au contact @@ -76,6 +85,9 @@ class sd_fiss_xfem(AsBase): LISEQ = Facultatif(AsVI(SDNom(nomj='.LISEQ'))) LISRL = Facultatif(AsVI(SDNom(nomj='.LISRL'))) +# I.4) objets relatifs au contact + # une sd_modele peut avoir une "sd_l_table" contenant des grandeurs caractéristiques de l'étude : + lt = Facultatif(sd_l_table(SDNom(nomj=''))) # 1.5) verifications d'existence : @@ -84,7 +96,8 @@ class sd_fiss_xfem(AsBase): sdu_ensemble((self.LISRL, self.LISCO)) sdu_ensemble((self.PRO_MES_EL.CELD, self.PRO_NORMAL.CELD)) sdu_ensemble((self.PRO_RAYON_TORE, self.PRO_NOEUD_TORE)) - + sdu_ensemble((self.GRILLE_MODELE, self.GRILLE_LNNO.DESC, self.GRILLE_GRLNNO.DESC)) + sdu_ensemble((self.GRILLE_LTNO.DESC, self.GRILLE_GRLTNO.DESC)) #------------------------------- # II. sd modele diff --git a/Aster/Cata/cataSTA10/Utilitai/Graph.py b/Aster/Cata/cataSTA10/Utilitai/Graph.py new file mode 100644 index 00000000..23127b1f --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/Graph.py @@ -0,0 +1,1200 @@ +#@ MODIF Graph Utilitai DATE 26/05/2010 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +# RESPONSABLE COURTOIS M.COURTOIS +__all__ = ['Graph', 'AjoutParaCourbe'] + +import sys +import os +import os.path +import string +import re +import types +import time +import numpy + +from Utilitai.Utmess import UTMESS + +# try/except pour utiliser hors aster +try: + import aster +except ImportError: + class fake_aster: + def repout(self): return '/opt/aster/outils' + aster=fake_aster() + + +if not sys.modules.has_key('Table'): + try: + from Utilitai import Table + except ImportError: + import Table + + +# ------------------------------------------------------------------------------ +class Graph: + """Cette classe définit l'objet Graph pour Code_Aster. + + Important : Utiliser les méthodes dédiées à la manipulation des données + (AjoutCourbe, ...) car elles tiennent à jour les attributs "privés" + relatifs aux données : NbCourbe, les extrema... + + Attributs : + - Données de chaque courbe : + .Valeurs : liste des valeurs de chaque courbe, pour chaque courbe : + (paramètres, parties réelles [, parties imaginaires]) + .Legendes : liste des noms de chaque courbe + .Labels : liste des noms des colonnes de chaque courbe + .Styles : liste des infices de styles de ligne + .Couleurs : liste des indices de couleurs + .Marqueurs : liste des indices de symboles/marqueurs + .FreqMarq : liste des fréquences des marqueurs + .Tri : liste du tri à effectuer sur les données ('N', 'X', 'Y', + 'XY' ou 'YX') + Pour Lignes, Couleurs, Marqueurs, FreqMarq, -1 signifie valeur par défaut + du traceur. + + - Propriétés : + .Titre : titre du graphique + .SousTitre : sous-titre (appelé commentaire dans agraf) + - Axes : + .Min_X, .Max_X, .Min_Y, .Max_Y : bornes du tracé (une méthode permet de + renseigner automatiquement ces valeurs avec les extréma globaux) + .Legende_X, .Legende_Y : légende des axes + .Echelle_X, .Echelle_Y : type d'échelle (LIN, LOG) + .Grille_X, .Grille_Y : paramètre de la grille (pas ou fréquence au choix + de l'utilisateur en fonction du traceur qu'il veut utiliser) + + Attributs privés (modifiés uniquement par les méthodes de la classe) : + .NbCourbe : nombre de courbes + .BBXmin, BBXmax, BBYmin, BBYmax : extrema globaux (bounding box) + .LastTraceArgs, LastTraceFormat : données utilisées lors du dernier tracé + """ +# ------------------------------------------------------------------------------ + def __init__(self): + """Construction + valeurs par défaut des attributs + """ + self.Valeurs = [] + self.Legendes = [] + self.Labels = [] + self.Styles = [] + self.Couleurs = [] + self.Marqueurs = [] + self.FreqMarq = [] + self.Tri = [] + self.Titre = '' + self.SousTitre = '' + self.Min_X = None + self.Max_X = None + self.Min_Y = None + self.Max_Y = None + self.MinP_X = 1.e+99 # minimum > 0 pour les échelles LOG + self.MinP_Y = 1.e+99 + self.Legende_X = '' + self.Legende_Y = '' + self.Echelle_X = 'LIN' + self.Echelle_Y = 'LIN' + self.Grille_X = -1 + self.Grille_Y = -1 + # attributs que l'utilisateur ne doit pas modifier + self.NbCourbe = len(self.Valeurs) + self.BBXmin = 1.e+99 + self.BBXmax = -1.e+99 + self.BBYmin = 1.e+99 + self.BBYmax = -1.e+99 + # pour conserver les paramètres du dernier tracé + self.LastTraceArgs = {} + self.LastTraceFormat = '' + +# ------------------------------------------------------------------------------ + def SetExtremaX(self,marge=0., x0=None, x1=None, force=True): + """Remplit les limites du tracé (Min/Max_X) avec les valeurs de la + bounding box +/- avec une 'marge'*(Max-Min)/2. + x0,x1 permettent de modifier la bb. + """ + if x0<>None: self.BBXmin=min([self.BBXmin, x0]) + if x1<>None: self.BBXmax=max([self.BBXmax, x1]) + + dx=max(self.BBXmax-self.BBXmin,0.01*self.BBXmax) + if dx == 0.: + dx = 1.e-6 + if force or self.Min_X==None: + self.Min_X = self.BBXmin - marge*dx/2. + if force or self.Max_X==None: + self.Max_X = self.BBXmax + marge*dx/2. + return + + def SetExtremaY(self,marge=0., y0=None, y1=None, force=True): + """Remplit les limites du tracé (Min/Max_Y) avec les valeurs de la + bounding box +/- avec une 'marge'*(Max-Min)/2. + y0,y1 permettent de modifier la bb. + """ + if y0<>None: self.BBYmin=min([self.BBYmin, y0]) + if y1<>None: self.BBYmax=max([self.BBYmax, y1]) + + dy=max(self.BBYmax-self.BBYmin,0.01*self.BBYmax) + if dy == 0.: + dy = 1.e-6 + if force or self.Min_Y==None: + self.Min_Y = self.BBYmin - marge*dy/2. + if force or self.Max_Y==None: + self.Max_Y = self.BBYmax + marge*dy/2. + return + + def SetExtrema(self,marge=0., x0=None, x1=None, y0=None, y1=None, force=True): + """Remplit les limites du tracé (Min/Max_X/Y) avec les valeurs de la + bounding box +/- avec une 'marge'*(Max-Min)/2. + x0,x1,y0,y1 permettent de modifier la bb. + """ + self.SetExtremaX(marge, x0, x1, force=force) + self.SetExtremaY(marge, y0, y1, force=force) + return +# ------------------------------------------------------------------------------ + def AutoBB(self,debut=-1): + """Met à jour automatiquement la "bounding box" + (extrema toutes courbes confondues) + Appelé par les méthodes de manipulation des données + """ + if debut == -1: + debut=self.NbCourbe-1 + if debut == 0: + X0 = 1.e+99 + X1 = -1.e+99 + Y0 = 1.e+99 + Y1 = -1.e+99 + else: + X0 = self.BBXmin + X1 = self.BBXmax + Y0 = self.BBYmin + Y1 = self.BBYmax + + for i in range(debut,self.NbCourbe): + X0 = min([X0,]+list(self.Valeurs[i][0])) + X1 = max([X1,]+list(self.Valeurs[i][0])) + self.MinP_X = min([self.MinP_X,]+[x for x \ + in list(self.Valeurs[i][0]) if x>0]) + for ny in range(1,len(self.Valeurs[i])): + Y0 = min([Y0,]+list(self.Valeurs[i][ny])) + Y1 = max([Y1,]+list(self.Valeurs[i][ny])) + self.MinP_Y = min([self.MinP_Y,]+[y for y \ + in list(self.Valeurs[i][ny]) if y>0]) + self.BBXmin = X0 + self.BBXmax = X1 + self.BBYmin = Y0 + self.BBYmax = Y1 + return +# ------------------------------------------------------------------------------ + def AjoutCourbe(self,Val,Lab,Leg='',Sty=-1,Coul=-1,Marq=-1,FreqM=-1,Tri='N'): + """Ajoute une courbe dans les données + Val : liste de 2 listes (ou 3 si complexe) : abs, ord[, imag] + Leg : une chaine + Lab : liste de 2 chaines (ou 3 si complexe) + Sty : un entier + Coul : un entier + Marq : un entier + FreqM : un entier + Tri : chaine de caractères : N, X, Y, XY ou YX + Met à jour les attributs : NbCourbe, BBXmin/Xmax/Ymin/Ymax + """ + nbc = len(Val) # nombre de colonnes : 2 ou 3 + + # verifications : "if not (conditions requises)" + if not ( 2 <= nbc <= 3 and \ + type(Val[0]) in (types.ListType, types.TupleType) and \ + type(Val[1]) in (types.ListType, types.TupleType) and \ + (nbc==2 or type(Val[2]) in (types.ListType, types.TupleType)) and \ + len(Val[0]) == len(Val[1]) and (nbc==2 or len(Val[0]) == len(Val[2])) ): + UTMESS('F','GRAPH0_1') + + if len(Lab) <> nbc: + UTMESS('S','GRAPH0_2') + + # ajout dans les données + self.Legendes.append(str(Leg)) + self.Labels.append([str(L) for L in Lab]) + self.Valeurs.append(Val) + self.Styles.append(Sty) + self.Couleurs.append(Coul) + self.Marqueurs.append(Marq) + self.FreqMarq.append(FreqM) + self.Tri.append(Tri) + + self.NbCourbe = self.NbCourbe + 1 + self.AutoBB() + return +# ------------------------------------------------------------------------------ + def Courbe(self,n): + """Permet de récupérer les données de la courbe d'indice n sous forme + d'un dictionnaire. + """ + dico={ + 'Leg' : self.Legendes[n], # légende de la courbe + 'LabAbs' : self.Labels[n][0], # labels des abscisses + 'LabOrd' : [self.Labels[n][1],], # labels des ordonnées + 'NbCol' : len(self.Valeurs[n]), # nombre de colonnes + 'NbPts' : len(self.Valeurs[n][0]), # nombre de points + 'Abs' : self.Valeurs[n][0], # liste des abscisses + 'Ord' : [self.Valeurs[n][1],], # liste des ordonnées + 'Sty' : self.Styles[n], # style de la ligne + 'Coul' : self.Couleurs[n], # couleur + 'Marq' : self.Marqueurs[n], # marqueur + 'FreqM' : self.FreqMarq[n], # fréquence du marqueur + 'Tri' : self.Tri[n], # ordre de tri des données + } + if(dico['NbCol'] == 3): + dico['LabOrd'].append(self.Labels[n][2]) # labels de la partie imaginaire + dico['Ord'].append(self.Valeurs[n][2]) # liste des ordonnées partie imaginaire + return dico +# ------------------------------------------------------------------------------ + def Trace(self,FICHIER=None,FORMAT=None,dform=None,**opts): + """Tracé du Graph selon le format spécifié. + FICHIER : nom du(des) fichier(s). Si None, on dirige vers stdout + dform : dictionnaire de formats d'impression (format des réels, + commentaires, saut de ligne...) + opts : voir TraceGraph. + """ + para={ + 'TABLEAU' : { 'mode' : 'a', 'driver' : TraceTableau, }, + 'XMGRACE' : { 'mode' : 'a', 'driver' : TraceXmgrace, }, + 'AGRAF' : { 'mode' : 'a', 'driver' : TraceAgraf, }, + } + kargs={} + if self.LastTraceArgs=={}: + kargs['FICHIER']=FICHIER + kargs['dform']=dform + kargs['opts']=opts + else: + kargs=self.LastTraceArgs.copy() + if FORMAT==None: + FORMAT=self.LastTraceFormat + if FICHIER<>None: + kargs['FICHIER']=FICHIER + if dform<>None: + kargs['dform']=dform + if opts<>{}: + kargs['opts']=opts + if not FORMAT in para.keys(): + UTMESS('A', 'GRAPH0_3', valk=FORMAT) + else: + kargs['fmod']=para[FORMAT]['mode'] + self.LastTraceArgs = kargs.copy() + self.LastTraceFormat = FORMAT + # call the associated driver + para[FORMAT]['driver'](self,**kargs) +# ------------------------------------------------------------------------------ + def __repr__(self): + """Affichage du contenu d'un Graph""" + srep='' + for attr in ['NbCourbe','Legendes','Labels','Valeurs','Min_X','Max_X','Min_Y','Max_Y','BBXmax','BBXmin','BBYmax','BBYmin','Legende_X','Legende_Y','Echelle_X','Echelle_Y','Grille_X','Grille_Y','Tri']: + srep=srep + '%-10s : %s\n' % (attr,str(getattr(self,attr))) + return srep + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +class TraceGraph: + """ + Cette classe définit le tracé d'un objet Graph dans un fichier. + + Attributs : + .NomFich : liste de noms de fichier de sortie + + Attributs privés (modifiés uniquement par les méthodes de la classe) : + .Fich : liste des objets 'fichier' + .Graph : objet Graph que l'on veut tracer + .DicForm : dictionnaire des formats de base (séparateur, format des réels...) + + Les méthodes Entete, DescrCourbe, Trace (définition de l'entete, partie descriptive + d'une courbe, méthode de tracé/impression) sont définies dans une classe dérivée. + """ +# ------------------------------------------------------------------------------ + def __init__(self,graph,FICHIER,fmod='w',dform=None,opts={}): + """Construction, ouverture du fichier, surcharge éventuelle du formatage + (dform), mode d'ouverture du fichier (fmod). + opts : dictionnaire dont les valeurs seront affectées comme attributs + de l'objet (A utiliser pour les propriétés spécifiques + à un format, exemple 'PILOTE' pour Xmgrace). + """ + # attributs optionnels (au début pour éviter un écrasement maladroit !) + for k,v in opts.items(): + setattr(self,k,v) + + # Ouverture du(des) fichier(s) + self.NomFich=[] + if type(FICHIER) is types.StringType: + self.NomFich.append(FICHIER) + elif type(FICHIER) in (types.ListType, types.TupleType): + self.NomFich=FICHIER[:] + else: + # dans ce cas, on écrira sur stdout (augmenter le 2 éventuellement) + self.NomFich=[None]*2 + self.Fich=[] + for ff in self.NomFich: + if ff<>None: + self.Fich.append(open(ff,fmod)) + else: + self.Fich.append(sys.stdout) + + # objet Graph sous-jacent + self.Graph=graph + # si Min/Max incohérents + if graph.Min_X==None or graph.Max_X==None or graph.Min_X > graph.Max_X: + graph.SetExtremaX(marge=0.05, force=True) + if graph.Min_Y==None or graph.Max_Y==None or graph.Min_Y > graph.Max_Y: + graph.SetExtremaY(marge=0.05, force=True) + + if graph.Echelle_X=='LOG': + graph.Grille_X=10 + # verif si Min<0 à cause de la marge + if graph.Min_X < 0.: + if graph.BBXmin < 0.: + UTMESS('A', 'GRAPH0_4') + graph.Min_X=graph.MinP_X + if graph.Echelle_Y=='LOG': + graph.Grille_Y=10 + if graph.Min_Y < 0.: + if graph.BBYmin < 0.: + UTMESS('A', 'GRAPH0_5') + graph.Min_Y=graph.MinP_Y + + # formats de base (identiques à ceux du module Table) + self.DicForm={ + 'csep' : ' ', # séparateur + 'ccom' : '#', # commentaire + 'ccpara' : '', # commentaire des labels + 'cdeb' : '', # début de ligne + 'cfin' : '\n', # fin de ligne + 'sepch' : ';', # remplace les sauts de ligne à l'intérieur d'une cellule + 'formK' : '%-12s', # chaines + 'formR' : '%12.5E', # réels + 'formI' : '%12d' # entiers + } + if dform<>None and type(dform)==types.DictType: + self.DicForm.update(dform) + + # let's go + self.Trace() + +# ------------------------------------------------------------------------------ + def __del__(self): + """Fermeture du(des) fichier(s) à la destruction""" + if hasattr(self,'Fich'): + self._FermFich() +# ------------------------------------------------------------------------------ + def _FermFich(self): + """Fermeture du(des) fichier(s)""" + for fp in self.Fich: + if fp<>sys.stdout: + fp.close() +# ------------------------------------------------------------------------------ + def _OuvrFich(self): + """Les fichiers sont ouverts par le constructeur. S'ils ont été fermés, + par un appel au Tracé, _OuvrFich ouvre de nouveau les fichiers dans le + meme mode""" + n=len(self.NomFich) + for i in range(n): + if self.Fich[i].closed: + self.Fich[i]=open(self.NomFich[i],self.Fich[i].mode) + +# ------------------------------------------------------------------------------ + def Entete(self): + """Retourne l'entete""" + raise NotImplementedError, "Cette méthode doit etre définie par la classe fille." +# ------------------------------------------------------------------------------ + def DescrCourbe(self,**args): + """Retourne la chaine de caractères décrivant les paramètres de la courbe. + """ + raise NotImplementedError, "Cette méthode doit etre définie par la classe fille." +# ------------------------------------------------------------------------------ + def Trace(self): + """Méthode pour 'tracer' l'objet Graph dans un fichier. + Met en page l'entete, la description des courbes et les valeurs selon + le format et ferme le fichier. + """ + raise NotImplementedError, "Cette méthode doit etre définie par la classe fille." + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +class TraceTableau(TraceGraph): + """ + Impression d'un objet Graph sous forme d'un tableau de colonnes, + on suppose que les courbes partagent la meme liste d'abscisse à 'EPSILON' + près, sinon on alarme. + """ + EPSILON=1.e-4 +# ------------------------------------------------------------------------------ + def Trace(self): + """Méthode pour 'tracer' l'objet Graph dans un fichier. + Met en page l'entete, la description des courbes et les valeurs selon + le format et ferme le fichier. + L'ouverture et la fermeture du fichier sont gérées par l'objet Table. + """ + g=self.Graph + msg=[] + if g.NbCourbe > 0: + # validité des données (abscisses identiques) + t0=numpy.array(g.Courbe(0)['Abs']) + max0=max(abs(t0)) + for i in range(1,g.NbCourbe): + if g.Courbe(i)['NbPts']<>g.Courbe(0)['NbPts']: + msg.append("La courbe %d n'a pas le meme " \ + "nombre de points que la 1ère." % i) + else: + ti=numpy.array(g.Courbe(i)['Abs']) + if max(abs((ti-t0).ravel())) > self.EPSILON*max0: + msg.append("Courbe %d : écart entre les "\ + "abscisses supérieur à %9.2E" % (i+1,self.EPSILON)) + msg.append(" Utilisez IMPR_FONCTION pour interpoler " \ + "les valeurs sur la première liste d'abscisses.") + # objet Table + Tab=Table.Table() + # titre / sous-titre + tit=[] + tit.append(self.DicForm['ccom']+' '+g.Titre) + tit.append(self.DicForm['ccom']+' '+g.SousTitre) + # legendes + for i in range(g.NbCourbe): + tit.append(self.DicForm['ccom']+' Courbe '+str(i)) + tit.extend([self.DicForm['ccom']+' '+leg for leg in g.Legendes[i].split(os.linesep)]) + Tab.titr=self.DicForm['cfin'].join(tit) + # noms des paramètres/colonnes + Tab.para.append(g.Labels[0][0]) + for i in range(g.NbCourbe): + for lab in g.Labels[i][1:]: + Tab.para.append(lab) + # types + Tab.type=['R']*len(Tab.para) + # lignes de la Table + dC0=g.Courbe(0) + for j in range(dC0['NbPts']): + row={} + row[dC0['LabAbs']]=dC0['Abs'][j] + for i in range(g.NbCourbe): + dCi=g.Courbe(i) + for k in range(dCi['NbCol']-1): + try: + row[dCi['LabOrd'][k]]=dCi['Ord'][k][j] + except IndexError: + row[dCi['LabOrd'][k]]=None + Tab.append(row) + Tab.Impr(FICHIER=self.NomFich[0], FORMAT='TABLEAU', dform=self.DicForm) + # erreurs ? + if msg: + UTMESS('A', 'GRAPH0_6', valk='\n'.join(msg)) + return + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +class TraceXmgrace(TraceGraph): + """ + Impression d'un objet Graph au format XMGRACE. + Attribut supplémentaire : .PILOTE + """ + PILOTE='' +# ------------------------------------------------------------------------------ + def Entete(self): + """Retourne l'entete du fichier .agr correspondant à la mise en forme + """ + dic_ech={ 'LIN' : 'Normal', 'LOG' : 'Logarithmic' } + g=self.Graph + entete=[] + entete.append(""" +# Grace project file +# +@version 50100 +@page size 842, 595 +@page scroll 5% +@page inout 5% +@link page off +@map font 0 to "Times-Roman", "Times-Roman" +@map font 1 to "Times-Italic", "Times-Italic" +@map font 2 to "Times-Bold", "Times-Bold" +@map font 3 to "Times-BoldItalic", "Times-BoldItalic" +@map font 4 to "Helvetica", "Helvetica" +@map font 5 to "Helvetica-Oblique", "Helvetica-Oblique" +@map font 6 to "Helvetica-Bold", "Helvetica-Bold" +@map font 7 to "Helvetica-BoldOblique", "Helvetica-BoldOblique" +@map font 8 to "Courier", "Courier" +@map font 9 to "Courier-Oblique", "Courier-Oblique" +@map font 10 to "Courier-Bold", "Courier-Bold" +@map font 11 to "Courier-BoldOblique", "Courier-BoldOblique" +@map font 12 to "Symbol", "Symbol" +@map font 13 to "ZapfDingbats", "ZapfDingbats" +@map color 0 to (255, 255, 255), "white" +@map color 1 to (0, 0, 0), "black" +@map color 2 to (255, 0, 0), "red" +@map color 3 to (0, 255, 0), "green" +@map color 4 to (0, 0, 255), "blue" +@map color 5 to (255, 255, 0), "yellow" +@map color 6 to (188, 143, 143), "brown" +@map color 7 to (220, 220, 220), "grey" +@map color 8 to (148, 0, 211), "violet" +@map color 9 to (0, 255, 255), "cyan" +@map color 10 to (255, 0, 255), "magenta" +@map color 11 to (255, 165, 0), "orange" +@map color 12 to (114, 33, 188), "indigo" +@map color 13 to (103, 7, 72), "maroon" +@map color 14 to (64, 224, 208), "turquoise" +@map color 15 to (0, 139, 0), "green4" +@reference date 0 +@date wrap off +@date wrap year 1950 +@timestamp off +@default linewidth 1.0 +@default linestyle 1 +@default color 1 +@default pattern 1 +@default font 0 +@default char size 1.000000 +@default symbol size 1.000000 +@default sformat "%.8g" +@background color 0 +@page background fill on +@r0 off +@link r0 to g0 +@r0 type above +@r0 linestyle 1 +@r0 linewidth 1.0 +@r0 color 1 +@r0 line 0, 0, 0, 0 +@r1 off +@link r1 to g0 +@r1 type above +@r1 linestyle 1 +@r1 linewidth 1.0 +@r1 color 1 +@r1 line 0, 0, 0, 0 +@r2 off +@link r2 to g0 +@r2 type above +@r2 linestyle 1 +@r2 linewidth 1.0 +@r2 color 1 +@r2 line 0, 0, 0, 0 +@r3 off +@link r3 to g0 +@r3 type above +@r3 linestyle 1 +@r3 linewidth 1.0 +@r3 color 1 +@r3 line 0, 0, 0, 0 +@r4 off +@link r4 to g0 +@r4 type above +@r4 linestyle 1 +@r4 linewidth 1.0 +@r4 color 1 +@r4 line 0, 0, 0, 0 +@g0 on +@g0 hidden false +@g0 type XY +@g0 stacked false +@g0 bar hgap 0.000000 +@with g0 +@ stack world 0, 0, 0, 0 +@ znorm 1 +@ view xmin 0.150000 +@ view xmax 1.150000 +@ view ymin 0.150000 +@ view ymax 0.850000 +@ title font 0 +@ title size 1.500000 +@ title color 1 +@ subtitle font 0 +@ subtitle size 1.000000 +@ subtitle color 1 +@ xaxes invert off +@ yaxes invert off +@ xaxis on +@ xaxis type zero false +@ xaxis offset 0.000000 , 0.000000 +@ xaxis bar on +@ xaxis bar color 1 +@ xaxis bar linestyle 1 +@ xaxis bar linewidth 1.0 +@ xaxis label layout para +@ xaxis label place auto +@ xaxis label char size 1.000000 +@ xaxis label font 0 +@ xaxis label color 1 +@ xaxis label place normal +@ xaxis tick on +@ xaxis tick minor ticks 1 +@ xaxis tick default 6 +@ xaxis tick place rounded true +@ xaxis tick in +@ xaxis tick major size 1.000000 +@ xaxis tick major color 1 +@ xaxis tick major linewidth 1.0 +@ xaxis tick major linestyle 2 +@ xaxis tick major grid on +@ xaxis tick minor color 1 +@ xaxis tick minor linewidth 1.0 +@ xaxis tick minor linestyle 2 +@ xaxis tick minor grid off +@ xaxis tick minor size 0.500000 +@ xaxis ticklabel on +@ xaxis ticklabel format general +@ xaxis ticklabel prec 5 +@ xaxis ticklabel angle 0 +@ xaxis ticklabel skip 0 +@ xaxis ticklabel stagger 0 +@ xaxis ticklabel place normal +@ xaxis ticklabel offset auto +@ xaxis ticklabel offset 0.000000 , 0.010000 +@ xaxis ticklabel start type auto +@ xaxis ticklabel start 0.000000 +@ xaxis ticklabel stop type auto +@ xaxis ticklabel stop 0.000000 +@ xaxis ticklabel char size 0.800000 +@ xaxis ticklabel font 0 +@ xaxis ticklabel color 1 +@ xaxis ticklabel formula "" +@ xaxis ticklabel append "" +@ xaxis ticklabel prepend "" +@ xaxis tick place both +@ xaxis tick spec type none +@ yaxis on +@ yaxis type zero false +@ yaxis offset 0.000000 , 0.000000 +@ yaxis bar on +@ yaxis bar color 1 +@ yaxis bar linestyle 1 +@ yaxis bar linewidth 1.0 +@ yaxis label layout para +@ yaxis label place auto +@ yaxis label char size 1.000000 +@ yaxis label font 0 +@ yaxis label color 1 +@ yaxis label place normal +@ yaxis tick on +@ yaxis tick minor ticks 1 +@ yaxis tick default 6 +@ yaxis tick place rounded true +@ yaxis tick in +@ yaxis tick major size 1.000000 +@ yaxis tick major color 1 +@ yaxis tick major linewidth 1.0 +@ yaxis tick major linestyle 2 +@ yaxis tick major grid on +@ yaxis tick minor color 1 +@ yaxis tick minor linewidth 1.0 +@ yaxis tick minor linestyle 1 +@ yaxis tick minor grid off +@ yaxis tick minor size 0.500000 +@ yaxis ticklabel on +@ yaxis ticklabel format general +@ yaxis ticklabel prec 5 +@ yaxis ticklabel angle 0 +@ yaxis ticklabel skip 0 +@ yaxis ticklabel stagger 0 +@ yaxis ticklabel place normal +@ yaxis ticklabel offset auto +@ yaxis ticklabel offset 0.000000 , 0.010000 +@ yaxis ticklabel start type auto +@ yaxis ticklabel start 0.000000 +@ yaxis ticklabel stop type auto +@ yaxis ticklabel stop 0.000000 +@ yaxis ticklabel char size 0.800000 +@ yaxis ticklabel font 0 +@ yaxis ticklabel color 1 +@ yaxis ticklabel formula "" +@ yaxis ticklabel append "" +@ yaxis ticklabel prepend "" +@ yaxis tick place both +@ yaxis tick spec type none +@ altxaxis off +@ altyaxis off +@ legend on +@ legend loctype view +@ legend 0.85, 0.8 +@ legend box color 1 +@ legend box pattern 1 +@ legend box linewidth 1.0 +@ legend box linestyle 1 +@ legend box fill color 0 +@ legend box fill pattern 1 +@ legend font 0 +@ legend char size 0.750000 +@ legend color 1 +@ legend length 4 +@ legend vgap 1 +@ legend hgap 1 +@ legend invert false +@ frame type 0 +@ frame linestyle 1 +@ frame linewidth 1.0 +@ frame color 1 +@ frame pattern 1 +@ frame background color 0 +@ frame background pattern 0 +""") + entete.append('@ title "'+g.Titre+'"') + entete.append('@ subtitle "'+g.SousTitre+'"') + entete.append('@ xaxis label "'+g.Legende_X+'"') + entete.append('@ yaxis label "'+g.Legende_Y+'"') + entete.append('@ xaxes scale '+dic_ech[g.Echelle_X]) + entete.append('@ yaxes scale '+dic_ech[g.Echelle_Y]) + entete.append('@ xaxis tick major '+str(g.Grille_X)) + entete.append('@ yaxis tick major '+str(g.Grille_Y)) + entete.append('@ world xmin '+str(g.Min_X)) + entete.append('@ world xmax '+str(g.Max_X)) + entete.append('@ world ymin '+str(g.Min_Y)) + entete.append('@ world ymax '+str(g.Max_Y)) + return entete +# ------------------------------------------------------------------------------ + def DescrCourbe(self,**args): + """Retourne la chaine de caractères décrivant les paramètres de la courbe. + """ + # valeurs par défaut + sty = str(ValCycl(args['Sty'],0,8,1)) + color = str(ValCycl(args['Coul'],1,15,args['NumSet']+1)) + symbol= str(ValCycl(args['Marq'],0,10,args['NumSet'])) + freqm = str(ValCycl(args['FreqM'],0,-1,0)) + + sn=str(args['NumSet']) + descr=[] + descr.append(string.replace(""" +@ s0 hidden false +@ s0 type xy +@ s0 symbol size 1.000000 +@ s0 symbol pattern 1 +@ s0 symbol linestyle 1 +@ s0 symbol fill pattern 0 +@ s0 symbol linewidth 1.0 +@ s0 symbol char 65 +@ s0 symbol char font 0 +@ s0 line type 1 +@ s0 line linewidth 1.0 +@ s0 line pattern 1 +@ s0 baseline type 0 +@ s0 baseline off +@ s0 dropline off +@ s0 fill type 0 +@ s0 fill rule 0 +@ s0 fill pattern 1 +@ s0 avalue off +@ s0 avalue type 2 +@ s0 avalue char size 1.000000 +@ s0 avalue font 0 +@ s0 avalue rot 0 +@ s0 avalue format general +@ s0 avalue prec 3 +@ s0 avalue prepend "" +@ s0 avalue append "" +@ s0 avalue offset 0.000000 , 0.000000 +@ s0 errorbar on +@ s0 errorbar place both +@ s0 errorbar pattern 1 +@ s0 errorbar size 1.000000 +@ s0 errorbar linewidth 1.0 +@ s0 errorbar linestyle 1 +@ s0 errorbar riser linewidth 1.0 +@ s0 errorbar riser linestyle 1 +@ s0 errorbar riser clip off +@ s0 errorbar riser clip length 0.100000 + +@ s0 comment "" +""",' s0 ',' s'+sn+' ')) + descr.append('@ s'+sn+' symbol '+symbol) + descr.append('@ s'+sn+' symbol color '+color) + descr.append('@ s'+sn+' symbol skip '+freqm) + descr.append('@ s'+sn+' symbol fill color '+color) + descr.append('@ s'+sn+' line linestyle '+sty) + descr.append('@ s'+sn+' line color '+color) + descr.append('@ s'+sn+' fill color '+color) + descr.append('@ s'+sn+' avalue color '+color) + descr.append('@ s'+sn+' errorbar color '+color) + descr.append('@ s'+sn+' legend "'+args['Leg'].replace(os.linesep, ' ; ')+'"') + return descr +# ------------------------------------------------------------------------------ + def Trace(self): + """Méthode pour 'tracer' l'objet Graph dans un fichier. + Met en page l'entete, la description des courbes et les valeurs selon + le format et ferme le fichier. + """ + g = self.Graph + if self.PILOTE == 'INTERACTIF': + self.NomFich[0] = 'Trace_%s.dat' % time.strftime('%y%m%d%H%M%S',time.localtime()) + self.Fich[0] = open(self.NomFich[0],'w') + # initialise le graph + self._FermFich() + nbsets, x0, x1, y0, y1 = IniGrace(self.NomFich[0]) + NumSetIni = nbsets+1 + g.SetExtrema(0.05, x0, x1, y0, y1, force=False) + # si Min/Max incohérents + if g.Echelle_X=='LOG': + g.Grille_X=10 + if g.Min_X < 0.: + if g.BBXmin < 0.: + UTMESS('A', 'GRAPH0_4') + g.Min_X=g.MinP_X + if g.Echelle_Y=='LOG': + g.Grille_Y=10 + if g.Min_Y < 0.: + if g.BBYmin < 0.: + UTMESS('A', 'GRAPH0_5') + g.Min_Y=g.MinP_Y + + if g.NbCourbe < 1: + self._FermFich() + return + # cohérence des valeurs par défaut + if g.Grille_X<0 or g.Grille_Y<0: + deltaX=g.Max_X-g.Min_X + deltaY=g.Max_Y-g.Min_Y + g.Grille_X=deltaX/5. + g.Grille_Y=deltaY/5. + if deltaX>4: + g.Grille_X=int(round(g.Grille_X)) + if deltaY>4: + g.Grille_Y=int(round(g.Grille_Y)) + if g.Grille_X == 0.: + g.Grille_X = 1.e-6 + if g.Grille_Y == 0.: + g.Grille_Y = 1.e-6 + # entete + content = self.Entete() + content.append('') + # valeurs + it=-1 + for i in range(g.NbCourbe): + dCi=g.Courbe(i) + for k in range(dCi['NbCol']-1): + it=it+1 + dCi['NumSet'] = NumSetIni + it + content.extend(self.DescrCourbe(**dCi)) + content.append('') + # partie données (.dat) + it=-1 + for i in range(g.NbCourbe): + dCi=g.Courbe(i) + for k in range(dCi['NbCol']-1): + it=it+1 + content.append('@target g0.s%d' % (NumSetIni + it)) + content.append('@type xy') + listX, listY = Tri(g.Tri, lx=dCi['Abs'], ly=dCi['Ord'][k]) + for j in range(dCi['NbPts']): + svX = self.DicForm['formR'] % listX[j] + svY = self.DicForm['formR'] % listY[j] + content.append(self.DicForm['formR'] % listX[j] + \ + ' ' + self.DicForm['formR'] % listY[j]) + content.append('&') + content.append('') + + # Production du fichier postscript, jpeg ou lancement interactif + pilo=self.PILOTE + if pilo == '': + self._OuvrFich() + self.Fich[0].write('\n'.join(content)) + self._FermFich() + else: + xmgr=os.path.join(aster.repout(),'xmgrace') + nfwrk = self.NomFich[0]+'.wrk' + open(nfwrk, 'w').write('\n'.join(content)) + nfhard = self.NomFich[0]+'.hardcopy' + # nom exact du pilote + if pilo == 'POSTSCRIPT': + pilo = 'PostScript' + elif pilo == 'INTERACTIF': + pilo = 'X11' + # ligne de commande + if pilo == 'X11': + lcmde = '%s %s' % (xmgr, nfwrk) + if not os.environ.has_key('DISPLAY') or os.environ['DISPLAY']=='': + os.environ['DISPLAY']=':0.0' + UTMESS('I','GRAPH0_7') + UTMESS('I','GRAPH0_8', valk=os.environ['DISPLAY']) + else: + if os.path.exists(os.path.join(aster.repout(),'gracebat')): + xmgr = os.path.join(aster.repout(),'gracebat') + lcmde = '%s -hdevice %s -hardcopy -printfile %s %s' % (xmgr, pilo, nfhard, nfwrk) + # appel xmgrace + UTMESS('I','EXECLOGICIEL0_8', valk=lcmde) + if not os.path.exists(xmgr): + UTMESS('S','EXECLOGICIEL0_6', valk=xmgr) + iret = os.system(lcmde) + if iret == 0 or os.path.exists(nfhard): + if pilo not in ('', 'X11'): + new = open(nfhard, 'r').read() + open(self.NomFich[0], 'a').write(new) + else: + UTMESS('A','GRAPH0_9', valk=pilo) + # menage + if self.PILOTE == 'INTERACTIF': + os.remove(self.NomFich[0]) + return + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +class TraceAgraf(TraceGraph): + """ + Impression d'un objet Graph au format AGRAF. + """ +# ------------------------------------------------------------------------------ + def Entete(self): + """Retourne l'entete des directives Agraf""" + dic_ech={ 'LIN' : '0', 'LOG' : '1' } + g=self.Graph + entete=[] + entete.append(""" +ASPECT_GRAPHIQUE: + En-tete :Departement Analyses Mecaniques et Acoustique + Aspect :0 + Nombre de vues :1 + Cesure commentaire :40 + MinMax :0 + Fonte Titre :%helvetica-14 + Fonte Axes :%courier-12 + Fonte Autre :%times-12 + + DEFAUT_COURBE: + Couleur (rvb) : 0 0 0 + + DEFAUT_COURBE: + Couleur (rvb) : 65535 0 0 + + DEFAUT_COURBE: + Couleur (rvb) : 11822 35723 22359 + + DEFAUT_COURBE: + Couleur (rvb) : 0 0 65535 + + DEFAUT_COURBE: + Couleur (rvb) : 65535 0 65535 + + DEFAUT_COURBE: + Couleur (rvb) : 0 65535 65535 + + DEFAUT_COURBE: + Couleur (rvb) : 0 65535 0 + + DEFAUT_COURBE: + Couleur (rvb) : 41120 21074 11565 + + DEFAUT_COURBE: + Couleur (rvb) : 65535 42405 0 + + DEFAUT_COURBE: + Couleur (rvb) : 41120 8224 61680 + + DEFAUT_COURBE: + Couleur (rvb) : 65535 65535 0 + + DEFAUT_COURBE: + Couleur (rvb) : 53970 46260 35980 + +GRAPHIQUE: +""") + if g.Titre=='': + g.Titre='GRAPHIQUE CODE_ASTER' + entete.append('Titre :'+g.Titre+'\n') + if g.SousTitre<>'': + entete.append('Commentaire :'+g.SousTitre+'\n') + entete.append('Frequence Grille X :'+str(int(g.Grille_X))+'\n') + entete.append('Frequence Grille Y :'+str(int(g.Grille_Y))+'\n') + entete.append('Echelle X :'+dic_ech[g.Echelle_X]+'\n') + entete.append('Echelle Y :'+dic_ech[g.Echelle_Y]+'\n') + if g.Legende_X<>'': + entete.append('Legende X :'+g.Legende_X+'\n') + if g.Legende_Y<>'': + entete.append('Legende Y :'+g.Legende_Y+'\n') + entete.append('Min X : '+str(g.Min_X)+'\n') + entete.append('Max X : '+str(g.Max_X)+'\n') + entete.append('Min Y : '+str(g.Min_Y)+'\n') + entete.append('Max Y : '+str(g.Max_Y)+'\n') + + return entete +# ------------------------------------------------------------------------------ + def DescrCourbe(self,**args): + """Retourne la chaine de caractères décrivant les paramètres de la courbe. + """ + # valeurs par défaut + sty = str(ValCycl(args['Sty'],0,2,0)) + color = str(ValCycl(args['Coul'],0,12,args['NumSet'])) + symbol= str(ValCycl(args['Marq'],0,12,args['NumSet'])) + freqm = str(ValCycl(args['FreqM'],0,-1,0)) + + descr=[] + descr.append(' COURBE:\n') + descr.append(' Trait :'+sty+'\n') + descr.append(' Couleur :'+color+'\n') + descr.append(' Marqueur :'+symbol+'\n') + descr.append(' Frequence Marqueur :'+freqm+'\n') + if args['Leg']<>'': + descr.append(' Legende :'+args['Leg']+'\n') + descr.append(' Tri :'+args['Tri']+'\n') + descr.append(' Abscisses : [ '+str(args['Bloc'])+', '+str(args['ColX'])+']\n') + descr.append(' Ordonnees : [ '+str(args['Bloc'])+', '+str(args['ColY'])+']\n') + return descr +# ------------------------------------------------------------------------------ + def Trace(self): + """Méthode pour 'tracer' l'objet Graph dans un fichier. + Met en page l'entete, la description des courbes et les valeurs selon + le format et ferme le fichier. + """ + self._OuvrFich() + fdogr=self.Fich[0] + fdigr=self.Fich[1] + g=self.Graph + if g.NbCourbe > 0: + # cohérence des valeurs par défaut + if g.Grille_X<0 or g.Grille_Y<0: + g.Grille_X=0 + g.Grille_Y=0 + # entete + for lig in self.Entete(): + fdigr.write(lig) + # valeurs + for i in range(g.NbCourbe): + dCi=g.Courbe(i) + dCi['NumSet']=i + # partie directives (.digr) + for k in range(dCi['NbCol']-1): + dCi['Bloc']=i+1 + dCi['ColX']=1 + dCi['ColY']=k+2 + for lig in self.DescrCourbe(**dCi): + fdigr.write(lig) + # partie données (.dogr) + if dCi['Leg']<>'': + leg=dCi['Leg'] + else: + leg='COURBE_'+str(i) + fdogr.write('#NOM DE LA FONCTION: '+leg+'\n') + for j in range(dCi['NbPts']): + for k in range(dCi['NbCol']): + sv=self.DicForm['formR'] % g.Valeurs[i][k][j] + fdogr.write(' '+sv) + fdogr.write('\n') + fdogr.write('\n') + self._FermFich() + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +def ValCycl(val,vmin,vmax,vdef): + """ + Retourne une valeur entre vmin et vmax (bornes incluses) : + - si valvmax, on cycle tel que val=vmax+1 retourne vmin, etc. + - si vmax0: + os.rename(fich, fich+'.prev') + fpre=open(fich+'.prev', 'r') + fnew=open(fich, 'w') + for line in fpre: + ikeep=True + mat=re.search('@target g[0-9]+\.s([0-9]+)', line) + if mat<>None and int(mat.group(1))>ns: + ns=int(mat.group(1)) + mat=re.search('@[ ]+world[ ]+xmin[ ]+([\-\+\.0-9eEdD]+)', line) + if mat<>None: + try: + x0=float(mat.group(1)) + ikeep=False + except ValueError: + pass + mat=re.search('@[ ]+world[ ]+xmax[ ]+([\-\+\.0-9eEdD]+)', line) + if mat<>None: + try: + x1=float(mat.group(1)) + ikeep=False + except ValueError: + pass + mat=re.search('@[ ]+world[ ]+ymin[ ]+([\-\+\.0-9eEdD]+)', line) + if mat<>None: + try: + y0=float(mat.group(1)) + ikeep=False + except ValueError: + pass + mat=re.search('@[ ]+world[ ]+ymax[ ]+([\-\+\.0-9eEdD]+)', line) + if mat<>None: + try: + y1=float(mat.group(1)) + ikeep=False + except ValueError: + pass + if ikeep: + fnew.write(line) + fpre.close() + fnew.close() + try: + UTMESS('I', 'GRAPH0_10', valk=fich, vali=ns, valr=(x0, x1, y0, y1)) + except TypeError: + # pas un format xmgrace + pass + return ns, x0, x1, y0, y1 diff --git a/Aster/Cata/cataSTA10/Utilitai/System.py b/Aster/Cata/cataSTA10/Utilitai/System.py new file mode 100644 index 00000000..ccc3996e --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/System.py @@ -0,0 +1,218 @@ +#@ MODIF System Utilitai DATE 13/10/2009 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +# RESPONSABLE COURTOIS M.COURTOIS + +"""Ce module définit la classe `SYSTEM` et la fonction `ExecCommand` +qui est présente uniquement pour commodité pour les Macros. + +La classe SYSTEM est semblable à celle utilisée dans asrun. +""" + +__all__ = ["SYSTEM", "ExecCommand"] + +import sys +import os +import re +import tempfile + +# ----- differ messages translation +def _(mesg): + return mesg + + +def _exitcode(status, default=0): + """ + Extract the exit code from status. Return 'default' if the process + has not been terminated by exit. + """ + if os.WIFEXITED(status): + iret = os.WEXITSTATUS(status) + elif os.WIFSIGNALED(status): + iret = os.WTERMSIG(status) + elif os.WIFSTOPPED(status): + iret = os.WSTOPSIG(status) + else: + iret = default + return iret + + + +class SYSTEM: + """ + Class to encapsultate "system" commands (this a simplified version of + ASTER_SYSTEM class defined in ASTK_SERV part). + """ + # this value should be set during installation step. + MaxCmdLen = 1024 + # line length -9 + _LineLen = 80-9 + + def __init__(self, **kargs): + """ + Initialization. + Optionnal arguments : silent, verbose, debug, cc_files, maxcmdlen. + """ + self.verbose = kargs.get('verbose', True) + self.debug = kargs.get('debug', False) + self.cc_files = kargs.get('cc_files', None) + if kargs.has_key('maxcmdlen'): + self.MaxCmdLen = kargs['maxcmdlen'] + + def _mess(self, msg, cod=''): + """ + Just print a message + """ + self._print('%-18s %s' % (cod, msg)) + + def _print(self, *args, **kargs): + """ + print replacement. + Optionnal argument : + term : line terminator (default to os.linesep). + """ + term = kargs.get('term', os.linesep) + files = set([sys.stdout]) + if self.cc_files: + files.add(self.cc_files) + for f in files: + if type(f) is file: + txt = ' '.join(['%s'%a for a in args]) + f.write(txt.replace(os.linesep+' ', os.linesep)+term) + f.flush() + else: + print _('file object expected : %s / %s') % (type(f), repr(f)) + + def VerbStart(self, cmd, verbose=None): + """ + Start message in verbose mode + """ + Lm = self._LineLen + if verbose == None: + verbose = self.verbose + if verbose: + pcmd = cmd + if len(cmd) > Lm-2 or cmd.count('\n') > 0: + pcmd = pcmd+'\n'+' '*Lm + self._print(('%-'+str(Lm)+'s') % (pcmd,), term='') + + def VerbEnd(self, iret, output='', verbose=None): + """ + End message in verbose mode + """ + if verbose == None: + verbose = self.verbose + if verbose: + if iret == 0: + self._print('[ OK ]') + else: + self._print(_('[FAILED]')) + self._print(_('Exit code : %d') % iret) + if (iret != 0 or self.debug) and output: + self._print(output) + + def VerbIgnore(self, verbose=None): + """ + End message in verbose mode + """ + if verbose == None: + verbose = self.verbose + if verbose: + self._print(_('[ SKIP ]')) + + def Shell(self, cmd, bg=False, verbose=False, follow_output=False, + alt_comment=None, interact=False, separated_stderr=False): + """ + Execute a command shell + cmd : command + bg : put command in background if True + verbose : print status messages during execution if True + follow_output : follow interactively output of command + alt_comment : print this "alternative comment" instead of "cmd" + interact : allow the user to interact with the process. + Return : + iret : exit code if bg = False, + 0 if bg = True + output : output lines (as string) + """ + if not alt_comment: + alt_comment = cmd + if bg: + interact = False + if len(cmd) > self.MaxCmdLen: + self._mess((_('length of command shell greater '\ + 'than %d characters.') % self.MaxCmdLen), '_ALARM') + if self.debug: + self._print('cmd :', cmd, 'background : %s' % bg, 'follow_output : %s' % follow_output) + self.VerbStart(alt_comment, verbose=verbose) + if follow_output and verbose: + print os.linesep+_('Command output :') + + fout = tempfile.NamedTemporaryFile() + ferr = tempfile.NamedTemporaryFile() + if bg: + new_cmd = cmd + ' &' + elif follow_output: + new_cmd = '( %s ) | tee %s' % (cmd, fout.name) + else: + if not separated_stderr: + new_cmd = '( %s ) > %s 2>&1' % (cmd, fout.name) + else: + new_cmd = '( %s ) > %s 2> %s' % (cmd, fout.name, ferr.name) + if self.debug: + self._print('modified cmd :', new_cmd) + # execution + iret = os.system(new_cmd) + fout.seek(0) + output = fout.read() + ferr.seek(0) + error = ferr.read() + fout.close() + ferr.close() + + if follow_output: + # repeat header message + self.VerbStart(alt_comment, verbose=verbose) + mat = re.search('EXIT_CODE=([0-9]+)', output) + if mat: + iret = int(mat.group(1)) + self.VerbEnd(iret, output, verbose=verbose) + if self.debug and iret != 0: + self._print(' ERROR : iret = %s' % iret) + self._print('STDOUT', output, all=True) + self._print('STDERR', error, all=True) + if bg: + iret = 0 + if not separated_stderr: + result = iret, output + else: + result = iret, output, error + return result + + +# Juste par commodité. +system = SYSTEM() +ExecCommand = system.Shell + + + +if __name__ == '__main__': + iret, output = ExecCommand('ls', alt_comment='Lancement de la commande...') + diff --git a/Aster/Cata/cataSTA10/Utilitai/Table.py b/Aster/Cata/cataSTA10/Utilitai/Table.py new file mode 100644 index 00000000..8943a58e --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/Table.py @@ -0,0 +1,1070 @@ +#@ MODIF Table Utilitai DATE 01/03/2011 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +# RESPONSABLE COURTOIS M.COURTOIS +__all__ = ['Table', 'merge'] + +import sys +import os +import re +from copy import copy +from types import IntType, FloatType, StringType, UnicodeType, NoneType + +from Noyau.N_types import is_int, is_float, is_complex, is_number, is_str, is_enum + +import transpose +from Utilitai.Utmess import UTMESS + +if not sys.modules.has_key('Graph'): + try: + from Utilitai import Graph + except ImportError: + import Graph + +# formats de base (identiques à ceux du module Graph) +DicForm = { + 'csep' : ' ', # séparateur + 'ccom' : '#', # commentaire + 'ccpara' : '', # commentaire des labels + 'cdeb' : '', # début de ligne + 'cfin' : '\n', # fin de ligne + 'sepch' : ';', # séparateur entre deux lignes d'une cellule + 'formK' : '%-12s', # chaines + 'formR' : '%12.5E', # réels + 'formI' : '%12d' # entiers +} +# type par défaut des chaines de caractères +Kdef = 'K24' + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +class TableBase(object): + """Classe pour partager les méthodes d'impression entre Table et Colonne + (c'est surtout utile pour vérifier que l'extraction et les filtres sur les + colonnes sont corrects). + """ + def __init__(self): + """Constructeur. + """ + self.rows=None + self.para=None + self.type=None + self.titr=None + + def __repr__(self): + return self.ReprTable() + def Croise(self, **kargs): + raise NotImplementedError, 'Must be defined in a derived class' + + def __len__(self): + """Retourne le nombre de ligne dans la Table/Colonne. + """ + return len(self.rows) + +# ------------------------------------------------------------------------------ + def Impr(self, FICHIER=None, FORMAT='TABLEAU', dform=None, **opts): + """Impresssion de la Table selon le format spécifié. + FICHIER : nom du(des) fichier(s). Si None, on dirige vers stdout + dform : dictionnaire de formats d'impression (format des réels, + commentaires, saut de ligne...) + opts : selon FORMAT. + """ + para={ + 'TABLEAU' : { 'mode' : 'a', 'driver' : self.ImprTableau, }, + 'ASTER' : { 'mode' : 'a', 'driver' : self.ImprTableau, }, + 'XMGRACE' : { 'mode' : 'a', 'driver' : self.ImprGraph, }, + 'AGRAF' : { 'mode' : 'a', 'driver' : self.ImprTableau, }, + 'TABLEAU_CROISE' : { 'mode' : 'a', 'driver' : self.ImprTabCroise, }, + } + kargs={ + 'FICHIER' : FICHIER, + 'FORMAT' : FORMAT, + 'dform' : DicForm.copy(), + 'mode' : para[FORMAT]['mode'], + } + if dform != None and type(dform) is dict: + kargs['dform'].update(dform) + # ajout des options + kargs.update(opts) + + if not kargs.get('PAGINATION'): + # call the associated driver + para[FORMAT]['driver'](**kargs) + + else: + if not is_enum(kargs['PAGINATION']): + ppag = [kargs['PAGINATION'],] + else: + ppag = list(kargs['PAGINATION']) + del kargs['PAGINATION'] + npag = len(ppag) + # paramètres hors ceux de la pagination + lkeep = [p for p in self.para if ppag.count(p)==0] + # création des listes des valeurs distinctes + lvd = [] + for p in ppag: + lvp = getattr(self,p).values() + lvn = [] + for it in lvp: + if it != None and lvn.count(it) == 0: + lvn.append(it) + lvn.sort() + lvd.append(lvn) + # création des n-uplets + s = '[['+','.join(['x'+str(i) for i in range(npag)])+'] ' + s += ' '.join(['for x'+str(i)+' in lvd['+str(i)+']' for i in range(npag)])+']' + try: + lnup = eval(s) + except SyntaxError, s: + UTMESS('F','TABLE0_20') + # pour chaque n-uplet, on imprime la sous-table + for nup in lnup: + tab = self + for i in range(npag): + tab = tab & (getattr(tab,ppag[i]) == nup[i]) + sl = '' + if tab.titr: sl='\n' + tab.titr += sl+ppag[i]+': '+str(nup[i]) + tab[lkeep].Impr(**kargs) + +# ------------------------------------------------------------------------------ + def ImprTableau(self,**kargs): + """Impression au format TABLEAU ou ASTER + """ + # fichier ou stdout + if kargs.get('FICHIER') != None: + f=open(kargs['FICHIER'],kargs['mode']) + else: + f=sys.stdout + # ecriture + f.write(self.ReprTable(**kargs) + '\n') + # fermeture + if kargs.get('FICHIER') != None: + f.close() + +# ------------------------------------------------------------------------------ + def ReprTable(self,FORMAT='TABLEAU',dform=None,**ignore): + """Représentation d'une Table ou d'une Colonne sous forme d'un tableau. + """ + rows=self.rows + para=self.para + typ =self.type + if not is_enum(para): + para=[self.para,] + typ =[self.type,] + if dform==None: + dform = DicForm.copy() + # est-ce que l'attribut .type est renseigné ? + typdef=typ != [None]*len(typ) + txt=[] + # ['']+ pour ajouter un séparateur en début de ligne + lspa=['',] + # lmax : largeur max des colonnes = max(form{K,R,I},len(parametre)) + lmax=[] + # formats + strfmt, strfmt_none = {}, {} + for t, p in zip(typ, para): + larg_max=max([len(str(p))] + \ + [len(FMT(dform,k,t) % 0) for k in ('formK','formR','formI')]) + lspa.append(FMT(dform,'formK',t,larg_max,str(p)) % p) + lmax.append(larg_max) + assert t is not None, "Type de la colonne '%s' non défini" % p + strfmt[p] = FMT(dform, 'form'+t[0], t, larg_max) + strfmt_none[p] = FMT(dform, 'formK', t, larg_max) + if typdef: + stype=dform['csep'].join([''] + \ + [FMT(dform,'formK',typ[i],lmax[i]) % typ[i] for i in range(len(para))]) + txt.append(dform['ccom']) + txt.append(dform['ccom']+'-'*80) + txt.append(dform['ccom']) + ASTER=(FORMAT=='ASTER') + if ASTER: + txt.append('#DEBUT_TABLE') + if self.titr: + if ASTER: + txt.extend(['#TITRE '+lig for lig in self.titr.split('\n')]) + else: + txt.extend([dform['ccom']+lig for lig in self.titr.split('\n')]) + txt.append(dform['ccpara'] + dform['csep'].join(lspa)) + if ASTER and typdef: + txt.append(stype) + for r in rows: + lig=[''] + empty=True + for t, p, lmax_i in zip(typ, para, lmax): + val = r.get(p) + if val is not None: + empty = False + lig.append(strfmt[p] % val) + else: + s = strfmt_none[p] % '-' + # format AGRAF = TABLEAU + '\' devant les chaines de caractères ! + if FORMAT=='AGRAF': + s='\\'+s + lig.append(s) + if not empty: + lig2 = [dform['sepch'].join(ch.splitlines()) for ch in lig] + txt.append(dform['csep'].join(lig2)) + if ASTER: + txt.append('#FIN_TABLE') + # ajout des debut et fin de ligne + txt=[dform['cdeb']+t+dform['cfin'] for t in txt] + + return ''.join(txt) +# ------------------------------------------------------------------------------ + def ImprTabCroise(self,**kargs): + """Impression au format TABLEAU_CROISE d'une table ayant 3 paramètres. + """ + # création du tableau croisé et impression au format TABLEAU + tabc=self.Croise() + kargs['FORMAT']='TABLEAU' + tabc.Impr(**kargs) +# ------------------------------------------------------------------------------ + def ImprGraph(self, **kargs): + """Impression au format XMGRACE : via le module Graph + """ + args=kargs.copy() + if len(self.para) != 2: + UTMESS('A','TABLE0_21') + return + # suppression des lignes contenant une cellule vide + tnv = getattr(self, self.para[0]).NON_VIDE() \ + & getattr(self, self.para[1]).NON_VIDE() + # objet Graph + graph=Graph.Graph() + dicC={ + 'Val' : [getattr(tnv, tnv.para[0]).values(), + getattr(tnv, tnv.para[1]).values()], + 'Lab' : tnv.para, + } + if args['LEGENDE']==None: del args['LEGENDE'] + Graph.AjoutParaCourbe(dicC, args) + graph.AjoutCourbe(**dicC) + + # Surcharge des propriétés du graphique et des axes + # (bloc quasiment identique dans impr_fonction_ops) + if args.get('TITRE'): graph.Titre=args['TITRE'] + if args.get('BORNE_X'): + graph.Min_X=args['BORNE_X'][0] + graph.Max_X=args['BORNE_X'][1] + if args.get('BORNE_Y'): + graph.Min_Y=args['BORNE_Y'][0] + graph.Max_Y=args['BORNE_Y'][1] + if args.get('LEGENDE_X'): graph.Legende_X=args['LEGENDE_X'] + if args.get('LEGENDE_Y'): graph.Legende_Y=args['LEGENDE_Y'] + if args.get('ECHELLE_X'): graph.Echelle_X=args['ECHELLE_X'] + if args.get('ECHELLE_Y'): graph.Echelle_Y=args['ECHELLE_Y'] + if args.get('GRILLE_X'): graph.Grille_X=args['GRILLE_X'] + if args.get('GRILLE_Y'): graph.Grille_Y=args['GRILLE_Y'] + + try: + graph.Trace(**args) + except TypeError: + UTMESS('A','TABLE0_22') + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +class Table(TableBase): + """Une table est construite comme une liste de lignes, chaque ligne est + un dictionnaire. + On crée puis on ajoute les lignes avec la méthode append : + t=Table() + t.append(dict(a=1,b=2)) + t.append(dict(a=3,b=4)) + La méthode __iter__ définit un itérateur sur les lignes de la table, + __repr__ retourne une représentation de la table, utilisée par "print t". + Grace à la classe Colonne et à sa méthode _extract, il est possible + de construire une sous-table qui satisfait un critère donné. + Le critère est donné par une fonction Python qui retourne vrai + ou faux si la valeur d'une colonne respecte le critère ou non. + Exemple: + def critere(valeur): + return valeur < 10 + soustable = t.a._extract(critere) + t.a retourne un objet intermédiaire de la classe Colonne qui mémorise + le nom de la colonne demandée (a, ici). + """ +# ------------------------------------------------------------------------------ + def __init__(self, rows=[], para=[], typ=[], titr=''): + """Constructeur de la Table : + rows : liste des lignes (dict) + para : liste des paramètres + type : liste des types des paramètres + titr : titre de la table + """ + self.rows = [r for r in rows if r.values() != [None]*len(r.values())] + self.para = list(para) + for i in self.para : + if self.para.count(i) != 1 : + UTMESS('F','TABLE0_23', valk=i) + if len(typ) == len(self.para): + self.type = list(typ) + else: + self.type = [None]*len(self.para) + self.titr = titr + +# ------------------------------------------------------------------------------ + def copy(self): + """Retourne une copie de la table. + """ + rows = [] + for r in self.rows: + rows.append(copy(r)) + return Table(rows, self.para[:], self.type[:], self.titr) + +# ------------------------------------------------------------------------------ + def add_para(self, para, typ): + """Ajoute un nouveau paramètre.""" + if not is_enum(para): + para=[para,] + if not is_enum(typ): + typ =[typ,] + if len(typ) != len(para): + typ = [typ[0],] * len(para) + for p, t in zip(para, typ): + if not p in self.para: + self.para.append(p) + self.type.append(t) + +# ------------------------------------------------------------------------------ + def append(self, obj): + """Ajoute une ligne (type dict) qui peut éventuellement définir un + nouveau paramètre.""" + para=obj.keys() + for p in para: + if not p in self.para: + self.add_para(p, _typaster(obj[p])) + else: + ip=self.para.index(p) + self.type[ip]=_typaster(obj[p], self.type[ip]) + self.rows.append(obj) + + + def extend(self, objs): + """Ajoute plusieurs lignes (list of dict).""" + for row in objs: + self.append(row) + +# ------------------------------------------------------------------------------ + def SansColonneVide(self, l_para=None): + """Retourne une copie de la table dans laquelle on a supprimé les colonnes + vides (les lignes vides sont automatiquement supprimées). + """ + # ptest : colonnes potentiellement vides + pkeep = l_para or self.para + ptest = pkeep[:] + for row in self: + notNone = [p for p in ptest if row.get(p) is not None] + ptest = [p for p in ptest if not p in notNone] + if len(ptest) == 0: + break + # pkeep : on conserve les colonnes non vides + pkeep = [p for p in pkeep if not p in ptest] + return self[pkeep] + +# ------------------------------------------------------------------------------ + def __setitem__(self, k_para, k_value): + """Ajoute une colonne k_para dont les valeurs sont dans k_value""" + if len(k_value) == 0: + return + if k_para in self.para : + UTMESS('F','TABLE0_24', valk=k_para) + self.add_para(k_para, typ=_typaster(k_value[0])) + i = 0 + for row in self: + if i < len(k_value): + row[k_para] = k_value[i] + self.type[-1] = _typaster(k_value[i], self.type[-1]) + else: + row[k_para] = None + i+=1 + for j in range(i, len(k_value)): + self.append({k_para : k_value[j]}) + +# ------------------------------------------------------------------------------ + def fromfunction(self, nom_para, funct, l_para=None, const=None): + """Ajoute une colonne `nom_para` en évaluant la fonction `funct` sur + la valeur des paramètres `l_para` (qui doivent exister dans la table). + Si `l_para` n'est pas fourni, on prend `funct`.nompar (FORMULE Aster). + On peut passer un dictionnaire de constantes dans `const`. Quand on + utilise une FORMULE Aster, les constantes sont prises dans le contexte + global. + """ + # vérif préalables + if not hasattr(funct, '__call__'): + UTMESS('F', 'TABLE0_25', valk=funct.__name__) + if nom_para in self.para : + UTMESS('F','TABLE0_24', valk=nom_para) + if l_para == None: + if not hasattr(funct, 'nompar'): + UTMESS('F', 'TABLE0_26', valk=funct.__name__) + l_para = funct.nompar + if not is_enum(l_para): + l_para = [l_para] + not_found = ', '.join([p for p in l_para if not p in self.para]) + if not_found != '': + UTMESS('F','TABLE0_27', valk=not_found) + if const == None: + const = {} + if type(const) is not dict: + UTMESS('F', 'TABLE0_28') + # liste des valeurs des paramètres + tabpar = [] + for para in l_para: + vals = getattr(self, para).values() + tabpar.append(vals) + tabpar = transpose.transpose(tabpar) + # évaluation de la fonction sur ces paramètres + vectval = [] + for lpar in tabpar: + # si un paramètre est absent, on ne peut pas évaluer la formule + if None in lpar: + vectval.append(None) + else: + vectval.append(funct(*lpar, **const)) + # ajout de la colonne + self[nom_para] = vectval + +# ------------------------------------------------------------------------------ + def __iter__(self): + """Itère sur les lignes de la Table""" + return iter(self.rows) + +# ------------------------------------------------------------------------------ + def __getattr__(self, column): + """Construit un objet intermediaire (couple table, colonne)""" + typ=None + if not column in self.para: + column='' + else: + typ=self.type[self.para.index(column)] + return Colonne(self, column, typ) + +# ------------------------------------------------------------------------------ + def sort(self, CLES=None, ORDRE='CROISSANT'): + """Tri de la table. + CLES : liste des clés de tri + ORDRE : CROISSANT ou DECROISSANT + """ + # par défaut, on prend tous les paramètres + if CLES == None: + CLES = self.para[:] + # vérification des arguments + if not is_enum(CLES): + CLES = [CLES] + else: + CLES = list(CLES) + not_found = ', '.join([p for p in CLES if not p in self.para]) + if not_found != '': + UTMESS('F', 'TABLE0_27', valk=not_found) + if not ORDRE in ('CROISSANT', 'DECROISSANT'): + UTMESS('F', 'TABLE0_29', valk=ORDRE) + # tri + self.rows = sort_table(self.rows, self.para, CLES, (ORDRE=='DECROISSANT')) + +# ------------------------------------------------------------------------------ + def __delitem__(self, args): + """Supprime les colonnes correspondantes aux éléments de args """ + if not is_enum(args): + args=[args,] + for item in args: + try: + ind_item = self.para.index(item) + except ValueError: + UTMESS('F', 'TABLE0_27', valk=item) + del self.type[ind_item] + self.para.remove(item) + for line in self.rows: + if line.has_key(item): + del line[item] + +# ------------------------------------------------------------------------------ + def __getitem__(self, args): + """Extrait la sous table composée des colonnes dont les paramètres sont dans args """ + if not is_enum(args): + args=[args,] + else: + args=list(args) + new_rows=[] + new_para=args + new_type=[] + for item in new_para: + if not item in self.para: + return Table() + new_type.append(self.type[self.para.index(item)]) + for line in self: + new_line={} + for item in new_para: + v = line.get(item) + if v is not None: + new_line[item] = v + new_rows.append(new_line) + return Table(new_rows, new_para, new_type, self.titr) + + + def OrdreColonne(self, cols): + """Réordonne les colonnes en mettant en premier 'cols'. + Ignore les colonnes qui ne seraient pas dans 'self.para'.""" + if type(cols) not in (list, tuple): + cols = [cols] + new_para = [p for p in cols if p in self.para] + others = [p for p in self.para if not p in cols] + new_para.extend(others) + new_type=[] + for item in new_para: + new_type.append(self.type[self.para.index(item)]) + self.para = new_para + self.type = new_type + +# ------------------------------------------------------------------------------ + def _tuplevalues(self, dico): + """Retourne la liste des valeurs d'une ligne dans l'ordre self.para + ("hashable" pour en faire une clé de dict.) + """ + return tuple(map(dico.get, self.para)) + + def __and__(self, other): + """Intersection de deux tables (opérateur &)""" + if other.para != self.para: + UTMESS('A','TABLE0_30') + return Table() + else: + dval_other = dict.fromkeys([self._tuplevalues(r) for r in other], 1) + tmp = [r for r in self if dval_other.get(self._tuplevalues(r)) is not None] + return Table(tmp, self.para, self.type, self.titr) + +# ------------------------------------------------------------------------------ + def __or__(self, other): + """Union de deux tables (opérateur |)""" + if other.para != self.para: + UTMESS('A','TABLE0_30') + return Table() + else: + tmp = self.rows[:] + dval_self = dict.fromkeys([self._tuplevalues(r) for r in self], 1) + tmp.extend([r for r in other if dval_self.get(self._tuplevalues(r)) is None]) + return Table(tmp, self.para, self.type[:], self.titr) + +# ------------------------------------------------------------------------------ + def values(self): + """Renvoie la table sous la forme d'un dictionnaire de listes dont les + clés sont les paramètres. + """ + dico={} + for column in self.para: + dico[column]=Colonne(self, column).values() + return dico + +# ------------------------------------------------------------------------------ + def dict_CREA_TABLE(self): + """Renvoie le dictionnaire des mots-clés à fournir à la commande CREA_TABLE + pour produire une table_sdaster. + """ + dico={ 'TITRE' : ['%-80s' % lig for lig in self.titr.split('\n')], + 'LISTE' : [], } + # remplissage de chaque occurence (pour chaque paramètre) du mot-clé facteur LISTE + for i in range(len(self.para)): + # nom du paramètre et type si K* + d={ 'PARA' : self.para[i], } + typ=self.type[i] + if typ[0]=='K': + mc='LISTE_K' + if not typ in ('K8', 'K16', 'K24'): + UTMESS('A','TABLE0_32', valk=(self.para[i],Kdef)) + typ=Kdef + d['TYPE_K']=typ + elif typ=='I': + mc='LISTE_I' + elif typ=='R': + mc='LISTE_R' + else: + UTMESS('F', 'TABLE0_31', valk=self.para[i]) + # valeurs sans trou / avec trou + vals=getattr(self, self.para[i]).values() + if typ == 'R': + try: + check_nan(vals) + except ValueError, err: + UTMESS('F', 'TABLE0_33', valk=(self.para[i], str(err))) + if vals.count(None)==0: + d[mc]=vals + else: + d['NUME_LIGN'] = [j+1 for j in range(len(vals)) if vals[j] != None] + d[mc] = [v for v in vals if v != None] + if len(d[mc])==0: + UTMESS('I','TABLE0_34', valk=self.para[i]) + else: + dico['LISTE'].append(d) + if len(dico['LISTE'])==0: + UTMESS('F','TABLE0_35') + return dico + +# ------------------------------------------------------------------------------ + def Array(self,Para,Champ): + """Renvoie sous forme de NumArray le résultat d'une extraction dans une table + méthode utile à macr_recal + """ + import numpy + __Rep = self[Para,Champ].values() + F = numpy.zeros((len(__Rep[Para]),2)) + for i in range(len(__Rep[Para])): + F[i][0] = __Rep[Para][i] + F[i][1] = __Rep[Champ][i] + del(__Rep) + return F + +# ------------------------------------------------------------------------------ + def Croise(self): + """Retourne un tableau croisé P3(P1,P2) à partir d'une table ayant + trois paramètres (P1, P2, P3). + """ + if len(self.para) != 3: + UTMESS('A', 'TABLE0_36') + return Table() + py, px, pz = self.para + ly, lx, lz = [getattr(self,p).values() for p in self.para] + new_rows=[] + #lpz='%s=f(%s,%s)' % (pz,px,py) + lpz='%s/%s' % (px,py) + # attention aux doublons dans lx et ly + new_para=set(ly) + new_para.discard(None) + new_para = list(new_para) + new_para.sort() + new_para.insert(0, lpz) + # attention aux doublons dans lx et ly + newx=set(lx) + newx.discard(None) + newx = list(newx) + newx.sort() + for x in newx: + if x != None: + d={ lpz : x, } + taux = (getattr(self,px)==x) + for dz in taux.rows: + d[dz[py]]=dz[pz] + new_rows.append(d) + new_type=[self.type[0],] + [self.type[2]]*(len(new_para) - 1) + new_titr=self.titr + if new_titr != '': new_titr+='\n' + new_titr+=pz + ' FONCTION DE ' + px + ' ET ' + py + return Table(new_rows, new_para, new_type, new_titr) + +# ------------------------------------------------------------------------------ + def Renomme(self, pold, pnew): + """Renomme le paramètre `pold` en `pnew`. + """ + if not pold in self.para: + raise KeyError, 'Paramètre %s inexistant dans cette table' % pold + elif self.para.count(pnew)>0: + raise KeyError, 'Le paramètre %s existe déjà dans la table' % pnew + else: + self.para[self.para.index(pold)] = pnew + for lig in self: + lig[pnew] = lig[pold] + del lig[pold] + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +class Colonne(TableBase): + """Classe intermédiaire pour mémoriser un couple (table, nom de colonne) + et exprimer les critères d'extraction sous une forme naturelle en python + en surchargeant les operateurs <, >, != et =. + Alors on peut écrire la requete simple : + soustable=t.a<10 + Ainsi que des requetes plus complexes : + soustable=t.a<10 and t.b <4 + ou + soustable=t.a<10 or t.b <4 + Les "alias" EQ, NE, LE, LT, GE, GT permettent à la macro IMPR_TABLE + d'utiliser directement le mot-clé utilisateur CRIT_COMP défini dans le + catalogue : getattr(Table,CRIT_COMP). + """ +# ------------------------------------------------------------------------------ + def __init__(self, table, column, typ=None): + """Constructeur (objet Table associé, paramètre de la colonne, type du + paramètre). + """ + self.Table=table + self.rows=self.Table.rows + self.para=column + self.type=typ + self.titr='' + +# ------------------------------------------------------------------------------ + def _extract(self, fun): + """Construit une table avec les lignes de self.Table + dont l'élément de nom self.para satisfait le critère fun, + fun est une fonction qui retourne vrai ou faux + """ + return Table([row for row in self.Table if fun(row.get(self.para))], self.Table.para, self.Table.type, self.Table.titr) + +# ------------------------------------------------------------------------------ + def __le__(self, VALE): + if is_enum(VALE) : + crit = max(VALE) + else: + crit = VALE + return self._extract(lambda v: v != None and v<=crit) + +# ------------------------------------------------------------------------------ + def __lt__(self, VALE): + if is_enum(VALE) : + crit = max(VALE) + else: + crit = VALE + return self._extract(lambda v: v != None and v=crit) + +# ------------------------------------------------------------------------------ + def __gt__(self, VALE): + if is_enum(VALE): + crit = min(VALE) + else: + crit = VALE + return self._extract(lambda v: v != None and v>crit) + +# ------------------------------------------------------------------------------ + def __eq__(self, VALE, CRITERE='RELATIF', PRECISION=0.): + if not is_enum(VALE): + VALE = [VALE] + if is_str(VALE[0]): + stripVALE = [value.strip() for value in VALE] + return self._extract(lambda v: str(v).strip() in stripVALE) + else: + if PRECISION==0. : + return self._extract(lambda v : v in VALE) + elif CRITERE=='ABSOLU': + return self._extract(lambda v : _func_test_abs(v, VALE, PRECISION)) + else: + return self._extract(lambda v : _func_test_rela(v, VALE, PRECISION)) + +# ------------------------------------------------------------------------------ + def REGEXP(self, regexp): + """Retient les lignes dont le paramètre satisfait l'expression + régulière `regexp`. + """ + if not is_str(regexp): + return self._extract(lambda v : False) + return self._extract(lambda v : v != None and re.search(regexp, v) != None) + +# ------------------------------------------------------------------------------ + def __ne__(self, VALE, CRITERE='RELATIF', PRECISION=0.): + if not is_enum(VALE): + VALE = [VALE] + if is_str(VALE[0]): + stripVALE = [value.strip() for value in VALE] + return self._extract(lambda v: str(v).strip() not in stripVALE) + else: + if PRECISION==0. : + return self._extract(lambda v : v not in VALE) + elif CRITERE=='ABSOLU': + return self._extract(lambda v : not (_func_test_abs(v, VALE, PRECISION))) + else: + return self._extract(lambda v : not (_func_test_rela(v, VALE, PRECISION))) + +# ------------------------------------------------------------------------------ + def MAXI(self): + # important pour les performances de récupérer le max une fois pour toutes + maxi=max(self) + return self._extract(lambda v: v==maxi) + +# ------------------------------------------------------------------------------ + def MINI(self): + # important pour les performances de récupérer le min une fois pour toutes + mini=min(self) + return self._extract(lambda v: v==mini) + +# ------------------------------------------------------------------------------ + def ABS_MAXI(self): + # important pour les performances de récupérer le max une fois pour toutes + abs_maxi=max([abs(v) for v in self.values() if is_number(v)]) + return self._extract(lambda v: v==abs_maxi or v==-abs_maxi) + +# ------------------------------------------------------------------------------ + def ABS_MINI(self): + # important pour les performances de récupérer le min une fois pour toutes + abs_mini=min([abs(v) for v in self.values() if is_number(v)]) + # tester le type de v est trop long donc pas de abs(v) + return self._extract(lambda v: v==abs_mini or v==-abs_mini) + +# ------------------------------------------------------------------------------ + def __iter__(self): + """Itère sur les éléments de la colonne""" + for row in self.Table: + # si l'élément n'est pas présent on retourne None + yield row.get(self.para) + #yield row[self.para] + +# ------------------------------------------------------------------------------ + def __getitem__(self, i): + """Retourne la ième valeur d'une colonne""" + return self.values()[i] + +# ------------------------------------------------------------------------------ + def values(self): + """Renvoie la liste des valeurs""" + return [r.get(self.para,None) for r in self.Table] + + def not_none_values(self): + """Renvoie la liste des valeurs non 'None'""" + return [val for val in self.values() if val != None] + +# ------------------------------------------------------------------------------ + # équivalences avec les opérateurs dans Aster + LE=__le__ + LT=__lt__ + GE=__ge__ + GT=__gt__ + EQ=__eq__ + NE=__ne__ + def VIDE(self): + return self.__eq__(None) + def NON_VIDE(self): + return self.__ne__(None) + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ +def sort_table(rows, l_para, w_para, reverse=False): + """Sort list of dict. + rows : list of dict + l_para : list of the keys of dict + w_para : keys of the sort + """ + c_para=[i for i in l_para if i not in w_para] + new_rows=rows + # rename sort keys by "__" + number + para + # ("__" to avoid conflict with existing parameters) + for i, p in enumerate(w_para) : + new_key= '__%03d%s' % (i, p) + for row in new_rows : + v = row.get(p) + row[new_key] = v # must have a value to sort properly + try: + del row[p] + except: + pass + # rename others parameters by "__999" + para + for p in c_para : + new_key= '__999'+p + for row in new_rows : + v = row.get(p) + row[new_key] = v # must have a value to sort properly + try: + del row[p] + except: + pass + # sort + new_rows.sort() + # reversed sort + if reverse: + new_rows.reverse() + for i, p in enumerate(w_para) : + old_key= '__%03d%s' % (i, p) + for row in new_rows: + v = row.get(old_key) + if v is not None: + row[p] = v + try: + del row[old_key] + except: + pass + for p in c_para : + old_key= '__999'+p + for row in new_rows : + v = row.get(old_key) + if v is not None: + row[p] = v + try: + del row[old_key] + except: + pass + return new_rows + +# ------------------------------------------------------------------------------ +def FMT(dform, nform, typAster=None, larg=0, val=''): + """Retourne un format d'impression Python à partir d'un type Aster ('R','I', + 'K8', 'K16'...). Si typAster==None, retourne dform[nform]. + larg : largeur minimale du format (val permet de ne pas ajouter des blancs + si la chaine à afficher est plus longue que le format, on prend le partie + de ne pas tronquer les chaines) + """ + if typAster==None: + fmt=dform[nform] + elif typAster in ('I', 'R'): + if nform=='formK': + # convertit %12.5E en %-12s + fmt=re.sub('([0-9]+)[\.0-9]*[diueEfFgG]+','-\g<1>s',dform['form'+typAster]) + else: + fmt=dform[nform] + else: + # typAster = Kn + fmt='%-'+typAster[1:]+'s' + # on ajoute éventuellement des blancs pour atteindre la largeur demandée + if larg != 0: + fmt=' '*max(min(larg-len(val),larg-len(fmt % 0)),0) + fmt + return fmt + +# ------------------------------------------------------------------------------ +def merge(tab1, tab2, labels=[], restrict=False): + """Assemble les deux tables tb1 et tb2 selon une liste de labels communs. + Si labels est vide: + - les lignes de tb2 sont ajoutés à celles de tb1, + sinon : + - si on trouve les valeurs de tb2 sur les labels dans tb1 (et une seule fois), + on surcharge tb1 avec les lignes de tb2 ; + - sinon on ajoute la ligne de tb2 à la fin de tb1. + """ + tb1 = tab1.copy() + tb2 = tab2.copy() + if not is_enum(labels): + labels=(labels,) + for key in labels : + if key not in tb1.para : UTMESS('F','TABLE0_27', valk=key) + if key not in tb2.para : UTMESS('F','TABLE0_27', valk=key) + # ensemble des paramètres et des types + n_para=tb1.para[:] + n_type=tb1.type[:] + for i in tb2.para: + if i not in tb1.para: + n_para.append(i) + n_type.append(tb2.type[tb2.para.index(i)]) + # restriction des lignes aux labels communs (peu cher en cpu) + rows1 = tb1.rows + dlab1 = {} + for i1 in range(len(rows1)): + tu1 = tuple(map(rows1[i1].__getitem__, labels)) + if dlab1.get(tu1, '') == '': + dlab1[tu1] = i1 + else: + dlab1[tu1] = None + # restriction des lignes aux labels communs (peu cher en cpu) + rows2 = tb2.rows + dlab2 = {} + for i2 in range(len(rows2)): + tu2 = tuple(map(rows2[i2].__getitem__, labels)) + if dlab2.get(tu2, '') == '': + dlab2[tu2] = i2 + else: + dlab2[tu2] = None + # creation de dic1 : dictionnaire de correspondance entre les + # lignes a merger dans les deux tableaux + dic1 = {} + for cle in dlab1.keys(): + if dlab1[cle] == None or cle == (): + bid = dlab1.pop(cle) + for cle in dlab2.keys(): + if dlab2[cle] == None or cle == (): + bid = dlab2.pop(cle) + for cle in dlab2.keys(): + if dlab1.has_key(cle): + dic1[dlab2[cle]] = dlab1[cle] + # insertion des valeurs de tb2 dans tb1 quand les labels sont communs + # (et uniques dans chaque table) + # OU ajout de la ligne de tb2 dans tb1 (si restrict == False) + if restrict: + def func_append_r2(row): + pass + else: + def func_append_r2(row): + rows1.append(row) + i2 = -1 + for r2 in rows2: + i2 += 1 + try: + rows1[dic1[i2]].update(r2) + except KeyError: + func_append_r2(r2) + # concaténation des titres + info sur le merge + tit = '\n'.join([tb1.titr, tb2.titr, 'MERGE avec labels=%s' % repr(labels)]) + return Table(rows1, n_para, n_type, tit) + +# ------------------------------------------------------------------------------ +def _typaster(obj, prev=None, strict=False): + """Retourne le type Aster ('R', 'I', Kdef) correspondant à l'objet obj. + Si prev est fourni, on vérifie que obj est du type prev. + Si strict=False, on autorise que obj ne soit pas du type prev s'ils sont + tous les deux numériques ; dans ce cas, on retourne le "type enveloppe" 'R'. + """ + dtyp={ + IntType : 'I', + FloatType : 'R', + StringType : Kdef, UnicodeType : Kdef, + NoneType : 'I', + } + if is_float(obj): + obj = float(obj) + if type(obj) in dtyp.keys(): + typobj=dtyp[type(obj)] + if prev in [None, typobj]: + return typobj + elif prev[0] == typobj[0] == 'K': + if len(obj) <= int(prev[1:]): + return prev + else: + raise TypeError, "La longueur de la chaine %s est incompatible avec le type %s" \ + % (repr(obj),repr(prev)) + elif strict: # prev != None et typobj != prev et strict + raise TypeError, "La valeur %s n'est pas de type %s" % (repr(obj),repr(prev)) + elif prev in ('I','R') and typobj in ('I','R'): + return 'R' + else: + raise TypeError, "La valeur %s n'est pas compatible avec le type %s" \ + % (repr(obj),repr(prev)) + else: + raise TypeError, 'Une table ne peut contenir que des entiers, réels ' \ + 'ou chaines de caractères.' + +# ------------------------------------------------------------------------------ +# fonctions utilitaires +def _func_test_abs(v, VALE, PRECISION): + """Retourne True si v est parmi VALE à PRECISION près en absolu + """ + for x in VALE: + if v != None and (x-PRECISION <= v <= x+PRECISION): + return True + return False + +def _func_test_rela(v, VALE, PRECISION): + """Retourne True si v est parmi VALE à PRECISION près en relatif + """ + for x in VALE: + sign = float(x > 0.) or -1. + if v != None and (sign*x*(1.-PRECISION) <= sign*v <= sign*x*(1.+PRECISION)): + return True + return False + +def check_nan(values): + """Raise ValueError exception if nan is found in values.""" + for i, v in enumerate(values): + if str(v) == 'nan': + raise ValueError, 'NaN present at index %d' % i + diff --git a/Aster/Cata/cataSTA10/Utilitai/UniteAster.py b/Aster/Cata/cataSTA10/Utilitai/UniteAster.py new file mode 100644 index 00000000..23864c12 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/UniteAster.py @@ -0,0 +1,210 @@ +#@ MODIF UniteAster Utilitai DATE 06/07/2009 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +# RESPONSABLE COURTOIS M.COURTOIS + +import types + +import aster +from Cata.cata import _F +from Cata.cata import DEFI_FICHIER +from Cata.cata import INFO_EXEC_ASTER +from Cata.cata import DETRUIRE + +#------------------------------------------------------------------------------- +#------------------------------------------------------------------------------- +#------------------------------------------------------------------------------- +class UniteAster: + """Classe pour manipuler les fichiers en Python en accord avec les unités + logiques utilisées en Fortran. + De manière analogue au Fortran, les états possibles d'une unité sont : + 'F' : fermé, 'O' : ouvert, 'R' : réservé. + + Méthodes : + Nom : Retourne le nom du fichier associé à une unité, + Etat : Retourne l'état d'une unité, + Libre : Retourne un numéro d'unité libre, + EtatInit : Remet une, plusieurs ou toutes les unités dans leur état initial. + + Méthode privée : + _setinfo : pour remplir le dictionnaire des 'infos' + Attribut privé : + infos[numéro unité] = { 'nom' : x, 'etat' : x , 'etat_init' : x } + """ +#------------------------------------------------------------------------------- + def __init__(self): + """Initialise le dictionnaire des unités. + """ + self.infos = {} + +#------------------------------------------------------------------------------- + def _setinfo(self, ul): + """Remplit les infos de l'unité 'ul'. + """ + # ul peut etre un entier Aster + try: + unit = ul.valeur + except: + unit = int(ul) + # Si la clé n'existe pas + ini = False + if not self.infos.has_key(unit): + self.infos[unit] = {} + self.infos[unit]['nom'] = '' + self.infos[unit]['etat'] = '?' + self.infos[unit]['etat_init'] = '?' + ini = True + + __tab=INFO_EXEC_ASTER(UNITE=unit, LISTE_INFO=('ETAT_UNITE')) + + # O:ouvert, F:fermé, R:réservé + self.infos[unit]['etat'] = __tab['ETAT_UNITE',1].strip()[0] + if ini: + self.infos[unit]['etat_init'] = self.infos[unit]['etat'] + + # nom du fichier + if self.infos[unit]['etat'] in ['O', 'R']: + nomfich=''.join([__tab['NOMFIC%d' % i,1] for i in range(1,5)]).strip() + elif self.infos[unit]['etat'] == 'F': + nomfich='fort.'+str(unit) + else: + message = "Etat de l'unité inconnu : %s" % self.infos[unit]['etat'] + print __tab.EXTR_TABLE() + raise aster.error," %s" % message + self.infos[unit]['nom'] = nomfich + #print 'DEBUG infos[unit] = ', self.infos[unit] + DETRUIRE(CONCEPT=_F(NOM=__tab),INFO=1) + +#------------------------------------------------------------------------------- + def Libre(self, nom=None, action='RESERVER'): + """Réserve/associe et retourne une unité libre en y associant, s'il est + fourni, le fichier 'nom'. + """ + __tab=INFO_EXEC_ASTER(LISTE_INFO=('UNITE_LIBRE')) + unit = __tab['UNITE_LIBRE',1] + DETRUIRE(CONCEPT=_F(NOM=__tab),INFO=1) + if nom==None: + nom='fort.'+str(unit) + + # Si la clé existe, c'est que le fichier n'était pas libre + if self.infos.has_key(unit): + message = "Cette unité est déjà affectée au fichier %s" % \ + self.infos[unit]['nom'] + raise aster.error," %s" % message + + DEFI_FICHIER(ACTION=action, UNITE=unit , FICHIER=nom.strip()) + self.infos[unit] = {} + self.infos[unit]['nom'] = nom.strip() + self.infos[unit]['etat'] = 'R' + self.infos[unit]['etat_init'] = 'F' + return unit + +#------------------------------------------------------------------------------- + def Nom(self, ul): + """Retourne le nom du fichier associé à l'unité 'ul'. + """ + # ul peut etre un entier Aster + try: + unit = ul.valeur + except: + unit = int(ul) + # Si la clé n'existe pas + if not self.infos.has_key(unit): + self._setinfo(unit) + return self.infos[unit]['nom'] + +#------------------------------------------------------------------------------- + def Etat(self, ul, **kargs): + """Retourne l'état de l'unité si 'etat' n'est pas fourni + et/ou change son état : + kargs['etat'] : nouvel état, + kargs['nom'] : nom du fichier, + kargs['TYPE'] : type du fichier à ouvrir ASCII/BINARY/LIBRE, + kargs['ACCES'] : type d'accès NEW/APPEND/OLD (APPEND uniquement en ASCII). + """ + # ul peut etre un entier Aster + try: + unit = ul.valeur + except: + unit = int(ul) + # Si la clé n'existe pas + if not self.infos.has_key(unit): + self._setinfo(unit) + if not kargs.has_key('etat'): + return self.infos[unit]['etat'] + + # En fonction de la demande, on bascule son état ou pas + new = kargs.get('etat') + if not new in ['R', 'F', 'O']: + message = "Nouvel état de l'unité incorrect : %s" % new + raise aster.error," %s" % message + + if self.infos[unit]['etat'] == new: + pass + elif new == 'R': + if self.infos[unit]['etat'] == 'O': + DEFI_FICHIER(ACTION='LIBERER', UNITE=unit) + DEFI_FICHIER(ACTION = 'RESERVER', + UNITE = unit, + FICHIER = kargs.get('nom', self.infos[unit]['nom'])) + self._setinfo(unit) + elif new == 'F': + DEFI_FICHIER(ACTION='LIBERER', UNITE=unit) + elif new == 'O': + if self.infos[unit]['etat'] == 'R': + DEFI_FICHIER(ACTION='LIBERER', UNITE=unit) + # valeurs par défaut + typ = kargs.get('TYPE', 'ASCII') + if typ == 'ASCII': + acces = 'APPEND' + else: + acces = 'OLD' + acces = kargs.get('ACCES', acces) + DEFI_FICHIER(ACTION ='ASSOCIER', + UNITE = unit, + FICHIER = kargs.get('nom', self.infos[unit]['nom']), + TYPE = typ, + ACCES = acces,) + self._setinfo(unit) + self.infos[unit]['etat'] = new + return self.infos[unit]['etat'] + +#------------------------------------------------------------------------------- + def EtatInit(self, ul=None): + """Remet l'unité 'ul' dans son état initial. + Si 'ul' est omis, toutes les unités sont remises dans leur état initial. + """ + if ul == None: + for uli, vul in self.infos.items(): + self.Etat(uli, etat=vul['etat_init']) + else: + if not type(ul) in [types.ListType, types.TupleType]: + ul=[ul,] + for u in ul: + # u peut etre un entier Aster + try: + unit = u.valeur + except: + unit = int(u) + # Si la clé n'existe pas + if not self.infos.has_key(unit): + self._setinfo(unit) + else: + self.Etat(unit, etat=self.infos[unit]['etat_init']) diff --git a/Aster/Cata/cataSTA10/Utilitai/Utmess.py b/Aster/Cata/cataSTA10/Utilitai/Utmess.py new file mode 100644 index 00000000..3aa5242d --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/Utmess.py @@ -0,0 +1,711 @@ +#@ MODIF Utmess Utilitai DATE 14/03/2011 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE COURTOIS M.COURTOIS + +import os +import sys +import traceback +import imp +import re + +# protection pour eficas +try: + import aster + from aster import error + aster_exists = True + from Messages.context_info import message_context_concept +except: + aster_exists = False + class error(Exception): + pass + +def _(s): + return s + +from Noyau.N_types import force_list + + +MAXLENGTH = 132 + +contacter_assistance = """ +Il y a probablement une erreur dans la programmation. +Veuillez contacter votre assistance technique.""" + +# voir en fin de fin les faux appels à UTMESS pour la vérification des messages + + +def list_unit(code): + """Retourne la liste des noms de fichiers (logiques) sur lesquels doit + etre imprimé le message. + """ + #IDF = INDEX('EFIDASXZ', ...) + #'Z' (IDF=8) = LEVEE D'EXCEPTION + d = { + 'E' : ('ERREUR', 'MESSAGE', 'RESULTAT'), + 'I' : ('MESSAGE',), + 'A' : ('MESSAGE', 'RESULTAT'), + } + d['F'] = d['S'] = d['Z'] = d['E'] + d['X'] = d['A'] + return d.get(code, d['F']) + + +class MESSAGE_LOGGER: + """Classe gérant l'impression de messages. + On ne crée qu'une instance de ce type. + Cette instance est accessible via le module E_Global pour astermodule.c + """ + def __init__(self): + """Initialisation + """ + self.init_buffer() + + # est-ce qu'une erreur s'est produite + self.erreur_E = False + + # compteur des alarmes émises { 'id_alarm' : count } + self.count_alarm = {} # dans la commande courante (pour arret à 5) + self.count_alarm_tot = {} # au total + + # alarmes à ignorer, à masquer (on ne les compte pas temporairement) + self._ignored_alarm = {} + self._hidden_alarm = {} + + # on prépare le dictionnaire des valeurs par défaut des arguments (dicarg) : + self.default_args = {} + # initialisation des 10 premiers + for i in range(1,11): + self.default_args['i%d' % i] = 99999999 + self.default_args['r%d' % i] = 9.9999E99 + self.default_args['k%d' % i] = 'xxxxxx' + + + def __call__(self, *args, **kwargs): + """Raccourci pour simplifier l'appel depuis astermodule.c et UTMESS. + """ + self.print_message(*args, **kwargs) + + + def print_message(self, code, idmess, valk=(), vali=(), valr=(), + exception=False, print_as=None, cc=None): + """Appelé par la routine fortran U2MESG ou à la fonction python UTMESS + pour afficher un message. + L'impression de ce message est différée si le `code` est suivi d'un "+". + code : 'A', 'E', 'S', 'F', 'I' + idmess : identificateur du message + valk, vali, valr : liste des chaines, entiers ou réels. + Si exception==True, on lève une exception en cas d'erreur, sinon + c'est l'appelant qui devra s'en charger (dans le C a priori). + 'print_as' : cf. print_buffer_content. + """ + # le '+' n'a pas de sens pour les messages 'I'. + if code == "I+": + code = "I" + # récupération du texte du message + dictmess = self.get_message(code, idmess, valk, vali, valr) + + # on le met dans le buffer + self.add_to_buffer(dictmess) + + # si on n'attend pas une suite, ... + if len(code) < 2 or code[1] != '+': + # mise à jour des compteurs + self.update_counter() + + # on imprime le message en attente + self.print_buffer_content(print_as, cc) + + if exception and code[0] in ('S', 'F'): + raise error(idmess, valk, vali, valr) + + return None + + + def build_dict_args(self, valk, vali, valr): + """Construit le dictionnaire de formatage du message. + """ + # homogénéisation : uniquement des tuples + strip des chaines de caractères + valk, vali, valr = map(force_list, (valk, vali, valr)) + valk = [k.strip() for k in valk] + + # variables passées au message + dicarg = self.default_args.copy() + for i in range(1,len(valk)+1): + dicarg['k%d' % i] = valk[i-1] + for i in range(1,len(vali)+1): + dicarg['i%d' % i] = vali[i-1] + for i in range(1,len(valr)+1): + dicarg['r%d' % i] = valr[i-1] + # valeur spéciale : ktout = concaténation de toutes les chaines + dicarg['ktout'] = ' '.join(valk) + + return dicarg + + + def get_message(self, code, idmess, valk=(), vali=(), valr=()): + """Retourne le texte du message dans un dictionnaire dont les clés sont : + 'code', 'id_message', 'corps_message' + """ + # décodage : idmess => (catamess, numess) + idmess = idmess.strip() + x = idmess.split("_") + assert len(x) > 1, idmess + catamess='_'.join(x[0:-1]).lower() + numess = int(x[-1]) + assert numess > 0 and numess < 100, idmess + + # import catamess => cata_msg + try: + mod = __import__('Messages.%s' % catamess, globals(), locals(), [catamess]) + # si le dictionnaire n'existe pas, on alertera au moment du formatage. + cata_msg = getattr(mod, 'cata_msg', {}) + except Exception, msg: + # doit permettre d'éviter la récursivité (catamess réservé à Utmess) + if catamess != 'catamess': + self.print_message('A', 'CATAMESS_57', valk=(catamess, str(msg))) + cata_msg = {} + + # corps du message + try: + dicarg = self.build_dict_args(valk, vali, valr) + + # cata_msg[num] = 'format' + # ou {'message' : 'format', 'context' : 'éléments de contexte'} + if type(cata_msg[numess]) == dict: + fmt_msg = cata_msg[numess]['message'] + ctxt_msg = cata_msg[numess]['context'] + else: + fmt_msg = cata_msg[numess] + ctxt_msg = None + + dictmess = { + 'code' : code, + 'id_message' : idmess, + 'corps_message' : fmt_msg % dicarg, + 'context_info' : self.get_context(ctxt_msg, idmess, dicarg), + } + except Exception, msg: + dictmess = { + 'code' : code, + 'id_message' : '', + 'corps_message' : """Erreur de programmation. +Le message %s n'a pas pu etre formaté correctement. +Arguments : + entiers : %s + réels : %s + chaines : %s +-------------------------------------------------------------------------- +%s +Exception : %s +-------------------------------------------------------------------------- + +%s""" \ + % (idmess, vali, valr, valk, ''.join(traceback.format_tb(sys.exc_traceback)), msg, contacter_assistance), + 'context_info' : '', + } + # limite la longueur des ligness + dictmess['corps_message'] = cut_long_lines(dictmess['corps_message'], MAXLENGTH) + return dictmess + + + def GetText(self, *args, **kwargs): + """Retourne le texte du message pret a etre imprime. + """ + return self.format_message(self.get_message(*args, **kwargs)) + + + def init_buffer(self): + """Initialise le buffer. + """ + self._buffer = [] + + + def add_to_buffer(self, dictmess): + """Ajoute le message décrit dans le buffer en vue d'une impression + ultérieure. + """ + self._buffer.append(dictmess) + + + def get_current_code(self): + """Retourne le code du message du buffer = code du message le plus grave + (cf. dgrav) + """ + dgrav = { '?' : -9, 'I' : 0, 'A' : 1, 'S' : 4, 'Z' : 4, 'E' : 6, 'F' : 10 } + + current = '?' + for dictmess in self._buffer: + code = dictmess['code'][0] + if dgrav.get(code, -9) > dgrav.get(current, -9): + current = code + + return current + + + def get_current_id(self): + """Retourne l'id du message du buffer = id du premier message + """ + return self._buffer[0]['id_message'] + + + def print_buffer_content(self, print_as=None, cc=None): + """Extrait l'ensemble des messages du buffer dans un dictionnaire unique, + imprime le message, et vide le buffer pour le message suivant. + - code : celui du message le plus grave (cf. dgrav) + - id : celui du premier message qui est affiché + - corps : concaténation de tous les messages. + 'print'_as permet d'imprimer un message sur des fichiers autres que les fichiers + habituels de 'code'. Par ex, imprimer un message d'info sur 'ERREUR'. + 'cc' : liste de noms de fichiers ou objets fichier dans lesquels copier le message + """ + if len(self._buffer) < 1: + return None + + # construction du dictionnaire du message global + dglob = { + 'code' : self.get_current_code(), + 'id_message' : self.get_current_id(), + 'liste_message' : [], + 'liste_context' : [], + } + for dictmess in self._buffer: + dglob['liste_message'].append(dictmess['corps_message']) + dglob['liste_context'].append(dictmess['context_info']) + dglob['corps_message'] = ''.join(dglob['liste_message']) + dglob['context_info'] = ''.join(dglob['liste_context']) + + # liste des unités d'impression en fonction du type de message + l_unit = list_unit(print_as or dglob['code']) + + # texte final et impression + txt = self.format_message(dglob) + for unite in l_unit: + self.affiche(unite, txt) + # "cc" + if cc: + copy_text_to(txt, cc) + + self.init_buffer() + + + def disable_alarm(self, idmess, hide=False): + """Ignore l'alarme "idmess". + """ + if hide: + self._hidden_alarm[idmess] = self._hidden_alarm.get(idmess, 0) + 1 + else: + self._ignored_alarm[idmess] = self._ignored_alarm.get(idmess, 0) + 1 + + def reset_alarm(self, idmess, hide=False): + """Réactive l'alarme "idmess". + """ + if hide: + self._hidden_alarm[idmess] = min(self._hidden_alarm.get(idmess, 0) - 1, 0) + else: + self._ignored_alarm[idmess] = min(self._ignored_alarm.get(idmess, 0) - 1, 0) + + def is_alarm_disabled(self, idmess): + """Doit-on ignorer l'alarme "idmess" ? + """ + return self._ignored_alarm.get(idmess, 0) + self._hidden_alarm.get(idmess, 0) > 0 + + def info_alarm(self, only_ignored=False): + """Fournit les infos sur les alarmes activées. + """ + s_alarm = set(self._ignored_alarm.keys()) + if not only_ignored: + s_alarm.update(self.count_alarm_tot.keys()) + l_alarm = list(s_alarm) + l_alarm.sort() + # on sépare des éventuels messages en attente + self.print_buffer_content() + # entete + dictmess = self.get_message('I', 'CATAMESS_89') + self.add_to_buffer(dictmess) + # occurrences + ieff = 0 + for idmess in l_alarm: + mark = ' ' + ieff += 1 + if self._ignored_alarm.get(idmess) is not None: + mark = '(*)' + dictmess = self.get_message('I', 'CATAMESS_90', valk=(mark, idmess), + vali=self.count_alarm_tot.get(idmess, 0)) + self.add_to_buffer(dictmess) + if ieff == 0: + dictmess = self.get_message('I', 'CATAMESS_92') + self.add_to_buffer(dictmess) + # fermeture + dictmess = self.get_message('I', 'CATAMESS_91') + self.add_to_buffer(dictmess) + self.print_buffer_content(print_as='A') + + + def update_counter(self): + """Mise à jour des compteurs et réaction si besoin. + """ + nmax_alarm = 5 + code = self.get_current_code() + if code == 'E': + self.erreur_E = True + elif code == 'F': + self.erreur_E = False + elif code == 'A': + idmess = self.get_current_id() + # nombre d'occurrence de cette alarme (sauf si cachee) + if self._hidden_alarm.get(idmess, 0) == 0: + self.count_alarm[idmess] = self.count_alarm.get(idmess, 0) + 1 + self.count_alarm_tot[idmess] = self.count_alarm_tot.get(idmess, 0) + 1 + + if self.is_alarm_disabled(idmess) or self.count_alarm[idmess] > nmax_alarm: + # ignorer l'alarme ou count_alarm > max, on vide le buffer + self.init_buffer() + elif self.count_alarm[idmess] == nmax_alarm: + # Pour mettre en relief le message CATAMESS_41, on le sépare + # de la dernière alarme + self.print_buffer_content() + dictmess = self.get_message(code, 'CATAMESS_41', + valk=idmess, vali=nmax_alarm) + self.add_to_buffer(dictmess) + + + def check_counter(self, info_alarm=0, silent=0): + """Méthode "jusqu'ici tout va bien" ! (Interface C : chkmsg) + Si des erreurs se sont produites, on arrete le code en . + Appelée par FIN ou directement au cours de l'exécution d'une commande. + Retourne un entier : 0 si tout est ok. + Si silent==1, on n'émet pas de message, on ne s'arrete pas. + """ + iret = 0 + if self.erreur_E: + iret = 4 + self.erreur_E = False + if not silent: + self.print_message('F', 'CATAMESS_6', exception=True) + if info_alarm: + self.info_alarm() + return iret + + + def reset_command(self): + """Méthode appelée entre les commandes. (Interface C : resmsg) + On remet à zéro le compteur d'alarme, + on vérifie les erreurs en attente.""" + iret = self.check_counter() + # reset des alarmes + self.count_alarm = {} + + + def format_message(self, dictmess): + """Formate le message décrit dans un dico : + 'code' : A, E, S, F, I + 'id_message' : identification du message + 'corps_message' : texte + """ + charh = '-' # horizontal + charv = '!' # vertical + charc = '!' # coin + dcomm = { + 'A' : _("""Ceci est une alarme. Si vous ne comprenez pas le sens de cette +alarme, vous pouvez obtenir des résultats inattendus !"""), + 'E' : _("""Cette erreur sera suivie d'une erreur fatale."""), + 'S' : _("""Cette erreur est fatale. Le code s'arrete. Toutes les étapes +du calcul ont été sauvées dans la base jusqu'au moment de l'arret."""), + 'F' : _("""Cette erreur est fatale. Le code s'arrete."""), + } + + # format complet + format_general = { + 'decal' : ' ', + 'header' : """<%(type_message)s> %(str_id_message)s""", + 'ligne' : '%(charv)s %%-%(maxlen)ds %(charv)s', + 'corps' : """%(header)s + +%(corps_message)s +%(context_info)s + +%(commentaire)s +""", + 'final' : """ +%(separateur)s +%(corps)s +%(separateur)s + +""", + } + # format light pour les infos + format_light = { + 'decal' : '', + 'header' : """<%(type_message)s> """, + 'ligne' : '%%s', + 'corps' : """%(corps_message)s +%(context_info)s""", + 'final' : """%(corps)s""", + } + dmsg = dictmess.copy() + dmsg['type_message'] = self.get_type_message(dictmess['code']) + if dmsg['id_message'] != 'I': + dmsg['str_id_message'] = '<%s>' % dmsg['id_message'] + else: + dmsg['str_id_message'] = '' + + # format utilisé + format = format_general + if dmsg['type_message'] == 'I': + format = format_light + if format is format_general: + dmsg['corps_message'] = dmsg['corps_message'].strip() + + dmsg['header'] = format['header'] % dmsg + dmsg['commentaire'] = dcomm.get(dmsg['type_message'], '') + if re.search('^DVP', dmsg['id_message']) != None: + dmsg['commentaire'] += contacter_assistance + + dmsg['corps'] = format['corps'] % dmsg + if format is format_general: + dmsg['corps'] = dmsg['corps'].strip() + + + # longueur de la ligne la plus longue + l_line = dmsg['corps'].splitlines() + maxlen = max([len(line) for line in l_line]) + + # format des lignes sur maxlen caractères + dlin = { + 'charh' : charh, + 'charv' : charv, + 'charc' : charc, + 'maxlen' : maxlen + } + fmt_line = format['ligne'] % dlin + + # on formate toutes les lignes + txt = [fmt_line % line for line in l_line] + dmsg['corps'] = os.linesep.join(txt) + dmsg['separateur'] = charc + charh * (maxlen + 2) + charc + + # ligne haut et bas + newtxt = format['final'] % dmsg + # on décale + l_txt = [format['decal'] + line for line in newtxt.splitlines()] + + return clean_string(os.linesep.join(l_txt)) + + + def get_type_message(self, code): + """Retourne le type du message affiché. + En cas d'erreur, si on lève une exception au lieu de s'arreter, + on n'affiche pas le type de l'erreur pour ne pas fausser le diagnostic + """ + typmess = code.strip() + if self.onFatalError().startswith('EXCEPTION'): + if typmess in ('E', 'F'): + typmess = 'EXCEPTION' + # dans tous les cas, pour S et Z (exception), on affiche EXCEPTION. + if typmess in ('Z', 'S'): + typmess = 'EXCEPTION' + return typmess + + + def get_context(self, ctxt_msg, idmess, dicarg): + """Prise en compte du context du message pour donner d'autres infos + à l'utilisateur. + ctxt_msg est un dictionnaire. Les clés traitées sont : + - CONCEPT + """ + if not ctxt_msg: + return '' + msg = [] + # tout dans un try/except car c'est du bonus, il ne faudrait pas planter ! + try: + if ctxt_msg.has_key('CONCEPT'): + l_co = [dicarg[arg] for arg in force_list(ctxt_msg['CONCEPT'])] + for co in l_co: + msg.append(message_context_concept(co)) + except: + pass + return os.linesep.join(msg) + + + # définitions pour fonctionner sans le module aster + def affiche(self, unite, txt): + """Affichage du message""" + if aster_exists: + aster.affiche(unite, txt) + else: + print txt + + + def onFatalError(self): + """Récupérer le comportement en cas d'erreur fatale.""" + if aster_exists: + return aster.onFatalError() + else: + return 'EXCEPTION' + + +def clean_string(chaine): + """Supprime tous les caractères non imprimables. + """ + invalid = '?' + txt = [] + for c in chaine: + if ord(c) != 0: + txt.append(c) + else: + txt.append(invalid) + return ''.join(txt) + + +def maximize_lines(l_fields, maxlen, sep): + """Construit des lignes dont la longueur est au plus de `maxlen` caractères. + Les champs sont assemblés avec le séparateur `sep`. + """ + newlines = [] + while len(l_fields) > 0: + cur = [] + while len(l_fields) > 0 and len(sep.join(cur + [l_fields[0],])) <= maxlen: + cur.append(l_fields.pop(0)) + newlines.append(sep.join(cur)) + newlines = [l for l in newlines if l != ''] + return newlines + +def cut_long_lines(txt, maxlen, sep=os.linesep, + l_separ=(' ', ',', ';', '.', ':')): + """Coupe les morceaux de `txt` (isolés avec `sep`) de plus de `maxlen` + caractères. + On utilise successivement les séparateurs de `l_separ`. + """ + l_lines = txt.split(sep) + newlines = [] + for line in l_lines: + if len(line) > maxlen: + l_sep = list(l_separ) + line = cut_long_lines(line, maxlen, l_sep[0], l_sep[1:]) + line = maximize_lines(line, maxlen, l_sep[0]) + newlines.extend(line) + else: + newlines.append(line) + # au plus haut niveau, on assemble le texte + if sep == os.linesep: + newlines = os.linesep.join(newlines) + return newlines + + +def copy_text_to(text, files): + """Imprime le texte dans les fichiers. + """ + files = force_list(files) + for f in files: + assert type(f) in (str, file) + if type(f) == file: + fobj = file + else: + fobj = open(f, 'a') + # should be closed automatically + fobj.write(text) + fobj.write(os.linesep) + fobj.flush() + + +# unique instance du MESSAGE_LOGGER +MessageLog = MESSAGE_LOGGER() + + +def UTMESS(code, idmess, valk=(), vali=(), valr=(), print_as=None, cc=None): + """Utilitaire analogue à la routine fortran U2MESS/U2MESG avec les arguments + optionnels. + code : 'A', 'E', 'S', 'F', 'I' + idmess : identificateur du message + valk, vali, valr : liste des chaines, entiers ou réels. + + Appel sans valeurs : avec valeurs : + UTMESS('A', 'SUPERVIS_40') UTMESS('A', 'SUPERVIS_40', vali=[1, 2]) + + Remarques : + - Nommer les arguments permet de ne pas tous les passer. + - Meme fonctionnement que U2MESG : + + appel à MessageLog + + puis exception ou abort en fonction du niveau d'erreur. + """ + MessageLog(code, idmess, valk, vali, valr, exception=True, print_as=print_as, cc=cc) + + +def ASSERT(condition, message=""): + """Remonter un assert dans un message. + """ + if condition: + return + stack = traceback.format_stack(limit=10) + UTMESS('F', 'DVP_9', valk=[(''.join(stack[:-1]),), message]) + + +def message_exception(code, exc): + """Retourne le message associé à une exception aster.error + tel qu'il aurait été imprimé par UTMESS selon la valeur de + `code` ('I', 'A', 'S', 'F', 'Z'...).""" + return MessageLog.GetText(code, exc.id_message, + exc.valk, exc.vali, exc.valr) + + +def MasquerAlarme(idmess): + """Masque une alarme : ni affichee, ni comptee. + Utilisation dans les macros : + MasquerAlarme(XXX) au debut de la macro + RetablirAlarme(XXX) a la fin de la macro + Comme il s'agit d'un compteur qui est incremente puis decremente, il est + imperatif qu'il y ait autant d'appel a MasquerAlarme qu'a RetablirAlarme. + """ + MessageLog.disable_alarm(idmess, hide=True) + + +def RetablirAlarme(idmess): + """Retablit l'etat initial pour l'alarme 'idmess'. + """ + MessageLog.reset_alarm(idmess, hide=True) + + +# faux appels à UTMESS +def __fake__(): + UTMESS('I', 'SUPERVIS_40') # surcharge émis par asrun + UTMESS('I', 'SUPERVIS_96') # émis depuis le C (inisig) + UTMESS('I', 'SUPERVIS_97') # émis depuis le C (inisig) + UTMESS('I', 'GENERIC_1') # dans des tests pour traiter les exceptions + UTMESS('I', 'CATAMESS_6') + UTMESS('I', 'CATAMESS_41') + UTMESS('I', 'CATAMESS_55') # pour u2mesg.f + UTMESS('I', 'CATAMESS_57') + UTMESS('I', 'CATAMESS_69') # pour u2mesg.f + UTMESS('I', 'CATAMESS_70') # pour u2mesg.f + UTMESS('I', 'CATAMESS_89') + UTMESS('I', 'CATAMESS_90') + UTMESS('I', 'CATAMESS_91') + UTMESS('I', 'CATAMESS_92') + # appelé par levé d'exception + UTMESS('I', 'MISS0_3') + UTMESS('I', 'MISS0_5') + UTMESS('I', 'MISS0_6') + UTMESS('I', 'MISS0_7') + UTMESS('I', 'MISS0_8') + UTMESS('I', 'MISS0_9') + UTMESS('I', 'MISS0_11') + UTMESS('I', 'MISS0_17') + + diff --git a/Aster/Cata/cataSTA10/Utilitai/__init__.py b/Aster/Cata/cataSTA10/Utilitai/__init__.py new file mode 100644 index 00000000..b51eff55 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/__init__.py @@ -0,0 +1,21 @@ +#@ MODIF __init__ Utilitai DATE 20/09/2004 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + + diff --git a/Aster/Cata/cataSTA10/Utilitai/as_timer.py b/Aster/Cata/cataSTA10/Utilitai/as_timer.py new file mode 100644 index 00000000..90d0701c --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/as_timer.py @@ -0,0 +1,272 @@ +#@ MODIF as_timer Utilitai DATE 05/09/2008 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE COURTOIS M.COURTOIS + +""" + Definition of ASTER_TIMER class. +""" + +__revision__ = "$Id: as_timer.py 3312 2008-06-06 12:42:58Z courtois $" + +# ----- differ messages translation +def _(mesg): + return mesg + +import os +import time + +#------------------------------------------------------------------------------- +def _dtimes(): + """Returns a dict of cpu, system and total times. + """ + l_t = os.times() + return { 'cpu' : (l_t[0], l_t[2]), + 'sys' : (l_t[1], l_t[3]), + 'tot' : l_t[4], } + +#------------------------------------------------------------------------------- +def _conv_hms(t): + """Convert a number of seconds in hours, minutes, seconds. + """ + h = int(t/3600) + m = int(t % 3600)/60 + s = (t % 3600) % 60 + return h, m, s + +#------------------------------------------------------------------------------- +#------------------------------------------------------------------------------- +#------------------------------------------------------------------------------- +class ASTER_TIMER: + """This class provides methods to easily measure time spent during + different steps. + Methods : + Start : start a timer in mode 'INIT' ([re]start from 0) or 'CONT' + (restart from last value). + Stop : stop a timer + Attributes : + timers : dict { + timer_id : { + 'name' : timer legend (=timer_id by default), + 'state' : state, + 'cpu_t0' : initial cpu time, + 'cpu_dt' : spent cpu time, + 'sys_t0' : initial system time, + 'sys_dt' : spent system time, + 'tot_t0' : start time, + 'tot_dt' : total spent time, + 'num' : timer number (to print timers in order of creation), + 'hide' : boolean, + }, + ... + } + state is one of 'start', 'stop' + """ + MaxNumTimer = 9999999 + +#------------------------------------------------------------------------------- + def __init__(self, add_total=True, format='as_run'): + """Constructor + """ + # ----- initialisation + self.timers = {} + self.add_total = add_total + + if not format in ('as_run', 'aster'): + format = 'as_run' + + if format == 'as_run': + self.fmtlig = ' %(name)-33s %(cpu_dt)9.2f %(sys_dt)9.2f %(cpu_sys)9.2f %(tot_dt)9.2f' + self.fmtstr = ' %(title)-33s %(cpu)9s %(sys)9s %(cpu+sys)9s %(elapsed)9s' + self.sepa = ' ' + '-'*81 + self.TotalKey = _('Total time') + self.d_labels = { + 'title' : '', + 'cpu' : _('cpu'), + 'sys' : _('system'), + 'cpu+sys' : _('cpu+sys'), + 'elapsed' : _('elapsed'), + } + elif format == 'aster': + self.fmtlig = ' * %(name)-24s : %(cpu_dt)10.2f : %(sys_dt)10.2f : %(cpu_sys)10.2f : %(tot_dt)10.2f *' + self.fmtstr = ' * %(title)-24s : %(cpu)10s : %(sys)10s : %(cpu+sys)10s : %(elapsed)10s *' + self.sepa = ' ' + '*'*80 + self.TotalKey = 'TOTAL_JOB' + self.d_labels = { + 'title' : 'COMMAND', + 'cpu' : 'USER', + 'sys' : 'SYSTEM', + 'cpu+sys' : 'USER+SYS', + 'elapsed' : 'ELAPSED', + } + + self.total_key = id(self) + if self.add_total: + self.Start(self.total_key, name=self.TotalKey, num=self.MaxNumTimer) + +#------------------------------------------------------------------------------- + def Start(self, timer, mode='CONT', num=None, hide=None, name=None): + """Start a new timer or restart one + """ + name = name or str(timer) + isnew = self.timers.get(timer) is None + if not num: + num = len(self.timers) + if mode == 'INIT': + num = self.timers[timer]['num'] + dico = _dtimes() + if isnew or mode == 'INIT': + self.timers[timer] = { + 'name' : name, + 'state' : 'start', + 'cpu_t0' : dico['cpu'], + 'cpu_dt' : 0., + 'sys_t0' : dico['sys'], + 'sys_dt' : 0., + 'tot_t0' : dico['tot'], + 'tot_dt' : 0., + 'num' : num, + 'hide' : hide, + } + elif mode == 'CONT' and self.timers[timer]['state'] == 'stop': + self.timers[timer].update({ + 'state' : 'start', + 'cpu_t0' : dico['cpu'], + 'sys_t0' : dico['sys'], + 'tot_t0' : dico['tot'], + }) + +#------------------------------------------------------------------------------- + def Add(self, timer, cpu_dt=0., sys_dt=0., to_total=False): + """Add dt values (hidden to os.times, for example under mpirun) to a timer. + """ + if self.timers.get(timer) is not None: + self.timers[timer]['cpu_dt'] += cpu_dt + self.timers[timer]['sys_dt'] += sys_dt + if to_total and timer != self.total_key: + self.Add(self.total_key, cpu_dt, sys_dt) + +#------------------------------------------------------------------------------- + def Stop(self, timer, hide=None): + """Stop a timer + """ + if self.timers.get(timer) is None: + self.timers[timer] = { + 'name' : str(timer), + 'hide' : hide, + 'state' : 'stop', + 'cpu_t0' : 0., + 'cpu_dt' : 0., + 'sys_t0' : 0., + 'sys_dt' : 0., + 'tot_t0' : 0., + 'tot_dt' : 0., + 'num': len(self.timers), + } + elif self.timers[timer]['state'] == 'start': + dico = _dtimes() + self.timers[timer]['state'] = 'stop' + for i in range(len(dico['cpu'])): + self.timers[timer]['cpu_dt'] += \ + dico['cpu'][i] - self.timers[timer]['cpu_t0'][i] + self.timers[timer]['cpu_t0'] = dico['cpu'] + for i in range(len(dico['sys'])): + self.timers[timer]['sys_dt'] += \ + dico['sys'][i] - self.timers[timer]['sys_t0'][i] + self.timers[timer]['sys_t0'] = dico['sys'] + self.timers[timer]['tot_dt'] = self.timers[timer]['tot_dt'] + \ + dico['tot'] - self.timers[timer]['tot_t0'] + self.timers[timer]['tot_t0'] = dico['tot'] + if hide is not None: + self.timers[timer]['hide'] = hide + +#------------------------------------------------------------------------------- + def StopAndGet(self, timer, *args, **kwargs): + """Stop a timer and return "delta" values. + """ + self.Stop(timer, *args, **kwargs) + cpu_dt = self.timers[timer]['cpu_dt'] + sys_dt = self.timers[timer]['sys_dt'] + tot_dt = self.timers[timer]['tot_dt'] + return cpu_dt, sys_dt, tot_dt + +#------------------------------------------------------------------------------- + def StopAndGetTotal(self): + """Stop the timer and return total "delta" values. + """ + return self.StopAndGet(self.total_key) + +#------------------------------------------------------------------------------- + def getsortedtimers(self): + """Return timers list sorted by timer number. + """ + lnum = [[timer['num'], timer] for timer in self.timers.values() if timer['hide'] is not True] + lnum.sort() + return lnum + +#------------------------------------------------------------------------------- + def StopAll(self): + """Stop all timers + """ + lk = self.timers.keys() + if self.add_total: + lk.remove(self.total_key) + for timer in lk: + self.Stop(timer) + +#------------------------------------------------------------------------------- + def __repr__(self): + """Pretty print content of the timer. + NB : call automatically StopAll + """ + self.StopAll() + if self.add_total: + self.Stop(self.total_key) + + labels = self.fmtstr % self.d_labels + out = [''] + # get timers list and sort by 'num' + lnum = self.getsortedtimers() + if lnum: + out.append(self.sepa) + if self.add_total and labels: + out.append(labels) + out.append(self.sepa) + for num, timer in lnum: + d_info = timer.copy() + d_info['cpu_sys'] = d_info['cpu_dt'] + d_info['sys_dt'] + if self.add_total and num == self.MaxNumTimer and len(lnum)>1: + out.append(self.sepa) + out.append(self.fmtlig % d_info) + if lnum: + out.append(self.sepa) + out.append('') + return os.linesep.join(out) + +#------------------------------------------------------------------------------- +if __name__ == '__main__': + chrono = ASTER_TIMER(format='aster') + chrono.Start('Compilation') + chrono.Start('CALC_FONCTION') + chrono.Start(23, name='CALC_FONCTION') + time.sleep(0.4) + chrono.Stop('Compilation') + chrono.Stop(23) + chrono.Start('Child') + print chrono diff --git a/Aster/Cata/cataSTA10/Utilitai/courbes.py b/Aster/Cata/cataSTA10/Utilitai/courbes.py new file mode 100644 index 00000000..5f8f66ae --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/courbes.py @@ -0,0 +1,135 @@ +#@ MODIF courbes Utilitai DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +#================================================== +# fonction "COURBES" +# usage : permet de tracer des courbes en interactif +# avec XMGRACE ou dans un fichier postscript +#================================================== + +import Stanley +from Stanley import xmgrace +from Stanley import as_courbes + +def COURBES(listcourb,titre=' ',soustitre=' ',legx=' ',legy=' ',bornex=None,borney=None,fichier=None): + +# ARGUMENTS + +# listcourb : tuple de courbes, chaque courbe etant definie soit par +# (TABLE1, NOM_PARA_X, TABLE2, NOM_PARA_Y, LEGENDE) +# soit par : +# (FONCTION,LEGENDE) +# titre et sous_titre : facultatifs, titre et sous-tritre du graphique +# legx, legy : facultatifs, legendes des axes +# bornex, borney : facultatifs, bornes sur les axes +# fichier : facultatif : sortie au format postscript si present +# +# exemples d'appel : +#-------------------- +# courb1=(SYYPRT,'ABSC_CURV',SYYPRT,'SIYY','PRT') +# courb2=(SYYMLC10,'ABSC_CURV',SYYMLC10,'SIYY','MLC10') +# courb3=(SYYML100,'ABSC_CURV',SYYML100,'SIYY','MLC100') +# listcourb=(courb1,courb2,courb3) +# COURBES(listcourb,titre='Plaque trouee',legx='Abcisses curvilignes',legy='Contraintes (MPa)',bornex=(0,100),borney=(500,1000)) +# fonc1=(F1,'F_PRT') +# fonc2=(F2,'F_MLC10') +# fonc3=(F3,'F_MLC100') +# listfonc=(fonc1,fonc2,fonc3) +# COURBES(listfonc,titre='Fonctions') +# postscript +# COURBES(listfonc,titre='Plaque trouee',fichier='./fort.24') +#-------------------------------------------------------------- + +# initialisation du trace de courbes + + if (fichier!=None): + graphe=xmgrace.Xmgr(10,' -hardcopy -nosafe') + print "Nombre de courbes ",len(listcourb)," sur le fichier :",fichier + + else: + graphe=xmgrace.Xmgr(10,' -noask') + print "Nombre de courbes ",len(listcourb) + + graphe.Nouveau_graphe() + +# dimensionnement des axes + if bornex != None : + xmin=list(bornex)[0] + xmax=list(bornex)[1] + ctest1 = as_courbes.Courbe() + ctest1.x=[xmin,xmax] + ctest1.y=[0.0,0.0] + graphe.Courbe(ctest1) + + if borney != None : + ymin=list(borney)[0] + ymax=list(borney)[1] + ctest2 = as_courbes.Courbe() + ctest2.x=[0.0,0.0] + ctest2.y=[ymin,ymax] + graphe.Courbe(ctest2) + + if titre != None : + if soustitre != None : + graphe.Titre(titre,soustitre) + else : + graphe.Titre(titre,' ') + + if legx != None : + graphe.Axe_x(legx) + + if legy != None : + graphe.Axe_y(legy) + + k = 0 + + for courbi in listcourb: + sigi = as_courbes.Courbe() + + try : + # cas d une table + sigi.Lire_x(courbi[0],courbi[1]) + sigi.Lire_y(courbi[2],courbi[3]) + legende=courbi[4] + except : + # cas d une fonction + sigi.x,sigi.y=courbi[0].Valeurs() + legende=courbi[1] + + graphe.Courbe(sigi,legende) + graphe.Send('WITH G'+repr(graphe.gr_act)) + graphe.Send('S' + str(k) + ' SYMBOL ' + str(k+2)) + graphe.Send('S' + str(k) + ' SYMBOL SIZE 0.5') + graphe.Send('S' + str(k) + ' SYMBOL COLOR '+str(k+2)) + graphe.Send('S' + str(k) + ' LINE COLOR '+str(k+2)) + k = k + 1 + graphe.Send('REDRAW') + + if (fichier!=None): + graphe.Sortie_EPS(fichier) + graphe.Fermer() + else: + graphe.Attendre() + + k=0 + +#=========================================== + + diff --git a/Aster/Cata/cataSTA10/Utilitai/funct_root.py b/Aster/Cata/cataSTA10/Utilitai/funct_root.py new file mode 100644 index 00000000..da488cfe --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/funct_root.py @@ -0,0 +1,95 @@ +#@ MODIF funct_root Utilitai DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# -*- coding: iso-8859-1 -*- +################################################################################ +# Mathematical utility routines +# Copyright (C) 1999, Wesley Phoa +# +# Reference: Numerical Recipes in C +# [[[[extraits]]]] + +class BracketingException(Exception): + pass + +class RootFindingException(Exception): + pass + +class MinimizationException(Exception): + pass + +GOLDEN = (1+5**.5)/2 + +# +# MISCELLANEOUS +# + +def sgn(x): + if x==0: + return 0 + else: + return x/abs(x) + +# +# UNIVARIATE ROOT FINDING +# + +def bracket_root(f, interval, max_iterations=50): + """\ +Given a univariate function f and a tuple interval=(x1,x2), +return a new tuple (bracket, fnvals) where bracket=(x1,x2) +brackets a root of f and fnvals=(f(x1),f(x2)). + """ + x1, x2 = interval + if x1==x2: + raise BracketingException("initial interval has zero width") + elif x2= 0: # not currently bracketed + if abs(f1)=0: + raise BracketingException("initial interval does not bracket a root") + x4 = 123456789. + for j in range(max_iterations): + x3 = (x1+x2)/2 + f3 = f(x3) + temp = f3*f3 - f1*f2 + x4, x4old = x3 + (x3-x1)*sgn(f1-f2)*f3/temp**.5, x4 + f4 = f(x4) + if f1*f4<0: # x1 and x4 bracket root + x2, f2 = x4, f4 + else: # x4 and x2 bracket root + x1, f1 = x4, f4 + if min(abs(x1-x2),abs(x4-x4old)) On propose d'opérer ligne par ligne + ==> L'absence d'informations sur la variabilité du nombre d'éléments oblige à traiter le cas général + + + + Etapes du développement : + 24/05/2005 : Test de lecture du fichier, choix d'une stratégie de gestion + 25/05/2005 : Objet itérable pour la lecture du fichier + 29/05/2005 : Créations de filtres pour les spectres +""" + +import math + +def nearestKeys(k1, dct) : + """ + retourne les clés (doublet) les plus proches de 'key' dans le dictionnaire dct + par valeur inférieure et supérieures + """ + kr = min(dct.keys()) + for k2 in dct.keys() : + if (k2kr) : kr = k2 + kinf = kr + + kr = max(dct.keys()) + for k2 in dct.keys() : + if (k2>k1) and (k2 self.upperBound : + toDel = toDel + [i] + + # Nettoyage des fréquences à suppimer (on commence par les plus hautes) + for i in toDel[::-1] : + del spr.listFreq[i] + del spr.dataVal[i] + + toDel = [] + for i in range(0, len(spr.listFreq)) : + if spr.listFreq[i] < self.lowerBound : + toDel = toDel + [i] + else : + break + + # Nettoyage des fréquences à suppimer (on finit par les plus basses) + for i in toDel[::-1] : + del spr.listFreq[i] + del spr.dataVal[i] + + return spr + +class filtreCrible(filtre): + """ + Criblage du spectre selon specif SEPTEN §C-5 (ce que j'en comprend) + """ + def __init__(self, **listOpt): + try : + self.tolerance = listOpt['tolerance'] + except KeyError : + self.tolerance = 0.25 + + self.listEtats = [] + + def _filtre(self, sp) : + self._initListeEtats(sp) # Création de la table des étsts des valeurs du spectre + coef = 1 + + # Parcours de la liste des fréquences + i1, i2, i3 = 0, 2, 1 + bTest = True + while True : + try : + bTest = self._amplitude(sp, i1, i2, i3, coef) + if not(bTest) and ((i2-i1) > 2) : + # Le point a été éliminé, on réexamine le point précédent sauf si c'est le premier examiné + i3 -= 1 + if self._amplitude(sp, i1, i2, i3, coef) : + # Le point a été "récupéré", il devient la nouvelle origine + i1 = i3 + i2 = i2 # écrit quand meme pour la compréhension + i3 += 1 + else : + # Le point reste désactivé, on avance au point suivant, le point d'origine est conservé + i1 = i1 + i2 += 1 + i3 += 2 + elif not(bTest) and not((i2-i1) > 2) : + i1 = i1 + i2 += 1 + i3 += 1 + else : # Le point est conservé, il devient la nouvelle origine + i1 = i3 + i2 += 1 + i3 += 1 + except IndexError : + break + + return self._crible(sp) + + def _initListeEtats(self, sp) : + """ + Crée une liste associant à chaque fréquence du spectre passé en paramètre, un état booléen + qui spécifie si ce couple fréquence-valeur est supprimé ou pas + NB : au départ toutes les valeur sont "True" car aucune valeur n'a été supprimée + """ + self.listEtats = [True for x in sp.listFreq] + + def _crible(self, sp) : + """ + Supprime les points de fréquence qui sont marqué False dans listEtats + """ + sp2 = spectre([], []) # On force car il y a un problème de persistance su spectre précédent + for x,y,z in zip(self.listEtats, sp.listFreq, sp.dataVal) : + if x : + sp2.listFreq.append(y) + sp2.dataVal.append(z) + + return sp2 + + def _amplitude(self, sp, id1, id2, id3, coef=1) : + """ + teste le point d'indice id3 par rapport aux points à sa gauche(p1 d'indice id1) et + à sa droite (p2 d'indice id2). + Le point est éliminé si sa valeur est en dessous de la droite reliant les points + d'indice id1 et id2 sauf si sa distance à cette droite est supérieure à : + tolerance*ordonnée + Le critère est purement sur l'amplitude du point indépendemment de l'intervalle + sur lequel il s'applique + """ + x0 = sp.listFreq[id1] + y0 = sp.dataVal[id1] + x1 = sp.listFreq[id2] + y1 = sp.dataVal[id2] + x2 = sp.listFreq[id3] + y2 = sp.dataVal[id3] + + yp2 = interpole(x2, x0, y0, x1, y1) + + # Le point est il susceptible d'etre supprimé (est il en dessous de la droite p1-p2 ?) + # Faut-il le supprimer pour autant (distance y2 à yp2 > tolerance% de y2) + bSup = not((y2 < yp2) and (abs(yp2-y2)/y2 < self.tolerance)) + + # Changement de l'état du point + self.listEtats[id3] = bSup + + return bSup + +class filtreChevauchement(filtre): + """ + Compare un spectre à un spectre de référence fréquence par fréquence. + Si une fréquence n'existe pas, on cherche la valeur équivalent par interpolation + Pour éviter tout recouvrement, il est éventuellement nécessaire de rajouter + des informations à certaines fréquences + """ + def __init__(self, **listOpt) : + try : + self.spRef = listOpt['ref'] + except KeyError : + self.spRef = spectre() + + try : + signe = listOpt['ordre'] + self.ordre = signe/abs(signe) #coefficient +1 ou -1 + except KeyError : + self.ordre = +1 + except ZeroDivisionError : + self.ordre = +1 + + def _filtre(self, sp) : + spDict = sp.buildMap() + spRefDict = self.spRef.buildMap() + spTestDict = {} + + # On commence par construire un dictionnaire des valeurs à tester comportant toutes les clés contenues + for k in spDict.keys() : spTestDict[k] = True + for k in spRefDict.keys() : spTestDict[k] = True + + # On teste ensuite toutes les valeurs du dictionnaire + for k in spTestDict.keys() : + # Test d'existence dans le dictionnaire du spectre de référence + try : + vr = spRefDict[k] + except KeyError : + ki = nearestKeys(k, spRefDict) + vr = interpole(k, ki[0], spRefDict[ki[0]], ki[1], spRefDict[ki[1]]) + # Test d'existence dans le dictionnaire du spectre à tester + try : + vt = spDict[k] + except KeyError : + ki = nearestKeys(k, spDict) + vt = interpole(k, ki[0], spDict[ki[0]], ki[1], spDict[ki[1]]) + + # Comparaison des deux valeurs. La clé est ajoutée si elle n'existe pas + if vt*self.ordre < vr*self.ordre : spDict[k] = vr + + return spectre.sortSpectre(spDict) + +class spectre : + """ + décrit un spectre composé d'un ensemble de résultat associé à un ensemble de fréquence + """ + def __init__(self, listFreq = [], dataVal = []) : + self.listFreq = [v for v in listFreq] + self.dataVal = [v for v in dataVal] + + def filtre(self, fi) : + """ + Applique le filtre passé en paramètre au spectre et retourne un nouveau spectre + """ + return fi(self) + + def __staticSortSpectre(dict) : + """ + Convertit un spectre présenté sous forme d'un dictionnaire en un spectre normal + Fonction créé parceque les clés du dictionnaire ne sont pas ordonnées + """ + lstFrq = dict.keys() + lstFrq.sort() + lstVal = [] + for fr in lstFrq : + try : + lstVal.append(dict[fr]) + except KeyError : # Ne devrait jamais arriver + lstVal.append(-1E15) + + return spectre(lstFrq, lstVal) + + sortSpectre = staticmethod(__staticSortSpectre) # définition en tant que méthode statique + + def getCoupleVal(self,indice) : + return (self.listFreq[indice], self.dataVal[indice]) + + def moyenne(self) : + """ + Calcule la moyenne pondéré : somme(An* dfn) /F + """ + somme = 0.0 + X0 = self.listFreq[0] + X1 = self.listFreq[len(self.listFreq)-1] + for i in range(0,len(self.listFreq)-1) : + x0 = self.listFreq[i] + y0 = self.dataVal[i] + x1 = self.listFreq[i+1] + y1 = self.dataVal[i+1] + + somme = somme + (y0+y1) * abs(x1-x0) / 2 + + return somme/abs(X1-X0) + + def seuil(self, limit=75) : + """ + retourne un couple d'index délimitant l'ensemble des valeurs du spectre + définissant "limit" pourcent du total cumulé des valeurs + [borne à gauche inclue, borne à droite exclue[ + ATTENTION on fait l'hypothèse que le spectre a une forme en cloche. + """ + resu = [0 for v in self.dataVal] # initialisation du tableau resultat + + maxi = max(self.dataVal) # Valeur maxu du spectre + iMaxi = self.dataVal.index(maxi) # Index de la valeur max du spectre + + # ETAPE 1 : SOMMATION + somme = 0.0 + for v, i in zip(self.dataVal[0:iMaxi], range(0, iMaxi)) : + somme = somme + v + resu[i] = somme + + somme = 0.0 + for v, i in zip(self.dataVal[:iMaxi:-1], range(len(self.dataVal)-1, iMaxi, -1)) : + somme = somme + v + resu[i] = somme + + resu[iMaxi] = resu[iMaxi-1] + self.dataVal[iMaxi] + resu[iMaxi+1] + + #ETAPE 2 : POURCENTAGE (PAS NECESSAIRE MAIS PLUS LISIBLE) + for v, i in zip(self.dataVal[0:iMaxi], range(0, iMaxi)) : + resu[i] = (resu[i] + maxi/2) / resu[iMaxi] * 100 + + for v, i in zip(self.dataVal[iMaxi+1:], range(iMaxi+1, len(self.dataVal))) : + resu[i] = (resu[i] + maxi/2) / resu[iMaxi] * 100 + + resu[iMaxi] = resu[iMaxi-1] + resu[iMaxi+1] + + # ETAPE 3 : RECHERCHE DES BORNES + limit = (100.0 - limit) / 2.0 + b1 = b2 = True + for v1, v2 in zip(resu[:], resu[::-1]): # Parcours simultané dans les deux sens + if b1 and v1 >= limit : # Borne à gauche trouvée + i1 = resu.index(v1) + b1 = False + if b2 and v2 >= limit : # Borne à droite trouvée + i2 = resu.index(v2) + 1 # Borne à droit exclue de l'intervalle + b2 = False + + return (i1, i2) + + def cut(self, nuplet) : + """ + Découpe un spectre en sous-spectres qui sont retournés en sortie de la fonction + sous la forme d'un tableau de spectres + """ + # transformation du nuplet en tableau (permet de lui ajouter un élément) + tabNuplet = [v for v in nuplet] + tabNuplet.append(len(self.listFreq)) + + # Traitement + tableRes = list() + bGauche = 0 + for borne in tabNuplet : + bDroite = borne + sp = spectre() + for i in range(bGauche, bDroite) : + sp.listFreq.append(self.listFreq[i]) + sp.dataVal.append(self.dataVal[i]) + + tableRes.append(sp) + bGauche = bDroite + + return tableRes + + def __staticMerge(tabSpectre) : + """ + A l'inverse de la fonction cut, construit un seul spectre à partir d'un ensemble de spectres + """ + # On vérifie d'abord que les spectres ne partagent pas la meme bande de fréquence (fut ce partiellement) + for i in range(0, len(tabSpectre)-1) : + if exclus(tabSpectre[i].listFreq, tabSpectre[i+1].listFreq) : raise SpectreError + if exclus(tabSpectre[0].listFreq, tabSpectre[len(tabSpectre)-1].listFreq) : raise SpectreError + + spRes = spectre() + #cumul des spectres + for sp in tabSpectre : + for f, v in zip(sp.listFreq, sp.dataVal) : + spRes.listFreq.append(f) + spRes.dataVal.append(v) + + return spRes + + merge = staticmethod(__staticMerge) # définition en tant que méthode statique + + def buildMap(self) : + """ + Construit un dictionnaire à partir d'un spectre + """ + dict = {} + for i, j in zip(self.listFreq, self.dataVal) : + dict[i] = j + + return dict + +class nappe : + """ + décrit un objet nappe qui associe à un ensemble de fréquence à une enesmble de résultats + """ + def __init__(self, listFreq = [], listeTable = [], listAmor = [], entete = ""): + self.listFreq = [v for v in listFreq] # recopie physique ! + self.listTable = [list() for t in listeTable] + for t, st in zip(listeTable, self.listTable) : + for v in t : st.append(v) + + self.listAmor = [l for l in listAmor] + self.entete = entete + + def __staticBuildFromListSpectre(lsp) : + """ + Construction d'une nappe à partir d'une liste de spectres + """ + # On commence par vérifier que toutes les nappes on la meme base de fréquences + # A inclus dans B inclus dans C inclus dans .... et DERNIER inclus dans PREMIER ==> tous égaux + for i in range(0,len(lsp.listSp)-1) : + if inclus(lsp.listSp[i].listFreq, lsp.listSp[i+1].listFreq) : raise NappeCreationError + if inclus(lsp.listSp[i+1].listFreq, lsp.listSp[0].listFreq) : raise NappeCreationError + + # Construction de la nappe à proprement parler + listeFreq = [fr for fr in lsp.listSp[0].listFreq] + listeTable = [list() for sp in lsp.listSp] + for sp, lv in zip(lsp.listSp, listeTable) : + for v in sp.dataVal : + lv.append(v) + return nappe(listeFreq, listeTable, [], 'toto') + + buildFromListSpectre = staticmethod(__staticBuildFromListSpectre) # définition en tant que méthode statique + + def getNbSpectres(self) : + """ Retourne le nombre d'éléments dans la nappe """ + return len(self.listAmor) + + def getNbFreq(self) : + """ Retourne le nombre d'éléments dans chaque spectre """ + return len(self.listFreq) + + def getSpectre(self, index) : + """ + Retourne le spectre d'indice 'index' dans la nappe + """ + return spectre(self.listFreq, self.listTable[index]) + + def filtreDoublons(self): + """ + Supprime bandes de fréquences constantes + """ + prevCpl = None + bCount = False + i=0 + # Recherche des doublons + lstBor = list() # Liste de listes de bornes + lst = list() + for cpl in self.__getListFreq() : + if not(prevCpl) : + prevCpl = cpl + continue + bTest = True + for v1, v2 in zip(cpl[1], prevCpl[1]) : + bTest &= (v1==v2) + if bTest and not bCount : # Début d'une suite de valeurs égales + bCount = True + lst.append(i) + elif not bTest and bCount : # Fin d'une suite de valeurs égales + bCount = False + lst.append(i) + lstBor.append(lst) + lst = list() # Nouvelle liste + + prevCpl = cpl + i += 1 + + # Suppression des doublons si plus de deux valeurs + for cpl in lstBor : + if (cpl[1]-cpl[0]) < 2 : continue + for i in range(cpl[1]-1, cpl[0], -1) : + del self.listFreq[i] + for j in range(0, len(self.listTable)) : + del self.listTable[j][i] + + + + + def __getListFreq(self) : + """ + Fonction privé qui parcours la matrice ligne par ligne + Retourne à chaque itération un couple frequence, liste de valeurs + """ + fr = 0.0 + + for i in range(0, self.getNbFreq()) : + fr = self.listFreq[i] + listVal = [] + for j in range(0, len(self.listTable)): + listVal.append(self.listTable[j][i]) + yield (fr, listVal) + + raise StopIteration + +class listSpectre : + """ + classe container d'une liste de spectre ne partageant pas la meme base de fréquence + cas des spectres à l'issue de la première passe de l'opération de filtrage d'enveloppe + """ + def __init__(self, *listSp) : + self.listSp = [] + for sp in listSp : + self.listSp = sp + + def append(self, spectre) : + """ Ajoute un spectre à la liste """ + self.listSp.append(spectre) + + def __staticBuildFromNappe(uneNappe) : + """ + Construit une liste de spectres (indépendants) à partir d'une nappe + """ + res = listSpectre() + for i in range(0, len(uneNappe.listAmor)) : + res.append(uneNappe.getSpectre(i)) + + return res + + buildFromNappe = staticmethod(__staticBuildFromNappe) #Définition en tant que méthode statique + + def testChevauchement(self) : + """ + Supprime les effets de chevauchement entre les spectres + """ + for i in range(0, len(self.listSp)-1) : + filter = filtreChevauchement(ref=self.listSp[i+1]) + self.listSp[i] = self.listSp[i].filtre(filter) + + def createBase(self, lspRef = None) : + """ + Crée une base de fréquence commune pour l'ensemble des spectres + En s'assurant que le l'on reste enveloppe des spectre de la liste lspRef + """ + lspRes = listSpectre([spectre() for sp in self.listSp]) # Liste résultante + + # Recherche des fréquences attribuées à 5 spectres, 4 spectres, ... classées dans un dictionnaire + dctOc = self.__sortByOccurence() + + iOcc = max(dctOc.keys()) + lst = dctOc[iOcc] # On comence par mettre les frequences communes à tous les spectres + lst.sort() + iOcc -= 1 + test = 0 + while True : + lspRes.__addFreqFromList(self, lst) + # On vérifie si on reste enveloppe du spectre initial + spTest = spectre() + lstComp = list() + for sp0, sp1 in zip(lspRes.listSp, self.listSp) : + filter = filtreChevauchement(ref=sp1) + spTest = sp0.filtre(filter) + # Crée une liste des fréquences ajoutées (s'il y en a...) + for fr in spTest.listFreq : + try : + idx = sp0.listFreq.index(fr) + except ValueError : # Valeur non trouvée dans le tableau + lstComp.append(fr) + + if len(lstComp) > 0 : # Il est nécessaire de compléter les spectres + # on prend de préférence les fréquences définies sur le plus de spectre possible + while True : + lstFreq = dctOc[iOcc] + prevLst = lst # On sauvegarde la liste précédente pour comparaison + lst = self.__buildList(lstComp, lstFreq) + if not(inclus(lst, prevLst)) : + iOcc -= 1 + else : + break + continue + else : + break # On peut sortir les spectres sont complets + + self.listSp = lspRes.listSp # Remplacement de la liste des spectres + + # On s'assure que le spectre reste enveloppe du spectre de référence rajoute des fréquences si nécessaire + # 1. filtre chevauchement + if lspRef : # Si une liste de spectre de référence a été définie, on vérifie le caractère enveloppe du résultat + listComp = list() + + for sp1, sp2 in zip(self.listSp, lspRef.listSp) : + filter = filtreChevauchement(ref=sp2) + spTest = sp1.filtre(filter) + test = inclus(spTest.listFreq, sp1.listFreq) + if test : listComp.append(test) + # 3. Complément éventuel de l'ensemble des spectres + if listComp : lspRes.__addFreqFromList(self, listComp) + + self.listSp = lspRes.listSp # Remplacement de la liste des spectres + + def filtre(self, filter): + """ + Applique un filtre à l'ensemble des spectres de la liste + """ + self.listSp = [sp.filtre(filter) for sp in self.listSp] + + + def __sortByOccurence(self) : + """ + Fonction qui trie les fréquences par leur occurence d'apparition dans la liste de spectre + """ + dct = {} + for sp in self.listSp : # Boucle sur tous les spectres + for fr in sp.listFreq : # Boucle sur toutes les fréquences de chaque spectre + try : + dct[fr] += 1 + except KeyError : + dct[fr] = 1 + + # "Inversion" du dictionnaire + dctOc = {} # Dictionnaire des occurences + for k in dct.keys() : + try : + dctOc[dct[k]].append(k) + except KeyError : + dctOc[dct[k]]=[k] + + + return dctOc + + def __addFreqFromList(self, lstSp, lstFreq) : + """ + Rajoute les fréquences contenues dans lstFreq aux spectres d'un listeSpectre + à partir des spectres fournis par le listeSpectre (lstSp) passé en paramètre + en procédant éventuellement à une interpolation linéaire + """ + # Suppression des doublons de la liste des fréquences + lstFreq = listToDict(lstFreq).keys() # lst est la liste des points qu'il faudrait ajouter pour rester enveloppe + lstFreq.sort() + + for i in range(0, len(self.listSp)) : + # Conversion des spectres en dictionnaire pour pouvoir les traiter + spDctSelf = self.listSp[i].buildMap() + spDctRef = lstSp.listSp[i].buildMap() + for fr in lstFreq : + # On cherche la valeur dans le spectre de référence + try : + vr = spDctRef[fr] + except KeyError : + ki = nearestKeys(fr, spDctRef) + vr = interpole(fr, ki[0], spDctRef[ki[0]], ki[1], spDctRef[ki[1]]) + + # On rajoute la valeur dans le spectre résultat + spDctSelf[fr] = vr + + # Conversion du dictionnaire en spectre réel + self.listSp[i] = spectre.sortSpectre(spDctSelf) + + def __buildList(self, lstComp, lstFreq) : + """ + Construit une liste de fréquences à ajouter à partir d'une liste de fréquences + à ajouter (listComp) et d'une liste de référence, (listFreq) + retourne une liste + """ + lst = list() + for fr in lstComp : + try : + idx = lstFreq.index(fr) + lst.append(fr) + except ValueError : # Fréquence non présente, recherche de la plus proche + couple = nearestKeys(fr, listToDict(lstFreq)) + if abs(couple[0]-fr) > abs(couple[1]-fr) : + lst.append(couple[1]) + else : + lst.append(couple[0]) + + lst = listToDict(lst).keys() # Suppression des doublons + lst.sort() + return lst + + +def lissage(nappe=nappe,fmin=0.2,fmax=35.5,elarg=0.1,tole_liss=0.25) : + resultat = listSpectre() # Le résultat sera contenu dans une liste de spectre + lspBrut = listSpectre.buildFromNappe(nappe) + # Passage en LogLog + lspBrut.filtre(filtreLog()) + for j in range(0,nappe.getNbSpectres()) : + # Spectre brut + sp = nappe.getSpectre(j) + # Limitation de la bande de fréquence + filter = filtreBandWidth(lower=fmin, upper=fmax) + sp = sp.filtre(filter) + # Expansion du spectre + filter = filtreExpand(coef=elarg) + sp = sp.filtre(filter) + # Passage en LogLin + filter = filtreLog(logOrd=False) + sp = sp.filtre(filter) + # éclatement du spectre en 3 sous-parties + tabSpectre = sp.cut(sp.seuil()) + # traitement individuel des sous parties + filter = filtreCrible(tolerance=2.*tole_liss) + tabSpectre[0] = tabSpectre[0].filtre(filter) + tabSpectre[2] = tabSpectre[2].filtre(filter) + filter.tolerance = tole_liss + tabSpectre[1] = tabSpectre[1].filtre(filter) + # Fusion des sous-spectres + sp = spectre.merge(tabSpectre) + + # Seconde passe de filtrage + sp = sp.filtre(filter) + + # On passe en log-log pour les tests de chevauchement + filter = filtreLog(logAbc=False) + sp = sp.filtre(filter) + # Ecriture dans la liste de spectres résultat + resultat.append(sp) # Ajoute la spectre lissé à la liste des spectres + + resultat.testChevauchement() # Test de chevauchement entre les spectre de la liste + resultat.createBase(lspBrut) # construction d'une base commune de fréquence + + # Passage en lin + resultat.filtre(filtreLin()) + + # Construction de la nappe résultat + nappeRes = nappe.buildFromListSpectre(resultat) + nappeRes.listAmor=nappe.listAmor + nappeRes.filtreDoublons() # Suppression des valeurs identiques accolées + + return nappeRes diff --git a/Aster/Cata/cataSTA10/Utilitai/macro_rota_globale.py b/Aster/Cata/cataSTA10/Utilitai/macro_rota_globale.py new file mode 100644 index 00000000..3440f8ec --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/macro_rota_globale.py @@ -0,0 +1,143 @@ +#@ MODIF macro_rota_globale Utilitai DATE 18/09/2007 AUTEUR DURAND C.DURAND +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +from Cata.cata import * + +# =========================================================================== +# CORPS DE LA MACRO "MACR_ROTA_GLOBALE" +# ------------------------------------- +# USAGE : +# RESULTAT : resultat +# GROUP_NO_ORIG : un groupe d un noeud definissant l entree du coude (A) +# GROUP_NO_EXTR : un groupe d un noeud definissant la sortie du coude (B) +# +# / +# A / +# (______ +# B +# +# =========================================================================== +# script PYTHON : rotation globale sur une tuyauterie + + +def macr_rota_globale_ops(self,RESULTAT,GROUP_NO_ORIG,GROUP_NO_EXTR,**args): + + + """ + Ecriture de la macro MACR_ROTA_GLOBALE + """ + import os + from Accas import _F + from Noyau.N_utils import AsType + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') + DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + # Le concept sortant (de type fonction) est nomme ROTGD dans + # le contexte de la macro + + self.DeclareOut('ROTGD',self.sd) + + # Commandes de la macro + + __ROTAB=POST_RELEVE_T(ACTION=_F(INTITULE='__ROTAB', + GROUP_NO=GROUP_NO_ORIG, + RESULTAT=RESULTAT, + NOM_CHAM='DEPL', + NOM_CMP=('DRX','DRY','DRZ',), + OPERATION='EXTRACTION',), + ) + + __ROTAC=POST_RELEVE_T(ACTION=_F(INTITULE='__ROTAC', + GROUP_NO=GROUP_NO_EXTR, + RESULTAT=RESULTAT, + NOM_CHAM='DEPL', + NOM_CMP=('DRX','DRY','DRZ',), + OPERATION='EXTRACTION',),); + + __ROTABt=__ROTAB.EXTR_TABLE() + __ROTACt=__ROTAC.EXTR_TABLE() + __DRXC = __ROTACt.Array('INST','DRX') + __DRYC = __ROTACt.Array('INST','DRY') + __DRZC = __ROTACt.Array('INST','DRZ') + __DRXB = __ROTABt.Array('INST','DRX') + __DRYB = __ROTABt.Array('INST','DRY') + __DRZB = __ROTABt.Array('INST','DRZ') + __DRXBC = __DRXC-__DRXB + __DRYBC = __DRYC-__DRYB + __DRZBC = __DRZC-__DRZB + __ROTG = __DRXBC*__DRXBC + __ROTG = __ROTG+__DRYBC*__DRYBC + __ROTG = __ROTG+__DRZBC*__DRZBC + __ROTG = __ROTG**(0.5) + + __livalr = [] + __livali = [] + for i in range(len(__ROTG)): + __livalr.append(__ROTG[i,1]) + __livali.append(__DRXC[i,0]) + + print __livalr + print __livali + + __LROTG = DEFI_LIST_REEL(VALE=__livalr) + __LINST = DEFI_LIST_REEL(VALE=__livali) + + ROTGD = DEFI_FONCTION(NOM_PARA='INST', + VALE_PARA=__LINST, + VALE_FONC=__LROTG, + ) + + return ier + + + +# =========================================================================== +# CATALOGUE DE LA MACRO "MACR_ROTA_GLOBALE" +# ----------------------------------------- +# USAGE : +# RESULTAT : resultat +# GROUP_NO_ORIG : un groupe d un noeud definissant l entree du coude (A) +# GROUP_NO_EXTR : un groupe d un noeud definissant la sortie du coude (B) +# +# / +# A / +# (______ +# B +# +# =========================================================================== + + + +MACR_ROTA_GLOBALE=MACRO(nom="MACR_ROTA_GLOBALE",op=macr_rota_globale_ops,sd_prod=fonction_sdaster, + docu="",reentrant='n', + fr="calcul de la rotation globale dans un coude.", + RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,evol_ther) ), + GROUP_NO_ORIG =SIMP(statut='o',typ=grno,max=1), + GROUP_NO_EXTR =SIMP(statut='o',typ=grno,max=1), +) ; + + + diff --git a/Aster/Cata/cataSTA10/Utilitai/optimize.py b/Aster/Cata/cataSTA10/Utilitai/optimize.py new file mode 100644 index 00000000..e4d3cc2f --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/optimize.py @@ -0,0 +1,591 @@ +#@ MODIF optimize Utilitai DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ASSIRE A.ASSIRE +# + +# ******NOTICE*************** +# optimize.py module by Travis E. Oliphant +# +# You may copy and use this module as you see fit with no +# guarantee implied provided you keep this notice in all copies. +# *****END NOTICE************ + +# A collection of optimization algorithms. Version 0.3.1 + +# Minimization routines +"""optimize.py + +A collection of general-purpose optimization routines using Numeric + +fmin --- Nelder-Mead Simplex algorithm (uses only function calls) +fminBFGS --- Quasi-Newton method (uses function and gradient) +fminNCG --- Line-search Newton Conjugate Gradient (uses function, gradient + and hessian (if it's provided)) + +""" +import numpy as Num +max = Num.max +min = Num.min +abs = Num.absolute +__version__="0.3.1" + +def rosen(x): # The Rosenbrock function + return Num.sum(100.0*(x[1:len(x)]-x[0:-1]**2.0)**2.0 + (1-x[0:-1])**2.0) + +def rosen_der(x): + xm = x[1:-1] + xm_m1 = x[0:-2] + xm_p1 = x[2:len(x)] + der = Num.zeros(x.shape,x.dtype.char) + der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm) + der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0]) + der[-1] = 200*(x[-1]-x[-2]**2) + return der + +def rosen3_hess_p(x,p): + assert(len(x)==3) + assert(len(p)==3) + hessp = Num.zeros((3,),x.dtype.char) + hessp[0] = (2 + 800*x[0]**2 - 400*(-x[0]**2 + x[1])) * p[0] \ + - 400*x[0]*p[1] \ + + 0 + hessp[1] = - 400*x[0]*p[0] \ + + (202 + 800*x[1]**2 - 400*(-x[1]**2 + x[2]))*p[1] \ + - 400*x[1] * p[2] + hessp[2] = 0 \ + - 400*x[1] * p[1] \ + + 200 * p[2] + + return hessp + +def rosen3_hess(x): + assert(len(x)==3) + hessp = Num.zeros((3,3),x.dtype.char) + hessp[0,:] = [2 + 800*x[0]**2 -400*(-x[0]**2 + x[1]), -400*x[0], 0] + hessp[1,:] = [-400*x[0], 202+800*x[1]**2 -400*(-x[1]**2 + x[2]), -400*x[1]] + hessp[2,:] = [0,-400*x[1], 200] + return hessp + + +def fmin(func, x0, args=(), xtol=1e-4, ftol=1e-4, maxiter=None, maxfun=None, fulloutput=0, printmessg=1): + """xopt,{fval,warnflag} = fmin(function, x0, args=(), xtol=1e-4, ftol=1e-4, + maxiter=200*len(x0), maxfun=200*len(x0), fulloutput=0, printmessg=0) + + Uses a Nelder-Mead Simplex algorithm to find the minimum of function + of one or more variables. + """ + x0 = Num.asarray(x0) + assert (len(x0.shape)==1) + N = len(x0) + if maxiter is None: + maxiter = N * 200 + if maxfun is None: + maxfun = N * 200 + + rho = 1; chi = 2; psi = 0.5; sigma = 0.5; + one2np1 = range(1,N+1) + + sim = Num.zeros((N+1,N),x0.dtype.char) + fsim = Num.zeros((N+1,),'d') + sim[0] = x0 + fsim[0] = apply(func,(x0,)+args) + nonzdelt = 0.05 + zdelt = 0.00025 + for k in range(0,N): + y = Num.array(x0,copy=1) + if y[k] != 0: + y[k] = (1+nonzdelt)*y[k] + else: + y[k] = zdelt + + sim[k+1] = y + f = apply(func,(y,)+args) + fsim[k+1] = f + + ind = Num.argsort(fsim) + fsim = Num.take(fsim,ind) # sort so sim[0,:] has the lowest function value + sim = Num.take(sim,ind,0) + + iterations = 1 + funcalls = N+1 + + while (funcalls < maxfun and iterations < maxiter): + if (max(Num.ravel(abs(sim[1:len(sim)]-sim[0]))) <= xtol \ + and max(abs(fsim[0]-fsim[1:len(fsim)])) <= ftol): + break + + xbar = Num.add.reduce(sim[0:-1],0) / N + xr = (1+rho)*xbar - rho*sim[-1] + fxr = apply(func,(xr,)+args) + funcalls = funcalls + 1 + doshrink = 0 + + if fxr < fsim[0]: + xe = (1+rho*chi)*xbar - rho*chi*sim[-1] + fxe = apply(func,(xe,)+args) + funcalls = funcalls + 1 + + if fxe < fxr: + sim[-1] = xe + fsim[-1] = fxe + else: + sim[-1] = xr + fsim[-1] = fxr + else: # fsim[0] <= fxr + if fxr < fsim[-2]: + sim[-1] = xr + fsim[-1] = fxr + else: # fxr >= fsim[-2] + # Perform contraction + if fxr < fsim[-1]: + xc = (1+psi*rho)*xbar - psi*rho*sim[-1] + fxc = apply(func,(xc,)+args) + funcalls = funcalls + 1 + + if fxc <= fxr: + sim[-1] = xc + fsim[-1] = fxc + else: + doshrink=1 + else: + # Perform an inside contraction + xcc = (1-psi)*xbar + psi*sim[-1] + fxcc = apply(func,(xcc,)+args) + funcalls = funcalls + 1 + + if fxcc < fsim[-1]: + sim[-1] = xcc + fsim[-1] = fxcc + else: + doshrink = 1 + + if doshrink: + for j in one2np1: + sim[j] = sim[0] + sigma*(sim[j] - sim[0]) + fsim[j] = apply(func,(sim[j],)+args) + funcalls = funcalls + N + + ind = Num.argsort(fsim) + sim = Num.take(sim,ind,0) + fsim = Num.take(fsim,ind) + iterations = iterations + 1 + + x = sim[0] + fval = min(fsim) + warnflag = 0 + + if funcalls >= maxfun: + warnflag = 1 + if printmessg: + print "Warning: Maximum number of function evaluations has been exceeded." + elif iterations >= maxiter: + warnflag = 2 + if printmessg: + print "Warning: Maximum number of iterations has been exceeded" + else: + if printmessg: + print "Optimization terminated successfully." + print " Current function value: %f" % fval + print " Iterations: %d" % iterations + print " Function evaluations: %d" % funcalls + + if fulloutput: + return x, fval, warnflag + else: + return x + + +def zoom(a_lo, a_hi): + pass + + + +def line_search(f, fprime, xk, pk, gfk, args=(), c1=1e-4, c2=0.9, amax=50): + """alpha, fc, gc = line_search(f, xk, pk, gfk, + args=(), c1=1e-4, c2=0.9, amax=1) + + minimize the function f(xk+alpha pk) using the line search algorithm of + Wright and Nocedal in 'Numerical Optimization', 1999, pg. 59-60 + """ + + fc = 0 + gc = 0 + alpha0 = 1.0 + phi0 = apply(f,(xk,)+args) + phi_a0 = apply(f,(xk+alpha0*pk,)+args) + fc = fc + 2 + derphi0 = Num.dot(gfk,pk) + derphi_a0 = Num.dot(apply(fprime,(xk+alpha0*pk,)+args),pk) + gc = gc + 1 + + # check to see if alpha0 = 1 satisfies Strong Wolfe conditions. + if (phi_a0 <= phi0 + c1*alpha0*derphi0) \ + and (abs(derphi_a0) <= c2*abs(derphi0)): + return alpha0, fc, gc + + alpha0 = 0 + alpha1 = 1 + phi_a1 = phi_a0 + phi_a0 = phi0 + + i = 1 + while 1: + if (phi_a1 > phi0 + c1*alpha1*derphi0) or \ + ((phi_a1 >= phi_a0) and (i > 1)): + return zoom(alpha0, alpha1) + + derphi_a1 = Num.dot(apply(fprime,(xk+alpha1*pk,)+args),pk) + gc = gc + 1 + if (abs(derphi_a1) <= -c2*derphi0): + return alpha1 + + if (derphi_a1 >= 0): + return zoom(alpha1, alpha0) + + alpha2 = (amax-alpha1)*0.25 + alpha1 + i = i + 1 + alpha0 = alpha1 + alpha1 = alpha2 + phi_a0 = phi_a1 + phi_a1 = apply(f,(xk+alpha1*pk,)+args) + + + +def line_search_BFGS(f, xk, pk, gfk, args=(), c1=1e-4, alpha0=1): + """alpha, fc, gc = line_search(f, xk, pk, gfk, + args=(), c1=1e-4, alpha0=1) + + minimize over alpha, the function f(xk+alpha pk) using the interpolation + algorithm (Armiijo backtracking) as suggested by + Wright and Nocedal in 'Numerical Optimization', 1999, pg. 56-57 + """ + + fc = 0 + phi0 = apply(f,(xk,)+args) # compute f(xk) + phi_a0 = apply(f,(xk+alpha0*pk,)+args) # compute f + fc = fc + 2 + derphi0 = Num.dot(gfk,pk) + + if (phi_a0 <= phi0 + c1*alpha0*derphi0): + return alpha0, fc, 0 + + # Otherwise compute the minimizer of a quadratic interpolant: + + alpha1 = -(derphi0) * alpha0**2 / 2.0 / (phi_a0 - phi0 - derphi0 * alpha0) + phi_a1 = apply(f,(xk+alpha1*pk,)+args) + fc = fc + 1 + + if (phi_a1 <= phi0 + c1*alpha1*derphi0): + return alpha1, fc, 0 + + # Otherwise loop with cubic interpolation until we find an alpha which satifies + # the first Wolfe condition (since we are backtracking, we will assume that + # the value of alpha is not too small and satisfies the second condition. + + while 1: # we are assuming pk is a descent direction + factor = alpha0**2 * alpha1**2 * (alpha1-alpha0) + a = alpha0**2 * (phi_a1 - phi0 - derphi0*alpha1) - \ + alpha1**2 * (phi_a0 - phi0 - derphi0*alpha0) + a = a / factor + b = -alpha0**3 * (phi_a1 - phi0 - derphi0*alpha1) + \ + alpha1**3 * (phi_a0 - phi0 - derphi0*alpha0) + b = b / factor + + alpha2 = (-b + Num.sqrt(abs(b**2 - 3 * a * derphi0))) / (3.0*a) + phi_a2 = apply(f,(xk+alpha2*pk,)+args) + fc = fc + 1 + + if (phi_a2 <= phi0 + c1*alpha2*derphi0): + return alpha2, fc, 0 + + if (alpha1 - alpha2) > alpha1 / 2.0 or (1 - alpha2/alpha1) < 0.96: + alpha2 = alpha1 / 2.0 + + alpha0 = alpha1 + alpha1 = alpha2 + phi_a0 = phi_a1 + phi_a1 = phi_a2 + +epsilon = 1e-8 + +def approx_fprime(xk,f,*args): + f0 = apply(f,(xk,)+args) + grad = Num.zeros((len(xk),),'d') + ei = Num.zeros((len(xk),),'d') + for k in range(len(xk)): + ei[k] = 1.0 + grad[k] = (apply(f,(xk+epsilon*ei,)+args) - f0)/epsilon + ei[k] = 0.0 + return grad + +def approx_fhess_p(x0,p,fprime,*args): + f2 = apply(fprime,(x0+epsilon*p,)+args) + f1 = apply(fprime,(x0,)+args) + return (f2 - f1)/epsilon + + +def fminBFGS(f, x0, fprime=None, args=(), avegtol=1e-5, maxiter=None, fulloutput=0, printmessg=1): + """xopt = fminBFGS(f, x0, fprime=None, args=(), avegtol=1e-5, + maxiter=None, fulloutput=0, printmessg=1) + + Optimize the function, f, whose gradient is given by fprime using the + quasi-Newton method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS) + See Wright, and Nocedal 'Numerical Optimization', 1999, pg. 198. + """ + + app_fprime = 0 + if fprime is None: + app_fprime = 1 + + x0 = Num.asarray(x0) + if maxiter is None: + maxiter = len(x0)*200 + func_calls = 0 + grad_calls = 0 + k = 0 + N = len(x0) + gtol = N*avegtol + I = Num.eye(N) + Hk = I + + if app_fprime: + gfk = apply(approx_fprime,(x0,f)+args) + func_calls = func_calls + len(x0) + 1 + else: + gfk = apply(fprime,(x0,)+args) + grad_calls = grad_calls + 1 + xk = x0 + sk = [2*gtol] + while (Num.add.reduce(abs(gfk)) > gtol) and (k < maxiter): + pk = -Num.dot(Hk,gfk) + alpha_k, fc, gc = line_search_BFGS(f,xk,pk,gfk,args) + func_calls = func_calls + fc + xkp1 = xk + alpha_k * pk + sk = xkp1 - xk + xk = xkp1 + if app_fprime: + gfkp1 = apply(approx_fprime,(xkp1,f)+args) + func_calls = func_calls + gc + len(x0) + 1 + else: + gfkp1 = apply(fprime,(xkp1,)+args) + grad_calls = grad_calls + gc + 1 + + yk = gfkp1 - gfk + k = k + 1 + + rhok = 1 / Num.dot(yk,sk) + A1 = I - sk[:,Num.newaxis] * yk[Num.newaxis,:] * rhok + A2 = I - yk[:,Num.newaxis] * sk[Num.newaxis,:] * rhok + Hk = Num.dot(A1,Num.dot(Hk,A2)) + rhok * sk[:,Num.newaxis] * sk[Num.newaxis,:] + gfk = gfkp1 + + + if printmessg or fulloutput: + fval = apply(f,(xk,)+args) + if k >= maxiter: + warnflag = 1 + if printmessg: + print "Warning: Maximum number of iterations has been exceeded" + print " Current function value: %f" % fval + print " Iterations: %d" % k + print " Function evaluations: %d" % func_calls + print " Gradient evaluations: %d" % grad_calls + else: + warnflag = 0 + if printmessg: + print "Optimization terminated successfully." + print " Current function value: %f" % fval + print " Iterations: %d" % k + print " Function evaluations: %d" % func_calls + print " Gradient evaluations: %d" % grad_calls + + if fulloutput: + return xk, fval, func_calls, grad_calls, warnflag + else: + return xk + + +def fminNCG(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-5, maxiter=None, fulloutput=0, printmessg=1): + """xopt = fminNCG(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-5, + maxiter=None, fulloutput=0, printmessg=1) + + Optimize the function, f, whose gradient is given by fprime using the + Newton-CG method. fhess_p must compute the hessian times an arbitrary + vector. If it is not given, finite-differences on fprime are used to + compute it. See Wright, and Nocedal 'Numerical Optimization', 1999, + pg. 140. + """ + + x0 = Num.asarray(x0) + fcalls = 0 + gcalls = 0 + hcalls = 0 + approx_hessp = 0 + if fhess_p is None and fhess is None: # Define hessian product + approx_hessp = 1 + + xtol = len(x0)*avextol + update = [2*xtol] + xk = x0 + k = 0 + while (Num.add.reduce(abs(update)) > xtol) and (k < maxiter): + # Compute a search direction pk by applying the CG method to + # del2 f(xk) p = - grad f(xk) starting from 0. + b = -apply(fprime,(xk,)+args) + gcalls = gcalls + 1 + maggrad = Num.add.reduce(abs(b)) + eta = min([0.5,Num.sqrt(maggrad)]) + termcond = eta * maggrad + xsupi = 0 + ri = -b + psupi = -ri + i = 0 + dri0 = Num.dot(ri,ri) + + if fhess is not None: # you want to compute hessian once. + A = apply(fhess,(xk,)+args) + hcalls = hcalls + 1 + + while Num.add.reduce(abs(ri)) > termcond: + if fhess is None: + if approx_hessp: + Ap = apply(approx_fhess_p,(xk,psupi,fprime)+args) + gcalls = gcalls + 2 + else: + Ap = apply(fhess_p,(xk,psupi)+args) + hcalls = hcalls + 1 + else: + Ap = Num.dot(A,psupi) + # check curvature + curv = Num.dot(psupi,Ap) + if (curv <= 0): + if (i > 0): + break + else: + xsupi = xsupi + dri0/curv * psupi + break + alphai = dri0 / curv + xsupi = xsupi + alphai * psupi + ri = ri + alphai * Ap + dri1 = Num.dot(ri,ri) + betai = dri1 / dri0 + psupi = -ri + betai * psupi + i = i + 1 + dri0 = dri1 # update Num.dot(ri,ri) for next time. + + pk = xsupi # search direction is solution to system. + gfk = -b # gradient at xk + alphak, fc, gc = line_search_BFGS(f,xk,pk,gfk,args) + fcalls = fcalls + fc + gcalls = gcalls + gc + + update = alphak * pk + xk = xk + update + k = k + 1 + + if printmessg or fulloutput: + fval = apply(f,(xk,)+args) + if k >= maxiter: + warnflag = 1 + if printmessg: + print "Warning: Maximum number of iterations has been exceeded" + print " Current function value: %f" % fval + print " Iterations: %d" % k + print " Function evaluations: %d" % fcalls + print " Gradient evaluations: %d" % gcalls + print " Hessian evaluations: %d" % hcalls + else: + warnflag = 0 + if printmessg: + print "Optimization terminated successfully." + print " Current function value: %f" % fval + print " Iterations: %d" % k + print " Function evaluations: %d" % fcalls + print " Gradient evaluations: %d" % gcalls + print " Hessian evaluations: %d" % hcalls + + if fulloutput: + return xk, fval, fcalls, gcalls, hcalls, warnflag + else: + return xk + + + +if __name__ == "__main__": + import string + import time + + + times = [] + algor = [] + x0 = [0.8,1.2,0.7] + start = time.time() + x = fmin(rosen,x0) + print x + times.append(time.time() - start) + algor.append('Nelder-Mead Simplex\t') + + start = time.time() + x = fminBFGS(rosen, x0, fprime=rosen_der, maxiter=80) + print x + times.append(time.time() - start) + algor.append('BFGS Quasi-Newton\t') + + start = time.time() + x = fminBFGS(rosen, x0, avegtol=1e-4, maxiter=100) + print x + times.append(time.time() - start) + algor.append('BFGS without gradient\t') + + + start = time.time() + x = fminNCG(rosen, x0, rosen_der, fhess_p=rosen3_hess_p, maxiter=80) + print x + times.append(time.time() - start) + algor.append('Newton-CG with hessian product') + + + start = time.time() + x = fminNCG(rosen, x0, rosen_der, fhess=rosen3_hess, maxiter=80) + print x + times.append(time.time() - start) + algor.append('Newton-CG with full hessian') + + print "\nMinimizing the Rosenbrock function of order 3\n" + print " Algorithm \t\t\t Seconds" + print "===========\t\t\t =========" + for k in range(len(algor)): + print algor[k], "\t -- ", times[k] + + + + + + + + + + + + + + + + diff --git a/Aster/Cata/cataSTA10/Utilitai/partition.py b/Aster/Cata/cataSTA10/Utilitai/partition.py new file mode 100644 index 00000000..f26b15c7 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/partition.py @@ -0,0 +1,1324 @@ +#@ MODIF partition Utilitai DATE 26/10/2010 AUTEUR MAHFOUZ D.MAHFOUZ +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ASSIRE A.ASSIRE + +import aster +import string, os, time, sys, UserList, types +import numpy as NP + +from Accas import _F +from Noyau.N_utils import AsType + +# ============================================================================ # +def enleve_doublons_liste(liste): + """ + A partir d une liste qui peut contenir des doublons, on renvoie une liste sans + doublons (et qui reviendra triée) + """ + #MC pourquoi ne pas faire : + # liste2 = NP.array(list(set(liste))) + # liste2.sort() + # Au cas ou ca ne serait pas deja un vecteur numpy # Exemple + liste=NP.sort(NP.array(liste,copy=0)) # [1, 2, 2, 3, 3, 4, 5] + liste_diff=liste[1:]-liste[:-1] # [1, 0, 1, 0, 1, 1] + liste_temp=NP.nonzero(liste_diff)[0] # [0, 2, 4, 5] + liste_indice=NP.zeros(liste_temp.shape[0]+1, dtype=int) + liste_indice[0]=0 + liste_indice[1:]=liste_temp+1 # [0, 1, 3, 5, 6] + liste2=NP.take(liste,liste_indice) # [1, 2, 3, 4, 5] + return liste2 + + +# ============================================================================ # +class CONNEC(UserList.UserList) : + """ + Connectivite : sequence mutable de sequences de noeuds + Pour l'instant, on s'appuie sur une liste de liste. + """ + def __init__(self,nma) : + UserList.UserList.__init__(self,[None]*nma) + + def Index(self) : + """ + Retourne la connectivite sous forme de deux vecteurs numpy : + ind -> tableau des index (y compris le n+1 eme) + noe -> tableau des listes de noeuds + """ + # Dimension des deux vecteurs + nma = len(self) + ltot = NP.reduce(lambda x,y : x+len(y), self,0) + ind = NP.zeros(nma+1, dtype=int) + noe = NP.zeros(ltot, dtype=int) + + # Construction des vecteurs + ind[0] = 0 + for i in range(nma) : + m = self[i] + ind[i+1] = ind[i] + len(m) + noe[ind[i]:ind[i+1]] = NP.array(m) + + return ind,noe + +# ============================================================================ # +class MAIL_PY : + """ + SD PYTHON MAILLAGE + La numeration est 0..N-1 pour les noeuds et 0..M-1 pour les mailles + +EXEMPLE D'UTILISATION +--------------------- +from Utilitai.Partition import * +import numpy as N + +mail=LIRE_MAILLAGE(); + +mm = MAIL_PY() +mm.FromAster(mail) + +# Nombre de noeuds +nbno = mm.dime_maillage[0] +# Nombre de mailles +nbma = mm.dime_maillage[2] + +# Coordonnées des noeuds +coord = mm.cn +# Noms des noeuds +linomno = list(mm.correspondance_noeuds) +# Groupe de Mailles +collgrma = mm.gma +# Groupe de Noeuds +collgrno = mm.gno +# La table de connextivité +connex = mm.co + +# Le décalage de -1 est déjà fait sur les numéros des noeuds et des mailles +# Pour ajouter des Noeuds + # Coordonnées + LesNoeudsEnPlus = NP.array([[xx,yy,zz]]) + LesNoeudsEnPlus = NP.concatenate((LesNoeudsEnPlus,NP.array([[xx,yy,zz]]))) + # Noms + NomNoeudsEnPlus = ['X%' % in] + NomNoeudsEnPlus.append('X%' % in) +# Ajout des noeuds au maillage : coordonnées , noms + mm.cn = NP.concatenate((mm.cn,LesNoeudsEnPlus)) + mm.correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus ) + +# Pour ajouter des mailles (ici TRIA3) in [ 1 , NbMailleAjouté ] + # Noms + NomMaillesEnPlus = ['Z%d' % im] + NomMaillesEnPlus.append('Z%d' % im) + # Numéro des mailles + num_maille = [ nbma + im ] + num_maille.append( nbma + im ) + # Noeuds des mailles + NoeudsMailles = [NP.array([i1,i2,i3])] + NoeudsMailles.append(NP.array(NP.array([i1,i2,i3]))) +# Ajout des TRIA3 + # Type de maille + typ_maille = mm.dic['TRIA3'] + mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*NbMailleAjouté))) + # Nom des mailles + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + # connectivite des éléments + mm.co += NoeudsMailles + +# Ajout d'un groupe de maille contenant les mailles ajoutés + maillage_python.gma['XXXAJOUT'] = NP.array(num_maille) + +# Ecriture dans un fichier, et transfert dans l'espace Aster + unite = mm.ToAster() + mail = LIRE_MAILLAGE(UNITE=unite) + """ + + def __init__(self, nno=0, nma=0, ndim=None) : + self.ndim = ndim + if ndim is None: + # on initialise le tableau au plus grand + ndim = 3 + self.cn = NP.zeros((nno, ndim), dtype=int) + self.tm = NP.zeros(nma, dtype=int) + self.co = CONNEC(nma) + self.gma = {} + self.gno = {} + self.indice_noeuds = NP.arange(nno) + + self.correspondance_noeuds = [] + self.correspondance_mailles = [] + + try: + import aster + nom_mailles = (None,) + string.strip(aster.getvectjev('&CATA.TM.NOMTM')) + except: + nom_mailles = (None, + 'POI1', 'SEG2', 'SEG22', 'SEG3', 'SEG33', 'SEG4', 'TRIA3', + 'TRIA33', 'TRIA6', 'TRIA66', 'TRIA7', 'QUAD4', 'QUAD44', 'QUAD8', + 'QUAD88', 'QUAD9', 'QUAD99', 'TETRA4', 'TETRA10','PENTA6', 'PENTA15', + 'PYRAM5', 'PYRAM13','HEXA8', 'HEXA20', 'HEXA27', 'TR3QU4', 'QU4TR3', + 'TR6TR3', 'TR3TR6', 'TR6QU4', 'QU4TR6', 'TR6QU8', 'QU8TR6', 'TR6QU9', + 'QU9TR6', 'QU8TR3', 'TR3QU8', 'QU8QU4', 'QU4QU8', 'QU8QU9', 'QU9QU8', + 'QU9QU4', 'QU4QU9', 'QU9TR3', 'TR3QU9', 'SEG32', 'SEG23' ) + + dic_mailles = {} + for i in range(len(nom_mailles)) : + dic_mailles[nom_mailles[i]] = i + + self.nom = nom_mailles + self.dic = dic_mailles + + try: + psyco.bind(self.FromAster) + except: pass + +# ------------------------------------------------------------- + def get_connexite(self, nom, nma): + co=CONNEC(nma) + dico_connexite = aster.getcolljev(nom) + for element in dico_connexite.keys() : + co[int(element)-1] = (NP.array(dico_connexite[element])-1) + return co + + def get_coordonnees_noeuds(self, nom, nombre_noeuds): + assert self.ndim != None, """Dimension réelle du maillage non initialisée.""" + lcoord = aster.getvectjev(nom) + coordonnees_noeuds = NP.array(lcoord) + nno = len(coordonnees_noeuds) / 3 + assert nno == nombre_noeuds, """Données incohérentes.""" + coordonnees_noeuds.shape = (nno, 3) + cn = coordonnees_noeuds[:, :self.ndim] + return cn + +# ------------------------------------------------------------- + def init_dimension(self, ndim): + """Initialise la dimension du maillage.""" + if self.ndim is None: + self.ndim = ndim + assert ndim == self.ndim, """Il est interdit de modifier la dimension du maillage !""" + +# ------------------------------------------------------------- + def FromAster(self,nom) : + # On accepte le concept Aster ou bien la chaine texte de son nom + if type(nom)!=types.StringType: + nom_maillage = nom.nom + else: + nom_maillage = nom + nom_maillage=string.ljust(nom_maillage,8) + + # recuperation de la taille + self.dime_maillage = aster.getvectjev(nom_maillage+'.DIME') + nombre_noeuds = self.dime_maillage[0] + nombre_mailles = self.dime_maillage[2] + ndim = self.dime_maillage[5] + self.init_dimension(ndim) + + # coordonnees des noeuds + self.cn = self.get_coordonnees_noeuds(nom_maillage+'.COORDO .VALE', nombre_noeuds) + + # type de maille + self.tm = NP.array(aster.getvectjev(nom_maillage+'.TYPMAIL')) + + # connexite + self.co = self.get_connexite(nom_maillage+'.CONNEX', nombre_mailles) + + self.indice_noeuds=NP.arange(nombre_noeuds) + + # groupe de noeuds + Lno_groupno_tot = aster.getcolljev(nom_maillage+'.GROUPENO') + + Lno_groupno={} + for key in Lno_groupno_tot : + # Tolerance car parfois defi_group crée des groupes nuls à clé entiere + try: + Lno_groupno[key.strip()]=NP.array(Lno_groupno_tot[key])-1 + except: + pass + self.gno=Lno_groupno + + # groupe de mailles + Lma_groupma_tot = aster.getcolljev(nom_maillage+'.GROUPEMA') + Lma_groupma={} + for key in Lma_groupma_tot : + Lma_groupma[key.strip()]=NP.array(Lma_groupma_tot[key])-1 + self.gma=Lma_groupma + + del(Lma_groupma_tot) + + # listes de correspondance entre Aster et Mail-Py + self.correspondance_noeuds = aster.getvectjev(nom_maillage+'.NOMNOE') + self.correspondance_mailles = aster.getvectjev(nom_maillage+'.NOMMAI') + +# ------------------------------------------------------------- + def ToAster(self,unite=None): + from Utilitai.UniteAster import UniteAster + try: + LIRE_MAILLAGE = self.jdc.get_cmd('LIRE_MAILLAGE') + except: + try: + from Cata.cata import LIRE_MAILLAGE + except: + print "Il faut lancer ce programme depuis Aster pour pouvoir générer un maillage Aster." + sys.exit() + + UL = UniteAster() + # Récupération d'une unité logique libre si besoin + if ( unite == None ): unite = UL.Libre(action='ASSOCIER') + fichier = UL.Nom(unite) + # Bascule le fichier en F : ferme + UL.Etat(unite,etat='F') + # Ouverture du fichier en WRITE + f = open(fichier, 'w') + # Sauvegarde du maillage dans le fichier + f.write( self.Voir_Mail() ) + f.close() + # Remet les unités comme au debut + UL.EtatInit() + + return unite + +# ------------------------------------------------------------- + def __str__(self) : + return self.Voir_Mail() + +# ------------------------------------------------------------- + def Voir_Mail(self) : + """ + Impression au format ASTER + """ + l = [] + l.append('TITRE') + l.append('% CLASSE PY_MAIL -> MAIL') + l.append('FINSF') + l.append('%') + + (nno,ndim) = self.cn.shape + self.init_dimension(ndim) + + # Coordonnees des noeuds + l.append('COOR_%sD' % ndim) + + # format des nombres : 21.14E ==> -3.00000000000002D-04 + # longueur d'une ligne : 8 + (2 + 21)*3 = 77 + fmt = ' '.join(["%21.14E"] * ndim) + # Si le maillage initial ne provient pas d'Aster + if len(self.correspondance_noeuds) == 0: + for i in range(nno) : + ch = fmt % tuple([self.cn[i, k] for k in range(ndim)]) + l.append("%-8s %s" % ('N'+repr(i), ch)) + + # Si le maillage initial provient d'Aster + else: + for i in range(nno) : + ch = fmt % tuple([self.cn[i, k] for k in range(ndim)]) + l.append("%-8s %s" % (self.correspondance_noeuds[i], ch)) + + # Connectivité des mailles + ind = range(len(self.tm)) + ty = 0 + # Si le maillage initial ne provient pas d'Aster + if len(self.correspondance_mailles) == 0: + for m in ind : + if self.tm[m] <> ty : + l.append('FINSF') ; l.append('%') + ty = self.tm[m] + l.append(self.nom[ty]) + ch = 'M%d ' % m + for n in self.co[m] : + zn = ' N%d'% n + if ( len(ch)+len(zn) > 80 ): + l.append(ch) + ch = ' ' + zn + else: + ch += zn + l.append(ch) + + # Si le maillage initial provient d'Aster + else: + for m in ind : + if self.tm[m] <> ty : + l.append('FINSF') ; l.append('%') + ty = self.tm[m] + l.append(self.nom[ty]) + ch = self.correspondance_mailles[m]+' ' + for n in self.co[m] : + zn = ' ' + self.correspondance_noeuds[n] + if ( len(ch)+len(zn) > 80 ): + l.append(ch) + ch = ' ' + zn + else: + ch += zn + l.append(ch) + l.append('FINSF') ; l.append('%') + + + # Group_ma et Group_no + entete = ['GROUP_MA','GROUP_NO'] + d_gp = [self.gma,self.gno] + pref = ['M','N'] + + # Si le maillage initial ne provient pas d'Aster + if len(self.correspondance_mailles) == 0: + for (d_gp,entete,prefixe) in [(self.gma,'GROUP_MA','M'),(self.gno,'GROUP_NO','N')] : + for gp in d_gp : + if len(d_gp[gp])>0: # On ne prend en compte que les group_* non vides + l.append(entete) + l.append(' ' + gp) + ch = '' + for o in d_gp[gp]: + zm = ' %s%d' % (prefixe , o) + if ( len(ch)+len(zm) > 80 ): + l.append(ch) + ch = zm + else: + ch += zm + l.append(ch) + l.append('FINSF') ; l.append('%') + + # Si le maillage initial provient d'Aster + else: + for (d_gp,entete,prefixe) in [(self.gma,'GROUP_MA','M'),(self.gno,'GROUP_NO','N')] : + for gp in d_gp : + if len(d_gp[gp])>0: # On ne prend en compte que les group_* non vides + l.append(entete) + l.append(' ' + gp) + ch = '' + for o in d_gp[gp]: + if prefixe=='M': + zm = ' ' + self.correspondance_mailles[o] + else: + zm = ' ' + self.correspondance_noeuds[o] + if ( len(ch)+len(zm) > 80 ): + l.append(ch) + ch = zm + else: + ch += zm + l.append(ch) + l.append('FINSF') ; l.append('%') + + # Fin + l.extend(['FIN', '']) + return os.linesep.join(l) + + +# ============================================================================ # +class PARTITION: + + def __init__(self, jdc=None ,nb=0): + + self.jdc = jdc + + self.fichier_out = '' + self.liste_mailles = NP.array( [] ) + self.liste_sd = NP.array( [] ) + self.liste_mailles_bord = [] + self.liste_sd_bord = [] + + self.MAILLAGE_Python = None + + self.RELATIONS = { 'C_plus' : None, + 'C_moins': None, + 'nr': 0 } + + self.ASTER = { 'MAILLAGE' : None, + 'MODELE' : None, + 'GROUP_MA' : None, + 'GROUP_MA_BORD' : None, + 'DICO_SD_MAILLES' : None, + } + + self.OPTIONS = { 'NB_PART' : '', + 'ALGO' : '', + 'INFO' : '', + 'rep_metis' : aster.repout(), + 'exe_metis' : aster.repout() + 'pmetis', + 'fichier_in' : 'fort.66', + 'fichier_out' : 'fort.68', + 'elimine_bords': 'OUI', + } + + self.Creation_Dico_Correspondance_Type_Maille() + + + +# ---------------------------------------------------------------------------- # + + def __str__(self) : + """ + Impression du contenu de la partition + """ + l = [] + l.append( 'Contenu de la partition :' ) + l.append( '-------------------------' ) + try: l.append( '- Maillage : ' + str(self.ASTER['MAILLAGE'].nom) ) + except: pass + try: l.append( '- Modele : ' + str(self.ASTER['MODELE'].nom) ) + except: pass + l.append( '- Nb part : ' + str(self.OPTIONS['NB_PART']) ) + l.append( '- Niveau INFO : ' + str(self.OPTIONS['INFO']) ) + l.append( '- Liste group_ma : ' + str(self.ASTER['GROUP_MA']) ) + + return string.join(l,'\n') + +# ---------------------------------------------------------------------------- # + + def Partitionne_Aster(self, MAILLAGE, NB_PART, MODELE=None, METHODE=None, LOGICIEL=None, INFO=1): + + self.t00 = time.clock() + + self.OPTIONS['INFO'] = INFO + + if MODELE: + # Recuperation de la liste des mailles à perndre en compte + self.ASTER['MODELE'] = MODELE + self.ASTER['MAILLAGE'] = MAILLAGE + _LST_MA = self.Modele_to_Liste_Mailles(MODELE) + + elif MAILLAGE: + self.ASTER['MAILLAGE'] = MAILLAGE + _LST_MA = None + + + # Creation du maillage Python correspondant au maillage Aster + MAILLAGE_Python = MAIL_PY() + MAILLAGE_Python.FromAster(MAILLAGE.nom) + + # Partitionne le maillage Python avec la liste de mailles _LST_MA + self.Partitionne_Maillage(MAILLAGE_Python, NB_PART, MAILLE=_LST_MA, METHODE=METHODE, LOGICIEL=LOGICIEL, INFO=INFO) + + return + + +# ---------------------------------------------------------------------------- # + + def Partitionne_Maillage(self, MAILLAGE_Python, NB_PART, MAILLE=None, METHODE=None, LOGICIEL=None, INFO=1): + + self.t00 = time.clock() + + if METHODE: + self.OPTIONS['exe_metis'] = aster.repout() + string.lower(METHODE) + elif LOGICIEL: + self.OPTIONS['exe_metis'] = LOGICIEL + + self.OPTIONS['NB_PART'] = NB_PART + self.OPTIONS['INFO'] = INFO + self.MAILLAGE_Python = MAILLAGE_Python + + exe_metis = self.OPTIONS['exe_metis'] + f_metis = self.OPTIONS['fichier_in'] + fw_metis = self.OPTIONS['fichier_out'] + + _LST_MA = MAILLE + + # On initialise la connectivité et la connectivité inverse des aretes + self.MAILLAGE_Python.ca = {} + self.MAILLAGE_Python.cia = {} + + _DIM = self.MAILLAGE_Python.dime_maillage[5] + _LST_TMA = self.MAILLAGE_Python.tm + + if self.OPTIONS['INFO']>=5: + print 'cn=', self.MAILLAGE_Python.cn + print 'tm=', self.MAILLAGE_Python.tm + print 'co=', self.MAILLAGE_Python.co + print 'gma=', self.MAILLAGE_Python.gma + print 'gno=', self.MAILLAGE_Python.gno + print 'dim=', self.MAILLAGE_Python.dime_maillage + if self.OPTIONS['INFO']>=5: print '_LST_MA=', _LST_MA + + + # Elimination des mailles de bords + if self.OPTIONS['elimine_bords']!='NON': + + # Liste des mailles à prendre en compte : dimension _DIM + _D_DIM_MAILLES = self.Creation_Listes_Mailles_Par_Dim(self.MAILLAGE_Python.tm, _LST_MA=_LST_MA) + + # Connectivité et connectivité inverse sur les bords + self.Connectivite_Aretes() + + self.liste_mailles = _D_DIM_MAILLES[ _DIM ] + + # Pour prendre en compte des mélanges d'elements de dimension differente + _LST, _LST_BD = self.Elimination_Mailles_de_bords(MAILLAGE_Python, _D_DIM_MAILLES, _DIM) + self.liste_mailles = NP.concatenate( (self.liste_mailles,NP.array(_LST)) ) + + if self.OPTIONS['INFO']>=5: + print '_LST_BD=',_LST_BD + print '_LST=',_LST + + else: + self.liste_mailles = _LST_MA + + + # Restriction des connectivités aux mailles à prendre en compte + self.Connectivite_Aretes(OPTION='all', _LST_OK=self.liste_mailles) + + # Creation de l'arbre de connectivité des bords + self.Creation_Graphe() + + # Reduction de l'arbre de connectivité des bords + _nb = self.Reduction_Graphe(_DIM) + + # Ecriture du fichier pour Metis/Chaco/Jostle + _D_CORRES = self.Ecrire_Graphe(f_metis, _nb) + + # Lancement de metis sur le fichier fort.UL (production de fort.UL.part.N) + txt = exe_metis + ' ' + f_metis + ' ' + str(NB_PART) + print 'Commande : ',txt + os.system( txt ) + + # Lecture du fichier resultant de Metis + self.fichier_out = f_metis + '.part.' + str(NB_PART) + self.liste_sd = self.Lecture_fichier_sdd(self.fichier_out, self.liste_mailles) + + # Traitement des mailles de bords (on les reinjecte dans un SD) + if self.OPTIONS['elimine_bords']!='NON': + self.Affectation_Mailles_de_bords(_LST_BD, _DIM) + + t1 = time.clock() + print "--- FIN PARTITIONNEMENT : ", t1 - self.t00 + + return + + + +# ---------------------------------------------------------------------------- # + + def Creation_Dico_Correspondance_Type_Maille(self): + + # TYPE_ELEM : CF. &CATA.TM + # 1 - >POI1 <>SEG2 <>SEG22 <>SEG3 <>SEG33 <>SEG4 <>TRIA3 < + # 8 - >TRIA33 <>TRIA6 <>TRIA66 <>TRIA7 <>QUAD4 <>QUAD44 <>QUAD8 < + # 15 - >QUAD88 <>QUAD9 <>QUAD99 <>TETRA4 <>TETRA10 <>PENTA6 <>PENTA15 < + # 22 - >PYRAM5 <>PYRAM13 <>HEXA8 <>HEXA20 <>HEXA27 <>TR3QU4 <>QU4TR3 < + # 29 - >TR6TR3 <>TR3TR6 <>TR6QU4 <>QU4TR6 <>TR6QU8 <>QU8TR6 <>TR6QU9 < + # 36 - >QU9TR6 <>QU8TR3 <>TR3QU8 <>QU8QU4 <>QU4QU8 <>QU8QU9 <>QU9QU8 < + # 43 - >QU9QU4 <>QU4QU9 <>QU9TR3 <>TR3QU9 <>SEG32 <>SEG23 < + + # Creation du dictionnaire des correspondance type_maille -> liste des aretes + maille2aretes={} + # POI + maille2aretes[1] = [ ] + # SEG + maille2aretes[2] = [ (0,1) ] + maille2aretes[3] = maille2aretes[4] = maille2aretes[5] = maille2aretes[6] = maille2aretes[2] + # TRIA + maille2aretes[7] = [ (0,1),(1,2),(0,2) ] + maille2aretes[8] = maille2aretes[9] = maille2aretes[10] = maille2aretes[11] = maille2aretes[7] + # QUAD + maille2aretes[12] = [ (0,1),(1,2),(2,3),(0,3) ] + maille2aretes[13] = maille2aretes[14] = maille2aretes[15] = maille2aretes[16] = maille2aretes[17] = maille2aretes[12] + # TETRA + maille2aretes[18] = [ (0,1,2),(0,1,3),(0,2,3),(1,3,2) ] + maille2aretes[19] = maille2aretes[18] + # PENTA + maille2aretes[20] = [ (0,1,2),(3,4,5),(0,2,5,3),(0,1,4,3),(2,1,4,5) ] + maille2aretes[21] = maille2aretes[20] + # PYRAM + maille2aretes[22] = [ (0,1,4),(1,2,4),(2,3,4),(3,0,4),(0,1,2,3) ] + maille2aretes[23] = maille2aretes[22] + # HEXA + maille2aretes[24] = [ (0,1,2,3), (4,5,6,7), (1,2,6,5), (2,3,7,6), (7,4,0,3), (4,5,1,0) ] + maille2aretes[25] = maille2aretes[26] = maille2aretes[24] + + + # dictionnaire de correspondance entre type_maille -> nb noeud (maille linéaire) + maille2nb={} + # POI + maille2nb[1] = 1 + # SEG + maille2nb[2] = 2 + maille2nb[3] = maille2nb[4] = maille2nb[5] = maille2nb[6] = maille2nb[2] + # TRIA + maille2nb[7] = 3 + maille2nb[8] = maille2nb[9] = maille2nb[10] = maille2nb[11] = maille2nb[7] + # QUAD + maille2nb[12] = 4 + maille2nb[13] = maille2nb[14] = maille2nb[15] = maille2nb[16] = maille2nb[17] = maille2nb[12] + # TETRA + maille2nb[18] = 4 + maille2nb[19] = maille2nb[18] + # PENTA + maille2nb[20] = 5 + maille2nb[21] = maille2nb[20] + # PYRAM + maille2nb[22] = 5 + maille2nb[23] = maille2nb[22] + # HEXA + maille2nb[24] = 6 + maille2nb[25] = maille2nb[26] = maille2nb[24] + + + # dictionnaire de correspondance entre type_maille -> dimension + maille2dim = {} + # POI + maille2dim[1] = 0 + # SEG + maille2dim[2] = 1 + maille2dim[3] = maille2dim[4] = maille2dim[5] = maille2dim[6] = maille2dim[2] + # TRIA + maille2dim[7] = 2 + maille2dim[8] = maille2dim[9] = maille2dim[10] = maille2dim[11] = maille2dim[7] + # QUAD + maille2dim[12] = 2 + maille2dim[13] = maille2dim[14] = maille2dim[15] = maille2dim[16] = maille2dim[17] = maille2dim[12] + # TETRA + maille2dim[18] = 3 + maille2dim[19] = maille2dim[18] + # PENTA + maille2dim[20] = 3 + maille2dim[21] = maille2dim[20] + # PYRAM + maille2dim[22] = 3 + maille2dim[23] = maille2dim[22] + # HEXA + maille2dim[24] = 3 + maille2dim[25] = maille2dim[26] = maille2dim[24] + + # On stocke les dictionnaires + self.maille2aretes = maille2aretes + self.maille2nb = maille2nb + self.maille2dim = maille2dim + + return + + +# ---------------------------------------------------------------------------- # + + def Modele_to_Liste_Mailles(self, MODELE): + + nommod = string.ljust(MODELE.nom,8) + _DIC_MA = aster.getcolljev(nommod.ljust(8)+'.MODELE .LIEL') + + # Creation de la liste des mailles + ll = [] + for type_maille in _DIC_MA.keys(): + ll.extend( _DIC_MA[type_maille][0:-1] ) + _LST_MA = NP.array( ll ) - 1 + + if self.OPTIONS['INFO']>=5: + print '\n# ----- MODELE ----- #\n' + print '_LST_MA=',len(_LST_MA),_LST_MA + print '_DIC_MA=',len(_DIC_MA),_DIC_MA + + return _LST_MA + + +# ---------------------------------------------------------------------------- # + + def Creation_Listes_Mailles_Par_Dim(self, _LST_TMA, _LST_MA=None): + + t0 = time.clock() + + # Si _LST_MA est renseigné on extrait la liste des TMA correspondante aux mailles de _LST_MA + if _LST_MA != None: + _LST_TMA = NP.take(_LST_TMA,_LST_MA) + else: + _LST_MA = NP.arange(len(_LST_TMA)) + + _D_DIM_MAILLES = {} + + # Liste des mailles 3D (type maille de 18 à 26) + _lst = NP.where( _LST_TMA>=18, -3, _LST_TMA ) + _tmp = NP.where( _lst==-3, -1, 0 ) +# _D_DIM_MAILLES[3] = NP.nonzero( _tmp ) + _D_DIM_MAILLES[3] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] ) + + # Liste des mailles 2D (type maille de 7 à 17) + _lst = NP.where( _lst>=7, -2, _lst ) + _tmp = NP.where( _lst==-2, -1, 0 ) + _D_DIM_MAILLES[2] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] ) + + # Liste des mailles 1D (type maille de 2 à 6) + _lst = NP.where( _lst>=2, -1, _lst ) + _tmp = NP.where( _lst==-1, -1, 0 ) + _D_DIM_MAILLES[1] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] ) + + # Liste des mailles 0D (type maille 1) + _lst = NP.where( _lst>=1, -4, _lst ) + _tmp = NP.where( _lst==-4, -1, 0 ) + _D_DIM_MAILLES[0] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] ) + + + if self.OPTIONS['INFO']>=5: + for i in _D_DIM_MAILLES.keys(): + print "-----------------" + print 'Dim:',i, _D_DIM_MAILLES[i] + print "-----------------" + + print "--- FIN Creation des listes de mailles par Dim : ", time.clock() - t0 + + return _D_DIM_MAILLES + + +# ---------------------------------------------------------------------------- # + + def Connectivite_Aretes(self, OPTION=None, _LST_OK=None): + + t0 = time.clock() + + # Si _LST_OK n'est pas renseigné on prend toutes les mailles + if not _LST_OK: _LST_OK = NP.arange(len(self.MAILLAGE_Python.tm)) + + if self.OPTIONS['INFO']>=5: print '_LST_OK (ca)=',_LST_OK + + maille2aretes = self.maille2aretes + + # Creation de la : + # - connectivite des aretes (self.MAILLAGE_Python.ca) : m1 -> [ (a1, a2), .. ] + # - connectivite inverse des aretes (self.MAILLAGE_Python.cia) : (a1, a2) -> [ m1, m2, ... ] + + self.MAILLAGE_Python.ca = {} + self.MAILLAGE_Python.cia = {} + + for n in _LST_OK: + + n1 = self.MAILLAGE_Python.tm[n] + + l_aretes = maille2aretes[n1] # liste des aretes de la maille n + l_noeuds = self.MAILLAGE_Python.co[n] # liste des noeuds de la maille n + + for arete in l_aretes: + ll = [] + for i in arete: + ll.append( l_noeuds[i] ) + ll.sort() + ll = tuple(ll) + + # Table de connectivité des aretes + if OPTION: + if not self.MAILLAGE_Python.ca.has_key(n): self.MAILLAGE_Python.ca[n]=[] + self.MAILLAGE_Python.ca[n].append(ll) +# try: +# self.MAILLAGE_Python.ca[n].append(ll) +# except KeyError: +# self.MAILLAGE_Python.ca[n]=[ll] + + # Table de connectivité inverse des aretes + if not self.MAILLAGE_Python.cia.has_key(ll): self.MAILLAGE_Python.cia[ll]=[] + self.MAILLAGE_Python.cia[ll].append(n) +# try: +# self.MAILLAGE_Python.cia[ll].append(n) +# except KeyError: +# self.MAILLAGE_Python.cia[ll]=[n] + + + if self.OPTIONS['INFO']>=5: + for k in self.MAILLAGE_Python.cia.keys(): + print 'cia:',k, ' ', self.MAILLAGE_Python.cia[k] + if OPTION: + for k in self.MAILLAGE_Python.ca.keys(): + print 'ca: ',k, ' ', self.MAILLAGE_Python.ca[k] + + + print "--- FIN Creation de la connectivite simple et inverse des aretes : ", time.clock() - t0 + + return + + +# ---------------------------------------------------------------------------- # + + def Elimination_Mailles_de_bords(self, MAILLAGE_Python, _D_DIM_MAILLES, _DIM): + """ + Extraction des mailles de bords (mailles incluses dans un bord d une autre maille) + """ + + t0 = time.clock() + + _LST_TMA = self.MAILLAGE_Python.tm + + if self.OPTIONS['INFO']>=5: + MAILLAGE = self.ASTER['MAILLAGE'] + nommail = string.ljust(MAILLAGE.nom,8) + _LST_MAI = aster.getvectjev(nommail.ljust(8)+'.NOMMAI') + + # Le dico maille2nb donne le nombre de noeuds definissant un bord (lineaire) + maille2nb = self.maille2nb + + + # construction des listes des mailles de dim N-1 : + # _LST_OK : Mailles de dim N-i qui ne sont pas un bord des mailles de dim N + # _LST_BD : Mailles de dim N-i qui sont un bord + # + if self.OPTIONS['INFO']>=5: print '\n\nElimination des mailles de bord de DIM', _DIM - 1 + + _LST4 = _D_DIM_MAILLES[ _DIM - 1 ] + _LST_IND = NP.arange( len(_LST4) ) + 1 # on ajoute 1 pour eviter le premier 0 dans les test nonzero plus bas + + if self.OPTIONS['INFO']>=5: print ' Mailles concernées=',_LST4 + + i=0 + for m in _LST4: + if self.OPTIONS['INFO']>=5: print '\n Maille de dim N-1:',m, ' Aster:',string.strip(_LST_MAI[m]), ' TMA:',self.MAILLAGE_Python.tm[m], ' CO:',self.MAILLAGE_Python.co[m], '(noeuds de cette maille)' + nb = maille2nb[ self.MAILLAGE_Python.tm[m] ] + ll = self.MAILLAGE_Python.co[m][0:nb] + ll = NP.sort(ll) + ll = ll.tolist() + ll = tuple(ll) + if self.OPTIONS['INFO']>=5: print ' Bord (lineaire)', ll, nb + + try: + if self.OPTIONS['INFO']>=5: print ' CIA=', self.MAILLAGE_Python.cia[ ll ], '(mailles de dim N qui ont cette maille pour bord)' + _tmp=[] + for maille in self.MAILLAGE_Python.cia[ ll ]: + if self.OPTIONS['INFO']>=5: print ' Maille N:', maille, 'Aster:', string.strip(_LST_MAI[maille]), ' TMA:', self.MAILLAGE_Python.tm[maille] +# self.liste_mailles_bord.append(m) + except: + if self.OPTIONS['INFO']>=5: print ' Maille non-bord' + _LST_IND[i] = 0 + + i+=1 + + # Recuperation des mailles de bords et non-bords + _LST_BD = NP.nonzero(_LST_IND)[0] + _LST_BD = NP.take(_LST4,_LST_BD) + + _LST_OK = NP.where( _LST_IND==0, 1 , 0 ) + _LST_OK = NP.nonzero(_LST_OK)[0] + _LST_OK = NP.take(_LST4,_LST_OK) + + if self.OPTIONS['INFO']>=5: print '\nListe Maille de bords de DIM', _DIM - 1,' :',_LST_BD + if self.OPTIONS['INFO']>=5: print 'Liste Maille de DIM', _DIM - 1,'qui ne sont pas des bords :',_LST_OK + + print "--- FIN Maille de bords de DIM",_DIM - 1, " : ", time.clock() - t0 + t0 = time.clock() + + + # On cherche à marier les mailles de dimension N-2, N-3 + # Peut etre lent car on utilise la connectivité ! Mais pour le moment on a rien d'autre. + + _LST_BD0 = [] + _LST_OK0 = [] + _D_BD = {} + for d in range(_DIM-1): + _LST4 = _D_DIM_MAILLES[ d ] + if self.OPTIONS['INFO']>=5: print '\n\nElimination des mailles de bord de DIM', d + if self.OPTIONS['INFO']>=5: print ' Mailles concernées=',_LST4 + for mai in _LST4: + if self.OPTIONS['INFO']>=5: print '\n Maille:', mai, ' Aster:',string.strip(_LST_MAI[mai]), ' TMA:',self.MAILLAGE_Python.tm[mai], ' CO:',self.MAILLAGE_Python.co[mai], '(noeuds de cette maille)' + + nb = maille2nb[ self.MAILLAGE_Python.tm[mai] ] + ll = self.MAILLAGE_Python.co[mai][0:nb] + ll = NP.sort(ll) + ll = ll.tolist() + _tmp = tuple(ll) +# _tmp = self.MAILLAGE_Python.co[mai] + + if self.OPTIONS['INFO']>=5: print ' Bord (lineaire):', _tmp, nb + + ok=0 + for arete in self.MAILLAGE_Python.cia: + _nb=0 + for noe in _tmp: + if noe in arete: _nb+=1 + if _nb == len(_tmp): + if self.OPTIONS['INFO']>=5: print ' Maille N+i:', self.MAILLAGE_Python.cia[arete], '- Arete:', arete + _LST_BD0.append( mai ) + ok=1 +# if not _D_BD.has_key( mai ): _D_BD[mai] = [] +# _D_BD[mai].append( self.MAILLAGE_Python.cia[arete] ) + break + if ok == 0: + _LST_OK0.append( mai ) + +# print 'Mai:',mai, '_D_BD[mai]=',_D_BD[mai] + + + if self.OPTIONS['INFO']>=5: print '\nListe Maille de bords de DIM', d,' :',_LST_BD0 + if self.OPTIONS['INFO']>=5: print 'Liste Maille de DIM', d,'qui ne sont pas des bords :',_LST_OK0 + + + print '--- FIN Maille de bords de DIM', d, ' :',time.clock() - t0 + t0 = time.clock() + + + _LST_OK = NP.concatenate( (_LST_OK, NP.array(_LST_OK0)) ) + _LST_BD = NP.concatenate( (_LST_BD, NP.array(_LST_BD0)) ) + + if self.OPTIONS['INFO']>=5: print '\nTotal:\nListe Maille de bords=',_LST_BD + if self.OPTIONS['INFO']>=5: print 'Liste Maille non-bords=',_LST_OK,'\n' + +# print "--- FIN Maille de bords 3 : ", time.clock() - t0 + + return _LST_OK, _LST_BD + + +# ---------------------------------------------------------------------------- # + + def Affectation_Mailles_de_bords(self, _LST_BD, _DIM): + """ + Affectation a un SD des mailles de bords (mailles incluses dans un bord d une autre maille) + """ + + if self.OPTIONS['INFO']>=5: + print 'liste_mailles_bord=', self.liste_mailles_bord + print 'liste_sd_bord', self.liste_sd_bord + print '_LST_BD=',_LST_BD + + + MAILLAGE = self.ASTER['MAILLAGE'] + _LST_TMA = self.MAILLAGE_Python.tm + + if self.OPTIONS['INFO']>=5: + nommail = string.ljust(MAILLAGE.nom,8) + _LST_MAI = aster.getvectjev(nommail.ljust(8)+'.NOMMAI') + + t0 = time.clock() + + # Affectation des mailles de bords à chacun des SD + + # Le dico maille2nb donne le nombre de noeuds definissant un bord (lineaire) + maille2nb = self.maille2nb + + i = 0 + for m in _LST_BD: + if self.OPTIONS['INFO']>=5: print '\n Maille de dim N-1:',m, ' Aster:',string.strip(_LST_MAI[m]), ' TMA:',self.MAILLAGE_Python.tm[m], ' CO:',self.MAILLAGE_Python.co[m], '(noeuds de cette maille)' + nb = maille2nb[ self.MAILLAGE_Python.tm[m] ] + ll = self.MAILLAGE_Python.co[m][0:nb] + ll = NP.sort(ll) + ll = ll.tolist() + ll = tuple(ll) + if self.OPTIONS['INFO']>=5: print ' Bord (lineaire)', ll, nb + + # Cas particulier des POI1 en 2D et 3D (ils ne peuvent etre des bords d'elements 2D ou 3D) + if ( (nb==1) and (_DIM>=2) ): + _tmp=[] + for arete in self.MAILLAGE_Python.cia.keys(): + if ll[0] in arete: + for maille in self.MAILLAGE_Python.cia[ arete ]: + if self.OPTIONS['INFO']>=5: print ' Maille N+i:', maille, ' Aster:',string.strip(_LST_MAI[maille]), ' Arete:', arete + _tmp.append( self.liste_sd[maille] ) + + # Cas particulier des SEG en 3D (ils ne peuvent etre des bords d'elements 3D) + elif ( (nb==2) and (_DIM==3) ): + _tmp=[] + for arete in self.MAILLAGE_Python.cia.keys(): + _nb=0 + for noe in ll: + if noe in arete: _nb+=1 + if _nb == len(ll): + for maille in self.MAILLAGE_Python.cia[arete]: + if self.OPTIONS['INFO']>=5: print ' Mailles N+i:', maille, ' Aster:',string.strip(_LST_MAI[maille]), ' Arete:', arete + _tmp.append( self.liste_sd[maille] ) + + # Autres mailles de bord + else: + if self.OPTIONS['INFO']>=5: print ' CIA=', self.MAILLAGE_Python.cia[ ll ], '(mailles de dim N qui ont cette maille pour bord)' + _tmp=[] + for maille in self.MAILLAGE_Python.cia[ ll ]: + if self.OPTIONS['INFO']>=5: print ' Maille N+i:', maille, 'Aster:', string.strip(_LST_MAI[maille]), ' SD:', self.liste_sd[maille], ' TMA:', self.MAILLAGE_Python.tm[maille] + _tmp.append( self.liste_sd[maille] ) + + # integre la maille au SD le plus faible (pour que des groupes de bords se retrouvent dans le meme SD) + _tmp.sort() + self.liste_mailles_bord.append(m) + self.liste_sd_bord.append( _tmp[0] ) + i += 1 + if self.OPTIONS['INFO']>=5: print ' ---> Maille:',m,'integree au SD:', _tmp[0] + + if self.OPTIONS['INFO']>=5: + print '\n\nliste_mailles_bord=', self.liste_mailles_bord + print 'liste_sd_bord=', self.liste_sd_bord + + + print "--- FIN Affectation des mailles de bords : ", time.clock() - t0 + + return + + +# ---------------------------------------------------------------------------- # + + def Creation_Graphe(self): + + t0 = time.clock() + + # Creation du graphe complet + self.GRAPH = {} + + for mai in self.liste_mailles: + _ll=[] + for are in self.MAILLAGE_Python.ca[mai]: + _ll.extend( self.MAILLAGE_Python.cia[are] ) + _mm = enleve_doublons_liste(_ll) # coute cher! + _tmp = _mm.tolist() + _tmp.remove(mai) + self.GRAPH[mai] = _tmp + + if self.OPTIONS['INFO']>=5: print 'self.GRAPH['+str(mai)+']=', self.GRAPH[mai] + + print "--- FIN Creation du graphe complet : ", time.clock() - t0 + + return + + +# ---------------------------------------------------------------------------- # + + def Reduction_Graphe(self, _DIM): + + t0 = time.clock() + + # Elimination des connectivités à interface nulle + maille2dim = self.maille2dim + _lst2 = [] + for mai in self.liste_mailles: + if self.OPTIONS['INFO']>=5: print '\nmai:', mai, 'co:', self.MAILLAGE_Python.co[mai], 'tm:', self.MAILLAGE_Python.tm[mai] + _DIM1 = maille2dim[ self.MAILLAGE_Python.tm[mai] ] + _tmp2 =[] + for mai2 in self.GRAPH[mai]: + if self.OPTIONS['INFO']>=5: print 'mai2:', mai2, 'co:', self.MAILLAGE_Python.co[mai2], 'tm:', self.MAILLAGE_Python.tm[mai2] + # calcule le nombre de noeuds communs aux deux mailles + _nb = 0 + for noe in self.MAILLAGE_Python.co[mai2]: + if noe in self.MAILLAGE_Python.co[mai]: _nb += 1 + _DIM2 = maille2dim[ self.MAILLAGE_Python.tm[mai2] ] + if _nb >= min(_DIM1, _DIM2): # le min permet de faire du collage 3D-coque par exemple + _tmp2.append( mai2 ) + _tmp = [mai, mai2] + _tmp.sort() + _lst2.append(_tmp) + self.GRAPH[mai] = _tmp2 + + print "--- FIN Elimination des connectivités avec une interface nulle : ", time.clock() - t0 + t0 = time.clock() + + + # Calcul du nombre d'aretes + # A voir : normalement il n'y a rien a faire car nb0 = 2*nb (a verifier...) + _lst2.sort() + _v = _lst2[0] + _nb = 1 + for i in _lst2: + if i != _v: + _v = i + _nb += 1 + + + if self.OPTIONS['INFO']>=5: + print '----------------------------------------------' + for mai in self.liste_mailles: + print 'self.GRAPH['+str(mai)+']=', self.GRAPH[mai] + print '----------------------------------------------' + + return _nb + + +# ------------------------------------------------------------------ # + + def Ecrire_Graphe(self, f_metis, _nb): + + t0 = time.clock() + + # On doit renumeroter les mailles qui arrivent dans self.liste_mailles pour avoir 0... N-1 + _D_CORRES = {} + for i in NP.arange(len(self.liste_mailles)): + _D_CORRES[ self.liste_mailles[i] ] = i + + # Ecriture du fichier fort.UL pour metis + fw = open(f_metis,'w') + fw.write( str(len(self.liste_mailles)) + ' ' + str(_nb) + '\n') + for l in self.liste_mailles: +# try: + _tmp = [] + for t in self.GRAPH[l]: + try: + t = _D_CORRES[t] + _tmp.append( str(t+1) ) # Necessaire car metis numerote de 1 à N + except: + print 'on oublie le bord:', t + fw.write( string.join(_tmp, ' ') + '\n' ) +# except: +# print 'Probleme ecriture graphe! On continue..' + fw.close() + + print "--- FIN Ecriture du fichier du graphe pour metis : ", time.clock() - t0 + + return _D_CORRES + + +# ---------------------------------------------------------------------------- # + + def Lecture_fichier_sdd(self, fichier, _LST_OK): + + t0 = time.clock() + + # Lecture du fichier produit par metis (partie a optimiser) + try: + f = open( fichier, 'r' ) + except: + print "\n\n ERREUR: le fichier est introuvable! Le partitionneur \n ne s'est probablement pas lancé.\n\n" + sys.exit(1) + else: + _tmp = [] + for l in f.readlines(): + _tmp.append( int(string.strip(l)) ) + f.close() + _l_domaines = NP.array(_tmp,copy=0) + + # Pour garder le fichier metis + os.system( 'mv ' + fichier + ' REPE_OUT/' ) + + if self.OPTIONS['INFO']>=5: print '_l_domaines=',_l_domaines + + print "--- FIN Lecture du fichier produit par metis : ", time.clock() - t0 + + return _l_domaines + + +# ---------------------------------------------------------------------------- # + + def Creation_Group_ma_Python_par_SD(self, NOM='SD', NOM2='B'): + + t0 = time.clock() + + NB_PART = self.OPTIONS['NB_PART'] + + # Creation du dictionnaire des listes des mailles par SD + # d_gma : { num sd -> [ liste mailles ] } + d_gma = {} + for i in range(NB_PART): + d_gma[i] = [] + + i=0 + for sdd in self.liste_sd: + d_gma[sdd].append( self.liste_mailles[i] ) + i+=1 + + + # Creation du dictionnaire des listes des mailles de bord par SD + # d_gma_bord : { num sd -> [ liste mailles ] } + d_gma_bord = {} + for i in range(NB_PART): + d_gma_bord[i] = [] + + i=0 + for sdd in self.liste_sd_bord: + d_gma_bord[sdd].append( self.liste_mailles_bord[i] ) + i+=1 + + + # Generation des listes de noms de groupes + _l_sd = [] + _l_bord = [] + for i in range(NB_PART): + if d_gma[i] != []: + _l_sd.append( NOM + str(i) ) + if d_gma_bord[i] != []: + _l_bord.append( NOM2 + str(i) ) + + # Stockage + self.ASTER['GROUP_MA'] = _l_sd + self.ASTER['GROUP_MA_BORD'] = _l_bord + + + # Creation des groupes de mailles dans le Maillage Python + for i in range(NB_PART): + self.MAILLAGE_Python.gma[NOM+str(i)] = d_gma[i] + self.MAILLAGE_Python.gma[NOM2+str(i)] = d_gma_bord[i] + + print "--- FIN creation du dictionnaire des listes des mailles par SD ", time.clock() - t0 + + return + + +# ---------------------------------------------------------------------------- # + + def Creation_Group_ma_Aster_par_SD(self, NOM='SD', NOM2='B', INCLUSE='NON'): + + t0 = time.clock() + + MAILLAGE = self.ASTER['MAILLAGE'] + NB_PART = self.OPTIONS['NB_PART'] + + nommail = string.ljust(MAILLAGE.nom,8) + _LST_MAI = aster.getvectjev(nommail.ljust(8)+'.NOMMAI') + + + # Creation du dictionnaire des listes des mailles par SD + # d_gma : { num sd -> [ liste mailles ] } + d_gma = {} + for i in range(NB_PART): + d_gma[i] = [] + + m=0 + for sdd in self.liste_sd: + d_gma[sdd].append( string.strip(_LST_MAI[ self.liste_mailles[m] ]) ) # voir si le strip coute cher ! + m += 1 + + + # Creation du dictionnaire des listes des mailles de bord par SD + # d_gma_bord : { num sd -> [ liste mailles ] } + d_gma_bord = {} + for i in range(NB_PART): + d_gma_bord[i] = [] + + # On inclus directement les mailles de bords dans les SD + if INCLUSE=='OUI': + m=0 + for sdd in self.liste_sd_bord: + d_gma[sdd].append( string.strip(_LST_MAI[ self.liste_mailles_bord[m] ]) ) # voir si le strip coute cher ! + m+=1 + + else: + m=0 + for sdd in self.liste_sd_bord: + d_gma_bord[sdd].append( string.strip(_LST_MAI[ self.liste_mailles_bord[m] ]) ) # voir si le strip coute cher ! + m+=1 + + + print "--- FIN creation du dictionnaire des listes des mailles par SD ", time.clock() - t0 + t0 = time.clock() + + + # Creation et lancement de la commande DEFI_GROUP associée + try: + DEFI_GROUP = self.jdc.get_cmd('DEFI_GROUP') + except: + try: + from Cata.cata import DEFI_GROUP + except: + print "\n\nERREUR : il faut lancer ce programme depuis Aster pour pouvoir \ngénérer les groupes de mailles Aster.\n\n" + return + + _tmp = [] + _l_sd = [] + _l_bord = [] + for i in range(NB_PART): + if d_gma[i] != []: + _tmp.append( {'MAILLE': d_gma[i],'NOM': NOM + str(i)} ) + _l_sd.append( NOM + str(i) ) + if d_gma_bord[i] != []: + _tmp.append( {'MAILLE': d_gma_bord[i],'NOM': NOM2 + str(i)} ) + _l_bord.append( NOM2 + str(i) ) + + motscle2= {'CREA_GROUP_MA': _tmp } + + DEFI_GROUP( reuse=MAILLAGE, + MAILLAGE=MAILLAGE, + INFO=1, + **motscle2 + ) ; + + # Stockage + self.ASTER['DICO_SD_MAILLES'] = d_gma + self.ASTER['GROUP_MA'] = _l_sd + self.ASTER['GROUP_MA_BORD'] = _l_bord + + print "--- FIN Creation et lancement de la commande DEFI_GROUP associée : ", time.clock() - t0 + + return + +# ---------------------------------------------------------------------------- # diff --git a/Aster/Cata/cataSTA10/Utilitai/stats.py b/Aster/Cata/cataSTA10/Utilitai/stats.py new file mode 100644 index 00000000..eb338b07 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/stats.py @@ -0,0 +1,61 @@ +#@ MODIF stats Utilitai DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS + +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# extract from pystat module +# +from math import pi,sqrt,log,exp,pow +import numpy +# CDF +# +# ------------------------------------------------------------------- +def normcdf(X): + # Cumulative normal distribution + + (a1,a2,a3,a4,a5) = (0.31938153, -0.356563782, 1.781477937, -1.821255978, 1.330274429) + L = numpy.absolute(X) + K = 1.0 / (1.0 + 0.2316419 * L) + w = 1.0 - 1.0 / sqrt(2*pi)*exp(-L*L/2.) * (a1*K + a2*K*K + a3*pow(K,3) + + a4*pow(K,4) + a5*pow(K,5)) + if X<0: + w = 1.0-w + return w + +# Inverse CDF +def normicdf(v): + if v > 0.5: + r = -1. + else: + r = 1. + xp = 0. + lim = 1.e-20 + p = [-0.322232431088, -1.0, -0.342242088547, -0.0204231210245, -0.453642210148e-4] + q = [0.0993484626060, 0.588581570495, 0.531103462366, 0.103537752850, 0.38560700634e-2] + + if v < lim or v == 1: + return -1./lim + elif v == 0.5: + return 0 + elif v > 0.5: + v = 1.-v + y = sqrt(log(1./v**2.)) + xp = y+((((y*p[4]+p[3])*y+p[2])*y+p[1])*y+p[0])/((((y*q[4]+q[3])*y+q[2])*y+q[1])*y+q[0]) + if v < 0.5: + xp *= -1. + return xp*r +#-- diff --git a/Aster/Cata/cataSTA10/Utilitai/sup_gmsh.py b/Aster/Cata/cataSTA10/Utilitai/sup_gmsh.py new file mode 100644 index 00000000..7d62cee3 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/sup_gmsh.py @@ -0,0 +1,1416 @@ +#@ MODIF sup_gmsh Utilitai DATE 26/05/2010 AUTEUR ASSIRE A.ASSIRE +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +import os.path, string, os, copy +import numpy as NP + +try : + from Cata.cata import * + from Accas import _F +except : + print 'Fonctionnalites Aster indisponibles' + + +_CARAC = { + 'prec' : 1.E-8 + } + + +def Class_search(class_name, target_class) : + + """ + Check that class_name inherits from target_class + (run recursively through the inheritance lists) + """ + + if class_name == target_class : return 1 + + for cl in class_name.__bases__ : + if Class_search(cl, target_class) : return 1 + return 0 + + +def Progress(L,**para) : + + """ + Compute the unknown parameters for a geometric progression : + r = ratio + N = number of elements + h = initial size + + So that : + L = Sum(i=0:N-1, h(i)) where h(i+1) = h(i)*r, h(0)=h + + Usage : + Progress(L,r=...,N=...) -> h + Progress(L,r=...,h=...) -> N + Progress(L,h=...,N=...) -> r + + """ + + prec = 1.E-4 + + # Calcul de N + if 'N' not in para.keys() : + r = float(para['r']) + h = float(para['h']) + N = log(1+(r-1)*L/h)/log(r) + N = int(N+0.5) + return N + + # Calcul de h + elif 'h' not in para.keys() : + r = float(para['r']) + N = int(para['N']+0.5) + h = L*(r-1)/(r**N-1) + return h + + # Calcul de r + elif 'r' not in para.keys() : + h = float(para['h']) + N = int(para['N']+0.5) + a = L/h + if N > a : + x = 0 + else : + x = a**(1./(N-1)) + + for i in xrange(100) : + res = x**N - a*x + a-1 + if abs(res) < prec*(x-1)*a : + return x + dx = res/(a-N*x**(N-1)) + x = x+dx + + raise 'Solution failure' + + else : + raise 'Unknown parameters' + + + +def Is_Geometric(object) : + + """ + return true if the object inherits of the Geometric class + """ + + return Class_search(object.__class__, Geometric) + + + +# -------------------------------------------------------------------------------------- + +class Geometric : + + """ + GENERIC CLASS FOR GEOMETRICAL OBJECTS + + private attribute + parameters : dictionnary of the attributes (except relation and parameters itself) + see __getattr__ and __setattr__ + + + Attributes + num : index among gmsh objects + md : mesh descriptor + mesh : related mesh object + relation : model object in case of coincidence + type : type of the object (None, Point, Line, Circle, Surface, Volume) + + Public methods + Is_point : return true is the object inherits of the Point class + + Is_line : return true is the object inherits of the Line class + + Is_surface : return true is the object inherits of the Surface class + + Is_volume : return true is the object inherits of the Volume class + + Base_class : return the name of the base class : Point, Line, Surface + or Volume + + Is_same_dimension : return true is both objects are of the same dimension + (point, line, surface or volume) + in -> object to compare to self + + Duplicate : duplicate an object and base its mesh_descriptor + on the mesh_descriptor of the model + + Coincide : assert that an object is coincident with a model one + All the attributes are then automatically read from + the model object (see __setattr__ and __getattr__). + in -> model object + + Private method + + Root : + Provides the root object of an object, ie the object itself if there is no relation + or the deepest model in case of relation. + + Geometric_coincide : check if a geometrical coincidence is possible + return information about the coincidence, false else. + in -> model object + + Deep_coincide : proceed recursively to ensure coincidence of the relevant sub-objects + in -> model object + in -> correspond (information returned by Geometric_coincide) + + __setattr__ : distinguish two sets of attributes + relation (to express a relation with a model object in case of coincidence) + all the other attributes which are stored in the dictionnary parameters + instead of the usual __dict__ if there is no relation (see Coincide) + and in the model object if there is a coincidence + + __getattr__ : if the object is related (relation <> None) the attribute is read + in the model object. Else, it is read in the current object, actually + in the dictionnary parameters (see __setattr__) + + Thanks to these two overloaded methods, the access to the attributes is usual if + there is no relation whereas the attributes of the model object are accessed + transparently if there is a relation. + + __cmp__ : + The comparison of two objects involves possible coincidence. It is no more the object ids + that are compared but the object roots (.relation if any). + + Gmsh : produce the source code for Gmsh + in -> mesh + + Gmsh_send : send a line code to the gmsh interpreter + in -> line_code (string) + + Intermediate_meshing : produce the source code for the intermediate objects + in -> mesh + + Object meshing : produce the source code for the current object + var -> object number (modified if several objects are created) + + """ + + def __init__(self) : + self.relation = None + self.parameters = {} + self.num = 0 + self.md = Mesh_Descriptor() + + types = {} + types[Geometric] = 'Geometric' + types[Point] = 'Point' + types[Line] = 'Line' + types[Circle] = 'Circle' + types[Surface] = 'Surface' + types[Volume] = 'Volume' + types[LineLoop] = 'LineLoop' + types[SurfaceLoop] = 'SurfaceLoop' + try : + self.type = types[self.__class__] + except KeyError : + raise 'Unknown object type' + + + def Is_point(self) : + return Class_search(self.__class__, Point) + + def Is_line(self) : + return Class_search(self.__class__, Line) + + def Is_surface(self) : + return Class_search(self.__class__, Surface) + + def Is_volume(self) : + return Class_search(self.__class__, Volume) + + def Base_class(self) : + if self.Is_volume() : return 'Volume' + if self.Is_surface() : return 'Surface' + if self.Is_line() : return 'Line' + if self.Is_point() : return 'Point' + + def Is_same_dimension(self, obj) : + + return ( + (self.Is_point() and obj.Is_point() ) or + (self.Is_line() and obj.Is_line() ) or + (self.Is_surface() and obj.Is_surface() ) or + (self.Is_volume() and obj.Is_volume() ) + ) + + + def __setattr__(self, attr, value) : + + if attr in ['relation','parameters'] : + self.__dict__[attr] = value + else : + if self.relation : + setattr(self.relation,attr,value) + else : + self.parameters[attr] = value + + + def __getattr__(self,attr) : + + if self.relation : + return (getattr(self.relation,attr)) + else : + if attr in self.parameters.keys() : + return self.parameters[attr] + else : + raise AttributeError,attr + + + def Root(self) : + + o = self + while o.relation : o = o.relation + return o + + + def __cmp__(self,obj) : + + if self.Root() is obj.Root() : + return 0 + else : + return -1 + + + def Geometric_coincide(self,obj) : return 0 + + def Deep_coincide(self,obj,correspond) : pass + + def Coincide(self, obj) : + + if self == obj : return # in that way recursive loops cannot exist + + if self.relation : # the root is put in coincidence, not the object itself + self.Root().Coincide(obj) + return + + if not self.Is_same_dimension(obj) : + raise 'Coincidence impossible : objects are not of the same dimension' + + correspond = self.Geometric_coincide(obj) + if not correspond : + raise 'The objects are not geometrically coincident' + + self.Deep_coincide(obj,correspond) + self.relation = obj + + + def Duplicate(self) : + + return copy.deepcopy(self) # special deepcopy for the Mesh_Descriptor + + + def Gmsh(self,mesh) : + + if self.num : return # already meshed object + self.mesh = mesh # Storing the mesh + self.Intermediate_meshing(mesh) # creation of the intermediate objects + num = mesh.num+1 # New object number + self.Object_meshing(num) # object meshing (with current number num) + mesh.num = num # Updating the current gmsh pointer + self.num = num # Storing the current object number + + + def Gmsh_send(self, line_code) : + + self.mesh.command.append(line_code) + + + def Intermediate_meshing(self,mesh) : + pass + + + def Object_meshing(self,num) : + raise "Creation of the Gmsh source not implemented" + + + + +# -------------------- POINT OBJECTS --------------------- + + +class Point(Geometric) : + + """ + POINT OBJECT + + Public methods + __init__ : + in -> coordinates (the 3rd is zero by default) + + Size : set the size of the neighbouring elements + in -> size + + Attractor : define the point as an attractor + in -> scale_x : size amplification factor in the x-direction + in -> scale_y : size amplification factor in the y-direction + in -> distance: influence distance for the perturbation + + Translate : translation of the point + in -> x,y,z translation vector (default : z=0) + + Attributes + coor : coordinates + size : neighbouring element size + attractor : parameters of the attractor + """ + + def __init__(self,x,y,z=0) : + + Geometric.__init__(self) + self.coor = NP.array([x,y,z], NP.float) + self.attractor = None + + + def Geometric_coincide(self,obj) : + + global _CARAC + prec = _CARAC['prec'] + + d = VectorNorm(self.coor - obj.coor) + if d < prec*self.md.size : + return 1 + else : + return None + + + def Size(self,h) : + + self.md.size = float(h) + + + def Attractor(self, scale_x, scale_y, distance) : + + self.attractor = (float(scale_x), float(scale_y), float(distance)) + + + def Translate(self,x,y,z=0) : + + tran = NP.array([x,y,z]).astype(NP.float) + self.coor = self.coor + tran + + + def Object_meshing(self,num) : + + ch = ( + 'Point(' + `num` + ') = {' + + `self.coor[0]` + ', ' + + `self.coor[1]` + ', ' + + `self.coor[2]` + ', ' + + `self.md.size` + '};' + ) + self.Gmsh_send(ch) + + if self.attractor : + ch = ( + 'Attractor Point{' + `num` + '} = {' + + `self.attractor[0]`+',' + + `self.attractor[1]`+',' + + `1./self.attractor[2]` + '};' + ) + self.Gmsh_send(ch) + + + +# -------------------- LINE OBJECTS ---------------------- + + +class Line(Geometric) : + + """ + LINE OBJECT + + + Public methods + + Attractor : define the point as an attractor + in -> scale_x : size amplification factor in the x-direction + in -> scale_y : size amplification factor in the y-direction + in -> distance: influence distance for the perturbation + + """ + + + def __init__(self,*points) : + + Geometric.__init__(self) + + if len(points) <=1 : + raise "There should be at least two points" + + for point in points : + if not point.Is_point() : + raise "Arguments should be points" + + self.points = list(points) + self.attractor = None + + + def Geometric_coincide(self,obj) : + + nb_points = len(self.points) + if nb_points <> len(obj.points) : + raise 'To coincide, lines should have the same number of points' + + # same order of points + info = range(nb_points) + for i in range(nb_points) : + p1 = self.points[i] + p2 = obj.points[info[i]] + if not p1.Geometric_coincide(p2) : + break + else : + return info + + # reverse order of points + info.reverse() + for i in range(nb_points) : + p1 = self.points[i] + p2 = obj.points[info[i]] + if not p1.Geometric_coincide(p2) : + break + else : + return info + + return None + + + def Deep_coincide(self,obj,info) : + + for i in range(len(info)) : + p1 = self.points[i] + p2 = obj.points[info[i]] + p1.Coincide(p2) + + + + def Translate(self,x,y,z=0) : + + for point in self.points : + point.Translate(x,y,z) + + + def Transfinite(self,number,progression = 1) : + + self.md.number = int(number) + self.md.progression = float(progression) + + + def Attractor(self,scale_x, scale_y, distance) : + + self.attractor = (float(scale_x), float(scale_y), float(distance)) + + + def __rmul__(self,base) : + + if len(self.points) > 2 : + raise "Support (right argument) should be a straight line" + + if self.points[0] in base.points : + supp_orig = 0 + supp_extr = 1 + elif self.points[1] in base.points : + supp_orig = 1 + supp_extr = 0 + else : + raise "No common point" + + if self.points[supp_orig] == base.points[0] : + base_orig = 0 + base_extr = -1 + else : + base_orig = -1 + base_extr = 0 + + # Translation vector + ce = self.points[supp_extr].coor + co = self.points[supp_orig].coor + tran = ce-co + + # Definition of the edge opposite to the base + opp_base = base.Duplicate() + opp_base.Translate(tran[0],tran[1],tran[2]) + opp_base.points[base_orig] = self.points[supp_extr] + + # Definition of the edge opposite to the support + opp_supp = self.Duplicate() + opp_supp.points[0] = base.points[base_extr] + opp_supp.points[1] = opp_base.points[base_extr] + + surf = Surface(base,self,opp_base,opp_supp) + + if len(base.points) > 2 : surf.Ruled() + + return surf + + + def Intermediate_meshing(self,mesh) : + + for point in self.points : + point.Gmsh(mesh) + + + def Object_meshing(self,num) : + + ch = self.type + '(' + `num` + ') = {' + for point in self.points : + ch = ch + `point.num` + ',' + ch = ch[:-1] + '};' + self.Gmsh_send(ch) + + if self.md.transfinite : + ch = ( + 'Transfinite Line{' + `num` + '} = ' + + `self.md.number+1` + + ' Using Progression ' + `self.md.progression` + ';' + ) + self.Gmsh_send(ch) + + if self.attractor : + ch = ( + 'Attractor Line{' + `num` + '} = {' + + `self.attractor[0]`+',' + + `self.attractor[1]`+',' + + `1./self.attractor[2]` + '};' + ) + self.Gmsh_send(ch) + + + +class Circle(Line) : pass + +# The class inherits everything from Line but its name (to tell Gmsh +# that it is a circle). + + + +def Curve(l_x,l_y,l_z=None) : + + if not l_z : + l_z = [0.] * len(l_x) + + l_P = [] + for x,y,z in map(None,l_x,l_y,l_z) : + l_P.append(Point(x,y,z)) + + line = apply(Line,l_P) + return line + + + + + +# -------------------- SURFACE OBJECTS --------------------- + + +class Surface(Geometric) : + + """ + SURFACE OBJECT (inherit from the Geometric class) + + Public methods + __init__ : + in -> lines : external bounday of the surface (lines should be connected) + + Holes : set the internal holes (surfaces) + in -> holes : list of holes + + Boundary : checks that the boundary is a closed loop and returns the orientation of the edges + + Summit : returns the summit list sorted according to the orientation (see Boundary method) + + Ruled : declare the surface is a ruled one + + Translate : translate the surface + in -> x,y,z translation vector (default : z=0) + + Recombine : recombine the surface (try to mesh with quadrangles instead of triangles) + + Transfinite : Declare the mesh to be transfinite + + + Attributes + lines : list of external boundary lines + holes : list of internal holes (surfaces) + ruled : indicates (false or true) if the surface is a ruled surface + loops : list of boundary (external and internal) loops (computed when meshing) + """ + + + def __init__(self,*lines) : + + Geometric.__init__(self) + self.lines = list(lines) + self.holes = [] + self.ruled = 0 + + # Check Assumptions + for line in lines : + if not line.Is_line() : + raise "Arguments should be lines : " + repr(line) + if lines == 0 : raise "There should be at least one line" + self.Boundary() + + + def Boundary(self) : + + # checking the boundary is a loop + orie = [] + tmp = list(self.lines) + [self.lines[0]] + for i in range(len(self.lines)) : + lb = tmp[i] + la = tmp[i+1] + if lb.points[-1] in [la.points[0], la.points[-1]] : + orie.append(1) + elif lb.points[0] in [la.points[0], la.points[-1]] : + orie.append(-1) + else : + raise "This is not a loop" + + # checking the boundary is closed + if orie[0] == 1 : pi = self.lines[0].points[0] + if orie[0] == -1 : pi = self.lines[0].points[-1] + if orie[-1] == 1 : pf = self.lines[-1].points[-1] + if orie[-1] == -1 : pf = self.lines[-1].points[0] + if pi <> pf : raise "The loop is not closed" + + return orie + + + def Summit(self) : + + summits = [] + for line, orie in map(None,self.lines,self.Boundary()) : + if orie == 1 : + summits.append(line.points[0]) + else : + summits.append(line.points[-1]) + return summits + + + def Holes(self,*holes) : + + for hole in holes : + if not hole.Is_surface() : + raise "Holes should be surfaces" + self.holes = list(holes) + + + def Geometric_coincide(self,obj) : + + """ + return (line_order, hole_order) : + line_order : list of the coupled lines ith line of self with line_order[i]th line of obj + hole_order : same as line_order but with the internal holes + """ + + if len(self.lines) <> len(obj.lines) : + raise 'To coincide, surfaces should have the same number of border lines' + + if len(self.holes) <> len(obj.holes) : + raise 'To coincide, surfaces should have the same number of internal holes' + + # Coincidence of the surface holes + hole_order = [] + nb_holes = len(self.holes) + for hole_1 in self.holes : + for i in xrange(nb_holes) : + if i in hole_order : + continue + hole_2 = obj.holes[i] + if hole_1.Geometric_coincide(hole_2) : + hole_order.append(i) + break + else : + return None + + # Coincidence of the external boundary lines + line_order = [] + nb_lines = len(self.lines) + for line_1 in self.lines : + for i in xrange(nb_lines) : + if i in line_order : + continue + line_2 = obj.lines[i] + if line_1.Geometric_coincide(line_2) : + line_order.append(i) + break + else : + return None + + return (line_order, hole_order) + + + def Deep_coincide(self,obj,info) : + + line_order = info[0] + hole_order = info[1] + + for i,j in map(None,xrange(len(line_order)),line_order) : + l1 = self.lines[i] + l2 = obj.lines[j] + l1.Coincide(l2) + + for i,j in map(None,xrange(len(hole_order)),hole_order) : + h1 = self.holes[i] + h2 = obj.holes[j] + h1.Coincide(h2) + + + + def Ruled(self) : + + self.ruled = 1 + + if len(self.lines) not in [3,4] : + raise "Ruled surfaces require 3 or 4 edges" + + if self.holes : + raise "Holes are forbidden for ruled surfaces" + + + def Translate(self,x,y,z=0) : + + l_points = [] + for surf in [self] + self.holes : + for line in surf.lines : + for point in line.points : + if point not in l_points : l_points.append(point) + + for point in l_points : + point.Translate(x,y,z) + + + def Recombine(self,val=1) : + + self.md.recombine = val + + + def Transfinite(self) : + + self.Ruled() + + if len(self.lines) == 4 : + self.Recombine() + + self.md.transfinite = 1 + + for line in self.lines : + if not line.md.transfinite : + raise "Transfinite surfaces require transfinite edges" + + if ( + self.lines[0].md.number <> self.lines[2].md.number or + self.lines[1].md.number <> self.lines[3].md.number + ) : + raise "Coupled edges should have the same number of elements" + + + + def Intermediate_meshing(self,mesh) : + + self.loops = [] + for surf in [self]+self.holes : + loop = LineLoop(surf) + self.loops.append(loop) + loop.Gmsh(mesh) + + + def Object_meshing(self,num) : + + # Creation of the surface + if self.ruled : + ch = 'Ruled Surface(' + `num` + ') = {' + else : + ch = 'Plane Surface(' + `num` + ') = {' + for loop in self.loops : + ch = ch + `loop.num` + ',' + ch = ch[:-1] + '};' + self.Gmsh_send(ch) + + # Declaration of transfinite surface + if self.md.transfinite : + ch = 'Transfinite Surface {' + `num` + '} = {' + for summit in self.Summit() : + ch = ch + `summit.num` + ',' + ch = ch[:-1] + '};' + self.Gmsh_send(ch) + + # Recombine elements if requested + if self.md.recombine : + self.Gmsh_send('Recombine Surface {' + `num` + '} ;') + + + +class LineLoop(Geometric) : # Used only during the meshing phase + + + def __init__(self,surface) : + + Geometric.__init__(self) + self.surface = surface + + + def Intermediate_meshing(self,mesh) : + + for line in self.surface.lines : + line.Gmsh(mesh) + + + def Object_meshing(self,num) : + + ch = 'Line Loop(' + `num` + ') = {' + for line,orie in map(None,self.surface.lines,self.surface.Boundary()) : + ch = ch + `orie*line.num` + ',' + ch = ch[:-1] + '};' + self.Gmsh_send(ch) + + + + +class Volume(Geometric) : + + + """ + VOLUME OBJECT (inherit from the Geometric class) + + Public methods + __init__ : + in -> surfaces : external bounday of the volume (surfaces should be connected) + + Edge : returns the list of edges + + Holes : set the internal holes (surfaces) + in -> holes : list of holes + + Transfinite : Declare the mesh to be transfinite (force the surfaces to be transfinite too) + + Translate : translate the surface + in -> x,y,z translation vector (default : z=0) + + + Attributes + surfaces : list of external boundary surfaces + holes : list of internal holes (volumes) + loops : list of boundary (external and internal) loops (computed when meshing) + + + Private methods : + + Boundary : checks that the boundary is a closed loop and returns the orientation of the edges + + """ + + + def __init__(self,*surfaces) : + + Geometric.__init__(self) + self.surfaces = list(surfaces) + self.holes = [] + self.ruled = 0 + + # Check Assumptions + for surface in surfaces : + if not surface.Is_surface() : + raise "Arguments should be surfaces : " + repr(surface) + if len(surfaces) < 2 : raise "There should be at least two surfaces" + self.Boundary() + + + def Boundary(self) : + + edges = [] + for surface in self.surfaces : + edges = edges + surface.lines + + # each edge has to appear twice in the list of edges + for edge in edges : + if edges.count(edge) <> 2 : + raise "The surface loop is not closed : each edge should appear twice" + + + def Edge(self) : + + edges = [] + for surface in self.surfaces : + for line in surface.lines : + if line not in edges : edges.append(line) + return edges + + + def Holes(self,*holes) : + + for hole in holes : + if not hole.Is_volume() : + raise "Holes should be volumes" + self.holes = list(holes) + + + def Geometric_coincide(self,obj) : + + """ + return (surface_order, hole_order) : + surface_order : list of the coupled surfaces ith surface of self with surface_order[i]th surface of obj + hole_order : same as surface_order but with the internal holes + """ + + if len(self.surfaces) <> len(obj.surfaces) : + raise 'To coincide, volumes should have the same number of border surfaces' + + if len(self.holes) <> len(obj.holes) : + raise 'To coincide, volumes should have the same number of internal holes' + + # Coincidence of the surface holes + hole_order = [] + nb_holes = len(self.holes) + for hole_1 in self.holes : + for i in xrange(nb_holes) : + if i in hole_order : + continue + hole_2 = obj.holes[i] + if hole_1.Geometric_coincide(hole_2) : + hole_order.append(i) + break + else : + return None + + # Coincidence of the external boundary lines + surface_order = [] + nb_surfaces = len(self.surfaces) + for surface_1 in self.surfaces : + for i in xrange(nb_surfaces) : + if i in surface_order : + continue + line_2 = obj.surfaces[i] + if surface_1.Geometric_coincide(surface_2) : + surface_order.append(i) + break + else : + return None + + return (surface_order, hole_order) + + + def Deep_coincide(self,obj,info) : + + surface_order = info[0] + hole_order = info[1] + + for i,j in map(None,xrange(len(surface_order)),surface_order) : + l1 = self.surfaces[i] + l2 = obj.surfaces[j] + l1.Coincide(l2) + + for i,j in map(None,xrange(len(hole_order)),hole_order) : + h1 = self.holes[i] + h2 = obj.holes[j] + h1.Coincide(h2) + + + def Transfinite(self) : + + if len(self.surfaces) == 5 : + raise "Not implemented" + + if len(self.surfaces) not in [5,6] : + raise "Transfinite volumes require 5 or 6 faces" + + if self.holes : + raise "Holes are forbidden for transfinite volumes" + + self.md.transfinite = 1 + + for surface in self.surfaces : + if not surface.md.transfinite : + surface.Transfinite() # attention : ce n'est pas vrai dans le cas des prismes + +# ATTENTION : ICI, IL FAUDRAIT VERIFIER QUE LES SURFACES PEUVENT ETRE MISES EN VIS A VIS + + + + def Translate(self,x,y,z=0) : + + l_points = [] + for volu in [self] + self.holes : + for surf in volu.surfaces : + for line in surf.lines : + for point in line.points : + if point not in l_points : l_points.append(point) + + for point in l_points : + point.Translate(x,y,z) + + + + def Intermediate_meshing(self,mesh) : + + self.loops = [] + for volume in [self]+self.holes : + loop = SurfaceLoop(volume) + self.loops.append(loop) + loop.Gmsh(mesh) + + + def Object_meshing(self,num) : + + # Creation of the volume + ch = 'Volume(' + `num` + ') = {' + for loop in self.loops : + ch = ch + `loop.num` + ',' + ch = ch[:-1] + '};' + self.Gmsh_send(ch) + + # Declaration of transfinite surface + if self.md.transfinite : + + bottom_summits = self.surfaces[0].Summit() + edges = self.Edge() + top_summits = [] + for summit in bottom_summits : + for edge in edges : + if summit == edge.points[0] and edge.points[-1] not in bottom_summits : + top_summits.append(edge.points[-1]) + break + elif summit == edge.points[-1] and edge.points[0] not in bottom_summits : + top_summits.append(edge.points[0]) + break + + ch = 'Transfinite Volume {' + `num` + '} = {' + for summit in bottom_summits + top_summits : + ch = ch + `summit.num` + ',' + ch = ch[:-1] + '};' + self.Gmsh_send(ch) + + + +class SurfaceLoop(Geometric) : # Used only during the meshing phase + + + def __init__(self,volume) : + + Geometric.__init__(self) + self.volume = volume + + + def Intermediate_meshing(self,mesh) : + + for surface in self.volume.surfaces : + surface.Gmsh(mesh) + + + def Object_meshing(self,num) : + + ch = 'Surface Loop(' + `num` + ') = {' + for surface in self.volume.surfaces : + ch = ch + `surface.num` + ',' + ch = ch[:-1] + '};' + self.Gmsh_send(ch) + + + + +# ------------------- GEOMETRICAL TRANSFORMATION -------------- + +def VectorProduct(u,v) : + + return NP.array([u[1]*v[2]-u[2]*v[1],u[2]*v[0]-u[0]*v[2],u[0]*v[1]-u[1]*v[0]]) + + +def VectorNorm(u) : + + return sqrt(dot(u,u)) + + +class Rotation : + + def __init__(self,A,C,B) : + + self.C = c + self.a = A-C + n = VectorProduct(self.a,B-C) + self.n = n / VectorNorm(n) + + + def Proj(self,M) : + + lbd = dot(M-self.C,self.n) + H = self.C + lbd*self.n + return H + + +def Scaling_P2(p,t) : return (1.-p)*t*t+p*t + +def Scaling_P3(p,t) : + q = 1./p + a = p+q-2 + b = 3-2*p-q + return a*t**3 + b*t*t +p*t + + +# -------------------- MESHING OPERATIONS --------------------- + +class Mesh_Descriptor : + + """ + Attributes + relation Another mesh descriptor provides the mesh parameters + parameters dictionnary of the mesh parameters + size Point size + transfinite Transfinite mesh (0 or 1) + number Number of elements along a line (transfinite) + progression Progression of element size (transfinite) + recombine Recombine mesh or not + + Specific access : + md.parameter_name = xxx -> the relation is destroyed (set to None) + xxx = md.parameter_name -> if there is a relation, the effective + parameter is looked for recursively + + Deep copying : a relation is set to the model instead of a true copy + """ + + List_Attr = ['size','transfinite','number','progression','recombine'] + + + def __init__(self) : + + self.relation = None + self.parameters = { + 'size' : 1. , # Point size + 'transfinite': 0 , # Transfinite mesh (0 or 1) + 'recombine' : 0 # Recombine mesh or not + } + + + def __setattr__(self, attr, value) : + + if attr in Mesh_Descriptor.List_Attr : + self.relation = None + self.parameters[attr] = value + + if attr == 'number' : + self.transfinite = 1 + + else : + self.__dict__[attr] = value + + + def __getattr__(self,attr) : + + if self.relation : + return (getattr(self.relation,attr)) + else : + if attr in self.parameters.keys() : + return self.parameters[attr] + else : + raise AttributeError + + + def __deepcopy__(self,visit) : + + md = copy.copy(self) + md.parameters = copy.copy(self.parameters) + md.relation = self + return md + + + +class Mesh : + + """ + + """ + + + def __init__(self, algo = 2, order = 1, gmsh='gmsh') : + + self.num_ph = 0 + self.num = 0 + self.order = order + self.command = ['Mesh.Algorithm = ' + repr(algo) + ' ;'] + self.command += ['Mesh.ElementOrder = ' + repr(order) + ' ;'] + self.physicals = {} + self.gmsh = gmsh + + + def Physical(self, name, *l_lobj) : + + # Checking the name + if type(name) <> type(' ') : + raise 'First argument should be the name of the physical' + if name in self.physicals.keys() : + raise 'Physical '+name+' already exists' + + # treating the case of list of lists parameters + l_obj = [] + for l in l_lobj : + if type(l) == type([]) : + l_obj = l_obj + l + else : + l_obj.append(l) + + # Checking all objects are geometric + for obj in l_obj : + if not Is_Geometric(obj) : + raise "Non geometrical object : " + repr(obj) + " Physical = " + name + + cl = l_obj[0].Base_class() + # Checking all objects are of the same dimension + # ref_dim = l_obj[0] + # for obj in l_obj[1:] : + # if not ref_dim.Is_same_dimension(obj) : + # raise "All objects are not of the same dimension : " + repr(obj) + + # Creation of the objects if necessary + for obj in l_obj : + obj.Gmsh(self) + + # Creation of the physical + self.num_ph= self.num_ph + 1 + ch = name + '=' + `self.num_ph` + ';' + self.command.append(ch) + ch = 'Physical ' + cl + '(' + name + ') = {' + for obj in l_obj : + ch = ch + `obj.num` + ',' + ch = ch[:-1] + '};' + self.command.append(ch) + + # Name of the physical + name_gmsh = 'GM'+`self.num_ph` + self.physicals[name] = name_gmsh + + + def Save(self, file = 'fort.geo') : + + if os.path.isfile(file) : + os.remove(file) + + f = open(file,'w') + f.write(string.joinfields(self.command,'\n')) + f.close() + + + def View(self) : + + self.Save('fort.geo') +# os.system('gmsh fort.geo') + os.system(self.gmsh + ' fort.geo') + os.remove('fort.geo') + + + def Create(self, file = 'fort.19') : + + self.Save() + os.system(self.gmsh + ' -3 fort.geo') + try: os.remove(file) + except: pass + os.rename('fort.msh',file) + + + def Name(self, MA, CREA_GROUP_NO) : + + l_gma = [] + l_mcf = [] + for gma in self.physicals.keys() : + l_gma.append(self.physicals[gma]) + l_mcf.append(_F(GROUP_MA = self.physicals[gma],NOM=gma)) + + DEFI_GROUP(reuse = MA, + MAILLAGE = MA, + CREA_GROUP_MA = tuple(l_mcf), + ) + + SMESH_02 = CREA_MAILLAGE( + MAILLAGE = MA, + DETR_GROUP_MA = _F(GROUP_MA = tuple(l_gma)), + ) + + DETRUIRE(CONCEPT = _F(NOM = MA), INFO=1) + + if CREA_GROUP_NO == 'OUI' : + DEFI_GROUP(reuse = SMESH_02, + MAILLAGE = SMESH_02, + CREA_GROUP_NO = _F(TOUT_GROUP_MA = 'OUI'), + ) + + else : +# Traitement des GROUP_NO qui sont des points + info_gno = SMESH_02.LIST_GROUP_NO() + l_gno = [] + for gno in info_gno : + if gno[1] == 1 : l_gno.append(gno[0]) + + l_gma = [] + for gma in self.physicals.keys() : + nom_gmsh = self.physicals[gma] + if nom_gmsh in l_gno : + l_gma.append(gma) + + if l_gma : + DEFI_GROUP(reuse = SMESH_02, + MAILLAGE = SMESH_02, + CREA_GROUP_NO = _F(GROUP_MA = tuple(l_gma)), + ) + + return SMESH_02 + + + + def LIRE_GMSH(self, + UNITE_GMSH = 19, + UNITE_MAILLAGE = 20, + MODI_QUAD = 'NON', + CREA_GROUP_NO = 'OUI' + ) : + + """ + Lecture du maillage (format Aster) a partir de sa definition + (format sup_gmsh) + UNITE_GMSH = Numero d'unite logique pour le fichier msh + UNITE_MAILLAGE = Numero d'unite logique pour le fichier mail + MODI_QUAD = 'OUI' si line->quad, 'NON' sinon + CREA_GROUP_NO = 'OUI' si on cree les group_no, 'NON' sinon + """ + + nom_gmsh = 'fort.' + repr(UNITE_GMSH) + self.Create(nom_gmsh) + + PRE_GMSH(UNITE_GMSH=UNITE_GMSH, UNITE_MAILLAGE=UNITE_MAILLAGE) + + SMESH_00 = LIRE_MAILLAGE(UNITE = UNITE_MAILLAGE) + DEFI_FICHIER(ACTION='LIBERER',UNITE = UNITE_GMSH) + DEFI_FICHIER(ACTION='LIBERER',UNITE = UNITE_MAILLAGE) + + if MODI_QUAD == 'OUI' and self.order == 2 : + raise 'The finite elements are already of second order' + + if MODI_QUAD == 'OUI' and self.order <> 2 : + SMESH_01 = CREA_MAILLAGE( + MAILLAGE = SMESH_00, + LINE_QUAD = _F(TOUT = 'OUI') + ) + DETRUIRE(CONCEPT=_F(NOM=SMESH_00), INFO=1) + SMESH_00 = SMESH_01 + + SMESH_00 = self.Name(SMESH_00,CREA_GROUP_NO) + + return SMESH_00 diff --git a/Aster/Cata/cataSTA10/Utilitai/transpose.py b/Aster/Cata/cataSTA10/Utilitai/transpose.py new file mode 100644 index 00000000..0a8698d0 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/transpose.py @@ -0,0 +1,41 @@ +#@ MODIF transpose Utilitai DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + + +# Il NE faudrait utiliser cette fonction QUE sur des tableaux hétérogènes. +# Pour les tableaux homogènes (int, float, string), utiliser numpy.transpose. + +def transpose(liste): + """Transposition de double liste + """ + import numpy + if isinstance(liste, numpy.ndarray): + from warnings import warn + warn('prefer use of numpy.transpose instead', DeprecationWarning, stacklevel=2) + + n = range(len(liste[0])) + m = range(len(liste)) + liste_t = [[] for i in n] + for i in n : + for j in m : + liste_t[i].append(liste[j][i]) + return liste_t + + diff --git a/Aster/Cata/cataSTA10/Utilitai/utils.py b/Aster/Cata/cataSTA10/Utilitai/utils.py new file mode 100644 index 00000000..36f48d73 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/utils.py @@ -0,0 +1,105 @@ +#@ MODIF utils Utilitai DATE 26/05/2010 AUTEUR COURTOIS M.COURTOIS +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + + +""" +Module fournissant quelques fonctions utilitaires. +""" + +import os +import time + + +def miss_dble(list1, list2): + """miss = elements de list1 absents de list2 + dble = elements de list2 presents dans list1, fournis plusieurs fois.""" + s_ini = set(list1) + inter = s_ini.intersection(list2) + miss = s_ini.copy() + dble = set() + for p in list2: + try: + miss.remove(p) + except KeyError: + if set(p).issubset(s_ini) and p.strip() != '': + dble.add(p) + return miss, inter, dble + + +#TODO faire à l'identique pour les commandes fortran (ou appeller cette fonction) +def get_titre_concept(co=None): + """Retourne un titre automatique.""" + # ASTER 10.01.25 CONCEPT tab0 CALCULE LE 21/05/2010 A 17:58:50 DE TYPE TABLE_SDASTER + import aster + from Noyau.N_ASSD import ASSD + if not isinstance(co, ASSD): + co = None + fmt = { + "version" : "ASTER %(version)s", + "nomco" : "CONCEPT %(nom_concept)s", + "etatco" : "CALCULE", + "dateheure" : "%(dateheure)s", + "typeco" : "DE TYPE %(type_concept)s", + } + format = [fmt["version"],] + df = { + "version" : aster.__version__, + "dateheure" : time.strftime("LE %m/%d/%Y A %H:%M:%S"), + } + if co: + df["nom_concept"] = co.nom + format.append(fmt["nomco"]) + format.append(fmt["etatco"]) + format.append(fmt["dateheure"]) + if co: + df["type_concept"] = co.__class__.__name__.upper() + format.append(fmt["typeco"]) + globfmt = " ".join(format) + titre = globfmt % df + lt = titre.split() + lt = maximize_lines(lt, 80, " ") + return os.linesep.join(lt) + + +# existe dans asrun.mystring +def maximize_lines(l_fields, maxlen, sep): + """Construit des lignes dont la longueur est au plus de `maxlen` caractères. + Les champs sont assemblés avec le séparateur `sep`. + """ + newlines = [] + # ceinture + assert max([len(f) for f in l_fields]) <= maxlen, 'lignes trop longues : %s' % l_fields + while len(l_fields) > 0: + cur = [] + while len(l_fields) > 0 and len(sep.join(cur + [l_fields[0],])) <= maxlen: + cur.append(l_fields.pop(0)) + # bretelle + assert len(cur) > 0, l_fields + newlines.append(sep.join(cur)) + newlines = [l for l in newlines if l != ''] + return newlines + + + +if __name__ == '__main__': + npar = ('X', 'Y',) + nuti = ('DX', 'DY', 'X', 'X') + print miss_dble(npar, nuti) + diff --git a/Aster/Cata/cataSTA10/Utilitai/veri_matr_tang.py b/Aster/Cata/cataSTA10/Utilitai/veri_matr_tang.py new file mode 100644 index 00000000..9ceb0663 --- /dev/null +++ b/Aster/Cata/cataSTA10/Utilitai/veri_matr_tang.py @@ -0,0 +1,269 @@ +#@ MODIF veri_matr_tang Utilitai DATE 10/01/2011 AUTEUR PROIX J-M.PROIX +# -*- coding: iso-8859-1 -*- +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +from Cata.cata import * + +# MACRO "VERI_MATR_TANG" +# ---------------------------- +import cPickle +import string + +import numpy as NP +from numpy import linalg as LA + +import aster + +class TANGENT : + + """ + VERIFICATION SUR LES MATRICES TANGENTES + + Attributs publics : + + mat : matrice tangente + ddl : nom des degres de liberte + nddl : nombre de ddl + norme : norme de la matrice tangente + prec_zero : en-dessous de prec_zero, on ne compare pas les matrices + + + Methodes publiques + + Save : sauvegarde la matrice dans un fichier + Load : lit la matrice depuis un fichier + Aster : lit la matrice depuis l'espace Aster + Matrice : range la matrice + Difference : comparaison entre la matrice tangente et une autre matrice + Symetrie : verification du caractere symetrique de la matrice tangente + + """ + + + def __init__(self,ddl='',prec_zero=1.E-12) : + + """ + ddl : chaine de caracteres designant les ddl (ex: 'UUP') + prec_zero : en-dessous de prec_zero, on ne compare pas les matrices + """ + + self.ddl = ddl + self.prec_zero = prec_zero + + + def Load(self,nom_fichier) : + + fichier = file(nom_fichier,'r') + self.__dict__ = cPickle.load(fichier) + + + def Save(self,nom_fichier) : + + fichier = file(nom_fichier,'w') + cPickle.dump(self.__dict__,fichier) + + + def Aster(self,suffixe = 'MATA') : + + """ + nom : suffixe de l'objet jeveux + """ + + nom_obj_jeveux = string.ljust('PYTHON.TANGENT.'+suffixe,24) + obj_jeveux = aster.getvectjev(nom_obj_jeveux) + if not obj_jeveux : + raise 'TANGENT : OBJET JEVEUX DE SUFFIXE '+suffixe+' INEXISTANT' + self.Matrice(obj_jeveux) + + + def Eigen(self) : + self.vp = NP.sort(LA.eigvals(self.mat)) + + + def Matrice(self,matrice) : + + """ + matrice : la matrice tangente (rangement carre) + """ + + if type(matrice) == type((1,)) : + matrice = NP.array(list(matrice)) + elif type(matrice) == type([]) : + matrice = NP.array(matrice) + matrice = matrice.astype(float) + + nddl = int(len(matrice)**0.5+0.5) + matrice.shape = (nddl,nddl) + + self.mat = matrice + self.nddl = nddl + + if not self.ddl : + self.ddl = 'D'*nddl + elif len(self.ddl) <> nddl : + raise 'Nommage des DDL incoherents avec la taille de la matrice' + + self.norme = NP.trace(NP.dot(NP.transpose(self.mat),self.mat)) + + + def Difference(self,matp,affi_ok=0,prec_diff = 1.E-4) : + + """ + COMPARAISON RELATIVE DE LA MATRICE TANGENTE AVEC UNE AUTRE MATRICE + + matp : matrice avec laquelle self.mat est comparee + affi_ok : si oui, on affiche egalement les valeurs qui collent bien + prec_diff : ecart au-dessus duquel on considere que ce n'est pas OK + """ + + if type(matp) is tuple : + matp = NP.array(list(matp)) + elif type(matp) is list : + matp = NP.array(matp) + elif type(matp) == type(self) : + matp = matp.mat + elif type(matp) is NP.ndarray: + pass + else : + raise '1er argument doit etre une matrice (tuple,liste,TANGENT ou tableau numpy)' + matp = NP.ravel(matp) + matp = matp.astype(float) + + if len(matp) <> self.nddl*self.nddl : + raise 'Matrices de tailles differentes' + matp.shape = (self.nddl,self.nddl) + + refe = NP.abs(self.mat) + NP.abs(matp) + diff = NP.where(refe > self.prec_zero,NP.abs(self.mat-matp)/(refe+self.prec_zero),0) + nook = (diff.ravel() > prec_diff).nonzero()[0] + ok = (diff.ravel() <= prec_diff).nonzero()[0] + + if affi_ok : + affi = [ok,nook] + else : + affi = [nook] + + liste_i=[] + liste_j=[] + liste_matt=[] + liste_matp=[] + liste_diff=[] + for ind in affi : +# print '-'*80 + for pos in ind : + i = pos / self.nddl + j = pos % self.nddl +# print self.ddl[i],self.ddl[j],' ',(i+1,j+1),' ',self.mat[i,j],' ',matp[i,j] + liste_i.append(i+1) + liste_j.append(j+1) + liste_matt.append(self.mat[i,j]) + liste_matp.append(matp[i,j]) + liste_diff.append( NP.abs(self.mat[i,j]-matp[i,j])/ ( NP.abs(self.mat[i,j]) + NP.abs(matp[i,j]) + self.prec_zero)) +# print '-'*80 + if self.norme > self.prec_zero : + ecart = (self.mat - matp)/2. + nor_ecart = NP.trace(NP.dot(NP.transpose(ecart),ecart)) + nor_diff= nor_ecart / self.norme + else : + nor_diff= 0. + max_diff=0. + if (len(liste_diff) > 0 ) : max_diff = NP.max(liste_diff) + return liste_i,liste_j,liste_matt,liste_matp, liste_diff,nor_diff,max_diff + + + def Symetrie(self,prec_diff = 1.E-4) : + + """ + VERIFICATION QUE LA MATRICE TANGENTE EST SYMETRIQUE + + On retourne la norme relative de l'ecart a la symetrie : || (A-At)/2|| / ||A|| + On affiche les termes qui s'ecartent de la symetrie + + prec_diff : ecart au-dessus duquel on considere que ce n'est pas OK + """ + + tran = NP.transpose(self.mat) + liste_i,liste_j,liste_matt,liste_matp,liste_diff,nor_diff,max_diff=self.Difference(tran,affi_ok=0,prec_diff=prec_diff) + + +# if self.norme > self.prec_zero : +# ecart = (self.mat - tran)/2. +# nor_ecart = NP.trace(NP.dot(NP.transpose(ecart),ecart)) +# return nor_ecart / self.norme +# else : +# return 0. + return liste_i,liste_j,liste_matt,liste_matp, liste_diff,nor_diff,max_diff + + def Sauve(self,nom_fichier) : + cPickler.dump(self.__dict__) + +def veri_matr_tang_ops(self,SYMETRIE,DIFFERENCE,PRECISION,**args): + + """ + Ecriture de la macro verif_matrice_tangente_ops + """ + import os + from Accas import _F + from Utilitai.Utmess import UTMESS + from Utilitai.UniteAster import UniteAster + + # On importe les definitions des commandes a utiliser dans la macro + CREA_TABLE = self.get_cmd('CREA_TABLE') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + # Le concept sortant (de type fonction) est nomme ROTGD dans + # le contexte de la macro + + self.DeclareOut('TAB_MAT',self.sd) + ier=0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + tgt=TANGENT() + tgt.Aster(suffixe='MATA') + matp=TANGENT() + matp.Aster(suffixe='MATC') + prec_diff = PRECISION + if (SYMETRIE=='OUI') : + list1_i,list1_j,list1_matt,list1_matp,list1_diff,symetgt,max_diff=tgt.Symetrie(prec_diff) + list2_i,list2_j,list2_matt,list2_matp,list2_diff,symeper,max_diff=matp.Symetrie(prec_diff) + print 'Symetrie de la matrice tangente',symetgt + print 'Symetrie de la matrice pr pertubation',symeper + #aster.affiche('MESSAGE',str(tgt.Difference(matp,prec_diff) )) + if (DIFFERENCE=='OUI'): + liste_i,liste_j,liste_matt,liste_matp,liste_diff,nor_diff,max_diff=tgt.Difference(matp,prec_diff) + print 'difference entre matrice tangente et matrice par pertubation : norme=',nor_diff,' max=',max_diff + TAB_MAT=CREA_TABLE(LISTE=( + _F(PARA ='I',LISTE_I = liste_i), + _F(PARA ='J',LISTE_I = liste_j), + _F(PARA ='MAT_TGTE',LISTE_R = liste_matt), + _F(PARA ='MAT_PERT',LISTE_R = liste_matp), + _F(PARA ='MAT_DIFF',LISTE_R = liste_diff), + )) + return + + +VERI_MATR_TANG=MACRO(nom="VERI_MATR_TANG",op=veri_matr_tang_ops,sd_prod=table_sdaster, + docu="",reentrant='n', +fr="verification de la matrice tangente : symetrie et difference par rapport a la matrice calculee par perturbation", + regles=(AU_MOINS_UN('SYMETRIE','DIFFERENCE')), + SYMETRIE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), + DIFFERENCE =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), + PRECISION =SIMP(statut='f',typ='R',defaut=1.E-4 ), +) ; + diff --git a/Aster/Cata/cataSTA10/cata.py b/Aster/Cata/cataSTA10/cata.py index 92ca10d2..fc785b52 100755 --- a/Aster/Cata/cataSTA10/cata.py +++ b/Aster/Cata/cataSTA10/cata.py @@ -1,8 +1,8 @@ -#& MODIF ENTETE DATE 14/06/2010 AUTEUR COURTOIS M.COURTOIS +#& MODIF ENTETE DATE 08/03/2011 AUTEUR MASSIN P.MASSIN # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -135,6 +135,7 @@ from SD.co_listr8 import listr8_sdaster # maillage : from SD.co_maillage import maillage_sdaster from SD.co_squelette import squelette +from SD.co_grille import grille_sdaster # ----------------------------------------------------------------------------- # champs @@ -218,10 +219,165 @@ from SD.co_vect_elem import vect_elem, \ vect_elem_pres_r, vect_elem_pres_c, \ vect_elem_temp_r -#& MODIF COMMUN DATE 24/08/2010 AUTEUR COURTOIS M.COURTOIS + +# ----------------------------------------------------------------------------- +# corresp_2_mailla : +from SD.co_corresp_2_mailla import corresp_2_mailla + +#& MODIF COMMUN DATE 21/12/2010 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ABBAS M.ABBAS + +def C_AFFICHAGE() : return FACT(statut='f',max=1, + INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + UNITE = SIMP(statut='f',typ='I',val_min=1), + ); +#& MODIF COMMUN DATE 21/02/2011 AUTEUR ABBAS M.ABBAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ABBAS M.ABBAS +def C_ARCHIVAGE() : return FACT(statut='d',max=1, + regles = (EXCLUS('PAS_ARCH','LIST_INST','INST'),), + LIST_INST = SIMP(statut='f',typ=(listr8_sdaster) ), + INST = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + PAS_ARCH = SIMP(statut='f',typ='I' ), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), + DETR_NUME_SUIV = SIMP(statut='f',typ='TXM',into=("OUI",)), + CHAM_EXCLU = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',), +); +#& MODIF COMMUN DATE 07/12/2010 AUTEUR GENIAUT S.GENIAUT +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GENIAUT S.GENIAUT +def C_COMP_ELAS( COMMAND ) : #COMMUN# + + assert COMMAND in ('MACR_ASCOUF_CALC','MACR_ASPIC_CALC','CALC_G','POST_GP', + 'CALC_POINT_MAT','SIMU_POINT_MAT', 'DYNA_NON_LINE','STAT_NON_LINE','CALCUL',) + + kwargs = {} + +# ---------------------------------------------------------------------------------------------------------------------------------- +# RELATION +# ---------------------------------------------------------------------------------------------------------------------------------- + # commandes pour lesquelles on ne peut pas choisir une relation de type 1d + if COMMAND in ('CALC_G','POST_GP','CALC_POINT_MAT','SIMU_POINT_MAT' ): + kwargs['RELATION'] = SIMP(statut='o',typ='TXM',defaut="ELAS", + into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS","ELAS_HYPER")) + + # commandes pour lesquelles tout type de relation est possible + elif COMMAND in ('DYNA_NON_LINE','STAT_NON_LINE','CALCUL',): + kwargs['RELATION'] = SIMP(statut='o',typ='TXM',defaut="ELAS", + into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC", + "ELAS_VMIS_PUIS","ELAS_HYPER","ELAS_POUTRE_GR","CABLE")) + + # cas particulier de MACR_ASCOUF/ASPIC_CALC : on limite volontairement le choix pour ne pas perturber l'utilisateur + # mais theoriquement, toutes les lois disponibles pour CALC_G le sont aussi pour MACR_ASCOUF/ASPIC_CALC + elif COMMAND in ('MACR_ASCOUF_CALC','MACR_ASPIC_CALC'): + kwargs['RELATION'] = SIMP(statut='o',typ='TXM',into=("ELAS","ELAS_VMIS_TRAC")) + + +# ---------------------------------------------------------------------------------------------------------------------------------- +# DEFORMATION +# ---------------------------------------------------------------------------------------------------------------------------------- + + # commandes pour lesquelles on ne peut pas choisir les grandes deformations + if COMMAND in ('CALC_POINT_MAT','MACR_ASCOUF_CALC','MACR_ASPIC_CALC'): + kwargs['DEFORMATION'] =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT",)) + + # commandes pour lesquelles on peut choisir tout type de deformation + elif COMMAND in ('DYNA_NON_LINE','STAT_NON_LINE','CALCUL','POST_GP','CALC_G','SIMU_POINT_MAT', ): + kwargs['DEFORMATION'] =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",)) + +# ---------------------------------------------------------------------------------------------------------------------------------- +# INTEGRATION (RESI_INTE_RELA, ITER_INTE_MAXI, ALGO_INTE) +# ---------------------------------------------------------------------------------------------------------------------------------- + + kwargs['RESI_INTE_RELA'] =SIMP(statut='f',typ='R',defaut= 1.0E-6) + kwargs['ITER_INTE_MAXI'] =SIMP(statut='f',typ='I',defaut= 10 ) + kwargs['ALGO_INTE'] =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE", "SECANTE",)) + +# ---------------------------------------------------------------------------------------------------------------------------------- +# LOCALISATION +# ---------------------------------------------------------------------------------------------------------------------------------- + + # commandes pour lesquelles la localisation n'a pas de sens + # 'CALC_POINT_MAT','SIMU_POINT_MAT' + + # commandes pour lesquelles la localisation est automatique + # 'MACR_ASCOUF_CALC','MACR_ASPIC_CALC' + + # commandes pour lesquelles on peut choisir la localisation + if COMMAND in ('DYNA_NON_LINE','STAT_NON_LINE','CALC_G','POST_GP','CALCUL'): + kwargs['regles'] = (PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),) + kwargs['TOUT'] =SIMP(statut='f',typ='TXM',into=("OUI",) ) + kwargs['GROUP_MA'] =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**') + kwargs['MAILLE'] =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**') + +# ---------------------------------------------------------------------------------------------------------------------------------- +# DIVERS +# ---------------------------------------------------------------------------------------------------------------------------------- + + if COMMAND == 'CALC_G': + kwargs['CALCUL_CONTRAINTE'] =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ) + + + mcfact = FACT(statut='f',max='**', **kwargs) + + return mcfact +#& MODIF COMMUN DATE 08/02/2011 AUTEUR PROIX J-M.PROIX +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -328,7 +484,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# ), DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT", - into=("PETIT","PETIT_REAC","GROT_GDEP","SIMO_MIEHE","GDEF_HYPO_ELAS","GREEN_REAC")), + into=("PETIT","PETIT_REAC","GROT_GDEP","SIMO_MIEHE","GDEF_HYPO_ELAS","GREEN_REAC","GDEF_LOG")), ALGO_C_PLAN =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)), RESI_DEBO_MAXI =SIMP(statut='f',typ='R',fr="Critère d'arret absolu pour assurer la condition de contraintes planes",), @@ -340,15 +496,17 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# ALGO_1D =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)), ITER_MAXI_DEBORST =SIMP(statut='f',typ='I',defaut= 1), RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), + ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 20 ), b_redec_local = BLOC(condition = "DEFORMATION in ('PETIT','PETIT_REAC','GROT_GDEP')", fr="Nombre de redécoupages internes du pas de temps", ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ), ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE","IMPLICITE_RELI")), + ALGO_INTE =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE", "SECANTE", "DEKKER", "NEWTON_1D","BRENT", + "NEWTON", "NEWTON_RELI", "NEWTON_PERT", "RUNGE_KUTTA", + "SPECIFIQUE", "SANS_OBJET")), + TYPE_MATR_TANG =SIMP(statut='f',typ='TXM',into=("PERTURBATION","VERIFICATION","TANGENTE_SECANTE")), b_perturb =BLOC(condition = " (TYPE_MATR_TANG != None) and (TYPE_MATR_TANG != 'TANGENTE_SECANTE') ", @@ -372,7 +530,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), ) ; -#& MODIF COMMUN DATE 12/04/2010 AUTEUR MICHEL S.MICHEL +#& MODIF COMMUN DATE 06/12/2010 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG @@ -390,7 +548,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE REZETTE C.REZETTE +# RESPONSABLE ABBAS M.ABBAS def C_CONVERGENCE() : return FACT(statut='d', regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA','RESI_COMP_RELA'),), b_refe_rela =BLOC(condition = "RESI_REFE_RELA != None", @@ -447,7 +605,7 @@ def C_IMPL_EX() : return FACT(statut='d', REAC_INCR =SIMP(statut='f',typ='I',defaut= 1), PREDICTION =SIMP(statut='f',typ='TXM',defaut="TANGENTE"), ); -#& MODIF COMMUN DATE 20/07/2009 AUTEUR GENIAUT S.GENIAUT +#& MODIF COMMUN DATE 06/12/2010 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG @@ -465,7 +623,7 @@ def C_IMPL_EX() : return FACT(statut='d', # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE REZETTE C.REZETTE +# RESPONSABLE ABBAS M.ABBAS def C_INCREMENT() : return FACT(statut='o', regles=(EXCLUS('NUME_INST_INIT','INST_INIT'), EXCLUS('NUME_INST_FIN','INST_FIN'),), @@ -479,7 +637,7 @@ def C_INCREMENT() : return FACT(statut='o', ang="Time adaptation for unstationary HM models"), PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6 ), ); -#& MODIF COMMUN DATE 07/07/2009 AUTEUR REZETTE C.REZETTE +#& MODIF COMMUN DATE 06/12/2010 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG @@ -497,7 +655,7 @@ def C_INCREMENT() : return FACT(statut='o', # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE REZETTE C.REZETTE +# RESPONSABLE ABBAS M.ABBAS def C_NEWTON() : return FACT(statut='d', REAC_INCR =SIMP(statut='f',typ='I',defaut= 1,val_min=0), PREDICTION =SIMP(statut='f',typ='TXM',into=("DEPL_CALCULE","TANGENTE","ELASTIQUE","EXTRAPOL") ), @@ -507,10 +665,10 @@ def C_NEWTON() : return FACT(statut='d', REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0,val_min=0), EVOL_NOLI =SIMP(statut='f',typ=evol_noli), ); -#& MODIF COMMUN DATE 19/10/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMUN DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -528,198 +686,209 @@ def C_NEWTON() : return FACT(statut='d', # RESPONSABLE VABHHTS J.PELLET # ce fichier contient la liste des "into" possibles pour le mot cle NOM_CHAM # c'est a dire les noms de champs des SD RESULTAT (DATA de la routine RSCRSD) -def C_NOM_CHAM_INTO() : return ("ACCE", #COMMUN# + +def C_NOM_CHAM_INTO( typ_cham=None ) : #COMMUN# + import types +# Liste de tout les champs + l_tout_cham = [ + "ACCE", "ACCE_ABSOLU", "ALPH0_ELGA_EPSP", "ALPHP_ELGA_ALPH0", "COMPORTEMENT", "COMPORTHER", - "CRIT_ELNO_RUPT", - "DCHA_ELGA_SIGM", - "DCHA_ELNO_SIGM", - "DCHA_NOEU_SIGM", - "DEDE_ELNO_DLDE", - "DEDE_NOEU_DLDE", - "DEGE_ELNO_DEPL", - "DEGE_NOEU_DEPL", + "CRIT_ELNO", + "DEDE_ELNO", + "DEDE_NOEU", + "DEGE_ELNO", + "DEGE_NOEU", "DEPL", "DEPL_ABSOLU", - "DESI_ELNO_DLSI", - "DESI_NOEU_DLSI", - "DETE_ELNO_DLTE", - "DETE_NOEU_DLTE", + "DERA_ELGA", + "DERA_ELNO", + "DERA_NOEU", + "DESI_ELNO", + "DESI_NOEU", + "DETE_ELNO", + "DETE_NOEU", "DISS_ELGA", - "DISS_ELNO_ELGA", - "DURT_ELGA_META", - "DURT_ELNO_META", - "DURT_NOEU_META", - "ECIN_ELEM_DEPL", - "EFGE_ELNO_CART", - "EFGE_ELNO_DEPL", - "EFGE_NOEU_CART", - "EFGE_NOEU_DEPL", + "DISS_ELNO", + "DISS_NOEU", + "DURT_ELNO", + "DURT_NOEU", + "ECIN_ELEM", + "EFCA_ELNO", + "EFCA_NOEU", + "EFGE_ELNO", + "EFGE_NOEU", "ENDO_ELGA", - "ENDO_ELNO_ELGA", - "ENDO_ELNO_SIGA", - "ENDO_ELNO_SINO", - "ENDO_NOEU_SINO", + "ENDO_ELNO", + "ENDO_NOEU", "ENEL_ELGA", - "ENEL_ELNO_ELGA", - "ENEL_NOEU_ELGA", - "EPEQ_ELNO_TUYO", - "EPVC_ELGA", - "EPVC_ELNO", + "ENEL_ELNO", + "ENEL_NOEU", + "EPEQ_ELGA", + "EPEQ_ELNO", + "EPEQ_NOEU", "EPFD_ELGA", "EPFD_ELNO", + "EPFD_NOEU", "EPFP_ELGA", "EPFP_ELNO", - "EPME_ELGA_DEPL", - "EPME_ELNO_DEPL", - "EPMG_ELGA_DEPL", - "EPMG_ELNO_DEPL", - "EPMG_NOEU_DEPL", - "EPOT_ELEM_DEPL", + "EPFP_NOEU", + "EPME_ELGA", + "EPME_ELNO", + "EPMG_ELGA", + "EPMG_ELNO", + "EPMG_NOEU", + "EPMQ_ELGA", + "EPMQ_ELNO", + "EPMQ_NOEU", + "EPOT_ELEM", "EPSA_ELNO", "EPSA_NOEU", - "EPSG_ELGA_DEPL", - "EPSG_ELNO_DEPL", - "EPSG_NOEU_DEPL", - "EPSI_ELGA_DEPL", - "EPSI_ELNO_DEPL", - "EPSI_ELNO_TUYO", - "EPSI_NOEU_DEPL", + "EPSG_ELGA", + "EPSG_ELNO", + "EPSG_NOEU", + "EPSI_ELGA", + "EPSI_ELNO", + "EPSI_NOEU", "EPSP_ELGA", "EPSP_ELNO", "EPSP_NOEU", - "EQUI_ELGA_EPME", - "EQUI_ELGA_EPSI", - "EQUI_ELGA_SIGM", - "EQUI_ELNO_EPME", - "EQUI_ELNO_EPSI", - "EQUI_ELNO_SIGM", - "EQUI_NOEU_EPME", - "EQUI_NOEU_EPSI", - "EQUI_NOEU_SIGM", - "ERRE_ELEM_SIGM", - "ERRE_ELEM_TEMP", - "ERRE_ELNO_ELEM", - "ERRE_NOEU_ELEM", - "ERZ1_ELEM_SIGM", - "ERZ2_ELEM_SIGM", - "FERRAILLAGE", - "QIRE_ELEM_SIGM", - "QIRE_ELNO_ELEM", - "QIRE_NOEU_ELEM", - "QIZ1_ELEM_SIGM", - "QIZ2_ELEM_SIGM", - "SING_ELEM", - "SING_ELNO_ELEM", + "EPTQ_ELNO", + "EPTU_ELNO", + "EPVC_ELGA", + "EPVC_ELNO", + "EPVC_NOEU", + "ERME_ELEM", + "ERME_ELNO", + "ERME_NOEU", + "ERTH_ELEM", + "ERTH_ELNO", + "ERTH_NOEU", + "ERZ1_ELEM", + "ERZ2_ELEM", "ETOT_ELEM", "ETOT_ELGA", - "ETOT_ELNO_ELGA", - "EXTR_ELGA_VARI", - "EXTR_ELNO_VARI", - "EXTR_NOEU_VARI", + "ETOT_ELNO", + "FERRAILLAGE", "FLHN_ELGA", - "FLUX_ELGA_TEMP", - "FLUX_ELNO_TEMP", - "FLUX_NOEU_TEMP", + "FLUX_ELGA", + "FLUX_ELNO", + "FLUX_NOEU", "FORC_NODA", "FSUR_2D", "FSUR_3D", "FVOL_2D", "FVOL_3D", "GRAD_NOEU_THETA", - "HYDR_ELNO_ELGA", - "HYDR_NOEU_ELGA", - "INDI_LOCA_ELGA", - "INTE_ELNO_ACTI", - "INTE_ELNO_REAC", - "INTE_NOEU_ACTI", - "INTE_NOEU_REAC", + "HYDR_ELNO", + "HYDR_NOEU", + "INDL_ELGA", + "INTE_ELNO", + "INTE_NOEU", "IRRA", "LANL_ELGA", "META_ELGA_TEMP", - "META_ELNO_TEMP", - "META_NOEU_TEMP", + "META_ELNO", + "META_NOEU", "MODE_FLAMB", - "PMPB_ELGA_SIEF", - "PMPB_ELNO_SIEF", - "PMPB_NOEU_SIEF", + "PMPB_ELGA", + "PMPB_ELNO", + "PMPB_NOEU", + "PRAC_ELNO", + "PRAC_NOEU", "PRES", - "PRES_DBEL_DEPL", - "PRES_ELNO_DBEL", - "PRES_ELNO_IMAG", - "PRES_ELNO_REEL", - "PRES_NOEU_DBEL", - "PRES_NOEU_IMAG", - "PRES_NOEU_REEL", - "PROJ_ELEM_SIGM", - "RADI_ELGA_SIGM", - "RADI_ELNO_SIGM", - "RADI_NOEU_SIGM", + "PRME_ELNO", + "QIRE_ELEM", + "QIRE_ELNO", + "QIRE_NOEU", + "QIZ1_ELEM", + "QIZ2_ELEM", "REAC_NODA", + "SICA_ELNO", + "SICA_NOEU", + "SICO_ELNO", + "SICO_NOEU", "SIEF_ELGA", - "SIEF_ELGA_DEPL", "SIEF_ELNO", - "SIEF_ELNO_ELGA", "SIEF_NOEU", - "SIEF_NOEU_ELGA", "SIEF_SENO_SEGA", - "SIEQ_ELNO_TUYO", - "SIGM_ELNO_CART", - "SIGM_ELNO_COQU", - "SIGM_ELNO_DEPL", - "SIGM_ELNO_SIEF", - "SIGM_ELNO_TUYO", - "SIGM_NOEU_CART", - "SIGM_NOEU_COQU", - "SIGM_NOEU_DEPL", - "SIGM_NOEU_SIEF", - "SIGM_NOZ1_ELGA", - "SIGM_NOZ2_ELGA", - "SIPO_ELNO_DEPL", - "SIPO_ELNO_SIEF", - "SIPO_NOEU_DEPL", - "SIPO_NOEU_SIEF", - "SOUR_ELGA_ELEC", + "SIEQ_ELGA", + "SIEQ_ELNO", + "SIEQ_NOEU", + "SIGM_ELNO", + "SIGM_NOEU", + "SING_ELEM", + "SING_ELNO", + "SIPM_ELNO", + "SIPO_ELNO", + "SIPO_NOEU", + "SIRO_ELEM", + "SITQ_ELNO", + "SITU_ELNO", + "SIZ1_ELGA", + "SIZ2_ELGA", + "SOUR_ELGA", + "SPMX_ELGA", "TEMP", "THETA", + "VACO_ELNO", + "VAEX_ELGA", + "VAEX_ELNO", + "VAEX_NOEU", "VALE_CONT", - "VALE_NCOU_MAXI", "VARC_ELGA", "VARI_ELGA", "VARI_ELNO", - "VARI_ELNO_COQU", - "VARI_ELNO_ELGA", - "VARI_ELNO_TUYO", "VARI_NOEU", - "VARI_NOEU_ELGA", + "VATU_ELNO", "VITE", "VITE_ABSOLU", "VITE_VENT", - ) -#& MODIF COMMUN DATE 14/12/2009 AUTEUR ANDRIAM H.ANDRIAMBOLOLONA + ] +# +# Si aucun argument n'est passe, on utilise tous les types de champs possibles + if ( typ_cham is None ) : + l_ncham = l_tout_cham +# +# Sinon, on n'utilise que les champs dont le type est passe en argument + else : + l_typ_cham = [] + if (type(typ_cham) == types.StringType) : + l_typ_cham.append(typ_cham) + else : + l_typ_cham = typ_cham + l_ncham = [] + for typ in l_typ_cham : + for cham in l_tout_cham : + if (cham.find(typ) != -1) : + if (cham.split('_')[1] == typ): + l_ncham.append(cham) + + return tuple(l_ncham) +#& MODIF COMMUN DATE 04/04/2011 AUTEUR PELLET J.PELLET # RESPONSABLE DESROCHES X.DESROCHES # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # ce fichier contient la liste des noms des grandeurs de CODE_ASTER -def C_NOM_GRANDEUR() : return ( #COMMUN# +def C_NOM_GRANDEUR() : return ( #COMMUN# "ABSC_R", "ADRSJEVE", "ADRSJEVN", @@ -757,8 +926,9 @@ def C_NOM_GRANDEUR() : return ( #COMMUN# "DEPL_F", "DEPL_R", "DISS_R", -"DOMMAG", +"DOMA_R", "DURT_R", +"ENDO_R", "ENER_R", "EPSI_C", "EPSI_F", @@ -766,6 +936,7 @@ def C_NOM_GRANDEUR() : return ( #COMMUN# "ERRE_R", "FACY_R", "FELECR", +"FER2_R", "FISS_R", "FLAPLA", "FLUN_F", @@ -786,7 +957,7 @@ def C_NOM_GRANDEUR() : return ( #COMMUN# "IMPE_C", "IMPE_F", "IMPE_R", -"IND_LOCA", +"INDL_R", "INFC_R", "INST_R", "INTE_R", @@ -848,6 +1019,88 @@ def C_NOM_GRANDEUR() : return ( #COMMUN# "WEIBULL", "XCONTAC", ) +#& MODIF COMMUN DATE 17/01/2011 AUTEUR ABBAS M.ABBAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ABBAS M.ABBAS + +def C_OBSERVATION() : return FACT(statut='f',max=99, + + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1, + into=("VALE_CONT","FORC_NODA", + "DEPL","VITE","ACCE","TEMP", + "SIEF_ELGA","VARI_ELGA", + "DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)), + + EVAL_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE', + into=("MIN","MAX","MOY","VALE",),), + + NOM_CMP =SIMP(statut='o',typ='TXM',max=20), + EVAL_CMP =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE', + into=("VALE","FORMULE",),), + + b_formule =BLOC(condition="(EVAL_CMP=='FORMULE')", + FORMULE = SIMP(statut='o',typ=formule,max=1), + ), + + b_cham_no =BLOC(condition="(NOM_CHAM=='DEPL') or \ + (NOM_CHAM=='VITE') or \ + (NOM_CHAM=='ACCE') or \ + (NOM_CHAM=='TEMP') or \ + (NOM_CHAM=='FORC_NODA') or \ + (NOM_CHAM=='VALE_CONT') or \ + (NOM_CHAM=='DEPL_ABSOLU') or \ + (NOM_CHAM=='VITE_ABSOLU') or \ + (NOM_CHAM=='ACCE_ABSOLU')", + regles =(UN_PARMI('NOEUD','GROUP_NO','GROUP_MA','MAILLE','TOUT')), + TOUT =SIMP(statut='d',typ='TXM',into=("OUI",) ), + NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + ), + + + b_cham_elga =BLOC(condition="(NOM_CHAM=='SIEF_ELGA') or \ + (NOM_CHAM=='VARI_ELGA')", + regles =(UN_PARMI('GROUP_MA','MAILLE','TOUT')), + TOUT =SIMP(statut='d',typ='TXM',into=("OUI",) ), + MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), + EVAL_ELGA =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE', + into=("MIN","MAX","VALE",),), + b_elga_vale =BLOC(condition="(EVAL_ELGA=='VALE')", + POINT =SIMP(statut='o',typ='I' ,validators=NoRepeat(),max='**'), + SOUS_POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), + ), + ), + + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + PAS_OBSE =SIMP(statut='f',typ='I'), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), + + + ); #& MODIF COMMUN DATE 29/03/2007 AUTEUR GRANET S.GRANET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -873,7 +1126,48 @@ def C_PARA_FONCTION() : return ( #COMMUN# "AMOR","ABSC","SIGM","HYDR","SECH","PORO","SAT", "PGAZ","PCAP","PLIQ","PVAP","PAD","VITE","ENDO", "NORM","EPAIS","NEUT1","NEUT2",) -#& MODIF COMMUN DATE 05/10/2010 AUTEUR ABBAS M.ABBAS +#& MODIF COMMUN DATE 01/02/2011 AUTEUR MASSIN P.MASSIN +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ABBAS M.ABBAS +def C_PILOTAGE() : return FACT(statut='f', + regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), + TYPE =SIMP(statut='o',typ='TXM',into=("DDL_IMPO","LONG_ARC","PRED_ELAS","DEFORMATION", + "ANA_LIM","SAUT_IMPO","SAUT_LONG_ARC") ), + COEF_MULT =SIMP(statut='f',typ='R',defaut= 1.0E+0), + EVOL_PARA =SIMP(statut='f',typ='TXM',defaut="SANS", into=("SANS","CROISSANT","DECROISSANT") ), + ETA_PILO_MAX =SIMP(statut='f',typ='R'), + ETA_PILO_MIN =SIMP(statut='f',typ='R'), + ETA_PILO_R_MAX =SIMP(statut='f',typ='R'), + ETA_PILO_R_MIN =SIMP(statut='f',typ='R'), + PROJ_BORNES =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), + SELECTION =SIMP(statut='f',typ='TXM',defaut="NORM_INCR_DEPL", into=("RESIDU","ANGL_INCR_DEPL","NORM_INCR_DEPL") ), + TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), + FISSURE =SIMP(statut='f',typ=fiss_xfem ,validators=NoRepeat(),max='**'), + MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), + NOM_CMP =SIMP(statut='f',typ='TXM',max='**'), + DIRE_PILO =SIMP(statut='f',typ='TXM',max='**'), + ); + +#& MODIF COMMUN DATE 06/12/2010 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG @@ -891,7 +1185,7 @@ def C_PARA_FONCTION() : return ( #COMMUN# # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE REZETTE C.REZETTE +# RESPONSABLE ABBAS M.ABBAS def C_RECH_LINEAIRE() : return FACT(statut='f', METHODE =SIMP(statut='f',typ='TXM',defaut="CORDE",into=("CORDE","MIXTE","PILOTAGE") ), RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ), @@ -902,10 +1196,10 @@ def C_RECH_LINEAIRE() : return FACT(statut='f', RHO_MAX =SIMP(statut='f',typ='R',defaut=1.0E+1), RHO_EXCL =SIMP(statut='f',typ='R',defaut=0.9E-2,val_min=0.), ); -#& MODIF COMMUN DATE 10/08/2010 AUTEUR MEUNIER S.MEUNIER +#& MODIF COMMUN DATE 28/02/2011 AUTEUR BARGELLI R.BARGELLINI # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -939,6 +1233,7 @@ def C_RELATION() : return ( "ELAS", #COMMUN# "CZM_LIN_REG", "CZM_OUV_MIX", "CZM_TAC_MIX", + "CZM_TRA_MIX", "DIS_BILI_ELAS", "DIS_CHOC", "DIS_ECRO_CINE", @@ -950,6 +1245,7 @@ def C_RELATION() : return ( "ELAS", #COMMUN# "DRUCK_PRAG_N_A", "ELAS_GONF", "ELAS_HYPER", + "ENDO_CARRE", "ENDO_FRAGILE", "ENDO_HETEROGENE", "ENDO_ISOT_BETON", @@ -969,13 +1265,11 @@ def C_RELATION() : return ( "ELAS", #COMMUN# "HOEK_BROWN_EFF", "HOEK_BROWN_TOT", "HUJEUX", - "IMPLEX_FRAG", - "IMPLEX_ISOT_BETO", - "IMPLEX_ISOT_LINE", "IRRAD3M", "JOINT_BA", "JOINT_BANDIS", "JOINT_MECA_RUPT", + "JOINT_MECA_FROT", "KIT_DDI", "KIT_HH", "KIT_H", @@ -1029,6 +1323,7 @@ def C_RELATION() : return ( "ELAS", #COMMUN# "RUPT_FRAG", "SANS", "VENDOCHAB", + "VISC_ENDO_LEMA", "VISCOCHAB", "VISC_CIN1_CHAB", "VISC_CIN2_CHAB", @@ -1053,10 +1348,10 @@ def C_RELATION() : return ( "ELAS", #COMMUN# "ZMAT", "UMAT", ) -#& MODIF COMMUN DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU +#& MODIF COMMUN DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -1096,7 +1391,7 @@ def C_SOLVEUR() : return FACT(statut='d', RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -1106,11 +1401,12 @@ def C_SOLVEUR() : return FACT(statut='d', TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), FILTRAGE_MATRICE =SIMP(statut='f',typ='R',defaut=-1.0,), MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), MATR_DISTRIBUEE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), @@ -1144,7 +1440,7 @@ def C_SOLVEUR() : return FACT(statut='d', RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -1157,6 +1453,79 @@ def C_SOLVEUR() : return FACT(statut='d', # -------------------------------------------------------------------------------------------------------------------------------- SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), ); +#& MODIF COMMUN DATE 17/01/2011 AUTEUR ABBAS M.ABBAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ABBAS M.ABBAS + +def C_SUIVI_DDL() : return FACT(statut='f',max=4, + + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1, + into=("DEPL","VITE","ACCE", + "FORC_NODA", + "SIEF_ELGA","VARI_ELGA", + "DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)), + + EVAL_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE', + into=("MIN","MAX","MOY","VALE",),), + + NOM_CMP =SIMP(statut='o',typ='TXM',max=20), + EVAL_CMP =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE', + into=("VALE","FORMULE",),), + + b_formule =BLOC(condition="(EVAL_CMP=='FORMULE')", + FORMULE = SIMP(statut='o',typ=formule,max=1), + ), + + b_cham_no =BLOC(condition="(NOM_CHAM=='DEPL') or \ + (NOM_CHAM=='VITE') or \ + (NOM_CHAM=='ACCE') or \ + (NOM_CHAM=='FORC_NODA') or \ + (NOM_CHAM=='VALE_CONT') or \ + (NOM_CHAM=='DEPL_ABSOLU') or \ + (NOM_CHAM=='VITE_ABSOLU') or \ + (NOM_CHAM=='ACCE_ABSOLU')", + regles =(UN_PARMI('NOEUD','GROUP_NO','GROUP_MA','MAILLE','TOUT')), + TOUT =SIMP(statut='d',typ='TXM',into=("OUI",) ), + NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + ), + + b_cham_elga =BLOC(condition="(NOM_CHAM=='SIEF_ELGA') or \ + (NOM_CHAM=='VARI_ELGA')", + regles =(UN_PARMI('GROUP_MA','MAILLE','TOUT')), + TOUT =SIMP(statut='d',typ='TXM',into=("OUI",) ), + MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), + EVAL_ELGA =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE', + into=("MIN","MAX","VALE",),), + b_elga_vale =BLOC(condition="(EVAL_ELGA=='VALE')", + POINT =SIMP(statut='o',typ='I' ,validators=NoRepeat(),max='**'), + SOUS_POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), + ), + ), + + TITRE = SIMP(statut='f',typ='TXM',max=3), + + + ); #& MODIF COMMUN DATE 09/11/2010 AUTEUR GNICOLAS G.NICOLAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -1195,10 +1564,10 @@ def C_TYPE_CHAM_INTO( type_cham=None ) : #COMMUN# # return tuple(l) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -1220,7 +1589,8 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, UIinfo ={"groupes":("Modélisation",)}, regles = (AU_MOINS_UN('POUTRE','BARRE','COQUE','CABLE','DISCRET','DISCRET_2D','MASSIF', 'GRILLE','MULTIFIBRE','RIGI_PARASOL'), - PRESENT_PRESENT('MULTIFIBRE','GEOM_FIBRE'),), + PRESENT_PRESENT('MULTIFIBRE','GEOM_FIBRE'), + EXCLUS('DISCRET','DISCRET_2D'),), MODELE = SIMP(statut='o',typ=modele_sdaster ), INFO = SIMP(statut='f',typ='I', defaut= 1 ,into=(1,2) ), VERIF = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=("MAILLE","NOEUD") ), @@ -1745,19 +2115,26 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, regles = (UN_PARMI('COEF_GROUP','FONC_GROUP'), UN_PARMI('COOR_CENTRE','NOEUD_CENTRE','GROUP_NO_CENTRE'), EXCLUS('GROUP_MA_POI1','GROUP_MA_SEG2'),), - GROUP_MA = SIMP(statut='o',typ=ma,validators=NoRepeat(),max='**', + GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**', fr="Surface servant à répartir les caractéristiques des discrets"), - GROUP_MA_POI1 = SIMP(statut='f',typ=ma,validators=NoRepeat(),max=1, + GROUP_MA_POI1 = SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1, fr="Mailles de type point correspondant aux discrets"), - GROUP_MA_SEG2 = SIMP(statut='f',typ=ma,validators=NoRepeat(),max=1, + GROUP_MA_SEG2 = SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1, fr="Mailles de type seg2 correspondant aux discrets"), FONC_GROUP = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), COEF_GROUP = SIMP(statut='f',typ='R',max='**'), REPERE = SIMP(statut='f',typ='TXM',into=("LOCAL","GLOBAL") ), CARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=2, into=("K_TR_D_N","K_T_D_N","K_TR_D_L","K_T_D_L", - "A_TR_D_N","A_T_D_N","A_TR_D_L","A_T_D_L") ), - VALE = SIMP(statut='o',typ='R',max='**'), + "A_TR_D_N","A_T_D_N","A_TR_D_L","A_T_D_L"), + fr="Choix des types de discrets du tapis de ressorts." ), + b_cara= BLOC(condition =""" (CARA in ["K_TR_D_N","K_T_D_N","K_TR_D_L","K_T_D_L", + "A_TR_D_N","A_T_D_N","A_TR_D_L","A_T_D_L"]) or \ + (len(CARA)==2 and CARA[0][2:]==CARA[1][2:]) """, + fr="Valeurs pour les discrets du tapis de ressorts.", + VALE = SIMP(statut='o',typ='R',max='**', + fr="Valeurs pour les discrets du tapis de ressorts.",), + ), GROUP_NO_CENTRE = SIMP(statut='f',typ=grno), NOEUD_CENTRE = SIMP(statut='f',typ=no), COOR_CENTRE = SIMP(statut='f',typ='R',min=2,max=3), @@ -1767,8 +2144,8 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, #============================================================================ RIGI_MISS_3D = FACT(statut='f',max='**', - GROUP_MA_POI1 = SIMP(statut='o',typ=ma,max=1), - GROUP_MA_SEG2 = SIMP(statut='f',typ=ma,max=1), + GROUP_MA_POI1 = SIMP(statut='o',typ=grma,max=1), + GROUP_MA_SEG2 = SIMP(statut='f',typ=grma,max=1), FREQ_EXTR = SIMP(statut='o',typ='R',max=1), UNITE_RESU_IMPE = SIMP(statut='f',typ='I',defaut=30), ), @@ -1846,10 +2223,10 @@ AFFE_CHAR_ACOU=OPER(nom="AFFE_CHAR_ACOU",op= 68,sd_prod=char_acou, DDL =SIMP(statut='o',typ='TXM',max='**'), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 01/03/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -1881,13 +2258,13 @@ def affe_char_cine_prod(MECA_IMPO,THER_IMPO,ACOU_IMPO,EVOL_IMPO,**args): AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod - ,fr="Affectation de conditions aux limites cinématiques constantes pour un traitement sans dualisation", + ,fr="Affectation de conditions aux limites cinématiques (U=U0) pour un traitement sans dualisation", reentrant='n', UIinfo={"groupes":("Chargements","Mécanique",)}, regles=(UN_PARMI('MECA_IMPO','THER_IMPO','ACOU_IMPO','EVOL_IMPO'), ), MODELE =SIMP(statut='o',typ=modele_sdaster ), - EVOL_IMPO =SIMP(statut='f',typ=(evol_noli,evol_elas,evol_ther),fr="Pour imposer tous les ddls d'un evol_xxx"), + MECA_IMPO =FACT(statut='f',max='**', regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'), AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI', @@ -1985,6 +2362,7 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod PRES33 =SIMP(statut='f',typ='R' ), LH1 =SIMP(statut='f',typ='R' ), ), + THER_IMPO =FACT(statut='f',max='**', regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'), AU_MOINS_UN('TEMP','TEMP_INF','TEMP_SUP'),), @@ -1997,6 +2375,7 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod TEMP =SIMP(statut='f',typ='R' ), TEMP_INF =SIMP(statut='f',typ='R' ), ), + ACOU_IMPO =FACT(statut='f',max='**', regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), @@ -2006,6 +2385,12 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), PRES =SIMP(statut='o',typ='C' ), ), + + EVOL_IMPO =SIMP(statut='f',typ=(evol_noli,evol_elas,evol_ther),fr="Pour imposer les ddls d'un evol_xxx"), + b_evol_impo = BLOC ( condition = "EVOL_IMPO != None", + NOM_CMP =SIMP(statut='f',typ='TXM',max='**',), # pour n'imposer que certaines CMPS (par défaut : toutes) + ), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS @@ -2151,10 +2536,10 @@ AFFE_CHAR_CINE_F=OPER(nom="AFFE_CHAR_CINE_F",op= 101,sd_prod=affe_char_cine_f_pr ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 08/11/2010 AUTEUR DESROCHES X.DESROCHES +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -2182,7 +2567,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 'LIAISON_GROUP','LIAISON_UNIF','FLUX_THM_REP','LIAISON_SOLIDE', 'LIAISON_ELEM','ONDE_FLUI','LIAISON_CHAMNO','VECT_ASSE','LIAISON_COQUE', 'LIAISON_MAIL','LIAISON_CYCL','FORCE_TUYAU', - 'EFFE_FOND','EVOL_CHAR','ARLEQUIN','DDL_POUTRE',), + 'EFFE_FOND','EVOL_CHAR','DDL_POUTRE',), ), VERI_NORM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), MODELE =SIMP(statut='o',typ=(modele_sdaster) ), @@ -2218,7 +2603,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 'UO3','VO2','VO3','WO2','WO3','UI4','UI5','VI4','VI5','WI4', 'WI5','UO4','UO5','VO4','VO5','WO4','WO5','UI6','UO6','VI6', 'VO6','WI6','WO6','WO','WI1','WO1','GONF','LIAISON', - 'H1X','H1Y','H1Z','H2X','H2Y','H2Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z', + 'H1X','H1Y','H1Z','H2X','H2Y','H2Z','H3X','H3Y','H3Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z', 'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22', 'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23', 'PRES31','PRES32','PRES33',),), @@ -2279,7 +2664,10 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, H1Z =SIMP(statut='f',typ='R' ), H2X =SIMP(statut='f',typ='R' ), H2Y =SIMP(statut='f',typ='R' ), - H2Z =SIMP(statut='f',typ='R' ), + H2Z =SIMP(statut='f',typ='R' ), + H3X =SIMP(statut='f',typ='R' ), + H3Y =SIMP(statut='f',typ='R' ), + H3Z =SIMP(statut='f',typ='R' ), E1X =SIMP(statut='f',typ='R' ), E1Y =SIMP(statut='f',typ='R' ), E1Z =SIMP(statut='f',typ='R' ), @@ -2433,7 +2821,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, MAILLE_2 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), GROUP_NO_1 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), NOEUD_1 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO_2 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), NOEUD_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), @@ -2694,21 +3082,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, KXY =SIMP(statut='f',typ='R' ), ), - ARLEQUIN =FACT(statut='f',min=1,max='**', - fr="Définit les paramètres de la méthode Arlequin", - GROUP_MA_1 =SIMP(statut='o',typ=grma,max='**'), - GROUP_MA_2 =SIMP(statut='o',typ=grma,max='**'), - GROUP_MA_COLL =SIMP(statut='f',typ=grma,max='**'), - CARA_ELEM =SIMP(statut='f',typ=cara_elem ), - COND_LIM =SIMP(statut='f',typ=char_meca ), - COLLAGE =SIMP(statut='f',typ='TXM',defaut="GROSSIER",into=("GROSSIER","FIN","GROUP_MA_1","GROUP_MA_2"),), - regles =(UN_PARMI('POIDS_1','POIDS_2','POIDS_GROSSIER','POIDS_FIN',),), - POIDS_1 =SIMP(statut='f',typ='R'), - POIDS_2 =SIMP(statut='f',typ='R'), - POIDS_GROSSIER =SIMP(statut='f',typ='R'), - UNITE_GMSH =SIMP(statut='f',typ='I',defaut=0,max=1), - POIDS_FIN =SIMP(statut='f',typ='R'),), - FORCE_POUTRE =FACT(statut='f',max='**', fr="Applique des forces linéiques sur des éléments de type poutre", regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'), @@ -3874,10 +4247,10 @@ AFFE_CHAR_THER_F=OPER(nom="AFFE_CHAR_THER_F",op=34,sd_prod=char_ther, INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -3938,13 +4311,18 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - NOM_VARC =SIMP(statut='o',typ='TXM', into=("TEMP","CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC", - "EPSA","NEUT1","NEUT2")), + NOM_VARC =SIMP(statut='o',typ='TXM', +# champ dans la doc into=("TEMP","CORR","IRRA","HYDR_ELNO","META_ELNO","NEUT") +# champ dans rscrsd into=("IRRA","TEMP","HYDR_ELNO","HYDR_NOEU","EPSA_ELNO","META_ELNO") + ), CHAMP_GD =SIMP(statut='f',typ=cham_gd_sdaster,), EVOL =SIMP(statut='f',typ=evol_sdaster,), B_EVOL =BLOC(condition="EVOL!=None", - NOM_CHAM =SIMP(statut='f',typ='TXM'), + NOM_CHAM =SIMP(statut='f',typ='TXM',into=("TEMP","CORR","IRRA","NEUT" + "HYDR_ELNO","HYDR_NOEU", + "META_ELNO","META_NOEU", + "EPSA_ELNO","EPSA_NOEU",)), PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), FONC_INST =SIMP(statut='f',typ=(fonction_sdaster,formule)), @@ -4043,10 +4421,10 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, ) ; -#& MODIF COMMANDE DATE 08/11/2010 AUTEUR PELLET J.PELLET +#& MODIF COMMANDE DATE 22/03/2011 AUTEUR DESOZA T.DESOZA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -4065,8 +4443,9 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, UIinfo={"groupes":("Modélisation",)}, fr="Définir le phénomène physique modélisé et le type d'éléments finis sur le maillage",reentrant='n', - regles=(AU_MOINS_UN('AFFE','AFFE_SOUS_STRUC'),), - MAILLAGE =SIMP(statut='o',typ=(maillage_sdaster) ), + regles=(AU_MOINS_UN('AFFE','AFFE_SOUS_STRUC'),UN_PARMI('MAILLAGE','GRILLE')), + MAILLAGE =SIMP(statut='f',typ=maillage_sdaster), + GRILLE =SIMP(statut='f',typ=grille_sdaster), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), VERIF =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2,into=("MAILLE","NOEUD") ), # @@ -4118,21 +4497,26 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "3D_FLUI_ABSO", # RESP. : DEVESA G.DEVESA "3D_FLUIDE", # RESP. : GREFFET N.GREFFET "3D_INCO", # RESP. : MICHEL S.MICHEL + "3D_INCO_UP", # RESP. : SFAYOLLE "3D_INCO_GD", # RESP. : MICHEL S.MICHEL "3D_SI", # RESP. : DESROCHES X.DESROCHES "3D_GRAD_EPSI", # RESP. : MICHEL S.MICHEL "3D_GRAD_VARI", # RESP. : MICHEL S.MICHEL + "3D_GVNO", # RESP. : BEAURAIN J.BEAURAIN "3D_XFEM_CONT", # RESP. : GENIAUT S.GENIAUT "3D_JOINT", # RESP. : LAVERNE J.LAVERNE + "3D_JOINT_HYME", # RESP. : LAVERNE J.LAVERNE "3D_INTERFACE", # RESP. : LAVERNE J.LAVERNE "AXIS", # RESP. : LEFEBVRE J.P.LEFEBVRE "AXIS_FLUI_STRU", # RESP. : GREFFET N.GREFFET "AXIS_FLUIDE", # RESP. : GREFFET N.GREFFET "AXIS_FOURIER", # RESP. : DESROCHES X.DESROCHES "AXIS_INCO", # RESP. : MICHEL S.MICHEL + "AXIS_INCO_UP", # RESP. : SFAYOLLE "AXIS_INCO_GD", # RESP. : MICHEL S.MICHEL "AXIS_SI", # RESP. : DESROCHES X.DESROCHES "AXIS_GRAD_VARI", # RESP. : MICHEL S.MICHEL + "AXIS_GVNO", # RESP. : BEAURAIN J.BEAURAIN "AXIS_JOINT", # RESP. : LAVERNE J.LAVERNE "AXIS_INTERFACE", # RESP. : LAVERNE J.LAVERNE "AXIS_ELDI", # RESP. : LAVERNE J.LAVERNE @@ -4152,12 +4536,15 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "D_PLAN_XFEM_CONT",# RESP. : GENIAUT S.GENIAUT "D_PLAN_GRAD_EPSI",# RESP. : MICHEL S.MICHEL "D_PLAN_GRAD_VARI",# RESP. : MICHEL S.MICHEL + "D_PLAN_GVNO", # RESP. : BEAURAIN J.BEAURAIN "D_PLAN_GRAD_SIGM",# RESP. : GRANET S.GRANET "PLAN_JOINT", # RESP. : LAVERNE J.LAVERNE + "PLAN_JOINT_HYME", # RESP. : LAVERNE J.LAVERNE "PLAN_INTERFACE", # RESP. : LAVERNE J.LAVERNE "PLAN_ELDI", # RESP. : LAVERNE J.LAVERNE "D_PLAN_ABSO", # RESP. : DEVESA G.DEVESA "D_PLAN_INCO", # RESP. : MICHEL S.MICHEL + "D_PLAN_INCO_UP", # RESP. : SFAYOLLE "D_PLAN_INCO_GD", # RESP. : MICHEL S.MICHEL "D_PLAN_SI", # RESP. : DESROCHES X.DESROCHES "DIS_T", # RESP. : FLEJOU J.L.FLEJOU @@ -4178,11 +4565,9 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "Q4G", # RESP. : DESROCHES X.DESROCHES "TUYAU_3M", # RESP. : PROIX J.M.PROIX "TUYAU_6M", # RESP. : PROIX J.M.PROIX - "SHB8", # RESP. : DESROCHES X.DESROCHES + "SHB", # RESP. : DESROCHES X.DESROCHES "D_PLAN_HHM", # RESP. : GRANET S.GRANET "D_PLAN_HM", # RESP. : GRANET S.GRANET - "D_PLAN_THH", # RESP. : GRANET S.GRANET - "D_PLAN_THHM", # RESP. : GRANET S.GRANET "D_PLAN_THM", # RESP. : GRANET S.GRANET "D_PLAN_HHMD", # RESP. : GRANET S.GRANET "D_PLAN_HH2MD", # RESP. : GRANET S.GRANET @@ -4210,8 +4595,6 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "D_PLAN_HH2S", # RESP. : GRANET S.GRANET "D_PLAN_2DG", # RESP. : GRANET S.GRANET "D_PLAN_DIL", # RESP. : GRANET S.GRANET - "AXIS_THH", # RESP. : GRANET S.GRANET - "AXIS_THHM", # RESP. : GRANET S.GRANET "AXIS_THM", # RESP. : GRANET S.GRANET "AXIS_HHM", # RESP. : GRANET S.GRANET "AXIS_HM", # RESP. : GRANET S.GRANET @@ -4239,8 +4622,6 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "AXIS_HH2S", # RESP. : GRANET S.GRANET "3D_HHM" , # RESP. : GRANET S.GRANET "3D_HM", # RESP. : GRANET S.GRANET - "3D_THH", # RESP. : GRANET S.GRANET - "3D_THV", # RESP. : GRANET S.GRANET "3D_THHM", # RESP. : GRANET S.GRANET "3D_THM", # RESP. : GRANET S.GRANET "3D_HHMD", # RESP. : GRANET S.GRANET @@ -4273,8 +4654,8 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "D_PLAN_HH2SUDM", # RESP. : GRANET S.GRANET "D_PLAN_HH2SUC", # RESP. : GRANET S.GRANET "D_PLAN_HH2SUDA", # RESP. : GRANET S.GRANET - "2D_JOINT_HMS", - "AXIS_JOINT_HMS", + "PLAN_JHMS", + "AXIS_JHMS", ) ) ), b_thermique =BLOC( condition = "PHENOMENE=='THERMIQUE'", @@ -4303,11 +4684,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, PARTITION =FACT(statut='d', PARALLELISME =SIMP(statut='f',typ='TXM',defaut="GROUP_ELEM", - into=("MAIL_CONTIGU","MAIL_DISPERSE","SOUS_DOMAINE","CENTRALISE","GROUP_ELEM")), - b_dist_sd =BLOC(condition = "PARALLELISME == 'SOUS_DOMAINE'", - PARTITION =SIMP(statut='o',typ=sd_feti_sdaster), - CHARGE_PROC0_SD =SIMP(statut='f',typ='I',defaut=0,val_min=0), - ), + into=("MAIL_CONTIGU","MAIL_DISPERSE","CENTRALISE","GROUP_ELEM")), b_dist_maille =BLOC(condition = "PARALLELISME in ('MAIL_DISPERSE','MAIL_CONTIGU')", CHARGE_PROC0_MA =SIMP(statut='f',typ='I',defaut=100,val_min=0,val_max=100), ), @@ -4316,40 +4693,160 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, VERI_JACOBIEN =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI', fr ="Vérification de la forme des mailles (jacobiens tous de meme signe).",), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 25/01/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE LEFEBVRE J.P.LEFEBVRE -AIDE=PROC(nom="AIDE",op=42, - UIinfo={"groupes":("Utilitaires",)}, - fr="Interroger et imprimer une documentation partielle sur les noms des concepts déjà définis et sur les couples" - +" (type d'éléments, option) disponibles dans la version.", - regles=(AU_MOINS_UN('CONCEPT','TYPE_ELEM', ),), - UNITE =SIMP(statut='f',typ='I',defaut=8), - TYPE_ELEM =FACT(fr="couple type_elem option",statut='f', - INITEL =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), - ), - CONCEPT =FACT(statut='f',max='**', - NOM =SIMP(fr="liste des noms de concept",statut='f',typ='TXM',validators=NoRepeat(),max='**',defaut="*"), - OPTION =SIMP(fr="option d'édition de concept",statut='f',typ='TXM',defaut="TOUT_TYPE", - into=("TOUT_TYPE","CREER","A_CREER",) ), +# RESPONSABLE PELLET J.PELLET + +def appl_cine_matr_prod(MATR_ASSE,**args): + if AsType(MATR_ASSE) == matr_asse_depl_r : return matr_asse_depl_r + if AsType(MATR_ASSE) == matr_asse_depl_c : return matr_asse_depl_c + if AsType(MATR_ASSE) == matr_asse_temp_r : return matr_asse_temp_r + if AsType(MATR_ASSE) == matr_asse_temp_c : return matr_asse_temp_c + if AsType(MATR_ASSE) == matr_asse_pres_r : return matr_asse_pres_r + if AsType(MATR_ASSE) == matr_asse_pres_c : return matr_asse_pres_c + raise AsException("type de concept resultat non prevu") + +APPL_CINE_MATR=OPER(nom="APPL_CINE_MATR",op=158,sd_prod=appl_cine_matr_prod, + fr="Appliquer les C.L. cinématiques sur la matrice", + reentrant='f', UIinfo={"groupes":("Résolution",)}, + MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r, + matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), +) ; +#& MODIF COMMANDE DATE 25/01/2011 AUTEUR PELLET J.PELLET +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE PELLET J.PELLET + +APPL_CINE_SCMB=OPER(nom="APPL_CINE_SCMB",op=159,sd_prod=cham_no_sdaster,reentrant='f', + fr="Application des C.L. cinématiques au second membre", + UIinfo={"groupes":("Résolution",)}, + CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), + MATR =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r, + matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ), + CHAM_CINE =SIMP(statut='f',typ=cham_no_sdaster), + + TITRE =SIMP(statut='f',typ='TXM',max='**'), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), +) ; +#& MODIF COMMANDE DATE 03/01/2011 AUTEUR ANDRIAM H.ANDRIAMBOLOLONA +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ANDRIAM H.ANDRIAMBOLOLONA + +from Macro.asse_elem_ssd_ops import asse_elem_ssd_ops + +def asse_elem_ssd_prod(self,RESU_ASSE_SSD,**args): + MTYPES = { + 'MODELE' : modele_gene, + 'NUME_DDL_GENE' : nume_ddl_gene, + 'RIGI_GENE' : matr_asse_gene_r, + 'MASS_GENE' : matr_asse_gene_r, + } + for res in RESU_ASSE_SSD: + for mc, typ in MTYPES.items(): + if res[mc]: + self.type_sdprod(res[mc], typ) + return None + +ASSE_ELEM_SSD=MACRO(nom="ASSE_ELEM_SSD", + op=asse_elem_ssd_ops, + sd_prod=asse_elem_ssd_prod, + reentrant='n', + fr="Enchainer les commandes DEFI_MODELE_GENE, NUME_DDL_GENE et ASSE_MATR_GENE", + UIinfo={"groupes":("Matrices/vecteurs",)}, + +# pour les concepts de sortie + RESU_ASSE_SSD = FACT( statut='o', max=1, + regles=(PRESENT_PRESENT('RIGI_GENE','NUME_DDL_GENE'), + PRESENT_PRESENT('MASS_GENE','NUME_DDL_GENE'),), + MODELE=SIMP(statut='o',typ=CO,defaut=None), + NUME_DDL_GENE=SIMP(statut='f',typ=CO,defaut=None), + RIGI_GENE=SIMP(statut='f',typ=CO,defaut=None), + MASS_GENE=SIMP(statut='f',typ=CO,defaut=None), + ), + + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), + +# pour DEFI_MODELE_GENE + SOUS_STRUC =FACT(statut='o',max='**', + NOM =SIMP(statut='o',typ='TXM' ), + MACR_ELEM_DYNA =SIMP(statut='o',typ=macr_elem_dyna ), + ANGL_NAUT =SIMP(statut='f',typ='R',max=3), + TRANS =SIMP(statut='f',typ='R',max=3), ), -) ; + LIAISON =FACT(statut='o',max='**', + SOUS_STRUC_1 =SIMP(statut='o',typ='TXM' ), + INTERFACE_1 =SIMP(statut='o',typ='TXM' ), + SOUS_STRUC_2 =SIMP(statut='o',typ='TXM' ), + INTERFACE_2 =SIMP(statut='o',typ='TXM' ), + regles=(EXCLUS('GROUP_MA_MAIT_1','GROUP_MA_MAIT_2','MAILLE_MAIT_2'), + EXCLUS('MAILLE_MAIT_1','GROUP_MA_MAIT_2','MAILLE_MAIT_2'),), + GROUP_MA_MAIT_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + MAILLE_MAIT_1 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA_MAIT_2 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + MAILLE_MAIT_2 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + OPTION =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("REDUIT","CLASSIQUE") ), + ), + VERIF =FACT(statut='d',max=1, + STOP_ERREUR =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + ), + + +# pour NUME_DDL_GENE + METHODE =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","ELIMINE") ), + STOCKAGE =SIMP(statut='f',typ='TXM',defaut="LIGN_CIEL",into=("LIGN_CIEL","PLEIN") ), + +) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -4471,14 +4968,19 @@ ASSE_MATRICE=OPER(nom="ASSE_MATRICE",op=12,sd_prod=asse_matrice_prod, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE PELLET J.PELLET - -ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster, - fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n', +# RESPONSABLE BODEL C.BODEL +ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene, + fr="Projection des chargements sur la base modale d'une sous structure", + reentrant='n', UIinfo={"groupes":("Matrices et vecteurs",)}, - VECT_ELEM =SIMP(statut='o',typ=vect_elem,max='**'), - NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ), - INFO =SIMP(statut='f',typ='I',into=(1,2,) ), + NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ), + METHODE =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","INITIAL") ), + b_nume =BLOC(condition = "METHODE == 'CLASSIQUE'", + CHAR_SOUS_STRUC =FACT(statut='o',max='**', + SOUS_STRUC =SIMP(statut='o',typ='TXM' ), + VECT_ASSE =SIMP(statut='o',typ=cham_no_sdaster ), + ), + ), ) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -4498,19 +5000,14 @@ ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE BODEL C.BODEL -ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene, - fr="Projection des chargements sur la base modale d'une sous structure", - reentrant='n', +# RESPONSABLE PELLET J.PELLET + +ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster, + fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n', UIinfo={"groupes":("Matrices et vecteurs",)}, - NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ), - METHODE =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","INITIAL") ), - b_nume =BLOC(condition = "METHODE == 'CLASSIQUE'", - CHAR_SOUS_STRUC =FACT(statut='o',max='**', - SOUS_STRUC =SIMP(statut='o',typ='TXM' ), - VECT_ASSE =SIMP(statut='o',typ=cham_no_sdaster ), - ), - ), + VECT_ELEM =SIMP(statut='o',typ=vect_elem,max='**'), + NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ), + INFO =SIMP(statut='f',typ='I',into=(1,2,) ), ) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -4583,10 +5080,10 @@ CALC_AMOR_MODAL=OPER(nom="CALC_AMOR_MODAL",op= 172,sd_prod=listr8_sdaster, SEUIL =SIMP(statut='f',typ='R',defaut= 0.3 ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 13/01/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -4622,15 +5119,15 @@ CALC_CHAM_ELEM=OPER(nom="CALC_CHAM_ELEM",op=38,sd_prod=cham_elem, # OPTION =SIMP(statut='o',typ='TXM', - into=("FLUX_ELGA_TEMP","FLUX_ELNO_TEMP", - "PRES_ELNO_DBEL","PRES_ELNO_REEL","PRES_ELNO_IMAG", + into=("FLUX_ELGA","FLUX_ELNO", + "PRAC_ELNO", "COOR_ELGA"), ), - b_thermique =BLOC(condition="OPTION in ('FLUX_ELNO_TEMP','FLUX_ELGA_TEMP',)", + b_thermique =BLOC(condition="OPTION in ('FLUX_ELNO','FLUX_ELGA',)", TEMP =SIMP(statut='o',typ=(cham_no_sdaster,)), ), - b_acoustique =BLOC(condition="OPTION in ('PRES_ELNO_DBEL','PRES_ELNO_REEL','PRES_ELNO_IMAG',)", + b_acoustique =BLOC(condition="OPTION in ('PRAC_ELNO',)", PRES =SIMP(statut='o',typ=(cham_no_sdaster,)), ), @@ -4716,10 +5213,10 @@ CALC_CHAR_SEISME=OPER(nom="CALC_CHAR_SEISME",op= 92,sd_prod=calc_char_seisme_pr ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 28/02/2011 AUTEUR BOTTONI M.BOTTONI # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -4751,8 +5248,7 @@ def calc_ecrevisse_prod(self,CHARGE_MECA,CHARGE_THER1,CHARGE_THER2,TABLE,DEBIT,* CALC_ECREVISSE=MACRO(nom="CALC_ECREVISSE",op=calc_ecrevisse_ops,sd_prod=calc_ecrevisse_prod,reentrant='n', UIinfo={"groupes":("Outils-métier",)},fr="Procedure de couplage avec Ecrevisse", - - regles = (UN_PARMI('LOGICIEL','VERSION'),), + regles = (UN_PARMI('LOGICIEL','VERSION'),), # CONCEPTS SORTANTS : 2 CHARGEMENTS THERMIQUE + 1 MECANIQUE + 2 TABLES POUR LE POST-TRAITEMENT # ******************************************** @@ -4884,16 +5380,16 @@ CALC_ECREVISSE=MACRO(nom="CALC_ECREVISSE",op=calc_ecrevisse_ops,sd_prod=calc_ecr COURBES =SIMP(statut='f',typ='TXM',into=("INTERACTIF","POSTSCRIPT","AUCUNE"),defaut="AUCUNE", fr="Generation eventuelle des courbes" ), LOGICIEL =SIMP(statut='f',typ='TXM',validators=LongStr(1,255),), - VERSION =SIMP(statut='f',typ='TXM',defaut="3.1.2",into = ("3.1.1","3.1.2")), + VERSION =SIMP(statut='f',typ='TXM',into = ("3.1.1","3.1.2","3.2")), ENTETE =SIMP(statut='f',typ='TXM',max='**',defaut="Titre du calcul Ecrevisse" ), IMPRESSION =SIMP(statut='f',typ='TXM',defaut='NON',into=( 'OUI','NON') ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -4925,8 +5421,7 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE', 'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'), - CONCEPT_SENSIBLE("SEPARE"), - DERIVABLE('RESULTAT'),), + ), TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), @@ -4984,48 +5479,49 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', "INDI_ERREUR","AUTRES","TOUTES"), ), b_toutes=BLOC( condition = "TYPE_OPTION == 'TOUTES'",fr="toutes les options evol elas", - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="SIEF_ELNO_ELGA", + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="SIEF_ELNO", # contraintes - into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL", - "SIPO_ELNO_DEPL","EFGE_ELNO_DEPL","EFGE_ELNO_CART","SIGM_ELNO_CART", - "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","SIGM_ELNO_TUYO","PROJ_ELEM_SIGM", + into=( "SIEF_ELNO","SIGM_ELNO","SIEF_ELGA", + "SIPO_ELNO","EFGE_ELNO","EFCA_ELNO","SICA_ELNO", + "SITU_ELNO","SIRO_ELEM","SIPM_ELNO", # déformations - "EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELGA_DEPL","EPSG_ELNO_DEPL", - "EPME_ELNO_DEPL","EPME_ELGA_DEPL","DEGE_ELNO_DEPL","EPSI_ELNO_TUYO", + "EPSI_ELNO","EPSI_ELGA","EPSG_ELGA","EPSG_ELNO", + "EPME_ELNO","EPME_ELGA","DEGE_ELNO","EPTU_ELNO", "EPVC_ELNO","EPVC_ELGA", # ENER - "EPOT_ELEM_DEPL","ECIN_ELEM_DEPL","ENEL_ELGA","ENEL_ELNO_ELGA", - "ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","DISS_ELGA","DISS_ELNO_ELGA", + "EPOT_ELEM","ECIN_ELEM","ENEL_ELGA","ENEL_ELNO", + "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","DISS_ELGA","DISS_ELNO", # estimateurs erreur - "SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM", - "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM", - "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM", - "SING_ELEM","SING_ELNO_ELEM", + "SIZ1_ELGA","ERZ1_ELEM","SIZ2_ELGA","ERZ2_ELEM", + "ERME_ELEM","ERME_ELNO", + "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM", + "SING_ELEM","SING_ELNO", # CRIT - "EQUI_ELNO_SIGM","EQUI_ELGA_SIGM","CRIT_ELNO_RUPT", - "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME", - "ENDO_ELGA","ENDO_ELNO_ELGA", - "ENDO_ELNO_SIGA","ENDO_ELNO_SINO","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO", - # derivees - "DEUL_ELGA_DEPL","DEDE_ELNO_DLDE","DESI_ELNO_DLSI", + "SIEQ_ELNO","SIEQ_ELGA","CRIT_ELNO", + "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA", + "ENDO_ELGA","ENDO_ELNO", + "SITQ_ELNO","EPTQ_ELNO", # autres - "VALE_NCOU_MAXI","PRES_DBEL_DEPL","VARC_ELGA"),), - - NOM_CHAM =SIMP(statut='f',typ='TXM',fr="nom du champ pour VALE_NCOU_MAXI", ), - NOM_CMP =SIMP(statut='f',typ='TXM',fr="nom de la composante pour VALE_NCOU_MAXI", ), - - b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \ - (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)", + "SPMX_ELGA","PRME_ELNO","VARC_ELGA"),), + +# Les 2 mots cles suivants ne sont utiles qu' a l'option SPMX_ELGA +# mais on est obligé de les laisser ici a cause des blocs + NOM_CHAM =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"), + fr="nom du champ pour SPMX_ELGA",), + NOM_CMP =SIMP(statut='f',typ='TXM',fr="nom de la composante pour SPMX_ELGA", ), + + b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \ + (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)", RESU_DUAL=SIMP(statut='o',typ=evol_elas,fr="resultat du probleme dual"),), b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \ (type(OPTION)==type(()) and 'SING_ELEM' in OPTION)", PREC_ERR=SIMP(statut='o',typ='R',val_min= 0., fr="precision demandee pour calculer la carte de taille des elements"), - TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM", - "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",), + TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM", + "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",), fr="choix de l'estimateur d'erreur"),), EXCIT =FACT(statut='f',max='**', @@ -5046,13 +5542,13 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', b_sigm_massif =BLOC( condition = "TYPE_OPTION == 'SIGM_MASSIF'", fr="options de contraintes elasticite 2D et 3D", - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO_ELGA', + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO', fr="option de calcul des contraintes", - into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL",),), + into=( "SIEF_ELNO","SIGM_ELNO","SIEF_ELGA",),), - b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO_DEPL','SIEF_ELGA_DEPL',) or \ - (type(OPTION)==type(()) and 'SIGM_ELNO_DEPL' in OPTION ) or \ - (type(OPTION)==type(()) and 'SIEF_ELGA_DEPL' in OPTION ) ", + b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO','SIEF_ELGA',) or \ + (type(OPTION)==type(()) and 'SIGM_ELNO' in OPTION ) or \ + (type(OPTION)==type(()) and 'SIEF_ELGA' in OPTION ) ", fr="charge contenant les temperatures ou autre charge", EXCIT =FACT(statut='f',max='**', CHARGE =SIMP(statut='o',typ=(char_meca,char_cine_meca) ),), @@ -5061,18 +5557,18 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', b_sigm_struct =BLOC( condition = "TYPE_OPTION == 'SIGM_STRUCT'", fr="options de contraintes elasticite poutres, coques, tuyaux", - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO_ELGA', + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO', fr="option de calcul des contraintes ou efforts generalises", - into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL","SIGM_ELNO_TUYO", - "SIPO_ELNO_DEPL","EFGE_ELNO_DEPL","EFGE_ELNO_CART","SIGM_ELNO_CART", - "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF"),), - - b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO_DEPL','SIEF_ELGA_DEPL',\ - 'SIPO_ELNO_DEPL','EFGE_ELNO_DEPL',) or \ - (type(OPTION)==type(()) and 'SIGM_ELNO_DEPL' in OPTION ) or \ - (type(OPTION)==type(()) and 'SIEF_ELGA_DEPL' in OPTION ) or \ - (type(OPTION)==type(()) and 'SIPO_ELNO_DEPL' in OPTION ) or \ - (type(OPTION)==type(()) and 'EFGE_ELNO_DEPL' in OPTION ) ", + into=( "SIEF_ELNO","SIGM_ELNO","SIEF_ELGA","SITU_ELNO", + "SIPO_ELNO","EFGE_ELNO","EFCA_ELNO","SICA_ELNO", + ),), + + b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO','SIEF_ELGA',\ + 'SIPO_ELNO','EFGE_ELNO',) or \ + (type(OPTION)==type(()) and 'SIGM_ELNO' in OPTION ) or \ + (type(OPTION)==type(()) and 'SIEF_ELGA' in OPTION ) or \ + (type(OPTION)==type(()) and 'SIPO_ELNO' in OPTION ) or \ + (type(OPTION)==type(()) and 'EFGE_ELNO' in OPTION ) ", fr="charge contenant les temperatures ou les efforts répartis (poutres) ou autre", EXCIT =FACT(statut='f',max='**', regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),), @@ -5092,15 +5588,15 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', b_epsi =BLOC( condition = "TYPE_OPTION=='EPSI'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPME_ELNO_DEPL","EPME_ELGA_DEPL", - "DEGE_ELNO_DEPL","EPSI_ELNO_TUYO","EPVC_ELNO","EPVC_ELGA",), + into=("EPSI_ELNO","EPSI_ELGA","EPME_ELNO","EPME_ELGA", + "DEGE_ELNO","EPTU_ELNO","EPVC_ELNO","EPVC_ELGA",), ), -b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ELGA_DEPL','EPSI_ELNO_DEPL','EPSI_ELNO_TUYO' ) or \ - (type(OPTION)==type(()) and 'EPSI_ELNO_DEPL' in OPTION ) or \ - (type(OPTION)==type(()) and 'EPSI_ELNO_TUYO' in OPTION ) or \ - (type(OPTION)==type(()) and 'EPSI_ELGA_DEPL' in OPTION ) or \ - (type(OPTION)==type(()) and 'EPME_ELNO_DEPL' in OPTION ) or \ - (type(OPTION)==type(()) and 'EPME_ELGA_DEPL' in OPTION ) ", +b_charge =BLOC( condition = "OPTION in ('EPME_ELNO','EPSI_ELGA','EPME_ELGA','EPSI_ELNO','EPTU_ELNO' ) or \ + (type(OPTION)==type(()) and 'EPSI_ELNO' in OPTION ) or \ + (type(OPTION)==type(()) and 'EPTU_ELNO' in OPTION ) or \ + (type(OPTION)==type(()) and 'EPSI_ELGA' in OPTION ) or \ + (type(OPTION)==type(()) and 'EPME_ELNO' in OPTION ) or \ + (type(OPTION)==type(()) and 'EPME_ELGA' in OPTION ) ", fr="charge contenant les temperatures", EXCIT =FACT(statut='f',max='**', CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou,char_cine_meca,) ),), @@ -5108,14 +5604,14 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ ), b_ener =BLOC( condition = "TYPE_OPTION=='ENER'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("EPOT_ELEM_DEPL","ECIN_ELEM_DEPL","ENEL_ELGA","ENEL_ELNO_ELGA", - "ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","DISS_ELGA","DISS_ELNO_ELGA",), + into=("EPOT_ELEM","ECIN_ELEM","ENEL_ELGA","ENEL_ELNO", + "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","DISS_ELGA","DISS_ELNO",), ), - b_charge =BLOC( condition = "OPTION in ('EPOT_ELEM_DEPL','ECIN_ELEM_DEPL','ENEL_ELGA','ENEL_ELNO_ELGA',) or \ - (type(OPTION)==type(()) and 'EPOT_ELEM_DEPL' in OPTION ) or \ + b_charge =BLOC( condition = "OPTION in ('EPOT_ELEM','ECIN_ELEM','ENEL_ELGA','ENEL_ELNO',) or \ + (type(OPTION)==type(()) and 'EPOT_ELEM' in OPTION ) or \ (type(OPTION)==type(()) and 'ENEL_ELGA' in OPTION ) or \ - (type(OPTION)==type(()) and 'ENEL_ELNO_ELGA' in OPTION ) or \ - (type(OPTION)==type(()) and 'ECIN_ELEM_DEPL' in OPTION ) ", + (type(OPTION)==type(()) and 'ENEL_ELNO' in OPTION ) or \ + (type(OPTION)==type(()) and 'ECIN_ELEM' in OPTION ) ", fr="charge contenant les temperatures", EXCIT =FACT(statut='f',max='**', CHARGE =SIMP(statut='f',typ=(char_meca,char_ther,char_acou) ),), @@ -5124,50 +5620,47 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ b_crit =BLOC( condition = "TYPE_OPTION=='CRIT'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("EQUI_ELNO_SIGM","EQUI_ELGA_SIGM", - "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME", - "ENDO_ELGA","ENDO_ELNO_ELGA", - "ENDO_ELNO_SIGA","ENDO_ELNO_SINO","CRIT_ELNO_RUPT","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO", + into=("SIEQ_ELNO","SIEQ_ELGA", + "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA", + "ENDO_ELGA","ENDO_ELNO", + "CRIT_ELNO","SITQ_ELNO","EPTQ_ELNO", ) ), EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),), ), - b_derivees =BLOC( condition = "TYPE_OPTION=='DERIVEES'", - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("DEUL_ELGA_DEPL","DEDE_ELNO_DLDE","DESI_ELNO_DLSI", - ) ),), b_autres =BLOC( condition = "TYPE_OPTION=='AUTRES'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("VALE_NCOU_MAXI","PRES_DBEL_DEPL", + into=("SPMX_ELGA","PRME_ELNO", ) ), - b_maxi =BLOC( condition = "OPTION=='VALE_NCOU_MAXI' or \ - (type(OPTION)==type(()) and 'VALE_NCOU_MAXI' in OPTION)", - NOM_CHAM =SIMP(statut='o',typ='TXM',fr="Nom du champ pour VALE_NCOU_MAXI" ), - NOM_CMP =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),), + b_maxi =BLOC( condition = "OPTION=='SPMX_ELGA' or \ + (type(OPTION)==type(()) and 'SPMX_ELGA' in OPTION)", + NOM_CHAM =SIMP(statut='o',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"), + fr="Nom du champ pour SPMX_ELGA",), + NOM_CMP =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour SPMX_ELGA"),), ), b_indi_erreur =BLOC( condition = "TYPE_OPTION=='INDI_ERREUR'", - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERRE_ELEM_SIGM", - into=("SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM", - "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM", - "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM", - "SING_ELEM","SING_ELNO_ELEM", + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERME_ELEM", + into=("SIZ1_ELGA","ERZ1_ELEM","SIZ2_ELGA","ERZ2_ELEM", + "ERME_ELEM","ERME_ELNO", + "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM", + "SING_ELEM","SING_ELNO", )), - b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \ - (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)", + b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \ + (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)", RESU_DUAL=SIMP(statut='o',typ=evol_elas,fr="resultat du probleme dual"),), b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \ (type(OPTION)==type(()) and 'SING_ELEM' in OPTION)", PREC_ERR=SIMP(statut='o',typ='R',val_min= 0., fr="precision demandee pour calculer la carte de taille des elements" ), - TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM", - "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",), + TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM", + "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",), fr="choix de l'estimateur d'erreur"),), EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", @@ -5184,55 +5677,55 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ ), b_toutes =BLOC( condition = "TYPE_OPTION == 'TOUTES'",fr="toutes les options evol noli", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=( "SIEF_ELNO_ELGA","PROJ_ELEM_SIGM", - "SIGM_ELNO_TUYO","SIGM_ELNO_COQU","PROJ_ELNO_SIGM", - "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","EFGE_ELNO_CART", + into=( "SIEF_ELNO","SIRO_ELEM", + "SITU_ELNO","SICO_ELNO", + "EFCA_ELNO","SIPO_ELNO","SIPM_ELNO", "FLHN_ELGA", # EPSI - "EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL", - "EPME_ELNO_DEPL","EPME_ELGA_DEPL","EPMG_ELNO_DEPL","EPMG_ELGA_DEPL", - "DEGE_ELNO_DEPL","EPSI_ELNO_TUYO", + "EPSI_ELNO","EPSI_ELGA","EPSG_ELNO","EPSG_ELGA", + "EPME_ELNO","EPME_ELGA","EPMG_ELNO","EPMG_ELGA", + "DEGE_ELNO","EPTU_ELNO", "EPSP_ELNO","EPSP_ELGA", "EPFD_ELNO","EPFD_ELGA","EPVC_ELNO","EPVC_ELGA", "EPFP_ELNO","EPFP_ELGA", "VARC_ELGA", - "VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU","CRIT_ELNO_RUPT", - "EXTR_ELGA_VARI","EXTR_ELNO_VARI", + "VARI_ELNO","VATU_ELNO","VACO_ELNO","CRIT_ELNO", + "VAEX_ELGA","VAEX_ELNO", # CRIT - "EQUI_ELNO_SIGM","EQUI_ELGA_SIGM","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO", - "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM", - "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM", - "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME", - "DCHA_ELNO_SIGM","DCHA_ELGA_SIGM","RADI_ELNO_SIGM","RADI_ELGA_SIGM", - "ENDO_ELGA","ENDO_ELNO_ELGA","INDI_LOCA_ELGA","SING_ELEM", - "SING_ELNO_ELEM","ENDO_ELNO_SIGA","ENDO_ELNO_SINO", - "PMPB_ELNO_SIEF","PMPB_ELGA_SIEF","ENEL_ELGA","ENEL_ELNO_ELGA", - "ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","VALE_NCOU_MAXI", - "DISS_ELGA","DISS_ELNO_ELGA"), + "SIEQ_ELNO","SIEQ_ELGA","SITQ_ELNO","EPTQ_ELNO", + "ERME_ELEM","ERME_ELNO","ERZ1_ELEM","ERZ2_ELEM", + "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM", + "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA", + "DERA_ELNO","DERA_ELGA", + "ENDO_ELGA","ENDO_ELNO","INDL_ELGA","SING_ELEM", + "SING_ELNO", + "PMPB_ELNO","PMPB_ELGA","ENEL_ELGA","ENEL_ELNO", + "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","SPMX_ELGA", + "DISS_ELGA","DISS_ELNO"), ), - NORME =SIMP(statut='f',typ='TXM',defaut="VMIS", - into=("VMIS","TOTAL","VMIS_CINE","TOTAL_CINE"), - fr="Type de norme pour les options RADI_ et DCHA_"), - NOM_CHAM =SIMP(statut='f',typ='TXM',fr="Nom du champ pour VALE_NCOU_MAXI"), - NOM_CMP =SIMP(statut='f',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"), +# Les 2 mots cles suivants ne sont utiles qu' a l'option SPMX_ELGA +# mais on est obligé de les laisser ici a cause des blocs + NOM_CHAM =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"), + fr="Nom du champ pour SPMX_ELGA",), + NOM_CMP =SIMP(statut='f',typ='TXM',fr="Nom de la composante pour SPMX_ELGA"), - b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \ - (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)", + b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \ + (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)", RESU_DUAL=SIMP(statut='o',typ=(evol_elas,evol_noli),fr="resultat du probleme dual"),), b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \ (type(OPTION)==type(()) and 'SING_ELEM' in OPTION)", PREC_ERR=SIMP(statut='o',typ='R',val_min= 0., fr="precision demandee pour calculer la carte de taille des elements" ), - TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM", - "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",), + TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM", + "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",), fr="choix de l'estimateur d'erreur"),), - b_extr = BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')", + b_extr = BLOC( condition = "OPTION in ('VAEX_ELNO','VAEX_ELGA')", NOM_VARI =SIMP(statut='o',typ='TXM',min= 1,max=1,fr="nom de la variable à extraire", into=("DPORO","DRHOLQ","DPVP","SATLIQ","EVP","IND_ETA","D","IND_END","TEMP_MAX","GAMP","PCR", "SEUIL_HYD","IND_HYD","PCOHE","COMP_ROC","SEUIL_ISO","ANG_DEV","X11","X22","X33","X12","X13","X23", @@ -5262,29 +5755,29 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ fr="options de contraintes non lin 2D et 3D", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', # contraintes - into=( "SIEF_ELNO_ELGA",),), + into=( "SIEF_ELNO",),), ), b_sigm_struct =BLOC( condition = "TYPE_OPTION == 'SIGM_STRUCT'", fr="options de contraintes non lin poutres, coques", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', # contraintes - into=( "SIEF_ELNO_ELGA","EFGE_ELNO_CART","SIGM_ELNO_TUYO","SIGM_ELNO_COQU", - "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF",),), + into=( "SIEF_ELNO","EFCA_ELNO","SITU_ELNO","SICO_ELNO", + ),), ), b_epsi =BLOC( condition = "TYPE_OPTION=='EPSI'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=( "EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL", - "EPME_ELNO_DEPL","EPME_ELGA_DEPL","EPMG_ELNO_DEPL","EPMG_ELGA_DEPL", - "EPSP_ELNO","EPSP_ELGA","DEGE_ELNO_DEPL","EPVC_ELNO","EPVC_ELGA", + into=( "EPSI_ELNO","EPSI_ELGA","EPSG_ELNO","EPSG_ELGA", + "EPME_ELNO","EPME_ELGA","EPMG_ELNO","EPMG_ELGA", + "EPSP_ELNO","EPSP_ELGA","DEGE_ELNO","EPVC_ELNO","EPVC_ELGA", "EPFD_ELNO","EPFD_ELGA","EPFP_ELNO","EPFP_ELGA"), ), EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),), ), - b_epstuyo =BLOC( condition = "OPTION == 'EPSI_ELNO_TUYO' or \ - (type(OPTION)==type(()) and 'EPSI_ELNO_TUYO' in OPTION) ", + b_epstuyo =BLOC( condition = "OPTION == 'EPTU_ELNO' or \ + (type(OPTION)==type(()) and 'EPTU_ELNO' in OPTION) ", EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),), ), @@ -5292,10 +5785,10 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ b_vari =BLOC( condition = "TYPE_OPTION=='VARI'", fr="Calcul et extraction des variables internes", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU", - "EXTR_ELGA_VARI","EXTR_ELNO_VARI"), + into=("VARI_ELNO","VATU_ELNO","VACO_ELNO", + "VAEX_ELGA","VAEX_ELNO"), ), - b_extr =BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')", + b_extr =BLOC( condition = "OPTION in ('VAEX_ELNO','VAEX_ELGA')", NOM_VARI =SIMP(statut='o',typ='TXM',min= 1,max=1,fr="nom de la variable à extraire", into=("DPORO","DRHOLQ","DPVP","SATLIQ","EVP","IND_ETA","D","IND_END","TEMP_MAX","GAMP","PCR", "SEUIL_HYD","IND_HYD","PCOHE","COMP_ROC","SEUIL_ISO","ANG_DEV","X11","X22","X33","X12","X13","X23", @@ -5306,8 +5799,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ b_ener =BLOC( condition = "TYPE_OPTION=='ENER'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","ENEL_ELGA","ENEL_ELNO_ELGA", - "DISS_ELGA","DISS_ELNO_ELGA",), + into=("ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","ENEL_ELGA","ENEL_ELNO", + "DISS_ELGA","DISS_ELNO",), ), EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),), @@ -5315,52 +5808,44 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ b_crit =BLOC( condition = "TYPE_OPTION=='CRIT'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("EQUI_ELNO_SIGM","EQUI_ELGA_SIGM", - "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME", - "ENDO_ELNO_SIGA","ENDO_ELNO_SINO","CRIT_ELNO_RUPT", - "ENDO_ELGA","ENDO_ELNO_ELGA", - "PMPB_ELNO_SIEF","PMPB_ELGA_SIEF","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO", + into=("SIEQ_ELNO","SIEQ_ELGA", + "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA", + "CRIT_ELNO", + "ENDO_ELGA","ENDO_ELNO", + "PMPB_ELNO","PMPB_ELGA","SITQ_ELNO","EPTQ_ELNO", ) ), ), b_autres =BLOC( condition = "TYPE_OPTION=='AUTRES'", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("VALE_NCOU_MAXI",) ), - b_maxi =BLOC( condition = "OPTION=='VALE_NCOU_MAXI' or \ - (type(OPTION)==type(()) and 'VALE_NCOU_MAXI' in OPTION)", - NOM_CHAM =SIMP(statut='o',typ='TXM',fr="Nom du champ pour VALE_NCOU_MAXI" ), - NOM_CMP =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),), + into=("SPMX_ELGA",) ), + b_maxi =BLOC( condition = "OPTION=='SPMX_ELGA' or \ + (type(OPTION)==type(()) and 'SPMX_ELGA' in OPTION)", + NOM_CHAM =SIMP(statut='o',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"), + fr="Nom du champ pour SPMX_ELGA",), + NOM_CMP =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour SPMX_ELGA"),), ), b_indi_erreur =BLOC( condition = "TYPE_OPTION=='INDI_ERREUR'", - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERRE_ELEM_SIGM", - into=("ERRE_ELEM_SIGM","ERRE_ELNO_ELEM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM", - "DCHA_ELNO_SIGM","DCHA_ELGA_SIGM","RADI_ELNO_SIGM","RADI_ELGA_SIGM", - "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM", - "SING_ELEM","SING_ELNO_ELEM",) ), - - b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \ - (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)", + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERME_ELEM", + into=("ERME_ELEM","ERME_ELNO","ERZ1_ELEM","ERZ2_ELEM", + "DERA_ELNO","DERA_ELGA", + "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM", + "SING_ELEM","SING_ELNO",) ), + + b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \ + (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \ + (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)", RESU_DUAL =SIMP(statut='o',typ=(evol_elas,evol_noli),fr="resultat du probleme dual")), b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \ (type(OPTION)==type(()) and 'SING_ELEM' in OPTION)", PREC_ERR=SIMP(statut='o',typ='R',val_min= 0., fr="precision demandee pour calculer la carte de taille des elements" ), - TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM", - "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",), + TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM", + "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",), fr="choix de l'estimateur d'erreur"),), - - b_indic = BLOC( condition ="OPTION in ('DCHA_ELNO_SIGM','DCHA_ELGA_SIGM','RADI_ELNO_SIGM','RADI_ELGA_SIGM') or\ - (type(OPTION)==type(()) and 'DCHA_ELNO_SIGM' in OPTION) or\ - (type(OPTION)==type(()) and 'DCHA_ELGA_SIGM' in OPTION) or\ - (type(OPTION)==type(()) and 'RADI_ELNO_SIGM' in OPTION) or\ - (type(OPTION)==type(()) and 'RADI_ELGA_SIGM' in OPTION) ", - NORME =SIMP(statut='f',typ='TXM',defaut="VMIS", - into=("VMIS","TOTAL","VMIS_CINE","TOTAL_CINE") ), - ), ), ), # fin bloc evol_noli @@ -5368,9 +5853,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ # thermique : evol_ther, fourier_ther b_ther =BLOC( condition = "AsType(RESULTAT) in (evol_ther,fourier_ther,)" ,fr="options thermiques", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("DEUL_ELGA_TEMP","DETE_ELNO_DLTE","FLUX_ELGA_TEMP","FLUX_ELNO_TEMP", - "HYDR_ELNO_ELGA","DURT_ELGA_META","DURT_ELNO_META", - "SOUR_ELGA_ELEC","ERRE_ELEM_TEMP","ERRE_ELNO_ELEM",),), + into=("FLUX_ELGA","FLUX_ELNO", + "DURT_ELNO","SOUR_ELGA","ERTH_ELEM","ERTH_ELNO",),), EXCIT =FACT(statut='f',max='**', regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),), CHARGE =SIMP(statut='o',typ=char_ther ), @@ -5387,8 +5871,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ # acoustique b_acou =BLOC( condition = "AsType(RESULTAT) in (acou_harmo,mode_acou,)",fr="options acoustiques", OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("PRES_ELNO_DBEL","PRES_ELNO_REEL","PRES_ELNO_IMAG", - "INTE_ELNO_ACTI","INTE_ELNO_REAC", + into=("PRAC_ELNO", "INTE_ELNO", ),), EXCIT =FACT(statut='f',max='**', regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),), @@ -5425,26 +5908,24 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), - SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', - fr="Liste des paramètres de sensibilité.", - ang="List of sensitivity parameters"), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -5558,21 +6039,21 @@ CALC_ESSAI = MACRO(nom = 'CALC_ESSAI', # Si on realise une modification structurale, on donne les DDL capteurs et interface b_modif = BLOC( condition="MODIFSTRUCT!=None", GROUP_NO_CAPTEURS = FACT( statut='f', max='**', - GROUP_NO = SIMP(statut='o',typ='TXM', max='**'), + GROUP_NO = SIMP(statut='o',typ=grno, max='**'), NOM_CMP = SIMP(statut='o',typ='TXM', max='**'), ), GROUP_NO_EXTERIEUR = FACT( statut='f', max='**', - GROUP_NO = SIMP(statut='o',typ='TXM', max='**'), + GROUP_NO = SIMP(statut='o',typ=grno, max='**'), NOM_CMP = SIMP(statut='o',typ='TXM', max='**'), ), ), ), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -5600,7 +6081,7 @@ CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",op=calc_europlexus_ops,sd_prod=cal UIinfo={"groupes":("Outils-métier","Dynamique",)}, fr="Chainage Code_Aster-Europlexus", - LOGICIEL = SIMP(statut='f', typ='TXM', defaut='/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d'), + LOGICIEL = SIMP(statut='f', typ='TXM', defaut='/home/europlex/EPXD/bin/europlexus'), MODELE = SIMP(statut='o',typ=modele_sdaster), CARA_ELEM = SIMP(statut='o',typ=cara_elem), @@ -5670,8 +6151,8 @@ CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",op=calc_europlexus_ops,sd_prod=cal EXCLUS('PAS_NBRE','PAS_INST',), EXCLUS('GROUP_NO','TOUT_GROUP_NO',), EXCLUS('GROUP_MA','TOUT_GROUP_MA',), ), - NOM_CHAM = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', defaut = ('DEPL',), - into=('DEPL','VITE','ACCE','SIEF_ELGA','EPSI_ELGA','VARI_ELGA'),), + NOM_CHAM = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',defaut=('DEPL',),into=('DEPL' + ,'VITE','ACCE','SIEF_ELGA','EPSI_ELGA','VARI_ELGA'),), PAS_INST = SIMP(statut='f',typ='R'), PAS_NBRE = SIMP(statut='f',typ='I'), GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), @@ -5682,7 +6163,7 @@ CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",op=calc_europlexus_ops,sd_prod=cal ), - ARCHIVAGE =FACT(statut='f', regles=( AU_MOINS_UN('PAS_NBRE','PAS_INST',), EXCLUS('PAS_NBRE','PAS_INST',), ), + ARCHIVAGE =FACT(statut='o', regles=( AU_MOINS_UN('PAS_NBRE','PAS_INST',), EXCLUS('PAS_NBRE','PAS_INST',), ), PAS_INST = SIMP(statut='f',typ='R'), PAS_NBRE = SIMP(statut='f',typ='I'), CONT_GENER = SIMP(statut='o',typ='TXM',defaut="NON",max=1,into=("OUI","NON")), @@ -5837,10 +6318,10 @@ CALC_FATIGUE=OPER(nom="CALC_FATIGUE",op= 151,sd_prod=calc_fatigue_prod,reentrant INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 02/02/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -5930,7 +6411,7 @@ CALC_FERRAILLAGE=OPER(nom="CALC_FERRAILLAGE",op=175,sd_prod=calc_ferrailage_prod # EPSIBE deformation béton # arrêt en erreur si: -# - EFGE_ELNO_DEPL n'a pas été précédemment calculé et n'est donc pas présent dans la structure de données RESULTAT +# - EFGE_ELNO n'a pas été précédemment calculé et n'est donc pas présent dans la structure de données RESULTAT # - si aucun CARA_ELEM n'est récupérable via la structure de données RESULTAT #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -6038,10 +6519,10 @@ CALC_FONC_INTERP=OPER(nom="CALC_FONC_INTERP",op= 134,sd_prod=calc_fonc_interp_pr TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 22/03/2011 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -6194,19 +6675,22 @@ CALC_FONCTION=MACRO(nom="CALC_FONCTION",op=calc_fonction_ops,sd_prod=calc_foncti ), NOM_PARA =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ), NOM_RESU =SIMP(statut='f',typ='TXM' ), - INTERPOL =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG") ), + INTERPOL =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG"), + fr="Type d'interpolation pour les abscisses et les ordonnées de la " \ + "fonction ou bien pour le paramètre de la nappe."), PROL_DROITE =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ), PROL_GAUCHE =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ), NOM_PARA_FONC =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ), - INTERPOL_FONC =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG") ), + INTERPOL_FONC =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG"), + fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction"), PROL_DROITE_FONC=SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ), PROL_GAUCHE_FONC=SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -6273,7 +6757,7 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -6282,11 +6766,12 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=1.0E-6,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", ALGORITHME =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ), @@ -6297,7 +6782,7 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -6309,7 +6794,59 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene, ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 14/12/2010 AUTEUR PELLET J.PELLET +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE DEVESA + +CALC_FORC_NONL=OPER(nom="CALC_FORC_NONL",op= 183,sd_prod=dyna_trans,reentrant='n', + fr="Créer un dyna_trans contenant des champs nommés 'DEPL' correspondant à 'FONL_NOEU' ", + UIinfo={"groupes":("Post-traitements","Résultats et champs",)}, + RESULTAT =SIMP(statut='o',typ=resultat_sdaster), + + regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE', + 'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'), + ), + TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), + NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), + NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), + NOEUD_CMP =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), + NOM_CAS =SIMP(statut='f',typ='TXM' ), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + FREQ =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster), + LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1, defaut="FONL_NOEU", + into=("FONL_NOEU",) ), + + MODELE =SIMP(statut='o',typ=modele_sdaster), + CHAM_MATER =SIMP(statut='f',typ=cham_mater), + CARA_ELEM =SIMP(statut='f',typ=cara_elem), + + COMP_INCR =C_COMP_INCR(), +) ; +#& MODIF COMMANDE DATE 07/12/2010 AUTEUR GENIAUT S.GENIAUT # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG @@ -6403,19 +6940,11 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, ), SYME_CHAR =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","ANTI","SANS") ), - COMP_ELAS =FACT(statut='f', - RELATION =SIMP(statut='f',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS") ), - CALCUL_CONTRAINTE =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), - DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ), - regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), - TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), - ), + COMP_ELAS =C_COMP_ELAS('CALC_G'), + COMP_INCR =FACT(statut='f', RELATION =SIMP(statut='f',typ='TXM',defaut="ELAS", - into=("ELAS","VMIS_ISOT_TRAC","VMIS_ISOT_LINE","VMIS_CINE_LINE","ELAS_VMIS_PUIS") ), + into=("ELAS","VMIS_ISOT_TRAC","VMIS_ISOT_LINE","VMIS_CINE_LINE","VMIS_ISOT_PUIS") ), DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT",into=("PETIT","PETIT_REAC") ), regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), @@ -6459,11 +6988,262 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GREFFET N.GREFFET +# +# MACRO DE COUPLAGE IFS AVEC SATURNE VIA YACS +# +from Macro.calc_ifs_dnl_ops import calc_ifs_dnl_ops +# +CALC_IFS_DNL= MACRO(nom='CALC_IFS_DNL',op=calc_ifs_dnl_ops,sd_prod=evol_noli,reentrant='f', + fr="Calcul de l'évolution dynamique d'une structure couplée à un domaine fluide (résolu avec le code Saturne) via YACS", + UIinfo={"groupes":("Résolution","Dynamique",)}, + regles=(AU_MOINS_UN('COMP_INCR','COMP_ELAS',), + CONCEPT_SENSIBLE('ENSEMBLE'),), +#IFS +#=> + GROUP_MA_IFS =SIMP(statut='o',typ=grma,max='**'), + NOM_CMP_IFS =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'), + UNITE_NOEUD =SIMP(statut='f',typ='I',defaut= 81 ), + UNITE_ELEM =SIMP(statut='f',typ='I',defaut= 82 ), + PAS_INIT =SIMP(statut='o',typ='R' ), +#<= +#IFS + MODELE =SIMP(statut='o',typ=modele_sdaster), + CHAM_MATER =SIMP(statut='o',typ=cham_mater), + MODE_STAT =SIMP(statut='f',typ=mode_meca), + CARA_ELEM =SIMP(statut='f',typ=cara_elem), + MASS_DIAG =SIMP(statut='f',typ='TXM',into=("OUI","NON",) ), +#IFS +#=> +#(une charge force nodale est fournie par le couplage avec code_saturne + EXCIT =FACT(statut='f',max='**', +#<= +#IFS + regles=(PRESENT_ABSENT('FONC_MULT','ACCE'), + PRESENT_PRESENT('ACCE','VITE','DEPL'), + # PRESENT_ABSENT('MULT_APPUI','FONC_MULT'), + ), + TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE", + into=("FIXE_CSTE","SUIV","DIDI")), +#IFS +#=> +#(une charge force nodale est fournie par le couplage avec code_saturne +# CHARGE =SIMP(statut='o',typ=(char_meca,char_cine_meca)), + CHARGE =SIMP(statut='f',typ=(char_meca,char_cine_meca)), +#<= +#IFS + FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + DEPL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + ACCE =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + VITE =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + MULT_APPUI =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), + DIRECTION =SIMP(statut='f',typ='R',max='**'), + NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + ), + EXCIT_GENE =FACT(statut='f',max='**', + FONC_MULT =SIMP(statut='f',typ=fonction_sdaster,max='**' ), + VECT_GENE =SIMP(statut='f',typ=vect_asse_gene,max='**' ), + ), + CONTACT =SIMP(statut='f',typ=char_contact), + SOUS_STRUC =FACT(statut='f',min=01,max='**', + regles=(UN_PARMI('TOUT','SUPER_MAILLE'),), + CAS_CHARGE =SIMP(statut='o',typ='TXM' ), + TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), + SUPER_MAILLE=SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',), + FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + ), + AMOR_RAYL_RIGI = SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE"),), + AMOR_MODAL =FACT(statut='f', + regles=(EXCLUS('AMOR_REDUIT','LIST_AMOR'),), + MODE_MECA =SIMP(statut='f',typ=mode_meca), + AMOR_REDUIT =SIMP(statut='f',typ='R',max='**' ), + LIST_AMOR =SIMP(statut='f',typ=listr8_sdaster ), + NB_MODE =SIMP(statut='f',typ='I',defaut= 9999 ), + REAC_VITE =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), + ), + PROJ_MODAL =FACT(statut='f',max='**', + MODE_MECA =SIMP(statut='o',typ=mode_meca), + NB_MODE =SIMP(statut='f',typ='I',defaut= 9999 ), + regles=(PRESENT_PRESENT('MASS_GENE','RIGI_GENE'),), + MASS_GENE =SIMP(statut='f',typ=matr_asse_gene_r), + RIGI_GENE =SIMP(statut='f',typ=matr_asse_gene_r), + AMOR_GENE =SIMP(statut='f',typ=matr_asse_gene_r), + DEPL_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene), + VITE_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene), + ACCE_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene), + ), +#------------------------------------------------------------------- + COMP_INCR =C_COMP_INCR(), +#------------------------------------------------------------------- + COMP_ELAS =C_COMP_ELAS('DYNA_NON_LINE'), +#------------------------------------------------------------------- + b_reuse =BLOC(condition = "reuse",fr="en mode concept reentrant : ETAT_INIT obligatoire", + ETAT_INIT =FACT(statut='o', + regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','VITE','ACCE','SIGM','VARI',), + EXCLUS('EVOL_NOLI','DEPL',), + EXCLUS('EVOL_NOLI','VITE'), + EXCLUS('EVOL_NOLI','ACCE'), + EXCLUS('EVOL_NOLI','SIGM',), + EXCLUS('EVOL_NOLI','VARI',), + EXCLUS('NUME_ORDRE','INST'), ), + DEPL =SIMP(statut='f',typ=cham_no_sdaster), + VITE =SIMP(statut='f',typ=cham_no_sdaster), + ACCE =SIMP(statut='f',typ=cham_no_sdaster), + SIGM =SIMP(statut='f',typ=(cham_elem,carte_sdaster)), + VARI =SIMP(statut='f',typ=cham_elem), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + NUME_ORDRE =SIMP(statut='f',typ='I'), + INST =SIMP(statut='f',typ='R'), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), + NUME_DIDI =SIMP(statut='f',typ='I'), + INST_ETAT_INIT =SIMP(statut='f',typ='R'), + ),), + b_not_reuse =BLOC(condition = "not reuse",fr="en mode concept non reentrant : ETAT_INIT facultatif", + ETAT_INIT =FACT(statut='f', + regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','VITE','ACCE','SIGM','VARI',), + EXCLUS('EVOL_NOLI','DEPL',), + EXCLUS('EVOL_NOLI','VITE'), + EXCLUS('EVOL_NOLI','ACCE'), + EXCLUS('EVOL_NOLI','SIGM',), + EXCLUS('EVOL_NOLI','VARI',), + EXCLUS('NUME_ORDRE','INST'), ), + DEPL =SIMP(statut='f',typ=cham_no_sdaster), + VITE =SIMP(statut='f',typ=cham_no_sdaster), + ACCE =SIMP(statut='f',typ=cham_no_sdaster), + SIGM =SIMP(statut='f',typ=(cham_elem,carte_sdaster)), + VARI =SIMP(statut='f',typ=cham_elem), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + NUME_ORDRE =SIMP(statut='f',typ='I'), + INST =SIMP(statut='f',typ='R'), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), + NUME_DIDI =SIMP(statut='f',typ='I'), + INST_ETAT_INIT =SIMP(statut='f',typ='R'), + ),), +#------------------------------------------------------------------- +#IFS : pas besoin d'INCREMENT +# INCREMENT =C_INCREMENT(), +#------------------------------------------------------------------- + SCHEMA_TEMPS =FACT(statut='o', + SCHEMA =SIMP(statut='o',min=1,max=1,typ='TXM', + into=("DIFF_CENT","TCHAMWA","NEWMARK","HHT","THETA_METHODE","KRENK"),), + COEF_MASS_SHIFT =SIMP(statut='f',typ='R',defaut= 0.0E+0 ), + b_tchamwa = BLOC(condition="SCHEMA=='TCHAMWA'", + PHI =SIMP(statut='f',typ='R',defaut= 1.05),), + + b_newmark = BLOC(condition="SCHEMA=='NEWMARK'", + BETA =SIMP(statut='f',typ='R',defaut= 0.25), + GAMMA =SIMP(statut='f',typ='R',defaut= 0.5),), + + b_hht = BLOC(condition="SCHEMA=='HHT'", + ALPHA =SIMP(statut='f',typ='R',defaut= -0.3 ), + MODI_EQUI =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),), + + b_theta = BLOC(condition="SCHEMA=='THETA_METHODE'", + THETA =SIMP(statut='f',typ='R',defaut= 1.,val_min=0.5,val_max=100. ),), + + b_krenk = BLOC(condition="SCHEMA=='KRENK'", + KAPPA =SIMP(statut='f',typ='R',defaut= 1.0,val_min=1.0,val_max=100. ),), + + b_explicit= BLOC(condition="SCHEMA=='TCHAMWA'or SCHEMA=='DIFF_CENT'", + STOP_CFL =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),), + FORMULATION =SIMP(statut='o',typ='TXM',into=("ACCELERATION",),),), + + b_implicit= BLOC(condition="SCHEMA!='TCHAMWA'and SCHEMA!='DIFF_CENT'", + FORMULATION =SIMP(statut='o',max=1,typ='TXM',into=("DEPLACEMENT","VITESSE","ACCELERATION"),),), + ), +#------------------------------------------------------------------- + NEWTON =C_NEWTON(), +#------------------------------------------------------------------- + RECH_LINEAIRE =C_RECH_LINEAIRE(), +#------------------------------------------------------------------- + CONVERGENCE =C_CONVERGENCE(), +#------------------------------------------------------------------- + SOLVEUR =C_SOLVEUR(), +#------------------------------------------------------------------- + OBSERVATION =C_OBSERVATION(), +#------------------------------------------------------------------- + SUIVI_DDL =C_SUIVI_DDL(), +#------------------------------------------------------------------- + AFFICHAGE =C_AFFICHAGE(), +#------------------------------------------------------------------- + ARCHIVAGE =C_ARCHIVAGE(), +#------------------------------------------------------------------- + CRIT_FLAMB =FACT(statut='f',min=1,max=1, + NB_FREQ =SIMP(statut='f',typ='I',max=1,defaut=3), + CHAR_CRIT =SIMP(statut='f',typ='R',min=2,max=2,defaut=(-10.0,10.), + fr="Valeur des deux charges critiques délimitant la bande de recherche en HPP"), + RIGI_GEOM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), + bloc_ddl_exclus=BLOC(condition="(RIGI_GEOM=='NON')", + DDL_EXCLUS =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=40, + into=('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI', + 'TEMP','PRE1','PRE2','UI2','UI3','VI2','VI3','WI2','WI3','UO2', + 'UO3','VO2','VO3','WO2','WO3','UI4','UI5','VI4','VI5','WI4', + 'WI5','UO4','UO5','VO4','VO5','WO4','WO5','UI6','UO6','VI6', + 'VO6','WI6','WO6','WO','WI1','WO1','GONF','LIAISON','DCX', + 'DCY','DCZ','H1X','H1Y','H1Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z', + 'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22', + 'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23', + 'PRES31','PRES32','PRES33','VARI','LAG_GV')),), + INST_CALCUL =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ), + ), + MODE_VIBR =FACT(statut='f',min=1,max=1, + MATR_RIGI =SIMP(statut='f',typ='TXM',defaut="ELASTIQUE",into=("ELASTIQUE","TANGENTE","SECANTE",) ), + NB_FREQ =SIMP(statut='f',typ='I',max=1,defaut=3, + fr="Nombre de fréquences propres à calculer"), + BANDE =SIMP(statut='f',typ='R',min=2,max=2, + fr="Valeur des deux fréquences délimitant la bande de recherche",), + INST_CALCUL =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ), + ), +#------------------------------------------------------------------- + SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', + fr="Liste des paramètres de sensibilité", + ang="List of sensitivity parameters"), +#------------------------------------------------------------------- + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), + b_info=BLOC(condition="(INFO==2)", + fr="filtre les messages émis dans le .mess selon le type de message demandé", + INFO_DBG = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(), + into=("CONTACT", + "MECA_NON_LINE", + "PILOTAGE", + "FACTORISATION", + "APPARIEMENT"), + ), + ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), +) ; +#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR # (AT YOUR OPTION) ANY LATER VERSION. @@ -6491,10 +7271,10 @@ CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_fonction, TITRE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1 , 2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -6553,7 +7333,7 @@ CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -6561,12 +7341,13 @@ CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r, b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS", TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), - POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=1.0E-6,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", ALGORITHME =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ), @@ -6577,10 +7358,10 @@ CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), - b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", + b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", fr="Paramètres des préconditionneurs JACOBI et SOR", RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), @@ -6744,10 +7525,10 @@ CALC_MATR_ELEM=OPER(nom="CALC_MATR_ELEM",op= 9,sd_prod=calc_matr_elem_prod CHARGE =SIMP(statut='o',typ=char_meca,validators=NoRepeat(),max='**' ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 13/01/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -6796,12 +7577,12 @@ CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o', MAILLE =SIMP(statut='f',typ=ma, validators=NoRepeat(), max='**'), ), OPTION =SIMP(statut='f',typ='TXM' - ,into=("META_ELNO_TEMP",) ), + ,into=("META_ELNO",) ), ) ; -#& MODIF COMMANDE DATE 23/11/2010 AUTEUR COURTOIS M.COURTOIS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -6818,51 +7599,155 @@ CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o', # ====================================================================== # RESPONSABLE COURTOIS M.COURTOIS +def calc_miss_sdprod(self, TYPE_RESU, **kwargs): + if TYPE_RESU == 'TABLE': + return table_sdaster + elif TYPE_RESU == 'HARM_GENE': + return harm_gene + elif TYPE_RESU == 'TRAN_GENE': + return tran_gene + else: + return None + from Macro.calc_miss_ops import calc_miss_ops -CALC_MISS = MACRO(nom="CALC_MISS",op=calc_miss_ops, - fr="Préparation des données puis exécution du logiciel MISS3D", +CALC_MISS = MACRO(nom="CALC_MISS", + op=calc_miss_ops, + sd_prod=calc_miss_sdprod, + fr="Préparation des données, exécution du logiciel Miss3D, et post-traitement", UIinfo={"groupes":("Résolution","Outils-métier",)}, - OPTION = FACT(statut='o', - MODULE = SIMP(statut='f',typ='TXM',defaut="MISS_IMPE", into=("MISS_IMPE",)), - ), - TABLE_SOL = SIMP(statut='o', typ=table_sdaster), - - PROJET = SIMP(statut='f', typ='TXM'), - REPERTOIRE = SIMP(statut='f', typ='TXM'), - VERSION = SIMP(statut='f', typ='TXM', into=("V1_4",), defaut="V1_4"), - - UNITE_IMPR_ASTER = SIMP(statut='f',typ='I',defaut=25), - UNITE_RESU_IMPE = SIMP(statut='f',typ='I',defaut=30), - UNITE_RESU_FORC = SIMP(statut='f',typ='I',defaut=0), - PARAMETRE = FACT(statut='o', - regles=(PRESENT_PRESENT('OFFSET_MAX','OFFSET_NB'), - PRESENT_PRESENT('FREQ_MIN','FREQ_MAX','FREQ_PAS'), - PRESENT_PRESENT('LFREQ_NB','LFREQ_LISTE'), - UN_PARMI('FREQ_MIN', 'LFREQ_NB'), - PRESENT_PRESENT('SPEC_MAX','SPEC_NB'),), - FREQ_MIN = SIMP(statut='f',typ='R'), - FREQ_MAX = SIMP(statut='f',typ='R'), - FREQ_PAS = SIMP(statut='f',typ='R'), - LFREQ_NB = SIMP(statut='f',typ='I'), - LFREQ_LISTE = SIMP(statut='f',typ='R',max='**'), - Z0 = SIMP(statut='f',typ='R',defaut=0.), - SURF = SIMP(statut='f',typ='TXM',into=("OUI","NON",),defaut="NON"), - ISSF = SIMP(statut='f',typ='TXM',into=("OUI","NON",),defaut="NON"), - TYPE = SIMP(statut='f',typ='TXM',into=("BINAIRE","ASCII",),defaut="ASCII"), - RFIC = SIMP(statut='f',typ='R',defaut=0.), - - ALGO = SIMP(statut='f',typ='TXM',into=("DEPL","REGU")), - DREF = SIMP(statut='f',typ='R'), - SPEC_MAX = SIMP(statut='f',typ='R'), - SPEC_NB = SIMP(statut='f',typ='I'), - OFFSET_MAX = SIMP(statut='f',typ='R'), - OFFSET_NB = SIMP(statut='f',typ='I'), - - FICH_POST_TRAI = SIMP(statut='f',typ='TXM'), - ), - INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2)), + TYPE_RESU = SIMP(statut='o', typ='TXM', into=('HARM_GENE', 'TRAN_GENE', 'TABLE', 'FICHIER'), + fr="Type de résultat produit en post-traitement. FICHIER : pas de post-traitement"), + PROJET = SIMP(statut='f', typ='TXM', defaut='MODELE', + fr="Nom de l'étude Miss"), + REPERTOIRE = SIMP(statut='f', typ='TXM', + fr="Répertoire de travail de Miss"), + VERSION = SIMP(statut='f', typ='TXM', into=("V6.6","V6.5"), defaut="V6.6", + fr="Version de Miss utilisée"), + + TABLE_SOL = SIMP(statut='o', typ=table_sdaster, + fr="Table des propriétés du sol"), + + # pas de post-traitement + b_fichier = BLOC(condition="TYPE_RESU == 'FICHIER'", + regles=(UN_PARMI('MACR_ELEM_DYNA', 'BASE_MODALE'),), + MACR_ELEM_DYNA = SIMP(statut='f', typ=macr_elem_dyna, + fr="Macro élément produit en amont"), + BASE_MODALE = SIMP(statut='f', typ=mode_meca, + fr="Base de modes"), + b_base_modale = BLOC(condition="BASE_MODALE is not None", + MATR_RIGI = SIMP(statut='f', typ=(matr_asse_depl_r, matr_asse_depl_c),), + MATR_MASS = SIMP(statut='f', typ=matr_asse_depl_r ), + ), + AMOR_REDUIT = SIMP(statut='f', typ='R', max='**'), + GROUP_MA_INTERF = SIMP(statut='o', typ=grma, max='**', + fr="Groupe de mailles de l'interface"), + + UNITE_IMPR_ASTER = SIMP(statut='f', typ='I', defaut=25, + fr="Unité des résultats transmis par Code_Aster à Miss"), + UNITE_RESU_IMPE = SIMP(statut='f', typ='I', defaut=38, + fr="Unité logique des impédances écrites par Miss"), + UNITE_RESU_FORC = SIMP(statut='f', typ='I', defaut=28, + fr="Unité logique des forces sismiques écrites par Miss"), + ), + # si post-traitement + b_donnees = BLOC(condition="TYPE_RESU != 'FICHIER'", + MACR_ELEM_DYNA = SIMP(statut='f', typ=macr_elem_dyna, + fr="Macro élément produit en amont"), + BASE_MODALE = SIMP(statut='o', typ=mode_meca, + fr="Base de modes"), + MATR_RIGI = SIMP(statut='o', typ=(matr_asse_depl_r, matr_asse_depl_c),), + MATR_MASS = SIMP(statut='o', typ=matr_asse_depl_r ), + AMOR_REDUIT = SIMP(statut='o', typ='R', max='**'), + GROUP_MA_INTERF = SIMP(statut='o', typ=grma, max='**', + fr="Groupe de mailles de l'interface"), + + UNITE_IMPR_ASTER = SIMP(statut='f', typ='I', + fr="Unité des résultats transmis par Code_Aster à Miss"), + UNITE_RESU_IMPE = SIMP(statut='f', typ='I', + fr="Unité logique des impédances à relire."), + UNITE_RESU_FORC = SIMP(statut='f', typ='I', + fr="Unité logique des forces sismiques à relire"), + ), + # Paramètres du calcul Miss + PARAMETRE = FACT(statut='o', + regles=(PRESENT_PRESENT('OFFSET_MAX', 'OFFSET_NB'), + PRESENT_PRESENT('FREQ_MIN', 'FREQ_MAX','FREQ_PAS'), + UN_PARMI('FREQ_MIN', 'LIST_FREQ'), + PRESENT_PRESENT('SPEC_MAX', 'SPEC_NB'),), + FREQ_MIN = SIMP(statut='f', typ='R'), + FREQ_MAX = SIMP(statut='f', typ='R'), + FREQ_PAS = SIMP(statut='f', typ='R'), + LIST_FREQ = SIMP(statut='f', typ='R', max='**'), + Z0 = SIMP(statut='f', typ='R', defaut=0.), + SURF = SIMP(statut='f', typ='TXM', into=("OUI","NON",), defaut="NON"), + RFIC = SIMP(statut='f', typ='R', defaut=0.), + + ALGO = SIMP(statut='f', typ='TXM', into=("DEPL","REGU")), + DREF = SIMP(statut='f', typ='R'), + SPEC_MAX = SIMP(statut='f', typ='R'), + SPEC_NB = SIMP(statut='f', typ='I'), + OFFSET_MAX = SIMP(statut='f', typ='R'), + OFFSET_NB = SIMP(statut='f', typ='I'), + TYPE = SIMP(statut='f', typ='TXM', into=("BINAIRE","ASCII",), defaut="ASCII"), + ), + # Post-traitement type 1 - tran_gene + b_post_tran_gene = BLOC(condition="TYPE_RESU == 'TRAN_GENE'", + regles=(AU_MOINS_UN('ACCE_X', 'ACCE_Y', 'ACCE_Z'),), + MODELE = SIMP(statut='o', typ=(modele_sdaster),), + ACCE_X = SIMP(statut='f', typ=fonction_sdaster,), + ACCE_Y = SIMP(statut='f', typ=fonction_sdaster,), + ACCE_Z = SIMP(statut='f', typ=fonction_sdaster,), + INST_FIN = SIMP(statut='o', typ='R', fr="Instant final du calcul"), + PAS_INST = SIMP(statut='o', typ='R', fr="Pas de temps du calcul"), + ), + # Post-traitement type 1 - harm_gene + b_post_harm_gene = BLOC(condition="TYPE_RESU == 'HARM_GENE'", + regles=(AU_MOINS_UN('EXCIT_HARMO', 'ACCE_X', 'ACCE_Y', 'ACCE_Z'), + PRESENT_ABSENT('EXCIT_HARMO', 'ACCE_X', 'ACCE_Y', 'ACCE_Z', 'INST_FIN'), + ENSEMBLE('INST_FIN', 'PAS_INST'),), + MODELE = SIMP(statut='o', typ=(modele_sdaster),), + ACCE_X = SIMP(statut='f', typ=fonction_sdaster,), + ACCE_Y = SIMP(statut='f', typ=fonction_sdaster,), + ACCE_Z = SIMP(statut='f', typ=fonction_sdaster,), + INST_FIN = SIMP(statut='f', typ='R', fr="Instant final du calcul"), + PAS_INST = SIMP(statut='f', typ='R', fr="Pas de temps du calcul"), + # identique à EXCIT de DYNA_LINE_HARM au type attendu pour VECT_ASSE près + EXCIT_HARMO = FACT(statut='f', max='**', + regles=(UN_PARMI('VECT_ASSE', 'CHARGE'), + UN_PARMI('FONC_MULT', 'FONC_MULT_C', 'COEF_MULT', 'COEF_MULT_C'),), + VECT_ASSE = SIMP(statut='f', typ=cham_no_sdaster,), + CHARGE = SIMP(statut='f', typ=char_meca), + TYPE_CHARGE = SIMP(statut='f', typ='TXM', defaut="FIXE", into=("FIXE",),), + FONC_MULT_C = SIMP(statut='f', typ=(fonction_c, formule_c),), + COEF_MULT_C = SIMP(statut='f', typ='C'), + FONC_MULT = SIMP(statut='f', typ=(fonction_sdaster, nappe_sdaster, formule) ), + COEF_MULT = SIMP(statut='f', typ='R'), + PHAS_DEG = SIMP(statut='f', typ='R', defaut=0.), + PUIS_PULS = SIMP(statut='f', typ='I', defaut=0), + ), + ), + # Post-traitement type 2 + b_post_table = BLOC(condition="TYPE_RESU == 'TABLE'", + regles=(AU_MOINS_UN('ACCE_X', 'ACCE_Y', 'ACCE_Z'),), + MODELE = SIMP(statut='o', typ=(modele_sdaster),), + GROUP_NO = SIMP(statut='o', typ=grno, max='**', + fr="Liste des groupes de noeud de post-traitement"), + ACCE_X = SIMP(statut='f', typ=fonction_sdaster,), + ACCE_Y = SIMP(statut='f', typ=fonction_sdaster,), + ACCE_Z = SIMP(statut='f', typ=fonction_sdaster,), + INST_FIN = SIMP(statut='o', typ='R', fr="Instant final du calcul"), + PAS_INST = SIMP(statut='o', typ='R', fr="Pas de temps du calcul"), + NORME = SIMP(statut='o', typ='R', + fr="Valeur de la norme du spectre d'oscillateur" ), + AMOR_SPEC_OSCI = SIMP(statut='o', typ='R', max='**', + fr="Amortissement du spectre d'oscillateur"), + LIST_FREQ = SIMP(statut='f', typ=listr8_sdaster, + fr="Fréquences utilisées pour le calcul du spectre d'oscillateur"), + ), + + INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2)), ) #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS @@ -7023,10 +7908,10 @@ CALC_MODE_ROTATION=MACRO(nom="CALC_MODE_ROTATION",op=calc_mode_rotation_ops,sd_p PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 5.E-3 ), STURM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 02/02/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -7050,14 +7935,10 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='f', fr="Enrichir une SD Résultat par des champs aux noeuds calculés à partir de champs aux éléments évalués aux noeuds", UIinfo={"groupes":("Post-traitements","Résultats et champs",)}, RESULTAT =SIMP(statut='o',typ=resultat_sdaster), - SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', - fr="Liste des paramètres de sensibilité.", - ang="List of sensitivity parameters"), regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE', 'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'), - CONCEPT_SENSIBLE("SEPARE"), - DERIVABLE('RESULTAT'),), + ), TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), @@ -7075,46 +7956,31 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='f', PRECISION =SIMP(statut='o',typ='R',),), OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', into=("FORC_NODA","REAC_NODA", - "FORC_NODA_NONL", - "DCHA_NOEU_SIGM", - "DEGE_NOEU_DEPL", - "DETE_NOEU_DLTE", - "DEDE_NOEU_DLDE", - "DESI_NOEU_DLSI", - "DURT_NOEU_META", - "EFGE_NOEU_CART","EFGE_NOEU_DEPL", - "ENDO_NOEU_SINO", - "ENEL_NOEU_ELGA", - "EPMG_NOEU_DEPL", - "EPSA_NOEU", - "EPSG_NOEU_DEPL", - "EPSI_NOEU_DEPL", + "DERA_NOEU", + "DURT_NOEU", + "EFCA_NOEU","EFGE_NOEU", + "ENDO_NOEU", + "ENEL_NOEU", + "EPMG_NOEU", + "EPSG_NOEU", + "EPSI_NOEU", "EPSP_NOEU" , "EPVC_NOEU","EPFD_NOEU","EPFP_NOEU","EPFP_NOEU", - "EQUI_NOEU_EPME","EQUI_NOEU_EPSI","EQUI_NOEU_SIGM", - "ERRE_NOEU_ELEM","QIRE_NOEU_ELEM", - "FLUX_NOEU_TEMP", - "HYDR_NOEU_ELGA", - "INTE_NOEU_ACTI","INTE_NOEU_REAC", - "META_NOEU_TEMP", - "PMPB_NOEU_SIEF", - "PRES_NOEU_DBEL","PRES_NOEU_IMAG","PRES_NOEU_REEL", - "RADI_NOEU_SIGM", - "SIEF_NOEU_ELGA", - "SIGM_NOEU_CART","SIGM_NOEU_COQU","SIGM_NOEU_DEPL", - "SIGM_NOEU_SIEF", - "SIPO_NOEU_DEPL","SIPO_NOEU_SIEF", - "VARI_NOEU","EXTR_NOEU_VARI","VARI_NOEU_ELGA",) ), - - b_forc_reac =BLOC(condition = """(OPTION == 'FORC_NODA') or (type(OPTION) == type(()) and 'FORC_NODA' in OPTION) or\ - (OPTION == 'REAC_NODA') or (type(OPTION) == type(()) and 'REAC_NODA' in OPTION)""", - MODELE =SIMP(statut='f',typ=modele_sdaster), - ), - b_forc_nonl =BLOC(condition = """(OPTION == 'FORC_NODA_NONL')""", - MODELE =SIMP(statut='f',typ=modele_sdaster), - COMP_INCR =C_COMP_INCR(), - ), + "EPMQ_NOEU","EPEQ_NOEU","SIEQ_NOEU", + "ERME_NOEU","ERTH_NOEU","QIRE_NOEU", + "FLUX_NOEU", + "HYDR_NOEU", + "INTE_NOEU", + "META_NOEU", + "PMPB_NOEU", + "PRAC_NOEU", + "SIEF_NOEU", + "SICA_NOEU","SICO_NOEU","SIGM_NOEU", + "SIPO_NOEU", + "VAEX_NOEU","VARI_NOEU","DISS_NOEU",) ), + + MODELE =SIMP(statut='f',typ=modele_sdaster), CHAM_MATER =SIMP(statut='f',typ=cham_mater), CARA_ELEM =SIMP(statut='f',typ=cara_elem), EXCIT =FACT(statut='f',max='**', @@ -7123,15 +7989,13 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='f', TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE", into=("FIXE_CSTE","FIXE_PILO","SUIV") ), ), + TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), - GROUP_MA_RESU =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE_RESU =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), - GROUP_NO_RESU =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - NOEUD_RESU =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), + ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 07/12/2010 AUTEUR GENIAUT S.GENIAUT # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG @@ -7155,13 +8019,7 @@ CALC_POINT_MAT=OPER(nom="CALC_POINT_MAT",op=33,sd_prod=table_sdaster,reentrant=' fr="Intégrer une loi de comportement", MATER =SIMP(statut='o',typ=mater_sdaster,max=1), COMP_INCR =C_COMP_INCR(), - COMP_ELAS =FACT(statut='f',max='**', - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - RELATION =SIMP(statut='o',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS","ELAS_HYPER")), - DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT",) ), - ), + COMP_ELAS =C_COMP_ELAS('CALC_POINT_MAT'), INCREMENT =C_INCREMENT(), NEWTON =C_NEWTON(), CONVERGENCE =C_CONVERGENCE(), @@ -7234,10 +8092,10 @@ CALC_POINT_MAT=OPER(nom="CALC_POINT_MAT",op=33,sd_prod=table_sdaster,reentrant=' ), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 28/02/2011 AUTEUR BARGELLI R.BARGELLINI # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -7275,7 +8133,6 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli, CABLE_BP =SIMP(statut='o',typ=cabl_precont,validators=NoRepeat(),max='**'), CABLE_BP_INACTIF =SIMP(statut='f',typ=cabl_precont,validators=NoRepeat(),max='**'), INCREMENT =C_INCREMENT(), - NEWTON =C_NEWTON(), RECH_LINEAIRE =C_RECH_LINEAIRE(), CONVERGENCE =C_CONVERGENCE(), ETAT_INIT =FACT(statut='f', @@ -7298,9 +8155,16 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli, NUME_DIDI =SIMP(statut='f',typ='I'), INST_ETAT_INIT =SIMP(statut='f',typ='R'), ), - SOLVEUR =C_SOLVEUR(), - INFO =SIMP(statut='f',typ='I',into=(1,2) ), - TITRE =SIMP(statut='f',typ='TXM',max='**' ), + METHODE = SIMP(statut='d',typ='TXM',defaut="NEWTON",into=("NEWTON","IMPL_EX")), + b_meth_newton = BLOC(condition = "METHODE == 'NEWTON'", + NEWTON = C_NEWTON(), + ), + b_meth_impl_ex = BLOC(condition = "METHODE == 'IMPL_EX'", + IMPL_EX = C_IMPL_EX(), + ), + SOLVEUR =C_SOLVEUR(), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), + TITRE =SIMP(statut='f',typ='TXM',max='**' ), EXCIT =FACT(statut='o',max='**', CHARGE =SIMP(statut='o',typ=char_meca), @@ -7308,6 +8172,88 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli, COMP_INCR =C_COMP_INCR(), ) ; +#& MODIF COMMANDE DATE 02/02/2011 AUTEUR PELLET J.PELLET +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# ====================================================================== +# RESPONSABLE GNICOLAS +def calc_sensi_prod(RESULTAT,**args): + if AsType(RESULTAT) != None : return AsType(RESULTAT) + raise AsException("type de concept resultat non prevu") + +CALC_SENSI=OPER(nom="CALC_SENSI",op=132,sd_prod=calc_sensi_prod,reentrant='f', + UIinfo={"groupes":("Post-traitements","Résultats et champs",)}, + fr="Compléter ou créer un résultat en calculant des champs dérivés )", + MODELE =SIMP(statut='f',typ=modele_sdaster), + CHAM_MATER =SIMP(statut='f',typ=cham_mater), + CARA_ELEM =SIMP(statut='f',typ=cara_elem), + + RESULTAT =SIMP(statut='o',typ=resultat_sdaster, + fr="Résultat d'une commande globale"), + + regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE', + 'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'), + CONCEPT_SENSIBLE("SEPARE"), + DERIVABLE('RESULTAT'),), + TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), + NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), + NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), + NOEUD_CMP =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), + NOM_CAS =SIMP(statut='f',typ='TXM' ), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + FREQ =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R'),), + LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster), + TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**', + fr="le calcul ne sera effectué que sur ces mailles là"), + MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**', + fr="le calcul ne sera effectué que sur ces mailles là"), + + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', + + into=('DEDE_ELNO','DEDE_NOEU','DESI_ELNO', + 'DESI_NOEU','DETE_ELNO','DETE_NOEU', + 'EFGE_ELNO','EPSI_ELGA','EPSI_ELNO', + 'EPSP_ELNO','FLUX_ELNO','FLUX_NOEU','REAC_NODA','SIEF_ELGA', + 'SIEF_ELNO','SIEF_NOEU', + 'SIGM_ELNO','SIGM_NOEU', + 'SIPO_ELNO','VARI_ELNO'), + ), + + + # -- mots cles inutiles mais qui permettent de reutiliser certaines routines : + EXCIT =FACT(statut='f',max='**', CHARGE=SIMP(statut='o',typ=(char_meca,) ),), + NORME =SIMP(statut='f',typ='TXM',defaut="XXXX", into=("XXXX",),), + + + SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', + fr="Liste des paramètres de sensibilité.", + ang="List of sensitivity parameters"), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), +) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -7569,63 +8515,6 @@ CALC_THETA=OPER(nom="CALC_THETA",op=54,sd_prod=theta_geom,reentrant='n', FORMAT =SIMP(statut='f',typ='TXM',defaut="EXCEL",into=("EXCEL","AGRAF") ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== -# RESPONSABLE ABBAS M.ABBAS - -CALCUL=OPER(nom="CALCUL",op=26,sd_prod=table_container,reentrant='f', - UIinfo={"groupes":("Résolution",)}, - fr="Calculer des objets élémentaires comme une matrice tangente, intégrer une loi de comportement, etc...", - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="COMPORTEMENT", - into=( "COMPORTEMENT","MATR_TANG_ELEM","FORC_INT_ELEM"),), - MODELE =SIMP(statut='o',typ=modele_sdaster), - CARA_ELEM =SIMP(statut='f',typ=cara_elem), - CHAM_MATER =SIMP(statut='o',typ=cham_mater), - TABLE =SIMP(statut='f',typ=table_container), - EXCIT =FACT(statut='o',max='**', - CHARGE =SIMP(statut='o',typ=(char_meca,char_cine_meca)), - FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE", - into=("FIXE_CSTE",)), - - ), - DEPL =SIMP(statut='o',typ=cham_no_sdaster ), - INCR_DEPL =SIMP(statut='o',typ=cham_no_sdaster ), - SIGM =SIMP(statut='o',typ=cham_elem), - VARI =SIMP(statut='o',typ=cham_elem), - INCREMENT =FACT(statut='o', - LIST_INST =SIMP(statut='o',typ=listr8_sdaster), - NUME_ORDRE =SIMP(statut='o',typ='I'),), - COMP_INCR =C_COMP_INCR(), - COMP_ELAS =FACT(statut='f',max='**', - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",into=("IMPLICITE",)), - RELATION =SIMP(statut='o',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC", - "ELAS_POUTRE_GR","CABLE","ELAS_HYPER")), - DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ), - ), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), -) ; - #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -7693,10 +8582,58 @@ CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentr MODELE =SIMP(statut='f',typ=modele_sdaster), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 07/12/2010 AUTEUR GENIAUT S.GENIAUT # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ABBAS M.ABBAS + +CALCUL=OPER(nom="CALCUL",op=26,sd_prod=table_container,reentrant='f', + UIinfo={"groupes":("Résolution",)}, + fr="Calculer des objets élémentaires comme une matrice tangente, intégrer une loi de comportement, etc...", + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="COMPORTEMENT", + into=( "COMPORTEMENT","MATR_TANG_ELEM","FORC_INT_ELEM"),), + MODELE =SIMP(statut='o',typ=modele_sdaster), + CARA_ELEM =SIMP(statut='f',typ=cara_elem), + CHAM_MATER =SIMP(statut='o',typ=cham_mater), + TABLE =SIMP(statut='f',typ=table_container), + EXCIT =FACT(statut='o',max='**', + CHARGE =SIMP(statut='o',typ=(char_meca,char_cine_meca)), + FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE", + into=("FIXE_CSTE",)), + + ), + DEPL =SIMP(statut='o',typ=cham_no_sdaster ), + INCR_DEPL =SIMP(statut='o',typ=cham_no_sdaster ), + SIGM =SIMP(statut='o',typ=cham_elem), + VARI =SIMP(statut='o',typ=cham_elem), + INCREMENT =FACT(statut='o', + LIST_INST =SIMP(statut='o',typ=listr8_sdaster), + NUME_ORDRE =SIMP(statut='o',typ='I'),), + COMP_INCR =C_COMP_INCR(), + COMP_ELAS =C_COMP_ELAS('CALCUL'), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), +) ; + +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -7717,8 +8654,8 @@ COMB_FOURIER=OPER(nom="COMB_FOURIER",op= 161,sd_prod=comb_fourier, UIinfo={"groupes":("Post-traitements",)}, RESULTAT =SIMP(statut='o',typ=(fourier_elas,fourier_ther),), ANGL =SIMP(statut='o',typ='R',max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=6, - into=("DEPL","REAC_NODA","SIEF_ELGA_DEPL","EPSI_ELNO_DEPL","SIGM_ELNO_DEPL","TEMP","FLUX_ELNO_TEMP"),), + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=6,into=("DEPL","REAC_NODA", + "SIEF_ELGA","EPSI_ELNO","SIGM_ELNO","TEMP","FLUX_ELNO"),), ) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -7782,10 +8719,10 @@ COMB_MATR_ASSE=OPER(nom="COMB_MATR_ASSE",op= 31,sd_prod=comb_matr_asse_prod, ), SANS_CMP =SIMP(statut='f',typ='TXM',into=("LAGR",) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 21/03/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -7890,7 +8827,7 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca, AU_MOINS_UN('DX','DY','DZ' ),), NOM_CAS =SIMP(statut='o',typ='TXM',max='**'), NUME_CAS =SIMP(statut='o',typ='I',max='**'), - MODE_STAT =SIMP(statut='f',typ=mode_meca, ), + MODE_STAT =SIMP(statut='o',typ=mode_meca, ), NOEUD_REFE =SIMP(statut='f',typ=no), NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), @@ -7899,9 +8836,9 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca, DZ =SIMP(statut='f',typ='R' ), ), OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=9, - into=("DEPL","VITE","ACCE_ABSOLU","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL", - "EFGE_ELNO_DEPL","REAC_NODA","FORC_NODA","EFGE_ELNO_CART", - "SIPO_ELNO_DEPL") ), + into=("DEPL","VITE","ACCE_ABSOLU","SIGM_ELNO","SIEF_ELGA", + "EFGE_ELNO","REAC_NODA","FORC_NODA","EFCA_ELNO", + "SIPO_ELNO") ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ), IMPRESSION =FACT(statut='f',max='**', regles=(EXCLUS('TOUT','NIVEAU'),), @@ -7910,10 +8847,10 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca, ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/03/2011 AUTEUR MASSIN P.MASSIN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -8042,6 +8979,7 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, # ------------------------------------------------------------------ b_extr =BLOC(condition = "OPERATION == 'EXTR'", regles=(AU_MOINS_UN('MAILLAGE','FISSURE','RESULTAT','TABLE'),), +# PRESENT_PRESENT('GRILLE_AUX','FISSURE'),), MAILLAGE =SIMP(statut='f',typ=(maillage_sdaster) ), FISSURE =SIMP(statut='f',typ=(fiss_xfem) ), RESULTAT =SIMP(statut='f',typ=(resultat_sdaster) ), @@ -8049,9 +8987,13 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, b_extr_maillage =BLOC(condition = "MAILLAGE != None and TABLE == None", NOM_CHAM =SIMP(statut='o',typ='TXM',into=("GEOMETRIE",)), ), - b_extr_fissure =BLOC(condition = "FISSURE != None", - NOM_CHAM =SIMP(statut='o',typ='TXM',into=("LTNO","LNNO","GRLTNO","GRLNNO","STNO","STNOR","BASLOC")), + + b_extr_fissure = BLOC(condition = "FISSURE != None", + NOM_CHAM=SIMP(statut='o',typ='TXM',into=("LTNO","LNNO","GRLTNO","GRLNNO","STNO","STNOR","BASLOC", + "GRI.LNNO","GRI.LTNO","GRI.GRLNNO","GRI.GRLTNO")), + ), + b_extr_table =BLOC(condition = "TABLE != None", regles=( EXCLUS('MODELE','MAILLAGE'), EXCLUS('PROL_ZERO','MAILLAGE'),), @@ -8115,10 +9057,102 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ), TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 03/01/2011 AUTEUR ANDRIAM H.ANDRIAMBOLOLONA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ANDRIAM H.ANDRIAMBOLOLONA + +from Macro.crea_elem_ssd_ops import crea_elem_ssd_ops + +def crea_elem_ssd_prod(self,NUME_DDL,**args): + if NUME_DDL: + self.type_sdprod(NUME_DDL,nume_ddl_sdaster) + return macr_elem_dyna + +CREA_ELEM_SSD=MACRO(nom="CREA_ELEM_SSD", + op=crea_elem_ssd_ops, + sd_prod=crea_elem_ssd_prod, + reentrant='n', + fr="Creation de macro-element dynamique en enchainant les commandes : \ + CALC_MATR_ELEM, NUME_DDL, ASSE_MATRICE, MODE_ITER_SIMULT, \ + DEFI_INTERF_DYNA, DEFI_BASE_MODALE et MACR_ELEM_DYNA", + UIinfo={"groupes":("Matrices/vecteurs",)}, + +# pour CAL_MATR_ELEM + NUME_DDL + ASSE_MATRICE + MODE_ITER_SIMULT + MODE_STATIQUE + MODELE =SIMP(statut='o',typ=modele_sdaster), + CHAM_MATER =SIMP(statut='o',typ=cham_mater), + CARA_ELEM =SIMP(statut='f',typ=cara_elem), + NUME_DDL =SIMP(statut='f',typ=CO,defaut=None), + CHARGE =SIMP(statut='f',typ=(char_meca,char_ther,char_acou),validators=NoRepeat(),max='**'), + +# pour DEFI_INTERF_DYNA + INTERFACE =FACT(statut='o',max='**', + regles=(ENSEMBLE('NOM','TYPE'), + UN_PARMI('NOEUD','GROUP_NO'),), + NOM =SIMP(statut='f',typ='TXM' ), + TYPE =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO",) ), + NOEUD =SIMP(statut='f',typ=no,max='**'), + GROUP_NO =SIMP(statut='f',typ=grno,max='**'), + FREQ =SIMP(statut='f',typ='R',defaut= 1.), + ), + +# pour DEFI_BASE_MODALE + BASE_MODALE = FACT(statut='o',max = 1, + TYPE =SIMP(statut='o',typ='TXM',max=1,into=('CLASSIQUE','RITZ',)), + b_ritz = BLOC(condition = "TYPE == 'RITZ' ", + NMAX_MODE_INTF =SIMP(statut='f',typ='I',defaut=10), + ), + ), + + INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), + + SOLVEUR =C_SOLVEUR(), + +# pour le calcul modal + CALC_FREQ =FACT(statut='d',min=0, + OPTION =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","BANDE","CENTRE"), + fr="Choix de l option et par consequent du shift du probleme modal" ), + b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites valeurs propres", + NMAX_FREQ =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ), + ), + b_centre =BLOC(condition = "OPTION == 'CENTRE'", + fr="Recherche des valeurs propres les plus proches d une valeur donnee", + FREQ =SIMP(statut='o',typ='R', + fr="Frequence autour de laquelle on cherche les frequences propres"), + AMOR_REDUIT =SIMP(statut='f',typ='R',), + NMAX_FREQ =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ), + ), + b_bande =BLOC(condition = "(OPTION == 'BANDE')", + fr="Recherche des valeurs propres dans une bande donnee", + NMAX_FREQ =SIMP(statut='f',typ='I',defaut= 9999,val_min=0 ), + FREQ =SIMP(statut='o',typ='R',min=2,validators=NoRepeat(),max='**', + fr="Valeurs des frequences delimitant les bandes de recherche"), + ), + APPROCHE =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG","COMPLEXE"), + fr="Choix du pseudo-produit scalaire pour la resolution du probleme quadratique" ), + ), + + +) ; +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -8270,16 +9304,16 @@ CREA_MAILLAGE=OPER(nom="CREA_MAILLAGE",op= 167,sd_prod=maillage_sdaster, GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), SHRINK =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de réduction" ), TAILLE_MIN =SIMP(statut='f',typ='R',defaut= 0.0, fr="Taille minimale d'un coté" ), - NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), + NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),), ), TITRE =SIMP(statut='f',typ='TXM',max='**'), # INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -8397,7 +9431,7 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', ECLA_PG =FACT(statut='o', regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'), + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),), MODELE_INIT =SIMP(statut='o',typ=modele_sdaster), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), @@ -8630,10 +9664,10 @@ DEBUG=PROC(nom="DEBUG",op=137, IMPR_MACRO =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess", statut='f',typ='TXM',into=("OUI","NON")), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 03/01/2011 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -8735,11 +9769,12 @@ DEBUT=MACRO(nom="DEBUT",op=ops.build_debut ,repetable='n', IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"), + INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2),), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 25/01/2011 AUTEUR NISTOR I.NISTOR # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -8810,13 +9845,12 @@ DEFI_BASE_MODALE=OPER(nom="DEFI_BASE_MODALE",op= 99,sd_prod=mode_meca, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - FILTRAGE_MATRICE =SIMP(statut='f',typ='R',defaut=-1.0,), - MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), @@ -8951,10 +9985,10 @@ DEFI_CABLE_OP=OPER(nom="DEFI_CABLE_OP",op= 180,sd_prod=cabl_precont,reentrant='n PRESENT =SIMP(statut='o',typ='TXM',min=2,max=2,into=("OUI","NON") ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 23/02/2011 AUTEUR LAVERNE J.LAVERNE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -8981,16 +10015,31 @@ DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster, MONOCRISTAL =FACT(statut='f', max='**', MATER =SIMP(statut='o', typ=mater_sdaster, max=1), ECOULEMENT =SIMP(statut='o', typ='TXM', max=1, + into=('MONO_VISC1', 'MONO_VISC2', 'MONO_VISC3', 'MONO_DD_KR', 'MONO_DD_CFC', 'MONO_DD_CC',), fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écoulement viscoplastique"), - ECRO_ISOT =SIMP(statut='o', typ='TXM', max=1, - fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage isotrope"), - ECRO_CINE =SIMP(statut='o', typ='TXM', max=1, - fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage cinématique"), ELAS =SIMP(statut='f', typ='TXM', max=1, fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le comportement élastique (un et un seul)"), - FAMI_SYST_GLIS =SIMP(statut='o',typ='TXM', max=1, + b_non_dd =BLOC(condition="ECOULEMENT=='MONO_VISC1' or ECOULEMENT=='MONO_VISC2' or ECOULEMENT=='MONO_VISC3'", + ECRO_ISOT =SIMP(statut='f', typ='TXM', max=1, + fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage isotrope"), + ECRO_CINE =SIMP(statut='f', typ='TXM', max=1, + fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage cinématique"), + FAMI_SYST_GLIS =SIMP(statut='o',typ='TXM', max=1, into=('BASAL', 'PRISMATIQUE', 'OCTAEDRIQUE', 'PYRAMIDAL1', - 'PYRAMIDAL2', 'CUBIQUE1', 'CUBIQUE2', 'MACLAGE', 'JOINT_GRAIN', 'RL', 'UNIAXIAL','BCC24'),), + 'PYRAMIDAL2', 'CUBIQUE1', 'CUBIQUE2', 'MACLAGE', 'UNIAXIAL','BCC24'),), + ), + b_dd_kr =BLOC(condition="ECOULEMENT=='MONO_DD_KR' ", + FAMI_SYST_GLIS =SIMP(statut='f',typ='TXM', max=1, + into=('BCC24',),defaut=('BCC24',),), + ), + b_dd_cfc =BLOC(condition="ECOULEMENT=='MONO_DD_CFC' ", + FAMI_SYST_GLIS =SIMP(statut='f',typ='TXM', max=1, + into=('OCTAEDRIQUE',),defaut=('OCTAEDRIQUE',),), + ), + b_dd_cc =BLOC(condition="ECOULEMENT=='MONO_DD_CC' ", + FAMI_SYST_GLIS =SIMP(statut='o',typ='TXM', max=1, + into=('CUBIQUE1',),defaut=('CUBIQUE1',),), + ), ), ROTA_RESEAU =SIMP(statut='f', typ='TXM', max=1,into=('NON','POST','CALC'),defaut='NON', @@ -9042,7 +10091,6 @@ DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster, "GRANGER_FP_V", "BETON_UMLV_FP", "ROUSS_PR", - "NADAI_B", "BETON_DOUBLE_DP", ),), # on pourrait ajouter TOUT_GROUP_FIBRE @@ -9076,10 +10124,10 @@ DEFI_CONSTANTE=OPER(nom="DEFI_CONSTANTE",op= 2,sd_prod=fonction_sdaster, VALE =SIMP(statut='o',typ='R',), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 23/02/2011 AUTEUR MASSIN P.MASSIN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -9100,6 +10148,7 @@ DEFI_CONTACT=OPER(nom = "DEFI_CONTACT", op = 30, sd_prod = char_contact, fr = "Définit les zones soumises à des conditions de contact unilatéral avec ou sans frottement", + #en = "Allows the definition of contact surfaces as well as unilateral conditions", reentrant = 'n', UIinfo = {"groupes":("Modélisation",)}, @@ -9111,63 +10160,59 @@ DEFI_CONTACT=OPER(nom = "DEFI_CONTACT", # FORMULATION (UNIQUE PAR OCCURRENCE DE DEFI_CONTACT) FORMULATION =SIMP(statut='o', - typ='TXM', position='global', + typ='TXM', + fr="Choix d'une formulation de contact ou de liaisons unilatérales", defaut="DISCRETE", into=("DISCRETE","CONTINUE","XFEM","LIAISON_UNIL",),), -# PARAMETRE GENERAL: FROTTEMENT +# PARAMETRE GENERAL : FROTTEMENT FROTTEMENT =SIMP(statut='f', - typ='TXM', position='global', + typ='TXM', + fr="Choix d'un modèle de frottement (uniquement pour les formulations de contact)", defaut="SANS", into=("COULOMB","SANS",)), ### PARAMETRES GENERAUX (UNIQUEMENT POUR LE CONTACT MAILLE, NE DEPENDENT PAS DE LA ZONE DE CONTACT) b_contact_mail=BLOC(condition = "((FORMULATION == 'CONTINUE') or (FORMULATION == 'DISCRETE'))", - STOP_INTERP = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - LISSAGE = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - ), - -### PARAMETRES GENERAUX (UNIQUEMENT POUR LE CONTACT, NE DEPENDENT PAS DE LA ZONE DE CONTACT) - - b_contact=BLOC(condition = "FORMULATION != 'LIAISON_UNIL' ", - -# PARAMETRE GENERAL: VERIFICATION DE L'ORIENTATION ET DE LA COHERENCE DES NORMALES - +# ARRET DU CALCUL POUR LE MODE SANS RESOLUTION DU CONTACT + STOP_INTERP = SIMP(statut='f', + typ='TXM', + fr="Arrête le calcul dès qu'une interpénétration est détectée en mode RESOLUTION='NON'", + defaut="NON", + into=("OUI","NON")), +# LISSAGE DES NORMALES PAR MOYENNATION AUX NOEUDS + LISSAGE = SIMP(statut='f', + typ='TXM', + fr="Lissage des normales par moyennation aux noeuds", + defaut="NON", + into=("OUI","NON")), +# VERIFICATION DE L'ORIENTATION ET DE LA COHERENCE DES NORMALES VERI_NORM =SIMP(statut='f', typ='TXM', + fr="Vérification de l'orientation (sortante) des normales aux surfaces", defaut="OUI", into=("OUI","NON"),), + ), -# PARAMETRE GENERAL: BOUCLE SUR GEOMETRIE +### PARAMETRES GENERAUX (UNIQUEMENT POUR LE CONTACT, NE DEPENDENT PAS DE LA ZONE DE CONTACT) - b_bouc_geom_disc=BLOC(condition = "FORMULATION == 'DISCRETE' ", - REAC_GEOM =SIMP(statut='f', - typ='TXM', - into=("AUTOMATIQUE","CONTROLE","SANS",), - defaut="AUTOMATIQUE", - ), - b_automatique = BLOC(condition = "REAC_GEOM == 'AUTOMATIQUE' ", - ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=5), - RESI_GEOM = SIMP(statut='f',typ='R',defaut=0.05), - ), - b_controle = BLOC(condition = "REAC_GEOM == 'CONTROLE' ", - NB_ITER_GEOM = SIMP(statut='f',typ='I',defaut = 2), - ), - ), + b_contact=BLOC(condition = "FORMULATION != 'LIAISON_UNIL' ", + +# PARAMETRE GENERAL : BOUCLE DE GEOMETRIE - b_bouc_geom_cont=BLOC(condition = "FORMULATION == 'CONTINUE' ", + b_bouc_geom_mail=BLOC(condition = "(FORMULATION == 'DISCRETE' or FORMULATION == 'CONTINUE')", REAC_GEOM =SIMP(statut='f', typ='TXM', into=("AUTOMATIQUE","CONTROLE","SANS",), defaut="AUTOMATIQUE", ), b_automatique = BLOC(condition = "REAC_GEOM == 'AUTOMATIQUE' ", - ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=5), - RESI_GEOM = SIMP(statut='f',typ='R',defaut=0.0001), + ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=10), + RESI_GEOM = SIMP(statut='f',typ='R',defaut=0.01), ), b_controle = BLOC(condition = "REAC_GEOM == 'CONTROLE' ", NB_ITER_GEOM = SIMP(statut='f',typ='I',defaut = 2), @@ -9181,7 +10226,7 @@ DEFI_CONTACT=OPER(nom = "DEFI_CONTACT", defaut="SANS", ), b_automatique = BLOC(condition = "REAC_GEOM == 'AUTOMATIQUE' ", - ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=5), + ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=10), RESI_GEOM = SIMP(statut='f',typ='R',defaut=0.0001), ), b_controle = BLOC(condition = "REAC_GEOM == 'CONTROLE' ", @@ -9189,7 +10234,8 @@ DEFI_CONTACT=OPER(nom = "DEFI_CONTACT", ), ), -# PARAMETRE GENERAL: BOUCLE SUR CONTACT + +# PARAMETRE GENERAL : BOUCLE DE CONTACT b_bouc_cont_disc=BLOC(condition = "FORMULATION == 'DISCRETE' ", ITER_CONT_MULT = SIMP(statut='f',typ='I',defaut = 4), @@ -9210,51 +10256,73 @@ DEFI_CONTACT=OPER(nom = "DEFI_CONTACT", ITER_CONT_TYPE= SIMP(statut='f',typ='TXM',defaut="MAXI", into=("MULT","MAXI")), b_bouc_cont_mult = BLOC(condition = "ITER_CONT_TYPE=='MULT'", - ITER_CONT_MULT = SIMP(statut='f',typ='I',defaut = 4), + ITER_CONT_MULT = SIMP(statut='f',typ='I',defaut = 4), ), b_bouc_cont_maxi = BLOC(condition = "ITER_CONT_TYPE=='MAXI'", - ITER_CONT_MAXI = SIMP(statut='f',typ='I',defaut = 30), + ITER_CONT_MAXI = SIMP(statut='f',typ='I',defaut = 30), ), ), -# PARAMETRE GENERAL: BOUCLE SUR FROTTEMENT +# PARAMETRE GENERAL : BOUCLE DE FROTTEMENT b_bouc_frot = BLOC(condition = "FROTTEMENT=='COULOMB' and ((FORMULATION == 'CONTINUE') or (FORMULATION == 'XFEM')) ", REAC_FROT =SIMP(statut='f', typ='TXM', + defaut="AUTOMATIQUE", into=("AUTOMATIQUE","CONTROLE",), - defaut="AUTOMATIQUE",), + ), b_automatique = BLOC(condition = "REAC_FROT == 'AUTOMATIQUE' ", - ITER_FROT_MAXI = SIMP(statut='f',typ='I',defaut=2), - RESI_FROT = SIMP(statut='f',typ='R',defaut=0.0001), + ITER_FROT_MAXI = SIMP(statut='f',typ='I',defaut=10), + RESI_FROT = SIMP(statut='f',typ='R',defaut=0.0001), ), b_controle = BLOC(condition = "REAC_FROT == 'CONTROLE' ", - NB_ITER_FROT = SIMP(statut='f',typ='I',defaut = 2), + NB_ITER_FROT = SIMP(statut='f',typ='I',defaut = 2), ), - ), + ), -# PARAMETRE GENERAL: METHODES DISCRETES +# PARAMETREs GENERAUX : METHODES DISCRETES b_para_discret = BLOC(condition = "FORMULATION == 'DISCRETE' ", - STOP_SINGULIER= SIMP(statut='f',typ='TXM',defaut="OUI", - into=("OUI","NON")), - NB_RESOL = SIMP(statut='f',typ='I', defaut=10 ), - RESI_ABSO = SIMP(statut='f',typ='R', - fr="Critere de convergence (niveau d'interpenetration autorise)"), - REAC_ITER = SIMP(statut='f',typ='I',defaut=3, - fr="Frequence de reinitialisation de la conjugaison"), - ITER_GCP_MAXI = SIMP(statut='f',typ='I',defaut=0, - fr="Nombre d'iterations maximal pour le GCP"), - - PRE_COND = SIMP(statut='f',typ='TXM',defaut="SANS",into=("DIRICHLET","SANS"), - fr="Choix d'un preconditionneur (accelere la convergence)"), - ITER_PRE_MAXI = SIMP(statut='f',typ='I',defaut=0, - fr="Nombre d'iterations maximal pour le preconditionneur"), - COEF_RESI = SIMP(statut='f',typ='R',defaut = 1., - fr="Critere_Convergence_Preconditionneur = COEF_RESI*Critere_Convergence_GCP",), - RECH_LINEAIRE = SIMP(statut='f',typ='TXM',defaut="ADMISSIBLE", - into=("ADMISSIBLE","NON_ADMISSIBLE"), - fr="Autorise-t-on de sortir du domaine admissible lors de la recherche lineaire",), +# ## METHODES DE DUALISATION ## + STOP_SINGULIER= SIMP(statut='f', + typ='TXM', + fr="Tient compte de la singularité de la matrice de contact", + defaut="OUI", + into=("OUI","NON"),), + NB_RESOL = SIMP(statut='f', + typ='I', + fr="Nombre de résolutions simultanées pour la construction du complément de Schur", + defaut=10,), +# ## GCP ## + RESI_ABSO = SIMP(statut='f', + typ='R', + fr="Critère de convergence (niveau d'interpénétration autorisé pour 'GCP')",), + REAC_ITER = SIMP(statut='f', + typ='I', + fr="Fréquence de réinitialisation de la conjugaison ('GCP')", + defaut=3,), + ITER_GCP_MAXI = SIMP(statut='f', + typ='I', + fr="Nombre d'itérations maximal ('GCP')", + defaut=0,), + PRE_COND = SIMP(statut='f', + typ='TXM', + fr="Choix d'un préconditionneur (accélère la convergence de 'GCP')", + defaut="SANS", + into=("DIRICHLET","SANS"),), + ITER_PRE_MAXI = SIMP(statut='f', + typ='I', + fr="Nombre d'itérations maximal pour le préconditionneur ('GCP')", + defaut=0,), + COEF_RESI = SIMP(statut='f', + typ='R', + fr="Critère de convergence du préconditionneur (COEF_RESI*RESI_ABSO)", + defaut = 1.,), + RECH_LINEAIRE = SIMP(statut='f', + typ='TXM', + fr="Autorisation de sortie du domaine admissible lors de la recherche linéaire", + defaut="ADMISSIBLE", + into=("ADMISSIBLE","NON_ADMISSIBLE"),), ), ), #fin bloc b_contact @@ -9262,304 +10330,294 @@ DEFI_CONTACT=OPER(nom = "DEFI_CONTACT", # AFFECTATION - CAS LIAISON_UNILATERALE - b_affe_unil = BLOC(condition = "FORMULATION == 'LIAISON_UNIL'", - ZONE=FACT(statut='o', - max='**', - + b_affe_unil = BLOC(condition = "FORMULATION == 'LIAISON_UNIL'", + ZONE=FACT(statut='o', + max='**', # -- Liaison unilatérale - regles=(UN_PARMI('GROUP_MA','MAILLE','GROUP_NO','NOEUD'),), - GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - - NOM_CMP =SIMP(statut='o',typ='TXM',max='**'), - COEF_IMPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),), - COEF_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'), - + regles=(UN_PARMI('GROUP_MA','MAILLE','GROUP_NO','NOEUD'),), + GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), + MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), + NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), +# + NOM_CMP =SIMP(statut='o',typ='TXM',max='**'), + COEF_IMPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),), + COEF_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'), # -- Incompatibilité avec CL - SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), + SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), - ), - ), #fin bloc b_affe_unil + ), + ), #fin bloc b_affe_unil # AFFECTATION - CAS DISCRET - b_affe_discret = BLOC(condition = "FORMULATION == 'DISCRETE'", - ZONE=FACT(statut='o', - max='**', - + b_affe_discret = BLOC(condition = "FORMULATION == 'DISCRETE'", + ZONE=FACT(statut='o', + max='**', # -- Appariement - APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", - into=("NODAL","MAIT_ESCL"),), - - regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'), - UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),), - GROUP_MA_MAIT =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), - MAILLE_MAIT =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_MA_ESCL =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), - MAILLE_ESCL =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - - NORMALE =SIMP(statut='f',typ='TXM',defaut="MAIT", - into=("MAIT","MAIT_ESCL","ESCL"),), - - VECT_MAIT =SIMP(statut='f',typ='TXM',defaut="AUTO", - into=("AUTO","FIXE","VECT_Y")), - - b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'", - MAIT_FIXE =SIMP(statut='o',typ='R',min=3,max=3), - ), - - b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'", - MAIT_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), - ), - - VECT_ESCL =SIMP(statut='f',typ='TXM',defaut="AUTO", - into=("AUTO","FIXE","VECT_Y")), - - b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'", - ESCL_FIXE =SIMP(statut='o',typ='R',min=3,max=3), - ), - - b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'", - ESCL_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), - ), + APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", + into=("NODAL","MAIT_ESCL"),), +# + regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'), + UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),), + GROUP_MA_MAIT =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), + MAILLE_MAIT =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA_ESCL =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), + MAILLE_ESCL =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), +# + NORMALE =SIMP(statut='f',typ='TXM',defaut="MAIT", + into=("MAIT","MAIT_ESCL","ESCL"),), +# + VECT_MAIT =SIMP(statut='f',typ='TXM',defaut="AUTO", + into=("AUTO","FIXE","VECT_Y")), - TYPE_APPA =SIMP(statut='f',typ='TXM',defaut="PROCHE", - into =("PROCHE","FIXE")), + b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'", + MAIT_FIXE =SIMP(statut='o',typ='R',min=3,max=3), + ), - b_appa_fixe =BLOC(condition = "TYPE_APPA == 'FIXE'", - DIRE_APPA =SIMP(statut='f',typ='R',min=3,max=3), - ), + b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'", + MAIT_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), + ), +# + VECT_ESCL =SIMP(statut='f',typ='TXM',defaut="AUTO", + into=("AUTO","FIXE","VECT_Y")), - DIST_POUTRE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), - DIST_COQUE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), - b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'", - CARA_ELEM =SIMP(statut='o',typ=(cara_elem) ), - ), + b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'", + ESCL_FIXE =SIMP(statut='o',typ='R',min=3,max=3), + ), - DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - DIST_ESCL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'", + ESCL_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), + ), +# + TYPE_APPA =SIMP(statut='f',typ='TXM',defaut="PROCHE", + into =("PROCHE","FIXE")), - TOLE_APPA =SIMP(statut='f',typ='R' ,defaut=-1.0), - TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), + b_appa_fixe =BLOC(condition = "TYPE_APPA == 'FIXE'", + DIRE_APPA =SIMP(statut='f',typ='R',min=3,max=3), + ), +# + DIST_POUTRE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), + DIST_COQUE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), + b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'", + CARA_ELEM =SIMP(statut='o',typ=(cara_elem) ), + ), + DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + DIST_ESCL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), +# + TOLE_APPA =SIMP(statut='f',typ='R' ,defaut=-1.0), + TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), # -- Incompatibilité avec CL - SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), - SANS_MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - SANS_GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), - + SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), + SANS_MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + SANS_GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), # -- Mode sans calcul - RESOLUTION =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), - b_verif=BLOC(condition = "RESOLUTION == 'NON' ", - TOLE_INTERP = SIMP(statut='f',typ='R',defaut = 0.), + RESOLUTION =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), + b_verif=BLOC(condition = "RESOLUTION == 'NON' ", + TOLE_INTERP = SIMP(statut='f',typ='R',defaut = 0.), ), - # -- Résolution - ALGO_CONT =SIMP(statut='o',typ='TXM',defaut="CONTRAINTE", - into=("CONTRAINTE","LAGRANGIEN","PENALISATION","GCP"),), - - b_active=BLOC(condition = "ALGO_CONT == 'CONTRAINTE' ", - fr="Paramètres de la méthode des contraintes actives (contact uniquement)", - GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - b_glissiere=BLOC(condition = "GLISSIERE == 'OUI' ", - ALARME_JEU =SIMP(statut='f',typ='R',defaut=0.), - ), - ), - - - b_penal_contact=BLOC(condition = "ALGO_CONT == 'PENALISATION' ", - fr="Paramètres de la méthode pénalisée (contact)", - E_N =SIMP(statut='o',typ='R'), - ), - - b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ", - fr="Paramètres du frottement", - COULOMB =SIMP(statut='o',typ='R',), - COEF_MATR_FROT=SIMP(statut='f',typ='R',defaut=0.E+0), - ALGO_FROT =SIMP(statut='o',typ='TXM',defaut="PENALISATION", - into=("PENALISATION","LAGRANGIEN"),), - - b_penal_frot=BLOC(condition = "ALGO_FROT == 'PENALISATION' ", - fr="Paramètres de la méthode pénalisée (frottement)", - E_T =SIMP(statut='o',typ='R'), - ), - ), - ), #fin mot-clé facteur ZONE - ), #fin bloc b_affe_discret - + ALGO_CONT =SIMP(statut='o',typ='TXM',defaut="CONTRAINTE", + into=("CONTRAINTE","LAGRANGIEN","PENALISATION","GCP"),), + + b_active=BLOC(condition = "ALGO_CONT == 'CONTRAINTE' ", + fr="Paramètres de la méthode des contraintes actives (contact uniquement)", + GLISSIERE=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + b_glissiere=BLOC(condition = "GLISSIERE == 'OUI' ", + ALARME_JEU =SIMP(statut='f',typ='R',defaut=0.), + ), + ), +# + b_penal_contact=BLOC(condition = "ALGO_CONT == 'PENALISATION' ", + fr="Paramètres de la méthode pénalisée (contact)", + E_N=SIMP(statut='o',typ='R'), + ), +# + b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ", + fr="Paramètres du frottement de Coulomb", + COULOMB =SIMP(statut='o',typ='R',), + COEF_MATR_FROT=SIMP(statut='f',typ='R',defaut=0.E+0), + ALGO_FROT =SIMP(statut='o',typ='TXM',defaut="PENALISATION", + into=("PENALISATION","LAGRANGIEN"),), +# + b_penal_frot=BLOC(condition = "ALGO_FROT == 'PENALISATION' ", + fr="Paramètres de la méthode pénalisée (frottement)", + E_T=SIMP(statut='o',typ='R'), + ), + ), + ), #fin mot-clé facteur ZONE + ), #fin bloc b_affe_discret # AFFECTATION - CAS CONTINUE - b_affe_continue = BLOC(condition = "FORMULATION == 'CONTINUE'", - ZONE=FACT(statut='o', - max='**', - + b_affe_continue = BLOC(condition = "FORMULATION == 'CONTINUE'", + ZONE=FACT(statut='o', + max='**', # -- Appariement - APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", - into=("MAIT_ESCL",)), - - regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'), - UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),), - GROUP_MA_MAIT =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), - MAILLE_MAIT =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_MA_ESCL =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), - MAILLE_ESCL =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - - NORMALE =SIMP(statut='f',typ='TXM',defaut="MAIT", - into=("MAIT","MAIT_ESCL","ESCL"),), - - VECT_MAIT =SIMP(statut='f',typ='TXM',defaut="AUTO", - into=("AUTO","FIXE","VECT_Y")), - - b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'", - MAIT_FIXE =SIMP(statut='o',typ='R',min=3,max=3), - ), - - b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'", - MAIT_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), - ), - - VECT_ESCL =SIMP(statut='f',typ='TXM',defaut="AUTO", - into=("AUTO","FIXE","VECT_Y")), - - b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'", - ESCL_FIXE =SIMP(statut='o',typ='R',min=3,max=3), - ), - - b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'", - ESCL_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), - ), + APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", + into=("MAIT_ESCL",)), +# + regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'), + UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),), + GROUP_MA_MAIT =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), + MAILLE_MAIT =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA_ESCL =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1), + MAILLE_ESCL =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), +# + NORMALE =SIMP(statut='f',typ='TXM',defaut="MAIT", + into=("MAIT","MAIT_ESCL","ESCL"),), +# + VECT_MAIT =SIMP(statut='f',typ='TXM',defaut="AUTO", + into=("AUTO","FIXE","VECT_Y")), - TYPE_APPA =SIMP(statut='f',typ='TXM',defaut="PROCHE", - into =("PROCHE","FIXE")), + b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'", + MAIT_FIXE =SIMP(statut='o',typ='R',min=3,max=3), + ), - b_appa_fixe=BLOC(condition = "TYPE_APPA == 'FIXE'", - DIRE_APPA =SIMP(statut='f',typ='R',min=3,max=3), - ), + b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'", + MAIT_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), + ), +# + VECT_ESCL =SIMP(statut='f',typ='TXM',defaut="AUTO", + into=("AUTO","FIXE","VECT_Y")), - DIST_POUTRE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), - DIST_COQUE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), - b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'", - CARA_ELEM =SIMP(statut='o',typ=(cara_elem) ), - ), + b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'", + ESCL_FIXE =SIMP(statut='o',typ='R',min=3,max=3), + ), - DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - DIST_ESCL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'", + ESCL_VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), + ), +# + TYPE_APPA =SIMP(statut='f',typ='TXM',defaut="PROCHE", + into =("PROCHE","FIXE")), - TOLE_APPA =SIMP(statut='f',typ='R' ,defaut=-1.0), - TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), + b_appa_fixe=BLOC(condition = "TYPE_APPA == 'FIXE'", + DIRE_APPA =SIMP(statut='f',typ='R',min=3,max=3), + ), +# + DIST_POUTRE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), + DIST_COQUE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), + b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'", + CARA_ELEM =SIMP(statut='o',typ=(cara_elem) ), + ), + DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + DIST_ESCL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), +# + TOLE_APPA =SIMP(statut='f',typ='R' ,defaut=-1.0), + TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), # -- Incompatibilité avec CL - - SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), - SANS_MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - SANS_GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), - - FOND_FISSURE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), - b_fond_fissure =BLOC(condition = "FOND_FISSURE == 'OUI' ", - fr="Traitement en fond de fissure", - regles=(UN_PARMI('NOEUD_FOND','GROUP_NO_FOND','MAILLE_FOND','GROUP_MA_FOND'),), - NOEUD_FOND =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO_FOND =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - MAILLE_FOND =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_MA_FOND =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - ), - - RACCORD_LINE_QUAD=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), - b_raccord_surf =BLOC(condition = "RACCORD_LINE_QUAD == 'OUI' ", - fr="Traitement du raccord surfacique", - regles=(UN_PARMI('NOEUD_RACC','GROUP_NO_RACC'),), - NOEUD_RACC =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO_RACC =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - ), - - EXCLUSION_PIV_NUL=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),), - + SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + SANS_GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), + SANS_MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + SANS_GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), +# + FOND_FISSURE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), + b_fond_fissure =BLOC(condition = "FOND_FISSURE == 'OUI' ", + fr="Traitement en fond de fissure", + regles=(UN_PARMI('NOEUD_FOND','GROUP_NO_FOND','MAILLE_FOND','GROUP_MA_FOND'),), + NOEUD_FOND =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO_FOND =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + MAILLE_FOND =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_MA_FOND =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + ), +# + RACCORD_LINE_QUAD=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), + b_raccord_surf =BLOC(condition = "RACCORD_LINE_QUAD == 'OUI' ", + fr="Traitement du raccord surfacique", + regles=(UN_PARMI('NOEUD_RACC','GROUP_NO_RACC'),), + NOEUD_RACC =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO_RACC =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + ), +# + EXCLUSION_PIV_NUL=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),), # -- Mode sans calcul - RESOLUTION =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), - b_verif=BLOC(condition = "RESOLUTION == 'NON' ", - TOLE_INTERP = SIMP(statut='f',typ='R',defaut = 0.), - ), - + RESOLUTION =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), + b_verif=BLOC(condition = "RESOLUTION == 'NON' ", + TOLE_INTERP = SIMP(statut='f',typ='R',defaut = 0.), + ), # -- Fonctionnalités spécifiques 'CONTINUE' - INTEGRATION =SIMP(statut='f',typ='TXM',defaut="NOEUD", - into=("GAUSS","NOEUD","SIMPSON","SIMPSON1","SIMPSON2", - "NCOTES" ,"NCOTES1" ,"NCOTES2"),), - - CONTACT_INIT =SIMP(statut='f',typ='TXM',defaut="NON", - into=("OUI","INTERPENETRE","NON"),), - - GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), - - ALGO_CONT =SIMP(statut='f',typ='TXM',defaut="STANDARD", - into=("STANDARD","AVANCE","PENALISATION"),), - - b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD' ", - fr="Parametres de la formulation Lagrangienne", - COEF_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), - ), - b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ", - fr="Parametres du Lagrangien augmenté", - COEF_REGU_CONT=SIMP(statut='f',typ='R',defaut=100.E+0), - COEF_STAB_CONT=SIMP(statut='f',typ='R',defaut=100.E+0), - COEF_PENA_CONT=SIMP(statut='f',typ='R',defaut=100.E+0), - ), - b_cont_pena =BLOC(condition = "ALGO_CONT == 'PENALISATION' ", + INTEGRATION =SIMP(statut='f',typ='TXM',defaut="NOEUD", + into=("GAUSS","NOEUD","SIMPSON","SIMPSON1","SIMPSON2", + "NCOTES" ,"NCOTES1" ,"NCOTES2"),), +# + CONTACT_INIT =SIMP(statut='f',typ='TXM',defaut="NON", + into=("OUI","INTERPENETRE","NON"),), +# + GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), +# + ALGO_CONT =SIMP(statut='f',typ='TXM',defaut="STANDARD", + into=("STANDARD","AVANCE","PENALISATION"),), + + b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD' ", + fr="Paramètres de la formulation Lagrangienne", + COEF_CONT = SIMP(statut='f',typ='R',defaut=100.E+0), + ), + b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ", + fr="Paramètres du Lagrangien augmenté", + COEF_REGU_CONT=SIMP(statut='f',typ='R',defaut=100.E+0), + COEF_STAB_CONT=SIMP(statut='f',typ='R',defaut=100.E+0), + COEF_PENA_CONT=SIMP(statut='f',typ='R',defaut=100.E+0), + ), + b_cont_pena=BLOC(condition = "ALGO_CONT == 'PENALISATION' ", fr="Paramètres de la méthode pénalisée", - COEF_PENA_CONT =SIMP(statut='o',typ='R'),), - - COMPLIANCE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), - b_compliance=BLOC(condition = "COMPLIANCE == 'OUI' ",fr="Parametres de la compliance", - ASPERITE =SIMP(statut='o',typ='R',), - E_N =SIMP(statut='o',typ='R',), - E_V =SIMP(statut='f',typ='R',defaut=0.E+0), - ), - - b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramètres du frottement", - COULOMB =SIMP(statut='o',typ='R',), - SEUIL_INIT =SIMP(statut='f',typ='R',defaut=0.E+0), - - regles=(EXCLUS('SANS_NOEUD_FR','SANS_GROUP_NO_FR'),), - SANS_NOEUD_FR =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - SANS_GROUP_NO_FR =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - b_sans_group_no_frot=BLOC(condition = " SANS_GROUP_NO_FR != None or \ - SANS_NOEUD_FR != None ", - fr="Direction de frottement à exclure (uniquement dans le cas 3D)", - DIRE_EXCL_FROT=SIMP(statut='f',typ='R',min=3,max=3), - ), - - ALGO_FROT =SIMP(statut='f',typ='TXM',defaut="STANDARD", - into=("STANDARD","AVANCE","PENALISATION"),), - b_frot_std =BLOC(condition = "ALGO_FROT == 'STANDARD' ", - fr="Parametres de la formulation Lagrangienne", - COEF_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), - ), - b_frot_avc =BLOC(condition = "ALGO_FROT == 'AVANCE' ", - fr="Parametres du Lagrangien augmenté", - COEF_REGU_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), - COEF_STAB_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), - COEF_PENA_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), - ), - b_frot_pena =BLOC(condition = "ALGO_FROT == 'PENALISATION' ", - fr="Paramètres de la méthode pénalisée", - COEF_PENA_FROT =SIMP(statut='o',typ='R'), - ), + COEF_PENA_CONT =SIMP(statut='o',typ='R'), + ), +# + COMPLIANCE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), + b_compliance=BLOC(condition = "COMPLIANCE == 'OUI' ", + fr="Paramètres de la compliance", + ASPERITE = SIMP(statut='o',typ='R',), + E_N = SIMP(statut='o',typ='R',), + E_V = SIMP(statut='f',typ='R',defaut=0.E+0), + ), +# + b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ", + fr="Paramètres du frottement de Coulomb", + COULOMB = SIMP(statut='o',typ='R',), + SEUIL_INIT = SIMP(statut='f',typ='R',defaut=0.E+0), +# + regles=(EXCLUS('SANS_NOEUD_FR','SANS_GROUP_NO_FR'),), + SANS_NOEUD_FR =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + SANS_GROUP_NO_FR =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + b_sans_group_no_frot=BLOC(condition = " SANS_GROUP_NO_FR != None or \ + SANS_NOEUD_FR != None ", + fr="Direction de frottement à exclure (uniquement dans le cas 3D)", + DIRE_EXCL_FROT=SIMP(statut='f',typ='R',min=3,max=3), + ), - USURE =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","ARCHARD",),), - b_usure =BLOC(condition = "USURE == 'ARCHARD' ", - fr="Parametres de la loi d'usure d'Archard", - K =SIMP(statut='o',typ='R',), - H =SIMP(statut='o',typ='R',val_min=1E-8), - ), + ALGO_FROT =SIMP(statut='f',typ='TXM',defaut="STANDARD", + into=("STANDARD","AVANCE","PENALISATION"),), + b_frot_std =BLOC(condition = "ALGO_FROT == 'STANDARD' ", + fr="Paramètres de la formulation Lagrangienne", + COEF_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), + ), + b_frot_avc =BLOC(condition = "ALGO_FROT == 'AVANCE' ", + fr="Paramètres du Lagrangien augmenté", + COEF_REGU_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), + COEF_STAB_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), + COEF_PENA_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), + ), + b_frot_pena =BLOC(condition = "ALGO_FROT == 'PENALISATION' ", + fr="Paramètres de la méthode pénalisée", + COEF_PENA_FROT =SIMP(statut='o',typ='R'), + ), +# + USURE =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","ARCHARD",),), + b_usure =BLOC(condition = "USURE == 'ARCHARD' ", + fr="Parametres de la loi d'usure d'Archard", + K =SIMP(statut='o',typ='R',), + H =SIMP(statut='o',typ='R',val_min=1E-8), + ), - ), #fin bloc b_frottement - ), #fin mot-clé facteur ZONE - ), #fin bloc b_affe_continue + ), #fin bloc b_frottement + ), #fin mot-clé facteur ZONE + ), #fin bloc b_affe_continue # AFFECTATION - CAS XFEM @@ -9578,55 +10636,61 @@ DEFI_CONTACT=OPER(nom = "DEFI_CONTACT", into=("GAUSS","FPG2","FPG3","FPG4","FPG6","FPG7", "NOEUD","SIMPSON","SIMPSON1","NCOTES","NCOTES1","NCOTES2"),), - CONTACT_INIT = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), - GLISSIERE = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), - RELATION = SIMP(statut='f',typ='TXM',defaut="NON",into=("CZM_XFEM","NON"),), + RELATION = SIMP(statut='f',typ='TXM',defaut="NON", + into=("CZM_EXP_REG","CZM_LIN_REG","NON"),), ALGO_LAGR = SIMP(statut='f',typ='TXM',defaut="VERSION1", into=("NON","VERSION1","VERSION2"),), COEF_ECHELLE = SIMP(statut='f',typ='R',defaut=1.E+6), - ALGO_CONT =SIMP(statut='f',typ='TXM',defaut="STANDARD", - into=("STANDARD","AVANCE","PENALISATION"),), + ALGO_CONT = SIMP(statut='f',typ='TXM',defaut="STANDARD", + into=("STANDARD","AVANCE","PENALISATION","CZM"),), + + b_cont_nczm =BLOC(condition = "ALGO_CONT!='CZM'", + CONTACT_INIT = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), + GLISSIERE = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),), + ), - b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD' ", - fr="Parametres de la formulation Lagrangienne", - COEF_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), - ), - b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ",fr="Parametres du Lagrangien augmenté", - COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), - COEF_STAB_CONT =SIMP(statut='f',typ='R',defaut=0.E+0), - COEF_PENA_CONT =SIMP(statut='f',typ='R',defaut=0.E+0), - ), + b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD'", + fr="Parametres de la formulation Lagrangienne", + COEF_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), + ), + + b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ", + fr="Parametres du Lagrangien augmenté", + COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), + COEF_STAB_CONT =SIMP(statut='f',typ='R',defaut=0.E+0), + COEF_PENA_CONT =SIMP(statut='f',typ='R',defaut=0.E+0), + ), b_cont_pen=BLOC(condition = "ALGO_CONT == 'PENALISATION' ", - fr="Paramètre de la méthode pénalisée", - COEF_PENA_CONT =SIMP(statut='o',typ='R'), - ), - - b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramètres du frottement", - COULOMB =SIMP(statut='o',typ='R',), - SEUIL_INIT =SIMP(statut='f',typ='R',defaut=0.E+0), + fr="Paramètre de la méthode pénalisée", + COEF_PENA_CONT =SIMP(statut='o',typ='R'), + ), - ALGO_FROT =SIMP(statut='f',typ='TXM',defaut="STANDARD", - into=("STANDARD","AVANCE","PENALISATION"),), + b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' and ALGO_CONT != 'CZM' ", + fr="Paramètres du frottement", + COULOMB =SIMP(statut='o',typ='R',), + SEUIL_INIT =SIMP(statut='f',typ='R',defaut=0.E+0), + ALGO_FROT =SIMP(statut='f',typ='TXM',defaut="STANDARD", + into=("STANDARD","AVANCE","PENALISATION"),), - b_frot_std=BLOC(condition = "ALGO_FROT == 'STANDARD' ", - fr="Parametres de la formulation Lagrangienne", - COEF_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), - ), - b_frot_avc=BLOC(condition = "ALGO_FROT == 'AVANCE' ", - fr="Parametres du Lagrangien augmenté", - COEF_REGU_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), - COEF_STAB_FROT =SIMP(statut='f',typ='R',defaut=0.E+0), - COEF_PENA_FROT =SIMP(statut='f',typ='R',defaut=0.E+0), - ), - b_frot_pen=BLOC(condition = "ALGO_FROT == 'PENALISATION' ", - fr="Paramètre de la méthode pénalisée", - COEF_PENA_FROT =SIMP(statut='o',typ='R'), - ), - ), #fin bloc b_frottement + b_frot_std=BLOC(condition = "ALGO_FROT == 'STANDARD' ", + fr="Parametres de la formulation Lagrangienne", + COEF_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), + ), + b_frot_avc=BLOC(condition = "ALGO_FROT == 'AVANCE' ", + fr="Parametres du Lagrangien augmenté", + COEF_REGU_FROT =SIMP(statut='f',typ='R',defaut=100.E+0), + COEF_STAB_FROT =SIMP(statut='f',typ='R',defaut=0.E+0), + COEF_PENA_FROT =SIMP(statut='f',typ='R',defaut=0.E+0), + ), + b_frot_pen=BLOC(condition = "ALGO_FROT == 'PENALISATION' ", + fr="Paramètre de la méthode pénalisée", + COEF_PENA_FROT =SIMP(statut='o',typ='R'), + ), + ), #fin bloc b_frottement ), #fin mot-clé facteur ZONE ), #fin bloc b_affe_xfem @@ -9733,10 +10797,10 @@ DEFI_FICHIER=MACRO(nom="DEFI_FICHIER",op=ops.build_DEFI_FICHIER,sd_prod=DEFIC_pr INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/03/2011 AUTEUR MASSIN P.MASSIN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -9762,6 +10826,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op= 41,sd_prod=fiss_xfem,reentrant='n' # ------------------------------------------------------------------------------------------------------------------------ MODELE =SIMP(statut='o',typ=modele_sdaster), + MODELE_GRILLE =SIMP(statut='f',typ=modele_sdaster,max=1,position='global'), # ------------------------------------------------------------------------------------------------------------------------ # fissure/interface @@ -9783,7 +10848,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op= 41,sd_prod=fiss_xfem,reentrant='n' # ENSEMBLE('CHAM_NO_LSN','CHAM_NO_LST'), # ENSEMBLE('GROUP_MA_FISS','GROUP_MA_FOND')), # ), -# +# # b_interface =BLOC(condition = "TYPE_DISCONTINUITE == 'INTERFACE' ",fr="Regles pour les interfaces", # regles =(PRESENT_ABSENT('FONC_LN','FONC_LT'), # PRESENT_ABSENT('CHAM_NO_LSN','CHAM_NO_LST'), @@ -9840,6 +10905,26 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op= 41,sd_prod=fiss_xfem,reentrant='n' VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),), ), +# ------------------------------------------------------------------------------------------------------------------------ +# grille (pour Homard) +# ------------------------------------------------------------------------------------------------------------------------ + + DEFI_FISS_GRILLE =FACT(statut='f',max=1, + + b_fissure =BLOC(condition="MODELE_GRILLE == None", + FISSURE =SIMP(statut='f',typ=fiss_xfem,max=1), + ), + + b_levelset_grille =BLOC(condition="MODELE_GRILLE != None" , + CHAM_NO_LSN_GRILLE =SIMP(statut='o',typ=cham_no_sdaster,max=1), + CHAM_NO_LST_GRILLE =SIMP(statut='o',typ=cham_no_sdaster,max=1), + CHAM_NO_GRLSN_GRILLE=SIMP(statut='o',typ=cham_no_sdaster,max=1), + CHAM_NO_GRLST_GRILLE=SIMP(statut='o',typ=cham_no_sdaster,max=1), + ), + ), + + + # ------------------------------------------------------------------------------------------------------------------------ # partie du maillage potentiellement enrichie # ------------------------------------------------------------------------------------------------------------------------ @@ -9847,7 +10932,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op= 41,sd_prod=fiss_xfem,reentrant='n' GROUP_MA_ENRI =SIMP(statut='f',typ=grma,max=01), # ------------------------------------------------------------------------------------------------------------------------ -# types d'enrichissement +# types d'enrichissement # ------------------------------------------------------------------------------------------------------------------------ b_enri_inte =BLOC(condition = "TYPE_DISCONTINUITE == 'INTERFACE' ", @@ -9869,7 +10954,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op= 41,sd_prod=fiss_xfem,reentrant='n' NB_COUCHES =SIMP(statut='f',typ='I',defaut=4,val_min=1), ), - ), + ), ), # ------------------------------------------------------------------------------------------------------------------------ @@ -9887,6 +10972,16 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op= 41,sd_prod=fiss_xfem,reentrant='n' ), # ------------------------------------------------------------------------------------------------------------------------ +# branchement +# ------------------------------------------------------------------------------------------------------------------------ + + b_jonction =BLOC(condition = "MODELE_GRILLE == None ", + JONCTION =FACT(statut='f',max=1, + FISSURE =SIMP(statut='o',typ=fiss_xfem,min=1,max='**',), + POINT =SIMP(statut='o',typ='R',max=3,), + ), + ), +# ------------------------------------------------------------------------------------------------------------------------ # info # ------------------------------------------------------------------------------------------------------------------------ @@ -10175,10 +11270,10 @@ DEFI_FONCTION=OPER(nom="DEFI_FONCTION",op=3,sd_prod=defi_fonction_prod INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -10236,7 +11331,7 @@ DEFI_FOND_FISS=OPER(nom="DEFI_FOND_FISS",op=55,sd_prod=fond_fiss,reentrant='n', NOEUD_ORIG =SIMP(statut='f',typ=no,), GROUP_NO_ORIG =SIMP(statut='f',typ=grno,), MAILLE_ORIG =SIMP(statut='f',typ=ma,), - GROUP_MA_ORIG =SIMP(statut='f',typ=ma,), + GROUP_MA_ORIG =SIMP(statut='f',typ=grma,), ), FOND_INF =FACT(statut='f', GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), @@ -10328,10 +11423,10 @@ DEFI_GEOM_FIBRE=OPER(nom="DEFI_GEOM_FIBRE",op= 119, sd_prod=gfibre_sdaster, ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 11/01/2011 AUTEUR SFAYOLLE S.FAYOLLE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -10348,69 +11443,134 @@ DEFI_GEOM_FIBRE=OPER(nom="DEFI_GEOM_FIBRE",op= 119, sd_prod=gfibre_sdaster, # ====================================================================== # RESPONSABLE SFAYOLLE S.FAYOLLE DEFI_GLRC=OPER(nom="DEFI_GLRC",op=57,sd_prod=mater_sdaster,reentrant='f', - UIinfo={"groupes":("Modélisation",)}, - fr="Determiner les caracteristiques du beton arme homogeneisees a partir des proprietes du beton et de " - +" plusieurs types d'armature", - reuse = SIMP(statut='f',typ=mater_sdaster), - BETON =FACT(statut='o',max=1, - MATER =SIMP(statut='o',typ=(mater_sdaster) ), - EPAIS =SIMP(statut='o',typ='R',val_min=0.E+0 ), - GAMMA =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), - QP1 =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), - QP2 =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), - - C1N1 =SIMP(statut='o',typ='R',val_min=0.E+0), - C1N2 =SIMP(statut='o',typ='R',val_min=0.E+0), - C1N3 =SIMP(statut='o',typ='R',val_min=0.E+0), - C2N1 =SIMP(statut='o',typ='R',val_min=0.E+0), - C2N2 =SIMP(statut='o',typ='R',val_min=0.E+0), - C2N3 =SIMP(statut='o',typ='R',val_min=0.E+0), - C1M1 =SIMP(statut='o',typ='R',val_min=0.E+0), - C1M2 =SIMP(statut='o',typ='R',val_min=0.E+0), - C1M3 =SIMP(statut='o',typ='R',val_min=0.E+0), - C2M1 =SIMP(statut='o',typ='R',val_min=0.E+0), - C2M2 =SIMP(statut='o',typ='R',val_min=0.E+0), - C2M3 =SIMP(statut='o',typ='R',val_min=0.E+0), - - OMT =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), - EAT =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), - BT1 =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), - BT2 =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), - - MP1X =SIMP(statut='f',typ=('R',listr8_sdaster)), - MP2X =SIMP(statut='f',typ=('R',listr8_sdaster)), - MP1Y =SIMP(statut='f',typ=('R',listr8_sdaster)), - MP2Y =SIMP(statut='f',typ=('R',listr8_sdaster)), - ), - NAPPE =FACT(statut='o',max=10, - MATER =SIMP(statut='o',typ=(mater_sdaster) ), - OMX =SIMP(statut='o',typ='R',val_min=0.E+0), - OMY =SIMP(statut='o',typ='R',val_min=0.E+0), - RX =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), - RY =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), - ), - CABLE_PREC =FACT(statut='f',max=1, - MATER =SIMP(statut='o',typ=(mater_sdaster) ), - OMX =SIMP(statut='o',typ='R',val_min=0.E+0), - OMY =SIMP(statut='o',typ='R',val_min=0.E+0), - RX =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), - RY =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), - PREX =SIMP(statut='o',typ='R'), - PREY =SIMP(statut='o',typ='R'), - ), - LINER =FACT(statut='f',max=10, - MATER =SIMP(statut='o',typ=(mater_sdaster) ), - OML =SIMP(statut='o',typ='R',val_min=0.E+0), - RLR =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), - ), - IMPRESSION =FACT(statut='f', - UNITE =SIMP(statut='f',typ='I',defaut=8), + UIinfo={"groupes":("Modélisation",)}, + fr="Déterminer les caractéristiques homogenéisées du béton armé à partir des propriétés du béton et des " + +" armatures", + reuse = SIMP(statut='f',typ=mater_sdaster), + RELATION = SIMP(statut='o',typ='TXM',defaut="GLRC_DAMAGE", + into=("GLRC_DM","GLRC_DAMAGE"),), + + b_glrc_dm=BLOC(condition = "RELATION == 'GLRC_DM'", + fr="Paramètres de la loi GLRC_DM", + BETON = FACT(statut='o',max=1, + MATER = SIMP(statut='o',typ=(mater_sdaster),), + EPAIS = SIMP(statut='o',typ='R',val_min=0.E+0 ),), + NAPPE = FACT(statut='o',max=1, + MATER = SIMP(statut='o',typ=(mater_sdaster),), + OMY = SIMP(statut='o',typ='R',val_min=0.E+0,), + OMX = SIMP(statut='o',typ='R',val_min=0.E+0,), + RY = SIMP(statut='o',typ='R',val_min=-1.0E+0,val_max=1.0E+0,), + RX = SIMP(statut='o',typ='R',val_min=-1.0E+0,val_max=1.0E+0),), + RHO = SIMP(statut='f',typ='R',val_min=0.E+0,), + AMOR_ALPHA = SIMP(statut='f',typ='R',val_min=0.E+0,), + AMOR_BETA = SIMP(statut='f',typ='R',val_min=0.E+0,), + COMPR = SIMP(statut='o',typ='TXM',defaut="GAMMA", + into=("GAMMA","SEUIL")), + b_gamma=BLOC(condition = "COMPR == 'GAMMA'", + fr="Paramètre d'endommagement en compression ", + GC = SIMP(statut='o',typ='R',defaut=1.0E+0,val_min=0.0E+0, val_max=1.0E+0),), + b_seuil=BLOC(condition = "COMPR == 'SEUIL'", + fr="Seuil d'endommagement en compression ", + SYC = SIMP(statut='o',typ='R'),), + PENTE = SIMP(statut='o',typ='TXM',defaut="RIGI_ACIER", + into=("PLAS_ACIER","UTIL","RIGI_ACIER")), + b_util = BLOC(condition = "PENTE == 'UTIL'", + fr="Valeur de la déformation maximale de l'élément", + EPSI_MEMB = SIMP(statut='o',typ='R',defaut=0.E+0), + EPSI_FLEX = SIMP(statut='o',typ='R',defaut=0.E+0),), + CISAIL = SIMP(statut='o',typ='TXM',defaut="NON", + into=("OUI","NON"),), + METHODE_ENDO = SIMP(statut='o',typ='TXM',defaut="ENDO_INTER", + into=("ENDO_NAISS","ENDO_LIM","ENDO_INTER"),), + INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2),), + ), + b_glrc_damage=BLOC(condition = "RELATION == 'GLRC_DAMAGE'", + fr="Paramètres de la loi GLRC_DAMAGE", + BETON =FACT(statut='o',max=1, + MATER =SIMP(statut='o',typ=(mater_sdaster) ), + EPAIS =SIMP(statut='o',typ='R',val_min=0.E+0 ), + GAMMA =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), + QP1 =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), + QP2 =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), + + C1N1 =SIMP(statut='o',typ='R',val_min=0.E+0), + C1N2 =SIMP(statut='o',typ='R',val_min=0.E+0), + C1N3 =SIMP(statut='o',typ='R',val_min=0.E+0), + C2N1 =SIMP(statut='o',typ='R',val_min=0.E+0), + C2N2 =SIMP(statut='o',typ='R',val_min=0.E+0), + C2N3 =SIMP(statut='o',typ='R',val_min=0.E+0), + C1M1 =SIMP(statut='o',typ='R',val_min=0.E+0), + C1M2 =SIMP(statut='o',typ='R',val_min=0.E+0), + C1M3 =SIMP(statut='o',typ='R',val_min=0.E+0), + C2M1 =SIMP(statut='o',typ='R',val_min=0.E+0), + C2M2 =SIMP(statut='o',typ='R',val_min=0.E+0), + C2M3 =SIMP(statut='o',typ='R',val_min=0.E+0), + + OMT =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), + EAT =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), + BT1 =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), + BT2 =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0), + + MP1X =SIMP(statut='f',typ=('R',listr8_sdaster)), + MP2X =SIMP(statut='f',typ=('R',listr8_sdaster)), + MP1Y =SIMP(statut='f',typ=('R',listr8_sdaster)), + MP2Y =SIMP(statut='f',typ=('R',listr8_sdaster)), + ), + NAPPE =FACT(statut='o',max=10, + MATER =SIMP(statut='o',typ=(mater_sdaster) ), + OMX =SIMP(statut='o',typ='R',val_min=0.E+0), + OMY =SIMP(statut='o',typ='R',val_min=0.E+0), + RX =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), + RY =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), + ), + CABLE_PREC =FACT(statut='f',max=1, + MATER =SIMP(statut='o',typ=(mater_sdaster) ), + OMX =SIMP(statut='o',typ='R',val_min=0.E+0), + OMY =SIMP(statut='o',typ='R',val_min=0.E+0), + RX =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), + RY =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), + PREX =SIMP(statut='o',typ='R'), + PREY =SIMP(statut='o',typ='R'), + ), + LINER =FACT(statut='f',max=10, + MATER =SIMP(statut='o',typ=(mater_sdaster) ), + OML =SIMP(statut='o',typ='R',val_min=0.E+0), + RLR =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0), + ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2),), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/03/2011 AUTEUR MASSIN P.MASSIN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GENIAUT S.GENIAUT +DEFI_GRILLE=OPER(nom="DEFI_GRILLE",op=82,sd_prod=grille_sdaster,reentrant='n', + UIinfo={"groupes":("Modélisation",)}, + fr="Définition d'une grille", + + MAILLAGE = SIMP(statut='o',typ=maillage_sdaster), + + INFO = SIMP(statut='f',typ='I',defaut= 0,into=(0,1,2) ), +) ; +#& MODIF COMMANDE DATE 01/03/2011 AUTEUR GENIAUT S.GENIAUT +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -10455,7 +11615,7 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod, TYPE_MAILLE =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","1D","2D","3D"),max=1 ), OPTION =SIMP(statut='f',typ='TXM',into=("FACE_NORMALE","SPHERE","CYLINDRE", - "BANDE","APPUI_LACHE","APPUI") ), + "BANDE","APPUI_LACHE","APPUI","FISS_XFEM") ), b_group_ma =BLOC(condition = "GROUP_MA != None", regles=(EXCLUS('POSITION','NUME_INIT'),), NUME_INIT =SIMP(statut='f',typ='I'), @@ -10515,12 +11675,17 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod, GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), TYPE_APPUI =SIMP(statut='o',typ='TXM',max=1, into=('AU_MOINS_UN','TOUT','SOMMET','MAJORITE')), ), + b_fiss_xfem =BLOC(condition = "OPTION == 'FISS_XFEM'", + TYPE_GROUP =SIMP(statut='o',typ='TXM',max=1,defaut='XFEM', + into=('HEAVISIDE','CRACKTIP','MIXTE','FISSUREE','XFEM',),), + FISSURE =SIMP(statut='o',typ=fiss_xfem,min=1,max='**'), + ), ), CREA_GROUP_NO =FACT(statut='f',max='**', OPTION =SIMP(statut='f',typ='TXM',into=("ENV_SPHERE","ENV_CYLINDRE","PLAN", - "SEGM_DROI_ORDO","NOEUD_ORDO","TUNNEL","INCLUSION") ), + "SEGM_DROI_ORDO","NOEUD_ORDO","TUNNEL","INCLUSION","FISS_XFEM") ), b_option =BLOC(condition = "OPTION == None" , regles=(UN_PARMI('TOUT_GROUP_MA','GROUP_MA','GROUP_NO','NOEUD', @@ -10632,7 +11797,12 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod, GROUP_MA_INCL =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), MAILLAGE_INCL =SIMP(statut='f',typ=maillage_sdaster), ), - ), + b_fiss_xfem =BLOC(condition = "OPTION == 'FISS_XFEM'", + NOM =SIMP(statut='o',typ=geom), + TYPE_GROUP =SIMP(statut='o',typ='TXM',max=1,into=('HEAVISIDE','CRACKTIP','MIXTE','XFEM',)), + FISSURE =SIMP(statut='o',typ=fiss_xfem,min=1,max='**'), + ), + ), ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), INFO =SIMP(statut='f',typ='I',into=( 1 , 2 ) ), ) ; @@ -10654,45 +11824,6 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE CORUS M.CORUS - -DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas, - reentrant='n', - UIinfo={"groupes":("Matrices et vecteurs","Dynamique",)}, - fr="Définir les interfaces d'une structure et leur affecter un type", - NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ), - INTERFACE =FACT(statut='o',max='**', - regles=(ENSEMBLE('NOM','TYPE'), -# erreur doc U sur la condition qui suit - UN_PARMI('NOEUD','GROUP_NO'),), - NOM =SIMP(statut='f',typ='TXM' ), - TYPE =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ), - NOEUD =SIMP(statut='f',typ=no,max='**'), - GROUP_NO =SIMP(statut='f',typ=grno,max='**'), -# DDL_ACTIF =SIMP(statut='f',typ='TXM',max='**'), - MASQUE =SIMP(statut='f',typ='TXM',max='**'), - ), - FREQ =SIMP(statut='f',typ='R',defaut= 1.), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), -) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== # RESPONSABLE ZENTNER I.ZENTNER from Macro.defi_inte_spec_ops import defi_inte_spec_ops @@ -10757,23 +11888,62 @@ DEFI_INTE_SPEC=MACRO(nom="DEFI_INTE_SPEC",op= defi_inte_spec_ops,sd_prod=table_f # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE COURTOIS M.COURTOIS -DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster, - fr="Définir une liste d'entiers strictement croissante", - reentrant='n', - UIinfo={"groupes":("Fonctions",)}, - - OPERATION =SIMP(statut='o',typ='TXM',defaut='DEFI',into=('DEFI','NUME_ORDRE',)), - +# RESPONSABLE CORUS M.CORUS - # définition d'une liste d'entiers - #---------------------------------- - b_defi =BLOC(condition = "OPERATION == 'DEFI'", - regles=(UN_PARMI('VALE','DEBUT'), - EXCLUS('VALE','INTERVALLE'),), - VALE =SIMP(statut='f',typ='I',max='**'), - DEBUT =SIMP(statut='f',typ='I'), - INTERVALLE =FACT(statut='f',max='**', +DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas, + reentrant='n', + UIinfo={"groupes":("Matrices et vecteurs","Dynamique",)}, + fr="Définir les interfaces d'une structure et leur affecter un type", + NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ), + INTERFACE =FACT(statut='o',max='**', + regles=(ENSEMBLE('NOM','TYPE'), +# erreur doc U sur la condition qui suit + UN_PARMI('NOEUD','GROUP_NO'),), + NOM =SIMP(statut='f',typ='TXM' ), + TYPE =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ), + NOEUD =SIMP(statut='f',typ=no,max='**'), + GROUP_NO =SIMP(statut='f',typ=grno,max='**'), +# DDL_ACTIF =SIMP(statut='f',typ='TXM',max='**'), + MASQUE =SIMP(statut='f',typ='TXM',max='**'), + ), + FREQ =SIMP(statut='f',typ='R',defaut= 1.), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), +) ; +#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE COURTOIS M.COURTOIS +DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster, + fr="Définir une liste d'entiers strictement croissante", + reentrant='n', + UIinfo={"groupes":("Fonctions",)}, + + OPERATION =SIMP(statut='o',typ='TXM',defaut='DEFI',into=('DEFI','NUME_ORDRE',)), + + + # définition d'une liste d'entiers + #---------------------------------- + b_defi =BLOC(condition = "OPERATION == 'DEFI'", + regles=(UN_PARMI('VALE','DEBUT'), + EXCLUS('VALE','INTERVALLE'),), + VALE =SIMP(statut='f',typ='I',max='**'), + DEBUT =SIMP(statut='f',typ='I'), + INTERVALLE =FACT(statut='f',max='**', regles=(UN_PARMI('NOMBRE','PAS'),), JUSQU_A =SIMP(statut='o',typ='I'), NOMBRE =SIMP(statut='f',typ='I',val_min=1,), @@ -10794,10 +11964,10 @@ DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster, INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 23/11/2010 AUTEUR COURTOIS M.COURTOIS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR GENIAUT S.GENIAUT # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -10814,6 +11984,7 @@ DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster, # ====================================================================== # RESPONSABLE GENIAUT S.GENIAUT + # bloc utilisé deux fois à l'identique bloc_unif = BLOC(condition = "SUBD_METHODE == 'UNIFORME'", SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,max=1, @@ -10835,7 +12006,6 @@ bloc_unif = BLOC(condition = "SUBD_METHODE == 'UNIFORME'", ), ) # fin si UNIFORME - DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op= 28,sd_prod=list_inst,reentrant='n', UIinfo={"groupes":("Fonctions",)}, fr="Définition de la gestion de la liste d'instants", @@ -10852,27 +12022,21 @@ DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op= 28,sd_prod=list_inst,reentrant='n' LIST_INST =SIMP(statut='o',typ=listr8_sdaster), ), - b_auto =BLOC(condition = "METHODE == 'AUTO' ",fr="a compléter", + b_auto =BLOC(condition = "(METHODE == 'AUTO') ",fr="Gestion automatique de la liste d'instants", LIST_INST =SIMP(statut='o',typ=listr8_sdaster), - PAS_MINI =SIMP(statut='o',typ='R',val_min=0.0,max=1), + PAS_MINI =SIMP(statut='f',typ='R',val_min=1.e-12,max=1), PAS_MAXI =SIMP(statut='f',typ='R',max=1), - NB_PAS_MAXI =SIMP(statut='f',typ='I',max=1), + NB_PAS_MAXI =SIMP(statut='f',typ='I',val_max=1000000,max=1,defaut=1000000), ), -# b_cfl =BLOC(condition = "METHODE == 'CFL' ",fr="Liste d'instants construite sur condition CFL", -# COEF =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut=0.5), -# MODELE =SIMP(statut='o',typ=modele_sdaster), -# ), - - ), - + ), # ---------------------------------------------------------------------------------------------------------------------------------- # mot-cle pour le comportement en cas d'echec (on doit recommencer le meme instant) # ---------------------------------------------------------------------------------------------------------------------------------- ECHEC =FACT(statut='d',max='**', - EVENEMENT =SIMP(statut='f',typ='TXM',into=("ERREUR","DELTA_GRANDEUR"),defaut="ERREUR",max=1 ), + EVENEMENT =SIMP(statut='f',typ='TXM',into=("ERREUR","DELTA_GRANDEUR","DIVE_ITER_PILO"),defaut="ERREUR",max=1 ), b_edelta =BLOC(condition = "EVENEMENT == 'DELTA_GRANDEUR' ",fr=" ", # event-driven : on sous-decoupe si l'increment d'une composante d'un champ depasse le seuil @@ -10961,7 +12125,9 @@ DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op= 28,sd_prod=list_inst,reentrant='n' # 2) parametre du mode de calcul de dt+ # ---------------------------------------- - MODE_CALCUL_TPLUS =SIMP(statut='f',typ='TXM',into=("FIXE","DELTA_GRANDEUR","ITER_NEWTON","FORMULE"),defaut='FIXE',max=1 ), + MODE_CALCUL_TPLUS =SIMP(statut='f',typ='TXM',into=("FIXE","DELTA_GRANDEUR","ITER_NEWTON","FORMULE","IMPLEX"),defaut='FIXE', + max=1), + b_mfixe =BLOC(condition = "MODE_CALCUL_TPLUS == 'FIXE' ",fr="fixe", # dans le cas FIXE :(deltaT+) = (deltaT-)x(1+PCENT_AUGM/100) PCENT_AUGM =SIMP(statut='f',typ='R',defaut=100.,val_min=-100.,max=1), @@ -11019,6 +12185,23 @@ DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op= 28,sd_prod=list_inst,reentrant='n' ), ), +# b_adaplex = BLOC(condition = "METHODE == 'AUTO' and MODE_CALCUL_TPLUS == 'IMPLEX'", +# +# ADAPTATION =FACT(statut='d',max='**', +# +# 1 parametres de l'evenement declencheur +# ---------------------------------------- +# +# EVENEMENT =SIMP(statut='f',typ='TXM',into=("TOUT_INST",),defaut="TOUT_INST",max=1 ), +# +# +# 2 parametre du mode de calcul de dt+ +# ---------------------------------------- +# +# MODE_CALCUL_TPLUS =SIMP(statut='f',typ='TXM',into=("IMPLEX",),defaut='IMPLEX',max=1,position='global' ), +# +# ), +# ), # ---------------------------------------------------------------------------------------------------------------------------------- @@ -11142,10 +12325,10 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, GROUP_NO_FIN =SIMP(statut='f',typ=grno), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 23/02/2011 AUTEUR LAVERNE J.LAVERNE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -11184,6 +12367,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, EXCLUS('META_LEMA_ANI','META_LEMA_ANI_FO'), EXCLUS('VMIS_POUTRE','VMIS_POUTRE_FO'), EXCLUS('VENDOCHAB','VENDOCHAB_FO'), + EXCLUS('VISC_ENDO','VISC_ENDO_FO'), PRESENT_PRESENT('BPEL_ACIER','ELAS'), EXCLUS('RCCM','RCCM_FO'), EXCLUS('WEIBULL','WEIBULL_FO'), @@ -11904,15 +13088,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PRESENT_PRESENT('ANG1_FO','ANG2_FO','PEN1_FO','PEN2_FO','PEN3_FO',), ), ), - NADAI_B =FACT(statut='f', - F_C =SIMP(statut='o',typ='R',val_min=0.E+0), - F_T =SIMP(statut='o',typ='R',val_min=0.E+0), - CRIT_E_C =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), - EPSP_P_C =SIMP(statut='o',typ='R',val_min=0.E+0), - EPSP_R_C =SIMP(statut='o',typ='R',val_min=0.E+0), - EPSI_R_T =SIMP(statut='o',typ='R',val_min=0.E+0), - FAC_T_C =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), - ), BETON_DOUBLE_DP =FACT(statut='f', F_C =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), F_T =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -11970,27 +13145,31 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, BDN =SIMP(statut='o',typ='R',defaut= 1.E+0,val_min=1.E-1), ), VENDOCHAB =FACT(statut='f', - S =SIMP(statut='o',typ='R',defaut= 0.E+0), + SY =SIMP(statut='o',typ='R',defaut= 0.E+0), ALPHA_D =SIMP(statut='o',typ='R',defaut= 0.E+0), BETA_D =SIMP(statut='o',typ='R',defaut= 0.E+0), - N =SIMP(statut='o',typ='R'), - UN_SUR_M =SIMP(statut='o',typ='R',defaut= 0.E+0), - UN_SUR_K =SIMP(statut='o',typ='R'), R_D =SIMP(statut='o',typ='R'), A_D =SIMP(statut='o',typ='R'), K_D =SIMP(statut='o',typ='R'), ), VENDOCHAB_FO =FACT(statut='f', - S =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), + SY =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), ALPHA_D =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), BETA_D =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - N =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - UN_SUR_M =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - UN_SUR_K =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), R_D =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), A_D =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), K_D =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), ), + VISC_ENDO =FACT(statut='f', + SY =SIMP(statut='o',typ='R',defaut= 0.E+0), + R_D =SIMP(statut='o',typ='R'), + A_D =SIMP(statut='o',typ='R'), + ), + VISC_ENDO_FO =FACT(statut='f', + SY =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), + R_D =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), + A_D =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), + ), PINTO_MENEGOTTO =FACT(statut='f', SY =SIMP(statut='o',typ='R'), EPSI_ULTM =SIMP(statut='o',typ='R'), @@ -12604,7 +13783,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PRE2 = SIMP(statut='f',typ='R'), PRES_VAPE = SIMP(statut='f',typ='R'), DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -12659,10 +13837,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PERM_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - SIGMA_T =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -12738,7 +13912,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # --------------------------------------------------------------------------------- PRES_VAPE = SIMP(statut='f',typ='R'), DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -12808,10 +13981,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- EMMAG = SIMP(statut='f',typ='R'), - SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -12890,7 +14059,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PRE2 = SIMP(statut='f',typ='R'), PRES_VAPE = SIMP(statut='f',typ='R'), DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -12942,10 +14110,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PERM_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - SIGMA_T =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -13022,7 +14186,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PRE2 = SIMP(statut='f',typ='R'), PRES_VAPE = SIMP(statut='f',typ='R'), DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -13074,10 +14237,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PERM_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - SIGMA_T =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -13154,7 +14313,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -13224,10 +14382,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES FACULTATIVES ------------------------------------ # --------------------------------------------------------------------------------- EMMAG = SIMP(statut='f',typ='R'), - SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_S = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -13258,11 +14412,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # --------------------------------------------------------------------------------- ALPHA = SIMP(statut='f',typ='R'), CP = SIMP(statut='f',typ='R'), - LAMB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_LB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - LAMB_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_LB_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- @@ -13339,7 +14488,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -13409,10 +14557,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES FACULTATIVE ---------------------------------- # --------------------------------------------------------------------------------- EMMAG = SIMP(statut='f',typ='R'), - SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_S = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -13499,7 +14643,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -13569,10 +14712,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES FACULTATIVES ------------------------------------ # --------------------------------------------------------------------------------- EMMAG = SIMP(statut='f',typ='R'), - SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_S = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -13600,11 +14739,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # --------------------------------------------------------------------------------- ALPHA = SIMP(statut='f',typ='R'), CP = SIMP(statut='f',typ='R'), - LAMB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_LB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - LAMB_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_LB_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - LAMB_CT = SIMP(statut='f',typ='R'), ), # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -13671,7 +14805,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # --------------------------------------------------------------------------------- PRE2 = SIMP(statut='f',typ='R'), DEGR_SATU = SIMP(statut='f',typ='R'), - PRES_ATMO = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEE CACHEE --------------------------------------------- # --------------------------------------------------------------------------------- @@ -13739,10 +14872,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- EMMAG = SIMP(statut='f',typ='R'), - SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - D_SIGMA_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - PERM_G_INTR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - CHAL_VAPO = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PV = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), FICKV_PG = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -13894,8 +15023,23 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PENA_ADHERENCE =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), PENA_CONTACT =SIMP(statut='f',typ='R',defaut=1.), ), + RUPT_DUCT =FACT(statut='f', + GC =SIMP(statut='o',typ='R'), + SIGM_C =SIMP(statut='o',typ='R'), + COEF_EXTR =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=9.99E-1), + COEF_PLAS =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=9.99E-1), + PENA_LAGR =SIMP(statut='f',typ='R',defaut=1.0E2,val_min=1.01E+0), + RIGI_GLIS =SIMP(statut='f',typ='R',defaut=1.0E1), + ), JOINT_MECA_RUPT =FACT(statut='f', - regles=(EXCLUS('PRES_FLUIDE','PRES_CLAVAGE'),), + regles=(EXCLUS('PRES_FLUIDE','PRES_CLAVAGE'), + PRESENT_PRESENT('RHO_FLUIDE','VISC_FLUIDE','OUV_MIN'), + PRESENT_ABSENT('PRES_FLUIDE','RHO_FLUIDE','VISC_FLUIDE','OUV_MIN'), + PRESENT_ABSENT('PRES_CLAVAGE','RHO_FLUIDE','VISC_FLUIDE','OUV_MIN'), + PRESENT_ABSENT('RHO_FLUIDE','PRES_FLUIDE','PRES_CLAVAGE'), + PRESENT_ABSENT('VISC_FLUIDE','PRES_FLUIDE','PRES_CLAVAGE'), + PRESENT_ABSENT('OUV_MIN','PRES_FLUIDE','PRES_CLAVAGE'), + ), K_N =SIMP(statut='o',typ='R',val_min=1.E-12), K_T =SIMP(statut='f',typ='R',val_min=1.E-12), SIGM_MAX =SIMP(statut='o',typ='R',val_min=0.), @@ -13904,7 +15048,17 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PENA_CONTACT =SIMP(statut='f',typ='R',defaut=1.,val_min=1.E-12), PRES_FLUIDE =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), PRES_CLAVAGE =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + RHO_FLUIDE =SIMP(statut='f',typ='R',val_min=0.), + VISC_FLUIDE =SIMP(statut='f',typ='R',val_min=1.E-20), + OUV_MIN =SIMP(statut='f',typ='R',val_min=1.E-15), ), + JOINT_MECA_FROT =FACT(statut='f', + K_N =SIMP(statut='o',typ='R',val_min=1.E-12), + K_T =SIMP(statut='f',typ='R',val_min=1.E-12), + MU =SIMP(statut='o',typ='R',val_min=1.E-3), + PENA_TANG =SIMP(statut='f',typ='R',val_min=0.), + ADHESION =SIMP(statut='f',typ='R',defaut=0., val_min=0.), + ), RCCM =FACT(statut='f', regles=(ENSEMBLE('A_AMORC','B_AMORC','D_AMORC','R_AMORC'),), SY_02 =SIMP(statut='f',typ='R'), @@ -14054,13 +15208,13 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, ), #### MONOCRISTAL - ECOU_VISC1 =FACT(statut='f', + MONO_VISC1 =FACT(statut='f', TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), N =SIMP(statut='o',typ='R'), K =SIMP(statut='o',typ='R'), C =SIMP(statut='o',typ='R'), ), - ECOU_VISC2 =FACT(statut='f', + MONO_VISC2 =FACT(statut='f', TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), N =SIMP(statut='o',typ='R'), K =SIMP(statut='o',typ='R'), @@ -14068,7 +15222,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, D =SIMP(statut='o',typ='R'), A =SIMP(statut='o',typ='R'), ), - ECOU_VISC3 =FACT(statut='f', + MONO_VISC3 =FACT(statut='f', TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), K =SIMP(statut='o',typ='R',fr="Constante de Boltzmann, en eV/K"), TAUMU =SIMP(statut='o',typ='R',fr="Seuil d ecoulement, en unite de contraintes"), @@ -14076,31 +15230,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, DELTAV =SIMP(statut='o',typ='R',fr="Volume d activation"), DELTAG0 =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"), ), - KOCKS_RAUCH =FACT(statut='f', - regles=(UN_PARMI('H','H1'), - PRESENT_PRESENT('H1','H2','H3','H4'), - PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'), - ), - TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), - K =SIMP(statut='o',typ='R',fr="Constante de Boltzmann, en eV/K"), - TAUR =SIMP(statut='o',typ='R',fr="Contraintes de cisaillement à T=0K, en unite de contraintes"), - TAU0 =SIMP(statut='o',typ='R',fr="Contraintes critique initiale de cisaillement, en unite de contraintes"), - GAMMA0 =SIMP(statut='o',typ='R',fr="Vitesse d ecoulement initiale"), - DELTAG0 =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"), - BSD =SIMP(statut='o',typ='R',fr="fonction de la taille du grain B/D"), - GCB =SIMP(statut='o',typ='R',fr="distance critique d'annihilation GC/B"), - KDCS =SIMP(statut='o',typ='R',fr="Parametre relatif à la direction principale de la dislocation"), - P =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"), - Q =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"), - H =SIMP(statut='f',typ='R'), - H1 =SIMP(statut='f',typ='R'), - H2 =SIMP(statut='f',typ='R'), - H3 =SIMP(statut='f',typ='R'), - H4 =SIMP(statut='f',typ='R'), - H5 =SIMP(statut='f',typ='R'), - H6 =SIMP(statut='f',typ='R'), - ), - ECRO_ISOT1 =FACT(statut='f', + MONO_ISOT1 =FACT(statut='f', regles=(UN_PARMI('H','H1'), PRESENT_PRESENT('H1','H2','H3','H4'), PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'), @@ -14117,7 +15247,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, H5 =SIMP(statut='f',typ='R'), H6 =SIMP(statut='f',typ='R'), ), - ECRO_ISOT2 =FACT(statut='f', + MONO_ISOT2 =FACT(statut='f', regles=(UN_PARMI('H','H1'), PRESENT_PRESENT('H1','H2','H3','H4'), PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'), @@ -14136,30 +15266,53 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, Q2 =SIMP(statut='o',typ='R'), B2 =SIMP(statut='o',typ='R'), ), - ECRO_CINE1 =FACT(statut='f', + MONO_CINE1 =FACT(statut='f', TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECRO_CINE",),), D =SIMP(statut='o',typ='R'), ), - ECRO_CINE2 =FACT(statut='f', + MONO_CINE2 =FACT(statut='f', TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECRO_CINE",),), D =SIMP(statut='o',typ='R'), GM =SIMP(statut='o',typ='R'), PM =SIMP(statut='o',typ='R'), C =SIMP(statut='o',typ='R'), ), - ECOU_DD_CFC =FACT(statut='f', - TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), + MONO_DD_KR =FACT(statut='f', + regles=(UN_PARMI('H','H1'), + PRESENT_PRESENT('H1','H2','H3','H4'), + PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'), + ), + # TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), + K =SIMP(statut='o',typ='R',fr="Constante de Boltzmann, en eV/K"), + TAUR =SIMP(statut='o',typ='R',fr="Contraintes de cisaillement à T=0K, en unite de contraintes"), + TAU0 =SIMP(statut='o',typ='R',fr="Contraintes critique initiale de cisaillement, en unite de contraintes"), + GAMMA0 =SIMP(statut='o',typ='R',fr="Vitesse d ecoulement initiale"), + DELTAG0 =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"), + BSD =SIMP(statut='o',typ='R',fr="fonction de la taille du grain B/D"), + GCB =SIMP(statut='o',typ='R',fr="distance critique d'annihilation GC/B"), + KDCS =SIMP(statut='o',typ='R',fr="Parametre relatif à la direction principale de la dislocation"), + P =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"), + Q =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"), + H =SIMP(statut='f',typ='R'), + H1 =SIMP(statut='f',typ='R'), + H2 =SIMP(statut='f',typ='R'), + H3 =SIMP(statut='f',typ='R'), + H4 =SIMP(statut='f',typ='R'), + H5 =SIMP(statut='f',typ='R'), + H6 =SIMP(statut='f',typ='R'), + ), + MONO_DD_CFC =FACT(statut='f', + regles=(UN_PARMI('H','H1'), + PRESENT_PRESENT('H1','H2','H3','H4','H5'), + PRESENT_ABSENT('H','H1','H2','H3','H4','H5'), + ), + #TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), GAMMA0 =SIMP(statut='f',typ='R',defaut=0.001,fr="Vitesse d ecoulement initiale en s**-1"), TAU_F =SIMP(statut='o',typ='R',fr="Contraintes , en unite de contraintes ex 20 MPa"), A =SIMP(statut='f',typ='R',defaut=0.13,fr="paramètre A, sans unité"), B =SIMP(statut='f',typ='R',defaut=0.005,fr="paramètre B, sans unité"), N =SIMP(statut='f',typ='R',defaut=200.,fr="paramètre n, sans unité"), Y =SIMP(statut='o',typ='R',fr="paramète Y, en unité de longueur ex 2.5 A"), - ), - ECRO_DD_CFC =FACT(statut='f', - regles=(PRESENT_PRESENT('H1','H2','H3','H4','H5'), - ), - TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECRO_ISOT",),), ALPHA =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, paramètre alpha"), BETA =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre b, en unite de longueur"), RHO_REF =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre rho_ref, en unité de longueur **-2"), @@ -14172,6 +15325,31 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, ), + MONO_DD_CC =FACT(statut='f', + regles=(UN_PARMI('H','H1'), + PRESENT_PRESENT('H1','H2','H3','H4','H5','H6'), + PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'), + ), + #TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),), + GAMMA0 =SIMP(statut='f',typ='R',defaut=0.001,fr="Vitesse d ecoulement initiale en s**-1"), + TAU_F =SIMP(statut='o',typ='R',fr="Contraintes , en unite de contraintes ex 20 MPa"), + A =SIMP(statut='f',typ='R',defaut=0.13,fr="paramètre A, sans unité"), + B =SIMP(statut='f',typ='R',defaut=0.005,fr="paramètre B, sans unité"), + N =SIMP(statut='f',typ='R',defaut=200.,fr="paramètre n, sans unité"), + Y =SIMP(statut='o',typ='R',fr="paramète Y, en unité de longueur ex 2.5 A"), + ALPHA =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, paramètre alpha"), + BETA =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre b, en unite de longueur"), + RHO_REF =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre rho_ref, en unité de longueur **-2"), + H =SIMP(statut='f',typ='R'), + H1 =SIMP(statut='f',typ='R'), + H2 =SIMP(statut='f',typ='R'), + H3 =SIMP(statut='f',typ='R'), + H4 =SIMP(statut='f',typ='R'), + H5 =SIMP(statut='f',typ='R'), + H6 =SIMP(statut='f',typ='R'), + ), + + #### MONOCRISTAL ### UMAT @@ -14335,10 +15513,10 @@ DEFI_MODELE_GENE=OPER(nom="DEFI_MODELE_GENE",op= 126,sd_prod=modele_gene, ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 22/03/2011 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -14367,14 +15545,16 @@ DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op=4,sd_prod=nappe_sdaster, NOM_PARA_FONC =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ), DEFI_FONCTION =FACT(statut='f',max='**', VALE =SIMP(statut='o',typ='R',max='**'), - INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ), + INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"), + fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction."), PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), ), - INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ), + INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"), + fr="Type d'interpolation pour le paramètre de la nappe"), PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1, 2) ), VERIF =SIMP(statut='f',typ='TXM',into=("CROISSANT",) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; @@ -14779,10 +15959,10 @@ DEFI_SPEC_TURB=OPER(nom="DEFI_SPEC_TURB",op= 145,sd_prod=spectre_sdaster, ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 25/01/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -14844,7 +16024,8 @@ DEFI_SQUELETTE=OPER(nom="DEFI_SQUELETTE",op= 110,sd_prod=squelette, TRANS =SIMP(statut='f',typ='R',min=3,max=3), ANGL_NAUT =SIMP(statut='f',typ='R',min=3,max=3), SOUS_STRUC =FACT(statut='f',max='**', - NOM =SIMP(statut='f',typ='TXM' ), + regles=(UN_PARMI('TOUT','MAILLE','GROUP_MA'),), + NOM =SIMP(statut='o',typ='TXM' ), MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), @@ -15070,10 +16251,10 @@ DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_fonction, TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -15089,45 +16270,68 @@ DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_fonction, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE ZENTNER I.ZENTNER + from Macro.dyna_iss_vari_ops import dyna_iss_vari_ops # -DYNA_ISS_VARI=MACRO(nom="DYNA_ISS_VARI",op=dyna_iss_vari_ops ,sd_prod=table_fonction, +def dyna_iss_vari_prod(self, FONC_SIGNAL,**args): + if FONC_SIGNAL !=None : + return tran_gene + else: + return table_fonction + raise AsException("type de concept resultat non prevu") +# + + +DYNA_ISS_VARI=MACRO(nom="DYNA_ISS_VARI",op=dyna_iss_vari_ops , sd_prod=dyna_iss_vari_prod, fr="Calcul du spectre de réponse ou de la reponse temporelle sismique incoherente par decomposition spectrale", reentrant='n', - UIinfo={"groupes":("Outils-métier","Dynamique",)}, - NOM_CMP =SIMP(statut='o',typ='TXM',into=("DX","DY","DZ") ), - PRECISION =SIMP(statut='f',typ='R',defaut=0.999 ), + UIinfo={"groupes":("Outils métier",)}, + regles=(UN_PARMI('FONC_SIGNAL','NB_FREQ'),), + FONC_SIGNAL =SIMP(statut='f',typ=(fonction_sdaster) ), + NB_FREQ =SIMP(statut='f',typ='I' ), + NOM_CMP =SIMP(statut='o',typ='TXM',into=("DX","DY","DZ") ), + PRECISION =SIMP(statut='f',typ='R',defaut=0.999 ), INTERF =FACT(statut='o', - GROUP_NO_INTERF =SIMP(statut='o',typ=grma ,max='**'), - MODE_INTERF =SIMP(statut='o',typ='TXM',into=("CORP_RIGI","TOUT")), - ), + GROUP_NO_INTERF =SIMP(statut='o',typ=grno ,max='**'), + MODE_INTERF =SIMP(statut='o',typ='TXM',into=("CORP_RIGI","TOUT")), + ), MATR_COHE =FACT(statut='o', - VITE_ONDE =SIMP(statut='o',typ='R'), - PARA_ALPHA =SIMP(statut='f',typ='R',defaut=0.5), + VITE_ONDE =SIMP(statut='o',typ='R'), + PARA_ALPHA =SIMP(statut='f',typ='R',defaut=0.5), ), -# FONC_MULT =SIMP(statut='f',typ='R' ), - FREQ_INIT =SIMP(statut='o',typ='R' ), - NB_FREQ =SIMP(statut='o',typ='I' ), - PAS =SIMP(statut='o',typ='R' ), -# LIST_FREQ =SIMP(statut='o',typ='liste' ), +# LIST_FREQ =SIMP(statut='o',typ='liste' ), UNITE_RESU_FORC = SIMP(statut='f',typ='I',defaut=33), - UNITE_RESU_IMPE = SIMP(statut='f',typ='I',defaut=32), + UNITE_RESU_IMPE = SIMP(statut='f',typ='I',defaut=32), TYPE = SIMP(statut='f',typ='TXM',into=("BINAIRE","ASCII"), defaut="ASCII"), +# NOM_CHAM =SIMP(statut='f',typ='TXM',into=("DEPL","VITE","ACCE") , validators=NoRepeat(),max=3,defaut="DEPL" ), # MATR_GENE = FACT(statut='o', MATR_MASS = SIMP(statut='o',typ=(matr_asse_gene_r ) ), MATR_RIGI = SIMP(statut='o',typ=(matr_asse_gene_r,matr_asse_gene_c ) ), - MATR_AMOR = SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c ) ), - ), -# - OPTION = SIMP(statut='f',typ='TXM',into=("TOUT","DIAG"),defaut="TOUT"), -# - INFO =SIMP(statut='f',typ='I' ,defaut=1,into=( 1 , 2)), + MATR_AMOR = SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c ) ), + ), +# + INFO =SIMP(statut='f',typ='I' ,defaut=1,into=( 1 , 2)), +# + b_type_trans = BLOC(condition="FONC_SIGNAL !=None", + FREQ_MAX =SIMP(statut='f',typ='R' ), + FREQ_PAS =SIMP(statut='f',typ='R' ), + regles=( ENSEMBLE('FREQ_MAX','FREQ_PAS'), ) + + ), + + b_type_spec = BLOC(condition="NB_FREQ != None", + FREQ_INIT =SIMP(statut='o',typ='R' ), + FREQ_PAS =SIMP(statut='o',typ='R' ), + OPTION = SIMP(statut='f',typ='TXM',into=("TOUT","DIAG"),defaut="TOUT"), + ), + + ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 18/01/2011 AUTEUR BOITEAU O.BOITEAU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -15217,11 +16421,12 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op= 60,sd_prod=dyna_line_harm_prod, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), ), @@ -15247,11 +16452,12 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op= 60,sd_prod=dyna_line_harm_prod, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), - OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), ), @@ -15264,10 +16470,10 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op= 60,sd_prod=dyna_line_harm_prod, # Rajouter test icompatibilite vect_asse et sensibilite # Peut-on aussi rajouter ici le test d incompatibilite charge complexe - derivation # presents dans le Fortran -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -15384,7 +16590,7 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -15393,12 +16599,13 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), PARALLELISME =SIMP(statut='f',typ='TXM',defaut="CENTRALISE",into=("CENTRALISE","CENTRALISE")), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", @@ -15410,7 +16617,7 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -15458,10 +16665,10 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 21/02/2011 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -15533,23 +16740,14 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', MASS_GENE =SIMP(statut='f',typ=matr_asse_gene_r), RIGI_GENE =SIMP(statut='f',typ=matr_asse_gene_r), AMOR_GENE =SIMP(statut='f',typ=matr_asse_gene_r), + DEPL_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene), + VITE_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene), + ACCE_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene), ), +#------------------------------------------------------------------- COMP_INCR =C_COMP_INCR(), - COMP_ELAS =FACT(statut='f',max='**', - RELATION =SIMP(statut='o',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS", - "ELAS_POUTRE_GR","CABLE","ELAS_HYPER")), - DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ), - regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), - TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("IMPLICITE",)), - ), +#------------------------------------------------------------------- + COMP_ELAS =C_COMP_ELAS('DYNA_NON_LINE'), #------------------------------------------------------------------- b_reuse =BLOC(condition = "reuse",fr="en mode concept reentrant : ETAT_INIT obligatoire", ETAT_INIT =FACT(statut='o', @@ -15632,14 +16830,8 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', b_implicit= BLOC(condition="SCHEMA!='TCHAMWA'and SCHEMA!='DIFF_CENT'", FORMULATION =SIMP(statut='o',max=1,typ='TXM',into=("DEPLACEMENT","VITESSE","ACCELERATION"),),), ), - NEWTON =FACT(statut='d', - REAC_INCR =SIMP(statut='f',typ='I',defaut= 1,val_min=0 ), - PREDICTION =SIMP(statut='f',typ='TXM',into=("TANGENTE","ELASTIQUE") ), - MATRICE =SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE") ), - REAC_ITER =SIMP(statut='f',typ='I',defaut= 0,val_min=0), - REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0,val_min=0), - PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0), - ), +#------------------------------------------------------------------- + NEWTON =C_NEWTON(), #------------------------------------------------------------------- RECH_LINEAIRE =C_RECH_LINEAIRE(), #------------------------------------------------------------------- @@ -15647,90 +16839,13 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', #------------------------------------------------------------------- SOLVEUR =C_SOLVEUR(), #------------------------------------------------------------------- - OBSERVATION =FACT(statut='f',max='**', - NOM_CMP =SIMP(statut='o',typ='TXM',max='**'), - SUIVI_DDL =SIMP(statut='f',typ='TXM',defaut="NON",max=1,into=("OUI","NON")), - b_suivi =BLOC(condition = "SUIVI_DDL == 'OUI' ", - regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'), - PRESENT_PRESENT('MAILLE','POINT'),), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("DEPL","VITE","ACCE","SIEF_ELGA", - "VARI_ELGA","FORC_NODA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)), - GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4), - VALE_MAX =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ), - VALE_MIN =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),), - b_non_suivi =BLOC(condition = "SUIVI_DDL == 'NON' ", - regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'),PRESENT_PRESENT('MAILLE','POINT'),), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("DEPL","VITE","ACCE","SIEF_ELGA", - "VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU")), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - PAS_OBSE =SIMP(statut='f',typ='I'), - LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), - b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", - PRECISION =SIMP(statut='o',typ='R',),),), - ), - - AFFICHAGE = FACT(statut='f',max=16, - - UNITE = SIMP(statut='f',typ='I',val_min=1), - - LONG_R = SIMP(statut='f',typ='I',defaut=12,val_min=1,val_max=12), - PREC_R = SIMP(statut='f',typ='I',defaut=5, val_min=1,val_max=8), - LONG_I = SIMP(statut='f',typ='I',defaut=6, val_min=1,val_max=12), - - NOM_COLONNE = SIMP(statut='o',typ='TXM',defaut="STANDARD", - into=("STANDARD","MINIMUM", - "ITER_NEWT", - "INCR_TPS", - "RESI_RELA","RELA_NOEU", - "RESI_MAXI","MAXI_NOEU", - "RESI_REFE","REFE_NOEU", - "RELI_ITER","RELI_COEF", - "PILO_PARA", - "MATR_ASSE", - "ITER_DEBO", - "CTCD_ITER","CTCD_GEOM","CTCD_NOEU", - "BOUC_GEOM","BOUC_FROT","BOUC_CONT","CTCC_BOUC","CTCC_NOEU", - "SUIV_1","SUIV_2","SUIV_3","SUIV_4", - ), - ), - b_residu = BLOC(condition = " NOM_COLONNE == 'RESI_RELA' or \ - NOM_COLONNE == 'RESI_MAXI' or\ - NOM_COLONNE == 'RESI_REFE' or\ - NOM_COLONNE == 'CTCD_GEOM' or\ - NOM_COLONNE == 'CTCC_BOUC' or\ - NOM_COLONNE == 'STANDARD' ", - INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - ), - ), + OBSERVATION =C_OBSERVATION(), #------------------------------------------------------------------- - ARCHIVAGE =FACT(statut='f', - regles=(EXCLUS('PAS_ARCH','LIST_INST','INST'), - EXCLUS('ARCH_ETAT_INIT','NUME_INIT'), ), - LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - PAS_ARCH =SIMP(statut='f',typ='I' ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ARCH_ETAT_INIT =SIMP(statut='f',typ='TXM',into=("OUI",)), - NUME_INIT =SIMP(statut='f',typ='I'), - DETR_NUME_SUIV =SIMP(statut='f',typ='TXM',into=("OUI",)), - CHAM_EXCLU =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', - into=("DEPL","SIEF_ELGA","VARI_ELGA","ACCE","VITE",)), - ), - + SUIVI_DDL =C_SUIVI_DDL(), +#------------------------------------------------------------------- + AFFICHAGE =C_AFFICHAGE(), +#------------------------------------------------------------------- + ARCHIVAGE =C_ARCHIVAGE(), #------------------------------------------------------------------- CRIT_FLAMB =FACT(statut='f',min=1,max=1, NB_FREQ =SIMP(statut='f',typ='I',max=1,defaut=3), @@ -15748,7 +16863,15 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22', 'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23', 'PRES31','PRES32','PRES33','VARI','LAG_GV')),), - INST_CALCUL =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ), + regles = (EXCLUS('PAS_CALC','LIST_INST','INST'),), + LIST_INST = SIMP(statut='f',typ=(listr8_sdaster) ), + INST = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + PAS_CALC = SIMP(statut='f',typ='I' ), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), ), MODE_VIBR =FACT(statut='f',min=1,max=1, MATR_RIGI =SIMP(statut='f',typ='TXM',defaut="ELASTIQUE",into=("ELASTIQUE","TANGENTE","SECANTE",) ), @@ -15756,7 +16879,15 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', fr="Nombre de fréquences propres à calculer"), BANDE =SIMP(statut='f',typ='R',min=2,max=2, fr="Valeur des deux fréquences délimitant la bande de recherche",), - INST_CALCUL =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ), + regles = (EXCLUS('PAS_CALC','LIST_INST','INST'),), + LIST_INST = SIMP(statut='f',typ=(listr8_sdaster) ), + INST = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + PAS_CALC = SIMP(statut='f',typ='I' ), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), ), #------------------------------------------------------------------- SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', @@ -15806,10 +16937,10 @@ DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=table_fonction, OPTION =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG") ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 31/01/2011 AUTEUR GREFFET N.GREFFET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -15833,7 +16964,7 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op= 74,sd_prod=tran_gene, regles=(EXCLUS('AMOR_REDUIT','AMOR_GENE','LIST_AMOR'), PRESENT_ABSENT('MODE_STAT','MODE_CORR'),), METHODE =SIMP(statut='f',typ='TXM',defaut="EULER", - into=("EULER","NEWMARK","DEVOGE","ADAPT","ITMI") ), + into=("EULER","NEWMARK","DEVOGE","ADAPT_ORDRE1","ADAPT_ORDRE2","ITMI") ), MASS_GENE =SIMP(statut='o',typ=matr_asse_gene_r ), RIGI_GENE =SIMP(statut='o',typ=matr_asse_gene_r ), AMOR_GENE =SIMP(statut='f',typ=matr_asse_gene_r ), @@ -15845,7 +16976,17 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op= 74,sd_prod=tran_gene, COUPLAGE_EDYOS =FACT(statut='f',max=1, VITE_ROTA = SIMP(statut='o',typ='R' ), PAS_TPS_EDYOS = SIMP(statut='o',typ='R' ), - UNITE = SIMP(statut='f',typ='I',defaut=45), + ), + + PALIER_EDYOS =FACT(statut='f',max='**', + regles=(PRESENT_ABSENT('UNITE','GROUP_NO'), + PRESENT_ABSENT('UNITE','TYPE_EDYOS'), + EXCLUS('GROUP_NO','NOEUD'),), + UNITE = SIMP(statut='f',typ='I',), + GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + NOEUD = SIMP(statut='f',typ=no), + TYPE_EDYOS = SIMP(statut='f',typ='TXM', + into=("PAPANL","PAFINL","PACONL","PAHYNL",),), ), ETAT_INIT =FACT(statut='f', @@ -16052,11 +17193,12 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op= 74,sd_prod=tran_gene, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), @@ -16103,15 +17245,58 @@ ENGENDRE_TEST=PROC(nom="ENGENDRE_TEST",op=178, TYPE_TEST =SIMP(statut='f',typ='TXM',defaut="SOMME",into=("SOMME",) ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 14/02/2011 AUTEUR GREFFET N.GREFFET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GREFFET N.GREFFET +# +# ENVOI DES CHAMPS CINEMATIQUES VIA YACS POUR COUPLAGE IFS +# +ENV_CINE_YACS=PROC(nom = "ENV_CINE_YACS", + op = 111, + UIinfo = {"groupes":("Résultats et champs",)}, + fr = "Envoi des champs de deplacement et vitesse via YACS pour Couplage de Code_Aster et Saturne", + regles = (EXCLUS('ETAT_INIT','RESULTAT',),), + MATR_PROJECTION = SIMP(statut='o', typ=corresp_2_mailla,), + VIS_A_VIS = FACT(statut='o', max='**', + GROUP_MA_1=SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + GROUP_NO_2=SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),), + RESULTAT = FACT(statut='f', + NUME_ORDRE=SIMP(statut='o', typ='I', validators=NoRepeat()), + RESU =SIMP(statut='o', typ=resultat_sdaster, validators=NoRepeat()),), + ETAT_INIT = FACT(statut='f', + DEPL=SIMP(statut='f', typ=cham_no_sdaster, validators=NoRepeat()), + VITE=SIMP(statut='f', typ=cham_no_sdaster, validators=NoRepeat()), + ACCE=SIMP(statut='f', typ=cham_no_sdaster, validators=NoRepeat()),), + INST = SIMP(statut='o',typ='R', ), + PAS = SIMP(statut='o',typ='R', ), + NUME_ORDRE_YACS = SIMP(statut='o', typ='I',), + INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), +) ; +#& MODIF COMMANDE DATE 01/03/2011 AUTEUR ASSIRE A.ASSIRE +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU @@ -16134,11 +17319,25 @@ EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",op=exec_logiciel_ops, sd_prod=exec_log fr="Exécute un logiciel ou une commande système depuis Aster", UIinfo={"groupes":("Gestion du travail","Outils-métier",)}, - regles = (AU_MOINS_UN('LOGICIEL', 'MAILLAGE'),), - + regles = ( AU_MOINS_UN('LOGICIEL', 'MAILLAGE', 'SALOME'), + EXCLUS('MACHINE_DISTANTE','MAILLAGE'), + EXCLUS('MAILLAGE','SALOME'), + ), + LOGICIEL = SIMP(statut='f', typ='TXM'), ARGUMENT = SIMP(statut='f', max='**', typ='TXM'), + + MACHINE_DISTANTE = FACT(statut='f', + SSH_ADRESSE = SIMP(statut='o', typ='TXM', val_min=1, val_max=255, + fr="Adresse IP ou nom de la machine sur laquelle le logiciel/script sera exécuté via SSH"), + SSH_LOGIN = SIMP(statut='f', typ='TXM', val_min=1, val_max=255, + fr="Nom d'utilisateur sur la machine distante"), + SSH_PORT = SIMP(statut='f', typ='I', val_min=1, val_max=65535, defaut=22, + fr="Port SSH de la machien distante"), + ), + + MAILLAGE = FACT(statut='f', FORMAT = SIMP(statut='o', typ='TXM', into=("GMSH", "GIBI", "SALOME")), UNITE_GEOM = SIMP(statut='f', typ='I', val_min=10, val_max=90, defaut=16, @@ -16148,6 +17347,30 @@ EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",op=exec_logiciel_ops, sd_prod=exec_log MAILLAGE = SIMP(statut='o', typ=CO), ), + + SALOME = FACT(statut='f', + regles=(UN_PARMI('CHEMIN_SCRIPT', 'UNITE_SCRIPT'), + PRESENT_PRESENT('NOM_PARA','VALE'),), + CHEMIN_SCRIPT = SIMP(statut='f', typ='TXM', + fr="Chemin du script Salome"), + UNITE_SCRIPT = SIMP(statut='f', typ='I', val_min=80, val_max=99, + fr="Unité logique du script Salome"), + SALOME_HOST = SIMP(statut='f', typ='TXM', defaut='localhost', + fr="Machine sur laquelle tourne Salome"), + SALOME_PORT = SIMP(statut='f', typ='I', val_min=2800, val_max=2900, defaut=2810, + fr="Port de l'instance Salome (2810 ou supérieur)"), + SALOME_RUNAPPLI = SIMP(statut='f', typ='TXM', + fr="Chemin vers le script de lancement runAppli de Salome"), + FICHIERS_ENTREE = SIMP(statut='f', typ='TXM', validators=NoRepeat(),max='**', + fr="Liste des fichiers d'entrée du script Salome"), + FICHIERS_SORTIE = SIMP(statut='f', typ='TXM', validators=NoRepeat(),max='**', + fr="Liste des fichiers générés par le script Salome"), + NOM_PARA = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(), + fr="Liste des noms des paramètres à modifier dans le script Salome"), + VALE = SIMP(statut='f',typ='TXM',max='**', + fr="Valeur des paramètres à) modifier dans le script Salome"), + ), + CODE_RETOUR_MAXI = SIMP(statut='f', typ='I', defaut=0, val_min=-1, fr="Valeur maximale du code retour toléré (-1 pour l'ignorer)"), @@ -16340,10 +17563,10 @@ EXTR_TABLE=OPER(nom="EXTR_TABLE",op=173,sd_prod=extr_table_prod,reentrant='n', TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -16394,6 +17617,7 @@ FACTORISER=OPER(nom="FACTORISER",op=14,sd_prod=factoriser_prod, PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), # mots clés pour solveur GCPC et PETSc : PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ), @@ -16403,7 +17627,7 @@ FACTORISER=OPER(nom="FACTORISER",op=14,sd_prod=factoriser_prod, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -16864,10 +18088,10 @@ IMPR_FONCTION=MACRO(nom="IMPR_FONCTION",op=impr_fonction_ops,sd_prod=None, ), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -16918,7 +18142,7 @@ IMPR_GENE=PROC(nom="IMPR_GENE",op= 157, TOUT_CMP_GENE =SIMP(statut='f',typ='TXM',into=("OUI","NON") ), NUME_CMP_GENE =SIMP(statut='f',typ='I',max='**'), TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI","NON") ), - NOM_CHAM =SIMP(statut='f',typ='TXM',max='**'), + NOM_CHAM =SIMP(statut='f',typ='TXM',max='**',into=C_NOM_CHAM_INTO(),), TOUT_PARA =SIMP(statut='f',typ='TXM',into=("OUI","NON") ), NOM_PARA =SIMP(statut='f',typ='TXM',max='**'), SOUS_TITRE =SIMP(statut='f',typ='TXM',max='**'), @@ -16987,10 +18211,10 @@ IMPR_JEVEUX=PROC(nom="IMPR_JEVEUX",op=16, ), COMMENTAIRE =SIMP(statut='f',typ='TXM' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 01/03/2011 AUTEUR CORUS M.CORUS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17012,17 +18236,17 @@ IMPR_MACR_ELEM=PROC(nom="IMPR_MACR_ELEM",op= 160, fr="Impression d'une structure de données MACR_ELEM_DYNA au format IDEAS MISS3D PLEXUS ou CADYRO", MACR_ELEM_DYNA =SIMP(statut='o',typ=macr_elem_dyna ), FORMAT =SIMP(statut='f',typ='TXM',defaut="IDEAS", - into=("MISS_3D","IDEAS","CADYRO","PLEXUS") ), + into=("MISS_3D","IDEAS") ), - b_plexus =BLOC(condition = "FORMAT == 'IDEAS'", + b_ideas =BLOC(condition = "FORMAT == 'IDEAS'", UNITE =SIMP(statut='f',typ='I',defaut=30), VERSION =SIMP(statut='f',typ='I',defaut= 5,into=( 5 ,) ), ), - b_ideas =BLOC(condition = "FORMAT == 'PLEXUS'", - UNITE =SIMP(statut='f',typ='I',defaut=30), - VERSION =SIMP(statut='f',typ='I',defaut= 5,into=( 5 ,) ), - ), +# b_plexus =BLOC(condition = "FORMAT == 'PLEXUS'", +# UNITE =SIMP(statut='f',typ='I',defaut=30), +# VERSION =SIMP(statut='f',typ='I',defaut= 5,into=( 5 ,) ), +# ), b_miss_3d =BLOC(condition = "FORMAT == 'MISS_3D'", regles=(EXCLUS('AMOR_REDUIT','LIST_AMOR'),), @@ -17040,20 +18264,49 @@ IMPR_MACR_ELEM=PROC(nom="IMPR_MACR_ELEM",op= 160, IMPR_MODE_STAT =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), ), - b_cadyro =BLOC(condition = "FORMAT == 'CADYRO'", - SQUELETTE =SIMP(statut='f',typ=squelette ), - UNITE_MODE_MECA =SIMP(statut='f',typ='I',defaut= 26 ), - UNITE_MODE_STAT =SIMP(statut='f',typ='I',defaut= 27 ), - UNITE_MAILLAGE =SIMP(statut='f',typ='I',defaut= 28 ), - IMPR_MODE_MECA =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), - IMPR_MODE_STAT =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), - ), +# b_cadyro =BLOC(condition = "FORMAT == 'CADYRO'", +# SQUELETTE =SIMP(statut='f',typ=squelette ), +# UNITE_MODE_MECA =SIMP(statut='f',typ='I',defaut= 26 ), +# UNITE_MODE_STAT =SIMP(statut='f',typ='I',defaut= 27 ), +# UNITE_MAILLAGE =SIMP(statut='f',typ='I',defaut= 28 ), +# IMPR_MODE_MECA =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), +# IMPR_MODE_STAT =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), +# ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 14/02/2011 AUTEUR GREFFET N.GREFFET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GREFFET N.GREFFET +# +# RECUPERATION DES MAILLAGES IFS VENANT DE SATURNE VIA YACS +# +IMPR_MAIL_YACS=PROC(nom="IMPR_MAIL_YACS",op=43, + UIinfo={"groupes":("Maillage",)}, + fr="Lecture d'un maillage via YACS lors du Couplage de Code_Aster et Saturne", + UNITE_MAILLAGE = SIMP(statut='f',typ='I',defaut=30), + TYPE_MAILLAGE = SIMP(statut='o',typ='TXM',into=("SOMMET","MILIEU")), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), +) ; +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17079,27 +18332,24 @@ IMPR_MISS_3D=PROC(nom="IMPR_MISS_3D",op= 162, EXCIT =FACT(statut='f',max='**', regles=(UN_PARMI('FONC_MULT','COEF_MULT' ),), VECT_ASSE =SIMP(statut='f',typ=cham_no_sdaster), - FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), + FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),), COEF_MULT =SIMP(statut='f',typ='R' ), ), EXCIT_SOL =FACT(statut='f',max='**', DIRECTION =SIMP(statut='o',typ='R',min=3,max=3), FONC_SIGNAL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","VITE","ACCE","FORC",) ), + NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","FORC",),), ), SOURCE_SOL =FACT(statut='f',max='**', POINT =SIMP(statut='o',typ='R',min=3,max=3), DIRECTION =SIMP(statut='o',typ='R',min=3,max=3), - FONC_SIGNAL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","VITE","ACCE","FORC",) ), + FONC_SIGNAL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),), + NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","FORC",),), ), SOURCE_FLUIDE =FACT(statut='f',max='**', POINT =SIMP(statut='o',typ='R',min=3,max=3), - FONC_SIGNAL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","VITE","ACCE","FORC",) ), + FONC_SIGNAL =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),), + NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","FORC",),), ), DIRE_ONDE =SIMP(statut='f',typ='R',min=3,max=3), INST_INIT =SIMP(statut='f',typ='R' ), @@ -17181,10 +18431,10 @@ IMPR_OAR =MACRO(nom="IMPR_OAR",op= impr_oar_ops, sd_prod=None, UNITE = SIMP(statut='f',typ='I',defaut=38), AJOUT = SIMP(statut='f', typ='TXM', defaut='NON', into=('OUI', 'NON')), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 11/05/2011 AUTEUR SELLENET N.SELLENET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17321,7 +18571,7 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39, ### b_med=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and(FORMAT == 'MED')""", fr="renommage du champ", - NOM_CHAM_MED =SIMP(statut='f',typ='TXM',validators=(LongStr(1,32),NoRepeat()),max='**'), + NOM_CHAM_MED =SIMP(statut='f',typ='TXM',validators=(LongStr(1,64),NoRepeat()),max='**'), ), ### b_gmsh=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and((FORMAT == 'GMSH'))""", @@ -17366,10 +18616,10 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39, ), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 18/01/2011 AUTEUR BOITEAU O.BOITEAU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -17422,10 +18672,11 @@ IMPR_STURM=PROC(nom="IMPR_STURM",op=32,fr="Calculer et imprimer le nombre de val b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS", TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), @@ -17996,10 +19247,10 @@ LIRE_CHAMP=OPER(nom="LIRE_CHAMP",op= 192,sd_prod=lire_champ_prod, ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 22/03/2011 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -18046,7 +19297,8 @@ LIRE_FONCTION=MACRO(nom="LIRE_FONCTION",op=lire_fonction_ops,sd_prod=lire_foncti b_nappe =BLOC(condition = "TYPE=='NAPPE' ", NOM_PARA_FONC =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ), INDIC_ABSCISSE =SIMP(statut='o',typ='I',min=2,max=2,), - INTERPOL_FONC =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ), + INTERPOL_FONC =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"), + fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction"), PROL_DROITE_FONC=SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), PROL_GAUCHE_FONC=SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), DEFI_FONCTION =FACT(statut='f',max='**', @@ -18054,7 +19306,9 @@ LIRE_FONCTION=MACRO(nom="LIRE_FONCTION",op=lire_fonction_ops,sd_prod=lire_foncti UNITE =SIMP(statut='o',typ='I' ), NOM_PARA =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ), NOM_RESU =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"), - INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ), + INTERPOL =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"), + fr="Type d'interpolation pour les abscisses et les ordonnées de la " \ + "fonction ou bien pour le paramètre de la nappe."), PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ), VERIF =SIMP(statut='f',typ='TXM',defaut="CROISSANT",into=("CROISSANT","NON") ), @@ -18306,10 +19560,10 @@ LIRE_PLEXUS=OPER(nom="LIRE_PLEXUS",op= 184,sd_prod=evol_char, PRECISION =SIMP(statut='o',typ='R',),),), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/03/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -18341,33 +19595,112 @@ def lire_resu_prod(TYPE_RESU,**args): # pour éviter d'écrire 3 fois cette liste : def l_nom_cham_pas_elga(): return ( - "ACCE", "ACCE_ABSOLU", "CRIT_ELNO_RUPT", "DCHA_ELNO_SIGM", - "DCHA_NOEU_SIGM", "DEDE_ELNO_DLDE", "DEDE_NOEU_DLDE", "DEGE_ELNO_DEPL", "DEGE_NOEU_DEPL", - "DEPL", "DEPL_ABSOLU", "DESI_ELNO_DLSI", "DESI_NOEU_DLSI", "DETE_ELNO_DLTE", "DETE_NOEU_DLTE", - "DURT_ELNO_META", "DURT_NOEU_META", "ECIN_ELEM_DEPL", "EFGE_ELNO_CART", "EFGE_ELNO_DEPL", - "EFGE_NOEU_CART", "EFGE_NOEU_DEPL", "ENDO_ELNO_SIGA", "ENDO_ELNO_SINO", "ENDO_NOEU_SINO", - "ENEL_ELNO_ELGA", "ENEL_NOEU_ELGA", "EPEQ_ELNO_TUYO", "EPGR_ELNO", "EPME_ELNO_DEPL", - "EPMG_ELNO_DEPL", "EPMG_NOEU_DEPL", "EPOT_ELEM_DEPL", "EPSA_ELNO", "EPSA_NOEU", - "EPSG_ELNO_DEPL", "EPSG_NOEU_DEPL", "EPSI_ELNO_DEPL", "EPSI_ELNO_TUYO", "EPSI_NOEU_DEPL", - "EPSP_ELNO", "EPSP_NOEU", "EQUI_ELNO_EPME", "EQUI_ELNO_EPSI", - "EQUI_ELNO_SIGM", "EQUI_NOEU_EPME", "EQUI_NOEU_EPSI", "EQUI_NOEU_SIGM", "ERRE_ELEM_NOZ1", - "ERRE_ELEM_NOZ2", "ERRE_ELNO_ELGA", "ERRE_NOEU_ELGA", "ERTH_ELEM_TEMP", "ERTH_ELNO_ELEM", - "ETOT_ELEM", "ETOT_ELNO_ELGA", "FLUX_ELNO_TEMP", "FLUX_NOEU_TEMP", "FORC_NODA", "FSUR_2D", - "FSUR_3D", "FVOL_2D", "FVOL_3D", "GRAD_NOEU_THETA", "HYDR_ELNO_ELGA", "HYDR_NOEU_ELGA", - "INTE_ELNO_ACTI", "INTE_ELNO_REAC", "INTE_NOEU_ACTI", "INTE_NOEU_REAC", "IRRA", - "META_ELNO_TEMP", "META_NOEU_TEMP", "PMPB_ELNO_SIEF", "PMPB_NOEU_SIEF", - "PRES", "PRES_DBEL_DEPL", "PRES_ELNO_DBEL", "PRES_ELNO_IMAG", "PRES_ELNO_REEL", - "PRES_NOEU_DBEL", "PRES_NOEU_IMAG", "PRES_NOEU_REEL", - "RADI_ELNO_SIGM", "RADI_NOEU_SIGM", "REAC_NODA", - "SIEF_ELNO", "SIEF_ELNO_ELGA", "SIEF_NOEU", "SIEF_NOEU_ELGA", "SIEQ_ELNO_TUYO", - "SIGM_ELNO_CART", "SIGM_ELNO_COQU", "SIGM_ELNO_DEPL", "SIGM_ELNO_SIEF", - "SIGM_ELNO_TUYO", "SIGM_NOEU_CART", "SIGM_NOEU_COQU", - "SIGM_NOEU_DEPL", "SIGM_NOEU_SIEF", "SIGM_NOZ1_ELGA", - "SIGM_NOZ2_ELGA", "SIPO_ELNO_DEPL", "SIPO_ELNO_SIEF", "SIPO_NOEU_DEPL", - "SIPO_NOEU_SIEF", "TEMP", "THETA", - "VALE_CONT", "VALE_NCOU_MAXI", "VARI_ELNO", "VARI_ELNO_COQU", - "VARI_ELNO_ELGA", "VARI_ELNO_TUYO", "VARI_NOEU", "VARI_NOEU_ELGA", - "VITE", "VITE_ABSOLU", "VITE_VENT", + "ACCE", + "ACCE_ABSOLU", + "CRIT_ELNO", + "DERA_ELNO", + "DERA_NOEU", + "DEDE_ELNO", + "DEDE_NOEU", + "DEGE_ELNO", + "DEGE_NOEU", + "DEPL", + "DEPL_ABSOLU", + "DESI_ELNO", + "DESI_NOEU", + "DETE_ELNO", + "DETE_NOEU", + "DURT_ELNO", + "DURT_NOEU", + "ECIN_ELEM", + "EFCA_ELNO", + "EFGE_ELNO", + "EFCA_NOEU", + "EFGE_NOEU", + "ENDO_ELNO", + "ENDO_NOEU", + "ENEL_ELNO", + "ENEL_NOEU", + "EPTQ_ELNO", + "EPGR_ELNO", + "EPME_ELNO", + "EPMG_ELNO", + "EPMG_NOEU", + "EPOT_ELEM", + "EPSA_ELNO", + "EPSA_NOEU", + "EPSG_ELNO", + "EPSG_NOEU", + "EPSI_ELNO", + "EPTU_ELNO", + "EPSI_NOEU", + "EPSP_ELNO", + "EPSP_NOEU", + "EPMQ_ELNO", + "EPEQ_ELNO", + "SIEQ_ELNO", + "EPMQ_NOEU", + "EPEQ_NOEU", + "SIEQ_NOEU", + "ERRE_ELEM_NOZ1", + "ERRE_ELEM_NOZ2", + "ERRE_ELNO_ELGA", + "ERRE_NOEU_ELGA", + "ERTH_ELEM_TEMP", + "ERTH_ELNO_ELEM", + "ETOT_ELEM", + "ETOT_ELNO", + "FLUX_ELNO", + "FLUX_NOEU", + "FORC_NODA", + "FSUR_2D", + "FSUR_3D", + "FVOL_2D", + "FVOL_3D", + "GRAD_NOEU_THETA", + "HYDR_ELNO", + "HYDR_NOEU", + "INTE_ELNO", + "INTE_NOEU", + "IRRA", + "META_ELNO", + "META_NOEU", + "PMPB_ELNO", + "PMPB_NOEU", + "PRES", + "PRME_ELNO", + "PRAC_ELNO", + "PRAC_NOEU", + "REAC_NODA", + "SIEF_ELNO", + "SIEF_ELNO", + "SIEF_NOEU", + "SIEF_NOEU", + "SITQ_ELNO", + "SICA_ELNO", + "SICO_ELNO", + "SIGM_ELNO", + "SITU_ELNO", + "SICA_NOEU", + "SICO_NOEU", + "SIGM_NOEU", + "SIZ1_ELGA", + "SIZ2_ELGA", + "SIPO_ELNO", + "SIPO_NOEU", + "TEMP", + "THETA", + "VALE_CONT", + "SPMX_ELGA", + "VARI_ELNO", + "VACO_ELNO", + "VARI_ELNO", + "VATU_ELNO", + "VARI_NOEU", + "VARI_NOEU", + "VITE", + "VITE_ABSOLU", + "VITE_VENT", ) LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n', @@ -18394,7 +19727,7 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n', NB_VARI =SIMP(statut='f',typ='I' ), CHAM_MATER =SIMP(statut='f',typ=cham_mater,), - + CARA_ELEM =SIMP(statut='f',typ=cara_elem,), b_evol_elas = BLOC(condition="TYPE_RESU=='EVOL_ELAS'", @@ -18436,7 +19769,7 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n', ), b_dataset_58_b = BLOC(condition="(FORMAT=='IDEAS_DS58') and ((TYPE_RESU=='DYNA_TRANS') or\ (TYPE_RESU=='DYNA_HARMO') or (TYPE_RESU=='HARM_GENE'))", - NOM_CHAM=SIMP(statut='o',typ='TXM',into=("DEPL","VITE","ACCE","EPSI_NOEU_DEPL","SIEF_NOEU",) ), + NOM_CHAM=SIMP(statut='o',typ='TXM',into=("DEPL","VITE","ACCE","EPSI_NOEU","SIEF_NOEU",),max='**' ), REDEFI_ORIENT=FACT(statut='f',max='**', regles=(PRESENT_PRESENT('CODE_DIR','DIRECTION','NOEUD',),), CODE_DIR =SIMP(statut='f',typ='I',into=(1,2,3,) ), @@ -18466,7 +19799,7 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n', POSI_INST =SIMP(statut='f',typ='I',min=2,max=2), POSI_FREQ =SIMP(statut='f',typ='I',min=2,max=2), NOM_CMP =SIMP(statut='o',typ='TXM',max='**'),), - ), + ), # 1-3 ensight : # ------------- @@ -18494,10 +19827,11 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n', # 2) blocs selon le type du résultat : #--------------------------------- b_mode_meca =BLOC(condition="(TYPE_RESU=='MODE_MECA')or(TYPE_RESU=='MODE_MECA_C')", + # Ces mots cles sont stockes dans l'objet .REFD des mode_meca + # Ces mots cles sont aussi utilises pour imposer la numerotation des cham_no de DEPL_R MATR_A =SIMP(statut='f',typ=matr_asse_depl_r,max=1), MATR_B =SIMP(statut='f',typ=matr_asse_depl_r,max=1), - NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster),max=1, - fr="Utile en dynamique pour pouvoir imposer la numérotation des cham_no."), + NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster),max=1,), ), @@ -18587,30 +19921,31 @@ MAC_MODES=OPER(nom="MAC_MODES",op= 141,sd_prod=table_sdaster, TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR GNICOLAS G.NICOLAS +#& MODIF COMMANDE DATE 11/05/2011 AUTEUR SELLENET N.SELLENET +# -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE GNICOLAS G.NICOLAS from Macro.macr_adap_mail_ops import macr_adap_mail_ops -def macr_adap_mail_prod(self,MAJ_CHAM,ADAPTATION,**args): +def macr_adap_mail_prod(self, MAJ_CHAM, ADAPTATION, **args): # # 0. Typage des structures produites # @@ -18641,14 +19976,14 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # # 2. Version de HOMARD # - VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_8", - into=("V9_8", "V9_N", "V9_N_PERSO"), + VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V10_1", + into=("V10_1", "V10_N", "V10_N_PERSO"), fr="Version de HOMARD", ang="HOMARD release"), # # 3. Langue des messages produits par HOMARD # - LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS", + LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS", into=("FRANCAIS","FRENCH","ANGLAIS","ENGLISH",), fr="Langue des messages produits par HOMARD.", ang="Language for the HOMARD messages." ), @@ -18663,14 +19998,14 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ang="Mesh before adaptation" ), # MAILLAGE_NP1 = SIMP(statut='o',typ=CO, - fr="Maillage apres adaptation", + fr="Maillage après adaptation", ang="Mesh after adaptation" ), # # 4.2. Eventuellement, on peut produire un maillage annexe # Actuellement, c'est le maillage n+1, mais de degré différent. # MAILLAGE_NP1_ANNEXE = SIMP(statut='f',typ=CO, - fr="Maillage annexe apres adaptation", + fr="Maillage annexe après adaptation", ang="Additional mesh after adaptation" ), # # 5. Le pilotage de l'adaptation, avec les variantes suivantes : @@ -18711,7 +20046,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 6.1.2. Sous forme de concept resultat_sdaster # RESULTAT_N = SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther) , - fr="Concept resultat Code_Aster contenant le champ", + fr="Concept résultat Code_Aster contenant le champ", ang="The Code_Aster result with the field" ), # b_champ_adaptation = BLOC(condition="(RESULTAT_N != None)", @@ -18755,7 +20090,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 6.1.5.1. Soit le numero d'ordre # NUME_ORDRE = SIMP(statut='f',typ='I', - fr="Numero d ordre", + fr="Numéro d ordre", ang="Rank" ), # # 6.1.5.2. Soit l'instant @@ -18801,7 +20136,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 6.1.7. Usage du champ : la valeur par maille ou le max du saut entre mailles # b_usage_champ = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ", - fr="Usage du champ : direct ou saut", + fr="Usage du champ : par maille ou saut entre mailles voisines", ang="Use type for the field : direct or jump", # USAGE_CHAMP = SIMP(statut='f',typ='TXM',defaut="MAILLE",into=("MAILLE","SAUT"), @@ -18860,7 +20195,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada fr="Pour une adaptation selon une zone à raffiner", ang="For adaptation among a zone", # - ZONE = FACT(statut='f',max='**', + ZONE = FACT(statut='o',min=1,max='**', fr="Définition de zones à raffiner.", ang="Refined zone definition.", # @@ -18935,10 +20270,10 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ##gn fr="X et Y du centre d'un disque plein ou perce, d'une sphere.", ##gn ang="X and Y of the centre of a disk or of a sphere.", X_CENTRE = SIMP(statut='f',typ='R', - fr="Abscisse du centre du disque ou de la sphere", + fr="Abscisse du centre du disque ou de la sphère", ang="X for the center of the disk or of the sphere"), Y_CENTRE = SIMP(statut='f',typ='R', - fr="Ordonnee du centre du disque ou de la sphere", + fr="Ordonnée du centre du disque ou de la sphère", ang="Y for the center of the disk or of the sphere"), ##gn ) , # @@ -18948,7 +20283,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ##gn fr="Cote du centre de la sphere.", ##gn ang="Z for the center of the sphere.", Z_CENTRE = SIMP(statut='f',typ='R', - fr="Cote du centre de la sphere", + fr="Cote du centre de la sphère", ang="Z for the center of the sphere"), ##gn ) , # @@ -18958,10 +20293,10 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ##gn fr="Le rayon d'un disque perce ou d'un tuyau.", ##gn ang="The radius of a holed disk or of a pipe.", RAYON_INT = SIMP(statut='f',typ='R', - fr="Rayon interieur", + fr="Rayon intérieur", ang="Internal radius"), RAYON_EXT = SIMP(statut='f',typ='R', - fr="Rayon exterieur", + fr="Rayon extérieur", ang="External radius"), ##gn ) , # @@ -18974,7 +20309,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada fr="Abscisse du vecteur directeur de l'axe", ang="X for the axial vector"), Y_AXE = SIMP(statut='f',typ='R', - fr="Ordonnee du vecteur directeur de l'axe", + fr="Ordonnée du vecteur directeur de l'axe", ang="Y for the axial vector"), Z_AXE = SIMP(statut='f',typ='R', fr="Cote du vecteur directeur de l'axe", @@ -18983,7 +20318,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada fr="Abscisse d'un point de la base, sur l'axe", ang="X for the basis, on the axis"), Y_BASE = SIMP(statut='f',typ='R', - fr="Ordonnee d'un point de la base, sur l'axe", + fr="Ordonnée d'un point de la base, sur l'axe", ang="Y for the basis, on the axis"), Z_BASE = SIMP(statut='f',typ='R', fr="Cote d'un point de la base, sur l'axe", @@ -19004,11 +20339,17 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada (ADAPTATION == 'RAFFINEMENT') or \ (ADAPTATION == 'RAFFINEMENT_UNIFORME') or \ (ADAPTATION == 'RAFFINEMENT_ZONE') " , - fr="Niveau maximum de profondeur de raffinement", - ang="Maximum level for the refinement", + fr="Profondeur maximale de raffinement", + ang="Maximum depth for the refinement", +# NIVE_MAX = SIMP(statut='f',typ='I', fr="Niveau maximum de profondeur de raffinement", ang="Maximum level for the refinement"), +# + DIAM_MIN = SIMP(statut='f',typ='R', + fr="Diamètre minimal de maille", + ang="Minimal diameter for the mesh" ), +# ) , # # 9.2. Pour le deraffinement : @@ -19043,46 +20384,46 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ang="List of the groups of nodes for filtering of the adaptation." ), ) , # -# 11. Suivi d'une frontiere +# 11. Suivi d'une frontière # -# 11.1. Definition d'une frontiere par un maillage (valable seulement pour des frontieres 1D) +# 11.1. Definition d'une frontière par un maillage (valable seulement pour des frontières 1D) # MAILLAGE_FRONTIERE = SIMP(statut='f',typ=maillage_sdaster, - fr="Maillage de la frontiere à suivre", - ang="Boundary mesh" ), + fr="Maillage de la frontière discrète à suivre", + ang="Discrete boundary mesh" ), # - b_frontiere = BLOC( condition = " MAILLAGE_FRONTIERE != None " , - fr="Information complémentaire sur la frontière", - ang="Further information about boundary", + b_FRONTIERE = BLOC( condition = " MAILLAGE_FRONTIERE != None " , + fr="Information complémentaire sur la frontière discrète", + ang="Further information about discrete boundary", # GROUP_MA_FRONT = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**', - fr="Liste des groupes de mailles définissant la frontière", - ang="Mesh groups which define the boundary" ), + fr="Liste des groupes de mailles définissant la frontière discrète", + ang="Mesh groups which define the discrete boundary" ), # ) , # -# 11.2. Definition analytique d'une frontiere +# 11.2. Definition analytique d'une frontière # FRONTIERE_ANALYTIQUE = FACT(statut='f',max='**', - fr="Definition analytique de frontieres a suivre.", + fr="Definition analytique de frontières a suivre.", ang="Analytical definition of a boundary.", # -# 11.2.1. Type de la frontiere +# 11.2.1. Nom de la frontière # - TYPE = SIMP(statut='o',typ='TXM',into=("SPHERE", "CYLINDRE"), - fr="Type de la frontiere", - ang="Type of the boundary" ), + NOM = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1, + fr="Nom de la frontière analytique", + ang="Name of the analytic boundary" ), # -# 11.2.2. Groupe lie a la frontiere +# 11.2.2. Type de la frontière # - GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**', - fr="Liste des groupes de mailles definissant la frontiere", - ang="Groups of meshes which define the boundary" ), + TYPE = SIMP(statut='o',typ='TXM',into=("SPHERE", "CYLINDRE"), + fr="Type de la frontière analytique", + ang="Type of the analytic boundary" ), # # 11.2.3. Pour une sphere ou un cylindre : rayon et centre # b_fr_rayon = BLOC( condition = " (TYPE == 'SPHERE') or (TYPE == 'CYLINDRE') " , - fr="Le rayon et le centre d'une sphere ou d'un cylindre.", + fr="Le rayon et le centre d'une sphère ou d'un cylindre.", ang="The radius and the centre of a sphere or of a cylinder.", RAYON = SIMP(statut='o',typ='R', fr="Rayon", @@ -19091,7 +20432,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada fr="Abscisse du centre", ang="X for the center"), Y_CENTRE = SIMP(statut='o',typ='R', - fr="Ordonnee du centre", + fr="Ordonneée du centre", ang="Y for the center"), Z_CENTRE = SIMP(statut='o',typ='R', fr="Cote du centre", @@ -19107,16 +20448,22 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada fr="Abscisse du vecteur directeur de l'axe", ang="X for the axial vector"), Y_AXE = SIMP(statut='o',typ='R', - fr="Ordonnee du vecteur directeur de l'axe", + fr="Ordonnée du vecteur directeur de l'axe", ang="Y for the axial vector"), Z_AXE = SIMP(statut='o',typ='R', fr="Cote du vecteur directeur de l'axe", ang="Z for the axial vector"), ) , +# +# 11.2.5. Groupe(s) lie(s) a la frontière +# + GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**', + fr="Liste des groupes de mailles placées sur la frontière", + ang="Groups of meshes which are located on the boundary" ), # ) , # -# 12. Mise à jour de champs sur le nouveau maillage +# 12. mise à jour de champs sur le nouveau maillage # MAJ_CHAM = FACT(statut='f',max='**', fr="Mise à jour de champs sur le nouveau maillage.", @@ -19147,7 +20494,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 12.3.2. Sous forme de champ dans un resultat # RESULTAT = SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther), - fr="Resultat contenant le champ à mettre à jour", + fr="Résultat contenant le champ à mettre à jour", ang="Result with the field to be updated" ), # b_nom_du_champ = BLOC(condition="(RESULTAT != None)", @@ -19160,11 +20507,11 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # ), # -# 12.4. Est-ce un champ dérivé +# 12.4. Les composantes # - SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom), - fr="Paramètre de sensibilité.", - ang="Sensitivity parameter"), + NOM_CMP = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**', + fr="Liste des composante(s) retenue(s) pour le champ.", + ang="List of the selected component(s) for the field." ), # # 12.5. Le paramètre temporel pour le champ a interpoler # @@ -19177,7 +20524,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 12.5.1. Soit le numero d'ordre # NUME_ORDRE = SIMP(statut='f',typ='I', - fr="Numero d ordre du champ à mettre à jour", + fr="Numéro d ordre du champ à mettre à jour", ang="Rank of the field to be updated" ), # # 12.5.2. Soit l'instant @@ -19208,6 +20555,19 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ), # ), +# +# 12.6. Type d'interpolation +# + TYPE_MAJ = SIMP(statut='f',typ='TXM',defaut="AUTO", + into=("AUTO", "ISOP2"), + fr="Type de mise à jour : automatique ou iso-P2", + ang="Type of the updating" ), +# +# 12.7. Est-ce un champ dérivé +# + SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom), + fr="Paramètre de sensibilité.", + ang="Sensitivity parameter"), ), # # 13. Les Modifications @@ -19221,7 +20581,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 13.1. Changement de degre # DEGRE = SIMP(statut='o',typ='TXM',defaut="NON",into=("OUI","NON"), - fr="Changement de degre du maillage", + fr="Changement de degré du maillage", ang="Modification of the degree of the mesh" ), # # 13.2. Création des joints @@ -19239,7 +20599,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada fr="Nombre de noeuds et de mailles du maillage", ang="Number of nodes and meshes in the mesh" ), # -# 14.2. Determination de la qualité des éléments du maillage +# 14.2. Determination de la qualité des mailles du maillage # QUALITE = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"), fr="Qualité du maillage", @@ -19271,13 +20631,13 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # # 15. Unite logique d'un fichier a ajouter a HOMARD.Configuration # - b_unite = BLOC( condition = " (VERSION_HOMARD == 'V9_N') or \ - (VERSION_HOMARD == 'V9_N_PERSO') " , - fr="Fichier supplementaire.", + b_unite = BLOC( condition = " (VERSION_HOMARD == 'V10_N') or \ + (VERSION_HOMARD == 'V10_N_PERSO') " , + fr="Fichier supplémentaire.", ang="Additional file.", # UNITE = SIMP(statut='f',typ='I', - fr="Unite logique a ajouter a HOMARD.Configuration", + fr="Unite logique du fichier à ajouter à HOMARD.Configuration", ang="Additional file to HOMARD.Configuration" ), # ) , @@ -19291,10 +20651,10 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ang="Incompatible meshes for HOMARD" ), # ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -19323,7 +20683,6 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma fr="Réalise l'analyse thermomécanique du coude dont le maillage a été concu par MACR_ASCOUF_MAIL", reentrant='n', UIinfo={"groupes":("Résolution","Outils-métier",)}, - regles=(UN_PARMI('COMP_INCR','COMP_ELAS'),), TYPE_MAILLAGE =SIMP(statut='o',typ='TXM', into=("SAIN", @@ -19347,7 +20706,7 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma AFFE_MATERIAU =FACT(statut='o',max=3, regles=(UN_PARMI('TOUT','GROUP_MA'),), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA =SIMP(statut='f',typ='TXM',into=("COUDE","BOL") ), + GROUP_MA =SIMP(statut='f',typ=grma,into=("COUDE","BOL") ), MATER =SIMP(statut='o',typ=mater_sdaster ), TEMP_REF =SIMP(statut='f',typ='R',defaut= 0.E+0 ), ), @@ -19375,24 +20734,8 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), ), - COMP_INCR =FACT(statut='f', - RELATION =SIMP(statut='o',typ='TXM',into=("VMIS_ISOT_TRAC",) ), - RESI_INTE_RELA =SIMP(statut='f',typ='R' - ,defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")), - ), - COMP_ELAS =FACT(statut='f', - RELATION =SIMP(statut='o',typ='TXM',into=("ELAS","ELAS_VMIS_TRAC") ), - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")), - ), + COMP_ELAS =C_COMP_ELAS('MACR_ASCOUF_CALC'), SOLVEUR =C_SOLVEUR(), @@ -19596,10 +20939,10 @@ MACR_ASCOUF_MAIL=MACRO(nom="MACR_ASCOUF_MAIL",op=macr_ascouf_mail_ops,sd_prod=ma INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -19629,7 +20972,6 @@ def macr_aspic_calc_prod(self,MODELE,CHAM_MATER,CARA_ELEM,FOND_FISS_1,FOND_FISS_ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_aspic_calc_prod, fr="Réalise un calcul prédéfini de piquages sains ou fissurés ainsi que les post-traitements associés ", UIinfo={"groupes":("Résolution","Outils-métier",)},reentrant='n', - regles=(UN_PARMI('COMP_INCR','COMP_ELAS'),), TYPE_MAILLAGE =SIMP(statut='o',typ='TXM', into=("SAIN_FIN","SAIN_GROS","FISS_COUR_DEB","FISS_COUR_NONDEB","FISS_LONG_DEB", @@ -19649,7 +20991,7 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_ AFFE_MATERIAU =FACT(statut='o',max=3, regles=(UN_PARMI('TOUT','GROUP_MA'),), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",)), - GROUP_MA =SIMP(statut='f',typ='TXM',into=("TUBU","CORP","SOUD","SOUDCORP","SOUDTUBU") ), + GROUP_MA =SIMP(statut='f',typ=grma,into=("TUBU","CORP","SOUD","SOUDCORP","SOUDTUBU") ), MATER =SIMP(statut='o',typ=mater_sdaster), TEMP_REF =SIMP(statut='f',typ='R',defaut= 0.E+0 ), RCCM =SIMP(statut='o',typ='TXM',into=("OUI","NON")), @@ -19696,23 +21038,7 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_ FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), ), - COMP_INCR =FACT(statut='f', - RELATION =SIMP(statut='o',typ='TXM',into=("VMIS_ISOT_TRAC",) ), - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut=1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut=10), - ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut=0), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")), - ), - - COMP_ELAS =FACT(statut='f', - RELATION =SIMP(statut='o',typ='TXM',into=("ELAS","ELAS_VMIS_TRAC") ), - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")), - ), + COMP_ELAS =C_COMP_ELAS('MACR_ASPIC_CALC'), THETA_3D =FACT(statut='f',max='**', R_INF =SIMP(statut='o',typ='R'), @@ -19753,8 +21079,7 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_ b_extrac =BLOC(condition="((FORMAT=='IDEAS')or(FORMAT=='CASTEM'))", fr="extraction d un champ de grandeur", regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST'),), - NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3, - into=("DEPL","EQUI_ELNO_SIGM","TEMP")), + NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,into=("DEPL","SIEQ_ELNO","TEMP")), TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), @@ -19940,10 +21265,10 @@ MACR_CARA_POUTRE=MACRO(nom="MACR_CARA_POUTRE",op=macr_cara_poutre_ops,sd_prod=ta fr="type de conditions aux limites sur le plancher supérieur" ), ), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -19976,7 +21301,7 @@ MACR_ECLA_PG=MACRO(nom="MACR_ECLA_PG",op=macr_ecla_pg_ops,sd_prod=macr_ecla_pg_p # SD résultat ,modèle et champs à "éclater" : RESU_INIT =SIMP(statut='o',typ=resultat_sdaster,fr="RESULTAT à éclater",), MODELE_INIT =SIMP(statut='o',typ=modele_sdaster,fr="MODELE à éclater"), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'), + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),), # paramètres numériques de la commande : SHRINK =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de réduction" ), @@ -20004,10 +21329,10 @@ MACR_ECLA_PG=MACRO(nom="MACR_ECLA_PG",op=macr_ecla_pg_ops,sd_prod=macr_ecla_pg_p b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", PRECISION =SIMP(statut='o',typ='R',),), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 28/02/2011 AUTEUR BOTTONI M.BOTTONI # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -20035,7 +21360,7 @@ def macr_ecre_calc_prod(self,TABLE,DEBIT,**args): MACR_ECRE_CALC=MACRO(nom="MACR_ECRE_CALC",op=macr_ecre_calc_ops,sd_prod=macr_ecre_calc_prod,reentrant='n', UIinfo={"groupes":("Résolution","Outils-métier",)},fr="Procedure de couplage avec Ecrevisse", - regles = (UN_PARMI('LOGICIEL','VERSION'),), + regles = (UN_PARMI('LOGICIEL','VERSION'),), # CONCEPTS SORTANT : 2 TABLES POUR LE POST-TRAITEMENT # ******************************************** @@ -20180,16 +21505,16 @@ MACR_ECRE_CALC=MACRO(nom="MACR_ECRE_CALC",op=macr_ecre_calc_ops,sd_prod=macr_ecr COURBES =SIMP(statut='f',typ='TXM',into=("INTERACTIF","POSTSCRIPT","AUCUNE"),defaut="AUCUNE", fr="Generation eventuelle des courbes" ), LOGICIEL =SIMP(statut='f',typ='TXM',validators=LongStr(1,255),), - VERSION =SIMP(statut='f',typ='TXM',defaut="3.1.2",into = ("3.1.1","3.1.2")), + VERSION =SIMP(statut='f',typ='TXM',into = ("3.1.1","3.1.2","3.2")), ENTETE =SIMP(statut='f',typ='TXM',max='**',defaut="Titre du calcul Ecrevisse" ), IMPRESSION =SIMP(statut='f',typ='TXM',defaut='NON',into=( 'OUI','NON') ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 28/02/2011 AUTEUR BOTTONI M.BOTTONI # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -20221,7 +21546,7 @@ def macr_ecrevisse_prod(self,TABLE,TEMPER,DEBIT,**args): MACR_ECREVISSE=MACRO(nom="MACR_ECREVISSE",op=macr_ecrevisse_ops,sd_prod=macr_ecrevisse_prod,reentrant='f', UIinfo={"groupes":("Résolution","Outils-métier",)},fr="Procedure de couplage avec Ecrevisse", - reuse =SIMP(statut='f',typ='evol_noli'), + reuse = SIMP(statut='f',typ='evol_noli'), regles = (EXCLUS('TEMPER','ETAT_INIT'), UN_PARMI('LOGICIEL','VERSION'),), @@ -20408,7 +21733,7 @@ MACR_ECREVISSE=MACRO(nom="MACR_ECREVISSE",op=macr_ecrevisse_ops,sd_prod=macr_ecr COURBES = SIMP(statut='f',typ='TXM',into=("INTERACTIF","POSTSCRIPT","AUCUNE"),defaut="AUCUNE", fr="Generation eventuelle des courbes" ), LOGICIEL = SIMP(statut='f',typ='TXM',validators=LongStr(1,255),), - VERSION = SIMP(statut='f',typ='TXM',defaut="3.1.2",into = ("3.1.1","3.1.2") ), + VERSION =SIMP(statut='f',typ='TXM',into = ("3.1.1","3.1.2","3.2")), ENTETE = SIMP(statut='f',typ='TXM',max='**',defaut="Titre du calcul Ecrevisse" ), IMPRESSION = SIMP(statut='f',typ='TXM',defaut='NON',into=( 'OUI','NON') ), INFO = SIMP(statut='f',typ='I',defaut="1",into=(1,2) ), @@ -20592,6 +21917,76 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant= # ====================================================================== # RESPONSABLE GNICOLAS G.NICOLAS +from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops + +MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops, + docu="U7.04.41",UIinfo={"groupes":("Impression","Outils-métier",)}, + fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.", + ang="Print values for the fiability software", +# +# 1. Le niveau d'information +# + INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)), +# +# 2. Impression de la valeur de la cible +# +# 2.1. ==> La table contenant la valeur à imprimer +# + TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster, + fr="Table contenant la valeur cible.", + ang="Table which includes the target value."), +# +# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table +# + NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM', + fr="Nom du paramètre associé à la valeur cible.", + ang="Name of the parameter connected to the target value."), +# +# 3. Impressions des valeurs des éventuels gradients +# + GRADIENTS = FACT(statut='f',min=1,max='**', +# +# 3.1. ==> La table contenant la valeur à imprimer +# + TABLE = SIMP(statut='o',typ=table_sdaster, + fr="Table contenant le gradient.", + ang="Table which includes the gradient."), +# +# 3.2. ==> Le paramètre sensible +# + PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom), + fr="Paramètre sensible associé au gradient.", + ang="Sensitivity parameter connected to the gradient."), +# +# 3.3. ==> Le nom du paramètre associé au gradient dans cette table +# + NOM_PARA = SIMP(statut='o',typ='TXM', + fr="Nom du paramètre associé au gradient.", + ang="Name of the parameter connected to the gradient."), +# + ), +# +); +#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS + from Macro.macr_fiabilite_ops import macr_fiabilite_ops # @@ -20951,97 +22346,28 @@ MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops, ), # ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 11/05/2011 AUTEUR SELLENET N.SELLENET +# -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE GNICOLAS G.NICOLAS -from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops - -MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops, - docu="U7.04.41",UIinfo={"groupes":("Impression","Outils-métier",)}, - fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.", - ang="Print values for the fiability software", -# -# 1. Le niveau d'information -# - INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)), -# -# 2. Impression de la valeur de la cible -# -# 2.1. ==> La table contenant la valeur à imprimer -# - TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster, - fr="Table contenant la valeur cible.", - ang="Table which includes the target value."), -# -# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table -# - NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM', - fr="Nom du paramètre associé à la valeur cible.", - ang="Name of the parameter connected to the target value."), -# -# 3. Impressions des valeurs des éventuels gradients -# - GRADIENTS = FACT(statut='f',min=1,max='**', -# -# 3.1. ==> La table contenant la valeur à imprimer -# - TABLE = SIMP(statut='o',typ=table_sdaster, - fr="Table contenant le gradient.", - ang="Table which includes the gradient."), -# -# 3.2. ==> Le paramètre sensible -# - PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom), - fr="Paramètre sensible associé au gradient.", - ang="Sensitivity parameter connected to the gradient."), -# -# 3.3. ==> Le nom du paramètre associé au gradient dans cette table -# - NOM_PARA = SIMP(statut='o',typ='TXM', - fr="Nom du paramètre associé au gradient.", - ang="Name of the parameter connected to the gradient."), -# - ), -# -); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR GNICOLAS G.NICOLAS -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== -# RESPONSABLE GNICOLAS G.NICOLAS - -from Macro.macr_adap_mail_ops import macr_adap_mail_ops +from Macro.macr_adap_mail_ops import macr_adap_mail_ops MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, docu="U7.03.02",UIinfo={"groupes":("Maillage",)}, @@ -21054,14 +22380,14 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, # # 2. Version de HOMARD # - VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_8", - into=("V9_8", "V9_N", "V9_N_PERSO"), + VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V10_1", + into=("V10_1", "V10_N", "V10_N_PERSO"), fr="Version de HOMARD", ang="HOMARD release"), # # 3. Langue des messages issus de HOMARD # - LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS", + LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS", into=("FRANCAIS","FRENCH","ANGLAIS","ENGLISH",), fr="Langue des messages issus de HOMARD.", ang="Language for HOMARD messages." ), @@ -21088,7 +22414,7 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, # ) , # -# 6. Les options ; par defaut, on controle tout +# 6. Les options ; par defaut, on controle tout, sauf l'interpénétration # 6.1. Nombre de noeuds et mailles # NOMBRE = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"), @@ -21113,10 +22439,10 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, fr="Tailles des sous-domaines du maillage.", ang="Sizes of mesh sub-domains." ), # -# 6.5. Controle de la non-interpenetration des elements +# 6.5. Controle de la non-interpénétration des mailles # INTERPENETRATION=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"), - fr="Controle de la non interpénétration des éléments.", + fr="Controle de la non interpénétration des mailles.", ang="Overlapping checking." ), # # 6.6. Propriétés du maillage de calcul @@ -21125,10 +22451,10 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, fr="Propriétés du maillage de calcul.", ang="Properties of the calculation mesh." ), # -# 7. Unite logique d'un fichier a ajouter a HOMARD.Configuration +# 7. Unite logique d'un fichier à ajouter a HOMARD.Configuration # - b_unite = BLOC( condition = " (VERSION_HOMARD == 'V9_N') or \ - (VERSION_HOMARD == 'V9_N_PERSO') " , + b_unite = BLOC( condition = " (VERSION_HOMARD == 'V10_N') or \ + (VERSION_HOMARD == 'V10_N_PERSO') " , fr="Fichier supplementaire.", ang="Additional file.", # @@ -21146,10 +22472,11 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, fr="Acceptation de mailles incompatibles avec HOMARD", ang="Incompatible meshes for HOMARD" ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS + +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21193,13 +22520,19 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table # extraction des résultats b_meca =BLOC(condition = "AsType(RESULTAT) in (evol_elas,evol_noli)",fr="résultat mécanique", - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut='SIGM_NOEU_DEPL' ), + NOM_CHAM =SIMP(statut='f',typ='TXM',defaut='SIGM_NOEU',into=C_NOM_CHAM_INTO(),), ), b_ther =BLOC(condition = "AsType(RESULTAT) in (evol_ther,)",fr="résultat thermique", - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut='TEMP' ), - ), + NOM_CHAM =SIMP(statut='f',typ='TXM',defaut='TEMP',into=("TEMP", + "FLUX_ELGA","FLUX_ELNO","FLUX_NOEU", + "META_ELNO","META_NOEU", + "DURT_ELNO","DURT_NOEU", + "HYDR_ELNO","HYDR_NOEU", + "DETE_ELNO","DETE_NOEU", + "SOUR_ELGA","COMPORTHER", + "ERTH_ELEM","ERTH_ELNO","ERTH_NOEU",),),), b_cham =BLOC(condition = "CHAM_GD!=None", - NOM_CHAM =SIMP(statut='f',typ='TXM',),), + NOM_CHAM =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO(),),), UNITE_MAILLAGE =SIMP(statut='f',typ='I',defaut=25), MODELE =SIMP(statut='f',typ=modele_sdaster ), @@ -21233,7 +22566,7 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table b_local =BLOC(condition = "REPERE=='LOCAL' ", - VECT_Y =SIMP(statut='o',typ='R',min=2,max=3),), + VECT_Y =SIMP(statut='f',typ='R',min=2,max=3),), b_utili =BLOC(condition = "REPERE=='UTILISATEUR'", ANGL_NAUT =SIMP(statut='o',typ='R',min=3,max=3),), @@ -21269,10 +22602,195 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table ) ; +#& MODIF COMMANDE DATE 28/03/2011 AUTEUR ASSIRE A.ASSIRE +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE ASSIRE A.ASSIRE + +from Macro.macr_recal_ops import macr_recal_ops + +def macr_recal_prod(self,**args ): + return listr8_sdaster + +MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops, + UIinfo={"groupes":("Résolution","Résultats et champs",)}, + sd_prod=macr_recal_prod, + fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux" + +" ou sur d'autres résultats de calculs", + + UNITE_ESCL =SIMP(statut='o',typ='I'), + RESU_EXP =SIMP(statut='o',typ=assd,max='**'), + POIDS =SIMP(statut='f',typ=assd,max='**'), + RESU_CALC =SIMP(statut='o',typ=assd,max='**'), + LIST_PARA =SIMP(statut='o',typ=assd,max='**'), + + UNITE_RESU =SIMP(statut='f',typ='I',defaut=91), + PARA_DIFF_FINI =SIMP(statut='f',typ='R',defaut=0.001), + + GRAPHIQUE =FACT(statut='f', + FORMAT =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT"),), + AFFICHAGE =SIMP(statut='f',typ='TXM',defaut='TOUTE_ITERATION',into=("TOUTE_ITERATION","ITERATION_FINALE"),), + b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", fr="Mots-clés propres à XMGRACE", + PILOTE =SIMP(statut='f',typ='TXM',defaut='', + into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'), + fr="Pilote de sortie, PNG/JPEG/PDF ne sont pas disponibles sur toutes les installations de xmgrace"), + UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29, + fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"), + ), + ), + + + # Methodes d'optimisation + # ----------------------- + METHODE =SIMP(statut='f',typ='TXM',defaut='LEVENBERG',into=("LEVENBERG", "FMIN", "FMINBFGS", "FMINNCG", + "GENETIQUE","HYBRIDE")), + + b_genetique_options=BLOC(condition = "METHODE == 'GENETIQUE' or METHODE == 'HYBRIDE'" , + NB_PARENTS =SIMP(statut='f',typ='I',defaut=10), + NB_FILS =SIMP(statut='f',typ='I',defaut=5), + ECART_TYPE =SIMP(statut='f',typ='R',defaut=1.), + GRAINE =SIMP(statut='f',typ='I'), + ITER_ALGO_GENE =SIMP(statut='f',typ='I',defaut=10), + RESI_ALGO_GENE =SIMP(statut='f',typ='R',defaut=1.E-3), + ), + + + # Criteres d'arret globaux + # ------------------------- + ITER_MAXI =SIMP(statut='f',typ='I',defaut=10, fr="Nombre maximum d'iterations d'optimisation"), + ITER_FONC_MAXI =SIMP(statut='f',typ='I',defaut=1000, fr="Nombre maximum d'evaluations de la focntionnelle"), + RESI_GLOB_RELA =SIMP(statut='f',typ='R',defaut=1.E-3, fr="Critere d'arret sur la valeur du residu"), + TOLE_PARA =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur des parametres"), + TOLE_FONC =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur de la fonctionnelle"), + + + # Calculs des gradients + # --------------------- + b_gradient =BLOC(condition = "METHODE == 'FMINBFGS' or METHODE == 'FMINNCG'" , + GRADIENT =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )), + ), + + b_gradient_levenberg =BLOC(condition = "METHODE == 'LEVENBERG'" , + GRADIENT =SIMP(statut='f',typ='TXM',defaut='NORMAL', into=( "NORMAL", "ADIMENSIONNE" )), + ), + + + # Mode d'evaluation de l'esclave + # ------------------------------ + CALCUL_ESCLAVE =FACT(statut='d', + LANCEMENT =SIMP(statut='f', typ='TXM', defaut='INCLUSION',into=("DISTRIBUTION","INCLUSION"),), + + b_eval_distrib =BLOC(condition = "LANCEMENT == 'DISTRIBUTION'", + UNITE_SUIVI =SIMP(statut='f', typ='I',val_min=10,val_max=99,defaut=29, + fr="Affichage de l'output et/ou error des jobs esclaves dans ce fichier"), + MODE =SIMP(statut='f', typ='TXM', into=("INTERACTIF","BATCH"),), + MEMOIRE =SIMP(statut='f', typ='I', fr="Memoire demandee pour les calculs esclaves (Mo)"), + TEMPS =SIMP(statut='f', typ='I', fr="Temps demandee pour les calculs esclaves (secondes)"), + CLASSE =SIMP(statut='f', typ='TXM', fr="Classe demandee pour les calculs en batch"), + NMAX_SIMULT =SIMP(statut='f', typ='I', + fr="Nombre de calculs esclaves lances en paralle en mode distribution (non precise = automatique)"), + ), + ), + + DYNAMIQUE =FACT(statut='f', + MODE_EXP =SIMP(statut='o',typ='TXM'), + MODE_CALC =SIMP(statut='o',typ='TXM'), + APPARIEMENT_MANUEL =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")), + ), + + INFO =SIMP(statut='f',typ='I',defaut=1, into=( 1, 2 ) ), +); #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE VOLDOIRE F.VOLDOIRE + +from Macro.macr_spectre_ops import macr_spectre_ops + +MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster, + reentrant='n', + UIinfo={"groupes":("Post-traitements","Outils-métier",)}, + fr="Calcul de spectre, post-traitement de séisme", + MAILLAGE =SIMP(statut='o',typ=maillage_sdaster,), + PLANCHER =FACT(statut='o',max='**', + regles=(AU_MOINS_UN('NOEUD','GROUP_NO' ),), + NOM =SIMP(statut='o',typ='TXM',), + GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), ), + NOM_CHAM =SIMP(statut='o',typ='TXM' ,into=('ACCE','DEPL')), + CALCUL =SIMP(statut='o',typ='TXM' ,into=('ABSOLU','RELATIF'),position='global'), + b_acce =BLOC( condition = "NOM_CHAM=='ACCE'", + regles=(UN_PARMI('LIST_FREQ','FREQ'),), + AMOR_SPEC =SIMP(statut='o',typ='R',max='**'), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster ), + LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster ), + FREQ =SIMP(statut='f',typ='R',max='**'), + NORME =SIMP(statut='o',typ='R'), + RESU =FACT(statut='o',max='**', + regles=(UN_PARMI('RESU_GENE','RESULTAT'),), + RESU_GENE =SIMP(statut='f',typ=tran_gene), + RESULTAT =SIMP(statut='f',typ=(dyna_trans,evol_noli)), + b_calc =BLOC( condition = "CALCUL=='RELATIF'", + ACCE_X =SIMP(statut='o',typ=fonction_sdaster), + ACCE_Y =SIMP(statut='o',typ=fonction_sdaster), + ACCE_Z =SIMP(statut='o',typ=fonction_sdaster),), ), + IMPRESSION =FACT(statut='f', + TRI =SIMP(statut='f',typ='TXM',defaut='AMOR_SPEC',into=("AMOR_SPEC","DIRECTION",),), + FORMAT =SIMP(statut='f',typ='TXM',defaut='TABLEAU',into=("TABLEAU","XMGRACE",),), + UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29, + fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"), + b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", + PILOTE =SIMP(statut='f',typ='TXM',defaut='', + into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),),), + TOUT =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON",),), + ), + ), + b_depl =BLOC( condition = "NOM_CHAM=='DEPL'", + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + RESU =FACT(statut='o',max=3, + regles=(UN_PARMI('RESU_GENE','RESULTAT'),), + RESU_GENE =SIMP(statut='f',typ=tran_gene), + RESULTAT =SIMP(statut='f',typ=(dyna_trans,evol_noli)), + b_calc =BLOC( condition = "CALCUL=='ABSOLU'", + DEPL_X =SIMP(statut='o',typ=fonction_sdaster), + DEPL_Y =SIMP(statut='o',typ=fonction_sdaster), + DEPL_Z =SIMP(statut='o',typ=fonction_sdaster),),), + ), +) +#& MODIF COMMANDE DATE 02/02/2011 AUTEUR PELLET J.PELLET +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21318,17 +22836,17 @@ MACRO_ELAS_MULT=MACRO(nom="MACRO_ELAS_MULT",op=macro_elas_mult_ops,sd_prod=macro TYPE_MODE =SIMP(statut='f',typ='TXM',defaut="SYME",into=("SYME","ANTI","TOUS") ), CHAR_MECA =SIMP(statut='f',typ=(char_meca),validators=NoRepeat(),max='**'), OPTION =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', - into=("EFGE_ELNO_DEPL","EPOT_ELEM_DEPL","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL", - "SIGM_ELNO_CART","EFGE_ELNO_CART","DEGE_ELNO_DEPL","EPSI_ELNO_DEPL", - "EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL","EPSP_ELNO","EPSP_ELGA", - "ECIN_ELEM_DEPL","FLUX_ELGA_TEMP","FLUX_ELNO_TEMP","SOUR_ELGA_ELEC", - "PRES_ELNO_DBEL","PRES_ELNO_REEL","PRES_ELNO_IMAG","INTE_ELNO_ACTI", - "INTE_ELNO_REAC","SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA", - "ERZ2_ELEM_SIGM","VNOR_ELEM_DEPL","ERRE_ELNO_ELEM", - "ERRE_ELEM_SIGM","EQUI_ELNO_SIGM","EQUI_ELGA_SIGM","EQUI_ELNO_EPSI", - "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM", - "EQUI_ELGA_EPSI","FORC_NODA","REAC_NODA","EPSI_NOEU_DEPL","SIGM_NOEU_DEPL", - "EFGE_NOEU_DEPL","EQUI_NOEU_SIGM","EQUI_NOEU_EPSI","FLUX_NOEU_TEMP") ), + into=("EFGE_ELNO","EPOT_ELEM","SIGM_ELNO","SIEF_ELGA", + "SICA_ELNO","EFCA_ELNO","DEGE_ELNO","EPSI_ELNO", + "EPSI_ELGA","EPSG_ELNO","EPSG_ELGA","EPSP_ELNO","EPSP_ELGA", + "ECIN_ELEM","FLUX_ELGA","FLUX_ELNO","SOUR_ELGA", + "PRAC_ELNO","INTE_ELNO", + "SIZ1_ELGA","ERZ1_ELEM","SIZ2_ELGA", + "ERZ2_ELEM","VNOR_ELEM_DEPL","ERME_ELNO", + "ERME_ELEM","SIEQ_ELNO","SIEQ_ELGA","EPEQ_ELNO", + "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM", + "EPEQ_ELGA","FORC_NODA","REAC_NODA","EPSI_NOEU","SIGM_NOEU", + "EFGE_NOEU","SIEQ_NOEU","EPEQ_NOEU","FLUX_NOEU") ), NUME_COUCHE =SIMP(statut='f',typ='I',defaut=1), NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY")), SOUS_TITRE =SIMP(statut='f',typ='TXM',max='**'), @@ -21352,10 +22870,10 @@ MACRO_ELAS_MULT=MACRO(nom="MACRO_ELAS_MULT",op=macro_elas_mult_ops,sd_prod=macro INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2)), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 13/01/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21404,7 +22922,7 @@ MACRO_EXPANS=MACRO(nom="MACRO_EXPANS", MODELE = SIMP(statut='o',typ=(modele_sdaster) ), MESURE = SIMP(statut='o',typ=(dyna_trans,dyna_harmo,mode_meca,mode_meca_c,) ), NOM_CHAM = SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","VITE","ACCE","SIEF_NOEU","EPSI_NOEU_DEPL",) ), + into=("DEPL","VITE","ACCE","SIEF_NOEU","EPSI_NOEU",) ), NUME_MODE = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0), NUME_ORDRE = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0), @@ -21427,10 +22945,10 @@ MACRO_EXPANS=MACRO(nom="MACRO_EXPANS", ), ), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21529,7 +23047,7 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -21554,7 +23072,7 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -21569,10 +23087,10 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro NOEUD_DOUBLE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), AVEC_MODE_STAT =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 18/01/2011 AUTEUR BOITEAU O.BOITEAU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -21636,8 +23154,9 @@ MACRO_MATR_ASSE=MACRO(nom="MACRO_MATR_ASSE",op=macro_matr_asse_ops, RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ), ), b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS", - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_gcpc =BLOC(condition="METHODE=='GCPC'",fr="Paramètres associés à la méthode gradient conjugué", RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ), @@ -21878,209 +23397,26 @@ MACRO_PROJ_BASE=MACRO(nom="MACRO_PROJ_BASE",op=macro_proj_base_ops, fr="Projection des matrices et/ou vecteurs assemblés sur une base (modale ou de RITZ)", BASE =SIMP(statut='o',typ=(mode_meca,mode_gene) ), NB_VECT =SIMP(statut='f',typ='I',defaut= 9999), - PROFIL =SIMP(statut='f',typ='TXM',defaut="DIAG",into=("PLEIN","DIAG") ), - MATR_ASSE_GENE =FACT(statut='f',max='**', - MATRICE =SIMP(statut='o',typ=CO,), - regles=(UN_PARMI('MATR_ASSE','MATR_ASSE_GENE',),), - MATR_ASSE =SIMP(statut='f',typ=matr_asse_depl_r), - MATR_ASSE_GENE =SIMP(statut='f',typ=matr_asse_gene_r), - ), - VECT_ASSE_GENE =FACT(statut='f',max='**', - VECTEUR =SIMP(statut='o',typ=CO,), - regles=(UN_PARMI('VECT_ASSE','VECT_ASSE_GENE',),), - TYPE_VECT =SIMP(statut='f',typ='TXM',defaut="FORC"), - VECT_ASSE =SIMP(statut='f',typ=cham_no_sdaster), - VECT_ASSE_GENE =SIMP(statut='f',typ=vect_asse_gene), - ), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), -) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== -# RESPONSABLE ASSIRE A.ASSIRE - -from Macro.macr_recal_ops import macr_recal_ops - -def macr_recal_prod(self,**args ): - return listr8_sdaster - -MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops, - UIinfo={"groupes":("Résolution","Résultats et champs",)}, - sd_prod=macr_recal_prod, - fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux" - +" ou sur d'autres résultats de calculs", - - UNITE_ESCL =SIMP(statut='o',typ='I'), - RESU_EXP =SIMP(statut='o',typ=assd,max='**'), - POIDS =SIMP(statut='f',typ=assd,max='**'), - RESU_CALC =SIMP(statut='o',typ=assd,max='**'), - LIST_PARA =SIMP(statut='o',typ=assd,max='**'), - - UNITE_RESU =SIMP(statut='f',typ='I',defaut=91), - PARA_DIFF_FINI =SIMP(statut='f',typ='R',defaut=0.001), - - GRAPHIQUE =FACT(statut='f', - FORMAT =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT"),), - AFFICHAGE =SIMP(statut='f',typ='TXM',defaut='TOUTE_ITERATION',into=("TOUTE_ITERATION","ITERATION_FINALE"),), - b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", fr="Mots-clés propres à XMGRACE", - PILOTE =SIMP(statut='f',typ='TXM',defaut='', - into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'), - fr="Pilote de sortie, PNG/JPEG/PDF ne sont pas disponibles sur toutes les installations de xmgrace"), - UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29, - fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"), - ), - ), - - - # Methodes d'optimisation - # ----------------------- - METHODE =SIMP(statut='f',typ='TXM',defaut='LEVENBERG',into=("LEVENBERG", "FMIN", "FMINBFGS", "FMINNCG", - "GENETIQUE","HYBRIDE")), - - b_genetique_options=BLOC(condition = "METHODE == 'GENETIQUE' or METHODE == 'HYBRIDE'" , - NB_PARENTS =SIMP(statut='f',typ='I',defaut=10), - NB_FILS =SIMP(statut='f',typ='I',defaut=5), - ECART_TYPE =SIMP(statut='f',typ='R',defaut=1.), - GRAINE =SIMP(statut='f',typ='I'), - ITER_ALGO_GENE =SIMP(statut='f',typ='I',defaut=10), - RESI_ALGO_GENE =SIMP(statut='f',typ='R',defaut=1.E-3), - ), - - - # Criteres d'arret globaux - # ------------------------- - ITER_MAXI =SIMP(statut='f',typ='I',defaut=10, fr="Nombre maximum d'iterations d'optimisation"), - ITER_FONC_MAXI =SIMP(statut='f',typ='I',defaut=1000, fr="Nombre maximum d'evaluations de la focntionnelle"), - RESI_GLOB_RELA =SIMP(statut='f',typ='R',defaut=1.E-3, fr="Critere d'arret sur la valeur du residu"), - TOLE_PARA =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur des parametres"), - TOLE_FONC =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur de la fonctionnelle"), - - - # Calculs des gradients - # --------------------- - b_gradient =BLOC(condition = "METHODE == 'FMINBFGS' or METHODE == 'FMINNCG'" , - GRADIENT =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )), - ), - - b_gradient_levenberg =BLOC(condition = "METHODE == 'LEVENBERG'" , - GRADIENT =SIMP(statut='f',typ='TXM',defaut='NORMAL', into=( "NORMAL", "ADIMENSIONNE" )), - ), - - - # Mode d'evaluation de l'esclave - # ------------------------------ - CALCUL_ESCLAVE =FACT(statut='d', - LANCEMENT =SIMP(statut='f', typ='TXM', defaut='INCLUSION',into=("DISTRIBUTION","INCLUSION"),), - - b_eval_distrib =BLOC(condition = "LANCEMENT == 'DISTRIBUTION'", - MODE =SIMP(statut='f', typ='TXM', into=("INTERACTIF","BATCH"),), - MEMOIRE =SIMP(statut='f', typ='I', fr="Memoire demandee pour les calculs esclaves (Mo)"), - TEMPS =SIMP(statut='f', typ='I', fr="Temps demandee pour les calculs esclaves (secondes)"), - CLASSE =SIMP(statut='f', typ='TXM', fr="Classe demandee pour les calculs en batch"), - NMAX_SIMULT =SIMP(statut='f', typ='I', - fr="Nombre de calculs esclaves lances en paralle en mode distribution (non precise = automatique)"), - ), - ), - - DYNAMIQUE =FACT(statut='f', - MODE_EXP =SIMP(statut='o',typ='TXM'), - MODE_CALC =SIMP(statut='o',typ='TXM'), - APPARIEMENT_MANUEL =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")), - ), - - INFO =SIMP(statut='f',typ='I',defaut=2,into=( 1, 2 ) ), -); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== -# RESPONSABLE VOLDOIRE F.VOLDOIRE - -from Macro.macr_spectre_ops import macr_spectre_ops - -MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster, - reentrant='n', - UIinfo={"groupes":("Post-traitements","Outils-métier",)}, - fr="Calcul de spectre, post-traitement de séisme", - MAILLAGE =SIMP(statut='o',typ=maillage_sdaster,), - PLANCHER =FACT(statut='o',max='**', - regles=(AU_MOINS_UN('NOEUD','GROUP_NO' ),), - NOM =SIMP(statut='o',typ='TXM',), - GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), ), - NOM_CHAM =SIMP(statut='o',typ='TXM' ,into=('ACCE','DEPL')), - CALCUL =SIMP(statut='o',typ='TXM' ,into=('ABSOLU','RELATIF'),position='global'), - b_acce =BLOC( condition = "NOM_CHAM=='ACCE'", - regles=(UN_PARMI('LIST_FREQ','FREQ'),), - AMOR_SPEC =SIMP(statut='o',typ='R',max='**'), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster ), - LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster ), - FREQ =SIMP(statut='f',typ='R',max='**'), - NORME =SIMP(statut='o',typ='R'), - RESU =FACT(statut='o',max='**', - regles=(UN_PARMI('RESU_GENE','RESULTAT'),), - RESU_GENE =SIMP(statut='f',typ=tran_gene), - RESULTAT =SIMP(statut='f',typ=(dyna_trans,evol_noli)), - b_calc =BLOC( condition = "CALCUL=='RELATIF'", - ACCE_X =SIMP(statut='o',typ=fonction_sdaster), - ACCE_Y =SIMP(statut='o',typ=fonction_sdaster), - ACCE_Z =SIMP(statut='o',typ=fonction_sdaster),), ), - IMPRESSION =FACT(statut='f', - TRI =SIMP(statut='f',typ='TXM',defaut='AMOR_SPEC',into=("AMOR_SPEC","DIRECTION",),), - FORMAT =SIMP(statut='f',typ='TXM',defaut='TABLEAU',into=("TABLEAU","XMGRACE",),), - UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29, - fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"), - b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", - PILOTE =SIMP(statut='f',typ='TXM',defaut='', - into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),),), - TOUT =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON",),), - ), - ), - b_depl =BLOC( condition = "NOM_CHAM=='DEPL'", - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - RESU =FACT(statut='o',max=3, - regles=(UN_PARMI('RESU_GENE','RESULTAT'),), - RESU_GENE =SIMP(statut='f',typ=tran_gene), - RESULTAT =SIMP(statut='f',typ=(dyna_trans,evol_noli)), - b_calc =BLOC( condition = "CALCUL=='ABSOLU'", - DEPL_X =SIMP(statut='o',typ=fonction_sdaster), - DEPL_Y =SIMP(statut='o',typ=fonction_sdaster), - DEPL_Z =SIMP(statut='o',typ=fonction_sdaster),),), + PROFIL =SIMP(statut='f',typ='TXM',defaut="DIAG",into=("PLEIN","DIAG") ), + MATR_ASSE_GENE =FACT(statut='f',max='**', + MATRICE =SIMP(statut='o',typ=CO,), + regles=(UN_PARMI('MATR_ASSE','MATR_ASSE_GENE',),), + MATR_ASSE =SIMP(statut='f',typ=matr_asse_depl_r), + MATR_ASSE_GENE =SIMP(statut='f',typ=matr_asse_gene_r), ), -) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS + VECT_ASSE_GENE =FACT(statut='f',max='**', + VECTEUR =SIMP(statut='o',typ=CO,), + regles=(UN_PARMI('VECT_ASSE','VECT_ASSE_GENE',),), + TYPE_VECT =SIMP(statut='f',typ='TXM',defaut="FORC"), + VECT_ASSE =SIMP(statut='f',typ=cham_no_sdaster), + VECT_ASSE_GENE =SIMP(statut='f',typ=vect_asse_gene), + ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), +) ; +#& MODIF COMMANDE DATE 01/03/2011 AUTEUR LEFEBVRE J-P.LEFEBVRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -22096,17 +23432,21 @@ MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE LEFEBVRE J.P.LEFEBVRE +# MAJ_CATA=PROC(nom="MAJ_CATA",op=20, - UIinfo={"groupes":("Gestion du travail",)}, - fr="Compilation des catalogues de commandes et d'éléments", + UIinfo={"groupes":("Gestion du travail",)}, + fr="Compilation des catalogues d'éléments et couverture des calculs élémentaires", + regles=(UN_PARMI('ELEMENT','TYPE_ELEM', ),), - ELEMENT =FACT(statut='f',), + ELEMENT =FACT(statut='f',), -) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS + UNITE =SIMP(statut='f',typ='I',defaut=8), + TYPE_ELEM =FACT(statut='f',), +); +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -22144,7 +23484,7 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas, INST =SIMP(statut='f',typ='R',defaut= 0.E+0 ), LIST_INST =SIMP(statut='f',typ=listr8_sdaster), INST_FIN =SIMP(statut='f',typ='R'), - OPTION =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA_DEPL","SANS"),defaut="SIEF_ELGA_DEPL",max=1, + OPTION =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA","SANS"),defaut="SIEF_ELGA",max=1, fr="seule option : contraintes aux points de Gauss. Utiliser CALC_ELEM pour les autres.", ), SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', @@ -22194,7 +23534,7 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -22204,12 +23544,13 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=1.0E-6,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), MATR_DISTRIBUEE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", @@ -22221,7 +23562,7 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -22291,10 +23632,10 @@ MODE_ITER_CYCL=OPER(nom="MODE_ITER_CYCL",op= 80,sd_prod=mode_cycl, ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 18/01/2011 AUTEUR BOITEAU O.BOITEAU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -22362,11 +23703,12 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op= 44,sd_prod=mode_iter_inv_prod TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), @@ -22403,11 +23745,12 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op= 44,sd_prod=mode_iter_inv_prod TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), @@ -22434,10 +23777,10 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op= 44,sd_prod=mode_iter_inv_prod INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), TITRE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 18/01/2011 AUTEUR BOITEAU O.BOITEAU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -22546,11 +23889,12 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op= 45,sd_prod=mode_iter_simult_pr TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), ), @@ -22599,11 +23943,12 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op= 45,sd_prod=mode_iter_simult_pr TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), ), @@ -22629,10 +23974,10 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op= 45,sd_prod=mode_iter_simult_pr INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -22654,7 +23999,6 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca, reentrant='n', UIinfo={"groupes":("Résolution","Dynamique",)}, - regles=(UN_PARMI('MODE_STAT','FORCE_NODALE','PSEUDO_MODE','MODE_INTERF'), PRESENT_PRESENT('MODE_INTERF','MATR_MASS'), PRESENT_PRESENT('PSEUDO_MODE','MATR_MASS'), @@ -22736,11 +24080,12 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", @@ -22752,7 +24097,7 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -22770,7 +24115,7 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -22816,6 +24161,45 @@ MODI_BASE_MODALE=OPER(nom="MODI_BASE_MODALE",op= 149,sd_prod=mode_meca, INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; +#& MODIF COMMANDE DATE 14/02/2011 AUTEUR GREFFET N.GREFFET +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GREFFET N.GREFFET +# +# RECUPERATION DES EFFORTS VIA YACS POUR COUPLAGE IFS +# +MODI_CHAR_YACS=OPER(nom = "MODI_CHAR_YACS", + op = 112, + sd_prod = char_meca, + reentrant = 'o', + UIinfo = {"groupes":("Résultats et champs",)}, + fr = "Reception des forces nodales via YACS lors du couplage de Code_Aster et Saturne", + CHAR_MECA = SIMP(statut ='o', typ = char_meca), + MATR_PROJECTION = SIMP(statut ='o', typ = corresp_2_mailla,), + NOM_CMP_IFS = SIMP(statut ='o', typ = 'TXM',validators = NoRepeat(), max = '**'), + VIS_A_VIS = FACT(statut ='o', max = '**', + GROUP_MA_1 = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), + GROUP_NO_2 = SIMP(statut='o',typ=grno,validators=NoRepeat(),max='**'),), + INST = SIMP(statut='o',typ='R', ), + PAS = SIMP(statut='o',typ='R', ), + NUME_ORDRE_YACS = SIMP(statut='o', typ='I',), + INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), +); #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -23222,10 +24606,10 @@ NORM_MODE=OPER(nom="NORM_MODE",op= 37,sd_prod=norm_mode_prod, TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 18/01/2011 AUTEUR BOITEAU O.BOITEAU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -23259,7 +24643,7 @@ NUME_DDL=OPER(nom="NUME_DDL",op=11,sd_prod=nume_ddl_sdaster,reentrant='n', RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ), ), b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS", - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ), b_gcpc =BLOC(condition="METHODE=='GCPC' or METHODE=='PETSC'",fr="paramètres associés à la GCPC ou PETSc", RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ), @@ -23301,10 +24685,10 @@ NUME_DDL_GENE=OPER(nom="NUME_DDL_GENE",op= 127,sd_prod=nume_ddl_gene, NB_VECT =SIMP(statut='f',typ='I',defaut= 9999 ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -23344,7 +24728,7 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops, MODELE_1 =SIMP(statut='o',typ=modele_sdaster), MODELE_2 =SIMP(statut='o',typ=modele_sdaster), RESULTAT =SIMP(statut='o',typ=(mode_meca,evol_elas,dyna_harmo,dyna_trans,) ), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1), + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(),), # ------------------------------------------------------------------ @@ -23375,7 +24759,8 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops, # fr="Si le résultat est un mode_xxx ou une base_xxx, on peut prolonger" # +" les champs par zéro la ou la projection ne donne pas de valeurs."), - NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster) ), + MATR_A =SIMP(statut='f',typ=(matr_asse_depl_r) ), + MATR_B =SIMP(statut='f',typ=(matr_asse_depl_r) ), VIS_A_VIS =FACT(statut='f',max='**', regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'), AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),), @@ -23459,6 +24844,8 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops, MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO(),), + # DDL_ACTIF =SIMP(statut='f',typ='TXM',max=6), # TODO : mettre en place le systeme de masques @@ -23469,10 +24856,10 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops, TITRE =SIMP(statut='f',typ='TXM',max='**' ), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 23/02/2011 AUTEUR BARGELLI R.BARGELLINI # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -23504,6 +24891,8 @@ POST_BORDET =MACRO(nom="POST_BORDET", op=post_bordet_ops,sd_prod=table_sdaster, GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**', fr="le calcul ne sera effectué que sur ces mailles"), INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + PRECISION =SIMP(statut='f',typ='R',validators=NoRepeat(),val_min=0.,val_max=1E-3,defaut=1E-6), + CRITERE =SIMP(statut='f',typ='TXM',defaut="ABSOLU",into=("RELATIF","ABSOLU") ), NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), PROBA_NUCL =SIMP(statut='f',typ='TXM',into=("NON","OUI"), defaut="NON", fr="prise en compte du facteur exponentiel"), @@ -23530,8 +24919,6 @@ POST_BORDET =MACRO(nom="POST_BORDET", op=post_bordet_ops,sd_prod=table_sdaster, RESULTAT =SIMP(statut='o',typ=resultat_sdaster, fr="Resultat d'une commande globale STAT_NON_LINE"), - MODELE =SIMP(statut='o',typ=modele_sdaster), - CHAM_MATER =SIMP(statut='o',typ=cham_mater), TEMP =SIMP(statut='o',typ=(fonction_sdaster,'R')), COEF_MULT =SIMP(statut='f',typ='R', defaut=1.), ) @@ -23739,10 +25126,10 @@ POST_DYNA_MODA_T=OPER(nom="POST_DYNA_MODA_T",op= 130,sd_prod=table_sdaster, INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 22/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -23764,7 +25151,7 @@ POST_ELEM=OPER(nom="POST_ELEM",op=107,sd_prod=table_sdaster,reentrant='n', regles=(UN_PARMI('MASS_INER', 'ENER_POT', 'ENER_CIN','TRAV_EXT','MINMAX', 'WEIBULL', 'RICE_TRACEY', 'CARA_GEOM','CHAR_LIMITE', - 'CARA_POUTRE', 'INDIC_ENER', 'INDIC_SEUIL', + 'CARA_POUTRE', 'INDIC_ENER', 'INDIC_SEUIL','VOLUMOGRAMME', 'AIRE_INTERNE','ENER_ELAS','ENER_TOTALE','ENER_DISS','INTEGRALE'), ), @@ -23995,6 +25382,36 @@ POST_ELEM=OPER(nom="POST_ELEM",op=107,sd_prod=table_sdaster,reentrant='n', regles=(UN_PARMI('CHAM_GD','RESULTAT'), EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_ORDRE','LIST_INST'),), MODELE = SIMP(statut='f',typ=modele_sdaster), + CHAM_MATER = SIMP(statut='f',typ=cham_mater), + RESULTAT = SIMP(statut='f',typ=(evol_noli,evol_ther,evol_elas,evol_char) ), + CHAM_GD = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), + TOUT_ORDRE = SIMP(statut='f',typ='TXM',into=("OUI",) ), + NUME_ORDRE = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), + LIST_ORDRE = SIMP(statut='f',typ=listis_sdaster), + INST = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + LIST_INST = SIMP(statut='f',typ=listr8_sdaster), + ), + + VOLUMOGRAMME = FACT(statut='f',max='**', + regles=(AU_MOINS_UN('TOUT','GROUP_MA'),), + TOUT = SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA = SIMP(statut='f',typ=grma,max=1), + TYPE_MAILLE = SIMP(statut='f',typ='TXM',into=('2D','3D',)), + NOM_CHAM = SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()), + NOM_CMP = SIMP(statut='o',typ='TXM'), + NB_INTERV = SIMP(statut='f',typ='I',defaut=5), + ), + b_volumogramme = BLOC(condition = "( VOLUMOGRAMME != None )", + fr="calcul de la distribution du volume d'une structure vis-à-vis d'une composante", + regles=(UN_PARMI('CHAM_GD','RESULTAT'), + EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_ORDRE','LIST_INST'),), + MODELE = SIMP(statut='f',typ=modele_sdaster), + CHAM_MATER = SIMP(statut='f',typ=cham_mater), RESULTAT = SIMP(statut='f',typ=(evol_noli,evol_ther,evol_elas,evol_char) ), CHAM_GD = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ), CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),), @@ -24452,10 +25869,10 @@ POST_FATIGUE=OPER(nom="POST_FATIGUE",op=136,sd_prod=table_sdaster,reentrant='n', INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -24491,8 +25908,7 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod, reentrant='n', UIinfo={"groupes":("Post-traitements","Rupture",)}, regles=(UN_PARMI('IDENTIFICATION', 'PREDICTION'), - UN_PARMI('THETA_2D','THETA_3D'), - PRESENT_PRESENT('THETA_2D','DIRECTION'),), + UN_PARMI('THETA_2D','THETA_3D'),), # Résultat, modèle, comportement, chargement RESULTAT = SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,mode_meca),), @@ -24500,12 +25916,10 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod, MODELE = SIMP(statut='o',typ=modele_sdaster), MATER = SIMP(statut='o',typ=mater_sdaster), - COMP_ELAS = FACT(statut='o', - RELATION = SIMP(statut='f',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC"),), - DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ), - ), + COMP_ELAS = C_COMP_ELAS('POST_GP'), + LIST_INST = SIMP(statut='o',typ=listr8_sdaster), + TYPE_DEF = SIMP(statut='f',typ='TXM', defaut="PETIT", into=("PETIT","GRAND")), EXCIT = FACT(statut='f', max='**', CHARGE = SIMP(statut='o', typ=(char_meca,char_cine_meca)), @@ -24514,8 +25928,8 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod, ), SYME_CHAR = SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","ANTI","SANS")), - - DIRECTION = SIMP(statut='f', typ='R', max=3), + b_direction =BLOC(condition = "(THETA_2D != None) ", + DIRECTION = SIMP(statut='o', typ='R', max=3),), THETA_2D = FACT(statut='f', max='**', fr="paramètres de définition des champs theta", @@ -24574,15 +25988,12 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod, # table résultat TABL_GPMAX = SIMP(statut='o', typ=CO,), TABL_GP = SIMP(statut='f', typ=CO,), - b_tabl_gp=BLOC(condition="(TABL_GP != None)", - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - LIST_INST = SIMP(statut='f',typ=listr8_sdaster),), INFO = SIMP(statut='f', typ='I', defaut=1, into=(1, 2),), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 14/03/2011 AUTEUR GENIAUT S.GENIAUT # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -24614,16 +26025,31 @@ POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",op=post_k1_k2_k3_ops,sd_prod=table_sdast ), MODELISATION =SIMP(statut='o',typ='TXM', - into=("3D","AXIS","D_PLAN","C_PLAN"), + into=("3D","AXIS","D_PLAN","C_PLAN"),position='global', fr="Modélisation cohérente avec celle utilisée pour le calcul des déplacements"), FOND_FISS =SIMP(statut='f',typ=fond_fiss), FISSURE =SIMP(statut='f',typ=fiss_xfem), NB_NOEUD_COUPE=SIMP(statut='f',typ='I',defaut=5,val_min = 3), + SYME_CHAR =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","SANS")), # bloc correspondant a la donnee du fond de fissure pour les fissures maillees - b_fond_fiss =BLOC (condition="(FOND_FISS!= None)", + b_fond_fiss_res =BLOC (condition="((FOND_FISS!= None)and(RESULTAT!= None))", + + b_ref_3d =BLOC (condition="MODELISATION=='3D'", + TYPE_MAILLAGE = SIMP(statut='f',typ='TXM',into=("LIBRE","REGLE"),defaut="REGLE"), + ), + + NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + SANS_NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + SANS_GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + TOUT = SIMP(statut='f',typ='TXM',into=("OUI",) ), + EVOL_THER = SIMP(statut='f',typ=(evol_ther),fr="Température sur le fond de fissure") + ), + + b_fond_fiss_tab =BLOC (condition="((FOND_FISS!= None)and(TABL_DEPL_SUP!= None)and(RESULTAT== None))", + MAILLAGE = SIMP(statut='o',typ=maillage_sdaster), - TYPE_MAILLAGE = SIMP(statut='f',typ='TXM',into=("LIBRE","REGLE"),defaut="REGLE"), NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), SANS_NOEUD = SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), @@ -24632,13 +26058,21 @@ POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",op=post_k1_k2_k3_ops,sd_prod=table_sdast EVOL_THER = SIMP(statut='f',typ=(evol_ther),fr="Température sur le fond de fissure") ), # bloc correspondant a la donnee de la fissure pour les fissures X-FEM - b_fissure =BLOC (condition="(FISSURE!= None)", + b_fissure_res =BLOC (condition="((FISSURE!= None)and(RESULTAT!= None))", + NB_POINT_FOND = SIMP(statut='f',typ='I' ,), + NUME_FOND = SIMP(statut='f',typ='I',defaut=1), + DTAN_ORIG = SIMP(statut='f',typ='R',max='**'), + DTAN_EXTR = SIMP(statut='f',typ='R',max='**'), + ), + + b_fissure_tab =BLOC (condition="((FISSURE!= None)and(TABL_DEPL_SUP!= None)and(RESULTAT== None))", MAILLAGE = SIMP(statut='o',typ=maillage_sdaster), NB_POINT_FOND = SIMP(statut='f',typ='I' ,), NUME_FOND = SIMP(statut='f',typ='I',defaut=1), DTAN_ORIG = SIMP(statut='f',typ='R',max='**'), DTAN_EXTR = SIMP(statut='f',typ='R',max='**'), ), + MATER =SIMP(statut='o',typ=mater_sdaster, fr="Matériau homogène et isotrope cohérent avec celui utilisé pour le calcul des déplacements"), RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_noli), @@ -24662,7 +26096,6 @@ POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",op=post_k1_k2_k3_ops,sd_prod=table_sdast b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", PRECISION =SIMP(statut='o',typ='R',),), ), - SYME_CHAR =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","SANS") ), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), VECT_K1 =SIMP(statut='f',typ='R',max=3,min=3, fr="Vecteur normal au plan de fissure, orienté de la lèvre inférieure vers la lèvre supérieure"), @@ -24809,10 +26242,10 @@ POST_MAIL_XFEM=OPER(nom="POST_MAIL_XFEM",op= 187,sd_prod=maillage_sdaster, INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 02/02/2011 AUTEUR PELLET J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -25011,7 +26444,7 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster, b_extrac =BLOC(condition="RESULTAT != None", fr="extraction d un champ de grandeur", regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','INST','NOEUD_CMP'),), - NOM_CHAM =SIMP(statut='o',typ='TXM',into=("EFGE_ELNO_DEPL","SIEF_ELNO_ELGA"),), + NOM_CHAM =SIMP(statut='o',typ='TXM',into=("EFGE_ELNO","SIEF_ELNO"),), TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), NUME_ORDRE =SIMP(statut='f',typ='I',), INST =SIMP(statut='f',typ='R',), @@ -25088,10 +26521,10 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster, ), ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # ====================================================================== # CONFIGURATION MANAGEMENT OF EDF VERSION -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -25165,7 +26598,7 @@ POST_RELEVE_T=OPER(nom="POST_RELEVE_T",op=51,sd_prod=table_sdaster,reentrant='f' b_extrac =BLOC(condition = "RESULTAT != None",fr="extraction des résultats", regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','NUME_MODE','LIST_MODE', 'INST','LIST_INST','FREQ','LIST_FREQ','NOEUD_CMP','NOM_CAS'), ), - NOM_CHAM =SIMP(statut='o',typ='TXM' ), + NOM_CHAM =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO(),), TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster), @@ -25378,10 +26811,10 @@ POST_USURE=OPER(nom="POST_USURE",op=153,sd_prod=table_sdaster,reentrant='f', INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 03/01/2011 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -25483,6 +26916,7 @@ POURSUITE=MACRO(nom="POURSUITE",op=ops.build_poursuite,repetable='n', IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"), + INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2),), ) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -25590,10 +27024,10 @@ PROD_MATR_CHAM=OPER(nom="PROD_MATR_CHAM",op= 156,sd_prod=cham_no_sdaster, CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -25610,21 +27044,30 @@ PROD_MATR_CHAM=OPER(nom="PROD_MATR_CHAM",op= 156,sd_prod=cham_no_sdaster, # ====================================================================== # RESPONSABLE PELLET J.PELLET def proj_champ_prod(RESULTAT=None,CHAM_GD=None,**args ): - if AsType(RESULTAT) != None : return AsType(RESULTAT) - if AsType(CHAM_GD) != None : return AsType(CHAM_GD) + if (RESULTAT == None and CHAM_GD == None) : return corresp_2_mailla + if RESULTAT != None : return AsType(RESULTAT) + if CHAM_GD != None : return AsType(CHAM_GD) raise AsException("type de concept resultat non prevu") PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', - UIinfo={"groupes":("Résultats et champs",)}, - fr="Projeter des champs d'un maillage sur un autre", + UIinfo={"groupes":("Résultats et champs",)}, + fr="Projeter des champs d'un maillage sur un autre", + + # faut-il projeter les champs ? + PROJECTION =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON",),), + + # pour projeter avec une sd_corresp_2_mailla deja calculée : + MATR_PROJECTION =SIMP(statut='f',typ=corresp_2_mailla,), - METHODE =SIMP(statut='f',typ='TXM',defaut="AUTO", - into=("NUAGE_DEG_0","NUAGE_DEG_1","AUTO","COLOCATION","ECLA_PG",) ), + #----------------------------------------------------------------------------------------------------------- + # 1er cas : on fait tout d'un coup : creation de la sd_corresp_2_mailla + projection des champs + #----------------------------------------------------------------------------------------------- + b_1_et_2 =BLOC(condition= "PROJECTION == 'OUI' and MATR_PROJECTION == None", regles=(UN_PARMI('RESULTAT','CHAM_GD'), UN_PARMI('MODELE_1','MAILLAGE_1'), UN_PARMI('MODELE_2','MAILLAGE_2'), @@ -25632,6 +27075,10 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', RESULTAT =SIMP(statut='f',typ=resultat_sdaster), CHAM_GD =SIMP(statut='f',typ=(cham_no_sdaster,cham_elem)), + METHODE =SIMP(statut='f',typ='TXM',defaut="AUTO", + into=("NUAGE_DEG_0","NUAGE_DEG_1","AUTO","COLLOCATION","ECLA_PG",) ), + + MODELE_1 =SIMP(statut='f',typ=modele_sdaster), MAILLAGE_1 =SIMP(statut='f',typ=maillage_sdaster), @@ -25645,29 +27092,180 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', ), - # Cas de la projection COLOCATION : - #-------------------------------------------- - b_elem =BLOC(condition="METHODE in ('COLOCATION','ECLA_PG','AUTO')", - CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",), - fr="Pour indiquer au programme le type de projection souhaité"), - DISTANCE_MAX =SIMP(statut='f',typ='R', - fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."), + # Cas de la projection COLLOCATION : + #-------------------------------------------- + b_elem =BLOC(condition="METHODE in ('COLLOCATION','ECLA_PG','AUTO')", + CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",), + fr="Pour indiquer au programme le type de projection souhaité"), + DISTANCE_MAX =SIMP(statut='f',typ='R', + fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."), + + TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_1 avant la projection."), + TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_2 avant la projection."), + + ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), + + TYPE_CHAM =SIMP(statut='f',typ='TXM',into=("NOEU",), + fr="Pour forcer le type des champs projetés. NOEU -> cham_no"), + + PROL_ZERO =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON", + fr="Pour prolonger les champs par zéro là ou la projection ne donne pas de valeurs."), + ), + + + # Cas de la projection d'une sd_resultat : + #-------------------------------------------- + b_resultat =BLOC(condition="RESULTAT != None", + regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','LIST_INST','LIST_FREQ','LIST_ORDRE'), + EXCLUS('TOUT_CHAM','NOM_CHAM',), + CONCEPT_SENSIBLE('SEPARE'), + REUSE_SENSIBLE(), + DERIVABLE('RESULTAT'),), + SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', + fr="Liste des paramétres de sensibilité.", + ang="List of sensitivity parameters",), + + NOM_PARA =SIMP(statut='f',typ='TXM', max='**'), + TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ), + NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(),), + + NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster), + fr="Utile en dynamique pour pouvoir imoser la numérotation des cham_no."), + + TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), + NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ), + LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + FREQ =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster), + NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ), + NOEUD_CMP =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), + + b_acce_reel =BLOC(condition="(FREQ != None)or(LIST_FREQ != None)or(INST != None)or(LIST_INST != None)", + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), + ), + ), + + + VIS_A_VIS =FACT(statut='f',max='**', + regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'), + AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),), + TOUT_1 =SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + MAILLE_1 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_NO_1 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + NOEUD_1 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + TOUT_2 =SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA_2 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + MAILLE_2 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_NO_2 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + NOEUD_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + + # les mots clés suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le vérifier: + CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ), + TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_1 avant la projection."), + TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_2 avant la projection."), + ), + ), # fin bloc b_1_et_2 + + + + #----------------------------------------------------------------------------------------------------------- + # 2eme cas : on s'arrete apres la creation de la sd_corresp_2_mailla + #----------------------------------------------------------------------------------------------- + b_1 =BLOC(condition="PROJECTION == 'NON'", + + METHODE =SIMP(statut='f',typ='TXM',defaut="COLLOCATION", + into=("COLLOCATION","COUPLAGE",) ), + + regles=(UN_PARMI('MODELE_1','MAILLAGE_1'), + UN_PARMI('MODELE_2','MAILLAGE_2'), + ), + MODELE_1 =SIMP(statut='f',typ=modele_sdaster), + MAILLAGE_1 =SIMP(statut='f',typ=maillage_sdaster), + + MODELE_2 =SIMP(statut='f',typ=modele_sdaster), + MAILLAGE_2 =SIMP(statut='f',typ=maillage_sdaster), + + + # Cas de la projection COLLOCATION : + #-------------------------------------------- + b_elem =BLOC(condition="METHODE in ('COLLOCATION',)", + CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",), + fr="Pour indiquer au programme le type de projection souhaité"), + DISTANCE_MAX =SIMP(statut='f',typ='R', + fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."), + + TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_1 avant la projection."), + TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_2 avant la projection."), + + ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), + + ), + + VIS_A_VIS =FACT(statut='f',max='**', + regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'), + AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),), + TOUT_1 =SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + MAILLE_1 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_NO_1 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + NOEUD_1 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + TOUT_2 =SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA_2 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + MAILLE_2 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_NO_2 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), + NOEUD_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + + # les mots clés suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le vérifier: + CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ), + TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_1 avant la projection."), + TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_2 avant la projection."), + ), + ), # fin bloc b_1 + + - TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, - fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ - " aux noeuds du MODELE_1 avant la projection."), - TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, - fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ - " aux noeuds du MODELE_2 avant la projection."), + #----------------------------------------------------------------------------------------------------------- + # 3eme cas : on projette les champs avec une sd_corresp_2_mailla déjé calculée + #----------------------------------------------------------------------------------------------- + b_2 =BLOC(condition="MATR_PROJECTION != None", + regles=(UN_PARMI('RESULTAT','CHAM_GD'),), + RESULTAT =SIMP(statut='f',typ=resultat_sdaster), + CHAM_GD =SIMP(statut='f',typ=(cham_no_sdaster,cham_elem)), - ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), + TYPE_CHAM =SIMP(statut='f',typ='TXM',into=("NOEU",), + fr="Pour forcer le type des champs projetés. NOEU -> cham_no"), - TYPE_CHAM =SIMP(statut='f',typ='TXM',into=("NOEU",), - fr="Pour forcer le type des champs projetés. NOEU -> cham_no"), + NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster), + fr="Parfois utile en dynamique pour pouvoir imposer la numérotation des cham_no."), - PROL_ZERO =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON", - fr="Pour prolonger les champs par zéro là ou la projection ne donne pas de valeurs."), - ), + # nécessaire si l'on projette des cham_elem : + MODELE_2 =SIMP(statut='f',typ=modele_sdaster), + + PROL_ZERO =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON", + fr="Pour prolonger les champs par zéro là où la projection ne donne pas de valeurs."), @@ -25680,15 +27278,12 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', REUSE_SENSIBLE(), DERIVABLE('RESULTAT'),), SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', - fr="Liste des paramètres de sensibilité.", + fr="Liste des paramétres de sensibilité.", ang="List of sensitivity parameters",), NOM_PARA =SIMP(statut='f',typ='TXM', max='**'), TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ), - NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), - - NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster), - fr="Utile en dynamique pour pouvoir imoser la numérotation des cham_no."), + NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(),), TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ), @@ -25710,37 +27305,12 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', ), ), + ), # fin bloc b_2 - # Mots clés utilisables dans tous les cas : - #--------------------------------------------- - TITRE =SIMP(statut='f',typ='TXM',max='**' ), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), - - VIS_A_VIS =FACT(statut='f',max='**', - regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'), - AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),), - TOUT_1 =SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE_1 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_NO_1 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - NOEUD_1 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - TOUT_2 =SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA_2 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE_2 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_NO_2 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - NOEUD_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - - # les mots clés suivants ne sont actifs que si METHODE='COLOCATION' mais on ne peut pas le vérifier: - CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ), - TRANSF_GEOM_1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, - fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ - " aux noeuds du MODELE_1 avant la projection."), - TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, - fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ - " aux noeuds du MODELE_2 avant la projection."), - ), + TITRE =SIMP(statut='f',typ='TXM',max='**' ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), ) ; #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -25779,10 +27349,10 @@ PROJ_MATR_BASE=OPER(nom="PROJ_MATR_BASE",op= 71,sd_prod=matr_asse_gene_prod, MATR_ASSE_GENE =SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -25822,7 +27392,8 @@ PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193, MODELE =SIMP(statut='o',typ=(modele_sdaster) ), # MESURE =SIMP(statut='o',typ=(dyna_trans,dyna_harmo,base_modale,mode_meca,mode_meca_c,) ), MESURE =SIMP(statut='o',typ=(dyna_trans,dyna_harmo,mode_meca,mode_meca_c,) ), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","SIEF_NOEU","EPSI_NOEU_DEPL",) ), + NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE", + "SIEF_NOEU","EPSI_NOEU",),max='**'), ), CORR_MANU =FACT(statut='f',max='**', regles=(PRESENT_PRESENT('NOEU_CALCUL','NOEU_MESURE'),), @@ -25915,10 +27486,10 @@ PROJ_VECT_BASE=OPER(nom="PROJ_VECT_BASE",op= 72,sd_prod=vect_asse_gene, VECT_ASSE =SIMP(statut='f',typ=cham_no_sdaster), VECT_ASSE_GENE =SIMP(statut='f',typ=vect_asse_gene ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 04/05/2011 AUTEUR MACOCCO K.MACOCCO # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -25974,7 +27545,6 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod, FISSURE = FACT(statut='o',min=1,max='**', FISS_ACTUELLE = SIMP(statut='o',typ=fiss_xfem,max=1), FISS_PROPAGEE = SIMP(statut='o',typ=CO,max=1), - GRILLE_AUX = SIMP(statut='f',typ=modele_sdaster,max=1), NB_POINT_FOND = SIMP(statut='f',typ='I',max='**'), TABLE = SIMP(statut='o',typ=table_sdaster,max=1), ), @@ -25997,7 +27567,6 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod, FISSURE = FACT(statut='o',min=1,max='**', FISS_ACTUELLE = SIMP(statut='o',typ=fiss_xfem,max=1), FISS_PROPAGEE = SIMP(statut='o',typ=CO,max=1), - GRILLE_AUX = SIMP(statut='f',typ=modele_sdaster,max=1), ), ITERATIONS = SIMP(statut='f',typ='I',max=1,val_min=3,defaut=5), TOLERANCE = SIMP(statut='f',typ='R',max=1,val_min=0.0,val_max=100.0,defaut=5.0), @@ -26012,12 +27581,11 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod, FISSURE = FACT(statut='o',min=1,max='**', MAIL_ACTUEL = SIMP(statut='o',typ=maillage_sdaster,max=1), - GROUP_MA_FOND = SIMP(statut='f',typ='TXM',defaut="FOND"), - GROUP_MA_FISS = SIMP(statut='f',typ='TXM',defaut="FISS"), + GROUP_MA_FOND = SIMP(statut='f',typ=grma,defaut="FOND"), + GROUP_MA_FISS = SIMP(statut='f',typ=grma,defaut="FISS"), FISS_ACTUELLE = SIMP(statut='o',typ=fiss_xfem,max=1), MAIL_PROPAGE = SIMP(statut='f',typ=CO,max=1), TABLE = SIMP(statut='o',typ=table_sdaster,max=1), - METHODE_POSTK = SIMP(statut='f',typ='I',into=(1,2,3),max=1), DTAN_ORIG = SIMP(statut='f',typ='R',max=3), DTAN_EXTR = SIMP(statut='f',typ='R',max=3), ), @@ -26031,8 +27599,8 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod, b_init =BLOC(condition="(METHODE_PROPA=='INITIALISATION')", MAIL_STRUC = SIMP(statut='o',typ=maillage_sdaster), FORM_FISS = SIMP(statut='o',typ='TXM', into=("DEMI_DROITE","DEMI_PLAN","ELLIPSE"), ), - GROUP_MA_FOND = SIMP(statut='f',typ='TXM',defaut="FOND"), - GROUP_MA_FISS = SIMP(statut='f',typ='TXM',defaut="FISS"), + GROUP_MA_FOND = SIMP(statut='f',typ=grma,defaut="FOND"), + GROUP_MA_FISS = SIMP(statut='f',typ=grma,defaut="FISS"), MAIL_TOTAL = SIMP(statut='o',typ=CO), MAIL_FISS = SIMP(statut='f',typ=CO), @@ -26045,7 +27613,7 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod, DTAN = SIMP(statut='o',typ='R',min=3,max=3), POINT_ORIG = SIMP(statut='o',typ='R',min=3,max=3), POINT_EXTR = SIMP(statut='o',typ='R',min=3,max=3), - NB_POINT_FOND = SIMP(statut='o',typ='I',val_max=26), + NB_POINT_FOND = SIMP(statut='o',typ='I',), ), b_ellipse = BLOC(condition = "FORM_FISS == 'ELLIPSE' ", @@ -26056,7 +27624,7 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod, VECT_Y =SIMP(statut='o',typ='R',min=3,max=3), ANGLE_ORIG = SIMP(statut='o',typ='R',), ANGLE_EXTR = SIMP(statut='o',typ='R',), - NB_POINT_FOND = SIMP(statut='o',typ='I',val_max=52,), + NB_POINT_FOND = SIMP(statut='o',typ='I',) ), ), @@ -26075,10 +27643,10 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod, INFO = SIMP(statut='f',typ='I',defaut=1,into=(0,1,2)), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/03/2011 AUTEUR MASSIN P.MASSIN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -26101,8 +27669,6 @@ PROPA_XFEM=OPER(nom="PROPA_XFEM",op=10,sd_prod=fiss_xfem,reentrant='n', MODELE =SIMP(statut='o',typ=modele_sdaster), - GRILLE_AUX =SIMP(statut='f',typ=modele_sdaster), - TEST_MAIL =SIMP(statut='f',typ='TXM',into=("NON","OUI",),defaut="NON"), DA_MAX =SIMP(statut='o',typ='R'), @@ -26489,6 +28055,46 @@ RECU_GENE=OPER(nom="RECU_GENE",op= 76,sd_prod=vect_asse_gene,reentrant='n', b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", PRECISION =SIMP(statut='o',typ='R',),), ) ; +#& MODIF COMMANDE DATE 14/02/2011 AUTEUR GREFFET N.GREFFET +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GREFFET N.GREFFET +# +# RECUPERATION DE PARAMETRES DE COUPLAGE VIA YACS +# +RECU_PARA_YACS=OPER(nom="RECU_PARA_YACS",op=114,sd_prod=listr8_sdaster, + reentrant = 'n', + UIinfo={"groupes":("Fonction",)}, + fr = "Gestion des scalaires via YACS pour le coupleur IFS", + DONNEES = SIMP(statut='o',typ='TXM',into=("INITIALISATION","CONVERGENCE","FIN","PAS",) ), + b_init = BLOC(condition= "DONNEES=='INITIALISATION'", + PAS = SIMP(statut='o',typ='R', ),), + b_noinit = BLOC(condition= "(DONNEES=='CONVERGENCE')or(DONNEES=='FIN')", + NUME_ORDRE_YACS = SIMP(statut='o', typ='I',), + INST = SIMP(statut='o',typ='R', ), + PAS = SIMP(statut='o',typ='R', ),), + b_pastps = BLOC(condition= "(DONNEES=='PAS')", + NUME_ORDRE_YACS = SIMP(statut='o', typ='I',), + INST = SIMP(statut='o',typ='R', ), + PAS = SIMP(statut='o',typ='R', ),), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), + TITRE =SIMP(statut='f',typ='TXM',max='**'), +); #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -26563,10 +28169,10 @@ RESOUDRE=OPER(nom="RESOUDRE",op=15,sd_prod=cham_no_sdaster,reentrant='f', TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -26583,10 +28189,11 @@ RESOUDRE=OPER(nom="RESOUDRE",op=15,sd_prod=cham_no_sdaster,reentrant='f', # ====================================================================== # RESPONSABLE DEVESA G.DEVESA -def rest_cond_tran_prod(RESULTAT,**args ): +def rest_cond_tran_prod(RESULTAT,TYPE_RESU,**args ): - if AsType(RESULTAT) == evol_noli : return dyna_trans - if AsType(RESULTAT) == dyna_trans : return dyna_trans + if AsType(RESULTAT) == dyna_trans : return dyna_trans + if (AsType(RESULTAT) == evol_noli and TYPE_RESU == "DYNA_TRANS") : return dyna_trans + if (AsType(RESULTAT) == evol_noli and TYPE_RESU == "EVOL_NOLI") : return evol_noli raise AsException("type de concept resultat non prevu") @@ -26594,12 +28201,14 @@ REST_COND_TRAN=OPER(nom="REST_COND_TRAN",op= 78,sd_prod=rest_cond_tran_prod, fr="Restituer dans la base physique des résultats issus d'un calcul" +"non-lineaire avec projection modale ou d'un calcul transitoire linear" +"avec condensation dynamique", - reentrant='n', + reentrant='f', UIinfo={"groupes":("Matrices et vecteurs",)}, regles=( EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','TOUT_INST'), EXCLUS('MACR_ELEM_DYNA','BASE_MODALE'),), RESULTAT =SIMP(statut='f',typ=(evol_noli,dyna_trans) ), + TYPE_RESU =SIMP(statut='f',typ='TXM',defaut="DYNA_TRANS", + into=("DYNA_TRANS","EVOL_NOLI") ), BASE_MODALE =SIMP(statut='f',typ=mode_meca), # NUME_DDL =SIMP(statut='f',typ=nume_ddl_sdaster ), MACR_ELEM_DYNA =SIMP(statut='f',typ=macr_elem_dyna), @@ -26616,14 +28225,18 @@ REST_COND_TRAN=OPER(nom="REST_COND_TRAN",op= 78,sd_prod=rest_cond_tran_prod, INTERPOL =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","LIN") ), TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ), b_nom_cham=BLOC(condition="TOUT_CHAM == None", - NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,defaut="ACCE", - into=("DEPL","VITE","ACCE",) ),), + NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,defaut="ACCE",into=("DEPL", + "VITE","ACCE",),),), + b_base_moda=BLOC(condition="BASE_MODALE != None", + CHAM_MATER =SIMP(statut='f',typ=cham_mater), + CARA_ELEM =SIMP(statut='f',typ=cara_elem),), + RESU_FINAL =SIMP(statut='f',typ=(evol_noli,dyna_trans) ), TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -26683,9 +28296,8 @@ REST_GENE_PHYS=OPER(nom="REST_GENE_PHYS",op= 75,sd_prod=rest_gene_phys_prod, CORR_STAT =SIMP(statut='f',typ='TXM',into=("OUI",) ), TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ), b_nom_cham=BLOC(condition="TOUT_CHAM == None", - NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE", - into=("DEPL","VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO_DEPL","SIPO_ELNO_DEPL", - "SIGM_ELNO_DEPL","FORC_NODA",) ),), + NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE",into=("DEPL", + "VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO","SIPO_ELNO","SIGM_ELNO","FORC_NODA",),),), GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), @@ -26694,10 +28306,10 @@ REST_GENE_PHYS=OPER(nom="REST_GENE_PHYS",op= 75,sd_prod=rest_gene_phys_prod, DIRECTION =SIMP(statut='f',typ='R',min=3,max=3 ), TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -26762,9 +28374,8 @@ REST_SOUS_STRUC=OPER(nom="REST_SOUS_STRUC",op= 77,sd_prod=rest_sous_struc_prod, INTERPOL =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","LIN") ), TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ), b_nom_cham=BLOC(condition="TOUT_CHAM == None", - NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE", - into=("DEPL","VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO_DEPL","SIPO_ELNO_DEPL", - "SIGM_ELNO_DEPL","FORC_NODA",) ),), + NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE",into=("DEPL", + "VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO","SIPO_ELNO","SIGM_ELNO","FORC_NODA",) ),), GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), @@ -26781,10 +28392,10 @@ REST_SOUS_STRUC=OPER(nom="REST_SOUS_STRUC",op= 77,sd_prod=rest_sous_struc_prod, SECTEUR =SIMP(statut='f',typ='I'), TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 29/03/2011 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -26814,9 +28425,8 @@ REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_fonction, NOEUD =SIMP(statut='o',typ=no ,max='**'), MAILLE =SIMP(statut='f',typ=ma ,max='**'), NOM_CMP =SIMP(statut='o',typ='TXM',max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=7, - into=("DEPL","VITE","ACCE","EFGE_ELNO_DEPL", - "SIPO_ELNO_DEPL","SIGM_ELNO_DEPL","FORC_NODA") ), + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=7,into=("DEPL", + "VITE","ACCE","EFGE_ELNO","SIPO_ELNO","SIGM_ELNO","FORC_NODA") ), MODE_STAT =SIMP(statut='f',typ=mode_meca ), EXCIT =FACT(statut='f', NOEUD =SIMP(statut='o',typ=no ,max='**'), @@ -26866,10 +28476,10 @@ REST_SPEC_TEMP=OPER(nom="REST_SPEC_TEMP",op=181,sd_prod=rest_spec_temp_prod, TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",)), NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,into=("DEPL","VITE","ACCE") ), ); -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 21/02/2011 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -26894,13 +28504,7 @@ SIMU_POINT_MAT=MACRO(nom="SIMU_POINT_MAT", op=simu_point_mat_ops,sd_prod=table_s fr="Calcul de l'évolution mécanique, en quasi-statique," +" d'un point matériel en non linéaire", COMP_INCR =C_COMP_INCR(), - COMP_ELAS =FACT(statut='f',max='**', - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - RELATION =SIMP(statut='o',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS","ELAS_HYPER")), - DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ), - ), + COMP_ELAS =C_COMP_ELAS('SIMU_POINT_MAT'), MATER =SIMP(statut='o',typ=mater_sdaster,max=30), ## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations imposées. @@ -26928,37 +28532,22 @@ SIMU_POINT_MAT=MACRO(nom="SIMU_POINT_MAT", op=simu_point_mat_ops,sd_prod=table_s ), b_EF = BLOC(condition="SUPPORT == 'ELEMENT'",fr="Simulation sur un élément fini", MODELISATION =SIMP(statut='f',typ='TXM',max=1,into=("3D","C_PLAN","D_PLAN",)), - RECH_LINEAIRE =C_RECH_LINEAIRE(), - ARCHIVAGE =FACT(statut='f', - LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - PAS_ARCH =SIMP(statut='f',typ='I' ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ARCH_ETAT_INIT =SIMP(statut='f',typ='TXM',into=("OUI",),defaut="OUI"), - NUME_INIT =SIMP(statut='f',typ='I'), - DETR_NUME_SUIV =SIMP(statut='f',typ='TXM',into=("OUI",)), - CHAM_EXCLU =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', - into=("DEPL","SIEF_ELGA","VARI_ELGA",)), - ), + RECH_LINEAIRE =C_RECH_LINEAIRE(), + ARCHIVAGE =C_ARCHIVAGE(), ), # on permet certaines variables de commandes scalaires, définies par une fonction du temps b_EFV = BLOC(condition="SUPPORT == 'ELEMENT'",fr="variables de commande sur un élément fini", # un mot clé caché qui ne sert qu'à boucler sur les VARC possibles : - LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP",)), + LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP","CORR","IRRA","HYDR","SECH","EPSA", + "M_ACIER","M_ZIRC","NEUT1","NEUT2")), + AFFE_VARC = FACT(statut='f',max='**', - NOM_VARC = SIMP(statut='o',typ='TXM', into=("TEMP",)), + NOM_VARC =SIMP(statut='o',typ='TXM', into=("TEMP","CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC", + "EPSA","NEUT1","NEUT2")), VALE_FONC = SIMP(statut='o',typ=(fonction_sdaster,formule) ), VALE_REF = SIMP(statut='f',typ='R'), ), - # mots clés cachés pour variable de commande TEMP : - # -------------------------------------------------- - VARC_TEMP =FACT(statut='d', - NOM_VARC =SIMP(statut='c',typ='TXM',defaut="TEMP"), - GRANDEUR =SIMP(statut='c',typ='TXM',defaut="TEMP_R"), - CMP_GD =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("TEMP",)), - CMP_VARC =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("TEMP",)), - VALE_DEF =SIMP(statut='c',typ='R',max=1,min=1,defaut=(0.,)), - ), + SIGM_IMPOSE=FACT(statut='f', SIXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), SIYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ), @@ -27072,10 +28661,10 @@ STANLEY=MACRO(nom="STANLEY",op=stanley_ops,sd_prod=None, fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit les md5"), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 21/02/2011 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -27116,23 +28705,11 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, SUPER_MAILLE=SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',), FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), ), +#------------------------------------------------------------------- COMP_INCR =C_COMP_INCR(), - COMP_ELAS =FACT(statut='f',max='**', - RESI_INTE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ITER_INTE_MAXI =SIMP(statut='f',typ='I',defaut= 10 ), - ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("IMPLICITE",)), - RELATION =SIMP(statut='o',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS", - "ELAS_POUTRE_GR","CABLE","ELAS_HYPER")), - - DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ), - regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), - TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - ), +#------------------------------------------------------------------- + COMP_ELAS =C_COMP_ELAS('STAT_NON_LINE'), +#------------------------------------------------------------------- b_reuse =BLOC(condition = "reuse",fr="en mode concept reentrant : ETAT_INIT obligatoire", ETAT_INIT =FACT(statut='o', regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','SIGM','VARI',), @@ -27175,130 +28752,33 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, NUME_DIDI =SIMP(statut='f',typ='I'), INST_ETAT_INIT =SIMP(statut='f',typ='R'), ),), +#------------------------------------------------------------------- INCREMENT =C_INCREMENT(), - -# **C_ALGO_RESOLUTION() - METHODE = SIMP(statut='d',typ='TXM',defaut="NEWTON",into=("NEWTON","IMPL_EX")), - b_meth_newton = BLOC(condition = "METHODE == 'NEWTON'", - NEWTON = C_NEWTON(), - ), - b_meth_impl_ex = BLOC(condition = "METHODE == 'IMPL_EX'", - IMPL_EX = C_IMPL_EX(), - ), - +#------------------------------------------------------------------- + METHODE =SIMP(statut='d',typ='TXM',defaut="NEWTON",into=("NEWTON","IMPL_EX")), + b_meth_newton = BLOC(condition = "METHODE == 'NEWTON'", + NEWTON = C_NEWTON(), + ), + b_meth_impl_ex = BLOC(condition = "METHODE == 'IMPL_EX'", + IMPL_EX = C_IMPL_EX(), + ), +#------------------------------------------------------------------- RECH_LINEAIRE =C_RECH_LINEAIRE(), - - PILOTAGE =FACT(statut='f', - regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), - TYPE =SIMP(statut='o',typ='TXM',into=("DDL_IMPO","LONG_ARC","PRED_ELAS","DEFORMATION","ANA_LIM") ), - COEF_MULT =SIMP(statut='f',typ='R',defaut= 1.0E+0), - EVOL_PARA =SIMP(statut='f',typ='TXM',defaut="SANS", into=("SANS","CROISSANT","DECROISSANT") ), - - - ETA_PILO_MAX =SIMP(statut='f',typ='R'), - ETA_PILO_MIN =SIMP(statut='f',typ='R'), - ETA_PILO_R_MAX =SIMP(statut='f',typ='R'), - ETA_PILO_R_MIN =SIMP(statut='f',typ='R'), - PROJ_BORNES =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), - SELECTION =SIMP(statut='f',typ='TXM',defaut="NORM_INCR_DEPL", into=("RESIDU","ANGL_INCR_DEPL","NORM_INCR_DEPL") ), - TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'), - NOM_CMP =SIMP(statut='f',typ='TXM',max='**'), - ), - +#------------------------------------------------------------------- + PILOTAGE =C_PILOTAGE(), +#------------------------------------------------------------------- CONVERGENCE =C_CONVERGENCE(), - +#------------------------------------------------------------------- SOLVEUR =C_SOLVEUR(), - - ARCHIVAGE =FACT(statut='f', - regles=(EXCLUS('PAS_ARCH','LIST_INST','INST'), - EXCLUS('ARCH_ETAT_INIT','NUME_INIT'), ), - LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - PAS_ARCH =SIMP(statut='f',typ='I' ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-6), - ARCH_ETAT_INIT =SIMP(statut='f',typ='TXM',into=("OUI",)), - NUME_INIT =SIMP(statut='f',typ='I'), - DETR_NUME_SUIV =SIMP(statut='f',typ='TXM',into=("OUI",)), - CHAM_EXCLU =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', - into=("DEPL","SIEF_ELGA","VARI_ELGA",)), - ), - OBSERVATION =FACT(statut='f',max='**', - NOM_CMP =SIMP(statut='o',typ='TXM',max='**'), - SUIVI_DDL =SIMP(statut='f',typ='TXM',defaut="NON",max=1,into=("OUI","NON")), - b_suivi =BLOC(condition = "SUIVI_DDL == 'OUI' ", - regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'), - PRESENT_PRESENT('MAILLE','POINT'),), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1, - into=("DEPL","VITE","ACCE","SIEF_ELGA", - "VARI_ELGA","FORC_NODA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)), - GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4), - VALE_MAX =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ), - VALE_MIN =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),), - b_non_suivi =BLOC(condition = "SUIVI_DDL == 'NON' ", - regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'),PRESENT_PRESENT('MAILLE','POINT'),), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("DEPL","VITE","ACCE","SIEF_ELGA", - "VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU","VALE_CONT")), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - PAS_OBSE =SIMP(statut='f',typ='I'), - LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), - b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", - PRECISION =SIMP(statut='o',typ='R',),),), - ), - - AFFICHAGE = FACT(statut='f',max=16, - - UNITE = SIMP(statut='f',typ='I',val_min=1), - - LONG_R = SIMP(statut='f',typ='I',defaut=12,val_min=1,val_max=12), - PREC_R = SIMP(statut='f',typ='I',defaut=5, val_min=1,val_max=8), - LONG_I = SIMP(statut='f',typ='I',defaut=6, val_min=1,val_max=12), - - NOM_COLONNE = SIMP(statut='o',typ='TXM',defaut="STANDARD", - into=("STANDARD","MINIMUM", - "ITER_NEWT", - "INCR_TPS", - "RESI_RELA","RELA_NOEU", - "RESI_MAXI","MAXI_NOEU", - "RESI_REFE","REFE_NOEU", - "RELI_ITER","RELI_COEF", - "RESI_COMP","COMP_NOEU", - "PILO_PARA", - "MATR_ASSE", - "ITER_DEBO", - "CTCD_ITER","CTCD_GEOM","CTCD_NOEU", - "BOUC_GEOM","BOUC_FROT","BOUC_CONT","CTCC_BOUC","CTCC_NOEU", - "SUIV_1","SUIV_2","SUIV_3","SUIV_4","ITER_FETI", - ), - ), - b_residu = BLOC(condition = " NOM_COLONNE == 'RESI_RELA' or \ - NOM_COLONNE == 'RESI_MAXI' or\ - NOM_COLONNE == 'RESI_REFE' or\ - NOM_COLONNE == 'CTCD_GEOM' or\ - NOM_COLONNE == 'CTCC_BOUC' or\ - NOM_COLONNE == 'STANDARD' ", - INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - ), - ), - - - +#------------------------------------------------------------------- + OBSERVATION =C_OBSERVATION(), +#------------------------------------------------------------------- + SUIVI_DDL =C_SUIVI_DDL(), +#------------------------------------------------------------------- + ARCHIVAGE =C_ARCHIVAGE(), +#------------------------------------------------------------------- + AFFICHAGE = C_AFFICHAGE(), +#------------------------------------------------------------------- CRIT_FLAMB =FACT(statut='f',min=1,max=1, NB_FREQ =SIMP(statut='f',typ='I',max=1,defaut=3), CHAR_CRIT =SIMP(statut='f',typ='R',min=2,max=2,defaut=(-10.0,10), @@ -27315,7 +28795,15 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, 'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22', 'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23', 'PRES31','PRES32','PRES33','VARI','LAG_GV')),), - INST_CALCUL =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ), + regles = (EXCLUS('PAS_CALC','LIST_INST','INST'),), + LIST_INST = SIMP(statut='f',typ=(listr8_sdaster) ), + INST = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + PAS_CALC = SIMP(statut='f',typ='I' ), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), + b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", + PRECISION =SIMP(statut='o',typ='R',),), ), SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', fr="Liste des paramètres de sensibilité", @@ -27334,6 +28822,88 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR PROIX J-M.PROIX +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# -*- coding: iso-8859-1 -*- +# RESPONSABLE PROIX J.M.PROIX + +from Macro.test_compor_ops import test_compor_ops + +# MACRO "TEST_THERMOPLASTIQUE" +# ---------------------------- + +TEST_COMPOR =MACRO(nom="TEST_COMPOR", op=test_compor_ops,sd_prod=table_sdaster, + docu="",reentrant='n', + fr="macro de test des comportements incrementaux dependant de la temperature", + + OPTION =SIMP(statut='f',typ='TXM',into=("THER","MECA"),defaut="THER"), + + COMP_INCR =C_COMP_INCR(), + COMP_ELAS =C_COMP_ELAS('SIMU_POINT_MAT'), + NEWTON =C_NEWTON(), + CONVERGENCE =C_CONVERGENCE(), + + b_ther =BLOC(condition = "OPTION == 'THER'", + regles=(EXCLUS('C_PRAG','D_SIGM_EPSI'),), + MATER =SIMP(statut='o',typ=mater_sdaster,max=1,fr="materiau dependant de la temperature"), + ALPHA =SIMP(statut='o',typ=fonction_sdaster, + fr="coefficient de dilatation fonction de la temperature"), + YOUNG =SIMP(statut='o',typ=fonction_sdaster, + fr="module d'Young fonction de la temperature"), + LIST_MATER =SIMP(statut='o',typ=mater_sdaster,max='**', + fr="liste des materiaux constants interpolés à chaque température"), + TEMP_INIT =SIMP(statut='o',typ='R', fr="temperature initiale et de reference"), + TEMP_FIN =SIMP(statut='o',typ='R', fr="temperature finale"), + INST_FIN =SIMP(statut='f',typ='R',defaut=1.,fr="instant final"), + NB_VARI =SIMP(statut='o',typ='I', fr="nombre de variables internes - 0 en elasticité"), + VARI_TEST =SIMP(statut='f',typ='TXM',max='**', + fr="liste de variables internes à tester - par defaut, toutes"), + +# special ecrouissage cinematique + D_SIGM_EPSI =SIMP(statut='f',typ=fonction_sdaster, + fr="module tangent fonction de la temperature- VMIS_CINE_LINE"), + C_PRAG =SIMP(statut='f',typ=fonction_sdaster, + fr="constante de Prager fonction de la temperature- VMIS_ECMI_*"), + ), + b_meca =BLOC(condition = "OPTION == 'MECA'", + LIST_MATER =SIMP(statut='o',typ=mater_sdaster,max=2,min=2, + fr="liste des materiaux en Pa puis MPa "), + YOUNG =SIMP(statut='o',typ='R',fr="module d'Young"), + POISSON =SIMP(statut='o',typ='R',fr="coef de Poisson"), + LIST_NPAS =SIMP(statut='f',typ='I',max='**', + fr="nombre de pas de temps pour chaque discretisation"), + LIST_TOLE =SIMP(statut='f',typ='R',max='**',), + PREC_ZERO =SIMP(statut='f',typ='R',max='**',), + VARI_TEST =SIMP(statut='f',typ='TXM',max='**',defaut=('V1','VMIS','TRACE'), + fr="liste des CMP à tester "), + SUPPORT =SIMP(statut='f',typ='TXM',max=1,into=("POINT","ELEMENT",)), + MODELISATION =SIMP(statut='f',typ='TXM',max=1,into=("3D","C_PLAN"),defaut="3D",), + ANGLE =SIMP(statut='f',typ='R',max=1, defaut=0., + fr='Rotation de ANGLE autour de Z uniquement, et seulement pour les déformations imposées',), + MASSIF =FACT(statut='f',max='**',fr='orientation du materiau (monocristal, orthotropie)', + regles=(UN_PARMI('ANGL_REP','ANGL_EULER'),), + ANGL_REP =SIMP(statut='f',typ='R',min=1,max=3), + ANGL_EULER =SIMP(statut='f',typ='R',min=1,max=3), + ), + ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), + ) #& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -27762,10 +29332,10 @@ TEST_TEMPS=MACRO(nom="TEST_TEMPS",op=test_temps_ops, sd_prod=None, INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ) -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 21/02/2011 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -27847,7 +29417,7 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f', RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -27856,11 +29426,12 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f', TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", @@ -27872,7 +29443,7 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f', RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -27884,24 +29455,16 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f', ), ), PARM_THETA =SIMP(statut='f',typ='R',defaut= 0.57), - ARCHIVAGE =FACT(statut='f', - regles=EXCLUS('PAS_ARCH','LIST_INST','INST'), - LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - PAS_ARCH =SIMP(statut='f',typ='I' ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-6), - NUME_INIT =SIMP(statut='f',typ='I'), - DETR_NUME_SUIV =SIMP(statut='f',typ='TXM',into=("OUI",)), - CHAM_EXCLU =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', - into=("VARI",)), - ), +#------------------------------------------------------------------- + ARCHIVAGE =C_ARCHIVAGE(), +#------------------------------------------------------------------- TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',into=(1,2)), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 21/02/2011 AUTEUR ABBAS M.ABBAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -28003,7 +29566,7 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f', RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -28012,13 +29575,14 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f', TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO","SCOTCH",)), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), FILTRAGE_MATRICE=SIMP(statut='f',typ='R',defaut=-1.0,), MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", @@ -28030,7 +29594,7 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f', RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", @@ -28043,45 +29607,21 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f', SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), ), PARM_THETA =SIMP(statut='f',typ='R',defaut= 0.57 ), - ARCHIVAGE =FACT(statut='f', - regles=EXCLUS('PAS_ARCH','LIST_INST','INST'), - LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - PAS_ARCH =SIMP(statut='f',typ='I' ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-6), - NUME_INIT =SIMP(statut='f',typ='I'), - DETR_NUME_SUIV =SIMP(statut='f',typ='TXM',into=("OUI",)), - CHAM_EXCLU =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', - into=("VARI",)), - ), - OBSERVATION =FACT(statut='f',max='**', - NOM_CMP =SIMP(statut='o',typ='TXM',max='**' ), - SUIVI_DDL =SIMP(statut='c',typ='TXM',defaut="NON",max=1,into=("NON",)), - b_non_suivi =BLOC(condition = "SUIVI_DDL == 'NON' ", - regles=(UN_PARMI('NOEUD','GROUP_NO')), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("TEMP",)), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - PAS_OBSE =SIMP(statut='f',typ='I'), - LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')", - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6,),), - b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')", - PRECISION =SIMP(statut='o',typ='R',),),), - ), +#------------------------------------------------------------------- + ARCHIVAGE =C_ARCHIVAGE(), +#------------------------------------------------------------------- + OBSERVATION =C_OBSERVATION(), +#------------------------------------------------------------------- TITRE =SIMP(statut='f',typ='TXM',max='**'), OPTION =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2, - into=("FLUX_ELGA_TEMP","FLUX_ELNO_TEMP") ), + into=("FLUX_ELGA","FLUX_ELNO") ), INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/11/2010 AUTEUR DELMAS J.DELMAS +#& MODIF COMMANDE DATE 08/02/2011 AUTEUR TARDIEU N.TARDIEU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG +# COPYRIGHT (C) 1991 - 2011 EDF R&D WWW.CODE-ASTER.ORG # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR @@ -28139,7 +29679,7 @@ THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_simple =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), ), RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), @@ -28148,11 +29688,12 @@ THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther, TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")), PRETRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")), - RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")), ELIM_LAGR2 =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=10,), RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), OUT_OF_CORE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), + LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), ), b_petsc =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC", ALGORITHME =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ), @@ -28163,7 +29704,7 @@ THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther, RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ), ), b_ldlt_sp =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision", - REAC_PRECOND =SIMP(statut='f',typ='I',defaut=5, ), + REAC_PRECOND =SIMP(statut='f',typ='I',defaut=30, ), RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ), ), b_jacobi_sor =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", diff --git a/Traducteur/traduitV9V10.py b/Traducteur/traduitV9V10.py index ec3c7e18..0330043f 100755 --- a/Traducteur/traduitV9V10.py +++ b/Traducteur/traduitV9V10.py @@ -508,8 +508,10 @@ def traduc(infile,outfile,flog=None): renameMotCle(jdc,"MACR_ADAP_MAIL","TYPE_VALEUR_INDICA","USAGE_CMP") AjouteMotClefDansFacteurCourantSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='BOITE'",((("RAYON",),"nexistepasMCsousMCFcourant"),)) AjouteMotClefDansFacteurCourantSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='SPHERE'",((("RAYON",),"existeMCsousMCFcourant"),)) - ChangementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_5":"V9_9"}) - ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_5":"V9_9"}) + ChangementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_5":"V10_1"}) + ChangementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_N":"V10_1_N"}) + ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_5":"V10_1"}) + ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_N":"V10_1_N"}) ###################### traitement de POST_CHAM_XFEM ################# removeMotCle(jdc,"POST_CHAM_XFEM","MODELE",pasDeRegle(),0) @@ -593,7 +595,7 @@ def traduc(infile,outfile,flog=None): "VARI_NOEU_ELGA":"VARI_NOEU","VARI_ELNO_ELGA":"VARI_ELNO", "INDI_LOCA_ELGA":"INDL_ELGA"} #"FORC_NODA":"FORC_NOEU","REAC_NODA":"REAC_NOEU" - ChangementValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VAR_C","NOM_CHAM",dOPTION) + ChangementValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VARC","NOM_CHAM",dOPTION) ChangementValeur(jdc,"COMB_FOURIER","NOM_CHAM",dOPTION) ChangementValeur(jdc,"CREA_CHAMP","NOM_CHAM",dOPTION) ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dOPTION) @@ -637,7 +639,7 @@ def traduc(infile,outfile,flog=None): # Options ambigue : PRES_ELNO_DBEL --> prac_elno/prme_elno, ERRE* --> ERME_ELNO ou ERTH_ELNO selon PHENOMENE # En commentaires les commandes non concernees par rOPTION - GenereErreurValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VAR_C","NOM_CHAM",rOPTION) + GenereErreurValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VARC","NOM_CHAM",rOPTION) #GenereErreurValeur(jdc,"COMB_FOURIER","NOM_CHAM",rOPTION) GenereErreurValeur(jdc,"CREA_CHAMP","NOM_CHAM",rOPTION) GenereErreurValeur(jdc,"CREA_RESU","NOM_CHAM",rOPTION) @@ -686,6 +688,9 @@ def traduc(infile,outfile,flog=None): removeMotCle(jdc,"CALC_MISS","UNITE_OPTI_MISS",pasDeRegle()) removeMotCle(jdc,"CALC_MISS","UNITE_MODELE_SOL",pasDeRegle()) removeMotCle(jdc,"CALC_MISS","OPTION",pasDeRegle(),1) + ChangementValeur(jdc,"CALC_MISS","VERSION",{"V1_4":"V6.5"}) + ChangementValeur(jdc,"CALC_MISS","VERSION",{"V1_5":"V6.6"}) + ChangementValeur(jdc,"CALC_MISS","VERSION",{"V1_3":"V6.5"}) macr="" interf=""