-#@ MODIF post_k1_k2_k3_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
+#@ MODIF post_k1_k2_k3_ops Macro DATE 12/10/2010 AUTEUR GENIAUT S.GENIAUT
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
+
+
+#---------------------------------------------------------------------------------------------------------------
+# FONCTIONS UTILITAIRES
+#---------------------------------------------------------------------------------------------------------------
+
def veri_tab(tab,nom,ndim) :
from Utilitai.Utmess import UTMESS
macro = 'POST_K1_K2_K3'
label='COOR_Z'
UTMESS('F','RUPTURE0_2',valk=[label,nom])
-#TODO prefer use numpy.cross
-def cross_product(a,b):
- cross = [0]*3
- cross[0] = a[1]*b[2]-a[2]*b[1]
- cross[1] = a[2]*b[0]-a[0]*b[2]
- cross[2] = a[0]*b[1]-a[1]*b[0]
- return cross
+#---------------------------------------------------------------------------------------------------------------
+
+# def cross_product(a,b):
+# cross = [0]*3
+# cross[0] = a[1]*b[2]-a[2]*b[1]
+# cross[1] = a[2]*b[0]-a[0]*b[2]
+# cross[2] = a[0]*b[1]-a[1]*b[0]
+# return cross
+#---------------------------------------------------------------------------------------------------------------
+
+def normalize(v):
+ import numpy as NP
+ norm = NP.sqrt(v[0]**2+v[1]**2+v[2]**2)
+ return v/norm
+
+#---------------------------------------------------------------------------------------------------------------
def complete(Tab):
n = len(Tab)
for i in range(n) :
if Tab[i]==None : Tab[i] = 0.
return Tab
+
+#---------------------------------------------------------------------------------------------------------------
+# sam : la methode average(t) ne repond-elle pas au besoin ?
def moy(t):
m = 0
for value in t :
m += value
return (m/len(t))
+#---------------------------------------------------------------------------------------------------------------
+
def InterpolFondFiss(s0, Coorfo) :
# Interpolation des points du fond de fissure (xfem)
# s0 = abscisse curviligne du point considere
xyz[3] = s0
return xyz
-def InterpolBaseFiss(s0, Basefo, Coorfo) :
-# Interpolation de la base locale en fond de fissure
-# s0 = abscisse curviligne du point considere
-# Basefo = base locale du fond (VNx,VNy,VNz,VPx,VPy,VPz)
-# Coorfo = Coordonnees et abscisses du fond (extrait de la sd fiss_xfem)
-# en sortie : VPVNi = base locale au point considere (6 coordonnes)
- n = len(Coorfo) / 4
- if ( s0 < Coorfo[3] ) :
- VPVNi = Basefo[0:6]
- return VPVNi
- if ( s0 > Coorfo[-1] ) :
- VPVNi = [Basefo[i] for i in range(-6,0)]
- return VPVNi
- i = 1
- while s0 > Coorfo[4*i+3]:
- i = i+1
- VPVNi = [0.]*6
- for k in range(6) :
- VPVNi[k] = (s0-Coorfo[4*(i-1)+3]) * (Basefo[6*i+k]-Basefo[6*(i-1)+k]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Basefo[6*(i-1)+k]
- return VPVNi
-
-
+#---------------------------------------------------------------------------------------------------------------
+
+def InterpolBaseFiss(s0, Basefo, Coorfo) :
+# Interpolation de la base locale en fond de fissure
+# s0 = abscisse curviligne du point considere
+# Basefo = base locale du fond (VNx,VNy,VNz,VPx,VPy,VPz)
+# Coorfo = Coordonnees et abscisses du fond (extrait de la sd fiss_xfem)
+# en sortie : VPVNi = base locale au point considere (6 coordonnes)
+ n = len(Coorfo) / 4
+ if ( s0 < Coorfo[3] ) :
+ VPVNi = Basefo[0:6]
+ return VPVNi
+ if ( s0 > Coorfo[-1] ) :
+ VPVNi = [Basefo[i] for i in range(-6,0)]
+ return VPVNi
+ i = 1
+ while s0 > Coorfo[4*i+3]:
+ i = i+1
+ VPVNi = [0.]*6
+ for k in range(6) :
+ VPVNi[k] = (s0-Coorfo[4*(i-1)+3]) * (Basefo[6*i+k]-Basefo[6*(i-1)+k]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Basefo[6*(i-1)+k]
+ return VPVNi
+
+#---------------------------------------------------------------------------------------------------------------
+
+def verif_type_fond_fiss(ndim,FOND_FISS) :
+ from Utilitai.Utmess import UTMESS
+ if ndim == 3 :
+ Typ = FOND_FISS.FOND_______TYPE.get()
+# attention : Typ est un tuple contenant une seule valeur
+ if Typ[0].rstrip() != 'SEG2' and Typ[0].rstrip() != 'SEG3' :
+ UTMESS('F','RUPTURE0_12')
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_noeud_fond_fiss(FOND_FISS) :
+ """ retourne la liste des noeuds de FOND_FISS"""
+ import string as S
+ from Utilitai.Utmess import UTMESS
+ Lnoff = FOND_FISS.FOND_______NOEU.get()
+ if Lnoff == None :
+# Cas double fond de fissure : par convention les noeuds sont ceux de fond_inf
+ Lnoff = FOND_FISS.FONDINF____NOEU.get()
+ if Lnoff == None : UTMESS('F','RUPTURE0_11')
+ Lnoff = map(S.rstrip,Lnoff)
+ return Lnoff
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_noeud_a_calculer(Lnoff,ndim,FOND_FISS,MAILLAGE,EnumTypes,args) :
+ """ retourne la liste des noeuds de FOND_FISS a calculer"""
+ import string as S
+ from Utilitai.Utmess import UTMESS
+
+ NOEUD = args['NOEUD']
+ SANS_NOEUD = args['SANS_NOEUD']
+ GROUP_NO = args['GROUP_NO']
+ SANS_GROUP_NO = args['SANS_GROUP_NO']
+ TOUT = args['TOUT']
+
+ if ndim == 2 :
+
+ Lnocal = Lnoff
+ assert (len(Lnocal) == 1)
+
+ elif ndim == 3 :
+
+# determination du pas de parcours des noeuds : 1 (tous les noeuds) ou 2 (un noeud sur 2)
+ Typ = FOND_FISS.FOND_______TYPE.get()
+ Typ = Typ[0].rstrip()
+ if (Typ == 'SEG2') or (Typ =='SEG3' and TOUT == 'OUI') :
+ pas = 1
+ elif (Typ =='SEG3') :
+ pas = 2
+
+# construction de la liste des noeuds "AVEC" et des noeuds "SANS"
+ NO_SANS = []
+ NO_AVEC = []
+ if GROUP_NO!=None :
+ collgrno = MAILLAGE.GROUPENO.get()
+ cnom = MAILLAGE.NOMNOE.get()
+ if type(GROUP_NO) not in EnumTypes :
+ GROUP_NO = (GROUP_NO,)
+ for m in xrange(len(GROUP_NO)) :
+ ngrno=GROUP_NO[m].ljust(8).upper()
+ if ngrno not in collgrno.keys() :
+ UTMESS('F','RUPTURE0_13',valk=ngrno)
+ for i in xrange(len(collgrno[ngrno])) :
+ NO_AVEC.append(cnom[collgrno[ngrno][i]-1])
+ NO_AVEC = map(S.rstrip,NO_AVEC)
+ if NOEUD!=None :
+ if type(NOEUD) not in EnumTypes :
+ NO_AVEC = (NOEUD,)
+ else :
+ NO_AVEC = NOEUD
+ if SANS_GROUP_NO!=None :
+ collgrno = MAILLAGE.GROUPENO.get()
+ cnom = MAILLAGE.NOMNOE.get()
+ if type(SANS_GROUP_NO) not in EnumTypes :
+ SANS_GROUP_NO = (SANS_GROUP_NO,)
+ for m in xrange(len(SANS_GROUP_NO)) :
+ ngrno=SANS_GROUP_NO[m].ljust(8).upper()
+ if ngrno not in collgrno.keys() :
+ UTMESS('F','RUPTURE0_13',valk=ngrno)
+ for i in xrange(len(collgrno[ngrno])) :
+ NO_SANS.append(cnom[collgrno[ngrno][i]-1])
+ NO_SANS= map(S.rstrip,NO_SANS)
+ if SANS_NOEUD!=None :
+ if type(SANS_NOEUD) not in EnumTypes :
+ NO_SANS = (SANS_NOEUD,)
+ else :
+ NO_SANS = SANS_NOEUD
+
+# verification que les noeuds "AVEC" et "SANS" appartiennent au fond de fissure
+ set_tmp = set(NO_AVEC) - set(Lnoff)
+ if set_tmp :
+ UTMESS('F','RUPTURE0_15',valk=list(set_tmp)[0])
+ set_tmp = set(NO_SANS) - set(Lnoff)
+ if set_tmp :
+ UTMESS('F','RUPTURE0_15',valk=list(set_tmp)[0])
+
+# creation de Lnocal
+ if NO_AVEC :
+ Lnocal = tuple( NO_AVEC )
+ elif NO_SANS :
+ Lnocal = tuple( set(Lnoff) - set(NO_SANS) )
+ else :
+ Lnocal = tuple(Lnoff)
+
+ return Lnocal
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_coor_libre(self,Lnoff,RESULTAT,ndim):
+ """ retourne les coordonnes des noeuds de FOND_FISS en dictionnaire"""
+
+ import numpy as NP
+ from Accas import _F
+ import string as S
+
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ __NCOFON=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds du fond',
+ NOEUD=Lnoff,
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ NUME_ORDRE=1,
+ NOM_CMP=('DX',),
+ OPERATION='EXTRACTION',),);
+
+ tcoorf=__NCOFON.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=__NCOFON),INFO=1)
+ nbt = len(tcoorf['NOEUD'].values()['NOEUD'])
+ xs=NP.array(tcoorf['COOR_X'].values()['COOR_X'][:nbt])
+ ys=NP.array(tcoorf['COOR_Y'].values()['COOR_Y'][:nbt])
+ if ndim==2 :
+ zs=NP.zeros(nbt,)
+ elif ndim==3 :
+ zs=NP.array(tcoorf['COOR_Z'].values()['COOR_Z'][:nbt])
+ ns = tcoorf['NOEUD'].values()['NOEUD'][:nbt]
+ ns = map(S.rstrip,ns)
+ l_coorf = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)]
+ l_coorf = [(i[0],i[1:]) for i in l_coorf]
+ return dict(l_coorf)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_Plev(self,MAILLAGE,ListmaS,RESULTAT):
+ """ retourne les coordonnes d'un point quelconque des levres pr determination sens de propagation"""
+ import numpy as NP
+ from Accas import _F
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ cmail=MAILLAGE.NOMMAI.get()
+ for i in range(len(cmail)) :
+ if cmail[i] == ListmaS[0] :
+ break
+ colcnx=MAILLAGE.CONNEX.get()
+ cnom = MAILLAGE.NOMNOE.get()
+ NO_TMP = []
+ for k in range(len(colcnx[i+1])) :
+ NO_TMP.append(cnom[colcnx[i+1][k]-1])
+
+ __NCOLEV=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees pt levre',
+ NOEUD = NO_TMP,
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ NUME_ORDRE=1,
+ NOM_CMP=('DX',),
+ OPERATION='EXTRACTION',),);
+
+ tcoorl=__NCOLEV.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=__NCOLEV),INFO=1)
+ nbt = len(tcoorl['NOEUD'].values()['NOEUD'])
+ xl=moy(tcoorl['COOR_X'].values()['COOR_X'][:nbt])
+ yl=moy(tcoorl['COOR_Y'].values()['COOR_Y'][:nbt])
+ zl=moy(tcoorl['COOR_Z'].values()['COOR_Z'][:nbt])
+ return NP.array([xl, yl, zl])
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_normale(VECT_K1,Nnoff,ndim,DTANOR,DTANEX,d_coorf,Lnoff,Plev) :
+ """ retourne les normales (direct de propa) en chaque point du fond,
+ les abscisses curvilignes et le sens de la tangete (a eclaircir)"""
+
+ import numpy as NP
+
+ v1 = NP.array(VECT_K1)
+ VN = [None]*Nnoff
+ absfon = [0,]
+ if ndim == 3 :
+ Pfon2 = NP.array([d_coorf[Lnoff[0]][0],d_coorf[Lnoff[0]][1],d_coorf[Lnoff[0]][2]])
+ VLori = Pfon2 - Plev
+ if DTANOR != None :
+ VN[0] = NP.array(DTANOR)
+ else :
+ Pfon3 = NP.array([d_coorf[Lnoff[1]][0],d_coorf[Lnoff[1]][1],d_coorf[Lnoff[1]][2]])
+ VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+ VN[0] = NP.array(NP.cross(VT,v1))
+ for i in range(1,Nnoff-1):
+ Pfon1 = NP.array([d_coorf[Lnoff[i-1]][0],d_coorf[Lnoff[i-1]][1],d_coorf[Lnoff[i-1]][2]])
+ Pfon2 = NP.array([d_coorf[Lnoff[i]][0],d_coorf[Lnoff[i]][1],d_coorf[Lnoff[i]][2]])
+ Pfon3 = NP.array([d_coorf[Lnoff[i+1]][0],d_coorf[Lnoff[i+1]][1],d_coorf[Lnoff[i+1]][2]])
+ absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
+ absfon.append(absf)
+ VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+ VT = VT+(Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+ VN[i] = NP.array(NP.cross(VT,v1))
+ VN[i] = VN[i]/NP.sqrt(NP.dot(NP.transpose(VN[i]),VN[i]))
+ i = Nnoff-1
+ Pfon1 = NP.array([d_coorf[Lnoff[i-1]][0],d_coorf[Lnoff[i-1]][1],d_coorf[Lnoff[i-1]][2]])
+ Pfon2 = NP.array([d_coorf[Lnoff[i]][0],d_coorf[Lnoff[i]][1],d_coorf[Lnoff[i]][2]])
+ VLextr = Pfon2 - Plev
+ absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
+ absfon.append(absf)
+ if DTANEX != None :
+ VN[i] = NP.array(DTANEX)
+ else :
+ VT = (Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+ VN[i] = NP.array(NP.cross(VT,v1))
+ dicoF = dict([(Lnoff[i],absfon[i]) for i in range(Nnoff)])
+ dicVN = dict([(Lnoff[i],VN[i]) for i in range(Nnoff)])
+# Sens de la tangente
+ v = NP.cross(VLori,VLextr)
+ sens = NP.sign(NP.dot(NP.transpose(v),v1))
+ elif ndim ==2 :
+ VT = NP.array([0.,0.,1.])
+ VN = NP.array(NP.cross(v1,VT))
+ dicVN = dict([(Lnoff[0],VN)])
+ Pfon = NP.array([d_coorf[Lnoff[0]][0],d_coorf[Lnoff[0]][1],d_coorf[Lnoff[0]][2]])
+ VLori = Pfon - Plev
+ sens = NP.sign(NP.dot(NP.transpose(VN),VLori))
+ return (dicVN, dicoF, sens)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def 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) :
+ """ retourne les tables des deplacements sup et inf pour les noeuds perpendiculaires pour
+ chaque point du fond de fissure"""
+
+ from Accas import _F
+ import numpy as NP
+
+ MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
+
+ TlibS = [None]*Nnocal
+ TlibI = [None]*Nnocal
+ for i in xrange(Nnocal):
+ Porig = NP.array(d_coorf[Lnocal[i]] )
+ if Lnocal[i]==Lnoff[0] and DTANOR :
+ Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnocal[i]]
+ elif Lnocal[i]==Lnoff[Nnoff-1] and DTANEX :
+ Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnocal[i]]
+ else :
+ Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnocal[i]]*sens
+
+ TlibS[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ MODELE=MODEL,
+ VIS_A_VIS=_F(MAILLE_1 = ListmaS),
+ LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,
+ COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+ TYPE='SEGMENT',
+ COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+ DISTANCE_MAX=dmax),);
+
+
+ if SYME_CHAR=='SANS':
+ TlibI[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ MODELE=MODEL,
+ VIS_A_VIS=_F(MAILLE_1 = ListmaI),
+ LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,
+ COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+ TYPE='SEGMENT',
+ COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+ DISTANCE_MAX=dmax),);
+ return (TlibS,TlibI)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_dico_levres(lev,FOND_FISS,ndim,Lnoff,Nnoff):
+ "retourne ???"""
+ import string as S
+ from Utilitai.Utmess import UTMESS
+ if lev == 'sup' :
+ Nnorm = FOND_FISS.SUPNORM____NOEU.get()
+ if not Nnorm :
+ UTMESS('F','RUPTURE0_19')
+ elif lev == 'inf' :
+ Nnorm = FOND_FISS.INFNORM____NOEU.get()
+ if not Nnorm :
+ UTMESS('F','RUPTURE0_20')
+ Nnorm = map(S.rstrip,Nnorm)
+# pourquoi modifie t-on Nnoff dans ce cas, alors que rien n'est fait pour les maillages libres ?
+ if Lnoff[0]==Lnoff[-1] and ndim == 3 :
+ Nnoff=Nnoff-1 # Cas fond de fissure ferme
+ Nnorm = [[Lnoff[i],Nnorm[i*20:(i+1)*20]] for i in range(0,Nnoff)]
+ Nnorm = [(i[0],i[1][0:]) for i in Nnorm]
+ return dict(Nnorm)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_coor_regle(self,RESULTAT,ndim,Lnoff,Lnocal,dicoS,SYME_CHAR,dicoI,TABL_DEPL_SUP,TABL_DEPL_INF):
+ """retourne le dictionnaires des coordonnees des noeuds des lèvres pour les maillages regles"""
+ import numpy as NP
+ import string as S
+ import copy
+ from Accas import _F
+
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+ CALC_TABLE = self.get_cmd('CALC_TABLE')
+
+ if RESULTAT :
+# a eclaircir
+ Ltot = copy.copy(Lnoff)
+ for ino in Lnocal :
+ for k in xrange(0,20) :
+ if dicoS[ino][k] !='':
+ Ltot.append(dicoS[ino][k])
+ if SYME_CHAR=='SANS':
+ for ino in Lnocal :
+ for k in xrange(0,20) :
+ if dicoI[ino][k] !='':
+ Ltot.append(dicoI[ino][k])
+ Ltot=dict([(i,0) for i in Ltot]).keys()
+
+ __NCOOR=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds des levres',
+ NOEUD=Ltot,
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ NUME_ORDRE=1,
+ NOM_CMP=('DX',),
+ OPERATION='EXTRACTION',),);
+
+ tcoor=__NCOOR.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1)
+ else :
+ if SYME_CHAR=='SANS':
+ __NCOOR=CALC_TABLE(TABLE=TABL_DEPL_SUP,
+ ACTION=_F(OPERATION = 'COMB',
+ NOM_PARA='NOEUD',
+ TABLE=TABL_DEPL_INF,))
+ tcoor=__NCOOR.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1)
+ else :
+ tcoor=TABL_DEPL_SUP.EXTR_TABLE()
+ nbt = len(tcoor['NOEUD'].values()['NOEUD'])
+ xs=NP.array(tcoor['COOR_X'].values()['COOR_X'][:nbt])
+ ys=NP.array(tcoor['COOR_Y'].values()['COOR_Y'][:nbt])
+ if ndim==2 :
+ zs=NP.zeros(nbt)
+ elif ndim==3 :
+ zs=NP.array(tcoor['COOR_Z'].values()['COOR_Z'][:nbt])
+ ns = tcoor['NOEUD'].values()['NOEUD'][:nbt]
+ ns = map(S.rstrip,ns)
+ l_coor = [[ns[i],xs[i],ys[i],zs[i]] for i in xrange(nbt)]
+ l_coor = [(i[0],i[1:]) for i in l_coor]
+ return dict(l_coor)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_absfon(Lnoff,Nnoff,d_coor):
+ """ retourne le dictionnaire des Abscisses curvilignes du fond"""
+ import numpy as NP
+ absfon = [0,]
+ for i in xrange(Nnoff-1) :
+ Pfon1 = NP.array([d_coor[Lnoff[i]][0],d_coor[Lnoff[i]][1],d_coor[Lnoff[i]][2]])
+ Pfon2 = NP.array([d_coor[Lnoff[i+1]][0],d_coor[Lnoff[i+1]][1],d_coor[Lnoff[i+1]][2]])
+ absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i]
+ absfon.append(absf)
+ return dict([(Lnoff[i],absfon[i]) for i in xrange(Nnoff)])
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_noeuds_perp_regle(Lnocal,d_coor,dicoS,dicoI,Lnoff,PREC_VIS_A_VIS,ABSC_CURV_MAXI,SYME_CHAR,rmprec,precn):
+ """retourne la liste des noeuds du fond (encore ?), la liste des listes des noeuds perpendiculaires"""
+ import numpy as NP
+ from Utilitai.Utmess import UTMESS
+
+ NBTRLS = 0
+ NBTRLI = 0
+ Lnosup = [None]*len(Lnocal)
+ Lnoinf = [None]*len(Lnocal)
+ Nbnofo = 0
+ Lnofon = []
+ for ino in Lnocal :
+ Pfon = NP.array([d_coor[ino][0],d_coor[ino][1],d_coor[ino][2]])
+ Tmpsup = []
+ Tmpinf = []
+ itots = 0
+ itoti = 0
+ NBTRLS = 0
+ NBTRLI = 0
+ for k in xrange(20) :
+ if dicoS[ino][k] !='':
+ itots = itots +1
+ Nsup = dicoS[ino][k]
+ Psup = NP.array([d_coor[Nsup][0],d_coor[Nsup][1],d_coor[Nsup][2]])
+ abss = NP.sqrt(NP.dot(NP.transpose(Pfon-Psup),Pfon-Psup))
+ if abss<rmprec :
+ NBTRLS = NBTRLS +1
+ Tmpsup.append(dicoS[ino][k])
+ if SYME_CHAR=='SANS':
+ if dicoI[ino][k] !='':
+ itoti = itoti +1
+ Ninf = dicoI[ino][k]
+ Pinf = NP.array([d_coor[Ninf][0],d_coor[Ninf][1],d_coor[Ninf][2]])
+ absi = NP.sqrt(NP.dot(NP.transpose(Pfon-Pinf),Pfon-Pinf))
+# On verifie que les noeuds sont en vis a vis
+ if abss<rmprec :
+ dist = NP.sqrt(NP.dot(NP.transpose(Psup-Pinf),Psup-Pinf))
+ if dist>precn :
+ UTMESS('A','RUPTURE0_21',valk=ino)
+ else :
+ NBTRLI = NBTRLI +1
+ Tmpinf.append(dicoI[ino][k])
+# On verifie qu il y a assez de noeuds
+ if NBTRLS < 3 :
+ UTMESS('A+','RUPTURE0_22',valk=ino)
+ if ino==Lnoff[0] or ino==Lnoff[-1]:
+ UTMESS('A+','RUPTURE0_23')
+ if itots<3 :
+ UTMESS('A','RUPTURE0_24')
+ else :
+ UTMESS('A','RUPTURE0_25')
+ elif (SYME_CHAR=='SANS') and (NBTRLI < 3) :
+ UTMESS('A+','RUPTURE0_26',valk=ino)
+ if ino==Lnoff[0] or ino==Lnoff[-1]:
+ UTMESS('A+','RUPTURE0_23')
+ if itoti<3 :
+ UTMESS('A','RUPTURE0_24')
+ else :
+ UTMESS('A','RUPTURE0_25')
+ else :
+ Lnosup[Nbnofo] = Tmpsup
+ if SYME_CHAR=='SANS' :
+ Lnoinf[Nbnofo] = Tmpinf
+ Lnofon.append(ino)
+ Nbnofo = Nbnofo+1
+ if Nbnofo == 0 :
+ UTMESS('F','RUPTURE0_30')
+
+ return (Lnofon, Lnosup, Lnoinf)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def verif_resxfem(self,RESULTAT) :
+ """ verifie que le resultat est bien compatible avec X-FEM et renvoie xcont et MODEL"""
+
+ import aster
+ from Utilitai.Utmess import UTMESS
+
+ iret,ibid,n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT')
+ n_modele=n_modele.rstrip()
+ if len(n_modele)==0 :
+ UTMESS('F','RUPTURE0_18')
+ MODEL = self.get_concept(n_modele)
+ xcont = MODEL.xfem.XFEM_CONT.get()
+ return (xcont,MODEL)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_resxfem(self,xcont,RESULTAT,MAILLAGE,MODELISATION,MODEL) :
+ """ retourne le resultat """
+ from Accas import _F
+
+ AFFE_MODELE = self.get_cmd('AFFE_MODELE')
+ PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ if xcont[0] == 0 :
+ __RESX = RESULTAT
+
+# XFEM + contact : il faut reprojeter sur le maillage lineaire
+ elif xcont[0] != 0 :
+ __MODLINE=AFFE_MODELE(MAILLAGE=MAILLAGE,
+ AFFE=(_F(TOUT='OUI',
+ PHENOMENE='MECANIQUE',
+ MODELISATION=MODELISATION,),),);
+
+ __RESX=PROJ_CHAMP(METHODE='COLOCATION',
+ TYPE_CHAM='NOEU',
+ NOM_CHAM='DEPL',
+ RESULTAT=RESULTAT,
+ MODELE_1=MODEL,
+ MODELE_2=__MODLINE, );
+
+# Rq : on ne peut pas détruire __MODLINE ici car on en a besoin lors du MACR_LIGN_COUP qui suivra
+
+ return __RESX
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_coor_xfem(args,FISSURE,ndim):
+ """retourne la liste des coordonnees des points du fond, la base locale en fond et le nombre de points"""
+
+ from Utilitai.Utmess import UTMESS
+
+ Listfo = FISSURE.FONDFISS.get()
+ Basefo = FISSURE.BASEFOND.get()
+ NB_POINT_FOND = args['NB_POINT_FOND']
+
+# Traitement du cas fond multiple
+ Fissmult = FISSURE.FONDMULT.get()
+ Nbfiss = len(Fissmult)/2
+ Numfiss = args['NUME_FOND']
+ if Numfiss <= Nbfiss and Nbfiss > 1 :
+ Ptinit = Fissmult[2*(Numfiss-1)]
+ Ptfin = Fissmult[2*(Numfiss-1)+1]
+ Listfo2 = Listfo[((Ptinit-1)*4):(Ptfin*4)]
+ Listfo = Listfo2
+ Basefo2 = Basefo[((Ptinit-1)*(2*ndim)):(Ptfin*(2*ndim))]
+ Basefo = Basefo2
+ elif Numfiss > Nbfiss :
+ UTMESS('F','RUPTURE1_38',vali=[Nbfiss,Numfiss])
+
+ if NB_POINT_FOND != None and ndim == 3 :
+ Nnoff = NB_POINT_FOND
+ absmax = Listfo[-1]
+ Coorfo = [None]*4*Nnoff
+ Vpropa = [None]*3*Nnoff
+ for i in xrange(Nnoff) :
+ absci = i*absmax/(Nnoff-1)
+ Coorfo[(4*i):(4*(i+1))] = InterpolFondFiss(absci, Listfo)
+ Vpropa[(6*i):(6*(i+1))] = InterpolBaseFiss(absci,Basefo, Listfo)
+ else :
+ Coorfo = Listfo
+ Vpropa = Basefo
+ Nnoff = len(Coorfo)/4
+
+ return (Coorfo, Vpropa, Nnoff)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_direction_xfem(Nnoff,Vpropa,Coorfo,VECT_K1,DTAN_ORIG,DTAN_EXTR,ndim) :
+ """retourne la dirction de propagation, la normale a la surface de la fissure,
+ et l'abscisse curviligne en chaque point du fond"""
+ import numpy as NP
+ from Utilitai.Utmess import UTMESS
+
+ VP = [None]*Nnoff
+ VN = [None]*Nnoff
+ absfon = [0,]
+
+# Cas fissure non necessairement plane
+ if VECT_K1 == None :
+ i = 0
+ if ndim == 3 :
+ if DTAN_ORIG != None :
+ VP[0] = NP.array(DTAN_ORIG)
+ VP[0] = VP[0]/NP.sqrt(VP[0][0]**2+VP[0][1]**2+VP[0][2]**2)
+ VN[0] = NP.array([Vpropa[0],Vpropa[1],Vpropa[2]])
+ verif = NP.dot(NP.transpose(VP[0]),VN[0])
+ if abs(verif) > 0.01:
+ UTMESS('A','RUPTURE1_33',valr=[VN[0][0],VN[0][1],VN[0][2]])
+ else :
+ VN[0] = NP.array([Vpropa[0],Vpropa[1],Vpropa[2]])
+ VP[0] = NP.array([Vpropa[3+0],Vpropa[3+1],Vpropa[3+2]])
+ for i in xrange(1,Nnoff-1):
+ absf = Coorfo[4*i+3]
+ absfon.append(absf)
+ VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+ VP[i] = NP.array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]])
+ verif = NP.dot(NP.transpose(VN[i]),VN[i-1])
+ if abs(verif) < 0.98:
+ UTMESS('A','RUPTURE1_35',vali=[i-1,i])
+ i = Nnoff-1
+ absf = Coorfo[4*i+3]
+ absfon.append(absf)
+ if DTAN_EXTR != None :
+ VP[i] = NP.array(DTAN_EXTR)
+ VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+ verif = NP.dot(NP.transpose(VP[i]),VN[0])
+ if abs(verif) > 0.01:
+ UTMESS('A','RUPTURE1_34',valr=[VN[i][0],VN[i][1],VN[i][2]])
+ else :
+ VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+ VP[i] = NP.array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]])
+ elif ndim == 2 :
+ for i in range(0,Nnoff):
+ VP[i] = NP.array([Vpropa[2+4*i],Vpropa[3+4*i],0.])
+ VN[i] = NP.array([Vpropa[0+4*i],Vpropa[1+4*i],0.])
+
+# Cas fissure plane (VECT_K1 donne)
+ if VECT_K1 != None :
+ v1 = NP.array(VECT_K1)
+ v1 = v1/NP.sqrt(v1[0]**2+v1[1]**2+v1[2]**2)
+ v1 = NP.array(VECT_K1)
+ i = 0
+ if ndim == 3 :
+# Sens du vecteur VECT_K1
+ v1x =NP.array([Vpropa[0],Vpropa[1],Vpropa[2]])
+ verif = NP.dot(NP.transpose(v1),v1x)
+ if verif < 0 :
+ v1 = -v1
+ VN = [v1]*Nnoff
+ if DTAN_ORIG != None :
+ VP[i] = NP.array(DTAN_ORIG)
+ VP[i] = VP[i]/NP.sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2)
+ verif = NP.dot(NP.transpose(VP[i]),VN[0])
+ if abs(verif) > 0.01:
+ UTMESS('A','RUPTURE1_36')
+ else :
+ Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+ Pfon3 = NP.array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]])
+ VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+ VP[0] = NP.array(NP.cross(VT,v1))
+ VNi = NP.array([Vpropa[3],Vpropa[4],Vpropa[5]])
+ verif = NP.dot(NP.transpose(VP[i]),VNi)
+ if abs(verif) < 0.99:
+ vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+ UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+ for i in range(1,Nnoff-1):
+ Pfon1 = NP.array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]])
+ Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+ Pfon3 = NP.array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]])
+ absf = Coorfo[4*i+3]
+ absfon.append(absf)
+ VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+ VT = VT+(Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+ VP[i] = NP.array(NP.cross(VT,v1))
+ VP[i] = VP[i]/NP.sqrt(NP.dot(NP.transpose(VP[i]),VP[i]))
+ VNi = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+ verif = NP.dot(NP.transpose(VN[i]),VNi)
+ if abs(verif) < 0.99:
+ vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+ UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+ i = Nnoff-1
+ Pfon1 = NP.array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]])
+ Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+ absf = Coorfo[4*i+3]
+ absfon.append(absf)
+ if DTAN_EXTR != None :
+ VP[i] = NP.array(DTAN_EXTR)
+ VP[i] = VP[i]/NP.sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2)
+ verif = NP.dot(NP.transpose(VP[i]),VN[i])
+ if abs(verif) > 0.01:
+ UTMESS('A','RUPTURE1_37')
+ else :
+ VT = (Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+ VP[i] = NP.array(NP.cross(VT,v1))
+ VNi = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+ verif = NP.dot(NP.transpose(VN[i]),VNi)
+ if abs(verif) < 0.99 :
+ vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+ UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+
+ elif ndim == 2 :
+
+ VT = NP.array([0.,0.,1.])
+ for i in range(0,Nnoff):
+ VP[i] = NP.array(NP.cross(v1,VT))
+ VN[i] = v1
+ VNi = NP.array([Vpropa[0+4*i],Vpropa[1+4*i],0.])
+ verif = NP.dot(NP.transpose(VN[i]),VNi)
+ if abs(verif) < 0.99 :
+ vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+ UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+
+ return (VP,VN,absfon)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_sens_tangente_xfem(self,ndim,Nnoff,Coorfo,VP,ABSC_CURV_MAXI,__RESX,dmax) :
+ """retourne le sens de la tangente ???"""
+ from Accas import _F
+ import numpy as NP
+ from Utilitai.Utmess import UTMESS
+
+ MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ if ndim == 3 :
+ i = Nnoff/2
+ elif ndim == 2 :
+ i = 0
+ Po = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+ Porig = Po + ABSC_CURV_MAXI*VP[i]
+ Pextr = Po - ABSC_CURV_MAXI*VP[i]
+ __Tabg = MACR_LIGN_COUPE(RESULTAT=__RESX,
+ NOM_CHAM='DEPL',
+ LIGN_COUPE=_F(NB_POINTS=3,
+ COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+ TYPE='SEGMENT',
+ COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+ DISTANCE_MAX=dmax),);
+ tmp=__Tabg.EXTR_TABLE()
+ test = getattr(tmp,'H1X').values()
+ if test==[None]*3 :
+ UTMESS('F','RUPTURE0_33')
+ if test[0]!=None :
+ sens = 1
+ else :
+ sens = -1
+ DETRUIRE(CONCEPT=_F(NOM=__Tabg),INFO=1)
+
+ return sens
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_sauts_xfem(self,Nnoff,Coorfo,VP,sens,DTAN_ORIG,DTAN_EXTR,ABSC_CURV_MAXI,NB_NOEUD_COUPE,dmax,__RESX) :
+ """retourne la table des sauts"""
+ from Accas import _F
+ import numpy as NP
+
+ MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
+
+ mcfact=[]
+ for i in xrange(Nnoff):
+ Porig = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+ if i==0 and DTAN_ORIG!=None :
+ Pextr = Porig - ABSC_CURV_MAXI*VP[i]
+ elif i==(Nnoff-1) and DTAN_EXTR!=None :
+ Pextr = Porig - ABSC_CURV_MAXI*VP[i]
+ else :
+ Pextr = Porig + ABSC_CURV_MAXI*VP[i]*sens
+
+ mcfact.append(_F(NB_POINTS=NB_NOEUD_COUPE,
+ COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+ TYPE='SEGMENT',
+ COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+ DISTANCE_MAX=dmax),)
+
+ __TSo = MACR_LIGN_COUPE(RESULTAT=__RESX,
+ NOM_CHAM='DEPL',
+ LIGN_COUPE=mcfact);
+
+ return __TSo.EXTR_TABLE()
+
+#---------------------------------------------------------------------------------------------------------------
+
+def affiche_xfem(self,INFO,Nnoff,VN,VP) :
+ """affiche des infos"""
+ from Accas import _F
+ import aster
+
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ if INFO==2 :
+ mcfact=[]
+ mcfact.append(_F(PARA='PT_FOND',LISTE_I=range(Nnoff)))
+ mcfact.append(_F(PARA='VN_X' ,LISTE_R=[VN[i][0] for i in xrange(Nnoff)]))
+ mcfact.append(_F(PARA='VN_Y' ,LISTE_R=[VN[i][1] for i in xrange(Nnoff)]))
+ mcfact.append(_F(PARA='VN_Z' ,LISTE_R=[VN[i][2] for i in xrange(Nnoff)]))
+ mcfact.append(_F(PARA='VP_X' ,LISTE_R=[VP[i][0] for i in xrange(Nnoff)]))
+ mcfact.append(_F(PARA='VP_Y' ,LISTE_R=[VP[i][1] for i in xrange(Nnoff)]))
+ mcfact.append(_F(PARA='VP_Z' ,LISTE_R=[VP[i][2] for i in xrange(Nnoff)]))
+ __resu2=CREA_TABLE(LISTE=mcfact,
+ TITRE= ' '*13 + 'VECTEUR NORMAL A LA FISSURE - DIRECTION DE PROPAGATION')
+ aster.affiche('MESSAGE',__resu2.EXTR_TABLE().__repr__())
+ DETRUIRE(CONCEPT=_F(NOM=__resu2),INFO=1)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def affiche_traitement(FOND_FISS,INFO,FISSURE,Lnofon,ino):
+ import aster
+ if FOND_FISS and INFO==2 :
+ texte="\n\n--> TRAITEMENT DU NOEUD DU FOND DE FISSURE: %s"%Lnofon[ino]
+ aster.affiche('MESSAGE',texte)
+ if FISSURE and INFO==2 :
+ texte="\n\n--> TRAITEMENT DU POINT DU FOND DE FISSURE NUMERO %s"%(ino+1)
+ aster.affiche('MESSAGE',texte)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_tab(self,lev,ino,Tlib,Lno,TTSo,FOND_FISS,FISSURE,TYPE_MAILLAGE,RESULTAT,SYME_CHAR,TABL_DEPL,ndim) :
+ """retourne la table des deplacements des noeuds perpendiculaires"""
+ from Accas import _F
+ import string as S
+
+ DETRUIRE = self.get_cmd('DETRUIRE')
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+
+ if lev == 'sup' or (lev == 'inf' and SYME_CHAR=='SANS' and not FISSURE) :
+
+ if FOND_FISS :
+ if TYPE_MAILLAGE =='LIBRE':
+ tab=Tlib[ino].EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=Tlib[ino]),INFO=1)
+ elif RESULTAT :
+ if ndim == 2:
+ nomcmp= ('DX','DY')
+ elif ndim == 3:
+ nomcmp= ('DX','DY','DZ')
+
+ __T=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement '+lev.upper(),
+ NOEUD=Lno[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=nomcmp,
+ OPERATION='EXTRACTION',),);
+ tab=__T.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=__T),INFO=1)
+ else :
+ tab=TABL_DEPL.EXTR_TABLE()
+ veri_tab(tab,TABL_DEPL.nom,ndim)
+ Ls = [S.ljust(Lno[ino][i],8) for i in range(len(Lno[ino]))]
+ tab=tab.NOEUD==Ls
+ elif FISSURE :
+ tab = TTSo.INTITULE=='l.coupe%i'%(ino+1)
+ else :
+ tab=TABL_DEPL.EXTR_TABLE()
+ veri_tab(tab,TABL_DEPL.nom,ndim)
+
+ else :
+
+ tab = None
+
+ return tab
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_liste_inst(tabsup,args,LIST_ORDRE,NUME_ORDRE,INST,LIST_INST,EnumTypes) :
+ """retourne la liste d'instants"""
+ from Utilitai.Utmess import UTMESS
+ if 'INST' in tabsup.para :
+ l_inst=None
+ l_inst_tab=tabsup['INST'].values()['INST']
+ l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() #elimine les doublons
+ l_inst_tab.sort()
+ if LIST_ORDRE !=None or NUME_ORDRE !=None :
+ l_ord_tab = tabsup['NUME_ORDRE'].values()['NUME_ORDRE']
+ l_ord_tab.sort()
+ l_ord_tab=dict([(i,0) for i in l_ord_tab]).keys()
+ d_ord_tab= [[l_ord_tab[i],l_inst_tab[i]] for i in range(0,len(l_ord_tab))]
+ d_ord_tab= [(i[0],i[1]) for i in d_ord_tab]
+ d_ord_tab = dict(d_ord_tab)
+ if NUME_ORDRE !=None :
+ if type(NUME_ORDRE) not in EnumTypes :
+ NUME_ORDRE=(NUME_ORDRE,)
+ l_ord=list(NUME_ORDRE)
+ elif LIST_ORDRE !=None :
+ l_ord = LIST_ORDRE.VALE.get()
+ l_inst = []
+ for ord in l_ord :
+ if ord in l_ord_tab :
+ l_inst.append(d_ord_tab[ord])
+ else :
+ UTMESS('F','RUPTURE0_37',vali=ord)
+ PRECISION = 1.E-6
+ CRITERE='ABSOLU'
+ elif INST !=None or LIST_INST !=None :
+ CRITERE = args['CRITERE']
+ PRECISION = args['PRECISION']
+ if INST !=None :
+ if type(INST) not in EnumTypes : INST=(INST,)
+ l_inst=list(INST)
+ elif LIST_INST !=None :
+ l_inst=LIST_INST.Valeurs()
+ for inst in l_inst :
+ if CRITERE=='RELATIF' and inst!=0.:
+ match=[x for x in l_inst_tab if abs((inst-x)/inst)<PRECISION]
+ else :
+ match=[x for x in l_inst_tab if abs(inst-x)<PRECISION]
+ if len(match)==0 :
+ UTMESS('F','RUPTURE0_38',valr=inst)
+ if len(match)>=2 :
+ UTMESS('F','RUPTURE0_39',valr=inst)
+ else :
+ l_inst=l_inst_tab
+ PRECISION = 1.E-6
+ CRITERE='ABSOLU'
+ else :
+ l_inst = [None,]
+ PRECISION = None
+ CRITERE = None
+
+ return (l_inst,PRECISION,CRITERE)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def affiche_instant(INFO,inst):
+ import aster
+ if INFO==2 and inst!=None:
+ texte= "#" + "="*80 + "\n" + "==> INSTANT: %f"%inst
+ aster.affiche('MESSAGE',texte)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_tab_inst(lev,inst,FISSURE,SYME_CHAR,PRECISION,CRITERE,tabsup,tabinf) :
+ """retourne la table des deplacements des noeuds à l'instant courant"""
+
+ tab = None
+ assert( lev == 'sup' or lev == 'inf')
+
+ # identification du cas (le cas sans instant sera à supprimer
+ # il doit normalement coincider avec le cas TAB_DEPL...
+ if inst==None:
+ cas = 'a_suppr'
+ else :
+ cas = 'normal'
+
+ if lev == 'sup' :
+ tabres = tabsup
+ elif lev == 'inf' :
+ if SYME_CHAR=='SANS' and not FISSURE :
+ tabres = tabinf
+ else :
+ return tab
+
+ if cas == 'normal' :
+
+ if inst ==0. :
+ crit = 'ABSOLU'
+ else :
+ crit = CRITERE
+
+ tab=tabres.INST.__eq__(VALE=inst,
+ CRITERE=crit,
+ PRECISION=PRECISION)
+ elif cas == 'a_suppr':
+
+ tab=tabres
+
+ return tab
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_propmat_tempe(MATER,tabtemp,Lnofon,ino,inst,PRECISION) :
+ """retourne les proprietes materiaux en fonction de la temperature à l'instant demandé"""
+ import numpy as NP
+ from math import pi
+
+ tempeno=tabtemp.NOEUD==Lnofon[ino]
+ tempeno=tempeno.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION)
+ nompar = ('TEMP',)
+ valpar = (tempeno.TEMP.values()[0],)
+ nomres=['E','NU']
+ valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F')
+ e = valres[0]
+ nu = valres[1]
+ coefd = e * NP.sqrt(2.*pi) / ( 8.0 * (1. - nu**2))
+ coefd3 = e*NP.sqrt(2*pi) / ( 8.0 * (1. + nu))
+ coefg = (1. - nu**2) / e
+ coefg3 = (1. + nu) / e
+
+ return (e,nu,coefd,coefd3,coefg,coefg3)
+#---------------------------------------------------------------------------------------------------------------
+
+def get_depl_sup(FISSURE,FOND_FISS,rmprec,RESULTAT,tabsupi,ndim,d_coor,Lnofon,ino) :
+ """retourne les déplacements sup"""
+
+ import numpy as NP
+ import copy
+ from Utilitai.Utmess import UTMESS
+
+ abscs = getattr(tabsupi,'ABSC_CURV').values()
+
+ if not FISSURE :
+ if not FOND_FISS :
+# cas a supprimer
+
+# on vérifie que les abscisses sont bien croissantes
+ refs=copy.copy(abscs)
+ refs.sort()
+ if refs!=abscs :
+ mctabl='TABL_DEPL_INF'
+ UTMESS('F','RUPTURE0_40',valk=mctabl)
+
+ refsc=[x for x in refs if x<rmprec]
+ nbval = len(refsc)
+ else :
+ nbval=len(abscs)
+
+ abscs=NP.array(abscs[:nbval])
+ coxs=NP.array(tabsupi['COOR_X'].values()['COOR_X'][:nbval])
+ coys=NP.array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval])
+ if ndim==2 :
+ cozs=NP.zeros(nbval)
+ elif ndim==3 :
+ cozs=NP.array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval])
+
+ if FOND_FISS and not RESULTAT :
+# assert (0 == 1)
+# tri des noeuds avec abscisse : a faire bien en amont !!!
+ Pfon = NP.array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]])
+ abscs = NP.sqrt((coxs-Pfon[0])**2+(coys-Pfon[1])**2+(cozs-Pfon[2])**2)
+ tabsupi['Abs_fo'] = abscs
+ tabsupi.sort('Abs_fo')
+ abscs = getattr(tabsupi,'Abs_fo').values()
+ abscs=NP.array(abscs[:nbval])
+ coxs=NP.array(tabsupi['COOR_X'].values()['COOR_X'][:nbval])
+ coys=NP.array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval])
+ if ndim==2 :
+ cozs=NP.zeros(nbval)
+ elif ndim==3 :
+ cozs=NP.array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval])
+
+ dxs=NP.array(tabsupi['DX'].values()['DX'][:nbval])
+ dys=NP.array(tabsupi['DY'].values()['DY'][:nbval])
+ if ndim==2 :
+ dzs=NP.zeros(nbval)
+ elif ndim==3 :
+ dzs=NP.array(tabsupi['DZ'].values()['DZ'][:nbval])
+
+# --- CAS FISSURE X-FEM ---
+ elif FISSURE :
+ H1 = getattr(tabsupi,'H1X').values()
+ nbval = len(H1)
+ H1 = complete(H1)
+ E1 = getattr(tabsupi,'E1X').values()
+ E1 = complete(E1)
+ dxs = 2*(H1 + NP.sqrt(abscs)*E1)
+ H1 = getattr(tabsupi,'H1Y').values()
+ E1 = getattr(tabsupi,'E1Y').values()
+ H1 = complete(H1)
+ E1 = complete(E1)
+ dys = 2*(H1 + NP.sqrt(abscs)*E1)
+ H1 = getattr(tabsupi,'H1Z').values()
+ E1 = getattr(tabsupi,'E1Z').values()
+ H1 = complete(H1)
+ E1 = complete(E1)
+ dzs = 2*(H1 + NP.sqrt(abscs)*E1)
+ abscs=NP.array(abscs[:nbval])
+
+ ds = NP.asarray([dxs,dys,dzs])
+
+ return (abscs,ds)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_depl_inf(FISSURE,FOND_FISS,rmprec,RESULTAT,tabinfi,ndim,d_coor,Lnofon,ino,SYME_CHAR) :
+ """retourne les déplacements inf"""
+ import numpy as NP
+ import copy
+ from Utilitai.Utmess import UTMESS
+
+ if SYME_CHAR=='SANS' and not FISSURE :
+ absci = getattr(tabinfi,'ABSC_CURV').values()
+ if not FOND_FISS :
+ refi=copy.copy(absci)
+ refi.sort()
+ if refi!=absci :
+ mctabl='TABL_DEPL_SUP'
+ UTMESS('F','RUPTURE0_40',valk=mctabl)
+ refic=[x for x in refi if x<rmprec]
+ nbval=len(refic)
+ else :
+ nbval=len(absci)
+
+ absci=NP.array(absci[:nbval])
+ coxi=NP.array(tabinfi['COOR_X'].values()['COOR_X'][:nbval])
+ coyi=NP.array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval])
+ if ndim==2 :
+ cozi=NP.zeros(nbval)
+ elif ndim==3 :
+ cozi=NP.array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval])
+
+# # --- ON VERIFIE QUE LES NOEUDS SONT EN VIS_A_VIS (SYME=SANS) ---
+# # verification a faire bien en amont !!!
+# if not FOND_FISS :
+# dist=(coxs-coxi)**2+(coys-coyi)**2+(cozs-cozi)**2
+# dist=NP.sqrt(dist)
+# for d in dist :
+# if d>precn : UTMESS('F','RUPTURE0_44')
+
+ if FOND_FISS and not RESULTAT :#tri des noeuds avec abscisse
+
+ Pfon = NP.array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]])
+ absci = NP.sqrt((coxi-Pfon[0])**2+(coyi-Pfon[1])**2+(cozi-Pfon[2])**2)
+ tabinfi['Abs_fo'] = absci
+ tabinfi.sort('Abs_fo')
+ absci = getattr(tabinfi,'Abs_fo').values()
+ absci=NP.array(absci[:nbval])
+ coxi=NP.array(tabinfi['COOR_X'].values()['COOR_X'][:nbval])
+ coyi=NP.array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval])
+ if ndim==2 :
+ cozi=NP.zeros(nbval)
+ elif ndim==3 :
+ cozi=NP.array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval],)
+
+ dxi=NP.array(tabinfi['DX'].values()['DX'][:nbval])
+ dyi=NP.array(tabinfi['DY'].values()['DY'][:nbval])
+ if ndim==2 :
+ dzi=NP.zeros(nbval)
+ elif ndim==3 :
+ dzi=NP.array(tabinfi['DZ'].values()['DZ'][:nbval])
+
+ di = NP.asarray([dxi,dyi,dzi])
+
+ else :
+
+ absci = []
+ di = []
+
+ return (absci,di)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_pgl(SYME_CHAR,FISSURE,VECT_K1,ino,VP,VN,tabsupi,tabinfi,nbval,ndim) :
+
+ """retourne la matrice du changement de repère"""
+ import numpy as NP
+#
+# 1 : VECTEUR NORMAL AU PLAN DE LA FISSURE
+# ORIENTE LEVRE INFERIEURE VERS LEVRE SUPERIEURE
+# 2 : VECTEUR NORMAL AU FOND DE FISSURE EN M
+# 3 : VECTEUR TANGENT AU FOND DE FISSURE EN M
+#
+ if FISSURE :
+ v1 = VN[ino]
+ v2 = VP[ino]
+
+ elif not FISSURE :
+
+# cette partie est a modifier car on devrait pas calculer la base tout le temps
+ coxs=NP.array(tabsupi['COOR_X'].values()['COOR_X'][:nbval])
+ coys=NP.array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval])
+ if ndim==2 :
+ cozs=NP.zeros(nbval)
+ elif ndim==3 :
+ cozs=NP.array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval])
+
+ v1 = NP.array(VECT_K1)
+ if SYME_CHAR=='SANS' :
+
+ coxi=NP.array(tabinfi['COOR_X'].values()['COOR_X'][:nbval])
+ coyi=NP.array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval])
+ if ndim==2 :
+ cozi=NP.zeros(nbval)
+ elif ndim==3 :
+ cozi=NP.array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval])
+
+ vo = NP.array([( coxs[-1]+coxi[-1] )/2.,( coys[-1]+coyi[-1] )/2.,( cozs[-1]+cozi[-1] )/2.])
+ ve = NP.array([( coxs[0 ]+coxi[0 ] )/2.,( coys[0 ]+coyi[0 ] )/2.,( cozs[0 ]+cozi[0 ] )/2.])
+ v2 = ve-vo
+ else :
+ vo = NP.array([ coxs[-1], coys[-1], cozs[-1]])
+ ve = NP.array([ coxs[0], coys[0], cozs[0]])
+ v2 = ve-vo
+
+ v2 = normalize(v2)
+
+ v1p = sum(v2*v1)
+
+ if SYME_CHAR=='SANS' :
+ v1 = v1-v1p*v2
+ else :
+ v2 = v2-v1p*v1
+
+ v1 = normalize(v1)
+ v2 = normalize(v2)
+ v3 = NP.cross(v1,v2)
+
+ pgl = NP.asarray([v1,v2,v3])
+
+ return pgl
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_saut(self,pgl,ds,di,INFO,FISSURE,SYME_CHAR,abscs,ndim) :
+
+ """retourne le saut de déplacements dans le nouveau repère"""
+
+ from Accas import _F
+ import aster
+ import numpy as NP
+ from Utilitai.Utmess import UTMESS
+
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+
+ dpls = NP.dot(pgl,ds)
+
+ if SYME_CHAR!='SANS' and abs(dpls[0][0]) > 1.e-10 :
+ UTMESS('A','RUPTURE0_49',valk=[Lnofon[ino],SYME_CHAR])
+
+ if FISSURE :
+ saut=dpls
+ elif SYME_CHAR=='SANS' :
+ dpli = NP.dot(pgl,di)
+ saut=(dpls-dpli)
+ else :
+ dpli = [NP.multiply(dpls[0],-1.),dpls[1],dpls[2]]
+ saut=(dpls-dpli)
+
+ if INFO==2 :
+ mcfact=[]
+ mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=abscs.tolist() ))
+ if not FISSURE :
+ mcfact.append(_F(PARA='DEPL_SUP_1',LISTE_R=dpls[0].tolist() ))
+ mcfact.append(_F(PARA='DEPL_INF_1',LISTE_R=dpli[0].tolist() ))
+ mcfact.append(_F(PARA='SAUT_1' ,LISTE_R=saut[0].tolist() ))
+ if not FISSURE :
+ mcfact.append(_F(PARA='DEPL_SUP_2',LISTE_R=dpls[1].tolist() ))
+ mcfact.append(_F(PARA='DEPL_INF_2',LISTE_R=dpli[1].tolist() ))
+ mcfact.append(_F(PARA='SAUT_2' ,LISTE_R=saut[1].tolist() ))
+ if ndim==3 :
+ if not FISSURE :
+ mcfact.append(_F(PARA='DEPL_SUP_3',LISTE_R=dpls[2].tolist() ))
+ mcfact.append(_F(PARA='DEPL_INF_3',LISTE_R=dpli[2].tolist() ))
+ mcfact.append(_F(PARA='SAUT_3' ,LISTE_R=saut[2].tolist() ))
+ __resu0=CREA_TABLE(LISTE=mcfact,TITRE='--> SAUTS')
+ aster.affiche('MESSAGE',__resu0.EXTR_TABLE().__repr__())
+ DETRUIRE(CONCEPT=_F(NOM=__resu0),INFO=1)
+
+ return saut
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_kgsig(saut,nbval,coefd,coefd3) :
+
+ """retourne des trucs...."""
+ import numpy as NP
+
+ isig=NP.sign(NP.transpose(NP.resize(saut[:,-1],(nbval-1,3))))
+ isig=NP.sign(isig+0.001)
+ saut2=saut*NP.array([[coefd]*nbval,[coefd]*nbval,[coefd3]*nbval])
+ saut2=saut2**2
+ ksig = isig[:,1]
+ ksig = NP.array([ksig,ksig])
+ ksig = NP.transpose(ksig)
+ kgsig= NP.resize(ksig,(1,6))[0]
+
+ return (isig,kgsig,saut2)
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_meth1(self,abscs,coefg,coefg3,kgsig,isig,saut2,INFO,ndim) :
+
+ """retourne kg1"""
+ from Accas import _F
+ import aster
+ import numpy as NP
+
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ nabs = len(abscs)
+ x1 = abscs[1:-1]
+ x2 = abscs[2:nabs]
+ y1 = saut2[:,1:-1]/x1
+ y2 = saut2[:,2:nabs]/x2
+ k = abs(y1-x1*(y2-y1)/(x2-x1))
+ g = coefg*(k[0]+k[1])+coefg3*k[2]
+ kg1 = [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])]
+ kg1 = NP.sqrt(kg1)*kgsig
+ kg1 = NP.concatenate([kg1,[max(g),min(g)]])
+ vk = NP.sqrt(k)*isig[:,:-1]
+ if INFO==2 :
+ mcfact=[]
+ mcfact.append(_F(PARA='ABSC_CURV_1' ,LISTE_R=x1.tolist() ))
+ mcfact.append(_F(PARA='ABSC_CURV_2' ,LISTE_R=x2.tolist() ))
+ mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0].tolist() ))
+ mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1].tolist() ))
+ if ndim==3 :
+ mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2].tolist() ))
+ mcfact.append(_F(PARA='G' ,LISTE_R=g.tolist() ))
+ __resu1=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 1')
+ aster.affiche('MESSAGE',__resu1.EXTR_TABLE().__repr__())
+ DETRUIRE(CONCEPT=_F(NOM=__resu1),INFO=1)
+
+ return kg1
+#---------------------------------------------------------------------------------------------------------------
+
+def get_meth2(self,abscs,coefg,coefg3,kgsig,isig,saut2,INFO,ndim) :
+
+ """retourne kg2"""
+ from Accas import _F
+ import aster
+ import numpy as NP
+
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ nabs = len(abscs)
+ x1 = abscs[1:nabs]
+ y1 = saut2[:,1:nabs]
+ k = abs(y1/x1)
+ g = coefg*(k[0]+k[1])+coefg3*k[2]
+ kg2= [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])]
+ kg2 = NP.sqrt(kg2)*kgsig
+ kg2= NP.concatenate([kg2,[max(g),min(g)]])
+ vk = NP.sqrt(k)*isig
+ if INFO==2 :
+ mcfact=[]
+ mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=x1.tolist() ))
+ mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0].tolist() ))
+ mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1].tolist() ))
+ if ndim==3 :
+ mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2].tolist() ))
+ mcfact.append(_F(PARA='G' ,LISTE_R=g.tolist() ))
+ __resu2=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 2')
+ aster.affiche('MESSAGE',__resu2.EXTR_TABLE().__repr__())
+ DETRUIRE(CONCEPT=_F(NOM=__resu2),INFO=1)
+
+ return kg2
+#---------------------------------------------------------------------------------------------------------------
+
+def get_meth3(self,abscs,coefg,coefg3,kgsig,isig,saut2,INFO,ndim) :
+
+ """retourne kg3"""
+ from Accas import _F
+ import aster
+ import numpy as NP
+
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+
+ nabs = len(abscs)
+ x1 = abscs[:-1]
+ x2 = abscs[1:nabs]
+ y1 = saut2[:,:-1]
+ y2 = saut2[:,1:nabs]
+ k = (NP.sqrt(y2)*NP.sqrt(x2)+NP.sqrt(y1)*NP.sqrt(x1))*(x2-x1)
+# attention, ici, il faut NP.sum et pas sum tout court
+ k = NP.sum(NP.transpose(k), axis=0)
+ de = abscs[-1]
+ vk = (k/de**2)*isig[:,0]
+ g = coefg*(vk[0]**2+vk[1]**2)+coefg3*vk[2]**2
+ kg3=NP.concatenate([[vk[0]]*2,[vk[1]]*2,[vk[2]]*2,[g]*2])
+ if INFO==2 :
+ mcfact=[]
+ mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0] ))
+ mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1] ))
+ if ndim==3 :
+ mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2] ))
+ mcfact.append(_F(PARA='G' ,LISTE_R=g ))
+ __resu3=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 3')
+ aster.affiche('MESSAGE',__resu3.EXTR_TABLE().__repr__())
+ DETRUIRE(CONCEPT=_F(NOM=__resu3),INFO=1)
+
+
+ return kg3
+
+#---------------------------------------------------------------------------------------------------------------
+
+def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord,
+ Lnofon,dicoF,absfon,Nnoff,tabout) :
+
+ """retourne la table de sortie"""
+ from Accas import _F
+ import aster
+ import numpy as NP
+
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ DETRUIRE = self.get_cmd('DETRUIRE')
+ CALC_TABLE = self.get_cmd('CALC_TABLE')
+
+
+ mcfact=[]
+
+ if TITRE != None :
+ titre = TITRE
+ else :
+ v = aster.__version__
+ titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K1_K2_K3 LE &DATE A &HEURE \n'%v
+
+ if FOND_FISS and MODELISATION=='3D':
+ mcfact.append(_F(PARA='NOEUD_FOND',LISTE_K=[Lnofon[ino],]*3))
+ mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[dicoF[Lnofon[ino]]]*3))
+
+ if FISSURE and MODELISATION=='3D':
+ mcfact.append(_F(PARA='PT_FOND',LISTE_I=[ino+1,]*3))
+ mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[absfon[ino],]*3))
+
+ if FISSURE and MODELISATION!='3D' and Nnoff!=1 :
+ mcfact.append(_F(PARA='PT_FOND',LISTE_I=[ino+1,]*3))
+
+ mcfact.append(_F(PARA='METHODE',LISTE_I=(1,2,3)))
+ mcfact.append(_F(PARA='K1_MAX' ,LISTE_R=kg[0].tolist() ))
+ mcfact.append(_F(PARA='K1_MIN' ,LISTE_R=kg[1].tolist() ))
+ mcfact.append(_F(PARA='K2_MAX' ,LISTE_R=kg[2].tolist() ))
+ mcfact.append(_F(PARA='K2_MIN' ,LISTE_R=kg[3].tolist() ))
+
+ if ndim==3 :
+ mcfact.append(_F(PARA='K3_MAX' ,LISTE_R=kg[4].tolist() ))
+ mcfact.append(_F(PARA='K3_MIN' ,LISTE_R=kg[5].tolist() ))
+
+ mcfact.append(_F(PARA='G_MAX' ,LISTE_R=kg[6].tolist() ))
+ mcfact.append(_F(PARA='G_MIN' ,LISTE_R=kg[7].tolist() ))
+
+ if (ino==0 and iord==0) and inst==None :
+ tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre)
+ 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)
+ else :
+ if inst!=None :
+ mcfact=[_F(PARA='INST' ,LISTE_R=[inst,]*3 )]+mcfact
+ __tabi=CREA_TABLE(LISTE=mcfact,)
+ npara = ['K1_MAX','METHODE']
+ if inst!=None :
+ npara.append('INST')
+ if FOND_FISS and MODELISATION=='3D' :
+ npara.append('NOEUD_FOND')
+
+ tabout=CALC_TABLE(reuse = tabout,
+ TABLE = tabout,
+ TITRE = titre,
+ ACTION=_F(OPERATION = 'COMB',
+ NOM_PARA = npara,
+ TABLE = __tabi,))
+
+ return tabout
+
+
+
+#---------------------------------------------------------------------------------------------------------------
+# 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,
TOUT_ORDRE,NUME_ORDRE,LIST_ORDRE,INST,LIST_INST,SYME_CHAR,
la fissure. Produit une table.
"""
import aster
- import string
- import copy
- import math
+ import string as S
import numpy as NP
from math import pi
from types import ListType, TupleType
from Accas import _F
from Utilitai.Table import Table, merge
- from SD.sd_l_charges import sd_l_charges
from SD.sd_mater import sd_compor1
EnumTypes = (ListType, TupleType)
macro = 'POST_K1_K2_K3'
- from Accas import _F
from Utilitai.Utmess import UTMESS
+
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# Le concept sortant (de type table_sdaster ou dérivé) est tab
self.DeclareOut('tabout', self.sd)
+ tabout=[]
+
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
- CREA_TABLE = self.get_cmd('CREA_TABLE')
- CALC_TABLE = self.get_cmd('CALC_TABLE')
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ CALC_TABLE = self.get_cmd('CALC_TABLE')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
- DETRUIRE = self.get_cmd('DETRUIRE')
- DEFI_GROUP = self.get_cmd('DEFI_GROUP')
- MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
-
+ DETRUIRE = self.get_cmd('DETRUIRE')
+ DEFI_GROUP = self.get_cmd('DEFI_GROUP')
+ MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
AFFE_MODELE = self.get_cmd('AFFE_MODELE')
- PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
-
+ PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
+
# ------------------------------------------------------------------
# CARACTERISTIQUES MATERIAUX
# ------------------------------------------------------------------
phenom=cmpt
break
if phenom==None : UTMESS('F','RUPTURE0_5')
-# --- RECHERCHE SI LE MATERIAU DEPEND DE LA TEMPERATURE:
+
+# RECHERCHE SI LE MATERIAU DEPEND DE LA TEMPERATURE:
compor = sd_compor1('%-8s.%s' % (MATER.nom, phenom))
valk = [s.strip() for s in compor.VALK.get()]
valr = compor.VALR.get()
dicmat=dict(zip(valk,valr))
-# --- PROPRIETES MATERIAUX DEPENDANTES DE LA TEMPERATURE
+
+# PROPRIETES MATERIAUX DEPENDANTES DE LA TEMPERATURE
Tempe3D = False
if FOND_FISS and args['EVOL_THER'] :
-# on recupere juste le nom du resultat thermique (la température est variable de commande)
+# on recupere juste le nom du resultat thermique (la température est variable de commande)
ndim = 3
Tempe3D=True
- resuth=string.ljust(args['EVOL_THER'].nom,8).rstrip()
+ resuth=S.ljust(args['EVOL_THER'].nom,8).rstrip()
+
if dicmat.has_key('TEMP_DEF') and not args['EVOL_THER'] :
nompar = ('TEMP',)
valpar = (dicmat['TEMP_DEF'],)
else :
UTMESS('F','RUPTURE0_10')
+ assert (ndim == 2 or ndim == 3)
+
+ try :
+ TYPE_MAILLAGE = args['TYPE_MAILLAGE']
+ except KeyError :
+ TYPE_MAILLAGE = []
+
+
+ rmprec = ABSC_CURV_MAXI*(1.+PREC_VIS_A_VIS/10.)
+ precn = PREC_VIS_A_VIS * ABSC_CURV_MAXI
+
+
+# ------------------------------------------------------------------
+# I. CAS FOND_FISS
+# ------------------------------------------------------------------
-# ------------------------------------------------------------------
-# CAS FOND_FISS
-# ------------------------------------------------------------------
if FOND_FISS :
+
MAILLAGE = args['MAILLAGE']
- NOEUD = args['NOEUD']
- SANS_NOEUD = args['SANS_NOEUD']
- GROUP_NO = args['GROUP_NO']
- SANS_GROUP_NO = args['SANS_GROUP_NO']
- TOUT = args['TOUT']
- TYPE_MAILLAGE = args['TYPE_MAILLAGE']
NB_NOEUD_COUPE = args['NB_NOEUD_COUPE']
- if NB_NOEUD_COUPE ==None : NB_NOEUD_COUPE = 5
- LNOFO = FOND_FISS.FOND_______NOEU.get()
- RECOL = False
-# Cas double fond de fissure : par convention les noeuds sont ceux de fond_inf
- if LNOFO==None :
- RECOL = True
- LNOFO = FOND_FISS.FONDINF____NOEU.get()
- if LNOFO==None : UTMESS('F','RUPTURE0_11')
- LNOFO = map(string.rstrip,LNOFO)
- Nbfond = len(LNOFO)
- if MODELISATION=='3D' :
-# ----------Mots cles TOUT, NOEUD, SANS_NOEUD -------------
- Typ = FOND_FISS.FOND_______TYPE.get()
- if (Typ[0]=='SEG2 ') or (Typ[0]=='SEG3 ' and TOUT=='OUI') :
- pas = 1
- elif (Typ[0]=='SEG3 ') :
- pas = 2
- else :
- UTMESS('F','RUPTURE0_12')
-####
- NO_SANS = []
- NO_AVEC = []
- if GROUP_NO!=None :
- collgrno = MAILLAGE.GROUPENO.get()
- cnom = MAILLAGE.NOMNOE.get()
- if type(GROUP_NO) not in EnumTypes : GROUP_NO = (GROUP_NO,)
- for m in range(len(GROUP_NO)) :
- ngrno=GROUP_NO[m].ljust(8).upper()
- if ngrno not in collgrno.keys() :
- UTMESS('F','RUPTURE0_13',valk=ngrno)
- for i in range(len(collgrno[ngrno])) : NO_AVEC.append(cnom[collgrno[ngrno][i]-1])
- NO_AVEC= map(string.rstrip,NO_AVEC)
- if NOEUD!=None :
- if type(NOEUD) not in EnumTypes : NO_AVEC = (NOEUD,)
- else : NO_AVEC = NOEUD
- if SANS_GROUP_NO!=None :
- collgrno = MAILLAGE.GROUPENO.get()
- cnom = MAILLAGE.NOMNOE.get()
- if type(SANS_GROUP_NO) not in EnumTypes : SANS_GROUP_NO = (SANS_GROUP_NO,)
- for m in range(len(SANS_GROUP_NO)) :
- ngrno=SANS_GROUP_NO[m].ljust(8).upper()
- if ngrno not in collgrno.keys() :
- UTMESS('F','RUPTURE0_13',valk=ngrno)
- for i in range(len(collgrno[ngrno])) : NO_SANS.append(cnom[collgrno[ngrno][i]-1])
- NO_SANS= map(string.rstrip,NO_SANS)
- if SANS_NOEUD!=None :
- if type(SANS_NOEUD) not in EnumTypes : NO_SANS = (SANS_NOEUD,)
- else : NO_SANS = SANS_NOEUD
-# Creation de la liste des noeuds du fond a traiter : Lnf1
- Lnf1 = []
- Nbf1 = 0
- if len(NO_AVEC)!=0 :
- for i in range(len(NO_AVEC)) :
- if NO_AVEC[i] in LNOFO :
- Lnf1.append(NO_AVEC[i])
- Nbf1 = Nbf1 +1
- else :
- UTMESS('F','RUPTURE0_15',valk=NO_AVEC[i])
- else :
- for i in range(0,Nbfond,pas) :
- if not (LNOFO[i] in NO_SANS) :
- Lnf1.append(LNOFO[i])
- Nbf1 = Nbf1 +1
- else :
- Lnf1 = LNOFO
- Nbf1 = 1
+# Verification du type des mailles de FOND_FISS
+# ---------------------------------------------
+
+ verif_type_fond_fiss(ndim,FOND_FISS)
+
+# Recuperation de la liste des noeuds du fond issus de la sd_fond_fiss : Lnoff, de longueur Nnoff
+# ------------------------------------------------------------------------------------------------
+
+ Lnoff = get_noeud_fond_fiss(FOND_FISS)
+ Nnoff = len(Lnoff)
+
+# Creation de la liste des noeuds du fond a calculer : Lnocal, de longueur Nnocal
+# (obtenue par restriction de Lnoff avec TOUT, NOEUD, SANS_NOEUD)
+# ----------------------------------------------------------------------------
+
+ Lnocal = get_noeud_a_calculer(Lnoff,ndim,FOND_FISS,MAILLAGE,EnumTypes,args)
+ Nnocal = len(Lnocal)
-##### Cas maillage libre###########
-# creation des directions normales et macr_lign_coup
+# ------------------------------------------------------------------
+# I.1 SOUS-CAS MAILLAGE LIBRE
+# ------------------------------------------------------------------
+
+# creation des directions normales et macr_lign_coup
if TYPE_MAILLAGE =='LIBRE':
- if not RESULTAT : UTMESS('F','RUPTURE0_16')
- Lnofon = Lnf1
- Nbnofo = Nbf1
- ListmaS = FOND_FISS.LEVRESUP___MAIL.get()
- if ListmaS==None : UTMESS('F','RUPTURE0_19')
- if SYME_CHAR=='SANS':
- ListmaI = FOND_FISS.LEVREINF___MAIL.get()
- __NCOFON=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds du fond',
- NOEUD=LNOFO,
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',),
- OPERATION='EXTRACTION',),);
- tcoorf=__NCOFON.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=__NCOFON),INFO=1)
- nbt = len(tcoorf['NOEUD'].values()['NOEUD'])
- xs=NP.array(tcoorf['COOR_X'].values()['COOR_X'][:nbt])
- ys=NP.array(tcoorf['COOR_Y'].values()['COOR_Y'][:nbt])
- if ndim==2 : zs=NP.zeros(nbt)
- elif ndim==3 : zs=NP.array(tcoorf['COOR_Z'].values()['COOR_Z'][:nbt])
- ns = tcoorf['NOEUD'].values()['NOEUD'][:nbt]
- ns = map(string.rstrip,ns)
- l_coorf = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)]
- l_coorf = [(i[0],i[1:]) for i in l_coorf]
- d_coorf = dict(l_coorf)
-# Coordonnee d un pt quelconque des levres pr determination sens de propagation
- cmail=MAILLAGE.NOMMAI.get()
- for i in range(len(cmail)) :
- if cmail[i] == ListmaS[0] : break
- colcnx=MAILLAGE.CONNEX.get()
- cnom = MAILLAGE.NOMNOE.get()
- NO_TMP = []
- for k in range(len(colcnx[i+1])) : NO_TMP.append(cnom[colcnx[i+1][k]-1])
- __NCOLEV=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees pt levre',
- NOEUD = NO_TMP,
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',),
- OPERATION='EXTRACTION',),);
- tcoorl=__NCOLEV.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=__NCOLEV),INFO=1)
- nbt = len(tcoorl['NOEUD'].values()['NOEUD'])
- xl=moy(tcoorl['COOR_X'].values()['COOR_X'][:nbt])
- yl=moy(tcoorl['COOR_Y'].values()['COOR_Y'][:nbt])
- zl=moy(tcoorl['COOR_Z'].values()['COOR_Z'][:nbt])
- Plev = NP.array([xl, yl, zl])
-# Calcul des normales a chaque noeud du fond
- v1 = NP.array(VECT_K1)
- VN = [None]*Nbfond
- absfon = [0,]
- if MODELISATION=='3D' :
- DTANOR = FOND_FISS.DTAN_ORIGINE.get()
- Pfon2 = NP.array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]])
- VLori = Pfon2 - Plev
- if DTANOR != None :
- VN[0] = NP.array(DTANOR)
- else :
- Pfon3 = NP.array([d_coorf[LNOFO[1]][0],d_coorf[LNOFO[1]][1],d_coorf[LNOFO[1]][2]])
- VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
- VN[0] = NP.array(cross_product(VT,v1))
- for i in range(1,Nbfond-1):
- Pfon1 = NP.array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]])
- Pfon2 = NP.array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]])
- Pfon3 = NP.array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]])
- absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
- absfon.append(absf)
- VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
- VT = VT+(Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
- VN[i] = NP.array(cross_product(VT,v1))
- VN[i] = VN[i]/NP.sqrt(NP.dot(NP.transpose(VN[i]),VN[i]))
- i = Nbfond-1
- Pfon1 = NP.array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]])
- Pfon2 = NP.array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]])
- VLextr = Pfon2 - Plev
- absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
- absfon.append(absf)
- DTANEX = FOND_FISS.DTAN_EXTREMITE.get()
- if DTANEX != None :
- VN[i] = NP.array(DTANEX)
- else :
- VT = (Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
- VN[i] = NP.array(cross_product(VT,v1))
- dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)])
- dicVN = dict([(LNOFO[i],VN[i]) for i in range(Nbfond)])
-#Sens de la tangente
- v = cross_product(VLori,VLextr)
- sens = NP.sign(NP.dot(NP.transpose(v),v1))
-#Cas 2D
- if MODELISATION!='3D' :
- DTANOR = False
- DTANEX = False
- VT = NP.array([0.,0.,1.])
- VN = NP.array(cross_product(v1,VT))
- dicVN = dict([(LNOFO[0],VN)])
- Pfon = NP.array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]])
- VLori = Pfon - Plev
- sens = NP.sign(NP.dot(NP.transpose(VN),VLori))
-#Extraction dep sup/inf sur les normales
- TlibS = [None]*Nbf1
- TlibI = [None]*Nbf1
- if NB_NOEUD_COUPE < 3 :
- UTMESS('A','RUPTURE0_17')
- NB_NOEUD_COUPE = 5
- iret,ibid,n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT')
- n_modele=n_modele.rstrip()
- if len(n_modele)==0 : UTMESS('F','RUPTURE0_18')
- MODEL = self.get_concept(n_modele)
- dmax = PREC_VIS_A_VIS * ABSC_CURV_MAXI
- for i in range(Nbf1):
- Porig = NP.array(d_coorf[Lnf1[i]] )
- if Lnf1[i]==LNOFO[0] and DTANOR : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]
- elif Lnf1[i]==LNOFO[Nbfond-1] and DTANEX : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]
- else : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]*sens
- TlibS[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',MODELE=MODEL, VIS_A_VIS=_F(MAILLE_1 = ListmaS),
- LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
- TYPE='SEGMENT', COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
- DISTANCE_MAX=dmax),);
- if SYME_CHAR=='SANS':
- TlibI[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',MODELE=MODEL, VIS_A_VIS=_F(MAILLE_1 = ListmaI),
- LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
- TYPE='SEGMENT',COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
- DISTANCE_MAX=dmax),);
+
+ if not RESULTAT :
+ UTMESS('F','RUPTURE0_16')
+
+ ListmaS = FOND_FISS.LEVRESUP___MAIL.get()
+
+ if not ListmaS :
+ UTMESS('F','RUPTURE0_19')
+
+ if SYME_CHAR == 'SANS':
+ ListmaI = FOND_FISS.LEVREINF___MAIL.get()
+
+# Dictionnaire des coordonnees des noeuds du fond
+ 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)
+
+# Calcul des normales a chaque noeud du fond
+ if ndim == 3 :
+ DTANOR = FOND_FISS.DTAN_ORIGINE.get()
+ DTANEX = FOND_FISS.DTAN_EXTREMITE.get()
+ elif ndim ==2 :
+ DTANOR = False
+ DTANEX = False
+ (dicVN, dicoF, sens) = get_normale(VECT_K1,Nnoff,ndim,DTANOR,DTANEX,d_coorf,Lnoff,Plev)
+# Extraction dep sup/inf sur les normales
+ iret,ibid,n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT')
+ n_modele=n_modele.rstrip()
+ if len(n_modele)==0 :
+ UTMESS('F','RUPTURE0_18')
+ 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,
+ ListmaS,ListmaI,NB_NOEUD_COUPE,dmax,SYME_CHAR)
+
+
+
+# A eclaircir
+ Lnofon = Lnocal
+ Nbnofo = Nnocal
+
+# ------------------------------------------------------------------
+# I.2 SOUS-CAS MAILLAGE REGLE
+# ------------------------------------------------------------------
-##### Cas maillage regle###########
else:
-# ---------- Dictionnaires des levres -------------
- NnormS = FOND_FISS.SUPNORM____NOEU.get()
- if NnormS==None :
- UTMESS('F','RUPTURE0_19')
- NnormS = map(string.rstrip,NnormS)
- if LNOFO[0]==LNOFO[-1] and MODELISATION=='3D' : Nbfond=Nbfond-1 # Cas fond de fissure ferme
- NnormS = [[LNOFO[i],NnormS[i*20:(i+1)*20]] for i in range(0,Nbfond)]
- NnormS = [(i[0],i[1][0:]) for i in NnormS]
- dicoS = dict(NnormS)
- if SYME_CHAR=='SANS':
- NnormI = FOND_FISS.INFNORM____NOEU.get()
- if NnormI==None :
- UTMESS('F','RUPTURE0_20')
- NnormI = map(string.rstrip,NnormI)
- NnormI = [[LNOFO[i],NnormI[i*20:(i+1)*20]] for i in range(0,Nbfond)]
- NnormI = [(i[0],i[1][0:]) for i in NnormI]
- dicoI = dict(NnormI)
-
-# ---------- Dictionnaire des coordonnees -------------
- if RESULTAT :
- Ltot = LNOFO
- for i in range(Nbf1) :
- for k in range(0,20) :
- if dicoS[Lnf1[i]][k] !='': Ltot.append(dicoS[Lnf1[i]][k])
- if SYME_CHAR=='SANS':
- for i in range(Nbf1) :
- for k in range(0,20) :
- if dicoI[Lnf1[i]][k] !='': Ltot.append(dicoI[Lnf1[i]][k])
- Ltot=dict([(i,0) for i in Ltot]).keys()
- __NCOOR=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds des levres',
- NOEUD=Ltot,
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',),
- OPERATION='EXTRACTION',),);
- tcoor=__NCOOR.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1)
- else :
- if SYME_CHAR=='SANS':
- __NCOOR=CALC_TABLE(TABLE=TABL_DEPL_SUP,
- ACTION=_F(OPERATION = 'COMB',NOM_PARA='NOEUD',TABLE=TABL_DEPL_INF,))
- tcoor=__NCOOR.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1)
- else :
- tcoor=TABL_DEPL_SUP.EXTR_TABLE()
- nbt = len(tcoor['NOEUD'].values()['NOEUD'])
- xs=NP.array(tcoor['COOR_X'].values()['COOR_X'][:nbt])
- ys=NP.array(tcoor['COOR_Y'].values()['COOR_Y'][:nbt])
- if ndim==2 : zs=NP.zeros(nbt)
- elif ndim==3 : zs=NP.array(tcoor['COOR_Z'].values()['COOR_Z'][:nbt])
- ns = tcoor['NOEUD'].values()['NOEUD'][:nbt]
- ns = map(string.rstrip,ns)
- l_coor = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)]
- l_coor = [(i[0],i[1:]) for i in l_coor]
- d_coor = dict(l_coor)
-
-# ---------- Abscisse curviligne du fond -------------
- absfon = [0,]
- for i in range(Nbfond-1) :
- Pfon1 = NP.array([d_coor[LNOFO[i]][0],d_coor[LNOFO[i]][1],d_coor[LNOFO[i]][2]])
- Pfon2 = NP.array([d_coor[LNOFO[i+1]][0],d_coor[LNOFO[i+1]][1],d_coor[LNOFO[i+1]][2]])
- absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i]
- absfon.append(absf)
- dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)])
+# Dictionnaires des levres
+ dicoS = get_dico_levres('sup',FOND_FISS,ndim,Lnoff,Nnoff)
+ dicoI= {}
+ if SYME_CHAR=='SANS':
+ dicoI = get_dico_levres('inf',FOND_FISS,ndim,Lnoff,Nnoff)
+
+# Dictionnaire des coordonnees
+ d_coor = get_coor_regle(self,RESULTAT,ndim,Lnoff,Lnocal,dicoS,SYME_CHAR,dicoI,TABL_DEPL_SUP,TABL_DEPL_INF)
+
+# Abscisse curviligne du fond
+ dicoF = get_absfon(Lnoff,Nnoff,d_coor)
+
+# Noeuds LEVRE_SUP et LEVRE_INF
+ (Lnofon, Lnosup, Lnoinf) = get_noeuds_perp_regle(Lnocal,d_coor,dicoS,dicoI,Lnoff,
+ PREC_VIS_A_VIS,ABSC_CURV_MAXI,SYME_CHAR,rmprec,precn)
+ Nbnofo = len(Lnofon)
+
+# ------------------------------------------------------------------
+# II. CAS X-FEM
+# ------------------------------------------------------------------
-
-# ---Noeuds LEVRE_SUP et LEVRE_INF: ABSC_CURV_MAXI et PREC_VIS_A_VIS-----
-
- NBTRLS = 0
- NBTRLI = 0
- Lnosup = [None]*Nbf1
- Lnoinf = [None]*Nbf1
- Nbnofo = 0
- Lnofon = []
- precv = PREC_VIS_A_VIS
- if ABSC_CURV_MAXI!=None : rmax = ABSC_CURV_MAXI
- else : rmax = 100
- precn = precv * rmax
- rmprec= rmax*(1.+precv/10.)
- for i in range(0,Nbf1) :
- Pfon = NP.array([d_coor[Lnf1[i]][0],d_coor[Lnf1[i]][1],d_coor[Lnf1[i]][2]])
- Tmpsup = []
- Tmpinf = []
- itots = 0
- itoti = 0
- NBTRLS = 0
- NBTRLI = 0
- for k in range(0,20) :
- if dicoS[Lnf1[i]][k] !='':
- itots = itots +1
- Nsup = dicoS[Lnf1[i]][k]
- Psup = NP.array([d_coor[Nsup][0],d_coor[Nsup][1],d_coor[Nsup][2]])
- abss = NP.sqrt(NP.dot(NP.transpose(Pfon-Psup),Pfon-Psup))
- if abss<rmprec :
- NBTRLS = NBTRLS +1
- Tmpsup.append(dicoS[Lnf1[i]][k])
- if SYME_CHAR=='SANS':
- if dicoI[Lnf1[i]][k] !='':
- itoti = itoti +1
- Ninf = dicoI[Lnf1[i]][k]
- Pinf = NP.array([d_coor[Ninf][0],d_coor[Ninf][1],d_coor[Ninf][2]])
- absi = NP.sqrt(NP.dot(NP.transpose(Pfon-Pinf),Pfon-Pinf))
-# On verifie que les noeuds sont en vis a vis
- if abss<rmprec :
- dist = NP.sqrt(NP.dot(NP.transpose(Psup-Pinf),Psup-Pinf))
- if dist>precn :
- UTMESS('A','RUPTURE0_21',valk=Lnf1[i])
- else :
- NBTRLI = NBTRLI +1
- Tmpinf.append(dicoI[Lnf1[i]][k])
-# On verifie qu il y a assez de noeuds
- if NBTRLS < 3 :
- UTMESS('A+','RUPTURE0_22',valk=Lnf1[i])
- if Lnf1[i]==LNOFO[0] or Lnf1[i]==LNOFO[-1]: UTMESS('A+','RUPTURE0_23')
- if itots<3 : UTMESS('A','RUPTURE0_24')
- else : UTMESS('A','RUPTURE0_25')
- elif (SYME_CHAR=='SANS') and (NBTRLI < 3) :
- UTMESS('A+','RUPTURE0_26',valk=Lnf1[i])
- if Lnf1[i]==LNOFO[0] or Lnf1[i]==LNOFO[-1]: UTMESS('A+','RUPTURE0_23')
- if itoti<3 : UTMESS('A','RUPTURE0_24')
- else :UTMESS('A','RUPTURE0_25')
-# UTMESS('A','RUPTURE0_23')
- else :
- Lnosup[Nbnofo] = Tmpsup
- if SYME_CHAR=='SANS' : Lnoinf[Nbnofo] = Tmpinf
- Lnofon.append(Lnf1[i])
- Nbnofo = Nbnofo+1
- if Nbnofo == 0 :
- UTMESS('F','RUPTURE0_30')
-
-#------------- Cas X-FEM ---------------------------------
elif FISSURE :
- MAILLAGE = args['MAILLAGE']
- DTAN_ORIG = args['DTAN_ORIG']
- DTAN_EXTR = args['DTAN_EXTR']
- dmax = PREC_VIS_A_VIS * ABSC_CURV_MAXI
-#Projection du resultat sur le maillage lineaire initial
- iret,ibid,n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT')
- n_modele=n_modele.rstrip()
- if len(n_modele)==0 : UTMESS('F','RUPTURE0_18')
- MODEL = self.get_concept(n_modele)
- xcont = MODEL.xfem.XFEM_CONT.get()
- if xcont[0] == 0 :
- __RESX = RESULTAT
-# Si XFEM + contact : il faut reprojeter sur le maillage lineaire
- if xcont[0] != 0 :
- __MODLINE=AFFE_MODELE(MAILLAGE=MAILLAGE,
- AFFE=(_F(TOUT='OUI',
- PHENOMENE='MECANIQUE',
- MODELISATION=MODELISATION,),),);
- __RESX=PROJ_CHAMP(METHODE='ELEM',TYPE_CHAM='NOEU',NOM_CHAM='DEPL',
- RESULTAT=RESULTAT,
- MODELE_1=MODEL,
- MODELE_2=__MODLINE, );
-#Recuperation des coordonnees des points du fond de fissure (x,y,z,absc_curv)
- Listfo = FISSURE.FONDFISS.get()
- Basefo = FISSURE.BASEFOND.get()
- NB_POINT_FOND = args['NB_POINT_FOND']
-#Traitement du cas fond multiple
- Fissmult = FISSURE.FONDMULT.get()
- Nbfiss = len(Fissmult)/2
- Numfiss = args['NUME_FOND']
- if Numfiss <= Nbfiss and Nbfiss > 1 :
- Ptinit = Fissmult[2*(Numfiss-1)]
- Ptfin = Fissmult[2*(Numfiss-1)+1]
- Listfo2 = Listfo[((Ptinit-1)*4):(Ptfin*4)]
- Listfo = Listfo2
- Basefo2 = Basefo[((Ptinit-1)*(2*ndim)):(Ptfin*(2*ndim))]
- Basefo = Basefo2
- elif Numfiss > Nbfiss :
- UTMESS('F','RUPTURE1_38',vali=[Nbfiss,Numfiss])
-####
-
- if NB_POINT_FOND != None and MODELISATION=='3D' :
- Nbfond = NB_POINT_FOND
- absmax = Listfo[-1]
- Coorfo = [None]*4*Nbfond
- Vpropa = [None]*3*Nbfond
- for i in range(0,Nbfond) :
- absci = i*absmax/(Nbfond-1)
- Coorfo[(4*i):(4*(i+1))] = InterpolFondFiss(absci, Listfo)
- Vpropa[(6*i):(6*(i+1))] = InterpolBaseFiss(absci,Basefo, Listfo)
- else :
- Coorfo = Listfo
- Vpropa = Basefo
- Nbfond = len(Coorfo)/4
-# Calcul de la direction de propagation en chaque point du fond
- VP = [None]*Nbfond
- VN = [None]*Nbfond
- absfon = [0,]
-# Cas fissure non necessairement plane
- if VECT_K1 == None :
- i = 0
- if MODELISATION=='3D' :
- if DTAN_ORIG != None :
- VP[0] = NP.array(DTAN_ORIG)
- VP[0] = VP[0]/NP.sqrt(VP[0][0]**2+VP[0][1]**2+VP[0][2]**2)
- VN[0] = NP.array([Vpropa[0],Vpropa[1],Vpropa[2]])
- verif = NP.dot(NP.transpose(VP[0]),VN[0])
- if abs(verif) > 0.01:
- UTMESS('A','RUPTURE1_33',valr=[VN[0][0],VN[0][1],VN[0][2]])
- else :
- VN[0] = NP.array([Vpropa[0],Vpropa[1],Vpropa[2]])
- VP[0] = NP.array([Vpropa[3+0],Vpropa[3+1],Vpropa[3+2]])
- for i in range(1,Nbfond-1):
- absf = Coorfo[4*i+3]
- absfon.append(absf)
- VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
- VP[i] = NP.array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]])
- verif = NP.dot(NP.transpose(VN[i]),VN[i-1])
- if abs(verif) < 0.98:
- UTMESS('A','RUPTURE1_35',vali=[i-1,i])
- i = Nbfond-1
- absf = Coorfo[4*i+3]
- absfon.append(absf)
- if DTAN_EXTR != None :
- VP[i] = NP.array(DTAN_EXTR)
- VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
- verif = NP.dot(NP.transpose(VP[i]),VN[0])
- if abs(verif) > 0.01:
- UTMESS('A','RUPTURE1_34',valr=[VN[i][0],VN[i][1],VN[i][2]])
- else :
- VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
- VP[i] = NP.array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]])
- else :
- for i in range(0,Nbfond):
- VP[i] = NP.array([Vpropa[2+4*i],Vpropa[3+4*i],0.])
- VN[i] = NP.array([Vpropa[0+4*i],Vpropa[1+4*i],0.])
-# Cas fissure plane (VECT_K1 donne)
- if VECT_K1 != None :
- v1 = NP.array(VECT_K1)
- v1 = v1/NP.sqrt(v1[0]**2+v1[1]**2+v1[2]**2)
- v1 = NP.array(VECT_K1)
- i = 0
- if MODELISATION=='3D' :
-# Sens du vecteur VECT_K1
- v1x =NP.array([Vpropa[0],Vpropa[1],Vpropa[2]])
- verif = NP.dot(NP.transpose(v1),v1x)
- if verif < 0 : v1 = -v1
- VN = [v1]*Nbfond
- if DTAN_ORIG != None :
- VP[i] = NP.array(DTAN_ORIG)
- VP[i] = VP[i]/NP.sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2)
- verif = NP.dot(NP.transpose(VP[i]),VN[0])
- if abs(verif) > 0.01:
- UTMESS('A','RUPTURE1_36')
- else :
- Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
- Pfon3 = NP.array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]])
- VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
- VP[0] = NP.array(cross_product(VT,v1))
- VNi = NP.array([Vpropa[3],Vpropa[4],Vpropa[5]])
- verif = NP.dot(NP.transpose(VP[i]),VNi)
- if abs(verif) < 0.99:
- vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
- UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
- for i in range(1,Nbfond-1):
- Pfon1 = NP.array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]])
- Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
- Pfon3 = NP.array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]])
- absf = Coorfo[4*i+3]
- absfon.append(absf)
- VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2))
- VT = VT+(Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
- VP[i] = NP.array(cross_product(VT,v1))
- VP[i] = VP[i]/NP.sqrt(NP.dot(NP.transpose(VP[i]),VP[i]))
- VNi = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
- verif = NP.dot(NP.transpose(VN[i]),VNi)
- if abs(verif) < 0.99:
- vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
- UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
- i = Nbfond-1
- Pfon1 = NP.array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]])
- Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
- absf = Coorfo[4*i+3]
- absfon.append(absf)
- if DTAN_EXTR != None :
- VP[i] = NP.array(DTAN_EXTR)
- VP[i] = VP[i]/NP.sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2)
- verif = NP.dot(NP.transpose(VP[i]),VN[i])
- if abs(verif) > 0.01:
- UTMESS('A','RUPTURE1_37')
- else :
- VT = (Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1))
- VP[i] = NP.array(cross_product(VT,v1))
- VNi = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
- verif = NP.dot(NP.transpose(VN[i]),VNi)
- if abs(verif) < 0.99 :
- vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
- UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
- else :
- VT = NP.array([0.,0.,1.])
- for i in range(0,Nbfond):
- VP[i] = NP.array(cross_product(v1,VT))
- VN[i] = v1
- VNi = NP.array([Vpropa[0+4*i],Vpropa[1+4*i],0.])
- verif = NP.dot(NP.transpose(VN[i]),VNi)
- if abs(verif) < 0.99 :
- vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
- UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
-#Sens de la tangente
- if MODELISATION=='3D' : i = Nbfond/2
- else : i = 0
- Po = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
- Porig = Po + ABSC_CURV_MAXI*VP[i]
- Pextr = Po - ABSC_CURV_MAXI*VP[i]
- __Tabg = MACR_LIGN_COUPE(RESULTAT=__RESX,NOM_CHAM='DEPL',
- LIGN_COUPE=_F(NB_POINTS=3,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
- TYPE='SEGMENT',COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
- DISTANCE_MAX=dmax),);
- tmp=__Tabg.EXTR_TABLE()
-# a sam
- test = getattr(tmp,'H1X').values()
-# test = getattr(tmp,'E1X').values()
- if test==[None]*3 :
- UTMESS('F','RUPTURE0_33')
- if test[0]!=None :
- sens = 1
- else :
- sens = -1
- DETRUIRE(CONCEPT=_F(NOM=__Tabg),INFO=1)
-# Extraction des sauts sur la fissure
- NB_NOEUD_COUPE = args['NB_NOEUD_COUPE']
- if NB_NOEUD_COUPE < 3 :
- UTMESS('A','RUPTURE0_34')
- NB_NOEUD_COUPE = 5
- mcfact=[]
- for i in range(Nbfond):
- Porig = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
- if i==0 and DTAN_ORIG!=None : Pextr = Porig - ABSC_CURV_MAXI*VP[i]
- elif i==(Nbfond-1) and DTAN_EXTR!=None : Pextr = Porig - ABSC_CURV_MAXI*VP[i]
- else : Pextr = Porig + ABSC_CURV_MAXI*VP[i]*sens
- mcfact.append(_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
- TYPE='SEGMENT',COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
- DISTANCE_MAX=dmax),)
- TSo = MACR_LIGN_COUPE(RESULTAT=__RESX,NOM_CHAM='DEPL',
- LIGN_COUPE=mcfact);
-
- TTSo = TSo.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=TSo),INFO=1)
- Nbnofo = Nbfond
- if xcont[0] != 0 :
- DETRUIRE(CONCEPT=_F(NOM=__MODLINE),INFO=1)
- DETRUIRE(CONCEPT=_F(NOM=__RESX),INFO=1)
+
+ MAILLAGE = args['MAILLAGE']
+ DTAN_ORIG = args['DTAN_ORIG']
+ DTAN_EXTR = args['DTAN_EXTR']
+ dmax = PREC_VIS_A_VIS * ABSC_CURV_MAXI
+
+ (xcont,MODEL) = verif_resxfem(self,RESULTAT)
+ # incohérence entre le modèle et X-FEM
+ if not xcont :
+ UTMESS('F','RUPTURE0_4')
+
+# Recuperation du resultat
+ __RESX = get_resxfem(self,xcont,RESULTAT,MAILLAGE,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)
+
+# Calcul de la direction de propagation en chaque point du fond
+ (VP,VN,absfon) = get_direction_xfem(Nnoff,Vpropa,Coorfo,VECT_K1,DTAN_ORIG,DTAN_EXTR,ndim)
+
+# Sens de la tangente
+ sens = get_sens_tangente_xfem(self,ndim,Nnoff,Coorfo,VP,ABSC_CURV_MAXI,__RESX,dmax)
+
+# Extraction des sauts sur la fissure
+ NB_NOEUD_COUPE = args['NB_NOEUD_COUPE']
+ TTSo = get_sauts_xfem(self,Nnoff,Coorfo,VP,sens,
+ DTAN_ORIG,DTAN_EXTR,ABSC_CURV_MAXI,NB_NOEUD_COUPE,dmax,__RESX)
+
+ Lnofon = []
+ Nbnofo = Nnoff
+
+# menage du resultat projete si contact
+ if xcont[0] != 0 :
+ DETRUIRE(CONCEPT=_F(NOM=__RESX),INFO=1)
- if INFO==2 :
- mcfact=[]
- mcfact.append(_F(PARA='PT_FOND',LISTE_I=range(Nbfond)))
- mcfact.append(_F(PARA='VN_X' ,LISTE_R=[VN[i][0] for i in range(Nbfond)]))
- mcfact.append(_F(PARA='VN_Y' ,LISTE_R=[VN[i][1] for i in range(Nbfond)]))
- mcfact.append(_F(PARA='VN_Z' ,LISTE_R=[VN[i][2] for i in range(Nbfond)]))
- mcfact.append(_F(PARA='VP_X' ,LISTE_R=[VP[i][0] for i in range(Nbfond)]))
- mcfact.append(_F(PARA='VP_Y' ,LISTE_R=[VP[i][1] for i in range(Nbfond)]))
- mcfact.append(_F(PARA='VP_Z' ,LISTE_R=[VP[i][2] for i in range(Nbfond)]))
- __resu2=CREA_TABLE(LISTE=mcfact,TITRE=' VECTEUR NORMAL A LA FISSURE - DIRECTION DE PROPAGATION')
- aster.affiche('MESSAGE',__resu2.EXTR_TABLE().__repr__())
- DETRUIRE(CONCEPT=_F(NOM=__resu2),INFO=1)
+ affiche_xfem(self,INFO,Nnoff,VN,VP)
+
+# ------------------------------------------------------------------
+# III. CAS BATARD
+# ------------------------------------------------------------------
else :
- Nbnofo = 1
-
-# ----------Recuperation de la temperature au fond -------------
+
+ Nbnofo = 1
+ Lnofon=[]
+
+ # a suprrimer qd menage
+ Nnoff = 1
+
+ # 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 'Lnosup' not in locals() : Lnosup = []
+ if 'Lnoinf' not in locals() : Lnoinf = []
+ if 'TTSo' not in locals() : TTSo = []
+ if 'VP' not in locals() : VP = []
+ if 'VN' not in locals() : VN = []
+ if 'dicoF' not in locals() : dicoF = []
+ if 'absfon' not in locals() : absfon = []
+ if 'd_coor' not in locals() : d_coor = []
+
+
+# ------------------------------------------------------------------
+# IV. RECUPERATION DE LA TEMPERATURE AU FOND
+# ------------------------------------------------------------------
+
if Tempe3D :
Rth = self.get_concept(resuth)
+
__TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='Temperature fond de fissure',
- NOEUD=Lnofon,TOUT_CMP='OUI',
- RESULTAT=Rth,NOM_CHAM='TEMP',TOUT_ORDRE='OUI',
- OPERATION='EXTRACTION',),);
+ NOEUD=Lnofon,
+ TOUT_CMP='OUI',
+ RESULTAT=Rth,
+ NOM_CHAM='TEMP',
+ TOUT_ORDRE='OUI',
+ OPERATION='EXTRACTION',),);
+
tabtemp=__TEMP.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=__TEMP),INFO=1)
+# ------------------------------------------------------------------
+# V. BOUCLE SUR NOEUDS DU FOND
+# ------------------------------------------------------------------
-# ------------------------------------------------------------------
-# BOUCLE SUR NOEUDS DU FOND
-# ------------------------------------------------------------------
for ino in range(0,Nbnofo) :
- if FOND_FISS and INFO==2 :
- texte="\n\n--> TRAITEMENT DU NOEUD DU FOND DE FISSURE: %s"%Lnofon[ino]
- aster.affiche('MESSAGE',texte)
- if FISSURE and INFO==2 :
- texte="\n\n--> TRAITEMENT DU POINT DU FOND DE FISSURE NUMERO %s"%(ino+1)
- aster.affiche('MESSAGE',texte)
-# ------------------------------------------------------------------
-# TABLE 'DEPSUP'
-# ------------------------------------------------------------------
- if FOND_FISS :
- if TYPE_MAILLAGE =='LIBRE':
- tabsup=TlibS[ino].EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=TlibS[ino]),INFO=1)
- elif RESULTAT :
- if MODELISATION=='AXIS' or MODELISATION=='C_PLAN' or MODELISATION=='D_PLAN':
- __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
- NOEUD=Lnosup[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY',),
- OPERATION='EXTRACTION',),);
- else :
- __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
- NOEUD=Lnosup[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY','DZ',),
- OPERATION='EXTRACTION',),);
- tabsup=__TSUP.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=__TSUP),INFO=1)
- else :
- tabsup=TABL_DEPL_SUP.EXTR_TABLE()
- veri_tab(tabsup,TABL_DEPL_SUP.nom,ndim)
- Ls = [string.ljust(Lnosup[ino][i],8) for i in range(len(Lnosup[ino]))]
- tabsup=tabsup.NOEUD==Ls
- elif FISSURE :
- tabsup = TTSo.INTITULE=='l.coupe%i'%(ino+1)
- else :
- tabsup=TABL_DEPL_SUP.EXTR_TABLE()
- veri_tab(tabsup,TABL_DEPL_SUP.nom,ndim)
+
+ affiche_traitement(FOND_FISS,INFO,FISSURE,Lnofon,ino)
-# ------------------------------------------------------------------
-# TABLE 'DEPINF'
-# ------------------------------------------------------------------
- if SYME_CHAR=='SANS' and not FISSURE :
- if FOND_FISS :
- if TYPE_MAILLAGE =='LIBRE':
- tabinf=TlibI[ino].EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=TlibI[ino]),INFO=1)
- elif RESULTAT :
- if MODELISATION=='AXIS' or MODELISATION=='C_PLAN' or MODELISATION=='D_PLAN':
- __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
- NOEUD=Lnoinf[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY'),
- OPERATION='EXTRACTION',),);
- else :
- __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
- NOEUD=Lnoinf[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY','DZ',),
- OPERATION='EXTRACTION',),);
- tabinf=__TINF.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=__TINF),INFO=1)
- else :
- tabinf=TABL_DEPL_INF.EXTR_TABLE()
- if TABL_DEPL_INF==None : UTMESS('F','RUPTURE0_35')
- veri_tab(tabinf,TABL_DEPL_INF.nom,ndim)
- Li = [string.ljust(Lnoinf[ino][i],8) for i in range(len(Lnoinf[ino]))]
- tabinf=tabinf.NOEUD==Li
- else :
- if TABL_DEPL_INF==None : UTMESS('F','RUPTURE0_35')
- tabinf=TABL_DEPL_INF.EXTR_TABLE()
- veri_tab(tabinf,TABL_DEPL_INF.nom,ndim)
+# table 'depsup' et 'depinf'
+ 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,
+ FOND_FISS,FISSURE,TYPE_MAILLAGE,RESULTAT,SYME_CHAR,TABL_DEPL_INF,ndim)
+# les instants de post-traitement : creation de l_inst
+ (l_inst,PRECISION,CRITERE) = get_liste_inst(tabsup,args,LIST_ORDRE,NUME_ORDRE,INST,LIST_INST,EnumTypes)
-# ------------------------------------------------------------------
-# LES INSTANTS DE POST-TRAITEMENT
-# ------------------------------------------------------------------
- if 'INST' in tabsup.para :
- l_inst=None
- l_inst_tab=tabsup['INST'].values()['INST']
- l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() #elimine les doublons
- l_inst_tab.sort()
- if LIST_ORDRE !=None or NUME_ORDRE !=None :
- l_ord_tab = tabsup['NUME_ORDRE'].values()['NUME_ORDRE']
- l_ord_tab.sort()
- l_ord_tab=dict([(i,0) for i in l_ord_tab]).keys()
- d_ord_tab= [[l_ord_tab[i],l_inst_tab[i]] for i in range(0,len(l_ord_tab))]
- d_ord_tab= [(i[0],i[1]) for i in d_ord_tab]
- d_ord_tab = dict(d_ord_tab)
- if NUME_ORDRE !=None :
- if type(NUME_ORDRE) not in EnumTypes : NUME_ORDRE=(NUME_ORDRE,)
- l_ord=list(NUME_ORDRE)
- elif LIST_ORDRE !=None :
- l_ord = LIST_ORDRE.VALE.get()
- l_inst = []
- for ord in l_ord :
- if ord in l_ord_tab : l_inst.append(d_ord_tab[ord])
- else :
- UTMESS('F','RUPTURE0_37',vali=ord)
- PRECISION = 1.E-6
- CRITERE='ABSOLU'
- elif INST !=None or LIST_INST !=None :
- CRITERE = args['CRITERE']
- PRECISION = args['PRECISION']
- if INST !=None :
- if type(INST) not in EnumTypes : INST=(INST,)
- l_inst=list(INST)
- elif LIST_INST !=None : l_inst=LIST_INST.Valeurs()
- for inst in l_inst :
- if CRITERE=='RELATIF' and inst!=0.: match=[x for x in l_inst_tab if abs((inst-x)/inst)<PRECISION]
- else : match=[x for x in l_inst_tab if abs(inst-x)<PRECISION]
- if len(match)==0 :
- UTMESS('F','RUPTURE0_38',valr=inst)
- if len(match)>=2 :
- UTMESS('F','RUPTURE0_39',valr=inst)
- else :
- l_inst=l_inst_tab
- PRECISION = 1.E-6
- CRITERE='ABSOLU'
- else :
- l_inst = [None,]
-
-# ------------------------------------------------------------------
+# ------------------------------------------------------------------
# BOUCLE SUR LES INSTANTS
-# ------------------------------------------------------------------
- for iord in range(len(l_inst)) :
- inst=l_inst[iord]
- if INFO==2 and inst!=None:
- texte="#=================================================================================\n"
- texte=texte+"==> INSTANT: %f"%inst
- aster.affiche('MESSAGE',texte)
- if inst!=None:
- if PRECISION == None : PRECISION = 1.E-6
- if CRITERE == None : CRITERE='ABSOLU'
- if inst==0. :
- tabsupi=tabsup.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION)
- if SYME_CHAR=='SANS'and not FISSURE: tabinfi=tabinf.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION)
- else :
- tabsupi=tabsup.INST.__eq__(VALE=inst,CRITERE=CRITERE,PRECISION=PRECISION)
- if SYME_CHAR=='SANS' and not FISSURE: tabinfi=tabinf.INST.__eq__(VALE=inst,CRITERE=CRITERE,PRECISION=PRECISION)
- else :
- tabsupi=tabsup
- if SYME_CHAR=='SANS' and not FISSURE : tabinfi=tabinf
-
-# --- LEVRE SUP : "ABSC_CURV" CROISSANTES, < RMAX ET DEP ---
- abscs = getattr(tabsupi,'ABSC_CURV').values()
- if not FISSURE :
- if not FOND_FISS :
- refs=copy.copy(abscs)
- refs.sort()
- if refs!=abscs :
- mctabl='TABL_DEPL_INF'
- UTMESS('F','RUPTURE0_40',valk=mctabl)
- if ABSC_CURV_MAXI!=None : rmax = ABSC_CURV_MAXI
- else : rmax = abscs[-1]
- precv = PREC_VIS_A_VIS
- rmprec= rmax*(1.+precv/10.)
- refsc=[x for x in refs if x<rmprec]
- nbval = len(refsc)
- else :
- nbval=len(abscs)
- abscs=NP.array(abscs[:nbval])
- coxs=NP.array(tabsupi['COOR_X'].values()['COOR_X'][:nbval])
- coys=NP.array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval])
- if ndim==2 : cozs=NP.zeros(nbval)
- elif ndim==3 : cozs=NP.array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval])
+# ------------------------------------------------------------------
+ for iord,inst in enumerate(l_inst) :
+
+# impression de l'instant de calcul
+ affiche_instant(INFO,inst)
+
+# recuperation de la table au bon instant : tabsupi (et tabinfi)
+ tabsupi = get_tab_inst('sup',inst,FISSURE,SYME_CHAR,PRECISION,CRITERE,tabsup,tabinf)
+ tabinfi = get_tab_inst('inf',inst,FISSURE,SYME_CHAR,PRECISION,CRITERE,tabsup,tabinf)
+
+# recupération des déplacements sup et inf : ds et di
+ (abscs,ds) = get_depl_sup(FISSURE,FOND_FISS,rmprec,RESULTAT,tabsupi,ndim,d_coor,Lnofon,ino)
+ (absci,di) = get_depl_inf(FISSURE,FOND_FISS,rmprec,RESULTAT,tabinfi,ndim,d_coor,Lnofon,ino,SYME_CHAR)
+
+# récupération des propriétés materiau avec temperature
+ if Tempe3D :
+ (e,nu,coefd,coefd3,coefg,coefg3) = get_propmat_tempe(MATER,tabtemp,Lnofon,ino,inst,PRECISION)
+
+# TESTS NOMBRE DE NOEUDS
+ nbval = len(abscs)
+
+ if nbval<3 :
+
+ UTMESS('A+','RUPTURE0_46')
+ if FOND_FISS :
+ UTMESS('A+','RUPTURE0_47',valk=Lnofon[ino])
+ if FISSURE :
+ UTMESS('A+','RUPTURE0_99',vali=ino)
+ UTMESS('A','RUPTURE0_25')
+ kg1 = [0.]*8
+ kg2 = [0.]*8
+ kg3 = [0.]*8
- if FOND_FISS and not RESULTAT : #tri des noeuds avec abscisse
- Pfon = NP.array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]])
- abscs = NP.sqrt((coxs-Pfon[0])**2+(coys-Pfon[1])**2+(cozs-Pfon[2])**2)
- tabsupi['Abs_fo'] = abscs
- tabsupi.sort('Abs_fo')
- abscs = getattr(tabsupi,'Abs_fo').values()
- abscs=NP.array(abscs[:nbval])
- coxs=NP.array(tabsupi['COOR_X'].values()['COOR_X'][:nbval])
- coys=NP.array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval])
- if ndim==2 : cozs=NP.zeros(nbval)
- elif ndim==3 : cozs=NP.array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval])
+ else :
+
+# SI NBVAL >= 3 :
+#
+# récupération de la matrice de changement de repère
+# (je ne comprends pas pourquoi elle dépend de l'instant)
+ pgl = get_pgl(SYME_CHAR,FISSURE,VECT_K1,ino,VP,VN,tabsupi,tabinfi,nbval,ndim)
+
+# calcul du saut de déplacements dans le nouveau repère
+ saut = get_saut(self,pgl,ds,di,INFO,FISSURE,SYME_CHAR,abscs,ndim)
+
+# CALCUL DES K1, K2, K3
+ (isig,kgsig,saut2) = get_kgsig(saut,nbval,coefd,coefd3)
- if FOND_FISS and INFO==2 and iord==0 and not TYPE_MAILLAGE =='LIBRE':
- for ks in range(0,nbval) :
- texte="NOEUD RETENU POUR LA LEVRE SUP: %s %f"%(Lnosup[ino][ks],abscs[ks])
- aster.affiche('MESSAGE',texte)
- dxs=NP.array(tabsupi['DX'].values()['DX'][:nbval])
- dys=NP.array(tabsupi['DY'].values()['DY'][:nbval])
- if ndim==2 : dzs=NP.zeros(nbval)
- elif ndim==3 : dzs=NP.array(tabsupi['DZ'].values()['DZ'][:nbval])
-
-# --- LEVRE INF : "ABSC_CURV" CROISSANTES et < RMAX ---
- if SYME_CHAR=='SANS' and not FISSURE :
- absci = getattr(tabinfi,'ABSC_CURV').values()
- if not FOND_FISS :
- refi=copy.copy(absci)
- refi.sort()
- if refi!=absci :
- mctabl='TABL_DEPL_SUP'
- UTMESS('F','RUPTURE0_40',valk=mctabl)
- refic=[x for x in refi if x<rmprec]
- nbvali=len(refic)
- else :
- nbvali=len(absci)
- if nbvali!=nbval :
- if FOND_FISS :
- UTMESS('A+','RUPTURE0_42')
- UTMESS('A','RUPTURE0_43',valk=Lnofon[i],vali=[len(refsc),len(refic)])
- else:
- UTMESS('A','RUPTURE0_42')
- nbval=min(nbval,nbvali)
- absci=NP.array(absci[:nbval])
- coxi=NP.array(tabinfi['COOR_X'].values()['COOR_X'][:nbval])
- coyi=NP.array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval])
- if ndim==2 : cozi=NP.zeros(nbval)
- elif ndim==3 : cozi=NP.array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval])
-# --- ON VERIFIE QUE LES NOEUDS SONT EN VIS_A_VIS (SYME=SANS) ---
- if not FOND_FISS :
- precn = precv * rmax
- dist=(coxs-coxi)**2+(coys-coyi)**2+(cozs-cozi)**2
- dist=NP.sqrt(dist)
- for d in dist :
- if d>precn : UTMESS('F','RUPTURE0_44')
-
- if FOND_FISS and not RESULTAT :#tri des noeuds avec abscisse
- Pfon = NP.array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]])
- absci = NP.sqrt((coxi-Pfon[0])**2+(coyi-Pfon[1])**2+(cozi-Pfon[2])**2)
- tabinfi['Abs_fo'] = absci
- tabinfi.sort('Abs_fo')
- absci = getattr(tabinfi,'Abs_fo').values()
- absci=NP.array(abscs[:nbval])
- coxi=NP.array(tabinfi['COOR_X'].values()['COOR_X'][:nbval])
- coyi=NP.array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval])
- if ndim==2 : cozi=NP.zeros(nbval)
- elif ndim==3 : cozi=NP.array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval])
+# calcul des K et de G par les methodes 1, 2 et 3
+ kg1 = get_meth1(self,abscs,coefg,coefg3,kgsig,isig,saut2,INFO,ndim)
+ kg2 = get_meth2(self,abscs,coefg,coefg3,kgsig,isig,saut2,INFO,ndim)
+ kg3 = get_meth3(self,abscs,coefg,coefg3,kgsig,isig,saut2,INFO,ndim)
- dxi=NP.array(tabinfi['DX'].values()['DX'][:nbval])
- dyi=NP.array(tabinfi['DY'].values()['DY'][:nbval])
- if ndim==2 : dzi=NP.zeros(nbval)
- elif ndim==3 : dzi=NP.array(tabinfi['DZ'].values()['DZ'][:nbval])
-
- if FOND_FISS and INFO==2 and iord==0 and not TYPE_MAILLAGE =='LIBRE':
- for ki in range(0,nbval) :
- texte="NOEUD RETENU POUR LA LEVRE INF: %s %f"%(Lnoinf[ino][ki],absci[ki])
- aster.affiche('MESSAGE',texte)
-
-# --- CAS FISSURE X-FEM ---
- if FISSURE :
- H1 = getattr(tabsupi,'H1X').values()
- nbval = len(H1)
- H1 = complete(H1)
- E1 = getattr(tabsupi,'E1X').values()
- E1 = complete(E1)
- dxs = 2*(H1 + NP.sqrt(abscs)*E1)
- H1 = getattr(tabsupi,'H1Y').values()
- E1 = getattr(tabsupi,'E1Y').values()
- H1 = complete(H1)
- E1 = complete(E1)
- dys = 2*(H1 + NP.sqrt(abscs)*E1)
- H1 = getattr(tabsupi,'H1Z').values()
- E1 = getattr(tabsupi,'E1Z').values()
- H1 = complete(H1)
- E1 = complete(E1)
- dzs = 2*(H1 + NP.sqrt(abscs)*E1)
- abscs=NP.array(abscs[:nbval])
-
-# ---------- CALCUL PROP. MATERIAU AVEC TEMPERATURE -----------
- if Tempe3D :
- tempeno=tabtemp.NOEUD==Lnofon[ino]
- tempeno=tempeno.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION)
- nompar = ('TEMP',)
- valpar = (tempeno.TEMP.values()[0],)
- nomres=['E','NU']
- valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F')
- e = valres[0]
- nu = valres[1]
- coefd = e * NP.sqrt(2.*pi) / ( 8.0 * (1. - nu**2))
- coefd3 = e*NP.sqrt(2*pi) / ( 8.0 * (1. + nu))
- coefg = (1. - nu**2) / e
- coefg3 = (1. + nu) / e
-
-# --- TESTS NOMBRE DE NOEUDS---
- if nbval<3 :
- UTMESS('A+','RUPTURE0_46')
- if FOND_FISS :
- UTMESS('A+','RUPTURE0_47',valk=Lnofon[ino])
- if FISSURE :
- UTMESS('A+','RUPTURE0_99',vali=ino)
- UTMESS('A','RUPTURE0_25')
- kg1 = [0.]*8
- kg2 =[0.]*8
- kg3 =[0.]*8
-
- else :
-# SI NBVAL >= 3 :
+# creation de la table
+ kg=NP.array([kg1,kg2,kg3])
+ kg=NP.transpose(kg)
+
+ tabout = get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord,
+ Lnofon,dicoF,absfon,Nnoff,tabout)
+
+# Fin de la boucle sur les instants
+
+# Fin de la boucle sur les noeuds du fond de fissure
+
+# Tri de la table si nécessaire
+ if len(l_inst)!=1 and ndim == 3 :
+ tabout=CALC_TABLE(reuse=tabout,
+ TABLE=tabout,
+ ACTION=_F(OPERATION = 'TRI',
+ NOM_PARA=('INST','ABSC_CURV','METHODE'),
+ ORDRE='CROISSANT'))
-# ------------------------------------------------------------------
-# CHANGEMENT DE REPERE
-# ------------------------------------------------------------------
-#
-# 1 : VECTEUR NORMAL AU PLAN DE LA FISSURE
-# ORIENTE LEVRE INFERIEURE VERS LEVRE SUPERIEURE
-# 2 : VECTEUR NORMAL AU FOND DE FISSURE EN M
-# 3 : VECTEUR TANGENT AU FOND DE FISSURE EN M
-#
- if FISSURE :
- v2 = VP[ino]
- v1 = VN[ino]
- elif SYME_CHAR=='SANS' :
- vo = NP.array([( coxs[-1]+coxi[-1] )/2.,( coys[-1]+coyi[-1] )/2.,( cozs[-1]+cozi[-1] )/2.])
- ve = NP.array([( coxs[0 ]+coxi[0 ] )/2.,( coys[0 ]+coyi[0 ] )/2.,( cozs[0 ]+cozi[0 ] )/2.])
- v2 = ve-vo
- else :
- vo = NP.array([ coxs[-1], coys[-1], cozs[-1]])
- ve = NP.array([ coxs[0], coys[0], cozs[0]])
- v2 = ve-vo
- if not FISSURE : v1 = NP.array(VECT_K1)
- v2 = v2/NP.sqrt(v2[0]**2+v2[1]**2+v2[2]**2)
- v1p = sum(v2*v1)
- if SYME_CHAR=='SANS' : v1 = v1-v1p*v2
- else : v2 = v2-v1p*v1
- v1 = v1/NP.sqrt(v1[0]**2+v1[1]**2+v1[2]**2)
- v2 = v2/NP.sqrt(v2[0]**2+v2[1]**2+v2[2]**2)
- v3 = NP.array([v1[1]*v2[2]-v2[1]*v1[2],v1[2]*v2[0]-v2[2]*v1[0],v1[0]*v2[1]-v2[0]*v1[1]])
- pgl = NP.asarray([v1,v2,v3])
- dpls = NP.asarray([dxs,dys,dzs])
- dpls = NP.dot(pgl,dpls)
- if SYME_CHAR!='SANS' and abs(dpls[0][0]) > 1.e-10 :
- UTMESS('A','RUPTURE0_49',valk=[Lnofon[ino],SYME_CHAR])
- if FISSURE :
- saut=dpls
- elif SYME_CHAR=='SANS' :
- dpli = NP.asarray([dxi,dyi,dzi])
- dpli = NP.dot(pgl,dpli)
- saut=(dpls-dpli)
- else :
- dpli = [NP.multiply(dpls[0],-1.),dpls[1],dpls[2]]
- saut=(dpls-dpli)
- if INFO==2 :
- mcfact=[]
- mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=abscs.tolist() ))
- if not FISSURE :
- mcfact.append(_F(PARA='DEPL_SUP_1',LISTE_R=dpls[0].tolist() ))
- mcfact.append(_F(PARA='DEPL_INF_1',LISTE_R=dpli[0].tolist() ))
- mcfact.append(_F(PARA='SAUT_1' ,LISTE_R=saut[0].tolist() ))
- if not FISSURE :
- mcfact.append(_F(PARA='DEPL_SUP_2',LISTE_R=dpls[1].tolist() ))
- mcfact.append(_F(PARA='DEPL_INF_2',LISTE_R=dpli[1].tolist() ))
- mcfact.append(_F(PARA='SAUT_2' ,LISTE_R=saut[1].tolist() ))
- if ndim==3 :
- if not FISSURE :
- mcfact.append(_F(PARA='DEPL_SUP_3',LISTE_R=dpls[2].tolist() ))
- mcfact.append(_F(PARA='DEPL_INF_3',LISTE_R=dpli[2].tolist() ))
- mcfact.append(_F(PARA='SAUT_3' ,LISTE_R=saut[2].tolist() ))
- __resu0=CREA_TABLE(LISTE=mcfact,TITRE='--> SAUTS')
- aster.affiche('MESSAGE',__resu0.EXTR_TABLE().__repr__())
- DETRUIRE(CONCEPT=_F(NOM=__resu0),INFO=1)
-# ------------------------------------------------------------------
-# CALCUL DES K1, K2, K3
-# ------------------------------------------------------------------
- isig=NP.sign(NP.transpose(NP.resize(saut[:,-1],(nbval-1,3))))
- isig=NP.sign(isig+0.001)
- saut=saut*NP.array([[coefd]*nbval,[coefd]*nbval,[coefd3]*nbval])
- saut=saut**2
- ksig = isig[:,1]
- ksig = NP.array([ksig,ksig])
- ksig = NP.transpose(ksig)
- kgsig=NP.resize(ksig,(1,6))[0]
-# ------------------------------------------------------------------
-# --- METHODE 1 ---
-# ------------------------------------------------------------------
- nabs = len(abscs)
- x1 = abscs[1:-1]
- x2 = abscs[2:nabs]
- y1 = saut[:,1:-1]/x1
- y2 = saut[:,2:nabs]/x2
- k = abs(y1-x1*(y2-y1)/(x2-x1))
- g = coefg*(k[0]+k[1])+coefg3*k[2]
- kg1 = [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])]
- kg1 = NP.sqrt(kg1)*kgsig
- kg1=NP.concatenate([kg1,[max(g),min(g)]])
- vk = NP.sqrt(k)*isig[:,:-1]
- if INFO==2 :
- mcfact=[]
- mcfact.append(_F(PARA='ABSC_CURV_1' ,LISTE_R=x1.tolist() ))
- mcfact.append(_F(PARA='ABSC_CURV_2' ,LISTE_R=x2.tolist() ))
- mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0].tolist() ))
- mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1].tolist() ))
- if ndim==3 :
- mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2].tolist() ))
- mcfact.append(_F(PARA='G' ,LISTE_R=g.tolist() ))
- __resu1=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 1')
- aster.affiche('MESSAGE',__resu1.EXTR_TABLE().__repr__())
- DETRUIRE(CONCEPT=_F(NOM=__resu1),INFO=1)
-# ------------------------------------------------------------------
-# --- METHODE 2 ---
-# ------------------------------------------------------------------
- nabs = len(abscs)
- x1 = abscs[1:nabs]
- y1 = saut[:,1:nabs]
- k = abs(y1/x1)
- g = coefg*(k[0]+k[1])+coefg3*k[2]
- kg2= [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])]
- kg2 = NP.sqrt(kg2)*kgsig
- kg2=NP.concatenate([kg2,[max(g),min(g)]])
- vk = NP.sqrt(k)*isig
- if INFO==2 :
- mcfact=[]
- mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=x1.tolist() ))
- mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0].tolist() ))
- mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1].tolist() ))
- if ndim==3 :
- mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2].tolist() ))
- mcfact.append(_F(PARA='G' ,LISTE_R=g.tolist() ))
- __resu2=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 2')
- aster.affiche('MESSAGE',__resu2.EXTR_TABLE().__repr__())
- DETRUIRE(CONCEPT=_F(NOM=__resu2),INFO=1)
-# ------------------------------------------------------------------
-# --- METHODE 3 ---
-# ------------------------------------------------------------------
- nabs = len(abscs)
- x1 = abscs[:-1]
- x2 = abscs[1:nabs]
- y1 = saut[:,:-1]
- y2 = saut[:,1:nabs]
- k = (NP.sqrt(y2)*NP.sqrt(x2)+NP.sqrt(y1)*NP.sqrt(x1))*(x2-x1)
- k = NP.sum(NP.transpose(k), axis=0)
- de = abscs[-1]
- vk = (k/de**2)*isig[:,0]
- g = coefg*(vk[0]**2+vk[1]**2)+coefg3*vk[2]**2
- kg3=NP.concatenate([[vk[0]]*2,[vk[1]]*2,[vk[2]]*2,[g]*2])
- if INFO==2 :
- mcfact=[]
- mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0] ))
- mcfact.append(_F(PARA='K2' ,LISTE_R=vk[1] ))
- if ndim==3 :
- mcfact.append(_F(PARA='K3' ,LISTE_R=vk[2] ))
- mcfact.append(_F(PARA='G' ,LISTE_R=g ))
- __resu3=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 3')
- aster.affiche('MESSAGE',__resu3.EXTR_TABLE().__repr__())
- DETRUIRE(CONCEPT=_F(NOM=__resu3),INFO=1)
-# ------------------------------------------------------------------
-# CREATION DE LA TABLE
-# ------------------------------------------------------------------
- kg=NP.array([kg1,kg2,kg3])
- kg=NP.transpose(kg)
- mcfact=[]
- if TITRE != None :
- titre = TITRE
- else :
- v = aster.__version__
- titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K1_K2_K3 LE &DATE A &HEURE \n'%v
- if FOND_FISS and MODELISATION=='3D':
- mcfact.append(_F(PARA='NOEUD_FOND',LISTE_K=[Lnofon[ino],]*3))
- mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[dicoF[Lnofon[ino]]]*3))
- if FISSURE and MODELISATION=='3D':
- mcfact.append(_F(PARA='PT_FOND',LISTE_I=[ino+1,]*3))
- mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[absfon[ino],]*3))
- if FISSURE and MODELISATION!='3D' and Nbfond!=1 :
- mcfact.append(_F(PARA='PT_FOND',LISTE_I=[ino+1,]*3))
- mcfact.append(_F(PARA='METHODE',LISTE_I=(1,2,3)))
- mcfact.append(_F(PARA='K1_MAX' ,LISTE_R=kg[0].tolist() ))
- mcfact.append(_F(PARA='K1_MIN' ,LISTE_R=kg[1].tolist() ))
- mcfact.append(_F(PARA='K2_MAX' ,LISTE_R=kg[2].tolist() ))
- mcfact.append(_F(PARA='K2_MIN' ,LISTE_R=kg[3].tolist() ))
- if ndim==3 :
- mcfact.append(_F(PARA='K3_MAX' ,LISTE_R=kg[4].tolist() ))
- mcfact.append(_F(PARA='K3_MIN' ,LISTE_R=kg[5].tolist() ))
- mcfact.append(_F(PARA='G_MAX' ,LISTE_R=kg[6].tolist() ))
- mcfact.append(_F(PARA='G_MIN' ,LISTE_R=kg[7].tolist() ))
- if (ino==0 and iord==0) and inst==None :
- tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre)
- 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)
- else :
- if inst!=None : mcfact=[_F(PARA='INST' ,LISTE_R=[inst,]*3 )]+mcfact
- __tabi=CREA_TABLE(LISTE=mcfact,)
- npara = ['K1_MAX','METHODE']
- if inst!=None : npara.append('INST')
- if FOND_FISS and MODELISATION=='3D' : npara.append('NOEUD_FOND')
- tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,TITRE = titre,
- ACTION=_F(OPERATION = 'COMB',NOM_PARA=npara,TABLE=__tabi,))
-
-# Tri de la table
- if len(l_inst)!=1 and MODELISATION=='3D':
- tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,
- ACTION=_F(OPERATION = 'TRI',NOM_PARA=('INST','ABSC_CURV','METHODE'),ORDRE='CROISSANT'))
return ier
-#& MODIF ENTETE DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
+#& MODIF ENTETE DATE 14/06/2010 AUTEUR COURTOIS M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
vect_elem_pres_r, vect_elem_pres_c, \
vect_elem_temp_r
-#& MODIF COMMUN DATE 20/04/2010 AUTEUR JAUBERT A.JAUBERT
+#& MODIF COMMUN DATE 24/08/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
fr="Comportement de la bibliotheque Zmat",
NB_VARI =SIMP(statut='o',typ='I',max=1),
UNITE =SIMP(statut='o',typ='I',max=1),),
+ b_umat = BLOC(condition = "RELATION == 'UMAT' ",
+ fr="Comportement utilisateur de type UMAT",
+ NB_VARI =SIMP(statut='o',typ='I',max=1,fr="Nombre de variables internes"),
+ LIBRAIRIE = SIMP(statut='o', typ='TXM',validators=LongStr(1,128),
+ fr="Chemin vers la bibliothèque dynamique définissant le comportement UMAT"),
+ NOM_ROUTINE = SIMP(statut='o', typ='TXM',
+ fr="Nom de la routine UMAT dans la bibliothèque"),
+ ),
# KITs
b_kit_ddi = BLOC(condition = "RELATION == 'KIT_DDI' ",
"MAZARS"
),),
),
- b_kit_thm = BLOC(condition = "RELATION in ['KIT_HHM','KIT_HH','KIT_HM','KIT_THHM','KIT_THH','KIT_THM','KIT_THV']",
+ b_kit_thm = BLOC(condition = "RELATION in ['KIT_HHM','KIT_HH','KIT_H','KIT_HM','KIT_THHM', \
+ 'KIT_THH','KIT_THM','KIT_THV']",
fr="lois de comportements thermo-hydro-mecaniques",
RELATION_KIT =SIMP(statut='o',typ='TXM',max=9,validators=NoRepeat(),
into=(
"MAZARS",
"ENDO_ISOT_BETON",
"JOINT_BANDIS",
+ "CZM_LIN_REG",
+ "CZM_EXP_REG",
# THMC
"GAZ",
"LIQU_SATU",
TAUX_RETOUR =SIMP(statut='f',typ='R',defaut= 0.05 ),
),
- PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ),
+ PARM_THETA =SIMP(statut='f',typ='R',val_min=0.,val_max=1., defaut= 1.),
PARM_ALPHA =SIMP(statut='f',typ='R',defaut= 1. ),
regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0,val_min=0),
EVOL_NOLI =SIMP(statut='f',typ=evol_noli),
);
-#& MODIF COMMUN DATE 27/04/2010 AUTEUR DESROCHES X.DESROCHES
+#& MODIF COMMUN DATE 19/10/2010 AUTEUR DELMAS J.DELMAS
# 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.
+# 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 VABHHTS J.PELLET
# ce fichier contient la liste des "into" possibles pour le mot cle NOM_CHAM
"ERRE_NOEU_ELEM",
"ERZ1_ELEM_SIGM",
"ERZ2_ELEM_SIGM",
+ "FERRAILLAGE",
"QIRE_ELEM_SIGM",
"QIRE_ELNO_ELEM",
"QIRE_NOEU_ELEM",
"PRES_NOEU_DBEL",
"PRES_NOEU_IMAG",
"PRES_NOEU_REEL",
- "PROJ_ELEM_SIGN",
- "PROJ_ELEM_SIGT",
- "PROJ_ELEM_SIT1",
- "PROJ_ELEM_SIT2",
+ "PROJ_ELEM_SIGM",
"RADI_ELGA_SIGM",
"RADI_ELNO_SIGM",
"RADI_NOEU_SIGM",
"SIPO_ELNO_SIEF",
"SIPO_NOEU_DEPL",
"SIPO_NOEU_SIEF",
- "SIRE_ELNO_DEPL",
- "SIRE_NOEU_DEPL",
"SOUR_ELGA_ELEC",
"TEMP",
"THETA",
"VALE_CONT",
"VALE_NCOU_MAXI",
+ "VARC_ELGA",
"VARI_ELGA",
"VARI_ELNO",
"VARI_ELNO_COQU",
"AMOR","ABSC","SIGM","HYDR","SECH","PORO","SAT",
"PGAZ","PCAP","PLIQ","PVAP","PAD","VITE","ENDO",
"NORM","EPAIS","NEUT1","NEUT2",)
-#& MODIF COMMUN DATE 07/07/2009 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMUN DATE 05/10/2010 AUTEUR ABBAS M.ABBAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
# ======================================================================
# RESPONSABLE REZETTE C.REZETTE
def C_RECH_LINEAIRE() : return FACT(statut='f',
- METHODE =SIMP(statut='f',typ='TXM',defaut="CORDE",into=("CORDE","MIXTE") ),
+ METHODE =SIMP(statut='f',typ='TXM',defaut="CORDE",into=("CORDE","MIXTE","PILOTAGE") ),
RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ),
ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 3,val_max=999),
ITER_LINE_CRIT =SIMP(statut='f',typ='I',defaut= 20),
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 20/04/2010 AUTEUR JAUBERT A.JAUBERT
+#& MODIF COMMUN DATE 10/08/2010 AUTEUR MEUNIER S.MEUNIER
# 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.
+# 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 PROIX J.M.PROIX
-def C_RELATION() : return ( "ELAS", # RESP. : PROIX J.M.PROIX #COMMUN#
- "ARME", # RESP. : PEYRARD C.PEYRARD
- "ASSE_CORN", # RESP. : PEYRARD C.PEYRARD
- "BARCELONE", # RESP. : ELGHARIB J.ELGHARIB
- "BETON_DOUBLE_DP", # RESP. : ELGHARIB J.ELGHARIB
- "BETON_RAG", # RESP. : DEBONNIERES P.DEBONNIERES
- "BETON_REGLE_PR", # RESP. : NECS
- "BETON_UMLV_FP", # RESP. : LEPAPE Y.LEPAPE
- "CAM_CLAY", # RESP. : ELGHARIB J.ELGHARIB
- "CJS", # RESP. : CHAVANT C.CHAVANT
- "CORR_ACIER", # RESP. : LEPAPE Y.LEPAPE
- "CZM_EXP_REG", # RESP. : LAVERNE J.LAVERNE
- "CZM_EXP", # RESP. : LAVERNE J.LAVERNE
- "CZM_LIN_REG", # RESP. : LAVERNE J.LAVERNE
- "CZM_OUV_MIX", # RESP. : LAVERNE J.LAVERNE
- "CZM_TAC_MIX", # RESP. : LAVERNE J.LAVERNE
- "CZM_FAT_MIX", # RESP. : LAVERNE J.LAVERNE
- "DIS_BILI_ELAS", # RESP. : FLEJOU J.L.FLEJOU
- "DIS_CHOC", # RESP. : DEVESA G.DEVESA
- "DIS_ECRO_CINE", # RESP. : FLEJOU J.L.FLEJOU
- "DIS_GOUJ2E_ELAS", # RESP. : ANGLES J.ANGLES
- "DIS_GOUJ2E_PLAS", # RESP. : ANGLES J.ANGLES
- "DIS_GRICRA", # RESP. : FERNANDES R.FERNANDES
- "DIS_VISC", # RESP. : FLEJOU J.L.FLEJOU
- "DRUCK_PRAGER", # RESP. : FERNANDES R.FERNANDES
- "DRUCK_PRAG_N_A", # RESP. : FERNANDES R.FERNANDES
- "VISC_DRUC_PRAG", # RESP. : ELGHARIB J.ELGHARIB
- "ELAS_GONF", # RESP. : GRANET S.GRANET
- "ELAS_HYPER", # RESP. : ABBAS M.ABBAS
- "ENDO_FRAGILE", # RESP. : MICHEL S.MICHEL
- "ENDO_SCALAIRE", # RESP. : MICHEL S.MICHEL
- "ENDO_ISOT_BETON", # RESP. : MICHEL S.MICHEL
- "ENDO_ORTH_BETON", # RESP. : MICHEL S.MICHEL
- "GATT_MONERIE", # RESP. : DEBONNIERES P.DEBONNIERES
- "GLRC_DAMAGE", # RESP. : MARKOVIC D.MARKOVIC
- "GLRC_DM", # RESP. : MARKOVIC D.MARKOVIC
- "GRANGER_FP_INDT", # RESP. : ROSPARS C.ROSPARS
- "GRANGER_FP", # RESP. : ROSPARS C.ROSPARS
- "GRANGER_FP_V", # RESP. : ROSPARS C.ROSPARS
- "GRAN_IRRA_LOG", # RESP. : FERNANDES R.FERNANDES
- "GRILLE_CINE_LINE",# RESP. : ROSPARS C.ROSPARS
- "GRILLE_ISOT_LINE",# RESP. : ROSPARS C.ROSPARS
- "GRILLE_PINTO_MEN",# RESP. : ROSPARS C.ROSPARS
- "HOEK_BROWN_EFF", # RESP. : CHAVANT C.CHAVANT
- "HOEK_BROWN", # RESP. : CHAVANT C.CHAVANT
- "HOEK_BROWN_TOT", # RESP. : CHAVANT C.CHAVANT
- "HUJEUX", # RESP. : FOUCAULT A.FOUCAULT
- "IRRAD3M", # RESP. : FLEJOU J.L.FLEJOU
- "JOINT_BA", # RESP. : MICHEL S.MICHEL
+def C_RELATION() : return ( "ELAS", #COMMUN#
+
+ "ARME",
+ "ASSE_CORN",
+ "BARCELONE",
+ "BETON_DOUBLE_DP",
+ "BETON_RAG",
+ "BETON_REGLE_PR",
+ "BETON_UMLV_FP",
+ "CAM_CLAY",
+ "CJS",
+ "CORR_ACIER",
+ "CZM_EXP",
+ "CZM_EXP_REG",
+ "CZM_FAT_MIX",
+ "CZM_LIN_REG",
+ "CZM_OUV_MIX",
+ "CZM_TAC_MIX",
+ "DIS_BILI_ELAS",
+ "DIS_CHOC",
+ "DIS_ECRO_CINE",
+ "DIS_GOUJ2E_ELAS",
+ "DIS_GOUJ2E_PLAS",
+ "DIS_GRICRA",
+ "DIS_VISC",
+ "DRUCK_PRAGER",
+ "DRUCK_PRAG_N_A",
+ "ELAS_GONF",
+ "ELAS_HYPER",
+ "ENDO_FRAGILE",
+ "ENDO_HETEROGENE",
+ "ENDO_ISOT_BETON",
+ "ENDO_ORTH_BETON",
+ "ENDO_SCALAIRE",
+ "GATT_MONERIE",
+ "GLRC_DAMAGE",
+ "GLRC_DM",
+ "GRANGER_FP",
+ "GRANGER_FP_INDT",
+ "GRANGER_FP_V",
+ "GRAN_IRRA_LOG",
+ "GRILLE_CINE_LINE",
+ "GRILLE_ISOT_LINE",
+ "GRILLE_PINTO_MEN",
+ "HOEK_BROWN",
+ "HOEK_BROWN_EFF",
+ "HOEK_BROWN_TOT",
+ "HUJEUX",
+ "IMPLEX_FRAG",
+ "IMPLEX_ISOT_BETO",
+ "IMPLEX_ISOT_LINE",
+ "IRRAD3M",
+ "JOINT_BA",
"JOINT_BANDIS",
- "JOINT_MECA_RUPT", # RESP. : KAZYMYRENKO C.KAZYMYRENKO
- "KIT_DDI", # RESP. : CHAVANT C.CHAVANT
- "KIT_HHM", # RESP. : GRANET S.GRANET
- "KIT_HH", # RESP. : GRANET S.GRANET
- "KIT_HM", # RESP. : GRANET S.GRANET
- "KIT_THHM", # RESP. : GRANET S.GRANET
- "KIT_THH", # RESP. : GRANET S.GRANET
- "KIT_THM", # RESP. : GRANET S.GRANET
- "KIT_THV", # RESP. : GRANET S.GRANET
- "LABORD_1D", # RESP. : VOLDOIRE F.VOLDOIRE
- "LAIGLE", # RESP. : ELGHARIB J.ELGHARIB
- "LEMAITRE_IRRA", # RESP. : FERNANDES R.FERNANDES
- "LEMAITRE", # RESP. : DEBONNIERES P.DEBONNIERES
- "LEMA_SEUIL", # RESP. : LECLERC S.LECLERC
- "LETK", # RESP. : ELGHARIB J.ELGHARIB
- "LMARC_IRRA", # RESP. : FERNANDES R.FERNANDES
- "LMARC", # RESP. : None
- "MAZARS", # RESP. : MICHEL S.MICHEL
- "META_LEMA_ANI", # RESP. : CANO V.CANO
- "META_P_CL_PT_RE", # RESP. : CANO V.CANO
- "META_P_CL_PT", # RESP. : CANO V.CANO
- "META_P_CL_RE", # RESP. : CANO V.CANO
- "META_P_CL", # RESP. : CANO V.CANO
- "META_P_IL_PT_RE", # RESP. : CANO V.CANO
- "META_P_IL_PT", # RESP. : CANO V.CANO
- "META_P_IL_RE", # RESP. : CANO V.CANO
- "META_P_IL", # RESP. : CANO V.CANO
- "META_P_INL_PT_RE",# RESP. : CANO V.CANO
- "META_P_INL_PT", # RESP. : CANO V.CANO
- "META_P_INL_RE", # RESP. : CANO V.CANO
- "META_P_INL", # RESP. : CANO V.CANO
- "META_V_CL_PT_RE", # RESP. : CANO V.CANO
- "META_V_CL_PT", # RESP. : CANO V.CANO
- "META_V_CL_RE", # RESP. : CANO V.CANO
- "META_V_CL", # RESP. : CANO V.CANO
- "META_V_IL_PT_RE", # RESP. : CANO V.CANO
- "META_V_IL_PT", # RESP. : CANO V.CANO
- "META_V_IL_RE", # RESP. : CANO V.CANO
- "META_V_IL", # RESP. : CANO V.CANO
- "META_V_INL_PT_RE",# RESP. : CANO V.CANO
- "META_V_INL_PT", # RESP. : CANO V.CANO
- "META_V_INL_RE", # RESP. : CANO V.CANO
- "META_V_INL", # RESP. : CANO V.CANO
- "MONOCRISTAL", # RESP. : PROIX J.M.PROIX
- "MULTIFIBRE", # RESP. : FLEJOU J.L.FLEJOU
- "NORTON_HOFF", # RESP. : MICHEL S.MICHEL
- "PINTO_MENEGOTTO", # RESP. : ROSPARS C.ROSPARS
- "POLYCRISTAL", # RESP. : PROIX J.M.PROIX
- "ROUSSELIER", # RESP. : CANO V.CANO
- "ROUSS_PR", # RESP. : PARROT A.PARROT
- "ROUSS_VISC", # RESP. : CANO V.CANO
- "RUPT_FRAG", # RESP. : LAVERNE J.LAVERNE
- "SANS", # RESP. : MICHEL S.MICHEL
- "VENDOCHAB", # RESP. : PROIX J.M.PROIX
- "VISC_CIN1_CHAB", # RESP. : PROIX J.M.PROIX
- "VISC_CIN2_CHAB", # RESP. : PROIX J.M.PROIX
- "VISC_CIN2_MEMO", # RESP. : PROIX J.M.PROIX
- "VISC_IRRA_LOG", # RESP. : FERNANDES R.FERNANDES
- "VISC_ISOT_LINE", # RESP. : MICHEL S.MICHEL
- "VISC_ISOT_TRAC", # RESP. : PROIX J.M.PROIX
- "VISCOCHAB", # RESP. : GENIAUT S.GENIAUT
- "VISC_TAHERI", # RESP. : TAHERI S.TAHERI
- "VMIS_ASYM_LINE", # RESP. : PROIX J.M.PROIX
- "VMIS_CIN1_CHAB", # RESP. : PROIX J.M.PROIX
- "VMIS_CIN2_CHAB", # RESP. : PROIX J.M.PROIX
- "VMIS_CIN2_MEMO", # RESP. : PROIX J.M.PROIX
- "VMIS_CINE_LINE", # RESP. : PROIX J.M.PROIX
- "VMIS_ECMI_LINE", # RESP. : PROIX J.M.PROIX
- "VMIS_ECMI_TRAC", # RESP. : PROIX J.M.PROIX
- "VMIS_ISOT_LINE", # RESP. : PROIX J.M.PROIX
- "VMIS_ISOT_PUIS", # RESP. : PROIX J.M.PROIX
- "VMIS_ISOT_TRAC", # RESP. : PROIX J.M.PROIX
- "VMIS_POU_FLEJOU", # RESP. : FLEJOU J.L.FLEJOU
- "VMIS_POU_LINE", # RESP. : PROIX J.M.PROIX
- "ZMAT", # RESP. : PROIX J.M.PROIX
- "IMPLEX_FRAG", # RESP. : BARGELLINI R.BARGELLINI
- "IMPLEX_ISOT_BETO",# RESP. : BARGELLINI R.BARGELLINI
- "IMPLEX_ISOT_LINE",# RESP. : BARGELLINI R.BARGELLINI
- )
-#& MODIF COMMUN DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+ "JOINT_MECA_RUPT",
+ "KIT_DDI",
+ "KIT_HH",
+ "KIT_H",
+ "KIT_HHM",
+ "KIT_HM",
+ "KIT_THH",
+ "KIT_THHM",
+ "KIT_THM",
+ "KIT_THV",
+ "LABORD_1D",
+ "LAIGLE",
+ "LEMAITRE",
+ "LEMAITRE_IRRA",
+ "LEMA_SEUIL",
+ "LETK",
+ "LMARC_IRRA",
+ "MAZARS",
+ "META_LEMA_ANI",
+ "META_P_CL",
+ "META_P_CL_PT",
+ "META_P_CL_PT_RE",
+ "META_P_CL_RE",
+ "META_P_IL",
+ "META_P_IL_PT",
+ "META_P_IL_PT_RE",
+ "META_P_IL_RE",
+ "META_P_INL",
+ "META_P_INL_PT",
+ "META_P_INL_PT_RE",
+ "META_P_INL_RE",
+ "META_V_CL",
+ "META_V_CL_PT",
+ "META_V_CL_PT_RE",
+ "META_V_CL_RE",
+ "META_V_IL",
+ "META_V_IL_PT",
+ "META_V_IL_PT_RE",
+ "META_V_IL_RE",
+ "META_V_INL",
+ "META_V_INL_PT",
+ "META_V_INL_PT_RE",
+ "META_V_INL_RE",
+ "MONOCRISTAL",
+ "MULTIFIBRE",
+ "NORTON_HOFF",
+ "PINTO_MENEGOTTO",
+ "POLYCRISTAL",
+ "ROUSSELIER",
+ "ROUSS_PR",
+ "ROUSS_VISC",
+ "RUPT_FRAG",
+ "SANS",
+ "VENDOCHAB",
+ "VISCOCHAB",
+ "VISC_CIN1_CHAB",
+ "VISC_CIN2_CHAB",
+ "VISC_CIN2_MEMO",
+ "VISC_DRUC_PRAG",
+ "VISC_IRRA_LOG",
+ "VISC_ISOT_LINE",
+ "VISC_ISOT_TRAC",
+ "VISC_TAHERI",
+ "VMIS_ASYM_LINE",
+ "VMIS_CIN1_CHAB",
+ "VMIS_CIN2_CHAB",
+ "VMIS_CIN2_MEMO",
+ "VMIS_CINE_LINE",
+ "VMIS_ECMI_LINE",
+ "VMIS_ECMI_TRAC",
+ "VMIS_ISOT_LINE",
+ "VMIS_ISOT_PUIS",
+ "VMIS_ISOT_TRAC",
+ "VMIS_POU_FLEJOU",
+ "VMIS_POU_LINE",
+ "ZMAT",
+ "UMAT",
+ )
+#& MODIF COMMUN DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
# RESPONSABLE REZETTE C.REZETTE
def C_SOLVEUR() : return FACT(statut='d',
METHODE=SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","FETI","PETSC") ),
+# --------------------------------------------------------------------------------------------------------------------------------
b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
),
+# --------------------------------------------------------------------------------------------------------------------------------
b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
),
+# --------------------------------------------------------------------------------------------------------------------------------
b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' or METHODE=='FETI' ",
fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON","DECOUPE") ),
),
+# --------------------------------------------------------------------------------------------------------------------------------
b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","LDLT_SP",),defaut="LDLT_INC" ),
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","LDLT_SP"),defaut="LDLT_INC" ),
b_ldltinc =BLOC(condition = "PRE_COND == 'LDLT_INC' ", fr="Paramètres de la factorisation incomplète",
NIVE_REMPLISSAGE =SIMP(statut='f',typ='I',defaut= 0 ),
RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
),
+# --------------------------------------------------------------------------------------------------------------------------------
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")),
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")),
+ MATR_DISTRIBUEE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
),
+# --------------------------------------------------------------------------------------------------------------------------------
b_feti =BLOC(condition = "METHODE == 'FETI' ",fr="Paramètres de la méthode FETI 1",
PARTITION =SIMP(statut='o',typ=sd_feti_sdaster),
RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
NB_SD_PROC0 =SIMP(statut='f',typ='I',defaut=0,val_min=0),
ACCELERATION_SM =SIMP(statut='f',typ='TXM',defaut="OUI",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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
- ), RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
- RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
+ ),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
-
-
+# --------------------------------------------------------------------------------------------------------------------------------
SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
);
#& MODIF COMMUN DATE 27/06/2005 AUTEUR D6BHHJP J.P.LEFEBVRE
l.append(typ+"_"+gd)
return tuple(l)
-#& MODIF COMMANDE DATE 22/09/2009 AUTEUR SELLENET N.SELLENET
+#& MODIF COMMANDE DATE 28/06/2010 AUTEUR FLEJOU J-L.FLEJOU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NOEUD_CENTRE = SIMP(statut='f',typ=no),
COOR_CENTRE = SIMP(statut='f',typ='R',min=2,max=3),
EUROPLEXUS = SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON"),
+ UNITE = SIMP(statut='f',typ='I',val_min=1),
),
#============================================================================
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+#& MODIF COMMANDE DATE 04/10/2010 AUTEUR MEUNIER S.MEUNIER
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
MODELE =SIMP(statut='o',typ=modele_sdaster ),
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','TEMP','PHI'),),
+ AU_MOINS_UN('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',
+ 'H1X','H1Y','H1Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
+ 'E3X','E3Y','E3Z','E4X','E4Y','E4Z','V11','V12','V13','V21','V22',
+ 'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21',
+ 'PRES22','PRES23','PRES31','PRES32','PRES33','LH1'),),
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_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
- DX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- DY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- DZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- DRX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- DRY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- DRZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- GRX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- PRES =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- TEMP =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- PHI =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ DX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ DY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ DZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ DRX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ DRY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ DRZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ GRX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PHI =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ TEMP =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRE1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRE2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UI2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UI3 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UI4 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UI5 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UI6 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UO2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UO3 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UO4 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UO5 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ UO6 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VI2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VI3 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VI4 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VI5 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VI6 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VO2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VO3 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VO4 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VO5 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ VO6 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WI2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WI3 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WI4 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WI5 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WI6 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WO2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WO3 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WO4 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WO5 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WO6 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WI1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ WO1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ GONF =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ H1X =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ H1Y =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ H1Z =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E1X =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E1Y =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E1Z =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E2X =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E2Y =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E2Z =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E3X =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E3Y =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E3Z =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E4X =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E4Y =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ E4Z =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V11 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V12 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V13 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V21 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V22 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V23 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V31 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V32 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ V33 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES11=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES12=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES13=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES21=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES22=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES23=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES31=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES32=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ PRES33=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ LH1 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+
),
THER_IMPO =FACT(statut='f',max='**',
regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 13/04/2010 AUTEUR PELLET J.PELLET
+#& MODIF COMMANDE DATE 28/09/2010 AUTEUR MASSIN P.MASSIN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
METHODE =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les déplacements imposés",
into=('DUALISATION',),defaut='DUALISATION',),
# METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
- ROTATION =SIMP(statut='f',typ='R',fr="Champ de rotation", min=4,max=4),
- b_rotation =BLOC ( condition = "ROTATION != None",
- CENTRE =SIMP(statut='f',typ='R',defaut=(0.,0.,0.),max=3),),
+
+ ROTATION =FACT(statut='f', max='**', fr="Définition d'un chargement de rotation",
+ GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(), max='**'),
+ MAILLE = SIMP(statut='f',typ=ma, validators=NoRepeat(),max='**'),
+ VITESSE = SIMP(statut='o', typ='R',min=1,max=1),
+ AXE = SIMP(statut='o', typ='R',min=2, max=3),
+ CENTRE = SIMP(statut='f',typ='R',defaut=(0.,0.,0.),max=3),
+ b_rotation_tout=BLOC(condition="(GROUP_MA == None) and (MAILLE ==None)",
+ TOUT = SIMP(statut='f',typ='TXM',into=("OUI",),defaut="OUI",),),
+ b_rotation=BLOC(condition="(GROUP_MA != None) or (MAILLE !=None)",
+ TOUT = SIMP(statut='f',typ='TXM',into=("NON","OUI"),defaut="NON",),),),
DDL_IMPO =FACT(statut='f',max='**',
fr="Impose à des noeuds une ou plusieurs valeurs de déplacement (ou de certaines grandeurs asscociées)",
'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','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
+ 'H1X','H1Y','H1Z','H2X','H2Y','H2Z','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',),),
H1X =SIMP(statut='f',typ='R' ),
H1Y =SIMP(statut='f',typ='R' ),
H1Z =SIMP(statut='f',typ='R' ),
+ H2X =SIMP(statut='f',typ='R' ),
+ H2Y =SIMP(statut='f',typ='R' ),
+ H2Z =SIMP(statut='f',typ='R' ),
E1X =SIMP(statut='f',typ='R' ),
E1Y =SIMP(statut='f',typ='R' ),
E1Z =SIMP(statut='f',typ='R' ),
NUME_LAGR =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
),
- LIAISON_ELEM =FACT(statut='f',max='**',
- fr="Modélise le raccord d'une partie massive 3D avec une poutre ou avec un tuyau, le raccord d'une coque"
- +" avec une poutre ou avec un tuyau",
- regles=(UN_PARMI('GROUP_MA_1','MAILLE_1'),
- UN_PARMI('GROUP_NO_2','NOEUD_2'),),
- OPTION =SIMP(statut='o',typ='TXM',into=("3D_TUYAU","3D_POU","COQ_POU","COQ_TUYAU") ),
- GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- MAILLE_1 =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='**'),
- NUME_LAGR =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
- CARA_ELEM =SIMP(statut='f',typ=(cara_elem) ),
- AXE_POUTRE =SIMP(statut='f',typ='R',max=3),
- ANGL_MAX =SIMP(statut='f',typ='R',defaut= 1. ),
- ),
+ LIAISON_ELEM =FACT(statut='f',max='**',
+ fr="Modélise le raccord : d'une partie massive 3D avec une poutre ou avec un tuyau, d'une coque"
+ +" avec une poutre ou avec un tuyau, d'une plaque avec une poutre",
+ regles =(UN_PARMI('GROUP_MA_1','MAILLE_1'), UN_PARMI('GROUP_NO_2','NOEUD_2'),),
+ OPTION =SIMP(statut='o',typ='TXM',into=("3D_TUYAU","3D_POU","COQ_POU","COQ_TUYAU","PLAQ_POUT_ORTH") ),
+ GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ MAILLE_1 =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='**'),
+ NUME_LAGR =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+ ANGL_MAX =SIMP(statut='f',typ='R',defaut= 1. ),
+ b_dalcol =BLOC( condition = "OPTION == 'PLAQ_POUT_ORTH'",
+ VERIF_EXCENT =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+ ),
+ b_option =BLOC( condition = "OPTION != 'PLAQ_POUT_ORTH'",
+ CARA_ELEM =SIMP(statut='f',typ=(cara_elem) ),
+ AXE_POUTRE =SIMP(statut='f',typ='R',max=3),
+ ),
+ ),
LIAISON_UNIF =FACT(statut='f',max='**',
fr="Impose une meme valeur (inconnue) à des DDLs d'un ensemble de noeuds",
NUME_LAGR =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
),
+
+ LIAISON_INTERF =FACT(statut='f',max='**',
+ fr="Définit une relation linéaire entre les DDLs d'interface à partir d'un MACRELEM",
+ MACR_ELEM_DYNA =SIMP(statut='o',typ=macr_elem_dyna),
+ TYPE_LIAISON =SIMP(statut='f',typ='TXM',defaut="RIGIDE",into=("RIGIDE","SOUPLE") ),
+ ),
+
LIAISON_XFEM =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON" ),
CONTACT_XFEM =SIMP(statut='f',typ=char_contact,min=1,max=1,),
) ;
-#& MODIF COMMANDE DATE 20/04/2010 AUTEUR JAUBERT A.JAUBERT
+#& MODIF COMMANDE DATE 10/08/2010 AUTEUR MEUNIER S.MEUNIER
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
"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_GRAD_SIGM",# RESP. : GRANET S.GRANET
"PLAN_JOINT", # RESP. : LAVERNE J.LAVERNE
"PLAN_INTERFACE", # RESP. : LAVERNE J.LAVERNE
"PLAN_ELDI", # RESP. : LAVERNE J.LAVERNE
"D_PLAN_THHMS", # RESP. : GRANET S.GRANET
"D_PLAN_THMS", # RESP. : GRANET S.GRANET
"D_PLAN_HM_P", # RESP. : GRANET S.GRANET
+ "D_PLAN_HS", # RESP. : GRANET S.GRANET
"D_PLAN_HHD", # RESP. : GRANET S.GRANET
"D_PLAN_HHS", # RESP. : GRANET S.GRANET
"D_PLAN_HH2D", # RESP. : GRANET S.GRANET
"3D_HH2MS", # RESP. : GRANET S.GRANET
"3D_THH2S", # RESP. : GRANET S.GRANET
"3D_THH2D", # RESP. : GRANET S.GRANET
+ "3D_HS", # RESP. : GRANET S.GRANET
"3D_HHD", # RESP. : GRANET S.GRANET
"3D_HHS", # RESP. : GRANET S.GRANET
"3D_HH2D", # RESP. : GRANET S.GRANET
"D_PLAN_HH2SUC", # RESP. : GRANET S.GRANET
"D_PLAN_HH2SUDA", # RESP. : GRANET S.GRANET
"2D_JOINT_HMS",
+ "AXIS_JOINT_HMS",
) ) ),
b_thermique =BLOC( condition = "PHENOMENE=='THERMIQUE'",
),
PARTITION =FACT(statut='d',
- PARALLELISME =SIMP(statut='f',typ='TXM',defaut="MAIL_DISPERSE",
- into=("MAIL_CONTIGU","MAIL_DISPERSE","SOUS_DOMAINE","CENTRALISE",)),
+ 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),
# 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/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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# 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/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 14/12/2009 AUTEUR DEVESA G.DEVESA
# CONFIGURATION MANAGEMENT OF EDF VERSION
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 27/04/2010 AUTEUR DESROCHES X.DESROCHES
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DELMAS J.DELMAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
"ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","DISS_ELGA","DISS_ELNO_ELGA",
# estimateurs erreur
"SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM",
- "SIRE_ELNO_DEPL","ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
+ "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
"QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
"SING_ELEM","SING_ELNO_ELEM",
# CRIT
# derivees
"DEUL_ELGA_DEPL","DEDE_ELNO_DLDE","DESI_ELNO_DLSI",
# autres
- "VALE_NCOU_MAXI","PRES_DBEL_DEPL"),),
+ "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_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",
- "SIRE_ELNO_DEPL","ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
+ "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
"QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
"SING_ELEM","SING_ELNO_ELEM",
)),
"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",
# CRIT
),
);
-#& MODIF COMMANDE DATE 28/04/2009 AUTEUR ASSIRE A.ASSIRE
+#& MODIF COMMANDE DATE 14/06/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
) ;
+#& MODIF COMMANDE DATE 11/10/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 PELLET
+
+def calc_ferrailage_prod(RESULTAT,**args):
+ if AsType(RESULTAT) != None : return AsType(RESULTAT)
+ raise AsException("type de concept resultat non prevu")
+
+
+CALC_FERRAILLAGE=OPER(nom="CALC_FERRAILLAGE",op=175,sd_prod=calc_ferrailage_prod, reentrant='o',
+ UIinfo={"groupes":("Outils métier",)},
+ fr="calcul de cartes de densité de ferraillage ",
+
+ RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,) ),
+
+
+#====
+# Sélection des numéros d'ordre pour lesquels on fait le calcul :
+#====
+ 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),
+
+ 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',),),
+ ),
+
+
+#
+#====
+# Définition des grandeurs caractéristiques
+#====
+#
+ TYPE_COMB =SIMP(statut='o',typ='TXM',into=('ELU','ELS')),
+
+# mot clé facteur répétable pour assigner les caractéristiques locales par zones topologiques (GROUP_MA)
+ AFFE =FACT(statut='o',max='**',
+ regles=(UN_PARMI('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='**'),
+ ENROBG =SIMP(statut='o',typ='R'), # enrobage
+ CEQUI =SIMP(statut='f',typ='R'), # coefficient d'équivalence acier/béton (pour ELS)
+ SIGM_ACIER =SIMP(statut='o',typ='R'), # contrainte admissible dans l'acier
+ SIGM_BETON =SIMP(statut='o',typ='R'), # contrainte admissible dans le béton
+ PIVA =SIMP(statut='f',typ='R'), # valeur du pivot a (pour ELU)
+ PIVB =SIMP(statut='f',typ='R'), # valeur du pivot b (pour ELU)
+ ),
+ )
+
+
+##############################################################################################################
+# Remarques :
+#-----------
+# l'épaisseur des coques sera récupérée automatiquement
+# via le cara_elem sous-jacent au résultat
+
+# Le résultat produit est un champ constant par éléments associé à la grandeur FER2_R
+# qui comporte les composantes :
+#
+# DNSXI densité d'acier longitudinal suivant X, peau inf
+# DNSXS densité d'acier longitudinal suivant X, peau sup
+# DNSYI densité d'acier longitudinal suivant Y, peau inf
+# DNSYS densité d'acier longitudinal suivant Y, peau sup
+# DNST densité d'acier transversal
+# SIGMBE contrainte beton
+# 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
+# - si aucun CARA_ELEM n'est récupérable via la structure de données RESULTAT
#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
) ;
-#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+#& MODIF COMMANDE DATE 11/10/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
from Macro.calc_fonction_ops import calc_fonction_ops
def calc_fonction_prod(self,DERIVE,EXTRACTION,INTEGRE,INVERSE,COMB,COMB_C,
ENVELOPPE,FRACTILE,SPEC_OSCI,ASSE,FFT,COMPOSE,CORR_ACCE,PUISSANCE,
- LISS_ENVELOP,ABS, **args):
+ LISS_ENVELOP,ABS, REGR_POLYNOMIALE, **args):
if (INTEGRE != None): return fonction_sdaster
if (DERIVE != None): return fonction_sdaster
if (AsType(vale) == fonction_c) : return fonction_sdaster
if (CORR_ACCE != None): return fonction_sdaster
if (LISS_ENVELOP!= None): return nappe_sdaster
+ if (REGR_POLYNOMIALE != None): return fonction_sdaster
if (PUISSANCE != None): return AsType(PUISSANCE[0]['FONCTION'])
if (ABS != None): return fonction_sdaster
raise AsException("type de concept resultat non prevu")
+
CALC_FONCTION=MACRO(nom="CALC_FONCTION",op=calc_fonction_ops,sd_prod=calc_fonction_prod
,fr="Effectue des opérations mathématiques sur des concepts de type fonction",
reentrant='n',
UIinfo={"groupes":("Fonction",)},
regles=(UN_PARMI('DERIVE','INTEGRE','SPEC_OSCI','COMB','COMB_C','ENVELOPPE',
'COMPOSE','EXTRACTION','ASSE','FFT','CORR_ACCE', 'PUISSANCE',
- 'LISS_ENVELOP','INVERSE','ABS','FRACTILE'),),
+ 'LISS_ENVELOP','INVERSE','ABS','FRACTILE','REGR_POLYNOMIALE'),),
FFT =FACT(statut='f',fr="Transformée de Fourier ou de son inverse",
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,fonction_c) ),
METHODE =SIMP(statut='f',typ='TXM',defaut="PROL_ZERO",into=("PROL_ZERO","TRONCATURE","COMPLET") ),
ELARG =SIMP(statut='f',typ='R',defaut =0.1 ),
TOLE_LISS =SIMP(statut='f',typ='R',defaut =0.25 ),
),
+ REGR_POLYNOMIALE = FACT(statut='f',fr="Régression polynomiale d'une fonction",
+ FONCTION =SIMP(statut='o',typ=fonction_sdaster),
+ DEGRE =SIMP(statut='o',typ='I'),
+ ),
SPEC_OSCI =FACT(statut='f',fr="Spectre d'oscillateur",
METHODE =SIMP(statut='f',typ='TXM',defaut="NIGAM",into=("NIGAM",) ),
FONCTION =SIMP(statut='o',typ=fonction_sdaster ),
COEF_R =SIMP(statut='f',typ='R',fr="Coefficient réel de la combinaison linéaire associée à la fonction" ),
COEF_C =SIMP(statut='f',typ='C',fr="Coefficient complexe de la combinaison linéaire associée à la fonction" ),
),
- b_comb =BLOC ( condition = " (COMB != None) or (COMB_C != None)",
+ b_comb =BLOC ( condition = "COMB != None or COMB_C != None or REGR_POLYNOMIALE != None",
LIST_PARA =SIMP(statut='f',typ=listr8_sdaster ),
),
COMPOSE =FACT(statut='f',fr="Composition de deux fonctions FONC_RESU(FONC_PARA)",
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 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
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")),
- ),
-
+ ),
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
- ),
-
- ) ;
+ ),
+ ) ;
#& MODIF COMMANDE DATE 08/12/2009 AUTEUR PROIX J-M.PROIX
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
TITRE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
RESI_RELA =SIMP(statut='f',typ='R',defaut=1.0E-6,),
OUT_OF_CORE =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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
OPTION =SIMP(statut='f',typ='TXM'
,into=("META_ELNO_TEMP",) ),
) ;
-#& MODIF COMMANDE DATE 16/02/2010 AUTEUR COURTOIS M.COURTOIS
+#& MODIF COMMANDE DATE 29/09/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG
UIinfo={"groupes":("Résolution",)},
OPTION = FACT(statut='o',
- regles=(UN_PARMI('TOUT','MODULE'),),
- TOUT = SIMP(statut='f',typ='TXM',into=("OUI",)),
- MODULE = SIMP(statut='f',typ='TXM',into=("MISS_IMPE",)), # "PRE_MISS","MISS_EVOL",
+ MODULE = SIMP(statut='f',typ='TXM',defaut="MISS_IMPE", into=("MISS_IMPE",)),
),
TABLE_SOL = SIMP(statut='f', typ=table_sdaster),
- PROJET = SIMP(statut='o', typ='TXM'),
+ 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_OPTI_MISS = SIMP(statut='f',typ='I',defaut=26),
-# UNITE_MODELE_SOL = SIMP(statut='f',typ='I',defaut=27),
UNITE_RESU_IMPE = SIMP(statut='f',typ='I',defaut=30),
UNITE_RESU_FORC = SIMP(statut='f',typ='I',defaut=0),
- PARAMETRE = FACT(statut='f',
+ 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('CONTR_NB','CONTR_LISTE'),
PRESENT_PRESENT('SPEC_MAX','SPEC_NB'),),
FREQ_MIN = SIMP(statut='f',typ='R'),
FREQ_MAX = SIMP(statut='f',typ='R'),
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.),
- DIRE_ONDE = SIMP(statut='f',typ='R',max='**'),
-
- FICH_RESU_IMPE = SIMP(statut='f',typ='TXM'),
- FICH_RESU_FORC = SIMP(statut='f',typ='TXM'),
ALGO = SIMP(statut='f',typ='TXM',into=("DEPL","REGU")),
DREF = SIMP(statut='f',typ='R'),
OFFSET_NB = SIMP(statut='f',typ='I'),
FICH_POST_TRAI = SIMP(statut='f',typ='TXM'),
- CONTR_NB = SIMP(statut='f',typ='I'),
- CONTR_LISTE = SIMP(statut='f',typ='R',max='**'),
),
INFO = SIMP(statut='f', typ='I', defaut=1, into=(1,2)),
)
-#& MODIF COMMANDE DATE 27/04/2009 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 13/10/2010 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
CHAM_MATER =SIMP(statut='o',typ=cham_mater),
INST =SIMP(statut='f',typ='R',defaut=0.),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
- CHARGE =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
- SOLVEUR =FACT(statut='d',
- METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT") ),
- b_mult_front =BLOC(condition="METHODE=='MULT_FRONT'",fr="Paramètres associés à la méthode multifrontale",
- RENUM =SIMP(statut='f',typ='TXM',into=("MD","MDA","METIS"),defaut="METIS" ),
- ),
- b_ldlt =BLOC(condition="METHODE=='LDLT'",fr="Paramètres associés à la méthode LDLT",
- RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ),
- ),),
+ CHARGE =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
METHODE =SIMP(statut='f',typ='TXM',defaut="SORENSEN",
into=("TRI_DIAG","JACOBI","SORENSEN","QZ") ),
b_tri_diag =BLOC(condition = "METHODE == 'TRI_DIAG'",
regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
- NPREC_SOLVEUR =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0 ),
SEUIL_FREQ =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
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 27/04/2010 AUTEUR DESROCHES X.DESROCHES
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DELMAS J.DELMAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
"SIGM_NOEU_CART","SIGM_NOEU_COQU","SIGM_NOEU_DEPL",
"SIGM_NOEU_SIEF",
"SIPO_NOEU_DEPL","SIPO_NOEU_SIEF",
- "SIRE_NOEU_DEPL",
"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\
GROUP_NO_RESU =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
NOEUD_RESU =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
) ;
-#& MODIF COMMANDE DATE 03/05/2010 AUTEUR PROIX J-M.PROIX
+#& MODIF COMMANDE DATE 28/06/2010 AUTEUR PROIX J-M.PROIX
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG
EPXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
EPXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
EPYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
-
+
SIGM_INIT=FACT(statut='f',
SIXX = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
SIYY = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
VARI_INIT=FACT(statut='f',
VALE = SIMP(statut='o',typ='R',max='**'),
),
+ MATR_C1=FACT(statut='f',max='**',
+ VALE =SIMP(statut='o',typ='R',max=1, ),
+ NUME_LIGNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=6 ),
+ NUME_COLONNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=12 ),
+ ),
+ MATR_C2=FACT(statut='f',max='**',
+ VALE =SIMP(statut='o',typ='R',max=1, ),
+ NUME_LIGNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=6 ),
+ NUME_COLONNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=12 ),
+ ),
+ VECT_IMPO=FACT(statut='f',max='**',
+ VALE =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule),max=1, ),
+ NUME_LIGNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=6 ),
+ ),
NB_VARI_TABLE =SIMP(statut='f',typ='I',max=1,),
+
+ 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),
+ ),
);
#& MODIF COMMANDE DATE 07/07/2009 AUTEUR REZETTE C.REZETTE
FORMAT =SIMP(statut='f',typ='TXM',defaut="EXCEL",into=("EXCEL","AGRAF") ),
),
) ;
-#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+#& MODIF COMMANDE DATE 08/12/2009 AUTEUR PROIX J-M.PROIX
# 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 - 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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+# 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 PELLET J.PELLET
def calc_vect_elem_prod(OPTION,**args):
MODELE =SIMP(statut='f',typ=modele_sdaster),
),
) ;
-#& MODIF COMMANDE DATE 08/12/2009 AUTEUR PROIX J-M.PROIX
-# 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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
-#& MODIF COMMANDE DATE 30/06/2008 AUTEUR PELLET J.PELLET
+#& MODIF COMMANDE DATE 14/09/2010 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
UIinfo={"groupes":("Maillage",)},
regles=(EXCLUS('COQU_VOLU', 'CREA_FISS', 'CREA_GROUP_MA', 'CREA_MAILLE', 'CREA_POI1',
'DETR_GROUP_MA', 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE',
- 'QUAD_LINE', 'REPERE','RESTREINT'),),
+ 'QUAD_LINE', 'REPERE','RESTREINT','PENTA15_18',),),
PREF_NOEUD =SIMP(statut='f',typ='TXM',defaut="NS"),
PREF_NUME =SIMP(statut='f',typ='I',defaut= 1 ),
),
+ PENTA15_18 =FACT(statut='f',fr="Passage PENTA15 -> PENTA18",
+ regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+ GROUP_MA =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
+ PREF_NOEUD =SIMP(statut='f',typ='TXM',defaut="NS"),
+ PREF_NUME =SIMP(statut='f',typ='I',defaut= 1 ),
+ ),
QUAD_LINE =FACT(statut='f',fr="Passage quadratique -> linéaire",
regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
),
),
) ;
-#& MODIF COMMANDE DATE 28/07/2009 AUTEUR TORKHANI M.TORKHANI
+#& MODIF COMMANDE DATE 28/06/2010 AUTEUR FLEJOU J-L.FLEJOU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
fr="Création d'une table à partir d'une fonction ou de deux listes",
reentrant='f',UIinfo={"groupes":("Table",)},
- regles=(EXCLUS('FONCTION','LISTE'),),
+ regles=(EXCLUS('FONCTION','LISTE','RESU'),),
LISTE=FACT(statut='f',max='**',
fr="Creation d'une table a partir de listes",
fr="Liste des paramètres de sensibilité.",
ang="List of sensitivity parameters"),
),
+ RESU=FACT(statut='f',max=1,
+ fr="Creation d'une table a partir d'un resultat ou d'un champ",
+ regles=(UN_PARMI('CHAM_GD','RESULTAT'),
+ UN_PARMI('TOUT_CMP','NOM_CMP'),
+ PRESENT_ABSENT('TOUT','GROUP_MA','GROUP_NO','MAILLE','NOEUD',),
+ AU_MOINS_UN('TOUT','GROUP_MA','GROUP_NO','MAILLE','NOEUD',),
+ ),
+ CHAM_GD =SIMP(statut='f',typ=cham_gd_sdaster),
+ RESULTAT =SIMP(statut='f',typ=(resultat_sdaster) ),
+ b_resultat =BLOC(condition = "RESULTAT != None",
+ regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST',
+ 'MODE','LIST_MODE','FREQ','LIST_FREQ'),),
+ 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',max='**'),
+ LIST_ORDRE =SIMP(statut='f',typ=(listis_sdaster) ),
+ INST =SIMP(statut='f',typ='R',max='**'),
+ LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ),
+ MODE =SIMP(statut='f',typ='I',max='**'),
+ LIST_MODE =SIMP(statut='f',typ=(listis_sdaster) ),
+ FREQ =SIMP(statut='f',typ='R',max='**'),
+ 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',),),
+ ),
+ TOUT_CMP =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ NOM_CMP =SIMP(statut='f',typ='TXM',max='**'),
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+ MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+ NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
+ ),
+
TYPE_TABLE = SIMP(statut='f', typ='TXM', defaut="TABLE",
into=('TABLE', 'TABLE_FONCTION', 'TABLE_CONTENEUR'),),
VALE =SIMP(statut='o',typ='R',),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 27/04/2010 AUTEUR DESOZA T.DESOZA
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DESOZA T.DESOZA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
defaut="DISCRETE",
into=("DISCRETE","CONTINUE","XFEM","LIAISON_UNIL",),),
-# PARAMETRE GENERAL: FROTTEMENT (A TERME DEVRA ETRE AU NIVEAU ZONE)
+# PARAMETRE GENERAL: FROTTEMENT
- FROTTEMENT =SIMP(statut='f',
- typ='TXM',
- position='global',
- defaut="SANS",
- into=("COULOMB","SANS",)),
+ FROTTEMENT =SIMP(statut='f',
+ typ='TXM',
+ position='global',
+ 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: APPARIEMENT
-
- LISSAGE =SIMP(statut='f',
- typ='TXM',
- defaut="NON",
- into=("OUI","NON"),),
-
# PARAMETRE GENERAL: VERIFICATION DE L'ORIENTATION ET DE LA COHERENCE DES NORMALES
VERI_NORM =SIMP(statut='f',
),
),
-
# PARAMETRE GENERAL: BOUCLE SUR CONTACT
b_bouc_cont_disc=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 ),
- STOP_INTERP = SIMP(statut='f',typ='TXM',defaut="NON",
- into=("OUI","NON")),
- TOLE_INTERP = SIMP(statut='f',typ='R',defaut = 0.),
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="Autorise-t-on de sortir du domaine admissible lors de la recherche lineaire",),
),
), #fin bloc b_contact
-
+
## AFFECTATIONS (ZONES PAR ZONES)
# AFFECTATION - CAS LIAISON_UNILATERALE
# -- Incompatibilité avec CL
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
# -- 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='**'),
+
+# -- 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.),
+ ),
# -- Résolution
ALGO_CONT =SIMP(statut='o',typ='TXM',defaut="CONTRAINTE",
- into=("CONTRAINTE","LAGRANGIEN","PENALISATION","VERIF","GCP"),),
+ into=("CONTRAINTE","LAGRANGIEN","PENALISATION","GCP"),),
b_active=BLOC(condition = "ALGO_CONT == 'CONTRAINTE' ",
fr="Paramètres de la méthode des contraintes actives (contact uniquement)",
),
),
- b_verif=BLOC(condition = "ALGO_CONT == 'VERIF' ",
- fr="Paramètres de la méthode sans calcul de contact",
- GROUP_MA_FOND =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- ),
b_penal_contact=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
fr="Paramètres de la méthode pénalisée (contact)",
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",
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.),
+ ),
+
# -- 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","NON"),),
+ CONTACT_INIT =SIMP(statut='f',typ='TXM',defaut="NON",
+ into=("OUI","INTERPENETRE","NON"),),
GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
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_NO_FR != None",
- fr="Direction(s) de frottement à exclure",
- EXCL_FROT_1 =SIMP(statut='f',typ='R',min=3,max=3),
- EXCL_FROT_2 =SIMP(statut='f',typ='R',min=3,max=3),
+ 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",
INFO =SIMP(statut='f',typ='I',into=(1,2) ),
)
-#& MODIF COMMANDE DATE 24/08/2009 AUTEUR GENIAUT S.GENIAUT
+#& MODIF COMMANDE DATE 27/09/2010 AUTEUR GENIAUT S.GENIAUT
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
CHAM_NO_LST =SIMP(statut='f',typ=cham_no_sdaster,min=1,max=1),
GROUP_MA_FISS =SIMP(statut='f',typ=grma,min=1,max=1),
GROUP_MA_FOND =SIMP(statut='f',typ=grma,min=1,max=1),
- FORM_FISS =SIMP(statut='f',typ='TXM',into=("ELLIPSE","CYLINDRE","DEMI_PLAN","SEGMENT","DEMI_DROITE","INCLUSION","DROITE") ),
+ FORM_FISS =SIMP(statut='f',typ='TXM',into=("ELLIPSE","RECTANGLE","CYLINDRE","DEMI_PLAN",
+ "SEGMENT","DEMI_DROITE","INCLUSION","DROITE") ),
b_ellipse =BLOC(condition = "FORM_FISS == 'ELLIPSE' ",fr="Paramètres de la fissure elliptique",
- DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
- DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+ DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
+ DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
+ CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
+ VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
+ VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),
+ COTE_FISS =SIMP(statut='f',typ='TXM',defaut="IN",into=("IN","OUT",) ), ),
+ b_rectangle =BLOC(condition = "FORM_FISS == 'RECTANGLE' ",fr="Paramètres de la fissure rectangulaire",
+ DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
+ DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
+ RAYON_CONGE =SIMP(statut='f',typ='R',val_min=0.,defaut=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),
COTE_FISS =SIMP(statut='f',typ='TXM',defaut="IN",into=("IN","OUT",) ), ),
b_cylindre =BLOC(condition = "FORM_FISS == 'CYLINDRE' ",fr="Paramètres de la fissure cylindrique",
- DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
- DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+ DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
+ DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),),
POINT =SIMP(statut='o',typ='R',min=3,max=3),
DTAN =SIMP(statut='o',typ='R',min=3,max=3),),
b_inclusion =BLOC(condition = "FORM_FISS == 'INCLUSION' ",fr="Paramètres de l'interface 2D (inclusion)",
- DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
- DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+ DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.),
+ DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.),
CENTRE =SIMP(statut='o',typ='R',min=3,max=3),
VECT_X =SIMP(statut='o',typ='R',min=3,max=3),
VECT_Y =SIMP(statut='o',typ='R',min=3,max=3),),
# partie du maillage potentiellement enrichie
# ------------------------------------------------------------------------------------------------------------------------
- GROUP_MA_ENRI =SIMP(statut='o',typ=grma,max=01),
+ GROUP_MA_ENRI =SIMP(statut='f',typ=grma,max=01),
# ------------------------------------------------------------------------------------------------------------------------
# types d'enrichissement
UNITE =SIMP(statut='f',typ='I',defaut=8),
),
) ;
-#& MODIF COMMANDE DATE 02/02/2010 AUTEUR PELLET J.PELLET
+#& MODIF COMMANDE DATE 21/06/2010 AUTEUR MACOCCO K.MACOCCO
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NOEUD_CENTRE =SIMP(statut='f',typ=no),
GROUP_NO_CENTRE =SIMP(statut='f',typ=grno),
RAYON =SIMP(statut='o',typ='R' ),
+ CRIT_NOEUD = SIMP(statut='f',typ='TXM',defaut="AU_MOINS_UN",
+ into=("TOUS","AU_MOINS_UN","MAJORITE"),),
),
b_cylindre =BLOC(condition = "OPTION == 'CYLINDRE'",
regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),
RAYON =SIMP(statut='o',typ='R' ),
ANGL_NAUT =SIMP(statut='f',typ='R',max=2),
VECT_NORMALE =SIMP(statut='f',typ='R',max=3),
+ CRIT_NOEUD = SIMP(statut='f',typ='TXM',defaut="AU_MOINS_UN",
+ into=("TOUS","AU_MOINS_UN","MAJORITE"),),
),
b_bande =BLOC(condition = "OPTION == 'BANDE'",
regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),
DIST =SIMP(statut='o',typ='R' ),
ANGL_NAUT =SIMP(statut='f',typ='R',max=2),
VECT_NORMALE =SIMP(statut='f',typ='R',max=3),
+ CRIT_NOEUD = SIMP(statut='f',typ='TXM',defaut="AU_MOINS_UN",
+ into=("TOUS","AU_MOINS_UN","MAJORITE"),),
),
b_app_lache =BLOC(condition = "OPTION == 'APPUI_LACHE'",
regles=(UN_PARMI('NOEUD','GROUP_NO'),),
ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
INFO =SIMP(statut='f',typ='I',into=( 1 , 2 ) ),
) ;
+#& MODIF COMMANDE DATE 06/05/2008 AUTEUR CORUS M.CORUS
+# 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 CORUS M.CORUS
+
+DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas,
+ reentrant='n',
+ UIinfo={"groupes":("Matrices/vecteurs",)},
+ 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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 06/05/2008 AUTEUR CORUS M.CORUS
-# 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 CORUS M.CORUS
-
-DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas,
- reentrant='n',
- UIinfo={"groupes":("Matrices/vecteurs",)},
- 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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 22/09/2009 AUTEUR SELLENET N.SELLENET
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DESOZA T.DESOZA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
ECHEC =FACT(statut='d',max='**',
- EVENEMENT =SIMP(statut='f',typ='TXM',into=("DIVERGENCE",),defaut="DIVERGENCE",max=1 ),
+ EVENEMENT =SIMP(statut='f',typ='TXM',into=("ERREUR","DELTA_GRANDEUR"),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
+ VALE_REF =SIMP(statut='o',typ='R',max=1),
+ NOM_CHAM =SIMP(statut='o',typ='TXM',into=("DEPL","VARI_ELGA","SIEF_ELGA",),max=1),
+ NOM_CMP =SIMP(statut='o',typ='TXM',max=1),
+ ),
+
+ b_subd_erreur = BLOC(condition="EVENEMENT == 'ERREUR'",
+ SUBD_METHODE =SIMP(statut='f',typ='TXM',into =("AUCUNE","UNIFORME","EXTRAPOLE"),defaut="UNIFORME",max=1,
+ fr="Méthode de subdivision des pas de temps en cas de divergence pour erreur"),
+ ),
+
+ b_subd_event = BLOC(condition="EVENEMENT == 'DELTA_GRANDEUR'",
+ SUBD_METHODE =SIMP(statut='f',typ='TXM',into =("AUCUNE","UNIFORME"),defaut="UNIFORME",max=1,
+ fr="Méthode de subdivision des pas de temps en cas de diconvergence pour event-driven"),
+ ),
+
SUBD_METHODE =SIMP(statut='f',typ='TXM',into =("AUCUNE","UNIFORME","EXTRAPOLE"),defaut="UNIFORME",max=1,
fr="Méthode de subdivision des pas de temps en cas de diconvergence"),
b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
- regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,max=1,
fr="Coefficient multiplicateur de la 1ère subdivision"),
SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,max=1,
fr="Nombre de subdivision d'un pas de temps"),
+
+ b_subd_unif_manu = BLOC(condition="METHODE == 'MANUEL'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,defaut=3,max=1,
fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
SUBD_PAS_MINI=SIMP(statut='f',typ='R',defaut=0.,val_min=0.0,max=1,
fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+
+ b_subd_unif_auto = BLOC(condition="METHODE == 'AUTO'",
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',defaut=0.,val_min=0.0,max=1,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+
+
),
b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
- regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
SUBD_OPTION =SIMP(statut='f',typ='TXM',
into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
defaut="IGNORE_PREMIERES",
SUBD_ITER_FIN =SIMP(statut='f',typ='I',defaut=8,val_min=3,max=1,
fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,max=1,
- fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ fr="Nombre de subdivision d'un pas de temps en cas ERREUR"),
+
+ b_subd_unif_manu = BLOC(condition="METHODE == 'MANUEL'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,max=1,
fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
SUBD_PAS_MINI=SIMP(statut='f',typ='R',defaut=0.,val_min=0.0,max=1,
fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+
+ b_subd_unif_auto = BLOC(condition="METHODE == 'AUTO'",
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',defaut=0.,val_min=0.0,max=1,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+
SUBD_ITER_PLUS =SIMP(statut='f',typ='I',defaut=50,val_min=20,max=1,
fr="% itération autorisée en plus"),
),
GROUP_NO_FIN =SIMP(statut='f',typ=grno),
),
) ;
-#& MODIF COMMANDE DATE 20/04/2010 AUTEUR JAUBERT A.JAUBERT
+#& MODIF COMMANDE DATE 12/07/2010 AUTEUR PROIX J-M.PROIX
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
'ELAS_HYPER','ELAS_2NDG',),
EXCLUS('THER','THER_FO','THER_ORTH','THER_NL'),
EXCLUS('ECRO_LINE','ECRO_LINE_FO','ECRO_PUIS'),
+ EXCLUS('ENDO_HETEROGENE'),
EXCLUS('TAHERI','TAHERI_FO'),
EXCLUS('ROUSSELIER','ROUSSELIER_FO'),
EXCLUS('VISC_SINH','VISC_SINH_FO'),
EXCLUS('VISCOCHAB','VISCOCHAB_FO'),
EXCLUS('LEMAITRE','LEMAITRE_FO','VISC_IRRA_LOG',
'LEMA_SEUIL','LEMA_SEUIL_FO','LEMAITRE_IRRA','LMARC_IRRA',),
- EXCLUS('LMARC','LMARC_FO'),
EXCLUS('META_LEMA_ANI','META_LEMA_ANI_FO'),
EXCLUS('VMIS_POUTRE','VMIS_POUTRE_FO'),
EXCLUS('VENDOCHAB','VENDOCHAB_FO'),
),
ELAS_HYPER =FACT(statut='f',
regles=(UN_PARMI('K','NU'),),
- C10 =SIMP(statut='f',typ='R',defaut=0.0),
- C01 =SIMP(statut='o',typ='R'),
- C20 =SIMP(statut='f',typ='R',defaut=0.0),
- K =SIMP(statut='f',typ='R'),
- RHO =SIMP(statut='f',typ='R',defaut=0.0),
- NU =SIMP(statut='f',typ='R',val_min=-1.E+0,val_max=0.5E+0),
+ C10 =SIMP(statut='o',typ='R',
+ fr="Si C10 est le seul coefficient fourni, alors le matériau est Néo-Hookéen."),
+ C01 =SIMP(statut='f',typ='R',defaut=0.0,
+ fr="Si l'on fournit C01 en plus de C10, on obtient un matériau de type Mooney-Rivlin."),
+ C20 =SIMP(statut='f',typ='R',defaut=0.0,
+ fr="Si l'on fournit C20 en plus de C10 et C01, on obtient un matériau de type Signorini."),
+ K =SIMP(statut='f',typ='R',fr="Module de compressibilité."),
+ NU =SIMP(statut='f',typ='R',val_min=-1.E+0,val_max=0.5E+0,fr="Coefficient de Poisson."),
+ RHO =SIMP(statut='f',typ='R',defaut=0.0,fr="Masse volumique."),
),
ELAS_COQUE =FACT(statut='f',
regles=(EXCLUS('MEMB_L','M_LLLL',),
D_SIGM_EPSI =SIMP(statut='o',typ='R',),
SY =SIMP(statut='o',typ='R',),
),
+ ENDO_HETEROGENE =FACT(statut='f',
+ WEIBULL =SIMP(statut='o',typ='R',),
+ SY =SIMP(statut='o',typ='R',),
+ KI =SIMP(statut='o',typ='R',),
+ EPAI =SIMP(statut='o',typ='R',),
+ GR =SIMP(statut='f',typ='R',defaut= 1.0),
+ ),
ECRO_LINE_FO =FACT(statut='f',
D_SIGM_EPSI =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
SY =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
N =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
UN_SUR_K =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
UN_SUR_M =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- ),
- LMARC =FACT(statut='f',
- DE_0 =SIMP(statut='o',typ='R'),
- R_0 =SIMP(statut='o',typ='R'),
- N =SIMP(statut='o',typ='R'),
- K =SIMP(statut='o',typ='R'),
- Y_I =SIMP(statut='o',typ='R'),
- Y_0 =SIMP(statut='o',typ='R'),
- B =SIMP(statut='o',typ='R'),
- A_0 =SIMP(statut='o',typ='R'),
- RM =SIMP(statut='o',typ='R'),
- M =SIMP(statut='o',typ='R'),
- P =SIMP(statut='o',typ='R'),
- P1 =SIMP(statut='o',typ='R'),
- P2 =SIMP(statut='o',typ='R'),
- M11 =SIMP(statut='o',typ='R'),
- M22 =SIMP(statut='o',typ='R'),
- M33 =SIMP(statut='o',typ='R'),
- M66 =SIMP(statut='o',typ='R'),
- N11 =SIMP(statut='o',typ='R'),
- N22 =SIMP(statut='o',typ='R'),
- N33 =SIMP(statut='o',typ='R'),
- N66 =SIMP(statut='o',typ='R'),
- Q11 =SIMP(statut='o',typ='R'),
- Q22 =SIMP(statut='o',typ='R'),
- Q33 =SIMP(statut='o',typ='R'),
- Q66 =SIMP(statut='o',typ='R'),
- R11 =SIMP(statut='o',typ='R'),
- R22 =SIMP(statut='o',typ='R'),
- R33 =SIMP(statut='o',typ='R'),
- R66 =SIMP(statut='o',typ='R'),
- ),
- LMARC_FO =FACT(statut='f',
- DE_0 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- R_0 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- N =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- K =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Y_I =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Y_0 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- B =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- A_0 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- RM =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- M =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- P =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- P1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- P2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- M11 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- M22 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- M33 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- M66 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- N11 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- N22 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- N33 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- N66 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Q11 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Q22 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Q33 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Q66 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- R11 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- R22 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- R33 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- R66 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
),
META_LEMA_ANI =FACT(statut='f',
F1_A =SIMP(statut='o',typ='R'),
COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
),
),
+
+
+ THM_RUPT =FACT(statut='f',
+ OUV_FICT =SIMP(statut='o',typ='R'),
+ UN_SUR_N =SIMP(statut='f',typ='R',defaut= 0.),
+ ),
#
# autres comportements ...
#
),
DILAT =SIMP(statut='f',typ='R',defaut=0.0),
),
+
+ DRUCK_PRAGER_FO =FACT(statut='f',
+ ALPHA =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+ SY =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+ P_ULTM =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+ ECROUISSAGE = SIMP(statut='o',typ='TXM',into=("LINEAIRE","PARABOLIQUE")),
+ b_lineaire =BLOC(condition="ECROUISSAGE=='LINEAIRE'",
+ fr="Loi de comportement de type Drucker Prager avec un ecrouissage lineaire",
+ H =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+ TYPE_DP =SIMP(statut='c',typ='R',defaut= 1.0,),
+ ),
+ b_parabolique =BLOC(condition="ECROUISSAGE=='PARABOLIQUE'",
+ fr="Loi de comportement de type Drucker Prager avec un ecrouissage parabolique",
+ SY_ULTM =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+ TYPE_DP =SIMP(statut='c',typ='R',defaut= 2.0,),
+ ),
+ DILAT =SIMP(statut='f',typ='R',defaut=0.0),
+ ),
+
VISC_DRUC_PRAG =FACT(statut='f',
PREF =SIMP(statut='o',typ='R',fr="pression de reference"),
A =SIMP(statut='o',typ='R',fr="parametre carcaterisant l amplitude de la vitesse de fluage"),
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",),),
+ 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"),
+ H =SIMP(statut='f',typ='R'),
+ H1 =SIMP(statut='f',typ='R',defaut=0.124,fr="matrice d'interaction, terme a*",),
+ H2 =SIMP(statut='f',typ='R',defaut=0.625,fr="matrice d'interaction, terme a_colineaire",),
+ H3 =SIMP(statut='f',typ='R',defaut=0.137,fr="matrice d'interaction, terme a_glissile",),
+ H4 =SIMP(statut='f',typ='R',defaut=0.122,fr="matrice d'interaction, terme a_Lomer",),
+ H5 =SIMP(statut='f',typ='R',defaut=0.07,fr="matrice d'interaction, terme a_Hirth",),
+ ),
+
#### MONOCRISTAL
- DRUCK_PRAGER_FO =FACT(statut='f',
- ALPHA =SIMP(statut='o',typ=(fonction_sdaster,formule)),
- SY =SIMP(statut='o',typ=(fonction_sdaster,formule)),
- P_ULTM =SIMP(statut='o',typ=(fonction_sdaster,formule)),
- ECROUISSAGE = SIMP(statut='o',typ='TXM',into=("LINEAIRE","PARABOLIQUE")),
- b_lineaire =BLOC(condition="ECROUISSAGE=='LINEAIRE'",
- fr="Loi de comportement de type Drucker Prager avec un ecrouissage lineaire",
- H =SIMP(statut='o',typ=(fonction_sdaster,formule)),
- TYPE_DP =SIMP(statut='c',typ='R',defaut= 1.0,),
- ),
- b_parabolique =BLOC(condition="ECROUISSAGE=='PARABOLIQUE'",
- fr="Loi de comportement de type Drucker Prager avec un ecrouissage parabolique",
- SY_ULTM =SIMP(statut='o',typ=(fonction_sdaster,formule)),
- TYPE_DP =SIMP(statut='c',typ='R',defaut= 2.0,),
- ),
- DILAT =SIMP(statut='f',typ='R',defaut=0.0),
- ),
+### UMAT
+ UMAT =FACT(statut='f',
+ C1 =SIMP(statut='f',typ='R'),
+ C2 =SIMP(statut='f',typ='R'),
+ C3 =SIMP(statut='f',typ='R'),
+ C4 =SIMP(statut='f',typ='R'),
+ C5 =SIMP(statut='f',typ='R'),
+ C6 =SIMP(statut='f',typ='R'),
+ C7 =SIMP(statut='f',typ='R'),
+ C8 =SIMP(statut='f',typ='R'),
+ C9 =SIMP(statut='f',typ='R'),
+ C10 =SIMP(statut='f',typ='R'),
+ C11 =SIMP(statut='f',typ='R'),
+ C12 =SIMP(statut='f',typ='R'),
+ C13 =SIMP(statut='f',typ='R'),
+ C14 =SIMP(statut='f',typ='R'),
+ C15 =SIMP(statut='f',typ='R'),
+ C16 =SIMP(statut='f',typ='R'),
+ C17 =SIMP(statut='f',typ='R'),
+ C18 =SIMP(statut='f',typ='R'),
+ C19 =SIMP(statut='f',typ='R'),
+ C20 =SIMP(statut='f',typ='R'),
+ C21 =SIMP(statut='f',typ='R'),
+ C22 =SIMP(statut='f',typ='R'),
+ C23 =SIMP(statut='f',typ='R'),
+ C24 =SIMP(statut='f',typ='R'),
+ C25 =SIMP(statut='f',typ='R'),
+ C26 =SIMP(statut='f',typ='R'),
+ C27 =SIMP(statut='f',typ='R'),
+ C28 =SIMP(statut='f',typ='R'),
+ C29 =SIMP(statut='f',typ='R'),
+ C30 =SIMP(statut='f',typ='R'),
+ C31 =SIMP(statut='f',typ='R'),
+ C32 =SIMP(statut='f',typ='R'),
+ C33 =SIMP(statut='f',typ='R'),
+ C34 =SIMP(statut='f',typ='R'),
+ C35 =SIMP(statut='f',typ='R'),
+ C36 =SIMP(statut='f',typ='R'),
+ C37 =SIMP(statut='f',typ='R'),
+ C38 =SIMP(statut='f',typ='R'),
+ C39 =SIMP(statut='f',typ='R'),
+ C40 =SIMP(statut='f',typ='R'),
+ C41 =SIMP(statut='f',typ='R'),
+ C42 =SIMP(statut='f',typ='R'),
+ C43 =SIMP(statut='f',typ='R'),
+ C44 =SIMP(statut='f',typ='R'),
+ C45 =SIMP(statut='f',typ='R'),
+ C46 =SIMP(statut='f',typ='R'),
+ C47 =SIMP(statut='f',typ='R'),
+ C48 =SIMP(statut='f',typ='R'),
+ C49 =SIMP(statut='f',typ='R'),
+ C50 =SIMP(statut='f',typ='R'),
+ ),
+ UMAT_FO =FACT(statut='f',
+ C1 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C2 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C3 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C4 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C5 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C6 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C7 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C8 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C9 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C10 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C11 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C12 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C13 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C14 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C15 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C16 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C17 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C18 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C19 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C20 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C21 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C22 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C23 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C24 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C25 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C26 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C27 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C28 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C29 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C30 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C31 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C32 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C33 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C34 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C35 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C36 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C37 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C38 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C39 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C40 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C41 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C42 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C43 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C44 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C45 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C46 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C47 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C48 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C49 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ C50 =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+ ),
+### UMAT
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
ang="Value of the parameter"),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 16/11/2009 AUTEUR ASSIRE A.ASSIRE
+#& MODIF COMMANDE DATE 26/10/2010 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
CHARGE =SIMP(statut='f',typ=(char_meca,char_cine_meca)),),
# Methode de partitionnement
- METHODE =SIMP(statut='f',typ='TXM',into=("PMETIS","SCOTCH","KMETIS",), defaut="SCOTCH" ),
+ METHODE =SIMP(statut='f',typ='TXM',into=("PMETIS","SCOTCH","KMETIS",), defaut="KMETIS" ),
LOGICIEL =SIMP(statut='f',typ='TXM'),
CHARGE =SIMP(statut='f',typ=(char_meca,char_cine_meca)),
),
);
-#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+#& MODIF COMMANDE DATE 26/10/2010 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
NB_PART =SIMP(statut='o',typ='I',),
# Methode de partitionnement
- METHODE =SIMP(statut='f',typ='TXM',into=("PMETIS","SCOTCH","KMETIS",), defaut="SCOTCH" ),
+ METHODE =SIMP(statut='f',typ='TXM',into=("PMETIS","SCOTCH","KMETIS",), defaut="KMETIS" ),
LOGICIEL =SIMP(statut='f',typ='TXM'),
INFO =SIMP(statut='f',typ='I',into=(1, 2), defaut=1),
);
-#& MODIF COMMANDE DATE 28/12/2009 AUTEUR COURTOIS M.COURTOIS
+#& MODIF COMMANDE DATE 14/06/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
# 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 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 04/10/2010 AUTEUR GREFFET N.GREFFET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
),
SOLVEUR =FACT(statut='d',
- METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
NB_POIN_PERIODE =SIMP(statut='f',typ='I',defaut= 50 ),
NMAX_ITER_PAS =SIMP(statut='f',typ='I',defaut= 16 ),
PAS_CALCUL =SIMP(statut='f',typ='I',defaut= 1 ),
+ PAS_MINI =SIMP(statut='f',typ='R' ),
),
ARCHIVAGE =FACT(statut='f',
regles=(UN_PARMI('LIST_ARCH','PAS_ARCH', ),),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 12/04/2010 AUTEUR MICHEL S.MICHEL
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DESOZA T.DESOZA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
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",) ),
- EXCIT =FACT(statut='o',max='**',
+ EXCIT =FACT(statut='f',max='**',
regles=(PRESENT_ABSENT('FONC_MULT','ACCE'),
PRESENT_PRESENT('ACCE','VITE','DEPL'),
# PRESENT_ABSENT('MULT_APPUI','FONC_MULT'),
INST_ETAT_INIT =SIMP(statut='f',typ='R'),
),),
#-------------------------------------------------------------------
- INCREMENT =FACT(statut='o',
- regles=(EXCLUS('NUME_INST_FIN','INST_FIN'),),
- LIST_INST =SIMP(statut='o',typ=(listr8_sdaster,list_inst)),
- INST_INIT =SIMP(statut='f',typ='R'),
- NUME_INST_INIT =SIMP(statut='f',typ='I'),
- NUME_INST_FIN =SIMP(statut='f',typ='I'),
- INST_FIN =SIMP(statut='f',typ='R'),
- ERRE_TEMPS =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
- fr="Adaptation temporelle pour les modélisations HM instationnaires",
- ang="Time adaptation for unstationary HM models"),
- PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6 ),
- ),
+ INCREMENT =C_INCREMENT(),
#-------------------------------------------------------------------
SCHEMA_TEMPS =FACT(statut='o',
SCHEMA =SIMP(statut='o',min=1,max=1,typ='TXM',
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),
),
- SOLVEUR =FACT(statut='d',
- METHODE=SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","FETI","PETSC") ),
- b_mult_front =BLOC(condition= "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
- RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
- ),
- b_ldlt =BLOC(condition= "METHODE == 'LDLT'",fr="Paramètres de la méthode LDLT",
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
- ),
- b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
- fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
- NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
- STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON","DECOUPE") ),
- ),
- 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")),
- 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")),
- ),
- b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","LDLT_SP",),defaut="LDLT_INC" ),
- b_ldltinc =BLOC(condition = "PRE_COND == 'LDLT_INC' ", fr="Paramètres de la factorisation incomplète",
- NIVE_REMPLISSAGE =SIMP(statut='f',typ='I',defaut= 0 ),
- 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, ),
- ),
- RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
- NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
- ),
- 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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
- NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
- REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
- ),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
- RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6),
- NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
- ),
- SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
- ),
#-------------------------------------------------------------------
- CONVERGENCE =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",
- regles=(AU_MOINS_UN('SIGM_REFE','EPSI_REFE','FLUX_THER_REFE',
- 'FLUX_HYD1_REFE','FLUX_HYD2_REFE','VARI_REFE'),),
- SIGM_REFE =SIMP(statut='f',typ='R'),
- EPSI_REFE =SIMP(statut='f',typ='R'),
- FLUX_THER_REFE =SIMP(statut='f',typ='R'),
- FLUX_HYD1_REFE =SIMP(statut='f',typ='R'),
- FLUX_HYD2_REFE =SIMP(statut='f',typ='R'),
- VARI_REFE =SIMP(statut='f',typ='R'),
- ),
- RESI_REFE_RELA =SIMP(statut='f',typ='R'),
- RESI_GLOB_MAXI =SIMP(statut='f',typ='R'),
- RESI_GLOB_RELA =SIMP(statut='f',typ='R'),
- RESI_COMP_RELA =SIMP(statut='f',typ='R'),
- ITER_GLOB_MAXI =SIMP(statut='f',typ='I',defaut=10),
- ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25),
- TYPE =SIMP(statut='f',typ='TXM',defaut="PIC",into=("PIC","PLATEAU")),
- b_plateau =BLOC(condition = "TYPE == 'PLATEAU' ",
-
- PLATEAU_ITER =SIMP(statut='f',typ='I',defaut=3, val_min =2),
- PLATEAU_RELA =SIMP(statut='f',typ='R',defaut=1E-3),
- ),
- ARRET =SIMP(statut='f',typ='TXM',defaut="OUI"),
-
- ),
+ RECH_LINEAIRE =C_RECH_LINEAIRE(),
+#-------------------------------------------------------------------
+ CONVERGENCE =C_CONVERGENCE(),
+#-------------------------------------------------------------------
+ SOLVEUR =C_SOLVEUR(),
#-------------------------------------------------------------------
OBSERVATION =FACT(statut='f',max='**',
NOM_CMP =SIMP(statut='o',typ='TXM',max='**'),
"MATR_ASSE",
"ITER_DEBO",
"CTCD_ITER","CTCD_GEOM","CTCD_NOEU",
- "CTCC_GEOM","CTCC_FROT","CTCC_CONT",
+ "BOUC_GEOM","BOUC_FROT","BOUC_CONT","CTCC_BOUC","CTCC_NOEU",
"SUIV_1","SUIV_2","SUIV_3","SUIV_4",
),
),
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")),
),
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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
OPTION =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG") ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 19/04/2010 AUTEUR GREFFET N.GREFFET
+#& MODIF COMMANDE DATE 04/10/2010 AUTEUR GREFFET N.GREFFET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NB_POIN_PERIODE =SIMP(statut='f',typ='I',defaut= 50 ),
NMAX_ITER_PAS =SIMP(statut='f',typ='I',defaut= 16 ),
PAS_MAXI =SIMP(statut='f',typ='R' ),
+ PAS_MINI =SIMP(statut='f',typ='R' ),
),
ARCHIVAGE =FACT(statut='f',
regles=(UN_PARMI('LIST_ARCH','PAS_ARCH'),),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
-#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+#& MODIF COMMANDE DATE 14/06/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
-#& MODIF COMMANDE DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG
# 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" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",fr="Paramètres de la factorisation incomplete",
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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",
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
UIinfo={"groupes":("Fonction",)},
TYPE_FLUI_STRU =SIMP(statut='o',typ=(type_flui_stru) ),
) ;
-#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+#& MODIF COMMANDE DATE 05/07/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
elif VALE_C != None:
return formule_c
-def form_pyth_ops(self,d):
- NOM_PARA=self.etape['NOM_PARA']
+def form_pyth_ops(self, d):
+ NOM_PARA = self.etape['NOM_PARA']
VALE =self.etape['VALE']
VALE_C =self.etape['VALE_C']
if type(NOM_PARA) not in (list, tuple):
NOM_PARA = [NOM_PARA,]
+ for para in NOM_PARA:
+ if para.strip() != para:
+ raise AsException("nom de paramètre invalide (contient des blancs) : %s" % repr(para))
if self.sd == None:
return
if VALE != None :
UNITE = SIMP(statut='f',typ='I',defaut=38),
AJOUT = SIMP(statut='f', typ='TXM', defaut='NON', into=('OUI', 'NON')),
);
-#& MODIF COMMANDE DATE 12/04/2010 AUTEUR SELLENET N.SELLENET
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DELMAS J.DELMAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
VERSION =SIMP(statut='f',typ='R',defaut=1.2,into=(1.0,1.2)),
),
-
- RESTREINT =FACT(statut='f', max=1,
- fr="Pour réduire une ou plusieurs sd_resultat sur un ensemble de mailles",
- regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),),
- GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
- TOUT_GROUP_MA =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
- GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- TOUT_GROUP_NO =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
+ b_restreint =BLOC(condition="FORMAT=='MED'",fr="Seulement pour les fichiers MED",
+ RESTREINT =FACT(statut='f', max=1,
+ fr="Pour réduire une ou plusieurs sd_resultat sur un ensemble de mailles",
+ regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),),
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+ TOUT_GROUP_MA =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
+ GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+ TOUT_GROUP_NO =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
+ ),
),
RESU =FACT(statut='o',max='**',
TOUT_CMP =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NOM_CMP =SIMP(statut='f',typ='TXM',max='**'),
),
+###
+ 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='**'),
+ ),
###
b_gmsh=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and((FORMAT == 'GMSH'))""",
fr="sélection des composantes et des entités toplogiques",
),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 05/05/2008 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 26/10/2010 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
IMPR_STURM=PROC(nom="IMPR_STURM",op=32,fr="Calculer et imprimer le nombre de valeurs propres dans un intervalle donné",
UIinfo={"groupes":("Résolution",)},
- MATR_A =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ),
- MATR_B =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ),
+ MATR_A =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r) ),
+ MATR_B =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r,matr_asse_gene_r) ),
TYPE_RESU =SIMP(statut='f',typ='TXM',defaut="DYNAMIQUE",into=("MODE_FLAMB","DYNAMIQUE"),
fr="Type d analyse" ),
b_dynamique =BLOC(condition = "TYPE_RESU == 'DYNAMIQUE'",
CHAR_CRIT_MIN =SIMP(statut='o',typ='R',fr="Borne inférieure de l intervalle" ),
CHAR_CRIT_MAX =SIMP(statut='o',typ='R',fr="Borne supérieure de l intervalle" ),
),
- NPREC_SOLVEUR =SIMP(statut='f',typ='I',defaut= 8 ),
NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5 ),
UNITE =SIMP(statut='f',typ='I',defaut=8),
PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
SEUIL_FREQ =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
+
+ SOLVEUR =FACT(statut='d',
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","MUMPS")),
+ b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+ ),
+ b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","SANS") ),
+ ),
+ b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+ fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+ NPREC =SIMP(statut='f',typ='I',defaut= 8, val_min=0),
+ ),
+ 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")),
+ 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")),
+ ),
+ ),
+
) ;
#& MODIF COMMANDE DATE 06/05/2008 AUTEUR CNGUYEN C.NGUYEN
# CONFIGURATION MANAGEMENT OF EDF VERSION
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 30/09/2008 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 24/08/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
),
MAX =FACT(statut='f',fr="Extrémas locaux d'une fonction",
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster),max='**' ),
+ INTERVALLE =SIMP(statut='f',typ='R',min=2,max='**',
+ fr ="définition des bornes des intervalles sous forme de couples (xi_i1,xs_i1,xi_i2,xs_i2)"),
),
NORME =FACT(statut='f',fr="Norme L2 d'une fonction",
FONCTION =SIMP(statut='o', typ=nappe_sdaster),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 30/09/2008 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 14/06/2010 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 11/05/2009 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 22/06/2010 AUTEUR DEVESA G.DEVESA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
BASE =SIMP(statut='o',typ=mode_meca),
NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
FREQ_EXTR =SIMP(statut='o',typ='R',max=1),
- NOM_CMP =SIMP(statut='o',typ='TXM',into=("DX","DY","DZ") ),
+ NOM_CMP =SIMP(statut='f',typ='TXM',into=("DX","DY","DZ") ),
NOM_CHAM =SIMP(statut='f',typ='TXM',into=("DEPL","VITE","ACCE"),defaut="DEPL"),
- UNITE_RESU_FORC =SIMP(statut='f',typ='I',defaut=30),
+ NUME_CHAR =SIMP(statut='f',typ='I' ),
+ ISSF =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","OUI") ),
+ UNITE_RESU_FORC =SIMP(statut='f',typ='I',defaut=30),
+ NOM_RESU_FORC =SIMP(statut='f',typ='TXM' ),
) ;
-#& MODIF COMMANDE DATE 11/05/2009 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 22/06/2010 AUTEUR DEVESA G.DEVESA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
FREQ_EXTR =SIMP(statut='o',typ='R',max=1),
UNITE_RESU_IMPE =SIMP(statut='f',typ='I',defaut=30),
+ ISSF =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","OUI") ),
TYPE =SIMP(statut='f',typ='TXM',defaut="ASCII",into=("BINAIRE","ASCII") ),
+ SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","OUI") ),
) ;
#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
PRECISION =SIMP(statut='o',typ='R',),),),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 15/03/2010 AUTEUR SELLENET N.SELLENET
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DELMAS J.DELMAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
"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", "SIRE_ELNO_DEPL", "SIRE_NOEU_DEPL", "TEMP", "THETA",
+ "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",
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='**'),),
- ),
-
- b_mode =BLOC(condition="((TYPE_RESU=='MODE_MECA')or(TYPE_RESU=='MODE_MECA_C') )and (FORMAT=='IDEAS')",
- NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster),max=1,
- fr="Utile en dynamique pour pouvoir imposer la numérotation des cham_no."),
- ),
+ ),
# 1-3 ensight :
# -------------
# 2) blocs selon le type du résultat :
#---------------------------------
b_mode_meca =BLOC(condition="(TYPE_RESU=='MODE_MECA')or(TYPE_RESU=='MODE_MECA_C')",
- MATR_A =SIMP(statut='f',typ=matr_asse_depl_r,),
- MATR_B =SIMP(statut='f',typ=matr_asse_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."),
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 15/03/2010 AUTEUR GNICOLAS G.NICOLAS
+#& MODIF COMMANDE DATE 18/10/2010 AUTEUR GNICOLAS G.NICOLAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
#
# 2. Version de HOMARD
#
- VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_6",
- into=("V9_6", "V9_N", "V9_N_PERSO"),
+ VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_7",
+ into=("V9_7", "V9_N", "V9_N_PERSO"),
fr="Version de HOMARD",
ang="HOMARD release"),
#
ang="Additional mesh after adaptation" ),
#
# 5. Le pilotage de l'adaptation, avec les variantes suivantes :
-# . Raffinement et deraffinement, selon un champ d'indicateurs d'erreur
-# . Raffinement seul, selon un champ d'indicateurs d'erreur
-# . Deraffinement seul, selon un champ d'indicateurs d'erreur
+# . Raffinement et deraffinement, selon un champ
+# . Raffinement seul, selon un champ
+# . Deraffinement seul, selon un champ
# . Raffinement seul, selon des zones geometriques
# . Raffinement uniforme : toutes les mailles sont divisées
# . Deraffinement uniforme : toutes les mailles sont regroupées
into=("RAFF_DERA","RAFFINEMENT","DERAFFINEMENT","RAFFINEMENT_ZONE", \
"RAFFINEMENT_UNIFORME","DERAFFINEMENT_UNIFORME", \
"MODIFICATION","RIEN"),
- fr="Pilotage de l'adaptation : selon un indicateur d'erreur ou uniforme.",
- ang="Adaptation control : either among an error indicator or uniform" ),
+ fr="Pilotage de l'adaptation : selon un champ ou uniforme.",
+ ang="Adaptation control : either among an field or uniform" ),
#
-# 6. Pour de l'adaptation libre, il faut un indicateur d'erreur
+# 6. Pour de l'adaptation libre, il faut un champ ou une zone
#
- b_indicateur_d_erreur = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
- (ADAPTATION == 'RAFFINEMENT') or \
- (ADAPTATION == 'DERAFFINEMENT') " ,
- fr="Pour une adaptation libre, choix de l'indicateur d'erreur ou d'une zone à raffiner",
- ang="For a free adaptation, selection of the error indicator or of a zone",
+ b_champ = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
+ (ADAPTATION == 'RAFFINEMENT') or \
+ (ADAPTATION == 'DERAFFINEMENT') " ,
+ fr="Pour une adaptation libre, choix du champ ou d'une zone à raffiner",
+ ang="For a free adaptation, selection of the field or of a zone",
#
regles=(UN_PARMI('CHAM_GD','RESULTAT_N')),
#
-# 6.1. Repérage de la zone à raffiner à l'aide d'un indicateur
+# 6.1. Reperage de la zone a raffiner a l'aide d'un champ
#
# 6.1.1. Sous forme de champ de grandeur
#
CHAM_GD = SIMP(statut='f',typ=cham_gd_sdaster,
- fr="Champ de grandeur Code_Aster contenant l'indicateur d'erreur",
- ang="Code_Aster champ de grandeur with error indicator" ),
+ fr="Champ de grandeur Code_Aster pilotant l'adaptation",
+ ang="Code_Aster 'champ de grandeur' governing the adapatation" ),
#
# 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 l'indicateur d'erreur",
- ang="The Code_Aster result with error indicator" ),
+ fr="Concept resultat Code_Aster contenant le champ",
+ ang="The Code_Aster result with the field" ),
#
- b_champ_indicateur = BLOC(condition="(RESULTAT_N != None)",
- INDICATEUR = SIMP(statut='o',typ='TXM',
- fr="Champ de l'indicateur d'erreur dans le résultat",
- ang="The error indicator field in the result structure" ),
+ b_champ_adaptation = BLOC(condition="(RESULTAT_N != None)",
+ NOM_CHAM = SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO(),
+ fr="Champ dans le résultat",
+ ang="The field in the result structure" ),
),
#
-# 6.1.3. Est-ce un champ dérivé
+# 6.1.3. Est-ce un champ derive
#
b_sensibilite = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
fr="Est-ce un champ dérivé",
- ang="Is the indicator a derivative field",
+ ang="Is the field a derivative field",
#
SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),
fr="Paramètre de sensibilité.",
# 6.1.4. La ou les composantes retenues
#
b_composante = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
- fr="Choix de la composante ou des composantes pour l'indicateur",
- ang="Selection of the component(s) for the error indicator",
+ fr="Choix de la composante ou des composantes pour le champ",
+ ang="Selection of the component(s) for the field",
#
- NOM_CMP_INDICA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
- fr="Liste des composante(s) retenue(s) pour l'indicateur d'erreur.",
- ang="List of the selected component(s) for the error indicator." ),
+ 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." ),
#
),
#
-# 6.1.5. Le paramètre temporel pour l'indicateur
+# 6.1.5. Le paramètre temporel pour le champ
#
b_parametre_temporel = BLOC(condition="(RESULTAT_N != None)",
- fr="Choix éventuel du paramètre temporel pour l'indicateur",
- ang="Time selection for the error indicator (option)",
+ fr="Choix éventuel du paramètre temporel pour le champ",
+ ang="Time selection for the field (option)",
#
regles=(EXCLUS('NUME_ORDRE','INST'),),
#
#
),
#
-# 6.1.6. Type de valeur de l'indicateur : absolue (norme L2), norme infinie, ou relative
+# 6.1.6. Usage des composantes : maximum, maximum de la valeur absolue, ou de la norme L2, ou de la norme infinie
#
- b_valeur_indicateur = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
- fr="Type de valeur pour l'indicateur",
- ang="Type of the value type for the error indicator",
+ b_usage_cmp = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+ fr="Type d'usage de(s) composante(s)",
+ ang="Type of the use for the component(s)",
#
- TYPE_VALEUR_INDICA = SIMP(statut='f',typ='TXM',defaut="V_ABSOLUE",
- into=("V_ABSOLUE", "NORME_L2", "NORME_INFINIE", "V_RELATIVE"),
- fr="Valeur absolue, norme des composantes ou valeur relative pour l'indicateur",
- ang="Absolute value, norm or relative value for the error indicator" ),
+ USAGE_CMP = SIMP(statut='f',typ='TXM',defaut="NORME_L2",
+ into=("ABSOLU", "NORME_L2", "NORME_INFINIE", "RELATIF"),
+ fr="Valeur absolue de la composante, ou norme du champ, ou valeur relative de la composante",
+ ang="Absolute value of the component, or norm of the field, or relative value of the component" ),
#
),
#
-# 6.1.7. Type d'opération sur l'indicateur : la valeur par maille ou le max du saut entre mailles
+# 6.1.7. Usage du champ : la valeur par maille ou le max du saut entre mailles
#
- b_usage_indicateur = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
- fr="Usage de l'indicateur : direct ou saut",
- ang="Use type for the error indicator : direct or jump",
+ b_usage_champ = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+ fr="Usage du champ : direct ou saut",
+ ang="Use type for the field : direct or jump",
#
- TYPE_OPER_INDICA = SIMP(statut='f',typ='TXM',defaut="MAILLE",into=("MAILLE","SAUT"),
- fr="Usage de l'indicateur : la valeur par maille ou le saut entre mailles voisines",
- ang="Use of the indicator : value over every mesh or jump between neighbour" ),
+ USAGE_CHAMP = SIMP(statut='f',typ='TXM',defaut="MAILLE",into=("MAILLE","SAUT"),
+ fr="Usage du champ : la valeur par maille ou le saut entre mailles voisines",
+ ang="Use of the field : value over every mesh or jump between the neighbours" ),
#
),
#
) ,
#
-# 7. Les criteres pour de l'adaptation libre avec un indicateur d'erreur :
+# 7. Les criteres pour de l'adaptation libre avec un champ :
# absolu, relatif, en proportion d'entite
# 7.1. Pour le raffinement :
#
fr="Choix éventuel du nom du champ à interpoler",
ang="Selection for the name of the field (option)",
#
- NOM_CHAM = SIMP(statut='o',typ='TXM',
+ NOM_CHAM = SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO(),
fr="Nom du champ à mettre à jour",
ang="Name of the field to be updated" ),
#
PARM_THETA =SIMP(statut='f',typ='R',defaut= 0.57),
)
-#& MODIF COMMANDE DATE 11/05/2009 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 22/06/2010 AUTEUR DEVESA G.DEVESA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
b_matr_impe =BLOC(condition = "MATR_IMPE != None",
FREQ_EXTR =SIMP(statut='o',typ='R' ),
AMOR_SOL =SIMP(statut='f',typ='R',defaut=0.E+0 ),
+ MATR_IMPE_INIT =SIMP(statut='f',typ=matr_asse_gene_c ),
),
CAS_CHARGE =FACT(statut='f',max='**',
NOM_CAS =SIMP(statut='o',typ='TXM'),
# ======================================================================
# RESPONSABLE GNICOLAS G.NICOLAS
-from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
+from Macro.macr_fiabilite_ops import macr_fiabilite_ops
-MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
- docu="U7.04.41",UIinfo={"groupe":("Impression",)},
- fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
- ang="Print values for the fiability software",
#
-# 1. Le niveau d'information
+#====
+# 1. Le retour : une liste de rééls.
+#====
#
- INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+def macr_fiabilite_prod ( self , **args ):
+ return listr8_sdaster
#
-# 2. Impression de la valeur de la cible
+#====
+# 2. L'entete
+#====
#
-# 2.1. ==> La table contenant la valeur à imprimer
+MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops,
+ docu="U7.03.31",UIinfo={"groupe":("Post traitements",)},
+ sd_prod=macr_fiabilite_prod,
+ fr="Calcule les probabiltés de dépassement de seuil (mécanique de fiabilité).",
+ ang="Fiability mechanics.",
#
- TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
- fr="Table contenant la valeur cible.",
- ang="Table which includes the target value."),
+#====
+# 3. Le niveau d'information
+#====
#
-# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
+ INFO = SIMP(statut="f",typ="I",defaut=1,into=(1,2)),
#
- 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."),
+#====
+# 4. Nom et Version du logiciel de fiabilité
+#====
#
-# 3. Impressions des valeurs des éventuels gradients
+ LOGICIEL = SIMP(statut="f",typ="TXM",defaut="MEFISTO",
+ into=("MEFISTO",),
+ fr="Nom du logiciel de fiabilité.",
+ ang="Fiability software name."),
#
- GRADIENTS = FACT(statut='f',min=1,max='**',
+ VERSION = SIMP(statut="f",typ="TXM",defaut="V3_2",
+ into=("V3_2", "V3_N"),
+ fr="Version du logiciel de fiabilité.",
+ ang="Fiability software release."),
#
-# 3.1. ==> La table contenant la valeur à imprimer
+#====
+# 5. Les entrees-sorties du calcul ASTER déterministe
+#====
#
- 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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
-# 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
-
-#
-#====
-# 1. Le retour : une liste de rééls.
-#====
-#
-def macr_fiabilite_prod ( self , **args ):
- return listr8_sdaster
-#
-#====
-# 2. L'entete
-#====
-#
-MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops,
- docu="U7.03.31",UIinfo={"groupe":("Post traitements",)},
- sd_prod=macr_fiabilite_prod,
- fr="Calcule les probabiltés de dépassement de seuil (mécanique de fiabilité).",
- ang="Fiability mechanics.",
-#
-#====
-# 3. Le niveau d'information
-#====
-#
- INFO = SIMP(statut="f",typ="I",defaut=1,into=(1,2)),
-#
-#====
-# 4. Nom et Version du logiciel de fiabilité
-#====
-#
- LOGICIEL = SIMP(statut="f",typ="TXM",defaut="MEFISTO",
- into=("MEFISTO",),
- fr="Nom du logiciel de fiabilité.",
- ang="Fiability software name."),
-#
- VERSION = SIMP(statut="f",typ="TXM",defaut="V3_2",
- into=("V3_2", "V3_N"),
- fr="Version du logiciel de fiabilité.",
- ang="Fiability software release."),
-#
-#====
-# 5. Les entrees-sorties du calcul ASTER déterministe
-#====
-#
-# 5.1. ==> Le jeu de commandes déterministe
+# 5.1. ==> Le jeu de commandes déterministe
#
UNITE_ESCL = SIMP(statut="o",typ="I",
fr="Unité logique associée aux commandes du calcul ASTER déterministe.",
),
#
);
-#& MODIF COMMANDE DATE 15/03/2010 AUTEUR GNICOLAS G.NICOLAS
+#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+# 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_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={"groupe":("Impression",)},
+ 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 18/10/2010 AUTEUR GNICOLAS G.NICOLAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
#
# 2. Version de HOMARD
#
- VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_6",
- into=("V9_6", "V9_N", "V9_N_PERSO"),
+ VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_7",
+ into=("V9_7", "V9_N", "V9_N_PERSO"),
fr="Version de HOMARD",
ang="HOMARD release"),
#
) ;
-#& MODIF COMMANDE DATE 22/04/2010 AUTEUR ASSIRE A.ASSIRE
-# 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é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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
-# 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":("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 19/01/2010 AUTEUR PELLET J.PELLET
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DELMAS J.DELMAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
"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","SIRE_ELNO_DEPL",
+ "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",
),
),
)
-#& MODIF COMMANDE DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
DIRE_ONDE =SIMP(statut='f',typ='R',max='**'),
),
) ;
-#& MODIF COMMANDE DATE 05/05/2008 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 13/10/2010 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NB_BLOC_FREQ =SIMP(statut='f',typ='I' ),
DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
- NPREC_SOLVEUR =SIMP(statut='f',typ='I',defaut= 8 ),
NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5 ),
PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 5.E-2 ),
SEUIL_FREQ =SIMP(statut='f',typ='R' ,defaut= 1.E-2 ),
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),
+ 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 22/04/2010 AUTEUR ASSIRE A.ASSIRE
+# 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é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 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
+# 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":("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),),),
),
- INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-) ;
+)
#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
ELEMENT =FACT(statut='f',),
) ;
-#& MODIF COMMANDE DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
ang="List of sensitivity parameters"),
SOLVEUR =FACT(statut='d',
- METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","FETI","MUMPS","PETSC") ),
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","FETI","MUMPS","PETSC")),
b_feti =BLOC(condition = "METHODE == 'FETI' ",fr="Paramètres de la méthode FETI 1",
PARTITION =SIMP(statut='o',typ=sd_feti_sdaster),
),
b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","LDLT_SP",),defaut="LDLT_INC" ),
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","LDLT_SP","SANS",),defaut="LDLT_INC" ),
b_ldltinc =BLOC(condition = "PRE_COND == 'LDLT_INC' ", fr="Paramètres de la factorisation incomplète",
NIVE_REMPLISSAGE =SIMP(statut='f',typ='I',defaut= 0 ),
RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 05/05/2009 AUTEUR BOITEAU O.BOITEAU
+#& MODIF COMMANDE DATE 13/10/2010 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NMAX_ITER_AJUSTE=SIMP(statut='f',typ='I',defaut= 15,val_min=0 ),
PREC_AJUSTE =SIMP(statut='f',typ='R',defaut= 1.E-4,val_min=0.E+0 ),
- NPREC_SOLVEUR =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0, ),
SEUIL_FREQ =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0, ),
+ ),
+ SOLVEUR =FACT(statut='d',
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","MUMPS")),
+ b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+ ),
+ b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","SANS") ),
+ ),
+ b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+ fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+ NPREC =SIMP(statut='f',typ='I',defaut= 8,val_min=0),
+ ),
+ 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")),
+ 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")),
+ ),
+ ),
+
),
- ),
b_flamb =BLOC(condition = "TYPE_RESU == 'MODE_FLAMB'",
CALC_FREQ =FACT(statut='o',fr="Choix des paramètres pour le calcul des valeurs propres",
NMAX_ITER_AJUSTE=SIMP(statut='f',typ='I',defaut= 15 ),
PREC_AJUSTE =SIMP(statut='f',typ='R',defaut= 1.E-4,val_min=0.E+0, ),
- NPREC_SOLVEUR =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0, ),
SEUIL_FREQ =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0, ),
+ ),
+ SOLVEUR =FACT(statut='d',
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","MUMPS")),
+ b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+ ),
+ b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","SANS") ),
+ ),
+ b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+ fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+ NPREC =SIMP(statut='f',typ='I',defaut= 8,val_min=0),
+ ),
+ 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")),
+ 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")),
+ ),
+ ),
+
),
- ),
CALC_MODE =FACT(statut='d',min=0,fr="Choix des paramètres pour le calcul des vecteurs propres",
OPTION =SIMP(statut='f',typ='TXM',defaut="DIRECT",into=("DIRECT","RAYLEIGH") ),
PREC =SIMP(statut='f',typ='R',defaut= 1.E-5,val_min=0.E+0,fr="Précision de convergence" ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
TITRE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
) ;
-#& MODIF COMMANDE DATE 05/05/2009 AUTEUR BOITEAU O.BOITEAU
+#& MODIF COMMANDE DATE 13/10/2010 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
- NPREC_SOLVEUR =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0 ),
SEUIL_FREQ =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
- ),
+ ),
+ SOLVEUR =FACT(statut='d',
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","MUMPS")),
+ b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+ ),
+ b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","SANS") ),
+ ),
+ b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+ fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+ NPREC =SIMP(statut='f',typ='I',defaut= 8,val_min=0),
+ ),
+ 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")),
+ 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")),
+ ),
+ ),
),
b_dynam =BLOC(condition = "TYPE_RESU == 'DYNAMIQUE'",
regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
- NPREC_SOLVEUR =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
PREC_SHIFT =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0 ),
SEUIL_FREQ =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
+ ),
+ SOLVEUR =FACT(statut='d',
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","MUMPS")),
+ b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+ ),
+ b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","SANS") ),
+ ),
+ b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+ fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+ NPREC =SIMP(statut='f',typ='I',defaut= 8,val_min=0),
+ ),
+ 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")),
+ 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")),
+ ),
+ ),
+
),
- ),
VERI_MODE =FACT(statut='d',min=0,
STOP_ERREUR =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 13/10/2009 AUTEUR COURTOIS M.COURTOIS
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
fr="Calcul de deformees statiques pour un déplacement, une force ou une accélération unitaire imposé",
reentrant='n',
UIinfo={"groupes":("Résolution",)},
+
+
+ regles=(UN_PARMI('MODE_STAT','FORCE_NODALE','PSEUDO_MODE','MODE_INTERF'),
+ PRESENT_PRESENT('MODE_INTERF','MATR_MASS'),
+ PRESENT_PRESENT('PSEUDO_MODE','MATR_MASS'),
+ ),
+
+
MATR_RIGI =SIMP(statut='o',typ=matr_asse_depl_r ),
MATR_MASS =SIMP(statut='f',typ=matr_asse_depl_r ),
- regles=(UN_PARMI('MODE_STAT','FORCE_NODALE','PSEUDO_MODE'),),
+
+
+
MODE_STAT =FACT(statut='f',max='**',
regles=(UN_PARMI('TOUT','NOEUD','GROUP_NO'),
UN_PARMI('TOUT_CMP','AVEC_CMP','SANS_CMP'),),
SANS_CMP =SIMP(statut='f',typ='TXM',max='**'),
),
),
+ MODE_INTERF =FACT(statut='f',max='**',
+ regles=(UN_PARMI('TOUT','NOEUD','GROUP_NO'),
+ UN_PARMI('TOUT_CMP','AVEC_CMP','SANS_CMP'),),
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",), ),
+ NOEUD =SIMP(statut='f',typ=no ,max='**'),
+ GROUP_NO =SIMP(statut='f',typ=grno ,max='**'),
+ TOUT_CMP =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ AVEC_CMP =SIMP(statut='f',typ='TXM',max='**'),
+ SANS_CMP =SIMP(statut='f',typ='TXM',max='**'),
+ NBMOD =SIMP(statut='o',typ='I',defaut= 1),
+ FREQ =SIMP(statut='o',typ='R',defaut= 1.0),
+ ),
SOLVEUR =FACT(statut='d', fr="Méthode de résolution des systèmes linéaires",
- METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
-
+ METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
- NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6),
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","LDLT_SP",),defaut="LDLT_INC" ),
+ b_ldltinc =BLOC(condition = "PRE_COND == 'LDLT_INC' ", fr="Paramètres de la factorisation incomplète",
+ NIVE_REMPLISSAGE =SIMP(statut='f',typ='I',defaut= 0 ),
+ 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, ),
+ ),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
),
),
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 16/06/2009 AUTEUR PELLET J.PELLET
+#& MODIF COMMANDE DATE 28/06/2010 AUTEUR PELLET J.PELLET
# 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.
+# 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
MODELE =SIMP(statut='o',typ=modele_sdaster,min=1,max=1,),
PARTITION =FACT(statut='d',
- PARALLELISME =SIMP(statut='f',typ='TXM',defaut="MAIL_DISPERSE",
- into=("MAIL_CONTIGU","MAIL_DISPERSE","SOUS_DOMAINE","CENTRALISE",)),
+ PARALLELISME =SIMP(statut='f',typ='TXM',defaut="GROUP_ELEM",
+ into=("MAIL_CONTIGU","MAIL_DISPERSE","SOUS_DOMAINE","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),
),
),
),
) ;
-#& MODIF COMMANDE DATE 20/04/2009 AUTEUR GENIAUT S.GENIAUT
+#& MODIF COMMANDE DATE 20/07/2010 AUTEUR MAHFOUZ D.MAHFOUZ
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
FISSURE =SIMP(statut='o',typ=fiss_xfem,min=1,max='**',),
CRITERE =SIMP(statut='f',typ='R',defaut=1.1E-4),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,)),
- CONTACT =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON"),min=1,max=1,),
+ CONTACT
+ =SIMP(statut='f',typ='TXM',defaut='SANS',into=("P1P1","P1P1A","P2P1","SANS"),min=1,max=1,),
) ;
#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
),
INFO =SIMP(statut='f',typ='I',into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 11/05/2009 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 21/06/2010 AUTEUR CORUS M.CORUS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
MODELE_GENE =SIMP(statut='f',typ=modele_gene ),
b_modele_gene =BLOC(condition = "MODELE_GENE != None",
STOCKAGE =SIMP(statut='f',typ='TXM',defaut="LIGN_CIEL",into=("LIGN_CIEL","PLEIN") ),
- METHODE =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("INITIAL","CLASSIQUE") ),
+ METHODE =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("INITIAL","CLASSIQUE","ELIMINE") ),
),
BASE =SIMP(statut='f',typ=(mode_meca,mode_gene ) ),
b_base =BLOC(condition = "BASE != None",
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 27/07/2009 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 09/08/2010 AUTEUR BARGELLINI 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.
+# ======================================================================
+# RESPONSABLE BARGELLINI R.BARGELLINI
+
+
+from Macro.post_bordet_ops import post_bordet_ops
+
+
+
+POST_BORDET =MACRO(nom="POST_BORDET", op=post_bordet_ops,sd_prod=table_sdaster,
+ docu="",reentrant='n',fr="calcul de la probabilite de clivage via le modele de Bordet",
+ regles=(UN_PARMI('TOUT','GROUP_MA'),
+ UN_PARMI('INST','NUME_ORDRE'),
+ ),
+ 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"),
+ INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+ 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"),
+ b_nucl =BLOC( condition = "PROBA_NUCL=='OUI'",
+ PARAM =FACT(statut='o',
+ M =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SIGM_REFE =SIMP(statut='o',typ=(fonction_sdaster),val_min=0.E+0),
+ VOLU_REFE =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SIG_CRIT =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SEUIL_REFE =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SEUIL_CALC =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster)),
+ DEF_PLAS_REFE =SIMP(statut='o',typ='R'),),),
+
+ b_prop =BLOC( condition = "PROBA_NUCL=='NON'",
+ PARAM =FACT(statut='o',
+ M =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SIGM_REFE =SIMP(statut='o',typ=fonction_sdaster,val_min=0.E+0),
+ VOLU_REFE =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SIG_CRIT =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SEUIL_REFE =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SEUIL_CALC =SIMP(statut='o',typ=(fonction_sdaster,nappe_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.),
+ )
+#& MODIF COMMANDE DATE 10/08/2010 AUTEUR GENIAUT S.GENIAUT
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=post_cham_xfem_prod,
reentrant='n',UIinfo={"groupes":("Post traitements",)},
- fr="Calcul des champs DEPL et SIEF_ELGA sur le maillage fissuré",
- MAILLAGE_SAIN = SIMP(statut='o',typ=maillage_sdaster),
- MAILLAGE_FISS = SIMP(statut='o',typ=maillage_sdaster),
- NOM_CHAM = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("DEPL","SIEF_ELGA","VARI_ELGA"),),
- MODELE = SIMP(statut='o',typ=modele_sdaster,),
+ fr="Calcul des champs DEPL, SIEF_ELGA et VARI_ELGA sur le maillage de visualisation (fissuré)",
+ MAILLAGE_SAIN = SIMP(statut='f',typ=maillage_sdaster),
RESULTAT = SIMP(statut='o',typ=resultat_sdaster),
- b_elga = BLOC(condition = "NOM_CHAM in ('SIEF_ELGA','VARI_ELGA') or \
- (type(NOM_CHAM)==type(()) and 'SIEF_ELGA' in NOM_CHAM) or \
- (type(NOM_CHAM)==type(()) and 'VARI_ELGA' in NOM_CHAM)",
- MODELE_VISU = SIMP(statut='o',typ=modele_sdaster,),
- ),
- INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
+ MODELE_VISU = SIMP(statut='o',typ=modele_sdaster,),
+ INFO = SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
);
-#& MODIF COMMANDE DATE 08/02/2010 AUTEUR DESROCHES X.DESROCHES
+#& MODIF COMMANDE DATE 11/10/2010 AUTEUR DESROCHES X.DESROCHES
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
RESULTAT =SIMP(statut='o',typ=resultat_sdaster,fr="RESULTAT à posttraiter",),
CHAM =SIMP(statut='o',typ='TXM',into=("EFFORT","DEFORMATION",)),
NUME_ORDRE =SIMP(statut='f',typ='I'),
- INST =SIMP(statut='f',typ='R',defaut=0.E+0),
+ INST =SIMP(statut='f',typ='R'),
# points de post-traitement :
COOR_POINT =FACT(statut='o',max='**',fr="coordonnées et position dans l épaisseur",
COOR=SIMP(statut='o',typ='R',min=3,max=4),),
)
+#& MODIF COMMANDE DATE 04/10/2010 AUTEUR GREFFET N.GREFFET
+# 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 G.DEVESA
+
+from Macro.post_decollement_ops import post_decollement_ops
+
+POST_DECOLLEMENT=MACRO(nom="POST_DECOLLEMENT",op=post_decollement_ops,sd_prod=table_sdaster,
+ fr="calcul du rapport de surfaces de contact radier/sol",
+ reentrant='n',
+ UIinfo={"groupes":("Post traitements",)},
+ RESULTAT =SIMP(statut='o',typ=(evol_noli) ),
+ NOM_CHAM =SIMP(statut='f',typ='TXM',defaut='DEPL',into=C_NOM_CHAM_INTO(),max=1),
+ NOM_CMP =SIMP(statut='f',typ='TXM',defaut='DZ',max=1),
+ GROUP_MA =SIMP(statut='o',typ=grma,max=1),
+ INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)
#& MODIF COMMANDE DATE 21/04/2008 AUTEUR LEFEBVRE J-P.LEFEBVRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 08/12/2009 AUTEUR PROIX J-M.PROIX
+#& MODIF COMMANDE DATE 13/07/2010 AUTEUR MAHFOUZ D.MAHFOUZ
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
# RESPONSABLE WADIER Y.WADIER
-
+
from Macro.post_gp_ops import post_gp_ops
-def post_gp_prod(self, TABL_RESU, **kargs):
+
+def post_gp_prod(self, TABL_GPMAX,TABL_GP, **kargs):
"""Typage des sd_prod
"""
- if TABL_RESU != None:
- self.type_sdprod(TABL_RESU, table_sdaster)
+ if TABL_GPMAX != None:
+ self.type_sdprod(TABL_GPMAX, table_sdaster)
+ if TABL_GP != None :
+ if TABL_GPMAX != None:
+ self.type_sdprod(TABL_GPMAX, table_sdaster)
+ self.type_sdprod(TABL_GP, table_sdaster)
return table_sdaster
+
POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod,
fr="Calcul du critère énergétique Gp suite à un calcul thermo-mécanique",
reentrant='n',
UIinfo={"groupes":("Post traitements",)},
regles=(UN_PARMI('IDENTIFICATION', 'PREDICTION'),
UN_PARMI('THETA_2D','THETA_3D'),
- UN_PARMI('PAS_ENTAILLE','LIST_EP_COPEAUX'),
PRESENT_PRESENT('THETA_2D','DIRECTION'),),
# Résultat, modèle, comportement, chargement
DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ),
),
+ 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)),
FONC_MULT = SIMP(statut='f', typ=(fonction_sdaster,nappe_sdaster,formule)),
),
SYME_CHAR = SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","ANTI","SANS")),
+
DIRECTION = SIMP(statut='f', typ='R', max=3),
-
+
THETA_2D = FACT(statut='f', max='**',
fr="paramètres de définition des champs theta",
GROUP_NO = SIMP(statut='o', typ=grno, validators=NoRepeat(), max='**'),
R_INF = SIMP(statut='o', typ='R'),
- R_SUP = SIMP(statut='o', typ='R'),
- ),
+ R_SUP = SIMP(statut='o', typ='R'),),
+ b_theta_2d=BLOC(condition="(THETA_2D != None)",
+ # correction axisymétrie
+ RAYON_AXIS = SIMP(statut='f', typ='R', val_min=0., defaut=1.),
+ TRANCHE = FACT(statut='o', max=1,
+
+ GROUP_MA = SIMP(statut='o', typ=grma, validators=NoRepeat(), max='**'),
+ ),),
THETA_3D =FACT(statut='f',max='**',
GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
),
FOND_FISS =SIMP(statut='o',typ=fond_fiss,max=1,),
- NB_TRANCHES =SIMP(statut='o',typ='I',max=1,
- fr="nombre de tranches: nombre de segments maillant le fond de fissure",),
- ),
+ TRANCHE = FACT(statut='o', max='**',
+ GROUP_MA = SIMP(statut='o', typ=grma, validators=NoRepeat(), max='**'),
+ ),),
# prise en compte de la traction compression
TRAC_COMP = SIMP(statut='f',typ='TXM',into=("OUI",),
fr="prise en compte de la traction-compression (plus lent)",
),
- # copeaux
- GROUP_MA = SIMP(statut='o', typ=grma, validators=NoRepeat(), max='**'),
- PAS_ENTAILLE = SIMP(statut='f', typ='R', val_min=0.),
- LIST_EP_COPEAUX = SIMP(statut='f', typ='R', max='**'),
-
# critère sur Gp
CRIT_MAXI_GP = SIMP(statut='f', typ='TXM', defaut="ABSOLU",
into=("RELATIF","ABSOLU")),
-
- # correction axisymétrie
- RAYON_AXIS = SIMP(statut='f', typ='R', val_min=0., defaut=1.),
-
+
# identification
IDENTIFICATION = FACT(statut='f', max=1,
KJ_CRIT = SIMP(statut='o', typ='R', val_min=0., max='**'),
),
# table résultat
- TABL_RESU = SIMP(statut='o', typ=CO,),
-
+ 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 20/10/2008 AUTEUR GALENNE E.GALENNE
+#& MODIF COMMANDE DATE 10/08/2010 AUTEUR GENIAUT S.GENIAUT
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
UIinfo={"groupes":("Post traitements",)},
regles=(UN_PARMI('RESULTAT','TABL_DEPL_SUP'),
- EXCLUS('FISSURE','FOND_FISS'),
- PRESENT_PRESENT('FISSURE','RESULTAT'),
- PRESENT_PRESENT('FOND_FISS','VECT_K1'),
- PRESENT_PRESENT('TABL_DEPL_SUP','VECT_K1'),
+ EXCLUS('FISSURE','FOND_FISS'),
+ PRESENT_PRESENT('FISSURE','RESULTAT'),
+ PRESENT_PRESENT('FOND_FISS','VECT_K1'),
+ PRESENT_PRESENT('TABL_DEPL_SUP','VECT_K1'),
#PRESENT_PRESENT('RESULTAT','FOND_FISS'),
),
into=("3D","AXIS","D_PLAN","C_PLAN"),
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),
+ FISSURE =SIMP(statut='f',typ=fiss_xfem),
+ NB_NOEUD_COUPE=SIMP(statut='f',typ='I',defaut=5,val_min = 3),
+
+# bloc correspondant a la donnee du fond de fissure pour les fissures maillees
b_fond_fiss =BLOC (condition="(FOND_FISS!= None)",
MAILLAGE = SIMP(statut='o',typ=maillage_sdaster),
TYPE_MAILLAGE = SIMP(statut='f',typ='TXM',into=("LIBRE","REGLE"),defaut="REGLE"),
- NB_NOEUD_COUPE= SIMP(statut='f',typ='I'),
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='**'),
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_fissure =BLOC (condition="(FISSURE!= None)",
- MAILLAGE = SIMP(statut='o',typ=maillage_sdaster),
- NB_NOEUD_COUPE = SIMP(statut='f',typ='I' ,defaut=5 ),
- 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='**'),
+# bloc correspondant a la donnee de la fissure pour les fissures X-FEM
+ b_fissure =BLOC (condition="(FISSURE!= 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"),
fr="Table issue de post_releve_t sur les noeuds de la lèvre inférieure"),
ABSC_CURV_MAXI=SIMP(statut='o',typ='R',
fr="Distance maximum à partir du fond de fissure à utiliser pour le calcul"),
- PREC_VIS_A_VIS= SIMP(statut='f',typ='R',defaut=0.1),
+ PREC_VIS_A_VIS=SIMP(statut='f',typ='R',defaut=0.1),
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),
TITRE =SIMP(statut='f',typ='TXM'),
)
-#& MODIF COMMANDE DATE 12/05/2009 AUTEUR MAZET S.MAZET
+#& MODIF COMMANDE DATE 10/08/2010 AUTEUR GENIAUT S.GENIAUT
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
reentrant='n',UIinfo={"groupes":("Maillage",)},
fr="Crée un maillage se conformant à la fissure pour le post-traitement des éléments XFEM",
MODELE = SIMP(statut='o',typ=modele_sdaster),
- MAILLAGE_SAIN = SIMP(statut='o',typ=maillage_sdaster),
+ MAILLAGE_SAIN = SIMP(statut='f',typ=maillage_sdaster),
PREF_NOEUD_X =SIMP(statut='f',typ='TXM',defaut="NX",validators=LongStr(1,2),),
PREF_NOEUD_M =SIMP(statut='f',typ='TXM',defaut="NM",validators=LongStr(1,2),),
PREF_NOEUD_P =SIMP(statut='f',typ='TXM',defaut="NP",validators=LongStr(1,2),),
CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 19/04/2010 AUTEUR BERARD A.BERARD
+#& MODIF COMMANDE DATE 12/07/2010 AUTEUR BERARD A.BERARD
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
fr="Projeter des champs d'un maillage sur un autre",
- METHODE =SIMP(statut='f',typ='TXM',defaut="ELEM",
- into=("NUAGE_DEG_0","NUAGE_DEG_1","ELEM",) ),
+ METHODE =SIMP(statut='f',typ='TXM',defaut="AUTO",
+ into=("NUAGE_DEG_0","NUAGE_DEG_1","AUTO","COLOCATION","ECLA_PG",) ),
regles=(UN_PARMI('RESULTAT','CHAM_GD'),
UN_PARMI('MODELE_1','MAILLAGE_1'),
),
- # Cas de la projection ELEM :
+ # Cas de la projection COLOCATION :
#--------------------------------------------
- b_elem =BLOC(condition="METHODE == 'ELEM'",
+ 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',
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='ELEM' mais on ne peut pas le vérifier:
+ # 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"+
DIRECTION =SIMP(statut='f',typ='R',min=3,max=3 ),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
-#& MODIF COMMANDE DATE 11/05/2009 AUTEUR NISTOR I.NISTOR
+#& MODIF COMMANDE DATE 19/07/2010 AUTEUR NISTOR I.NISTOR
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
EXCLUS('NOEUD','GROUP_NO'),
EXCLUS('MAILLE','GROUP_MA'),
PRESENT_PRESENT('RESULTAT','SQUELETTE'),
+ UN_PARMI('SQUELETTE','SOUS_STRUC','SECTEUR'),
),
RESULTAT =SIMP(statut='f',typ=(evol_noli,dyna_trans,
SQUELETTE =SIMP(statut='f',typ=squelette ),
SOUS_STRUC =SIMP(statut='f',typ='TXM' ),
- SECTEUR =SIMP(statut='f',typ='I',defaut= 1 ),
+ SECTEUR =SIMP(statut='f',typ='I'),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
#& MODIF COMMANDE DATE 11/05/2009 AUTEUR NISTOR I.NISTOR
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 03/05/2010 AUTEUR PROIX J-M.PROIX
+#& MODIF COMMANDE DATE 28/06/2010 AUTEUR PROIX J-M.PROIX
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
NB_VARI_TABLE =SIMP(statut='f',typ='I',max=1,),
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),
),
),
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) ),
+ SIZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ ),
+ EPSI_IMPOSE=FACT(statut='f',
+ EPXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ ),
),
+ b_COEF = BLOC(condition="SUPPORT != 'ELEMENT'",fr="matrice de coefficients",
+ regles = (PRESENT_ABSENT('SIGM_IMPOSE','MATR_C1','MATR_C2','VECT_IMPO'),
+ PRESENT_ABSENT('EPSI_IMPOSE','MATR_C1','MATR_C2','VECT_IMPO'),
+ PRESENT_ABSENT('MATR_C1','SIGM_IMPOSE','EPSI_IMPOSE'),
+ PRESENT_ABSENT('MATR_C2','SIGM_IMPOSE','EPSI_IMPOSE'),
+ PRESENT_ABSENT('VECT_IMPO', 'SIGM_IMPOSE','EPSI_IMPOSE'),
+ ),
- 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) ),
- SIZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- SIXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- SIXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- SIYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ 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) ),
+ SIZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ ),
+ EPSI_IMPOSE=FACT(statut='f',
+ EPXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ ),
+ MATR_C1=FACT(statut='f',max='**',
+ VALE =SIMP(statut='o',typ='R',max=1, ),
+ NUME_LIGNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=6 ),
+ NUME_COLONNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=12 ),
+ ),
+ MATR_C2=FACT(statut='f',max='**',
+ VALE =SIMP(statut='o',typ='R',max=1, ),
+ NUME_LIGNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=6 ),
+ NUME_COLONNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=12 ),
+ ),
+ VECT_IMPO=FACT(statut='f',max='**',
+ VALE =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule),max=1, ),
+ NUME_LIGNE =SIMP(statut='o',typ='I',max=1,val_min=1,val_max=6 ),
+ ),
),
- EPSI_IMPOSE=FACT(statut='f',
- EPXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- EPYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- EPZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- EPXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- EPXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- EPYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
- ),
SIGM_INIT=FACT(statut='f',
SIXX = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
SIYY = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit les md5"),
) ;
-#& MODIF COMMANDE DATE 12/04/2010 AUTEUR MICHEL S.MICHEL
+#& MODIF COMMANDE DATE 19/10/2010 AUTEUR DESOZA T.DESOZA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
"MATR_ASSE",
"ITER_DEBO",
"CTCD_ITER","CTCD_GEOM","CTCD_NOEU",
- "CTCC_GEOM","CTCC_FROT","CTCC_CONT",
+ "BOUC_GEOM","BOUC_FROT","BOUC_CONT","CTCC_BOUC","CTCC_NOEU",
"SUIV_1","SUIV_2","SUIV_3","SUIV_4","ITER_FETI",
),
),
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")),
),
fr="Liste des paramètres de sensibilité",
ang="List of sensitivity parameters"),
INFO =SIMP(statut='f',typ='I',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 01/02/2010 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 06/09/2010 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
CHAM_GD =SIMP(statut='o',typ=cham_no_sdaster),
NOEUD =SIMP(statut='f',typ=no ),
GROUP_NO =SIMP(statut='f',typ=grno ),
- NOM_CMP =SIMP(statut='f',typ='TXM'),
+ NOM_CMP =SIMP(statut='f',typ='TXM',max=1),
TYPE_TEST =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN")),
VALE =SIMP(statut='f',typ='R',max='**'),
VALE_I =SIMP(statut='f',typ='I',max='**'),
SOUS_POINT =SIMP(statut='f',typ='I'),
NOEUD =SIMP(statut='f',typ=no),
GROUP_NO =SIMP(statut='f',typ=grno),
- NOM_CMP =SIMP(statut='f',typ='TXM',max='**'),
+ NOM_CMP =SIMP(statut='f',typ='TXM',max=1),
TYPE_TEST =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN") ),
VALE =SIMP(statut='f',typ='R',max='**' ),
VALE_I =SIMP(statut='f',typ='I',max='**' ),
ANGL =SIMP(statut='f',typ='R'),
PARA =SIMP(statut='f',typ='TXM'),
NOM_CHAM =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
- NOM_CMP =SIMP(statut='f',typ='TXM',max='**'),
+ NOM_CMP =SIMP(statut='f',typ='TXM',max=1),
MAILLE =SIMP(statut='f',typ=ma ,max='**'),
NOEUD =SIMP(statut='f',typ=no ,max='**'),
GROUP_NO =SIMP(statut='f',typ=grno ,max='**'),
INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
)
-#& MODIF COMMANDE DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
- RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
- RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
INFO =SIMP(statut='f',typ='I',into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 18/01/2010 AUTEUR TARDIEU N.TARDIEU
+#& MODIF COMMANDE DATE 20/09/2010 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
),
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" ),
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
- b_petsc_ilu =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+ PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
+ b_ldlt_inc =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
REMPLISSAGE = SIMP(statut='f',typ='R',defaut= 1.0),
+ 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, ),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
+ ),
+ 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") ),
),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= -1 ),
),
