Update from Aster NEW10

diff --git a/Aster/Cata/cataSTA10/Cata_Utils/__init__.py b/Aster/Cata/cataSTA10/Cata_Utils/__init__.py
new file mode 100644 (file)
index 0000000..17af639
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Cata_Utils/__init__.py
@@ -0,0 +1,26 @@
+#@ MODIF __init__ Cata_Utils  DATE 16/11/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+#
+# Ce package ne doit contenir que les modules nécessaires au catalogue
+# qui ne peuvent pas être dans Macro ou SD.
+# Exemple : t_fonction permettant d'évaluer les fonctions dans le catalogue materiau.
+#
+

diff --git a/Aster/Cata/cataSTA10/Cata_Utils/t_fonction.py b/Aster/Cata/cataSTA10/Cata_Utils/t_fonction.py
new file mode 100644 (file)
index 0000000..82f41c3
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Cata_Utils/t_fonction.py
@@ -0,0 +1,780 @@
+#@ MODIF t_fonction Cata_Utils  DATE 22/03/2011   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+import copy
+import types
+from math import exp, log
+
+import numpy as NP
+import numpy.fft as FFT
+
+from Noyau.N_types import is_float, is_float_or_int, is_complex, is_number, is_enum
+
+
+# -----------------------------------------------------------------------------
+class FonctionError(Exception): pass
+
+class ParametreError(FonctionError):      pass  # probleme de NOM_PARA
+class InterpolationError(FonctionError):  pass
+class ProlongementError(FonctionError):   pass
+
+# -----------------------------------------------------------------------------
+def interp(typ_i,val,x1,x2,y1,y2,tol=1.e-6) :
+  """Interpolation linéaire/logarithmique entre un couple de valeurs
+  """
+  if abs(val-x1) < tol : return y1
+  if abs(val-x2) < tol : return y2
+  if typ_i[0] == 'LOG' and (x1 <= 0. or x2 <= 0.):
+      raise InterpolationError("Interpolation LOG invalide sur l'intervalle [%g, %g]." % (x1, x2))
+  if typ_i[1] == 'LOG' and (y1 <= 0. or y2 <= 0.):
+      raise InterpolationError("Interpolation LOG invalide sur les ordonnées [%g, %g]." % (y1, y2))
+  if typ_i==['LIN','LIN']: return y1+(y2-y1)*(val-x1)/(x2-x1)
+  if typ_i==['LIN','LOG']: return exp(log(y1)+(val-x1)*(log(y2)-log(y1))/(x2-x1))
+  if typ_i==['LOG','LOG']: return exp(log(y1)+(log(val)-log(x1))*(log(y2)-log(y1))/(log(x2)-log(x1)))
+  if typ_i==['LOG','LIN']: return y1+(log(val)-log(x1))*(y2-y1)/(log(x2)-log(x1))
+  raise InterpolationError, "abscisse = %g, intervalle = [%g, %g]" % (val, x1, x2)
+
+
+def is_ordo(liste):
+  if len(liste) > 1:
+    val = NP.array(liste, float)
+    return min(val[1:len(val)] - val[0:len(val)-1]) >= 0.
+  else: return True
+
+# -----------------------------------------------------------------------------
+class t_fonction :
+  """Classe pour fonctions réelles, équivalent au type aster = fonction_sdaster
+  """
+  def __init__(self,vale_x,vale_y,para,nom='') :
+    """Création d'un objet fonction
+    - vale_x et vale_y sont des listes de réels de meme longueur
+    - para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER)
+    """
+    self.nom=nom
+    pk=para.keys()
+    pk.sort()
+    if pk!=['INTERPOL','NOM_PARA','NOM_RESU','PROL_DROITE','PROL_GAUCHE'] :
+         raise FonctionError, 'fonction : parametres incorrects'
+    if para['INTERPOL'] not in [['NON','NON'],['LIN','LIN'],['LIN','LOG'],['LOG','LOG'],['LOG','LIN'],] :
+         raise FonctionError, 'fonction : parametre INTERPOL incorrect : %s' % para['INTERPOL']
+    if para['PROL_DROITE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
+         raise FonctionError, 'fonction : parametre PROL_DROITE incorrect : %s' % para['PROL_DROITE']
+    if para['PROL_GAUCHE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
+         raise FonctionError, 'fonction : parametre PROL_GAUCHE incorrect : %s' % para['PROL_GAUCHE']
+    self.vale_x    = NP.array(vale_x)
+    self.vale_y    = NP.array(vale_y)
+    self.para      = para
+    if len(self.vale_x)!=len(self.vale_y) :
+         raise FonctionError, 'fonction : longueur abscisse <> longueur ordonnées'
+    if not is_ordo(self.vale_x) :
+         raise FonctionError, 'fonction : abscisses non strictement croissantes'
+
+  def __add__(self,other) :
+    """addition avec une autre fonction ou un nombre, par surcharge de l'opérateur +
+    """
+    if   isinstance(other,t_fonction):
+      para=copy.copy(self.para)
+      vale_x,para['PROL_GAUCHE'],para['PROL_DROITE']=self.homo_support(other)
+      fff=self.evalfonc(vale_x)
+      ggg=other.evalfonc(vale_x)
+      if   isinstance(self,t_fonction_c): return t_fonction_c(vale_x,fff.vale_y+ggg.vale_y,para)
+      else                              : return t_fonction(vale_x,fff.vale_y+ggg.vale_y,para)
+    elif is_number(other):
+      if   isinstance(self,t_fonction_c): return t_fonction_c(self.vale_x,self.vale_y+other,self.para)
+      else                              : return t_fonction(self.vale_x,self.vale_y+other,self.para)
+    else:  raise FonctionError, 'fonctions : erreur de type dans __add__ : %s %s' % (self, type(other))
+
+  def __mul__(self,other) :
+    """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur *
+    """
+    if   isinstance(other,t_fonction):
+      para=copy.copy(self.para)
+      vale_x,para['PROL_GAUCHE'],para['PROL_DROITE']=self.homo_support(other)
+      fff=self.evalfonc(vale_x)
+      ggg=other.evalfonc(vale_x)
+      if   isinstance(self,t_fonction_c): return t_fonction_c(vale_x,fff.vale_y*ggg.vale_y,para)
+      else                              : return t_fonction(vale_x,fff.vale_y*ggg.vale_y,para)
+    elif is_float_or_int(other):
+      return t_fonction(self.vale_x,self.vale_y*other,self.para)
+    elif is_complex(other):
+      return t_fonction_c(self.vale_x,self.vale_y*other,self.para)
+    else:  raise FonctionError, 'fonctions : erreur de type dans __mul__%s %s' % (self, type(other))
+
+  def __repr__(self) :
+    """affichage de la fonction en double colonne
+    """
+    texte=[]
+    for i in range(len(self.vale_x)) :
+      texte.append('%f %f' % (self.vale_x[i],self.vale_y[i]))
+    return '\n'.join(texte)
+
+  def __getitem__(self,other) :
+    """composition de deux fonction F[G]=FoG=F(G(x))
+    """
+    para=copy.copy(self.para)
+    if other.para['NOM_RESU'] != self.para['NOM_PARA'] :
+       raise ParametreError,'''composition de fonctions : NOM_RESU1 et NOM_PARA2 incohérents '''
+    para['NOM_PARA']==other.para['NOM_PARA']
+    return t_fonction(other.vale_x,map(self,other.vale_y),para)
+
+  def __call__(self,val,tol=1.e-6):
+    """méthode pour évaluer f(x)
+    - tolérance, par défaut 1.e-6 en relatif sur la longueur de l'intervalle
+    - adjacent, pour capter les erreurs d'arrondi en cas de prolongement exclu
+    """
+    i=NP.searchsorted(self.vale_x, val)
+    n=len(self.vale_x)
+    if n == 1:
+      # Utilisation abusive de la tolérance relative mais ce cas est particulier
+      if (val-self.vale_x[0]) < tol:
+         return self.vale_y[0]
+      elif val-self.vale_x[0] > 0:
+         if (self.para['PROL_DROITE']=='CONSTANT') or (self.para['PROL_DROITE']=='LINEAIRE'):
+            return self.vale_y[0]
+         else: raise ProlongementError, 'fonction évaluée hors du domaine de définition'
+      elif val-self.vale_x[0] < 0:
+         if (self.para['PROL_GAUCHE']=='CONSTANT') or (self.para['PROL_GAUCHE']=='LINEAIRE'):
+            return self.vale_y[0]
+         else: raise ProlongementError, 'fonction évaluée hors du domaine de définition'
+    
+    if i==0 :
+      if self.para['PROL_GAUCHE']=='EXCLU'    :
+         eps_g=(val-self.vale_x[0] )/(self.vale_x[1] -self.vale_x[0])
+         if abs(eps_g)<=tol  : return self.vale_y[0]
+         else                : raise ProlongementError, 'fonction évaluée hors du domaine de définition'
+      else  : 
+         if self.para['PROL_GAUCHE']=='CONSTANT' : return self.vale_y[0]
+         if self.para['PROL_GAUCHE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val,self.vale_x[0],
+                                                                                           self.vale_x[1],
+                                                                                           self.vale_y[0],
+                                                                                           self.vale_y[1])
+    elif i==n :
+      if self.para['PROL_DROITE']=='EXCLU'    :
+         eps_d=(val-self.vale_x[-1])/(self.vale_x[-1]-self.vale_x[-2])
+         if abs(eps_d)<=tol  : return self.vale_y[-1]
+         else                : raise ProlongementError, 'fonction évaluée hors du domaine de définition'
+      else  : 
+         if self.para['PROL_DROITE']=='CONSTANT' : return self.vale_y[-1]
+         if self.para['PROL_DROITE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val,self.vale_x[-1],
+                                                                                           self.vale_x[-2],
+                                                                                           self.vale_y[-1],
+                                                                                           self.vale_y[-2])
+    else :
+      return interp(self.para['INTERPOL'],val,self.vale_x[i-1],
+                                              self.vale_x[i],
+                                              self.vale_y[i-1],
+                                              self.vale_y[i])
+
+  def homo_support(self,other) :
+    """Renvoie le support d'abscisses homogénéisé entre self et other
+    i.e. si prolongement exclu, on retient plus grand min ou plus petit max, selon
+    si prolongement autorisé, on conserve les abscisses d'une fonction, extrapolantes
+    sur l'autre.
+    Pour les points intermédiaires : union et tri des valeurs des vale_x réunis.
+    """
+    if other.vale_x[0]>self.vale_x[0]:
+       if other.para['PROL_GAUCHE']!='EXCLU' : f_g=self
+       else                                  : f_g=other
+    else :
+       if self.para['PROL_GAUCHE'] !='EXCLU' : f_g=other
+       else                                  : f_g=self
+    val_min    =f_g.vale_x[0]
+    prol_gauche=f_g.para['PROL_GAUCHE']
+    if self.vale_x[-1]>other.vale_x[-1]:
+       if other.para['PROL_DROITE']!='EXCLU' : f_d=self
+       else                                  : f_d=other
+    else :
+       if self.para['PROL_DROITE'] !='EXCLU' : f_d=other
+       else                                  : f_d=self
+    val_max    =f_d.vale_x[-1]
+    prol_droite=f_d.para['PROL_DROITE']
+    vale_x=NP.concatenate((self.vale_x,other.vale_x))
+    vale_x=NP.clip(vale_x,val_min,val_max)
+    vale_x=NP.sort(list(set(vale_x)))
+    return vale_x, prol_gauche, prol_droite
+
+  def cut(self,rinf,rsup,prec,crit='RELATIF',nom='') :
+    """Renvoie la fonction self dont on a 'coupé' les extrémités en x=rinf et x=rsup
+    pour la recherche de rinf et rsup dans la liste d'abscisses :
+       prec=precision crit='absolu' ou 'relatif'
+    """
+    para=copy.copy(self.para)
+    para['PROL_GAUCHE']='EXCLU'
+    para['PROL_DROITE']='EXCLU'
+    if   crit=='ABSOLU' : rinf_tab=NP.greater(abs(self.vale_x-rinf),prec)
+    elif crit=='RELATIF': rinf_tab=NP.greater(abs(self.vale_x-rinf),prec*rinf)
+    else : raise FonctionError, 'fonction : cut : critère absolu ou relatif'
+    if   crit=='ABSOLU' : rsup_tab=NP.greater(abs(self.vale_x-rsup),prec)
+    elif crit=='RELATIF': rsup_tab=NP.greater(abs(self.vale_x-rsup),prec*rsup)
+    else : raise FonctionError, 'fonction : cut : critère absolu ou relatif'
+    if NP.alltrue(rinf_tab) : i=NP.searchsorted(self.vale_x,rinf)
+    else                 : i=rinf_tab.tolist().index(0)+1
+    if NP.alltrue(rsup_tab) : j=NP.searchsorted(self.vale_x,rsup)
+    else                 : j=rsup_tab.tolist().index(0)
+    vale_x=NP.array([rinf,]+self.vale_x.tolist()[i:j]+[rsup,])
+    vale_y=NP.array([self(rinf),]+self.vale_y.tolist()[i:j]+[self(rsup),])
+    return t_fonction(vale_x,vale_y,para,nom)
+
+  def cat(self,other,surcharge) :
+    """renvoie une fonction concaténée avec une autre, avec règles de surcharge
+    """
+    para=copy.copy(self.para)
+    if self.para['INTERPOL']!=other.para['INTERPOL'] : raise FonctionError, 'concaténation de fonctions à interpolations différentes'
+    if NP.min(self.vale_x)<NP.min(other.vale_x) :
+            f1=self
+            f2=other
+    else                                  :
+            f1=other
+            f2=self
+    para['PROL_GAUCHE']=f1.para['PROL_GAUCHE']
+    if   surcharge=='GAUCHE' :
+       i=NP.searchsorted(f2.vale_x,f1.vale_x[-1])
+       if i!=len(f2.vale_x) : para['PROL_DROITE']=f2.para['PROL_DROITE']
+       else                 : para['PROL_DROITE']=f1.para['PROL_DROITE']
+       vale_x = NP.concatenate((f1.vale_x, f2.vale_x[i:len(f2.vale_x)]))
+       vale_y = NP.concatenate((f1.vale_y, f2.vale_y[i:len(f2.vale_y)]))
+    elif surcharge=='DROITE' :
+       i=NP.searchsorted(f1.vale_x,f2.vale_x[0])
+       if i!=len(f1.vale_x) : para['PROL_DROITE']=f2.para['PROL_DROITE']
+       else                 : para['PROL_DROITE']=f1.para['PROL_DROITE']
+       vale_x = NP.concatenate((f1.vale_x[:i], f2.vale_x))
+       vale_y = NP.concatenate((f1.vale_y[:i], f2.vale_y))
+    return t_fonction(vale_x,vale_y,para)
+
+  def tabul(self) :
+    """mise en forme de la fonction selon un vecteur unique (x1,y1,x2,y2,...)
+    """
+    __tab=NP.array([self.vale_x,self.vale_y])
+    return NP.ravel(NP.transpose(__tab)).tolist()
+
+  def extreme(self) :
+    """renvoie un dictionnaire des valeurs d'ordonnées min et max
+    """
+    val_min=min(self.vale_y)
+    val_max=max(self.vale_y)
+    vm={}
+    vm['min']=[[self.vale_y[i],self.vale_x[i]] for i in range(len(self.vale_x))\
+                                               if self.vale_y[i]==val_min]
+    vm['max']=[[self.vale_y[i],self.vale_x[i]] for i in range(len(self.vale_x))\
+                                               if self.vale_y[i]==val_max]
+    vm['min'].sort()
+    vm['max'].sort()
+    for item in vm['min'] : item.reverse()
+    for item in vm['max'] : item.reverse()
+    return vm
+
+  def trapeze(self,coef) :
+    """renvoie la primitive de la fonction, calculée avec la constante d'intégration 'coef'
+    """
+    n = len(self.vale_y)   # [1:n] car pb sur calibre 5 (etch, python2.5 x86_64)
+    trapz     = NP.zeros(n, float)
+    trapz[0]  = coef
+    trapz[1:n] = (self.vale_y[1:n]+self.vale_y[:-1])/2*(self.vale_x[1:n]-self.vale_x[:-1])
+    prim_y=NP.cumsum(trapz)
+    para=copy.copy(self.para)
+    para['PROL_GAUCHE']='EXCLU'
+    para['PROL_DROITE']='EXCLU'
+    if   para['NOM_RESU'][:4]=='VITE' : para['NOM_RESU']='DEPL'
+    elif para['NOM_RESU'][:4]=='ACCE' : para['NOM_RESU']='VITE'
+    return t_fonction(self.vale_x,prim_y,para)
+
+  def simpson(self,coef) :
+    """renvoie la primitive de la fonction, calculée avec la constante d'intégration 'coef'
+    """
+    para=copy.copy(self.para)
+    para['PROL_GAUCHE']='EXCLU'
+    para['PROL_DROITE']='EXCLU'
+    if   para['NOM_RESU'][:4]=='VITE' : para['NOM_RESU']='DEPL'
+    elif para['NOM_RESU'][:4]=='ACCE' : para['NOM_RESU']='VITE'
+    fm      = self.vale_y[0]
+    fb      = self.vale_y[1]
+    h2      = self.vale_x[1] - self.vale_x[0]
+    tabl    = [coef,coef +(fb+fm)*h2/2.]
+    prim_y  = copy.copy(tabl)
+    iperm   = 0
+    ip      = (1,0)
+    eps     = 1.E-4
+    for i in range(2,len(self.vale_x)) :
+       h1  = h2
+       h2  = self.vale_x[i] - self.vale_x[i-1]
+       bma = h1 + h2
+       fa  = fm
+       fm  = fb
+       fb  = self.vale_y[i]
+       deltah = h2 - h1
+       if h1==0. or h2==0. or abs( deltah / h1 ) <= eps :
+          ct  = (1.,4.,1.)
+       else :
+          epsi = deltah / (h1*h2)
+          ct   = (1.-epsi*h2,2.+epsi*deltah,1.+epsi*h1)
+       tabl[iperm] = tabl[iperm] + (bma/6.)*(ct[0]*fa+ct[1]*fm+ct[2]*fb)
+       prim_y.append(tabl[iperm])
+       iperm       = ip[iperm]
+    return t_fonction(self.vale_x,prim_y,para)
+
+  def derive(self) :
+    """renvoie la dérivée de la fonction
+    """
+    n = len(self.vale_y)   # [1:n] car pb sur calibre 5 (etch, python2.5 x86_64)
+    pas=self.vale_x[1:n]-self.vale_x[:-1]
+    pentes=(self.vale_y[1:n]-self.vale_y[:-1])/(self.vale_x[1:n]-self.vale_x[:-1])
+    derive=(pentes[1:n-1]*pas[1:n-1]+pentes[:-1]*pas[:-1])/(pas[1:n-1]+pas[:-1])
+    derv_y=[pentes[0]]+derive.tolist()+[pentes[-1]]
+    para=copy.copy(self.para)
+    para['PROL_GAUCHE']='EXCLU'
+    para['PROL_DROITE']='EXCLU'
+    if   para['NOM_RESU'][:4]=='DEPL' : para['NOM_RESU']='VITE'
+    elif para['NOM_RESU'][:4]=='VITE' : para['NOM_RESU']='ACCE'
+    return t_fonction(self.vale_x,derv_y,para)
+
+  def inverse(self) :
+    """renvoie l'inverse de la fonction
+    on intervertit vale_x et vale_y, on swape interpolation
+    """
+    para=copy.copy(self.para)
+    para['NOM_RESU']='TOUTRESU'
+    para['NOM_PARA']=self.para['NOM_PARA']
+    para['INTERPOL'].reverse()
+    if para['PROL_GAUCHE']=='CONSTANT' : para['PROL_GAUCHE']='EXCLU'
+    if para['PROL_DROITE']=='CONSTANT' : para['PROL_DROITE']='EXCLU'
+    vale_x=self.vale_y
+    vale_y=self.vale_x
+    if not is_ordo(vale_x) :
+       vale_x=vale_x[::-1]
+       vale_y=vale_y[::-1]
+    return t_fonction(vale_x,vale_y,para)
+
+  def abs(self) :
+    """renvoie la mm fonction avec valeur absolue des ordonnées
+    """
+    para=copy.copy(self.para)
+    if para['PROL_GAUCHE']=='LINEAIRE' : para['PROL_GAUCHE']='EXCLU'
+    if para['PROL_DROITE']=='LINEAIRE' : para['PROL_DROITE']='EXCLU'
+    return t_fonction(self.vale_x,NP.absolute(self.vale_y),para)
+
+  def evalfonc(self,liste_val) :
+    """renvoie la mm fonction interpolée aux points définis par la liste 'liste_val'
+    """
+    return self.__class__(liste_val,map(self,liste_val),self.para)
+
+  def suppr_tend(self) :
+    """pour les corrections d'accélérogrammes
+    suppression de la tendance moyenne d'une fonction
+    """
+    para=copy.copy(self.para)
+    xy=NP.sum(self.vale_x*self.vale_y)
+    x0=NP.sum(self.vale_x)
+    y0=NP.sum(self.vale_y)
+    xx=NP.sum(self.vale_x*self.vale_x)
+    n=len(self.vale_x)
+    a1 = ( n*xy - x0*y0) / (n*xx - x0*x0)
+    a0 = (xx*x0 - x0*xy) / (n*xx - x0*x0)
+    return t_fonction(self.vale_x,self.vale_y-a1*self.vale_x-a0,self.para)
+
+  def normel2(self) :
+    """norme de la fonction
+    """
+    __ex=self*self
+    __ex=__ex.trapeze(0.)
+    return NP.sqrt(__ex.vale_y[-1])
+
+  def fft(self,methode) :
+    """renvoie la transformée de Fourier rapide FFT
+    """
+    para=copy.copy(self.para)
+    para['NOM_PARA']='FREQ'
+    if self.para['NOM_PARA']!='INST' :
+       raise ParametreError, 'fonction réelle : FFT : NOM_PARA=INST pour une transformée directe'
+    pas = self.vale_x[1]-self.vale_x[0]
+    for i in range(1,len(self.vale_x)) :
+        ecart = NP.abs(((self.vale_x[i]-self.vale_x[i-1])-pas)/pas)
+        if ecart>1.e-2 :
+           raise FonctionError, 'fonction réelle : FFT : la fonction doit etre à pas constant'
+    n = get_len_puis2(self.vale_x)
+    if   methode=='TRONCATURE' :
+       vale_y=self.vale_y[:2**n]
+    elif methode=='PROL_ZERO'  :
+       vale_y=self.vale_y
+       if len(self.vale_y) > 2**n:
+          vale_y=NP.array(self.vale_y)
+          vale_y = NP.concatenate( (vale_y, NP.zeros(2**(n+1)-len(self.vale_x))) )
+    elif   methode=='COMPLET'  : 
+       vale_y=self.vale_y
+    vect=FFT.fft(vale_y)
+    pasfreq =1./(pas*(len(vect)))
+    vale_x  =[pasfreq*i for i in range(len(vect))]
+    vale_y  =vect
+    return t_fonction_c(vale_x,vale_y,para)
+
+
+# -----------------------------------------------------------------------------
+class t_fonction_c(t_fonction) :
+  """Classe pour fonctions complexes, équivalent au type aster = fonction_c
+  """
+  def __add__(self,other) :
+    """addition avec une autre fonction ou un nombre, par surcharge de l'opérateur +
+    """
+    if isinstance(other,t_fonction_c):
+      para=copy.copy(self.para)
+      vale_x, para['PROL_GAUCHE'], para['PROL_DROITE'] = self.homo_support(other)
+      fff = self.evalfonc(vale_x)
+      ggg = other.evalfonc(vale_x)
+      res = t_fonction_c(vale_x, fff.vale_y + ggg.vale_y, para)
+    elif is_number(other):
+      res = t_fonction_c(self.vale_x, self.vale_y + other, self.para)
+    else:
+        raise FonctionError, 'fonctions : erreur de type dans __add__ : %s %s' % (self, type(other))
+    return res
+
+  def __mul__(self,other) :
+    """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur *
+    """
+    if   isinstance(other,t_fonction_c):
+      para=copy.copy(self.para)
+      vale_x, para['PROL_GAUCHE'], para['PROL_DROITE'] = self.homo_support(other)
+      fff = self.evalfonc(vale_x)
+      ggg = other.evalfonc(vale_x)
+      res = t_fonction_c(vale_x, fff.vale_y * ggg.vale_y, self.para)
+    elif is_number(other):
+      res = t_fonction_c(self.vale_x, self.vale_y*other, self.para)
+    else:
+        raise FonctionError, 'fonctions : erreur de type dans __mul__%s %s' % (self, type(other))
+    return res
+
+  def tabul(self) :
+    """mise en forme de la fonction selon un vecteur unique (x1,yr1,yi1,x2,yr2,yr2,...)
+    """
+    __tab=NP.array([self.vale_x,self.vale_y.real,self.vale_y.imag])
+    return NP.ravel(NP.transpose(__tab)).tolist()
+
+  def __repr__(self) :
+    """affichage de la fonction en double colonne
+    """
+    texte=[]
+    for i in range(len(self.vale_x)) :
+      texte.append('%f %f + %f .j' % (self.vale_x[i],self.vale_y[i].real,self.vale_y[i].imag))
+    return '\n'.join(texte)
+
+  def fft(self,methode,syme) :
+    """renvoie la transformée de Fourier rapide FFT (sens inverse)
+
+       Dans le cas syme == 'NON', on choisit de renvoyer 
+       un vecteur de longueur 2N, ou N est la longueur du vecteur F de depart,
+       en faisant l'approximation que pour la vraie FFT, F(N+1) est fonction
+       de F(N) et F(N-1).
+       On effectue un prolongement a l'ordre 2 par continuite pour simplifier
+       l'analyse des pas de temps en post traitement
+    """
+    para=copy.copy(self.para)
+    para['NOM_PARA']='INST'
+    if self.para['NOM_PARA']!='FREQ' :
+       raise ParametreError, 'fonction complexe : FFT : NOM_PARA=FREQ pour une transformée directe'
+    pas = self.vale_x[1]-self.vale_x[0]
+    for i in range(1,len(self.vale_x)) :
+        ecart = NP.abs(((self.vale_x[i]-self.vale_x[i-1])-pas)/pas)
+        if ecart>1.e-3 :
+           raise FonctionError, 'fonction complexe : FFT : la fonction doit etre à pas constant'
+    n = get_len_puis2(self.vale_x)
+    if   syme=='OUI' :
+       vale_fonc=self.vale_y
+    else :
+       if methode=='PROL_ZERO' :
+          fonc_temp=self.vale_y
+          if len(self.vale_y) > 2**n:
+             fonc_temp = NP.concatenate( (self.vale_y, NP.zeros(2**(n+1)-len(self.vale_x)))  )
+       elif methode=='TRONCATURE' :
+          fonc_temp=self.vale_y[:2**n]
+       elif methode=='COMPLET' :
+          fonc_temp=self.vale_y
+       part1=fonc_temp.tolist()
+
+       if NP.remainder(len(part1),2) == 0 :
+          # Si le nombre de point du spectre est pair,
+          # on prolonge en interpolant les 3 dernier points par un polynome de
+          # degre 2, en imposant une tangente horizontale au dernier point (celui
+          # dont on cherche l'ordonnee :
+          # on pose Y=a.w^2+b.w+C , ou Y est la partie reelle de la FFT, et
+          # w la frequence. On connait Y(N-1), Y(N), et on impose dY/dw(N+1)=0
+          # pour la symetrie. On identifie a, b et c, pour calculer Y(N+1)
+          middle=[];
+          middle.append((4*part1[-1].real-part1[len(part1)-2].real)/3);
+          part2=NP.conjugate(fonc_temp[1:len(part1)])
+          part2=part2.tolist();
+          part2.reverse();
+          vale_fonc=NP.array(part1+middle+part2)
+       else :
+          # Si le dernier point est effectivement reel, on reconstruit theoriquement
+          if abs(part1[-1].imag) < abs(part1[-1].real*1e-6) :
+             part1[-1]=part1[-1].real
+          else :
+          # Sinon, on approxime comme dans le cas ou N est pair
+             part1[-1]=(4*part1[len(part1)-2].real-part1[len(part1)-3].real)/3
+          part2=NP.conjugate(fonc_temp[1:len(part1)-1])
+          part2=part2.tolist();
+          part2.reverse();
+          vale_fonc=NP.array(part1+part2)
+
+    vect=FFT.ifft(vale_fonc)
+    vect=vect.real
+    pasfreq =1./(pas*(len(vect)))
+    vale_x  =[pasfreq*i for i in range(len(vect))]
+    vale_y  =vect
+    return t_fonction(vale_x,vale_y,para)
+
+# -----------------------------------------------------------------------------
+class t_nappe :
+  """Classe pour nappes, équivalent au type aster = nappe_sdaster
+  """
+  def __init__(self,vale_para,l_fonc,para,nom='') :
+    """Création d'un objet nappe
+    - vale_para est la liste de valeur des parametres (mot clé PARA dans DEFI_NAPPE)
+    - para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER)
+    - l_fonc est la liste des fonctions, de cardinal égal à celui de vale_para
+    """
+    self.nom = nom
+    pk=para.keys()
+    pk.sort()
+    if pk!=['INTERPOL','NOM_PARA','NOM_PARA_FONC','NOM_RESU','PROL_DROITE','PROL_GAUCHE'] :
+         raise FonctionError, 'nappe : parametres incorrects'
+    if para['INTERPOL'] not in ['NON', 'LIN', 'LOG', ['NON','NON'],['LIN','LIN'],
+                                ['LIN','LOG'],['LOG','LOG'],['LOG','LIN'],] :
+         raise FonctionError, 'nappe : parametre INTERPOL incorrect : %s' % para['INTERPOL']
+    if para['PROL_DROITE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
+         raise FonctionError, 'nappe : parametre PROL_DROITE incorrect : %s' % para['PROL_DROITE']
+    if para['PROL_GAUCHE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
+         raise FonctionError, 'nappe : parametre PROL_GAUCHE incorrect : %s' % para['PROL_GAUCHE']
+    self.vale_para    = NP.array(vale_para)
+    if not is_enum(l_fonc):
+         raise FonctionError, 'nappe : la liste de fonctions fournie n est pas une liste'
+    if len(l_fonc)!=len(vale_para) :
+         raise FonctionError, 'nappe : nombre de fonctions différent du nombre de valeurs du paramètre'
+    for f in l_fonc :
+      if not isinstance(f,t_fonction) and not isinstance(f,t_fonction_c) :
+         raise FonctionError, 'nappe : les fonctions fournies ne sont pas du bon type'
+    self.l_fonc       = l_fonc
+    self.para         = para
+
+  def __call__(self,val1,val2):
+    """méthode pour évaluer nappe(val1,val2)
+    """
+    i=NP.searchsorted(self.vale_para,val1)
+    n=len(self.vale_para)
+    if i==0 :
+      if val1==self.vale_para[0]  : return self.l_fonc[0](val2)
+      if val1 <self.vale_para[0]  : 
+         if self.para['PROL_GAUCHE']=='EXCLU'    : raise ParametreError, 'nappe évaluée hors du domaine de définition'
+         if self.para['PROL_GAUCHE']=='CONSTANT' : return self.l_fonc[0](val2)
+         if self.para['PROL_GAUCHE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val1,
+                                                                 self.vale_para[0],
+                                                                 self.vale_para[1],
+                                                                 self.l_fonc[0](val2),
+                                                                 self.l_fonc[1](val2))
+    elif i==n :
+      if val1==self.vale_para[-1] : return self.l_fonc[-1](val2)
+      if val1 >self.vale_para[-1]  : 
+         if self.para['PROL_DROITE']=='EXCLU'    : raise ParametreError, 'nappe évaluée hors du domaine de définition'
+         if self.para['PROL_DROITE']=='CONSTANT' : return self.l_fonc[-1](val2)
+         if self.para['PROL_DROITE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val1,
+                                                                 self.vale_para[-1],
+                                                                 self.vale_para[-2],
+                                                                 self.l_fonc[-1](val2),
+                                                                 self.l_fonc[-2](val2))
+    else :
+      return interp(self.para['INTERPOL'],val1,self.vale_para[i-1],
+                                               self.vale_para[i],
+                                               self.l_fonc[i-1](val2),
+                                               self.l_fonc[i](val2))
+
+  def evalfonc(self, liste_val) :
+    """Renvoie la mm nappe dont les fonctions sont interpolées aux points définis
+    par la liste 'liste_val'.
+    """
+    l_fonc = []
+    for f in self.l_fonc:
+      f2 = f.evalfonc(liste_val)
+      l_fonc.append(f2)
+    return t_nappe(self.vale_para, l_fonc, self.para)
+
+  def __add__(self,other) :
+    """addition avec une autre nappe ou un nombre, par surcharge de l'opérateur +
+    """
+    l_fonc=[]
+    if   isinstance(other,t_nappe):
+      if NP.all(self.vale_para != other.vale_para):
+          raise ParametreError, 'nappes à valeurs de paramètres différentes'
+      for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]+other.l_fonc[i])
+    elif is_float_or_int(other):
+      for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]+other)
+    else:  raise FonctionError, 't_nappe : erreur de type dans __add__ : %s %s' % (other, type(other))
+    return t_nappe(self.vale_para,l_fonc,self.para)
+
+  def __mul__(self,other) :
+    """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur *
+    """
+    l_fonc=[]
+    if   isinstance(other,t_nappe):
+      if NP.all(self.vale_para != other.vale_para) :
+          raise ParametreError, 'nappes à valeurs de paramètres différentes'
+      for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]*other.l_fonc[i])
+    elif is_float_or_int(other):
+      for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]*other)
+    else:  raise FonctionError, 't_nappe : erreur de type dans __mul__ : %s %s' % (other, type(other))
+    return t_nappe(self.vale_para,l_fonc,self.para)
+
+  def __repr__(self) :
+    """affichage de la nappe en double colonne
+    """
+    texte=[]
+    for i in range(len(self.vale_para)) :
+      texte.append('paramètre : %f' % self.vale_para[i])
+      texte.append(repr(self.l_fonc[i]))
+    return '\n'.join(texte)
+
+  def homo_support(self,other) :
+    """Renvoie la nappe self avec un support union de celui de self et de other
+    le support est la discrétisation vale_para et les discrétisations des fonctions
+    """
+    if self==other:
+       return self
+    vale_para=self.vale_para.tolist()+other.vale_para.tolist()
+    vale_para=list(set(vale_para))
+    vale_para.sort()
+    vale_para=NP.array(vale_para)
+    l_fonc=[]
+    for val in vale_para :
+      if   val in self.vale_para:
+         l_fonc.append(self.l_fonc[NP.searchsorted(self.vale_para, val)])
+      elif val in other.vale_para:
+         other_fonc=other.l_fonc[NP.searchsorted(other.vale_para, val)]
+         new_vale_x=other_fonc.vale_x
+         new_para  =other_fonc.para
+         new_vale_y=[self(val,x) for x in new_vale_x]
+         if isinstance(other_fonc, t_fonction):
+            l_fonc.append(t_fonction(new_vale_x, new_vale_y, new_para))
+         if isinstance(other_fonc, t_fonction_c):
+            l_fonc.append(t_fonction_c(new_vale_x, new_vale_y, new_para))
+      else:
+         raise FonctionError, 'combinaison de nappes : incohérence'
+    return t_nappe(vale_para,l_fonc,self.para)
+
+  def extreme(self) :
+    """renvoie un dictionnaire des valeurs d'ordonnées min et max
+    """
+    val_min=min([min(fonc.vale_y) for fonc in self.l_fonc])
+    val_max=max([max(fonc.vale_y) for fonc in self.l_fonc])
+    vm={'min':[],'max':[]}
+    for i in range(len(self.vale_para)) :
+        for j in range(len(self.l_fonc[i].vale_y)) :
+          y = self.l_fonc[i].vale_y[j]
+          if y==val_min : vm['min'].append([y,self.l_fonc[i].vale_x[j],self.vale_para[i]])
+          if y==val_max : vm['max'].append([y,self.l_fonc[i].vale_x[j],self.vale_para[i]])
+    vm['min'].sort()
+    vm['max'].sort()
+    for item in vm['min'] : item.reverse()
+    for item in vm['max'] : item.reverse()
+    return vm
+
+
+# -----------------------------------------------------------------------------
+def homo_support_nappe(l_f):
+   """Homogénéisation du support d'une liste de nappes.
+   Retourne une liste de nappes.
+   """
+   if not is_enum(l_f):
+      l_f = [l_f,]
+   l_fres=[]
+   for f in l_f:
+      assert isinstance(f, t_nappe), 'Erreur : homo_support_nappe est réservé aux nappes !'
+      __ff=f
+      for g in l_f:
+         __ff=__ff.homo_support(g)
+      l_fres.append(__ff)
+   return l_fres
+
+
+def func_union(func,l_f) :
+    """Retourne la fonction x : func(y0=l_f[0](x), y1=l_f[1](x), ...)
+    sur la liste d'abscisses union de celles de self et de other.
+    """
+    para = copy.copy(l_f[0].para)
+    # Pour les prolongements et l'interpolation, c'est la première fonction qui prime
+    vale_x=[]
+    for f in l_f :
+        vale_x = vale_x + f.vale_x.tolist()
+    # on ote les abscisses doublons
+    vale_x = list(set(vale_x))
+    vale_x.sort()
+    vale_x = NP.array(vale_x)
+    # interpolation des fonctions sur l'union des abscisses
+    vale_y = [map(f,vale_x) for f in l_f]
+    # applique la fonction
+    vale_y = map(func, *vale_y)
+    return t_fonction(vale_x, vale_y, para)
+
+
+def enveloppe(l_f, crit):
+    """renvoie l'enveloppe supérieure ou inférieure de self et other.
+    """
+    if crit.upper() == 'SUP':
+       env = func_union(max, l_f)
+    elif crit.upper() == 'INF':
+       env = func_union(min, l_f)
+    else:
+       raise FonctionError, 'enveloppe : le critère doit etre SUP ou INF !'
+    return env
+
+
+def fractile(l_f, fract):
+    """renvoie l'enveloppe supérieure ou inférieure de self et other.
+    """
+    para = copy.copy(l_f[0].para)
+    # Pour les prolongements et l'interpolation, c'est la première fonction qui prime
+    vale_x=[]
+    for f in l_f :
+        vale_x = vale_x + f.vale_x.tolist()
+    # on ote les abscisses doublons
+    vale_x = list(set(vale_x))
+    vale_x.sort()
+    vale_x = NP.array(vale_x)
+    #
+    l_vale_y=[]
+    for f in l_f :
+        vale_y = map(f,vale_x)
+        l_vale_y.append(vale_y)
+    tab_val=NP.transpose(NP.array(l_vale_y))
+    tab_val=tab_val.tolist()
+    for l in tab_val : l.sort()
+    vale_y=[]
+    if fract>=1. :
+       for l_val in tab_val :
+           vale_y.append(l_val[-1])
+    else :
+       indice=int((len(tab_val[0])-1)*fract)
+       reste =(len(tab_val[0])-1)*fract-indice
+       for l_val in tab_val :
+           vale_y.append(l_val[indice]*(1-reste)+l_val[indice+1]*reste)
+    return t_fonction(vale_x, vale_y, para)
+
+
+def get_len_puis2(tab_in):
+    """Retourne N, la plus grande puissance de 2 telle que 2**N <= len(tab_in)
+    """
+    return int( log(len(tab_in)) / log(2.) )
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/asse_elem_ssd_ops.py b/Aster/Cata/cataSTA10/Macro/asse_elem_ssd_ops.py
new file mode 100644 (file)
index 0000000..fa9d494
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/asse_elem_ssd_ops.py
@@ -0,0 +1,119 @@
+#@ MODIF asse_elem_ssd_ops Macro  DATE 03/01/2011   AUTEUR ANDRIAM H.ANDRIAMBOLOLONA 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# ======================================================================
+
+def asse_elem_ssd_ops(self, RESU_ASSE_SSD, SOUS_STRUC, LIAISON, VERIF, **args):
+    """
+     Echainement des commandes :
+       DEFI_MODELE_GENE + NUME_DDL_GENE + ASSE_MATR_GENE
+    """
+
+    from Accas import _F
+
+    # On importe les definitions des commandes a utiliser dans la macro
+    DEFI_MODELE_GENE = self.get_cmd('DEFI_MODELE_GENE')
+    NUME_DDL_GENE = self.get_cmd('NUME_DDL_GENE')
+    ASSE_MATR_GENE = self.get_cmd('ASSE_MATR_GENE')
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    self.DeclareOut('modele', RESU_ASSE_SSD['MODELE'])
+    self.DeclareOut('nugene', RESU_ASSE_SSD['NUME_DDL_GENE'])
+    if  RESU_ASSE_SSD['RIGI_GENE']:
+        self.DeclareOut('rigidite', RESU_ASSE_SSD['RIGI_GENE'])
+    if RESU_ASSE_SSD['MASS_GENE']:
+        self.DeclareOut('masse', RESU_ASSE_SSD['MASS_GENE'])
+
+    modl_gene = {}
+    mcfact = []
+    for i in range(len(SOUS_STRUC)):
+        arg_sstruc = {}
+        if SOUS_STRUC[i]['ANGL_NAUT'] :
+            arg_sstruc['ANGL_NAUT'] = SOUS_STRUC[i]['ANGL_NAUT']
+        else: # on impose un angle nul
+            arg_sstruc['ANGL_NAUT'] = (0.,0.,0.,)
+        if SOUS_STRUC[i]['TRANS'] :
+            arg_sstruc['TRANS'] = SOUS_STRUC[i]['TRANS']
+        else: # on impose une translation nulle
+            arg_sstruc['TRANS'] = (0.,0.,0.,)
+        mcfact.append( _F(NOM = SOUS_STRUC[i]['NOM'],
+                          MACR_ELEM_DYNA = SOUS_STRUC[i]['MACR_ELEM_DYNA'],
+                       **arg_sstruc))
+    modl_gene['SOUS_STRUC'] = mcfact
+
+    mcfact = []
+    for i in range(len(LIAISON)):
+        arg_liaison = {}
+        if LIAISON[i]['GROUP_MA_MAIT_1'] :
+            arg_liaison['GROUP_MA_MAIT_1'] = LIAISON[i]['GROUP_MA_MAIT_1']
+        if LIAISON[i]['MAILLE_MAIT_1'] :
+            arg_liaison['MAILLE_MAIT_1'] = LIAISON[i]['MAILLE_MAIT_1']
+        if LIAISON[i]['GROUP_MA_MAIT_2'] :
+            arg_liaison['GROUP_MA_MAIT_2'] = LIAISON[i]['GROUP_MA_MAIT_2']
+        if LIAISON[i]['MAILLE_MAIT_2'] :
+            arg_liaison['MAILLE_MAIT_2'] = LIAISON[i]['MAILLE_MAIT_2']
+        if LIAISON[i]['OPTION'] :
+            arg_liaison['OPTION'] = LIAISON[i]['OPTION']
+            if arg_liaison['OPTION'] == 'CLASSIQUE' and args['METHODE'] == 'ELIMINE':
+                print 'ALARME : methode ELIMINE non adaptee a OPTION : ', \
+                      arg_liaison['OPTION']
+        mcfact.append( _F(SOUS_STRUC_1 = LIAISON[i]['SOUS_STRUC_1'],
+                          INTERFACE_1 = LIAISON[i]['INTERFACE_1'],
+                          SOUS_STRUC_2 = LIAISON[i]['SOUS_STRUC_2'],
+                          INTERFACE_2 = LIAISON[i]['INTERFACE_2'],
+                       **arg_liaison))
+    modl_gene['LIAISON'] = mcfact
+
+    if VERIF:
+        mcfact = []
+        for i in range(len(VERIF)):
+            arg_verif = {}
+            if VERIF[i]['STOP_ERREUR'] :
+                arg_verif['STOP_ERREUR'] = VERIF[i]['STOP_ERREUR']
+            if VERIF[i]['PRECISION'] :
+                arg_verif['PRECISION'] = VERIF[i]['PRECISION']
+            if VERIF[i]['CRITERE'] :
+                arg_verif['CRITERE'] = VERIF[i]['CRITERE']
+            mcfact.append( _F( **arg_verif))
+        modl_gene['VERIF'] = mcfact
+    else:
+        modl_gene['VERIF'] = None
+
+    modele = DEFI_MODELE_GENE(
+                 SOUS_STRUC = modl_gene['SOUS_STRUC'],
+                 LIAISON = modl_gene['LIAISON'],
+                 VERIF = modl_gene['VERIF'],
+                       )
+
+    nugene = NUME_DDL_GENE(MODELE_GENE = modele,
+                           METHODE = args['METHODE'],
+                           STOCKAGE = args['STOCKAGE'],
+                          )
+
+    if  RESU_ASSE_SSD['RIGI_GENE']:
+        rigidite = ASSE_MATR_GENE( NUME_DDL_GENE = nugene,
+                                   OPTION = 'RIGI_GENE')
+    if RESU_ASSE_SSD['MASS_GENE']:
+        masse = ASSE_MATR_GENE( NUME_DDL_GENE = nugene,
+                                OPTION = 'MASS_GENE')
+
+    return
+

diff --git a/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py b/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py
index 749fa42751602d103832980971a2fce9f953fce0..e2967d47b12fc3d68818ccb64415c216413841e0 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF calc_essai_ops Macro  DATE 28/01/2010   AUTEUR BODEL C.BODEL 
+#@ MODIF calc_essai_ops Macro  DATE 14/12/2010   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -21,31 +21,24 @@
 ## \package calc_essai_ops Implémentation de la macro CALC_ESSAI
 #
 # Ce module contient la partie controle de la macro CALC_ESSAI
-# l'implémetation de cette macro se trouve dans les modules
-# meidee_help, meidee_mac, meidee_massamor, meidee_turbulent
-# on utilise aussi une librairie de support
-# pour la gestion de l'interface graphique dans meidee_iface
+# les autres fichiers sources sont situes dans ../Calc_essai
 
 
 def calc_essai_ops( self,
                     INTERACTIF          = None,
-                    #UNITE_FIMEN         = None,
                     UNITE_RESU          = None,
                     EXPANSION           = None,
-                    #MEIDEE_FLUDELA      = None,
-                    #MEIDEE_TURBULENT    = None,
                     IDENTIFICATION      = None,
                     MODIFSTRUCT         = None,
                     TRAITEMENTSIG       = None,
                     GROUP_NO_CAPTEURS   = None,
                     GROUP_NO_EXTERIEUR  = None,
-                    #RESU_FLUDELA        = None,
-                    #RESU_TURBULENT      = None,
                     RESU_IDENTIFICATION = None,
                     RESU_MODIFSTRU      = None,
                     **args):
+
+    from Calc_essai.cata_ce import CalcEssaiObjects
     import aster
-    from Meidee.meidee_cata import MeideeObjects
     ier = 0
     
     # La macro compte pour 1 dans la numerotation des commandes
@@ -75,60 +68,35 @@ def calc_essai_ops( self,
                           "ComptTable" : 0,
                           "TablesOut"  : table_fonction}
 
-## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS
-##    if not RESU_FLUDELA:
-##        RESU_FLUDELA = []
-##    else:
-##        for res in RESU_FLUDELA:
-##            table.append(res['TABLE'])
-##    out_fludela = {"DeclareOut" : self.DeclareOut,
-##                   "TypeTables" : 'TABLE',
-##                   "ComptTable" : 0,
-##                   "TablesOut" : table}
-##
-##    if not RESU_TURBULENT:
-##        RESU_TURBULENT = []
-##    else:
-##        for res in RESU_TURBULENT:
-##            table_fonction.append(res['FONCTION'])
-##    out_meideeturb = {"DeclareOut" : self.DeclareOut,
-##                      "FoncOut" : table_fonction}
     
     # Mode interactif : ouverture d'une fenetre Tk
     if INTERACTIF == "OUI":
         aster.onFatalError('EXCEPTION')
 
         create_interactive_window(self,
-                                  #UNITE_FIMEN,
-                                  #out_fludela,
-                                  #out_meideeturb,
                                   out_identification,
                                   out_modifstru,
                                   )
     else:
-        from Meidee.meidee_calcul import MessageBox
-        from Meidee.meidee_test import TestMeidee
+        from Calc_essai.ce_test import MessageBox
+        from Calc_essai.ce_test import TestCalcEssai
         mess = MessageBox(UNITE_RESU)
         mess.disp_mess("Mode non intéractif")
         
-        objects = MeideeObjects(self, mess)
+        objects = CalcEssaiObjects(self, mess)
 
         # importation des concepts aster existants de la memoire jeveux
-        TestMeidee(self,
-                   mess,
-                   #out_fludela,
-                   #out_meideeturb,
-                   out_identification,
-                   out_modifstru,
-                   objects,
-                   EXPANSION,
-                   #MEIDEE_FLUDELA,
-                   #MEIDEE_TURBULENT,
-                   IDENTIFICATION,
-                   MODIFSTRUCT,
-                   GROUP_NO_CAPTEURS,
-                   GROUP_NO_EXTERIEUR              
-                   )
+        TestCalcEssai(self,
+                      mess,
+                      out_identification,
+                      out_modifstru,
+                      objects,
+                      EXPANSION,
+                      IDENTIFICATION,
+                      MODIFSTRUCT,
+                      GROUP_NO_CAPTEURS,
+                      GROUP_NO_EXTERIEUR              
+                      )
 
         mess.close_file()
     aster.onFatalError(prev)
@@ -136,28 +104,21 @@ def calc_essai_ops( self,
 
 
 
-def create_tab_mess_widgets(tk):
+def create_tab_mess_widgets(tk,tabskeys):
     """Construits les objects table et boîte à messages."""
     try:
         from Pmw import PanedWidget
     except ImportError:
         PanedWidget = None
     
-    from Meidee.meidee_iface import MessageBoxInteractif, TabbedWindow
+    from Calc_essai.outils_ihm import MessageBoxInteractif, TabbedWindow
     
     tabsw = tk
     msgw = tk
     tk.rowconfigure(0, weight=2)
     tk.rowconfigure(1, weight=1)
 
-    tabs = TabbedWindow(tabsw, ["Expansion de modeles",
-                                "Modification structurale",
-                                #"MEIDEE mono-modal fludela",
-                                #"MEIDEE mono-modal turbulent",
-                                "Identification de chargement",
-                                "Traitement du signal",
-                                "Parametres de visualisation",
-                               ])
+    tabs = TabbedWindow(tabsw, tabskeys)
 
     tabs.grid(row=0, column=0, sticky='nsew')
     # pack(side='top',expand=1,fill='both')
@@ -168,23 +129,6 @@ def create_tab_mess_widgets(tk):
     
     return tabs, mess
 
-## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS
-##def get_fimen_files(UNITE_FIMEN, FIMEN=None):
-##    """Fichiers fimen éventuels associés aux unités logiques en entrée"""
-##    # XXX FIMEN is not defined (should it be included in the macro)
-##    from Utilitai.UniteAster import UniteAster
-##    fichiers_fimen = []
-##    print "FIMEN:", UNITE_FIMEN
-##
-##    if UNITE_FIMEN:
-##        if type(FIMEN)==int:
-##            UNITE_FIMEN= [ UNITE_FIMEN ]
-##        for unit in UNITE_FIMEN:
-##            UL = UniteAster()
-##            fichiers_fimen.append( (unit, UL.Nom(unit)) )
-##
-##    return fichiers_fimen
-
 
 class FermetureCallback:
     """Opérations à appliquer lors de la fermeture de la
@@ -203,70 +147,60 @@ class FermetureCallback:
 
 
 def create_interactive_window(macro,
-                              #UNITE_FIMEN,
-                              #out_fludela,
-                              #out_meideeturb,
                               out_identification,
                               out_modifstru,
                               ):
     """Construit la fenêtre interactive comprenant une table pour 
-    les 4 domaines de Meidee."""
+    les 4 domaines de CALC_ESSAI."""
     from Tkinter import Tk
     
-    from Meidee.meidee_cata import MeideeObjects
-    from Meidee.meidee_correlation import InterfaceCorrelation
-    from Meidee.meidee_modifstruct import InterfaceModifStruct
-    from Meidee.meidee_turbulent import InterfaceTurbulent
-    from Meidee.meidee_parametres import InterfaceParametres
-    from Meidee.meidee_calc_spec import InterfaceCalcSpec
-## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS
-##    from Meidee.meidee_fludela import InterfaceFludela, InterfaceTurbMonomod
+    from Calc_essai.cata_ce import CalcEssaiObjects
+    from Calc_essai.ce_ihm_expansion import InterfaceCorrelation
+    from Calc_essai.ce_ihm_modifstruct import InterfaceModifStruct
+    from Calc_essai.ce_ihm_identification import InterfaceIdentification
+    from Calc_essai.ce_ihm_parametres import InterfaceParametres
+    from Calc_essai.ce_calc_spec import InterfaceCalcSpec
     
     # fenetre principale
     tk = Tk()
-    tk.rowconfigure(0, weight=1)
-    tk.columnconfigure(0,weight=1)
     tk.title("CALC_ESSAI")
+    tk.rowconfigure(0,weight=1)
+    tk.rowconfigure(1,weight=20)
+    tk.rowconfigure(2,weight=1)
 
-    tabs, mess = create_tab_mess_widgets(tk)
+    tabskeys = ["Expansion de modeles",
+                "Modification structurale",
+                "Identification de chargement",
+                "Traitement du signal",
+                "Parametres de visualisation" ]
+    
+    tabs, mess = create_tab_mess_widgets(tk, tabskeys)
     main = tabs.root()
     
     # importation des concepts aster de la memoire jeveux    
-    objects = MeideeObjects(macro, mess)
+    objects = CalcEssaiObjects(macro, mess)
     tabs.set_objects(objects)
     
     param_visu = InterfaceParametres(main, mess)
     
-    iface = InterfaceCorrelation(main, objects, macro, mess,
-                                 param_visu)
-    imodifstruct = InterfaceModifStruct(main, objects, macro,
-                                        mess, out_modifstru, param_visu)
-    identification = InterfaceTurbulent(main, objects, mess, out_identification, param_visu)
-    
+    iface = InterfaceCorrelation(main, objects, macro, mess,param_visu)
+    imodifstruct = InterfaceModifStruct(main, objects, macro,mess, out_modifstru, param_visu)
+    identification = InterfaceIdentification(main, objects, mess, out_identification, param_visu)
     calc_spec= InterfaceCalcSpec(main,objects,mess,param_visu)
-## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS
-##    fludelamonomod = InterfaceFludela(main, objects,
-##                                      get_fimen_files(UNITE_FIMEN), mess, out_fludela, param_visu)
-##    turbmonomod = InterfaceTurbMonomod(main, objects,get_fimen_files(UNITE_FIMEN) ,mess, out_meideeturb, param_visu)
-
 
-    tabs.set_tab("Expansion de modeles", iface.main)
-    tabs.set_tab("Modification structurale", imodifstruct.main)
-    tabs.set_tab("Identification de chargement", identification)
-    tabs.set_tab("Traitement du signal", calc_spec)
-    tabs.set_tab("Parametres de visualisation", param_visu)
-## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS
-##    tabs.set_tab("MEIDEE mono-modal fludela", fludelamonomod )
-##    tabs.set_tab("MEIDEE mono-modal turbulent", turbmonomod )
-    
+    tabs.set_tab(tabskeys[0], iface.main)
+    tabs.set_tab(tabskeys[1], imodifstruct.main)
+    tabs.set_tab(tabskeys[2], identification)
+    tabs.set_tab(tabskeys[3], calc_spec)
+    tabs.set_tab(tabskeys[4], param_visu)    
     
-    tabs.set_current_tab("Expansion de modeles")
+    tabs.set_current_tab(tabskeys[4])
 
     tk.protocol("WM_DELETE_WINDOW", FermetureCallback(tk, identification).apply)
     
     try:
         tk.mainloop()
     except :
-        print "MEIDEE : *ERREUR*"
+        print "CALC_ESSAI : *ERREUR*"
 
     

diff --git a/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py
index 95a09ffffb5f8382ace625f8b6edd487b4c43e6c..7d2ac6d1d3b607ac98c6302a8cf2fb6ecf67c4a4 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF calc_europlexus_ops Macro  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF calc_europlexus_ops Macro  DATE 15/02/2011   AUTEUR ASSIRE A.ASSIRE 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -113,10 +113,13 @@ def calc_europlexus_ops(self,MODELE,CARA_ELEM,CHAM_MATER,EXCIT,FONC_PARASOL=None
   from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
   MasquerAlarme('MED_1')
   MasquerAlarme('MED_54')
+  MasquerAlarme('MED_77')
+  MasquerAlarme('MED_37')
+
 
   # Ligne de commande d'Europlexus
   if args.has_key('LOGICIEL'): EXEC = args['LOGICIEL']
-  else: EXEC = '/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d'
+  else: EXEC = '/home/europlex/EPXD/bin/europlexus'
   if debug: print 'args_keys : %s'%args.keys()
   if args.has_key('PAS_NBRE_COURBE') :
      if debug: print 'PAS NBRE COURBE = ok (%s)'%args['PAS_NBRE_COURBE']
@@ -168,6 +171,8 @@ def calc_europlexus_ops(self,MODELE,CARA_ELEM,CHAM_MATER,EXCIT,FONC_PARASOL=None
   # Pour la gestion des alarmes
   RetablirAlarme('MED_1')
   RetablirAlarme('MED_54')
+  RetablirAlarme('MED_77')
+  RetablirAlarme('MED_37')
 
   return ier
 
@@ -1815,7 +1820,7 @@ class EUROPLEXUS:
     
     # Dictionnaire permettant de traduire le champ epx en med au nom asscie dans aster
 # AA    epx2aster = {'CONTRAINTE':'SIEF_ELGA','ECROUISSAGE':'VARI_ELGA'}
-    epx2aster = {'CONTRAINTE':'SIEF_ELGA','DEFORMATION':'EPSI_ELGA_DEPL','ECROUISSAGE':'VARI_ELGA'}
+    epx2aster = {'CONTRAINTE':'SIEF_ELGA','DEFORMATION':'EPSI_ELGA','ECROUISSAGE':'VARI_ELGA'}
 
 # AA : desactive pour le moment
 #     # Enrichir la liste format_med par les champs aux pts de gauss
@@ -1842,6 +1847,8 @@ class EUROPLEXUS:
     fort = 'fort.%i' %unite
     if os.path.isfile(fort) : os.remove(fort)
 
+    if not os.path.isfile(fichier_med): UTMESS('F','PLEXUS_14')   
+
     os.symlink(fichier_med,fort)
 
     # Regeneration des mots-cles EXCIT passés en argument de la macro
@@ -1850,6 +1857,7 @@ class EUROPLEXUS:
        dExcit.append(j.cree_dict_valeurs(j.mc_liste))
        for i in dExcit[-1].keys():
           if dExcit[-1][i]==None : del dExcit[-1][i]
+
     resu = LIRE_RESU(TYPE_RESU='EVOL_NOLI',
 #                  VERI_ELGA='NON',
                   FORMAT='MED',
@@ -2299,7 +2307,7 @@ class EUROPLEXUS:
         # resu = CREA_RESU(reuse=resu,
             # OPERATION = 'AFFE',
             # TYPE_RESU = 'EVOL_NOLI',
-            # NOM_CHAM  = 'EPSI_ELGA_DEPL',
+            # NOM_CHAM  = 'EPSI_ELGA',
             # AFFE = dicAffe2)
         resu = CREA_RESU(reuse=resu,
             OPERATION = 'AFFE',
@@ -2316,7 +2324,11 @@ class EUROPLEXUS:
   def lancer_calcul(self,fichier_med='auto'):
 
      fichier_epx = self.nom_fichiers['COMMANDE']
-     EXEC_LOGICIEL(LOGICIEL='cd %s ; unset TMPDIR ; %s -usetmpdir %s ; iret=$? ; cd %s ; echo "Code_Retour Europlexus : $iret" ; exit 0' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd),
+#     EXEC_LOGICIEL(LOGICIEL='cd %s ; unset TMPDIR ; %s -usetmpdir %s ; iret=$? ; cd %s ; echo "Code_Retour Europlexus : $iret" ; exit 0' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd),
+#                   CODE_RETOUR_MAXI=-1,
+#                   INFO=2)
+
+     EXEC_LOGICIEL(LOGICIEL='cd %s ; unset TMPDIR ; unset PMI_RANK ; %s %s ; iret=$? ; cd %s ; echo "Code_Retour Europlexus : $iret" ; exit 0' % (self.pwd + self.REPE, self.EXEC, fichier_epx, self.pwd),
                    CODE_RETOUR_MAXI=-1,
                    INFO=2)
 

diff --git a/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py
index 7afe34ed90e06d2c86f88fef213e1626d85f9815..baf97a6175ba7bc5eec1081b4ab1d8473a65b1e4 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF calc_fonction_ops Macro  DATE 11/10/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF calc_fonction_ops Macro  DATE 22/03/2011   AUTEUR COURTOIS M.COURTOIS 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2005  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -17,6 +17,7 @@
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
 
 import os
 import copy
@@ -304,7 +305,7 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP,
       
          # construction de la nappe
          vale_para = l_amor
-         para      = { 'INTERPOL'      : ['LIN','LOG'],
+         para      = { 'INTERPOL'      : ['LIN', 'LOG'],
                        'NOM_PARA_FONC' : 'FREQ',
                        'NOM_PARA'      : 'AMOR',
                        'PROL_DROITE'   : 'EXCLU',
@@ -372,11 +373,11 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP,
    
    if isinstance(__ex,t_fonction) or isinstance(__ex,t_fonction_c):
       para=__ex.para
-      if NOM_PARA   !=None : para['NOM_PARA']   =NOM_PARA
-      if NOM_RESU   !=None : para['NOM_RESU']   =NOM_RESU
-      if PROL_DROITE!=None : para['PROL_DROITE']=PROL_DROITE
-      if PROL_GAUCHE!=None : para['PROL_GAUCHE']=PROL_GAUCHE
-      if INTERPOL   !=None : para['INTERPOL']   =INTERPOL
+      if NOM_PARA    != None: para['NOM_PARA']    = NOM_PARA
+      if NOM_RESU    != None: para['NOM_RESU']    = NOM_RESU
+      if PROL_DROITE != None: para['PROL_DROITE'] = PROL_DROITE
+      if PROL_GAUCHE != None: para['PROL_GAUCHE'] = PROL_GAUCHE
+      if INTERPOL    != None: para['INTERPOL']    = INTERPOL
       if   isinstance(__ex,t_fonction_c): para['VALE_C'] = __ex.tabul()
       elif isinstance(__ex,t_fonction)  : para['VALE']   = __ex.tabul()
       C_out=DEFI_FONCTION(**para)
@@ -385,17 +386,20 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP,
       for f in __ex.l_fonc :
          para=f.para
          def_fonc.append(_F(VALE       =f.tabul(),
-                            INTERPOL   =f.para['INTERPOL'],
-                            PROL_DROITE=f.para['PROL_DROITE'],
-                            PROL_GAUCHE=f.para['PROL_GAUCHE'],))
+                            INTERPOL   =INTERPOL_FONC or f.para['INTERPOL'],
+                            PROL_DROITE=PROL_DROITE_FONC or f.para['PROL_DROITE'],
+                            PROL_GAUCHE=PROL_GAUCHE_FONC or f.para['PROL_GAUCHE'],))
       para=__ex.para
-      if NOM_PARA      !=None : para['NOM_PARA']   =NOM_PARA
-      if NOM_RESU      !=None : para['NOM_RESU']   =NOM_RESU
-      if PROL_DROITE   !=None : para['PROL_DROITE']=PROL_DROITE
-      if PROL_GAUCHE   !=None : para['PROL_GAUCHE']=PROL_GAUCHE
-      if NOM_PARA_FONC !=None : para['NOM_PARA_FONC']   =INTERPOL
-      if INTERPOL_FONC !=None : para['INTERPOL']   =INTERPOL
-      C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(),DEFI_FONCTION=def_fonc,**para)
+      if NOM_PARA      != None: para['NOM_PARA']      = NOM_PARA
+      if NOM_RESU      != None: para['NOM_RESU']      = NOM_RESU
+      if PROL_DROITE   != None: para['PROL_DROITE']   = PROL_DROITE
+      if PROL_GAUCHE   != None: para['PROL_GAUCHE']   = PROL_GAUCHE
+      if NOM_PARA_FONC != None: para['NOM_PARA_FONC'] = NOM_PARA_FONC
+      if INTERPOL      != None: para['INTERPOL']      = INTERPOL
+      print para
+      C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(),
+                       DEFI_FONCTION=def_fonc,
+                       **para)
    if INFO > 1:
       IMPR_FONCTION(FORMAT='TABLEAU',
                     UNITE=6,

diff --git a/Aster/Cata/cataSTA10/Macro/calc_ifs_dnl_ops.py b/Aster/Cata/cataSTA10/Macro/calc_ifs_dnl_ops.py
new file mode 100644 (file)
index 0000000..0794c6a
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_ifs_dnl_ops.py
@@ -0,0 +1,580 @@
+#@ MODIF calc_ifs_dnl_ops Macro  DATE 14/02/2011   AUTEUR GREFFET N.GREFFET 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GREFFET N.GREFFET
+#
+# MACRO DE COUPLAGE IFS AVEC SATURNE VIA YACS
+#
+import os
+def calc_ifs_dnl_ops(self,GROUP_MA_IFS,NOM_CMP_IFS,UNITE_NOEUD,UNITE_ELEM,MODELE,ETAT_INIT,EXCIT,PAS_INIT,**args):
+  #=================================================================#
+  # Initialisations                                                 #
+  # --------------------------------------------------------------- #
+  """
+     Corps de la macro CALC_IFS_DNL
+  """
+  ier=0
+  import aster
+  import os,string,types
+  from Accas import _F
+  from Utilitai.Table import Table
+  from Utilitai.Utmess import  UTMESS
+  # from Cata.cata import *
+  from Cata.cata import EXTR_RESU, DEFI_LIST_ENTI, IMPR_RESU
+  from SD.sd_maillage      import sd_maillage
+  #
+  self.set_icmd(1)
+  #=================================================================#
+  # Liste des commandes ASTER utilisees                             #
+  # --------------------------------------------------------------- #
+  AFFE_CHAR_MECA=self.get_cmd('AFFE_CHAR_MECA')
+  DEFI_GROUP    =self.get_cmd('DEFI_GROUP')
+  DEFI_LIST_REEL=self.get_cmd('DEFI_LIST_REEL')
+  DYNA_NON_LINE=self.get_cmd('DYNA_NON_LINE')
+  LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE')
+  PROJ_CHAMP    =self.get_cmd('PROJ_CHAMP')
+  # Operateurs specifiques pour IFS
+  IMPR_MAIL_YACS  =self.get_cmd('IMPR_MAIL_YACS')
+  ENV_CINE_YACS=self.get_cmd('ENV_CINE_YACS')
+  MODI_CHAR_YACS =self.get_cmd('MODI_CHAR_YACS')
+  RECU_PARA_YACS =self.get_cmd('RECU_PARA_YACS')
+  #=================================================================#
+  # Gestion des mots cles specifiques a CALC_IFS_DNL                #
+  # --------------------------------------------------------------- #
+  motscles     = {}
+  poidsMocle   = {}
+  grpRefeMocle = {}
+  grpProjMocle = {}
+  ifsCharMocle = {}
+  tmpListe     = []
+  ifsCharList  = []
+  poidsMocle  ['VIS_A_VIS']     = []
+  grpRefeMocle['CREA_GROUP_NO'] = []
+  grpProjMocle['CREA_GROUP_NO'] = []
+  ifsCharMocle['GROUP_NO']      = []
+  
+  ifsCharTuple = (GROUP_MA_IFS,)
+  #print "ifsCharTuple=",ifsCharTuple
+  ifsCharList = GROUP_MA_IFS
+  #print "len(ifsCharList)=",len(ifsCharList)
+  prefix="_"
+  for j in range(len(ifsCharTuple)):
+    poidsDico              = {}
+    poidsDico['GROUP_MA_1']= ifsCharTuple[j]
+    poidsDico['GROUP_NO_2']= 'GN'+str(j+1)
+    poidsMocle['VIS_A_VIS'].append(poidsDico)
+
+    grpProjDico                  ={}
+    grpProjDico['GROUP_MA']      ='GM'+str(j+1)
+    grpProjDico['NOM']           ='GN'+str(j+1)
+    grpProjMocle['CREA_GROUP_NO'].append(grpProjDico)
+
+    if (not(ifsCharTuple[j] in tmpListe)):
+      tmpListe.append(ifsCharTuple[j])
+      grpRefeNode  = prefix + ifsCharTuple[j]
+    #  ifsCharTuple = ifsCharTuple[1:] + (grpRefeNode,)
+            
+      grpRefeDico                  = {}
+      grpRefeDico['GROUP_MA']      = ifsCharTuple[j]
+      grpRefeDico['NOM']           = grpRefeNode
+      grpRefeMocle['CREA_GROUP_NO'].append(grpRefeDico)
+
+  for j in range(len(tmpListe)):
+    tmpListe[j] = prefix + tmpListe[j]
+  ifsCharMocle['GROUP_NO']=tuple(tmpListe)
+
+  for j in range(len(NOM_CMP_IFS)):
+    if (NOM_CMP_IFS[j] == 'FX'):
+      ifsCharMocle['FX'] = 0.0
+    elif (NOM_CMP_IFS[j] == 'FY'):
+      ifsCharMocle['FY'] = 0.0
+    elif (NOM_CMP_IFS[j] == 'FZ'):
+      ifsCharMocle['FZ'] = 0.0
+    else:
+      raise AsException("MOT-CLE NON PERMIS : ",NOM_CMP_IFS[j])
+
+  #=================================================================#
+  # Gestion des mots cles de DYNA_NON_LINE                          #
+  # --------------------------------------------------------------- #
+  motCleSimpTuple= ('MODELE',
+                    'CHAM_MATER',
+                    'MODE_STAT',
+                    'CARA_ELEM',
+                    'MASS_DIAG',
+                    'SENSIBILITE',
+                    'INFO',
+                    'TITRE')
+
+# 'COMP_INCR' =C_COMP_INCR() : dans motCleFactTuple ?
+  motCleFactTuple= ('EXCIT',
+                    'EXCIT_GENE',
+                    'SOUS_STRUC',
+                    'AMOR_MODAL',
+                    'PROJ_MODAL',
+                    'COMP_INCR',
+                    'COMP_ELAS',
+                    'ETAT_INIT',
+                    'SCHEMA_TEMPS',
+                    'NEWTON',
+                    'SOLVEUR',
+                    'RECH_LINEAIRE',
+                    'PILOTAGE',
+                    'CONVERGENCE',
+                    'OBSERVATION',
+                    'AFFICHAGE',
+                    'ARCHIVAGE',
+                    'CRIT_FLAMB',
+                    'MODE_VIBR')
+
+  for i in range(len(motCleSimpTuple)):
+    cle = motCleSimpTuple[i]
+    if args.has_key(cle):
+      motscles[cle]=args[cle]
+
+  for i in range(len(motCleFactTuple)):
+    cle = motCleFactTuple[i]  
+    if args.has_key(cle):
+      if args[cle] != None :
+        dMotCle=[]
+        for j in args[cle]:
+          dMotCle.append(j.cree_dict_valeurs(j.mc_liste))
+          for k in dMotCle[-1].keys():
+            if dMotCle[-1][k]==None : del dMotCle[-1][k]
+        motscles[cle]=dMotCle
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
+
+  #===============================#
+  # INITIALISATION DE LA SD MACRO #
+  # ----------------------------- #
+  self.DeclareOut('resdnl',self.sd)
+
+
+  #============================================================#
+  # GENERATION DES GROUPES DE NOEUDS SUR LE MAILLAGE STRUCTURE #
+  # ---------------------------------------------------------- #
+  ### on recupere le concept maillage
+  #print "MODELE=",MODELE
+  #print "MODELE.strip()=",MODELE.strip()
+  
+  iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',MODELE.nom,'MODELE')
+  _strucMesh = self.get_concept(nom_ma.strip())
+  #print "MAILLAGE STRUCTURE=",_strucMesh
+  #print "DEFI_GROUP MAILLAGE STRUCTURE"
+  #print "grpRefeMocle=",grpRefeMocle
+  _strucMesh = DEFI_GROUP(reuse    = _strucMesh,
+                          MAILLAGE = _strucMesh,
+                          **grpRefeMocle)
+
+  #=============================================================================#
+  # RECUPERATION DU MAILLAGE COUPLE POUR LES DEPLACEMENTS (NOEUDS Code_Saturne) #  !!! YACS COMMUNICATION !!!
+  # --------------------------------------------------------------------------- #
+  print "IMPR_MAIL_YACS MAILLAGE NOEUDS"
+  IMPR_MAIL_YACS(UNITE_MAILLAGE = UNITE_NOEUD,TYPE_MAILLAGE = 'SOMMET',),
+  print "LIRE_MAILLAGE MAILLAGE NOEUDS"
+  _fluidNodeMesh = LIRE_MAILLAGE(UNITE = UNITE_NOEUD)
+  print "DEFI_GROUP MAILLAGE NOEUDS"
+  #print "grpProjMocle=",grpProjMocle
+  _fluidNodeMesh = DEFI_GROUP(reuse    = _fluidNodeMesh,
+                              MAILLAGE = _fluidNodeMesh,
+                              **grpProjMocle)
+
+  #====================================================================================#
+  # RECUPERATION DU MAILLAGE COUPLE POUR LES FORCES (CENTRE DES ELEMENTS Code_Saturne) #  !!! YACS COMMUNICATION !!!
+  # ---------------------------------------------------------------------------------- #
+  print "IMPR_MAIL_YACS MAILLAGE ELEMENTS"
+  IMPR_MAIL_YACS(UNITE_MAILLAGE = UNITE_ELEM,TYPE_MAILLAGE = 'MILIEU',)
+  print "LIRE_MAILLAGE MAILLAGE ELEMENTS"
+  _fluidElemMesh = LIRE_MAILLAGE(UNITE = UNITE_ELEM)
+  print "DEFI_GROUP MAILLAGE ELEMENTS"
+  #print "grpProjMocle=",grpProjMocle
+  _fluidElemMesh = DEFI_GROUP(reuse    = _fluidElemMesh,
+                               MAILLAGE = _fluidElemMesh,
+                               **grpProjMocle)
+
+  #==============================================#
+  # CALCUL DES PROJECTEURS POUR LES DEPLACEMENTS #
+  # ASTER -> CODE COUPLE                         #
+  # -------------------------------------------- #
+  print "PROJ_CHAMP MAILLAGE NOEUDS"
+  #print "MAILLAGE_1=",_strucMesh.nom
+  #print "MAILLAGE_2=",_fluidNodeMesh.nom
+  _fluidNodePoids = PROJ_CHAMP(PROJECTION = 'NON',
+                               METHODE    = 'COUPLAGE',
+                               MAILLAGE_1 = _strucMesh,
+                               MAILLAGE_2 = _fluidNodeMesh,
+                               **poidsMocle)
+
+  #========================================#
+  # CALCUL DES PROJECTEURS POUR LES FORCES #
+  # CODE COUPLE -> ASTER                   #
+  # -------------------------------------- #
+  print "PROJ_CHAMP MAILLAGE ELEMENTS"
+  #print "MAILLAGE_1=",_strucMesh
+  #print "MAILLAGE_2=",_fluidElemMesh
+  _fluidElemPoids = PROJ_CHAMP(PROJECTION = 'NON',
+                               METHODE    = 'COUPLAGE',
+                               MAILLAGE_1 = _strucMesh,
+                               MAILLAGE_2 = _fluidElemMesh,
+                               **poidsMocle)
+
+  #====================================================================================#
+  # CREATION DE LA CARTES DES FORCES NODALES AVEC UNE INITIALISATION DES FORCES A ZERO #
+  # ---------------------------------------------------------------------------------- #
+  print "AFFE_CHAR_MECA"
+  _ifsCharMeca = AFFE_CHAR_MECA(MODELE       = MODELE,
+                                FORCE_NODALE = _F(**ifsCharMocle),)
+  dExcit=[]
+  if (EXCIT != None):
+    for j in EXCIT :
+      dExcit.append(j.cree_dict_valeurs(j.mc_liste))
+      for i in dExcit[-1].keys():
+        if dExcit[-1][i]==None : del dExcit[-1][i]
+  dExcit.append(_F(CHARGE=_ifsCharMeca),)
+
+  #====================================#
+  # ENVOIE DU MAILLAGE INITIAL DEFORME #  !!! YACS COMMUNICATION !!!
+  # ---------------------------------- #
+  dEtatInit=[]
+  dExtrInit={}
+  if (ETAT_INIT != None):
+    if (ETAT_INIT['DEPL'] != None):
+      dExtrInit['DEPL']=ETAT_INIT['DEPL']
+    if (ETAT_INIT['VITE'] != None):
+      dExtrInit['VITE']=ETAT_INIT['VITE']
+    if (ETAT_INIT['ACCE'] != None):
+      dExtrInit['ACCE']=ETAT_INIT['ACCE']
+    for j in ETAT_INIT:
+      dEtatInit.append(j.cree_dict_valeurs(j.mc_liste))
+      for i in dEtatInit[-1].keys():
+        if dEtatInit[-1][i]==None : del dEtatInit[-1][i]
+
+  #======================================#
+  # RECUPERATION DES DONNEES TEMPORELLES #  !!! YACS COMMUNICATION !!!
+  # ------------------------------------ #
+  print "Appel initialisation"
+  
+  _timeStepAster = PAS_INIT
+  print "PAS=",_timeStepAster
+  _timeV = RECU_PARA_YACS(DONNEES    = 'INITIALISATION',
+                     PAS    = _timeStepAster,)
+  #print "__timeValues=",_timeV.Valeurs()
+  _timeValues   = _timeV.Valeurs()
+  _nbTimeStep  = int(_timeValues[0])
+  
+#  Ancien nommage
+#   _timeStep    = _timeValues[1]
+#   _tInitial    = _timeValues[2]
+#   _nbSsIterMax = int(_timeValues[3])
+#   _impEnsight  = int(_timeValues[4])
+#   _PeriodImp   = int(_timeValues[5])
+#   _StartImp    = int(_timeValues[6])
+  _nbSsIterMax  = int(_timeValues[1])
+  _Epsilo       = _timeValues[2]
+  _impEnsight   = int(_timeValues[3])
+  _PeriodImp    = int(_timeValues[4])
+  _tInitial     = _timeValues[5]
+  _timeStep     = _timeValues[6]
+  _StartImp     = _tInitial
+  print '_nbTimeStep  = ',_nbTimeStep
+  print '_timeStep    = ',_timeStep
+  print '_tInitial    = ',_tInitial
+  print '_nbSsIterMax = ',_nbSsIterMax
+  print '_impEnsight  = ',_impEnsight
+  print '_PeriodImp   = ',_PeriodImp
+  print '_StartImp   = ',_StartImp
+  if (_nbSsIterMax == 0):
+    _nbSsIterMax = 1
+
+#  _endValue   = int(_timeValues[7])
+#  _nbTimeStep = _endValue
+  #print '_nbTimeStep 2  = ',_nbTimeStep
+  
+#  Compteur de pas :
+  _numpas     = 1
+# Compteur pour le couplage : CP_ITERATION
+  _ntcast     = 0
+# Compteur de sous-itearation
+  _SousIterations = 1
+  
+  ticv=[None]*(_nbTimeStep+1) ;
+  endv=[None]*(_nbTimeStep+1) ;
+
+
+#
+#   Envoi des donnees initiales si besoin est
+#
+#   print "ENV_CINE_YACS 1"
+#   ENV_CINE_YACS(ETAT_INIT   = dExtrInit,
+#                 MATR_PROJECTION       = _fluidNodePoids,
+#                 NUME_ORDRE_YACS   = _numpas,
+#                 INST     = _tInitial,
+#                 PAS     = _timeStep,
+#                 **poidsMocle)
+#   print "RETOUR ENV_CINE_YACS 1"
+
+  #=================================#
+  # 1ER PASSAGE POUR L'ETAT INITIAL #
+  # ------------------------------- #
+
+  # ------------------------------------- #
+  # CALCUL NON LINEAIRE AVEC ETAT INITIAL #
+  # ------------------------------------- #
+  if (_numpas <= _nbTimeStep):
+    # ---------------------------------- #
+    # Affectation de l'instant de calcul #
+    # ---------------------------------- #
+    print "RECU_PARA_YACS 1"
+    _tStart = _tInitial
+    _pastps = RECU_PARA_YACS(DONNEES   = 'PAS',
+                        NUME_ORDRE_YACS = _numpas,
+                        INST   = _tStart,
+                        PAS   = _timeStepAster,
+                     )
+    _pastps0   = _pastps.Valeurs() 
+    print "_pastps0[0]=", _pastps0[0]
+    _timeStep  = _pastps0[0]
+    print "DEFI_LIST_REEL"
+    _tEnd   = _tInitial+_timeStep
+    print "_tStart=",_tStart," ; _tEnd=",_tEnd
+    _liste=DEFI_LIST_REEL(DEBUT      = _tStart,
+                          INTERVALLE = _F(JUSQU_A = _tEnd,
+                                          NOMBRE  = 1,),)
+#    _iter = 1
+    _SousIterations = 0
+    icv = 0
+    while (_SousIterations < _nbSsIterMax):
+
+      # Increment des sous-iterations
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      _SousIterations = _SousIterations + 1
+      _ntcast = _ntcast + 1
+
+      # Reception des forces nodales et projection !!! YACS COMMUNICATION !!!
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      print "MODI_CHAR_YACS"
+      _ifsCharMeca = MODI_CHAR_YACS(reuse      = _ifsCharMeca,
+                                    CHAR_MECA  = _ifsCharMeca,
+                                    MATR_PROJECTION      = _fluidElemPoids,
+                                    NOM_CMP_IFS  = NOM_CMP_IFS,
+                                    NUME_ORDRE_YACS  = _ntcast,
+                                    INST    = _tStart,
+                                    PAS    = _timeStep,
+                                    **poidsMocle)
+
+      # Resolution non-lineaire
+      # ~~~~~~~~~~~~~~~~~~~~~~~
+      print "DYNA_NON_LINE NUMPAS=",_numpas
+      #__rescur=DYNA_NON_LINE(
+      __rescur=DYNA_NON_LINE(
+      #                       ETAT_INIT = dEtatInit,
+                             MODELE    = MODELE,
+                             INCREMENT = _F(LIST_INST=_liste,),
+                             EXCIT     = dExcit,
+                             **motscles)
+      # test de convergence
+      # ~~~~~~~~~~~~~~~~~~~
+      _ticv = RECU_PARA_YACS(DONNEES   = 'CONVERGENCE',
+                          NUME_ORDRE_YACS = _ntcast,
+                          INST   = _tEnd,
+                          PAS   = _timeStep,)
+      __icv   = _ticv.Valeurs()
+      icv = int(__icv[0])
+      print "Convergence=",icv
+      if (icv == 1 or _SousIterations == _nbSsIterMax ):
+        # Envoi des deplacements
+        # ~~~~~~~~~~~~~~~~~~~~~~
+        print "ENV_CINE_YACS ",_numpas
+        ENV_CINE_YACS(RESULTAT = _F(RESU       = __rescur,
+        #ENV_CINE_YACS(RESULTAT = _F(RESU       = resdnl,
+                                  NUME_ORDRE = _numpas),
+                    MATR_PROJECTION    = _fluidNodePoids,
+                    NUME_ORDRE_YACS = _ntcast,
+                    INST  = _tEnd,
+                    PAS  = _timeStep,
+                    **poidsMocle)
+
+        _SousIterations = _nbSsIterMax
+        print "EXTR_RESU"
+        resdnl=EXTR_RESU(RESULTAT=__rescur,
+                        ARCHIVAGE=_F(NUME_ORDRE = (0,1),))
+        #resdnl = __rescur
+
+#     endv[0] = RECU_PARA_YACS(DONNEES='FIN',
+#                         NUME_ORDRE_YACS = _iter,
+#                         INST  = _tEnd,
+#                         PAS  = _timeStep,)
+#     __endv = endv[0].Valeurs()
+#     _endValue   = __endv[0]
+#     _nbTimeStep = _endValue
+#     print "FIN=",_endValue
+    _numpas = _numpas + 1
+
+  #===============================#
+  # CALCUL NON-LINEAIRE PAS A PAS #
+  # ----------------------------- #
+  while (_numpas <= _nbTimeStep):
+
+    # ------------------ #
+    # Increment du temps #
+    # ------------------ #
+    _tStart = _tStart + _timeStep
+    _tyacs = _tStart + _timeStep
+    _pastps = RECU_PARA_YACS(DONNEES   = 'PAS',
+                        NUME_ORDRE_YACS = _numpas,
+                        INST   = _tyacs,
+                        PAS   = _timeStepAster,
+                     )
+    _pastps0   = _pastps.Valeurs() 
+    print "_pastps0[0]=", _pastps0[0]
+    _timeStep  = _pastps0[0]
+    _tEnd   = _tStart   + _timeStep
+    print "_tStart=",_tStart," ; _tEnd=",_tEnd
+    _liste=DEFI_LIST_REEL(DEBUT      = _tStart,
+                          INTERVALLE = _F(JUSQU_A = _tEnd,
+                                          NOMBRE  = 1,),)
+#    _iter = _iter + 1
+    _SousIterations = 0
+    icv = 0
+    while (_SousIterations < _nbSsIterMax):
+
+      # Increment des sous-iterations
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      _SousIterations = _SousIterations + 1
+      _ntcast = _ntcast + 1
+
+      # Reception des forces nodales et projection !!! YACS COMMUNICATION !!!
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      print "MODI_CHAR_YACS_BOUCLE"
+      _ifsCharMeca = MODI_CHAR_YACS(reuse      = _ifsCharMeca,
+                                    CHAR_MECA  = _ifsCharMeca,
+                                    MATR_PROJECTION      = _fluidElemPoids,
+                                    NOM_CMP_IFS  = NOM_CMP_IFS,
+                                    NUME_ORDRE_YACS  = _ntcast,
+                                    INST    = _tStart,
+                                    PAS    = _timeStep,
+                                    **poidsMocle)
+
+      # Resolution non-lineaire
+      # ~~~~~~~~~~~~~~~~~~~~~~~
+      print "DYNA_NON_LINE_BOUCLE"
+      resdnl=DYNA_NON_LINE(reuse     = resdnl,
+                           MODELE    = MODELE,
+                           ETAT_INIT = _F(EVOL_NOLI = resdnl,),
+                           INCREMENT = _F(LIST_INST = _liste,),
+                           EXCIT     = dExcit,
+                           **motscles)
+
+
+      # test de convergence
+      # ~~~~~~~~~~~~~~~~~~~
+      print "CONVERGENCE ",_SousIterations
+      #icv = cocas_fonctions.CONVERGENCE()
+      _ticv = RECU_PARA_YACS(DONNEES   = 'CONVERGENCE',
+                              NUME_ORDRE_YACS = _ntcast,
+                              INST   = _tEnd,
+                              PAS   = _timeStep,)
+      __icv   = _ticv.Valeurs()
+      icv = int(__icv[0])
+      print "Convergence=",icv
+      _ntcat = _ntcast + 1
+      if (icv == 1 or _SousIterations == _nbSsIterMax ):
+        _SousIterations = _nbSsIterMax
+        # Envoi des deplacements !!! YACS COMMUNICATION !!!
+        # ~~~~~~~~~~~~~~~~~~~~~~
+        print "ENV_CINE_YACS_BOUCLE"
+        ENV_CINE_YACS(RESULTAT = _F(RESU       = resdnl,
+                                  NUME_ORDRE = _numpas),
+                    MATR_PROJECTION     = _fluidNodePoids,
+                    NUME_ORDRE_YACS = _ntcast,
+                    INST   = _tEnd,
+                    PAS   = _timeStep,
+                    **poidsMocle)
+
+      else:
+        _list2=DEFI_LIST_ENTI(DEBUT=0,
+                              INTERVALLE=_F(JUSQU_A = _numpas-1,
+                                            PAS     = 1,),);
+        resdnl=EXTR_RESU(RESULTAT = resdnl,
+                         ARCHIVAGE = _F(LIST_ORDRE =  _list2,))
+    
+#     endv[_iter] = RECU_PARA_YACS(DONNEES='FIN',
+#                         NUME_ORDRE_YACS = _iter,
+#                         INST  = _tEnd,
+#                         PAS  = _timeStep,)
+#     __endv = endv[_iter].Valeurs()
+#     _endValue   = __endv[0]
+#     _nbTimeStep = _endValue
+    _numpas = _numpas + 1
+
+    print "NUMPAS : ",_numpas,"nbTimeStep=",_nbTimeStep
+
+
+
+  #========================================================================#
+  # Impression Ensight si demandee                                         #
+  # (premier et dernier pas d'impression pour coherence avec Code_Saturne) #
+  # ---------------------------------------------------------------------- #
+  print "impression ensight : ",_impEnsight
+  if (_impEnsight == 1):
+
+    impEnsiMocle               = {}
+    impEnsiMocle['INTERVALLE'] = []
+
+    if (_nbTimeStep < _PeriodImp):
+      _StartImp                  = 0
+      impEnsiDico                = {}
+      impEnsiDico['JUSQU_A']     = _nbTimeStep
+      impEnsiDico['PAS']         = 1
+      impEnsiMocle['INTERVALLE'].append(impEnsiDico)
+    elif (_nbTimeStep == _PeriodImp and _nbTimeStep == _StartImp):
+      _StartImp                  = 0
+      impEnsiDico                = {}
+      impEnsiDico['JUSQU_A']     = _nbTimeStep
+      impEnsiDico['PAS']         = 1
+      impEnsiMocle['INTERVALLE'].append(impEnsiDico)
+    elif (_PeriodImp == -1):
+      if (_nbTimeStep == _StartImp):
+        _StartImp                = 0
+      impEnsiDico                = {}
+      impEnsiDico['JUSQU_A']     = _nbTimeStep
+      impEnsiDico['PAS']         = 1
+      impEnsiMocle['INTERVALLE'].append(impEnsiDico)
+    else:
+      impEnsiDico                = {}
+      _reste                     = (_nbTimeStep-_StartImp) % _PeriodImp
+      impEnsiDico['JUSQU_A']     = _nbTimeStep - _reste
+      impEnsiDico['PAS']         = _PeriodImp
+      impEnsiMocle['INTERVALLE'].append(impEnsiDico)
+      if (_reste != 0):
+        impEnsiDico                = {}
+        impEnsiDico['JUSQU_A']     = _nbTimeStep
+        impEnsiDico['PAS']         = _reste
+        impEnsiMocle['INTERVALLE'].append(impEnsiDico)
+
+    print "Liste impEnsiMocle=", impEnsiMocle
+    _listImp=DEFI_LIST_ENTI(DEBUT      = _StartImp,
+                            **impEnsiMocle);
+    print "Liste impression=", _listImp
+    IMPR_RESU(FORMAT='ENSIGHT',
+              RESU=_F(MAILLAGE=_strucMesh,
+                      RESULTAT=resdnl,
+                      LIST_ORDRE=_listImp,),);
+
+  return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py b/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py
index bda3c3aa1d563c6d578623ab9bb81fb8ab847a8f..3eb5034c7a302464967456c098847fc846c05b3b 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/calc_miss_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF calc_miss_ops Macro  DATE 29/09/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF calc_miss_ops Macro  DATE 01/03/2011   AUTEUR COURTOIS M.COURTOIS 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -19,10 +19,12 @@
 # ======================================================================
 # RESPONSABLE COURTOIS M.COURTOIS
 
+import sys
 import os
+import traceback
 
 
-def calc_miss_ops(self, OPTION, **kwargs):
+def calc_miss_ops(self, **kwargs):
     """Macro CALC_MISS :
     Préparation des données et exécution d'un calcul MISS3D
     """
@@ -39,8 +41,7 @@ def calc_miss_ops(self, OPTION, **kwargs):
     param = MISS_PARAMETER(initial_dir=os.getcwd(), **kwargs)
     
     # création de l'objet CALCUL_MISS_xxx
-    option_calcul = OPTION["MODULE"]
-    calcul = CalculMissFactory(option_calcul, self, param)
+    calcul = CalculMissFactory(self, param)
 
     try:
         calcul.prepare_donnees()
@@ -48,4 +49,8 @@ def calc_miss_ops(self, OPTION, **kwargs):
         calcul.post_traitement()
     except aster.error, err:
         UTMESS('F', err.id_message, valk=err.valk, vali=err.vali, valr=err.valr)
+    except Exception, err:
+        trace = ''.join(traceback.format_tb(sys.exc_traceback))
+        UTMESS('F', 'SUPERVIS2_5', valk=('CALC_MISS', trace, str(err)))
+
 

diff --git a/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py
index 090b69e66b573743cb58c346baea046c6b3d3f48..33d847652f37988a8e443dc1cd6d9b4af18a79a5 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF calc_precont_ops Macro  DATE 23/03/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF calc_precont_ops Macro  DATE 21/03/2011   AUTEUR MICHEL S.MICHEL 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -23,8 +23,8 @@
 
 def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
                                 CABLE_BP,CABLE_BP_INACTIF,
-                                COMP_INCR,ETAT_INIT,NEWTON,RECH_LINEAIRE,
-                                CONVERGENCE,INCREMENT,SOLVEUR,
+                                COMP_INCR,ETAT_INIT,METHODE,
+                                RECH_LINEAIRE,CONVERGENCE,INCREMENT,SOLVEUR,
                                 INFO,TITRE,**args):
 
 
@@ -69,12 +69,24 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
   # 1.1 Recuperation de la liste d'instants, de l'instant initial et final
   #     Creation de la nouvelle liste d'instants
   # ----------------------------------------------------------
-
   dIncrement=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
-
   __prec = dIncrement['PRECISION']
+
+
+#  import pdb ; pdb.set_trace()
+
   __L0   = dIncrement['LIST_INST']
-  __L1   = __L0.Valeurs()
+  from SD.co_listr8 import listr8_sdaster
+  from SD.co_list_inst import list_inst
+
+  if   type(__L0) == listr8_sdaster:
+  #cas où liste definie par DEFI_LIST_REEL 
+     __L1   = __L0.Valeurs()
+  elif type(__L0) == list_inst:
+  # cas où liste definie par DEFI_LIST_INST
+     tmp = __L0.get_name().ljust(8) + '.LIST.' + 'DITR'.ljust(18)
+     __L1 = aster.getvectjev(tmp)
+
 
   # Traitement de l'etat initial
   if ETAT_INIT:
@@ -135,10 +147,18 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
 
   # 1.2 Recuperation des parametres pour STAT_NON_LINE
   # -------------------------------------------------------
+  motscle4={}
+  motscle5={}
 
-  dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
-  for i in dNewton.keys():
-      if dNewton[i]==None : del dNewton[i]
+  if METHODE=='IMPL_EX':
+     motscle4['IMPL_EX']=args['IMPL_EX'].List_F() 
+     motscle5['IMPL_EX']=args['IMPL_EX'].List_F() 
+  else:
+     motscle4['NEWTON']=args['NEWTON'].List_F()
+     motscle5['NEWTON']=args['NEWTON'].List_F()
+#     for j in dNewton.keys():
+#       if dNewton[j]==None : del dNewton[j]
+       
 
   dConvergence=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
   for i in dConvergence.keys():
@@ -351,7 +371,7 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
 
   __EV1 = CALC_NO( reuse    = __EV1,
                    RESULTAT = __EV1,
-                   GROUP_MA = __GROUP_MA_A,
+                  # GROUP_MA = __GROUP_MA_A,
                    OPTION = 'FORC_NODA' )
 
   __REA = CREA_CHAMP (
@@ -394,7 +414,7 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
   dExcit1.append(_F(CHARGE = _F_CA,
                     FONC_MULT=__FCT ),)
 
-  motscle4={}
+  
   if self.reuse:
     motscle4['reuse'] = self.reuse
 
@@ -405,14 +425,14 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
                      COMP_INCR=dComp_incr0,
                      INCREMENT=dIncrement,
                      ETAT_INIT = dEtatInit,
-                     NEWTON =dNewton,
+                     METHODE=METHODE,
                      CONVERGENCE=dConvergence,
                      RECH_LINEAIRE = dRech_lin,
                      SOLVEUR = dSolveur,
                      ARCHIVAGE = _F(INST = __TINT),
                      INFO     =INFO,
                      TITRE = TITRE,
-                     EXCIT = dExcit1,
+                     EXCIT = dExcit1,  
                      **motscle4)
 
   # Recuperation du dernier numero d'ordre pour pouvoir  l'écraser dans RES
@@ -437,15 +457,19 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
                      COMP_INCR=dComp_incr1,
                      INCREMENT=_F(LIST_INST = __LST,
                                   PRECISION = __prec),
-                     NEWTON =dNewton,
+                     METHODE=METHODE,
+#                     NEWTON =dNewton,
+#                     IMPL_EX=dImplex,
+    
                      RECH_LINEAIRE = dRech_lin,
                      CONVERGENCE=dConvergence,
                      SOLVEUR = dSolveur,
-                     ARCHIVAGE = _F(NUME_INIT = __no,
+                     ARCHIVAGE = _F(
                                     DETR_NUME_SUIV = 'OUI' ),
                      INFO  =INFO,
                      TITRE = TITRE,
                      EXCIT =dExcit2,
+                     **motscle5 
                      )
 
   return ier

diff --git a/Aster/Cata/cataSTA10/Macro/crea_elem_ssd_ops.py b/Aster/Cata/cataSTA10/Macro/crea_elem_ssd_ops.py
new file mode 100644 (file)
index 0000000..8b37f32
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/crea_elem_ssd_ops.py
@@ -0,0 +1,265 @@
+#@ MODIF crea_elem_ssd_ops Macro  DATE 03/01/2011   AUTEUR ANDRIAM H.ANDRIAMBOLOLONA 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# ======================================================================
+
+def crea_elem_ssd_ops(self,  NUME_DDL, INTERFACE, BASE_MODALE,
+                             CALC_FREQ, SOLVEUR, **args):
+    """
+     Enchainement des commandes :
+        CALC_MATR_ELEM + ASSE_MATRICE + MODE_ITER_SIMULT + MODE_STATIQUE
+        DEFI_INTERF_DYNA + DEFI_BASE_MODALE + MACR_ELEM_DYNA
+    """
+
+    from Accas import _F
+
+    # On met le mot cle NUME_DDL dans une variable locale pour le proteger
+    numeddl=NUME_DDL
+
+    if numeddl:
+        self.DeclareOut('_nume_ddl', numeddl)
+
+    # On importe les definitions des commandes a utiliser dans la macro
+    CALC_MATR_ELEM = self.get_cmd('CALC_MATR_ELEM')
+    NUME_DDL = self.get_cmd('NUME_DDL')
+    ASSE_MATRICE = self.get_cmd('ASSE_MATRICE')
+    EXTR_MODE = self.get_cmd('EXTR_MODE')
+    MODE_ITER_SIMULT = self.get_cmd('MODE_ITER_SIMULT')
+    MODE_STATIQUE = self.get_cmd('MODE_STATIQUE')
+    DEFI_INTERF_DYNA = self.get_cmd('DEFI_INTERF_DYNA')
+    DEFI_BASE_MODALE = self.get_cmd('DEFI_BASE_MODALE')
+    MACR_ELEM_DYNA = self.get_cmd('MACR_ELEM_DYNA')
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    mSolveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+    # SYME ne fait pas partie des mots cles lies a SOLVEUR
+    # dans MODE_STATIQUE et DEFI_BASE_MODALE
+    for i in mSolveur.keys():
+        if mSolveur[i] == None or i == 'SYME' :
+            del mSolveur[i]
+
+    _kelem = CALC_MATR_ELEM(CHARGE = args['CHARGE'],
+                            OPTION = 'RIGI_MECA',
+                            CARA_ELEM = args['CARA_ELEM'],
+                            MODELE = args['MODELE'],
+                            CHAM_MATER = args['CHAM_MATER'],)
+
+    __melem = CALC_MATR_ELEM(CHARGE = args['CHARGE'],
+                             OPTION = 'MASS_MECA',
+                             CARA_ELEM = args['CARA_ELEM'],
+                             MODELE = args['MODELE'],
+                             CHAM_MATER = args['CHAM_MATER'],)
+
+    _nume_ddl = NUME_DDL(MATR_RIGI = _kelem,
+                         METHODE = SOLVEUR[0]['METHODE'],
+                         RENUM = SOLVEUR[0]['RENUM'],)
+
+    _matrigi = ASSE_MATRICE(NUME_DDL = _nume_ddl,
+                            MATR_ELEM = _kelem,)
+
+    __mmass = ASSE_MATRICE(NUME_DDL = _nume_ddl,
+                           MATR_ELEM = __melem,)
+
+    # recuperation des options de MODE_ITER_SIMULT (equivalent CALC_MODAL)
+    motscit = {}
+    motscfa = {}
+
+    if CALC_FREQ['OPTION'] == 'PLUS_PETITE':
+        nbande = 1
+
+    if CALC_FREQ['OPTION'] == 'CENTRE':
+        nbande = 1
+
+    if CALC_FREQ['OPTION'] == 'BANDE':
+        nbande = len(CALC_FREQ['FREQ'])-1
+    
+    motfilt = {}
+    motfilt['FILTRE_MODE'] = []
+    for i in range(nbande):
+        if CALC_FREQ['OPTION'] == 'PLUS_PETITE':
+            motscfa['NMAX_FREQ'] = CALC_FREQ['NMAX_FREQ']
+
+        if CALC_FREQ['OPTION'] == 'CENTRE':
+            motscfa['FREQ'] = CALC_FREQ['FREQ']
+            if CALC_FREQ['AMOR_REDUIT']:
+                motscfa['AMOR_REDUIT'] = CALC_FREQ['AMOR_REDUIT']
+            motscfa['NMAX_FREQ'] = CALC_FREQ['NMAX_FREQ']
+
+        if CALC_FREQ['OPTION'] == 'BANDE':
+            motscfa['FREQ'] = (CALC_FREQ['FREQ'][i], CALC_FREQ['FREQ'][i+1])
+
+        motscit['CALC_FREQ'] = _F(OPTION =CALC_FREQ['OPTION'],
+                            APPROCHE =CALC_FREQ['APPROCHE'],
+                            **motscfa)
+
+        __modes = MODE_ITER_SIMULT(MATR_A = _matrigi,
+                                   MATR_B = __mmass,
+                                   INFO = args['INFO'],
+                                   **motscit)
+
+        motfilt['FILTRE_MODE'].append(_F(MODE=__modes,
+                                             TOUT_ORDRE='OUI',),)
+
+    _mode_meca = EXTR_MODE(**motfilt)
+
+    if BASE_MODALE[0]['TYPE'] == 'RITZ':
+        mcfactc = []
+        mcfactm = []
+        mcfacti = []
+        arg_no = []
+        arg_grno = []
+        for i in range(len(INTERFACE)):
+            if BASE_MODALE[0]['NMAX_MODE_INTF']:
+              if INTERFACE[i]['TYPE'] == 'CRAIGB':
+                if INTERFACE[i]['NOEUD'] :
+                  if isinstance(INTERFACE[i]['NOEUD'],(list,tuple)):
+                    for noeu in INTERFACE[i]['NOEUD']:
+                      arg_no.append(noeu)
+                  else:
+                    arg_no.append(INTERFACE[i]['NOEUD'])
+                if INTERFACE[i]['GROUP_NO'] :
+                  if isinstance(INTERFACE[i]['GROUP_NO'],(list,tuple)):
+                    for grno in INTERFACE[i]['GROUP_NO']:
+                      arg_grno.append(grno)
+                  else:
+                    arg_grno.append(INTERFACE[i]['GROUP_NO'])
+            else:
+                arg_int = {}
+                if INTERFACE[i]['NOEUD'] :
+                    arg_int['NOEUD'] = INTERFACE[i]['NOEUD']
+                if INTERFACE[i]['GROUP_NO'] :
+                    arg_int['GROUP_NO'] = INTERFACE[i]['GROUP_NO']
+                arg_int['TOUT_CMP'] = 'OUI'
+                if INTERFACE[i]['TYPE'] == 'CRAIGB':
+                    mcfactc.append( _F(**arg_int))
+                elif INTERFACE[i]['TYPE'] == 'MNEAL':
+                    mcfactm.append( _F(**arg_int))
+        modstatc = {}
+        modstatm = {}
+        modstati = {}
+        lmodint = []
+        if mcfactc:
+            modstatc['MODE_STAT'] = mcfactc
+            _mode_intf = MODE_STATIQUE(MATR_RIGI = _matrigi,
+                                           SOLVEUR = mSolveur,
+                                           **modstatc)
+            lmodint.append(_mode_intf)
+        if mcfactm:
+            modstatm['FORCE_NODALE'] = mcfactm
+            _mode_intf = MODE_STATIQUE(MATR_RIGI = _matrigi,
+                                           SOLVEUR = mSolveur,
+                                           **modstatm)
+            lmodint.append(_mode_intf)
+        if BASE_MODALE[0]['NMAX_MODE_INTF']:
+            arg_int = {}
+            if arg_no:
+                arg_int['NOEUD'] = arg_no
+            if arg_grno:
+                arg_int['GROUP_NO'] = arg_grno
+            arg_int['NBMOD'] = BASE_MODALE[0]['NMAX_MODE_INTF']
+            arg_int['TOUT_CMP'] = 'OUI'
+            mcfacti.append( _F(**arg_int))
+            modstati['MODE_INTERF'] = mcfacti
+            _mode_intf = MODE_STATIQUE(MATR_RIGI = _matrigi,
+                                           MATR_MASS = __mmass,
+                                           SOLVEUR = mSolveur,
+                                           **modstati)
+            lmodint.append(_mode_intf)
+
+    interface = {}
+    mcfact = []
+    freqnew = None
+    ifreq = INTERFACE[0]['FREQ']
+    for i in range(len(INTERFACE)):
+        arg_int = {}
+        if INTERFACE[i]['NOEUD'] :
+            arg_int['NOEUD'] = INTERFACE[i]['NOEUD']
+        if INTERFACE[i]['GROUP_NO'] :
+            arg_int['GROUP_NO'] = INTERFACE[i]['GROUP_NO']
+        mcfact.append( _F(NOM = INTERFACE[i]['NOM'],
+                          TYPE = INTERFACE[i]['TYPE'],
+                           **arg_int))
+        ifreq_i = INTERFACE[i]['FREQ']
+        if ifreq != ifreq_i:
+            freqnew = ifreq_i
+    if freqnew:
+        UTMESS('A','SOUSTRUC2_12',valr=freqnew)
+        ifreq = freqnew
+    interface['INTERFACE'] = mcfact
+
+    if args['INFO']:
+        interface['INFO'] = args['INFO']
+    if ifreq:
+        interface['FREQ'] = ifreq
+
+    _interf = DEFI_INTERF_DYNA(NUME_DDL = _nume_ddl,
+                               **interface)
+
+    base = {}
+    if args['INFO']:
+        base['INFO'] = args['INFO']
+    mcfact = []
+
+    if BASE_MODALE[0]['TYPE'] == 'CLASSIQUE':
+        arg_base = {}
+        type_base = 'CLASSIQUE'
+        arg_base['NMAX_MODE'] = CALC_FREQ[0]['NMAX_FREQ']
+        mcfact.append(_F(INTERF_DYNA = _interf,
+                         MODE_MECA = _mode_meca,
+                         **arg_base))
+
+    if BASE_MODALE[0]['TYPE'] == 'RITZ':
+        type_base = 'RITZ'
+        # il faut deux occurrences du mot cle facteur RITZ
+        arg_base = {}
+        if CALC_FREQ[0]['OPTION'] == 'PLUS_PETITE' or \
+           CALC_FREQ[0]['OPTION'] == 'CENTRE':
+            arg_base['NMAX_MODE'] = CALC_FREQ[0]['NMAX_FREQ']
+        
+        mcfact.append(_F(MODE_MECA = _mode_meca,
+                             **arg_base))
+
+        arg_base = {}
+        if len(lmodint) > 0: # MODE_INTF ou MODE_STATIQUE doit etre a la 2 occ
+            if BASE_MODALE[0]['NMAX_MODE_INTF']:
+                arg_base['NMAX_MODE'] = BASE_MODALE[0]['NMAX_MODE_INTF']
+            mcfact.append(_F(MODE_INTF = _mode_intf,
+                             **arg_base))
+
+    if type_base == 'CLASSIQUE':
+        base['CLASSIQUE'] = mcfact
+    elif type_base == 'RITZ':
+        base['RITZ'] = mcfact
+        base['INTERF_DYNA'] = _interf
+        base['NUME_REF'] = _nume_ddl
+
+    _base_modale = DEFI_BASE_MODALE( **base)
+
+    elem = {}
+    elem['MATR_RIGI'] = _matrigi
+    elem['MATR_MASS'] = __mmass
+  
+    self.DeclareOut('macr_elem', self.sd)
+    macr_elem = MACR_ELEM_DYNA(BASE_MODALE = _base_modale,
+                               **elem)
+
+    return
+

diff --git a/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py
index 761e11778610fa198923eeef2e92d37ce0cfa73e..e182159df0ce69c934dbe6f0cb73edc26137ab9e 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py
+++ b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py
@@ -1,30 +1,30 @@
-#@ MODIF creation_donnees_homard Macro  DATE 18/10/2010   AUTEUR GNICOLAS G.NICOLAS 
+#@ MODIF creation_donnees_homard Macro  DATE 11/05/2011   AUTEUR SELLENET N.SELLENET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                   
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 # RESPONSABLE GNICOLAS G.NICOLAS
 """
-Cette classe cree le fichier de configuration permettant de lancer HOMARD
+Cette classe crée le fichier de configuration permettant de lancer HOMARD
 depuis Code_Aster.
 """
-__revision__ = "V1.7"
+__revision__ = "V1.10"
 __all__ = [ ]
- 
+
 import os
 import os.path
 from types import ListType, TupleType
@@ -41,11 +41,11 @@ except ImportError:
 
 # ------------------------------------------------------------------------------
 class creation_donnees_homard:
-  """Cette classe cree les donnees permettant de lancer HOMARD depuis Code_Aster.
+  """Cette classe crée les données permettant de lancer HOMARD depuis Code_Aster.
       Ce sont :
       . le fichier de configuration
-      . le fichier des donnees dans le cas d'information
-   
+      . le fichier des données dans le cas d'information
+
    Arguments (stockes en tant qu'attribut) :
       . nom_macro : nom de la macro-commande qui appelle :
                       'MACR_ADAP_MAIL' pour une adaptation
@@ -55,7 +55,7 @@ class creation_donnees_homard:
 
    Attributs :
       . Nom_Fichier_Configuration : nom du fichier de configuration (immuable)
-      . Nom_Fichier_Donnees : nom du fichier de donnees (immuable)
+      . Nom_Fichier_Donnees : nom du fichier de données (immuable)
       . mode_homard : le mode pour filtrer ici ("ADAP" ou "INFO")
       . mode_homard_texte : le mode d'utilisation, en francais ("ADAPTATION" ou "INFORMATION")
       . mailles_incompatibles : que faire des mailles incompatibles avec HOMARD
@@ -76,7 +76,7 @@ class creation_donnees_homard:
     else :
       UTMESS("F", 'HOMARD0_1')
 #
-# 2. Donnees generales de cette initialisation
+# 2. Données generales de cette initialisation
 #
 #gn    for mot_cle in mots_cles.keys() :
 #gn      print "mots_cles[", mot_cle, "] = ", mots_cles[mot_cle]
@@ -105,13 +105,13 @@ class creation_donnees_homard:
 # ------------------------------------------------------------------------------
   def int_to_str2 (self, entier) :
     """
-    Transforme un entier compris entre 0 et 99 en une chaine sur deux caracteres
+    Transforme un entier positif en une chaine d'au moins deux caracteres
     """
-#    print "\nArguments a l'entree de", __name__, ":", entier
+#    print "\nArguments à l'entree de", __name__, ":", entier
 #
-    try:
+    if type(entier) == type(0) :
       la_chaine = '%02d' % entier
-    except TypeError:
+    else :
       la_chaine = None
 #
     return la_chaine
@@ -124,14 +124,14 @@ class creation_donnees_homard:
     return
 # ------------------------------------------------------------------------------
   def creation_configuration (self) :
-    """Cree les donnees necessaires e la configuration
+    """Cree les données necessaires à la configuration
     """
 #
     message_erreur = None
 #
     while message_erreur is None :
 #
-#     1. Les chaines liees aux numeros d'iteration
+#     1. Les chaines liées aux numeros d'iteration
 #
       if self.mode_homard == "ADAP" :
         niter = self.dico_configuration["niter"]
@@ -167,7 +167,7 @@ class creation_donnees_homard:
         self.critere_deraffinement = None
         self.niveau = []
 #
-#     4. Le type de bilan : il faut convertir la donnee textuelle en un entier,
+#     4. Le type de bilan : il faut convertir la donnée textuelle en un entier,
 #        produit de nombres premiers.
 #        Si rien n'est demande, on met 1.
 #
@@ -188,7 +188,7 @@ class creation_donnees_homard:
         aux = 0
       self.TypeBila = aux
 #
-#     5. Les entrees/sorties au format MED
+#     5. Les entrées/sorties au format MED
 #
       self.CCNoMN__ = self.dico_configuration["NOM_MED_MAILLAGE_N"]
       if self.mode_homard == "ADAP" :
@@ -198,7 +198,7 @@ class creation_donnees_homard:
         else :
           self.CCMaiAnn = None
 #
-#     6. Les entrees/sorties au format HOMARD
+#     6. Les entrées/sorties au format HOMARD
 #
       if self.mode_homard == "ADAP" :
         self.fic_homard_niter   = "maill." + self.str_niter   + ".hom.med"
@@ -234,7 +234,7 @@ class creation_donnees_homard:
 #gn        print "... self.TypeRaff = ",self.TypeRaff
 #gn        print "... self.TypeDera = ",self.TypeDera
 #
-#     7.2. L'eventuel seuil de raffinement
+#     7.2. L'éventuel seuil de raffinement
 #
         if self.TypeRaff == "libre" and self.mots_cles["ADAPTATION"] != "RAFFINEMENT_ZONE" :
           d_aux = {}
@@ -248,7 +248,7 @@ class creation_donnees_homard:
               self.critere_raffinement = (d_aux[mot_cle][0], aux)
 #gn          print "... self.critere_raffinement = ", self.critere_raffinement
 #
-#     7.3. L'eventuel seuil de deraffinement
+#     7.3. L'éventuel seuil de deraffinement
 #
         if self.TypeDera == "libre" :
           d_aux = {}
@@ -262,17 +262,29 @@ class creation_donnees_homard:
               self.critere_deraffinement = (d_aux[mot_cle][0], aux)
 #gn          print "... self.critere_deraffinement = ", self.critere_deraffinement
 #
-#     7.4. Les niveaux extremes
+#     7.4. Les profondeurs extremes de raffinement/deraffinement
 #
-        for mot_cle in [ "NIVE_MIN", "NIVE_MAX" ] :
+        saux = " "
+        for mot_cle in [ "NIVE_MIN", "NIVE_MAX", "DIAM_MIN" ] :
           if self.mots_cles.has_key(mot_cle) :
             if self.mots_cles[mot_cle] is not None :
               if mot_cle == "NIVE_MIN" :
                 aux = "NiveauMi"
-              else :
+              elif mot_cle == "NIVE_MAX" :
                 aux = "NiveauMa"
+              else :
+                aux = "DiametMi"
               self.niveau.append((aux, self.mots_cles[mot_cle]))
-        if len(self.niveau) == 2 :
+              saux += aux
+#
+        if ( "DiametMi" in saux ) :
+#gn          print self.mots_cles["DIAM_MIN"]
+          if self.mots_cles["DIAM_MIN"] < 0 :
+            message_erreur = "Le diametre mini doit etre strictement positif. "+\
+                             "La valeur "+str(self.mots_cles["DIAM_MIN"])+" est incorrecte."
+            break
+#
+        if ( ( "NiveauMi" in saux ) and ( "NiveauMa" in saux ) ) :
 #gn          print self.mots_cles["NIVE_MIN"]
 #gn          print self.mots_cles["NIVE_MAX"]
           if self.mots_cles["NIVE_MIN"] >= self.mots_cles["NIVE_MAX"] :
@@ -280,7 +292,7 @@ class creation_donnees_homard:
                              ", doit etre < au niveau maxi, "+str(self.mots_cles["NIVE_MAX"])+"."
             break
 #
-#     7.5. Les eventuelles zones de raffinement
+#     7.5. Les éventuelles zones de raffinement
 #
         if self.dico_configuration.has_key("Zones_raffinement") :
           iaux = 0
@@ -341,7 +353,7 @@ class creation_donnees_homard:
       try :
         os.remove (nomfic)
       except os.error, codret_partiel :
-        print "Probleme au remove, erreur numero ", codret_partiel[0], ":", codret_partiel[1]
+        print "Probleme au remove, erreur numéro ", codret_partiel[0], ":", codret_partiel[1]
         UTMESS("F", 'HOMARD0_3', valk=nomfic)
 #
     fichier = open (nomfic,"w")
@@ -380,7 +392,7 @@ class creation_donnees_homard:
     """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur
    Arguments :
       . motcle : le mot-cle HOMARD a ecrire
-      . valeur : la valeur associee
+      . valeur : la valeur associée
     """
 #
     ligne = motcle + " " + str(valeur) + "\n"
@@ -392,7 +404,7 @@ class creation_donnees_homard:
     """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur1 + valeur2
    Arguments :
       . motcle : le mot-cle HOMARD a ecrire
-      . valeur : la valeur associee
+      . valeur : la valeur associée
     """
 #
     ligne = motcle + " " + str(valeur1) + " " + str(valeur2) + "\n"
@@ -466,7 +478,7 @@ class creation_donnees_homard:
 #
           self.ecrire_ligne_configuration_0("L'indicateur d'erreur")
           self.ecrire_ligne_configuration_2("CCIndica", self.dico_configuration["Fichier_ASTER_vers_HOMARD"])
-          self.ecrire_ligne_configuration_2("CCNoChaI", self.dico_configuration["Indicateur"]["NOM_MED"])
+          self.ecrire_ligne_configuration_2("CCNoChaI", self.dico_configuration["Indicateur"]["NOM_CHAM_MED"])
           if self.dico_configuration["Indicateur"].has_key("COMPOSANTE") :
             for saux in self.dico_configuration["Indicateur"]["COMPOSANTE"] :
               self.ecrire_ligne_configuration_2("CCCoChaI", saux)
@@ -518,7 +530,7 @@ class creation_donnees_homard:
               if zone.has_key(aux) :
                 self.ecrire_ligne_configuration_3(dico_zone[aux], iaux, zone[aux])
 #
-#     5.4. Les niveaux extremes
+#     5.4. Les profondeurs extremes de raffinement/deraffinement
 #
         for aux in self.niveau :
           self.ecrire_ligne_configuration_2(aux[0], aux[1])
@@ -554,17 +566,18 @@ class creation_donnees_homard:
           self.ecrire_ligne_configuration_2("CCNoMAnn", self.CCMaiAnn)
           self.ecrire_ligne_configuration_2("CCMaiAnn", self.dico_configuration["Fichier_HOMARD_vers_ASTER"])
 #
-#     6. Les eventuels champs e mettre e jour
+#     6. Les eventuels champs a mettre a jour
 #
       if self.dico_configuration.has_key("Champs") :
-        self.ecrire_ligne_configuration_0("Champs e mettre e jour")
+        self.ecrire_ligne_configuration_0("Champs a mettre e jour")
         self.ecrire_ligne_configuration_2("CCSolN__", self.dico_configuration["Fichier_ASTER_vers_HOMARD"])
         self.ecrire_ligne_configuration_2("CCSolNP1", self.dico_configuration["Fichier_HOMARD_vers_ASTER"])
         iaux = 0
         for maj_champ in self.dico_configuration["Champs"] :
           iaux = iaux + 1
-          self.ecrire_ligne_configuration_0("Mise e jour du champ numero "+str(iaux))
-          self.ecrire_ligne_configuration_3("CCChaNom", iaux, maj_champ["NOM_MED"])
+          self.ecrire_ligne_configuration_0("Mise a jour du champ numero "+str(iaux))
+          self.ecrire_ligne_configuration_3("CCChaNom", iaux, maj_champ["NOM_CHAM_MED"])
+          self.ecrire_ligne_configuration_3("CCChaTIn", iaux, maj_champ["TYPE_MAJ"])
           if maj_champ.has_key("NUME_ORDRE") :
             self.ecrire_ligne_configuration_3("CCChaNuO", iaux, maj_champ["NUME_ORDRE"])
             self.ecrire_ligne_configuration_3("CCChaPdT", iaux, maj_champ["NUME_ORDRE"])
@@ -595,6 +608,7 @@ class creation_donnees_homard:
       if self.dico_configuration.has_key("Frontiere_analytique") :
         SuivFron = SuivFron * 3
         dico_frontiere = {}
+        dico_frontiere["NOM"] = "FANom"
         dico_frontiere["RAYON"] = "FARayon"
         dico_frontiere["X_CENTRE"] = "FAXCen"
         dico_frontiere["Y_CENTRE"] = "FAYCen"
@@ -603,25 +617,30 @@ class creation_donnees_homard:
         dico_frontiere["Y_AXE"] = "FAYAxe"
         dico_frontiere["Z_AXE"] = "FAZAxe"
         l_aux = dico_frontiere.keys()
-        dico_frontiere["GROUP_MA"] = "FAGroupe"
+        dico_frontiere["FGNomGro"] = "FGNomGro"
+        dico_frontiere["FGNomFro"] = "FGNomFro"
         dico_frontiere["TYPE"] = "FAType"
         dico_frontiere["CYLINDRE"] = 1
         dico_frontiere["SPHERE"] = 2
         iaux = 0
+        kaux = 0
         for frontiere in self.dico_configuration["Frontiere_analytique"] :
+          iaux += 1
+          self.ecrire_ligne_configuration_0("Description de la frontiere analytique numero "+str(iaux))
+          jaux = dico_frontiere[frontiere["TYPE"]]
+          self.ecrire_ligne_configuration_3(dico_frontiere["TYPE"], iaux, jaux)
+          for aux in l_aux :
+            if frontiere.has_key(aux) :
+              self.ecrire_ligne_configuration_3(dico_frontiere[aux], iaux, frontiere[aux])
+          self.ecrire_ligne_configuration_0("Lien de la frontiere analytique numero "+str(iaux)+" avec les groupes")
           if not type(frontiere["GROUP_MA"]) in EnumTypes :
             lt_aux = [ frontiere["GROUP_MA"] ]
           else :
             lt_aux = frontiere["GROUP_MA"]
           for group_ma in lt_aux :
-            iaux = iaux + 1
-            self.ecrire_ligne_configuration_0("Description de la frontiere analytique numero "+str(iaux))
-            jaux = dico_frontiere[frontiere["TYPE"]]
-            self.ecrire_ligne_configuration_3(dico_frontiere["TYPE"], iaux, jaux)
-            self.ecrire_ligne_configuration_3(dico_frontiere["GROUP_MA"], iaux, group_ma)
-            for aux in l_aux :
-              if frontiere.has_key(aux) :
-                self.ecrire_ligne_configuration_3(dico_frontiere[aux], iaux, frontiere[aux])
+            kaux += 1
+            self.ecrire_ligne_configuration_3(dico_frontiere["FGNomGro"], kaux, group_ma)
+            self.ecrire_ligne_configuration_3(dico_frontiere["FGNomFro"], kaux, frontiere["NOM"])
 #
 #     7.3. Activation de la fonction
 #
@@ -637,7 +656,7 @@ class creation_donnees_homard:
         self.ecrire_ligne_configuration_2("MessInfo", self.MessInfo)
       if self.dico_configuration["version_perso"] :
         VERSION_HOMARD = self.dico_configuration["VERSION_HOMARD"]
-        self.ecrire_ligne_configuration_2("DicoOSGM", "$HOMARD_USER/"+VERSION_HOMARD+"/CONFIG/typobj.stu")
+        self.ecrire_ligne_configuration_2("DicoOSGM", "$HOMARD_USER/"+VERSION_HOMARD+"/src/CONFIG/typobj.stu")
 #
 #     9. L'usage des mailles incompatibles avec HOMARD
 #
@@ -670,7 +689,7 @@ class creation_donnees_homard:
     return
 # ------------------------------------------------------------------------------
   def ecrire_fichier_donnees (self) :
-    """Ecrit le fichier des donnees dans le cas d'une demande d'information
+    """Ecrit le fichier des données dans le cas d'une demande d'information
     """
     message_erreur = None
 #

diff --git a/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py b/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py
index 8e5fa7cfc75192580b95f8c68d4346f89941e896..57edffc761f8860a4fcc43ec94db3e7a4d69dd51 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py
@@ -1,4 +1,4 @@
-#@ MODIF dyna_iss_vari_ops Macro  DATE 18/10/2010   AUTEUR NISTOR I.NISTOR 
+#@ MODIF dyna_iss_vari_ops Macro  DATE 08/12/2010   AUTEUR ZENTNER I.ZENTNER 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -17,11 +17,14 @@
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
+
+# RESPONSABLE ZENTNER I.ZENTNER
 import os
 
 
-def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNITE_RESU_FORC,
-                       NB_FREQ, PAS, UNITE_RESU_IMPE, TYPE, MATR_GENE , OPTION,INFO,
+def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, UNITE_RESU_FORC, 
+                                 UNITE_RESU_IMPE, TYPE, MATR_GENE ,INFO, 
+#                      NB_FREQ, FREQ_INIT, FREQ_PAS,  FREQ_MAX, OPTION,
                          **args):
    """
       Macro DYNA_ISS_VARI
@@ -29,37 +32,97 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
    ier=0
    import numpy as NP
    from numpy import linalg
-   import aster
+   from math import pi, ceil, sqrt, floor, log, tanh
+   import aster   
    from Accas import _F
    from Utilitai.Table import Table
    from Utilitai.Utmess import  UTMESS
-
+   
+  #--------------------------------------------------------------------------------  
    def get_group_coord(group):
       """Retourne les coordonnees des noeuds du groupe 'group'
       """
       l_ind = NP.array(coll_grno.get('%-8s' % group, [])) - 1
       return NP.take(t_coordo, l_ind, axis=0)
 
-
-   # On importe les definitions des commandes a utiliser dans la macro
-
+ #-------------------------------------------------------------------------------- 
+ # On importe les definitions des commandes a utiliser dans la macro
+ # 
    COMB_MATR_ASSE = self.get_cmd('COMB_MATR_ASSE')
    LIRE_IMPE_MISS = self.get_cmd('LIRE_IMPE_MISS')
    LIRE_FORC_MISS = self.get_cmd('LIRE_FORC_MISS')
    COMB_MATR_ASSE = self.get_cmd('COMB_MATR_ASSE')   
-
    CREA_CHAMP = self.get_cmd('CREA_CHAMP')   
    DYNA_LINE_HARM = self.get_cmd('DYNA_LINE_HARM')   
    DETRUIRE= self.get_cmd('DETRUIRE')   
-
+   
+ 
    DEFI_FONCTION  = self.get_cmd('DEFI_FONCTION')
+   CALC_FONCTION  = self.get_cmd('CALC_FONCTION')      
    CREA_TABLE     = self.get_cmd('CREA_TABLE')
-
+   REST_SPEC_TEMP     = self.get_cmd('REST_SPEC_TEMP')
+   DEFI_LIST_REEL=self.get_cmd('DEFI_LIST_REEL')
+  
    # Comptage commandes + declaration concept sortant
    self.set_icmd(1)
-   self.DeclareOut('tab_out', self.sd)
-   macro='DYNA_ISS_VARI'
-#--------------------------------------------------------
+   macro='DYNA_ISS_VARI'   
+   # Type de résultat
+   fonc_acce  =  args['FONC_SIGNAL'] 
+   if fonc_acce !=None:
+      TYPE_RESU='TRANS'
+      self.DeclareOut('dyha', self.sd)
+   else:
+      TYPE_RESU='SPEC'   
+      self.DeclareOut('tab_out', self.sd)
+   
+#--------------------------------------------------------------------------------
+ # -------- DISCRETISATION frequentielle ou temporelle -------- 
+
+   if TYPE_RESU=='SPEC':
+         FREQ_INIT=  args['FREQ_INIT']
+         NB_FREQ =  args['NB_FREQ'] 
+         PAS=  args['FREQ_PAS']  
+         OPTION=args['OPTION']  
+     
+   if TYPE_RESU=='TRANS':         
+         tt, vale_s=fonc_acce.Valeurs()  
+         DT=tt[1]-tt[0]            
+
+         __foint=CALC_FONCTION(                            
+#          __foncaf=CALC_FONCTION(
+                             FFT=_F( FONCTION =fonc_acce , 
+#                             METHODE='COMPLET',
+                               METHODE='PROL_ZERO', 
+                     ),  );    
+                            
+         vale_fre, vale_re, vale_im =__foint.Valeurs()            
+         NB_FREQ2= len(vale_fre)
+         PAS=1./(NB_FREQ2*DT)
+         NB_FREQ= int(floor(len(vale_fre)/2)) #signal nombre impair (floor(N/2)) ou signal nombre pair avec REST_SPEC_TEMP (prend N/2 pour N pair)
+#         NB_FREQ= int(floor(len(vale_fre)/2)+1)  # signal nombre pair: N/2+1
+         OMF =1./(2.*DT)            
+         FREQ_INIT=0.0
+                  
+        # liste des frequences complete 
+         l_freq_sig=[]   
+         for k in range(NB_FREQ):
+            freqk=FREQ_INIT+PAS*k
+            l_freq_sig.append(freqk)
+            
+
+         FREQ_FIN  =  args['FREQ_MAX']                
+         if  FREQ_FIN  !=None :  
+            assert (FREQ_FIN > (NB_FREQ-1)*PAS),  'FREQ_FIN = ' + str(FREQ_FIN)  +'  < frequence de coupure: augmenter FREQ_FIN'
+            PAS  =  args['FREQ_PAS'] 
+            NB_FREQ = int(ceil(FREQ_FIN/ PAS))+1
+            FREQ_INIT =0.0
+            
+#          NB_FREQ=NB_FREQ2
+         print '', NB_FREQ, PAS, FREQ_INIT,  (NB_FREQ-1)*PAS        
+ #        if INFO==2:
+ #            aster.affiche('MESSAGE','DISCRETISATION UTILISATEUR :  NB_FREQ, PAS, FREQ_FIN'+str(NB_FREQ)+' ,'+str(PAS)+' ,'+ str(NB_FREQ-1)*PAS))
+#---------------------------------------------------------------------------------------           
+# --------------------------------------------------------------------------------------
    dgene = MATR_GENE[0].cree_dict_valeurs(MATR_GENE[0].mc_liste)
    if dgene['MATR_AMOR'] != None:
      aster.affiche('MESSAGE',' MATR_AMOR existe')
@@ -71,9 +134,7 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
                                          ),                               
                                   );
      aster.affiche('MESSAGE',' MATR_AMOR pas donnee, on prend AMOR_REDUIT=0.0,')
-#   dint = INTERF[0].cree_dict_valeurs(INTERF[0].mc_liste)
-#   dcoh = MATR_COHE[0].cree_dict_valeurs(MATR_COHE[0].mc_liste)
-   
+  
    from SD.sd_maillage      import sd_maillage
    from SD.sd_nume_ddl_gd   import sd_nume_ddl_gd    
    from SD.sd_nume_ddl_gene import sd_nume_ddl_gene    
@@ -86,7 +147,6 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
    # MAILLAGE
    nom_bamo = v_refa_rigi[0]
    nume_ddl = aster.getvectjev(nom_bamo[0:8] + '           .REFD        ' )[3]
-   print 'nume ddl=',nume_ddl
    nom_mail = aster.getvectjev( nume_ddl[0:14] + '.NUME.REFN        ' )[0] 
    maillage = sd_maillage(nom_mail)
    # MODELE, DDLGENE
@@ -112,14 +172,16 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
    GROUP_NO_INTER=INTERF['GROUP_NO_INTERF']
    noe_interf = get_group_coord(GROUP_NO_INTER)
    nbno, nbval = noe_interf.shape
+   
+   del nume_ddl, nom_mail, nom_modele
    if INFO==2:
       aster.affiche('MESSAGE','NBNO INTERFACE : '+str(nbno))
-  # MODES
-   iret,nbmodt,kbid=aster.dismoi('F','NB_MODES_TOT',nom_bamo,'RESULTAT')
-   iret,nbmodd,kbid=aster.dismoi('F','NB_MODES_DYN',nom_bamo,'RESULTAT')
-   iret,nbmods,kbid=aster.dismoi('F','NB_MODES_STA',nom_bamo,'RESULTAT')
 
+  # MODES
    nbmodt2 = MATR_GENE['MATR_RIGI'].DESC.get()[1]
+   iret,nbmodd,kbid=aster.dismoi('F','NB_MODES_DYN', nom_bamo,'RESULTAT')
+   iret,nbmods,kbid=aster.dismoi('F','NB_MODES_STA', nom_bamo,'RESULTAT')
+   iret,nbmodt,kbid=aster.dismoi('F','NB_MODES_TOT',nom_bamo,'RESULTAT')  
    if nbmodt2 != nbmodt:
        UTMESS('F','ALGORITH5_42')
 
@@ -127,22 +189,47 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
       texte = 'NOMBRE DE MODES: '+str(nbmodt)+'   MODES DYNAMIQUES: '+str(nbmodd)+'   MODES STATIQUES: '+str(nbmods)
       aster.affiche('MESSAGE',texte)
       aster.affiche('MESSAGE','COMPOSANTE '+NOM_CMP)
-   SPEC = NP.zeros((NB_FREQ,nbmodt,nbmodt)) + 1j
-#
-#---------------------------------------------------------------------
-  # BOUCLE SUR LES FREQUENCES
+
+
+   if TYPE_RESU=="SPEC":
+      SPEC = NP.zeros((NB_FREQ,nbmodt,nbmodt))+1j
+   if TYPE_RESU=="TRANS":      
+      VEC = NP.zeros((NB_FREQ,nbmodt))+1j 
+   abscisse = [None]*NB_FREQ     
+   
+  # PARAMETRES fonction de cohérence
    VITE_ONDE = MATR_COHE['VITE_ONDE']
    alpha = MATR_COHE['PARA_ALPHA']
-   abscisse = [None]*NB_FREQ
+   
+#   # PARAMETRE nom_champ   
+#    cham_calc=NOM_CHAM
+#    print 'NOM_CHAMP   ',cham_calc 
+#    if cham_calc=='DEPL':
+#       ii_cham=1
+#    elif   cham_calc=='VITE': 
+#       ii_cham=2     
+#    elif   cham_calc=='ACCE': 
+#       ii_cham=3   
+
+ #   POUR TRANS, on sort le champ en dépalcement: c'est équivalen du champ en deplacement si on applique un signal en ACCE
+   cham_calc='DEPL'     
+   ii_cham=1      
 
-   for k in range(0,NB_FREQ):
-      freqk=FREQ_INIT+PAS*k
-      aster.affiche('MESSAGE','FREQUENCE DE CALCUL: '+str(freqk))
 
-      # Matrice de coherence                  
+#---------------------------------------------------------------------
+#---------------------------------------------------------------------
+  # BOUCLE SUR LES FREQUENCES
+   for k in range(NB_FREQ):
+      freqk=FREQ_INIT+PAS*k   
+      if INFO==2:
+         aster.affiche('MESSAGE','FREQUENCE DE CALCUL: '+str(freqk))      
+      
+# #---------------------------------------------------------           
+#       # Matrice de coherence                  
       XX=noe_interf[:,0]
       YY=noe_interf[:,1]
-
+#       
+# # ----MITA & LUCO
       XN=NP.repeat(XX,nbno)
       YN=NP.repeat(YY,nbno)
       XR=NP.reshape(XN,(nbno,nbno))
@@ -152,8 +239,26 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
       DX=XR-XRT
       DY=YR-YRT
       DIST=DX**2+DY**2
-      COHE=NP.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.))
       
+      COHE=NP.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.))
+
+# #----ABRAHAMSON (EPRI)
+#       p_a1=1.647
+#       p_a2=1.01
+#       p_a3=0.4
+#       p_n1=7.02
+#    #    p_n2=1.685
+#       COHE=NP.zeros((nbno,nbno))
+#       for no1 in range(nbno):
+#          for no2 in range(nbno):
+#             dist_xi=sqrt((XX[no1]-XX[no2])**2+(YY[no1]-YY[no2])**2)
+#             p_n2=5.1-0.51*log(dist_xi+10.)
+#             pfc=-1.886+2.221*log(4000./(dist_xi+1.)+1.5)
+#             term1=1.+(freqk*tanh(p_a3*dist_xi)/(p_a1*pfc))**p_n1
+#             term2=1.+(freqk*tanh(p_a3*dist_xi)/(p_a2*pfc))**p_n2
+#             COHE[no1,no2]=1./sqrt(term1* term2)
+#             
+  #---------------------------------------------------------          
       # On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas
       aster.matfpe(-1)
       eig, vec =linalg.eig(COHE)
@@ -166,17 +271,15 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
       order = (NP.argsort(eig)[::-1])
       eig = NP.take(eig, order)
       vec = NP.take(vec, order, 0)
-
+      
       #-----------------------
       # Nombre de modes POD a retenir
-      etot=NP.sum(NP.diag(COHE))
+      
+      etot=NP.sum(eig**2)
       ener=0.0
       nbme=0
- 
-      if INFO==2:
-         aster.affiche('MESSAGE','ETOT :'+str(etot))
       while nbme < nbno:
-         ener= eig[nbme]+ener
+         ener= eig[nbme]**2+ener
          prec=ener/etot
          nbme=nbme+1
          if INFO==2:
@@ -184,12 +287,13 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
          if prec > PRECISION :
             break
 
-      aster.affiche('MESSAGE','NOMBRE DE MODES POD RETENUS : '+str(nbme))
-      aster.affiche('MESSAGE','PRECISION (ENERGIE RETENUE) : '+str(prec))      
+      if INFO==2:      
+         aster.affiche('MESSAGE','NOMBRE DE MODES POD RETENUS : '+str(nbme))
+         aster.affiche('MESSAGE','PRECISION (ENERGIE RETENUE) : '+str(prec))      
 
       PVEC=NP.zeros((nbme,nbno))
       for k1 in range(0,nbme):
-         PVEC[k1, 0:nbno]=NP.sqrt(eig[k1])*vec[k1]
+         PVEC[k1, 0:nbno]=NP.sqrt(eig[k1])*vec[k1] 
       # CALCUL DE FS variable-------------------------------
       XO=NP.zeros((nbme,nbmods))
       if NOM_CMP=='DX':
@@ -198,7 +302,6 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
          COMP = 2
       elif NOM_CMP=='DZ': 
          COMP = 3  
-
    #---------MODES interface
       # ----- boucle sur les modes statiques
       for mods in range(0,nbmods):
@@ -217,19 +320,20 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
          som=NP.sum(MCMP)
          max1=NP.max(MCMP)
          min1=NP.min(MCMP)
-         maxm=NP.max([NP.abs(max1), NP.abs(min1)])
-      #CALCUL DE XO
+         maxm=NP.max([abs(max1),abs(min1)])
+
+      #-------------CALCUL DE XO -------------
 #  on recupere la composante COMP (dx,dy,dz) des modes et on projete
          #  CAS 1: MODES DE CORPS RIGIDE
          if INTERF['MODE_INTERF'] =='CORP_RIGI':
             for modp in range(0,nbme):
                #modes de translation
                if mods+1 <=3:
-                  if NP.abs(som)<10.E-6:
+                  if abs(som)<10.E-6:
                      XO[modp,mods]=0.0
                   else :
                      fact=1./som               
-                     XO[modp,mods]=fact*NP.inner(MCMP,PVEC[modp])
+                     XO[modp,mods]=fact*abs(NP.inner(MCMP,PVEC[modp]))
                #modes de rotation
                else:
                   if maxm<10.E-6:
@@ -244,19 +348,18 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
          # CAS 2: MODES EF
          if INTERF['MODE_INTERF'] =='TOUT':
             for modp in range(0,nbme):
-               if NP.abs(som)<10.E-6:
+               if abs(som)<10.E-6:
                   if maxm<10.E-6:
                      XO[modp,mods]=0.0 
                   else:
                      UTMESS('F','UTILITAI5_89')                     
                else:
                   fact=1./som                  
-                  XO[modp,mods]=fact*NP.inner(MCMP,PVEC[modp])
+                  XO[modp,mods]=fact*abs(NP.inner(MCMP,PVEC[modp]))
 
          DETRUIRE(CONCEPT=_F(NOM=(__CHAM)),INFO=1)
 
-   #----Impedances etc.----------------------------------------------------------------- 
-
+   #----Impedances + force sismique.----------------------------------------------------------------- 
       if k>0:
          DETRUIRE(CONCEPT=_F(NOM=(__impe,__fosi,__rito)),INFO=1) 
 
@@ -273,30 +376,35 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
                                  COEF_C=1.0+0.j,),
                                  ),
                                  SANS_CMP='LAGR',
-                                 );                                                                            
+                                 );        
+
+      #    on cree __fosi  pour  RECU_VECT_GENE_C   plus loin                                                                                                             
+
       __fosi = LIRE_FORC_MISS(BASE=resultat,  
                            NUME_DDL_GENE=nume_ddlgene,
                            NOM_CMP=NOM_CMP,
-                           NOM_CHAM='DEPL',               
+                            NOM_CHAM='DEPL',                                       
                            UNITE_RESU_FORC = UNITE_RESU_FORC, 
                            FREQ_EXTR=freqk,); 
+
+
       # impedance
       MIMPE=__impe.EXTR_MATR_GENE() 
       #  extraction de la partie modes interface 
       KRS = MIMPE[nbmodd:nbmodt,nbmodd:nbmodt]
-
-      # force sismique pour verif
-#      FS0=__fosi.EXTR_VECT_GENE_C()
-#      FSE=FS0[nbmodd:nbmodt][:]
-      SP=NP.zeros((nbmodt,nbmodt))
-      for k1 in range(0,nbme):
-         #  calcul de la force sismique mode POD par mode POD
-         FS = NP.dot(KRS,XO[k1]) 
+      
+ 
+      if TYPE_RESU=="TRANS":        
+           #   force sismique resultante: somme des mode POD 
+         XO_s=NP.sum(XO,0)          
+         FS = NP.dot(KRS,XO_s) 
          Fzero=NP.zeros((1,nbmodd)) 
          FS2=NP.concatenate((Fzero,NP.reshape(FS,(1,nbmods))),1)
-      #  Calcul harmonique
-         __fosi.RECU_VECT_GENE_C(FS2[0]) 
-         __dyge = DYNA_LINE_HARM(MODELE=modele,
+       
+        #  Calcul harmonique
+         __fosi.RECU_VECT_GENE_C(FS2[0])       
+         __dyge = DYNA_LINE_HARM(
+                          MODELE=modele,
                           MATR_MASS = MATR_GENE['MATR_MASS'],
                           MATR_RIGI = __rito, 
                           FREQ = freqk,
@@ -304,53 +412,177 @@ def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNIT
                           EXCIT =_F ( VECT_ASSE = __fosi,
                                       COEF_MULT= 1.0,
                                   ),
-                        );                              
-         #  recuperer le vecteur modal depl calcule par dyge                                                     
+                        );                                        
+         #  recuperer le vecteur modal depl calcule par dyge                                                      
          desc = __dyge.DESC.get()
-         assert desc[0].strip() == 'DEPL', 'Champ DEPL non trouvé'
-         nomcham = __dyge.TACH.get()[1][0].strip()
+         assert desc[ii_cham-1].strip() ==cham_calc , 'Champ'+cham_calc+ 'non trouvé'
+            
+         nomcham = __dyge.TACH.get()[ii_cham][0].strip()
          cham = sd_cham_gene(nomcham)
-         RS = NP.array(cham.VALE.get())
-         SP=SP+RS*NP.conj(RS[:,NP.newaxis])   
+         RS = NP.array(cham.VALE.get())                
          DETRUIRE(CONCEPT=_F(NOM=(__dyge)),INFO=1) 
+         
+         
+      if  TYPE_RESU=="SPEC":               
+         SP=NP.zeros((nbmodt,nbmodt))
+         for k1 in range(0,nbme):
+         #  calcul de la force sismique mode POD par mode POD
+            FS = NP.dot(KRS,XO[k1]) 
+            Fzero=NP.zeros((1,nbmodd)) 
+            FS2=NP.concatenate((Fzero,NP.reshape(FS,(1,nbmods))),1)       
+        #  Calcul harmonique
+            __fosi.RECU_VECT_GENE_C(FS2[0])       
+            __dyge = DYNA_LINE_HARM(
+                          MODELE=modele,
+                          MATR_MASS = MATR_GENE['MATR_MASS'],
+                          MATR_RIGI = __rito, 
+                          FREQ = freqk,
+                          MATR_AMOR = __ma_amort,                          
+                          EXCIT =_F ( VECT_ASSE = __fosi,
+                                      COEF_MULT= 1.0,
+                                  ),
+                        );                                        
+         #  recuperer le vecteur modal depl calcule par dyge                                                      
+            desc = __dyge.DESC.get()
+            assert desc[ii_cham-1].strip() ==cham_calc , 'Champ'+cham_calc+ 'non trouvé'
+            
+            nomcham = __dyge.TACH.get()[ii_cham][0].strip()
+            cham = sd_cham_gene(nomcham)
+            RS = NP.array(cham.VALE.get())                
+            DETRUIRE(CONCEPT=_F(NOM=(__dyge)),INFO=1) 
+             # stockage des matrices résultats: sum(s_q s_q* ) 
+            SP=SP+RS*NP.conj(RS[:,NP.newaxis])   
+
+          
+            
+#--------------------------------------------
+# stockage de résultats pour toutes les fréquences calculées
+
+      if  TYPE_RESU=="SPEC":      #SPEC = (NB_FREQ,nbmodt,nbmodt)
+         SPEC[k]=SP
+      if TYPE_RESU=="TRANS":      #VEC (NB_FREQ,nbmodt) 
+         VEC[k]=RS
+ 
+      abscisse[k]= freqk
 
-      SPEC[k]=SP
+#   DETRUIRE(CONCEPT=_F(NOM=(__impe,__fosi,__rito)),INFO=1) 
 
-      abscisse[k]= freqk
+##-------------------------------------------------------------------------------------------------------------------------       
+##--------------------------------------------------------------------------------------------------------------------------
+#  Creation des sorties : table_fonction pour SPEC ou dyna_trans pour TRANS
+#-------------------------------------------------------------------------------------------------------------------------- 
+#-
+   aster.affiche('MESSAGE','TYPE_RESU : '+TYPE_RESU) 
 ##---------------------------------------------------------------------
-#  Ecriture des tables
+#  Si SPEC: Ecriture des tables
 #--------------------------------------------------------------------- 
+   if TYPE_RESU=='SPEC':
+       
 #   ------ CREATION DE L OBJET TABLE 
-   tab = Table()
-   tab.append({'NOM_CHAM' : 'DSP', 'OPTION' : 'TOUT',  'DIMENSION' : nbmodt})
-   for k2 in range(nbmodt):
-      if OPTION =='DIAG' : # on ecrit uniquement les termes diagonaux (autospectres) de la matrice
-         foncc=[]
-         for k in range(NB_FREQ) :
-                foncc.append(abscisse[k])
-                foncc.append(SPEC[k][k2,k2].real)
-                foncc.append(SPEC[k][k2,k2].imag)      
-         _f = DEFI_FONCTION(NOM_PARA='FREQ',
-                      NOM_RESU='SPEC',
-                      VALE_C  = foncc )      
-         # Ajout d'une ligne dans la Table
-         tab.append({'NUME_ORDRE_I' : k2+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom})
-
-      else: # on ecrit tout
-         for k1 in range(k2+1):
+      tab = Table()
+      tab.append({'NOM_CHAM' : 'DSP', 'OPTION' : 'TOUT',  'DIMENSION' : nbmodt})
+      for k2 in range(nbmodt):
+         if OPTION =='DIAG' : # on ecrit uniquement les termes diagonaux (autospectres) de la matrice
             foncc=[]
             for k in range(NB_FREQ) :
-               foncc.append(abscisse[k])
-               foncc.append(SPEC[k][k1,k2].real)
-               foncc.append(SPEC[k][k1,k2].imag)      
+                 foncc.append(abscisse[k])
+                 foncc.append(SPEC[k][k2,k2].real)
+                 foncc.append(SPEC[k][k2,k2].imag)      
             _f = DEFI_FONCTION(NOM_PARA='FREQ',
+                      NOM_RESU='SPEC',
+                      VALE_C  = foncc )      
+         # Ajout d'une ligne dans la Table
+            tab.append({'NUME_ORDRE_I' : k2+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom})
+
+         else: # on ecrit tout
+            for k1 in range(k2+1):
+               foncc=[]
+               for k in range(NB_FREQ) :
+                  foncc.append(abscisse[k])
+                  foncc.append(SPEC[k][k1,k2].real)
+                  foncc.append(SPEC[k][k1,k2].imag)      
+               _f = DEFI_FONCTION(NOM_PARA='FREQ',
                       NOM_RESU='SPEC',
                       VALE_C  = foncc )
             # Ajout d'une ligne dans la Table
-            tab.append({'NUME_ORDRE_I' : k1+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom})
+               tab.append({'NUME_ORDRE_I' : k1+1, 'NUME_ORDRE_J' : k2+1, 'FONCTION_C' : _f.nom})
 
    # Creation du concept en sortie
-   dict_keywords = tab.dict_CREA_TABLE()
-   tab_out = CREA_TABLE(TYPE_TABLE='TABLE_FONCTION',
+      dict_keywords = tab.dict_CREA_TABLE()
+      tab_out = CREA_TABLE(TYPE_TABLE='TABLE_FONCTION',
                         **dict_keywords)                       
+
+#-
+##---------------------------------------------------------------------
+#  Si TRANS: Ecriture de  tran_gene
+#--------------------------------------------------------------------- 
+# 1) on cree un concept harm_gene (factice) et le remplit a l'aide de putvectjev avec les bonnes valeurs, 
+# 2) On interpole les valeurs non calculés (l_freq_sig)
+# 3) puis on fait la FFT pour obtenir le signal temporel
+         
+   elif TYPE_RESU=='TRANS':  
+               
+      __lfre = DEFI_LIST_REEL(  VALE = list(l_freq_sig), ) ;
+#      print ' creation SD DYNA_LINE_HARM'
+        # on cree la SD resultat - factice (le champ ACCE sera remplace dans la suit par celui calcule)
+      __dyge0 = DYNA_LINE_HARM(
+                          MODELE=modele,
+                          MATR_MASS = MATR_GENE['MATR_MASS'],
+                          MATR_RIGI = __rito,                
+                          LIST_FREQ= __lfre,              #tuple(l_freq_sig),
+                          MATR_AMOR = __ma_amort,                          
+                          EXCIT =_F ( VECT_ASSE = __fosi,
+                                      COEF_MULT_C=1.,
+                                  ),
+                        );               
+
+#   ATTENTION:  on sort le champ en dépalcement: c'est équivalent au champ en acceleration car on a applique un signal en ACCE pour fosi en acce    
+      #   #         cela evite de diviser pr w2 pour intégrer l'acceleration (erreurs numeriques au point 0)
+      #   #         on remplace donc le champ en acceleration      
+      cham_calc='ACCE'     
+      ii_cham=3      
+
+#       print ' putvectjev'                          
+#      si tous les point on été calculés: pas d'interpolation
+      if  FREQ_FIN ==None :  
+         for  k,freqk in enumerate(l_freq_sig):       
+            coef_a=(vale_re[k]+vale_im[k]*1.j)                   
+            VEC_comp=VEC[k]*coef_a            
+            nomcham = __dyge0.TACH.get()[ii_cham][k].strip()
+            tup_re=tuple(VEC_comp.real)
+            tup_im=tuple(VEC_comp.imag)
+            aster.putvectjev( nomcham + '.VALE        ', nbmodt,tuple(range(1,nbmodt+1)),tup_re,tup_im,1 ) 
+
+      else:
+
+         for  k,freqk in enumerate(l_freq_sig):
+            coef_a=(vale_re[k]+vale_im[k]*1.j)                              
+  #  ------------ interpolation du vecteur POD  VEC (NB_FREQ, nbmodt)       
+            vale_i=NP.searchsorted(abscisse, freqk)
+#         print  freqk, vale_i,  abscisse[vale_i-1], abscisse[vale_i]
+            if vale_i ==0:
+               VEC_comp=VEC[0]*coef_a
+               VEC_real=VEC_comp.real
+               VEC_imag=VEC_comp.imag
+            else:
+               dfp=(freqk-abscisse[vale_i-1])/(abscisse[vale_i]-abscisse[vale_i-1])
+               VEC_comp=(VEC[vale_i-1]+dfp*(VEC[vale_i]-VEC[vale_i-1]))*coef_a
+               VEC_real=VEC_comp.real
+               VEC_imag=VEC_comp.imag                               
+            nomcham = __dyge0.TACH.get()[ii_cham][k].strip()
+            tup_re=tuple(VEC_real)
+            tup_im=tuple(VEC_imag)
+            aster.putvectjev( nomcham + '.VALE        ', nbmodt,tuple(range(1,nbmodt+1)),tup_re,tup_im,1 ) 
+      
+
+      print 'REST_SPEC_TEMP'         
+      
+      dyha= REST_SPEC_TEMP( RESU_GENE = __dyge0 , 
+#                        METHODE = 'PROL_ZERO' ,
+                          SYMETRIE = 'NON' ,        # signal non symmétrique: a completer
+#                        SYMETRIE = 'OUI' ,           # pas de prolongation                    
+                          NOM_CHAM = 'ACCE' );
+     
+      
+                    
    return ier

diff --git a/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py b/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py
index f22b7551864f016b2bb13c4967e9a9d32bf5c460..1f81cdbe938ac7f64321e832568d13790256e419 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF exec_logiciel_ops Macro  DATE 15/03/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF exec_logiciel_ops Macro  DATE 15/03/2011   AUTEUR ASSIRE A.ASSIRE 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -24,11 +24,71 @@ import os
 import os.path as osp
 import traceback
 import shutil
+import tempfile
 from types import ListType, TupleType
 EnumTypes = (ListType, TupleType)
 
+cmd_ssh = "%(ssh)s -p %(port)s -o BatchMode=yes -o ConnectTimeout=2 -o ChallengeResponseAuthentication=yes -o PasswordAuthentication=no -o StrictHostKeyChecking=no %(user_machine)s '%(cmd)s'"
+cmd_scp = "%(scp)s -P %(port)s -o BatchMode=yes -o ConnectTimeout=2 -o ChallengeResponseAuthentication=yes -o PasswordAuthentication=no -o StrictHostKeyChecking=no %(src)s %(dst)s"
+
+#cmd_ssh = "%(ssh)s -p %(port)s %(user_machine)s '%(cmd)s'"
+#cmd_scp = "%(scp)s -P %(port)s %(src)s %(dst)s"
+
+exe_ssh = 'ssh'
+exe_scp = 'scp'
+
+tmpdir = '/tmp'
+
+debug = False
+
+# ------------------------------------------------------------------------------
+def ExecCommand_SSH(scmd, alt_comment='', verbose=False, separated_stderr=True):
+   """ Lance une commande distante via SSH
+       Recupere les differents problemes liés à SSH
+   """   
+   import aster
+   from Utilitai.Utmess     import  UTMESS
+   from Utilitai.System     import ExecCommand
+
+   iret, output, error = ExecCommand(scmd, alt_comment, verbose=False, separated_stderr=True)
+
+   if debug:
+     print 'scmd=', scmd
+     print 'iret=', iret
+     print 'output=', output
+     print 'error=', error
+
+   if iret != 0:
+      # on dump l'output et l'error
+      UTMESS('I', 'EXECLOGICIEL0_8',  valk=scmd,   print_as='E')
+      UTMESS('I', 'EXECLOGICIEL0_9',  valk=output, print_as='E')
+      UTMESS('I', 'EXECLOGICIEL0_10', valk=error,  print_as='E')
+
+      # Probleme de cle SSH
+      if error.find("Permission denied")!=-1:
+         UTMESS('F', 'EXECLOGICIEL0_14',  valk=scmd)
+
+      # Probleme d'adresse IP ou de hostname
+      elif error.find("Name or service not known")!=-1:
+         UTMESS('F', 'EXECLOGICIEL0_15',  valk=scmd)
+
+      # Probleme de port SSH
+      elif error.find("Connection refused")!=-1:
+         UTMESS('F', 'EXECLOGICIEL0_16',  valk=scmd)
+
+      # Probleme d'acces au logiciel/script distant
+      elif error.find("Aucun fichier ou dossier de ce type")!=-1:
+         UTMESS('F', 'EXECLOGICIEL0_17',  valk=scmd)
+
+      # Autre probleme non determinable
+      else:
+         UTMESS('F', 'EXECLOGICIEL0_18',  valk=scmd)
+
+   return iret, output, error
+
+
 # ------------------------------------------------------------------------------
-def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO, **args):
+def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MACHINE_DISTANTE, MAILLAGE, SALOME, CODE_RETOUR_MAXI, INFO, **args):
    """
    Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions,
    colonnes de table...
@@ -39,11 +99,13 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO
    from Utilitai.Utmess     import  UTMESS
    from Utilitai.System     import ExecCommand
    from Utilitai.UniteAster import UniteAster
-   
+   from Stanley.salomeRunScript import MakeTempScript, DelTempScript, RunScript
+   from Noyau.N_types import is_enum
+
    PRE_GMSH      = self.get_cmd("PRE_GMSH")
    PRE_GIBI      = self.get_cmd("PRE_GIBI")
    LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE")
-   
+
    ier=0
    # La macro compte pour 1 dans la numerotation des commandes
    self.set_icmd(1)
@@ -57,51 +119,247 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO
    # paramètres nécessaires pour écrire la ligne de commande
    # !! d_para['options'] est une liste !!
    d_para = {'prog' : '', 'options' : ''}
-   
+
    l_args = []
    if ARGUMENT != None:
       l_args = ARGUMENT[:]
       if type(l_args) not in EnumTypes:
          l_args = [l_args,]
-   
+
+
+   #----------------------------------------------
+   # 0. Prepare les parametres dans le cas d'une execution sur une machine distante
+
+   if MACHINE_DISTANTE != None:
+      mcf = MACHINE_DISTANTE[0]
+      dMCF = mcf.cree_dict_valeurs(mcf.mc_liste)
+   else:
+      dMCF = {'SSH_ADRESSE': 'localhost', 'SSH_PORT': 22}
+
+
+   #----------------------------------------------
+   # 0. Prepare les parametres dans le cas d'une execution SALOME
+   if SALOME != None:
+      mcf = SALOME[0]
+      dMCFS = mcf.cree_dict_valeurs(mcf.mc_liste)
+
+      # Cas ou SALOME_HOST est different de SSH_ADRESSE ou que MACHINE_DISTANTE / SSH_ADRESSE n'est pas defini
+      if not dMCFS['SALOME_HOST'] in [ 'localhost', dMCF['SSH_ADRESSE'] ]:
+          MACHINE_DISTANTE = True
+          dMCF['SSH_ADRESSE'] = dMCFS['SALOME_HOST']
+          if dMCFS['SALOME_HOST'] != dMCF['SSH_ADRESSE']:
+              UTMESS('A','EXECLOGICIEL0_22')
+
+
+   #----------------------------------------------
+   # 0. Prepare les parametres dans le cas d'une execution sur une machine distante
+   if MACHINE_DISTANTE != None:
+
+      if dMCF.has_key('SSH_LOGIN') and dMCF['SSH_LOGIN'] != None: user_machine = '%s@%s' % (dMCF['SSH_LOGIN'], dMCF['SSH_ADRESSE'])
+      else:                                                       user_machine = '%s'    %  dMCF['SSH_ADRESSE']
+
+      if dMCF.has_key('SSH_PORT') and dMCF['SSH_PORT'] != None:   port = dMCF['SSH_PORT']
+      else:                                                       port = None
+
+
    #----------------------------------------------
    # 1. Préparation des données
    # 1.1. EXEC_LOGICIEL standard
-   if MAILLAGE == None:
+   if MAILLAGE == None and SALOME == None:
       mode_lancement = CMD_EXTERNE
       cmd = '%(prog)s %(options)s'
-   
+
    # 1.2. Cas "lancement d'un mailleur"
-   else:
+   elif MAILLAGE != None:
       mcf = MAILLAGE[0]
       dMCF = mcf.cree_dict_valeurs(mcf.mc_liste)
       d_para['fichIN']  = 'fort.%d' % dMCF['UNITE_GEOM']
       d_para['fichOUT'] = 'fort.%d' % dMCF['UNITE']
       if osp.exists(d_para['fichOUT']):
          os.remove(d_para['fichOUT'])
-      
+
       if dMCF['FORMAT'] == 'GMSH':
          mode_lancement = CMD_EXTERNE
          cmd = '%(prog)s %(options)s -o %(fichOUT)s %(fichIN)s'
          d_para['prog'] = osp.join(aster.repout(), 'gmsh')
          d_para['options'] = ('-3',)
-      
+
       elif dMCF['FORMAT'] == 'GIBI':
          mode_lancement = CMD_EXTERNE
          cmd = '%(prog)s %(options)s %(fichIN)s %(fichOUT)s'
          d_para['prog'] = osp.join(aster.repout(), 'gibi')
-      
+
       elif dMCF['FORMAT'] == 'SALOME':
          mode_lancement = EXECFILE
          if len(l_args) < 1:
             UTMESS('F','EXECLOGICIEL0_1')
          else:
             d_para['fichMED'] = l_args[0]
-      
+
+
+   # Cas "lancement d'un script salome"
+   elif SALOME != None:
+      mode_lancement = CMD_EXTERNE
+      cmd = '%(prog)s %(options)s'
+
+      mcf = SALOME[0]
+      dMCF = mcf.cree_dict_valeurs(mcf.mc_liste)
+      #print dMCF
+
+      # Mot-cles
+      if dMCF.has_key('FICHIERS_ENTREE') and dMCF['FICHIERS_ENTREE'] != None: FICHIERS_ENTREE = dMCF['FICHIERS_ENTREE']
+      else:                                                                   FICHIERS_ENTREE = []
+
+      if dMCF.has_key('FICHIERS_SORTIE') and dMCF['FICHIERS_SORTIE'] != None: FICHIERS_SORTIE = dMCF['FICHIERS_SORTIE']
+      else:                                                                   FICHIERS_SORTIE = []
+
+      if dMCF.has_key('SALOME_RUNAPPLI') and dMCF['SALOME_RUNAPPLI'] != None: RUNAPPLI = dMCF['SALOME_RUNAPPLI']
+      else:                                                                   RUNAPPLI = os.path.join( aster.repout(), 'runSalomeScript' )
+
+      if MACHINE_DISTANTE is None:
+          if dMCF['SALOME_HOST']: RUNAPPLI += ' -m %s ' % dMCF['SALOME_HOST']
+
+      if dMCF['SALOME_PORT']: RUNAPPLI += ' -p %s ' % dMCF['SALOME_PORT']
+
+      # Chemin du script
+      if   dMCF.has_key('CHEMIN_SCRIPT') and dMCF['CHEMIN_SCRIPT'] != None: CHEMIN_SCRIPT = dMCF['CHEMIN_SCRIPT']
+      elif dMCF.has_key('UNITE_SCRIPT')  and dMCF['UNITE_SCRIPT']  != None: CHEMIN_SCRIPT = 'fort.%s' % dMCF['UNITE_SCRIPT']
+      else:                                                                 CHEMIN_SCRIPT = ''
+
+
+      # dic = Dictionnaire a passer pour la creation du script temporaire
+      dic = { 'SALOMESCRIPT': CHEMIN_SCRIPT }
+
+
+      # Parametres a remplacer dans le script
+      if dMCF.has_key('NOM_PARA') and dMCF['NOM_PARA'] != None: NOM_PARA = dMCF['NOM_PARA']
+      else:                                                     NOM_PARA = []
+      if dMCF.has_key('VALE')     and dMCF['VALE']     != None: VALE     = dMCF['VALE']
+      else:                                                     VALE     = []
+      if len(NOM_PARA) != len(VALE): UTMESS('F', 'EXECLOGICIEL0_23')
+
+      for i in range(len(NOM_PARA)):
+         dic[ NOM_PARA[i] ] = VALE[i]
+
+
+      # Changement en liste s'il n'y a qu'un seul element
+      if (not is_enum(FICHIERS_ENTREE)):
+          FICHIERS_ENTREE = [FICHIERS_ENTREE,]
+      if (not is_enum(FICHIERS_SORTIE)):
+          FICHIERS_SORTIE = [FICHIERS_SORTIE,]
+
+
+      # On regenere des noms temporaires dans le repertoire temporaire distant
+      if MACHINE_DISTANTE != None:
+          FICHIERS_ENTREE_DIST = []
+          FICHIERS_SORTIE_DIST = []
+
+      for i in range(len(FICHIERS_ENTREE)):
+          if MACHINE_DISTANTE != None:
+              fw = tempfile.NamedTemporaryFile(mode='w', suffix='.salome_input')
+              fname =  os.path.join(tmpdir, os.path.basename(fw.name))
+              fw.close()
+              FICHIERS_ENTREE_DIST.append( fname )
+          else:
+              fname = FICHIERS_ENTREE[i]
+          #dic['INPUTFILE%s' % str(i+1)] = os.path.normpath(os.path.abspath(os.path.realpath(fname)))
+          dic['INPUTFILE%s' % str(i+1)] = fname
+
+      for i in range(len(FICHIERS_SORTIE)):
+          if MACHINE_DISTANTE != None:
+              fw = tempfile.NamedTemporaryFile(mode='w', suffix='.salome_output')
+              fname =  os.path.join(tmpdir, os.path.basename(fw.name))
+              fw.close()
+              FICHIERS_SORTIE_DIST.append( fname )
+          else:
+              fname = FICHIERS_SORTIE[i]
+          #dic['OUTPUTFILE%s' % str(i+1)] = os.path.normpath(os.path.abspath(os.path.realpath(fname)))
+          dic['OUTPUTFILE%s' % str(i+1)] = fname
+
+
+      # Creation du script de de la commande a executer
+      CHEMIN_SCRIPT = MakeTempScript( **dic )
+
+      # Ligne de commande
+      cmd_salome = []
+
+      if MACHINE_DISTANTE != None:
+
+         # on recopie le script sur le serveur distant
+         d_scp = { 'scp':    exe_scp,
+                   'port':   port,
+                   'src':    CHEMIN_SCRIPT,
+                   'dst':    '%s:%s/' % (user_machine, tmpdir),
+                  }
+         cmd_salome.append( cmd_scp % d_scp )
+
+         # Recopie les fichiers d'entrée sur le serveur distant
+         for i in range(len(FICHIERS_ENTREE)):
+             fsrc = FICHIERS_ENTREE[i]
+             fdst = FICHIERS_ENTREE_DIST[i]
+             d_scp = { 'scp':    exe_scp,
+                       'port':   port,
+                       'src':    fsrc,
+                       'dst':    '%s:%s' % (user_machine, fdst),
+                     }
+             cmd_salome.append( cmd_scp % d_scp )
+
+
+         # Execution du script
+         d_ssh = { 'ssh':          exe_ssh,
+                   'user_machine': user_machine,
+                   'port':         port,
+                   'cmd':          '%s %s' % (RUNAPPLI, os.path.join(tmpdir, os.path.basename(CHEMIN_SCRIPT)) ),
+                 }
+         cmd_salome.append( cmd_ssh % d_ssh )
+
+
+         # Recopie des fichiers de sortie depuis le serveur distant
+         for i in range(len(FICHIERS_SORTIE)):
+             fsrc = FICHIERS_SORTIE_DIST[i]
+             fdst = FICHIERS_SORTIE[i]
+             d_scp = { 'scp':    exe_scp,
+                       'port':   port,
+                       'src':    '%s:%s' % (user_machine, fsrc),
+                       'dst':    fdst,
+                     }
+             cmd_salome.append( cmd_scp % d_scp )
+
+
+         # Effacement des fichiers distants
+         lst_src = [ os.path.join( tmpdir, os.path.basename(CHEMIN_SCRIPT) ) ]
+         if FICHIERS_ENTREE_DIST: lst_src.extend( FICHIERS_ENTREE_DIST )
+         if FICHIERS_SORTIE_DIST: lst_src.extend( FICHIERS_SORTIE_DIST )
+
+         #print lst_src
+         d_ssh['cmd'] = ' '.join([ 'if [ -f "%s" ]; then \\rm %s; fi ; ' % (f,f) for f in lst_src ])
+         cmd_salome.append( cmd_ssh % d_ssh )
+
+
       else:
-         UTMESS('F', 'EXECLOGICIEL0_2', valk=dMCF['FORMAT'])
+         if not debug: cmd_salome.append( '%s %s ; if [ -f "%s" ]; then \\rm %s; fi ; ' % (RUNAPPLI, CHEMIN_SCRIPT, CHEMIN_SCRIPT, CHEMIN_SCRIPT) )
+         else:         cmd_salome.append( '%s %s ' % (RUNAPPLI, CHEMIN_SCRIPT) )
+
+
+      if INFO>=2: 
+         UTMESS('I', 'EXECLOGICIEL0_21',  valk='\n\n'.join(cmd_salome))
+
+         f=open(CHEMIN_SCRIPT, 'r')
+         txt=f.read()
+         f.close()
+         UTMESS('I', 'EXECLOGICIEL0_20', valk=txt)
+
+
+      d_para['prog'] = ' ; ' .join(cmd_salome)
+
+
+
+   #----------------------------------------------
+   # Pas prevu..
+   else:
+      UTMESS('F', 'EXECLOGICIEL0_2', valk=dMCF['FORMAT'])
+
 
-   
    #----------------------------------------------
    # 2. lecture des mots-clés
    if LOGICIEL != None:
@@ -110,14 +368,48 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO
    if len(l_args) > 0:
       d_para['options'] = l_args
    d_para['options'] = ' '.join(d_para['options'])
-   
+
+
    #----------------------------------------------
    # 3. Exécution
    # 3a. Lancement d'une commande externe
    if mode_lancement == CMD_EXTERNE:
-      scmd = cmd % d_para
+
+      # Traite le cas d'une execution sur une machine distante
+      if MACHINE_DISTANTE != None:
+
+         # Construit le dictionnaire des parametres de la ligne de commande SSH
+         d_ssh = { 'ssh':          exe_ssh,
+                   'user_machine': user_machine,
+                   'port':         port,
+                 }
+
+         # Teste la connection via SSH (remplace la commande par un pwd)
+         d_ssh['cmd'] = 'pwd'
+         scmd = cmd_ssh % d_ssh
+         ExecCommand_SSH(scmd)
+
+         # Construit la commande SSH a partir de la commande initiale
+         if SALOME:
+            scmd = cmd % d_para             # La commande Salome integre deja le SSH
+         else:
+            d_ssh['cmd'] = cmd % d_para
+            scmd = cmd_ssh % d_ssh          # On encapsule la commande dans un SSH
+
+      else:
+         scmd = cmd % d_para
+
+
+      # Lancement de la commande
       comment = "Lancement de la commande :\n%s" % scmd
-      iret, output, error = ExecCommand(scmd, alt_comment=comment, verbose=False, separated_stderr=True)
+      if debug: print comment
+
+      if MACHINE_DISTANTE != None:
+#         iret, output, error = ExecCommand_SSH(scmd, alt_comment=comment, verbose=False, separated_stderr=True)  # bizarrement les output/error ne suivent pas!
+         iret, output, error = ExecCommand(scmd, alt_comment=comment, verbose=False, separated_stderr=True)
+      else:
+         iret, output, error = ExecCommand(scmd, alt_comment=comment, verbose=False, separated_stderr=True)
+
       erreur = iret > CODE_RETOUR_MAXI
       if CODE_RETOUR_MAXI == -1: erreur = False
 
@@ -125,15 +417,16 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO
       if INFO > 0 or erreur:
          UTMESS('I', 'EXECLOGICIEL0_11', vali=(iret, CODE_RETOUR_MAXI))
          UTMESS('I', 'EXECLOGICIEL0_9',  valk=output)
-      
+
       # en cas d'erreur, on dump tout dans le .resu + .erre
       if INFO == 2 or erreur:
          UTMESS('I', 'EXECLOGICIEL0_8',  valk=scmd, print_as='E')
          UTMESS('I', 'EXECLOGICIEL0_10', valk=error, print_as='E')
-      
+
       if erreur:
          UTMESS('F', 'EXECLOGICIEL0_3', vali=[CODE_RETOUR_MAXI, iret])
-   
+
+
    #----------------------------------------------
    # 3b. Exécution d'un fichier Python
    elif mode_lancement == EXECFILE:

diff --git a/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py
index 99000615cbbb5ec7f147987887425d05aa46d99a..0bb940e11a075690a3d623e51d1f415dddef5029 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF lire_fonction_ops Macro  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF lire_fonction_ops Macro  DATE 22/03/2011   AUTEUR COURTOIS M.COURTOIS 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -17,6 +17,7 @@
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
 
 import os.path as osp
 import numpy

diff --git a/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py b/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py
index 708dfef42492ba6fb74d1311ad073e1cd4283be9..64d3f4da73fd99d7d04da7690a7f60160992f240 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF lire_inte_spec_ops Macro  DATE 26/03/2008   AUTEUR BODEL C.BODEL 
+#@ MODIF lire_inte_spec_ops Macro  DATE 14/12/2010   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -145,7 +145,7 @@ def lire_inte_spec_ops(self,
         # Verification a posteriori de la dimension de l'inter-spectre
         tmp = 0.5*(-1+sqrt(1+8*len(l_fonc)))
         dim = int(tmp)
-        nb_fonc = 0.5*dim*(dim+1) 
+        nb_fonc = dim*(dim+1)/2
 
         if dim != tmp :
             UTMESS('F', 'SPECTRAL0_6')

diff --git a/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py
index 0ff39ac10ca38a030cb41c5740be0441a4eda056..7578438b72b6a66f202ae7dbe8586ef4be694ffd 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py
@@ -1,28 +1,28 @@
-#@ MODIF macr_adap_mail_ops Macro  DATE 04/10/2010   AUTEUR GNICOLAS G.NICOLAS 
+#@ MODIF macr_adap_mail_ops Macro  DATE 11/05/2011   AUTEUR SELLENET N.SELLENET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                   
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 # RESPONSABLE GNICOLAS G.NICOLAS
 #
 """
 Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
 """
-__revision__ = "V1.4"
+__revision__ = "V1.6"
 #
 def macr_adap_mail_ops ( self,
                          INFO, VERSION_HOMARD, MAILLAGE_FRONTIERE,
@@ -46,14 +46,14 @@ def macr_adap_mail_ops ( self,
 #  2. Les caracteristiques d'un passage sont conservees dans un dictionnaire. Il y a autant de
 #     dictionnaires que de sollicitations pour une serie d'adaptation. L'ensemble de ces dictionnaires
 #     est conserve dans la liste Liste_Passages. Cette liste est necessairement globale pour pouvoir
-#     la retrouver e chaque nouveau passage.
+#     la retrouver a chaque nouveau passage.
 #     Description du dictionnaire de passages :
 #        dico["Maillage_0"]             = o ; string ; nom du concept du maillage initial de la serie d'adaptation
 #        dico["Maillage_NP1"]           = o ; string ; nom du concept du dernier maillage adapte
 #        dico["Rep_Calc_HOMARD_global"] = o ; string ; Nom global du repertoire de calcul pour HOMARD
 #        dico["Rep_Calc_HOMARD_local"]  = o ; string ; Nom local du repertoire de calcul pour HOMARD
 #                                                      depuis le repertoire de calcul pour ASTER
-#        dico["niter"]                  = o ; entier ; numero d'iteration
+#        dico["niter"]                  = o ; entier ; numero d'iteration de depart
 #
 #  3. Les caracteristiques d'un maillage sont conservees dans un dictionnaire. Il y a autant de
 #     dictionnaires que de maillages manipules. L'ensemble de ces dictionnaires est conserve
@@ -72,13 +72,13 @@ def macr_adap_mail_ops ( self,
 #        dico["RESULTAT"]     = f ; concept ASTER du resutat associe
 #        dico["NOM_CHAM"]     = f ; string ; Nom ASTER du champ
 #        dico["CHAM_GD"]      = f ; concept ASTER du champ de grandeur associee
-#        dico["COMPOSANTE"]   = f ; liste ; Liste des noms ASTER des composante de l'indicateur
+#        dico["COMPOSANTE"]   = f ; liste ; Liste des noms ASTER des composantes du champ
 #        dico["NUME_ORDRE"]   = f ; entier ; Numero d'ordre du champ
 #        dico["INST"]         = f ; entier ; Instant du champ
 #        dico["PRECISION"]    = f ; entier ; Precision sur l'instant du champ
 #        dico["CRITERE"]      = f ; entier ; Critere de precision sur l'instant du champ
 #        dico["CHAM_MAJ"]     = f ; string ; Nom ASTER du champ interpole sur le nouveau maillage
-#        dico["NOM_MED"]      = o ; string ; Nom MED du champ
+#        dico["NOM_CHAM_MED"] = o ; string ; Nom MED du champ
 #        dico["SENSIBILITE"]  = f ; string ; Nom du parametre sensible associe
 #
 #  5. Signification de INFO
@@ -90,16 +90,20 @@ def macr_adap_mail_ops ( self,
 #                2nd niveau de message pour l'execution de HOMARD
 #
   from Accas import _F
-  from Macro import creation_donnees_homard 
+  from Macro import creation_donnees_homard
   from Utilitai.Utmess     import UTMESS, MasquerAlarme, RetablirAlarme
-  import aster 
+  import aster
   import string
   import os
+  import cPickle
+  from glob import glob
+  import tarfile
   from types import ListType, TupleType
   EnumTypes = (ListType, TupleType)
 #gn  import shutil
 #
   global Liste_Passages
+  global numero_passage_fonction
 #
 #====================================================================
 # 1. Prealables
@@ -109,15 +113,64 @@ def macr_adap_mail_ops ( self,
 #
   self.set_icmd(1)
 #
-# 1.2. ==> Numero du passage dans cette macro
+# 1.2. ==> Initialisations de parametres Aster
+#
+  repertoire_outils = aster.repout()
+  Rep_Calc_ASTER = os.getcwd()
+  if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER)
+#
+# Remarque : le nom pick.homard.tar est obligatoire car ASTK rapatrie dans la base tous les fichiers en pick.*
+  fichier_archive = os.path.join(Rep_Calc_ASTER, "pick.homard.tar")
+#gn  print "fichier_archive = ",fichier_archive
+#
+# 1.3. ==> Numero du passage dans cette macro
 #
   try :
-    self.jdc.indice_macro_homard = self.jdc.indice_macro_homard + 1
+    numero_passage_fonction = numero_passage_fonction + 1
   except :
-    self.jdc.indice_macro_homard = 1
+    numero_passage_fonction = 1
+#gn  print "numero_passage_fonction = ",numero_passage_fonction
+#
+# 1.4. ==> Au tout premier passage
+#
+  if numero_passage_fonction == 1 :
+#
     Liste_Passages = []
-  numero_passage_fonction = self.jdc.indice_macro_homard
-###  print "numero_passage_fonction = ",numero_passage_fonction
+#
+# 1.4.2. ==> Avec un fichier de reprise : on recupere les repertoires archives
+#
+    if os.path.isfile(fichier_archive) :
+#
+#     Extraction de l'archive
+#     Remarque : a partir de python 2.5 on pourra utiliser extractall
+      if ( INFO >= 3 ) : print "Extraction de l'archive", fichier_archive
+      file = tarfile.open(fichier_archive, "r")
+      for tarinfo in file :
+        if ( INFO >= 3 ) : print tarinfo.name, "is", tarinfo.size, "bytes in size and is",
+        if tarinfo.isreg():
+          if ( INFO >= 3 ) : print "a regular file."
+          file.extract(tarinfo.name)
+        elif tarinfo.isdir():
+          if ( INFO >= 3 ) : print "a directory."
+          file.extract(tarinfo.name)
+        else:
+          if ( INFO >= 3 ) : print "something else."
+      if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER)
+#     Liste de tous les repertoires d'adaptation qui ont ete recuperes
+      laux = glob("*_ADAP_*")
+#     On prend le fichier pickle du 1er repertoire (ce sont tous les memes),
+#     puis on recupere la liste des passages
+      fic = os.path.join(Rep_Calc_ASTER, laux[0], "pick.1")
+      file = open(fic, "r")
+      laux = cPickle.load(file)
+      file.close()
+#     Pour chaque cas, mise a jour du repertoire global
+      for dico in laux :
+        Rep_Calc_HOMARD_local  = dico["Rep_Calc_HOMARD_local"]
+        dico["Rep_Calc_HOMARD_global"] = os.path.join(Rep_Calc_ASTER, Rep_Calc_HOMARD_local)
+        Liste_Passages.append(dico)
+#
+  if ( INFO >= 3 ) : print "Liste_Passages = ", Liste_Passages
 #
 # 1.3. ==> On importe les definitions des commandes a utiliser dans la macro
 #
@@ -127,15 +180,11 @@ def macr_adap_mail_ops ( self,
   LIRE_MAILLAGE   = self.get_cmd("LIRE_MAILLAGE")
   LIRE_CHAMP      = self.get_cmd("LIRE_CHAMP")
 #
-# 1.4. ==> Le nom du programme HOMARD a lancer
-#
-  repertoire_outils = aster.repout()
-  homard            = repertoire_outils + "homard"
-#
 # 1.5. ==> Initialisations
 #
   codret_partiel = [0]
-  Rep_Calc_ASTER = os.getcwd()
+#
+  homard          = repertoire_outils + "homard"
 #
   liste_maillages = []
   liste_champs    = []
@@ -167,7 +216,6 @@ def macr_adap_mail_ops ( self,
 # 2.1.1. ==> Les concepts "maillage"
 #
 #gn    print "\n.. Debut de 2.1.1"
-#    for mot_cle in ["MAILLAGE_N" , "MAILLAGE_NP1"] :
     for mot_cle in ["MAILLAGE_N" , "MAILLAGE_NP1" , "MAILLAGE_NP1_ANNEXE"] :
 #gn      print "\nmot_cle = ",mot_cle
       dico = {}
@@ -184,7 +232,7 @@ def macr_adap_mail_ops ( self,
 #gn      print "dico = ",dico
       liste_maillages.append(dico)
 #
-# 2.1.2. ==> L'eventuel indicateur d'erreur
+# 2.1.2. ==> L'eventuel pilotage de l'adaptation
 #
 #gn    print "\n.. Debut de 2.1.2"
 #gn    print "args = ", args
@@ -192,11 +240,8 @@ def macr_adap_mail_ops ( self,
       dico = {}
       dico["Type_Champ"] = "INDICATEUR"
       if ( args["RESULTAT_N"] != None ) :
-        lresu = 1
         dico["RESULTAT"]   = args["RESULTAT_N"]
-        noresu = dico["RESULTAT"].nom
         dico["NOM_CHAM"]   = args["NOM_CHAM"]
-        nomsym = dico["NOM_CHAM"]
         if ( args["NUME_ORDRE"] != None ) :
           dico["NUME_ORDRE"] = args["NUME_ORDRE"]
         if ( args["INST"] != None ) :
@@ -207,19 +252,13 @@ def macr_adap_mail_ops ( self,
         if ( args["SENSIBILITE"] != None ) :
           dico["SENSIBILITE"] = args["SENSIBILITE"]
       else :
-        lresu = 0
         dico["CHAM_GD"] = args["CHAM_GD"]
-        noresu = dico["CHAM_GD"].nom
-        nomsym = " "
 #gn      print "dico = ", dico
 #
-      if dico.has_key("SENSIBILITE") :
-        nopase = dico["SENSIBILITE"].nom
-      else :
-        nopase = " "
-#gn      print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
-      dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase )
-#gn      print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"]
+      nom_cham_med_fichier = "champ_de_pilotage"
+#                             12345678901234567890123456789012
+      dico["NOM_CHAM_MED"] = nom_cham_med_fichier
+#gn      print "==> dico[\"NOM_CHAM_MED\"] = ", dico["NOM_CHAM_MED"]
 #
       if args.has_key("NOM_CMP") :
         if args["NOM_CMP"] is not None :
@@ -237,7 +276,6 @@ def macr_adap_mail_ops ( self,
 ###      print dico
 #
 # 2.1.3. ==> Les champs a mettre a jour
-#
 #gn     print "\n.. Debut de 2.1.3."
 #
     if args.has_key("MAJ_CHAM") :
@@ -247,15 +285,19 @@ def macr_adap_mail_ops ( self,
       else :
         les_champs = args["MAJ_CHAM"]
 #
+      dico_interp = {}
+      dico_interp["AUTO"] = 0
+      dico_interp["ISOP2"] = 3
+#
+      iaux = 0
       for maj_cham in les_champs :
-#gn        print maj_cham
+#gn        print "maj_cham :", maj_cham
 #gn        print type(maj_cham)
 #
         dico = {}
         dico["Type_Champ"] = "CHAMP_MAJ"
         l_aux = [ "CHAM_MAJ", "TYPE_CHAM" ]
         if ( maj_cham["RESULTAT"] != None ) :
-          lresu = 1
           l_aux.append("RESULTAT")
           l_aux.append("NOM_CHAM")
           if ( maj_cham["NUME_ORDRE"] != None ) :
@@ -265,28 +307,37 @@ def macr_adap_mail_ops ( self,
             for cle in [ "PRECISION", "CRITERE" ] :
               if ( maj_cham[cle] != None ) :
                 dico[cle] = maj_cham[cle]
-          noresu = maj_cham["RESULTAT"].nom
-          nomsym = maj_cham["NOM_CHAM"]
           if ( maj_cham["SENSIBILITE"] != None ) :
             dico["SENSIBILITE"] = maj_cham["SENSIBILITE"]
         else :
-          lresu = 0
           l_aux.append("CHAM_GD")
-          noresu = maj_cham["CHAM_GD"].nom
-          nomsym = " "
         for cle in l_aux :
           dico[cle] = maj_cham[cle]
 #gn        print "dico = ", dico
 #
-        if dico.has_key("SENSIBILITE") :
-          nopase = dico["SENSIBILITE"].nom
-        else :
-          nopase = " "
-#gn        print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
-        dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase )
-#gn        print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"]
+        if maj_cham["NOM_CMP"] is not None :
+          if not type(maj_cham["NOM_CMP"]) in EnumTypes :
+            l_aux = [maj_cham["NOM_CMP"]]
+          else :
+            l_aux = []
+            les_composantes = maj_cham["NOM_CMP"]
+            for composante in les_composantes :
+              l_aux.append(composante)
+          dico["COMPOSANTE"] = l_aux
+#gn          print "COMPOSANTEmaj_cham", dico["COMPOSANTE"]
 #
-###        print dico
+#gn        print "dico = ", dico
+        iaux += 1
+        la_chaine = '%08d' % iaux
+        nom_cham_med_fichier = "champ_" + la_chaine
+#                               123456789012345678901234    56789012
+        dico["NOM_CHAM_MED"] = nom_cham_med_fichier
+#gn        print "==> dico[\"NOM_CHAM_MED\"] = ", dico["NOM_CHAM_MED"]
+#
+        dico["TYPE_MAJ"] = dico_interp[maj_cham["TYPE_MAJ"]]
+#gn        print "==> dico[\"TYPE_MAJ\"] = ", dico["TYPE_MAJ"]
+#
+#gn        print "dico :", dico
         liste_champs.append(dico)
 #
 # 2.1.4. ==> Les zones de raffinement
@@ -300,8 +351,7 @@ def macr_adap_mail_ops ( self,
         les_zones = args["ZONE"]
 #
         for zone in les_zones :
-###          print zone
-###          print type(zone)
+###          print zone, "de type", type(zone)
           dico = {}
           for aux in l_aux :
             if ( zone[aux] != None ) :
@@ -348,7 +398,7 @@ def macr_adap_mail_ops ( self,
       les_front_analytiques = args["FRONTIERE_ANALYTIQUE"]
 #
     for frontiere in les_front_analytiques :
-      l_aux = [ "TYPE", "GROUP_MA", "RAYON", "X_CENTRE", "Y_CENTRE", "Z_CENTRE"]
+      l_aux = [ "NOM", "TYPE", "GROUP_MA", "RAYON", "X_CENTRE", "Y_CENTRE", "Z_CENTRE"]
       if ( frontiere["TYPE"] == "CYLINDRE" ) :
         l_aux.append("X_AXE")
         l_aux.append("Y_AXE")
@@ -389,7 +439,6 @@ def macr_adap_mail_ops ( self,
       UTMESS('I','HOMARD0_6')
     else :
       UTMESS('A','HOMARD0_7')
-#    UTMESS('I','HOMARD0_6',valk='glop')
 #
 #====================================================================
 # 3. Preparation du lancement des commandes
@@ -399,7 +448,7 @@ def macr_adap_mail_ops ( self,
 #          . Memorisation des noms ASTER du maillage en entree et en sortie (sous forme string)
 #
 #          On cree une nouvelle liste des dictionnaires decrivant les maillages
-#          et e la fin on ecrase l'ancienne liste par cette nouvelle.
+#          et a la fin on ecrase l'ancienne liste par cette nouvelle.
 #
 #gn  print "\n.. Debut de 3.1."
 #
@@ -446,6 +495,7 @@ def macr_adap_mail_ops ( self,
 #              le cas, cela veut dire que l'adaptation en cours est la suite d'une
 #              precedente. On doit donc utiliser le meme repertoire. Le numero
 #              d'iteration est celui de l'adaptation precedente augmente de 1.
+#              Si on n'a rien trouve, c'est que l'on demarre un nouveau cas.
 #
 #gn    print "\.. Debut de 3.2.2.1."
 #
@@ -459,16 +509,20 @@ def macr_adap_mail_ops ( self,
 #
 #gn    print "\.. Debut de 3.2.2.2."
 #
-# 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure
+# 3.2.2.2.1. ==> Enregistrement d'un nouveau cas
+#                On emet une alarme si il existe deja un cas pour etre certain
+#                que l'utilisateur ne s'est pas trompe dans l'enchainement
 #
     if ( niter == 0 ) :
+      for dico in Liste_Passages :
+        UTMESS("A", 'HOMARD0_9', valk=(Nom_Concept_Maillage_N, Nom_Concept_Maillage_NP1, dico["Maillage_NP1"], dico["Maillage_0"]), vali=dico["niter"]+1 )
       dico = {}
-      dico["Maillage_0"]   = Nom_Concept_Maillage_N
-      dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
-      dico["Maillage_NP1_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE
+      dico["Maillage_0"]             = Nom_Concept_Maillage_N
+      dico["Maillage_NP1"]           = Nom_Concept_Maillage_NP1
+      dico["Maillage_NP1_ANNEXE"]    = Nom_Concept_Maillage_NP1_ANNEXE
       dico["Rep_Calc_HOMARD_local"]  = Rep_Calc_HOMARD_local
       dico["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global
-      dico["niter"]        = niter
+      dico["niter"]                  = niter
       Liste_Passages.append(dico)
 #
 # 3.2.2.2.2. ==> Modification du cas en cours
@@ -477,16 +531,20 @@ def macr_adap_mail_ops ( self,
       l_aux = []
       for dico in Liste_Passages :
         if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
-          dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
+          dico["Maillage_NP1"]        = Nom_Concept_Maillage_NP1
           dico["Maillage_NP1_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE
-          dico["niter"]        = niter
+          dico["niter"]               = niter
         l_aux.append(dico)
-      Liste_Passages = l_aux
+      Liste_Passages = []
+      for dico in l_aux :
+        Liste_Passages.append(dico)
+#
+#gn    print "Apres 3.2.2.2. Liste_Passages = ", Liste_Passages
 #
 ###  print "niter = ", niter, ", Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
 #
-# 3.2.3. Creation du repertoire pour homard
-#        attention : on ne fait cette creation qu'une seule fois par cas
+# 3.2.3. Le repertoire pour homard
+#        Attention : on ne fait cette creation qu'une seule fois par cas
 #                    d'adaptation ou d'information
 #
 #gn  print "\.. Debut de 3.2.3."
@@ -498,6 +556,11 @@ def macr_adap_mail_ops ( self,
     except os.error,codret_partiel :
       self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
       UTMESS("F", 'HOMARD0_4', valk=Rep_Calc_HOMARD_global)
+#
+  else :
+#
+    if not os.path.isdir(Rep_Calc_HOMARD_global) :
+      UTMESS("F", 'HOMARD0_8', valk=Rep_Calc_HOMARD_global)
 #
 #====================================================================
 # 4. Ecriture des commandes de creation des donnees MED
@@ -506,20 +569,20 @@ def macr_adap_mail_ops ( self,
 #gn  print "\.. Debut de 4."
 #
 #  On doit ecrire : le maillage,
-#                   le champ d'indicateur d'erreur
-#                   les champs e convertir
+#                   le champ de pilotage de l'adaptation
+#                   les champs a convertir
 #  Remarque : on met tout dans le meme fichier
 #
 #  Chacune de ces ecritures est optionnelle selon le contexte.
 #
 # 4.1. ==> Noms des fichiers d'ASTER vers HOMARD et eventuellement de HOMARD vers ASTER
-#          Remarque : aujourd'hui, les ecritures ou les lectures au format MED se font obligatoirement sur
-#                     un fichier de nom fort.n, place dans le repertoire de calcul
+#          Remarque : aujourd'hui, les ecritures ou les lectures au format MED se font obligatoirement
+#                     dans un fichier de nom fort.n, place dans le repertoire de calcul
 ##
 # 4.1.1. ==> D'ASTER vers HOMARD
 #
   unite_fichier_aster_vers_homard = 1787 + 2*numero_passage_fonction
-  fichier_aster_vers_homard = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_aster_vers_homard))
+  fichier_aster_vers_homard = os.path.join(Rep_Calc_ASTER, "fort." + str(unite_fichier_aster_vers_homard))
 ###  print "fichier_aster_vers_homard = ",fichier_aster_vers_homard
 #
 # 4.1.2. ==> De HOMARD vers ASTER
@@ -552,33 +615,31 @@ def macr_adap_mail_ops ( self,
       motscfa["RESU"] = _F( INFO_MAILLAGE=infomail,
                           **motscsi )
 #
-      IMPR_RESU ( INFO = infocomm, 
+      IMPR_RESU ( INFO = infocomm,
                   FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard,
                   **motscfa )
 #
 # 4.4. Le(s) champ(s)
-#        Attention : il se peut que l'on demande la mise a jour du champ qui a servi comme
-#                    indicateur d'erreur. Si c'est le cas, il ne faut pas demander son
+#        Attention : il se peut que l'on demande la mise à jour du champ qui a servi comme
+#                    pilotage de l'adaptation. Si c'est le cas, il ne faut pas demander son
 #                    impression sinon il y a plantage d'IMPR_RESU qui ne sait pas substituer
 #                    deux champs. D'ailleurs, c'est plus economique ainsi !
-#        Remarque : pour l'adaptation, on peut ne demander qu'un nombre reduit de composante du
-#                   champ d'indicateur.
-#                   s'il y a demande de mise a jour, toutes les composantes sont concernees. Il faut
-#                   donc dans ce cas imprimer le champ total.
+#        Remarque : pour l'adaptation ou les champs a mettre a jour, on peut ne demander
+#                   qu'un nombre reduit de composantes.
 #        dico["Type_Champ"]   = o ; string ; "INDICATEUR" ou "CHAMP_MAJ"
 #        dico["RESULTAT"]     = f ; concept ASTER du resutat associe
 #        dico["NOM_CHAM"]     = f ; string ; Nom ASTER du champ
 #        dico["CHAM_GD"]      = f ; concept ASTER du champ de grandeur associee
-#        dico["COMPOSANTE"]   = f ; liste ; Liste des noms ASTER des composante de l'indicateur
+#        dico["COMPOSANTE"]   = f ; liste ; Liste des noms ASTER des composante du champ
 #        dico["NUME_ORDRE"]   = f ; entier ; Numero d'ordre du champ
 #        dico["INST"]         = f ; entier ; Instant du champ
 #        dico["PRECISION"]    = f ; entier ; Precision sur l'instant du champ
 #        dico["CRITERE"]      = f ; entier ; Critere de precision sur l'instant du champ
 #        dico["CHAM_MAJ"]     = f ; string ; Nom ASTER du champ interpole sur le nouveau maillage
-#        dico["NOM_MED"]      = o ; string ; Nom MED du champ
+#        dico["NOM_CHAM_MED"] = o ; string ; Nom MED du champ
 #        dico["SENSIBILITE"]  = f ; string ; Nom du parametre sensible associe
 #
-# 4.4.1. Recherche d'un doublon eventuel sur le champ d'indicateur d'erreur
+# 4.4.1. Recherche d'un doublon eventuel sur le champ de pilotage de l'adaptation
 #
 #gn  print "dico_indi = ",dico_indi
   if len(dico_indi) > 0 :
@@ -595,11 +656,11 @@ def macr_adap_mail_ops ( self,
 #
   liste_champs_imprime = []
   for dico in liste_champs :
-###    print "\n.... dico = ",dico
-#   Pour un champ e mettre e jour, on a toujours impression
+#gn    print "\n.... dico = ",dico
+#   Pour un champ a mettre a jour, on a toujours impression
     if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
       liste_champs_imprime.append(dico)
-#     Si le champ d'indicateur n'a toujours pas ete repere comme champ e mettre e jour :
+#     Si le champ de pilotage de l'adaptation n'a toujours pas ete repere comme champ a mettre a jour :
       if not indic_est_deja_imprime :
 #       Est-ce le meme champ ?
         on_a_le_champ = 1
@@ -636,11 +697,14 @@ def macr_adap_mail_ops ( self,
                   if ( dico_indi[cle] != dico[cle] ) :
                     on_a_le_champ = 0
                     break
+#       Le champ de pilotage fait partie des champs mis a jour : on le note
+#       et on utilise le meme nom de champ MED
         if on_a_le_champ :
+          dico_indi["NOM_CHAM_MED"] = dico["NOM_CHAM_MED"]
           indic_est_deja_imprime = 1
-###  print "\n\nFin de la boucle .. indic_est_deja_imprime = ",indic_est_deja_imprime
-#   Si le champ d'indicateur n'a pas ete repere comme champ e mettre e jour, il faut
-#   l'inclure dans les champs e imprimer
+#gn  print "\n\nFin de la boucle .. indic_est_deja_imprime = ",indic_est_deja_imprime
+#   Si le champ de pilotage de l'adaptation n'a pas ete repere comme champ a mettre a jour,
+#   il faut l'inclure dans les champs e imprimer
   if not indic_est_deja_imprime :
     liste_champs_imprime.append(dico_indi)
 #
@@ -649,7 +713,7 @@ def macr_adap_mail_ops ( self,
 #
   for dico in liste_champs_imprime :
     motscsi = {}
-    for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
+    for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE", "NOM_CHAM_MED" ] :
       if dico.has_key(cle) :
         if ( dico[cle] != None ) :
           motscsi[cle] = dico[cle]
@@ -666,7 +730,7 @@ def macr_adap_mail_ops ( self,
                       )
 #gn    print ".. motscfa = ",motscfa
 #
-    IMPR_RESU ( INFO = infocomm, 
+    IMPR_RESU ( INFO = infocomm,
                 FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard,
                 **motscfa )
 #
@@ -702,12 +766,12 @@ def macr_adap_mail_ops ( self,
     dico_configuration[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"]
 #gn  print dico_configuration
 #
-# 5.3. ==> Les caracteristiques de l'eventuel indicateur d'erreur
+# 5.3. ==> Les caracteristiques de l'eventuel pilotage de l'adaptation
 #
   for dico in liste_champs :
     dico_aux = {}
     if ( dico["Type_Champ"] == "INDICATEUR" ) :
-      l_aux = [ "NOM_MED" ]
+      l_aux = [ "NOM_CHAM_MED" ]
       if dico.has_key("COMPOSANTE") :
         l_aux.append("COMPOSANTE")
       if dico.has_key("NUME_ORDRE") :
@@ -733,13 +797,13 @@ def macr_adap_mail_ops ( self,
 ###  if dico_configuration.has_key("Zones_raffinement") :
 ###    print "dico_configuration[Zones_raffinement] = ", dico_configuration["Zones_raffinement"]
 #
-# 5.5. ==> La mise a jour de champs
+# 5.5. ==> Les eventuelles mises a jour de champs
 #
   prem = 1
   for dico in liste_champs :
     dico_aux = {}
     if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
-      l_aux = [ "NOM_MED", "COMPOSANTE" ]
+      l_aux = [ "NOM_CHAM_MED", "COMPOSANTE", "TYPE_MAJ" ]
       if dico.has_key("NUME_ORDRE") :
         l_aux.append("NUME_ORDRE")
       else :
@@ -789,7 +853,6 @@ def macr_adap_mail_ops ( self,
 # 5.8. ==> Impression eventuelle des fichiers crees
 #
 #gn  print "Repertoire ",Rep_Calc_HOMARD_global
-#gn  os.system("ls -la "+Rep_Calc_HOMARD_global)
   if ( INFO >= 4 ) :
     l_aux = ["HOMARD.Donnees" , "HOMARD.Configuration"]
   else :
@@ -814,13 +877,7 @@ def macr_adap_mail_ops ( self,
 #====================================================================
 # 6. Ecriture de la commande d'execution de homard
 #====================================================================
-#
-#
 #gn  print "\.. Debut de 6."
-#gn  os.system("cp " + Rep_Calc_HOMARD_global + "/../fort.17* $HOME/aster")
-#gn  os.system("cp " + Rep_Calc_HOMARD_global + "/HOMARD.Configuration $HOME/aster/HOMARD.Configuration"+str(niter))
-#gn  fichier_aster_vers_homard_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_aster_vers_homard))
-#gn  shutil.copyfile(fichier_aster_vers_homard, fichier_aster_vers_homard_2)
 #
   if ( INFO == 1 ) :
     iaux = INFO
@@ -838,25 +895,18 @@ def macr_adap_mail_ops ( self,
 #gn  import time
 #gn  time.sleep(3600)
 #
-#gn  if ( mode_homard == "ADAP" ) :
-#gn    fichier_homard_vers_aster_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster))
-#gn    shutil.copyfile(fichier_homard_vers_aster, fichier_homard_vers_aster_2)
-#gn    fichier_homard_vers_aster_2_1 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".1")
-#gn    os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_1+"</tmp/donn1")
-#gn    fichier_homard_vers_aster_2_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".2")
-#gn    os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_2+"</tmp/donn2")
-#
 #====================================================================
 # 7. ==> Ecriture de la commande de lecture des resultats med
 #        Remarque :
 #        La fonction self.DeclareOut(a,b) fonctionne ainsi :
 #        a est une chaine de caracteres
 #        b est la variable declaree dans la commande
-#        le but est de associer le contenu de b e la variable locale qui sera designee par a
+#        le but est de associer le contenu de b a la variable locale qui sera designee par a
 #        Exemple :
-#        self.DeclareOut("maillage_a_lire",args["MAILLAGE_NP1"])
-#        ==> la variable maillage_a_lire est identifiee e l'argument "MAILLAGE_NP1"
+#        self.DeclareOut("maillage_a_lire", args["MAILLAGE_NP1"])
+#        ==> la variable maillage_a_lire est identifiee a l'argument "MAILLAGE_NP1"
 #====================================================================
+#gn  print "\.. Debut de 7."
 #
   if ( mode_homard in [ "ADAP", "MODI" ] ) :
 #
@@ -891,7 +941,6 @@ def macr_adap_mail_ops ( self,
     for dico in liste_champs :
       if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
 #gn        print dico
-        self.DeclareOut("champ_maj", dico["CHAM_MAJ"])
         motscsi = {}
         for cle in [ "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
           if dico.has_key(cle) :
@@ -901,11 +950,12 @@ def macr_adap_mail_ops ( self,
           motscsi["NUME_PT"] = dico["NUME_ORDRE"]
 #gn        print "MAILLAGE = ",maillage_np1
 #gn        print "NOM_MAIL_MED = ",maillage_np1_nom_med
-#gn        print "NOM_MED = ",dico["NOM_MED"]
+#gn        print "NOM_CHAM_MED = ",dico["NOM_CHAM_MED"]
 #gn        print "TYPE_CHAM =", dico["TYPE_CHAM"]
+        self.DeclareOut("champ_maj", dico["CHAM_MAJ"])
         champ_maj = LIRE_CHAMP ( UNITE = unite_fichier_homard_vers_aster, FORMAT = "MED",
                                  MAILLAGE = maillage_np1, NOM_MAIL_MED=maillage_np1_nom_med,
-                                 NOM_MED = dico["NOM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"],
+                                 NOM_MED = dico["NOM_CHAM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"],
                                  INFO = infocomm, **motscsi )
 #
 #====================================================================
@@ -915,6 +965,7 @@ def macr_adap_mail_ops ( self,
 #    On doit imperativement garder le dernier fichier homard produit
 #    En mode d'information, on garde egalement les fichiers textes
 #====================================================================
+#gn  print "\.. Debut de 8."
 #
   l_aux = [fichier_aster_vers_homard]
   if ( mode_homard in [ "ADAP", "MODI" ] ) :
@@ -929,7 +980,6 @@ def macr_adap_mail_ops ( self,
   if ( mode_homard == "ADAP" ) :
     fic = os.path.join(Rep_Calc_HOMARD_global, fic_homard_niterp1)
     l_aux_bis.append(fic)
-#gn  os.system("cp " + Rep_Calc_HOMARD_global + "/* $HOME/aster")
 #
   for fic in l_aux :
     if ( INFO >= 3 ) :
@@ -944,12 +994,46 @@ def macr_adap_mail_ops ( self,
           self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
           UTMESS("F", 'HOMARD0_5', valk=fic)
 #
+# Liberation du fichier de ASTER vers HOMARD
+#
+  DEFI_FICHIER ( ACTION= "LIBERER",
+                 UNITE = unite_fichier_aster_vers_homard,
+                 INFO = infocomm )
 #gn  print "Repertoire ",Rep_Calc_HOMARD_global
 #gn  print os.listdir(Rep_Calc_HOMARD_global)
 #gn  print "Repertoire ",Rep_Calc_ASTER
 #gn  print os.listdir(Rep_Calc_ASTER)
 #
 #====================================================================
+# 9. Archivage des repertoires d'adaptation en vue de poursuite
+#====================================================================
+#gn  print "\.. Debut de 9."
+#
+#
+  if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER)
+  if ( INFO >= 3 ) : print "Archivage dans", fichier_archive
+  laux = []
+  for dico in Liste_Passages :
+#   Memorisation du nom du repertoire local pour ce cas d'adaptation
+    Rep_Calc_HOMARD_local  = dico["Rep_Calc_HOMARD_local"]
+    laux.append(Rep_Calc_HOMARD_local)
+#   Memorisation de la liste des passages
+#   Remarque : c'est fait a chaque repertoire pour faciliter le decodage ensuite
+    Rep_Calc_HOMARD_global = dico["Rep_Calc_HOMARD_global"]
+    fic = os.path.join(Rep_Calc_HOMARD_global, "pick.1")
+    file = open(fic, "w")
+    cPickle.dump(Liste_Passages, file)
+    file.close()
+# Si on a au moins un cas d'adaptation, archivage
+  if len(laux) > 0 :
+    file = tarfile.open(fichier_archive, "w")
+    for rep in laux :
+      if ( INFO >= 3 ) : print ".. Insertion de", rep
+      file.add(rep)
+    file.close()
+  if ( INFO >= 3 ) : print os.listdir(Rep_Calc_ASTER)
+#
+#====================================================================
 #  C'est fini !
 #====================================================================
 #
@@ -959,3 +1043,6 @@ def macr_adap_mail_ops ( self,
 #gn  time.sleep(3600)
 #
   return
+
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py
index 1931bda34e5a4e34877422c817ad0c560ebf575f..d9677c140ac2a80baf8bb541c6635f9f3d1ca3ea 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macr_ascouf_calc_ops Macro  DATE 14/09/2010   AUTEUR ABBAS M.ABBAS 
+#@ MODIF macr_ascouf_calc_ops Macro  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -21,7 +21,7 @@
 
 def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,
                               FOND_FISS,RESU_THER,AFFE_MATERIAU,
-                              PRES_REP,ECHANGE,TORS_P1,COMP_INCR,COMP_ELAS,
+                              PRES_REP,ECHANGE,TORS_P1,COMP_ELAS,
                               SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE,
                               INCREMENT,THETA_3D,IMPR_TABLE,IMPRESSION,INFO,TITRE ,**args):
   """
@@ -347,10 +347,8 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
     contact = _chcont  
   motscles['EXCIT'] =mcfex
 #
-  mcfci=[]  # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets
-  if COMP_INCR!=None :
-    mcfci.append(_F(TOUT='OUI' ,RELATION=COMP_INCR['RELATION']))
-  elif COMP_ELAS!=None :
+  mcfci=[]  # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets dans STAT_NON_LINE
+  if COMP_ELAS!=None :
     motscles['COMP_ELAS'] =_F(GROUP_MA='COUDE',RELATION=COMP_ELAS['RELATION'])
     if TORS_P1!=None     : mcfci.append(  _F(GROUP_MA='P1',RELATION='ELAS'))
     if CL_BOL_P2_GV==None: mcfci.append(  _F(GROUP_MA='P2',RELATION='ELAS'))
@@ -404,7 +402,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
   nomres = CALC_ELEM( reuse      = nomres,
                       RESULTAT   = nomres ,
                       TOUT_ORDRE = 'OUI'  ,
-                      OPTION     = ('SIEF_ELNO_ELGA','EQUI_ELNO_SIGM') ,
+                      OPTION     = ('SIEF_ELNO','SIEQ_ELNO') ,
                       INFO       = INFO   ,)
 #
 #     --- post-traitements ---
@@ -442,7 +440,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
       motscles['ACTION']=[]
       for grno in lgrno :
          motscles['ACTION'].append(_F(RESULTAT=nomres,
-                                      NOM_CHAM='SIEF_ELNO_ELGA',
+                                      NOM_CHAM='SIEF_ELNO',
                                       TOUT_CMP='OUI',
                                       INTITULE=grno,
                                       GROUP_NO=grno,
@@ -458,7 +456,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
       motscles['ACTION']=[]
       for tgrno in lgrno :
          motscles['ACTION'].append(_F(RESULTAT=nomres,
-                                      NOM_CHAM='SIEF_ELNO_ELGA',
+                                      NOM_CHAM='SIEF_ELNO',
                                       INTITULE=tgrno,
                                       GROUP_NO=tgrno,
                                       INVARIANT='OUI',
@@ -496,7 +494,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
                       ANGSEC = atan2(VSIN,VCOS)
                  vecty=(sin(ANGSEC),0.,cos(ANGSEC))
          motscles['ACTION'].append(_F(RESULTAT=nomres,
-                                      NOM_CHAM='SIEF_ELNO_ELGA',
+                                      NOM_CHAM='SIEF_ELNO',
                                       INTITULE=tgrno,
                                       GROUP_NO=tgrno,
                                       NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ',),
@@ -529,7 +527,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
          motscles['ACTION']=[]
          for j in range(8) :
             motscles['ACTION'].append(_F(RESULTAT=nomres,
-                                         NOM_CHAM='SIEF_ELNO_ELGA',
+                                         NOM_CHAM='SIEF_ELNO',
                                          TOUT_CMP='OUI',
                                          INTITULE=LIG[j]+SECT[i],
                                          GROUP_NO=LIG[j]+SECT[i],
@@ -549,7 +547,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
          for j in range(8) : motscles['ACTION'].append(_F(INTITULE =LIG[j]+SECT[i],
                                                           GROUP_NO =LIG[j]+SECT[i],
                                                           RESULTAT =nomres,
-                                                          NOM_CHAM ='SIEF_ELNO_ELGA',
+                                                          NOM_CHAM ='SIEF_ELNO',
                                                           INVARIANT='OUI',
                                                           OPERATION='EXTRACTION'))
          secinv[i] = POST_RELEVE_T(**motscles)
@@ -564,7 +562,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
                                                           VECT_Y   =vecty,
                                                           GROUP_NO =LIG[j]+SECT[i],
                                                           RESULTAT =nomres,
-                                                          NOM_CHAM ='SIEF_ELNO_ELGA',
+                                                          NOM_CHAM ='SIEF_ELNO',
                                                           NOM_CMP  =('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),
                                                           OPERATION='MOYENNE'))
          secmoy[i] = POST_RELEVE_T(**motscles)
@@ -721,7 +719,6 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
                                        R_SUP  = thet['R_SUP'],),
                            );
         motscles = {}
-        if COMP_INCR!=None : motscles['COMP_INCR']=_F(RELATION=COMP_INCR['RELATION'])
         if COMP_ELAS!=None : motscles['COMP_ELAS']=_F(RELATION=COMP_ELAS['RELATION'])
         _nogthe=CALC_G( RESULTAT   =nomres,
                         OPTION='CALC_G_GLOB',
@@ -732,7 +729,6 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA
 #
       for thet in THETA_3D:
         motscles = {}
-        if COMP_INCR!=None : motscles['COMP_INCR']=_F(RELATION=COMP_INCR['RELATION'])
         if COMP_ELAS!=None : motscles['COMP_ELAS']=_F(RELATION=COMP_ELAS['RELATION'])
         if   TYPE_MAILLAGE =='FISS_COUDE' :
                              motscles['LISSAGE']=_F(LISSAGE_THETA='LEGENDRE',

diff --git a/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py
index 0355d1c46a4f0d73d56734f02a3ccbad14101898..d56cc8d63a9b837c910e2f24b923be18a5b60047 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macr_aspic_calc_ops Macro  DATE 14/09/2010   AUTEUR ABBAS M.ABBAS 
+#@ MODIF macr_aspic_calc_ops Macro  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -21,7 +21,7 @@
 
 def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,
                              FOND_FISS_1,FOND_FISS_2,RESU_THER,AFFE_MATERIAU,EQUILIBRE,
-                             PRES_REP,ECHANGE,TORS_CORP,TORS_TUBU,COMP_INCR,COMP_ELAS,
+                             PRES_REP,ECHANGE,TORS_CORP,TORS_TUBU,COMP_ELAS,
                              THETA_3D,OPTION,SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE,
                              INCREMENT,PAS_AZIMUT,IMPRESSION,INFO,TITRE,BORNES ,**args):
   """
@@ -346,9 +346,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
      
   motscles['EXCIT'] =mcfex
 #
-  mcfci=[]  # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets
-  if COMP_INCR!=None :
-    mcfci.append(_F(TOUT    ='OUI' ,RELATION=COMP_INCR['RELATION']))
+  mcfci=[]  # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets dans STAT_NON_LINE
   mcfci.append(  _F(GROUP_MA=NOMNOE,RELATION='ELAS'))
   motscles['COMP_INCR'] =mcfci
 #
@@ -405,7 +403,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
   nomres = CALC_ELEM( reuse      = nomres,
                       RESULTAT   = nomres ,
                       TOUT_ORDRE = 'OUI'  ,
-                      OPTION     = ('SIEF_ELNO_ELGA','VARI_ELNO_ELGA','EQUI_ELNO_SIGM') ,
+                      OPTION     = ('SIEF_ELNO','VARI_ELNO','SIEQ_ELNO') ,
                       INFO       = INFO ,)
 #
 #-----------------------------------------------------------------------
@@ -438,7 +436,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
       mcsimp['GROUP_NO' ]='LD'+str(i)
       mcfact.append( _F( RESULTAT   = nomres,
                          TOUT_ORDRE ='OUI',
-                         NOM_CHAM   ='SIEF_ELNO_ELGA',
+                         NOM_CHAM   ='SIEF_ELNO',
                          PRECISION  =55.E-1,
                          TOUT_CMP   ='OUI',
                          OPERATION  ='EXTRACTION',**mcsimp))
@@ -465,7 +463,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
         mcsimp['GROUP_NO'   ]='LD'+str(i)
         mcsimp['RESULTAT'   ]=nomres
         mcsimp['TOUT_ORDRE' ]='OUI'
-        mcsimp['NOM_CHAM'   ]='SIEF_ELNO_ELGA'
+        mcsimp['NOM_CHAM'   ]='SIEF_ELNO'
         mcsimp['PRECISION'  ]=55.E-1
         mcsimp['TOUT_CMP'   ]='OUI'
         mcsimp['OPERATION'  ]='EXTRACTION'
@@ -532,7 +530,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
       mcsimp['GROUP_NO'   ]='LI'+str(i)
       mcsimp['RESULTAT'   ]=nomres
       mcsimp['TOUT_ORDRE' ]='OUI'
-      mcsimp['NOM_CHAM'   ]='SIEF_ELNO_ELGA'
+      mcsimp['NOM_CHAM'   ]='SIEF_ELNO'
       mcsimp['PRECISION'  ]=55.E-1
       mcsimp['TOUT_CMP'   ]='OUI'
       mcsimp['REPERE'     ]='LOCAL'
@@ -555,7 +553,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
         mcsimp['GROUP_NO'   ]='LI'+str(i)
         mcsimp['RESULTAT'   ]=nomres
         mcsimp['TOUT_ORDRE' ]='OUI'
-        mcsimp['NOM_CHAM'   ]='SIEF_ELNO_ELGA'
+        mcsimp['NOM_CHAM'   ]='SIEF_ELNO'
         mcsimp['PRECISION'  ]=55.E-1
         mcsimp['TOUT_CMP'   ]='OUI'
         mcsimp['OPERATION'  ]='EXTRACTION'
@@ -754,7 +752,6 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
           motscles={}
           if COMP_ELAS!=None:  motscles['COMP_ELAS']=  _F(TOUT     = 'OUI',
                                                           RELATION = COMP_ELAS['RELATION'],)
-          if COMP_INCR!=None:  motscles['COMP_INCR']=  _F(RELATION = COMP_INCR['RELATION'],)
           __gtheta = CALC_G ( THETA      = _F(THETA=__theta),
                               OPTION     = 'CALC_G_GLOB',
                               RESULTAT   = nomres,
@@ -783,7 +780,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
 #
 #          --- commande CALC_G (3D LOCAL) ---
 #
-          montit = 'G_LOCAL AVEC R_INF = '+str(tht3d['R_INF'])+' ET R_SUP = '+str(tht3d['R_SUP'])
+          montit = 'G AVEC R_INF = '+str(tht3d['R_INF'])+' ET R_SUP = '+str(tht3d['R_SUP'])
           motscles={}
           if COMP_ELAS!=None:  motscles['COMP_ELAS'    ]=  _F(TOUT     = 'OUI',
                                                               RELATION = COMP_ELAS['RELATION'],)
@@ -834,7 +831,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C
       if IMPRESSION['NOM_CHAM']!=None :
          if type(IMPRESSION['NOM_CHAM']) in (types.TupleType,types.ListType) : ncham= IMPRESSION['NOM_CHAM']
          else                                                                : ncham=[IMPRESSION['NOM_CHAM'],]
-      if    len(ncham)==3       : motscles['NOM_CHAM'  ]=('DEPL','EQUI_ELNO_SIGM')
+      if    len(ncham)==3       : motscles['NOM_CHAM'  ]=('DEPL','SIEQ_ELNO')
       elif (len(ncham)==1) and (ncham[0][:4]!='TEMP')  :
                                   motscles['NOM_CHAM'  ]= ncham[0]
       elif (len(ncham)==2) and (ncham[0][:4]!='TEMP') and (ncham[1][:4]!='TEMP')  :

diff --git a/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py b/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py
index 6f082892ffd7be4fa74c7971b7b96348b1b47e7e..053d4d0a1f8d653614684fadcb9905a66447f6b5 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macr_cara_poutre_ops Macro  DATE 13/09/2010   AUTEUR PELLET J.PELLET 
+#@ MODIF macr_cara_poutre_ops Macro  DATE 13/01/2011   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -317,7 +317,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD,
      __tempe1=CALC_ELEM(reuse=__tempe1,
                        RESULTAT=__tempe1,
                        TOUT_ORDRE='OUI',
-                       OPTION='FLUX_ELNO_TEMP',
+                       OPTION='FLUX_ELNO',
                       )
 
      __chem=INTE_MAIL_2D(MAILLAGE=__nomapi,
@@ -327,7 +327,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD,
      __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
                              CHEMIN=__chem,
                              RESULTAT=__tempe1,
-                             NOM_CHAM='FLUX_ELNO_TEMP',
+                             NOM_CHAM='FLUX_ELNO',
                              TRAC_NOR='OUI',
                              NOM_CMP=('FLUX','FLUY'),
                              OPERATION='MOYENNE'))
@@ -352,7 +352,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD,
            __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
                                           CHEMIN=__chem,
                                           RESULTAT=__tempe1,
-                                          NOM_CHAM='FLUX_ELNO_TEMP',
+                                          NOM_CHAM='FLUX_ELNO',
                                           TRAC_NOR='OUI',
                                           NOM_CMP=('FLUX','FLUY'),
                                           OPERATION='MOYENNE'))
@@ -762,7 +762,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD,
         __tempe1=CALC_ELEM(reuse=__tempe1,
                             RESULTAT=__tempe1,
                             TOUT_ORDRE='OUI',
-                            OPTION='FLUX_ELNO_TEMP',
+                            OPTION='FLUX_ELNO',
                            )
 
         __chem=INTE_MAIL_2D(MAILLAGE=__nomapi,
@@ -772,7 +772,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD,
         __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
                                        CHEMIN=__chem,
                                        RESULTAT=__tempe1,
-                                       NOM_CHAM='FLUX_ELNO_TEMP',
+                                       NOM_CHAM='FLUX_ELNO',
                                        TRAC_NOR='OUI',
                                        NOM_CMP=('FLUX','FLUY'),
                                        OPERATION='MOYENNE'))
@@ -797,7 +797,7 @@ def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD,
               __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
                                              CHEMIN=__chem,
                                              RESULTAT=__tempe1,
-                                             NOM_CHAM='FLUX_ELNO_TEMP',
+                                             NOM_CHAM='FLUX_ELNO',
                                              TRAC_NOR='OUI',
                                              NOM_CMP=('FLUX','FLUY'),
                                              OPERATION='MOYENNE'))

diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py
index 3f81fc7964206c9e668753d6becc204690c4a59c..581e3dee8f3dad1c8e4767a064d43802bea60ec8 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macr_ecre_calc_ops Macro  DATE 21/04/2010   AUTEUR BOTTONI M.BOTTONI 
+#@ MODIF macr_ecre_calc_ops Macro  DATE 28/02/2011   AUTEUR BOTTONI M.BOTTONI 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -52,7 +52,8 @@ def macr_ecre_calc_ops(
 
 
   # PARAMETRES DEBUG
-  debug = True
+  debug = False
+  
 
 
 
@@ -554,6 +555,7 @@ Choix des correlations de frottement et de transfert de chaleur
 $V[70]       ifrot : frottement (avec : ifrot=1 ou -1 ; sans :  ifrot=0 )
 $V[71]       cas ifrot=-1 : relim = Re limite
 $V[72]       cas ifrot=-1 : frtlim = coeff frottement si Re > relim
+
 $V[73]       ichal : transfert de chaleur (-2 <= ichal <= 2  ichal=0 ==> Pas d'echange de chaleur)
 $V[74]       cas ichal < 0 : xminch = titre m. gaz avec corr. Chen ou liq pour x<xminch
 $V[75]       cas ichal < 0 : xmaxch = titre m. gaz avec corr. melange pour x>xmaxch

diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py
index d2c4d3595ccbd8907adb16e066fcf0bfb9fa7575..14a6f80bf07709388924088bad64cdbb5d7a7d7b 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macr_ecrevisse_ops Macro  DATE 12/07/2010   AUTEUR BERARD A.BERARD 
+#@ MODIF macr_ecrevisse_ops Macro  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -300,12 +300,12 @@ def macr_ecrevisse_ops(self,reuse,
                 CHAM_MATER = CHAM_MATER,
                 EXCIT      = _dEXCIT_THER,
                 INCREMENT  = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,),
-                ARCHIVAGE  = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
+                ARCHIVAGE  = _F(DETR_NUME_SUIV='OUI'),
                 INFO       = InfoAster,
                 **motclefs )
 
               RTHERMPJ=PROJ_CHAMP(RESULTAT=__THINIT, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
-                     METHODE='COLOCATION',
+                     METHODE='COLLOCATION',
                      VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
                      INFO=2,
                       )
@@ -316,14 +316,14 @@ def macr_ecrevisse_ops(self,reuse,
                CHAM_MATER = CHAM_MATER,
                EXCIT      = _dEXCIT_THER,
                INCREMENT  = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,),
-               ARCHIVAGE  = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
+               ARCHIVAGE  = _F(DETR_NUME_SUIV='OUI'),
                INFO       = InfoAster,
                **motclefs
                )
 
            # Projection du champ thermique, a tous les instants sinon pas de deformations thermiques
               RTHERMPJ=PROJ_CHAMP(RESULTAT=RTHERM, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
-                METHODE='COLOCATION',
+                METHODE='COLLOCATION',
                 VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
                 INFO=2,
                  )
@@ -408,7 +408,7 @@ def macr_ecrevisse_ops(self,reuse,
               NEWTON      = _F(**dNEWTON),
               CONVERGENCE = _F(**dCONVERGENCE),
               SOLVEUR     = _F(SYME='OUI'),
-              ARCHIVAGE   = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
+              ARCHIVAGE   = _F(DETR_NUME_SUIV='OUI'),
               INFO        = InfoAster,
               **motclefs
            )

diff --git a/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py
index 6c66718d91ee507c0e47bd996eb19504fbd65da0..ff38e2dd99baaaea367ab2d28fbacbe55491f6a4 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macr_lign_coupe_ops Macro  DATE 15/11/2010   AUTEUR PELLET J.PELLET 
+#@ MODIF macr_lign_coupe_ops Macro  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -133,7 +133,7 @@ def crea_resu_local(self,dime,NOM_CHAM,m,resin,mail,nomgrma):
        elif dime ==3 :
           LCMP=['DX','DY','DZ']
           TYPE_CHAM='VECT_3D'
-  elif NOM_CHAM in ('SIGM_NOEU_DEPL','SIEF_ELNO_ELGA','SIGM_NOEU_SIEF','SIGM_NOEU_ELGA','SIGM_NOEU_COQU','SIGM_ELNO_DEPL'):
+  elif NOM_CHAM in ('SIGM_NOEU','SIEF_ELNO','SIGM_NOEU_ELGA','SICO_NOEU','SIGM_ELNO'):
        if dime == 2:
           LCMP=['SIXX','SIYY','SIZZ','SIXY']
           TYPE_CHAM='TENS_2D'
@@ -815,7 +815,7 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE,
 
   if NOM_CHAM[5:9]=='ELGA' : UTMESS('F','POST0_18',valk=[NOM_CHAM,])
 
-  __recou=PROJ_CHAMP(METHODE='COLOCATION',
+  __recou=PROJ_CHAMP(METHODE='COLLOCATION',
                      RESULTAT=RESULTAT,
                      MODELE_1=MODELE_1,
                      DISTANCE_MAX=m['DISTANCE_MAX'],
@@ -831,7 +831,7 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE,
 
   if AsType(RESULTAT).__name__ in ('evol_elas','evol_noli') :
 
-   if  NOM_CHAM in ('DEPL','SIEF_ELNO_ELGA','SIGM_NOEU_DEPL','SIGM_NOEU_SIEF','SIGM_NOEU_ELGA','SIGM_NOEU_COQU','SIGM_ELNO_DEPL'):icham=1
+   if  NOM_CHAM in ('DEPL','SIEF_ELNO','SIGM_NOEU','SIGM_NOEU_ELGA','SICO_NOEU','SIGM_ELNO'):icham=1
    iocc=0
    for m in LIGN_COUPE :
 

diff --git a/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py
index 6d74951f49f19dae573cf45463bb123d3764e46d..7c5850d9cb8112fc55d74ab361d53c93c3bdf456 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macr_recal_ops Macro  DATE 16/11/2010   AUTEUR ASSIRE A.ASSIRE 
+#@ MODIF macr_recal_ops Macro  DATE 28/03/2011   AUTEUR ASSIRE A.ASSIRE 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -179,13 +179,15 @@ def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC,
    TOLE_FONC       = args['TOLE_FONC']
 
    # Pour les calculs esclaves
-   CALCUL_ESCLAVE  = {}.fromkeys( ['LANCEMENT', 'MODE', 'CLASSE', 'ACTUALISATION', 'memjeveux', 'memjob', 'mem_aster', 'tpmax', 'tpsjob', 'NMAX_SIMULT', ] )
+   CALCUL_ESCLAVE  = {}.fromkeys( ['LANCEMENT', 'MODE', 'UNITE_SUIVI', 'CLASSE', 'ACTUALISATION', 'memjeveux', 'memjob', 'mem_aster', 'tpmax', 'tpsjob', 'NMAX_SIMULT', ] )
 
    dESCLAVE=args['CALCUL_ESCLAVE'][0].cree_dict_valeurs(args['CALCUL_ESCLAVE'][0].mc_liste)
    for i in dESCLAVE.keys():
        if dESCLAVE[i]==None : del dESCLAVE[i]
 
    CALCUL_ESCLAVE['LANCEMENT']                                            = dESCLAVE['LANCEMENT']
+   if dESCLAVE.has_key('UNITE_SUIVI'):   CALCUL_ESCLAVE['UNITE_SUIVI']    = dESCLAVE['UNITE_SUIVI']
+   else:                                 CALCUL_ESCLAVE['UNITE_SUIVI']    = None
    if dESCLAVE.has_key('MODE'):          CALCUL_ESCLAVE['MODE']           = dESCLAVE['MODE']
    else:                                 CALCUL_ESCLAVE['MODE']           = prof['mode'][0].upper()
 
@@ -231,11 +233,12 @@ def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC,
 
    if LANCEMENT == 'DISTRIBUTION':
 
-       print prof.param['tpsjob'][0]
-       print prof.args['tpmax']
-       print prof.param['mem_aster'][0]
-       print prof.args['memjeveux']
-       print prof.param['memjob'][0]
+       if debug:
+           print prof.param['tpsjob'][0]
+           print prof.args['tpmax']
+           print prof.param['mem_aster'][0]
+           print prof.args['memjeveux']
+           print prof.param['memjob'][0]
 
        # Pour la conversion mega-mots / mega-octets
        from asrun.common.sysutils import on_64bits
@@ -366,6 +369,8 @@ def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC,
    CALCUL_ASTER.RESU_CALC = RESU_CALC
    CALCUL_ASTER.LIST_PARA = LIST_PARA
 
+   if CALCUL_ESCLAVE['UNITE_SUIVI']: CALCUL_ASTER.unity_follow = CALCUL_ESCLAVE['UNITE_SUIVI']
+
 
    # Instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim
    Dim                    = reca_algo.Dimension(copy.copy(val_init))

diff --git a/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py b/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py
index 6e05cae277be284087db4646e353c10960b5ad34..719b42d848cd9fbe0b9f64db8785736d747c78ab 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macro_elas_mult_ops Macro  DATE 23/03/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF macro_elas_mult_ops Macro  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -219,8 +219,8 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL,
            liste_option=m['OPTION']
         for option in liste_option :
            if option in (     'FORC_NODA','REAC_NODA',
-                              'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL',
-                              'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI',):
+                              'EPSI_NOEU','SIGM_NOEU','EFGE_NOEU',
+                              'SIEQ_NOEU','EPEQ_NOEU',):
               nbno=nbno+1
               liste_no.append(option)
            else:

diff --git a/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py
index 17004981407de9613cf861b3b67e313f528f8c0f..63b4dd73edf9b8121f18ac95215c4c3096a107e2 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macro_expans_ops Macro  DATE 12/07/2010   AUTEUR BERARD A.BERARD 
+#@ MODIF macro_expans_ops Macro  DATE 14/12/2010   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -30,7 +30,7 @@ def macro_expans_ops( self,
                       MODES_NUM=None,
                       MODES_EXP=None,
                       RESOLUTION=None,
-                      *args
+                      **args
                      ):
     """!macro MACRO_EXPANS """
     from Accas import _F
@@ -47,6 +47,13 @@ def macro_expans_ops( self,
     NORM_MODE = self.get_cmd('NORM_MODE')
 
 
+    RESU_NUM = MODELE_CALCUL['BASE']
+    RESU_EXP = MODELE_MESURE['MESURE']
+    MOD_CALCUL = MODELE_CALCUL['MODELE']
+    MOD_MESURE = MODELE_MESURE['MODELE']
+    NOM_CHAM = MODELE_MESURE['NOM_CHAM']
+
+
     # La macro compte pour 1 dans la numerotation des commandes
     self.set_icmd(1)
 
@@ -56,20 +63,18 @@ def macro_expans_ops( self,
         is_nume_num = 1
     else:
         if RESU_NX:
-            UTMESS('A','MEIDEE0_6',valk=['MODELE_MESURE','RESU_EX'])
+            UTMESS('A','CALCESSAI0_6',valk=['MODELE_MESURE','RESU_EX'])
+
     if MODELE_MESURE['NUME_MODE'] or  MODELE_MESURE['NUME_ORDRE']:
         # On cree un RESU_EX par extraction de NUME_ORDREs
         is_nume_exp = 1
+        if isinstance(RESU_NUM,dyna_harmo):
+            # on ne peut pas faire de EXTR_MODE  sur un DYNA_HARMO
+            is_nume_exp = 0
+            UTMESS('A','CALCESSAI0_13')
     else:
-        if RESU_EX: UTMESS('A','MEIDEE0_6',valk=['MODELE_CALCUL','RESU_NX'])
+        if RESU_EX: UTMESS('A','CALCESSAI0_6',valk=['MODELE_CALCUL','RESU_NX'])
 
-    RESU_NUM = MODELE_CALCUL['BASE']
-    RESU_EXP = MODELE_MESURE['MESURE']
-
-    MOD_CALCUL = MODELE_CALCUL['MODELE']
-    MOD_MESURE = MODELE_MESURE['MODELE']
-
-    NOM_CHAM = MODELE_MESURE['NOM_CHAM']
 
     # Extraction des modes numériques
     # -------------------------------
@@ -133,7 +138,7 @@ def macro_expans_ops( self,
     else:
         paras = None
         #"LE MODELE MEDURE DOIT ETRE UN CONCEPT DE TYPE DYNA_HARMO OU MODE_MECA")
-        UTMESS('A','MEIDEE0_1')
+        UTMESS('A','CALCESSAI0_1')
 
 
     try:
@@ -167,15 +172,16 @@ def macro_expans_ops( self,
         self.DeclareOut( "RESU_RD", RESU_RD )
 
     nume=None
-    if resu_ex.REFD.get():
-        tmp = resu_ex.REFD.get()[3]
-        if tmp.strip() :
-            nume = self.get_concept(tmp)
-    elif NUME_DDL:
+    if NUME_DDL:
         nume = NUME_DDL
     if not nume :
-        UTMESS('A','MEIDEE0_5')
-    RESU_RD = PROJ_CHAMP( METHODE    = 'COLOCATION',
+        if resu_ex.REFD.get():
+            tmp = resu_ex.REFD.get()[3]
+            if tmp.strip() :
+                nume = self.get_concept(tmp)
+        else:
+            UTMESS('A','CALCESSAI0_5')
+    RESU_RD = PROJ_CHAMP( METHODE    = 'COLLOCATION',
                           RESULTAT   = RESU_ET,
                           MODELE_1   = MOD_CALCUL,
                           MODELE_2   = MOD_MESURE,

diff --git a/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py
index 30984e882c148b167c0e31266fdb047b3cdc9cc2..91da1619f625a47bf05290f1576bad8e74383a60 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF macro_miss_3d_ops Macro  DATE 30/08/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF macro_miss_3d_ops Macro  DATE 14/03/2011   AUTEUR COURTOIS M.COURTOIS 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -74,7 +74,17 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS,
       MODUL2='MISS_PTAS'
   elif OPTION['MODULE']=='PRE_MISS':
       MODUL2='GTASTER'
-      
+
+  alarm16 = False
+  typ15 = 'A'
+  if OPTION['MODULE'] == 'MISS_IMPE' \
+     and PARAMETRE != None and PARAMETRE['ISSF'] == 'NON':
+         alarm16 = True
+         typ15 = 'A+'
+
+  UTMESS(typ15, 'MISS0_15')
+  if alarm16:
+     UTMESS('A', 'MISS0_16')
 
   ETUDE = PROJET
   BASE  = REPERTOIRE

diff --git a/Aster/Cata/cataSTA10/Macro/observation_ops.py b/Aster/Cata/cataSTA10/Macro/observation_ops.py
index 8ab6065981cf4cca29ba8b84acb87546f9bdb4ba..cc924ff9f2e344687c85332d89c31222283781d5 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/observation_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/observation_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF observation_ops Macro  DATE 12/07/2010   AUTEUR BERARD A.BERARD 
+#@ MODIF observation_ops Macro  DATE 13/01/2011   AUTEUR PELLET J.PELLET 
 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -19,15 +19,15 @@
 # ======================================================================
 
 
-
-
+# RESPONSABLE BODEL C.BODEL
 
 def observation_ops(self,
                     PROJECTION   = None,
                     MODELE_1     = None,
                     MODELE_2     = None,
                     RESULTAT     = None,
-                    NUME_DDL     = None,
+                    MATR_A       = None,
+                    MATR_B       = None,
                     MODI_REPERE  = None,
                     NOM_CHAM     = None,
                     FILTRE       = None,
@@ -50,9 +50,7 @@ def observation_ops(self,
     # importation de commandes
     import aster
     from Accas import _F
-    from Utilitai.UniteAster import UniteAster
     from Utilitai.Utmess     import UTMESS
-    from Utilitai.Table      import Table
     from Cata.cata import mode_meca, dyna_harmo, evol_elas,dyna_trans
     MODI_REPERE = self.get_cmd('MODI_REPERE')
     PROJ_CHAMP  = self.get_cmd('PROJ_CHAMP')
@@ -65,18 +63,11 @@ def observation_ops(self,
     # ne sert pas par la suite
     mcfact = args
 
-    if NOM_CHAM == 'DEPL':
-      if isinstance( RESULTAT, dyna_harmo):
-        TYPE_CHAM = 'NOEU_DEPL_C'
-      else:
-        TYPE_CHAM = 'NOEU_DEPL_R'
-    elif NOM_CHAM == 'EPSI_NOEU_DEPL':
-      if isinstance( RESULTAT, dyna_harmo):
-        TYPE_CHAM  = 'NOEU_EPSI_C'
-      else:
-        TYPE_CHAM  = 'NOEU_EPSI_R'
-    else:
-        UTMESS('F','ELEMENTS4_48',valk=[NOM_CHAM])
+    if not isinstance(NOM_CHAM,tuple):
+        NOM_CHAM = [NOM_CHAM]
+
+    TYPE_CHAM = None
+    RESU = None
 
     if isinstance( RESULTAT, evol_elas): TYPE_RESU='EVOL_ELAS'
     if isinstance( RESULTAT, dyna_trans): TYPE_RESU='DYNA_TRANS'
@@ -84,7 +75,6 @@ def observation_ops(self,
     if isinstance( RESULTAT, mode_meca): TYPE_RESU='MODE_MECA'
 
     self.DeclareOut( 'RESU', self.sd)
-    jdc = CONTEXT.get_current_step().jdc
 
     # recuperation du maillage associe au modele numerique
     _maillag = aster.getvectjev( MODELE_1.nom.ljust(8) + '.MODELE    .LGRF' )
@@ -123,34 +113,48 @@ def observation_ops(self,
 
     # afreq pour les frequences propres
     if isinstance( RESULTAT, mode_meca):
+        # frequences propres
         from Cata.cata import RECU_TABLE
         __freq  = RECU_TABLE(CO=RESULTAT,
                              NOM_PARA='FREQ',);
         afreq  = __freq.EXTR_TABLE().Array('NUME_ORDRE','FREQ')
+        # noms des matrices
+        if MATR_A !=None or MATR_B !=None:
+            # recherche du nume_ddl associe
+            iret,ibid,nom_nume_ddl = aster.dismoi('F','NOM_NUME_DDL',MATR_A.nom,'MATR_ASSE')
+            NUME_DDL = self.get_concept(nom_nume_ddl)
+            # coherence avec le nom associe a MODELE_2 :
+            iret,ibid,nom_modele = aster.dismoi('F','NOM_MODELE',nom_nume_ddl,'NUME_DDL')
+            if nom_modele.strip() != MODELE_2.nom.strip():
+                UTMESS('F','CALCESSAI0_10')
+        else:
+            UTMESS('A','CALCESSAI0_9')
+            NUME_DDL = None
+
     else:
         afreq = None
+        NUME_DDL = None
 
-    nume_ordr_demande = mcfact['NUME_ORDRE']
-    if type(nume_ordr_demande) != tuple :
-        nume_ordr_demande = [nume_ordr_demande]
-
-    num_max = len(RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE'])
+    indice = range(len(RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']))
 
 #***********************************************
 #  PHASE DE CALCUL DE LA DEFORMATION MOYENNE AUX NOEUDS
 #  CHAMP CALCULE SUR LE MODELE NUMERIQUE
 #***********************************************
 
+    resu_epsi = None
     if EPSI_MOYENNE != None :
+      for nomcham in NOM_CHAM:
+        if nomcham == 'EPSI_NOEU':
+          if isinstance( RESULTAT, dyna_harmo):
+            TYPE_CHAM  = 'NOEU_EPSI_C'
+          else:
+            TYPE_CHAM  = 'NOEU_EPSI_R'
 
-      if NOM_CHAM != 'EPSI_NOEU_DEPL':
-            __proj= RESULTAT
-            UTMESS('F','UTILITAI8_24',valk=['NOEU_EPSI',NOM_CHAM])
+      if TYPE_CHAM == None:
+            UTMESS('F', 'UTILITAI8_24', valk = ['NOEU_EPSI', nomcham])
       else:
-        if nume_ordr_demande[0]:
-            num_ordr = nume_ordr_demande
-        else:
-            num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']
+        num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']
 
         if isinstance( RESULTAT, evol_elas):
             list_inst = RESULTAT.LIST_VARI_ACCES()['INST']
@@ -202,34 +206,34 @@ def observation_ops(self,
 
             if TYPE_CHAM[-1:] == 'C':
               mcfactr = { 'NOM_CMP'   : nom_cmps,
-                         'OPERATION' : 'EXTRACTION',
-                         'INTITULE' : str('R'+str(nb_mcfact)),
-                         'FORMAT_C' : 'REEL',
-                         'NOEUD' : l_noeud,
-                        'NOM_CHAM'  : 'EPSI_NOEU_DEPL',
-                        'RESULTAT'  : RESULTAT,
-                        'NUME_ORDRE'  : num_ordr,
-                       }
+                          'OPERATION' : 'EXTRACTION',
+                          'INTITULE' : str('R'+str(nb_mcfact)),
+                          'FORMAT_C' : 'REEL',
+                          'NOEUD' : l_noeud,
+                          'NOM_CHAM'  : 'EPSI_NOEU',
+                          'RESULTAT'  : RESULTAT,
+                          'NUME_ORDRE'  : num_ordr,
+                        }
               argsi['ACTION'].append(mcfactr)
               mcfacti = { 'NOM_CMP'   : nom_cmps,
-                         'OPERATION' : 'EXTRACTION',
-                         'INTITULE' : str('I'+str(nb_mcfact)),
-                         'FORMAT_C' : 'IMAG',
-                         'NOEUD' : l_noeud,
-                        'NOM_CHAM'  : 'EPSI_NOEU_DEPL',
-                        'RESULTAT'  : RESULTAT,
-                        'NUME_ORDRE'  : num_ordr,
-                       }
+                          'OPERATION' : 'EXTRACTION',
+                          'INTITULE' : str('I'+str(nb_mcfact)),
+                          'FORMAT_C' : 'IMAG',
+                          'NOEUD' : l_noeud,
+                          'NOM_CHAM'  : 'EPSI_NOEU',
+                          'RESULTAT'  : RESULTAT,
+                          'NUME_ORDRE'  : num_ordr,
+                         }
               argsi['ACTION'].append(mcfacti)
             else:
               mcfactr = { 'NOM_CMP'   : nom_cmps,
-                         'OPERATION' : 'EXTRACTION',
-                         'INTITULE' : str(nb_mcfact),
-                         'NOEUD' : l_noeud,
-                        'NOM_CHAM'  : 'EPSI_NOEU_DEPL',
-                        'RESULTAT'  : RESULTAT,
-                        'NUME_ORDRE'  : num_ordr,
-                       }
+                          'OPERATION' : 'EXTRACTION',
+                          'INTITULE' : str(nb_mcfact),
+                          'NOEUD' : l_noeud,
+                          'NOM_CHAM'  : 'EPSI_NOEU',
+                          'RESULTAT'  : RESULTAT,
+                          'NUME_ORDRE'  : num_ordr,
+                         }
               argsi['ACTION'].append(mcfactr)
 
         _tepsi=POST_RELEVE_T(
@@ -240,8 +244,8 @@ def observation_ops(self,
         DETRUIRE( CONCEPT= _F( NOM = _tepsi ), INFO=1)
 
         mcfact2 = { }
-        __chame = [None]*num_max
-        for ind in num_ordr:
+        __chame = [None]*len(indice)
+        for ind in indice:
          argsa = {'AFFE' : [], }
          for mcfacta in range(nb_mcfact):
           l_noeud_mcfact = lnoeuds[str(mcfacta+1)]
@@ -259,17 +263,17 @@ def observation_ops(self,
            for row in table.rows:
             if TYPE_CHAM[-1:] == 'C':
              if row['INTITULE'].strip() == str('R'+str(mcfacta+1))   \
-                      and row['NUME_ORDRE'] == ind :
+                      and row['NUME_ORDRE'] == num_ordr[ind] :
                 l_valr.append(row[cmp])
                 lur = 1
              elif row['INTITULE'].strip() == str('I'+str(mcfacta+1))   \
-                      and row['NUME_ORDRE'] == ind :
+                      and row['NUME_ORDRE'] == num_ordr[ind] :
                 l_vali.append(row[cmp])
                 lui = 1
-                  
+
             else:
              if row['INTITULE'].strip() == str(mcfacta+1)   \
-                      and row['NUME_ORDRE'] == ind: 
+                      and row['NUME_ORDRE'] == num_ordr[ind]:
                   l_val.append(row[cmp])
 
            if TYPE_CHAM[-1:] == 'C':
@@ -288,8 +292,8 @@ def observation_ops(self,
              vmoyer = sum(l_valr)/len(l_valr)
              vmoyei = sum(l_vali)/len(l_vali)
              vmoye = sum(l_valc)/len(l_valc)
-             vminr = min(l_valr)  
-             vmini = min(l_vali)  
+             vminr = min(l_valr)
+             vmini = min(l_vali)
              vmaxr = max(l_valr)
              vmaxi = max(l_vali)
              if vmoyer > 0:
@@ -324,10 +328,10 @@ def observation_ops(self,
              if cmp_vari not in masque_mc:
               if cmp == cmp_vari and not vu:
                 if EPSI_MOYENNE[mcfacta]['MAILLE'] != None:
-                  entite = str('MAILLE : '+str(PSI_MOYENNE[mcfacta]['MAILLE']))
+                  entite = str('MAILLE : '+str(EPSI_MOYENNE[mcfacta]['MAILLE']))
                 if EPSI_MOYENNE[mcfacta]['GROUP_MA'] != None:
                   entite = str('GROUP_MA : '+str(EPSI_MOYENNE[mcfacta]['GROUP_MA']))
-                UTMESS('A','OBSERVATION_8',vali=[ind],valr=[seuil_mc],valk=[entite,cmp])
+                UTMESS('A','OBSERVATION_8',vali=[num_ordr[ind]],valr=[seuil_mc],valk=[entite,cmp])
                 vu = 1
 
 
@@ -344,38 +348,38 @@ def observation_ops(self,
 
           argsa['AFFE'].append(mcfactc)
 
-         __chame[ind-1] = CREA_CHAMP( OPERATION  = 'AFFE',
+         __chame[ind] = CREA_CHAMP( OPERATION  = 'AFFE',
                           MODELE = MODELE_1,
                           PROL_ZERO = 'OUI',
-                          TYPE_CHAM  = TYPE_CHAM, 
-                          OPTION   = NOM_CHAM,
+                          TYPE_CHAM  = TYPE_CHAM,
+                          OPTION   = 'EPSI_NOEU',
                           **argsa
                           );
 
          if isinstance( RESULTAT, mode_meca):
-                  mcfact2 = {'CHAM_GD'    : __chame[ind-1],
+                  mcfact2 = {'CHAM_GD'    : __chame[ind],
                        'MODELE'     : MODELE_1,
-                       'NUME_MODE'    : int(afreq[ind-1,0]),
-                       'FREQ'    : afreq[ind-1,1],
+                       'NUME_MODE'    : int(afreq[ind,0]),
+                       'FREQ'    : afreq[ind,1],
                        }
 
          if isinstance( RESULTAT, evol_elas):
-                    mcfact2 = {'CHAM_GD'    : __chame[ind-1],
+                    mcfact2 = {'CHAM_GD'    : __chame[ind],
                        'MODELE'     : MODELE_1,
-                       'INST'    : list_inst[ind-1],
+                       'INST'    : list_inst[ind],
                        }
 
          if isinstance( RESULTAT, dyna_trans):
-                    mcfact2 = {'CHAM_GD'    : __chame[ind-1],
+                    mcfact2 = {'CHAM_GD'    : __chame[ind],
                        'MODELE'     : MODELE_1,
                        'INST'    : list_inst[ind],
                        }
 
          if isinstance( RESULTAT, dyna_harmo):
-                mcfact2 = {'CHAM_GD'    : __chame[ind-1],
-                       'MODELE'     : MODELE_1,
-                       'FREQ'    : list_freq[ind-1],
-                       }
+                mcfact2 = {'CHAM_GD'    : __chame[ind],
+                           'MODELE'     : MODELE_1,
+                           'FREQ'    : list_freq[ind],
+                          }
 
          if cham_mater is not None:
                     mcfact2['CHAM_MATER'] = cham_mater
@@ -384,33 +388,62 @@ def observation_ops(self,
 
          liste.append(mcfact2)
 
-        __proj = CREA_RESU(
+        resu_epsi = 'EPSI_NOEU'
+        RESU = CREA_RESU(
                               OPERATION = 'AFFE',
                               TYPE_RESU = TYPE_RESU,
-                              NOM_CHAM  = NOM_CHAM,
+                              NOM_CHAM  = 'EPSI_NOEU',
                               AFFE      = liste,
                              );
-    else:
-        __proj= RESULTAT
 
 
+#***********************************************
+#  BOUCLE SUR LES NOM_CHAM
+#***********************************************
+
+    for nomcham in NOM_CHAM:
+
+     if nomcham == 'DEPL' or nomcham == 'VITE' or nomcham == 'ACCE':
+             if isinstance( RESULTAT, dyna_harmo):
+                  TYPE_CHAM = 'NOEU_DEPL_C'
+             else:
+                  TYPE_CHAM = 'NOEU_DEPL_R'
+     elif nomcham == 'EPSI_NOEU':
+             if isinstance( RESULTAT, dyna_harmo):
+               TYPE_CHAM  = 'NOEU_EPSI_C'
+             else:
+               TYPE_CHAM  = 'NOEU_EPSI_R'
+     else:
+               UTMESS('F', 'ELEMENTS4_48', valk = [nomcham])
+
 #***********************************************
 #  PHASE DE PROJECTION
 #***********************************************
 
-    if PROJECTION == 'OUI':
-        __proj=PROJ_CHAMP(METHODE='COLOCATION',
-                          RESULTAT = __proj,
+     if PROJECTION == 'OUI':
+      if resu_epsi and nomcham == 'EPSI_NOEU':
+        __proj = PROJ_CHAMP(METHODE='COLLOCATION',
+                          RESULTAT = RESU,
                           MODELE_1 = MODELE_1,
                           MODELE_2 = MODELE_2,
-                          NUME_DDL = NUME_DDL,
-                          NOM_CHAM = NOM_CHAM,
+                          NOM_CHAM = nomcham,
                           **mcfact
-                         );
-
-        modele = MODELE_2
-    else:
-        modele = MODELE_1
+                         )
+      else:
+        __proj = PROJ_CHAMP(METHODE = 'COLLOCATION',
+                          RESULTAT = RESULTAT,
+                          MODELE_1 = MODELE_1,
+                          MODELE_2 = MODELE_2,
+                          NOM_CHAM = nomcham,
+                          **mcfact
+                         )
+      modele = MODELE_2
+     else:
+      if resu_epsi and nomcham == 'EPSI_NOEU':
+        __proj = RESU
+      else:
+        __proj = RESULTAT
+      modele = MODELE_1
 
 
 #***********************************************
@@ -433,26 +466,27 @@ def observation_ops(self,
 #                    )
 
 
-    if MODIF_REPERE != None :
-        if nume_ordr_demande[0]:
-            num_ordr = nume_ordr_demande
-        else:
-            num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE']
+     if MODIF_REPERE != None :
+        num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE']
 
         for modif_rep in MODIF_REPERE :
-            type_cham = modif_rep['TYPE_CHAM']
-            if type_cham == 'TENS_2D':
-                nom_cmp = ['EPXX','EPYY','EPZZ','EPXY',]
-            elif type_cham == 'TENS_3D':
-                nom_cmp = ['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ',]
-            else:
-                nom_cmp = modif_rep['NOM_CMP']
+          modi_rep = modif_rep.val
+          type_cham = modif_rep['TYPE_CHAM']
+          nom_cmp = modif_rep['NOM_CMP']
+
+          if type_cham == 'TENS_2D':
+                nomchamx = 'EPSI_NOEU'
+          elif type_cham == 'TENS_3D':
+                nomchamx = 'EPSI_NOEU'
+          else:
+                nomchamx = 'DEPL'
+
+          if nomcham == nomchamx:
             mcfact1 = { 'NOM_CMP'   : nom_cmp,
                         'TYPE_CHAM' : type_cham,
-                        'NOM_CHAM'  : NOM_CHAM }
+                        'NOM_CHAM'  : nomcham }
 
             mcfact2 = { }
-            modi_rep = modif_rep.val
 
             if modi_rep['REPERE'] == 'DIR_JAUGE' :
                 vect_x = None
@@ -463,7 +497,6 @@ def observation_ops(self,
                     vect_y = modi_rep['VECT_Y']
 
                 # il faut des mailles pour les tenseurs d'ordre 2
-                taille = 0
                 for typ in ['MAILLE','GROUP_MA',]:
                   if modi_rep.has_key(typ) :
                     if PROJECTION == 'OUI':
@@ -471,7 +504,6 @@ def observation_ops(self,
                     else:
                       maya = mayanum
                     list_ma = find_ma(maya, {typ : modi_rep[typ]})
-                taille = len(list_ma)
 
                 mcfact1.update({ 'MAILLE'    : list_ma })
                 angl_naut = crea_repere_xy(vect_x, vect_y)
@@ -479,12 +511,14 @@ def observation_ops(self,
                 mcfact2.update({ 'REPERE'    : 'UTILISATEUR',
                                  'ANGL_NAUT' : angl_naut })
 
-                args = {'MODI_CHAM'   : mcfact1,
+                argsm = {'MODI_CHAM'   : mcfact1,
                         'DEFI_REPERE' : mcfact2 }
 
-                __proj = MODI_REPERE( RESULTAT    = __proj,
-                                      NUME_ORDRE  = num_ordr, 
-                                      **args)
+                __bidon = MODI_REPERE( RESULTAT    = __proj,
+                                      NUME_ORDRE  = num_ordr,
+                                      **argsm)
+                DETRUIRE( CONCEPT= _F( NOM = __proj ), INFO=1)
+                __proj = __bidon
 
             if modi_rep['REPERE'] == 'NORMALE' :
                 # Cas ou l'utilisateur choisit de creer les reperes locaux
@@ -497,7 +531,7 @@ def observation_ops(self,
                     UTMESS('E','UTILITAI7_9')
 
                 chnorm = crea_normale(self, MODELE_1, MODELE_2, NUME_DDL,
-                                                      cham_mater, cara_elem)
+                                      cham_mater, cara_elem)
                 modele = MODELE_2
                 chnormx = chnorm.EXTR_COMP('DX',[],1)
                 ind_noeuds = chnormx.noeud
@@ -520,12 +554,12 @@ def observation_ops(self,
                     mcfact1.update({ 'NOEUD'     : nomnoe })
                     mcfact2.update({ 'REPERE'    : 'UTILISATEUR',
                                      'ANGL_NAUT' : angl_naut})
-                    args = {'MODI_CHAM'   : mcfact1,
+                    argsm = {'MODI_CHAM'   : mcfact1,
                             'DEFI_REPERE' : mcfact2 }
                     __bid[k+1] = MODI_REPERE( RESULTAT    = __bid[k],
                                               TOUT_ORDRE  = 'OUI',
                                               CRITERE     = 'RELATIF',
-                                              **args)
+                                              **argsm)
                     k = k + 1
 
                 __proj = __bid[-1:][0]
@@ -554,12 +588,12 @@ def observation_ops(self,
                     mcfact2.update({ 'REPERE'    : 'UTILISATEUR',
                                      'ANGL_NAUT' : angl_naut })
 
-              args = {'MODI_CHAM'   : mcfact1,
-                        'DEFI_REPERE' : mcfact2 }
+              argsm = {'MODI_CHAM'   : mcfact1,
+                      'DEFI_REPERE' : mcfact2 }
 
               __bidon = MODI_REPERE( RESULTAT    = __proj,
                                      CRITERE     = 'RELATIF',
-                                     **args)
+                                     **argsm)
               DETRUIRE( CONCEPT= _F( NOM = __proj ), INFO=1)
               __proj = __bidon
 
@@ -568,199 +602,157 @@ def observation_ops(self,
 # Phase de selection des DDL de mesure
 #*************************************************
 
-    if FILTRE != None:
-        if nume_ordr_demande[0]:
-            num_ordr = nume_ordr_demande
-        else:
-            num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE']
+     resu_filtre = None
+     if FILTRE != None:
+         num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE']
 
-        __chamf = [None]*num_max
-        if isinstance( RESULTAT, evol_elas):
-            list_inst_ini = RESULTAT.LIST_VARI_ACCES()['INST']
-        if isinstance( RESULTAT, dyna_trans):
-            list_inst_ini = RESULTAT.LIST_VARI_ACCES()['INST']
-        if isinstance( RESULTAT, dyna_harmo):
-            list_freq_ini = RESULTAT.LIST_VARI_ACCES()['FREQ']
+         __chamf = [None]*len(indice)
+         if isinstance( RESULTAT, evol_elas):
+            list_inst = __proj.LIST_VARI_ACCES()['INST']
+         if isinstance( RESULTAT, dyna_trans):
+            list_inst = __proj.LIST_VARI_ACCES()['INST']
+         if isinstance( RESULTAT, dyna_harmo):
+            list_freq = __proj.LIST_VARI_ACCES()['FREQ']
 
-        liste = []
 
-        for ind in num_ordr:
-            mcfact2 = { }
-            filtres = []
-            __chamex = CREA_CHAMP(TYPE_CHAM  = TYPE_CHAM,
+         liste = []
+
+         for ind in indice:
+             mcfact2 = { }
+             filtres = []
+             __chamex = CREA_CHAMP(TYPE_CHAM  = TYPE_CHAM,
                                   OPERATION  = 'EXTR',
                                   RESULTAT   = __proj,
-                                  NOM_CHAM   = NOM_CHAM,
-                                  NUME_ORDRE = ind,);
+                                  NOM_CHAM   = nomcham,
+                                  NUME_ORDRE = num_ordr[ind],);
+
+             for mcfiltre in FILTRE :
+              filtre = mcfiltre.val
+              try:
+                nomchamx = filtre['NOM_CHAM']
+              except KeyError:
+                nomchamx = None
+
+              if nomchamx == None or nomchamx == nomcham:
 
-            for mcfiltre in FILTRE :
                 mcfact1 = {}
-                filtre = mcfiltre.val
-                for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA']:
+
+                atraiter = None
+                if filtre['DDL_ACTIF'][0][0] == 'E' and nomcham == 'EPSI_NOEU':
+                   atraiter = nomcham
+                elif filtre['DDL_ACTIF'][0][0] == 'D' and nomcham == 'DEPL':
+                   atraiter = nomcham
+                elif filtre['DDL_ACTIF'][0][0] == 'D' and nomcham == 'VITE':
+                   atraiter = nomcham
+                elif filtre['DDL_ACTIF'][0][0] == 'D' and nomcham == 'ACCE':
+                   atraiter = nomcham
+
+                if atraiter:
+                 for typ in ['NOEUD', 'GROUP_NO', 'MAILLE', 'GROUP_MA']:
                     if filtre.has_key(typ) :
                         mcfact1.update({typ : filtre[typ]})
-                mcfact1.update({'NOM_CMP' : filtre['DDL_ACTIF'],
+                 mcfact1.update({'NOM_CMP' : filtre['DDL_ACTIF'],
                                 'CHAM_GD' : __chamex })
-                filtres.append(mcfact1)
+                 filtres.append(mcfact1)
 
-            if NOM_CHAM == 'DEPL':
-                __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM,
+             if len(filtres) > 0:
+              if nomcham == 'DEPL' or nomcham == 'VITE' or nomcham == 'ACCE':
+                __chamf[ind] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM,
                                        OPERATION = 'ASSE',
                                        MODELE    = modele,
                                        ASSE      = filtres
                                        );
 
-            elif NOM_CHAM == 'EPSI_NOEU_DEPL':
-                __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM,
+              elif nomcham == 'EPSI_NOEU':
+                __chamf[ind] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM,
                                        OPERATION = 'ASSE',
                                        PROL_ZERO = 'OUI',
                                        MODELE    = modele,
                                        ASSE      = filtres,
                                        );
-
-            else:
+              else:
                 valk = []
-                valk.append(NOM_CHAM)
-                valk.append('DEPL')
-                valk.append('EPSI_NOEU_DEPL')
-                UTMESS('F','OBSERVATION_6',valk) 
-
-            if isinstance( RESULTAT, mode_meca):
-                mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
-                       'MODELE'     : modele,
-                       'NUME_MODE'    : int(afreq[ind-1,0]),
-                       'FREQ'    : afreq[ind-1,1],
+                valk.append(nomcham)
+                valk.append('DEPL VITE ACCE')
+                valk.append('EPSI_NOEU')
+                UTMESS('F','OBSERVATION_6',valk)
+
+              argsr = {}
+              if isinstance( RESULTAT, mode_meca):
+                mcfact2 = {'CHAM_GD' : __chamf[ind],
+                       'MODELE'      : modele,
+                       'NUME_MODE'   : int(afreq[ind,0]),
+                       'FREQ'        : afreq[ind,1],
                        }
-
-            if isinstance( RESULTAT, evol_elas):
-                mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
+            ## on recopie les matrices associees au MODELE_2 dans le resultat final
+            ## NB : ce n'est peut-etre pas propre, car ces matrices ne
+            ## veulent plus rien dire si on a filtre des DDL !!!!!
+                argsr = { 'MATR_A' : MATR_A,
+                         'MATR_B' : MATR_B
+                        }
+
+              if isinstance( RESULTAT, evol_elas):
+                mcfact2 = {'CHAM_GD'    : __chamf[ind],
                        'MODELE'     : modele,
-                       'INST'    : list_inst_ini[ind-1],
+                       'INST'    : list_inst[ind],
                        }
 
-            if isinstance( RESULTAT, dyna_trans):
-                mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
+              if isinstance( RESULTAT, dyna_trans):
+                mcfact2 = {'CHAM_GD'    : __chamf[ind],
                        'MODELE'     : modele,
-                       'INST'    : list_inst_ini[ind-1],
+                       'INST'    : list_inst[ind],
                        }
 
-            if isinstance( RESULTAT, dyna_harmo):
-                mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
+              if isinstance( RESULTAT, dyna_harmo):
+                mcfact2 = {'CHAM_GD'    : __chamf[ind],
                        'MODELE'     : MODELE_2,
-                       'FREQ'    : list_freq_ini[ind-1],
+                       'FREQ'    : list_freq[ind],
                        }
 
-
-            if cham_mater is not None:
+              if cham_mater is not None:
                 mcfact2['CHAM_MATER'] = cham_mater
-            if cara_elem is not None:
+              if cara_elem is not None:
                 mcfact2['CARA_ELEM'] = cara_elem
 
-            liste.append(mcfact2)
-            DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1)
+              liste.append(mcfact2)
+
+             DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1)
 
-        __proj = CREA_RESU(
+         if len(filtres) > 0 and len(liste) > 0:
+            resu_filtre = nomcham
+            if RESU:
+             RESU = CREA_RESU( reuse = RESU,
                               OPERATION = 'AFFE',
                               TYPE_RESU = TYPE_RESU,
-                              NOM_CHAM  = NOM_CHAM,
+                              NOM_CHAM  = nomcham,
                               AFFE      = liste,
+                              **argsr
                              );
+            else:
+             RESU = CREA_RESU(
+                              OPERATION = 'AFFE',
+                              TYPE_RESU = TYPE_RESU,
+                              NOM_CHAM  = nomcham,
+                              AFFE      = liste,
+                              **argsr
+                             )
+
 
 #*************************************************
-# Recopie des resultats (__proj) dans RESU
+# Recopie de __proj dans RESU si celle-ci
+# n'a pas encore ete faite via FILTRE
 #*************************************************
 
-    if nume_ordr_demande[0]:
-        num_ordr = nume_ordr_demande
-    else:
-        num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE']
-
-    __chamf = [None]*num_max
-    if isinstance( RESULTAT, evol_elas):
-        list_inst = __proj.LIST_VARI_ACCES()['INST']
-    if isinstance( RESULTAT, dyna_trans):
-        list_inst = __proj.LIST_VARI_ACCES()['INST']
-    if isinstance( RESULTAT, dyna_harmo):
-        list_freq = __proj.LIST_VARI_ACCES()['FREQ']
-
-    liste = []
-
-    for ind in num_ordr:
-        mcfact2 = { }
-        filtres = []
-        __chamex = CREA_CHAMP(TYPE_CHAM  = TYPE_CHAM,
-                              OPERATION  = 'EXTR',
-                              RESULTAT   = __proj,
-                              NOM_CHAM   = NOM_CHAM,
-                              NUME_ORDRE = ind,);
-
-        mcfact1 = {}
-        mcfact1.update({'TOUT' : 'OUI',
-                        'CHAM_GD' : __chamex })
-        filtres.append(mcfact1)
-
-        if NOM_CHAM == 'DEPL':
-            __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM,
-                                       OPERATION = 'ASSE',
-                                       MODELE    = modele,
-                                       ASSE      = filtres
-                                       );
-
-        elif NOM_CHAM == 'EPSI_NOEU_DEPL':
-            __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM,
-                                       OPERATION = 'ASSE',
-                                       PROL_ZERO = 'OUI',
-                                       MODELE    = modele,
-                                       ASSE      = filtres,
-                                       );
-
-        else:
-            valk = []
-            valk.append(NOM_CHAM)
-            valk.append('DEPL')
-            valk.append('EPSI_NOEU_DEPL')
-            UTMESS('F','OBSERVATION_6',valk) 
-
-        if isinstance( RESULTAT, mode_meca):
-            mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
-                       'MODELE'     : modele,
-                       'NUME_MODE'    : int(afreq[ind-1,0]),
-                       'FREQ'    : afreq[ind-1,1],
-                       }
-
-        if isinstance( RESULTAT, evol_elas):
-            mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
-                       'MODELE'     : modele,
-                       'INST'    : list_inst[ind-1],
-                       }
-
-        if isinstance( RESULTAT, dyna_trans):
-            mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
-                       'MODELE'     : modele,
-                       'INST'    : list_inst[ind-1],
-                       }
-
-        if isinstance( RESULTAT, dyna_harmo):
-            mcfact2 = {'CHAM_GD'    : __chamf[ind-1],
-                       'MODELE'     : MODELE_2,
-                       'FREQ'    : list_freq[ind-1],
-                       }
-
-
-        if cham_mater is not None:
-            mcfact2['CHAM_MATER'] = cham_mater
-        if cara_elem is not None:
-            mcfact2['CARA_ELEM'] = cara_elem
-
-        liste.append(mcfact2)
-        DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1)
+     if resu_filtre == None:
+        RESU = PROJ_CHAMP(METHODE = 'COLLOCATION',
+                          RESULTAT = __proj,
+                          MODELE_1 = modele,
+                          MODELE_2 = modele,
+                          NUME_DDL = NUME_DDL,
+                          NOM_CHAM = nomcham,
+                          **mcfact
+                         )
 
-    RESU = CREA_RESU(
-                      OPERATION = 'AFFE',
-                      TYPE_RESU = TYPE_RESU,
-                      NOM_CHAM  = NOM_CHAM,
-                      AFFE      = liste,
-                     );
 
     return ier
 
@@ -787,7 +779,6 @@ def crea_normale(self, modele_1, modele_2,
     nom_modele_num = modele_1.nom
     _maillag = aster.getvectjev( nom_modele_num.ljust(8) + '.MODELE    .LGRF' )
     maillage = _maillag[0].strip()
-    jdc = CONTEXT.get_current_step().jdc
     mayanum = self.get_concept(maillage)
 
 
@@ -834,7 +825,7 @@ def crea_normale(self, modele_1, modele_2,
                        );
 
 
-    __norm4 = PROJ_CHAMP( METHODE='COLOCATION',
+    __norm4 = PROJ_CHAMP( METHODE='COLLOCATION',
                           RESULTAT   = __norm3,
                           MODELE_1   = modele_1,
                           MODELE_2   = modele_2,
@@ -868,7 +859,6 @@ def crea_repere(chnorm, ind_no, vect):
     import numpy
 
     nom_para = vect.keys()[0] # nom_para = 'VECT_X' ou 'VECT_Y'
-    condition = list(vect[nom_para])
 
     # 1) pour tous les noeuds du maillage experimental, recuperer la normale
     #    calculee a partir du maillage numerique
@@ -876,9 +866,6 @@ def crea_repere(chnorm, ind_no, vect):
     chnormy = chnorm.EXTR_COMP('DY',[],1)
     chnormz = chnorm.EXTR_COMP('DZ',[],1)
 
-    noeuds = chnormx.noeud
-    nbno = len(noeuds)
-
     normale = [chnormx.valeurs[ind_no],
                chnormy.valeurs[ind_no],
                chnormz.valeurs[ind_no]]
@@ -913,7 +900,6 @@ def crea_repere(chnorm, ind_no, vect):
 
     return angl_naut
 
-
 #**********************************************************************
 # Calcul des angles nautiques pour le repere associe a VECT_X et VECT_Y
 #**********************************************************************
@@ -985,7 +971,7 @@ def crea_repere_xy(vect_x, vect_y):
         vect2 = vy
         vect1 = numpy.cross(vect2, vect3)
 
-      
+
       norm12=numpy.dot(vect1,vect1)
       norm22=numpy.dot(vect2,vect2)
       norm32=numpy.dot(vect3,vect3)
@@ -1093,7 +1079,6 @@ def norm(x):
     tmp = numpy.sqrt(numpy.dot(x,x))
     return tmp
 
-
 def anglnaut(P):
 
 
@@ -1105,9 +1090,7 @@ def anglnaut(P):
     import copy
     import numpy
     # expression des coordonnees globales des 3 vecteurs de base locale
-    x = numpy.array([1.,0.,0.])
     y = numpy.array([0.,1.,0.])
-    z = numpy.array([0.,0.,1.])
 
     xg = P[:,0]
     yg = P[:,1]

diff --git a/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py b/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py
index df4b1533da6043c3dda24117a5486b46721e7a3f..6773ec43a7e7ae56e7a80b8ea1a7ac698836b2a9 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/post_bordet_ops.py
@@ -1,21 +1,21 @@
-#@ MODIF post_bordet_ops Macro  DATE 09/08/2010   AUTEUR BARGELLINI R.BARGELLINI 
+#@ MODIF post_bordet_ops Macro  DATE 23/02/2011   AUTEUR BARGELLI R.BARGELLINI 
 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 
 #definition des fonctions python pour les passer en formule plus tard
@@ -33,11 +33,11 @@ def post_bordet_ops(self,
 TOUT,
 GROUP_MA,
 INST,
+PRECISION,
+CRITERE,
 NUME_ORDRE,
 PROBA_NUCL,
 RESULTAT,
-MODELE,
-CHAM_MATER,
 PARAM,
 TEMP,
 COEF_MULT,**args):
@@ -52,7 +52,7 @@ COEF_MULT,**args):
  # La macro compte pour 1 dans la numerotation des commandes
  #
    self.set_icmd(1)
- # 
+ #
  # On importe les definitions des commandes a utiliser dans la macro
  #
    CREA_CHAMP = self.get_cmd('CREA_CHAMP')
@@ -61,13 +61,32 @@ COEF_MULT,**args):
    CREA_TABLE  = self.get_cmd('CREA_TABLE')
    FORMULE     =self.get_cmd('FORMULE')
    CALC_TABLE  =self.get_cmd('CALC_TABLE')
- #  
+ # 
  # Definition du concept sortant dans le contexte de la macro
  #
  
    self.DeclareOut('tabout', self.sd)
 
  #
+ #Recuperation du champ materiau compris dans le resultat
+ #
+   iret,ibid,__nom_cham_mater = aster.dismoi('F','CHAM_MATER',RESULTAT.nom,'RESULTAT')
+#   if (len(__nom_cham_mater) == 0) or (len(__nom_cham_mater) > 1)  :
+   if (__nom_cham_mater.strip() == "#PLUSIEURS") or (__nom_cham_mater.strip() == "#AUCUN") :
+        print 'ON EST LA'
+        UTMESS('F','RUPTURE1_58')
+   else :
+        __cham_mater = self.get_concept(__nom_cham_mater.strip())
+#
+#Recuperation du modele a partir du resultat
+   iret,ibid,__n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT')
+   __n_modele=__n_modele.rstrip()
+   if len(__n_modele)==0 or __n_modele=="#PLUSIEURS":
+      UTMESS('F','RUPTURE1_58')
+   __model = self.get_concept(__n_modele)
+# 
+ 
+# 
  # Creation du dictionnaire des parametres materiau de l'utilisateur
  #
    __DPARAM=PARAM[0].cree_dict_valeurs(PARAM[0].mc_liste)
@@ -78,7 +97,7 @@ COEF_MULT,**args):
  #
  #Dimension du modele
  #
-   iret,ndim,rbid = aster.dismoi('F','DIM_GEOM',self['MODELE'].nom,'MODELE')
+   iret,ndim,rbid = aster.dismoi('F','DIM_GEOM',__model.nom,'MODELE')
    
    if (iret==1) or (ndim==23): UTMESS('F','RUPTURE1_57')
    
@@ -98,8 +117,8 @@ COEF_MULT,**args):
  #
 
  #Volume point de gauss
-   __VOL_PG=CALC_CHAM_ELEM(MODELE=self['MODELE'],
-                      CHAM_MATER=self['CHAM_MATER'],
+   __VOL_PG=CALC_CHAM_ELEM(MODELE=__model,
+                      CHAM_MATER=__cham_mater,
                       TOUT='OUI',
                       OPTION='COOR_ELGA',);
    if GROUP_MA:
@@ -110,8 +129,8 @@ COEF_MULT,**args):
 #contrainte principale max
    __RESU=CALC_ELEM(
             RESULTAT=self['RESULTAT'],
-            OPTION='EQUI_ELGA_SIGM',
-            NOM_CMP='PRIN3',);
+            OPTION='SIEQ_ELGA');
+#            NOM_CMP='PRIN3',);
 #deformation plastique
    __RESU=CALC_ELEM(
             reuse=__RESU,
@@ -127,14 +146,23 @@ COEF_MULT,**args):
 #On va travailler en ordre ; si l'utilisateur entre un instant, on va le transformer en ordre
    __entree_instant=None
    if INST :
+      if CRITERE=='ABSOLU':
+         __prec=PRECISION
+      elif CRITERE=='RELATIF':
+         __prec=PRECISION*INST
       __entree_instant=True
-      __instant=INST
+      __n=0
+      __trouv=None
+      while (__n<len(__list_inst) and not __trouv):
+       if (__list_inst[__n]+__prec>=INST) and (__list_inst[__n]-__prec<=INST):
+           __instant=__list_inst[__n]
+           __trouv=True
+       __n=__n+1
+      if not __trouv:
+       UTMESS('F','RUPTURE1_53',valr=INST,valk='utilise pour le calcul de Bordet')
    if __entree_instant==True:
-      if __instant not in __list_inst :
-         UTMESS('F','RUPTURE1_53',valr=__instant,valk='utilise pour le calcul de Bordet')
-      elif __instant in __list_inst :
-         index_ordre=__list_inst.index(__instant)
-         nume_ordre=__list_ordre[index_ordre]
+          index_ordre=__list_inst.index(__instant)
+          nume_ordre=__list_ordre[index_ordre]
    elif NUME_ORDRE:
       nume_ordre=NUME_ORDRE
       if nume_ordre not in __list_ordre :
@@ -153,7 +181,7 @@ COEF_MULT,**args):
    __EQ_PT=[[None] for i in range(nume_ordre+1)]
    __EQ_PT2=[[None] for i in range(nume_ordre+1)]
    __PR_BAR=[[None]for i in range(nume_ordre+1)]
-   __DEP=[[None] for i in range(nume_ordre+1)]   
+   __DEP=[[None] for i in range(nume_ordre+1)]
    __BORDTO=0.#valeur sans l'exposant final, que l'on va sommer sur les instants
    __BORDTI=0.#valeur sans l'exposant final, sommee sur les instants
    __BORDTT=[0. for i in range(nume_ordre+1)]#valeur avec l'exposant, que l'on stocke dans la table a chaque instant
@@ -178,7 +206,7 @@ COEF_MULT,**args):
    elif __list_ordre[0]!=0:
       __fin_ordre=nume_ordre
    for ordre in range(__list_ordre[0],__fin_ordre):
-#   
+# 
 #Temperature a extraire : soit une fonction du temps, soit un reel
 #
       if type(TEMP)==fonction_sdaster:
@@ -195,7 +223,7 @@ COEF_MULT,**args):
                 RESULTAT=__RESU,
                 OPERATION='EXTR',
                 NUME_ORDRE=ordre,
-                NOM_CHAM='EQUI_ELGA_SIGM',);
+                NOM_CHAM='SIEQ_ELGA',);
 
       __EPSP[ordre]=CREA_CHAMP(TYPE_CHAM='ELGA_EPSI_R',
                 RESULTAT=__RESU,
@@ -204,7 +232,7 @@ COEF_MULT,**args):
                 NOM_CHAM='EPSP_ELGA',);
 #
 #On recupere la valeur des champs au niveau des groupes qui nous interessent
-#    
+#
               
       if GROUP_MA:
          __PRIN[ordre]=__S_TOT[ordre].EXTR_COMP('PRIN_3',[GROUP_MA],0).valeurs;

diff --git a/Aster/Cata/cataSTA10/Macro/post_coque_ops.py b/Aster/Cata/cataSTA10/Macro/post_coque_ops.py
index 8c1015ed7e884f241260e46069c63591b11db91d..7392f73c3b803e8d7c557e22747bb576cea040eb 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/post_coque_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/post_coque_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF post_coque_ops Macro  DATE 11/10/2010   AUTEUR DESROCHES X.DESROCHES 
+#@ MODIF post_coque_ops Macro  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -60,9 +60,9 @@ def post_coque_ops(self,RESULTAT,COOR_POINT,CHAM,NUME_ORDRE,INST,
       if not INST in dico2['INST'] :
           UTMESS('F','POST0_20',valr=INST)
     else :
-      if not NUME_ORDRE in dico['SIEF_ELNO_ELGA'] :
+      if not NUME_ORDRE in dico['SIEF_ELNO'] :
         if NUME_ORDRE in dico['DEPL'] :        
-          CALC_ELEM(RESULTAT=RESULTAT,reuse=RESULTAT,OPTION='SIEF_ELNO_ELGA',
+          CALC_ELEM(RESULTAT=RESULTAT,reuse=RESULTAT,OPTION='SIEF_ELNO',
                     NUME_ORDRE=NUME_ORDRE)
         else :
           UTMESS('F','POST0_19',vali=NUME_ORDRE)
@@ -72,36 +72,36 @@ def post_coque_ops(self,RESULTAT,COOR_POINT,CHAM,NUME_ORDRE,INST,
     if CHAM=='DEFORMATION':
       if NUME_ORDRE:
         __ressup=CALC_ELEM(RESULTAT=RESULTAT,
-                  OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='SUP'),
+                  OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='SUP'),
                   NUME_ORDRE=NUME_ORDRE)
         __resinf=CALC_ELEM(RESULTAT=RESULTAT,
-                  OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='INF'),
+                  OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='INF'),
                   NUME_ORDRE=NUME_ORDRE)
         __epssup=CREA_CHAMP(RESULTAT=__ressup,TYPE_CHAM='ELNO_EPSI_R',
-                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL',
+                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO',
                   NUME_ORDRE=NUME_ORDRE)
         __epsinf=CREA_CHAMP(RESULTAT=__resinf,TYPE_CHAM='ELNO_EPSI_R',
-                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL',
+                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO',
                   NUME_ORDRE=NUME_ORDRE)
       else :
         __ressup=CALC_ELEM(RESULTAT=RESULTAT,
-                  OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='SUP'),
+                  OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='SUP'),
                   INST=INST)
         __resinf=CALC_ELEM(RESULTAT=RESULTAT,
-                  OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='INF'),
+                  OPTION='EPSI_ELNO',REPE_COQUE=_F(NIVE_COUCHE='INF'),
                   INST=INST)
         __epssup=CREA_CHAMP(RESULTAT=__ressup,TYPE_CHAM='ELNO_EPSI_R',
-                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL',
+                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO',
                   INST=INST)
         __epsinf=CREA_CHAMP(RESULTAT=__resinf,TYPE_CHAM='ELNO_EPSI_R',
-                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL',
+                  OPERATION='EXTR',NOM_CHAM='EPSI_ELNO',
                   INST=INST)
 
                                                                      
     # Appel MACR_LIGN_COUPE :
     motscles={}
-    if   CHAM=='EFFORT'      : motscles['NOM_CHAM']   ='SIEF_ELNO_ELGA'
-    if   CHAM=='DEFORMATION' : motscles['NOM_CHAM']   ='EPSI_ELNO_DEPL'
+    if   CHAM=='EFFORT'      : motscles['NOM_CHAM']   ='SIEF_ELNO'
+    if   CHAM=='DEFORMATION' : motscles['NOM_CHAM']   ='EPSI_ELNO'
 
     if CHAM=='EFFORT' :
       motscles['LIGN_COUPE']=[]

diff --git a/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py b/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py
index 0f0d1bf7a562509733fbd2290194713ef0aeaf36..20867c67bb1435244a37b936d34ce7bd1e1bf87b 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/post_decollement_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF post_decollement_ops Macro  DATE 04/10/2010   AUTEUR GREFFET N.GREFFET 
+#@ MODIF post_decollement_ops Macro  DATE 14/03/2011   AUTEUR TARDIEU N.TARDIEU 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -36,7 +36,7 @@ def post_decollement_ops(self,RESULTAT,NOM_CHAM,NOM_CMP,GROUP_MA,INFO,**args):
   import aster
   import os,string,types
   from Accas import _F
-  from Utilitai.Utmess import  UTMESS
+  from Utilitai.Utmess import  UTMESS, MasquerAlarme, RetablirAlarme
 
 
   ### On importe les definitions des commandes a utiliser dans la macro
@@ -66,10 +66,19 @@ def post_decollement_ops(self,RESULTAT,NOM_CHAM,NOM_CMP,GROUP_MA,INFO,**args):
              CREA_GROUP_NO=_F(GROUP_MA=GROUP_MA,NOM='PDECOL'),
              ALARME='NON',)
 
+  
+  ### le modele 3D ne va contenir que des mailles de peau : on masque les alarmes
+  MasquerAlarme('CALCULEL2_63')
+  MasquerAlarme('CALCULEL2_64')
+  
   ### model restreint au GROUP_MA
   __model=AFFE_MODELE(MAILLAGE=MAILLAGE,
                   AFFE=_F(  GROUP_MA = GROUP_MA,PHENOMENE = 'MECANIQUE',
-                            MODELISATION = 'DKT'),)
+                            MODELISATION = '3D'),)
+                            
+  ### le modele 3D ne va contenir que des mailles de peau : on retablit les alarmes
+  RetablirAlarme('CALCULEL2_63')
+  RetablirAlarme('CALCULEL2_64')
   
   ### Calcul de la surface du GROUP_MA : __surf
   __unit = CREA_CHAMP(OPERATION='AFFE',TYPE_CHAM='NOEU_NEUT_R',MODELE=__model,

diff --git a/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py b/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py
index 167322e3e7ff87796f95a40b7331e68223959862..6004fa977bf35fb1cce6149deb8db2b79cc401c4 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF post_endo_fiss_ops Macro  DATE 12/07/2010   AUTEUR BERARD A.BERARD 
+#@ MODIF post_endo_fiss_ops Macro  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -236,7 +236,7 @@ def post_endo_fiss_ops(self,
   # TEST SUR LE TYPE DE CHAMP
   #
   ltyP_cham = ['NOEU_DEPL_R','ELGA_EPSI_R','ELNO_EPSI_R','NOEU_SIEF_R','ELGA_VARI_R','ELNO_VARI_R','ELNO_VARI_R','NOEU_VAR2_R']
-  lnoM_cham = ['DEPL','EPSI_ELGA_DEPL','EPSI_ELNO_DEPL','EPSI_NOEU_DEPL','VARI_ELGA','VARI_ELNO','VARI_ELNO_ELGA','VARI_NOEU_ELGA']
+  lnoM_cham = ['DEPL','EPSI_ELGA','EPSI_ELNO','EPSI_NOEU','VARI_ELGA','VARI_ELNO','VARI_ELNO','VARI_NOEU']
 
   if NOM_CHAM in lnoM_cham :
     Xtype_cham = ltyP_cham[lnoM_cham.index(NOM_CHAM)]
@@ -423,7 +423,7 @@ def post_endo_fiss_ops(self,
                                       PHENOMENE    = 'MECANIQUE',
                                       MODELISATION = 'BARRE'),)
 
-    __YBARPR = PROJ_CHAMP(METHODE        = 'COLOCATION',
+    __YBARPR = PROJ_CHAMP(METHODE        = 'COLLOCATION',
                             RESULTAT     = __resu,
                             MODELE_1     = __modtot,
                             MODELE_2     = __MO,
@@ -537,7 +537,7 @@ def post_endo_fiss_ops(self,
                                      PHENOMENE    = 'MECANIQUE',
                                      MODELISATION = 'BARRE'),)
 
-    __YBARPR = PROJ_CHAMP(METHODE      = 'COLOCATION',
+    __YBARPR = PROJ_CHAMP(METHODE      = 'COLLOCATION',
                           RESULTAT     = __resu,
                           MODELE_1     = __modtot,
                           MODELE_2     = __MO,
@@ -683,7 +683,7 @@ def post_endo_fiss_ops(self,
 
       try:
         # on essaie de projeter, exception: il n'y a pas des points "dans la matiere"
-        __YBARPR = PROJ_CHAMP(METHODE      = 'COLOCATION',
+        __YBARPR = PROJ_CHAMP(METHODE      = 'COLLOCATION',
                               RESULTAT     = __resu,
                               MODELE_1     = __modtot,
                               MODELE_2     = __MO,

diff --git a/Aster/Cata/cataSTA10/Macro/post_gp_ops.py b/Aster/Cata/cataSTA10/Macro/post_gp_ops.py
index 4a02d8f67768cf67c949e14f8830a46b9e9e4a92..7cf700e8b9d3886fffac074cc9eb4ad99ed746e3 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/post_gp_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/post_gp_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF post_gp_ops Macro  DATE 30/08/2010   AUTEUR MACOCCO K.MACOCCO 
+#@ MODIF post_gp_ops Macro  DATE 29/03/2011   AUTEUR MACOCCO K.MACOCCO 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -48,52 +48,54 @@ def post_gp_ops(self, **args):
    CALC_ELEM     = self.get_cmd('CALC_ELEM')
    RECU_FONCTION = self.get_cmd('RECU_FONCTION')
    DEFI_GROUP    = self.get_cmd('DEFI_GROUP')
+   EXTR_RESU      = self.get_cmd('EXTR_RESU')
    DETRUIRE      = self.get_cmd('DETRUIRE')
    FIN           = self.get_cmd('FIN')
    
    tmp_liste_inst_postgp = []
    
+   #----------------------------------------------------------
    # ----- Comptage, commandes + déclaration concept sortant
+   #----------------------------------------------------------
    self.set_icmd(1)
    self.DeclareOut('result', self.sd)
    self.DeclareOut('tabresult', self['TABL_GPMAX'])
    if (self['TABL_GP']!= None ):   
-    self.DeclareOut('tabgp', self['TABL_GP'])
-    if (self['LIST_INST']!=None) :
-     LIST_INST =  self['LIST_INST']
-     tmp_list_inst1 = aster.getvectjev(string.ljust(LIST_INST.nom,19)+'.VALE')
-     for itmp in tmp_list_inst1 :  
-      tmp_liste_inst_postgp.append(itmp)
-    if (self['INST']!=None) :
-     tmp_INST =  self['INST']
-     for jtmp in tmp_INST :
-      tmp_liste_inst_postgp.append(jtmp)
-      
-    liste_inst_postgp = list(set(tmp_liste_inst_postgp))
-    liste_inst_postgp.sort()
+       self.DeclareOut('tabgp', self['TABL_GP'])
+
+   liste_inst_post = self['LIST_INST']
+   Resultat = EXTR_RESU(RESULTAT=self['RESULTAT'],ARCHIVAGE=_F(LIST_INST=liste_inst_post))
+   liste_inst_postgp = aster.getvectjev(string.ljust(liste_inst_post.nom,19)+'.VALE')
+   
 
+   #----------------------------------------------------------
    # ---- Recuperation du nombre d'instants deja calculés 
-   num_ord = len(NP.nonzero(aster.getvectjev(string.ljust(self['RESULTAT'].nom,19)+'.ORDR        '))[0])
+   #----------------------------------------------------------
+   if aster.getvectjev(string.ljust(Resultat.nom,19)+'.ORDR        ').__contains__(0):UTMESS('F','POST0_37')
+   num_ord = len(aster.getvectjev(string.ljust(Resultat.nom,19)+'.ORDR        '))
+   liste_ord = aster.getvectjev(string.ljust(Resultat.nom,19)+'.ORDR        ')
+
            
    # Cas 2D
    if self['THETA_2D'] is not None:
       is_2D = True
    else:
       is_2D = False
+      UTMESS('A','POST0_38')
+      # TABLE GP à remplier pour 3D
+      liste_3d_inst =  []  
+      liste_3d_lieu =  []  
+      liste_3d_icop =  []
+      liste_3d_deltal =  [] 
+      liste_3d_gp =  []
 
    info = self['INFO']
    type_def = self['TYPE_DEF']
    
-   # TABLE GP à remplier pour 3D
-   liste_3d_inst =  []
-   liste_3d_lieu =  []  
-   liste_3d_icop =  []
-   liste_3d_deltal =  [] 
-   liste_3d_gp =  []
-   
-   
    
+   #----------------------------------------------------------
    # 0. ----- Type de calcul
+   #----------------------------------------------------------
    identification = self['IDENTIFICATION'] != None
    if identification:
       # 0.1. --- identification : on boucle sur les valeurs de TEMP.
@@ -120,19 +122,25 @@ def post_gp_ops(self, **args):
       l_crit = [l_crit,]
    
 
+   #----------------------------------------------------------
    # Maillage associe au modele
+   #----------------------------------------------------------
    __MAIL = aster.getvectjev( self['MODELE'].nom.ljust(8) + '.MODELE    .LGRF        ' )
    nom_maillage = __MAIL[0].strip()
    
    maya = self.get_concept(nom_maillage)
    ltyma =aster.getvectjev("&CATA.TM.NOMTM")
    
+   #----------------------------------------------------------
    # Excitation 
+   #----------------------------------------------------------
    args={}      
    if self['EXCIT']:args={'EXCIT'   : self['EXCIT'].List_F()}
 
    
+   #----------------------------------------------------------
    # 1. ----- calcul de G-theta
+   #----------------------------------------------------------
 
    if is_2D:
       nbcour = len(self['THETA_2D'])
@@ -148,7 +156,7 @@ def post_gp_ops(self, **args):
                                           R_SUP=dMC['R_SUP']),)
    
          __gtheta = CALC_G(THETA=_F(THETA=__theta),
-                           RESULTAT=self['RESULTAT'],
+                           RESULTAT=Resultat,
                            TOUT_ORDRE='OUI',
                            SYME_CHAR=self['SYME_CHAR'],
                            COMP_ELAS=self['COMP_ELAS'].List_F(),
@@ -158,21 +166,22 @@ def post_gp_ops(self, **args):
          
          # une Table par couronne
          l_tab.append(tab)      
-  
+         
    else:
       #Cas 3D
       nbcour = len(self['THETA_3D'])
       l_tab = []
       l_noeuds_fissure, pas = getFondFissInfo(self['FOND_FISS'])
       nb_noeuds_fissure = len(l_noeuds_fissure)
+      FOND_FISS =  self['FOND_FISS']
+      lnormale = aster.getvectjev(FOND_FISS.nom.ljust(8)+'.NORMALE              ')
+      if (lnormale==None):UTMESS('F','POST0_39')
       
       for occ in self['THETA_3D']:
          dMC = occ.cree_dict_valeurs(occ.mc_liste)
          
          # on met les mots-clés facultatifs dans des dictionnaires
          dpar_theta = {}
-         if self['DIRECTION'] is not None:
-            dpar_theta['DIRECTION'] = self['DIRECTION']
          
          __gtheta = CALC_G(
                            THETA=_F(R_INF=dMC['R_INF'],
@@ -180,7 +189,7 @@ def post_gp_ops(self, **args):
                                     MODULE=1.0,
                                     FOND_FISS=self['FOND_FISS'],
                                     **dpar_theta),
-                           RESULTAT=self['RESULTAT'],
+                           RESULTAT=Resultat,
                            TOUT_ORDRE='OUI',
                            SYME_CHAR=self['SYME_CHAR'],
                            COMP_ELAS=self['COMP_ELAS'].List_F(),
@@ -193,8 +202,11 @@ def post_gp_ops(self, **args):
          # une Table par couronne
          l_tab.append(tab)
 
-   # 1.1.----- calcul de la mesure des mailles appartenant à l'axe de symétrie 
-   # ou au plan de symétrie
+   #----------------------------------------------------------
+   # 1.1.----- calcul de la mesure des mailles 
+   #           appartenant à l'axe de symétrie 
+   #           ou au plan de symétrie
+   #----------------------------------------------------------
    l_copo_tot = []
    l_ep_copeaux_tot_3D = []
    for tmpocc in self['TRANCHE']:
@@ -210,36 +222,34 @@ def post_gp_ops(self, **args):
    if is_2D:
       # Récupération des noeuds appartenant à la droite de symétrie
       # le vecteur normal est construit comme étant perpendiculaire au vecteur direction
-       if (self['DIRECTION'][0]==1.):
-           ldirection = (0.,1.)
-       elif (self['DIRECTION'][1]==1.):
-           ldirection = (1.,0.)
+      # La commande CALC_THETA/THETA_2D suppose que la composante suivant z est nulle
+       lnormale = (self['DIRECTION'][1],self['DIRECTION'][0])
        Nds_fdfiss = dMC['GROUP_NO']
-       Recup_Noeuds_Surf(is_2D,maya,Nds_fdfiss,ldirection)
-       mesure = Calcul_mesure_2D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,self['RESULTAT'],type_def)
+       Recup_Noeuds_Surf(is_2D,maya,Nds_fdfiss,lnormale)
+       mesure = Calcul_mesure_2D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,Resultat,type_def)
 
    else:
       # Récupération des noeuds appartenant à la surface de symétrie
       # le vecteur normal est récuperé dans FOND_FISS
        FOND_FISS =  self['FOND_FISS']
-       ldirection = aster.getvectjev(FOND_FISS.nom.ljust(8)+'.NORMALE              ')
-       Recup_Noeuds_Surf(is_2D,maya,l_noeuds_fissure[0],ldirection,l_noeuds_fissure)
-       mesure, l_ep_copeaux_tot_3D = Calcul_mesure_3D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,self['RESULTAT'],type_def)
-   Supr_mano(maya)
+       Recup_Noeuds_Surf(is_2D,maya,l_noeuds_fissure[0],lnormale,l_noeuds_fissure)
+       mesure, l_ep_copeaux_tot_3D = Calcul_mesure_3D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,Resultat,type_def)
+       l_ep_copeaux_tot_3D = l_ep_copeaux_tot_3D*num_ord 
+
+   #----------------------------------------------------------
    # 2. ----- Calcul de l'energie élastique en exploitant les groupes de
    #          mailles fournis par la procedure de maillage
+   #----------------------------------------------------------
    l_ep_copeaux_tot = []
-   for it in range(num_ord):
-     for k in range(0,len(l_copo_tot)) :
-       Copeau_k = l_copo_tot[k]
+   for it in range(len(liste_ord)):
+     for Copeau_k in l_copo_tot :
        l_ep_copeaux_tot.append(mesure[Copeau_k][it])
-   l_ep_copeaux_tot_3D=l_ep_copeaux_tot_3D*num_ord   
    l_t_enel = []
    
    if self['TRAC_COMP']=='OUI':
       # prise en compte de la traction-compression dans le calcul de l'energie
-      resu2=CALC_ELEM(OPTION=('EQUI_ELNO_SIGM'),
-                     RESULTAT=self['RESULTAT'],
+      resu2=CALC_ELEM(OPTION=('SIEQ_ELNO'),
+                     RESULTAT=Resultat,
                      )
                      
       # indices des mailles du dernier group_ma
@@ -305,7 +315,7 @@ def post_gp_ops(self, **args):
             d_nomma[id_elem]=elem
             
             E_el[kk] = POST_ELEM(MODELE=self['MODELE'],
-                                 RESULTAT=self['RESULTAT'],
+                                 RESULTAT=Resultat,
                                  TOUT_ORDRE='OUI',
                                  ENER_ELAS=_F(MAILLE=elem),
                                  TITRE='Energie élastique',
@@ -315,7 +325,7 @@ def post_gp_ops(self, **args):
             
             l_enel = T_el[kk].TOTALE.values()
             
-            # signe de la trace <=> signe de la composante VMIS_SG du tenseur EQUI_ELNO_SIGM,
+            # signe de la trace <=> signe de la composante VMIS_SG du tenseur SIEQ_ELNO,
             # mais E_enel est par element => on fait une moyenne sur les noeuds de l'element
             
             list_no = []
@@ -335,7 +345,7 @@ def post_gp_ops(self, **args):
                
                __VM=RECU_FONCTION(RESULTAT=resu2,
                                     TOUT_INST='OUI',
-                                    NOM_CHAM='EQUI_ELNO_SIGM',
+                                    NOM_CHAM='SIEQ_ELNO',
                                     NOM_CMP='VMIS_SG',
                                     MAILLE=elem,
                                     NOEUD=noeud);
@@ -420,7 +430,7 @@ def post_gp_ops(self, **args):
          # calcul classique de l'energie elastique
       
          __ener = POST_ELEM(MODELE=self['MODELE'],
-                                 RESULTAT=self['RESULTAT'],
+                                 RESULTAT=Resultat,
                                  TOUT_ORDRE='OUI',
                                  ENER_ELAS=_F(GROUP_MA=l_copo),
                                  TITRE='Energie élastique',
@@ -466,15 +476,6 @@ def post_gp_ops(self, **args):
       
       # 2.3. ----- Tableau de Gp = f(icop) pour chaque instant    
       
-###############################################################################################
-# BESOIN D4AFFICHE TABLEAU GP pour chque instant dans fichier mess      
-#      print "####Dana_tGp_t_icop####"
-#      Dana_tGp_t_icop = t_enel['INST', 'LIEU', 'ICOP', 'DELTAL', 'GP']
-#      Dana_tGp_t_icop.titr = "Dana Gp à chaque instant en fonction de la distance au " \
-#                          "fond d'entaille"
-#      Dana_tGp_t_icop.ImprTableau()
-###############################################################################################
-                  
       if info >= 2:
          tGp_t_icop = t_enel['INST', 'DELTAL', 'GP']
          tGp_t_icop.titr = "Gp à chaque instant en fonction de la distance au " \
@@ -502,7 +503,7 @@ def post_gp_ops(self, **args):
          if len(t.GP.values())>1:
             t = t.DELTAL.MINI()
          
-         if j == 1:
+         if l_numord.index(j) == 0:
             tb_Gpmax_i = t
          else:
             tb_Gpmax_i = tb_Gpmax_i | t
@@ -639,8 +640,8 @@ def post_gp_ops(self, **args):
                tab=mergeLineInTable(tab, t_relev, nb_noeuds_fissure)
 
             # en 3D, le paramètre R n'intervient pas
-            tab.fromfunction(new_para, fKj, ('G_LOCAL', 'YOUNG', 'NU'))
-            tab.Renomme('G_LOCAL', 'G_%d' % (k + 1))
+            tab.fromfunction(new_para, fKj, ('G', 'YOUNG', 'NU'))
+            tab.Renomme('G', 'G_%d' % (k + 1))
 
          l_tabi.append(tab)
       
@@ -710,12 +711,24 @@ def post_gp_ops(self, **args):
             d_para.update({ 'NOM_PARA' : 'KMOY',
                            'NOM_RESU' : 'INST', })
             valkmoy = tabres.KMOY.values()
-            # temps en fonction de Kmoy
-            finv = t_fonction(valkmoy, tabres.INST.values(), d_para)
+            if len(liste_inst_postgp) == 1 :
+                # si un seul instant alors
+                ti = liste_inst_postgp[0]
+            else:
 
-            # valeurs à mettre dans la table
-            # temps correspondant à KJ_CRIT
-            ti   = finv(KJ_CRIT)
+                # temps en fonction de Kmoy
+                finv = t_fonction(valkmoy, tabres.INST.values(), d_para)
+
+                # valeurs à mettre dans la table
+                # temps correspondant à KJ_CRIT
+                ti   = finv(KJ_CRIT)
+                ind_instant_plus = [x > ti for x in liste_inst_postgp].index(True)
+                if (abs(liste_inst_postgp[ind_instant_plus-1]-ti)/ti) <= 1e-4:
+                   ti = liste_inst_postgp[ind_instant_plus-1]
+                elif (abs(liste_inst_postgp[ind_instant_plus]-ti)/ti) <= 1e-4:
+                   ti = liste_inst_postgp[ind_instant_plus]
+                else:
+                   UTMESS('A','POST0_36',valr =tuple(liste_inst_postgp[ind_instant_plus-1:ind_instant_plus+1]))
             
             # GP correspondant au temps critique
             if (message_kjcritique_non_atteint == 1) :
@@ -746,46 +759,55 @@ def post_gp_ops(self, **args):
 
          else:
             
-            l_i_noeuds_sommets = range(0,len(l_noeuds_fissure),pas)
-            t_noeud_Kcrit = Table(para=tabres.para)
-            
-            # On determine quel noeud sommet maximise KMOY au cours du temps:
-            
             row_KMOY_max = tabres.KMOY.MAXI()
             noeud_KMOY_max = row_KMOY_max.NOEUD.values()[0]
-            
-            # avec le noeud ou KJ_CRIT est atteint, on regarde GP a gauche et a droite. 
-            # le GP le plus grand correspond au GPmax
-            # on garde la tranche ou GP est le plus grand            
-            
-            id_noeud_KMOY_max = list(l_noeuds_fissure).index(noeud_KMOY_max)
-            if id_noeud_KMOY_max==0:
-               # "Gpmax sur la 1ere tranche"
-               nume_tranche_Gpmax = 1
-            elif id_noeud_KMOY_max==(len(l_noeuds_fissure)-1):
-               # "Gpmax sur la derniere tranche"
-               nume_tranche_Gpmax = nb_tranches
-            else:
-               # "Gpmax sur une tranche intermediaire"
-               Gpi_tot = Table(para=tb_Gpmax.para)
-               Gpi_gauche = tb_Gpmax.NUME_TRANCHE==(id_noeud_KMOY_max/pas)
-               Gpi_tot.append(Gpi_gauche.rows[0])
-               Gpi_droite = tb_Gpmax.NUME_TRANCHE==(id_noeud_KMOY_max/pas+1)
-               Gpi_tot.append(Gpi_droite.rows[0])
-               Gpi_tab = Gpi_tot.GPMAX.MAXI()
-               nume_tranche_Gpmax = Gpi_tab.NUME_TRANCHE.values()[0]
-            
-            # tb_Gpmax_TrancheCrit est une table de la meme nature que la table 2D tb_Gpmax
-            # i.e. valeurs sur la seule tranche qui nous interesse (ou on sait
-            # que KJ_CRIT sera atteint)
-            
-            tb_Gpmax_TrancheCrit = tb_Gpmax.NUME_TRANCHE==nume_tranche_Gpmax
-            
-            # avec le noeud ou KJ_CRIT est atteint, on determine le temps
-            # critique par interpolation            
+            Gpi = 0.0
+            nume_tranche_kjcrit = 0
+            # On determine par interpolation le temps critique ou KJ_CRIT est atteint
             tabres_NoeudCrit = tabres.NOEUD==noeud_KMOY_max
-            
-            # la suite est idem 2D, seuls les noms des tables changent
+            d_para.update({ 'NOM_PARA' : 'KMOY',
+                           'NOM_RESU' : 'INST', })
+            valkmoy = tabres_NoeudCrit.KMOY.values()
+            if len(liste_inst_postgp) == 1 :
+                # si un seul instant alors
+                ti = liste_inst_postgp[0]
+            else:
+
+                # temps en fonction de Kmoy
+                finv = t_fonction(valkmoy, tabres_NoeudCrit.INST.values(), d_para)
+   
+                # valeurs à mettre dans la table
+                # temps correspondant a KJ_CRIT
+                ti   = finv(KJ_CRIT)
+                ind_instant_plus = [x > ti for x in liste_inst_postgp].index(True)
+                if abs(liste_inst_postgp[ind_instant_plus-1]-ti)/ti < 1e-4:
+                   ti = liste_inst_postgp[ind_instant_plus-1]
+                elif abs(liste_inst_postgp[ind_instant_plus]-ti)/ti < 1e-4:
+                   ti = liste_inst_postgp[ind_instant_plus]
+                else:
+                   UTMESS('A','POST0_36',valr =tuple(liste_inst_postgp[ind_instant_plus-1:ind_instant_plus+1]))
+
+            # Gpmax fonction du temps
+            d_para.update({  'NOM_PARA' : 'INST','NOM_RESU' : 'GPMAX' })
+            for id_noeud_KMOY_max in range(len( tb_Gpmax.NUME_TRANCHE)):
+                if id_noeud_KMOY_max==0:
+                  # "Gpmax sur la 1ere tranche"
+                  nume_tranche_Gpmax = 1
+                elif id_noeud_KMOY_max==(len(l_noeuds_fissure)-1):
+                  # "Gpmax sur la derniere tranche"
+                  nume_tranche_Gpmax = nb_tranches
+                else:
+                  # "Gpmax sur une tranche intermediaire"
+                  Gpi_tot = Table(para=tb_Gpmax.para)
+                  nume_tranche_Gpmax = tb_Gpmax.NUME_TRANCHE[id_noeud_KMOY_max]
+
+                tb_Gpmax_TrancheCrit = tb_Gpmax.NUME_TRANCHE==nume_tranche_Gpmax
+                fGp = t_fonction(tb_Gpmax_TrancheCrit.INST.values(),
+                                 tb_Gpmax_TrancheCrit.GPMAX.values(),
+                                 d_para)
+                if (Gpi<fGp(ti)):
+                  Gpi = max(Gpi,fGp(ti))
+                  nume_tranche_kjcrit = nume_tranche_Gpmax
     
             # définition des fonctions pour faire les interpolations
             d_para.update({ 'NOM_RESU' : 'DELTALMAX' })
@@ -794,23 +816,6 @@ def post_gp_ops(self, **args):
                               tb_Gpmax_TrancheCrit.DELTALMAX.values(),
                               d_para)
             
-            # Gpmax fonction du temps
-            d_para.update({ 'NOM_RESU' : 'GPMAX' })
-            fGp = t_fonction(tb_Gpmax_TrancheCrit.INST.values(),
-                              tb_Gpmax_TrancheCrit.GPMAX.values(),
-                              d_para)
-            
-    
-            d_para.update({ 'NOM_PARA' : 'KMOY',
-                           'NOM_RESU' : 'INST', })
-            valkmoy = tabres_NoeudCrit.KMOY.values()
-            # temps en fonction de Kmoy
-            finv = t_fonction(valkmoy, tabres_NoeudCrit.INST.values(), d_para)
-   
-            # valeurs à mettre dans la table
-            # temps correspondant a KJ_CRIT
-            ti   = finv(KJ_CRIT)
-
             if (message_kjcritique_non_atteint == 1) :
                Gpi     = '-'
                kgpcrit = '-'
@@ -819,7 +824,6 @@ def post_gp_ops(self, **args):
                type_tab_ident=('R', 'R', 'I', 'K8', 'K8', 'K8', 'K24' ) 
             else :
             # GP correspondant au temps critique
-               Gpi  = fGp(ti)
                kgpcrit = fKj(Gpi, **dict_constantes)
                dLcrit  = fdL(ti)
                message = 'KJ CRITIQUE ATTEINT'
@@ -829,7 +833,7 @@ def post_gp_ops(self, **args):
             d_ident = {
                'KJ_CRIT'     : KJ_CRIT,
                'INST'        : ti,
-               'NUME_TRANCHE': int(nume_tranche_Gpmax),
+               'NUME_TRANCHE': nume_tranche_kjcrit,
                'GP_CRIT'     : Gpi,
                'KGP_CRIT'    : kgpcrit,
                'DELTALCRIT'  : dLcrit,
@@ -901,94 +905,33 @@ def post_gp_ops(self, **args):
      # CAS 2D
      if is_2D : 
        
-       # verifier si la liste d'instant definie par POST_GP est inclus dans la liste d'instant de STAT_NON_LINE
-       if (self['LIST_INST']!=None) :
-
-         liste_2d_inst_reduit = []
-         liste_2d_inst_reduit = dict().fromkeys(t_enel['INST'].values()['INST']).keys()
-
-         temps_agarde_gp = Save_VALGP_DE_LISTINST (liste_inst_postgp,liste_2d_inst_reduit, t_enel['INST'].values()['INST'])
-
-         for i in temps_agarde_gp : 
+         for i in range(num_ord) : 
  
            d_tabgp = {
-               'INST'   : t_enel['INST'].values()['INST'][i],
-               'GROUP_MA'   : t_enel['LIEU'].values()['LIEU'][i],
+               'INST'         : t_enel['INST'].values()['INST'][i],
+               'GROUP_MA'     : t_enel['LIEU'].values()['LIEU'][i],
                'NUMERO_COP'   : t_enel['ICOP'].values()['ICOP'][i],
-               'DELTAL' : t_enel['DELTAL'].values()['DELTAL'][i],
-               'GP' : t_enel['GP'].values()['GP'][i],
+               'DELTAL'       : t_enel['DELTAL'].values()['DELTAL'][i],
+               'GP'           : t_enel['GP'].values()['GP'][i],
                 }
            lv_tabgp.append(d_tabgp)
 
-       # si la liste d'instant de POST_GP n'est pas definie        
-       else :
-       
-         temps_agarde_gp = t_enel['INST'].values()['INST']    
-       
-         for i in range(len(temps_agarde_gp)) : 
-           d_tabgp = {
-               'INST'   : t_enel['INST'].values()['INST'][i],
-               'GROUP_MA'   : t_enel['LIEU'].values()['LIEU'][i],
-               'NUMERO_COP'   : t_enel['ICOP'].values()['ICOP'][i],
-               'DELTAL' : t_enel['DELTAL'].values()['DELTAL'][i],
-               'GP' : t_enel['GP'].values()['GP'][i],
-              }
-           lv_tabgp.append(d_tabgp)
-
-       texte = 'GP 2D pour chaque instant'
+           texte = 'GP 2D pour chaque instant'
        
      # CAS 3D
      else :
-       # verifier si la liste d'instant definie par POST_GP est inclus dans la liste d'instant de STAT_NON_LINE
-       if (self['LIST_INST']!=None) :
-
-         liste_3d_inst_reduit = []
-         liste_3d_inst_reduit = dict().fromkeys(liste_3d_inst).keys()
-
-         temps_agarde_gp = Save_VALGP_DE_LISTINST (liste_inst_postgp,liste_3d_inst_reduit,liste_3d_inst)
 
-         for i in temps_agarde_gp : 
+         for i in range(len(liste_3d_inst)) : 
  
            d_tabgp = {
-               'INST'   : liste_3d_inst[i],
-               'GROUP_MA'   : liste_3d_lieu[i],
+               'INST'         : liste_3d_inst[i],
+               'GROUP_MA'     : liste_3d_lieu[i],
                'NUMERO_COP'   : liste_3d_icop[i],
-               'DELTAL' : liste_3d_deltal[i],
-               'GP' : liste_3d_gp[i],
+               'DELTAL'       : liste_3d_deltal[i],
+               'GP'           : liste_3d_gp[i],
               }    
            lv_tabgp.append(d_tabgp)
-       # si la liste d'instant de POST_GP n'est pas definie 
-       else :
-         inst_agarde_gp = []
-         inst_agarde_gp = liste_3d_inst      
-         inst_agarde_gp.sort()
-
-         inst_sauv = []
-         # réorganisation
-         for j in range(len(inst_agarde_gp)) :
-          if j < len(inst_agarde_gp)-1 :
-           if (inst_agarde_gp[j] != inst_agarde_gp[j+1]) :
-            inst_sauv.append(inst_agarde_gp[j])
-         inst_sauv.append(inst_agarde_gp[len(inst_agarde_gp)-1])
-
-         temps_agarde_gp_inst_sauv = []
-         for tmp_inst_sauv in inst_sauv :
-           compteur_inst_sauv = 0
-           for tmp_liste_3d_inst in liste_3d_inst:
-             if (tmp_inst_sauv == tmp_liste_3d_inst) :
-               temps_agarde_gp_inst_sauv.append(compteur_inst_sauv)
-             compteur_inst_sauv = compteur_inst_sauv + 1
-
-         for i in temps_agarde_gp_inst_sauv :
-           d_tabgp = {
-               'INST'   : liste_3d_inst[i],
-               'GROUP_MA'   : liste_3d_lieu[i],
-               'NUMERO_COP'   : liste_3d_icop[i],
-               'DELTAL' : liste_3d_deltal[i],
-               'GP' : liste_3d_gp[i],
-                }
-           lv_tabgp.append(d_tabgp)
-       texte = 'GP 3D pour chaque instant'
+         texte = 'GP 3D pour chaque instant'
      
      
 #    Creation du tableau Gp 2D ou 3D     
@@ -1003,7 +946,7 @@ def post_gp_ops(self, **args):
 
      dprod_tabgp = tab_tabgp.dict_CREA_TABLE()
      tabgp = CREA_TABLE(**dprod_tabgp)
-
+   DETRUIRE(CONCEPT=_F(NOM=Resultat),INFO=1);
 
 # -----------------------------------------------------------------------------
 def CallRCVALE(TEMP, para, MATER):
@@ -1224,15 +1167,15 @@ def Recup_Noeuds_Copeaux(is_2D,maya,Copeau_k):
       DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_NO=dicma);
 
 
-def Recup_2D(maya,C_k):
+def Recup_2D(maya,C_k,mon_nom):
 
    from Accas import _F
    if C_k==0:
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan' })
+       dicma.append({'NOM' : mon_nom })
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, DETR_GROUP_MA=dicma),
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan', 'OPTION' : 'APPUI', 'GROUP_NO' : 'Cop_Pl', 'TYPE_APPUI' : 'TOUT'})
+       dicma.append({'NOM' : mon_nom, 'OPTION' : 'APPUI', 'GROUP_NO' : 'Cop_Pl', 'TYPE_APPUI' : 'TOUT'})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma)
        dicma=[]
        dicma.append({'NOM' : 'Mai_Pla2'})
@@ -1248,10 +1191,10 @@ def Recup_2D(maya,C_k):
        dicma.append({'NOM' : 'Mai_Pla1', 'OPTION' : 'APPUI', 'GROUP_NO' : 'Cop_Pl', 'TYPE_APPUI' : 'TOUT'})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma),
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan'})
+       dicma.append({'NOM' : mon_nom})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, DETR_GROUP_MA=dicma),
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan', 'DIFFE' : ('Mai_Pla1','Mai_Pla2')})
+       dicma.append({'NOM' : mon_nom, 'DIFFE' : ('Mai_Pla1','Mai_Pla2')})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma),       
        dicma=[]
        dicma.append({'NOM' : 'Mai_Pla2'})
@@ -1260,33 +1203,33 @@ def Recup_2D(maya,C_k):
        dicma.append({'NOM' : 'Mai_Pla2', 'UNION' : ('Mai_Pla1','Mai_Plan')})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma)
       
-def Recup_3D(maya,C_k):
+def Recup_3D(maya,C_k,mon_nom):
 
    from Accas import _F
    if C_k==0:
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan' })
+       dicma.append({'NOM' : mon_nom })
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, DETR_GROUP_MA=dicma),
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan', 'OPTION' : 'APPUI', 'GROUP_NO' : 'Cop_Pl', 'TYPE_APPUI' : 'TOUT'})
+       dicma.append({'NOM' : mon_nom, 'OPTION' : 'APPUI', 'GROUP_NO' : 'Cop_Pl', 'TYPE_APPUI' : 'TOUT', 'TYPE_MAILLE' : '2D'})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma),
        dicma=[]
        dicma.append({'NOM' : 'Mai_Pla2'})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, DETR_GROUP_MA=dicma),
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Pla2', 'GROUP_MA' : ('Mai_Plan')})
+       dicma.append({'NOM' : 'Mai_Pla2', 'GROUP_MA' : (mon_nom)})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma),       
 
 
        dicma=[]
        dicma.append(_F(NOM = 'Nds_Delt'))
        dicma.append(_F(NOM = 'Nds_Floc'))
-       dicma.append(_F(NOM = 'Mai_Plan'))
+       dicma.append(_F(NOM = mon_nom))
        DEFI_GROUP(reuse =maya,MAILLAGE=maya,DETR_GROUP_NO=dicma,);
 
        dicma=[]
-       dicma.append(_F(NOM = 'Mai_Plan',GROUP_MA='Mai_Plan'))
-       dicma.append(_F(NOM = 'Nds_Delt',INTERSEC=('Nds_Fond','Mai_Plan')))
+       dicma.append(_F(NOM = mon_nom,GROUP_MA=mon_nom))
+       dicma.append(_F(NOM = 'Nds_Delt',INTERSEC=('Nds_Fond',mon_nom)))
        dicma.append(_F(NOM = 'Nds_Floc',GROUP_NO='Nds_Delt'))
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_NO=dicma);
 
@@ -1298,20 +1241,20 @@ def Recup_3D(maya,C_k):
        dicma.append({'NOM' : 'Mai_Pla1', 'OPTION' : 'APPUI', 'GROUP_NO' : 'Cop_Pl', 'TYPE_APPUI' : 'TOUT'})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma),
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan'})
+       dicma.append({'NOM' : mon_nom})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, DETR_GROUP_MA=dicma),
        dicma=[]
-       dicma.append({'NOM' : 'Mai_Plan', 'DIFFE' : ('Mai_Pla1','Mai_Pla2')})
+       dicma.append({'NOM' : mon_nom, 'DIFFE' : ('Mai_Pla1','Mai_Pla2'), 'TYPE_MAILLE' : '2D'})
        DEFI_GROUP(reuse =maya, MAILLAGE=maya, CREA_GROUP_MA=dicma),       
        dicma=[]
        dicma.append(_F(NOM = 'Nds_Delt'))
-       dicma.append(_F(NOM = 'Mai_Plan'))
+       dicma.append(_F(NOM = mon_nom))
        dicma.append(_F(NOM = 'Mai_Pla2'))
        DEFI_GROUP(reuse =maya,MAILLAGE=maya,DETR_GROUP_NO=dicma,);
        dicma=[]
-       dicma.append(_F(NOM = 'Mai_Plan', GROUP_MA ='Mai_Plan'))
+       dicma.append(_F(NOM = mon_nom, GROUP_MA =mon_nom))
        dicma.append(_F(NOM = 'Mai_Pla2', GROUP_MA ='Mai_Pla2'))
-       dicma.append(_F(NOM = 'Nds_Delt', INTERSEC = ('Mai_Pla2','Mai_Plan')))
+       dicma.append(_F(NOM = 'Nds_Delt', INTERSEC = ('Mai_Pla2',mon_nom)))
        DEFI_GROUP(reuse =maya,MAILLAGE=maya,CREA_GROUP_NO=dicma);
        dicma=[]
        dicma.append({'NOM' : 'Mai_Pla2'})
@@ -1328,43 +1271,60 @@ def Calcul_mesure_2D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,resu,type_def):
    import numpy as NP
 
    mesure = {}     
+   mon_nom = 'Mai_Plan'
    for C_k in range(nbcop) :
         Copeau_k = l_copo_tot[C_k]
         Recup_Noeuds_Copeaux(True,maya,Copeau_k)
-        Recup_2D(maya,C_k)
+        Recup_2D(maya,C_k,mon_nom)
         if C_k==0:
           mesure[Copeau_k] = NP.zeros(num_ord)
         else:
           mesure[Copeau_k] = mesure[l_copo_tot[C_k-1]]
           
         # Calcul de la surface des mailles du copeau courant pour chaque instant
-        mon_nom = 'Mai_Plan'
         tmp_mesure = NP.zeros(num_ord)
+        tab_noeud=[]
+        tab_maille=[]
         for maille_courante in maya.GROUPEMA.get()[mon_nom.ljust(8)]:
           if ltyma[maya.TYPMAIL.get()[maille_courante]][0:3]=='SEG':
             connexe = maya.CONNEX.get()[maille_courante]
-            coord_nds = []
-            deforme=[]
-            DEP_el = [None]*2
-            for i in range(0,2):
-               tab_DEP_el = Coord_Recup(maya.NOMNOE.get()[connexe[i]-1],maya.NOMMAI.get()[maille_courante],resu)
-               coord_nds.append((tab_DEP_el.COOR_X.values(),tab_DEP_el.COOR_Y.values()))
-               deforme.append((tab_DEP_el.DX.values(),tab_DEP_el.DY.values()))       
-
-            if type_def=='GRAND':
-              for it in range(num_ord):
-                Coor_int=[]
-                Def_int=[]
-                for i in range(0,2):
-                  Coor_int.append((coord_nds[i][0][it],coord_nds[i][1][it]))
-                  Def_int.append((deforme[i][0][it],deforme[i][1][it]))
-                tmp_mesure[it] = mesure[Copeau_k][it] + NP.sqrt((Coor_int[0][0]+Def_int[0][0]-Coor_int[1][0]-Def_int[1][0])**2 + 
-                                 (Coor_int[0][1]+Def_int[0][1]-Coor_int[1][1]-Def_int[1][1])**2 )
-            
-              mesure[Copeau_k] = tmp_mesure
-    
-            else:
-              mesure[Copeau_k] = NP.sqrt((coord_nds[0][0][0]-coord_nds[1][0][0])**2 + (coord_nds[0][1][0]-coord_nds[1][1][0])**2 ) + mesure[Copeau_k]
+            tab_noeud = tab_noeud + [maya.NOMNOE.get()[connexe[i]-1] for i in range(2)]
+            tab_maille.append(maya.NOMMAI.get()[maille_courante])
+        tab_DEP_el = Coord_Recup(tab_noeud,tab_maille,resu)
+        num_ord_init  = tab_DEP_el.NUME_ORDRE[0]
+        # Calcul de la surface des mailles du copeau courant pour chaque instant
+        Coord_int = []
+        tab_DEP_el_ord = tab_DEP_el.NUME_ORDRE.values()
+        indices = [tab_DEP_el_ord.index(num_ord_init,x) for x in range(tab_DEP_el_ord.index(num_ord_init),tab_DEP_el_ord.index(num_ord_init)+tab_DEP_el_ord.count(num_ord_init))]
+        tab_noeud = [tab_DEP_el.NOEUD[x] for x in indices]
+        tab_coordX = [tab_DEP_el.COOR_X[x] for x in indices]
+        tab_coordY = [tab_DEP_el.COOR_Y[x] for x in indices]
+        tab_coordZ = [tab_DEP_el.COOR_Z[x] for x in indices]
+        for i_maille_courante in range(len(tab_maille)):
+           indic = [tab_noeud.index(tab_noeud[i_maille_courante*2+x]) for x in range(2)]
+           Coord_int = Coord_int + [(tab_coordX[indic[x]],tab_coordY[indic[x]],tab_coordZ[indic[x]]) for x in indic]
+                 
+        # Si le type est grandes déformations alors il faut tenir compte de la déformée lors du calcul de la surface
+        if type_def=='GRAND':
+          l_ord = list(set(tab_DEP_el_ord))
+          for it in range(num_ord):
+               Def_int   = []
+               indices = [tab_DEP_el_ord.index(l_ord[it],x) for x in range(tab_DEP_el_ord.index(l_ord[it]),tab_DEP_el_ord.index(l_ord[it])+tab_DEP_el_ord.count(l_ord[it]))]
+               tab_defoX = [tab_DEP_el.DX[x] for x in indices]
+               tab_defoY = [tab_DEP_el.DY[x] for x in indices]
+               tab_defoZ = [tab_DEP_el.DZ[x] for x in indices]
+               for i_maille_courante in range(len(tab_maille)):
+                   indic = [tab_noeud.index(tab_noeud[i_maille_courante*2+x]) for x in range(2)]
+                   Def_int   = Def_int   + [(tab_defoX[indic[x]], tab_defoY[indic[x]], tab_defoZ[indic[x]])  for x in indic]
+                   tmp_mesure[it] = mesure[Copeau_k][it] + NP.sqrt((Coord_int[0][0]+Def_int[0][0]-Coord_int[1][0]-Def_int[1][0])**2 + 
+                                 (Coord_int[0][1]+Def_int[0][1]-Coord_int[1][1]-Def_int[1][1])**2 + (Coord_int[0][2]+Def_int[0][2]-Coord_int[1][2]-Def_int[1][2])**2)
+          mesure[Copeau_k] = tmp_mesure
+        else:
+          mesure[Copeau_k] = mesure[Copeau_k] + NP.sqrt((Coord_int[0][0]-Coord_int[1][0])**2 + 
+                                 (Coord_int[0][1]-Coord_int[1][1])**2 + (Coord_int[0][2]-Coord_int[1][2])**2)
+
+   Supr_mano(maya,mon_nom)
+
    return mesure
        
 def Calcul_mesure_3D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,resu,type_def):
@@ -1372,62 +1332,94 @@ def Calcul_mesure_3D(is_2D,maya,nbcop,num_ord,l_copo_tot,ltyma,resu,type_def):
    # appartenant à l'axe de symétrie
 
    import numpy as NP
+   import aster
+   from Accas import _F
+   from Utilitai.Table        import Table
    
+   # Initialisation
+   coord_fond = []
    mesure={}
-   l_ep_copeaux_tot_3D = [] 
+   l_ep_copeaux_tot_3D = []   
+   
+   mon_nom = 'Mai_Plan'
+   COOR = maya.COORDO.VALE.get()
+
+   # Recupération des noeuds de fond de fissure appartenant à la tranche courante
+   Recup_Noeuds_Copeaux(False,maya,l_copo_tot[0])
+   Recup_3D(maya,0,mon_nom)
+   l_noeud_fond = [noeud_courant for noeud_courant in maya.GROUPENO.get()['Nds_Floc'.ljust(8)]]
+   tab_DEP_el   = Coord_Recup([maya.NOMNOE.get()[x-1] for x in maya.GROUPENO.get()['Nds_Floc'.ljust(8)]] ,None,resu)
+   coord_fond   = [(tab_DEP_el.COOR_X[x],tab_DEP_el.COOR_Y[x], tab_DEP_el.COOR_Z[x]) for x in range(len(l_noeud_fond))]
+   
    for C_k in range(len(l_copo_tot)) :
 
        Copeau_k = l_copo_tot[C_k]
+       
+       # Recupération des groupes de noeuds appartenant au copeau courant
        Recup_Noeuds_Copeaux(False,maya,Copeau_k)
-       Recup_3D(maya,C_k%nbcop)
+       Recup_3D(maya,C_k%nbcop,mon_nom)
 
+       # La mesure de la surface est cumulée
        if C_k%nbcop==0:
-          coord_fond = []
-          for noeud_courant in maya.GROUPENO.get()['Nds_Floc'.ljust(8)]:
-               tab_DEP_el = Coord_Recup(maya.NOMNOE.get()[noeud_courant-1],None,resu)
-               coord_fond.append((tab_DEP_el.COOR_X.values()[0],tab_DEP_el.COOR_Y.values()[0],tab_DEP_el.COOR_Z.values()[0]))
-               
           mesure[Copeau_k] = NP.zeros(num_ord)
        else :
           mesure[Copeau_k] = mesure[l_copo_tot[C_k-1]]
-
-       # Calcul de la surface des mailles du copeau courant pour chaque instant
-       mon_nom = 'Mai_Plan'
+          
+          
+       # Recupération des coordonnées des noeuds appartenant au copeau courant
        tmp_mesure = NP.zeros(num_ord)
+       tab_noeud  = []
+       tab_maille = []
        for maille_courante in maya.GROUPEMA.get()[mon_nom.ljust(8)]:
            if ltyma[maya.TYPMAIL.get()[maille_courante]][0:4]=='QUAD':
-               connexe = maya.CONNEX.get()[maille_courante]
-               coord_nds = []
-               deforme=[]
-               DEP_el = [None]*4
-               for i in range(0,4):
-                   tab_DEP_el = Coord_Recup(maya.NOMNOE.get()[connexe[i]-1],maya.NOMMAI.get()[maille_courante],resu)
-                   coord_nds.append((tab_DEP_el.COOR_X.values(),tab_DEP_el.COOR_Y.values(),
-                                   tab_DEP_el.COOR_Z.values()))
-                   deforme.append((tab_DEP_el.DX.values(),tab_DEP_el.DY.values(),
-                                   tab_DEP_el.DZ.values()))  
-
-               if type_def=='GRAND':
-                   for it in range(num_ord):
-                       Coor_int=[]
-                       Def_int=[]
-                       for i in range(0,4):
-                           Coor_int.append((coord_nds[i][0][it],coord_nds[i][1][it],coord_nds[i][2][it]))
-                           Def_int.append((deforme[i][0][it],deforme[i][1][it],deforme[i][2][it]))
-                       tmp_mesure[it] = mesure[Copeau_k][it] + CalSurf(Coor_int,Def_int)
-                   mesure[Copeau_k] = tmp_mesure
-               else:
-                   mesure[Copeau_k] = CalSurf(coord_nds,[tuple(NP.zeros(3))]*len(coord_nds)) + mesure[Copeau_k]
+               connexe   = maya.CONNEX.get()[maille_courante]
+               tab_noeud = tab_noeud + [maya.NOMNOE.get()[connexe[i]-1] for i in range(4)]
+               tab_maille.append(maya.NOMMAI.get()[maille_courante])
+       tab_DEP_el    = Coord_Recup(tab_noeud,tab_maille,resu)
+       num_ord_init  = tab_DEP_el.NUME_ORDRE[0]
+       
+       # Calcul de la surface des mailles du copeau courant pour chaque instant
+       Coord_int      = []
+       tab_DEP_el_ord = tab_DEP_el.NUME_ORDRE.values()
+       indices        = [tab_DEP_el_ord.index(num_ord_init,x) for x in range(tab_DEP_el_ord.index(num_ord_init),tab_DEP_el_ord.index(num_ord_init)+tab_DEP_el_ord.count(num_ord_init))]
+       tab_noeud      = [tab_DEP_el.NOEUD[x] for x in indices]
+       tab_coordX     = [tab_DEP_el.COOR_X[x] for x in indices]
+       tab_coordY     = [tab_DEP_el.COOR_Y[x] for x in indices]
+       tab_coordZ     = [tab_DEP_el.COOR_Z[x] for x in indices]
+       for i_maille_courante in range(len(tab_maille)):
+           indic = [tab_noeud.index(tab_noeud[i_maille_courante*4+x]) for x in range(4)]
+           Coord_int = Coord_int + [(tab_coordX[indic[x]],tab_coordY[indic[x]],tab_coordZ[indic[x]]) for x in indic]
+
+       # Si le type est grandes déformations alors il faut tenir compte de la déformée lors du calcul de la surface
+       if type_def=='GRAND':
+         l_ord = list(set(tab_DEP_el_ord))
+         for it in range(num_ord):
+               Def_int   = []
+               indices = [tab_DEP_el_ord.index(l_ord[it],x) for x in range(tab_DEP_el_ord.index(l_ord[it]),tab_DEP_el_ord.index(l_ord[it])+tab_DEP_el_ord.count(l_ord[it]))]
+               tab_defoX = [tab_DEP_el.DX[x] for x in indices]
+               tab_defoY = [tab_DEP_el.DY[x] for x in indices]
+               tab_defoZ = [tab_DEP_el.DZ[x] for x in indices]
+               surface_maille = 0.0
+               for i_maille_courante in range(len(tab_maille)):
+                   indic = [tab_noeud.index(tab_noeud[i_maille_courante*4+x]) for x in range(4)]
+                   Def_int   = Def_int   + [(tab_defoX[indic[x]], tab_defoY[indic[x]], tab_defoZ[indic[x]])  for x in indic]
+                   surface_maille = surface_maille + CalSurf(Coord_int,Def_int)
+               tmp_mesure[it] = mesure[Copeau_k][it] + surface_maille
+         mesure[Copeau_k] = tmp_mesure
+       else:
+         mesure[Copeau_k] = mesure[Copeau_k] + CalSurf(Coord_int,[tuple(NP.zeros(3))]*len(tab_noeud)) 
             
        # Calcul de la distance du copeau au fond d'entaille
        coord_nds = [] 
        dist_moy=0. 
        for noeud_courant in maya.GROUPENO.get()['Nds_Delt'.ljust(8)]:
-            tab_DEP_el = Coord_Recup(maya.NOMNOE.get()[noeud_courant-1],None,resu)
-            coord_nds = (tab_DEP_el.COOR_X.values()[0],tab_DEP_el.COOR_Y.values()[0],tab_DEP_el.COOR_Z.values()[0])
+            coord_nds = (COOR[(noeud_courant-1)*3],COOR[(noeud_courant-1)*3+1],COOR[(noeud_courant-1)*3+2])
             dist_moy  = dist_moy + CalDist(coord_nds,NP.zeros(3),coord_fond,[tuple(NP.zeros(3))]*len(coord_fond))
 
        l_ep_copeaux_tot_3D.append(dist_moy/len(maya.GROUPENO.get()['Nds_Delt'.ljust(8)]))
+       
+   Supr_mano(maya,mon_nom)
+   
    return mesure, l_ep_copeaux_tot_3D
 
 def Coord_Recup(noeud_courant,maille_courante,resu):
@@ -1443,7 +1435,7 @@ def Coord_Recup(noeud_courant,maille_courante,resu):
                     NOEUD=noeud_courant,MAILLE=maille_courante))
    else:
        dicarg.append(_F(OPERATION='EXTRACTION',RESULTAT=resu, INTITULE='DEP_el',
-                    TOUT_CMP='OUI',NOM_CHAM='DEPL', TOUT_ORDRE='OUI', 
+                    TOUT_CMP='OUI',NOM_CHAM='DEPL',  TOUT_ORDRE='OUI', 
                     NOEUD=noeud_courant))
 
    DEP_el_i = POST_RELEVE_T(ACTION=dicarg)
@@ -1451,12 +1443,12 @@ def Coord_Recup(noeud_courant,maille_courante,resu):
    DETRUIRE(CONCEPT=_F(NOM=DEP_el_i),INFO=1);  
    return tab_DEP_el
 
-def Supr_mano(maya):
+def Supr_mano(maya,mon_nom):
 
       from Accas import _F
       dicno=[];
       dicno.append(_F(NOM = 'Cop_Pl'));
-      dicno.append(_F(NOM = 'Mai_Plan'));
+      dicno.append(_F(NOM = mon_nom));
       dicno.append(_F(NOM = 'Mai_Pla1'));
       dicno.append(_F(NOM = 'Mai_Pla2'));
       dicno.append(_F(NOM = 'Nds_Plan'));
@@ -1464,38 +1456,7 @@ def Supr_mano(maya):
       dicno.append(_F(NOM = 'Nds_Floc'));
       dicno.append(_F(NOM = 'Nds_Delt'));
       dicma=[];
-      dicma.append(_F(NOM = 'Mai_Plan'));
+      dicma.append(_F(NOM = mon_nom));
       dicma.append(_F(NOM = 'Mai_Pla1'));
       dicma.append(_F(NOM = 'Mai_Pla2'));
       DEFI_GROUP(reuse =maya, MAILLAGE=maya, DETR_GROUP_NO=dicno, DETR_GROUP_MA=dicma);
-#-------------------------------------------------------------                          
-
-def Save_VALGP_DE_LISTINST (liste_inst_postgp,liste_inst_reduit, liste_inst_complete):
-  # sauvegarde les positions de liste des valeurs de GP à des instants définis par l'utilisateur sous le mot clé
-  # LIST_INST ou INST
-    
-  from Utilitai.Utmess       import UTMESS
-  temps_agarde_gp = []
-  trouve = False
-  for tmp_liste in liste_inst_postgp:
-    trouve = False
-    for tmp_resu_reduit in liste_inst_reduit:
-      if (tmp_liste == tmp_resu_reduit):
-          trouve = True
-          break
-    if (trouve == False):
-      UTMESS('F','POST0_36')
-
-  for tmp_liste in liste_inst_postgp :
-    compteur = 0
-    message  = True
-    for tmp_resu in liste_inst_complete : 
-      if (tmp_liste == tmp_resu) :              
-          temps_agarde_gp.append(compteur)
-      else :
-          if (message):
-            message = False
-      compteur = compteur + 1
-  if (len(temps_agarde_gp)==0):  
-          UTMESS('F','POST0_36')
-  return temps_agarde_gp

diff --git a/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py b/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py
index 620d1ecdfe60d66a6231c6df0ddd823ae727409e..a90171ab6cebf5be23d92b694e461b4e31d8d162 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py
@@ -1,28 +1,28 @@
-#@ MODIF post_k1_k2_k3_ops Macro  DATE 12/10/2010   AUTEUR GENIAUT S.GENIAUT 
+#@ MODIF post_k1_k2_k3_ops Macro  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 
 
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 #                 FONCTIONS UTILITAIRES
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
 def veri_tab(tab,nom,ndim) :
    from Utilitai.Utmess     import  UTMESS
@@ -38,7 +38,8 @@ def veri_tab(tab,nom,ndim) :
           label='COOR_Z'
           UTMESS('F','RUPTURE0_2',valk=[label,nom])
 
-#--------------------------------------------------------------------------------------------------------------- 
+
+#---------------------------------------------------------------------------------------------------------------
 
 # def cross_product(a,b):
 #     cross = [0]*3
@@ -46,14 +47,14 @@ def veri_tab(tab,nom,ndim) :
 #     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)
@@ -62,7 +63,7 @@ def complete(Tab):
     return Tab
 
  
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 # sam : la methode average(t) ne repond-elle pas au besoin ?
 def moy(t):
     m = 0
@@ -70,7 +71,7 @@ def moy(t):
       m += value
     return (m/len(t))
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
 def InterpolFondFiss(s0, Coorfo) :
 # Interpolation des points du fond de fissure (xfem)
@@ -94,7 +95,7 @@ def InterpolFondFiss(s0, Coorfo) :
    xyz[3] = s0
    return xyz
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
 def InterpolBaseFiss(s0, Basefo, Coorfo) :
 # Interpolation de la base locale en fond de fissure
@@ -117,7 +118,7 @@ def InterpolBaseFiss(s0, Basefo, Coorfo) :
       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
@@ -127,7 +128,7 @@ def verif_type_fond_fiss(ndim,FOND_FISS) :
       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"""
@@ -141,7 +142,7 @@ def get_noeud_fond_fiss(FOND_FISS) :
    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"""
@@ -225,7 +226,7 @@ def get_noeud_a_calculer(Lnoff,ndim,FOND_FISS,MAILLAGE,EnumTypes,args) :
       
       return Lnocal
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
 def get_coor_libre(self,Lnoff,RESULTAT,ndim):
          """ retourne les coordonnes des noeuds de FOND_FISS en dictionnaire"""
@@ -260,15 +261,19 @@ def get_coor_libre(self,Lnoff,RESULTAT,ndim):
          l_coorf = [(i[0],i[1:]) for i in l_coorf]
          return dict(l_coorf) 
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
-def get_Plev(self,MAILLAGE,ListmaS,RESULTAT):
+def get_Plev(self,ListmaS,RESULTAT):
          """ retourne les coordonnes d'un point quelconque des levres pr determination sens de propagation"""
          import numpy as NP
          from Accas import _F
+         import aster
          POST_RELEVE_T    = self.get_cmd('POST_RELEVE_T')
          DETRUIRE         = self.get_cmd('DETRUIRE')
 
+         iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',RESULTAT.nom,'RESULTAT')
+         MAILLAGE = self.get_concept(nom_ma.strip())
+
          cmail=MAILLAGE.NOMMAI.get()
          for i in range(len(cmail)) :
              if cmail[i] == ListmaS[0] :
@@ -295,7 +300,7 @@ def get_Plev(self,MAILLAGE,ListmaS,RESULTAT):
          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,
@@ -350,20 +355,19 @@ def get_normale(VECT_K1,Nnoff,ndim,DTANOR,DTANEX,d_coorf,Lnoff,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"""
+      tous les points 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
+      mcfact=[]
       for i in xrange(Nnocal):
          Porig = NP.array(d_coorf[Lnocal[i]] )
          if Lnocal[i]==Lnoff[0] and DTANOR : 
@@ -373,30 +377,28 @@ def get_tab_dep(self,Lnocal,Nnocal,Nnoff,d_coorf,Lnoff,DTANOR,DTANEX,ABSC_CURV_M
          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),);
+         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),)
 
+      __TlibS = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
+                              NOM_CHAM='DEPL',
+                              MODELE=MODEL, 
+                              VIS_A_VIS=_F(MAILLE_1 = ListmaS),
+                              LIGN_COUPE=mcfact)
 
-         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)
-
-#--------------------------------------------------------------------------------------------------------------- 
+      if SYME_CHAR=='SANS':
+         __TlibI = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
+                                 NOM_CHAM='DEPL',
+                                 MODELE=MODEL,
+                                 VIS_A_VIS=_F(MAILLE_1 = ListmaI),
+                                 LIGN_COUPE=mcfact)
+
+      return (__TlibS.EXTR_TABLE(),__TlibI.EXTR_TABLE())
+
+#---------------------------------------------------------------------------------------------------------------
 
 def get_dico_levres(lev,FOND_FISS,ndim,Lnoff,Nnoff):
       "retourne ???"""
@@ -418,7 +420,7 @@ def get_dico_levres(lev,FOND_FISS,ndim,Lnoff,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"""
@@ -478,7 +480,7 @@ def get_coor_regle(self,RESULTAT,ndim,Lnoff,Lnocal,dicoS,SYME_CHAR,dicoI,TABL_DE
       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"""
@@ -491,7 +493,7 @@ def get_absfon(Lnoff,Nnoff,d_coor):
          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"""
@@ -563,7 +565,7 @@ def get_noeuds_perp_regle(Lnocal,d_coor,dicoS,dicoI,Lnoff,PREC_VIS_A_VIS,ABSC_CU
 
       return (Lnofon, Lnosup, Lnoinf) 
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
 def verif_resxfem(self,RESULTAT) :
       """ verifie que le resultat est bien compatible avec X-FEM et renvoie xcont et MODEL"""
@@ -579,33 +581,41 @@ def verif_resxfem(self,RESULTAT) :
       xcont = MODEL.xfem.XFEM_CONT.get()
       return (xcont,MODEL)
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
-def get_resxfem(self,xcont,RESULTAT,MAILLAGE,MODELISATION,MODEL) :
+def get_resxfem(self,xcont,RESULTAT,MODELISATION,MODEL) :
       """ retourne le resultat """
       from Accas import _F
+      import aster
 
       AFFE_MODELE      = self.get_cmd('AFFE_MODELE')
       PROJ_CHAMP       = self.get_cmd('PROJ_CHAMP')
       DETRUIRE         = self.get_cmd('DETRUIRE')
+      CREA_MAILLAGE    = self.get_cmd('CREA_MAILLAGE')
 
+      iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',RESULTAT.nom,'RESULTAT')
       if xcont[0] == 0 :
          __RESX = RESULTAT
 
 #     XFEM + contact : il faut reprojeter sur le maillage lineaire
       elif xcont[0] != 0 :
-         __MODLINE=AFFE_MODELE(MAILLAGE=MAILLAGE,
+         MAILL1 = self.get_concept(nom_ma.strip())
+         MAILL2 = CREA_MAILLAGE(MAILLAGE = MAILL1,
+                               QUAD_LINE =_F(TOUT = 'OUI',),);
+
+         __MODLINE=AFFE_MODELE(MAILLAGE=MAILL2,
                                AFFE=(_F(TOUT='OUI',
                                         PHENOMENE='MECANIQUE',
-                                        MODELISATION=MODELISATION,),),);        
+                                        MODELISATION=MODELISATION,),),); 
 
-         __RESX=PROJ_CHAMP(METHODE='COLOCATION',
+         __RESX=PROJ_CHAMP(METHODE='COLLOCATION',
                            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
@@ -897,8 +907,7 @@ def get_tab(self,lev,ino,Tlib,Lno,TTSo,FOND_FISS,FISSURE,TYPE_MAILLAGE,RESULTAT,
 
          if FOND_FISS : 
             if TYPE_MAILLAGE =='LIBRE':
-               tab=Tlib[ino].EXTR_TABLE()
-               DETRUIRE(CONCEPT=_F(NOM=Tlib[ino]),INFO=1)
+               tab = Tlib.INTITULE=='l.coupe%i'%(ino+1)
             elif RESULTAT :
                if ndim == 2:
                   nomcmp= ('DX','DY')
@@ -1449,6 +1458,100 @@ def get_meth3(self,abscs,coefg,coefg3,kgsig,isig,saut2,INFO,ndim) :
 
 #---------------------------------------------------------------------------------------------------------------
 
+def get_erreur(self,ndim,__tabi) :
+
+      """retourne l'erreur selon les méthodes. 
+      En FEM/X-FEM, on ne retient que le K_MAX de la méthode 1."""
+      from Accas import _F
+      import aster
+      import string
+      import numpy as NP
+
+      CREA_TABLE    = self.get_cmd('CREA_TABLE')
+      CALC_TABLE    = self.get_cmd('CALC_TABLE')
+      DETRUIRE      = self.get_cmd('DETRUIRE')
+      FORMULE       = self.get_cmd('FORMULE')
+
+      labels = ['K1_MAX', 'K1_MIN', 'K2_MAX', 'K2_MIN', 'K3_MAX', 'K3_MIN']
+      index = 2
+      if ndim == 3:
+         index = 3
+      py_tab = __tabi.EXTR_TABLE()
+
+      nlines = len(py_tab.values()[py_tab.values().keys()[0]])
+      err = NP.zeros((index, nlines/3))
+      kmax = [0.] * index
+      kmin = [0.] * index
+      for i in range(nlines/3):
+         for j in range(index):
+            kmax[j] = max(__tabi[labels[  2*j], 3*i+1], __tabi[labels[  2*j], 3*i+2], __tabi[labels[  2*j], 3*i+3])
+            kmin[j] = min(__tabi[labels[2*j+1], 3*i+1], __tabi[labels[2*j+1], 3*i+2], __tabi[labels[2*j+1], 3*i+3])
+         kmaxmax = max(kmax)
+         if NP.fabs(kmaxmax) > 1e-15:
+            for j in range(index):
+               err[j,i] = (kmax[j] - kmin[j]) / kmaxmax
+
+      # filter method 1 line
+      imeth = 1
+      __tabi = CALC_TABLE(TABLE=__tabi,
+                          reuse=__tabi,
+                          ACTION=_F(OPERATION='FILTRE',
+                                    CRIT_COMP='EQ',
+                                    VALE = imeth,
+                                    NOM_PARA='METHODE')
+                          )
+
+      # rename k parameters
+      __tabi = CALC_TABLE(TABLE=__tabi,
+                          reuse=__tabi,
+                          ACTION=(_F(OPERATION='RENOMME',NOM_PARA=('K1_MAX','K1')),
+                                  _F(OPERATION='RENOMME',NOM_PARA=('K2_MAX','K2')),
+                                  _F(OPERATION='RENOMME',NOM_PARA=('G_MAX','G')))
+                        )
+      if ndim == 3:
+        __tabi = CALC_TABLE(TABLE=__tabi,
+                            reuse=__tabi,
+                            ACTION=_F(OPERATION='RENOMME',NOM_PARA=('K3_MAX','K3'))
+                            )
+
+      # create error
+      if ndim != 3:
+         tab_int = CREA_TABLE(LISTE=(_F(LISTE_R=(tuple(__tabi.EXTR_TABLE().values()['G_MIN'])), PARA='G_MIN'),
+                                     _F(LISTE_R=(tuple(err[0].tolist())), PARA='ERR_K1'),
+                                     _F(LISTE_R=(tuple(err[1].tolist())), PARA='ERR_K2')))
+      else:
+         tab_int = CREA_TABLE(LISTE=(_F(LISTE_R=(tuple(__tabi.EXTR_TABLE().values()['G_MIN'])), PARA='G_MIN'),
+                                     _F(LISTE_R=(tuple(err[0].tolist())), PARA='ERR_K1'),
+                                     _F(LISTE_R=(tuple(err[1].tolist())), PARA='ERR_K2'),
+                                     _F(LISTE_R=(tuple(err[2].tolist())), PARA='ERR_K3')))
+
+      # add error
+      __tabi = CALC_TABLE(TABLE=__tabi,reuse=__tabi,ACTION=(_F(OPERATION='COMB',NOM_PARA='G_MIN',TABLE=tab_int)),INFO=1)
+      DETRUIRE(CONCEPT=(_F(NOM=tab_int)),INFO=1)
+
+      # remove kj_min + sort data
+      params = ()
+      if ('INST' in __tabi.EXTR_TABLE().para) : params = ('INST',)
+      if ('NOEUD_FOND' in __tabi.EXTR_TABLE().para) :
+          params =  params + ('NOEUD_FOND',)
+      elif ('PT_FOND' in __tabi.EXTR_TABLE().para) :
+          params =  params + ('PT_FOND',)
+
+      if ('ABSC_CURV' in __tabi.EXTR_TABLE().para) :
+          params = params + ('ABSC_CURV',)
+
+      params = params + ('K1', 'ERR_K1', 'K2', 'ERR_K2',)
+      if ndim == 3: params = params + ('K3', 'ERR_K3', 'G',)
+      else: params = params + ('G',)
+
+      __tabi = CALC_TABLE(TABLE=__tabi,
+                          reuse=__tabi,ACTION=(_F(OPERATION='EXTR',NOM_PARA=tuple(params))),
+                          TITRE="CALCUL DES FACTEURS D'INTENSITE DES CONTRAINTES PAR LA METHODE POST_K1_K2_K3")
+
+      return __tabi
+
+#---------------------------------------------------------------------------------------------------------------
+
 def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord,
                Lnofon,dicoF,absfon,Nnoff,tabout) :
 
@@ -1460,7 +1563,7 @@ def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord,
       CREA_TABLE    = self.get_cmd('CREA_TABLE')
       DETRUIRE      = self.get_cmd('DETRUIRE')
       CALC_TABLE    = self.get_cmd('CALC_TABLE')
-
+      
 
       mcfact=[]
 
@@ -1496,19 +1599,22 @@ def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord,
 
       if  (ino==0 and iord==0) and inst==None :
          tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre)
+         get_erreur(self,ndim,tabout)
       elif iord==0 and ino==0 and inst!=None :
          mcfact=[_F(PARA='INST'  ,LISTE_R=[inst,]*3      )]+mcfact
          tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre)
+         get_erreur(self,ndim,tabout)
       else :
          if inst!=None :
             mcfact=[_F(PARA='INST'  ,LISTE_R=[inst,]*3     )]+mcfact
          __tabi=CREA_TABLE(LISTE=mcfact,)
-         npara = ['K1_MAX','METHODE']
+         npara = ['K1']
          if inst!=None :
             npara.append('INST')
          if FOND_FISS and MODELISATION=='3D' :
             npara.append('NOEUD_FOND')
 
+         get_erreur(self,ndim,__tabi)
          tabout=CALC_TABLE(reuse = tabout,
                            TABLE = tabout,
                            TITRE = titre,
@@ -1520,9 +1626,9 @@ def get_tabout(self,kg,TITRE,FOND_FISS,MODELISATION,FISSURE,ndim,ino,inst,iord,
 
 
 
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 #                 CORPS DE LA MACRO POST_K1_K2_K3
-#--------------------------------------------------------------------------------------------------------------- 
+#---------------------------------------------------------------------------------------------------------------
 
 def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
                    TABL_DEPL_SUP,TABL_DEPL_INF,ABSC_CURV_MAXI,PREC_VIS_A_VIS,
@@ -1567,7 +1673,6 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
    MACR_LIGN_COUPE  = self.get_cmd('MACR_LIGN_COUPE')
    AFFE_MODELE      = self.get_cmd('AFFE_MODELE')
    PROJ_CHAMP       = self.get_cmd('PROJ_CHAMP')
-     
 #   ------------------------------------------------------------------
 #                         CARACTERISTIQUES MATERIAUX
 #   ------------------------------------------------------------------
@@ -1658,7 +1763,12 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
 
    if FOND_FISS : 
 
-      MAILLAGE = args['MAILLAGE']
+      if RESULTAT :
+        iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',RESULTAT.nom,'RESULTAT')
+        MAILLAGE = self.get_concept(nom_ma.strip())
+      else:
+        MAILLAGE = args['MAILLAGE']
+
       NB_NOEUD_COUPE = args['NB_NOEUD_COUPE']
 
 #     Verification du type des mailles de FOND_FISS
@@ -1701,7 +1811,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
          d_coorf = get_coor_libre(self,Lnoff,RESULTAT,ndim)
 
 #        Coordonnee d un pt quelconque des levres pour determination sens de propagation
-         Plev = get_Plev(self,MAILLAGE,ListmaS,RESULTAT)
+         Plev = get_Plev(self,ListmaS,RESULTAT)
 
 #        Calcul des normales a chaque noeud du fond
          if ndim == 3 :
@@ -1720,7 +1830,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
          MODEL = self.get_concept(n_modele)
          dmax  = PREC_VIS_A_VIS * ABSC_CURV_MAXI
 
-         (TlibS,TlibI) = get_tab_dep(self,Lnocal,Nnocal,Nnoff,d_coorf,Lnoff,DTANOR,DTANEX,ABSC_CURV_MAXI,dicVN,sens,RESULTAT,MODEL,
+         (__TlibS,__TlibI) = get_tab_dep(self,Lnocal,Nnocal,Nnoff,d_coorf,Lnoff,DTANOR,DTANEX,ABSC_CURV_MAXI,dicVN,sens,RESULTAT,MODEL,
                                      ListmaS,ListmaI,NB_NOEUD_COUPE,dmax,SYME_CHAR)
 
 
@@ -1757,7 +1867,12 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
 
    elif FISSURE :
 
-      MAILLAGE = args['MAILLAGE']
+      if RESULTAT :
+        iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',RESULTAT.nom,'RESULTAT')
+        MAILLAGE = self.get_concept(nom_ma.strip())
+      else:
+        MAILLAGE = args['MAILLAGE']
+
       DTAN_ORIG = args['DTAN_ORIG']
       DTAN_EXTR = args['DTAN_EXTR']
       dmax  = PREC_VIS_A_VIS * ABSC_CURV_MAXI
@@ -1768,7 +1883,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
          UTMESS('F','RUPTURE0_4')
 
 #     Recuperation du resultat
-      __RESX = get_resxfem(self,xcont,RESULTAT,MAILLAGE,MODELISATION,MODEL)
+      __RESX = get_resxfem(self,xcont,RESULTAT,MODELISATION,MODEL)
 
 #     Recuperation des coordonnees des points du fond de fissure (x,y,z,absc_curv)
       (Coorfo, Vpropa, Nnoff) = get_coor_xfem(args,FISSURE,ndim)
@@ -1808,8 +1923,8 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
    #  creation des objets vides s'ils n'existent pas
    #  de maniere a pouvoir les passer en argument des fonctions
    #  c'est pas terrible : il faudrait harmoniser les noms entre les différents cas
-   if 'TlibS'  not in locals() : TlibS  = []
-   if 'TlibI'  not in locals() : TlibI  = []
+   if '__TlibS'  not in locals() : __TlibS  = []
+   if '__TlibI'  not in locals() : __TlibI  = []
    if 'Lnosup' not in locals() : Lnosup = []
    if 'Lnoinf' not in locals() : Lnoinf = []
    if 'TTSo'   not in locals() : TTSo   = []
@@ -1847,9 +1962,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
       affiche_traitement(FOND_FISS,INFO,FISSURE,Lnofon,ino)
 
 #     table 'depsup' et 'depinf'
-      tabsup = get_tab(self,'sup',ino,TlibS,Lnosup,TTSo,
+      tabsup = get_tab(self,'sup',ino,__TlibS,Lnosup,TTSo,
                        FOND_FISS,FISSURE,TYPE_MAILLAGE,RESULTAT,SYME_CHAR,TABL_DEPL_SUP,ndim)
-      tabinf = get_tab(self,'inf',ino,TlibI,Lnoinf,TTSo,
+      tabinf = get_tab(self,'inf',ino,__TlibI,Lnoinf,TTSo,
                        FOND_FISS,FISSURE,TYPE_MAILLAGE,RESULTAT,SYME_CHAR,TABL_DEPL_INF,ndim)
 
 #     les instants de post-traitement : creation de l_inst
@@ -1925,9 +2040,8 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
       tabout=CALC_TABLE(reuse=tabout,
                         TABLE=tabout,
                         ACTION=_F(OPERATION = 'TRI',
-                                  NOM_PARA=('INST','ABSC_CURV','METHODE'),
+                                  NOM_PARA=('INST','ABSC_CURV'),
                                   ORDRE='CROISSANT'))
 
-
    return ier
  

diff --git a/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py b/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py
index d0a3b8908b9722cd9022a995d3520597309fc477..3fbdf9893e385cc819787c41b3466df1c29dbbcc 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF post_k_trans_ops Macro  DATE 07/10/2008   AUTEUR PELLET J.PELLET 
+#@ MODIF post_k_trans_ops Macro  DATE 25/01/2011   AUTEUR MACOCCO K.MACOCCO 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -186,9 +186,9 @@ def post_k_trans_ops(self,RESU_TRANS,K_MODAL,TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE,
   if F3D : 
     K3mod = [None]*n_mode*nbno
     K3t = [None]*nbarch*nbno
-    k1 = 'K1_LOCAL'
-    k2 = 'K2_LOCAL'
-    k3 = 'K3_LOCAL'
+    k1 = 'K1'
+    k2 = 'K2'
+    k3 = 'K3'
   else :
     k1 = 'K1'
     k2 = 'K2'

diff --git a/Aster/Cata/cataSTA10/Macro/post_miss_ops.py b/Aster/Cata/cataSTA10/Macro/post_miss_ops.py
new file mode 100644 (file)
index 0000000..ee4aac3
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/post_miss_ops.py
@@ -0,0 +1,52 @@
+#@ MODIF post_miss_ops Macro  DATE 01/03/2011   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+import sys
+import os
+import traceback
+
+
+def post_miss_ops(self, **kwargs):
+    """Macro POST_MISS :
+    Post-traitement d'un calcul MISS3D
+    """
+    import aster
+    from Utilitai.Utmess  import UTMESS
+    from Miss.miss_post import PostMissFactory
+    
+    ier = 0
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    # création de l'objet POST_MISS_xxx
+    post = PostMissFactory(kwargs['OPTION'], self, kwargs)
+
+    try:
+        post.argument()
+        post.execute()
+        post.sortie()
+    except aster.error, err:
+        UTMESS('F', err.id_message, valk=err.valk, vali=err.vali, valr=err.valr)
+    except Exception, err:
+        trace = ''.join(traceback.format_tb(sys.exc_traceback))
+        UTMESS('F', 'SUPERVIS2_5', valk=('POST_MISS', trace, str(err)))
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py
index 04b333fb30e78f87cc7e3f774b790752e7c1d4fa..34943b921f301b5a6f0e5e3d964715b35c62ac01 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF propa_fiss_ops Macro  DATE 24/11/2010   AUTEUR MICOL A.MICOL 
+#@ MODIF propa_fiss_ops Macro  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -18,7 +18,7 @@
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
 
-from math import atan, atan2, cos, sin
+from math import atan, atan2, cos, sin, log
 
 import numpy as NP
 from Accas import _F
@@ -106,6 +106,7 @@ def betaf(k1,k2) :
   return beta
 
 def recup_Elas(LOI):
+      from SD.sd_mater     import sd_compor1
       if LOI == None :
          UTMESS('F','RUPTURE1_50') 
       dLoi=LOI[0].cree_dict_valeurs(LOI[0].mc_liste)
@@ -133,6 +134,29 @@ def recup_Elas(LOI):
         e  = dicmat['E']
         nu = dicmat['NU'] 
       return e,nu,dLoi
+
+def nom_points_fonds(n_taille):
+   """
+   Construction des noms des points en fond de fissure
+   """
+   alphabet            = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];
+   if n_taille <= 26:
+       return alphabet[:n_taille]
+   else:
+       tab_alphabet        = alphabet  
+       taille_tab_alphabet = int(log(n_taille,26))
+       for l_let1 in range(1,taille_tab_alphabet):
+               for l_let2 in range(26):
+                   for l_let3 in range(26):
+                       tab_alphabet =  tab_alphabet + [tab_alphabet[(l_let1-1)*26+l_let2]+alphabet[l_let3]]       
+       reste1 = int(n_taille-len(tab_alphabet))/26
+       for l_let2 in range(reste1):
+                  for l_let3 in range(26):
+                      tab_alphabet =  tab_alphabet + [tab_alphabet[(taille_tab_alphabet-1)*26+l_let2]+alphabet[l_let3]]
+       reste2 = int(n_taille-len(tab_alphabet))
+       for l_let3 in range(reste2):
+                   tab_alphabet =  tab_alphabet + [tab_alphabet[(taille_tab_alphabet-1)*26+reste1]+alphabet[l_let3]]
+       return tab_alphabet  
     
 #def propa_fiss_ops(self,METHODE_PROPA,TEST_MAIL,INFO,**args):
 def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
@@ -147,7 +171,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
   from Accas import _F
   from Utilitai.Utmess     import  UTMESS
   from Utilitai.partition import MAIL_PY
-  from SD.sd_mater     import sd_compor1
 
   EnumTypes = (ListType, TupleType)
   
@@ -208,10 +231,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
     NbPointFond = []
     
     for Fiss in Fissures :
-        if Fiss['GRILLE_AUX']!=None :
-           GrilleAux.append(Fiss['GRILLE_AUX'])
-        else :
-           GrilleAux.append(args['MODELE'])
         FissAct.append(Fiss['FISS_ACTUELLE'])
         FissNou.append(Fiss['FISS_PROPAGEE'])
         if TEST_MAIL == 'NON':
@@ -242,11 +261,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
 #      propagating crack.
        for NumFiss in range(0,len(FissAct)) :
            mcsimp['FISS_PROP'] = FissAct[NumFiss]
-           mcsimp['GRILLE_AUX'] = 123
-           if GrilleAux[NumFiss]!=args['MODELE'] : 
-               mcsimp['GRILLE_AUX'] = GrilleAux[NumFiss]
-           else :
-               del mcsimp['GRILLE_AUX']
            self.DeclareOut('nomfiss',FissNou[NumFiss])
            nomfiss = PROPA_XFEM(METHODE=METHODE_PROPA,INFO=INFO,**mcsimp )
            
@@ -282,11 +296,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
                  mcsimp['MODELE'] = __Mod[NumStep-1]
                  mcsimp['FISS_PROP'] = __Fis[(NumStep-1)*len(FissAct)+NumFiss]
               mcsimp['FISS_INITIALE'] = FissAct[NumFiss]
-              mcsimp['GRILLE_AUX'] = 123
-              if GrilleAux[NumFiss]!=args['MODELE'] : 
-                 mcsimp['GRILLE_AUX'] = GrilleAux[NumFiss]
-              else :
-                  del mcsimp['GRILLE_AUX']
               if NumStep==StepTot-1 :
                  self.DeclareOut('nomfiss',FissNou[NumFiss])
                  nomfiss = PROPA_XFEM(METHODE=METHODE_PROPA,INFO=INFO,**mcsimp )
@@ -308,9 +317,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
 #------------------------------------------------------------------
 # CAS 2 : METHODE_PROPA = 'MAILLAGE'
 #
-# il faudrait rendre cela plus automatique pour lever la limite a 52 points
-  ALPHABET=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];
-#            'AA','AB','AC','AD','AE','AF','AG','AH','AI','AJ','AK','AL','AM','AN','AO','AP','AQ','AR','AS','AT','AU','AV','AW','AX','AY','AZ'];
   
   if METHODE_PROPA == 'MAILLAGE' :
     Fissures =  args['FISSURE']
@@ -359,146 +365,98 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
          UTMESS('F','RUPTURE1_48',vali=Nbfiss)
 
 # Recuperation des K et calcul de DeltaK
-      Nmeth = Fiss['METHODE_POSTK']
       SIF = Fiss['TABLE']
       nbinst = 1
-# A- TABLEAU ISSSU DE POST_K1_K2_K3    
-      if  (Nmeth != None) :
-         __TABN = CALC_TABLE(TABLE=SIF,ACTION=_F(OPERATION='FILTRE',
-                                           NOM_PARA='METHODE',VALE_I=Nmeth),);
-         __tabp = __TABN.EXTR_TABLE()
-         if ('K1_MAX' not in __tabp.para) or ('G_MAX' not in __tabp.para):
-            UTMESS('F','RUPTURE1_44')
-         __tab1 = __tabp.values()
-         nbinst = 1
-         if 'INST' in __tabp.para : 
-           l_inst_tab=__tabp['INST'].values()['INST']
-           l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys()
-           nbinst = len(l_inst_tab)
-         nbptfon = len(__tab1['K1_MAX']) / nbinst
-         R[numfis] = [None]*nbptfon
-         RmM[numfis] = [None]*nbptfon
-         DKeq[numfis] = [None]*nbptfon
-         BETA[numfis] = [None]*nbptfon
-         absc = [0.]*nbptfon
-         if nbinst > 1 :
-           for k in range(nbptfon) :
-             if (dime == 2) : __tmp = __tabp
-             if (dime == 3) : __tmp = __tabp.PT_FOND==(k+1)
-             if (dime == 3) : absc[k]=__tmp['ABSC_CURV'][k]
-             ddkeq = NP.sqrt(YOUNG)*(NP.sqrt(max(__tmp.values()['G_MAX'])) 
-                          - NP.sqrt(min(__tmp.values()['G_MAX']))) 
-             rminmax = NP.sqrt(min(__tmp.values()['G_MAX'])) / NP.sqrt(max(__tmp.values()['G_MAX']))
-             DKeq[numfis][k] = [absc[k], ddkeq ]
-             RmM[numfis][k]  =   [absc[k], rminmax ]
-             k1 = __tmp.values()['K1_MAX']
-             k2 = __tmp.values()['K2_MAX']
-             betat = [0.]*nbinst
-             for jt in range(nbinst) :
-               betat[jt] = betaf(k1[jt],k2[jt])
+      __tabp = SIF.EXTR_TABLE()
+      if ('K1' not in __tabp.para) or ('G' not in __tabp.para):
+         UTMESS('F','RUPTURE1_44')
+
+      __tab1 = __tabp.values()
+      
+      if 'INST' in __tabp.para : 
+        l_inst_tab=__tabp['INST'].values()['INST']
+        l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys()
+        nbinst = len(l_inst_tab)
+      nbptfon = len(__tab1['K1']) / nbinst
+      RmM[numfis] = [None]*nbptfon
+      DKeq[numfis] = [None]*nbptfon
+      BETA[numfis] = [None]*nbptfon
+      
+# Lorsque le calcul porte sur plusieurs instants 
+      if nbinst > 1 :
+        for k in range(nbptfon) :
+          if (dime == 2) : __tmp = __tabp
+          if (dime == 3) :
+              if __tabp.PT_FOND :
+                  __tmp = __tabp.PT_FOND==(k+1)
+                  indice_k = k
+              else:
+                  __tmp = __tabp.NUM_PT==(k+1)
+                  indice_k = 0
+          if ('ABSC_CURV' in __tmp.values()):
+              abscisse_curv_courante = __tmp.values()['ABSC_CURV'][indice_k]
+          else:
+              abscisse_curv_courante = 0.
+          ddkeq = NP.sqrt(YOUNG)*(NP.sqrt(max(__tmp.values()['G'])) 
+                       - NP.sqrt(min(__tmp.values()['G']))) 
+          rminmax = NP.sqrt(min(__tmp.values()['G'])) / NP.sqrt(max(__tmp.values()['G']))
+          DKeq[numfis][k] = [abscisse_curv_courante, ddkeq ]
+          RmM[numfis][k]  =   [abscisse_curv_courante, rminmax ]
+          if ('BETA' in __tmp.values()):
+               dbeta = max(__tmp.values()['BETA'])-min(__tmp.values()['BETA'])
+               if dbeta > (5./180.*3.1415) :
+                   UTMESS('F','XFEM2_72')
+               BETA[numfis][k] = [abscisse_curv_courante, __tmp.values()['BETA'][0] ]
+          else:
+               if (dime == 2) :
+                  k1 = __tmp.values()['K1'][k]
+                  k2 = __tmp.values()['K2'][k]
+                  BETA[numfis][k]=[0., betaf(k1,k2)]
+               else:
+                  k1 = __tmp.values()['K1']
+                  k2 = __tmp.values()['K2']
+                  betat = [0.]*nbinst
+                  for jt in range(nbinst) :
+                      betat[jt] = betaf(k1[jt],k2[jt])
 # ANGLE BETA NE DOIT PAS TROP VARIER ENTRE LES PAS DE TEMPS
-             dbeta = max(betat) - min(betat) 
-             if dbeta > (5./180.*3.1415) :
-                  UTMESS('F','XFEM2_72')
-             BETA[numfis][k] = [absc[k], betat[0] ]
-             VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) 
-             VMAX = max(VMAX,VMAX0 )
-         else :
-            if COMP_LINE == None :
-              UTMESS('A','XFEM2_76')
-              CMIN = 0.
-              CMAX = 1.
-            else :
-              CMIN = COMP_LINE['COEF_MULT_MINI']
-              CMAX = COMP_LINE['COEF_MULT_MAXI']
-            if (min(__tab1['G_MAX']) < 0.) :
-              UTMESS('F','RUPTURE1_46')
-            DKmax0 = max(NP.sqrt(__tab1['G_MAX']))
-            DKmax = max(DKmax,DKmax0)
-            for k in range(nbptfon) :
-              k1 = __tab1['K1_MAX'][k]
-              k2 = __tab1['K2_MAX'][k]
-              if (dime == 3) : absc[k]=__tab1['ABSC_CURV'][k]
-              BETA[numfis][k] = [absc[k] , betaf(k1,k2)] 
-              DKeq[numfis][k] = [absc[k],NP.sqrt(YOUNG)*NP.sqrt(__tab1['G_MAX'][k])]
-              RmM[numfis][k] = [absc[k], CMIN/CMAX]
-              VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) 
-              VMAX = max(VMAX,VMAX0 )
-# B- TABLEAU ISSSU DE CALC_G (option CALC_K_G)
+                  dbeta = max(betat) - min(betat) 
+                  if dbeta > (5./180.*3.1415) :
+                     UTMESS('F','XFEM2_72')
+          VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) 
+          VMAX = max(VMAX,VMAX0 )
+# Lorsque le calcul porte un seul instant 
       else :
-         __tabp = SIF.EXTR_TABLE()
-         if (dime == 3) and (('K1_LOCAL' not in __tabp.para) or ('G_LOCAL' not in __tabp.para) or ('BETA_LOCAL' not in __tabp.para)):
-            UTMESS('F','RUPTURE1_45')
-         if (dime == 2) and (('K1' not in __tabp.para) or ('G' not in __tabp.para)) :
-            UTMESS('F','RUPTURE1_45')
-         __tab1= __tabp.values()
-         if 'INST' in __tabp.para : 
-           l_inst_tab=__tabp['INST'].values()['INST']
-           l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys()
-           nbinst = len(l_inst_tab)
-         if (dime == 2) : nbptfon = 1
-         if (dime == 3) : nbptfon = len(__tab1['G_LOCAL']) / nbinst
-         RmM[numfis] = [None]*nbptfon
-         DKeq[numfis] = [None]*nbptfon
-         BETA[numfis] = [None]*nbptfon
-         if nbinst > 1 :
-           for k in range(nbptfon) :
-              if (dime == 3) : 
-                __tmp = __tabp.NUM_PT==(k+1)
-                if (min(__tmp['G_LOCAL']) < 0.) :
-                  UTMESS('F','RUPTURE1_46')
-                absc = __tmp.values()['ABSC_CURV'][0]
-                DKeq[numfis][k]=[absc, NP.sqrt(YOUNG)*(NP.sqrt(max(__tmp.values()['G_LOCAL']))-NP.sqrt(min(__tmp.values()['G_LOCAL'])))]
-                RmM[numfis][k] = [absc, NP.sqrt(min(__tmp.values()['G_LOCAL'])) / NP.sqrt(max(__tmp.values()['G_LOCAL']))]
-                dbeta = max(__tmp.values()['BETA_LOCAL'])-min(__tmp.values()['BETA_LOCAL'])
-                if dbeta > (5./180.*3.1415) :
-                  UTMESS('F','XFEM2_72')
-                BETA[numfis][k] = [absc, __tmp.values()['BETA_LOCAL'][0] ]
-              else :
-                if (min(__tabp.values()['G']) < 0.) :
-                  UTMESS('F','RUPTURE1_46')
-                DKeq[numfis][k]=[0.,NP.sqrt(YOUNG)*(NP.sqrt(max(__tabp.values()['G']))-NP.sqrt(min(__tabp.values()['G'])))]
-                RmM[numfis][k] = [0., NP.sqrt(min(__tabp.values()['G'])) / NP.sqrt(max(__tabp.values()['G'])) ]
-                k1 = __tabp.values()['K1'][0]
-                k2 = __tabp.values()['K2'][0]
-                BETA[numfis][k]=[0., betaf(k1,k2)]
-              VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1])
-              VMAX = max(VMAX,VMAX0 )
-         elif dime == 3 :
-            nbptfon = len(__tab1['G_LOCAL'])
-            if COMP_LINE == None :
-              UTMESS('A','XFEM2_76')
-              CMIN = 0.
-              CMAX = 1.
-            else :
-              CMIN = COMP_LINE['COEF_MULT_MINI']
-              CMAX = COMP_LINE['COEF_MULT_MAXI']
-            if (min(__tab1['G_LOCAL']) < 0.) :
-              UTMESS('F','RUPTURE1_46')
-            DKeq[numfis] = [[__tab1['ABSC_CURV'][i],NP.sqrt(__tab1['G_LOCAL'][i])*NP.sqrt(YOUNG) ] for i in range(nbptfon)]
-            RmM[numfis] = [[__tab1['ABSC_CURV'][i], CMIN/CMAX] for i in range(nbptfon)]
-            BETA[numfis] = [[__tab1['ABSC_CURV'][i],__tab1['BETA_LOCAL'][i]] for i in range(nbptfon)]
-            for i in range(nbptfon) :
-              VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][i][1],RmM[numfis][i][1])
-              VMAX = max(VMAX,VMAX0 )
-         else :
-            nbptfon = 1
-            if COMP_LINE == None :
-              UTMESS('A','XFEM2_76')
-              CMIN = 0.
-              CMAX = 1.
-            else :
-              CMIN = COMP_LINE['COEF_MULT_MINI']
-              CMAX = COMP_LINE['COEF_MULT_MAXI']
-            if (min(__tab1['G']) < 0.) :
-              UTMESS('F','RUPTURE1_46')
-            DKeq[numfis][0] = [0.,NP.sqrt(YOUNG)*max(NP.sqrt(__tab1['G']))]
-            k1 = __tab1['K1'][0]
-            k2 = __tab1['K2'][0]
-            BETA[numfis][0] = [0.,betaf(k1,k2)] 
-            RmM[numfis][0] = [0.,CMIN/CMAX] 
-            VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][0][1],RmM[numfis][0][1])
-            VMAX = max(VMAX,VMAX0 )
+        if COMP_LINE == None :
+             UTMESS('A','XFEM2_76')
+             CMIN = 0.
+             CMAX = 1.
+        else :
+           CMIN = COMP_LINE['COEF_MULT_MINI']
+           CMAX = COMP_LINE['COEF_MULT_MAXI']
+        if (min(__tab1['G']) < 0.) :
+           UTMESS('F','RUPTURE1_46')
+
+        for k in range(nbptfon) :
+          if (dime == 3) :
+              if __tabp.PT_FOND :
+                  indice_k = k
+          else:
+                  indice_k = 0
+          if ('ABSC_CURV' in __tabp.para) :
+              abscisse_curv_courante = __tab1['ABSC_CURV'][k]
+          else:
+              abscisse_curv_courante = 0.
+          DKeq[numfis][k] =   [abscisse_curv_courante, NP.sqrt(YOUNG)*NP.sqrt(__tab1['G'][k]) ]
+          RmM[numfis][k]  =   [abscisse_curv_courante, CMIN/CMAX ]
+          if ('BETA' in __tab1.values()):
+               BETA[numfis][k] = [abscisse_curv_courante, __tab1['BETA'][0] ]
+          else:
+              k1 = __tab1['K1'][indice_k]
+              k2 = __tab1['K2'][indice_k]
+              BETA[numfis][indice_k]=[abscisse_curv_courante, betaf(k1,k2)]
+          VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) 
+          VMAX = max(VMAX,VMAX0 )
+
 
       numfis = numfis + 1
       
@@ -576,6 +534,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
            DKmax = 1
         if (coef_C ==None) :
            coef_C = Damax
+        ALPHABET = nom_points_fonds(nbnofo)
         for ifond in range(nbnofo) :
            Xf =  d_coorf['NX%s%i' %(ALPHABET[ifond],it)][0]   
            Yf =  d_coorf['NX%s%i' %(ALPHABET[ifond],it)][1]     
@@ -705,6 +664,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
         NomNoeudsEnPlus =     ['NXA%i' %(it+1)]
         mm[numfis].cn = NP.concatenate((mm[numfis].cn,LesNoeudsEnPlus))
         mm[numfis].correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus )
+        ALPHABET = nom_points_fonds(1)
         
   # Ajout Maille levre (SEG2)
         NomMaillesEnPlus =     ['MX%s%i' %(ALPHABET[0], it+1)]
@@ -783,6 +743,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
       NomNoeudsEnPlus =     ['NXA0','NXA1']
       mm.cn = LesNoeudsEnPlus
       mm.correspondance_noeuds = tuple( NomNoeudsEnPlus )
+      ALPHABET = nom_points_fonds(1)
 
 # Ajout Maille levre (SEG2)
       it = 1
@@ -816,6 +777,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
       P1 = args['POINT_EXTR']
       dpropa = args['DTAN']
       nbpt = args['NB_POINT_FOND']
+      ALPHABET = nom_points_fonds(nbpt)
       Q0 = NP.array([[P0[0]-dpropa[0],P0[1]-dpropa[1],P0[2]-dpropa[2]]])
       
       mm = MAIL_PY()
@@ -906,6 +868,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
       if abs(verif) > 0.01:
           UTMESS('F','RUPTURE1_52')
       nbpt = args['NB_POINT_FOND']
+      ALPHABET = nom_points_fonds(nbpt)
 
       mm = MAIL_PY()
       mm.__init__()      

diff --git a/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py
index 000bcb68916fa3659250ae2d738c9ed019d50bbd..eebe3f0c5b4c9406255392e61e45a80cbdde4c15 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF raff_xfem_ops Macro  DATE 12/10/2010   AUTEUR GENIAUT S.GENIAUT 
+#@ MODIF raff_xfem_ops Macro  DATE 03/01/2011   AUTEUR COURTOIS M.COURTOIS 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -32,7 +32,6 @@ def raff_xfem_ops(self,FISSURE,INFO,**args):
    from types import ListType, TupleType
    from Accas import _F
    from SD.sd_xfem import sd_fiss_xfem
-   from Execution.E_JDC import JDC
    EnumTypes = (ListType, TupleType)
 
    macro = 'RAFF_XFEM'

diff --git a/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py
index 9effd6790726588783e69535407a63049f3e212e..e0dd202e470c92a268aaa30526b24ff4fa0063d8 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py
+++ b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py
@@ -1,9 +1,9 @@
-#@ MODIF reca_calcul_aster Macro  DATE 16/11/2010   AUTEUR ASSIRE A.ASSIRE 
+#@ MODIF reca_calcul_aster Macro  DATE 28/03/2011   AUTEUR ASSIRE A.ASSIRE 
 # -*- coding: iso-8859-1 -*-
 # RESPONSABLE ASSIRE A.ASSIRE
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -91,6 +91,8 @@ class CALCUL_ASTER:
       self.UNITE_GRAPHIQUE       = None
       self.export                = None
       self.follow_output         = None
+      self.unity_follow          = None
+
       self.GRADIENT              = GRADIENT
       self.DYNAMIQUE             = DYNAMIQUE
       #self.LANCEMENT             = LANCEMENT
@@ -194,6 +196,8 @@ class CALCUL_ASTER:
             export           = self.new_export
 
             C.follow_output = self.follow_output
+            C.unity_follow  = self.unity_follow
+
 
             # Lancement des calculs
             fonctionnelle, gradient = C.run(

diff --git a/Aster/Cata/cataSTA10/Macro/reca_mac.py b/Aster/Cata/cataSTA10/Macro/reca_mac.py
index f7bf786fc1a8b1a0661a21424aa269d7005137a0..69853c792a7a50f2a8cea9b7bab99d211977760f 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/reca_mac.py
+++ b/Aster/Cata/cataSTA10/Macro/reca_mac.py
@@ -1,8 +1,8 @@
-#@ MODIF reca_mac Macro  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF reca_mac Macro  DATE 03/01/2011   AUTEUR BODEL C.BODEL 
 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -24,9 +24,6 @@ recalage en dynamique
 '''
 import numpy as NP
 
-from Tkinter import Tk, Frame, StringVar, Entry, Label, Button
-from Meidee.modes import MacWindowFrame
-
 def extract_mac_array( mac_mode ):
 
     data1 = mac_mode.EXTR_TABLE().Array('NUME_MODE_1','MAC')
@@ -52,6 +49,9 @@ def get_modes(resu):
 class fenetre_mac:
 
     def __init__(self,resu1,resu2,mac):
+        from Calc_essai.outils_ihm import MacWindowFrame
+        from Tkinter import Tk, Frame, StringVar, Entry, Label, Button
+
         self.resu1 = resu1
         self.resu2 = resu2
         self.mac = mac

diff --git a/Aster/Cata/cataSTA10/Macro/recal.py b/Aster/Cata/cataSTA10/Macro/recal.py
index ec128ecbc84d70393f7604c17a2ec2911acf7b20..9a878761eae8c26c13e8b37185209397d97aeb42 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/recal.py
+++ b/Aster/Cata/cataSTA10/Macro/recal.py
@@ -1,8 +1,8 @@
-#@ MODIF recal Macro  DATE 16/11/2010   AUTEUR ASSIRE A.ASSIRE 
+#@ MODIF recal Macro  DATE 28/03/2011   AUTEUR ASSIRE A.ASSIRE 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -76,6 +76,40 @@ except:
        if code=='F': sys.exit()
 
 
+# -------------------------------------------------------------------------------
+def affiche(unity, filename, label='', filetype='stderr'):
+   """ Affiche un fichier dans l'output courant (methode utilisee pour l'affichage
+       du stdout et/ou du stderr
+   """
+   try:
+       f=open(filename, 'r')
+       txt = f.read()
+       txt = """
+
+============================ %s (%s) =============================
+
+
+%s
+
+
+======================================================================
+======================================================================
+
+""" % (label, filetype, txt)   
+
+       f.close()
+
+       if unity:
+           fw=open('fort.%s' % str(unity), 'a')
+           fw.write( txt )
+           fw.close()
+       else:
+           print txt
+   except Exception, e: 
+       print e
+   return
+
+
 # # -------------------------------------------------------------------------------
 # def find_parameter(content, param):
 #    """
@@ -135,7 +169,7 @@ def make_include_files(UNITE_INCLUDE, calcul, parametres):
        sys.path.append(os.path.join(ASTER_ROOT, 'lib', 'python%s.%s' % (sys.version_info[0], sys.version_info[1] ) , 'site-packages'))
    except: pass
    try:
-       from asrun.utils import find_command, search_enclosed
+       from asrun.common.utils import find_command, search_enclosed
    except Exception, e:
        print e
        UTMESS('F','RECAL0_99')
@@ -365,6 +399,10 @@ class CALCULS_ASTER:
 
        self.jdc                = jdc
 
+       self.follow_output      = False
+       self.unity_follow       = None
+
+
        self.list_params        = [x[0] for x in parametres]
        self.list_params.sort()
 
@@ -676,8 +714,7 @@ class CALCULS_ASTER:
         try:
             from asrun.run          import AsRunFactory
             from asrun.profil       import ASTER_PROFIL
-            from asrun.common_func  import get_hostrc
-            from asrun.utils        import get_timeout
+            from asrun.repart       import get_hostrc
             from asrun.parametric   import is_list_of_dict
             from asrun.thread       import Dispatcher
             from asrun.distrib      import DistribParametricTask
@@ -694,7 +731,9 @@ class CALCULS_ASTER:
         # ----------------------------------------------------------------------------
         sys.argv = ['']
         run = AsRunFactory()
-        if info<=2: run.options['debug_stderr'] = False  # pas d'output d'executions des esclaves dans l'output maitre
+        #if info<=2: run.options['debug_stderr'] = False  # pas d'output d'executions des esclaves dans l'output maitre
+        if self.unity_follow and info==2: run.options['debug_stderr'] = True
+        else:                             run.options['debug_stderr'] = False  # pas d'output d'executions des esclaves dans l'output maitre
 
         # Master profile
         prof = ASTER_PROFIL(filename=export)
@@ -755,7 +794,7 @@ class CALCULS_ASTER:
         hostrc = get_hostrc(run, prof)
 
         # timeout before rejected a job
-        timeout = get_timeout(prof)
+        timeout = prof.get_timeout()
 
 
         # Ajout des impressions de tables a la fin du .comm
@@ -816,22 +855,29 @@ class CALCULS_ASTER:
             else:                output_filename = ''
             d_diag[label] = diag
 
+            # Affichage de l'output de l'esclave dans l'output du maitre
+            if self.unity_follow:
+                affiche(unity=self.unity_follow, filename=output_filename, label=label, filetype='stdout')
+
+            # Calcul esclave NOOK
             if not diag[0:2] in ['OK', '<A']:
+
+              # Affichage de l'output et/ou de l'error de l'esclave dans l'output du maitre
+              try:
+                  affiche(unity=None, filename=output_filename, label=label, filetype='stdout')
+                  error_filename = '.'.join(output_filename.split('.')[0:-1]) + '.e' + output_filename.split('.')[-1][1:]
+                  affiche(unity=None, filename=error_filename, label=label, filetype='stderr')
+              except Exception, e: 
+                  print e
+
               if diag in ['<F>_NOT_RUN', '<A>_NOT_SUBMITTED']:
                   UTMESS('F', 'RECAL0_86', valk=(label, diag))
               else:
                   UTMESS('A', 'RECAL0_83', valk=(label, output_filename))
 
-#                  # Affichage de l'output
-#                  try:
-#                     f=open(output_filename, 'r')
-#                     print f.read()
-#                     f.close()
-#                  except: pass
-
 
         if not d_diag: 
-                UTMESS('F', 'RECAL0_84', valk=resudir)
+            UTMESS('F', 'RECAL0_84', valk=resudir)
         self.list_diag = [ d_diag[label] for label in labels ]
 
         # ----------------------------------------------------------------------------

diff --git a/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py
index 4085050a4255cffbfd3392e396561a6235f46b71..4f6f9cbc30bcad049f18403622129ac55216b418 100644 (file)
--- a/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py
+++ b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py
@@ -1,8 +1,8 @@
-#@ MODIF simu_point_mat_ops Macro  DATE 05/07/2010   AUTEUR PROIX J-M.PROIX 
+#@ MODIF simu_point_mat_ops Macro  DATE 28/02/2011   AUTEUR PROIX J-M.PROIX 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -50,6 +50,7 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT,
   from Accas import _F
   from Utilitai.UniteAster import UniteAster
   from Utilitai.Utmess import  UTMESS
+  from Noyau.N_types import is_enum
   
 # -- Tests de cohérence
   __fonczero = DEFI_FONCTION(NOM_PARA = 'INST',
@@ -60,12 +61,16 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT,
   CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ']
   CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ']
   
+  if COMP_INCR  :
+     lcomp = COMP_INCR.List_F()[0]
+  if COMP_ELAS   :
+     lcomp = COMP_ELAS.List_F()[0]
+
   if SUPPORT != None :
      if SUPPORT=='ELEMENT': 
         itetra=1
   if itetra==0 :
      if COMP_INCR != None : 
-        lcomp = COMP_INCR.List_F()[0]
         if lcomp['DEFORMATION'] != 'PETIT' :
            itetra=1
            UTMESS('A','COMPOR2_1',valk=lcomp['DEFORMATION'] )
@@ -436,26 +441,33 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT,
              lvarc  = args['AFFE_VARC'].List_F()
              nbvarc=len(lvarc)
              for ivarc in range(nbvarc) :
-                  typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_F'
                   dico={}
-                  __CHVARC=CREA_CHAMP(TYPE_CHAM=typech,
-                                     OPERATION='AFFE', 
-                                     MAILLAGE=__MA, 
-                                     AFFE=_F(MAILLE='VOLUME', 
+                  typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_R'
+                  labsc=lvarc[ivarc]['VALE_FONC'].Absc()
+                  lordo=lvarc[ivarc]['VALE_FONC'].Ordo()
+                  l_affe_cham=[]
+                  __CHV=[None]*len(labsc)
+                  for it,time in enumerate(labsc):
+                      __CHV[it]=CREA_CHAMP(TYPE_CHAM=typech,
+                                     OPERATION='AFFE',
+                                     MAILLAGE=__MA,
+                                     AFFE=_F(MAILLE='VOLUME',
                                              NOM_CMP=lvarc[ivarc]['NOM_VARC'],
-                                             VALE_F=lvarc[ivarc]['VALE_FONC'],
+                                             VALE=lordo[it],
                                             ),
-                                     ), 
-                  __LIST2  = INCREMENT.List_F()[0]['LIST_INST']
-                  __TEMP=CREA_RESU(OPERATION='AFFE',TYPE_RESU='EVOL_THER',NOM_CHAM='TEMP',
-                                   AFFE = _F(CHAM_GD = __CHVARC,LIST_INST = __LIST2,),
-                                   )
+                                     ),
+                      dicoch={}
+                      dicoch["CHAM_GD"]=__CHV[it]
+                      dicoch["INST"]=time
+                      l_affe_cham.append(dicoch)
+                  __EVOV=CREA_RESU(OPERATION='AFFE',TYPE_RESU='EVOL_VARC',NOM_CHAM=str(lvarc[ivarc]['NOM_VARC']),
+                               AFFE = l_affe_cham)  
                   dico["MAILLE"]='VOLUME'
-                  dico["EVOL"]=__TEMP
+                  dico["EVOL"]=__EVOV
                   dico["NOM_VARC"]=lvarc[ivarc]['NOM_VARC']
                   if lvarc[ivarc]['VALE_REF'] != None:
                      dico["VALE_REF"]=lvarc[ivarc]['VALE_REF']
-             mcvarc.append(dico)
+                  mcvarc.append(dico)
 #      -- Materiau et modele
       if len(mcvarc) > 0 :
          __CHMAT=AFFE_MATERIAU(MAILLAGE=__MA,AFFE = _F(MAILLE='VOLUME',MATER=MATER),
@@ -491,6 +503,8 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT,
           lnomneu=[]
           lnomvar=[]
           VARINI=VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste)
+          if (not is_enum(VARINI['VALE'])) :
+              VARINI['VALE'] = [VARINI['VALE'],]
           nbvari=len(VARINI['VALE'])
           for i in range(nbvari):
               lnomneu.append('X'+str(i+1))
@@ -617,43 +631,48 @@ def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT,
                                  EXCIT = l_char,**motscles)
 
 
+      if lcomp['DEFORMATION'] != 'PETIT' :
+         nomepsi='EPSG_ELNO'
+      else :
+         nomepsi='EPSI_ELNO'
+         
       __EVOL1 = CALC_ELEM(reuse = __EVOL1,RESULTAT = __EVOL1,
-        OPTION = ('SIEF_ELNO_ELGA','EPSI_ELNO_DEPL','VARI_ELNO_ELGA'))
+        OPTION = ('SIEF_ELNO',nomepsi,'VARI_ELNO'))
  
       if MODELISATION=="3D":
           angles=(ANGLE,0,0)
           __EVOL=MODI_REPERE(RESULTAT=__EVOL1, MODI_CHAM=(
               _F(NOM_CHAM='DEPL',NOM_CMP=('DX','DY','DZ'),TYPE_CHAM='VECT_3D',),
-              _F(NOM_CHAM='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),TYPE_CHAM='TENS_3D',),
-              _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),TYPE_CHAM='TENS_3D',),
+              _F(NOM_CHAM='SIEF_ELNO',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),TYPE_CHAM='TENS_3D',),
+              _F(NOM_CHAM=nomepsi,NOM_CMP=('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),TYPE_CHAM='TENS_3D',),
                                   ),
                      DEFI_REPERE=_F(REPERE='UTILISATEUR',ANGL_NAUT=angles),);
       else :
           angles=ANGLE
           __EVOL=MODI_REPERE(RESULTAT=__EVOL1,MODI_CHAM=(
                      _F(NOM_CHAM='DEPL',NOM_CMP=('DX','DY'),TYPE_CHAM='VECT_2D',),
-                     _F(NOM_CHAM='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY'),TYPE_CHAM='TENS_2D',),
-                     _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY'),TYPE_CHAM='TENS_2D',),
+                     _F(NOM_CHAM='SIEF_ELNO',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY'),TYPE_CHAM='TENS_2D',),
+                     _F(NOM_CHAM=nomepsi,NOM_CMP=('EPXX','EPYY','EPZZ','EPXY'),TYPE_CHAM='TENS_2D',),
                                   ),
                      DEFI_REPERE=_F(REPERE='UTILISATEUR',ANGL_NAUT=angles),);
  
 #     -- Recuperation des courbes
 
       __REP_VARI = POST_RELEVE_T(ACTION = (
-          _F(INTITULE='VARI_INT',RESULTAT=__EVOL1,NOM_CHAM='VARI_ELNO_ELGA',
+          _F(INTITULE='VARI_INT',RESULTAT=__EVOL1,NOM_CHAM='VARI_ELNO',
             TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD='P0'),))
 
  
       __REP_EPSI = POST_RELEVE_T(ACTION = (
-          _F(INTITULE='EPSILON',RESULTAT=__EVOL,NOM_CHAM='EPSI_ELNO_DEPL',
+          _F(INTITULE='EPSILON',RESULTAT=__EVOL,NOM_CHAM=nomepsi,
             TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD     = 'P0'),))
 
       __REP_SIGM = POST_RELEVE_T(ACTION = (
-          _F(INTITULE  = 'SIGMA',RESULTAT  =  __EVOL,NOM_CHAM  = 'SIEF_ELNO_ELGA',
+          _F(INTITULE  = 'SIGMA',RESULTAT  =  __EVOL,NOM_CHAM  = 'SIEF_ELNO',
             TOUT_CMP  = 'OUI',OPERATION = 'EXTRACTION',NOEUD     = 'P0'),))
  
       __REP_INV = POST_RELEVE_T(ACTION = (
-          _F(INTITULE  = 'INV',RESULTAT  =  __EVOL,NOM_CHAM  = 'SIEF_ELNO_ELGA',
+          _F(INTITULE  = 'INV',RESULTAT  =  __EVOL,NOM_CHAM  = 'SIEF_ELNO',
             INVARIANT  = 'OUI',OPERATION = 'EXTRACTION',NOEUD     = 'P0'),))
  
       __REP_INV=CALC_TABLE( TABLE=__REP_INV,reuse=__REP_INV,

diff --git a/Aster/Cata/cataSTA10/Macro/test_compor_ops.py b/Aster/Cata/cataSTA10/Macro/test_compor_ops.py
new file mode 100644 (file)
index 0000000..62b22ff
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/test_compor_ops.py
@@ -0,0 +1,783 @@
+#@ MODIF test_compor_ops Macro  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+#              MACRO "TEST_COMPOR"
+#           ----------------------------
+
+#######################################################################
+# utilitaires
+#######################################################################
+def PROD_ROT(X1,X2):
+    # calcul Produit de 2 vecteurs pour les coef de rotations
+    # dimension de X1 et X2 liste de 3 scalaire resultat liste de 6 scalaires
+    if (len(X1)==len(X2)==3) : 
+            Y=[None]*6
+            V_ind=[[0,0,0.5],[1,1,0.5],[2,2,0.5],[0,1,1.0],[0,2,1.0],[1,2,1.0]]
+            for ind in V_ind:
+                    i=V_ind.index(ind)
+                    ind1,ind2,coef=ind[0],ind[1],ind[2]
+                    Y[i]=coef*(X1[ind1]*X2[ind2]+X1[ind2]*X2[ind1])
+            return Y
+    else :
+            print "CALCUL PROD_ROT IMPOSSIBLE, dimensions innatendues"
+            return None
+#######################################################################
+def RENOMME(self,i,N_pas,label_cal,ch_param,_RES,_RSI):
+# On renomme les composantes en fonction de  l'ordre de discrétisation
+   from Accas import _F
+   DETRUIRE       = self.get_cmd('DETRUIRE')
+   CALC_TABLE     = self.get_cmd('CALC_TABLE')
+   N = N_pas[i]
+   chN=label_cal[i]+str(N)
+   for ch in ch_param:
+           j=ch_param.index(ch)
+           chnew=ch+chN
+            ##Extraction par type de variable 
+           if _RSI[j] == None:
+                   _RSI[j]=CALC_TABLE( TABLE=_RES[i],
+                                TITRE = ' ',
+                                ACTION=( _F(OPERATION='EXTR',
+                                       NOM_PARA=('INST',ch,),),
+                                         _F(OPERATION='RENOMME',
+                                           NOM_PARA=(ch,chnew,),),
+                                                           ),);
+           else:
+                   TMP_S=CALC_TABLE( TABLE=_RES[i],
+                                TITRE = ' ',
+                                ACTION=( _F(OPERATION='EXTR',
+                                       NOM_PARA=('INST',ch,),),
+                                           _F(OPERATION='RENOMME',
+                                           NOM_PARA=(ch,chnew,),),
+                                                           ),);
+                   _RSI[j]=CALC_TABLE( reuse=_RSI[j], TABLE=_RSI[j],
+                                TITRE = ' ',
+                                   ACTION=( _F(OPERATION='COMB',
+                                   TABLE=TMP_S,NOM_PARA='INST',),
+                                           ),);
+                   DETRUIRE ( CONCEPT = _F (NOM = TMP_S,),INFO=1)
+ 
+   
+   return _RSI
+#######################################################################
+
+def ERREUR(X,Xref,prec_zero,coef):
+    "calcul erreur relative entre deux nombres"
+    if (abs(Xref)<prec_zero) : 
+       err=0.
+    else :
+       err= abs((X*coef-Xref)/Xref)
+    return err
+#######################################################################
+
+def TEST_ECART(self,ch_param2,label_cal,N_pas,Ncal,ch_param,_RSI,prec_ecart,prec_zero):
+   from Accas import _F
+   DETRUIRE       = self.get_cmd('DETRUIRE')
+   FORMULE        = self.get_cmd('FORMULE')
+   CALC_TABLE     = self.get_cmd('CALC_TABLE')
+
+   #Exploitations
+   CH_V1 = ['INST']
+   C_Pa=1.e6
+   _ERSI=[None]*len(ch_param2)
+
+   for ch in ch_param2 :
+   #CALCUL des ecarts relatifs
+        i=ch_param2.index(ch)
+        chref1 =ch + label_cal[4] + str(N_pas[4]) 
+        chref2 = ch + label_cal[Ncal-1] + str(N_pas[Ncal-1])
+        chref = [chref1, chref2]        
+        preczero=prec_zero[i]   
+
+        for j in range(Ncal) :
+                coef = 1.
+                ch_cal = ch + label_cal[j] + str(N_pas[j]) 
+                ch_err = 'ER_' + ch_cal
+                if j < 4 :
+                        if (j==0 and i>0 and i<9) : coef = 1/C_Pa
+                        iref = 0
+                else :
+                        iref =1
+                        if (i==0) : CH_V1.append(ch_cal)
+#               calcul de l'erreur (ecart relatif)
+                valfor='ERREUR(%s,%s,%e,%f)' % (ch_cal,chref[iref],preczero,coef)
+                nompar1='%s' % (ch_cal )
+                nompar2='%s' % (chref[iref] )                
+                ERR_REL = FORMULE(NOM_PARA=(nompar1,nompar2),VALE=valfor)
+                if _ERSI[i] == None :
+                   _ERSI[i] = CALC_TABLE(TABLE =_RSI[i], 
+                                     TITRE = '_RSI'+str(j),
+                             ACTION = (_F(OPERATION='OPER',NOM_PARA=ch_err,
+                                          FORMULE=ERR_REL),
+                                      ),);
+                else :
+                   _ERSI[i] = CALC_TABLE(TABLE =_ERSI[i], reuse=_ERSI[i],
+                                     TITRE = '_RSI'+str(j),
+                             ACTION = (_F(OPERATION='OPER',NOM_PARA=ch_err,
+                                          FORMULE=ERR_REL),
+                                      ),);
+                DETRUIRE ( CONCEPT = _F (NOM = ERR_REL,),INFO=1)                
+   return _ERSI
+        
+#######################################################################
+
+def CHAR3D(self,POISSON,YOUNG,_tempsar,INFO):
+   CALC_FONCTION       = self.get_cmd('CALC_FONCTION')
+   DEFI_FONCTION       = self.get_cmd('DEFI_FONCTION')
+   DEFI_LIST_REEL      = self.get_cmd('DEFI_LIST_REEL')
+   IMPR_FONCTION       = self.get_cmd('IMPR_FONCTION')
+   from Accas import _F
+   import numpy as NP
+   
+   ##################################################################################
+ 
+   # definition du trajet de chargement 3D
+ 
+   #######################################################################
+   #fonctions chargement
+   calibrage = 3.5;
+   Ctau = ((2 * calibrage) * ((1 + POISSON) / (2 * YOUNG)));
+   Ctrac = (calibrage * (1 / YOUNG));
+   _Ytrace=DEFI_LIST_REEL( VALE = (0., 150., 150., -50, 0., 50., -150., -150., 0.),)
+   _Trace=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= _Ytrace,
+                       PROL_DROITE='EXCLU',
+                       PROL_GAUCHE='EXCLU',);
+
+   _YDevi_1=DEFI_LIST_REEL( VALE = (0., 75., 150., 150, 0., -150., -150., -75., 0.),)
+   _Devi_1=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= _YDevi_1,
+                        PROL_DROITE='EXCLU',
+                        PROL_GAUCHE='EXCLU',);
+
+   _YDevi_2=DEFI_LIST_REEL( VALE = (0., 75., -50., 100, 0., -100., 50., -75., 0.),)
+   _Devi_2=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= _YDevi_2,
+                        PROL_DROITE='EXCLU',
+                        PROL_GAUCHE='EXCLU',);
+
+   _Ytauxy=DEFI_LIST_REEL( VALE = (0., 200., 100., 300, 0., -300., -100., -200., 0.),)
+   _TAU_xy=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= _Ytauxy,
+                        PROL_DROITE='EXCLU',
+                        PROL_GAUCHE='EXCLU',);
+
+   _Ytauxz=DEFI_LIST_REEL( VALE = (0., -100., 100., 200, 0., -200., -100., 100., 0.),)
+   _TAU_xz=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= _Ytauxz,
+                        PROL_DROITE='EXCLU',
+                        PROL_GAUCHE='EXCLU',);
+
+   _Ytauyz=DEFI_LIST_REEL( VALE = (0., 0., 200., -100, 0., 100., -200., 0., 0.),)
+   _TAU_yz=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= _Ytauyz,
+                        PROL_DROITE='EXCLU',
+                        PROL_GAUCHE='EXCLU',);
+
+   _eps_xy=CALC_FONCTION(COMB=_F(FONCTION=_TAU_xy,
+                                COEF=Ctau,),);
+
+   _eps_xz=CALC_FONCTION(COMB=_F(FONCTION=_TAU_xz,
+                                COEF=Ctau,),);
+
+   _eps_yz=CALC_FONCTION(COMB=_F(FONCTION=_TAU_yz,
+                                COEF=Ctau,),);
+
+   _eps_xx=CALC_FONCTION(COMB=(_F(FONCTION=_Trace,
+                                 COEF=Ctrac,),
+                              _F(FONCTION=_Devi_1,
+                                 COEF=Ctrac,),),);
+
+   _eps_yy=CALC_FONCTION(COMB=(_F(FONCTION=_Trace,
+                                 COEF=Ctrac,),
+                              _F(FONCTION=_Devi_1,
+                                 COEF=-(Ctrac),),
+                              _F(FONCTION=_Devi_2,
+                                 COEF=Ctrac,),),);
+
+   _eps_zz=CALC_FONCTION(COMB=(_F(FONCTION=_Trace,
+                                 COEF=Ctrac,),
+                              _F(FONCTION=_Devi_2,
+                                 COEF=-(Ctrac),),),);
+   eps_imp = [_eps_xx, _eps_yy, _eps_zz, _eps_xy, _eps_xz, _eps_yz]
+   #rotation tenseur des def
+   #angle de precession, nutation, rotation propre
+   psi,teta,phi=0.9,0.7,0.4
+   cps,cte,cph=NP.cos(psi),NP.cos(teta),NP.cos(phi)
+   sps,ste,sph=NP.sin(psi),NP.sin(teta),NP.sin(phi)
+   #matrice de passage
+   p11,p21,p31 = cph*cps-sph*cte*sps,cph*sps+sph*cte*cps,sph*ste
+   p12,p22,p32 = -sph*cps-cph*cte*sps,-sph*sps+cph*cte*cps,cph*ste
+   p13,p23,p33 = ste*sps,-ste*cps,cte
+   V1= [p11, p21, p31]
+   V2= [p12, p22, p32]
+   V3= [p13, p23, p33]
+   #eps apres rotation
+   VI = [[V1,V1],[V2,V2],[V3,V3],[V1,V2],[V1,V3],[V2,V3]]
+   _eps_rot = [None]*6
+   for vect_i in VI:
+           i = VI.index(vect_i)
+           V_COEF = PROD_ROT(vect_i[0],vect_i[1])
+           _eps_rot[i] =CALC_FONCTION(COMB=(
+                           _F(FONCTION=_eps_xx,COEF=V_COEF[0],),
+                           _F(FONCTION=_eps_yy,COEF=V_COEF[1],),
+                           _F(FONCTION=_eps_zz,COEF=V_COEF[2],),
+                           _F(FONCTION=_eps_xy,COEF=V_COEF[3],),
+                           _F(FONCTION=_eps_xz,COEF=V_COEF[4],),
+                           _F(FONCTION=_eps_yz,COEF=V_COEF[5],),
+                                   ),);
+   #eps apres symetrie
+   eps_sym = [_eps_zz,_eps_xx,_eps_yy,_eps_xz,_eps_yz,_eps_xy]
+
+   V_EPS = [eps_imp,eps_sym,_eps_rot]
+   #trace chargement
+   if INFO == 2 :
+      IMPR_FONCTION(#FORMAT='XMGRACE',PILOTE='INTERACTIF',
+                 COURBE=(_F(FONCTION=eps_imp[0],),
+                         _F(FONCTION=eps_imp[1],),
+                         _F(FONCTION=eps_imp[2],),
+                         _F(FONCTION=eps_imp[3],),
+                         _F(FONCTION=eps_imp[4],),
+                         _F(FONCTION=eps_imp[5],),
+                         ),
+                 UNITE=29,);
+   return eps_imp
+        
+#######################################################################
+def CHAR2D(self,POISSON,YOUNG,_tempsar,INFO):
+   CALC_FONCTION       = self.get_cmd('CALC_FONCTION')
+   DEFI_FONCTION       = self.get_cmd('DEFI_FONCTION')
+   DEFI_LIST_REEL      = self.get_cmd('DEFI_LIST_REEL')
+   IMPR_FONCTION       = self.get_cmd('IMPR_FONCTION')
+   #######################################################################
+   # definition du trajet de chargement 2D
+   #######################################################################
+   from Accas import _F
+   import numpy as NP
+
+   #fonctions chargement
+   calibrage = 4.5;
+   Ctau = ((2 * calibrage) * ((1 + POISSON) / (2 * YOUNG)));
+   Ctrac = (calibrage * (1 / YOUNG));
+   YTrace2d=DEFI_LIST_REEL( VALE = (0., 150., 200., 300., 0., -300., -200., -150., 0.),)
+   Trace2d=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= YTrace2d,
+                       PROL_DROITE='EXCLU',
+                       PROL_GAUCHE='EXCLU',);
+
+   Y_Devi2=DEFI_LIST_REEL( VALE = (0., 0., 100., 0., 0., 0., -100., 0., 0.),)
+   Devi1_2d=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= Y_Devi2,
+                        PROL_DROITE='EXCLU',
+                        PROL_GAUCHE='EXCLU',);
+
+   Y_tauxy2=DEFI_LIST_REEL( VALE = (0., 100., 40., 0., 0., 0., -40., -100., 0.0),)
+   TAU_xy2=DEFI_FONCTION(NOM_PARA='INST',
+                       VALE_PARA= _tempsar,
+                       VALE_FONC= Y_tauxy2,
+                        PROL_DROITE='EXCLU',
+                        PROL_GAUCHE='EXCLU',);
+
+   eps_xy2=CALC_FONCTION(COMB=_F(FONCTION=TAU_xy2,
+                                COEF=Ctau,),);
+
+   eps_xx2=CALC_FONCTION(COMB=(_F(FONCTION=Trace2d,
+                                 COEF=Ctrac,),
+                              _F(FONCTION=Devi1_2d,
+                                 COEF=Ctrac,),),);
+
+   eps_yy2=CALC_FONCTION(COMB=(_F(FONCTION=Trace2d,
+                                 COEF=Ctrac,),
+                              _F(FONCTION=Devi1_2d,
+                                 COEF=-(Ctrac),),),);
+   #rotation tenseur des def
+   angle = 0.9
+   c,s = NP.cos(0.9) , NP.sin(0.9)
+   c2,s2,cs = c*c, s*s, c*s
+   eps_rr2=CALC_FONCTION(COMB=(_F(FONCTION=eps_xx2,
+                                   COEF=c2,),
+                             _F(FONCTION=eps_yy2,
+                                   COEF=s2,),
+                             _F(FONCTION=eps_xy2,
+                                   COEF=2*cs,),),);
+
+   eps_tt2=CALC_FONCTION(COMB=(_F(FONCTION=eps_xx2,
+                                   COEF=s2,),
+                             _F(FONCTION=eps_yy2,
+                                   COEF=c2,),
+                             _F(FONCTION=eps_xy2,
+                                   COEF=-2*cs,),),);
+
+   eps_rt2=CALC_FONCTION(COMB=(_F(FONCTION=eps_xx2,
+                                   COEF=-cs,),
+                             _F(FONCTION=eps_yy2,
+                                   COEF=cs,),
+                             _F(FONCTION=eps_xy2,
+                                   COEF=c2-s2,),),);
+   eps_imp = [eps_xx2 , eps_yy2, eps_xy2, eps_rr2,eps_tt2, eps_rt2]
+
+   #Trace2d chargement
+   if INFO==2 :
+      IMPR_FONCTION(#FORMAT='XMGRACE',PILOTE='INTERACTIF',
+                 COURBE=(_F(FONCTION=eps_imp[0],),
+                         _F(FONCTION=eps_imp[1],),
+                         _F(FONCTION=eps_imp[2],),
+                         _F(FONCTION=eps_imp[3],),
+                         _F(FONCTION=eps_imp[4],),
+                         _F(FONCTION=eps_imp[5],),
+                         ),
+                 UNITE=29,);
+   return eps_imp
+        
+
+#######################################################################
+
+
+
+def test_compor_ops(self,OPTION,NEWTON,CONVERGENCE,COMP_INCR,COMP_ELAS,LIST_MATER,VARI_TEST,INFO,
+                             **args):
+ # seule l'option "THER", c'est à dire le test thermomecanique est programme a ce jour
+ # ajouter l'option MECA (tests comp001,002), l'option HYDR, etc..
+  from Accas import _F
+  import numpy as NP
+  from Utilitai.veri_matr_tang import VERI_MATR_TANG
+  self.update_const_context({'ERREUR' : ERREUR})
+  
+  ier=0
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+  
+  # Le concept sortant (de type fonction) est nomme U dans 
+  # le contexte de la macro
+
+  self.DeclareOut('U',self.sd)
+  
+  # On importe les definitions des commandes a utiliser dans la macro
+  CALC_FONCTION  = self.get_cmd('CALC_FONCTION')
+  CALC_TABLE     = self.get_cmd('CALC_TABLE')
+  DEFI_CONSTANTE = self.get_cmd('DEFI_CONSTANTE')
+  DEFI_FONCTION  = self.get_cmd('DEFI_FONCTION')
+  DEFI_LIST_INST = self.get_cmd('DEFI_LIST_INST')
+  DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
+  DEFI_MATERIAU  = self.get_cmd('DEFI_MATERIAU')
+  DETRUIRE       = self.get_cmd('DETRUIRE')
+  FORMULE        = self.get_cmd('FORMULE')
+  IMPR_FONCTION  = self.get_cmd('IMPR_FONCTION')
+  SIMU_POINT_MAT = self.get_cmd('SIMU_POINT_MAT')
+  TEST_TABLE     = self.get_cmd('TEST_TABLE')
+  IMPR_TABLE     = self.get_cmd('IMPR_TABLE')
+  CALC_TABLE     = self.get_cmd('CALC_TABLE')
+
+  motscles={}
+  if   COMP_INCR  :
+      motscles['COMP_INCR']   = COMP_INCR.List_F()
+  if   COMP_ELAS   :
+      motscles['COMP_ELAS']   = COMP_ELAS.List_F()
+  motscles['CONVERGENCE'] = CONVERGENCE.List_F()  
+  motscles['NEWTON']      = NEWTON.List_F()
+  
+  if OPTION=="THER" :
+      epsi = 1.E-10
+      MATER=args['MATER']
+      ALPHA=args['ALPHA']
+      YOUNG=args['YOUNG']
+      TEMP_INIT=args['TEMP_INIT']
+      TEMP_FIN=args['TEMP_FIN']
+      NB_VARI=args['NB_VARI']
+
+      if args['INST_FIN'] != None : INST_FIN=args['INST_FIN']
+ 
+      NCAL=len(LIST_MATER)
+ 
+      _LINST0=DEFI_LIST_REEL(DEBUT=0.,
+                          INTERVALLE=(_F(JUSQU_A=INST_FIN,
+                                         NOMBRE=NCAL,),
+                                         ),
+                          );
+
+      _LINST=DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST=_LINST0,
+                                         METHODE='MANUEL',
+                                        # PAS_MINI=1.0E-12
+                                         ),
+                             ECHEC=_F(SUBD_PAS=10),
+                           # ADAPTATION=_F(EVENEMENT='SEUIL'),
+                            );
+      _TIMP=DEFI_FONCTION(NOM_PARA='INST',  NOM_RESU='TEMP',
+                         VALE=(  0. , TEMP_INIT, INST_FIN , TEMP_FIN)
+                         )
+
+      _zero=DEFI_CONSTANTE(VALE=0.)
+
+ 
+      _U=SIMU_POINT_MAT(MATER=MATER,INFO=INFO,
+                       SUPPORT='ELEMENT',
+                         AFFE_VARC=(
+                         _F(  NOM_VARC='TEMP',
+                              VALE_FONC=_TIMP,
+                              VALE_REF=TEMP_INIT),
+                              ),
+                       INCREMENT=_F(LIST_INST=_LINST,),
+                       EPSI_IMPOSE=_F(EPXX=_zero,),
+                       **motscles);
+
+      # On ne garde pas les valeurs initiales (NUME_ORDRE = 0 exclu)
+
+      _U = CALC_TABLE(reuse =_U,
+                    TABLE=_U,
+                    ACTION=(_F(
+                          OPERATION = 'FILTRE',
+                          NOM_PARA  = 'NUME_ORDRE',
+                          CRIT_COMP = 'GT',
+                          VALE    = 0,
+                         ),),);
+
+      SXM = 0.
+      EXM = 0.
+      time = 0.
+
+      _RES   = [None]*(NCAL)
+      if (NB_VARI > 0):
+         Vim    = NP.zeros(NB_VARI)
+
+      for i in range(NCAL):
+ 
+          timem = time
+ 
+          time = timem + INST_FIN/NCAL
+ 
+          Ti = TEMP_INIT + time/INST_FIN * (TEMP_FIN - TEMP_INIT)
+ 
+          Tm = TEMP_INIT + timem/INST_FIN * (TEMP_FIN - TEMP_INIT)
+ 
+          # deformation mecanique imposee correspondant a la deformation thermique du premier calcul
+ 
+          _epsimp =DEFI_CONSTANTE(VALE=-ALPHA(Ti)*(Ti - TEMP_INIT));
+
+          # variation des coef du COMPORtement avec la temperature
+          # correction eventuelle des valeurs initiales du temps ti
+ 
+          if i > 0 :
+ 
+             SXM = SXM *(YOUNG(Ti)/YOUNG(Tm))
+             # cas particuliers
+             if COMP_INCR.List_F()[0]['RELATION'] == 'VMIS_CINE_LINE' :
+                 
+                 if args['D_SIGM_EPSI'] != None : 
+                    D_SIGM_EPSI=args['D_SIGM_EPSI']
+                 else :
+                    raise 'erreur'
+                    
+                 Vim[0:5] = Vim[0:5]*D_SIGM_EPSI(Ti)/D_SIGM_EPSI(Tm)
+                 
+             if COMP_INCR.List_F()[0]['RELATION']== 'VMIS_ECMI_LINE' :
+                 if args['C_PRAG'] != None : 
+                    C_PRAG=args['C_PRAG']
+                 else :
+                    raise 'erreur'
+                 Vim[2:7] = Vim[2:7]*C_PRAG(Ti)/C_PRAG(Tm)
+                 
+             if COMP_INCR.List_F()[0]['RELATION']== 'VMIS_ECMI_TRAC' :
+                 if args['C_PRAG'] != None : 
+                    C_PRAG=args['C_PRAG']
+                 else :
+                    raise 'erreur'
+                 Vim[2:7] = Vim[2:7]*C_PRAG(Ti)/C_PRAG(Tm)
+ 
+
+          _list0 = DEFI_LIST_REEL(DEBUT=timem,
+                      INTERVALLE=(_F(JUSQU_A=time,NOMBRE=1,),),);
+ 
+          _list=DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST=_list0,
+                                         METHODE='MANUEL',
+                                        # PAS_MINI=1.0E-12
+                                         ),
+                             ECHEC=_F(SUBD_PAS=10),
+                           # ADAPTATION=_F(EVENEMENT='SEUIL'),
+                            );
+          if (NB_VARI > 0):
+              _RES[i]=SIMU_POINT_MAT(INFO=INFO,
+                                 MATER=LIST_MATER[i],
+                                 SUPPORT='ELEMENT',
+                                 INCREMENT=_F(LIST_INST = _list, ),
+                                 EPSI_IMPOSE=_F(EPXX=_epsimp),
+                                 SIGM_INIT=_F(SIXX=SXM),
+                                 VARI_INIT=_F(VALE=[Vim[j] for j in range(NB_VARI)]),
+                                 EPSI_INIT=_F(EPXX=EXM, EPYY=0.,EPZZ=0.,EPXY=0.,EPXZ=0.,EPYZ=0.),
+                                 **motscles);
+ 
+          else :
+              _RES[i]=SIMU_POINT_MAT(INFO=INFO,
+                                 MATER=LIST_MATER[i],
+                                 SUPPORT='ELEMENT',
+                                 INCREMENT=_F(LIST_INST = _list, ),
+                                 EPSI_IMPOSE=_F(EPXX=_epsimp),
+                                 SIGM_INIT=_F(SIXX=SXM),
+                                 EPSI_INIT=_F(EPXX=EXM, EPYY=0.,EPZZ=0.,EPXY=0.,EPXZ=0.,EPYZ=0.),
+                                 **motscles);
+ 
+          # On ne teste pas les valeurs initiales (NUME_ORDRE = 0 exclu)
+
+          _RES[i] = CALC_TABLE(reuse =_RES[i],
+                    TABLE=_RES[i],
+                    ACTION=(_F(
+                          OPERATION = 'FILTRE',
+                          NOM_PARA  = 'NUME_ORDRE',
+                          CRIT_COMP = 'GT',
+                          VALE    = 0,
+                         ),),);
+ 
+          # recuperation des valeurs initiales du futur pas de temps dans la table resultat
+ 
+          EXM = _RES[i]['EPXX',1]
+ 
+          SXM = _RES[i]['SIXX',1]
+
+          if (NB_VARI > 0):
+             for j in range(NB_VARI):
+                Vim[j] = _RES[i]['V'+str(j+1),1]
+ 
+          DETRUIRE ( CONCEPT =  _F (NOM =_epsimp),INFO=1);
+          DETRUIRE ( CONCEPT =  _F (NOM =_list),INFO=1);
+ 
+          
+
+          TEST_TABLE(TABLE=_RES[i],
+                     NOM_PARA='VMIS',VALE=_U['VMIS',i+1],
+                     FILTRE=_F(NOM_PARA='INST',VALE=time),
+                     REFERENCE='AUTRE_ASTER',);
+
+          TEST_TABLE(TABLE=_RES[i],
+                     NOM_PARA='TRACE',VALE=_U['TRACE',i+1],
+                     FILTRE=_F(NOM_PARA='INST',VALE=time),
+                     REFERENCE='AUTRE_ASTER',);
+          if (NB_VARI > 0):
+             if VARI_TEST <> None  :
+                for j in range(len(VARI_TEST)):
+                   nomvari=VARI_TEST[j]
+                   if abs(_U[nomvari,i+1]) > epsi :
+                      TEST_TABLE(TABLE=_RES[i],
+                         NOM_PARA=nomvari,VALE=_U[nomvari,i+1],
+                         FILTRE=_F(NOM_PARA='INST',VALE=time),
+                         REFERENCE='AUTRE_ASTER',);
+             else  :
+                for j in range(NB_VARI):
+                   nomvari='V'+str(j+1)
+                   if abs(_U[nomvari,i+1]) > epsi :
+                      TEST_TABLE(TABLE=_RES[i],
+                         NOM_PARA=nomvari,VALE=_U[nomvari,i+1],
+                         FILTRE=_F(NOM_PARA='INST',VALE=time),
+                         REFERENCE='AUTRE_ASTER',);
+      for i in range(NCAL):
+          DETRUIRE ( CONCEPT =  _F (NOM =_RES[i]),INFO=1)
+      
+  elif OPTION=="MECA" :
+
+      LIST_NPAS=args['LIST_NPAS']
+      YOUNG=args['YOUNG']
+      POISSON=args['POISSON']
+
+      #Discretisation du calcul
+      if args['LIST_NPAS'] != None : 
+         LIST_NPAS=args['LIST_NPAS']
+      else :
+         LIST_NPAS=4*[1] + [1, 5, 25]             
+      Ncal = len(LIST_NPAS)
+
+      # les differents calculs effectues et les precisions sur chaque TEST_RESU
+      label_cal=['_Pa_','_Th_','_sym_','_rot_'] + 6* ['_N']
+      if args['LIST_TOLE'] != None : 
+         LIST_TOLE=args['LIST_TOLE']
+      else :
+         LIST_TOLE=4*[1.E-10] + [1.E-1] + (Ncal-5)*[1.E-2] + [1.E-8]  
+                  
+      if args['PREC_ZERO'] != None : 
+         PREC_ZERO=args['PREC_ZERO']
+      else :
+         PREC_ZERO=len(VARI_TEST)*[1.E-10]
+
+      prec_tgt=LIST_TOLE[-1]
+
+      #parametres vitesse de sollicitation
+      t_0 = 1.0
+      if   COMP_INCR  :
+         if COMP_INCR.List_F()[0]['RELATION'][0:4]== 'VISC' :
+            vitesse = 1.e-5
+            t_0 = 5.e-2/(8.0*vitesse)
+      # liste d'archivage
+      _tempsar=DEFI_LIST_REEL( VALE =[t_0*i for i in range(9)],)
+      
+      if args['MODELISATION'] != None :
+         modelisation=args['MODELISATION']
+      else :
+         modelisation= "3D"
+      if modelisation == "3D" : 
+
+          ##################################################################################
+          #  TEST 3D
+          ##################################################################################
+          
+          eps_imp = CHAR3D(self,POISSON,YOUNG,_tempsar,INFO)
+
+          ch_param2 = list(VARI_TEST)
+          ch_param=ch_param2+['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ']
+
+      elif modelisation == "C_PLAN"  : 
+      
+          ##################################################################################
+          #  TEST 2D C_PLAN
+          ##################################################################################
+          
+          eps_imp = CHAR2D(self,POISSON,YOUNG,_tempsar,INFO)
+
+          # les quantites (invariants...) sur lequels portent les calculs d'erreur et les test_resu
+          ch_param2 = list(VARI_TEST)
+          ch_param=ch_param2+['SIXX','SIYY','SIZZ','SIXY']
+
+
+      ###############################################################################
+      #Discretisation et calcul
+      ###############################################################################
+
+      _RES=[None]*Ncal
+      _RSI=[None]*len(ch_param)
+      TMP_S=[None]
+
+      #pointeur materiau
+      P_imat = [0] + [1] + (Ncal-2)*[1]
+      #pointeur deformation
+      nomdef, symdef, rotdef = [0, 1, 2], [1, 0, 2], [3, 4, 5]
+      P_idef = [nomdef, nomdef,symdef, rotdef]
+      for i in range(6): P_idef.append(nomdef)
+
+      ldicoeps=[]
+      dicoeps={}
+      dicoeps['EPXX']=eps_imp[0]
+      dicoeps['EPYY']=eps_imp[1]
+      dicoeps['EPZZ']=eps_imp[2]
+      dicoeps['EPXY']=eps_imp[3]
+      if modelisation == "3D" :
+         dicoeps['EPXZ']=eps_imp[4]
+         dicoeps['EPYZ']=eps_imp[5]
+      ldicoeps.append(dicoeps)               
+      motscles['EPSI_IMPOSE']=ldicoeps
+
+      if args['SUPPORT'] != None :
+         if modelisation == "C_PLAN" : 
+            motscles['MODELISATION']='C_PLAN'
+            motscles['SUPPORT']='ELEMENT'            
+         else :   
+            motscles['SUPPORT']=args['SUPPORT']     
+         
+      #Boucle sur l'ensemble des calculs
+      for i in range(Ncal):
+              N = LIST_NPAS[i]
+              imat = P_imat[i]
+              idef = P_idef[i]
+              temps=DEFI_LIST_REEL(DEBUT=0.0,
+                           INTERVALLE=(_F(JUSQU_A=t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=2.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=3.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=4.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=5.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=6.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=7.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=8.0*t_0,NOMBRE=N,),),);
+
+              _DEFLIST =DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST = temps,),
+                            ECHEC=_F(SUBD_METHODE='EXTRAPOLE',
+                                     SUBD_PAS=10,
+                                     SUBD_NIVEAU=10,),)
+      #       Resout le pb a deformation imposee
+              _RES[i]=SIMU_POINT_MAT(INFO=INFO,
+                         MATER      = LIST_MATER[imat],
+                         ARCHIVAGE = _F(LIST_INST = _tempsar),
+                         INCREMENT=_F(LIST_INST=_DEFLIST,),
+                         **motscles
+                              );
+      
+      #       On renomme les composantes en fonction de  l'ordre de discretisation
+              _RSI=RENOMME(self,i,LIST_NPAS,label_cal,ch_param,_RES,_RSI)
+              
+              DETRUIRE ( CONCEPT = _F (NOM = temps,),INFO=1)
+ 
+      # TEST_RESU sur les erreurs relatives
+      # les quantites (invariants...) sur lequels portent les calculs d'erreur et les test_resu
+      _RSI=TEST_ECART(self,ch_param2,label_cal,LIST_NPAS,Ncal,ch_param,_RSI,LIST_TOLE,PREC_ZERO)
+      
+      for ch in ch_param2 :
+        i=ch_param2.index(ch)
+        if INFO==2 : IMPR_TABLE(TABLE=_RSI[i]);
+        for j in range(Ncal) :
+          ch_cal = ch + label_cal[j] + str(LIST_NPAS[j])
+          ch_err = 'ER_' + ch_cal
+          TEST_TABLE(TABLE=_RSI[i],NOM_PARA=ch_err,
+            TYPE_TEST='MAX',VALE=0.,CRITERE='ABSOLU',PRECISION=LIST_TOLE[j],REFERENCE='ANALYTIQUE',);
+
+      ###############################################################################
+      # Test de la matrice tangente sur le calcul le plus fin
+      ###############################################################################
+
+      N = LIST_NPAS[Ncal-1]
+      _Linst=DEFI_LIST_REEL(DEBUT=0.0,
+                           INTERVALLE=(_F(JUSQU_A=t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=2.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=3.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=4.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=5.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=6.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=7.0*t_0,NOMBRE=N,),
+                                       _F(JUSQU_A=8.0*t_0,NOMBRE=N,),),);
+
+      if   COMP_INCR  :
+          motscles['COMP_INCR'][0]['TYPE_MATR_TANG'] = 'VERIFICATION' 
+      
+          _DEFLIS2 =DEFI_LIST_INST(DEFI_LIST=_F(LIST_INST = _Linst,),
+                            ECHEC=_F(SUBD_METHODE='EXTRAPOLE',
+                                     SUBD_PAS=10,
+                                     SUBD_NIVEAU=10,),)
+      #       Resout le pb a deformation imposee
+          U=SIMU_POINT_MAT(INFO=INFO,
+                         MATER      = LIST_MATER[imat],
+                         ARCHIVAGE = _F(LIST_INST = _tempsar),
+                         INCREMENT=_F(LIST_INST=_DEFLIS2,),
+                         **motscles
+                              );
+
+          _DIFFMAT=VERI_MATR_TANG()
+
+          TEST_TABLE(TABLE=_DIFFMAT,
+                     NOM_PARA='MAT_DIFF',
+                     TYPE_TEST='MAX',
+                     VALE=0.,
+                     CRITERE='ABSOLU',
+                     PRECISION=prec_tgt,
+                     REFERENCE='ANALYTIQUE',);
+
+          if INFO==2 : IMPR_TABLE(TABLE=_DIFFMAT)
+  
+  return ier
+

diff --git a/Aster/Cata/cataSTA10/SD/co_cham_no.py b/Aster/Cata/cataSTA10/SD/co_cham_no.py
index 764968155504f61b1f86a479dd85aed0f08bc180..59e4c63601758ca3320061d6e47f6fabf976f581 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/co_cham_no.py
+++ b/Aster/Cata/cataSTA10/SD/co_cham_no.py
@@ -1,8 +1,8 @@
-#@ MODIF co_cham_no SD  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF co_cham_no SD  DATE 14/12/2010   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -28,13 +28,14 @@ import numpy
 # -----------------------------------------------------------------------------
 # post-traitement :
 class post_comp_cham_no :
-  def __init__(self,valeurs,noeud=None) :
+  def __init__(self,valeurs,noeud=None,comp=None) :
     self.valeurs=valeurs
     self.noeud=noeud
+    self.comp=comp
 
 # -----------------------------------------------------------------------------
 class cham_no_sdaster(cham_gd_sdaster, sd_cham_no):
-   def EXTR_COMP(self,comp,lgno,topo=0) :
+   def EXTR_COMP(self,comp=' ',lgno=[],topo=0) :
       """ retourne les valeurs de la composante comp du champ sur la liste
         de groupes de noeuds lgno avec eventuellement l'info de la
         topologie si topo>0. Si lgno est une liste vide, c'est equivalent
@@ -42,7 +43,10 @@ class cham_no_sdaster(cham_gd_sdaster, sd_cham_no):
         Attributs retourne
           - self.valeurs : numpy.array contenant les valeurs
         Si on a demande la topo (i.e. self.topo = 1) :
-          - self.noeud  : numero de noeud """
+          - self.noeud  : numero de noeud 
+        Si on demande toutes les composantes (comp = ' ') :
+          - self.comp : les composantes associees a chaque grandeur pour chaque noeud
+      """
       if not self.accessible() :
          raise Accas.AsException("Erreur dans cham_no.EXTR_COMP en PAR_LOT='OUI'")
 
@@ -50,7 +54,7 @@ class cham_no_sdaster(cham_gd_sdaster, sd_cham_no):
       ncham=ncham+(8-len(ncham))*' '
       nchams=ncham[0:7]+'S'
       ncmp=comp+(8-len(comp))*' '
-
+      
       aster.prepcompcham(ncham,nchams,ncmp,"NO      ",topo,lgno)
 
       valeurs=numpy.array(aster.getvectjev(nchams+(19-len(ncham))*' '+'.V'))
@@ -60,9 +64,13 @@ class cham_no_sdaster(cham_gd_sdaster, sd_cham_no):
       else :
          noeud=None
 
-      aster.prepcompcham("__DETR__",nchams,ncmp,"NO      ",topo,lgno)
-
-      return post_comp_cham_no(valeurs,noeud)
+      if comp[:1] == ' ':
+         comp=(aster.getvectjev(nchams+(19-len(ncham))*' '+'.C'))
+         aster.prepcompcham("__DETR__",nchams,ncmp,"NO      ",topo,lgno)
+         return post_comp_cham_no(valeurs,noeud,comp)
+      else:
+         aster.prepcompcham("__DETR__",nchams,ncmp,"NO      ",topo,lgno)
+         return post_comp_cham_no(valeurs,noeud)
       
    def __add__(self, other):
       from SD.sd_nume_equa import sd_nume_equa

diff --git a/Aster/Cata/cataSTA10/SD/co_corresp_2_mailla.py b/Aster/Cata/cataSTA10/SD/co_corresp_2_mailla.py
new file mode 100644 (file)
index 0000000..2758688
--- /dev/null
+++ b/Aster/Cata/cataSTA10/SD/co_corresp_2_mailla.py
@@ -0,0 +1,25 @@
+#@ MODIF co_corresp_2_mailla SD  DATE 14/12/2010   AUTEUR PELLET J.PELLET 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+from SD import *
+from SD.sd_corresp_2_mailla import sd_corresp_2_mailla
+
+class corresp_2_mailla(ASSD, sd_corresp_2_mailla):
+   pass

diff --git a/Aster/Cata/cataSTA10/SD/co_grille.py b/Aster/Cata/cataSTA10/SD/co_grille.py
new file mode 100644 (file)
index 0000000..724b7b0
--- /dev/null
+++ b/Aster/Cata/cataSTA10/SD/co_grille.py
@@ -0,0 +1,29 @@
+#@ MODIF co_grille SD  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
+
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+#  RESPONSABLE GENIAUT S.GENIAUT
+
+from SD import *
+from co_maillage import maillage_sdaster
+from sd_grille   import sd_grille
+
+# -----------------------------------------------------------------------------
+class grille_sdaster(maillage_sdaster,sd_grille):
+   pass
+      

diff --git a/Aster/Cata/cataSTA10/SD/co_matr_asse.py b/Aster/Cata/cataSTA10/SD/co_matr_asse.py
index b57e3846f9e5df4a078817b7249b2cf0b06d8144..46858f223a278a17ab2d04e75c9017b192412ba0 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/co_matr_asse.py
+++ b/Aster/Cata/cataSTA10/SD/co_matr_asse.py
@@ -1,27 +1,75 @@
-#@ MODIF co_matr_asse SD  DATE 13/02/2007   AUTEUR PELLET J.PELLET 
+#@ MODIF co_matr_asse SD  DATE 07/12/2010   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 
 from SD import *
 from sd_matr_asse import sd_matr_asse
+from sd_nume_ddl  import sd_nume_ddl
+from SD.sd_stoc_morse import sd_stoc_morse
+import numpy
 
 # -----------------------------------------------------------------------------
 class matr_asse(ASSD, sd_matr_asse):
-   pass
-      
+
+
+  def EXTR_MATR(self) :
+    """ retourne les valeurs de la matrice  dans un format numpy
+        Attributs retourne
+          - self.valeurs : numpy.array contenant les valeurs """
+
+    if not self.accessible():
+       raise Accas.AsException("Erreur dans matr_asse.EXTR_MATR en PAR_LOT='OUI'")
+
+    refa = numpy.array(self.REFA.get())
+    ma=refa[0]
+    nu=refa[1]
+    smos = sd_stoc_morse(nu[:14]+'.SMOS')
+
+    valm=self.VALM.get()
+    smhc=smos.SMHC.get()
+    smdi=smos.SMDI.get()
+
+    sym=len(valm)==1
+    dim=len(smdi)
+    nnz=smdi[dim-1]
+
+    triang_sup = numpy.array(valm[1])
+    print "AJACOT triang_sup=",triang_sup
+    if sym:
+      triang_inf = triang_sup
+    else:
+      triang_inf = numpy.array(valm[2])
+
+    if type(valm[1][0]) == type(1.j) :
+       dtype=complex
+    else :
+       dtype=float
+    valeur=numpy.zeros([dim, dim], dtype=dtype)
+
+    jcol=1
+    for kterm in range(1,nnz+1):
+      ilig=smhc[kterm-1]
+      if (smdi[jcol-1] < kterm) : jcol=jcol+1
+
+      valeur[jcol-1,ilig-1]=triang_inf[kterm-1]
+      valeur[ilig-1,jcol-1]=triang_sup[kterm-1]
+
+
+
+    return valeur

diff --git a/Aster/Cata/cataSTA10/SD/sd_compor.py b/Aster/Cata/cataSTA10/SD/sd_compor.py
index df8475890ee6b13ea6138a4f098032477be0b50d..892d47dd3d34052058a6de5b6a6424f6e02c0d47 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/sd_compor.py
+++ b/Aster/Cata/cataSTA10/SD/sd_compor.py
@@ -1,8 +1,8 @@
-#@ MODIF sd_compor SD  DATE 08/12/2009   AUTEUR PROIX J-M.PROIX 
+#@ MODIF sd_compor SD  DATE 14/12/2010   AUTEUR PROIX J-M.PROIX 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -82,15 +82,14 @@ class sd_compor(AsBase):
             famil     =cprk[5*k+0]
             mater     =cprk[5*k+1]
             ecoul     =cprk[5*k+2]
-            ecro_isot =cprk[5*k+3]
-            ecro_cine =cprk[5*k+4]
+            MONO_isot =cprk[5*k+3]
+            MONO_cine =cprk[5*k+4]
             sd2=sd_mater(mater) ; sd2.check(checker)
             assert famil in ('BASAL','BCC24','PRISMATIQUE','OCTAEDRIQUE','PYRAMIDAL1',
-                            'PYRAMIDAL2','CUBIQUE1','CUBIQUE2','MACLAGE','JOINT_GRAIN',
-                            'RL','UNIAXIAL')
-            assert ecoul in ('ECOU_VISC1','ECOU_VISC2','ECOU_VISC3')
-            assert ecro_isot in ('ECRO_ISOT1','ECRO_ISOT2')
-            assert ecro_cine in ('ECRO_CINE1','ECRO_CINE2')
+                            'PYRAMIDAL2','CUBIQUE1','CUBIQUE2','MACLAGE','UNIAXIAL')
+            assert ecoul in ('MONO_VISC1','MONO_VISC2','MONO_VISC3')
+            assert MONO_isot in ('MONO_ISOT1','MONO_ISOT2')
+            assert MONO_cine in ('MONO_CINE1','MONO_CINE2')
 
 
 

diff --git a/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py b/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py
index 340ca74f21201c1d8a6a28dd4d17195ea7a2e04f..400182eda9f465d376a4426f737406a735842328 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py
+++ b/Aster/Cata/cataSTA10/SD/sd_corresp_2_mailla.py
@@ -1,26 +1,28 @@
-#@ MODIF sd_corresp_2_mailla SD  DATE 02/02/2010   AUTEUR PELLET J.PELLET 
+#@ MODIF sd_corresp_2_mailla SD  DATE 08/03/2011   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 
 from SD import *
+from SD.sd_titre import sd_titre
 
-class sd_corresp_2_mailla(AsBase):
+
+class sd_corresp_2_mailla(sd_titre):
     nomj = SDNom(fin=16)
     PJXX_K1 = AsVK24(lonmax=5)
 
@@ -34,7 +36,6 @@ class sd_corresp_2_mailla(AsBase):
     PJEF_M1 = Facultatif(AsVI())
     PJEF_CF = Facultatif(AsVR())
     PJEF_TR = Facultatif(AsVI())
-    PJEF_AM = Facultatif(AsVI())
     PJEF_CO = Facultatif(AsVR())
 
     PJNG_I1 = Facultatif(AsVI())

diff --git a/Aster/Cata/cataSTA10/SD/sd_grille.py b/Aster/Cata/cataSTA10/SD/sd_grille.py
new file mode 100644 (file)
index 0000000..82f2fa7
--- /dev/null
+++ b/Aster/Cata/cataSTA10/SD/sd_grille.py
@@ -0,0 +1,29 @@
+#@ MODIF sd_grille SD  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
+
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+#  RESPONSABLE GENIAUT S.GENIAUT
+
+from SD import *
+from SD.sd_maillage import sd_maillage
+
+class sd_grille(sd_maillage):
+     nomj = SDNom(fin=8)
+     
+     GRLR = AsVR()
+     GRLI = AsVI()

diff --git a/Aster/Cata/cataSTA10/SD/sd_maillage.py b/Aster/Cata/cataSTA10/SD/sd_maillage.py
index 2ac6be121fe4fc264e8072a5a7abf1e6e5dfad8a..b1fd54a181fbe335be15ee9dbaaf266e4abceac7 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/sd_maillage.py
+++ b/Aster/Cata/cataSTA10/SD/sd_maillage.py
@@ -1,8 +1,8 @@
-#@ MODIF sd_maillage SD  DATE 06/05/2008   AUTEUR PELLET J.PELLET 
+#@ MODIF sd_maillage SD  DATE 11/05/2011   AUTEUR SELLENET N.SELLENET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -68,7 +68,6 @@ class sd_maillage(sd_titre):
     VGE  = Facultatif(sd_voisinage())
 
     ADAPTATION = Facultatif(AsVI(lonmax=1, ))
-    FORM = Facultatif(AsVK32(SDNom(debut=19), lonmax=2, ))
 
 
     def u_dime(self):

diff --git a/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py b/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py
index eb8e74432b397bf7ccae2eb068396397e88e32cd..62a7126d708225359b8ebf55b1d622353e4a0275 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py
+++ b/Aster/Cata/cataSTA10/SD/sd_proj_mesu.py
@@ -1,8 +1,8 @@
-#@ MODIF sd_proj_mesu SD  DATE 15/01/2008   AUTEUR PELLET J.PELLET 
+#@ MODIF sd_proj_mesu SD  DATE 14/12/2010   AUTEUR PELLET J.PELLET 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -53,7 +53,7 @@ class sd_proj_mesu(AsBase):
 
         # vérifications communes :
         assert self.PJMRG.lonmax >= nbutil
-        n1=self.PJMBP.lonmax
+        n1=self.PJMBP.lonuti
         nbmode=n1/nbutil
         assert n1==nbutil*nbmode , (nbmode,nbutil,n1)
         assert self.PJMRF.exists

diff --git a/Aster/Cata/cataSTA10/SD/sd_solveur.py b/Aster/Cata/cataSTA10/SD/sd_solveur.py
index 3d73281077d8fd030decd2255b646ffc902e1853..d3837f9e0d220d6fec63f3b787995d34de76bddc 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/sd_solveur.py
+++ b/Aster/Cata/cataSTA10/SD/sd_solveur.py
@@ -1,8 +1,8 @@
-#@ MODIF sd_solveur SD  DATE 05/10/2009   AUTEUR BOITEAU O.BOITEAU 
+#@ MODIF sd_solveur SD  DATE 18/01/2011   AUTEUR BOITEAU O.BOITEAU 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -22,7 +22,7 @@ from SD import *
 
 class sd_solveur(AsBase):
     nomj = SDNom(fin=19)
-    SLVK = AsVK24(SDNom(debut=19), lonmax=11, )
+    SLVK = AsVK24(SDNom(debut=19), lonmax=12, )
     SLVR = AsVR(SDNom(debut=19), lonmax=4, )
     SLVI = AsVI(SDNom(debut=19), lonmax=7, )
 
@@ -34,7 +34,7 @@ class sd_solveur(AsBase):
         if method == 'MUMPS' :
             assert slvk[1] in ('AUTO', 'SANS'), slvk
             assert slvk[2] in ('NONSYM', 'SYMGEN', 'SYMDEF', 'AUTO'), slvk
-            assert slvk[3] in ('AMD','AMF','PORD','METIS','QAMD','AUTO'), slvk
+            assert slvk[3] in ('AMD','AMF','PORD','METIS','QAMD','AUTO','SCOTCH'), slvk
             assert slvk[4] in ('OUI', 'NON'), slvk
             assert slvk[5] in ('OUI', 'NON'), slvk
         else :

diff --git a/Aster/Cata/cataSTA10/SD/sd_xfem.py b/Aster/Cata/cataSTA10/SD/sd_xfem.py
index 120fcb20b2143e4f83356412a86bce182abe3d76..092eb78234c8831c740601b75fa5a794758739dd 100644 (file)
--- a/Aster/Cata/cataSTA10/SD/sd_xfem.py
+++ b/Aster/Cata/cataSTA10/SD/sd_xfem.py
@@ -1,8 +1,8 @@
-#@ MODIF sd_xfem SD  DATE 28/09/2010   AUTEUR MASSIN P.MASSIN 
+#@ MODIF sd_xfem SD  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -24,6 +24,7 @@ from SD.sd_cham_no   import sd_cham_no
 from SD.sd_cham_elem import sd_cham_elem
 from SD.sd_carte     import sd_carte
 from SD.sd_util      import *
+from SD.sd_l_table import sd_l_table
 
 
 
@@ -48,6 +49,14 @@ class sd_fiss_xfem(AsBase):
     BASEFOND        = Facultatif(AsVR())
     FONDMULT        = Facultatif(AsVI())
     CARAFOND        = Facultatif(AsVR(lonmax=12,))
+    JONFISS = Facultatif(AsVK8())
+    JONCOEF = Facultatif(AsVI())
+#   objets relatifs a la grille auxiliaire
+    GRILLE_MODELE  = Facultatif(AsVK8(SDNom(nomj='.GRI.MODELE'),lonmax=1,))
+    GRILLE_LNNO    = Facultatif(sd_cham_no(SDNom(nomj='.GRI.LNNO')))
+    GRILLE_LTNO    = Facultatif(sd_cham_no(SDNom(nomj='.GRI.LTNO')))
+    GRILLE_GRLNNO  = Facultatif(sd_cham_no(SDNom(nomj='.GRI.GRLNNO')))
+    GRILLE_GRLTNO  = Facultatif(sd_cham_no(SDNom(nomj='.GRI.GRLTNO')))
 
 # I.2) objets relatifs a l'enrichissement
 
@@ -65,9 +74,9 @@ class sd_fiss_xfem(AsBase):
 
     PRO_MES_EL  = Facultatif(sd_cham_elem(SDNom(nomj='.PRO.MES_EL')))
     PRO_NORMAL  = Facultatif(sd_cham_elem(SDNom(nomj='.PRO.NORMAL')))
+#   objets relatifs a la localisation du domaine de calcul
     PRO_RAYON_TORE  = Facultatif(AsVR(SDNom(nomj='.PRO.RAYON_TORE'),lonmax=1,))
     PRO_NOEUD_TORE  = Facultatif(AsVL(SDNom(nomj='.PRO.NOEUD_TORE')))
-    PRO_MOD_GRILLE  = Facultatif(AsVK8(SDNom(nomj='.PRO.MOD_GRILLE'),lonmax=1,))
 
 # I.4) objets relatifs au contact
 
@@ -76,6 +85,9 @@ class sd_fiss_xfem(AsBase):
     LISEQ  = Facultatif(AsVI(SDNom(nomj='.LISEQ')))
     LISRL  = Facultatif(AsVI(SDNom(nomj='.LISRL')))
 
+# I.4) objets relatifs au contact
+    # une sd_modele peut avoir une "sd_l_table" contenant des grandeurs caractéristiques de l'étude :
+    lt = Facultatif(sd_l_table(SDNom(nomj='')))
 
 # 1.5) verifications d'existence :
 
@@ -84,7 +96,8 @@ class sd_fiss_xfem(AsBase):
         sdu_ensemble((self.LISRL, self.LISCO))
         sdu_ensemble((self.PRO_MES_EL.CELD, self.PRO_NORMAL.CELD))
         sdu_ensemble((self.PRO_RAYON_TORE, self.PRO_NOEUD_TORE))
-
+        sdu_ensemble((self.GRILLE_MODELE, self.GRILLE_LNNO.DESC, self.GRILLE_GRLNNO.DESC))
+        sdu_ensemble((self.GRILLE_LTNO.DESC, self.GRILLE_GRLTNO.DESC))
 
 #-------------------------------
 #       II. sd modele

diff --git a/Aster/Cata/cataSTA10/Utilitai/Graph.py b/Aster/Cata/cataSTA10/Utilitai/Graph.py
new file mode 100644 (file)
index 0000000..23127b1
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/Graph.py
@@ -0,0 +1,1200 @@
+#@ MODIF Graph Utilitai  DATE 26/05/2010   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+# RESPONSABLE COURTOIS M.COURTOIS
+__all__ = ['Graph', 'AjoutParaCourbe']
+
+import sys
+import os
+import os.path
+import string
+import re
+import types
+import time
+import numpy
+
+from Utilitai.Utmess import UTMESS
+
+# try/except pour utiliser hors aster
+try:
+   import aster
+except ImportError:
+   class fake_aster:
+      def repout(self): return '/opt/aster/outils'
+   aster=fake_aster()
+
+
+if not sys.modules.has_key('Table'):
+   try:
+      from Utilitai import Table
+   except ImportError:
+      import Table
+   
+
+# ------------------------------------------------------------------------------
+class Graph:
+   """Cette classe définit l'objet Graph pour Code_Aster.
+   
+   Important :  Utiliser les méthodes dédiées à la manipulation des données
+      (AjoutCourbe, ...) car elles tiennent à jour les attributs "privés"
+      relatifs aux données : NbCourbe, les extrema...
+   
+   Attributs :
+   - Données de chaque courbe :
+      .Valeurs   : liste des valeurs de chaque courbe, pour chaque courbe :
+         (paramètres, parties réelles [, parties imaginaires])
+      .Legendes  : liste des noms de chaque courbe
+      .Labels    : liste des noms des colonnes de chaque courbe
+      .Styles    : liste des infices de styles de ligne
+      .Couleurs  : liste des indices de couleurs
+      .Marqueurs : liste des indices de symboles/marqueurs
+      .FreqMarq  : liste des fréquences des marqueurs
+      .Tri       : liste du tri à effectuer sur les données ('N', 'X', 'Y',
+         'XY' ou 'YX')
+     Pour Lignes, Couleurs, Marqueurs, FreqMarq, -1 signifie valeur par défaut
+     du traceur.
+
+   - Propriétés :
+      .Titre : titre du graphique
+      .SousTitre : sous-titre (appelé commentaire dans agraf)
+   - Axes :
+      .Min_X, .Max_X, .Min_Y, .Max_Y : bornes du tracé (une méthode permet de
+         renseigner automatiquement ces valeurs avec les extréma globaux)
+      .Legende_X, .Legende_Y : légende des axes
+      .Echelle_X, .Echelle_Y : type d'échelle (LIN, LOG)
+      .Grille_X, .Grille_Y : paramètre de la grille (pas ou fréquence au choix
+         de l'utilisateur en fonction du traceur qu'il veut utiliser)
+
+   Attributs privés (modifiés uniquement par les méthodes de la classe) :
+      .NbCourbe : nombre de courbes
+      .BBXmin, BBXmax, BBYmin, BBYmax : extrema globaux (bounding box)
+      .LastTraceArgs, LastTraceFormat : données utilisées lors du dernier tracé
+   """
+# ------------------------------------------------------------------------------
+   def __init__(self):
+      """Construction + valeurs par défaut des attributs
+      """
+      self.Valeurs   = []
+      self.Legendes  = []
+      self.Labels    = []
+      self.Styles    = []
+      self.Couleurs  = []
+      self.Marqueurs = []
+      self.FreqMarq  = []
+      self.Tri       = []
+      self.Titre     = ''
+      self.SousTitre = ''
+      self.Min_X     = None
+      self.Max_X     = None
+      self.Min_Y     = None
+      self.Max_Y     = None
+      self.MinP_X    =  1.e+99   # minimum > 0 pour les échelles LOG
+      self.MinP_Y    =  1.e+99
+      self.Legende_X = ''
+      self.Legende_Y = ''
+      self.Echelle_X = 'LIN'
+      self.Echelle_Y = 'LIN'
+      self.Grille_X  = -1
+      self.Grille_Y  = -1
+      # attributs que l'utilisateur ne doit pas modifier
+      self.NbCourbe  = len(self.Valeurs)
+      self.BBXmin    =  1.e+99
+      self.BBXmax    = -1.e+99
+      self.BBYmin    =  1.e+99
+      self.BBYmax    = -1.e+99
+      # pour conserver les paramètres du dernier tracé
+      self.LastTraceArgs = {}
+      self.LastTraceFormat = ''
+
+# ------------------------------------------------------------------------------
+   def SetExtremaX(self,marge=0., x0=None, x1=None, force=True):
+      """Remplit les limites du tracé (Min/Max_X) avec les valeurs de la
+      bounding box +/- avec une 'marge'*(Max-Min)/2.
+      x0,x1 permettent de modifier la bb.
+      """
+      if x0<>None:   self.BBXmin=min([self.BBXmin, x0])
+      if x1<>None:   self.BBXmax=max([self.BBXmax, x1])
+
+      dx=max(self.BBXmax-self.BBXmin,0.01*self.BBXmax)
+      if dx == 0.:
+         dx = 1.e-6
+      if force or self.Min_X==None:
+         self.Min_X = self.BBXmin - marge*dx/2.
+      if force or self.Max_X==None:
+         self.Max_X = self.BBXmax + marge*dx/2.
+      return
+
+   def SetExtremaY(self,marge=0., y0=None, y1=None, force=True):
+      """Remplit les limites du tracé (Min/Max_Y) avec les valeurs de la
+      bounding box +/- avec une 'marge'*(Max-Min)/2.
+      y0,y1 permettent de modifier la bb.
+      """
+      if y0<>None:   self.BBYmin=min([self.BBYmin, y0])
+      if y1<>None:   self.BBYmax=max([self.BBYmax, y1])
+
+      dy=max(self.BBYmax-self.BBYmin,0.01*self.BBYmax)
+      if dy == 0.:
+         dy = 1.e-6
+      if force or self.Min_Y==None:
+         self.Min_Y = self.BBYmin - marge*dy/2.
+      if force or self.Max_Y==None:
+         self.Max_Y = self.BBYmax + marge*dy/2.
+      return
+
+   def SetExtrema(self,marge=0., x0=None, x1=None, y0=None, y1=None, force=True):
+      """Remplit les limites du tracé (Min/Max_X/Y) avec les valeurs de la
+      bounding box +/- avec une 'marge'*(Max-Min)/2.
+      x0,x1,y0,y1 permettent de modifier la bb.
+      """
+      self.SetExtremaX(marge, x0, x1, force=force)
+      self.SetExtremaY(marge, y0, y1, force=force)
+      return
+# ------------------------------------------------------------------------------
+   def AutoBB(self,debut=-1):
+      """Met à jour automatiquement la "bounding box"
+      (extrema toutes courbes confondues)
+      Appelé par les méthodes de manipulation des données
+      """
+      if debut == -1:
+         debut=self.NbCourbe-1
+      if debut == 0:
+         X0 =  1.e+99
+         X1 = -1.e+99
+         Y0 =  1.e+99
+         Y1 = -1.e+99
+      else:
+         X0 = self.BBXmin
+         X1 = self.BBXmax
+         Y0 = self.BBYmin
+         Y1 = self.BBYmax
+      
+      for i in range(debut,self.NbCourbe):
+         X0 = min([X0,]+list(self.Valeurs[i][0]))
+         X1 = max([X1,]+list(self.Valeurs[i][0]))
+         self.MinP_X = min([self.MinP_X,]+[x for x \
+                  in list(self.Valeurs[i][0]) if x>0])
+         for ny in range(1,len(self.Valeurs[i])):
+            Y0 = min([Y0,]+list(self.Valeurs[i][ny]))
+            Y1 = max([Y1,]+list(self.Valeurs[i][ny]))
+            self.MinP_Y = min([self.MinP_Y,]+[y for y \
+                  in list(self.Valeurs[i][ny]) if y>0])
+      self.BBXmin = X0
+      self.BBXmax = X1
+      self.BBYmin = Y0
+      self.BBYmax = Y1
+      return
+# ------------------------------------------------------------------------------
+   def AjoutCourbe(self,Val,Lab,Leg='',Sty=-1,Coul=-1,Marq=-1,FreqM=-1,Tri='N'):
+      """Ajoute une courbe dans les données
+         Val   : liste de 2 listes (ou 3 si complexe) : abs, ord[, imag]
+         Leg   : une chaine
+         Lab   : liste de 2 chaines (ou 3 si complexe)
+         Sty   : un entier
+         Coul  : un entier
+         Marq  : un entier
+         FreqM : un entier
+         Tri   : chaine de caractères : N, X, Y, XY ou YX
+      Met à jour les attributs : NbCourbe, BBXmin/Xmax/Ymin/Ymax
+      """
+      nbc = len(Val)   # nombre de colonnes : 2 ou 3
+      
+      # verifications : "if not (conditions requises)"
+      if not ( 2 <= nbc <= 3 and \
+         type(Val[0]) in (types.ListType, types.TupleType) and \
+         type(Val[1]) in (types.ListType, types.TupleType) and \
+         (nbc==2 or type(Val[2]) in (types.ListType, types.TupleType)) and \
+         len(Val[0]) == len(Val[1]) and (nbc==2 or len(Val[0]) == len(Val[2])) ):
+            UTMESS('F','GRAPH0_1')
+      
+      if len(Lab) <> nbc:
+            UTMESS('S','GRAPH0_2')
+            
+      # ajout dans les données
+      self.Legendes.append(str(Leg))
+      self.Labels.append([str(L) for L in Lab])
+      self.Valeurs.append(Val)
+      self.Styles.append(Sty)
+      self.Couleurs.append(Coul)
+      self.Marqueurs.append(Marq)
+      self.FreqMarq.append(FreqM)
+      self.Tri.append(Tri)
+
+      self.NbCourbe = self.NbCourbe + 1
+      self.AutoBB()
+      return
+# ------------------------------------------------------------------------------
+   def Courbe(self,n):
+      """Permet de récupérer les données de la courbe d'indice n sous forme
+      d'un dictionnaire.
+      """
+      dico={
+         'Leg'    : self.Legendes[n],           # légende de la courbe
+         'LabAbs' : self.Labels[n][0],          # labels des abscisses
+         'LabOrd' : [self.Labels[n][1],],       # labels des ordonnées
+         'NbCol'  : len(self.Valeurs[n]),       # nombre de colonnes
+         'NbPts'  : len(self.Valeurs[n][0]),    # nombre de points
+         'Abs'    : self.Valeurs[n][0],         # liste des abscisses
+         'Ord'    : [self.Valeurs[n][1],],      # liste des ordonnées
+         'Sty'    : self.Styles[n],             # style de la ligne
+         'Coul'   : self.Couleurs[n],           # couleur
+         'Marq'   : self.Marqueurs[n],          # marqueur
+         'FreqM'  : self.FreqMarq[n],           # fréquence du marqueur
+         'Tri'    : self.Tri[n],                # ordre de tri des données
+      }
+      if(dico['NbCol'] == 3):
+         dico['LabOrd'].append(self.Labels[n][2]) # labels de la partie imaginaire
+         dico['Ord'].append(self.Valeurs[n][2])   # liste des ordonnées partie imaginaire
+      return dico
+# ------------------------------------------------------------------------------
+   def Trace(self,FICHIER=None,FORMAT=None,dform=None,**opts):
+      """Tracé du Graph selon le format spécifié.
+         FICHIER : nom du(des) fichier(s). Si None, on dirige vers stdout
+         dform : dictionnaire de formats d'impression (format des réels,
+            commentaires, saut de ligne...)
+         opts  : voir TraceGraph.
+      """
+      para={
+         'TABLEAU' : { 'mode' : 'a', 'driver' : TraceTableau, },
+         'XMGRACE' : { 'mode' : 'a', 'driver' : TraceXmgrace, },
+         'AGRAF'   : { 'mode' : 'a', 'driver' : TraceAgraf,   },
+      }
+      kargs={}
+      if self.LastTraceArgs=={}:
+         kargs['FICHIER']=FICHIER
+         kargs['dform']=dform
+         kargs['opts']=opts
+      else:
+         kargs=self.LastTraceArgs.copy()
+         if FORMAT==None:
+            FORMAT=self.LastTraceFormat
+         if FICHIER<>None:
+            kargs['FICHIER']=FICHIER
+         if dform<>None:
+            kargs['dform']=dform
+         if opts<>{}:
+            kargs['opts']=opts
+      if not FORMAT in para.keys():
+         UTMESS('A', 'GRAPH0_3', valk=FORMAT)
+      else:
+         kargs['fmod']=para[FORMAT]['mode']
+         self.LastTraceArgs   = kargs.copy()
+         self.LastTraceFormat = FORMAT
+         # call the associated driver
+         para[FORMAT]['driver'](self,**kargs)
+# ------------------------------------------------------------------------------
+   def __repr__(self):
+      """Affichage du contenu d'un Graph"""
+      srep=''
+      for attr in ['NbCourbe','Legendes','Labels','Valeurs','Min_X','Max_X','Min_Y','Max_Y','BBXmax','BBXmin','BBYmax','BBYmin','Legende_X','Legende_Y','Echelle_X','Echelle_Y','Grille_X','Grille_Y','Tri']:
+         srep=srep + '%-10s : %s\n' % (attr,str(getattr(self,attr)))
+      return srep
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+class TraceGraph:
+   """
+   Cette classe définit le tracé d'un objet Graph dans un fichier.
+   
+   Attributs :
+      .NomFich : liste de noms de fichier de sortie
+
+   Attributs privés (modifiés uniquement par les méthodes de la classe) :
+      .Fich    : liste des objets 'fichier'
+      .Graph   : objet Graph que l'on veut tracer
+      .DicForm : dictionnaire des formats de base (séparateur, format des réels...)
+   
+   Les méthodes Entete, DescrCourbe, Trace (définition de l'entete, partie descriptive
+   d'une courbe, méthode de tracé/impression) sont définies dans une classe dérivée.
+   """
+# ------------------------------------------------------------------------------
+   def __init__(self,graph,FICHIER,fmod='w',dform=None,opts={}):
+      """Construction, ouverture du fichier, surcharge éventuelle du formatage
+      (dform), mode d'ouverture du fichier (fmod).
+      opts  : dictionnaire dont les valeurs seront affectées comme attributs
+         de l'objet (A utiliser pour les propriétés spécifiques
+         à un format, exemple 'PILOTE' pour Xmgrace).
+      """
+      # attributs optionnels (au début pour éviter un écrasement maladroit !)
+      for k,v in opts.items():
+         setattr(self,k,v)
+
+      # Ouverture du(des) fichier(s)
+      self.NomFich=[]
+      if type(FICHIER) is types.StringType:
+         self.NomFich.append(FICHIER)
+      elif type(FICHIER) in (types.ListType, types.TupleType):
+         self.NomFich=FICHIER[:]
+      else:
+         # dans ce cas, on écrira sur stdout (augmenter le 2 éventuellement)
+         self.NomFich=[None]*2
+      self.Fich=[]
+      for ff in self.NomFich:
+         if ff<>None:
+            self.Fich.append(open(ff,fmod))
+         else:
+            self.Fich.append(sys.stdout)
+      
+      # objet Graph sous-jacent
+      self.Graph=graph
+      # si Min/Max incohérents
+      if graph.Min_X==None or graph.Max_X==None or graph.Min_X > graph.Max_X:
+         graph.SetExtremaX(marge=0.05, force=True)
+      if graph.Min_Y==None or graph.Max_Y==None or graph.Min_Y > graph.Max_Y:
+         graph.SetExtremaY(marge=0.05, force=True)
+
+      if graph.Echelle_X=='LOG':
+         graph.Grille_X=10
+         # verif si Min<0 à cause de la marge
+         if graph.Min_X < 0.:
+            if graph.BBXmin < 0.:
+               UTMESS('A', 'GRAPH0_4')
+            graph.Min_X=graph.MinP_X
+      if graph.Echelle_Y=='LOG':
+         graph.Grille_Y=10
+         if graph.Min_Y < 0.:
+            if graph.BBYmin < 0.:
+               UTMESS('A', 'GRAPH0_5')
+            graph.Min_Y=graph.MinP_Y
+      
+      # formats de base (identiques à ceux du module Table)
+      self.DicForm={
+         'csep'   : ' ',       # séparateur
+         'ccom'   : '#',       # commentaire
+         'ccpara' : '',        # commentaire des labels
+         'cdeb'   : '',        # début de ligne
+         'cfin'   : '\n',      # fin de ligne
+         'sepch'  : ';',       # remplace les sauts de ligne à l'intérieur d'une cellule
+         'formK'  : '%-12s',   # chaines
+         'formR'  : '%12.5E',  # réels
+         'formI'  : '%12d'     # entiers
+      }
+      if dform<>None and type(dform)==types.DictType:
+         self.DicForm.update(dform)
+      
+      # let's go
+      self.Trace()
+
+# ------------------------------------------------------------------------------
+   def __del__(self):
+      """Fermeture du(des) fichier(s) à la destruction"""
+      if hasattr(self,'Fich'):
+         self._FermFich()
+# ------------------------------------------------------------------------------
+   def _FermFich(self):
+      """Fermeture du(des) fichier(s)"""
+      for fp in self.Fich:
+         if fp<>sys.stdout:
+            fp.close()
+# ------------------------------------------------------------------------------
+   def _OuvrFich(self):
+      """Les fichiers sont ouverts par le constructeur. S'ils ont été fermés,
+      par un appel au Tracé, _OuvrFich ouvre de nouveau les fichiers dans le
+      meme mode"""
+      n=len(self.NomFich)
+      for i in range(n):
+         if self.Fich[i].closed:
+            self.Fich[i]=open(self.NomFich[i],self.Fich[i].mode)
+
+# ------------------------------------------------------------------------------
+   def Entete(self):
+      """Retourne l'entete"""
+      raise NotImplementedError, "Cette méthode doit etre définie par la classe fille."
+# ------------------------------------------------------------------------------
+   def DescrCourbe(self,**args):
+      """Retourne la chaine de caractères décrivant les paramètres de la courbe.
+      """
+      raise NotImplementedError, "Cette méthode doit etre définie par la classe fille."
+# ------------------------------------------------------------------------------
+   def Trace(self):
+      """Méthode pour 'tracer' l'objet Graph dans un fichier.
+      Met en page l'entete, la description des courbes et les valeurs selon
+      le format et ferme le fichier.
+      """
+      raise NotImplementedError, "Cette méthode doit etre définie par la classe fille."
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+class TraceTableau(TraceGraph):
+   """
+   Impression d'un objet Graph sous forme d'un tableau de colonnes,
+   on suppose que les courbes partagent la meme liste d'abscisse à 'EPSILON'
+   près, sinon on alarme.
+   """
+   EPSILON=1.e-4
+# ------------------------------------------------------------------------------
+   def Trace(self):
+      """Méthode pour 'tracer' l'objet Graph dans un fichier.
+      Met en page l'entete, la description des courbes et les valeurs selon
+      le format et ferme le fichier.
+      L'ouverture et la fermeture du fichier sont gérées par l'objet Table.
+      """
+      g=self.Graph
+      msg=[]
+      if g.NbCourbe > 0:
+         # validité des données (abscisses identiques)
+         t0=numpy.array(g.Courbe(0)['Abs'])
+         max0=max(abs(t0))
+         for i in range(1,g.NbCourbe):
+            if g.Courbe(i)['NbPts']<>g.Courbe(0)['NbPts']:
+               msg.append("La courbe %d n'a pas le meme " \
+                     "nombre de points que la 1ère." % i)
+            else:
+               ti=numpy.array(g.Courbe(i)['Abs'])
+               if max(abs((ti-t0).ravel())) > self.EPSILON*max0:
+                  msg.append("Courbe %d : écart entre les "\
+                        "abscisses supérieur à %9.2E" % (i+1,self.EPSILON))
+                  msg.append("     Utilisez IMPR_FONCTION pour interpoler " \
+                        "les valeurs sur la première liste d'abscisses.")
+         # objet Table
+         Tab=Table.Table()
+         # titre / sous-titre
+         tit=[]
+         tit.append(self.DicForm['ccom']+' '+g.Titre)
+         tit.append(self.DicForm['ccom']+' '+g.SousTitre)
+         # legendes
+         for i in range(g.NbCourbe):
+            tit.append(self.DicForm['ccom']+' Courbe '+str(i))
+            tit.extend([self.DicForm['ccom']+' '+leg for leg in g.Legendes[i].split(os.linesep)])
+         Tab.titr=self.DicForm['cfin'].join(tit)
+         # noms des paramètres/colonnes
+         Tab.para.append(g.Labels[0][0])
+         for i in range(g.NbCourbe):
+            for lab in g.Labels[i][1:]:
+               Tab.para.append(lab)
+         # types
+         Tab.type=['R']*len(Tab.para)
+         # lignes de la Table
+         dC0=g.Courbe(0)
+         for j in range(dC0['NbPts']):
+            row={}
+            row[dC0['LabAbs']]=dC0['Abs'][j]
+            for i in range(g.NbCourbe):
+               dCi=g.Courbe(i)
+               for k in range(dCi['NbCol']-1):
+                  try:
+                     row[dCi['LabOrd'][k]]=dCi['Ord'][k][j]
+                  except IndexError:
+                     row[dCi['LabOrd'][k]]=None
+            Tab.append(row)
+         Tab.Impr(FICHIER=self.NomFich[0], FORMAT='TABLEAU', dform=self.DicForm)
+         # erreurs ?
+         if msg:
+            UTMESS('A', 'GRAPH0_6', valk='\n'.join(msg))
+      return
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+class TraceXmgrace(TraceGraph):
+   """
+   Impression d'un objet Graph au format XMGRACE.
+   Attribut supplémentaire : .PILOTE
+   """
+   PILOTE=''
+# ------------------------------------------------------------------------------
+   def Entete(self):
+      """Retourne l'entete du fichier .agr correspondant à la mise en forme
+      """
+      dic_ech={ 'LIN' : 'Normal', 'LOG' : 'Logarithmic' }
+      g=self.Graph
+      entete=[]
+      entete.append("""
+# Grace project file
+#
+@version 50100
+@page size 842, 595
+@page scroll 5%
+@page inout 5%
+@link page off
+@map font 0 to "Times-Roman", "Times-Roman"
+@map font 1 to "Times-Italic", "Times-Italic"
+@map font 2 to "Times-Bold", "Times-Bold"
+@map font 3 to "Times-BoldItalic", "Times-BoldItalic"
+@map font 4 to "Helvetica", "Helvetica"
+@map font 5 to "Helvetica-Oblique", "Helvetica-Oblique"
+@map font 6 to "Helvetica-Bold", "Helvetica-Bold"
+@map font 7 to "Helvetica-BoldOblique", "Helvetica-BoldOblique"
+@map font 8 to "Courier", "Courier"
+@map font 9 to "Courier-Oblique", "Courier-Oblique"
+@map font 10 to "Courier-Bold", "Courier-Bold"
+@map font 11 to "Courier-BoldOblique", "Courier-BoldOblique"
+@map font 12 to "Symbol", "Symbol"
+@map font 13 to "ZapfDingbats", "ZapfDingbats"
+@map color 0 to (255, 255, 255), "white"
+@map color 1 to (0, 0, 0), "black"
+@map color 2 to (255, 0, 0), "red"
+@map color 3 to (0, 255, 0), "green"
+@map color 4 to (0, 0, 255), "blue"
+@map color 5 to (255, 255, 0), "yellow"
+@map color 6 to (188, 143, 143), "brown"
+@map color 7 to (220, 220, 220), "grey"
+@map color 8 to (148, 0, 211), "violet"
+@map color 9 to (0, 255, 255), "cyan"
+@map color 10 to (255, 0, 255), "magenta"
+@map color 11 to (255, 165, 0), "orange"
+@map color 12 to (114, 33, 188), "indigo"
+@map color 13 to (103, 7, 72), "maroon"
+@map color 14 to (64, 224, 208), "turquoise"
+@map color 15 to (0, 139, 0), "green4"
+@reference date 0
+@date wrap off
+@date wrap year 1950
+@timestamp off
+@default linewidth 1.0
+@default linestyle 1
+@default color 1
+@default pattern 1
+@default font 0
+@default char size 1.000000
+@default symbol size 1.000000
+@default sformat "%.8g"
+@background color 0
+@page background fill on
+@r0 off
+@link r0 to g0
+@r0 type above
+@r0 linestyle 1
+@r0 linewidth 1.0
+@r0 color 1
+@r0 line 0, 0, 0, 0
+@r1 off
+@link r1 to g0
+@r1 type above
+@r1 linestyle 1
+@r1 linewidth 1.0
+@r1 color 1
+@r1 line 0, 0, 0, 0
+@r2 off
+@link r2 to g0
+@r2 type above
+@r2 linestyle 1
+@r2 linewidth 1.0
+@r2 color 1
+@r2 line 0, 0, 0, 0
+@r3 off
+@link r3 to g0
+@r3 type above
+@r3 linestyle 1
+@r3 linewidth 1.0
+@r3 color 1
+@r3 line 0, 0, 0, 0
+@r4 off
+@link r4 to g0
+@r4 type above
+@r4 linestyle 1
+@r4 linewidth 1.0
+@r4 color 1
+@r4 line 0, 0, 0, 0
+@g0 on
+@g0 hidden false
+@g0 type XY
+@g0 stacked false
+@g0 bar hgap 0.000000
+@with g0
+@    stack world 0, 0, 0, 0
+@    znorm 1
+@    view xmin 0.150000
+@    view xmax 1.150000
+@    view ymin 0.150000
+@    view ymax 0.850000
+@    title font 0
+@    title size 1.500000
+@    title color 1
+@    subtitle font 0
+@    subtitle size 1.000000
+@    subtitle color 1
+@    xaxes invert off
+@    yaxes invert off
+@    xaxis  on
+@    xaxis  type zero false
+@    xaxis  offset 0.000000 , 0.000000
+@    xaxis  bar on
+@    xaxis  bar color 1
+@    xaxis  bar linestyle 1
+@    xaxis  bar linewidth 1.0
+@    xaxis  label layout para
+@    xaxis  label place auto
+@    xaxis  label char size 1.000000
+@    xaxis  label font 0
+@    xaxis  label color 1
+@    xaxis  label place normal
+@    xaxis  tick on
+@    xaxis  tick minor ticks 1
+@    xaxis  tick default 6
+@    xaxis  tick place rounded true
+@    xaxis  tick in
+@    xaxis  tick major size 1.000000
+@    xaxis  tick major color 1
+@    xaxis  tick major linewidth 1.0
+@    xaxis  tick major linestyle 2
+@    xaxis  tick major grid on
+@    xaxis  tick minor color 1
+@    xaxis  tick minor linewidth 1.0
+@    xaxis  tick minor linestyle 2
+@    xaxis  tick minor grid off
+@    xaxis  tick minor size 0.500000
+@    xaxis  ticklabel on
+@    xaxis  ticklabel format general
+@    xaxis  ticklabel prec 5
+@    xaxis  ticklabel angle 0
+@    xaxis  ticklabel skip 0
+@    xaxis  ticklabel stagger 0
+@    xaxis  ticklabel place normal
+@    xaxis  ticklabel offset auto
+@    xaxis  ticklabel offset 0.000000 , 0.010000
+@    xaxis  ticklabel start type auto
+@    xaxis  ticklabel start 0.000000
+@    xaxis  ticklabel stop type auto
+@    xaxis  ticklabel stop 0.000000
+@    xaxis  ticklabel char size 0.800000
+@    xaxis  ticklabel font 0
+@    xaxis  ticklabel color 1
+@    xaxis  ticklabel formula ""
+@    xaxis  ticklabel append ""
+@    xaxis  ticklabel prepend ""
+@    xaxis  tick place both
+@    xaxis  tick spec type none
+@    yaxis  on
+@    yaxis  type zero false
+@    yaxis  offset 0.000000 , 0.000000
+@    yaxis  bar on
+@    yaxis  bar color 1
+@    yaxis  bar linestyle 1
+@    yaxis  bar linewidth 1.0
+@    yaxis  label layout para
+@    yaxis  label place auto
+@    yaxis  label char size 1.000000
+@    yaxis  label font 0
+@    yaxis  label color 1
+@    yaxis  label place normal
+@    yaxis  tick on
+@    yaxis  tick minor ticks 1
+@    yaxis  tick default 6
+@    yaxis  tick place rounded true
+@    yaxis  tick in
+@    yaxis  tick major size 1.000000
+@    yaxis  tick major color 1
+@    yaxis  tick major linewidth 1.0
+@    yaxis  tick major linestyle 2
+@    yaxis  tick major grid on
+@    yaxis  tick minor color 1
+@    yaxis  tick minor linewidth 1.0
+@    yaxis  tick minor linestyle 1
+@    yaxis  tick minor grid off
+@    yaxis  tick minor size 0.500000
+@    yaxis  ticklabel on
+@    yaxis  ticklabel format general
+@    yaxis  ticklabel prec 5
+@    yaxis  ticklabel angle 0
+@    yaxis  ticklabel skip 0
+@    yaxis  ticklabel stagger 0
+@    yaxis  ticklabel place normal
+@    yaxis  ticklabel offset auto
+@    yaxis  ticklabel offset 0.000000 , 0.010000
+@    yaxis  ticklabel start type auto
+@    yaxis  ticklabel start 0.000000
+@    yaxis  ticklabel stop type auto
+@    yaxis  ticklabel stop 0.000000
+@    yaxis  ticklabel char size 0.800000
+@    yaxis  ticklabel font 0
+@    yaxis  ticklabel color 1
+@    yaxis  ticklabel formula ""
+@    yaxis  ticklabel append ""
+@    yaxis  ticklabel prepend ""
+@    yaxis  tick place both
+@    yaxis  tick spec type none
+@    altxaxis  off
+@    altyaxis  off
+@    legend on
+@    legend loctype view
+@    legend 0.85, 0.8
+@    legend box color 1
+@    legend box pattern 1
+@    legend box linewidth 1.0
+@    legend box linestyle 1
+@    legend box fill color 0
+@    legend box fill pattern 1
+@    legend font 0
+@    legend char size 0.750000
+@    legend color 1
+@    legend length 4
+@    legend vgap 1
+@    legend hgap 1
+@    legend invert false
+@    frame type 0
+@    frame linestyle 1
+@    frame linewidth 1.0
+@    frame color 1
+@    frame pattern 1
+@    frame background color 0
+@    frame background pattern 0
+""")
+      entete.append('@    title "'+g.Titre+'"')
+      entete.append('@    subtitle "'+g.SousTitre+'"')
+      entete.append('@    xaxis  label "'+g.Legende_X+'"')
+      entete.append('@    yaxis  label "'+g.Legende_Y+'"')
+      entete.append('@    xaxes scale '+dic_ech[g.Echelle_X])
+      entete.append('@    yaxes scale '+dic_ech[g.Echelle_Y])
+      entete.append('@    xaxis  tick major '+str(g.Grille_X))
+      entete.append('@    yaxis  tick major '+str(g.Grille_Y))
+      entete.append('@    world xmin '+str(g.Min_X))
+      entete.append('@    world xmax '+str(g.Max_X))
+      entete.append('@    world ymin '+str(g.Min_Y))
+      entete.append('@    world ymax '+str(g.Max_Y))
+      return entete
+# ------------------------------------------------------------------------------
+   def DescrCourbe(self,**args):
+      """Retourne la chaine de caractères décrivant les paramètres de la courbe.
+      """
+      # valeurs par défaut
+      sty   = str(ValCycl(args['Sty'],0,8,1))
+      color = str(ValCycl(args['Coul'],1,15,args['NumSet']+1))
+      symbol= str(ValCycl(args['Marq'],0,10,args['NumSet']))
+      freqm = str(ValCycl(args['FreqM'],0,-1,0))
+
+      sn=str(args['NumSet'])
+      descr=[]
+      descr.append(string.replace("""
+@    s0 hidden false
+@    s0 type xy
+@    s0 symbol size 1.000000
+@    s0 symbol pattern 1
+@    s0 symbol linestyle 1
+@    s0 symbol fill pattern 0
+@    s0 symbol linewidth 1.0
+@    s0 symbol char 65
+@    s0 symbol char font 0
+@    s0 line type 1
+@    s0 line linewidth 1.0
+@    s0 line pattern 1
+@    s0 baseline type 0
+@    s0 baseline off
+@    s0 dropline off
+@    s0 fill type 0
+@    s0 fill rule 0
+@    s0 fill pattern 1
+@    s0 avalue off
+@    s0 avalue type 2
+@    s0 avalue char size 1.000000
+@    s0 avalue font 0
+@    s0 avalue rot 0
+@    s0 avalue format general
+@    s0 avalue prec 3
+@    s0 avalue prepend ""
+@    s0 avalue append ""
+@    s0 avalue offset 0.000000 , 0.000000
+@    s0 errorbar on
+@    s0 errorbar place both
+@    s0 errorbar pattern 1
+@    s0 errorbar size 1.000000
+@    s0 errorbar linewidth 1.0
+@    s0 errorbar linestyle 1
+@    s0 errorbar riser linewidth 1.0
+@    s0 errorbar riser linestyle 1
+@    s0 errorbar riser clip off
+@    s0 errorbar riser clip length 0.100000
+
+@    s0 comment ""
+""",' s0 ',' s'+sn+' '))
+      descr.append('@    s'+sn+' symbol '+symbol)
+      descr.append('@    s'+sn+' symbol color '+color)
+      descr.append('@    s'+sn+' symbol skip '+freqm)
+      descr.append('@    s'+sn+' symbol fill color '+color)
+      descr.append('@    s'+sn+' line linestyle '+sty)
+      descr.append('@    s'+sn+' line color '+color)
+      descr.append('@    s'+sn+' fill color '+color)
+      descr.append('@    s'+sn+' avalue color '+color)
+      descr.append('@    s'+sn+' errorbar color '+color)
+      descr.append('@    s'+sn+' legend "'+args['Leg'].replace(os.linesep, ' ; ')+'"')
+      return descr
+# ------------------------------------------------------------------------------
+   def Trace(self):
+      """Méthode pour 'tracer' l'objet Graph dans un fichier.
+      Met en page l'entete, la description des courbes et les valeurs selon
+      le format et ferme le fichier.
+      """
+      g = self.Graph
+      if self.PILOTE == 'INTERACTIF':
+         self.NomFich[0] = 'Trace_%s.dat' % time.strftime('%y%m%d%H%M%S',time.localtime())
+         self.Fich[0] = open(self.NomFich[0],'w')
+      # initialise le graph
+      self._FermFich()
+      nbsets, x0, x1, y0, y1 = IniGrace(self.NomFich[0])
+      NumSetIni = nbsets+1
+      g.SetExtrema(0.05, x0, x1, y0, y1, force=False)
+      # si Min/Max incohérents
+      if g.Echelle_X=='LOG':
+         g.Grille_X=10
+         if g.Min_X < 0.:
+            if g.BBXmin < 0.:
+               UTMESS('A', 'GRAPH0_4')
+            g.Min_X=g.MinP_X
+      if g.Echelle_Y=='LOG':
+         g.Grille_Y=10
+         if g.Min_Y < 0.:
+            if g.BBYmin < 0.:
+               UTMESS('A', 'GRAPH0_5')
+            g.Min_Y=g.MinP_Y
+      
+      if g.NbCourbe < 1:
+         self._FermFich()
+         return
+      # cohérence des valeurs par défaut
+      if g.Grille_X<0 or g.Grille_Y<0:
+         deltaX=g.Max_X-g.Min_X
+         deltaY=g.Max_Y-g.Min_Y
+         g.Grille_X=deltaX/5.
+         g.Grille_Y=deltaY/5.
+         if deltaX>4:
+            g.Grille_X=int(round(g.Grille_X))
+         if deltaY>4:
+            g.Grille_Y=int(round(g.Grille_Y))
+         if g.Grille_X == 0.:
+            g.Grille_X = 1.e-6
+         if g.Grille_Y == 0.:
+            g.Grille_Y = 1.e-6
+      # entete
+      content = self.Entete()
+      content.append('')
+      # valeurs
+      it=-1
+      for i in range(g.NbCourbe):
+         dCi=g.Courbe(i)
+         for k in range(dCi['NbCol']-1):
+            it=it+1
+            dCi['NumSet'] = NumSetIni + it
+            content.extend(self.DescrCourbe(**dCi))
+            content.append('')
+      # partie données (.dat)
+      it=-1
+      for i in range(g.NbCourbe):
+         dCi=g.Courbe(i)
+         for k in range(dCi['NbCol']-1):
+            it=it+1
+            content.append('@target g0.s%d' % (NumSetIni + it))
+            content.append('@type xy')
+            listX, listY = Tri(g.Tri, lx=dCi['Abs'], ly=dCi['Ord'][k])
+            for j in range(dCi['NbPts']):
+               svX = self.DicForm['formR'] % listX[j]
+               svY = self.DicForm['formR'] % listY[j]
+               content.append(self.DicForm['formR'] % listX[j] + \
+                  ' ' + self.DicForm['formR'] % listY[j])
+            content.append('&')
+      content.append('')
+      
+      # Production du fichier postscript, jpeg ou lancement interactif
+      pilo=self.PILOTE
+      if pilo == '':
+         self._OuvrFich()
+         self.Fich[0].write('\n'.join(content))
+         self._FermFich()
+      else:
+         xmgr=os.path.join(aster.repout(),'xmgrace')
+         nfwrk = self.NomFich[0]+'.wrk'
+         open(nfwrk, 'w').write('\n'.join(content))
+         nfhard = self.NomFich[0]+'.hardcopy'
+         # nom exact du pilote
+         if pilo == 'POSTSCRIPT':
+            pilo = 'PostScript'
+         elif pilo == 'INTERACTIF':
+            pilo = 'X11'
+         # ligne de commande
+         if pilo == 'X11':
+            lcmde = '%s %s' % (xmgr, nfwrk)
+            if not os.environ.has_key('DISPLAY') or os.environ['DISPLAY']=='':
+               os.environ['DISPLAY']=':0.0'
+               UTMESS('I','GRAPH0_7')
+            UTMESS('I','GRAPH0_8', valk=os.environ['DISPLAY'])
+         else:
+            if os.path.exists(os.path.join(aster.repout(),'gracebat')):
+               xmgr = os.path.join(aster.repout(),'gracebat')
+            lcmde = '%s -hdevice %s -hardcopy -printfile %s %s' % (xmgr, pilo, nfhard, nfwrk)
+         # appel xmgrace
+         UTMESS('I','EXECLOGICIEL0_8', valk=lcmde)
+         if not os.path.exists(xmgr):
+            UTMESS('S','EXECLOGICIEL0_6', valk=xmgr)
+         iret = os.system(lcmde)
+         if iret == 0 or os.path.exists(nfhard):
+            if pilo not in ('', 'X11'):
+               new = open(nfhard, 'r').read()
+               open(self.NomFich[0], 'a').write(new)
+         else:
+            UTMESS('A','GRAPH0_9', valk=pilo)
+      # menage
+      if self.PILOTE == 'INTERACTIF':
+         os.remove(self.NomFich[0])
+      return
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+class TraceAgraf(TraceGraph):
+   """
+   Impression d'un objet Graph au format AGRAF.
+   """
+# ------------------------------------------------------------------------------
+   def Entete(self):
+      """Retourne l'entete des directives Agraf"""
+      dic_ech={ 'LIN' : '0', 'LOG' : '1' }
+      g=self.Graph
+      entete=[]
+      entete.append("""
+ASPECT_GRAPHIQUE:
+  En-tete :Departement Analyses Mecaniques et Acoustique
+  Aspect :0
+  Nombre de vues :1
+  Cesure commentaire :40
+  MinMax :0
+  Fonte Titre :%helvetica-14
+  Fonte Axes :%courier-12
+  Fonte Autre :%times-12
+
+  DEFAUT_COURBE:
+    Couleur (rvb) :     0     0     0
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 65535     0     0
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 11822 35723 22359
+
+  DEFAUT_COURBE:
+    Couleur (rvb) :     0     0 65535
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 65535     0 65535
+
+  DEFAUT_COURBE:
+    Couleur (rvb) :     0 65535 65535
+
+  DEFAUT_COURBE:
+    Couleur (rvb) :     0 65535     0
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 41120 21074 11565
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 65535 42405     0
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 41120  8224 61680
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 65535 65535     0
+
+  DEFAUT_COURBE:
+    Couleur (rvb) : 53970 46260 35980
+
+GRAPHIQUE:
+""")
+      if g.Titre=='':
+         g.Titre='GRAPHIQUE CODE_ASTER'
+      entete.append('Titre :'+g.Titre+'\n')
+      if g.SousTitre<>'':
+         entete.append('Commentaire :'+g.SousTitre+'\n')
+      entete.append('Frequence Grille X :'+str(int(g.Grille_X))+'\n')
+      entete.append('Frequence Grille Y :'+str(int(g.Grille_Y))+'\n')
+      entete.append('Echelle X :'+dic_ech[g.Echelle_X]+'\n')
+      entete.append('Echelle Y :'+dic_ech[g.Echelle_Y]+'\n')
+      if g.Legende_X<>'':
+         entete.append('Legende X :'+g.Legende_X+'\n')
+      if g.Legende_Y<>'':
+         entete.append('Legende Y :'+g.Legende_Y+'\n')
+      entete.append('Min X : '+str(g.Min_X)+'\n')
+      entete.append('Max X : '+str(g.Max_X)+'\n')
+      entete.append('Min Y : '+str(g.Min_Y)+'\n')
+      entete.append('Max Y : '+str(g.Max_Y)+'\n')
+
+      return entete
+# ------------------------------------------------------------------------------
+   def DescrCourbe(self,**args):
+      """Retourne la chaine de caractères décrivant les paramètres de la courbe.
+      """
+      # valeurs par défaut
+      sty   = str(ValCycl(args['Sty'],0,2,0))
+      color = str(ValCycl(args['Coul'],0,12,args['NumSet']))
+      symbol= str(ValCycl(args['Marq'],0,12,args['NumSet']))
+      freqm = str(ValCycl(args['FreqM'],0,-1,0))
+
+      descr=[]
+      descr.append('  COURBE:\n')
+      descr.append('     Trait :'+sty+'\n')
+      descr.append('     Couleur :'+color+'\n')
+      descr.append('     Marqueur :'+symbol+'\n')
+      descr.append('     Frequence Marqueur :'+freqm+'\n')
+      if args['Leg']<>'':
+         descr.append('     Legende :'+args['Leg']+'\n')
+      descr.append('     Tri :'+args['Tri']+'\n')
+      descr.append('     Abscisses : [ '+str(args['Bloc'])+', '+str(args['ColX'])+']\n')
+      descr.append('     Ordonnees : [ '+str(args['Bloc'])+', '+str(args['ColY'])+']\n')
+      return descr
+# ------------------------------------------------------------------------------
+   def Trace(self):
+      """Méthode pour 'tracer' l'objet Graph dans un fichier.
+      Met en page l'entete, la description des courbes et les valeurs selon
+      le format et ferme le fichier.
+      """
+      self._OuvrFich()
+      fdogr=self.Fich[0]
+      fdigr=self.Fich[1]
+      g=self.Graph
+      if g.NbCourbe > 0:
+         # cohérence des valeurs par défaut
+         if g.Grille_X<0 or g.Grille_Y<0:
+            g.Grille_X=0
+            g.Grille_Y=0
+         # entete
+         for lig in self.Entete():
+            fdigr.write(lig)
+         # valeurs
+         for i in range(g.NbCourbe):
+            dCi=g.Courbe(i)
+            dCi['NumSet']=i
+            # partie directives (.digr)
+            for k in range(dCi['NbCol']-1):
+               dCi['Bloc']=i+1
+               dCi['ColX']=1
+               dCi['ColY']=k+2
+               for lig in self.DescrCourbe(**dCi):
+                  fdigr.write(lig)
+            # partie données (.dogr)
+            if dCi['Leg']<>'':
+               leg=dCi['Leg']
+            else:
+               leg='COURBE_'+str(i)
+            fdogr.write('#NOM DE LA FONCTION: '+leg+'\n')
+            for j in range(dCi['NbPts']):
+               for k in range(dCi['NbCol']):
+                  sv=self.DicForm['formR'] % g.Valeurs[i][k][j]
+                  fdogr.write(' '+sv)
+               fdogr.write('\n')
+            fdogr.write('\n')
+      self._FermFich()
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+def ValCycl(val,vmin,vmax,vdef):
+   """
+   Retourne une valeur entre vmin et vmax (bornes incluses) :
+      - si val<vmin, on utilise val=vdef,
+      - si val>vmax, on cycle tel que val=vmax+1 retourne vmin, etc.
+      - si vmax<vmin, il n'y a pas de max
+   """
+   v = val
+   if v < vmin:
+      v = vdef
+   if vmax < vmin:
+      return v
+   else:
+      return (((v-vmin) % (vmax+1-vmin))+vmin)
+
+# ------------------------------------------------------------------------------
+def Tri(tri, lx, ly):
+   """Retourne les listes triées selon la valeur de tri ('X','Y','XY','YX').
+   """
+   dNumCol={ 'X' : 0, 'Y' : 1 }
+   tab=numpy.array((lx,ly))
+   tab=numpy.transpose(tab)
+   li=range(len(tri))
+   li.reverse()
+   for i in li:
+      if tri[-i] in dNumCol.keys():
+         icol=dNumCol[tri[-i]]
+         tab = numpy.take(tab, numpy.argsort(tab[:,icol]))
+   return [ tab[:,0].tolist(), tab[:,1].tolist() ]
+
+# ------------------------------------------------------------------------------
+def AjoutParaCourbe(dCourbe, args):
+   """Ajoute les arguments fournis par l'utilisateur (args) dans le dictionnaire
+   décrivant la courbe (dCourbe).
+   """
+   # correspondance : mot-clé Aster / clé du dico de l'objet Graph
+   keys={
+      'LEGENDE'         : 'Leg',
+      'STYLE'           : 'Sty',
+      'COULEUR'         : 'Coul',
+      'MARQUEUR'        : 'Marq',
+      'FREQ_MARQUEUR'   : 'FreqM',
+      'TRI'             : 'Tri',
+   }
+   for mc, key in keys.items():
+      if args.has_key(mc):
+         dCourbe[key]=args[mc]
+
+# ------------------------------------------------------------------------------
+def IniGrace(fich):
+   """Retourne le numéro de la dernière courbe d'un fichier xmgrace (sinon 0).
+   """
+   ns=0
+   x0=None
+   x1=None
+   y0=None
+   y1=None
+   if os.path.exists(fich) and os.stat(fich).st_size<>0:
+      os.rename(fich, fich+'.prev')
+      fpre=open(fich+'.prev', 'r')
+      fnew=open(fich,         'w')
+      for line in fpre:
+         ikeep=True
+         mat=re.search('@target g[0-9]+\.s([0-9]+)', line)
+         if mat<>None and int(mat.group(1))>ns:
+            ns=int(mat.group(1))
+         mat=re.search('@[ ]+world[ ]+xmin[ ]+([\-\+\.0-9eEdD]+)', line)
+         if mat<>None:
+            try:
+               x0=float(mat.group(1))
+               ikeep=False
+            except ValueError:
+               pass
+         mat=re.search('@[ ]+world[ ]+xmax[ ]+([\-\+\.0-9eEdD]+)', line)
+         if mat<>None:
+            try:
+               x1=float(mat.group(1))
+               ikeep=False
+            except ValueError:
+               pass
+         mat=re.search('@[ ]+world[ ]+ymin[ ]+([\-\+\.0-9eEdD]+)', line)
+         if mat<>None:
+            try:
+               y0=float(mat.group(1))
+               ikeep=False
+            except ValueError:
+               pass
+         mat=re.search('@[ ]+world[ ]+ymax[ ]+([\-\+\.0-9eEdD]+)', line)
+         if mat<>None:
+            try:
+               y1=float(mat.group(1))
+               ikeep=False
+            except ValueError:
+               pass
+         if ikeep:
+            fnew.write(line)
+      fpre.close()
+      fnew.close()
+      try:
+         UTMESS('I', 'GRAPH0_10', valk=fich, vali=ns, valr=(x0, x1, y0, y1))
+      except TypeError:
+         # pas un format xmgrace
+         pass
+   return ns, x0, x1, y0, y1

diff --git a/Aster/Cata/cataSTA10/Utilitai/System.py b/Aster/Cata/cataSTA10/Utilitai/System.py
new file mode 100644 (file)
index 0000000..ccc3996
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/System.py
@@ -0,0 +1,218 @@
+#@ MODIF System Utilitai  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+# RESPONSABLE COURTOIS M.COURTOIS
+
+"""Ce module définit la classe `SYSTEM` et la fonction `ExecCommand`
+qui est présente uniquement pour commodité pour les Macros.
+
+La classe SYSTEM est semblable à celle utilisée dans asrun.
+"""
+
+__all__ = ["SYSTEM", "ExecCommand"]
+
+import sys
+import os
+import re
+import tempfile
+
+# ----- differ messages translation
+def _(mesg):
+   return mesg
+
+
+def _exitcode(status, default=0):
+   """
+   Extract the exit code from status. Return 'default' if the process
+   has not been terminated by exit.
+   """
+   if os.WIFEXITED(status):
+      iret = os.WEXITSTATUS(status)
+   elif os.WIFSIGNALED(status):
+      iret = os.WTERMSIG(status)
+   elif os.WIFSTOPPED(status):
+      iret = os.WSTOPSIG(status)
+   else:
+      iret = default
+   return iret
+
+
+
+class SYSTEM:
+   """
+   Class to encapsultate "system" commands (this a simplified version of
+   ASTER_SYSTEM class defined in ASTK_SERV part).
+   """
+   # this value should be set during installation step.
+   MaxCmdLen = 1024
+   # line length -9
+   _LineLen = 80-9
+   
+   def __init__(self, **kargs):
+      """
+      Initialization.
+      Optionnal arguments : silent, verbose, debug, cc_files, maxcmdlen.
+      """
+      self.verbose   = kargs.get('verbose', True)
+      self.debug     = kargs.get('debug', False)
+      self.cc_files  = kargs.get('cc_files', None)
+      if kargs.has_key('maxcmdlen'):
+         self.MaxCmdLen = kargs['maxcmdlen']
+
+   def _mess(self, msg, cod=''):
+      """
+      Just print a message
+      """
+      self._print('%-18s %s' % (cod, msg))
+
+   def _print(self, *args, **kargs):
+      """
+      print replacement.
+      Optionnal argument :
+         term  : line terminator (default to os.linesep).
+      """
+      term = kargs.get('term', os.linesep)
+      files = set([sys.stdout])
+      if self.cc_files:
+         files.add(self.cc_files)
+      for f in files:
+         if type(f) is file:
+            txt = ' '.join(['%s'%a for a in args])
+            f.write(txt.replace(os.linesep+' ', os.linesep)+term)
+            f.flush()
+         else:
+            print _('file object expected : %s / %s') % (type(f), repr(f))
+
+   def VerbStart(self, cmd, verbose=None):
+      """
+      Start message in verbose mode
+      """
+      Lm = self._LineLen
+      if verbose == None:
+         verbose = self.verbose
+      if verbose:
+         pcmd = cmd
+         if len(cmd) > Lm-2 or cmd.count('\n') > 0:
+            pcmd = pcmd+'\n'+' '*Lm
+         self._print(('%-'+str(Lm)+'s') % (pcmd,), term='')
+
+   def VerbEnd(self, iret, output='', verbose=None):
+      """
+      End message in verbose mode
+      """
+      if verbose == None:
+         verbose = self.verbose
+      if verbose:
+         if iret == 0:
+            self._print('[  OK  ]')
+         else:
+            self._print(_('[FAILED]'))
+            self._print(_('Exit code : %d') % iret)
+         if (iret != 0 or self.debug) and output:
+            self._print(output)
+
+   def VerbIgnore(self, verbose=None):
+      """
+      End message in verbose mode
+      """
+      if verbose == None:
+         verbose = self.verbose
+      if verbose:
+         self._print(_('[ SKIP ]'))
+
+   def Shell(self, cmd, bg=False, verbose=False, follow_output=False,
+                   alt_comment=None, interact=False, separated_stderr=False):
+      """
+      Execute a command shell
+         cmd           : command
+         bg            : put command in background if True
+         verbose       : print status messages during execution if True
+         follow_output : follow interactively output of command
+         alt_comment   : print this "alternative comment" instead of "cmd"
+         interact      : allow the user to interact with the process.
+      Return :
+         iret     : exit code if bg = False,
+                    0 if bg = True
+         output   : output lines (as string)
+      """
+      if not alt_comment:
+         alt_comment = cmd
+      if bg:
+         interact = False
+      if len(cmd) > self.MaxCmdLen:
+         self._mess((_('length of command shell greater '\
+               'than %d characters.') % self.MaxCmdLen), '<A>_ALARM')
+      if self.debug:
+         self._print('cmd :', cmd, 'background : %s' % bg, 'follow_output : %s' % follow_output)
+      self.VerbStart(alt_comment, verbose=verbose)
+      if follow_output and verbose:
+         print os.linesep+_('Command output :')
+
+      fout = tempfile.NamedTemporaryFile()
+      ferr = tempfile.NamedTemporaryFile()
+      if bg:
+         new_cmd = cmd + ' &'
+      elif follow_output:
+         new_cmd = '( %s ) | tee %s' % (cmd, fout.name)
+      else:
+         if not separated_stderr:
+            new_cmd = '( %s ) > %s 2>&1' % (cmd, fout.name)
+         else:
+            new_cmd = '( %s ) > %s 2> %s' % (cmd, fout.name, ferr.name)
+      if self.debug:
+         self._print('modified cmd :', new_cmd)
+      # execution
+      iret = os.system(new_cmd)
+      fout.seek(0)
+      output = fout.read()
+      ferr.seek(0)
+      error = ferr.read()
+      fout.close()
+      ferr.close()
+      
+      if follow_output:
+         # repeat header message
+         self.VerbStart(alt_comment, verbose=verbose)
+      mat = re.search('EXIT_CODE=([0-9]+)', output)
+      if mat:
+         iret = int(mat.group(1))
+      self.VerbEnd(iret, output, verbose=verbose)
+      if self.debug and iret != 0:
+         self._print('<debug> ERROR : iret = %s' % iret)
+         self._print('STDOUT', output, all=True)
+         self._print('STDERR', error, all=True)
+      if bg:
+         iret = 0
+      if not separated_stderr:
+         result = iret, output
+      else:
+         result = iret, output, error
+      return result
+
+
+# Juste par commodité.
+system = SYSTEM()
+ExecCommand = system.Shell
+
+
+
+if __name__ == '__main__':
+   iret, output = ExecCommand('ls', alt_comment='Lancement de la commande...')
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/Table.py b/Aster/Cata/cataSTA10/Utilitai/Table.py
new file mode 100644 (file)
index 0000000..8943a58
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/Table.py
@@ -0,0 +1,1070 @@
+#@ MODIF Table Utilitai  DATE 01/03/2011   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+# RESPONSABLE COURTOIS M.COURTOIS
+__all__ = ['Table', 'merge']
+
+import sys
+import os
+import re
+from copy  import copy
+from types import IntType, FloatType, StringType, UnicodeType, NoneType
+
+from Noyau.N_types import is_int, is_float, is_complex, is_number, is_str, is_enum
+
+import transpose
+from Utilitai.Utmess import UTMESS
+
+if not sys.modules.has_key('Graph'):
+   try:
+      from Utilitai import Graph
+   except ImportError:
+      import Graph
+
+# formats de base (identiques à ceux du module Graph)
+DicForm = {
+   'csep'  : ' ',       # séparateur
+   'ccom'  : '#',       # commentaire
+   'ccpara' : '',       # commentaire des labels
+   'cdeb'  : '',        # début de ligne
+   'cfin'  : '\n',      # fin de ligne
+   'sepch' : ';',       # séparateur entre deux lignes d'une cellule
+   'formK' : '%-12s',   # chaines
+   'formR' : '%12.5E',  # réels
+   'formI' : '%12d'     # entiers
+}
+# type par défaut des chaines de caractères
+Kdef = 'K24'
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+class TableBase(object):
+   """Classe pour partager les méthodes d'impression entre Table et Colonne
+   (c'est surtout utile pour vérifier que l'extraction et les filtres sur les
+   colonnes sont corrects).
+   """
+   def __init__(self):
+      """Constructeur.
+      """
+      self.rows=None
+      self.para=None
+      self.type=None
+      self.titr=None
+   
+   def __repr__(self):
+      return self.ReprTable()
+   def Croise(self, **kargs):
+      raise NotImplementedError, 'Must be defined in a derived class'
+
+   def __len__(self):
+      """Retourne le nombre de ligne dans la Table/Colonne.
+      """
+      return len(self.rows)
+
+# ------------------------------------------------------------------------------
+   def Impr(self, FICHIER=None, FORMAT='TABLEAU', dform=None, **opts):
+      """Impresssion de la Table selon le format spécifié.
+         FICHIER : nom du(des) fichier(s). Si None, on dirige vers stdout
+         dform : dictionnaire de formats d'impression (format des réels,
+            commentaires, saut de ligne...)
+         opts  : selon FORMAT.
+      """
+      para={
+         'TABLEAU'         : { 'mode' : 'a', 'driver' : self.ImprTableau,   },
+         'ASTER'           : { 'mode' : 'a', 'driver' : self.ImprTableau,   },
+         'XMGRACE'         : { 'mode' : 'a', 'driver' : self.ImprGraph,     },
+         'AGRAF'           : { 'mode' : 'a', 'driver' : self.ImprTableau,   },
+         'TABLEAU_CROISE'  : { 'mode' : 'a', 'driver' : self.ImprTabCroise, },
+      }
+      kargs={
+         'FICHIER'   : FICHIER,
+         'FORMAT'    : FORMAT,
+         'dform'     : DicForm.copy(),
+         'mode'      : para[FORMAT]['mode'],
+      }
+      if dform != None and type(dform) is dict:
+         kargs['dform'].update(dform)
+      # ajout des options
+      kargs.update(opts)
+      
+      if not kargs.get('PAGINATION'):
+         # call the associated driver
+         para[FORMAT]['driver'](**kargs)
+
+      else:
+         if not is_enum(kargs['PAGINATION']):
+            ppag = [kargs['PAGINATION'],]
+         else:
+            ppag = list(kargs['PAGINATION'])
+         del kargs['PAGINATION']
+         npag = len(ppag)
+         # paramètres hors ceux de la pagination
+         lkeep = [p for p in self.para if ppag.count(p)==0]
+         # création des listes des valeurs distinctes
+         lvd = []
+         for p in ppag:
+            lvp = getattr(self,p).values()
+            lvn = []
+            for it in lvp:
+               if it != None and lvn.count(it) == 0:
+                  lvn.append(it)
+            lvn.sort()
+            lvd.append(lvn)
+         # création des n-uplets
+         s  = '[['+','.join(['x'+str(i) for i in range(npag)])+'] '
+         s += ' '.join(['for x'+str(i)+' in lvd['+str(i)+']' for i in range(npag)])+']'
+         try:
+            lnup = eval(s)
+         except SyntaxError, s:
+            UTMESS('F','TABLE0_20')
+         # pour chaque n-uplet, on imprime la sous-table
+         for nup in lnup:
+            tab = self
+            for i in range(npag):
+               tab = tab & (getattr(tab,ppag[i]) == nup[i])
+               sl = ''
+               if tab.titr: sl='\n'
+               tab.titr += sl+ppag[i]+': '+str(nup[i])
+            tab[lkeep].Impr(**kargs)
+
+# ------------------------------------------------------------------------------
+   def ImprTableau(self,**kargs):
+      """Impression au format TABLEAU ou ASTER
+      """
+      # fichier ou stdout
+      if kargs.get('FICHIER') != None:
+         f=open(kargs['FICHIER'],kargs['mode'])
+      else:
+         f=sys.stdout
+      # ecriture
+      f.write(self.ReprTable(**kargs) + '\n')
+      # fermeture
+      if kargs.get('FICHIER') != None:
+         f.close()
+
+# ------------------------------------------------------------------------------
+   def ReprTable(self,FORMAT='TABLEAU',dform=None,**ignore):
+      """Représentation d'une Table ou d'une Colonne sous forme d'un tableau.
+      """
+      rows=self.rows
+      para=self.para
+      typ =self.type
+      if not is_enum(para):
+         para=[self.para,]
+         typ =[self.type,]
+      if dform==None:
+         dform = DicForm.copy()
+      # est-ce que l'attribut .type est renseigné ?
+      typdef=typ != [None]*len(typ)
+      txt=[]
+      # ['']+ pour ajouter un séparateur en début de ligne
+      lspa=['',]
+      # lmax : largeur max des colonnes = max(form{K,R,I},len(parametre))
+      lmax=[]
+      # formats
+      strfmt, strfmt_none = {}, {}
+      for t, p in zip(typ, para):
+         larg_max=max([len(str(p))] + \
+               [len(FMT(dform,k,t) % 0) for k in ('formK','formR','formI')])
+         lspa.append(FMT(dform,'formK',t,larg_max,str(p)) % p)
+         lmax.append(larg_max)
+         assert t is not None, "Type de la colonne '%s' non défini" % p
+         strfmt[p] = FMT(dform, 'form'+t[0], t, larg_max)
+         strfmt_none[p] = FMT(dform, 'formK', t, larg_max)
+      if typdef:
+         stype=dform['csep'].join([''] + \
+          [FMT(dform,'formK',typ[i],lmax[i]) % typ[i] for i in range(len(para))])
+      txt.append(dform['ccom'])
+      txt.append(dform['ccom']+'-'*80)
+      txt.append(dform['ccom'])
+      ASTER=(FORMAT=='ASTER')
+      if ASTER:
+         txt.append('#DEBUT_TABLE')
+      if self.titr:
+         if ASTER:
+            txt.extend(['#TITRE '+lig for lig in self.titr.split('\n')])
+         else:
+            txt.extend([dform['ccom']+lig for lig in self.titr.split('\n')])
+      txt.append(dform['ccpara'] + dform['csep'].join(lspa))
+      if ASTER and typdef:
+         txt.append(stype)
+      for r in rows:
+         lig=['']
+         empty=True
+         for t, p, lmax_i in zip(typ, para, lmax):
+            val = r.get(p)
+            if val is not None:
+               empty = False
+               lig.append(strfmt[p] % val)
+            else:
+               s = strfmt_none[p] % '-'
+               # format AGRAF = TABLEAU + '\' devant les chaines de caractères !
+               if FORMAT=='AGRAF':
+                  s='\\'+s
+               lig.append(s)
+         if not empty:
+            lig2 = [dform['sepch'].join(ch.splitlines()) for ch in lig]
+            txt.append(dform['csep'].join(lig2))
+      if ASTER:
+         txt.append('#FIN_TABLE')
+      # ajout des debut et fin de ligne
+      txt=[dform['cdeb']+t+dform['cfin'] for t in txt]
+
+      return ''.join(txt)
+# ------------------------------------------------------------------------------
+   def ImprTabCroise(self,**kargs):
+      """Impression au format TABLEAU_CROISE d'une table ayant 3 paramètres.
+      """
+      # création du tableau croisé et impression au format TABLEAU
+      tabc=self.Croise()
+      kargs['FORMAT']='TABLEAU'
+      tabc.Impr(**kargs)
+# ------------------------------------------------------------------------------
+   def ImprGraph(self, **kargs):
+      """Impression au format XMGRACE : via le module Graph
+      """
+      args=kargs.copy()
+      if len(self.para) != 2:
+         UTMESS('A','TABLE0_21')
+         return
+      # suppression des lignes contenant une cellule vide
+      tnv = getattr(self, self.para[0]).NON_VIDE() \
+          & getattr(self, self.para[1]).NON_VIDE()
+      # objet Graph
+      graph=Graph.Graph()
+      dicC={
+         'Val' : [getattr(tnv, tnv.para[0]).values(),
+                  getattr(tnv, tnv.para[1]).values()],
+         'Lab' : tnv.para,
+      }
+      if args['LEGENDE']==None: del args['LEGENDE']
+      Graph.AjoutParaCourbe(dicC, args)
+      graph.AjoutCourbe(**dicC)
+      
+      # Surcharge des propriétés du graphique et des axes
+      # (bloc quasiment identique dans impr_fonction_ops)
+      if args.get('TITRE'):            graph.Titre=args['TITRE']
+      if args.get('BORNE_X'):
+                                       graph.Min_X=args['BORNE_X'][0]
+                                       graph.Max_X=args['BORNE_X'][1]
+      if args.get('BORNE_Y'):
+                                       graph.Min_Y=args['BORNE_Y'][0]
+                                       graph.Max_Y=args['BORNE_Y'][1]
+      if args.get('LEGENDE_X'):        graph.Legende_X=args['LEGENDE_X']
+      if args.get('LEGENDE_Y'):        graph.Legende_Y=args['LEGENDE_Y']
+      if args.get('ECHELLE_X'):        graph.Echelle_X=args['ECHELLE_X']
+      if args.get('ECHELLE_Y'):        graph.Echelle_Y=args['ECHELLE_Y']
+      if args.get('GRILLE_X'):         graph.Grille_X=args['GRILLE_X']
+      if args.get('GRILLE_Y'):         graph.Grille_Y=args['GRILLE_Y']
+      
+      try:
+         graph.Trace(**args)
+      except TypeError:
+         UTMESS('A','TABLE0_22')
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+class Table(TableBase):
+   """Une table est construite comme une liste de lignes, chaque ligne est
+   un dictionnaire.
+   On crée puis on ajoute les lignes avec la méthode append :
+      t=Table()
+      t.append(dict(a=1,b=2))
+      t.append(dict(a=3,b=4))
+   La méthode __iter__ définit un itérateur sur les lignes de la table,
+   __repr__ retourne une représentation de la table, utilisée par "print t".
+   Grace à la classe Colonne et à sa méthode _extract, il est possible
+   de construire une sous-table qui satisfait un critère donné.
+   Le critère est donné par une fonction Python qui retourne vrai
+   ou faux si la valeur d'une colonne respecte le critère ou non.
+   Exemple:
+     def critere(valeur):
+         return valeur < 10
+     soustable = t.a._extract(critere)
+   t.a retourne un objet intermédiaire de la classe Colonne qui mémorise
+   le nom de la colonne demandée (a, ici).
+   """
+# ------------------------------------------------------------------------------
+   def __init__(self, rows=[], para=[], typ=[], titr=''):
+      """Constructeur de la Table :
+         rows : liste des lignes (dict)
+         para : liste des paramètres
+         type : liste des types des paramètres
+         titr : titre de la table
+      """
+      self.rows = [r for r in rows if r.values() != [None]*len(r.values())]
+      self.para = list(para)
+      for i in self.para :
+          if self.para.count(i) != 1 :
+             UTMESS('F','TABLE0_23', valk=i)
+      if len(typ) == len(self.para):
+         self.type = list(typ)
+      else:
+         self.type = [None]*len(self.para)
+      self.titr = titr
+   
+# ------------------------------------------------------------------------------
+   def copy(self):
+      """Retourne une copie de la table.
+      """
+      rows = []
+      for r in self.rows:
+         rows.append(copy(r))
+      return Table(rows, self.para[:], self.type[:], self.titr)
+
+# ------------------------------------------------------------------------------
+   def add_para(self, para, typ):
+      """Ajoute un nouveau paramètre."""
+      if not is_enum(para):
+         para=[para,]
+      if not is_enum(typ):
+         typ =[typ,]
+      if len(typ) != len(para):
+         typ = [typ[0],] * len(para)
+      for p, t in zip(para, typ):
+         if not p in self.para:
+            self.para.append(p)
+            self.type.append(t)
+
+# ------------------------------------------------------------------------------
+   def append(self, obj):
+      """Ajoute une ligne (type dict) qui peut éventuellement définir un
+      nouveau paramètre."""
+      para=obj.keys()
+      for p in para:
+         if not p in self.para:
+            self.add_para(p, _typaster(obj[p]))
+         else:
+            ip=self.para.index(p)
+            self.type[ip]=_typaster(obj[p], self.type[ip])
+      self.rows.append(obj)
+
+
+   def extend(self, objs):
+      """Ajoute plusieurs lignes (list of dict)."""
+      for row in objs:
+          self.append(row)
+
+# ------------------------------------------------------------------------------
+   def SansColonneVide(self, l_para=None):
+      """Retourne une copie de la table dans laquelle on a supprimé les colonnes
+      vides (les lignes vides sont automatiquement supprimées).
+      """
+      # ptest : colonnes potentiellement vides
+      pkeep = l_para or self.para
+      ptest = pkeep[:]
+      for row in self:
+         notNone = [p for p in ptest if row.get(p) is not None]
+         ptest = [p for p in ptest if not p in notNone]
+         if len(ptest) == 0:
+            break
+      # pkeep : on conserve les colonnes non vides
+      pkeep = [p for p in pkeep if not p in ptest]
+      return self[pkeep]
+
+# ------------------------------------------------------------------------------
+   def __setitem__(self, k_para, k_value):
+      """Ajoute une colonne k_para dont les valeurs sont dans k_value"""
+      if len(k_value) == 0:
+         return
+      if k_para in self.para :
+         UTMESS('F','TABLE0_24', valk=k_para)
+      self.add_para(k_para, typ=_typaster(k_value[0]))
+      i = 0
+      for row in self:
+         if i < len(k_value):
+            row[k_para]   = k_value[i]
+            self.type[-1] = _typaster(k_value[i], self.type[-1])
+         else:
+            row[k_para] = None
+         i+=1
+      for j in range(i, len(k_value)): 
+         self.append({k_para : k_value[j]})
+
+# ------------------------------------------------------------------------------
+   def fromfunction(self, nom_para, funct, l_para=None, const=None):
+      """Ajoute une colonne `nom_para` en évaluant la fonction `funct` sur
+      la valeur des paramètres `l_para` (qui doivent exister dans la table).
+      Si `l_para` n'est pas fourni, on prend `funct`.nompar (FORMULE Aster).
+      On peut passer un dictionnaire de constantes dans `const`. Quand on
+      utilise une FORMULE Aster, les constantes sont prises dans le contexte
+      global.
+      """
+      # vérif préalables
+      if not hasattr(funct, '__call__'):
+         UTMESS('F', 'TABLE0_25', valk=funct.__name__)
+      if nom_para in self.para :
+         UTMESS('F','TABLE0_24', valk=nom_para)
+      if l_para == None:
+         if not hasattr(funct, 'nompar'):
+            UTMESS('F', 'TABLE0_26', valk=funct.__name__)
+         l_para = funct.nompar
+      if not is_enum(l_para):
+         l_para = [l_para]
+      not_found = ', '.join([p for p in l_para if not p in self.para])
+      if not_found != '':
+         UTMESS('F','TABLE0_27', valk=not_found)
+      if const == None:
+         const = {}
+      if type(const) is not dict:
+         UTMESS('F', 'TABLE0_28')
+      # liste des valeurs des paramètres
+      tabpar = []
+      for para in l_para:
+         vals = getattr(self, para).values()
+         tabpar.append(vals)
+      tabpar = transpose.transpose(tabpar)
+      # évaluation de la fonction sur ces paramètres
+      vectval = []
+      for lpar in tabpar:
+         # si un paramètre est absent, on ne peut pas évaluer la formule
+         if None in lpar:
+            vectval.append(None)
+         else:
+            vectval.append(funct(*lpar, **const))
+      # ajout de la colonne
+      self[nom_para] = vectval
+
+# ------------------------------------------------------------------------------
+   def __iter__(self):
+      """Itère sur les lignes de la Table"""
+      return iter(self.rows)
+
+# ------------------------------------------------------------------------------
+   def __getattr__(self, column):
+      """Construit un objet intermediaire (couple table, colonne)"""
+      typ=None
+      if not column in self.para:
+         column=''
+      else:
+         typ=self.type[self.para.index(column)]
+      return Colonne(self, column, typ)
+
+# ------------------------------------------------------------------------------
+   def sort(self, CLES=None, ORDRE='CROISSANT'):
+      """Tri de la table.
+         CLES  : liste des clés de tri
+         ORDRE : CROISSANT ou DECROISSANT
+      """
+      # par défaut, on prend tous les paramètres
+      if CLES == None:
+         CLES = self.para[:]
+      # vérification des arguments
+      if not is_enum(CLES):
+         CLES = [CLES]
+      else:
+         CLES = list(CLES)
+      not_found = ', '.join([p for p in CLES if not p in self.para])
+      if not_found != '':
+         UTMESS('F', 'TABLE0_27', valk=not_found)
+      if not ORDRE in ('CROISSANT', 'DECROISSANT'):
+         UTMESS('F', 'TABLE0_29', valk=ORDRE)
+      # tri
+      self.rows = sort_table(self.rows, self.para, CLES, (ORDRE=='DECROISSANT'))
+
+# ------------------------------------------------------------------------------
+   def __delitem__(self, args):
+      """Supprime les colonnes correspondantes aux éléments de args """
+      if not is_enum(args):
+         args=[args,]
+      for item in args:
+         try:
+            ind_item = self.para.index(item)
+         except ValueError:
+            UTMESS('F', 'TABLE0_27', valk=item)
+         del self.type[ind_item]
+         self.para.remove(item)
+         for line in self.rows:
+            if line.has_key(item):
+               del line[item]
+
+# ------------------------------------------------------------------------------
+   def __getitem__(self, args):
+      """Extrait la sous table composée des colonnes dont les paramètres sont dans args """
+      if not is_enum(args):
+         args=[args,]
+      else:
+         args=list(args)
+      new_rows=[]
+      new_para=args
+      new_type=[]
+      for item in new_para:
+         if not item in self.para:
+            return Table()
+         new_type.append(self.type[self.para.index(item)])
+      for line in self:
+         new_line={}
+         for item in new_para:
+            v = line.get(item)
+            if v is not None:
+               new_line[item] = v
+         new_rows.append(new_line)
+      return Table(new_rows, new_para, new_type, self.titr)
+
+
+   def OrdreColonne(self, cols):
+      """Réordonne les colonnes en mettant en premier 'cols'.
+      Ignore les colonnes qui ne seraient pas dans 'self.para'."""
+      if type(cols) not in (list, tuple):
+         cols = [cols]
+      new_para = [p for p in cols if p in self.para]
+      others = [p for p in self.para if not p in cols]
+      new_para.extend(others)
+      new_type=[]
+      for item in new_para:
+         new_type.append(self.type[self.para.index(item)])
+      self.para = new_para
+      self.type = new_type
+
+# ------------------------------------------------------------------------------
+   def _tuplevalues(self, dico):
+      """Retourne la liste des valeurs d'une ligne dans l'ordre self.para
+      ("hashable" pour en faire une clé de dict.)
+      """
+      return tuple(map(dico.get, self.para))
+
+   def __and__(self, other):
+      """Intersection de deux tables (opérateur &)"""
+      if other.para != self.para:
+         UTMESS('A','TABLE0_30')
+         return Table()
+      else:
+         dval_other = dict.fromkeys([self._tuplevalues(r) for r in other], 1)
+         tmp = [r for r in self if dval_other.get(self._tuplevalues(r)) is not None]
+         return Table(tmp, self.para, self.type, self.titr)
+
+# ------------------------------------------------------------------------------
+   def __or__(self, other):
+      """Union de deux tables (opérateur |)"""
+      if other.para != self.para:
+         UTMESS('A','TABLE0_30')
+         return Table()
+      else:
+         tmp = self.rows[:]
+         dval_self = dict.fromkeys([self._tuplevalues(r) for r in self], 1)
+         tmp.extend([r for r in other if dval_self.get(self._tuplevalues(r)) is None])
+         return Table(tmp, self.para, self.type[:], self.titr)
+
+# ------------------------------------------------------------------------------
+   def values(self):
+      """Renvoie la table sous la forme d'un dictionnaire de listes dont les
+      clés sont les paramètres.
+      """
+      dico={}
+      for column in self.para:
+         dico[column]=Colonne(self, column).values()
+      return dico
+
+# ------------------------------------------------------------------------------
+   def dict_CREA_TABLE(self):
+      """Renvoie le dictionnaire des mots-clés à fournir à la commande CREA_TABLE
+      pour produire une table_sdaster.
+      """
+      dico={ 'TITRE' : ['%-80s' % lig for lig in self.titr.split('\n')],
+             'LISTE' : [], }
+      # remplissage de chaque occurence (pour chaque paramètre) du mot-clé facteur LISTE
+      for i in range(len(self.para)):
+         # nom du paramètre et type si K*
+         d={ 'PARA' : self.para[i], }
+         typ=self.type[i]
+         if typ[0]=='K':
+            mc='LISTE_K'
+            if not typ in ('K8', 'K16', 'K24'):
+               UTMESS('A','TABLE0_32', valk=(self.para[i],Kdef))
+               typ=Kdef
+            d['TYPE_K']=typ
+         elif typ=='I':
+            mc='LISTE_I'
+         elif typ=='R':
+            mc='LISTE_R'
+         else:
+            UTMESS('F', 'TABLE0_31', valk=self.para[i])
+         # valeurs sans trou / avec trou
+         vals=getattr(self, self.para[i]).values()
+         if typ == 'R':
+            try:
+               check_nan(vals)
+            except ValueError, err:
+               UTMESS('F', 'TABLE0_33', valk=(self.para[i], str(err)))
+         if vals.count(None)==0:
+            d[mc]=vals
+         else:
+            d['NUME_LIGN'] = [j+1 for j in range(len(vals)) if vals[j] != None]
+            d[mc]          = [v   for v in vals             if v       != None]
+         if len(d[mc])==0:
+            UTMESS('I','TABLE0_34', valk=self.para[i])
+         else:
+            dico['LISTE'].append(d)
+      if len(dico['LISTE'])==0:
+         UTMESS('F','TABLE0_35')
+      return dico
+
+# ------------------------------------------------------------------------------
+   def Array(self,Para,Champ):
+      """Renvoie sous forme de NumArray le résultat d'une extraction dans une table
+      méthode utile à macr_recal
+      """
+      import numpy
+      __Rep = self[Para,Champ].values()
+      F = numpy.zeros((len(__Rep[Para]),2))
+      for i in range(len(__Rep[Para])):
+         F[i][0] = __Rep[Para][i]
+         F[i][1] = __Rep[Champ][i]
+      del(__Rep)
+      return F
+
+# ------------------------------------------------------------------------------
+   def Croise(self):
+      """Retourne un tableau croisé P3(P1,P2) à partir d'une table ayant
+      trois paramètres (P1, P2, P3).
+      """
+      if len(self.para) != 3:
+         UTMESS('A', 'TABLE0_36')
+         return Table()
+      py, px, pz = self.para
+      ly, lx, lz = [getattr(self,p).values() for p in self.para]
+      new_rows=[]
+      #lpz='%s=f(%s,%s)' % (pz,px,py)
+      lpz='%s/%s' % (px,py)
+      # attention aux doublons dans lx et ly
+      new_para=set(ly)
+      new_para.discard(None)
+      new_para = list(new_para)
+      new_para.sort()
+      new_para.insert(0, lpz)
+      # attention aux doublons dans lx et ly
+      newx=set(lx)
+      newx.discard(None)
+      newx = list(newx)
+      newx.sort()
+      for x in newx:
+         if x != None:
+            d={ lpz : x, }
+            taux = (getattr(self,px)==x)
+            for dz in taux.rows:
+               d[dz[py]]=dz[pz]
+            new_rows.append(d)
+      new_type=[self.type[0],] + [self.type[2]]*(len(new_para) - 1)
+      new_titr=self.titr
+      if new_titr != '': new_titr+='\n'
+      new_titr+=pz + ' FONCTION DE ' + px + ' ET ' + py
+      return Table(new_rows, new_para, new_type, new_titr)
+
+# ------------------------------------------------------------------------------
+   def Renomme(self, pold, pnew):
+      """Renomme le paramètre `pold` en `pnew`.
+      """
+      if not pold in self.para:
+         raise KeyError, 'Paramètre %s inexistant dans cette table' % pold
+      elif self.para.count(pnew)>0:
+         raise KeyError, 'Le paramètre %s existe déjà dans la table' % pnew
+      else:
+         self.para[self.para.index(pold)] = pnew
+         for lig in self:
+            lig[pnew] = lig[pold]
+            del lig[pold]
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+class Colonne(TableBase):
+   """Classe intermédiaire pour mémoriser un couple (table, nom de colonne)
+   et exprimer les critères d'extraction sous une forme naturelle en python
+   en surchargeant les operateurs <, >, != et =.
+   Alors on peut écrire la requete simple :
+     soustable=t.a<10
+   Ainsi que des requetes plus complexes :
+     soustable=t.a<10 and t.b <4
+   ou
+     soustable=t.a<10 or t.b <4
+   Les "alias" EQ, NE, LE, LT, GE, GT permettent à la macro IMPR_TABLE
+   d'utiliser directement le mot-clé utilisateur CRIT_COMP défini dans le
+   catalogue : getattr(Table,CRIT_COMP).
+   """
+# ------------------------------------------------------------------------------
+   def __init__(self, table, column, typ=None):
+      """Constructeur (objet Table associé, paramètre de la colonne, type du
+      paramètre).
+      """
+      self.Table=table
+      self.rows=self.Table.rows
+      self.para=column
+      self.type=typ
+      self.titr=''
+
+# ------------------------------------------------------------------------------
+   def _extract(self, fun):
+      """Construit une table avec les lignes de self.Table 
+         dont l'élément de nom self.para satisfait le critère fun,
+         fun est une fonction qui retourne vrai ou faux
+      """
+      return Table([row for row in self.Table if fun(row.get(self.para))], self.Table.para, self.Table.type, self.Table.titr)
+
+# ------------------------------------------------------------------------------
+   def __le__(self, VALE):
+      if is_enum(VALE) :
+        crit = max(VALE)
+      else:
+        crit = VALE
+      return self._extract(lambda v: v != None and v<=crit)
+
+# ------------------------------------------------------------------------------
+   def __lt__(self, VALE):
+      if is_enum(VALE) :
+        crit = max(VALE)
+      else:
+        crit = VALE
+      return self._extract(lambda v: v != None and v<crit)
+
+# ------------------------------------------------------------------------------
+   def __ge__(self, VALE):
+      if is_enum(VALE):
+        crit = min(VALE)
+      else:
+        crit = VALE
+      return self._extract(lambda v: v != None and v>=crit)
+
+# ------------------------------------------------------------------------------
+   def __gt__(self, VALE):
+      if is_enum(VALE):
+        crit = min(VALE)
+      else:
+        crit = VALE
+      return self._extract(lambda v: v != None and v>crit)
+
+# ------------------------------------------------------------------------------
+   def __eq__(self, VALE, CRITERE='RELATIF', PRECISION=0.):
+      if not is_enum(VALE):
+         VALE = [VALE]
+      if is_str(VALE[0]):
+         stripVALE = [value.strip() for value in VALE]
+         return self._extract(lambda v: str(v).strip() in stripVALE)
+      else:           
+         if PRECISION==0. :
+            return self._extract(lambda v : v in VALE)
+         elif CRITERE=='ABSOLU':
+            return self._extract(lambda v : _func_test_abs(v, VALE, PRECISION))
+         else:
+            return self._extract(lambda v : _func_test_rela(v, VALE, PRECISION))
+      
+# ------------------------------------------------------------------------------
+   def REGEXP(self, regexp):
+      """Retient les lignes dont le paramètre satisfait l'expression
+      régulière `regexp`.
+      """
+      if not is_str(regexp):
+         return self._extract(lambda v : False)
+      return self._extract(lambda v : v != None and re.search(regexp, v) != None)
+
+# ------------------------------------------------------------------------------
+   def __ne__(self, VALE, CRITERE='RELATIF', PRECISION=0.):
+      if not is_enum(VALE):
+         VALE = [VALE]
+      if is_str(VALE[0]):
+         stripVALE = [value.strip() for value in VALE]
+         return self._extract(lambda v: str(v).strip() not in stripVALE)
+      else:           
+         if PRECISION==0. :
+            return self._extract(lambda v : v not in VALE)
+         elif CRITERE=='ABSOLU':
+            return self._extract(lambda v : not (_func_test_abs(v, VALE, PRECISION)))
+         else:
+            return self._extract(lambda v : not (_func_test_rela(v, VALE, PRECISION)))
+
+# ------------------------------------------------------------------------------
+   def MAXI(self):
+      # important pour les performances de récupérer le max une fois pour toutes
+      maxi=max(self)
+      return self._extract(lambda v: v==maxi)
+
+# ------------------------------------------------------------------------------
+   def MINI(self):
+      # important pour les performances de récupérer le min une fois pour toutes
+      mini=min(self)
+      return self._extract(lambda v: v==mini)
+
+# ------------------------------------------------------------------------------
+   def ABS_MAXI(self):
+      # important pour les performances de récupérer le max une fois pour toutes
+      abs_maxi=max([abs(v) for v in self.values() if is_number(v)])
+      return self._extract(lambda v: v==abs_maxi or v==-abs_maxi)
+
+# ------------------------------------------------------------------------------
+   def ABS_MINI(self):
+      # important pour les performances de récupérer le min une fois pour toutes
+      abs_mini=min([abs(v) for v in self.values() if is_number(v)])
+      # tester le type de v est trop long donc pas de abs(v)
+      return self._extract(lambda v: v==abs_mini or v==-abs_mini)
+
+# ------------------------------------------------------------------------------
+   def __iter__(self):
+      """Itère sur les éléments de la colonne"""
+      for row in self.Table:
+         # si l'élément n'est pas présent on retourne None
+         yield row.get(self.para)
+         #yield row[self.para]
+
+# ------------------------------------------------------------------------------
+   def __getitem__(self, i):
+      """Retourne la ième valeur d'une colonne"""
+      return self.values()[i]
+
+# ------------------------------------------------------------------------------
+   def values(self):
+      """Renvoie la liste des valeurs"""
+      return [r.get(self.para,None) for r in self.Table]
+
+   def not_none_values(self):
+      """Renvoie la liste des valeurs non 'None'"""
+      return [val for val in self.values() if val != None]
+
+# ------------------------------------------------------------------------------
+   # équivalences avec les opérateurs dans Aster
+   LE=__le__
+   LT=__lt__
+   GE=__ge__
+   GT=__gt__
+   EQ=__eq__
+   NE=__ne__
+   def VIDE(self):
+      return self.__eq__(None)
+   def NON_VIDE(self):
+      return self.__ne__(None)
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+def sort_table(rows, l_para, w_para, reverse=False):
+   """Sort list of dict.
+      rows     : list of dict
+      l_para   : list of the keys of dict
+      w_para   : keys of the sort
+   """
+   c_para=[i for i in l_para if i not in w_para]
+   new_rows=rows
+   # rename sort keys by "__" + number + para
+   # ("__" to avoid conflict with existing parameters)
+   for i, p in enumerate(w_para) :
+      new_key= '__%03d%s' % (i, p)
+      for row in new_rows :
+         v = row.get(p)
+         row[new_key] = v     # must have a value to sort properly
+         try:
+            del row[p]
+         except:
+            pass
+   # rename others parameters by "__999" + para
+   for p in c_para :
+      new_key= '__999'+p
+      for row in new_rows :
+         v = row.get(p)
+         row[new_key] = v     # must have a value to sort properly
+         try:
+            del row[p]
+         except:
+            pass
+   # sort
+   new_rows.sort()
+   # reversed sort
+   if reverse:
+      new_rows.reverse()
+   for i, p in enumerate(w_para) :
+      old_key= '__%03d%s' % (i, p)
+      for row in new_rows:
+         v = row.get(old_key)
+         if v is not None:
+            row[p] = v
+         try:
+            del row[old_key]
+         except:
+            pass
+   for p in c_para :
+      old_key= '__999'+p
+      for row in new_rows :
+         v = row.get(old_key)
+         if v is not None:
+            row[p] = v
+         try:
+            del row[old_key]
+         except:
+            pass
+   return new_rows
+
+# ------------------------------------------------------------------------------
+def FMT(dform, nform, typAster=None, larg=0, val=''):
+   """Retourne un format d'impression Python à partir d'un type Aster ('R','I',
+   'K8', 'K16'...). Si typAster==None, retourne dform[nform].
+      larg : largeur minimale du format (val permet de ne pas ajouter des blancs
+      si la chaine à afficher est plus longue que le format, on prend le partie
+      de ne pas tronquer les chaines)
+   """
+   if typAster==None:
+      fmt=dform[nform]
+   elif typAster in ('I', 'R'):
+      if nform=='formK':
+         # convertit %12.5E en %-12s
+         fmt=re.sub('([0-9]+)[\.0-9]*[diueEfFgG]+','-\g<1>s',dform['form'+typAster])
+      else:
+         fmt=dform[nform]
+   else:
+      # typAster = Kn
+      fmt='%-'+typAster[1:]+'s'
+   # on ajoute éventuellement des blancs pour atteindre la largeur demandée
+   if larg != 0:
+      fmt=' '*max(min(larg-len(val),larg-len(fmt % 0)),0) + fmt
+   return fmt
+
+# ------------------------------------------------------------------------------
+def merge(tab1, tab2, labels=[], restrict=False):
+   """Assemble les deux tables tb1 et tb2 selon une liste de labels communs.
+      Si labels est vide:
+       - les lignes de tb2 sont ajoutés à celles de tb1,
+      sinon :
+       - si on trouve les valeurs de tb2 sur les labels dans tb1 (et une seule fois),
+         on surcharge tb1 avec les lignes de tb2 ;
+       - sinon on ajoute la ligne de tb2 à la fin de tb1.
+   """
+   tb1 = tab1.copy()
+   tb2 = tab2.copy()
+   if not is_enum(labels):
+      labels=(labels,)
+   for key in labels :
+       if key not in tb1.para : UTMESS('F','TABLE0_27', valk=key)
+       if key not in tb2.para : UTMESS('F','TABLE0_27', valk=key)
+   # ensemble des paramètres et des types
+   n_para=tb1.para[:]
+   n_type=tb1.type[:]
+   for i in tb2.para:
+      if i not in tb1.para:
+         n_para.append(i)
+         n_type.append(tb2.type[tb2.para.index(i)])
+   # restriction des lignes aux labels communs (peu cher en cpu)
+   rows1 = tb1.rows
+   dlab1 = {}
+   for i1 in range(len(rows1)):
+      tu1 = tuple(map(rows1[i1].__getitem__, labels))
+      if dlab1.get(tu1, '') == '':
+         dlab1[tu1] = i1
+      else:
+         dlab1[tu1] = None
+   # restriction des lignes aux labels communs (peu cher en cpu)
+   rows2 = tb2.rows
+   dlab2 = {}
+   for i2 in range(len(rows2)):
+      tu2 = tuple(map(rows2[i2].__getitem__, labels))
+      if dlab2.get(tu2, '') == '':
+         dlab2[tu2] = i2
+      else:
+         dlab2[tu2] = None
+   # creation de dic1 : dictionnaire de correspondance entre les 
+   # lignes a merger dans les deux tableaux
+   dic1 = {}
+   for cle in dlab1.keys():
+      if dlab1[cle] == None or cle == ():
+         bid = dlab1.pop(cle)
+   for cle in dlab2.keys():
+      if dlab2[cle] == None or cle == ():
+         bid = dlab2.pop(cle)
+   for cle in dlab2.keys():
+      if dlab1.has_key(cle):
+         dic1[dlab2[cle]] = dlab1[cle]
+   # insertion des valeurs de tb2 dans tb1 quand les labels sont communs
+   # (et uniques dans chaque table)
+   # OU ajout de la ligne de tb2 dans tb1 (si restrict == False)
+   if restrict:
+      def func_append_r2(row):
+         pass
+   else:
+      def func_append_r2(row):
+         rows1.append(row)
+   i2 = -1
+   for r2 in rows2:
+      i2 += 1
+      try:
+         rows1[dic1[i2]].update(r2)
+      except KeyError:
+         func_append_r2(r2)
+   # concaténation des titres + info sur le merge
+   tit = '\n'.join([tb1.titr, tb2.titr, 'MERGE avec labels=%s' % repr(labels)])
+   return Table(rows1, n_para, n_type, tit)
+
+# ------------------------------------------------------------------------------
+def _typaster(obj, prev=None, strict=False):
+   """Retourne le type Aster ('R', 'I', Kdef) correspondant à l'objet obj.
+   Si prev est fourni, on vérifie que obj est du type prev.
+   Si strict=False, on autorise que obj ne soit pas du type prev s'ils sont
+   tous les deux numériques ; dans ce cas, on retourne le "type enveloppe" 'R'.
+   """
+   dtyp={
+      IntType    : 'I',
+      FloatType  : 'R',
+      StringType : Kdef, UnicodeType : Kdef,
+      NoneType   : 'I',
+   }
+   if is_float(obj):
+       obj = float(obj)
+   if type(obj) in dtyp.keys():
+      typobj=dtyp[type(obj)]
+      if prev in [None, typobj]:
+         return typobj
+      elif prev[0] == typobj[0] == 'K':
+         if len(obj) <= int(prev[1:]):
+            return prev
+         else:
+            raise TypeError, "La longueur de la chaine %s est incompatible avec le type %s" \
+               % (repr(obj),repr(prev))
+      elif strict:   # prev != None et typobj != prev et strict
+         raise TypeError, "La valeur %s n'est pas de type %s" % (repr(obj),repr(prev))
+      elif prev in ('I','R') and typobj in ('I','R'):
+         return 'R'
+      else:
+         raise TypeError, "La valeur %s n'est pas compatible avec le type %s" \
+               % (repr(obj),repr(prev))
+   else:
+      raise TypeError, 'Une table ne peut contenir que des entiers, réels ' \
+                       'ou chaines de caractères.'
+                  
+# ------------------------------------------------------------------------------
+# fonctions utilitaires
+def _func_test_abs(v, VALE, PRECISION):
+   """Retourne True si v est parmi VALE à PRECISION près en absolu
+   """
+   for x in VALE:
+      if v != None and (x-PRECISION <= v <= x+PRECISION):
+         return True
+   return False
+
+def _func_test_rela(v, VALE, PRECISION):
+   """Retourne True si v est parmi VALE à PRECISION près en relatif
+   """
+   for x in VALE: 
+      sign = float(x > 0.) or -1.
+      if v != None and (sign*x*(1.-PRECISION) <= sign*v <= sign*x*(1.+PRECISION)):
+         return True
+   return False
+
+def check_nan(values):
+   """Raise ValueError exception if nan is found in values."""
+   for i, v in enumerate(values):
+      if str(v) == 'nan':
+         raise ValueError, 'NaN present at index %d' % i
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/UniteAster.py b/Aster/Cata/cataSTA10/Utilitai/UniteAster.py
new file mode 100644 (file)
index 0000000..23864c1
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/UniteAster.py
@@ -0,0 +1,210 @@
+#@ MODIF UniteAster Utilitai  DATE 06/07/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2005  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+# RESPONSABLE COURTOIS M.COURTOIS
+
+import types
+
+import aster
+from Cata.cata import _F
+from Cata.cata import DEFI_FICHIER
+from Cata.cata import INFO_EXEC_ASTER
+from Cata.cata import DETRUIRE
+
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+class UniteAster:
+   """Classe pour manipuler les fichiers en Python en accord avec les unités
+   logiques utilisées en Fortran.
+   De manière analogue au Fortran, les états possibles d'une unité sont :
+      'F' : fermé, 'O' : ouvert, 'R' : réservé.
+
+   Méthodes :
+      Nom      : Retourne le nom du fichier associé à une unité,
+      Etat     : Retourne l'état d'une unité,
+      Libre    : Retourne un numéro d'unité libre,
+      EtatInit : Remet une, plusieurs ou toutes les unités dans leur état initial.
+
+   Méthode privée :
+      _setinfo : pour remplir le dictionnaire des 'infos'
+   Attribut privé :
+      infos[numéro unité] = { 'nom' : x, 'etat' : x , 'etat_init' : x }
+   """
+#-------------------------------------------------------------------------------
+   def __init__(self):
+      """Initialise le dictionnaire des unités.
+      """
+      self.infos = {}
+
+#-------------------------------------------------------------------------------
+   def _setinfo(self, ul):
+      """Remplit les infos de l'unité 'ul'.
+      """
+      # ul peut etre un entier Aster
+      try:
+         unit = ul.valeur
+      except:
+         unit = int(ul)
+      # Si la clé n'existe pas
+      ini = False
+      if not self.infos.has_key(unit):
+         self.infos[unit] = {}
+         self.infos[unit]['nom']       = ''
+         self.infos[unit]['etat']      = '?'
+         self.infos[unit]['etat_init'] = '?'
+         ini = True
+
+      __tab=INFO_EXEC_ASTER(UNITE=unit, LISTE_INFO=('ETAT_UNITE'))
+      
+      # O:ouvert, F:fermé, R:réservé
+      self.infos[unit]['etat'] = __tab['ETAT_UNITE',1].strip()[0]
+      if ini:
+         self.infos[unit]['etat_init'] = self.infos[unit]['etat']
+
+      # nom du fichier
+      if self.infos[unit]['etat'] in ['O', 'R']:
+         nomfich=''.join([__tab['NOMFIC%d' % i,1] for i in range(1,5)]).strip()
+      elif self.infos[unit]['etat'] == 'F':
+         nomfich='fort.'+str(unit)
+      else:
+         message = "Etat de l'unité inconnu : %s" % self.infos[unit]['etat']
+         print __tab.EXTR_TABLE()
+         raise aster.error,"<F> <UniteAster._setinfo> %s" % message
+      self.infos[unit]['nom'] = nomfich
+      #print 'DEBUG infos[unit] = ', self.infos[unit]
+      DETRUIRE(CONCEPT=_F(NOM=__tab),INFO=1)
+
+#-------------------------------------------------------------------------------
+   def Libre(self, nom=None, action='RESERVER'):
+      """Réserve/associe et retourne une unité libre en y associant, s'il est
+      fourni, le fichier 'nom'.
+      """
+      __tab=INFO_EXEC_ASTER(LISTE_INFO=('UNITE_LIBRE'))
+      unit = __tab['UNITE_LIBRE',1]
+      DETRUIRE(CONCEPT=_F(NOM=__tab),INFO=1)
+      if nom==None:
+         nom='fort.'+str(unit)
+
+      # Si la clé existe, c'est que le fichier n'était pas libre
+      if self.infos.has_key(unit):
+         message = "Cette unité est déjà affectée au fichier %s" % \
+            self.infos[unit]['nom']
+         raise aster.error,"<F> <UniteAster.Libre> %s" % message
+
+      DEFI_FICHIER(ACTION=action, UNITE=unit , FICHIER=nom.strip())
+      self.infos[unit] = {}
+      self.infos[unit]['nom']       = nom.strip()
+      self.infos[unit]['etat']      = 'R'
+      self.infos[unit]['etat_init'] = 'F'
+      return unit
+
+#-------------------------------------------------------------------------------
+   def Nom(self, ul):
+      """Retourne le nom du fichier associé à l'unité 'ul'.
+      """
+      # ul peut etre un entier Aster
+      try:
+         unit = ul.valeur
+      except:
+         unit = int(ul)
+      # Si la clé n'existe pas
+      if not self.infos.has_key(unit):
+         self._setinfo(unit)
+      return self.infos[unit]['nom']
+
+#-------------------------------------------------------------------------------
+   def Etat(self, ul, **kargs):
+      """Retourne l'état de l'unité si 'etat' n'est pas fourni
+      et/ou change son état :
+         kargs['etat']  : nouvel état,
+         kargs['nom']   : nom du fichier,
+         kargs['TYPE']  : type du fichier à ouvrir ASCII/BINARY/LIBRE,
+         kargs['ACCES'] : type d'accès NEW/APPEND/OLD (APPEND uniquement en ASCII).
+      """
+      # ul peut etre un entier Aster
+      try:
+         unit = ul.valeur
+      except:
+         unit = int(ul)
+      # Si la clé n'existe pas
+      if not self.infos.has_key(unit):
+         self._setinfo(unit)
+      if not kargs.has_key('etat'):
+         return self.infos[unit]['etat']
+
+      # En fonction de la demande, on bascule son état ou pas
+      new = kargs.get('etat')
+      if not new in ['R', 'F', 'O']:
+         message = "Nouvel état de l'unité incorrect : %s" % new
+         raise aster.error,"<F> <UniteAster.Etat> %s" % message
+
+      if self.infos[unit]['etat'] == new:
+         pass
+      elif new == 'R':
+         if self.infos[unit]['etat'] == 'O':
+            DEFI_FICHIER(ACTION='LIBERER',  UNITE=unit)
+         DEFI_FICHIER(ACTION  = 'RESERVER', 
+                      UNITE   = unit,
+                      FICHIER = kargs.get('nom', self.infos[unit]['nom']))
+         self._setinfo(unit)
+      elif new == 'F':
+         DEFI_FICHIER(ACTION='LIBERER', UNITE=unit)
+      elif new == 'O':
+         if self.infos[unit]['etat'] == 'R':
+            DEFI_FICHIER(ACTION='LIBERER', UNITE=unit)
+         # valeurs par défaut
+         typ   = kargs.get('TYPE', 'ASCII')
+         if typ == 'ASCII':
+            acces = 'APPEND'
+         else:
+            acces = 'OLD'
+         acces = kargs.get('ACCES', acces)
+         DEFI_FICHIER(ACTION  ='ASSOCIER',
+                      UNITE   = unit,
+                      FICHIER = kargs.get('nom', self.infos[unit]['nom']),
+                      TYPE    = typ,
+                      ACCES   = acces,)
+         self._setinfo(unit)
+      self.infos[unit]['etat'] = new
+      return self.infos[unit]['etat']
+
+#-------------------------------------------------------------------------------
+   def EtatInit(self, ul=None):
+      """Remet l'unité 'ul' dans son état initial.
+      Si 'ul' est omis, toutes les unités sont remises dans leur état initial.
+      """
+      if ul == None:
+         for uli, vul in self.infos.items():
+            self.Etat(uli, etat=vul['etat_init'])
+      else:
+         if not type(ul) in [types.ListType, types.TupleType]:
+            ul=[ul,]
+         for u in ul:
+            # u peut etre un entier Aster
+            try:
+               unit = u.valeur
+            except:
+               unit = int(u)
+            # Si la clé n'existe pas
+            if not self.infos.has_key(unit):
+               self._setinfo(unit)
+            else:
+               self.Etat(unit, etat=self.infos[unit]['etat_init'])

diff --git a/Aster/Cata/cataSTA10/Utilitai/Utmess.py b/Aster/Cata/cataSTA10/Utilitai/Utmess.py
new file mode 100644 (file)
index 0000000..3aa5242
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/Utmess.py
@@ -0,0 +1,711 @@
+#@ MODIF Utmess Utilitai  DATE 14/03/2011   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+import os
+import sys
+import traceback
+import imp
+import re
+
+# protection pour eficas
+try:
+    import aster
+    from aster import error
+    aster_exists = True
+    from Messages.context_info import message_context_concept
+except:
+    aster_exists = False
+    class error(Exception):
+        pass
+
+def _(s):
+    return s
+
+from Noyau.N_types import force_list
+
+
+MAXLENGTH = 132
+
+contacter_assistance = """
+Il y a probablement une erreur dans la programmation.
+Veuillez contacter votre assistance technique."""
+
+# voir en fin de fin les faux appels à UTMESS pour la vérification des messages
+
+
+def list_unit(code):
+    """Retourne la liste des noms de fichiers (logiques) sur lesquels doit
+    etre imprimé le message.
+    """
+    #IDF  = INDEX('EFIDASXZ', ...)
+    #'Z' (IDF=8) = LEVEE D'EXCEPTION
+    d = {
+        'E' : ('ERREUR', 'MESSAGE', 'RESULTAT'),
+        'I' : ('MESSAGE',),
+        'A' : ('MESSAGE', 'RESULTAT'),
+    }
+    d['F'] = d['S'] = d['Z'] = d['E']
+    d['X'] = d['A']
+    return d.get(code, d['F'])
+
+
+class MESSAGE_LOGGER:
+    """Classe gérant l'impression de messages.
+    On ne crée qu'une instance de ce type.
+    Cette instance est accessible via le module E_Global pour astermodule.c
+    """
+    def __init__(self):
+        """Initialisation
+        """
+        self.init_buffer()
+        
+        # est-ce qu'une erreur <E> s'est produite
+        self.erreur_E = False
+        
+        # compteur des alarmes émises { 'id_alarm' : count }
+        self.count_alarm = {}         # dans la commande courante (pour arret à 5)
+        self.count_alarm_tot = {}     # au total
+        
+        # alarmes à ignorer, à masquer (on ne les compte pas temporairement)
+        self._ignored_alarm = {}
+        self._hidden_alarm  = {}
+        
+        # on prépare le dictionnaire des valeurs par défaut des arguments (dicarg) :
+        self.default_args = {}
+        # initialisation des 10 premiers
+        for i in range(1,11):
+            self.default_args['i%d' % i] = 99999999
+            self.default_args['r%d' % i] = 9.9999E99
+            self.default_args['k%d' % i] = 'xxxxxx'
+
+
+    def __call__(self, *args, **kwargs):
+        """Raccourci pour simplifier l'appel depuis astermodule.c et UTMESS.
+        """
+        self.print_message(*args, **kwargs)
+
+
+    def print_message(self, code, idmess, valk=(), vali=(), valr=(),
+                            exception=False, print_as=None, cc=None):
+        """Appelé par la routine fortran U2MESG ou à la fonction python UTMESS
+        pour afficher un message.
+        L'impression de ce message est différée si le `code` est suivi d'un "+".
+            code  : 'A', 'E', 'S', 'F', 'I'
+            idmess : identificateur du message
+            valk, vali, valr : liste des chaines, entiers ou réels.
+        Si exception==True, on lève une exception en cas d'erreur, sinon
+        c'est l'appelant qui devra s'en charger (dans le C a priori).
+        'print_as' : cf. print_buffer_content.
+        """
+        # le '+' n'a pas de sens pour les messages 'I'.
+        if code == "I+":
+            code = "I"
+        # récupération du texte du message
+        dictmess = self.get_message(code, idmess, valk, vali, valr)
+        
+        # on le met dans le buffer
+        self.add_to_buffer(dictmess)
+        
+        # si on n'attend pas une suite, ...
+        if len(code) < 2 or code[1] != '+':
+            # mise à jour des compteurs
+            self.update_counter()
+            
+            # on imprime le message en attente
+            self.print_buffer_content(print_as, cc)
+
+            if exception and code[0] in ('S', 'F'):
+                raise error(idmess, valk, vali, valr)
+        
+        return None
+
+
+    def build_dict_args(self, valk, vali, valr):
+        """Construit le dictionnaire de formatage du message.
+        """
+        # homogénéisation : uniquement des tuples + strip des chaines de caractères
+        valk, vali, valr = map(force_list, (valk, vali, valr))
+        valk    = [k.strip() for k in valk]
+        
+        # variables passées au message
+        dicarg = self.default_args.copy()
+        for i in range(1,len(valk)+1):
+            dicarg['k%d' % i] = valk[i-1]
+        for i in range(1,len(vali)+1):
+            dicarg['i%d' % i] = vali[i-1]
+        for i in range(1,len(valr)+1):
+            dicarg['r%d' % i] = valr[i-1]
+        # valeur spéciale : ktout = concaténation de toutes les chaines
+        dicarg['ktout'] = ' '.join(valk)
+    
+        return dicarg
+
+
+    def get_message(self, code, idmess, valk=(), vali=(), valr=()):
+        """Retourne le texte du message dans un dictionnaire dont les clés sont :
+            'code', 'id_message', 'corps_message'
+        """
+        # décodage : idmess => (catamess, numess)
+        idmess  = idmess.strip()
+        x = idmess.split("_")
+        assert len(x) > 1, idmess
+        catamess='_'.join(x[0:-1]).lower()
+        numess = int(x[-1])
+        assert numess > 0 and numess < 100, idmess
+    
+        # import catamess => cata_msg
+        try:
+            mod = __import__('Messages.%s' % catamess, globals(), locals(), [catamess])
+            # si le dictionnaire n'existe pas, on alertera au moment du formatage.
+            cata_msg = getattr(mod, 'cata_msg', {})
+        except Exception, msg:
+            # doit permettre d'éviter la récursivité (catamess réservé à Utmess)
+            if catamess != 'catamess':
+                self.print_message('A', 'CATAMESS_57', valk=(catamess, str(msg)))
+            cata_msg = {}
+        
+        # corps du message
+        try:
+            dicarg = self.build_dict_args(valk, vali, valr)
+
+            # cata_msg[num] = 'format'
+            #              ou {'message' : 'format', 'context' : 'éléments de contexte'}
+            if type(cata_msg[numess]) == dict:
+                fmt_msg  = cata_msg[numess]['message']
+                ctxt_msg = cata_msg[numess]['context']
+            else:
+                fmt_msg  = cata_msg[numess]
+                ctxt_msg = None
+            
+            dictmess = {
+                'code'          : code,
+                'id_message'    : idmess,
+                'corps_message' : fmt_msg % dicarg,
+                'context_info'  : self.get_context(ctxt_msg, idmess, dicarg),
+            }
+        except Exception, msg:
+            dictmess = {
+                'code'          : code,
+                'id_message'    : '',
+                'corps_message' : """Erreur de programmation.
+Le message %s n'a pas pu etre formaté correctement.
+Arguments :
+    entiers : %s
+    réels   : %s
+    chaines : %s
+--------------------------------------------------------------------------
+%s
+Exception : %s
+--------------------------------------------------------------------------
+
+%s""" \
+        % (idmess, vali, valr, valk, ''.join(traceback.format_tb(sys.exc_traceback)), msg, contacter_assistance),
+                'context_info'  : '',
+            }
+        # limite la longueur des ligness
+        dictmess['corps_message'] = cut_long_lines(dictmess['corps_message'], MAXLENGTH)
+        return dictmess
+
+
+    def GetText(self, *args, **kwargs):
+        """Retourne le texte du message pret a etre imprime.
+        """
+        return self.format_message(self.get_message(*args, **kwargs))
+
+
+    def init_buffer(self):
+        """Initialise le buffer.
+        """
+        self._buffer = []
+
+
+    def add_to_buffer(self, dictmess):
+        """Ajoute le message décrit dans le buffer en vue d'une impression
+        ultérieure.
+        """
+        self._buffer.append(dictmess)
+
+
+    def get_current_code(self):
+        """Retourne le code du message du buffer = code du message le plus grave
+        (cf. dgrav)
+        """
+        dgrav = { '?' : -9, 'I' : 0, 'A' : 1, 'S' : 4, 'Z' : 4, 'E' : 6, 'F' : 10 }
+        
+        current = '?'
+        for dictmess in self._buffer:
+            code = dictmess['code'][0]
+            if dgrav.get(code, -9) > dgrav.get(current, -9):
+                current = code
+        
+        return current
+
+
+    def get_current_id(self):
+        """Retourne l'id du message du buffer = id du premier message
+        """
+        return self._buffer[0]['id_message']
+
+
+    def print_buffer_content(self, print_as=None, cc=None):
+        """Extrait l'ensemble des messages du buffer dans un dictionnaire unique,
+        imprime le message, et vide le buffer pour le message suivant.
+            - code : celui du message le plus grave (cf. dgrav)
+            - id   : celui du premier message qui est affiché
+            - corps : concaténation de tous les messages.
+        'print'_as permet d'imprimer un message sur des fichiers autres que les fichiers
+        habituels de 'code'. Par ex, imprimer un message d'info sur 'ERREUR'.
+        'cc' : liste de noms de fichiers ou objets fichier dans lesquels copier le message
+        """
+        if len(self._buffer) < 1:
+            return None
+        
+        # construction du dictionnaire du message global
+        dglob = {
+            'code'          : self.get_current_code(),
+            'id_message'    : self.get_current_id(),
+            'liste_message' : [],
+            'liste_context' : [],
+        }
+        for dictmess in self._buffer:
+            dglob['liste_message'].append(dictmess['corps_message'])
+            dglob['liste_context'].append(dictmess['context_info'])
+        dglob['corps_message'] = ''.join(dglob['liste_message'])
+        dglob['context_info'] = ''.join(dglob['liste_context'])
+        
+        # liste des unités d'impression en fonction du type de message
+        l_unit = list_unit(print_as or dglob['code'])
+        
+        # texte final et impression
+        txt = self.format_message(dglob)
+        for unite in l_unit:
+            self.affiche(unite, txt)
+        # "cc"
+        if cc:
+            copy_text_to(txt, cc)
+        
+        self.init_buffer()
+
+
+    def disable_alarm(self, idmess, hide=False):
+        """Ignore l'alarme "idmess".
+        """
+        if hide:
+            self._hidden_alarm[idmess] = self._hidden_alarm.get(idmess, 0) + 1
+        else:
+            self._ignored_alarm[idmess] = self._ignored_alarm.get(idmess, 0) + 1
+
+    def reset_alarm(self, idmess, hide=False):
+        """Réactive l'alarme "idmess".
+        """
+        if hide:
+            self._hidden_alarm[idmess] = min(self._hidden_alarm.get(idmess, 0) - 1, 0)
+        else:
+            self._ignored_alarm[idmess] = min(self._ignored_alarm.get(idmess, 0) - 1, 0)
+
+    def is_alarm_disabled(self, idmess):
+        """Doit-on ignorer l'alarme "idmess" ?
+        """
+        return self._ignored_alarm.get(idmess, 0) + self._hidden_alarm.get(idmess, 0) > 0
+
+    def info_alarm(self, only_ignored=False):
+        """Fournit les infos sur les alarmes activées.
+        """
+        s_alarm = set(self._ignored_alarm.keys())
+        if not only_ignored:
+            s_alarm.update(self.count_alarm_tot.keys())
+        l_alarm = list(s_alarm)
+        l_alarm.sort()
+        # on sépare des éventuels messages en attente
+        self.print_buffer_content()
+        # entete
+        dictmess = self.get_message('I', 'CATAMESS_89')
+        self.add_to_buffer(dictmess)
+        # occurrences
+        ieff = 0
+        for idmess in l_alarm:
+            mark = ' '
+            ieff += 1
+            if self._ignored_alarm.get(idmess) is not None:
+                mark = '(*)'
+            dictmess = self.get_message('I', 'CATAMESS_90', valk=(mark, idmess),
+                                     vali=self.count_alarm_tot.get(idmess, 0))
+            self.add_to_buffer(dictmess)
+        if ieff == 0:
+            dictmess = self.get_message('I', 'CATAMESS_92')
+            self.add_to_buffer(dictmess)
+        # fermeture
+        dictmess = self.get_message('I', 'CATAMESS_91')
+        self.add_to_buffer(dictmess)
+        self.print_buffer_content(print_as='A')
+
+
+    def update_counter(self):
+        """Mise à jour des compteurs et réaction si besoin.
+        """
+        nmax_alarm = 5
+        code = self.get_current_code()
+        if   code == 'E':
+            self.erreur_E = True
+        elif code == 'F':
+            self.erreur_E = False
+        elif code == 'A':
+            idmess = self.get_current_id()
+            # nombre d'occurrence de cette alarme (sauf si cachee)
+            if self._hidden_alarm.get(idmess, 0) == 0:
+                self.count_alarm[idmess]     = self.count_alarm.get(idmess, 0) + 1
+                self.count_alarm_tot[idmess] = self.count_alarm_tot.get(idmess, 0) + 1
+            
+            if self.is_alarm_disabled(idmess) or self.count_alarm[idmess] > nmax_alarm:
+                # ignorer l'alarme ou count_alarm > max, on vide le buffer
+                self.init_buffer()
+            elif self.count_alarm[idmess] == nmax_alarm:
+                # Pour mettre en relief le message CATAMESS_41, on le sépare
+                # de la dernière alarme
+                self.print_buffer_content()
+                dictmess = self.get_message(code, 'CATAMESS_41',
+                                        valk=idmess, vali=nmax_alarm)
+                self.add_to_buffer(dictmess)
+
+
+    def check_counter(self, info_alarm=0, silent=0):
+        """Méthode "jusqu'ici tout va bien" ! (Interface C : chkmsg)
+        Si des erreurs <E> se sont produites, on arrete le code en <F>.
+        Appelée par FIN ou directement au cours de l'exécution d'une commande.
+        Retourne un entier : 0 si tout est ok.
+        Si silent==1, on n'émet pas de message, on ne s'arrete pas.
+        """
+        iret = 0
+        if self.erreur_E:
+            iret = 4
+            self.erreur_E = False
+            if not silent:
+                self.print_message('F', 'CATAMESS_6', exception=True)
+        if info_alarm:
+            self.info_alarm()
+        return iret
+
+
+    def reset_command(self):
+        """Méthode appelée entre les commandes. (Interface C : resmsg)
+        On remet à zéro le compteur d'alarme,
+        on vérifie les erreurs <E> en attente."""
+        iret = self.check_counter()
+        # reset des alarmes
+        self.count_alarm = {}
+
+
+    def format_message(self, dictmess):
+        """Formate le message décrit dans un dico :
+            'code'          : A, E, S, F, I
+            'id_message'    : identification du message
+            'corps_message' : texte
+        """
+        charh = '-'    # horizontal
+        charv = '!'    # vertical
+        charc = '!'    # coin
+        dcomm = {
+            'A' : _("""Ceci est une alarme. Si vous ne comprenez pas le sens de cette
+alarme, vous pouvez obtenir des résultats inattendus !"""),
+            'E' : _("""Cette erreur sera suivie d'une erreur fatale."""),
+            'S' : _("""Cette erreur est fatale. Le code s'arrete. Toutes les étapes
+du calcul ont été sauvées dans la base jusqu'au moment de l'arret."""),
+            'F' : _("""Cette erreur est fatale. Le code s'arrete."""),
+        }
+        
+        # format complet
+        format_general = {
+            'decal'  : '   ',
+            'header' : """<%(type_message)s> %(str_id_message)s""",
+            'ligne'  : '%(charv)s %%-%(maxlen)ds %(charv)s',
+            'corps'  : """%(header)s
+
+%(corps_message)s
+%(context_info)s
+
+%(commentaire)s
+""",
+            'final'  : """
+%(separateur)s
+%(corps)s
+%(separateur)s
+
+""",
+        }
+        # format light pour les infos
+        format_light = {
+            'decal'  : '',
+            'header' : """<%(type_message)s> """,
+            'ligne'  : '%%s',
+            'corps'  : """%(corps_message)s
+%(context_info)s""",
+            'final'  : """%(corps)s""",
+        }
+        dmsg = dictmess.copy()
+        dmsg['type_message'] = self.get_type_message(dictmess['code'])
+        if dmsg['id_message'] != 'I':
+            dmsg['str_id_message'] = '<%s>' % dmsg['id_message']
+        else:
+            dmsg['str_id_message'] = ''
+        
+        # format utilisé
+        format = format_general
+        if dmsg['type_message'] == 'I':
+            format = format_light
+        if format is format_general:
+            dmsg['corps_message'] = dmsg['corps_message'].strip()
+        
+        dmsg['header']      = format['header'] % dmsg
+        dmsg['commentaire'] = dcomm.get(dmsg['type_message'], '')
+        if re.search('^DVP', dmsg['id_message']) != None:
+            dmsg['commentaire'] += contacter_assistance
+        
+        dmsg['corps']       = format['corps'] % dmsg
+        if format is format_general:
+            dmsg['corps'] = dmsg['corps'].strip()
+        
+        
+        # longueur de la ligne la plus longue
+        l_line = dmsg['corps'].splitlines()
+        maxlen = max([len(line) for line in l_line])
+        
+        # format des lignes sur maxlen caractères
+        dlin = {
+            'charh'  : charh,
+            'charv'  : charv,
+            'charc'  : charc,
+            'maxlen' : maxlen
+        }
+        fmt_line = format['ligne'] % dlin
+        
+        # on formate toutes les lignes
+        txt = [fmt_line % line for line in l_line]
+        dmsg['corps'] = os.linesep.join(txt)
+        dmsg['separateur'] = charc + charh * (maxlen + 2) + charc
+        
+        # ligne haut et bas
+        newtxt = format['final'] % dmsg
+        # on décale
+        l_txt = [format['decal'] + line for line in newtxt.splitlines()]
+        
+        return clean_string(os.linesep.join(l_txt))
+
+
+    def get_type_message(self, code):
+        """Retourne le type du message affiché.
+        En cas d'erreur, si on lève une exception au lieu de s'arreter,
+        on n'affiche pas le type de l'erreur pour ne pas fausser le diagnostic
+        """
+        typmess = code.strip()
+        if self.onFatalError().startswith('EXCEPTION'):
+            if typmess in ('E', 'F'):
+                typmess = 'EXCEPTION'
+        # dans tous les cas, pour S et Z (exception), on affiche EXCEPTION.
+        if typmess in ('Z', 'S'):
+            typmess = 'EXCEPTION'
+        return typmess
+
+
+    def get_context(self, ctxt_msg, idmess, dicarg):
+        """Prise en compte du context du message pour donner d'autres infos
+        à l'utilisateur.
+        ctxt_msg est un dictionnaire. Les clés traitées sont :
+            - CONCEPT
+        """
+        if not ctxt_msg:
+            return ''
+        msg = []
+        # tout dans un try/except car c'est du bonus, il ne faudrait pas planter !
+        try:
+            if ctxt_msg.has_key('CONCEPT'):
+                l_co =  [dicarg[arg] for arg in force_list(ctxt_msg['CONCEPT'])]
+                for co in l_co:
+                    msg.append(message_context_concept(co))
+        except:
+            pass
+        return os.linesep.join(msg)
+
+
+    # définitions pour fonctionner sans le module aster
+    def affiche(self, unite, txt):
+        """Affichage du message"""
+        if aster_exists:
+            aster.affiche(unite, txt)
+        else:
+            print txt
+
+
+    def onFatalError(self):
+        """Récupérer le comportement en cas d'erreur fatale."""
+        if aster_exists:
+            return aster.onFatalError()
+        else:
+            return 'EXCEPTION'
+
+
+def clean_string(chaine):
+    """Supprime tous les caractères non imprimables.
+    """
+    invalid = '?'
+    txt = []
+    for c in chaine:
+        if ord(c) != 0:
+            txt.append(c)
+        else:
+            txt.append(invalid)
+    return ''.join(txt)
+
+
+def maximize_lines(l_fields, maxlen, sep):
+    """Construit des lignes dont la longueur est au plus de `maxlen` caractères.
+    Les champs sont assemblés avec le séparateur `sep`.
+    """
+    newlines = []
+    while len(l_fields) > 0:
+        cur = []
+        while len(l_fields) > 0 and len(sep.join(cur + [l_fields[0],])) <= maxlen:
+            cur.append(l_fields.pop(0))
+        newlines.append(sep.join(cur))
+    newlines = [l for l in newlines if l != '']
+    return newlines
+
+def cut_long_lines(txt, maxlen, sep=os.linesep,
+                   l_separ=(' ', ',', ';', '.', ':')):
+    """Coupe les morceaux de `txt` (isolés avec `sep`) de plus de `maxlen`
+    caractères.
+    On utilise successivement les séparateurs de `l_separ`.
+    """
+    l_lines = txt.split(sep)
+    newlines = []
+    for line in l_lines:
+        if len(line) > maxlen:
+            l_sep = list(l_separ)
+            line = cut_long_lines(line, maxlen, l_sep[0], l_sep[1:])
+            line = maximize_lines(line, maxlen, l_sep[0])
+            newlines.extend(line)
+        else:
+            newlines.append(line)
+    # au plus haut niveau, on assemble le texte
+    if sep == os.linesep:
+        newlines = os.linesep.join(newlines)
+    return newlines
+
+
+def copy_text_to(text, files):
+    """Imprime le texte dans les fichiers.
+    """
+    files = force_list(files)
+    for f in files:
+        assert type(f) in (str, file)
+        if type(f) == file:
+            fobj = file
+        else:
+            fobj = open(f, 'a')
+            # should be closed automatically
+        fobj.write(text)
+        fobj.write(os.linesep)
+        fobj.flush()
+
+
+# unique instance du MESSAGE_LOGGER
+MessageLog = MESSAGE_LOGGER()
+
+
+def UTMESS(code, idmess, valk=(), vali=(), valr=(), print_as=None, cc=None):
+    """Utilitaire analogue à la routine fortran U2MESS/U2MESG avec les arguments
+    optionnels.
+        code   : 'A', 'E', 'S', 'F', 'I'
+        idmess : identificateur du message
+        valk, vali, valr : liste des chaines, entiers ou réels.
+    
+    Appel sans valeurs :                avec valeurs :
+        UTMESS('A', 'SUPERVIS_40')          UTMESS('A', 'SUPERVIS_40', vali=[1, 2])
+    
+    Remarques :
+        - Nommer les arguments permet de ne pas tous les passer.
+        - Meme fonctionnement que U2MESG :
+            + appel à MessageLog
+            + puis exception ou abort en fonction du niveau d'erreur.
+    """
+    MessageLog(code, idmess, valk, vali, valr, exception=True, print_as=print_as, cc=cc)
+
+
+def ASSERT(condition, message=""):
+    """Remonter un assert dans un message.
+    """
+    if condition:
+        return
+    stack = traceback.format_stack(limit=10)
+    UTMESS('F', 'DVP_9', valk=[(''.join(stack[:-1]),), message])
+
+
+def message_exception(code, exc):
+    """Retourne le message associé à une exception aster.error
+    tel qu'il aurait été imprimé par UTMESS selon la valeur de
+    `code` ('I', 'A', 'S', 'F', 'Z'...)."""
+    return MessageLog.GetText(code, exc.id_message,
+                              exc.valk, exc.vali, exc.valr)
+
+
+def MasquerAlarme(idmess):
+    """Masque une alarme : ni affichee, ni comptee.
+    Utilisation dans les macros :
+        MasquerAlarme(XXX)  au debut de la macro
+        RetablirAlarme(XXX) a la fin de la macro
+    Comme il s'agit d'un compteur qui est incremente puis decremente, il est
+    imperatif qu'il y ait autant d'appel a MasquerAlarme qu'a RetablirAlarme.
+    """
+    MessageLog.disable_alarm(idmess, hide=True)
+
+
+def RetablirAlarme(idmess):
+    """Retablit l'etat initial pour l'alarme 'idmess'.
+    """
+    MessageLog.reset_alarm(idmess, hide=True)
+
+
+# faux appels à UTMESS
+def __fake__():
+    UTMESS('I', 'SUPERVIS_40')    # surcharge émis par asrun
+    UTMESS('I', 'SUPERVIS_96')    # émis depuis le C (inisig)
+    UTMESS('I', 'SUPERVIS_97')    # émis depuis le C (inisig)
+    UTMESS('I', 'GENERIC_1')      # dans des tests pour traiter les exceptions
+    UTMESS('I', 'CATAMESS_6')
+    UTMESS('I', 'CATAMESS_41')
+    UTMESS('I', 'CATAMESS_55')    # pour u2mesg.f
+    UTMESS('I', 'CATAMESS_57')
+    UTMESS('I', 'CATAMESS_69')    # pour u2mesg.f
+    UTMESS('I', 'CATAMESS_70')    # pour u2mesg.f
+    UTMESS('I', 'CATAMESS_89')
+    UTMESS('I', 'CATAMESS_90')
+    UTMESS('I', 'CATAMESS_91')
+    UTMESS('I', 'CATAMESS_92')
+    # appelé par levé d'exception
+    UTMESS('I', 'MISS0_3')
+    UTMESS('I', 'MISS0_5')
+    UTMESS('I', 'MISS0_6')
+    UTMESS('I', 'MISS0_7')
+    UTMESS('I', 'MISS0_8')
+    UTMESS('I', 'MISS0_9')
+    UTMESS('I', 'MISS0_11')
+    UTMESS('I', 'MISS0_17')
+
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/__init__.py b/Aster/Cata/cataSTA10/Utilitai/__init__.py
new file mode 100644 (file)
index 0000000..b51eff5
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/__init__.py
@@ -0,0 +1,21 @@
+#@ MODIF __init__ Utilitai  DATE 20/09/2004   AUTEUR DURAND C.DURAND 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/as_timer.py b/Aster/Cata/cataSTA10/Utilitai/as_timer.py
new file mode 100644 (file)
index 0000000..90d0701
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/as_timer.py
@@ -0,0 +1,272 @@
+#@ MODIF as_timer Utilitai  DATE 05/09/2008   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+"""
+   Definition of ASTER_TIMER class.
+"""
+
+__revision__ = "$Id: as_timer.py 3312 2008-06-06 12:42:58Z courtois $"
+
+# ----- differ messages translation
+def _(mesg):
+   return mesg
+
+import os
+import time
+
+#-------------------------------------------------------------------------------
+def _dtimes():
+   """Returns a dict of cpu, system and total times.
+   """
+   l_t = os.times()
+   return { 'cpu'   : (l_t[0], l_t[2]),
+            'sys'   : (l_t[1], l_t[3]),
+            'tot'   : l_t[4], }
+
+#-------------------------------------------------------------------------------
+def _conv_hms(t):
+   """Convert a number of seconds in hours, minutes, seconds.
+   """
+   h = int(t/3600)
+   m = int(t % 3600)/60
+   s = (t % 3600) % 60
+   return h, m, s
+
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+class ASTER_TIMER:
+   """This class provides methods to easily measure time spent during
+   different steps.
+   Methods :
+      Start : start a timer in mode 'INIT' ([re]start from 0) or 'CONT'
+         (restart from last value).
+      Stop  : stop a timer
+   Attributes :
+      timers : dict {
+         timer_id : {
+            'name'   : timer legend (=timer_id by default),
+            'state'  : state,
+            'cpu_t0' : initial cpu time,
+            'cpu_dt' : spent cpu time,
+            'sys_t0' : initial system time,
+            'sys_dt' : spent system time,
+            'tot_t0' : start time,
+            'tot_dt' : total spent time,
+            'num'    : timer number (to print timers in order of creation),
+            'hide'   : boolean,
+         },
+         ...
+      }
+         state is one of 'start', 'stop'
+   """
+   MaxNumTimer = 9999999
+
+#-------------------------------------------------------------------------------
+   def __init__(self, add_total=True, format='as_run'):
+      """Constructor
+      """
+      # ----- initialisation
+      self.timers = {}
+      self.add_total = add_total
+      
+      if not format in ('as_run', 'aster'):
+         format = 'as_run'
+      
+      if format == 'as_run':
+         self.fmtlig = '   %(name)-33s  %(cpu_dt)9.2f  %(sys_dt)9.2f  %(cpu_sys)9.2f  %(tot_dt)9.2f'
+         self.fmtstr = '   %(title)-33s  %(cpu)9s  %(sys)9s  %(cpu+sys)9s  %(elapsed)9s'
+         self.sepa   = ' ' + '-'*81
+         self.TotalKey = _('Total time')
+         self.d_labels = {
+            'title'   : '',
+            'cpu'     : _('cpu'),
+            'sys'     : _('system'),
+            'cpu+sys' : _('cpu+sys'),
+            'elapsed' : _('elapsed'),
+         }
+      elif format == 'aster':
+         self.fmtlig = ' * %(name)-24s : %(cpu_dt)10.2f : %(sys_dt)10.2f : %(cpu_sys)10.2f : %(tot_dt)10.2f *'
+         self.fmtstr = ' * %(title)-24s : %(cpu)10s : %(sys)10s : %(cpu+sys)10s : %(elapsed)10s *'
+         self.sepa   = ' ' + '*'*80
+         self.TotalKey = 'TOTAL_JOB'
+         self.d_labels = {
+            'title'   : 'COMMAND',
+            'cpu'     : 'USER',
+            'sys'     : 'SYSTEM',
+            'cpu+sys' : 'USER+SYS',
+            'elapsed' : 'ELAPSED',
+         }      
+      
+      self.total_key = id(self)
+      if self.add_total:
+         self.Start(self.total_key, name=self.TotalKey, num=self.MaxNumTimer)
+
+#-------------------------------------------------------------------------------
+   def Start(self, timer, mode='CONT', num=None, hide=None, name=None):
+      """Start a new timer or restart one
+      """
+      name = name or str(timer)
+      isnew = self.timers.get(timer) is None
+      if not num:
+         num = len(self.timers)
+      if mode == 'INIT':
+         num = self.timers[timer]['num']
+      dico = _dtimes()
+      if isnew or mode == 'INIT':
+         self.timers[timer] = {
+            'name'   : name,
+            'state'  : 'start',
+            'cpu_t0' : dico['cpu'],
+            'cpu_dt' : 0.,
+            'sys_t0' : dico['sys'],
+            'sys_dt' : 0.,
+            'tot_t0' : dico['tot'],
+            'tot_dt' : 0.,
+            'num'    : num,
+            'hide'   : hide,
+         }
+      elif mode == 'CONT' and self.timers[timer]['state'] == 'stop':
+         self.timers[timer].update({
+            'state'  : 'start',
+            'cpu_t0' : dico['cpu'],
+            'sys_t0' : dico['sys'],
+            'tot_t0' : dico['tot'],
+         })
+
+#-------------------------------------------------------------------------------
+   def Add(self, timer, cpu_dt=0., sys_dt=0., to_total=False):
+      """Add dt values (hidden to os.times, for example under mpirun) to a timer.
+      """
+      if self.timers.get(timer) is not None:
+         self.timers[timer]['cpu_dt'] += cpu_dt
+         self.timers[timer]['sys_dt'] += sys_dt
+      if to_total and timer != self.total_key:
+         self.Add(self.total_key, cpu_dt, sys_dt)
+      
+#-------------------------------------------------------------------------------
+   def Stop(self, timer, hide=None):
+      """Stop a timer
+      """
+      if self.timers.get(timer) is None:
+         self.timers[timer] = {
+            'name'   : str(timer),
+            'hide'   : hide,
+            'state'  : 'stop',
+            'cpu_t0' : 0.,
+            'cpu_dt' : 0.,
+            'sys_t0' : 0.,
+            'sys_dt' : 0.,
+            'tot_t0' : 0.,
+            'tot_dt' : 0.,
+            'num': len(self.timers),
+         }
+      elif self.timers[timer]['state'] == 'start':
+         dico = _dtimes()
+         self.timers[timer]['state'] = 'stop'
+         for i in range(len(dico['cpu'])):
+            self.timers[timer]['cpu_dt'] += \
+               dico['cpu'][i] - self.timers[timer]['cpu_t0'][i]
+         self.timers[timer]['cpu_t0'] = dico['cpu']
+         for i in range(len(dico['sys'])):
+            self.timers[timer]['sys_dt'] += \
+               dico['sys'][i] - self.timers[timer]['sys_t0'][i]
+         self.timers[timer]['sys_t0'] = dico['sys']
+         self.timers[timer]['tot_dt'] = self.timers[timer]['tot_dt'] + \
+               dico['tot'] - self.timers[timer]['tot_t0']
+         self.timers[timer]['tot_t0'] = dico['tot']
+         if hide is not None:
+            self.timers[timer]['hide'] = hide
+
+#-------------------------------------------------------------------------------
+   def StopAndGet(self, timer, *args, **kwargs):
+      """Stop a timer and return "delta" values.
+      """
+      self.Stop(timer, *args, **kwargs)
+      cpu_dt  = self.timers[timer]['cpu_dt']
+      sys_dt  = self.timers[timer]['sys_dt']
+      tot_dt  = self.timers[timer]['tot_dt']
+      return cpu_dt, sys_dt, tot_dt
+
+#-------------------------------------------------------------------------------
+   def StopAndGetTotal(self):
+      """Stop the timer and return total "delta" values.
+      """
+      return self.StopAndGet(self.total_key)
+
+#-------------------------------------------------------------------------------
+   def getsortedtimers(self):
+      """Return timers list sorted by timer number.
+      """
+      lnum = [[timer['num'], timer] for timer in self.timers.values() if timer['hide'] is not True]
+      lnum.sort()
+      return lnum
+
+#-------------------------------------------------------------------------------
+   def StopAll(self):
+      """Stop all timers
+      """
+      lk = self.timers.keys()
+      if self.add_total:
+         lk.remove(self.total_key)
+      for timer in lk:
+         self.Stop(timer)
+
+#-------------------------------------------------------------------------------
+   def __repr__(self):
+      """Pretty print content of the timer.
+      NB : call automatically StopAll
+      """
+      self.StopAll()
+      if self.add_total:
+         self.Stop(self.total_key)
+      
+      labels = self.fmtstr % self.d_labels
+      out = ['']
+      # get timers list and sort by 'num'
+      lnum = self.getsortedtimers()
+      if lnum:
+         out.append(self.sepa)
+         if self.add_total and labels:
+            out.append(labels)
+            out.append(self.sepa)
+      for num, timer in lnum:
+         d_info = timer.copy()
+         d_info['cpu_sys'] = d_info['cpu_dt'] + d_info['sys_dt']
+         if self.add_total and num == self.MaxNumTimer and len(lnum)>1:
+            out.append(self.sepa)
+         out.append(self.fmtlig % d_info)
+      if lnum:
+         out.append(self.sepa)
+      out.append('')
+      return os.linesep.join(out)
+
+#-------------------------------------------------------------------------------
+if __name__ == '__main__':
+   chrono = ASTER_TIMER(format='aster')
+   chrono.Start('Compilation')
+   chrono.Start('CALC_FONCTION')
+   chrono.Start(23, name='CALC_FONCTION')
+   time.sleep(0.4)
+   chrono.Stop('Compilation')
+   chrono.Stop(23)
+   chrono.Start('Child')
+   print chrono

diff --git a/Aster/Cata/cataSTA10/Utilitai/courbes.py b/Aster/Cata/cataSTA10/Utilitai/courbes.py
new file mode 100644 (file)
index 0000000..5f8f66a
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/courbes.py
@@ -0,0 +1,135 @@
+#@ MODIF courbes Utilitai  DATE 14/09/2004   AUTEUR MCOURTOI M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+#==================================================
+# fonction "COURBES"
+# usage : permet de tracer des courbes en interactif
+# avec XMGRACE ou dans un fichier postscript
+#==================================================
+
+import Stanley
+from Stanley import xmgrace
+from Stanley import as_courbes
+
+def COURBES(listcourb,titre=' ',soustitre=' ',legx=' ',legy=' ',bornex=None,borney=None,fichier=None):
+
+# ARGUMENTS 
+
+# listcourb : tuple de courbes, chaque courbe etant definie soit par 
+#             (TABLE1, NOM_PARA_X, TABLE2, NOM_PARA_Y, LEGENDE)
+# soit par :
+#             (FONCTION,LEGENDE)
+# titre et sous_titre : facultatifs, titre et sous-tritre du graphique
+# legx, legy          : facultatifs, legendes des axes
+# bornex, borney      : facultatifs, bornes sur les axes
+# fichier             : facultatif : sortie au format postscript si present
+#
+# exemples  d'appel :
+#--------------------
+# courb1=(SYYPRT,'ABSC_CURV',SYYPRT,'SIYY','PRT')
+# courb2=(SYYMLC10,'ABSC_CURV',SYYMLC10,'SIYY','MLC10')
+# courb3=(SYYML100,'ABSC_CURV',SYYML100,'SIYY','MLC100')
+# listcourb=(courb1,courb2,courb3)
+# COURBES(listcourb,titre='Plaque trouee',legx='Abcisses curvilignes',legy='Contraintes (MPa)',bornex=(0,100),borney=(500,1000))
+# fonc1=(F1,'F_PRT')
+# fonc2=(F2,'F_MLC10')
+# fonc3=(F3,'F_MLC100')
+# listfonc=(fonc1,fonc2,fonc3)
+# COURBES(listfonc,titre='Fonctions')
+# postscript
+# COURBES(listfonc,titre='Plaque trouee',fichier='./fort.24')
+#--------------------------------------------------------------
+
+# initialisation du trace de  courbes
+
+  if (fichier!=None):
+     graphe=xmgrace.Xmgr(10,' -hardcopy -nosafe')
+     print "Nombre de courbes  ",len(listcourb)," sur le fichier :",fichier
+
+  else:
+     graphe=xmgrace.Xmgr(10,' -noask')
+     print "Nombre de courbes  ",len(listcourb)
+
+  graphe.Nouveau_graphe()
+
+# dimensionnement des axes 
+  if bornex != None : 
+     xmin=list(bornex)[0]
+     xmax=list(bornex)[1]
+     ctest1 = as_courbes.Courbe()
+     ctest1.x=[xmin,xmax]
+     ctest1.y=[0.0,0.0]
+     graphe.Courbe(ctest1)
+
+  if borney != None : 
+     ymin=list(borney)[0]
+     ymax=list(borney)[1]
+     ctest2 = as_courbes.Courbe()
+     ctest2.x=[0.0,0.0]
+     ctest2.y=[ymin,ymax]
+     graphe.Courbe(ctest2)
+
+  if titre != None :
+     if soustitre != None :
+        graphe.Titre(titre,soustitre)
+     else :
+        graphe.Titre(titre,' ')
+     
+  if legx != None :
+     graphe.Axe_x(legx)
+     
+  if legy != None :
+     graphe.Axe_y(legy)
+
+  k = 0
+       
+  for courbi in listcourb:
+     sigi = as_courbes.Courbe()
+     
+     try :
+        # cas d une table
+        sigi.Lire_x(courbi[0],courbi[1])
+        sigi.Lire_y(courbi[2],courbi[3])
+        legende=courbi[4]
+     except :
+        # cas d une fonction
+        sigi.x,sigi.y=courbi[0].Valeurs()
+        legende=courbi[1]
+
+     graphe.Courbe(sigi,legende)
+     graphe.Send('WITH G'+repr(graphe.gr_act))
+     graphe.Send('S' + str(k) + ' SYMBOL ' + str(k+2))
+     graphe.Send('S' + str(k) + ' SYMBOL SIZE 0.5')
+     graphe.Send('S' + str(k) + ' SYMBOL COLOR '+str(k+2))
+     graphe.Send('S' + str(k) + ' LINE COLOR '+str(k+2))
+     k = k + 1
+     graphe.Send('REDRAW')
+  
+  if (fichier!=None):
+     graphe.Sortie_EPS(fichier)
+     graphe.Fermer()
+  else:
+     graphe.Attendre()
+
+  k=0
+
+#===========================================
+
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/funct_root.py b/Aster/Cata/cataSTA10/Utilitai/funct_root.py
new file mode 100644 (file)
index 0000000..da488cf
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/funct_root.py
@@ -0,0 +1,95 @@
+#@ MODIF funct_root Utilitai  DATE 14/09/2004   AUTEUR MCOURTOI M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+################################################################################
+#       Mathematical utility routines
+#       Copyright (C) 1999, Wesley Phoa
+#
+#       Reference: Numerical Recipes in C
+#       [[[[extraits]]]]
+
+class BracketingException(Exception):
+        pass
+
+class RootFindingException(Exception):
+        pass
+
+class MinimizationException(Exception):
+        pass
+
+GOLDEN = (1+5**.5)/2
+
+# 
+# MISCELLANEOUS
+#
+
+def sgn(x):
+        if x==0:
+                return 0
+        else:
+                return x/abs(x)
+
+#
+# UNIVARIATE ROOT FINDING
+#
+
+def bracket_root(f, interval, max_iterations=50):
+        """\
+Given a univariate function f and a tuple interval=(x1,x2),
+return a new tuple (bracket, fnvals) where bracket=(x1,x2)
+brackets a root of f and fnvals=(f(x1),f(x2)).
+        """
+        x1, x2 = interval
+        if x1==x2:
+                 raise BracketingException("initial interval has zero width")
+        elif x2<x1:
+                x1, x2 = x2, x1
+        f1, f2 = f(x1), f(x2)
+        for j in range(max_iterations):
+                while f1*f2 >= 0:  # not currently bracketed
+                        if abs(f1)<abs(f2):
+                                x1 = x1 + GOLDEN*(x1-x2)
+                        else:
+                                x2 = x2 + GOLDEN*(x2-x1)
+                        f1, f2 = f(x1), f(x2)
+                return (x1, x2), (f1, f2)
+        raise BracketingException("too many iterations")
+
+def ridder_root(f, bracket, fnvals=None, accuracy=1e-6, max_iterations=50):
+        """\
+Given a univariate function f and a tuple bracket=(x1,x2) bracketing a root,
+find a root x of f using Ridder s method. Parameter fnvals=(f(x1),f(x2)) is optional.
+        """
+        x1, x2 = bracket
+        if fnvals==None:
+                f1, f2 = f(x1), f(x2)
+        else:
+                f1, f2 = fnvals
+        if f1==0:
+                return x1
+        elif f2==0:
+                return x2
+        elif f1*f2>=0:
+                raise BracketingException("initial interval does not bracket a root")
+        x4 = 123456789.
+        for j in range(max_iterations):
+                x3 = (x1+x2)/2
+                f3 = f(x3)
+                temp = f3*f3 - f1*f2
+                x4, x4old = x3 + (x3-x1)*sgn(f1-f2)*f3/temp**.5, x4
+                f4 = f(x4)
+                if f1*f4<0:  # x1 and x4 bracket root
+                        x2, f2 = x4, f4
+                else:  # x4 and x2 bracket root
+                        x1, f1 = x4, f4
+                if min(abs(x1-x2),abs(x4-x4old))<accuracy or temp==0:
+                        return x4
+        raise RootFindingException("too many iterations")
+
+def root(f, interval=(0.,1.), accuracy=1e-4, max_iterations=50):
+        """\
+Given a univariate function f and an optional interval (x1,x2),
+find a root of f using bracket_root and ridder_root.
+        """
+        bracket, fnvals = bracket_root(f, interval, max_iterations)
+        return ridder_root(f, bracket, fnvals, accuracy, max_iterations)
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/liss_enveloppe.py b/Aster/Cata/cataSTA10/Utilitai/liss_enveloppe.py
new file mode 100644 (file)
index 0000000..0545b1d
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/liss_enveloppe.py
@@ -0,0 +1,931 @@
+#@ MODIF liss_enveloppe Utilitai  DATE 29/08/2005   AUTEUR THOMASSO D.THOMASSON 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2005  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+"""
+    Maquette demande SEPTEN fonction de lissage enveloppe
+    Les données se présentent sous la forme d'un fichier texte comportant
+    un ensemble de groupe de lignes organisé comme suit :
+        - ligne 1 : Informations générales
+        - ligne 2 : une liste de valeur d'amortissement
+        - lignes 3...n : une liste de valeur commencant par une frequence suivit 
+                         des amplitudes du spectre pour chacun des amortissements
+                         liste en ligne 2
+    Points importants :
+        - Le nombre de lignes définissant le spectre peut varier
+        - Le nombre de valeur d'amortissement peut varier ?
+
+    ==> On propose d'opérer ligne par ligne
+    ==> L'absence d'informations sur la variabilité du nombre d'éléments oblige à traiter le cas général
+
+        
+
+    Etapes du développement :
+        24/05/2005 : Test de lecture du fichier, choix d'une stratégie de gestion
+        25/05/2005 : Objet itérable pour la  lecture du fichier
+        29/05/2005 : Créations de filtres pour les spectres
+"""
+
+import math
+
+def nearestKeys(k1, dct) :
+    """
+        retourne les clés (doublet) les plus proches de 'key' dans le dictionnaire dct
+        par valeur inférieure et supérieures
+    """
+    kr = min(dct.keys())
+    for k2 in dct.keys() :
+        if (k2<k1) and (k2>kr) : kr = k2 
+    kinf = kr
+
+    kr = max(dct.keys())
+    for k2 in dct.keys() :
+        if (k2>k1) and (k2<kr) : kr = k2
+    ksup = kr
+
+    return (kinf, ksup)
+
+def interpole(x2, x0, y0, x1, y1) :
+    """
+        renvoie la valeur pour x2 interpolée (linéairement) entre x0 et x1  
+    """
+    try : 
+        a = (y1-y0) / (x1-x0)
+    except ZeroDivisionError :
+        return y0
+
+    return a * (x2-x0) + y0
+
+
+def listToDict(lst) :
+    """
+        Cette fonction recoit une liste et la transforme en un dictionnaire 
+    """
+    dctRes = {}
+    for val in lst :
+        dctRes[val] = True
+    return dctRes
+
+def inclus(l1, l2) :
+    """
+        Teste si une liste (lst1) est incluse dans une autre (lst2)
+        Renvoie le premier élément de l1 qui n'est pas inclus ou None si l1 inclus dans l2)
+    """
+    for v in l1 :
+        try :
+            l2.index(v)
+        except ValueError :
+            return v
+    return None
+
+def exclus(i1, i2) :
+    """
+        Teste si deux listes ne partagent pas d'élément commun
+        Renvoie le premier élément de l1 qui n'est pas exclus ou None si l1 exclus de l2)
+    """
+    for v in i1 :
+        try :
+            i2.index(v)
+            return v
+        except ValueError :
+            continue
+    return None
+        
+class NappeCreationError(Exception) :
+    def __init__(self) :
+        self.mess = "Un problème est survenu lors dla création d'une nappe"
+        self.otherExcept = Exception()
+        
+    def getMess(self) :
+        """ Retourne le message associé à l'erreur """
+        # Analyse les différents cas d'erreurs
+        if self.otherExcept == IOError :
+            self.mess += "\nProblème à l'ouverture du fichier\n"
+
+        return self.mess
+    
+class SpectreError(Exception) :
+    def __init__(self) :
+        self.mess = "Un problème est survenu lors de la construction du spectre"
+        self.otherExcept = Exception()
+        
+    def getMess(self) :
+        """ Retourne le message associé à l'erreur """
+        # Analyse les différents cas d'erreurs
+        if self.otherExcept == IOError :
+            self.mess += "\nProblème à l'ouverture du fichier\n"
+
+        return self.mess
+    
+class filtre :
+    """
+        La classe filtre est la classe de base des filtres applicables au spectre
+        Elle possède une fonction privée filtre qui prend un spectre en entrée et qui
+        retourne un spectre filtré en sortie et qui est appelée par la fonction __call__
+    """
+    def __init__(self): pass
+    def __call__(self, sp) :
+        return self._filtre(sp)
+
+    def _filtre(self, sp) :
+        spr = sp
+        return spr # la fonction filtre de la classe de base retourne le spectre sans le modifier
+
+class filtreExpand(filtre) :
+    """ effectue l'expansion du spectre selon spécif du SEPTEN """
+    def __init__(self, **listOpt) :
+        try :
+            self.expandCoef = listOpt['coef']
+        except KeyError :
+            self.expandCoef = 0.1
+       
+    def _filtre(self, sp) :
+        spLower = spectre()
+        spUpper = spectre()
+        # Etape 1 : Construction du spectre inférieur sans considération des échelons de fréquence
+        for i in range(0, len(sp.listFreq)) :
+            spLower.listFreq = spLower.listFreq + [sp.listFreq[i] - abs(sp.listFreq[i]*self.expandCoef)]
+            spLower.dataVal = spLower.dataVal + [sp.dataVal[i]]
+            spUpper.listFreq = spUpper.listFreq + [sp.listFreq[i] + abs(sp.listFreq[i]*self.expandCoef)]
+            spUpper.dataVal = spUpper.dataVal + [sp.dataVal[i]]
+
+
+        # Etape 2 : Construction du spectre "élargi" sur la base de fréquence du spectre initial
+        #           On tronque en deca de la fréquence minimale du spectre de référence
+        index = 0
+        while spLower.listFreq[index] < sp.listFreq[0] : index+=1
+            
+        # Recopie des valeurs à conserver
+        spLower.dataVal = spLower.dataVal[index:]
+
+        index = 0
+        while spUpper.listFreq[index] < sp.listFreq[len(sp.listFreq)-1] : index+=1
+            
+        # Recopie des valeurs à conserver
+        spUpper.dataVal = spUpper.dataVal[0:index]
+        # calcul du nombre d'éléments à rajouter
+        nb = len(sp.dataVal) - index
+        #Décalage le la liste de nb elements
+        for i in range(0, nb) : spUpper.dataVal.insert(0,-1.0e6)
+
+        #On remplace la base de fréquence 'décalée' de lower et upper par la base de fréquence 'standard'
+        spLower.listFreq = sp.listFreq
+        spUpper.listFreq = sp.listFreq
+
+        return self._selectVal(spLower, sp, spUpper)
+
+    def _selectVal(self,spLower, sp, spUpper) :
+        spr = sp
+        for i in range(0, len(sp.listFreq)) :
+            try :
+                v1 = spLower.dataVal[i]
+            except IndexError :
+                v1 = -200.0
+            try :
+                v2 = sp.dataVal[i]
+            except IndexError :
+                v2 = -200.0
+            try :
+                v3 = spUpper.dataVal[i]
+            except IndexError :
+                v3 = -200.0
+
+            spr.dataVal[i] = max([v1,v2,v3])
+
+        return spr
+    
+class filtreLog(filtre) :
+    """
+        Convertit un spectre en LogLog (log base 10)
+            + Possibilité d'obtenir un linLog (abcsisses linéaires, ordonnées en log)
+            + Possibilité d'obtenir un logLin (abcsisses log, ordonnées en linéaires) 
+    """
+    def __init__(self, **listOpt) :
+        try :
+            self.logAbc = listOpt['logAbc']
+        except KeyError :
+            self.logAbc = True
+        try :
+            self.logOrd = listOpt['logOrd']
+        except KeyError :
+            self.logOrd = True
+
+    def _filtre(self, sp) :
+        spr = spectre()
+        if self.logAbc :
+            spr.listFreq = [math.log10(i) for i in sp.listFreq]
+        else :
+            spr.listFreq = [i for i in sp.listFreq]
+        if self.logOrd :
+            spr.dataVal  = [math.log10(i) for i in sp.dataVal]
+        else :
+            spr.dataVal  = [i for i in sp.dataVal]
+            
+        return spr
+
+class filtreLin(filtre) :
+    """
+        Convertit un spectre en LinLin (10^n) à partir d'un spectre en linLog,LogLin ou logLog
+    """
+    def __init__(self, **listOpt) :
+        try :
+            self.logAbc = listOpt['logAbc']
+        except KeyError :
+            self.logAbc = True
+        try :
+            self.logOrd = listOpt['logOrd']
+        except KeyError :
+            self.logOrd = True
+
+    def _filtre(self, sp) :
+        spr = spectre()
+        if self.logAbc :
+            spr.listFreq = [10**i for i in sp.listFreq]
+        else :
+            spr.listFreq = [i for i in sp.listFreq]
+        if self.logOrd :
+            spr.dataVal  = [10**i for i in sp.dataVal]
+        else :
+            spr.dataVal  = [i for i in sp.dataVal]
+            
+        return spr
+        
+class filtreBandWidth(filtre) :
+    def __init__(self, **listOpt) :
+        try :
+            self.lowerBound = listOpt['lower']
+        except KeyError :
+            self.lowerBound = 0.2
+        try :
+            self.upperBound = listOpt['upper']
+        except KeyError :
+            self.upperBound = 35.5
+
+    def _filtre(self, sp) :
+        spr = sp
+        toDel = []
+        for i in range(0, len(spr.listFreq)) :
+            if spr.listFreq[i] > self.upperBound :
+                toDel = toDel + [i]
+
+        # Nettoyage des fréquences à suppimer (on commence par les plus hautes)
+        for i in toDel[::-1] :
+            del spr.listFreq[i]
+            del spr.dataVal[i]
+
+        toDel = []
+        for i in range(0, len(spr.listFreq)) :
+            if spr.listFreq[i] < self.lowerBound :
+                toDel = toDel + [i]
+            else :
+                break
+
+        # Nettoyage des fréquences à suppimer (on finit par les plus basses)
+        for i in toDel[::-1] :
+            del spr.listFreq[i]
+            del spr.dataVal[i]
+             
+        return spr
+
+class filtreCrible(filtre):
+    """
+        Criblage du spectre selon specif SEPTEN §C-5 (ce que j'en comprend)
+    """
+    def __init__(self, **listOpt):
+        try :
+            self.tolerance = listOpt['tolerance']
+        except KeyError :
+            self.tolerance = 0.25
+
+        self.listEtats = []
+
+    def _filtre(self, sp) :
+            self._initListeEtats(sp) # Création de la table des étsts des valeurs du spectre
+            coef = 1
+
+            # Parcours de la liste des fréquences
+            i1, i2, i3 = 0, 2, 1
+            bTest = True
+            while True :
+                try :
+                    bTest = self._amplitude(sp, i1, i2, i3, coef)
+                    if not(bTest) and ((i2-i1) > 2) :
+                        # Le point a été éliminé, on réexamine le point précédent sauf si c'est le premier examiné
+                        i3 -= 1
+                        if self._amplitude(sp, i1, i2, i3, coef) :
+                            # Le point a été "récupéré", il devient la nouvelle origine
+                            i1 = i3
+                            i2 = i2 # écrit quand meme pour la compréhension
+                            i3 += 1
+                        else :
+                            # Le point reste désactivé, on avance au point suivant, le point d'origine est conservé
+                            i1 = i1
+                            i2 += 1
+                            i3 += 2
+                    elif not(bTest) and not((i2-i1) > 2) :
+                        i1 = i1
+                        i2 += 1
+                        i3 += 1
+                    else : # Le point est conservé, il devient la nouvelle origine
+                        i1 = i3
+                        i2 += 1
+                        i3 += 1
+                except IndexError : 
+                    break
+
+            return self._crible(sp)
+
+    def _initListeEtats(self, sp) :
+        """
+            Crée une liste associant à chaque fréquence du spectre passé en paramètre, un état booléen
+            qui spécifie si ce couple fréquence-valeur est supprimé ou pas
+            NB : au départ toutes les valeur sont "True" car aucune valeur n'a été supprimée
+        """
+        self.listEtats = [True for x in sp.listFreq]
+
+    def _crible(self, sp) :
+        """
+            Supprime les points de fréquence qui sont marqué False dans listEtats
+        """
+        sp2 = spectre([], []) # On force car il y a un problème de persistance su spectre précédent
+        for x,y,z in zip(self.listEtats, sp.listFreq, sp.dataVal) :
+            if x :
+                sp2.listFreq.append(y)
+                sp2.dataVal.append(z)
+                
+        return sp2
+
+    def _amplitude(self, sp, id1, id2, id3, coef=1) :
+        """
+            teste le point d'indice id3 par rapport aux points à sa gauche(p1 d'indice id1) et 
+            à sa droite (p2 d'indice id2).
+            Le point est éliminé si sa valeur est en dessous de la droite reliant les points
+            d'indice id1 et id2 sauf si sa distance à cette droite est supérieure à :
+                tolerance*ordonnée
+            Le critère est purement sur l'amplitude du point indépendemment de l'intervalle
+            sur lequel il s'applique
+        """
+        x0 = sp.listFreq[id1]
+        y0 = sp.dataVal[id1]
+        x1 = sp.listFreq[id2]
+        y1 = sp.dataVal[id2]
+        x2 = sp.listFreq[id3]
+        y2 = sp.dataVal[id3]
+
+        yp2 = interpole(x2, x0, y0, x1, y1)
+        
+        # Le point est il susceptible d'etre supprimé (est il en dessous de la droite p1-p2 ?)
+        # Faut-il le supprimer pour autant (distance y2 à yp2 > tolerance% de y2)
+        bSup = not((y2 < yp2) and (abs(yp2-y2)/y2 < self.tolerance))
+
+        # Changement de l'état du point
+        self.listEtats[id3] = bSup
+
+        return bSup
+
+class filtreChevauchement(filtre):
+    """
+        Compare un spectre à un spectre de référence fréquence par fréquence.
+        Si une fréquence n'existe pas, on cherche la valeur équivalent par interpolation
+        Pour éviter tout recouvrement, il est éventuellement nécessaire de rajouter
+        des informations à certaines fréquences
+    """
+    def __init__(self, **listOpt) :
+        try :
+            self.spRef = listOpt['ref']
+        except KeyError :
+            self.spRef = spectre()
+
+        try :
+            signe = listOpt['ordre']
+            self.ordre = signe/abs(signe) #coefficient +1 ou -1
+        except KeyError :
+            self.ordre = +1
+        except ZeroDivisionError :
+            self.ordre = +1
+
+    def _filtre(self, sp) :
+        spDict = sp.buildMap()
+        spRefDict = self.spRef.buildMap()
+        spTestDict = {}
+
+        # On commence par construire un dictionnaire des valeurs à tester comportant toutes les clés contenues
+        for k in spDict.keys() : spTestDict[k] = True
+        for k in spRefDict.keys() : spTestDict[k] = True
+
+        # On teste ensuite toutes les valeurs du dictionnaire
+        for k in spTestDict.keys() :
+            # Test d'existence dans le dictionnaire du spectre de référence
+            try :
+                vr = spRefDict[k]
+            except KeyError :
+                ki = nearestKeys(k, spRefDict)
+                vr = interpole(k, ki[0], spRefDict[ki[0]], ki[1], spRefDict[ki[1]])
+            # Test d'existence dans le dictionnaire du spectre à tester
+            try :
+                vt = spDict[k]
+            except KeyError :
+                ki = nearestKeys(k, spDict)
+                vt = interpole(k, ki[0], spDict[ki[0]], ki[1], spDict[ki[1]])
+
+            # Comparaison des deux valeurs. La clé est ajoutée si elle n'existe pas
+            if vt*self.ordre < vr*self.ordre : spDict[k] = vr
+
+        return spectre.sortSpectre(spDict)
+
+class spectre :
+    """
+        décrit un spectre composé d'un ensemble de résultat associé à un ensemble de fréquence
+    """
+    def __init__(self, listFreq = [], dataVal = []) :
+        self.listFreq = [v for v in listFreq]
+        self.dataVal  = [v for v in dataVal]
+
+    def filtre(self, fi) :
+        """
+        Applique le filtre passé en paramètre au spectre et retourne un nouveau spectre
+        """
+        return fi(self)
+    
+    def __staticSortSpectre(dict) :
+        """
+            Convertit un spectre présenté sous forme d'un dictionnaire en un spectre normal
+            Fonction créé parceque les clés du dictionnaire ne sont pas ordonnées
+        """
+        lstFrq = dict.keys()
+        lstFrq.sort()
+        lstVal = []
+        for fr in lstFrq :
+            try :
+                lstVal.append(dict[fr])
+            except KeyError : # Ne devrait jamais arriver
+                lstVal.append(-1E15)
+
+        return spectre(lstFrq, lstVal)
+    
+    sortSpectre = staticmethod(__staticSortSpectre) # définition en tant que méthode statique
+
+    def getCoupleVal(self,indice) :
+        return (self.listFreq[indice], self.dataVal[indice])
+    
+    def moyenne(self) :
+        """
+            Calcule la moyenne pondéré : somme(An* dfn) /F
+        """
+        somme = 0.0
+        X0 = self.listFreq[0]
+        X1 = self.listFreq[len(self.listFreq)-1]
+        for i in range(0,len(self.listFreq)-1) :
+            x0 = self.listFreq[i]
+            y0 = self.dataVal[i]
+            x1 = self.listFreq[i+1]
+            y1 = self.dataVal[i+1]
+            
+            somme = somme + (y0+y1) * abs(x1-x0) / 2
+
+        return somme/abs(X1-X0)
+
+    def seuil(self, limit=75) :
+        """
+            retourne un couple d'index délimitant l'ensemble des valeurs du spectre
+            définissant "limit" pourcent du total cumulé des valeurs
+            [borne à gauche inclue, borne à droite exclue[
+            ATTENTION on fait l'hypothèse que le spectre a une forme en cloche.
+        """
+        resu = [0 for v in self.dataVal] # initialisation du tableau resultat
+
+        maxi = max(self.dataVal) # Valeur maxu du spectre
+        iMaxi = self.dataVal.index(maxi) # Index de la valeur max du spectre
+
+        # ETAPE 1 : SOMMATION
+        somme = 0.0
+        for v, i in zip(self.dataVal[0:iMaxi], range(0, iMaxi)) :
+            somme = somme + v
+            resu[i] = somme
+
+        somme = 0.0
+        for v, i in zip(self.dataVal[:iMaxi:-1], range(len(self.dataVal)-1, iMaxi, -1)) :
+            somme = somme + v
+            resu[i] = somme
+            
+        resu[iMaxi] = resu[iMaxi-1] + self.dataVal[iMaxi] + resu[iMaxi+1]
+
+        #ETAPE 2 : POURCENTAGE (PAS NECESSAIRE MAIS PLUS LISIBLE)
+        for v, i in zip(self.dataVal[0:iMaxi], range(0, iMaxi)) :
+            resu[i] = (resu[i] + maxi/2) / resu[iMaxi] * 100
+
+        for v, i in zip(self.dataVal[iMaxi+1:], range(iMaxi+1, len(self.dataVal))) :
+            resu[i] = (resu[i] + maxi/2) / resu[iMaxi] * 100
+
+        resu[iMaxi] =  resu[iMaxi-1] + resu[iMaxi+1]
+
+        # ETAPE 3 : RECHERCHE DES BORNES
+        limit = (100.0 - limit) / 2.0
+        b1 = b2 = True
+        for v1, v2 in zip(resu[:], resu[::-1]): # Parcours simultané dans les deux sens
+            if b1 and v1 >= limit : # Borne à gauche trouvée
+                i1 = resu.index(v1)
+                b1 = False
+            if b2 and v2 >= limit : # Borne à droite trouvée
+                i2 = resu.index(v2) + 1 # Borne à droit exclue de l'intervalle
+                b2 = False
+                
+        return (i1, i2)
+        
+    def cut(self, nuplet) :
+        """
+            Découpe un spectre en sous-spectres qui sont retournés en sortie de la fonction
+            sous la forme d'un tableau de spectres
+        """
+        # transformation du nuplet en tableau (permet de lui ajouter un élément)
+        tabNuplet = [v for v in nuplet]
+        tabNuplet.append(len(self.listFreq))
+
+        # Traitement
+        tableRes = list()
+        bGauche = 0
+        for borne in tabNuplet :
+            bDroite = borne
+            sp = spectre()
+            for i in range(bGauche, bDroite) :
+                sp.listFreq.append(self.listFreq[i])
+                sp.dataVal.append(self.dataVal[i])
+
+            tableRes.append(sp)
+            bGauche = bDroite
+
+        return tableRes
+
+    def __staticMerge(tabSpectre) :
+        """
+            A l'inverse de la fonction cut, construit un seul spectre à partir d'un ensemble de spectres
+        """
+        # On vérifie d'abord que les spectres ne partagent pas la meme bande de fréquence (fut ce partiellement)
+        for i in range(0, len(tabSpectre)-1) :
+            if exclus(tabSpectre[i].listFreq, tabSpectre[i+1].listFreq) : raise SpectreError
+        if exclus(tabSpectre[0].listFreq, tabSpectre[len(tabSpectre)-1].listFreq) : raise SpectreError
+
+        spRes = spectre()
+        #cumul des spectres
+        for sp in tabSpectre :
+            for f, v in zip(sp.listFreq, sp.dataVal) :
+                spRes.listFreq.append(f)
+                spRes.dataVal.append(v)
+
+        return spRes
+
+    merge = staticmethod(__staticMerge) # définition en tant que méthode statique
+    
+    def buildMap(self) :
+        """
+            Construit un dictionnaire à partir d'un spectre
+        """
+        dict = {}
+        for i, j in zip(self.listFreq, self.dataVal) :
+            dict[i] = j
+
+        return dict 
+
+class nappe :
+    """
+        décrit un objet nappe qui associe à un ensemble de fréquence à une enesmble de résultats
+    """
+    def __init__(self, listFreq = [], listeTable = [], listAmor = [], entete = ""):
+        self.listFreq = [v for v in listFreq] # recopie physique !
+        self.listTable = [list() for t in listeTable] 
+        for t, st in zip(listeTable, self.listTable) :
+            for v in t  : st.append(v)
+                
+        self.listAmor = [l for l in listAmor]
+        self.entete = entete
+
+    def __staticBuildFromListSpectre(lsp) :
+        """
+            Construction d'une nappe à partir d'une liste de spectres
+        """
+        # On commence par vérifier que toutes les nappes on la meme base de fréquences
+        # A inclus dans B inclus dans C inclus dans .... et DERNIER inclus dans PREMIER ==> tous égaux 
+        for i in range(0,len(lsp.listSp)-1) :
+            if inclus(lsp.listSp[i].listFreq, lsp.listSp[i+1].listFreq) : raise NappeCreationError
+        if inclus(lsp.listSp[i+1].listFreq, lsp.listSp[0].listFreq) : raise NappeCreationError
+
+        # Construction de la nappe à proprement parler
+        listeFreq = [fr for fr in lsp.listSp[0].listFreq]
+        listeTable = [list() for sp in lsp.listSp]
+        for sp, lv in zip(lsp.listSp, listeTable) :
+            for v in sp.dataVal :
+                lv.append(v)
+        return nappe(listeFreq, listeTable, [], 'toto')
+        
+    buildFromListSpectre = staticmethod(__staticBuildFromListSpectre) # définition en tant que méthode statique
+
+    def getNbSpectres(self) :
+        """ Retourne le nombre d'éléments dans la nappe """
+        return len(self.listAmor)
+
+    def getNbFreq(self) :
+        """ Retourne le nombre d'éléments dans chaque spectre """
+        return len(self.listFreq)
+
+    def getSpectre(self, index) :
+        """
+            Retourne le spectre d'indice 'index' dans la nappe
+        """
+        return spectre(self.listFreq, self.listTable[index])
+
+    def filtreDoublons(self):
+        """
+            Supprime bandes de fréquences constantes 
+        """
+        prevCpl = None
+        bCount = False
+        i=0
+        # Recherche des doublons
+        lstBor = list() # Liste de listes de bornes
+        lst = list()
+        for cpl in self.__getListFreq() :
+            if not(prevCpl) :
+                prevCpl = cpl
+                continue
+            bTest = True
+            for v1, v2 in zip(cpl[1], prevCpl[1]) :
+                bTest &= (v1==v2)
+            if bTest and not bCount : # Début d'une suite de valeurs égales
+                bCount = True
+                lst.append(i)
+            elif not bTest and bCount : # Fin d'une suite de valeurs égales
+                bCount = False
+                lst.append(i)
+                lstBor.append(lst)
+                lst = list() # Nouvelle liste
+
+            prevCpl = cpl
+            i += 1
+
+        # Suppression des doublons si plus de deux valeurs
+        for cpl in lstBor :
+            if (cpl[1]-cpl[0]) < 2 : continue
+            for i in range(cpl[1]-1, cpl[0], -1) :
+                del self.listFreq[i]
+                for j in range(0, len(self.listTable)) :
+                    del self.listTable[j][i]
+
+
+            
+
+    def __getListFreq(self) :
+        """
+            Fonction privé qui parcours la matrice ligne par ligne
+            Retourne à chaque itération un couple frequence, liste de valeurs 
+        """
+        fr = 0.0
+
+        for i in range(0, self.getNbFreq()) :
+            fr = self.listFreq[i]
+            listVal = []
+            for j in range(0, len(self.listTable)):
+                listVal.append(self.listTable[j][i])
+            yield (fr, listVal)
+
+        raise StopIteration    
+
+class listSpectre :
+    """
+        classe container d'une liste de spectre ne partageant pas la meme base de fréquence
+        cas des spectres à l'issue de la première passe de l'opération de filtrage d'enveloppe
+    """
+    def __init__(self, *listSp) :
+        self.listSp = []
+        for sp in listSp :
+            self.listSp = sp
+
+    def append(self, spectre) :
+        """ Ajoute un spectre à la liste """
+        self.listSp.append(spectre)
+        
+    def __staticBuildFromNappe(uneNappe) :
+        """
+            Construit une liste de spectres (indépendants) à partir d'une nappe
+        """
+        res = listSpectre()
+        for i in range(0, len(uneNappe.listAmor)) :
+            res.append(uneNappe.getSpectre(i))
+
+        return res
+    
+    buildFromNappe = staticmethod(__staticBuildFromNappe) #Définition en tant que méthode statique
+    
+    def testChevauchement(self) :
+        """
+            Supprime les effets de chevauchement entre les spectres
+        """
+        for i in range(0, len(self.listSp)-1) :
+            filter = filtreChevauchement(ref=self.listSp[i+1])
+            self.listSp[i] = self.listSp[i].filtre(filter)
+
+    def createBase(self, lspRef = None) :
+        """
+            Crée une base de fréquence commune pour l'ensemble des spectres
+            En s'assurant que le l'on reste enveloppe des spectre de la liste lspRef
+        """
+        lspRes = listSpectre([spectre() for sp in self.listSp]) # Liste résultante
+
+        # Recherche des fréquences attribuées à 5 spectres, 4 spectres, ... classées dans un dictionnaire
+        dctOc = self.__sortByOccurence()
+
+        iOcc = max(dctOc.keys())
+        lst = dctOc[iOcc] # On comence par mettre les frequences communes à tous les spectres
+        lst.sort() 
+        iOcc -= 1
+        test = 0
+        while True : 
+            lspRes.__addFreqFromList(self, lst)
+            # On vérifie si on reste enveloppe du spectre initial
+            spTest = spectre()
+            lstComp = list()
+            for sp0, sp1 in zip(lspRes.listSp, self.listSp) :
+                filter = filtreChevauchement(ref=sp1)
+                spTest = sp0.filtre(filter)
+                # Crée une liste des fréquences ajoutées (s'il y en a...)
+                for fr in spTest.listFreq :
+                    try :
+                        idx = sp0.listFreq.index(fr)
+                    except ValueError : # Valeur non trouvée dans le tableau
+                        lstComp.append(fr)
+
+            if len(lstComp) > 0 : # Il est nécessaire de compléter les spectres
+                # on prend de préférence les fréquences définies sur le plus de spectre possible
+                while True :
+                    lstFreq = dctOc[iOcc]
+                    prevLst = lst # On sauvegarde la liste précédente pour comparaison
+                    lst = self.__buildList(lstComp, lstFreq)
+                    if not(inclus(lst, prevLst)) :
+                        iOcc -= 1
+                    else :
+                        break
+                continue
+            else :
+                break # On peut sortir les spectres sont complets
+
+        self.listSp = lspRes.listSp # Remplacement de la liste des spectres
+
+        # On s'assure que le spectre reste enveloppe du spectre de référence rajoute des fréquences si nécessaire
+        # 1. filtre chevauchement
+        if lspRef : # Si une liste de spectre de référence a été définie, on vérifie le caractère enveloppe du résultat
+            listComp = list()
+
+            for sp1, sp2 in zip(self.listSp, lspRef.listSp) :
+                filter = filtreChevauchement(ref=sp2)
+                spTest = sp1.filtre(filter)
+                test = inclus(spTest.listFreq, sp1.listFreq)
+                if test : listComp.append(test)
+            # 3. Complément éventuel de l'ensemble des spectres
+            if listComp : lspRes.__addFreqFromList(self, listComp)
+
+        self.listSp = lspRes.listSp # Remplacement de la liste des spectres
+
+    def filtre(self, filter):
+        """
+            Applique un filtre à l'ensemble des spectres de la liste
+        """
+        self.listSp = [sp.filtre(filter) for sp in self.listSp]
+
+
+    def __sortByOccurence(self) :
+        """
+            Fonction qui trie les fréquences par leur occurence d'apparition dans la liste de spectre
+        """
+        dct = {}
+        for sp in self.listSp : # Boucle sur tous les spectres
+           for fr in sp.listFreq : # Boucle sur toutes les fréquences de chaque spectre
+                try :
+                    dct[fr] += 1
+                except KeyError :
+                    dct[fr] = 1
+
+        # "Inversion" du dictionnaire
+        dctOc = {} # Dictionnaire des occurences
+        for k in dct.keys() :
+            try :
+                dctOc[dct[k]].append(k)
+            except KeyError :
+                dctOc[dct[k]]=[k]
+
+
+        return dctOc
+    
+    def __addFreqFromList(self, lstSp, lstFreq) :
+        """
+            Rajoute les fréquences contenues dans lstFreq aux spectres d'un listeSpectre
+            à partir des spectres fournis par le listeSpectre (lstSp) passé en paramètre
+            en procédant éventuellement à une interpolation linéaire
+        """
+        # Suppression des doublons de la liste des fréquences
+        lstFreq = listToDict(lstFreq).keys() # lst est la liste des points qu'il faudrait ajouter pour rester enveloppe
+        lstFreq.sort()
+        
+        for i in range(0, len(self.listSp)) :
+            # Conversion des spectres en dictionnaire pour pouvoir les traiter
+            spDctSelf = self.listSp[i].buildMap()
+            spDctRef = lstSp.listSp[i].buildMap() 
+            for fr in lstFreq :
+                # On cherche la valeur dans le spectre de référence
+                try :
+                    vr = spDctRef[fr]
+                except KeyError :
+                    ki = nearestKeys(fr, spDctRef)
+                    vr = interpole(fr, ki[0], spDctRef[ki[0]], ki[1], spDctRef[ki[1]])
+
+                # On rajoute la valeur dans le spectre résultat
+                spDctSelf[fr] = vr
+
+            # Conversion du dictionnaire en spectre réel
+            self.listSp[i] = spectre.sortSpectre(spDctSelf)
+            
+    def __buildList(self, lstComp, lstFreq) :
+        """
+            Construit une liste de fréquences à ajouter à partir d'une liste de fréquences
+            à ajouter (listComp) et d'une liste de référence, (listFreq)
+            retourne une liste
+        """
+        lst = list()
+        for fr in lstComp :
+            try :
+                idx = lstFreq.index(fr)
+                lst.append(fr)
+            except ValueError : # Fréquence non présente, recherche de la plus proche 
+                couple = nearestKeys(fr, listToDict(lstFreq))
+                if abs(couple[0]-fr) > abs(couple[1]-fr) :
+                    lst.append(couple[1])
+                else :
+                    lst.append(couple[0])
+
+        lst = listToDict(lst).keys() # Suppression des doublons
+        lst.sort()
+        return lst
+        
+      
+def lissage(nappe=nappe,fmin=0.2,fmax=35.5,elarg=0.1,tole_liss=0.25) :
+    resultat = listSpectre() # Le résultat sera contenu dans une liste de spectre
+    lspBrut = listSpectre.buildFromNappe(nappe)
+    # Passage en LogLog
+    lspBrut.filtre(filtreLog())
+    for j in range(0,nappe.getNbSpectres()) :
+        # Spectre brut
+        sp = nappe.getSpectre(j)
+        # Limitation de la bande de fréquence
+        filter = filtreBandWidth(lower=fmin, upper=fmax)
+        sp = sp.filtre(filter)
+        # Expansion du spectre
+        filter = filtreExpand(coef=elarg)
+        sp = sp.filtre(filter)
+        # Passage en LogLin
+        filter = filtreLog(logOrd=False)
+        sp = sp.filtre(filter)
+        # éclatement du spectre en 3 sous-parties
+        tabSpectre = sp.cut(sp.seuil())
+        # traitement individuel des sous parties
+        filter = filtreCrible(tolerance=2.*tole_liss)
+        tabSpectre[0] = tabSpectre[0].filtre(filter)
+        tabSpectre[2] = tabSpectre[2].filtre(filter)
+        filter.tolerance = tole_liss
+        tabSpectre[1] = tabSpectre[1].filtre(filter)
+        # Fusion des sous-spectres
+        sp = spectre.merge(tabSpectre)
+
+        # Seconde passe de filtrage
+        sp = sp.filtre(filter)
+
+        # On passe en log-log pour les tests de chevauchement
+        filter = filtreLog(logAbc=False)
+        sp = sp.filtre(filter)
+        # Ecriture dans la liste de spectres résultat
+        resultat.append(sp) # Ajoute la spectre lissé à la liste des spectres
+            
+    resultat.testChevauchement() # Test de chevauchement entre les spectre de la liste
+    resultat.createBase(lspBrut) # construction d'une base commune de fréquence
+
+    # Passage en lin
+    resultat.filtre(filtreLin())
+        
+    # Construction de la nappe résultat
+    nappeRes = nappe.buildFromListSpectre(resultat)
+    nappeRes.listAmor=nappe.listAmor
+    nappeRes.filtreDoublons() # Suppression des valeurs identiques accolées
+    
+    return nappeRes

diff --git a/Aster/Cata/cataSTA10/Utilitai/macro_rota_globale.py b/Aster/Cata/cataSTA10/Utilitai/macro_rota_globale.py
new file mode 100644 (file)
index 0000000..3440f8e
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/macro_rota_globale.py
@@ -0,0 +1,143 @@
+#@ MODIF macro_rota_globale Utilitai  DATE 18/09/2007   AUTEUR DURAND C.DURAND 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+from Cata.cata import *
+
+# ===========================================================================
+#           CORPS DE LA MACRO "MACR_ROTA_GLOBALE"
+#           -------------------------------------
+# USAGE :
+#  RESULTAT : resultat
+#  GROUP_NO_ORIG : un groupe d un noeud definissant l entree du coude (A)
+#  GROUP_NO_EXTR : un groupe d un noeud definissant la sortie du coude (B)
+# 
+#              /
+#           A /
+#            (______
+#            B
+#  
+# ===========================================================================
+# script PYTHON : rotation globale sur une tuyauterie
+
+
+def macr_rota_globale_ops(self,RESULTAT,GROUP_NO_ORIG,GROUP_NO_EXTR,**args):
+
+
+  """
+     Ecriture de la macro MACR_ROTA_GLOBALE
+  """
+  import os
+  from Accas import _F
+  from Noyau.N_utils import AsType
+  ier=0
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  POST_RELEVE_T  = self.get_cmd('POST_RELEVE_T')
+  DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
+  DEFI_FONCTION  = self.get_cmd('DEFI_FONCTION')
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Le concept sortant (de type fonction) est nomme ROTGD dans 
+  # le contexte de la macro
+
+  self.DeclareOut('ROTGD',self.sd)
+
+  # Commandes de la macro
+  
+  __ROTAB=POST_RELEVE_T(ACTION=_F(INTITULE='__ROTAB',
+                                GROUP_NO=GROUP_NO_ORIG,
+                                RESULTAT=RESULTAT,
+                                NOM_CHAM='DEPL',
+                                NOM_CMP=('DRX','DRY','DRZ',),
+                                OPERATION='EXTRACTION',),
+                                )
+
+  __ROTAC=POST_RELEVE_T(ACTION=_F(INTITULE='__ROTAC',
+                                GROUP_NO=GROUP_NO_EXTR,
+                                RESULTAT=RESULTAT,
+                                NOM_CHAM='DEPL',
+                                NOM_CMP=('DRX','DRY','DRZ',),
+                                OPERATION='EXTRACTION',),);
+  
+  __ROTABt=__ROTAB.EXTR_TABLE()
+  __ROTACt=__ROTAC.EXTR_TABLE()
+  __DRXC  = __ROTACt.Array('INST','DRX')
+  __DRYC  = __ROTACt.Array('INST','DRY')
+  __DRZC  = __ROTACt.Array('INST','DRZ')
+  __DRXB  = __ROTABt.Array('INST','DRX')
+  __DRYB  = __ROTABt.Array('INST','DRY')
+  __DRZB  = __ROTABt.Array('INST','DRZ')
+  __DRXBC = __DRXC-__DRXB
+  __DRYBC = __DRYC-__DRYB
+  __DRZBC = __DRZC-__DRZB
+  __ROTG  = __DRXBC*__DRXBC
+  __ROTG  = __ROTG+__DRYBC*__DRYBC
+  __ROTG  = __ROTG+__DRZBC*__DRZBC
+  __ROTG  = __ROTG**(0.5)
+  
+  __livalr = []
+  __livali = []
+  for i in range(len(__ROTG)):
+    __livalr.append(__ROTG[i,1])
+    __livali.append(__DRXC[i,0])
+
+  print __livalr
+  print __livali
+
+  __LROTG = DEFI_LIST_REEL(VALE=__livalr)
+  __LINST = DEFI_LIST_REEL(VALE=__livali)
+
+  ROTGD = DEFI_FONCTION(NOM_PARA='INST',
+                        VALE_PARA=__LINST,
+                        VALE_FONC=__LROTG,
+                       )
+
+  return ier
+
+
+
+# ===========================================================================
+#           CATALOGUE DE LA MACRO "MACR_ROTA_GLOBALE"
+#           -----------------------------------------
+# USAGE :
+#  RESULTAT : resultat
+#  GROUP_NO_ORIG : un groupe d un noeud definissant l entree du coude (A)
+#  GROUP_NO_EXTR : un groupe d un noeud definissant la sortie du coude (B)
+# 
+#              /
+#           A /
+#            (______
+#            B
+#  
+# ===========================================================================
+
+
+
+MACR_ROTA_GLOBALE=MACRO(nom="MACR_ROTA_GLOBALE",op=macr_rota_globale_ops,sd_prod=fonction_sdaster,
+                       docu="",reentrant='n',
+                       fr="calcul de la rotation globale dans un coude.",
+         RESULTAT        =SIMP(statut='o',typ=(evol_elas,evol_noli,evol_ther) ),
+         GROUP_NO_ORIG   =SIMP(statut='o',typ=grno,max=1),
+         GROUP_NO_EXTR   =SIMP(statut='o',typ=grno,max=1),
+)  ;
+
+
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/optimize.py b/Aster/Cata/cataSTA10/Utilitai/optimize.py
new file mode 100644 (file)
index 0000000..e4d3cc2
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/optimize.py
@@ -0,0 +1,591 @@
+#@ MODIF optimize Utilitai  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+#
+
+# ******NOTICE***************
+# optimize.py module by Travis E. Oliphant
+#
+# You may copy and use this module as you see fit with no
+# guarantee implied provided you keep this notice in all copies.
+# *****END NOTICE************
+
+# A collection of optimization algorithms.  Version 0.3.1
+
+# Minimization routines
+"""optimize.py
+
+A collection of general-purpose optimization routines using Numeric
+
+fmin        ---      Nelder-Mead Simplex algorithm (uses only function calls)
+fminBFGS    ---      Quasi-Newton method (uses function and gradient)
+fminNCG     ---      Line-search Newton Conjugate Gradient (uses function, gradient
+                     and hessian (if it's provided))
+
+"""
+import numpy as Num
+max = Num.max
+min = Num.min
+abs = Num.absolute
+__version__="0.3.1"
+
+def rosen(x):  # The Rosenbrock function
+    return Num.sum(100.0*(x[1:len(x)]-x[0:-1]**2.0)**2.0 + (1-x[0:-1])**2.0)
+
+def rosen_der(x):
+    xm = x[1:-1]
+    xm_m1 = x[0:-2]
+    xm_p1 = x[2:len(x)]
+    der = Num.zeros(x.shape,x.dtype.char)
+    der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)
+    der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])
+    der[-1] = 200*(x[-1]-x[-2]**2)
+    return der
+
+def rosen3_hess_p(x,p):
+    assert(len(x)==3)
+    assert(len(p)==3)
+    hessp = Num.zeros((3,),x.dtype.char)
+    hessp[0] = (2 + 800*x[0]**2 - 400*(-x[0]**2 + x[1])) * p[0] \
+               - 400*x[0]*p[1] \
+               + 0
+    hessp[1] = - 400*x[0]*p[0] \
+               + (202 + 800*x[1]**2 - 400*(-x[1]**2 + x[2]))*p[1] \
+               - 400*x[1] * p[2]
+    hessp[2] = 0 \
+               - 400*x[1] * p[1] \
+               + 200 * p[2]
+    
+    return hessp
+
+def rosen3_hess(x):
+    assert(len(x)==3)
+    hessp = Num.zeros((3,3),x.dtype.char)
+    hessp[0,:] = [2 + 800*x[0]**2 -400*(-x[0]**2 + x[1]), -400*x[0], 0]
+    hessp[1,:] = [-400*x[0], 202+800*x[1]**2 -400*(-x[1]**2 + x[2]), -400*x[1]]
+    hessp[2,:] = [0,-400*x[1], 200]
+    return hessp
+    
+        
+def fmin(func, x0, args=(), xtol=1e-4, ftol=1e-4, maxiter=None, maxfun=None, fulloutput=0, printmessg=1):
+    """xopt,{fval,warnflag} = fmin(function, x0, args=(), xtol=1e-4, ftol=1e-4,
+    maxiter=200*len(x0), maxfun=200*len(x0), fulloutput=0, printmessg=0)
+
+    Uses a Nelder-Mead Simplex algorithm to find the minimum of function
+    of one or more variables.
+    """
+    x0 = Num.asarray(x0)
+    assert (len(x0.shape)==1)
+    N = len(x0)
+    if maxiter is None:
+        maxiter = N * 200
+    if maxfun is None:
+        maxfun = N * 200
+
+    rho = 1; chi = 2; psi = 0.5; sigma = 0.5;
+    one2np1 = range(1,N+1)
+
+    sim = Num.zeros((N+1,N),x0.dtype.char)
+    fsim = Num.zeros((N+1,),'d')
+    sim[0] = x0
+    fsim[0] = apply(func,(x0,)+args)
+    nonzdelt = 0.05
+    zdelt = 0.00025
+    for k in range(0,N):
+        y = Num.array(x0,copy=1)
+        if y[k] != 0:
+            y[k] = (1+nonzdelt)*y[k]
+        else:
+            y[k] = zdelt
+
+        sim[k+1] = y
+        f = apply(func,(y,)+args)
+        fsim[k+1] = f
+
+    ind = Num.argsort(fsim)
+    fsim = Num.take(fsim,ind)     # sort so sim[0,:] has the lowest function value
+    sim = Num.take(sim,ind,0)
+    
+    iterations = 1
+    funcalls = N+1
+    
+    while (funcalls < maxfun and iterations < maxiter):
+        if (max(Num.ravel(abs(sim[1:len(sim)]-sim[0]))) <= xtol \
+            and max(abs(fsim[0]-fsim[1:len(fsim)])) <= ftol):
+            break
+
+        xbar = Num.add.reduce(sim[0:-1],0) / N
+        xr = (1+rho)*xbar - rho*sim[-1]
+        fxr = apply(func,(xr,)+args)
+        funcalls = funcalls + 1
+        doshrink = 0
+
+        if fxr < fsim[0]:
+            xe = (1+rho*chi)*xbar - rho*chi*sim[-1]
+            fxe = apply(func,(xe,)+args)
+            funcalls = funcalls + 1
+
+            if fxe < fxr:
+                sim[-1] = xe
+                fsim[-1] = fxe
+            else:
+                sim[-1] = xr
+                fsim[-1] = fxr
+        else: # fsim[0] <= fxr
+            if fxr < fsim[-2]:
+                sim[-1] = xr
+                fsim[-1] = fxr
+            else: # fxr >= fsim[-2]
+                # Perform contraction
+                if fxr < fsim[-1]:
+                    xc = (1+psi*rho)*xbar - psi*rho*sim[-1]
+                    fxc = apply(func,(xc,)+args)
+                    funcalls = funcalls + 1
+
+                    if fxc <= fxr:
+                        sim[-1] = xc
+                        fsim[-1] = fxc
+                    else:
+                        doshrink=1
+                else:
+                    # Perform an inside contraction
+                    xcc = (1-psi)*xbar + psi*sim[-1]
+                    fxcc = apply(func,(xcc,)+args)
+                    funcalls = funcalls + 1
+
+                    if fxcc < fsim[-1]:
+                        sim[-1] = xcc
+                        fsim[-1] = fxcc
+                    else:
+                        doshrink = 1
+
+                if doshrink:
+                    for j in one2np1:
+                        sim[j] = sim[0] + sigma*(sim[j] - sim[0])
+                        fsim[j] = apply(func,(sim[j],)+args)
+                    funcalls = funcalls + N
+
+        ind = Num.argsort(fsim)
+        sim = Num.take(sim,ind,0)
+        fsim = Num.take(fsim,ind)
+        iterations = iterations + 1
+
+    x = sim[0]
+    fval = min(fsim)
+    warnflag = 0
+
+    if funcalls >= maxfun:
+        warnflag = 1
+        if printmessg:
+            print "Warning: Maximum number of function evaluations has been exceeded."
+    elif iterations >= maxiter:
+        warnflag = 2
+        if printmessg:
+            print "Warning: Maximum number of iterations has been exceeded"
+    else:
+        if printmessg:
+            print "Optimization terminated successfully."
+            print "         Current function value: %f" % fval
+            print "         Iterations: %d" % iterations
+            print "         Function evaluations: %d" % funcalls
+
+    if fulloutput:
+        return x, fval, warnflag
+    else:        
+        return x
+
+
+def zoom(a_lo, a_hi):
+    pass
+
+    
+
+def line_search(f, fprime, xk, pk, gfk, args=(), c1=1e-4, c2=0.9, amax=50):
+    """alpha, fc, gc = line_search(f, xk, pk, gfk,
+                                   args=(), c1=1e-4, c2=0.9, amax=1)
+
+    minimize the function f(xk+alpha pk) using the line search algorithm of
+    Wright and Nocedal in 'Numerical Optimization', 1999, pg. 59-60
+    """
+
+    fc = 0
+    gc = 0
+    alpha0 = 1.0
+    phi0  = apply(f,(xk,)+args)
+    phi_a0 = apply(f,(xk+alpha0*pk,)+args)
+    fc = fc + 2
+    derphi0 = Num.dot(gfk,pk)
+    derphi_a0 = Num.dot(apply(fprime,(xk+alpha0*pk,)+args),pk)
+    gc = gc + 1
+
+    # check to see if alpha0 = 1 satisfies Strong Wolfe conditions.
+    if (phi_a0 <= phi0 + c1*alpha0*derphi0) \
+       and (abs(derphi_a0) <= c2*abs(derphi0)):
+        return alpha0, fc, gc
+
+    alpha0 = 0
+    alpha1 = 1
+    phi_a1 = phi_a0
+    phi_a0 = phi0
+
+    i = 1
+    while 1:
+        if (phi_a1 > phi0 + c1*alpha1*derphi0) or \
+           ((phi_a1 >= phi_a0) and (i > 1)):
+            return zoom(alpha0, alpha1)
+
+        derphi_a1 = Num.dot(apply(fprime,(xk+alpha1*pk,)+args),pk)
+        gc = gc + 1
+        if (abs(derphi_a1) <= -c2*derphi0):
+            return alpha1
+
+        if (derphi_a1 >= 0):
+            return zoom(alpha1, alpha0)
+
+        alpha2 = (amax-alpha1)*0.25 + alpha1
+        i = i + 1
+        alpha0 = alpha1
+        alpha1 = alpha2
+        phi_a0 = phi_a1
+        phi_a1 = apply(f,(xk+alpha1*pk,)+args)
+
+    
+
+def line_search_BFGS(f, xk, pk, gfk, args=(), c1=1e-4, alpha0=1):
+    """alpha, fc, gc = line_search(f, xk, pk, gfk,
+                                   args=(), c1=1e-4, alpha0=1)
+
+    minimize over alpha, the function f(xk+alpha pk) using the interpolation
+    algorithm (Armiijo backtracking) as suggested by
+    Wright and Nocedal in 'Numerical Optimization', 1999, pg. 56-57
+    """
+
+    fc = 0
+    phi0 = apply(f,(xk,)+args)               # compute f(xk)
+    phi_a0 = apply(f,(xk+alpha0*pk,)+args)     # compute f
+    fc = fc + 2
+    derphi0 = Num.dot(gfk,pk)
+
+    if (phi_a0 <= phi0 + c1*alpha0*derphi0):
+        return alpha0, fc, 0
+
+    # Otherwise compute the minimizer of a quadratic interpolant:
+
+    alpha1 = -(derphi0) * alpha0**2 / 2.0 / (phi_a0 - phi0 - derphi0 * alpha0)
+    phi_a1 = apply(f,(xk+alpha1*pk,)+args)
+    fc = fc + 1
+
+    if (phi_a1 <= phi0 + c1*alpha1*derphi0):
+        return alpha1, fc, 0
+
+    # Otherwise loop with cubic interpolation until we find an alpha which satifies
+    #  the first Wolfe condition (since we are backtracking, we will assume that
+    #  the value of alpha is not too small and satisfies the second condition.
+
+    while 1:       # we are assuming pk is a descent direction
+        factor = alpha0**2 * alpha1**2 * (alpha1-alpha0)
+        a = alpha0**2 * (phi_a1 - phi0 - derphi0*alpha1) - \
+            alpha1**2 * (phi_a0 - phi0 - derphi0*alpha0)
+        a = a / factor
+        b = -alpha0**3 * (phi_a1 - phi0 - derphi0*alpha1) + \
+            alpha1**3 * (phi_a0 - phi0 - derphi0*alpha0)
+        b = b / factor
+
+        alpha2 = (-b + Num.sqrt(abs(b**2 - 3 * a * derphi0))) / (3.0*a)
+        phi_a2 = apply(f,(xk+alpha2*pk,)+args)
+        fc = fc + 1
+
+        if (phi_a2 <= phi0 + c1*alpha2*derphi0):
+            return alpha2, fc, 0
+
+        if (alpha1 - alpha2) > alpha1 / 2.0 or (1 - alpha2/alpha1) < 0.96:
+            alpha2 = alpha1 / 2.0
+
+        alpha0 = alpha1
+        alpha1 = alpha2
+        phi_a0 = phi_a1
+        phi_a1 = phi_a2
+
+epsilon = 1e-8
+
+def approx_fprime(xk,f,*args):
+    f0 = apply(f,(xk,)+args)
+    grad = Num.zeros((len(xk),),'d')
+    ei = Num.zeros((len(xk),),'d')
+    for k in range(len(xk)):
+        ei[k] = 1.0
+        grad[k] = (apply(f,(xk+epsilon*ei,)+args) - f0)/epsilon
+        ei[k] = 0.0
+    return grad
+
+def approx_fhess_p(x0,p,fprime,*args):
+    f2 = apply(fprime,(x0+epsilon*p,)+args)
+    f1 = apply(fprime,(x0,)+args)
+    return (f2 - f1)/epsilon
+
+
+def fminBFGS(f, x0, fprime=None, args=(), avegtol=1e-5, maxiter=None, fulloutput=0, printmessg=1):
+    """xopt = fminBFGS(f, x0, fprime=None, args=(), avegtol=1e-5,
+                       maxiter=None, fulloutput=0, printmessg=1)
+
+    Optimize the function, f, whose gradient is given by fprime using the
+    quasi-Newton method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS)
+    See Wright, and Nocedal 'Numerical Optimization', 1999, pg. 198.
+    """
+
+    app_fprime = 0
+    if fprime is None:
+        app_fprime = 1
+
+    x0 = Num.asarray(x0)
+    if maxiter is None:
+        maxiter = len(x0)*200
+    func_calls = 0
+    grad_calls = 0
+    k = 0
+    N = len(x0)
+    gtol = N*avegtol
+    I = Num.eye(N)
+    Hk = I
+
+    if app_fprime:
+        gfk = apply(approx_fprime,(x0,f)+args)
+        func_calls = func_calls + len(x0) + 1
+    else:
+        gfk = apply(fprime,(x0,)+args)
+        grad_calls = grad_calls + 1
+    xk = x0
+    sk = [2*gtol]
+    while (Num.add.reduce(abs(gfk)) > gtol) and (k < maxiter):
+        pk = -Num.dot(Hk,gfk)
+        alpha_k, fc, gc = line_search_BFGS(f,xk,pk,gfk,args)
+        func_calls = func_calls + fc
+        xkp1 = xk + alpha_k * pk
+        sk = xkp1 - xk
+        xk = xkp1
+        if app_fprime:
+            gfkp1 = apply(approx_fprime,(xkp1,f)+args)
+            func_calls = func_calls + gc + len(x0) + 1
+        else:
+            gfkp1 = apply(fprime,(xkp1,)+args)
+            grad_calls = grad_calls + gc + 1
+
+        yk = gfkp1 - gfk
+        k = k + 1
+
+        rhok = 1 / Num.dot(yk,sk)
+        A1 = I - sk[:,Num.newaxis] * yk[Num.newaxis,:] * rhok
+        A2 = I - yk[:,Num.newaxis] * sk[Num.newaxis,:] * rhok
+        Hk = Num.dot(A1,Num.dot(Hk,A2)) + rhok * sk[:,Num.newaxis] * sk[Num.newaxis,:]
+        gfk = gfkp1
+
+
+    if printmessg or fulloutput:
+        fval = apply(f,(xk,)+args)
+    if k >= maxiter:
+        warnflag = 1
+        if printmessg:
+            print "Warning: Maximum number of iterations has been exceeded"
+            print "         Current function value: %f" % fval
+            print "         Iterations: %d" % k
+            print "         Function evaluations: %d" % func_calls
+            print "         Gradient evaluations: %d" % grad_calls
+    else:
+        warnflag = 0
+        if printmessg:
+            print "Optimization terminated successfully."
+            print "         Current function value: %f" % fval
+            print "         Iterations: %d" % k
+            print "         Function evaluations: %d" % func_calls
+            print "         Gradient evaluations: %d" % grad_calls
+
+    if fulloutput:
+        return xk, fval, func_calls, grad_calls, warnflag
+    else:        
+        return xk
+
+
+def fminNCG(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-5, maxiter=None, fulloutput=0, printmessg=1):
+    """xopt = fminNCG(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-5,
+                       maxiter=None, fulloutput=0, printmessg=1)
+
+    Optimize the function, f, whose gradient is given by fprime using the
+    Newton-CG method.  fhess_p must compute the hessian times an arbitrary
+    vector. If it is not given, finite-differences on fprime are used to
+    compute it. See Wright, and Nocedal 'Numerical Optimization', 1999,
+    pg. 140.
+    """
+
+    x0 = Num.asarray(x0)
+    fcalls = 0
+    gcalls = 0
+    hcalls = 0
+    approx_hessp = 0
+    if fhess_p is None and fhess is None:    # Define hessian product
+        approx_hessp = 1
+    
+    xtol = len(x0)*avextol
+    update = [2*xtol]
+    xk = x0
+    k = 0
+    while (Num.add.reduce(abs(update)) > xtol) and (k < maxiter):
+        # Compute a search direction pk by applying the CG method to
+        #  del2 f(xk) p = - grad f(xk) starting from 0.
+        b = -apply(fprime,(xk,)+args)
+        gcalls = gcalls + 1
+        maggrad = Num.add.reduce(abs(b))
+        eta = min([0.5,Num.sqrt(maggrad)])
+        termcond = eta * maggrad
+        xsupi = 0
+        ri = -b
+        psupi = -ri
+        i = 0
+        dri0 = Num.dot(ri,ri)
+
+        if fhess is not None:               # you want to compute hessian once.
+            A = apply(fhess,(xk,)+args)
+            hcalls = hcalls + 1
+
+        while Num.add.reduce(abs(ri)) > termcond:
+            if fhess is None:
+                if approx_hessp:
+                    Ap = apply(approx_fhess_p,(xk,psupi,fprime)+args)
+                    gcalls = gcalls + 2
+                else:
+                    Ap = apply(fhess_p,(xk,psupi)+args)
+                    hcalls = hcalls + 1
+            else:
+                Ap = Num.dot(A,psupi)
+            # check curvature
+            curv = Num.dot(psupi,Ap)
+            if (curv <= 0):
+                if (i > 0):
+                    break
+                else:
+                    xsupi = xsupi + dri0/curv * psupi
+                    break
+            alphai = dri0 / curv
+            xsupi = xsupi + alphai * psupi
+            ri = ri + alphai * Ap
+            dri1 = Num.dot(ri,ri)
+            betai = dri1 / dri0
+            psupi = -ri + betai * psupi
+            i = i + 1
+            dri0 = dri1          # update Num.dot(ri,ri) for next time.
+    
+        pk = xsupi  # search direction is solution to system.
+        gfk = -b    # gradient at xk
+        alphak, fc, gc = line_search_BFGS(f,xk,pk,gfk,args)
+        fcalls = fcalls + fc
+        gcalls = gcalls + gc
+
+        update = alphak * pk
+        xk = xk + update
+        k = k + 1
+
+    if printmessg or fulloutput:
+        fval = apply(f,(xk,)+args)
+    if k >= maxiter:
+        warnflag = 1
+        if printmessg:
+            print "Warning: Maximum number of iterations has been exceeded"
+            print "         Current function value: %f" % fval
+            print "         Iterations: %d" % k
+            print "         Function evaluations: %d" % fcalls
+            print "         Gradient evaluations: %d" % gcalls
+            print "         Hessian evaluations: %d" % hcalls
+    else:
+        warnflag = 0
+        if printmessg:
+            print "Optimization terminated successfully."
+            print "         Current function value: %f" % fval
+            print "         Iterations: %d" % k
+            print "         Function evaluations: %d" % fcalls
+            print "         Gradient evaluations: %d" % gcalls
+            print "         Hessian evaluations: %d" % hcalls
+            
+    if fulloutput:
+        return xk, fval, fcalls, gcalls, hcalls, warnflag
+    else:        
+        return xk
+
+    
+
+if __name__ == "__main__":
+    import string
+    import time
+
+    
+    times = []
+    algor = []
+    x0 = [0.8,1.2,0.7]
+    start = time.time()
+    x = fmin(rosen,x0)
+    print x
+    times.append(time.time() - start)
+    algor.append('Nelder-Mead Simplex\t')
+
+    start = time.time()
+    x = fminBFGS(rosen, x0, fprime=rosen_der, maxiter=80)
+    print x
+    times.append(time.time() - start)
+    algor.append('BFGS Quasi-Newton\t')
+
+    start = time.time()
+    x = fminBFGS(rosen, x0, avegtol=1e-4, maxiter=100)
+    print x
+    times.append(time.time() - start)
+    algor.append('BFGS without gradient\t')
+
+
+    start = time.time()
+    x = fminNCG(rosen, x0, rosen_der, fhess_p=rosen3_hess_p, maxiter=80)
+    print x
+    times.append(time.time() - start)
+    algor.append('Newton-CG with hessian product')
+    
+
+    start = time.time()
+    x = fminNCG(rosen, x0, rosen_der, fhess=rosen3_hess, maxiter=80)
+    print x
+    times.append(time.time() - start)
+    algor.append('Newton-CG with full hessian')
+
+    print "\nMinimizing the Rosenbrock function of order 3\n"
+    print " Algorithm \t\t\t       Seconds"
+    print "===========\t\t\t      ========="
+    for k in range(len(algor)):
+        print algor[k], "\t -- ", times[k]
+        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/partition.py b/Aster/Cata/cataSTA10/Utilitai/partition.py
new file mode 100644 (file)
index 0000000..f26b15c
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/partition.py
@@ -0,0 +1,1324 @@
+#@ MODIF partition Utilitai  DATE 26/10/2010   AUTEUR MAHFOUZ D.MAHFOUZ 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+
+import aster
+import string, os, time, sys, UserList, types
+import numpy as NP
+
+from Accas import _F
+from Noyau.N_utils import AsType
+
+# ============================================================================ #
+def enleve_doublons_liste(liste):
+   """
+      A partir d une liste qui peut contenir des doublons, on renvoie une liste sans
+      doublons (et qui reviendra triée)
+   """
+   #MC pourquoi ne pas faire :
+   # liste2 = NP.array(list(set(liste)))
+   # liste2.sort()
+   # Au cas ou ca ne serait pas deja un vecteur numpy      # Exemple
+   liste=NP.sort(NP.array(liste,copy=0))                   # [1, 2, 2, 3, 3, 4, 5]
+   liste_diff=liste[1:]-liste[:-1]                         # [1, 0, 1, 0, 1, 1]
+   liste_temp=NP.nonzero(liste_diff)[0]                    # [0, 2, 4, 5]
+   liste_indice=NP.zeros(liste_temp.shape[0]+1, dtype=int)
+   liste_indice[0]=0
+   liste_indice[1:]=liste_temp+1                           # [0, 1, 3, 5, 6]
+   liste2=NP.take(liste,liste_indice)                      # [1, 2, 3, 4, 5]
+   return liste2
+
+
+# ============================================================================ #
+class CONNEC(UserList.UserList) :
+   """
+      Connectivite : sequence mutable de sequences de noeuds
+      Pour l'instant, on s'appuie sur une liste de liste.
+   """
+   def __init__(self,nma) :
+      UserList.UserList.__init__(self,[None]*nma)
+
+   def Index(self) :
+      """
+         Retourne la connectivite sous forme de deux vecteurs numpy :
+            ind -> tableau des index (y compris le n+1 eme)
+            noe -> tableau des listes de noeuds
+      """
+      # Dimension des deux vecteurs
+      nma  = len(self)
+      ltot = NP.reduce(lambda x,y : x+len(y), self,0)
+      ind = NP.zeros(nma+1, dtype=int)
+      noe = NP.zeros(ltot, dtype=int)
+
+      # Construction des vecteurs
+      ind[0] = 0
+      for i in range(nma) :
+         m = self[i]
+         ind[i+1] = ind[i] + len(m)
+         noe[ind[i]:ind[i+1]] = NP.array(m)
+
+      return ind,noe
+
+# ============================================================================ #
+class MAIL_PY :
+   """
+      SD PYTHON  MAILLAGE
+      La numeration est 0..N-1 pour les noeuds et 0..M-1 pour les mailles
+
+EXEMPLE D'UTILISATION
+---------------------
+from Utilitai.Partition import *
+import numpy as N
+
+mail=LIRE_MAILLAGE();
+
+mm = MAIL_PY()
+mm.FromAster(mail)
+
+# Nombre de noeuds
+nbno = mm.dime_maillage[0]
+# Nombre de mailles
+nbma = mm.dime_maillage[2]
+
+# Coordonnées des noeuds
+coord    = mm.cn
+# Noms des noeuds
+linomno  = list(mm.correspondance_noeuds)
+# Groupe de Mailles
+collgrma = mm.gma
+# Groupe de Noeuds
+collgrno = mm.gno
+# La table de connextivité
+connex   = mm.co
+
+# Le décalage de -1 est déjà fait sur les numéros des noeuds et des mailles
+# Pour ajouter des Noeuds
+   #  Coordonnées
+         LesNoeudsEnPlus = NP.array([[xx,yy,zz]])
+         LesNoeudsEnPlus = NP.concatenate((LesNoeudsEnPlus,NP.array([[xx,yy,zz]])))
+   #  Noms
+         NomNoeudsEnPlus =     ['X%' % in]
+         NomNoeudsEnPlus.append('X%' % in)
+# Ajout des noeuds au maillage : coordonnées , noms
+   mm.cn = NP.concatenate((mm.cn,LesNoeudsEnPlus))
+   mm.correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus )
+
+# Pour ajouter des mailles (ici TRIA3)  in [ 1 , NbMailleAjouté ]
+   #  Noms
+         NomMaillesEnPlus =     ['Z%d' % im]
+         NomMaillesEnPlus.append('Z%d' % im)
+   #  Numéro des mailles
+         num_maille = [ nbma + im ]
+         num_maille.append( nbma + im )
+   #  Noeuds des mailles
+         NoeudsMailles = [NP.array([i1,i2,i3])]
+         NoeudsMailles.append(NP.array(NP.array([i1,i2,i3])))
+# Ajout des TRIA3
+   # Type de maille
+         typ_maille = mm.dic['TRIA3']
+         mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*NbMailleAjouté)))
+   # Nom des mailles
+         mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+   # connectivite des éléments
+      mm.co += NoeudsMailles
+
+# Ajout d'un groupe de maille contenant les mailles ajoutés
+   maillage_python.gma['XXXAJOUT'] = NP.array(num_maille)
+
+# Ecriture dans un fichier, et transfert dans l'espace Aster
+   unite = mm.ToAster()
+   mail = LIRE_MAILLAGE(UNITE=unite)
+   """
+
+   def __init__(self, nno=0, nma=0, ndim=None) :
+      self.ndim = ndim
+      if ndim is None:
+         # on initialise le tableau au plus grand
+         ndim = 3
+      self.cn  = NP.zeros((nno, ndim), dtype=int)
+      self.tm  = NP.zeros(nma, dtype=int)
+      self.co  = CONNEC(nma)
+      self.gma = {}
+      self.gno = {}
+      self.indice_noeuds = NP.arange(nno)
+
+      self.correspondance_noeuds = []
+      self.correspondance_mailles = []
+
+      try:
+         import aster
+         nom_mailles = (None,) + string.strip(aster.getvectjev('&CATA.TM.NOMTM'))
+      except:
+         nom_mailles = (None,
+         'POI1',   'SEG2',   'SEG22',  'SEG3',   'SEG33',  'SEG4',   'TRIA3',
+         'TRIA33', 'TRIA6',  'TRIA66', 'TRIA7',  'QUAD4',  'QUAD44', 'QUAD8',
+         'QUAD88', 'QUAD9',  'QUAD99', 'TETRA4', 'TETRA10','PENTA6', 'PENTA15',
+         'PYRAM5', 'PYRAM13','HEXA8',  'HEXA20', 'HEXA27', 'TR3QU4', 'QU4TR3',
+         'TR6TR3', 'TR3TR6', 'TR6QU4', 'QU4TR6', 'TR6QU8', 'QU8TR6', 'TR6QU9',
+         'QU9TR6', 'QU8TR3', 'TR3QU8', 'QU8QU4', 'QU4QU8', 'QU8QU9', 'QU9QU8',
+         'QU9QU4', 'QU4QU9', 'QU9TR3', 'TR3QU9', 'SEG32',  'SEG23' )
+
+      dic_mailles = {}
+      for i in range(len(nom_mailles)) :
+         dic_mailles[nom_mailles[i]] = i
+
+      self.nom = nom_mailles
+      self.dic = dic_mailles
+
+      try:
+         psyco.bind(self.FromAster)
+      except: pass
+
+# -------------------------------------------------------------
+   def get_connexite(self, nom, nma):
+      co=CONNEC(nma)
+      dico_connexite = aster.getcolljev(nom)
+      for element in dico_connexite.keys() :
+         co[int(element)-1] = (NP.array(dico_connexite[element])-1)
+      return co
+
+   def get_coordonnees_noeuds(self, nom, nombre_noeuds):
+      assert self.ndim != None, """Dimension réelle du maillage non initialisée."""
+      lcoord = aster.getvectjev(nom)
+      coordonnees_noeuds = NP.array(lcoord)
+      nno = len(coordonnees_noeuds) / 3
+      assert nno == nombre_noeuds, """Données incohérentes."""
+      coordonnees_noeuds.shape = (nno, 3)
+      cn = coordonnees_noeuds[:, :self.ndim]
+      return cn
+
+# -------------------------------------------------------------
+   def init_dimension(self, ndim):
+      """Initialise la dimension du maillage."""
+      if self.ndim is None:
+         self.ndim = ndim
+      assert ndim == self.ndim, """Il est interdit de modifier la dimension du maillage !"""
+
+# -------------------------------------------------------------
+   def FromAster(self,nom) :
+      # On accepte le concept Aster ou bien la chaine texte de son nom
+      if type(nom)!=types.StringType:
+         nom_maillage = nom.nom
+      else:
+         nom_maillage = nom
+      nom_maillage=string.ljust(nom_maillage,8)
+
+      # recuperation de la taille
+      self.dime_maillage = aster.getvectjev(nom_maillage+'.DIME')
+      nombre_noeuds      = self.dime_maillage[0]
+      nombre_mailles     = self.dime_maillage[2]
+      ndim               = self.dime_maillage[5]
+      self.init_dimension(ndim)
+
+      # coordonnees des noeuds
+      self.cn = self.get_coordonnees_noeuds(nom_maillage+'.COORDO    .VALE', nombre_noeuds)
+
+      # type de maille
+      self.tm = NP.array(aster.getvectjev(nom_maillage+'.TYPMAIL'))
+
+      # connexite
+      self.co = self.get_connexite(nom_maillage+'.CONNEX', nombre_mailles)
+
+      self.indice_noeuds=NP.arange(nombre_noeuds)
+
+      # groupe de noeuds
+      Lno_groupno_tot = aster.getcolljev(nom_maillage+'.GROUPENO')
+
+      Lno_groupno={}
+      for key in Lno_groupno_tot :
+         # Tolerance car parfois defi_group crée des groupes nuls à clé entiere
+         try:
+            Lno_groupno[key.strip()]=NP.array(Lno_groupno_tot[key])-1
+         except:
+            pass
+      self.gno=Lno_groupno
+
+      # groupe de mailles
+      Lma_groupma_tot     = aster.getcolljev(nom_maillage+'.GROUPEMA')
+      Lma_groupma={}
+      for key in Lma_groupma_tot :
+         Lma_groupma[key.strip()]=NP.array(Lma_groupma_tot[key])-1
+      self.gma=Lma_groupma
+
+      del(Lma_groupma_tot)
+
+      # listes de correspondance entre Aster et Mail-Py
+      self.correspondance_noeuds  = aster.getvectjev(nom_maillage+'.NOMNOE')
+      self.correspondance_mailles = aster.getvectjev(nom_maillage+'.NOMMAI')
+
+# -------------------------------------------------------------
+   def ToAster(self,unite=None):
+      from Utilitai.UniteAster import UniteAster
+      try:
+         LIRE_MAILLAGE   = self.jdc.get_cmd('LIRE_MAILLAGE')
+      except:
+         try:
+            from Cata.cata import LIRE_MAILLAGE
+         except:
+            print "Il faut lancer ce programme depuis Aster pour pouvoir générer un maillage Aster."
+            sys.exit()
+
+      UL = UniteAster()
+      # Récupération d'une unité logique libre si besoin
+      if ( unite == None ): unite = UL.Libre(action='ASSOCIER')
+      fichier = UL.Nom(unite)
+      # Bascule le fichier en F : ferme
+      UL.Etat(unite,etat='F')
+      # Ouverture du fichier en WRITE
+      f = open(fichier, 'w')
+      # Sauvegarde du maillage dans le fichier
+      f.write( self.Voir_Mail() )
+      f.close()
+      # Remet les unités comme au debut
+      UL.EtatInit()
+
+      return unite
+
+# -------------------------------------------------------------
+   def __str__(self) :
+      return self.Voir_Mail()
+
+# -------------------------------------------------------------
+   def Voir_Mail(self) :
+      """
+         Impression au format ASTER
+      """
+      l = []
+      l.append('TITRE')
+      l.append('%  CLASSE PY_MAIL -> MAIL')
+      l.append('FINSF')
+      l.append('%')
+
+      (nno,ndim) = self.cn.shape
+      self.init_dimension(ndim)
+
+      # Coordonnees des noeuds
+      l.append('COOR_%sD' % ndim)
+
+      #  format des nombres : 21.14E ==> -3.00000000000002D-04
+      #  longueur d'une ligne : 8 + (2 + 21)*3 = 77
+      fmt = '  '.join(["%21.14E"] * ndim)
+      # Si le maillage initial ne provient pas d'Aster
+      if len(self.correspondance_noeuds) == 0:
+         for i in range(nno) :
+            ch = fmt % tuple([self.cn[i, k] for k in range(ndim)])
+            l.append("%-8s  %s" % ('N'+repr(i), ch))
+
+      # Si le maillage initial provient d'Aster
+      else:
+         for i in range(nno) :
+            ch = fmt % tuple([self.cn[i, k] for k in range(ndim)])
+            l.append("%-8s  %s" % (self.correspondance_noeuds[i], ch))
+
+      # Connectivité des mailles
+      ind = range(len(self.tm))
+      ty = 0
+      # Si le maillage initial ne provient pas d'Aster
+      if len(self.correspondance_mailles) == 0:
+         for m in ind :
+            if self.tm[m] <> ty :
+               l.append('FINSF') ; l.append('%')
+               ty = self.tm[m]
+               l.append(self.nom[ty])
+            ch = 'M%d ' % m
+            for n in self.co[m] :
+               zn = ' N%d'% n
+               if ( len(ch)+len(zn) > 80 ):
+                  l.append(ch)
+                  ch = '      ' + zn
+               else:
+                  ch += zn
+            l.append(ch)
+
+      # Si le maillage initial provient d'Aster
+      else:
+         for m in ind :
+            if self.tm[m] <> ty :
+               l.append('FINSF') ; l.append('%')
+               ty = self.tm[m]
+               l.append(self.nom[ty])
+            ch = self.correspondance_mailles[m]+' '
+            for n in self.co[m] :
+               zn = ' ' + self.correspondance_noeuds[n]
+               if ( len(ch)+len(zn) > 80 ):
+                  l.append(ch)
+                  ch = '      ' + zn
+               else:
+                  ch += zn
+            l.append(ch)
+      l.append('FINSF') ; l.append('%')
+
+
+      # Group_ma et Group_no
+      entete = ['GROUP_MA','GROUP_NO']
+      d_gp   = [self.gma,self.gno]
+      pref   = ['M','N']
+
+      # Si le maillage initial ne provient pas d'Aster
+      if len(self.correspondance_mailles) == 0:
+         for (d_gp,entete,prefixe) in [(self.gma,'GROUP_MA','M'),(self.gno,'GROUP_NO','N')] :
+            for gp in d_gp :
+               if len(d_gp[gp])>0:  # On ne prend en compte que les group_* non vides
+                  l.append(entete)
+                  l.append('  ' + gp)
+                  ch = ''
+                  for o in d_gp[gp]:
+                     zm = ' %s%d' % (prefixe , o)
+                     if ( len(ch)+len(zm) > 80 ):
+                        l.append(ch)
+                        ch = zm
+                     else:
+                        ch += zm
+                  l.append(ch)
+                  l.append('FINSF') ; l.append('%')
+
+      # Si le maillage initial provient d'Aster
+      else:
+         for (d_gp,entete,prefixe) in [(self.gma,'GROUP_MA','M'),(self.gno,'GROUP_NO','N')] :
+            for gp in d_gp :
+               if len(d_gp[gp])>0:  # On ne prend en compte que les group_* non vides
+                  l.append(entete)
+                  l.append('  ' + gp)
+                  ch = ''
+                  for o in d_gp[gp]:
+                     if prefixe=='M':
+                        zm = ' ' + self.correspondance_mailles[o]
+                     else:
+                        zm = ' ' + self.correspondance_noeuds[o]
+                     if ( len(ch)+len(zm) > 80 ):
+                        l.append(ch)
+                        ch = zm
+                     else:
+                        ch += zm
+                  l.append(ch)
+                  l.append('FINSF') ; l.append('%')
+
+      # Fin
+      l.extend(['FIN', ''])
+      return os.linesep.join(l)
+
+
+# ============================================================================ #
+class PARTITION:
+
+  def __init__(self, jdc=None ,nb=0):
+
+    self.jdc = jdc
+
+    self.fichier_out        = ''
+    self.liste_mailles      = NP.array( [] )
+    self.liste_sd           = NP.array( [] )
+    self.liste_mailles_bord = []
+    self.liste_sd_bord      = []
+
+    self.MAILLAGE_Python    = None
+
+    self.RELATIONS      = { 'C_plus' : None,
+                            'C_moins': None,
+                            'nr': 0 }
+
+    self.ASTER          = { 'MAILLAGE'        : None,
+                            'MODELE'          : None,
+                            'GROUP_MA'        : None,
+                            'GROUP_MA_BORD'   : None,
+                            'DICO_SD_MAILLES' : None,
+                             }
+
+    self.OPTIONS        = { 'NB_PART'     : '',
+                            'ALGO'        : '',
+                            'INFO'        : '',
+                            'rep_metis'   : aster.repout(),
+                            'exe_metis'   : aster.repout() + 'pmetis',
+                            'fichier_in'  : 'fort.66',
+                            'fichier_out' : 'fort.68',
+                            'elimine_bords': 'OUI',
+                             }
+
+    self.Creation_Dico_Correspondance_Type_Maille()
+
+
+
+# ---------------------------------------------------------------------------- #
+
+  def __str__(self) :
+    """
+      Impression du contenu de la partition
+    """
+    l = []
+    l.append( 'Contenu de la partition :' )
+    l.append( '-------------------------' )
+    try: l.append( '- Maillage       : ' + str(self.ASTER['MAILLAGE'].nom) )
+    except: pass
+    try: l.append( '- Modele         : ' + str(self.ASTER['MODELE'].nom) )
+    except: pass
+    l.append( '- Nb part        : ' + str(self.OPTIONS['NB_PART']) )
+    l.append( '- Niveau INFO    : ' + str(self.OPTIONS['INFO']) )
+    l.append( '- Liste group_ma : ' + str(self.ASTER['GROUP_MA']) )
+
+    return string.join(l,'\n')
+
+# ---------------------------------------------------------------------------- #
+
+  def Partitionne_Aster(self, MAILLAGE, NB_PART, MODELE=None, METHODE=None, LOGICIEL=None, INFO=1):
+
+    self.t00 = time.clock()
+
+    self.OPTIONS['INFO'] = INFO
+
+    if MODELE:
+      # Recuperation de la liste des mailles à perndre en compte
+      self.ASTER['MODELE'] = MODELE
+      self.ASTER['MAILLAGE'] = MAILLAGE
+      _LST_MA = self.Modele_to_Liste_Mailles(MODELE)
+
+    elif MAILLAGE:
+      self.ASTER['MAILLAGE'] = MAILLAGE
+      _LST_MA = None
+
+
+    # Creation du maillage Python correspondant au maillage Aster
+    MAILLAGE_Python = MAIL_PY()
+    MAILLAGE_Python.FromAster(MAILLAGE.nom)
+
+    # Partitionne le maillage Python avec la liste de mailles _LST_MA
+    self.Partitionne_Maillage(MAILLAGE_Python, NB_PART, MAILLE=_LST_MA, METHODE=METHODE, LOGICIEL=LOGICIEL, INFO=INFO)
+
+    return
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Partitionne_Maillage(self, MAILLAGE_Python, NB_PART, MAILLE=None, METHODE=None, LOGICIEL=None, INFO=1):
+
+    self.t00 =  time.clock()
+
+    if METHODE:
+      self.OPTIONS['exe_metis'] = aster.repout() + string.lower(METHODE)
+    elif LOGICIEL:
+      self.OPTIONS['exe_metis'] = LOGICIEL
+
+    self.OPTIONS['NB_PART'] = NB_PART
+    self.OPTIONS['INFO']    = INFO
+    self.MAILLAGE_Python    = MAILLAGE_Python
+
+    exe_metis = self.OPTIONS['exe_metis']
+    f_metis   = self.OPTIONS['fichier_in']
+    fw_metis  = self.OPTIONS['fichier_out']
+
+    _LST_MA = MAILLE
+
+    # On initialise la connectivité et la connectivité inverse des aretes
+    self.MAILLAGE_Python.ca = {}
+    self.MAILLAGE_Python.cia = {}
+
+    _DIM = self.MAILLAGE_Python.dime_maillage[5]
+    _LST_TMA = self.MAILLAGE_Python.tm
+
+    if self.OPTIONS['INFO']>=5:
+      print 'cn=', self.MAILLAGE_Python.cn
+      print 'tm=', self.MAILLAGE_Python.tm
+      print 'co=', self.MAILLAGE_Python.co
+      print 'gma=', self.MAILLAGE_Python.gma
+      print 'gno=', self.MAILLAGE_Python.gno
+      print 'dim=', self.MAILLAGE_Python.dime_maillage
+    if self.OPTIONS['INFO']>=5: print '_LST_MA=', _LST_MA
+
+
+    # Elimination des mailles de bords
+    if self.OPTIONS['elimine_bords']!='NON':
+
+      # Liste des mailles à prendre en compte : dimension _DIM
+      _D_DIM_MAILLES = self.Creation_Listes_Mailles_Par_Dim(self.MAILLAGE_Python.tm, _LST_MA=_LST_MA)
+
+      # Connectivité et connectivité inverse sur les bords
+      self.Connectivite_Aretes()
+
+      self.liste_mailles = _D_DIM_MAILLES[ _DIM ]
+
+      # Pour prendre en compte des mélanges d'elements de dimension differente
+      _LST, _LST_BD = self.Elimination_Mailles_de_bords(MAILLAGE_Python, _D_DIM_MAILLES, _DIM)
+      self.liste_mailles = NP.concatenate( (self.liste_mailles,NP.array(_LST)) )
+
+      if self.OPTIONS['INFO']>=5:
+        print '_LST_BD=',_LST_BD
+        print '_LST=',_LST
+
+    else:
+      self.liste_mailles = _LST_MA
+
+
+    # Restriction des connectivités aux mailles à prendre en compte
+    self.Connectivite_Aretes(OPTION='all', _LST_OK=self.liste_mailles)
+
+    # Creation de l'arbre de connectivité des bords
+    self.Creation_Graphe()
+
+    # Reduction de l'arbre de connectivité des bords
+    _nb = self.Reduction_Graphe(_DIM)
+
+    # Ecriture du fichier pour Metis/Chaco/Jostle
+    _D_CORRES = self.Ecrire_Graphe(f_metis, _nb)
+
+    # Lancement de metis sur le fichier fort.UL (production de fort.UL.part.N)
+    txt = exe_metis + ' ' + f_metis + ' ' + str(NB_PART)
+    print 'Commande : ',txt
+    os.system( txt )
+
+    # Lecture du fichier resultant de Metis
+    self.fichier_out = f_metis + '.part.' + str(NB_PART)
+    self.liste_sd = self.Lecture_fichier_sdd(self.fichier_out, self.liste_mailles)
+
+    # Traitement des mailles de bords (on les reinjecte dans un SD)
+    if self.OPTIONS['elimine_bords']!='NON':
+      self.Affectation_Mailles_de_bords(_LST_BD, _DIM)
+
+    t1 = time.clock()
+    print "--- FIN PARTITIONNEMENT : ", t1 - self.t00
+
+    return
+
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Creation_Dico_Correspondance_Type_Maille(self):
+
+    # TYPE_ELEM : CF. &CATA.TM
+    #   1 - >POI1    <>SEG2    <>SEG22   <>SEG3    <>SEG33   <>SEG4    <>TRIA3   <
+    #   8 - >TRIA33  <>TRIA6   <>TRIA66  <>TRIA7   <>QUAD4   <>QUAD44  <>QUAD8   <
+    #  15 - >QUAD88  <>QUAD9   <>QUAD99  <>TETRA4  <>TETRA10 <>PENTA6  <>PENTA15 <
+    #  22 - >PYRAM5  <>PYRAM13 <>HEXA8   <>HEXA20  <>HEXA27  <>TR3QU4  <>QU4TR3  <
+    #  29 - >TR6TR3  <>TR3TR6  <>TR6QU4  <>QU4TR6  <>TR6QU8  <>QU8TR6  <>TR6QU9  <
+    #  36 - >QU9TR6  <>QU8TR3  <>TR3QU8  <>QU8QU4  <>QU4QU8  <>QU8QU9  <>QU9QU8  <
+    #  43 - >QU9QU4  <>QU4QU9  <>QU9TR3  <>TR3QU9  <>SEG32   <>SEG23   <
+
+    # Creation du dictionnaire des correspondance type_maille -> liste des aretes
+    maille2aretes={}
+    # POI
+    maille2aretes[1]  = [ ]
+    # SEG
+    maille2aretes[2]  = [ (0,1) ]
+    maille2aretes[3]  = maille2aretes[4] = maille2aretes[5] = maille2aretes[6] = maille2aretes[2]
+    # TRIA
+    maille2aretes[7]  = [ (0,1),(1,2),(0,2) ]
+    maille2aretes[8]  = maille2aretes[9] = maille2aretes[10] = maille2aretes[11] = maille2aretes[7]
+    # QUAD
+    maille2aretes[12] = [ (0,1),(1,2),(2,3),(0,3) ]
+    maille2aretes[13] = maille2aretes[14] = maille2aretes[15] = maille2aretes[16] = maille2aretes[17] = maille2aretes[12]
+    # TETRA
+    maille2aretes[18] = [ (0,1,2),(0,1,3),(0,2,3),(1,3,2) ]
+    maille2aretes[19] = maille2aretes[18]
+    # PENTA
+    maille2aretes[20] = [ (0,1,2),(3,4,5),(0,2,5,3),(0,1,4,3),(2,1,4,5) ]
+    maille2aretes[21] = maille2aretes[20]
+    # PYRAM
+    maille2aretes[22] = [ (0,1,4),(1,2,4),(2,3,4),(3,0,4),(0,1,2,3) ]
+    maille2aretes[23] = maille2aretes[22]
+    # HEXA
+    maille2aretes[24] = [ (0,1,2,3), (4,5,6,7), (1,2,6,5), (2,3,7,6), (7,4,0,3), (4,5,1,0) ]
+    maille2aretes[25] = maille2aretes[26] =  maille2aretes[24]
+
+
+    # dictionnaire de correspondance entre type_maille -> nb noeud (maille linéaire)
+    maille2nb={}
+    # POI
+    maille2nb[1]  = 1
+    # SEG
+    maille2nb[2]  = 2
+    maille2nb[3]  = maille2nb[4] = maille2nb[5] = maille2nb[6] = maille2nb[2]
+    # TRIA
+    maille2nb[7]  = 3
+    maille2nb[8]  = maille2nb[9] = maille2nb[10] = maille2nb[11] = maille2nb[7]
+    # QUAD
+    maille2nb[12] = 4
+    maille2nb[13] = maille2nb[14] = maille2nb[15] = maille2nb[16] = maille2nb[17] = maille2nb[12]
+    # TETRA
+    maille2nb[18] = 4
+    maille2nb[19] = maille2nb[18]
+    # PENTA
+    maille2nb[20] = 5
+    maille2nb[21] = maille2nb[20]
+    # PYRAM
+    maille2nb[22] = 5
+    maille2nb[23] = maille2nb[22]
+    # HEXA
+    maille2nb[24] = 6
+    maille2nb[25] = maille2nb[26] =  maille2nb[24]
+
+
+    # dictionnaire de correspondance entre type_maille -> dimension
+    maille2dim = {}
+    # POI
+    maille2dim[1]  = 0
+    # SEG
+    maille2dim[2]  = 1
+    maille2dim[3]  = maille2dim[4] = maille2dim[5] = maille2dim[6] = maille2dim[2]
+    # TRIA
+    maille2dim[7]  = 2
+    maille2dim[8]  = maille2dim[9] = maille2dim[10] = maille2dim[11] = maille2dim[7]
+    # QUAD
+    maille2dim[12] = 2
+    maille2dim[13] = maille2dim[14] = maille2dim[15] = maille2dim[16] = maille2dim[17] = maille2dim[12]
+    # TETRA
+    maille2dim[18] = 3
+    maille2dim[19] = maille2dim[18]
+    # PENTA
+    maille2dim[20] = 3
+    maille2dim[21] = maille2dim[20]
+    # PYRAM
+    maille2dim[22] = 3
+    maille2dim[23] = maille2dim[22]
+    # HEXA
+    maille2dim[24] = 3
+    maille2dim[25] = maille2dim[26] =  maille2dim[24]
+
+    # On stocke les dictionnaires
+    self.maille2aretes = maille2aretes
+    self.maille2nb     = maille2nb
+    self.maille2dim    = maille2dim
+
+    return
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Modele_to_Liste_Mailles(self, MODELE):
+
+    nommod = string.ljust(MODELE.nom,8)
+    _DIC_MA  = aster.getcolljev(nommod.ljust(8)+'.MODELE    .LIEL')
+
+    # Creation de la liste des mailles
+    ll = []
+    for type_maille in _DIC_MA.keys():
+      ll.extend( _DIC_MA[type_maille][0:-1] )
+    _LST_MA = NP.array( ll ) - 1
+
+    if self.OPTIONS['INFO']>=5:
+      print '\n# ----- MODELE ----- #\n'
+      print '_LST_MA=',len(_LST_MA),_LST_MA
+      print '_DIC_MA=',len(_DIC_MA),_DIC_MA
+
+    return _LST_MA
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Creation_Listes_Mailles_Par_Dim(self, _LST_TMA, _LST_MA=None):
+
+    t0 = time.clock()
+
+    # Si _LST_MA est renseigné on extrait la liste des TMA correspondante aux mailles de _LST_MA
+    if _LST_MA != None:
+      _LST_TMA = NP.take(_LST_TMA,_LST_MA)
+    else:
+      _LST_MA = NP.arange(len(_LST_TMA))
+
+    _D_DIM_MAILLES = {}
+
+    # Liste des mailles 3D (type maille de 18 à 26)
+    _lst = NP.where( _LST_TMA>=18, -3, _LST_TMA )
+    _tmp = NP.where( _lst==-3, -1, 0 )
+#    _D_DIM_MAILLES[3] = NP.nonzero( _tmp )
+    _D_DIM_MAILLES[3] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] )
+
+    # Liste des mailles 2D (type maille de 7 à 17)
+    _lst = NP.where( _lst>=7, -2, _lst )
+    _tmp = NP.where( _lst==-2, -1, 0 )
+    _D_DIM_MAILLES[2] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] )
+
+    # Liste des mailles 1D (type maille de 2 à 6)
+    _lst = NP.where( _lst>=2, -1, _lst )
+    _tmp = NP.where( _lst==-1, -1, 0 )
+    _D_DIM_MAILLES[1] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] )
+
+    # Liste des mailles 0D (type maille 1)
+    _lst = NP.where( _lst>=1, -4, _lst )
+    _tmp = NP.where( _lst==-4, -1, 0 )
+    _D_DIM_MAILLES[0] = NP.take(_LST_MA, NP.nonzero( _tmp )[0] )
+
+
+    if self.OPTIONS['INFO']>=5:
+      for i in _D_DIM_MAILLES.keys():
+        print "-----------------"
+        print 'Dim:',i, _D_DIM_MAILLES[i]
+      print "-----------------"
+
+    print "--- FIN Creation des listes de mailles par Dim : ", time.clock() - t0
+
+    return _D_DIM_MAILLES
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Connectivite_Aretes(self, OPTION=None, _LST_OK=None):
+
+    t0 = time.clock()
+
+    # Si _LST_OK n'est pas renseigné on prend toutes les mailles
+    if not _LST_OK: _LST_OK = NP.arange(len(self.MAILLAGE_Python.tm))
+
+    if self.OPTIONS['INFO']>=5: print '_LST_OK (ca)=',_LST_OK
+
+    maille2aretes = self.maille2aretes
+
+    # Creation de la :
+    #   - connectivite des aretes (self.MAILLAGE_Python.ca) : m1 -> [ (a1, a2), .. ]
+    #   - connectivite inverse des aretes (self.MAILLAGE_Python.cia) : (a1, a2) -> [ m1, m2, ... ]
+
+    self.MAILLAGE_Python.ca  = {}
+    self.MAILLAGE_Python.cia = {}
+
+    for n in _LST_OK:
+
+        n1 = self.MAILLAGE_Python.tm[n]
+
+        l_aretes = maille2aretes[n1]           # liste des aretes de la maille n
+        l_noeuds = self.MAILLAGE_Python.co[n]  # liste des noeuds de la maille n
+
+        for arete in l_aretes:
+          ll = []
+          for i in arete:
+            ll.append( l_noeuds[i] )
+          ll.sort()
+          ll = tuple(ll)
+
+          # Table de connectivité des aretes
+          if OPTION:
+            if not self.MAILLAGE_Python.ca.has_key(n): self.MAILLAGE_Python.ca[n]=[]
+            self.MAILLAGE_Python.ca[n].append(ll)
+#             try:
+#               self.MAILLAGE_Python.ca[n].append(ll)
+#             except KeyError:
+#               self.MAILLAGE_Python.ca[n]=[ll]
+
+          # Table de connectivité inverse des aretes
+          if not self.MAILLAGE_Python.cia.has_key(ll): self.MAILLAGE_Python.cia[ll]=[]
+          self.MAILLAGE_Python.cia[ll].append(n)
+#           try:
+#             self.MAILLAGE_Python.cia[ll].append(n)
+#           except KeyError:
+#             self.MAILLAGE_Python.cia[ll]=[n]
+
+
+    if self.OPTIONS['INFO']>=5:
+      for k in self.MAILLAGE_Python.cia.keys():
+        print 'cia:',k, '     ', self.MAILLAGE_Python.cia[k]
+      if OPTION:
+        for k in self.MAILLAGE_Python.ca.keys():
+          print 'ca: ',k, '     ', self.MAILLAGE_Python.ca[k]
+
+
+    print "--- FIN Creation de la connectivite simple et inverse des aretes : ", time.clock() - t0
+
+    return
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Elimination_Mailles_de_bords(self, MAILLAGE_Python, _D_DIM_MAILLES, _DIM):
+    """
+    Extraction des mailles de bords (mailles incluses dans un bord d une autre maille)
+    """
+
+    t0 = time.clock()
+
+    _LST_TMA = self.MAILLAGE_Python.tm
+
+    if self.OPTIONS['INFO']>=5:
+      MAILLAGE = self.ASTER['MAILLAGE']
+      nommail = string.ljust(MAILLAGE.nom,8)
+      _LST_MAI = aster.getvectjev(nommail.ljust(8)+'.NOMMAI')
+
+    # Le dico maille2nb donne le nombre de noeuds definissant un bord (lineaire)
+    maille2nb = self.maille2nb
+
+
+    # construction des listes des mailles de dim N-1 :
+    # _LST_OK :   Mailles de dim N-i qui ne sont pas un bord des mailles de dim N
+    # _LST_BD :   Mailles de dim N-i qui sont un bord
+    #
+    if self.OPTIONS['INFO']>=5: print '\n\nElimination des mailles de bord de DIM', _DIM - 1
+
+    _LST4 = _D_DIM_MAILLES[ _DIM - 1 ]
+    _LST_IND = NP.arange( len(_LST4) ) + 1  # on ajoute 1 pour eviter le premier 0 dans les test nonzero plus bas
+
+    if self.OPTIONS['INFO']>=5: print '  Mailles concernées=',_LST4
+
+    i=0
+    for m in _LST4:
+      if self.OPTIONS['INFO']>=5: print '\n  Maille de dim N-1:',m, ' Aster:',string.strip(_LST_MAI[m]), ' TMA:',self.MAILLAGE_Python.tm[m], ' CO:',self.MAILLAGE_Python.co[m], '(noeuds de cette maille)'
+      nb = maille2nb[ self.MAILLAGE_Python.tm[m] ]
+      ll = self.MAILLAGE_Python.co[m][0:nb]
+      ll = NP.sort(ll)
+      ll = ll.tolist()
+      ll = tuple(ll)
+      if self.OPTIONS['INFO']>=5: print '  Bord (lineaire)', ll, nb
+
+      try:
+        if self.OPTIONS['INFO']>=5: print '  CIA=', self.MAILLAGE_Python.cia[ ll ], '(mailles de dim N qui ont cette maille pour bord)'
+        _tmp=[]
+        for maille in self.MAILLAGE_Python.cia[ ll ]:
+          if self.OPTIONS['INFO']>=5: print '  Maille N:', maille, 'Aster:', string.strip(_LST_MAI[maille]), ' TMA:', self.MAILLAGE_Python.tm[maille]
+#        self.liste_mailles_bord.append(m)
+      except:
+        if self.OPTIONS['INFO']>=5: print '  Maille non-bord'
+        _LST_IND[i] = 0
+
+      i+=1
+
+    # Recuperation des mailles de bords et non-bords
+    _LST_BD = NP.nonzero(_LST_IND)[0]
+    _LST_BD = NP.take(_LST4,_LST_BD)
+
+    _LST_OK = NP.where( _LST_IND==0, 1 , 0 )
+    _LST_OK = NP.nonzero(_LST_OK)[0]
+    _LST_OK = NP.take(_LST4,_LST_OK)
+
+    if self.OPTIONS['INFO']>=5: print '\nListe Maille de bords de DIM', _DIM - 1,' :',_LST_BD
+    if self.OPTIONS['INFO']>=5: print 'Liste Maille de DIM', _DIM - 1,'qui ne sont pas des bords :',_LST_OK
+
+    print "--- FIN Maille de bords de DIM",_DIM - 1, " : ", time.clock() - t0
+    t0 = time.clock()
+
+
+    # On cherche à marier les mailles de dimension N-2, N-3
+    # Peut etre lent car on utilise la connectivité ! Mais pour le moment on a rien d'autre.
+
+    _LST_BD0 = []
+    _LST_OK0 = []
+    _D_BD = {}
+    for d in range(_DIM-1):
+      _LST4 = _D_DIM_MAILLES[ d ]
+      if self.OPTIONS['INFO']>=5: print '\n\nElimination des mailles de bord de DIM', d
+      if self.OPTIONS['INFO']>=5: print '  Mailles concernées=',_LST4
+      for mai in _LST4:
+        if self.OPTIONS['INFO']>=5: print '\n  Maille:', mai, ' Aster:',string.strip(_LST_MAI[mai]), ' TMA:',self.MAILLAGE_Python.tm[mai], ' CO:',self.MAILLAGE_Python.co[mai], '(noeuds de cette maille)'
+
+        nb = maille2nb[ self.MAILLAGE_Python.tm[mai] ]
+        ll = self.MAILLAGE_Python.co[mai][0:nb]
+        ll = NP.sort(ll)
+        ll = ll.tolist()
+        _tmp = tuple(ll)
+#        _tmp = self.MAILLAGE_Python.co[mai]
+
+        if self.OPTIONS['INFO']>=5: print '  Bord (lineaire):', _tmp, nb
+
+        ok=0
+        for arete in self.MAILLAGE_Python.cia:
+          _nb=0
+          for noe in _tmp:
+            if noe in arete: _nb+=1
+          if _nb == len(_tmp):
+            if self.OPTIONS['INFO']>=5: print '  Maille N+i:', self.MAILLAGE_Python.cia[arete], '- Arete:', arete
+            _LST_BD0.append( mai )
+            ok=1
+#             if not _D_BD.has_key( mai ): _D_BD[mai] = []
+#             _D_BD[mai].append( self.MAILLAGE_Python.cia[arete] )
+            break
+        if ok == 0:
+          _LST_OK0.append( mai )
+
+#        print 'Mai:',mai, '_D_BD[mai]=',_D_BD[mai]
+
+
+      if self.OPTIONS['INFO']>=5: print '\nListe Maille de bords de DIM', d,' :',_LST_BD0
+      if self.OPTIONS['INFO']>=5: print 'Liste Maille de DIM', d,'qui ne sont pas des bords :',_LST_OK0
+
+
+      print '--- FIN Maille de bords de DIM', d, ' :',time.clock() - t0
+      t0 = time.clock()
+
+
+    _LST_OK = NP.concatenate( (_LST_OK, NP.array(_LST_OK0)) )
+    _LST_BD = NP.concatenate( (_LST_BD, NP.array(_LST_BD0)) )
+
+    if self.OPTIONS['INFO']>=5: print '\nTotal:\nListe Maille de bords=',_LST_BD
+    if self.OPTIONS['INFO']>=5: print 'Liste Maille non-bords=',_LST_OK,'\n'
+
+#    print "--- FIN Maille de bords 3 : ", time.clock() - t0
+
+    return _LST_OK, _LST_BD
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Affectation_Mailles_de_bords(self, _LST_BD, _DIM):
+    """
+    Affectation a un SD des mailles de bords (mailles incluses dans un bord d une autre maille)
+    """
+
+    if self.OPTIONS['INFO']>=5:
+      print 'liste_mailles_bord=', self.liste_mailles_bord
+      print 'liste_sd_bord', self.liste_sd_bord
+      print '_LST_BD=',_LST_BD
+
+
+    MAILLAGE = self.ASTER['MAILLAGE']
+    _LST_TMA = self.MAILLAGE_Python.tm
+
+    if self.OPTIONS['INFO']>=5:
+      nommail = string.ljust(MAILLAGE.nom,8)
+      _LST_MAI = aster.getvectjev(nommail.ljust(8)+'.NOMMAI')
+
+    t0 = time.clock()
+
+    # Affectation des mailles de bords à chacun des SD
+
+    # Le dico maille2nb donne le nombre de noeuds definissant un bord (lineaire)
+    maille2nb = self.maille2nb
+
+    i = 0
+    for m in _LST_BD:
+      if self.OPTIONS['INFO']>=5: print '\n  Maille de dim N-1:',m, ' Aster:',string.strip(_LST_MAI[m]), ' TMA:',self.MAILLAGE_Python.tm[m], ' CO:',self.MAILLAGE_Python.co[m], '(noeuds de cette maille)'
+      nb = maille2nb[ self.MAILLAGE_Python.tm[m] ]
+      ll = self.MAILLAGE_Python.co[m][0:nb]
+      ll = NP.sort(ll)
+      ll = ll.tolist()
+      ll = tuple(ll)
+      if self.OPTIONS['INFO']>=5: print '  Bord (lineaire)', ll, nb
+
+      # Cas particulier des POI1 en 2D et 3D (ils ne peuvent etre des bords d'elements 2D ou 3D)
+      if ( (nb==1) and (_DIM>=2) ):
+        _tmp=[]
+        for arete in self.MAILLAGE_Python.cia.keys():
+          if ll[0] in arete:
+            for maille in self.MAILLAGE_Python.cia[ arete ]:
+              if self.OPTIONS['INFO']>=5: print '  Maille N+i:', maille, ' Aster:',string.strip(_LST_MAI[maille]), ' Arete:', arete
+              _tmp.append( self.liste_sd[maille] )
+
+      # Cas particulier des SEG en 3D (ils ne peuvent etre des bords d'elements 3D)
+      elif ( (nb==2) and (_DIM==3) ):
+        _tmp=[]
+        for arete in self.MAILLAGE_Python.cia.keys():
+          _nb=0
+          for noe in ll:
+            if noe in arete: _nb+=1
+          if _nb == len(ll):
+            for maille in self.MAILLAGE_Python.cia[arete]:
+              if self.OPTIONS['INFO']>=5: print '  Mailles N+i:', maille, ' Aster:',string.strip(_LST_MAI[maille]), ' Arete:', arete
+              _tmp.append( self.liste_sd[maille] )
+
+      # Autres mailles de bord
+      else:
+        if self.OPTIONS['INFO']>=5: print '  CIA=', self.MAILLAGE_Python.cia[ ll ], '(mailles de dim N qui ont cette maille pour bord)'
+        _tmp=[]
+        for maille in self.MAILLAGE_Python.cia[ ll ]:
+          if self.OPTIONS['INFO']>=5: print '  Maille N+i:', maille, 'Aster:', string.strip(_LST_MAI[maille]), ' SD:', self.liste_sd[maille], ' TMA:', self.MAILLAGE_Python.tm[maille]
+          _tmp.append( self.liste_sd[maille] )
+
+      # integre la maille au SD le plus faible (pour que des groupes de bords se retrouvent dans le meme SD)
+      _tmp.sort()
+      self.liste_mailles_bord.append(m)
+      self.liste_sd_bord.append( _tmp[0] )
+      i += 1
+      if self.OPTIONS['INFO']>=5: print '  ---> Maille:',m,'integree au SD:', _tmp[0]
+
+    if self.OPTIONS['INFO']>=5:
+      print '\n\nliste_mailles_bord=', self.liste_mailles_bord
+      print 'liste_sd_bord=', self.liste_sd_bord
+
+
+    print "--- FIN Affectation des mailles de bords : ", time.clock() - t0
+
+    return
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Creation_Graphe(self):
+
+    t0 = time.clock()
+
+    # Creation du graphe complet
+    self.GRAPH = {}
+
+    for mai in self.liste_mailles:
+      _ll=[]
+      for are in self.MAILLAGE_Python.ca[mai]:
+        _ll.extend( self.MAILLAGE_Python.cia[are] )
+        _mm = enleve_doublons_liste(_ll)  # coute cher!
+      _tmp = _mm.tolist()
+      _tmp.remove(mai)
+      self.GRAPH[mai] = _tmp
+
+      if self.OPTIONS['INFO']>=5: print 'self.GRAPH['+str(mai)+']=', self.GRAPH[mai]
+
+    print "--- FIN Creation du graphe complet : ", time.clock() - t0
+
+    return
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Reduction_Graphe(self, _DIM):
+
+    t0 = time.clock()
+
+    # Elimination des connectivités à interface nulle
+    maille2dim = self.maille2dim
+    _lst2 = []
+    for mai in self.liste_mailles:
+      if self.OPTIONS['INFO']>=5: print '\nmai:', mai, 'co:', self.MAILLAGE_Python.co[mai], 'tm:', self.MAILLAGE_Python.tm[mai]
+      _DIM1 = maille2dim[ self.MAILLAGE_Python.tm[mai] ]
+      _tmp2 =[]
+      for mai2 in self.GRAPH[mai]:
+        if self.OPTIONS['INFO']>=5: print 'mai2:', mai2, 'co:', self.MAILLAGE_Python.co[mai2], 'tm:', self.MAILLAGE_Python.tm[mai2]
+        # calcule le nombre de noeuds communs aux deux mailles
+        _nb = 0
+        for noe in self.MAILLAGE_Python.co[mai2]:
+          if noe in self.MAILLAGE_Python.co[mai]: _nb += 1
+        _DIM2 = maille2dim[ self.MAILLAGE_Python.tm[mai2] ]
+        if _nb >= min(_DIM1, _DIM2):  # le min permet de faire du collage 3D-coque par exemple
+          _tmp2.append( mai2 )
+          _tmp = [mai, mai2]
+          _tmp.sort()
+          _lst2.append(_tmp)
+      self.GRAPH[mai] = _tmp2
+
+    print "--- FIN Elimination des connectivités avec une interface nulle : ", time.clock() - t0
+    t0 = time.clock()
+
+
+    # Calcul du nombre d'aretes
+    # A voir : normalement il n'y a rien a faire car nb0 = 2*nb (a verifier...)
+    _lst2.sort()
+    _v = _lst2[0]
+    _nb = 1
+    for i in _lst2:
+      if i != _v:
+        _v = i
+        _nb += 1
+
+
+    if self.OPTIONS['INFO']>=5:
+      print '----------------------------------------------'
+      for mai in self.liste_mailles:
+        print 'self.GRAPH['+str(mai)+']=', self.GRAPH[mai]
+      print '----------------------------------------------'
+
+    return _nb
+
+
+# ------------------------------------------------------------------ #
+
+  def Ecrire_Graphe(self, f_metis, _nb):
+
+    t0 = time.clock()
+
+    # On doit renumeroter les mailles qui arrivent dans self.liste_mailles pour avoir 0... N-1
+    _D_CORRES = {}
+    for i in NP.arange(len(self.liste_mailles)):
+      _D_CORRES[ self.liste_mailles[i] ] = i
+
+    # Ecriture du fichier fort.UL pour metis
+    fw = open(f_metis,'w')
+    fw.write( str(len(self.liste_mailles)) + ' ' +  str(_nb) + '\n')
+    for l in self.liste_mailles:
+#      try:
+        _tmp = []
+        for t in self.GRAPH[l]:
+          try:
+            t = _D_CORRES[t]
+            _tmp.append( str(t+1) )    # Necessaire car metis numerote de 1 à N
+          except:
+            print 'on oublie le bord:', t
+        fw.write( string.join(_tmp, ' ') + '\n' )
+#      except:
+#        print 'Probleme ecriture graphe! On continue..'
+    fw.close()
+
+    print "--- FIN Ecriture du fichier du graphe pour metis : ", time.clock() - t0
+
+    return _D_CORRES
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Lecture_fichier_sdd(self, fichier, _LST_OK):
+
+    t0 = time.clock()
+
+    # Lecture du fichier produit par metis (partie a optimiser)
+    try:
+      f = open( fichier, 'r' )
+    except:
+      print "\n\n          ERREUR: le fichier est introuvable! Le partitionneur \n          ne s'est probablement pas lancé.\n\n"
+      sys.exit(1)
+    else:
+      _tmp = []
+      for l in f.readlines():
+        _tmp.append( int(string.strip(l)) )
+      f.close()
+      _l_domaines = NP.array(_tmp,copy=0)
+
+      # Pour garder le fichier metis
+      os.system( 'mv ' + fichier + ' REPE_OUT/' )
+
+      if self.OPTIONS['INFO']>=5: print '_l_domaines=',_l_domaines
+
+      print "--- FIN Lecture du fichier produit par metis : ", time.clock() - t0
+
+    return _l_domaines
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Creation_Group_ma_Python_par_SD(self, NOM='SD', NOM2='B'):
+
+    t0 = time.clock()
+
+    NB_PART = self.OPTIONS['NB_PART']
+
+    # Creation du dictionnaire des listes des mailles par SD
+    #     d_gma : { num sd -> [ liste mailles ] }
+    d_gma = {}
+    for i in range(NB_PART):
+      d_gma[i] = []
+
+    i=0
+    for sdd in self.liste_sd:
+      d_gma[sdd].append( self.liste_mailles[i] )
+      i+=1
+
+
+    # Creation du dictionnaire des listes des mailles de bord par SD
+    #     d_gma_bord : { num sd -> [ liste mailles ] }
+    d_gma_bord = {}
+    for i in range(NB_PART):
+      d_gma_bord[i] = []
+
+    i=0
+    for sdd in self.liste_sd_bord:
+      d_gma_bord[sdd].append( self.liste_mailles_bord[i] )
+      i+=1
+
+
+    # Generation des listes de noms de groupes
+    _l_sd = []
+    _l_bord = []
+    for i in range(NB_PART):
+      if d_gma[i] != []:
+        _l_sd.append( NOM + str(i) )
+      if d_gma_bord[i] != []:
+        _l_bord.append( NOM2 + str(i) )
+
+    # Stockage
+    self.ASTER['GROUP_MA']        = _l_sd
+    self.ASTER['GROUP_MA_BORD']   = _l_bord
+
+
+    # Creation des groupes de mailles dans le Maillage Python
+    for i in range(NB_PART):
+      self.MAILLAGE_Python.gma[NOM+str(i)]  = d_gma[i]
+      self.MAILLAGE_Python.gma[NOM2+str(i)] = d_gma_bord[i]
+
+    print "--- FIN creation du dictionnaire des listes des mailles par SD ", time.clock() - t0
+
+    return
+
+
+# ---------------------------------------------------------------------------- #
+
+  def Creation_Group_ma_Aster_par_SD(self, NOM='SD', NOM2='B', INCLUSE='NON'):
+
+    t0 = time.clock()
+
+    MAILLAGE    = self.ASTER['MAILLAGE']
+    NB_PART     = self.OPTIONS['NB_PART']
+
+    nommail     = string.ljust(MAILLAGE.nom,8)
+    _LST_MAI    = aster.getvectjev(nommail.ljust(8)+'.NOMMAI')
+
+
+    # Creation du dictionnaire des listes des mailles par SD
+    #     d_gma : { num sd -> [ liste mailles ] }
+    d_gma = {}
+    for i in range(NB_PART):
+      d_gma[i] = []
+
+    m=0
+    for sdd in self.liste_sd:
+      d_gma[sdd].append( string.strip(_LST_MAI[ self.liste_mailles[m] ]) )   # voir si le strip coute cher !
+      m += 1
+
+
+    # Creation du dictionnaire des listes des mailles de bord par SD
+    #     d_gma_bord : { num sd -> [ liste mailles ] }
+    d_gma_bord = {}
+    for i in range(NB_PART):
+      d_gma_bord[i] = []
+
+    # On inclus directement les mailles de bords dans les SD
+    if INCLUSE=='OUI':
+      m=0
+      for sdd in self.liste_sd_bord:
+        d_gma[sdd].append( string.strip(_LST_MAI[ self.liste_mailles_bord[m] ]) )   # voir si le strip coute cher !
+        m+=1
+
+    else:
+      m=0
+      for sdd in self.liste_sd_bord:
+        d_gma_bord[sdd].append( string.strip(_LST_MAI[ self.liste_mailles_bord[m] ]) )   # voir si le strip coute cher !
+        m+=1
+
+
+    print "--- FIN creation du dictionnaire des listes des mailles par SD ", time.clock() - t0
+    t0 = time.clock()
+
+
+    # Creation et lancement de la commande DEFI_GROUP associée
+    try:
+      DEFI_GROUP = self.jdc.get_cmd('DEFI_GROUP')
+    except:
+      try:
+        from Cata.cata import DEFI_GROUP
+      except:
+        print "\n\nERREUR : il faut lancer ce programme depuis Aster pour pouvoir \ngénérer les groupes de mailles Aster.\n\n"
+        return
+
+    _tmp  = []
+    _l_sd = []
+    _l_bord = []
+    for i in range(NB_PART):
+      if d_gma[i] != []:
+        _tmp.append( {'MAILLE': d_gma[i],'NOM': NOM + str(i)} )
+        _l_sd.append( NOM + str(i) )
+      if d_gma_bord[i] != []:
+        _tmp.append( {'MAILLE': d_gma_bord[i],'NOM': NOM2 + str(i)} )
+        _l_bord.append( NOM2 + str(i) )
+
+    motscle2= {'CREA_GROUP_MA': _tmp }
+
+    DEFI_GROUP( reuse=MAILLAGE,
+                MAILLAGE=MAILLAGE,
+                INFO=1,
+                **motscle2
+               ) ;
+
+    # Stockage
+    self.ASTER['DICO_SD_MAILLES'] = d_gma
+    self.ASTER['GROUP_MA']        = _l_sd
+    self.ASTER['GROUP_MA_BORD']   = _l_bord
+
+    print "--- FIN Creation et lancement de la commande DEFI_GROUP associée : ", time.clock() - t0
+
+    return
+
+# ---------------------------------------------------------------------------- #

diff --git a/Aster/Cata/cataSTA10/Utilitai/stats.py b/Aster/Cata/cataSTA10/Utilitai/stats.py
new file mode 100644 (file)
index 0000000..eb338b0
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/stats.py
@@ -0,0 +1,61 @@
+#@ MODIF stats Utilitai  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS 
+
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# extract from pystat module
+#
+from math import pi,sqrt,log,exp,pow
+import numpy
+# CDF
+#
+# -------------------------------------------------------------------
+def normcdf(X):
+    # Cumulative normal distribution
+
+    (a1,a2,a3,a4,a5) = (0.31938153, -0.356563782, 1.781477937, -1.821255978, 1.330274429)
+    L = numpy.absolute(X)
+    K = 1.0 / (1.0 + 0.2316419 * L)
+    w = 1.0 - 1.0 / sqrt(2*pi)*exp(-L*L/2.) * (a1*K + a2*K*K + a3*pow(K,3) +
+    a4*pow(K,4) + a5*pow(K,5))
+    if X<0:
+        w = 1.0-w
+    return w
+
+# Inverse CDF
+def normicdf(v):
+   if v > 0.5:
+      r = -1.
+   else:
+      r = 1.
+   xp = 0.
+   lim = 1.e-20
+   p = [-0.322232431088, -1.0, -0.342242088547, -0.0204231210245, -0.453642210148e-4]
+   q = [0.0993484626060, 0.588581570495, 0.531103462366, 0.103537752850, 0.38560700634e-2]
+
+   if v < lim or v == 1:
+      return -1./lim
+   elif v == 0.5:
+      return 0
+   elif v > 0.5:
+      v = 1.-v
+   y = sqrt(log(1./v**2.))
+   xp = y+((((y*p[4]+p[3])*y+p[2])*y+p[1])*y+p[0])/((((y*q[4]+q[3])*y+q[2])*y+q[1])*y+q[0])
+   if v < 0.5:
+      xp *= -1.
+   return xp*r
+#--

diff --git a/Aster/Cata/cataSTA10/Utilitai/sup_gmsh.py b/Aster/Cata/cataSTA10/Utilitai/sup_gmsh.py
new file mode 100644 (file)
index 0000000..7d62cee
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/sup_gmsh.py
@@ -0,0 +1,1416 @@
+#@ MODIF sup_gmsh Utilitai  DATE 26/05/2010   AUTEUR ASSIRE A.ASSIRE 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+import os.path, string, os, copy
+import numpy as NP
+
+try :
+  from Cata.cata import *
+  from Accas import _F
+except :
+  print 'Fonctionnalites Aster indisponibles'
+
+
+_CARAC = {
+  'prec' : 1.E-8
+  }
+
+
+def Class_search(class_name, target_class) :
+
+  """
+    Check that class_name inherits from target_class
+    (run recursively through the inheritance lists)
+  """
+
+  if class_name == target_class : return 1
+
+  for cl in class_name.__bases__ :
+    if Class_search(cl, target_class) : return 1
+  return 0
+
+
+def Progress(L,**para) :
+
+  """
+    Compute the unknown parameters for a geometric progression :
+      r = ratio
+      N = number of elements
+      h = initial size
+
+    So that :
+      L = Sum(i=0:N-1, h(i)) where h(i+1) = h(i)*r, h(0)=h
+
+    Usage :
+      Progress(L,r=...,N=...) -> h
+      Progress(L,r=...,h=...) -> N
+      Progress(L,h=...,N=...) -> r
+
+  """
+
+  prec = 1.E-4
+
+ # Calcul de N
+  if 'N' not in para.keys() :
+    r = float(para['r'])
+    h = float(para['h'])
+    N = log(1+(r-1)*L/h)/log(r)
+    N = int(N+0.5)
+    return N
+
+ # Calcul de h
+  elif 'h' not in para.keys() :
+    r = float(para['r'])
+    N = int(para['N']+0.5)
+    h = L*(r-1)/(r**N-1)
+    return h
+
+ # Calcul de r
+  elif 'r' not in para.keys() :
+    h = float(para['h'])
+    N = int(para['N']+0.5)
+    a = L/h
+    if N > a :
+      x = 0
+    else :
+      x = a**(1./(N-1))
+
+    for i in xrange(100) :
+      res = x**N - a*x + a-1
+      if abs(res) < prec*(x-1)*a :
+        return x
+      dx = res/(a-N*x**(N-1))
+      x = x+dx
+
+    raise 'Solution failure'
+
+  else :
+    raise 'Unknown parameters'
+
+
+
+def Is_Geometric(object) :
+
+  """
+    return true if the object inherits of the Geometric class
+  """
+
+  return Class_search(object.__class__, Geometric)
+
+
+
+# --------------------------------------------------------------------------------------
+
+class Geometric :
+
+  """
+    GENERIC CLASS FOR GEOMETRICAL OBJECTS
+
+    private attribute
+     parameters  : dictionnary of the attributes (except relation and parameters itself)
+                   see __getattr__ and __setattr__
+
+
+    Attributes
+     num         : index among gmsh objects
+     md          : mesh descriptor
+     mesh        : related mesh object
+     relation    : model object in case of coincidence
+     type        : type of the object (None, Point, Line, Circle, Surface, Volume)
+
+    Public methods
+     Is_point : return true is the object inherits of the Point class
+
+     Is_line  : return true is the object inherits of the Line class
+
+     Is_surface : return true is the object inherits of the Surface class
+
+     Is_volume : return true is the object inherits of the Volume class
+
+     Base_class : return the name of the base class : Point, Line, Surface
+                     or Volume
+
+     Is_same_dimension : return true is both objects are of the same dimension
+                         (point, line, surface or volume)
+       in -> object to compare to self
+
+     Duplicate   : duplicate an object and base its mesh_descriptor
+                   on the mesh_descriptor of the model
+
+     Coincide    : assert that an object is coincident with a model one
+                   All the attributes are then automatically read from
+                   the model object (see __setattr__ and __getattr__).
+       in -> model object
+
+    Private method
+
+     Root :
+       Provides the root object of an object, ie the object itself if there is no relation
+       or the deepest model in case of relation.
+
+     Geometric_coincide : check if a geometrical coincidence is possible
+                          return information about the coincidence, false else.
+       in -> model object
+
+     Deep_coincide : proceed recursively to ensure coincidence of the relevant sub-objects
+       in -> model object
+       in -> correspond (information returned by Geometric_coincide)
+
+     __setattr__ : distinguish two sets of attributes
+                    relation (to express a relation with a model object in case of coincidence)
+                    all the other attributes which are stored in the dictionnary parameters
+                    instead of the usual __dict__ if there is no relation (see Coincide)
+                    and in the model object if there is a coincidence
+
+     __getattr__ : if the object is related (relation <> None) the attribute is read
+                   in the model object. Else, it is read in the current object, actually
+                   in the dictionnary parameters (see __setattr__)
+
+     Thanks to these two overloaded methods, the access to the attributes is usual if
+     there is no relation whereas the attributes of the model object are accessed
+     transparently if there is a relation.
+
+     __cmp__ :
+       The comparison of two objects involves possible coincidence. It is no more the object ids
+       that are compared but the object roots (.relation if any).
+
+     Gmsh  : produce the source code for Gmsh
+       in -> mesh
+
+     Gmsh_send : send a line code to the gmsh interpreter
+       in -> line_code (string)
+
+     Intermediate_meshing : produce the source code for the intermediate objects
+       in -> mesh
+
+     Object meshing : produce the source code for the current object
+       var -> object number (modified if several objects are created)
+
+  """
+
+  def __init__(self) :
+    self.relation    = None
+    self.parameters  = {}
+    self.num         = 0
+    self.md          = Mesh_Descriptor()
+
+    types = {}
+    types[Geometric]   = 'Geometric'
+    types[Point]       = 'Point'
+    types[Line]        = 'Line'
+    types[Circle]      = 'Circle'
+    types[Surface]     = 'Surface'
+    types[Volume]      = 'Volume'
+    types[LineLoop]    = 'LineLoop'
+    types[SurfaceLoop] = 'SurfaceLoop'
+    try :
+      self.type = types[self.__class__]
+    except KeyError :
+      raise 'Unknown object type'
+
+
+  def Is_point(self) :
+    return Class_search(self.__class__, Point)
+
+  def Is_line(self) :
+    return Class_search(self.__class__, Line)
+
+  def Is_surface(self) :
+    return Class_search(self.__class__, Surface)
+
+  def Is_volume(self) :
+    return Class_search(self.__class__, Volume)
+
+  def Base_class(self) :
+    if self.Is_volume()  : return 'Volume'
+    if self.Is_surface() : return 'Surface'
+    if self.Is_line()    : return 'Line'
+    if self.Is_point()   : return 'Point'
+
+  def Is_same_dimension(self, obj) :
+
+    return (
+      (self.Is_point()    and  obj.Is_point()   ) or
+      (self.Is_line()     and  obj.Is_line()    ) or
+      (self.Is_surface()  and  obj.Is_surface() ) or
+      (self.Is_volume()   and  obj.Is_volume()  )
+      )
+
+
+  def __setattr__(self, attr, value) :
+
+    if attr in ['relation','parameters'] :
+      self.__dict__[attr] = value
+    else :
+      if self.relation :
+        setattr(self.relation,attr,value)
+      else :
+        self.parameters[attr] = value
+
+
+  def __getattr__(self,attr) :
+
+    if self.relation :
+      return (getattr(self.relation,attr))
+    else :
+      if attr in self.parameters.keys() :
+        return self.parameters[attr]
+      else :
+        raise AttributeError,attr
+
+
+  def Root(self) :
+
+    o = self
+    while o.relation : o = o.relation
+    return o
+
+
+  def __cmp__(self,obj) :
+
+    if self.Root() is obj.Root() :
+      return 0
+    else :
+      return -1
+
+
+  def Geometric_coincide(self,obj) : return 0
+
+  def Deep_coincide(self,obj,correspond) : pass
+
+  def Coincide(self, obj) :
+
+    if self == obj : return       # in that way recursive loops cannot exist
+
+    if self.relation :            # the root is put in coincidence, not the object itself
+      self.Root().Coincide(obj)
+      return
+
+    if not self.Is_same_dimension(obj) :
+      raise 'Coincidence impossible : objects are not of the same dimension'
+
+    correspond = self.Geometric_coincide(obj)
+    if not correspond :
+      raise 'The objects are not geometrically coincident'
+
+    self.Deep_coincide(obj,correspond)
+    self.relation = obj
+
+
+  def Duplicate(self) :
+
+    return copy.deepcopy(self)    # special deepcopy for the Mesh_Descriptor
+
+
+  def Gmsh(self,mesh) :
+
+    if self.num : return              # already meshed object
+    self.mesh = mesh                  # Storing the mesh
+    self.Intermediate_meshing(mesh)   # creation of the intermediate objects
+    num = mesh.num+1                  # New object number
+    self.Object_meshing(num)          # object meshing (with current number num)
+    mesh.num = num                    # Updating the current gmsh pointer
+    self.num = num                    # Storing the current object number
+
+
+  def Gmsh_send(self, line_code) :
+
+    self.mesh.command.append(line_code)
+
+
+  def Intermediate_meshing(self,mesh) :
+    pass
+
+
+  def Object_meshing(self,num) :
+    raise "Creation of the Gmsh source not implemented"
+
+
+
+
+# -------------------- POINT OBJECTS ---------------------
+
+
+class Point(Geometric) :
+
+  """
+    POINT OBJECT
+
+    Public methods
+     __init__ :
+       in -> coordinates (the 3rd is zero by default)
+
+     Size  : set the size of the neighbouring elements
+       in -> size
+
+     Attractor : define the point as an attractor
+       in -> scale_x : size amplification factor in the x-direction
+       in -> scale_y : size amplification factor in the y-direction
+       in -> distance: influence distance for the perturbation
+
+     Translate : translation of the point
+       in -> x,y,z translation vector (default : z=0)
+
+    Attributes
+     coor : coordinates
+     size : neighbouring element size
+     attractor : parameters of the attractor
+  """
+
+  def __init__(self,x,y,z=0) :
+
+    Geometric.__init__(self)
+    self.coor = NP.array([x,y,z], NP.float)
+    self.attractor = None
+
+
+  def Geometric_coincide(self,obj) :
+
+    global _CARAC
+    prec = _CARAC['prec']
+
+    d = VectorNorm(self.coor - obj.coor)
+    if d < prec*self.md.size :
+      return 1
+    else :
+      return None
+
+
+  def Size(self,h) :
+
+    self.md.size = float(h)
+
+
+  def Attractor(self, scale_x, scale_y, distance) :
+
+    self.attractor = (float(scale_x), float(scale_y), float(distance))
+
+
+  def Translate(self,x,y,z=0) :
+
+    tran = NP.array([x,y,z]).astype(NP.float)
+    self.coor = self.coor + tran
+
+
+  def Object_meshing(self,num) :
+
+    ch = (
+        'Point(' + `num` + ') = {'
+      + `self.coor[0]` + ', '
+      + `self.coor[1]` + ', '
+      + `self.coor[2]` + ', '
+      + `self.md.size` + '};'
+      )
+    self.Gmsh_send(ch)
+
+    if self.attractor :
+      ch = (
+        'Attractor Point{' + `num` + '} = {'
+        + `self.attractor[0]`+','
+        + `self.attractor[1]`+','
+        + `1./self.attractor[2]` + '};'
+        )
+      self.Gmsh_send(ch)
+
+
+
+# -------------------- LINE OBJECTS ----------------------
+
+
+class Line(Geometric) :
+
+  """
+    LINE OBJECT
+
+
+    Public methods
+
+     Attractor : define the point as an attractor
+       in -> scale_x : size amplification factor in the x-direction
+       in -> scale_y : size amplification factor in the y-direction
+       in -> distance: influence distance for the perturbation
+
+  """
+
+
+  def __init__(self,*points) :
+
+    Geometric.__init__(self)
+
+    if len(points) <=1 :
+      raise "There should be at least two points"
+
+    for point in points :
+      if not point.Is_point() :
+        raise "Arguments should be points"
+
+    self.points = list(points)
+    self.attractor = None
+
+
+  def Geometric_coincide(self,obj) :
+
+    nb_points = len(self.points)
+    if nb_points <> len(obj.points) :
+      raise 'To coincide, lines should have the same number of points'
+
+   # same order of points
+    info = range(nb_points)
+    for i in range(nb_points) :
+      p1 = self.points[i]
+      p2 = obj.points[info[i]]
+      if not p1.Geometric_coincide(p2) :
+        break
+    else :
+      return info
+
+   # reverse order of points
+    info.reverse()
+    for i in range(nb_points) :
+      p1 = self.points[i]
+      p2 = obj.points[info[i]]
+      if not p1.Geometric_coincide(p2) :
+        break
+    else :
+      return info
+
+    return None
+
+
+  def Deep_coincide(self,obj,info) :
+
+    for i in range(len(info)) :
+      p1 = self.points[i]
+      p2 = obj.points[info[i]]
+      p1.Coincide(p2)
+
+
+
+  def Translate(self,x,y,z=0) :
+
+    for point in self.points :
+      point.Translate(x,y,z)
+
+
+  def Transfinite(self,number,progression = 1) :
+
+    self.md.number      = int(number)
+    self.md.progression = float(progression)
+
+
+  def Attractor(self,scale_x, scale_y, distance) :
+
+    self.attractor = (float(scale_x), float(scale_y), float(distance))
+
+
+  def __rmul__(self,base) :
+
+    if len(self.points) > 2 :
+      raise "Support (right argument) should be a straight line"
+
+    if self.points[0] in base.points :
+      supp_orig = 0
+      supp_extr = 1
+    elif self.points[1] in base.points :
+      supp_orig = 1
+      supp_extr = 0
+    else :
+      raise "No common point"
+
+    if self.points[supp_orig] == base.points[0] :
+      base_orig = 0
+      base_extr = -1
+    else :
+      base_orig = -1
+      base_extr = 0
+
+  # Translation vector
+    ce = self.points[supp_extr].coor
+    co = self.points[supp_orig].coor
+    tran = ce-co
+
+  # Definition of the edge opposite to the base
+    opp_base = base.Duplicate()
+    opp_base.Translate(tran[0],tran[1],tran[2])
+    opp_base.points[base_orig] = self.points[supp_extr]
+
+  # Definition of the edge opposite to the support
+    opp_supp = self.Duplicate()
+    opp_supp.points[0] = base.points[base_extr]
+    opp_supp.points[1] = opp_base.points[base_extr]
+
+    surf = Surface(base,self,opp_base,opp_supp)
+
+    if len(base.points) > 2 : surf.Ruled()
+
+    return surf
+
+
+  def Intermediate_meshing(self,mesh) :
+
+    for point in self.points :
+      point.Gmsh(mesh)
+
+
+  def Object_meshing(self,num) :
+
+    ch = self.type + '(' + `num` + ') = {'
+    for point in self.points :
+      ch = ch + `point.num` + ','
+    ch = ch[:-1] + '};'
+    self.Gmsh_send(ch)
+
+    if self.md.transfinite :
+      ch = (
+          'Transfinite Line{' + `num` + '} = ' +
+          `self.md.number+1` +
+          ' Using Progression ' + `self.md.progression` + ';'
+          )
+      self.Gmsh_send(ch)
+
+    if self.attractor :
+      ch = (
+        'Attractor Line{' + `num` + '} = {'
+        + `self.attractor[0]`+','
+        + `self.attractor[1]`+','
+        + `1./self.attractor[2]` + '};'
+        )
+      self.Gmsh_send(ch)
+
+
+
+class Circle(Line) : pass
+
+# The class inherits everything from Line but its name (to tell Gmsh
+# that it is a circle).
+
+
+
+def Curve(l_x,l_y,l_z=None) :
+
+  if not l_z :
+    l_z = [0.] * len(l_x)
+
+  l_P = []
+  for x,y,z in map(None,l_x,l_y,l_z) :
+    l_P.append(Point(x,y,z))
+
+  line = apply(Line,l_P)
+  return line
+
+
+
+
+
+# -------------------- SURFACE OBJECTS ---------------------
+
+
+class Surface(Geometric) :
+
+  """
+    SURFACE OBJECT (inherit from the Geometric class)
+
+    Public methods
+     __init__ :
+       in -> lines : external bounday of the surface (lines should be connected)
+
+     Holes : set the internal holes (surfaces)
+       in -> holes : list of holes
+
+     Boundary : checks that the boundary is a closed loop and returns the orientation of the edges
+
+     Summit : returns the summit list sorted according to the orientation (see Boundary method)
+
+     Ruled : declare the surface is a ruled one
+
+     Translate : translate the surface
+       in -> x,y,z translation vector (default : z=0)
+
+     Recombine : recombine the surface (try to mesh with quadrangles instead of triangles)
+
+     Transfinite : Declare the mesh to be transfinite
+
+
+    Attributes
+     lines : list of external boundary lines
+     holes : list of internal holes (surfaces)
+     ruled : indicates (false or true) if the surface is a ruled surface
+     loops : list of boundary (external and internal) loops (computed when meshing)
+  """
+
+
+  def __init__(self,*lines) :
+
+    Geometric.__init__(self)
+    self.lines = list(lines)
+    self.holes = []
+    self.ruled = 0
+
+  # Check Assumptions
+    for line in lines :
+      if not line.Is_line() :
+        raise "Arguments should be lines : " + repr(line)
+    if lines == 0 : raise "There should be at least one line"
+    self.Boundary()
+
+
+  def Boundary(self) :
+
+  # checking the boundary is a loop
+    orie = []
+    tmp  = list(self.lines) + [self.lines[0]]
+    for i in range(len(self.lines)) :
+      lb = tmp[i]
+      la = tmp[i+1]
+      if lb.points[-1] in [la.points[0], la.points[-1]] :
+        orie.append(1)
+      elif lb.points[0] in [la.points[0], la.points[-1]] :
+        orie.append(-1)
+      else :
+        raise "This is not a loop"
+
+  # checking the boundary is closed
+    if orie[0]  ==  1 : pi = self.lines[0].points[0]
+    if orie[0]  == -1 : pi = self.lines[0].points[-1]
+    if orie[-1] ==  1 : pf = self.lines[-1].points[-1]
+    if orie[-1] == -1 : pf = self.lines[-1].points[0]
+    if pi <> pf : raise "The loop is not closed"
+
+    return orie
+
+
+  def Summit(self) :
+
+    summits = []
+    for line, orie in map(None,self.lines,self.Boundary()) :
+      if orie == 1 :
+        summits.append(line.points[0])
+      else :
+        summits.append(line.points[-1])
+    return summits
+
+
+  def Holes(self,*holes) :
+
+    for hole in holes :
+      if not hole.Is_surface() :
+        raise "Holes should be surfaces"
+    self.holes = list(holes)
+
+
+  def Geometric_coincide(self,obj) :
+
+    """
+      return (line_order, hole_order) :
+        line_order : list of the coupled lines ith line of self with line_order[i]th line of obj
+        hole_order : same as line_order but with the internal holes
+    """
+
+    if len(self.lines) <> len(obj.lines) :
+      raise 'To coincide, surfaces should have the same number of border lines'
+
+    if len(self.holes) <> len(obj.holes) :
+      raise 'To coincide, surfaces should have the same number of internal holes'
+
+   # Coincidence of the surface holes
+    hole_order = []
+    nb_holes = len(self.holes)
+    for hole_1 in self.holes :
+      for i in xrange(nb_holes) :
+        if i in hole_order :
+          continue
+        hole_2 = obj.holes[i]
+        if hole_1.Geometric_coincide(hole_2) :
+          hole_order.append(i)
+          break
+      else :
+        return None
+
+   # Coincidence of the external boundary lines
+    line_order = []
+    nb_lines = len(self.lines)
+    for line_1 in self.lines :
+      for i in xrange(nb_lines) :
+        if i in line_order :
+          continue
+        line_2 = obj.lines[i]
+        if line_1.Geometric_coincide(line_2) :
+          line_order.append(i)
+          break
+      else :
+        return None
+
+    return (line_order, hole_order)
+
+
+  def Deep_coincide(self,obj,info) :
+
+    line_order = info[0]
+    hole_order = info[1]
+
+    for i,j in map(None,xrange(len(line_order)),line_order) :
+      l1 = self.lines[i]
+      l2 = obj.lines[j]
+      l1.Coincide(l2)
+
+    for i,j in map(None,xrange(len(hole_order)),hole_order) :
+      h1 = self.holes[i]
+      h2 = obj.holes[j]
+      h1.Coincide(h2)
+
+
+
+  def Ruled(self) :
+
+    self.ruled = 1
+
+    if len(self.lines) not in [3,4] :
+      raise "Ruled surfaces require 3 or 4 edges"
+
+    if self.holes :
+      raise "Holes are forbidden for ruled surfaces"
+
+
+  def Translate(self,x,y,z=0) :
+
+    l_points = []
+    for surf in [self] + self.holes :
+      for line in surf.lines :
+        for point in line.points :
+          if point not in l_points : l_points.append(point)
+
+    for point in l_points :
+      point.Translate(x,y,z)
+
+
+  def Recombine(self,val=1) :
+
+    self.md.recombine = val
+
+
+  def Transfinite(self) :
+
+    self.Ruled()
+
+    if len(self.lines) == 4 :
+      self.Recombine()
+
+    self.md.transfinite = 1
+
+    for line in self.lines :
+      if not line.md.transfinite :
+        raise "Transfinite surfaces require transfinite edges"
+
+    if (
+      self.lines[0].md.number <> self.lines[2].md.number or
+      self.lines[1].md.number <> self.lines[3].md.number
+    ) :
+      raise "Coupled edges should have the same number of elements"
+
+
+
+  def Intermediate_meshing(self,mesh) :
+
+    self.loops = []
+    for surf in [self]+self.holes :
+      loop = LineLoop(surf)
+      self.loops.append(loop)
+      loop.Gmsh(mesh)
+
+
+  def Object_meshing(self,num) :
+
+  # Creation of the surface
+    if self.ruled :
+      ch = 'Ruled Surface(' + `num` + ') = {'
+    else :
+      ch = 'Plane Surface(' + `num` + ') = {'
+    for loop in self.loops :
+      ch = ch + `loop.num` + ','
+    ch = ch[:-1] + '};'
+    self.Gmsh_send(ch)
+
+  # Declaration of transfinite surface
+    if self.md.transfinite :
+      ch = 'Transfinite Surface {' + `num` + '} = {'
+      for summit in self.Summit() :
+        ch = ch + `summit.num` + ','
+      ch = ch[:-1] + '};'
+      self.Gmsh_send(ch)
+
+  # Recombine elements if requested
+    if self.md.recombine :
+      self.Gmsh_send('Recombine Surface {' + `num` + '} ;')
+
+
+
+class LineLoop(Geometric) :    # Used only during the meshing phase
+
+
+  def __init__(self,surface) :
+
+    Geometric.__init__(self)
+    self.surface = surface
+
+
+  def Intermediate_meshing(self,mesh) :
+
+    for line in self.surface.lines :
+      line.Gmsh(mesh)
+
+
+  def Object_meshing(self,num) :
+
+    ch = 'Line Loop(' + `num` + ') = {'
+    for line,orie in map(None,self.surface.lines,self.surface.Boundary()) :
+      ch = ch + `orie*line.num` + ','
+    ch = ch[:-1] +  '};'
+    self.Gmsh_send(ch)
+
+
+
+
+class Volume(Geometric) :
+
+
+  """
+    VOLUME OBJECT (inherit from the Geometric class)
+
+    Public methods
+     __init__ :
+       in -> surfaces : external bounday of the volume (surfaces should be connected)
+
+     Edge : returns the list of edges
+
+     Holes : set the internal holes (surfaces)
+       in -> holes : list of holes
+
+     Transfinite : Declare the mesh to be transfinite (force the surfaces to be transfinite too)
+
+     Translate : translate the surface
+       in -> x,y,z translation vector (default : z=0)
+
+
+    Attributes
+     surfaces : list of external boundary surfaces
+     holes : list of internal holes (volumes)
+     loops : list of boundary (external and internal) loops (computed when meshing)
+
+
+    Private methods :
+
+     Boundary : checks that the boundary is a closed loop and returns the orientation of the edges
+
+  """
+
+
+  def __init__(self,*surfaces) :
+
+    Geometric.__init__(self)
+    self.surfaces = list(surfaces)
+    self.holes = []
+    self.ruled = 0
+
+  # Check Assumptions
+    for surface in surfaces :
+      if not surface.Is_surface() :
+        raise "Arguments should be surfaces : " + repr(surface)
+    if len(surfaces) < 2 : raise "There should be at least two surfaces"
+    self.Boundary()
+
+
+  def Boundary(self) :
+
+    edges = []
+    for surface in self.surfaces :
+      edges = edges + surface.lines
+
+  # each edge has to appear twice in the list of edges
+    for edge in edges :
+      if edges.count(edge) <> 2 :
+        raise "The surface loop is not closed : each edge should appear twice"
+
+
+  def Edge(self) :
+
+    edges = []
+    for surface in self.surfaces :
+      for line in surface.lines :
+        if line not in edges : edges.append(line)
+    return edges
+
+
+  def Holes(self,*holes) :
+
+    for hole in holes :
+      if not hole.Is_volume() :
+        raise "Holes should be volumes"
+    self.holes = list(holes)
+
+
+  def Geometric_coincide(self,obj) :
+
+    """
+      return (surface_order, hole_order) :
+        surface_order : list of the coupled surfaces ith surface of self with surface_order[i]th surface of obj
+        hole_order    : same as surface_order but with the internal holes
+    """
+
+    if len(self.surfaces) <> len(obj.surfaces) :
+      raise 'To coincide, volumes should have the same number of border surfaces'
+
+    if len(self.holes) <> len(obj.holes) :
+      raise 'To coincide, volumes should have the same number of internal holes'
+
+   # Coincidence of the surface holes
+    hole_order = []
+    nb_holes = len(self.holes)
+    for hole_1 in self.holes :
+      for i in xrange(nb_holes) :
+        if i in hole_order :
+          continue
+        hole_2 = obj.holes[i]
+        if hole_1.Geometric_coincide(hole_2) :
+          hole_order.append(i)
+          break
+      else :
+        return None
+
+   # Coincidence of the external boundary lines
+    surface_order = []
+    nb_surfaces = len(self.surfaces)
+    for surface_1 in self.surfaces :
+      for i in xrange(nb_surfaces) :
+        if i in surface_order :
+          continue
+        line_2 = obj.surfaces[i]
+        if surface_1.Geometric_coincide(surface_2) :
+          surface_order.append(i)
+          break
+      else :
+        return None
+
+    return (surface_order, hole_order)
+
+
+  def Deep_coincide(self,obj,info) :
+
+    surface_order = info[0]
+    hole_order    = info[1]
+
+    for i,j in map(None,xrange(len(surface_order)),surface_order) :
+      l1 = self.surfaces[i]
+      l2 = obj.surfaces[j]
+      l1.Coincide(l2)
+
+    for i,j in map(None,xrange(len(hole_order)),hole_order) :
+      h1 = self.holes[i]
+      h2 = obj.holes[j]
+      h1.Coincide(h2)
+
+
+  def Transfinite(self) :
+
+    if len(self.surfaces) == 5 :
+      raise "Not implemented"
+
+    if len(self.surfaces) not in [5,6] :
+      raise "Transfinite volumes require 5 or 6 faces"
+
+    if self.holes :
+      raise "Holes are forbidden for transfinite volumes"
+
+    self.md.transfinite = 1
+
+    for surface in self.surfaces :
+      if not surface.md.transfinite :
+        surface.Transfinite() # attention : ce n'est pas vrai dans le cas des prismes
+
+# ATTENTION : ICI, IL FAUDRAIT VERIFIER QUE LES SURFACES PEUVENT ETRE MISES EN VIS A VIS
+
+
+
+  def Translate(self,x,y,z=0) :
+
+    l_points = []
+    for volu in [self] + self.holes :
+      for surf in volu.surfaces :
+        for line in surf.lines :
+          for point in line.points :
+            if point not in l_points : l_points.append(point)
+
+    for point in l_points :
+      point.Translate(x,y,z)
+
+
+
+  def Intermediate_meshing(self,mesh) :
+
+    self.loops = []
+    for volume in [self]+self.holes :
+      loop = SurfaceLoop(volume)
+      self.loops.append(loop)
+      loop.Gmsh(mesh)
+
+
+  def Object_meshing(self,num) :
+
+  # Creation of the volume
+    ch = 'Volume(' + `num` + ') = {'
+    for loop in self.loops :
+      ch = ch + `loop.num` + ','
+    ch = ch[:-1] + '};'
+    self.Gmsh_send(ch)
+
+  # Declaration of transfinite surface
+    if self.md.transfinite :
+
+      bottom_summits = self.surfaces[0].Summit()
+      edges = self.Edge()
+      top_summits = []
+      for summit in bottom_summits :
+        for edge in edges :
+          if summit == edge.points[0] and edge.points[-1] not in bottom_summits :
+            top_summits.append(edge.points[-1])
+            break
+          elif summit == edge.points[-1] and edge.points[0] not in bottom_summits :
+            top_summits.append(edge.points[0])
+            break
+
+      ch = 'Transfinite Volume {' + `num` + '} = {'
+      for summit in bottom_summits + top_summits :
+        ch = ch + `summit.num` + ','
+      ch = ch[:-1] + '};'
+      self.Gmsh_send(ch)
+
+
+
+class SurfaceLoop(Geometric) :    # Used only during the meshing phase
+
+
+  def __init__(self,volume) :
+
+    Geometric.__init__(self)
+    self.volume = volume
+
+
+  def Intermediate_meshing(self,mesh) :
+
+    for surface in self.volume.surfaces :
+      surface.Gmsh(mesh)
+
+
+  def Object_meshing(self,num) :
+
+    ch = 'Surface Loop(' + `num` + ') = {'
+    for surface in self.volume.surfaces :
+      ch = ch + `surface.num` + ','
+    ch = ch[:-1] +  '};'
+    self.Gmsh_send(ch)
+
+
+
+
+# ------------------- GEOMETRICAL TRANSFORMATION --------------
+
+def VectorProduct(u,v) :
+
+  return NP.array([u[1]*v[2]-u[2]*v[1],u[2]*v[0]-u[0]*v[2],u[0]*v[1]-u[1]*v[0]])
+
+
+def VectorNorm(u) :
+
+  return sqrt(dot(u,u))
+
+
+class Rotation :
+
+  def __init__(self,A,C,B) :
+
+    self.C = c
+    self.a = A-C
+    n = VectorProduct(self.a,B-C)
+    self.n = n / VectorNorm(n)
+
+
+  def Proj(self,M) :
+
+    lbd = dot(M-self.C,self.n)
+    H = self.C + lbd*self.n
+    return H
+
+
+def Scaling_P2(p,t) : return (1.-p)*t*t+p*t
+
+def Scaling_P3(p,t) :
+  q = 1./p
+  a = p+q-2
+  b = 3-2*p-q
+  return a*t**3 + b*t*t +p*t
+
+
+# -------------------- MESHING OPERATIONS ---------------------
+
+class Mesh_Descriptor :
+
+  """
+    Attributes
+      relation     Another mesh descriptor provides the mesh parameters
+      parameters   dictionnary of the mesh parameters
+                        size         Point size
+                        transfinite  Transfinite mesh (0 or 1)
+                        number       Number of elements along a line (transfinite)
+                        progression  Progression of element size (transfinite)
+                        recombine    Recombine mesh or not
+
+     Specific access :
+       md.parameter_name = xxx -> the relation is destroyed (set to None)
+       xxx = md.parameter_name -> if there is a relation, the effective
+                                  parameter is looked for recursively
+
+     Deep copying : a relation is set to the model instead of a true copy
+  """
+
+  List_Attr = ['size','transfinite','number','progression','recombine']
+
+
+  def __init__(self) :
+
+    self.relation = None
+    self.parameters = {
+      'size'       :  1.  ,     # Point size
+      'transfinite':  0   ,     # Transfinite mesh (0 or 1)
+      'recombine'  :  0         # Recombine mesh or not
+      }
+
+
+  def __setattr__(self, attr, value) :
+
+    if attr in Mesh_Descriptor.List_Attr :
+      self.relation = None
+      self.parameters[attr] = value
+
+      if attr == 'number' :
+        self.transfinite = 1
+
+    else :
+      self.__dict__[attr] = value
+
+
+  def __getattr__(self,attr) :
+
+    if self.relation :
+      return (getattr(self.relation,attr))
+    else :
+      if attr in self.parameters.keys() :
+        return self.parameters[attr]
+      else :
+        raise AttributeError
+
+
+  def __deepcopy__(self,visit) :
+
+    md = copy.copy(self)
+    md.parameters = copy.copy(self.parameters)
+    md.relation = self
+    return md
+
+
+
+class Mesh :
+
+  """
+
+  """
+
+
+  def __init__(self, algo = 2, order = 1, gmsh='gmsh') :
+
+    self.num_ph  = 0
+    self.num     = 0
+    self.order   = order
+    self.command = ['Mesh.Algorithm = ' + repr(algo) + ' ;']
+    self.command += ['Mesh.ElementOrder = ' + repr(order) + ' ;']
+    self.physicals = {}
+    self.gmsh    = gmsh
+
+
+  def Physical(self, name, *l_lobj) :
+
+  # Checking the name
+    if type(name) <> type(' ') :
+      raise 'First argument should be the name of the physical'
+    if name in self.physicals.keys() :
+      raise 'Physical '+name+' already exists'
+
+  # treating the case of list of lists parameters
+    l_obj = []
+    for l in l_lobj :
+      if type(l) == type([]) :
+        l_obj = l_obj + l
+      else :
+        l_obj.append(l)
+
+  # Checking all objects are geometric
+    for obj in l_obj :
+      if not Is_Geometric(obj) :
+        raise "Non geometrical object : " + repr(obj) + " Physical = " + name
+
+    cl = l_obj[0].Base_class()
+  # Checking all objects are of the same dimension
+  #  ref_dim = l_obj[0]
+  #  for obj in l_obj[1:] :
+  #    if not ref_dim.Is_same_dimension(obj) :
+  #      raise "All objects are not of the same dimension : " + repr(obj)
+
+  # Creation of the objects if necessary
+    for obj in l_obj :
+      obj.Gmsh(self)
+
+  # Creation of the physical
+    self.num_ph= self.num_ph + 1
+    ch = name + '=' + `self.num_ph` + ';'
+    self.command.append(ch)
+    ch = 'Physical ' + cl + '(' + name + ') = {'
+    for obj in l_obj :
+      ch = ch + `obj.num` + ','
+    ch = ch[:-1] + '};'
+    self.command.append(ch)
+
+  # Name of the physical
+    name_gmsh = 'GM'+`self.num_ph`
+    self.physicals[name] = name_gmsh
+
+
+  def Save(self, file = 'fort.geo') :
+
+    if os.path.isfile(file) :
+      os.remove(file)
+
+    f = open(file,'w')
+    f.write(string.joinfields(self.command,'\n'))
+    f.close()
+
+
+  def View(self) :
+
+    self.Save('fort.geo')
+#    os.system('gmsh fort.geo')
+    os.system(self.gmsh + ' fort.geo')
+    os.remove('fort.geo')
+
+
+  def Create(self, file = 'fort.19') :
+
+    self.Save()
+    os.system(self.gmsh + ' -3 fort.geo')
+    try: os.remove(file)
+    except: pass
+    os.rename('fort.msh',file)
+
+
+  def Name(self, MA, CREA_GROUP_NO) :
+
+    l_gma = []
+    l_mcf =  []
+    for gma in self.physicals.keys() :
+      l_gma.append(self.physicals[gma])
+      l_mcf.append(_F(GROUP_MA = self.physicals[gma],NOM=gma))
+
+    DEFI_GROUP(reuse = MA,
+      MAILLAGE = MA,
+      CREA_GROUP_MA = tuple(l_mcf),
+      )
+
+    SMESH_02 = CREA_MAILLAGE(
+      MAILLAGE = MA,
+      DETR_GROUP_MA = _F(GROUP_MA = tuple(l_gma)),
+      )
+
+    DETRUIRE(CONCEPT = _F(NOM = MA), INFO=1)
+
+    if CREA_GROUP_NO == 'OUI' :
+      DEFI_GROUP(reuse = SMESH_02,
+        MAILLAGE = SMESH_02,
+        CREA_GROUP_NO = _F(TOUT_GROUP_MA = 'OUI'),
+        )
+
+    else :
+#    Traitement des GROUP_NO qui sont des points
+      info_gno = SMESH_02.LIST_GROUP_NO()
+      l_gno = []
+      for gno in info_gno :
+        if gno[1] == 1 : l_gno.append(gno[0])
+
+      l_gma = []
+      for gma in self.physicals.keys() :
+        nom_gmsh = self.physicals[gma]
+        if nom_gmsh in l_gno :
+          l_gma.append(gma)
+
+      if l_gma :
+        DEFI_GROUP(reuse = SMESH_02,
+          MAILLAGE = SMESH_02,
+          CREA_GROUP_NO = _F(GROUP_MA = tuple(l_gma)),
+          )
+
+    return SMESH_02
+
+
+
+  def LIRE_GMSH(self,
+    UNITE_GMSH     = 19,
+    UNITE_MAILLAGE = 20,
+    MODI_QUAD      = 'NON',
+    CREA_GROUP_NO  = 'OUI'
+    ) :
+
+    """
+      Lecture du maillage (format Aster) a partir de sa definition
+      (format sup_gmsh)
+      UNITE_GMSH     = Numero d'unite logique pour le fichier msh
+      UNITE_MAILLAGE = Numero d'unite logique pour le fichier mail
+      MODI_QUAD      = 'OUI' si line->quad, 'NON' sinon
+      CREA_GROUP_NO  = 'OUI' si on cree les group_no, 'NON' sinon
+    """
+
+    nom_gmsh = 'fort.' + repr(UNITE_GMSH)
+    self.Create(nom_gmsh)
+
+    PRE_GMSH(UNITE_GMSH=UNITE_GMSH, UNITE_MAILLAGE=UNITE_MAILLAGE)
+
+    SMESH_00 = LIRE_MAILLAGE(UNITE = UNITE_MAILLAGE)
+    DEFI_FICHIER(ACTION='LIBERER',UNITE = UNITE_GMSH)
+    DEFI_FICHIER(ACTION='LIBERER',UNITE = UNITE_MAILLAGE)
+
+    if MODI_QUAD == 'OUI' and self.order == 2 :
+      raise 'The finite elements are already of second order'
+
+    if MODI_QUAD == 'OUI' and self.order <> 2 :
+      SMESH_01 = CREA_MAILLAGE(
+        MAILLAGE = SMESH_00,
+        LINE_QUAD = _F(TOUT = 'OUI')
+        )
+      DETRUIRE(CONCEPT=_F(NOM=SMESH_00), INFO=1)
+      SMESH_00 = SMESH_01
+
+    SMESH_00 = self.Name(SMESH_00,CREA_GROUP_NO)
+
+    return SMESH_00

diff --git a/Aster/Cata/cataSTA10/Utilitai/transpose.py b/Aster/Cata/cataSTA10/Utilitai/transpose.py
new file mode 100644 (file)
index 0000000..0a8698d
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/transpose.py
@@ -0,0 +1,41 @@
+#@ MODIF transpose Utilitai  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+
+# Il NE faudrait utiliser cette fonction QUE sur des tableaux hétérogènes.
+# Pour les tableaux homogènes (int, float, string), utiliser numpy.transpose.
+
+def transpose(liste):
+    """Transposition de double liste
+    """
+    import numpy
+    if isinstance(liste, numpy.ndarray):
+        from warnings import warn
+        warn('prefer use of numpy.transpose instead', DeprecationWarning, stacklevel=2)
+
+    n = range(len(liste[0]))
+    m = range(len(liste))
+    liste_t = [[] for i in n]
+    for i in n :
+        for j in m :
+            liste_t[i].append(liste[j][i])
+    return liste_t
+
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/utils.py b/Aster/Cata/cataSTA10/Utilitai/utils.py
new file mode 100644 (file)
index 0000000..36f48d7
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/utils.py
@@ -0,0 +1,105 @@
+#@ MODIF utils Utilitai  DATE 26/05/2010   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+
+"""
+Module fournissant quelques fonctions utilitaires.
+"""
+
+import os
+import time
+
+
+def miss_dble(list1, list2):
+    """miss = elements de list1 absents de list2
+      dble = elements de list2 presents dans list1, fournis plusieurs fois."""
+    s_ini = set(list1)
+    inter = s_ini.intersection(list2)
+    miss = s_ini.copy()
+    dble = set()
+    for p in list2:
+        try:
+            miss.remove(p)
+        except KeyError:
+            if set(p).issubset(s_ini) and p.strip() != '':
+                dble.add(p)
+    return miss, inter, dble
+
+
+#TODO faire à l'identique pour les commandes fortran (ou appeller cette fonction)
+def get_titre_concept(co=None):
+    """Retourne un titre automatique."""
+    # ASTER 10.01.25 CONCEPT tab0 CALCULE LE 21/05/2010 A 17:58:50 DE TYPE TABLE_SDASTER
+    import aster
+    from Noyau.N_ASSD import ASSD
+    if not isinstance(co, ASSD):
+        co = None
+    fmt = {
+        "version" : "ASTER %(version)s",
+        "nomco" : "CONCEPT %(nom_concept)s",
+        "etatco" : "CALCULE",
+        "dateheure" : "%(dateheure)s",
+        "typeco" : "DE TYPE %(type_concept)s",
+    }
+    format = [fmt["version"],]
+    df = {
+        "version" : aster.__version__,
+        "dateheure" : time.strftime("LE %m/%d/%Y A %H:%M:%S"),
+    }
+    if co:
+        df["nom_concept"] = co.nom
+        format.append(fmt["nomco"])
+        format.append(fmt["etatco"])
+    format.append(fmt["dateheure"])
+    if co:
+        df["type_concept"] = co.__class__.__name__.upper()
+        format.append(fmt["typeco"])
+    globfmt = " ".join(format)
+    titre = globfmt % df
+    lt = titre.split()
+    lt = maximize_lines(lt, 80, " ")
+    return os.linesep.join(lt)
+
+
+# existe dans asrun.mystring
+def maximize_lines(l_fields, maxlen, sep):
+    """Construit des lignes dont la longueur est au plus de `maxlen` caractères.
+    Les champs sont assemblés avec le séparateur `sep`.
+    """
+    newlines = []
+    # ceinture
+    assert max([len(f) for f in l_fields]) <= maxlen, 'lignes trop longues : %s' % l_fields
+    while len(l_fields) > 0:
+        cur = []
+        while len(l_fields) > 0 and len(sep.join(cur + [l_fields[0],])) <= maxlen:
+            cur.append(l_fields.pop(0))
+        # bretelle
+        assert len(cur) > 0, l_fields
+        newlines.append(sep.join(cur))
+    newlines = [l for l in newlines if l != '']
+    return newlines
+
+
+
+if __name__ == '__main__':
+   npar = ('X', 'Y',)
+   nuti = ('DX', 'DY', 'X', 'X')
+   print miss_dble(npar, nuti)
+

diff --git a/Aster/Cata/cataSTA10/Utilitai/veri_matr_tang.py b/Aster/Cata/cataSTA10/Utilitai/veri_matr_tang.py
new file mode 100644 (file)
index 0000000..9ceb066
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Utilitai/veri_matr_tang.py
@@ -0,0 +1,269 @@
+#@ MODIF veri_matr_tang Utilitai  DATE 10/01/2011   AUTEUR PROIX J-M.PROIX 
+# -*- coding: iso-8859-1 -*-
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+from Cata.cata import *
+
+#              MACRO "VERI_MATR_TANG"
+#           ----------------------------
+import cPickle
+import string
+
+import numpy as NP
+from numpy import linalg as LA
+
+import aster
+
+class TANGENT :
+
+     """
+       VERIFICATION SUR LES MATRICES TANGENTES
+ 
+       Attributs publics :
+ 
+         mat       : matrice tangente
+         ddl       : nom des degres de liberte
+         nddl      : nombre de ddl
+         norme     : norme de la matrice tangente
+         prec_zero : en-dessous de prec_zero, on ne compare pas les matrices
+ 
+ 
+       Methodes publiques
+ 
+         Save       : sauvegarde la matrice dans un fichier
+         Load       : lit la matrice depuis un fichier
+         Aster      : lit la matrice depuis l'espace Aster
+         Matrice    : range la matrice
+         Difference : comparaison entre la matrice tangente et une autre matrice
+         Symetrie   : verification du caractere symetrique de la matrice tangente
+ 
+     """
+ 
+ 
+     def __init__(self,ddl='',prec_zero=1.E-12) :
+ 
+       """
+         ddl       : chaine de caracteres designant les ddl (ex: 'UUP')
+         prec_zero : en-dessous de prec_zero, on ne compare pas les matrices
+       """
+ 
+       self.ddl = ddl
+       self.prec_zero = prec_zero
+ 
+
+     def Load(self,nom_fichier) :
+ 
+       fichier = file(nom_fichier,'r')
+       self.__dict__ = cPickle.load(fichier)
+ 
+ 
+     def Save(self,nom_fichier) :
+ 
+       fichier = file(nom_fichier,'w')
+       cPickle.dump(self.__dict__,fichier)
+ 
+
+     def Aster(self,suffixe = 'MATA') :
+ 
+       """
+         nom : suffixe de l'objet jeveux
+       """
+
+       nom_obj_jeveux = string.ljust('PYTHON.TANGENT.'+suffixe,24)
+       obj_jeveux = aster.getvectjev(nom_obj_jeveux)
+       if not obj_jeveux :
+         raise 'TANGENT : OBJET JEVEUX DE SUFFIXE '+suffixe+' INEXISTANT'
+       self.Matrice(obj_jeveux)
+ 
+ 
+     def Eigen(self) :
+       self.vp = NP.sort(LA.eigvals(self.mat))
+ 
+ 
+     def Matrice(self,matrice) :
+ 
+       """
+         matrice   : la matrice tangente (rangement carre)
+       """
+ 
+       if type(matrice) == type((1,)) :
+         matrice = NP.array(list(matrice))
+       elif type(matrice) == type([]) :
+         matrice = NP.array(matrice)
+       matrice = matrice.astype(float)
+ 
+       nddl = int(len(matrice)**0.5+0.5)
+       matrice.shape = (nddl,nddl)
+
+       self.mat = matrice
+       self.nddl = nddl
+ 
+       if not self.ddl :
+         self.ddl = 'D'*nddl
+       elif len(self.ddl) <> nddl :
+         raise 'Nommage des DDL incoherents avec la taille de la matrice'
+
+       self.norme = NP.trace(NP.dot(NP.transpose(self.mat),self.mat))
+ 
+
+     def Difference(self,matp,affi_ok=0,prec_diff = 1.E-4) :
+ 
+       """
+         COMPARAISON RELATIVE DE LA MATRICE TANGENTE AVEC UNE AUTRE MATRICE
+ 
+         matp      : matrice avec laquelle self.mat est comparee
+         affi_ok   : si oui, on affiche egalement les valeurs qui collent bien
+         prec_diff : ecart au-dessus duquel on considere que ce n'est pas OK
+       """
+ 
+       if type(matp) is tuple :
+         matp = NP.array(list(matp))
+       elif type(matp) is list :
+         matp = NP.array(matp)
+       elif type(matp) == type(self) :
+         matp = matp.mat
+       elif type(matp) is NP.ndarray:
+         pass
+       else :
+         raise '1er argument doit etre une matrice (tuple,liste,TANGENT ou tableau numpy)'
+       matp = NP.ravel(matp)
+       matp = matp.astype(float)
+ 
+       if len(matp) <> self.nddl*self.nddl :
+         raise 'Matrices de tailles differentes'
+       matp.shape = (self.nddl,self.nddl)
+ 
+       refe = NP.abs(self.mat) + NP.abs(matp)
+       diff = NP.where(refe > self.prec_zero,NP.abs(self.mat-matp)/(refe+self.prec_zero),0)
+       nook = (diff.ravel()  > prec_diff).nonzero()[0]
+       ok   = (diff.ravel() <= prec_diff).nonzero()[0]
+
+       if affi_ok :
+         affi = [ok,nook]
+       else :
+         affi = [nook]
+         
+       liste_i=[]
+       liste_j=[]
+       liste_matt=[]
+       liste_matp=[]
+       liste_diff=[]
+       for ind in affi :         
+#         print '-'*80
+         for pos in ind :
+           i = pos / self.nddl
+           j = pos % self.nddl
+#           print self.ddl[i],self.ddl[j],'  ',(i+1,j+1),'  ',self.mat[i,j],' ',matp[i,j]
+           liste_i.append(i+1)
+           liste_j.append(j+1)
+           liste_matt.append(self.mat[i,j])
+           liste_matp.append(matp[i,j])
+           liste_diff.append( NP.abs(self.mat[i,j]-matp[i,j])/ ( NP.abs(self.mat[i,j]) + NP.abs(matp[i,j]) + self.prec_zero))
+#       print '-'*80
+       if self.norme > self.prec_zero :
+         ecart = (self.mat - matp)/2.
+         nor_ecart = NP.trace(NP.dot(NP.transpose(ecart),ecart))
+         nor_diff= nor_ecart / self.norme
+       else :
+         nor_diff= 0.
+       max_diff=0.
+       if (len(liste_diff) > 0 ) : max_diff = NP.max(liste_diff)
+       return liste_i,liste_j,liste_matt,liste_matp, liste_diff,nor_diff,max_diff
+ 
+
+     def Symetrie(self,prec_diff = 1.E-4) :
+ 
+       """
+         VERIFICATION QUE LA MATRICE TANGENTE EST SYMETRIQUE
+ 
+         On retourne la norme relative de l'ecart a la symetrie : || (A-At)/2|| / ||A||
+         On affiche les termes qui s'ecartent de la symetrie
+
+         prec_diff : ecart au-dessus duquel on considere que ce n'est pas OK
+       """
+
+       tran = NP.transpose(self.mat)
+       liste_i,liste_j,liste_matt,liste_matp,liste_diff,nor_diff,max_diff=self.Difference(tran,affi_ok=0,prec_diff=prec_diff)
+       
+ 
+#       if self.norme > self.prec_zero :
+#         ecart = (self.mat - tran)/2.
+#         nor_ecart = NP.trace(NP.dot(NP.transpose(ecart),ecart))
+#         return nor_ecart / self.norme
+#       else :
+#         return 0.
+       return liste_i,liste_j,liste_matt,liste_matp, liste_diff,nor_diff,max_diff
+ 
+     def Sauve(self,nom_fichier) : 
+       cPickler.dump(self.__dict__)
+       
+def veri_matr_tang_ops(self,SYMETRIE,DIFFERENCE,PRECISION,**args):
+
+   """
+      Ecriture de la macro verif_matrice_tangente_ops
+   """
+   import os
+   from Accas import _F
+   from Utilitai.Utmess     import UTMESS
+   from Utilitai.UniteAster import UniteAster
+
+   # On importe les definitions des commandes a utiliser dans la macro
+   CREA_TABLE  = self.get_cmd('CREA_TABLE')
+
+  # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+  # Le concept sortant (de type fonction) est nomme ROTGD dans 
+  # le contexte de la macro
+
+   self.DeclareOut('TAB_MAT',self.sd)
+   ier=0                                                                            
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+   tgt=TANGENT()                                                                    
+   tgt.Aster(suffixe='MATA')                                                        
+   matp=TANGENT()                                                                   
+   matp.Aster(suffixe='MATC')                                                       
+   prec_diff = PRECISION                                                                                 
+   if (SYMETRIE=='OUI') :
+      list1_i,list1_j,list1_matt,list1_matp,list1_diff,symetgt,max_diff=tgt.Symetrie(prec_diff)                                                        
+      list2_i,list2_j,list2_matt,list2_matp,list2_diff,symeper,max_diff=matp.Symetrie(prec_diff)                                                       
+      print 'Symetrie de la matrice tangente',symetgt                            
+      print 'Symetrie de la matrice pr pertubation',symeper                      
+      #aster.affiche('MESSAGE',str(tgt.Difference(matp,prec_diff) ))
+   if (DIFFERENCE=='OUI'):                                                            
+       liste_i,liste_j,liste_matt,liste_matp,liste_diff,nor_diff,max_diff=tgt.Difference(matp,prec_diff)
+       print 'difference entre matrice tangente et matrice par pertubation : norme=',nor_diff,' max=',max_diff  
+       TAB_MAT=CREA_TABLE(LISTE=(
+                     _F(PARA     ='I',LISTE_I = liste_i),
+                     _F(PARA     ='J',LISTE_I = liste_j),
+                     _F(PARA     ='MAT_TGTE',LISTE_R = liste_matt),
+                     _F(PARA     ='MAT_PERT',LISTE_R = liste_matp),
+                     _F(PARA     ='MAT_DIFF',LISTE_R = liste_diff),
+                     ))
+   return
+                                                     
+ 
+VERI_MATR_TANG=MACRO(nom="VERI_MATR_TANG",op=veri_matr_tang_ops,sd_prod=table_sdaster,
+                       docu="",reentrant='n',
+fr="verification de la matrice tangente : symetrie et difference par rapport a la matrice calculee par perturbation",
+         regles=(AU_MOINS_UN('SYMETRIE','DIFFERENCE')),
+         SYMETRIE        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         DIFFERENCE      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         PRECISION       =SIMP(statut='f',typ='R',defaut=1.E-4 ),
+)  ;
+

diff --git a/Aster/Cata/cataSTA10/cata.py b/Aster/Cata/cataSTA10/cata.py
index 92ca10d2616605b5e11d6bc9fcf6ad7a2ac4d646..fc785b526e899abea19f05f9ef7786f0481aa308 100755 (executable)
--- a/Aster/Cata/cataSTA10/cata.py
+++ b/Aster/Cata/cataSTA10/cata.py
@@ -1,8 +1,8 @@
-#& MODIF ENTETE  DATE 14/06/2010   AUTEUR COURTOIS M.COURTOIS 
+#& MODIF ENTETE  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -135,6 +135,7 @@ from SD.co_listr8 import listr8_sdaster
 # maillage :
 from SD.co_maillage  import maillage_sdaster
 from SD.co_squelette import squelette
+from SD.co_grille    import grille_sdaster
 
 # -----------------------------------------------------------------------------
 # champs
@@ -218,10 +219,165 @@ from SD.co_vect_elem import vect_elem, \
                             vect_elem_pres_r, vect_elem_pres_c, \
                             vect_elem_temp_r
 
-#& MODIF COMMUN  DATE 24/08/2010   AUTEUR COURTOIS M.COURTOIS 
+
+# -----------------------------------------------------------------------------
+# corresp_2_mailla :
+from SD.co_corresp_2_mailla import corresp_2_mailla
+
+#& MODIF COMMUN  DATE 21/12/2010   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ABBAS M.ABBAS
+
+def C_AFFICHAGE() : return FACT(statut='f',max=1,
+        INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+        UNITE       = SIMP(statut='f',typ='I',val_min=1),
+       );
+#& MODIF COMMUN  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ABBAS M.ABBAS
+def C_ARCHIVAGE() : return FACT(statut='d',max=1,
+    regles         = (EXCLUS('PAS_ARCH','LIST_INST','INST'),),
+    LIST_INST      = SIMP(statut='f',typ=(listr8_sdaster) ),
+    INST           = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
+    PAS_ARCH       = SIMP(statut='f',typ='I' ),
+    CRITERE        = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+              PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+           b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+              PRECISION       =SIMP(statut='o',typ='R',),),
+    DETR_NUME_SUIV = SIMP(statut='f',typ='TXM',into=("OUI",)),
+    CHAM_EXCLU     = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',),
+);
+#& MODIF COMMUN  DATE 07/12/2010   AUTEUR GENIAUT S.GENIAUT 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GENIAUT S.GENIAUT
+def C_COMP_ELAS( COMMAND ) :  #COMMUN#
+    
+    assert COMMAND in ('MACR_ASCOUF_CALC','MACR_ASPIC_CALC','CALC_G','POST_GP',
+                       'CALC_POINT_MAT','SIMU_POINT_MAT', 'DYNA_NON_LINE','STAT_NON_LINE','CALCUL',)
+    
+    kwargs = {}
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+#                            RELATION
+# ----------------------------------------------------------------------------------------------------------------------------------
+    # commandes pour lesquelles on ne peut pas choisir une relation de type 1d
+    if COMMAND in ('CALC_G','POST_GP','CALC_POINT_MAT','SIMU_POINT_MAT' ):
+        kwargs['RELATION'] = SIMP(statut='o',typ='TXM',defaut="ELAS",
+                                 into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS","ELAS_HYPER"))
+
+    # commandes pour lesquelles tout type de relation est possible
+    elif COMMAND in ('DYNA_NON_LINE','STAT_NON_LINE','CALCUL',):
+        kwargs['RELATION'] = SIMP(statut='o',typ='TXM',defaut="ELAS",
+                                 into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC",
+                                       "ELAS_VMIS_PUIS","ELAS_HYPER","ELAS_POUTRE_GR","CABLE"))
+
+     # cas particulier de MACR_ASCOUF/ASPIC_CALC : on limite volontairement le choix pour ne pas perturber l'utilisateur
+     # mais theoriquement, toutes les lois disponibles pour CALC_G le sont aussi pour MACR_ASCOUF/ASPIC_CALC
+    elif COMMAND in ('MACR_ASCOUF_CALC','MACR_ASPIC_CALC'):
+        kwargs['RELATION'] = SIMP(statut='o',typ='TXM',into=("ELAS","ELAS_VMIS_TRAC"))
+
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+#                            DEFORMATION
+# ----------------------------------------------------------------------------------------------------------------------------------
+
+    # commandes pour lesquelles on ne peut pas choisir les grandes deformations
+    if COMMAND in ('CALC_POINT_MAT','MACR_ASCOUF_CALC','MACR_ASPIC_CALC'):
+        kwargs['DEFORMATION'] =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT",))
+
+    # commandes pour lesquelles on peut choisir tout type de deformation
+    elif COMMAND in ('DYNA_NON_LINE','STAT_NON_LINE','CALCUL','POST_GP','CALC_G','SIMU_POINT_MAT', ):
+        kwargs['DEFORMATION'] =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",))
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+#                            INTEGRATION (RESI_INTE_RELA, ITER_INTE_MAXI, ALGO_INTE)
+# ----------------------------------------------------------------------------------------------------------------------------------
+
+    kwargs['RESI_INTE_RELA']    =SIMP(statut='f',typ='R',defaut= 1.0E-6)
+    kwargs['ITER_INTE_MAXI']    =SIMP(statut='f',typ='I',defaut= 10 )
+    kwargs['ALGO_INTE']         =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE", "SECANTE",))
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+#                            LOCALISATION
+# ----------------------------------------------------------------------------------------------------------------------------------
+
+    # commandes pour lesquelles la localisation n'a pas de sens
+    # 'CALC_POINT_MAT','SIMU_POINT_MAT' 
+
+    # commandes pour lesquelles la localisation est automatique
+    # 'MACR_ASCOUF_CALC','MACR_ASPIC_CALC'
+
+    # commandes pour lesquelles on peut choisir la localisation
+    if COMMAND in ('DYNA_NON_LINE','STAT_NON_LINE','CALC_G','POST_GP','CALCUL'):
+        kwargs['regles'] = (PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),)
+        kwargs['TOUT'] =SIMP(statut='f',typ='TXM',into=("OUI",) )
+        kwargs['GROUP_MA']  =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**')
+        kwargs['MAILLE']    =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**')
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+#                            DIVERS
+# ----------------------------------------------------------------------------------------------------------------------------------
+
+    if COMMAND == 'CALC_G':
+        kwargs['CALCUL_CONTRAINTE'] =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") )
+
+
+    mcfact = FACT(statut='f',max='**', **kwargs)
+
+    return mcfact
+#& MODIF COMMUN  DATE 08/02/2011   AUTEUR PROIX J-M.PROIX 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -328,7 +484,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**',  #COMMUN#
                                  ),
 
            DEFORMATION       =SIMP(statut='f',typ='TXM',defaut="PETIT",
-                                   into=("PETIT","PETIT_REAC","GROT_GDEP","SIMO_MIEHE","GDEF_HYPO_ELAS","GREEN_REAC")),
+                                   into=("PETIT","PETIT_REAC","GROT_GDEP","SIMO_MIEHE","GDEF_HYPO_ELAS","GREEN_REAC","GDEF_LOG")),
            ALGO_C_PLAN       =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)),
            RESI_DEBO_MAXI    =SIMP(statut='f',typ='R',fr="Critère d'arret absolu pour assurer la condition de contraintes planes",),
 
@@ -340,15 +496,17 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**',  #COMMUN#
            ALGO_1D           =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)),
            ITER_MAXI_DEBORST =SIMP(statut='f',typ='I',defaut= 1),
            RESI_INTE_RELA    =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ITER_INTE_MAXI    =SIMP(statut='f',typ='I',defaut= 10 ),
+           ITER_INTE_MAXI    =SIMP(statut='f',typ='I',defaut= 20 ),
 
            b_redec_local      = BLOC(condition = "DEFORMATION in ('PETIT','PETIT_REAC','GROT_GDEP')",
                                      fr="Nombre de redécoupages internes du pas de temps",
                ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut= 0 ),
                                      ),
 
-           RESO_INTE         =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
-                                   into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE","IMPLICITE_RELI")),
+           ALGO_INTE         =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE", "SECANTE", "DEKKER", "NEWTON_1D","BRENT", 
+                                                              "NEWTON", "NEWTON_RELI", "NEWTON_PERT", "RUNGE_KUTTA",
+                                                              "SPECIFIQUE", "SANS_OBJET")),
+
            TYPE_MATR_TANG    =SIMP(statut='f',typ='TXM',into=("PERTURBATION","VERIFICATION","TANGENTE_SECANTE")),
 
            b_perturb         =BLOC(condition = " (TYPE_MATR_TANG != None) and (TYPE_MATR_TANG != 'TANGENTE_SECANTE') ",
@@ -372,7 +530,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**',  #COMMUN#
            MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
 
          ) ;
-#& MODIF COMMUN  DATE 12/04/2010   AUTEUR MICHEL S.MICHEL 
+#& MODIF COMMUN  DATE 06/12/2010   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
@@ -390,7 +548,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**',  #COMMUN#
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
-# RESPONSABLE REZETTE C.REZETTE
+# RESPONSABLE ABBAS M.ABBAS
 def C_CONVERGENCE() : return FACT(statut='d',
            regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA','RESI_COMP_RELA'),),
            b_refe_rela    =BLOC(condition = "RESI_REFE_RELA != None",
@@ -447,7 +605,7 @@ def C_IMPL_EX() : return FACT(statut='d',
            REAC_INCR       =SIMP(statut='f',typ='I',defaut= 1),
            PREDICTION      =SIMP(statut='f',typ='TXM',defaut="TANGENTE"),
          );
-#& MODIF COMMUN  DATE 20/07/2009   AUTEUR GENIAUT S.GENIAUT 
+#& MODIF COMMUN  DATE 06/12/2010   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
@@ -465,7 +623,7 @@ def C_IMPL_EX() : return FACT(statut='d',
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
-# RESPONSABLE REZETTE C.REZETTE
+# RESPONSABLE ABBAS M.ABBAS
 def C_INCREMENT() : return FACT(statut='o',
            regles=(EXCLUS('NUME_INST_INIT','INST_INIT'),
                    EXCLUS('NUME_INST_FIN','INST_FIN'),),
@@ -479,7 +637,7 @@ def C_INCREMENT() : return FACT(statut='o',
                                  ang="Time adaptation for unstationary HM models"),
            PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-6 ),
          );
-#& MODIF COMMUN  DATE 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#& MODIF COMMUN  DATE 06/12/2010   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
@@ -497,7 +655,7 @@ def C_INCREMENT() : return FACT(statut='o',
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
-# RESPONSABLE REZETTE C.REZETTE
+# RESPONSABLE ABBAS M.ABBAS
 def C_NEWTON() : return FACT(statut='d',
            REAC_INCR       =SIMP(statut='f',typ='I',defaut= 1,val_min=0),
            PREDICTION      =SIMP(statut='f',typ='TXM',into=("DEPL_CALCULE","TANGENTE","ELASTIQUE","EXTRAPOL") ),
@@ -507,10 +665,10 @@ def C_NEWTON() : return FACT(statut='d',
            REAC_ITER_ELAS  =SIMP(statut='f',typ='I',defaut=0,val_min=0),
            EVOL_NOLI       =SIMP(statut='f',typ=evol_noli),
          );
-#& MODIF COMMUN  DATE 19/10/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMUN  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -528,198 +686,209 @@ def C_NEWTON() : return FACT(statut='d',
 # RESPONSABLE VABHHTS J.PELLET
 # ce fichier contient la liste des "into" possibles pour le mot cle NOM_CHAM
 # c'est a dire les noms de champs des SD RESULTAT (DATA de la routine RSCRSD)
-def C_NOM_CHAM_INTO() : return  ("ACCE",    #COMMUN#
+
+def C_NOM_CHAM_INTO( typ_cham=None ) : #COMMUN# 
+  import types
+# Liste de tout les champs
+  l_tout_cham = [
+                        "ACCE",
                         "ACCE_ABSOLU",
                         "ALPH0_ELGA_EPSP",
                         "ALPHP_ELGA_ALPH0",
                         "COMPORTEMENT",
                         "COMPORTHER",
-                        "CRIT_ELNO_RUPT",
-                        "DCHA_ELGA_SIGM",
-                        "DCHA_ELNO_SIGM",
-                        "DCHA_NOEU_SIGM",
-                        "DEDE_ELNO_DLDE",
-                        "DEDE_NOEU_DLDE",
-                        "DEGE_ELNO_DEPL",
-                        "DEGE_NOEU_DEPL",
+                        "CRIT_ELNO",
+                        "DEDE_ELNO",
+                        "DEDE_NOEU",
+                        "DEGE_ELNO",
+                        "DEGE_NOEU",
                         "DEPL",
                         "DEPL_ABSOLU",
-                        "DESI_ELNO_DLSI",
-                        "DESI_NOEU_DLSI",
-                        "DETE_ELNO_DLTE",
-                        "DETE_NOEU_DLTE",
+                        "DERA_ELGA",
+                        "DERA_ELNO",
+                        "DERA_NOEU",
+                        "DESI_ELNO",
+                        "DESI_NOEU",
+                        "DETE_ELNO",
+                        "DETE_NOEU",
                         "DISS_ELGA",
-                        "DISS_ELNO_ELGA",
-                        "DURT_ELGA_META",
-                        "DURT_ELNO_META",
-                        "DURT_NOEU_META",
-                        "ECIN_ELEM_DEPL",
-                        "EFGE_ELNO_CART",
-                        "EFGE_ELNO_DEPL",
-                        "EFGE_NOEU_CART",
-                        "EFGE_NOEU_DEPL",
+                        "DISS_ELNO",
+                        "DISS_NOEU",
+                        "DURT_ELNO",
+                        "DURT_NOEU",
+                        "ECIN_ELEM",
+                        "EFCA_ELNO",
+                        "EFCA_NOEU",
+                        "EFGE_ELNO",
+                        "EFGE_NOEU",
                         "ENDO_ELGA",
-                        "ENDO_ELNO_ELGA",
-                        "ENDO_ELNO_SIGA",
-                        "ENDO_ELNO_SINO",
-                        "ENDO_NOEU_SINO",
+                        "ENDO_ELNO",
+                        "ENDO_NOEU",
                         "ENEL_ELGA",
-                        "ENEL_ELNO_ELGA",
-                        "ENEL_NOEU_ELGA",
-                        "EPEQ_ELNO_TUYO",
-                        "EPVC_ELGA",
-                        "EPVC_ELNO",
+                        "ENEL_ELNO",
+                        "ENEL_NOEU",
+                        "EPEQ_ELGA",
+                        "EPEQ_ELNO",
+                        "EPEQ_NOEU",
                         "EPFD_ELGA",
                         "EPFD_ELNO",
+                        "EPFD_NOEU",
                         "EPFP_ELGA",
                         "EPFP_ELNO",
-                        "EPME_ELGA_DEPL",
-                        "EPME_ELNO_DEPL",
-                        "EPMG_ELGA_DEPL",
-                        "EPMG_ELNO_DEPL",
-                        "EPMG_NOEU_DEPL",
-                        "EPOT_ELEM_DEPL",
+                        "EPFP_NOEU",
+                        "EPME_ELGA",
+                        "EPME_ELNO",
+                        "EPMG_ELGA",
+                        "EPMG_ELNO",
+                        "EPMG_NOEU",
+                        "EPMQ_ELGA",
+                        "EPMQ_ELNO",
+                        "EPMQ_NOEU",
+                        "EPOT_ELEM",
                         "EPSA_ELNO",
                         "EPSA_NOEU",
-                        "EPSG_ELGA_DEPL",
-                        "EPSG_ELNO_DEPL",
-                        "EPSG_NOEU_DEPL",
-                        "EPSI_ELGA_DEPL",
-                        "EPSI_ELNO_DEPL",
-                        "EPSI_ELNO_TUYO",
-                        "EPSI_NOEU_DEPL",
+                        "EPSG_ELGA",
+                        "EPSG_ELNO",
+                        "EPSG_NOEU",
+                        "EPSI_ELGA",
+                        "EPSI_ELNO",
+                        "EPSI_NOEU",
                         "EPSP_ELGA",
                         "EPSP_ELNO",
                         "EPSP_NOEU",
-                        "EQUI_ELGA_EPME",
-                        "EQUI_ELGA_EPSI",
-                        "EQUI_ELGA_SIGM",
-                        "EQUI_ELNO_EPME",
-                        "EQUI_ELNO_EPSI",
-                        "EQUI_ELNO_SIGM",
-                        "EQUI_NOEU_EPME",
-                        "EQUI_NOEU_EPSI",
-                        "EQUI_NOEU_SIGM",
-                        "ERRE_ELEM_SIGM",
-                        "ERRE_ELEM_TEMP",
-                        "ERRE_ELNO_ELEM",
-                        "ERRE_NOEU_ELEM",
-                        "ERZ1_ELEM_SIGM",
-                        "ERZ2_ELEM_SIGM",
-                        "FERRAILLAGE",
-                        "QIRE_ELEM_SIGM",
-                        "QIRE_ELNO_ELEM",
-                        "QIRE_NOEU_ELEM",
-                        "QIZ1_ELEM_SIGM",
-                        "QIZ2_ELEM_SIGM",
-                        "SING_ELEM",
-                        "SING_ELNO_ELEM",
+                        "EPTQ_ELNO",
+                        "EPTU_ELNO",
+                        "EPVC_ELGA",
+                        "EPVC_ELNO",
+                        "EPVC_NOEU",
+                        "ERME_ELEM",
+                        "ERME_ELNO",
+                        "ERME_NOEU",
+                        "ERTH_ELEM",
+                        "ERTH_ELNO",
+                        "ERTH_NOEU",
+                        "ERZ1_ELEM",
+                        "ERZ2_ELEM",
                         "ETOT_ELEM",
                         "ETOT_ELGA",
-                        "ETOT_ELNO_ELGA",
-                        "EXTR_ELGA_VARI",
-                        "EXTR_ELNO_VARI",
-                        "EXTR_NOEU_VARI",
+                        "ETOT_ELNO",
+                        "FERRAILLAGE",
                         "FLHN_ELGA",
-                        "FLUX_ELGA_TEMP",
-                        "FLUX_ELNO_TEMP",
-                        "FLUX_NOEU_TEMP",
+                        "FLUX_ELGA",
+                        "FLUX_ELNO",
+                        "FLUX_NOEU",
                         "FORC_NODA",
                         "FSUR_2D",
                         "FSUR_3D",
                         "FVOL_2D",
                         "FVOL_3D",
                         "GRAD_NOEU_THETA",
-                        "HYDR_ELNO_ELGA",
-                        "HYDR_NOEU_ELGA",
-                        "INDI_LOCA_ELGA",
-                        "INTE_ELNO_ACTI",
-                        "INTE_ELNO_REAC",
-                        "INTE_NOEU_ACTI",
-                        "INTE_NOEU_REAC",
+                        "HYDR_ELNO",
+                        "HYDR_NOEU",
+                        "INDL_ELGA",
+                        "INTE_ELNO",
+                        "INTE_NOEU",
                         "IRRA",
                         "LANL_ELGA",
                         "META_ELGA_TEMP",
-                        "META_ELNO_TEMP",
-                        "META_NOEU_TEMP",
+                        "META_ELNO",
+                        "META_NOEU",
                         "MODE_FLAMB",
-                        "PMPB_ELGA_SIEF",
-                        "PMPB_ELNO_SIEF",
-                        "PMPB_NOEU_SIEF",
+                        "PMPB_ELGA",
+                        "PMPB_ELNO",
+                        "PMPB_NOEU",
+                        "PRAC_ELNO",
+                        "PRAC_NOEU",
                         "PRES",
-                        "PRES_DBEL_DEPL",
-                        "PRES_ELNO_DBEL",
-                        "PRES_ELNO_IMAG",
-                        "PRES_ELNO_REEL",
-                        "PRES_NOEU_DBEL",
-                        "PRES_NOEU_IMAG",
-                        "PRES_NOEU_REEL",
-                        "PROJ_ELEM_SIGM",
-                        "RADI_ELGA_SIGM",
-                        "RADI_ELNO_SIGM",
-                        "RADI_NOEU_SIGM",
+                        "PRME_ELNO",
+                        "QIRE_ELEM",
+                        "QIRE_ELNO",
+                        "QIRE_NOEU",
+                        "QIZ1_ELEM",
+                        "QIZ2_ELEM",
                         "REAC_NODA",
+                        "SICA_ELNO",
+                        "SICA_NOEU",
+                        "SICO_ELNO",
+                        "SICO_NOEU",
                         "SIEF_ELGA",
-                        "SIEF_ELGA_DEPL",
                         "SIEF_ELNO",
-                        "SIEF_ELNO_ELGA",
                         "SIEF_NOEU",
-                        "SIEF_NOEU_ELGA",
                         "SIEF_SENO_SEGA",
-                        "SIEQ_ELNO_TUYO",
-                        "SIGM_ELNO_CART",
-                        "SIGM_ELNO_COQU",
-                        "SIGM_ELNO_DEPL",
-                        "SIGM_ELNO_SIEF",
-                        "SIGM_ELNO_TUYO",
-                        "SIGM_NOEU_CART",
-                        "SIGM_NOEU_COQU",
-                        "SIGM_NOEU_DEPL",
-                        "SIGM_NOEU_SIEF",
-                        "SIGM_NOZ1_ELGA",
-                        "SIGM_NOZ2_ELGA",
-                        "SIPO_ELNO_DEPL",
-                        "SIPO_ELNO_SIEF",
-                        "SIPO_NOEU_DEPL",
-                        "SIPO_NOEU_SIEF",
-                        "SOUR_ELGA_ELEC",
+                        "SIEQ_ELGA",
+                        "SIEQ_ELNO",
+                        "SIEQ_NOEU",
+                        "SIGM_ELNO",
+                        "SIGM_NOEU",
+                        "SING_ELEM",
+                        "SING_ELNO",
+                        "SIPM_ELNO",
+                        "SIPO_ELNO",
+                        "SIPO_NOEU",
+                        "SIRO_ELEM",
+                        "SITQ_ELNO",
+                        "SITU_ELNO",
+                        "SIZ1_ELGA",
+                        "SIZ2_ELGA",
+                        "SOUR_ELGA",
+                        "SPMX_ELGA",
                         "TEMP",
                         "THETA",
+                        "VACO_ELNO",
+                        "VAEX_ELGA",
+                        "VAEX_ELNO",
+                        "VAEX_NOEU",
                         "VALE_CONT",
-                        "VALE_NCOU_MAXI",
                         "VARC_ELGA",
                         "VARI_ELGA",
                         "VARI_ELNO",
-                        "VARI_ELNO_COQU",
-                        "VARI_ELNO_ELGA",
-                        "VARI_ELNO_TUYO",
                         "VARI_NOEU",
-                        "VARI_NOEU_ELGA",
+                        "VATU_ELNO",
                         "VITE",
                         "VITE_ABSOLU",
                         "VITE_VENT",
-                        )
-#& MODIF COMMUN  DATE 14/12/2009   AUTEUR ANDRIAM H.ANDRIAMBOLOLONA 
+                        ]
+#
+# Si aucun argument n'est passe, on utilise tous les types de champs possibles
+  if ( typ_cham is None ) :
+    l_ncham = l_tout_cham
+#
+# Sinon, on n'utilise que les champs dont le type est passe en argument
+  else :
+    l_typ_cham = []
+    if (type(typ_cham) == types.StringType) :
+      l_typ_cham.append(typ_cham)
+    else :
+      l_typ_cham = typ_cham
+    l_ncham = []
+    for typ in l_typ_cham :
+     for cham in l_tout_cham :
+       if (cham.find(typ) != -1) :
+        if (cham.split('_')[1] == typ):
+           l_ncham.append(cham)
+
+  return tuple(l_ncham)
+#& MODIF COMMUN  DATE 04/04/2011   AUTEUR PELLET J.PELLET 
 # RESPONSABLE DESROCHES X.DESROCHES
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2005  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 # ce fichier contient la liste des  noms des grandeurs de CODE_ASTER
-def C_NOM_GRANDEUR() : return  ( #COMMUN# 
+def C_NOM_GRANDEUR() : return  ( #COMMUN#
 "ABSC_R",
 "ADRSJEVE",
 "ADRSJEVN",
@@ -757,8 +926,9 @@ def C_NOM_GRANDEUR() : return  ( #COMMUN#
 "DEPL_F",
 "DEPL_R",
 "DISS_R",
-"DOMMAG",
+"DOMA_R",
 "DURT_R",
+"ENDO_R",
 "ENER_R",
 "EPSI_C",
 "EPSI_F",
@@ -766,6 +936,7 @@ def C_NOM_GRANDEUR() : return  ( #COMMUN#
 "ERRE_R",
 "FACY_R",
 "FELECR",
+"FER2_R",
 "FISS_R",
 "FLAPLA",
 "FLUN_F",
@@ -786,7 +957,7 @@ def C_NOM_GRANDEUR() : return  ( #COMMUN#
 "IMPE_C",
 "IMPE_F",
 "IMPE_R",
-"IND_LOCA",
+"INDL_R",
 "INFC_R",
 "INST_R",
 "INTE_R",
@@ -848,6 +1019,88 @@ def C_NOM_GRANDEUR() : return  ( #COMMUN#
 "WEIBULL",
 "XCONTAC",
                                  )
+#& MODIF COMMUN  DATE 17/01/2011   AUTEUR ABBAS M.ABBAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ABBAS M.ABBAS
+
+def C_OBSERVATION() : return FACT(statut='f',max=99,
+
+           NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
+                                   into=("VALE_CONT","FORC_NODA",
+                                         "DEPL","VITE","ACCE","TEMP",
+                                         "SIEF_ELGA","VARI_ELGA",                                        
+                                         "DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)),
+          
+           EVAL_CHAM       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE',
+                                   into=("MIN","MAX","MOY","VALE",),),
+                                         
+           NOM_CMP         =SIMP(statut='o',typ='TXM',max=20),
+           EVAL_CMP        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE',
+                                   into=("VALE","FORMULE",),),
+                                   
+           b_formule       =BLOC(condition="(EVAL_CMP=='FORMULE')",
+                                   FORMULE = SIMP(statut='o',typ=formule,max=1),
+                                ),
+                                                 
+           b_cham_no       =BLOC(condition="(NOM_CHAM=='DEPL') or \
+                                            (NOM_CHAM=='VITE') or \
+                                            (NOM_CHAM=='ACCE') or \
+                                            (NOM_CHAM=='TEMP') or \
+                                            (NOM_CHAM=='FORC_NODA') or \
+                                            (NOM_CHAM=='VALE_CONT') or \
+                                            (NOM_CHAM=='DEPL_ABSOLU') or \
+                                            (NOM_CHAM=='VITE_ABSOLU') or \
+                                            (NOM_CHAM=='ACCE_ABSOLU')",
+                                 regles   =(UN_PARMI('NOEUD','GROUP_NO','GROUP_MA','MAILLE','TOUT')),
+                                 TOUT            =SIMP(statut='d',typ='TXM',into=("OUI",) ),
+                                 NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                                 GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                                 MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                                 GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),          
+                                ),          
+
+                                          
+           b_cham_elga     =BLOC(condition="(NOM_CHAM=='SIEF_ELGA') or \
+                                            (NOM_CHAM=='VARI_ELGA')",
+                                 regles          =(UN_PARMI('GROUP_MA','MAILLE','TOUT')), 
+                                 TOUT            =SIMP(statut='d',typ='TXM',into=("OUI",) ),          
+                                 MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                                 GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), 
+                                 EVAL_ELGA       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE',
+                                                        into=("MIN","MAX","VALE",),), 
+                                 b_elga_vale     =BLOC(condition="(EVAL_ELGA=='VALE')",                     
+                                   POINT           =SIMP(statut='o',typ='I'  ,validators=NoRepeat(),max='**'), 
+                                   SOUS_POINT      =SIMP(statut='f',typ='I'  ,validators=NoRepeat(),max='**'),  
+                                 ),  
+                                ),
+             
+           INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
+           LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+           PAS_OBSE        =SIMP(statut='f',typ='I'),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+              PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+           b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+              PRECISION       =SIMP(statut='o',typ='R',),),
+       
+       
+       );
 #& MODIF COMMUN  DATE 29/03/2007   AUTEUR GRANET S.GRANET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -873,7 +1126,48 @@ def C_PARA_FONCTION() : return  ( #COMMUN#
                    "AMOR","ABSC","SIGM","HYDR","SECH","PORO","SAT",
                    "PGAZ","PCAP","PLIQ","PVAP","PAD","VITE","ENDO",
                    "NORM","EPAIS","NEUT1","NEUT2",)
-#& MODIF COMMUN  DATE 05/10/2010   AUTEUR ABBAS M.ABBAS 
+#& MODIF COMMUN  DATE 01/02/2011   AUTEUR MASSIN P.MASSIN 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ABBAS M.ABBAS
+def C_PILOTAGE() : return FACT(statut='f',
+           regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
+           TYPE    =SIMP(statut='o',typ='TXM',into=("DDL_IMPO","LONG_ARC","PRED_ELAS","DEFORMATION",
+                                                    "ANA_LIM","SAUT_IMPO","SAUT_LONG_ARC") ),
+           COEF_MULT       =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+           EVOL_PARA       =SIMP(statut='f',typ='TXM',defaut="SANS", into=("SANS","CROISSANT","DECROISSANT") ),
+           ETA_PILO_MAX    =SIMP(statut='f',typ='R'),
+           ETA_PILO_MIN    =SIMP(statut='f',typ='R'),
+           ETA_PILO_R_MAX  =SIMP(statut='f',typ='R'),
+           ETA_PILO_R_MIN  =SIMP(statut='f',typ='R'),
+           PROJ_BORNES     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+           SELECTION       =SIMP(statut='f',typ='TXM',defaut="NORM_INCR_DEPL", into=("RESIDU","ANGL_INCR_DEPL","NORM_INCR_DEPL") ),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
+           FISSURE         =SIMP(statut='f',typ=fiss_xfem ,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
+           NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),
+           DIRE_PILO       =SIMP(statut='f',typ='TXM',max='**'),
+         );
+
+#& MODIF COMMUN  DATE 06/12/2010   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
@@ -891,7 +1185,7 @@ def C_PARA_FONCTION() : return  ( #COMMUN#
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
-# RESPONSABLE REZETTE C.REZETTE
+# RESPONSABLE ABBAS M.ABBAS
 def C_RECH_LINEAIRE() : return FACT(statut='f',
            METHODE         =SIMP(statut='f',typ='TXM',defaut="CORDE",into=("CORDE","MIXTE","PILOTAGE") ),
            RESI_LINE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-1 ),
@@ -902,10 +1196,10 @@ def C_RECH_LINEAIRE() : return FACT(statut='f',
            RHO_MAX         =SIMP(statut='f',typ='R',defaut=1.0E+1),
            RHO_EXCL        =SIMP(statut='f',typ='R',defaut=0.9E-2,val_min=0.),
          );
-#& MODIF COMMUN  DATE 10/08/2010   AUTEUR MEUNIER S.MEUNIER 
+#& MODIF COMMUN  DATE 28/02/2011   AUTEUR BARGELLI R.BARGELLINI 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -939,6 +1233,7 @@ def C_RELATION() : return (             "ELAS",            #COMMUN#
                                         "CZM_LIN_REG",
                                         "CZM_OUV_MIX",
                                         "CZM_TAC_MIX",
+                                        "CZM_TRA_MIX",
                                         "DIS_BILI_ELAS",
                                         "DIS_CHOC",
                                         "DIS_ECRO_CINE",
@@ -950,6 +1245,7 @@ def C_RELATION() : return (             "ELAS",            #COMMUN#
                                         "DRUCK_PRAG_N_A",
                                         "ELAS_GONF",
                                         "ELAS_HYPER",
+                                        "ENDO_CARRE",
                                         "ENDO_FRAGILE",
                                         "ENDO_HETEROGENE",
                                         "ENDO_ISOT_BETON",
@@ -969,13 +1265,11 @@ def C_RELATION() : return (             "ELAS",            #COMMUN#
                                         "HOEK_BROWN_EFF",
                                         "HOEK_BROWN_TOT",
                                         "HUJEUX",
-                                        "IMPLEX_FRAG",
-                                        "IMPLEX_ISOT_BETO",
-                                        "IMPLEX_ISOT_LINE",
                                         "IRRAD3M",
                                         "JOINT_BA",
                                         "JOINT_BANDIS",
                                         "JOINT_MECA_RUPT",
+                                        "JOINT_MECA_FROT",
                                         "KIT_DDI",
                                         "KIT_HH",
                                         "KIT_H",
@@ -1029,6 +1323,7 @@ def C_RELATION() : return (             "ELAS",            #COMMUN#
                                         "RUPT_FRAG",
                                         "SANS",
                                         "VENDOCHAB",
+                                        "VISC_ENDO_LEMA",
                                         "VISCOCHAB",
                                         "VISC_CIN1_CHAB",
                                         "VISC_CIN2_CHAB",
@@ -1053,10 +1348,10 @@ def C_RELATION() : return (             "ELAS",            #COMMUN#
                                         "ZMAT",
                                         "UMAT",
                                      )
-#& MODIF COMMUN  DATE 20/09/2010   AUTEUR TARDIEU N.TARDIEU 
+#& MODIF COMMUN  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -1096,7 +1391,7 @@ def C_SOLVEUR() : return FACT(statut='d',
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -1106,11 +1401,12 @@ def C_SOLVEUR() : return FACT(statut='d',
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),            
              FILTRAGE_MATRICE =SIMP(statut='f',typ='R',defaut=-1.0,),
              MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              MATR_DISTRIBUEE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
@@ -1144,7 +1440,7 @@ def C_SOLVEUR() : return FACT(statut='d',
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -1157,6 +1453,79 @@ def C_SOLVEUR() : return FACT(statut='d',
 # --------------------------------------------------------------------------------------------------------------------------------
            SYME            =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
          );
+#& MODIF COMMUN  DATE 17/01/2011   AUTEUR ABBAS M.ABBAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ABBAS M.ABBAS
+
+def C_SUIVI_DDL() : return FACT(statut='f',max=4,
+
+           NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
+                                   into=("DEPL","VITE","ACCE",
+                                         "FORC_NODA",
+                                         "SIEF_ELGA","VARI_ELGA",                                        
+                                         "DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)),
+          
+           EVAL_CHAM       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE',
+                                   into=("MIN","MAX","MOY","VALE",),),
+                                         
+           NOM_CMP         =SIMP(statut='o',typ='TXM',max=20),
+           EVAL_CMP        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE',
+                                   into=("VALE","FORMULE",),),
+                                   
+           b_formule       =BLOC(condition="(EVAL_CMP=='FORMULE')",
+                                   FORMULE = SIMP(statut='o',typ=formule,max=1),
+                                ),                 
+           
+           b_cham_no       =BLOC(condition="(NOM_CHAM=='DEPL') or \
+                                            (NOM_CHAM=='VITE') or \
+                                            (NOM_CHAM=='ACCE') or \
+                                            (NOM_CHAM=='FORC_NODA') or \
+                                            (NOM_CHAM=='VALE_CONT') or \
+                                            (NOM_CHAM=='DEPL_ABSOLU') or \
+                                            (NOM_CHAM=='VITE_ABSOLU') or \
+                                            (NOM_CHAM=='ACCE_ABSOLU')",                                 
+                                 regles   =(UN_PARMI('NOEUD','GROUP_NO','GROUP_MA','MAILLE','TOUT')),
+                                 TOUT            =SIMP(statut='d',typ='TXM',into=("OUI",) ),
+                                 NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                                 GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                                 MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                                 GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),   
+                                ), 
+                                          
+           b_cham_elga     =BLOC(condition="(NOM_CHAM=='SIEF_ELGA') or \
+                                            (NOM_CHAM=='VARI_ELGA')",
+                                 regles          =(UN_PARMI('GROUP_MA','MAILLE','TOUT')), 
+                                 TOUT            =SIMP(statut='d',typ='TXM',into=("OUI",) ),          
+                                 MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                                 GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'), 
+                                 EVAL_ELGA       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,defaut='VALE',
+                                                        into=("MIN","MAX","VALE",),), 
+                                 b_elga_vale     =BLOC(condition="(EVAL_ELGA=='VALE')",                     
+                                   POINT           =SIMP(statut='o',typ='I'  ,validators=NoRepeat(),max='**'), 
+                                   SOUS_POINT      =SIMP(statut='f',typ='I'  ,validators=NoRepeat(),max='**'),  
+                                 ),  
+                                ), 
+             
+           TITRE           =  SIMP(statut='f',typ='TXM',max=3),     
+       
+       
+       );
 #& MODIF COMMUN  DATE 09/11/2010   AUTEUR GNICOLAS G.NICOLAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -1195,10 +1564,10 @@ def C_TYPE_CHAM_INTO( type_cham=None ) : #COMMUN#
 #
   return tuple(l)
 
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -1220,7 +1589,8 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op=  19,sd_prod=cara_elem,
    UIinfo ={"groupes":("Modélisation",)},
    regles = (AU_MOINS_UN('POUTRE','BARRE','COQUE','CABLE','DISCRET','DISCRET_2D','MASSIF',
                          'GRILLE','MULTIFIBRE','RIGI_PARASOL'),
-             PRESENT_PRESENT('MULTIFIBRE','GEOM_FIBRE'),),
+             PRESENT_PRESENT('MULTIFIBRE','GEOM_FIBRE'),
+             EXCLUS('DISCRET','DISCRET_2D'),),
    MODELE = SIMP(statut='o',typ=modele_sdaster ),
    INFO   = SIMP(statut='f',typ='I', defaut= 1 ,into=(1,2) ),
    VERIF  = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=("MAILLE","NOEUD") ),
@@ -1745,19 +2115,26 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op=  19,sd_prod=cara_elem,
       regles               = (UN_PARMI('COEF_GROUP','FONC_GROUP'),
                               UN_PARMI('COOR_CENTRE','NOEUD_CENTRE','GROUP_NO_CENTRE'),
                               EXCLUS('GROUP_MA_POI1','GROUP_MA_SEG2'),),
-      GROUP_MA             = SIMP(statut='o',typ=ma,validators=NoRepeat(),max='**',
+      GROUP_MA             = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**',
          fr="Surface servant à répartir les caractéristiques des discrets"),
-      GROUP_MA_POI1        = SIMP(statut='f',typ=ma,validators=NoRepeat(),max=1,
+      GROUP_MA_POI1        = SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1,
          fr="Mailles de type point correspondant aux discrets"),
-      GROUP_MA_SEG2        = SIMP(statut='f',typ=ma,validators=NoRepeat(),max=1,
+      GROUP_MA_SEG2        = SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1,
          fr="Mailles de type seg2 correspondant aux discrets"),
       FONC_GROUP           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
       COEF_GROUP           = SIMP(statut='f',typ='R',max='**'),
       REPERE               = SIMP(statut='f',typ='TXM',into=("LOCAL","GLOBAL") ),
       CARA                 = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=2,
                                  into=("K_TR_D_N","K_T_D_N","K_TR_D_L","K_T_D_L",
-                                       "A_TR_D_N","A_T_D_N","A_TR_D_L","A_T_D_L") ),
-      VALE                 = SIMP(statut='o',typ='R',max='**'),
+                                       "A_TR_D_N","A_T_D_N","A_TR_D_L","A_T_D_L"),
+                                 fr="Choix des types de discrets du tapis de ressorts." ),
+      b_cara= BLOC(condition =""" (CARA in ["K_TR_D_N","K_T_D_N","K_TR_D_L","K_T_D_L",
+                                            "A_TR_D_N","A_T_D_N","A_TR_D_L","A_T_D_L"]) or \
+                                  (len(CARA)==2 and CARA[0][2:]==CARA[1][2:]) """,
+                   fr="Valeurs pour les discrets du tapis de ressorts.",
+         VALE = SIMP(statut='o',typ='R',max='**',
+              fr="Valeurs pour les discrets du tapis de ressorts.",),
+      ),
       GROUP_NO_CENTRE      = SIMP(statut='f',typ=grno),
       NOEUD_CENTRE         = SIMP(statut='f',typ=no),
       COOR_CENTRE          = SIMP(statut='f',typ='R',min=2,max=3),
@@ -1767,8 +2144,8 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op=  19,sd_prod=cara_elem,
 
 #============================================================================
    RIGI_MISS_3D         = FACT(statut='f',max='**',
-      GROUP_MA_POI1        = SIMP(statut='o',typ=ma,max=1),
-      GROUP_MA_SEG2        = SIMP(statut='f',typ=ma,max=1),
+      GROUP_MA_POI1        = SIMP(statut='o',typ=grma,max=1),
+      GROUP_MA_SEG2        = SIMP(statut='f',typ=grma,max=1),
       FREQ_EXTR            = SIMP(statut='o',typ='R',max=1),
       UNITE_RESU_IMPE      = SIMP(statut='f',typ='I',defaut=30),
    ),
@@ -1846,10 +2223,10 @@ AFFE_CHAR_ACOU=OPER(nom="AFFE_CHAR_ACOU",op=  68,sd_prod=char_acou,
            DDL             =SIMP(statut='o',typ='TXM',max='**'),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 01/03/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -1881,13 +2258,13 @@ def affe_char_cine_prod(MECA_IMPO,THER_IMPO,ACOU_IMPO,EVOL_IMPO,**args):
 
 
 AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod
-                    ,fr="Affectation de conditions aux limites cinématiques constantes pour un traitement sans dualisation",
+                    ,fr="Affectation de conditions aux limites cinématiques (U=U0) pour un traitement sans dualisation",
                      reentrant='n',
             UIinfo={"groupes":("Chargements","Mécanique",)},
          regles=(UN_PARMI('MECA_IMPO','THER_IMPO','ACOU_IMPO','EVOL_IMPO'),
                  ),
          MODELE          =SIMP(statut='o',typ=modele_sdaster ),
-         EVOL_IMPO  =SIMP(statut='f',typ=(evol_noli,evol_elas,evol_ther),fr="Pour imposer tous les ddls d'un evol_xxx"),
+
          MECA_IMPO       =FACT(statut='f',max='**',
            regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
                    AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
@@ -1985,6 +2362,7 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod
              PRES33          =SIMP(statut='f',typ='R' ),
              LH1             =SIMP(statut='f',typ='R' ),
          ),
+
          THER_IMPO       =FACT(statut='f',max='**',
            regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
                    AU_MOINS_UN('TEMP','TEMP_INF','TEMP_SUP'),),
@@ -1997,6 +2375,7 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod
            TEMP            =SIMP(statut='f',typ='R' ),
            TEMP_INF        =SIMP(statut='f',typ='R' ),
          ),
+
          ACOU_IMPO       =FACT(statut='f',max='**',
            regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
            TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
@@ -2006,6 +2385,12 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod
            NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
            PRES            =SIMP(statut='o',typ='C' ),
          ),
+
+         EVOL_IMPO  =SIMP(statut='f',typ=(evol_noli,evol_elas,evol_ther),fr="Pour imposer les ddls d'un evol_xxx"),
+         b_evol_impo = BLOC ( condition = "EVOL_IMPO != None",
+           NOM_CMP         =SIMP(statut='f',typ='TXM',max='**',), # pour n'imposer que certaines CMPS (par défaut : toutes)
+         ),
+
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
 )  ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
@@ -2151,10 +2536,10 @@ AFFE_CHAR_CINE_F=OPER(nom="AFFE_CHAR_CINE_F",op= 101,sd_prod=affe_char_cine_f_pr
          ),
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
 )  ;
-#& MODIF COMMANDE  DATE 08/11/2010   AUTEUR DESROCHES X.DESROCHES 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -2182,7 +2567,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op=   7,sd_prod=char_meca,
                              'LIAISON_GROUP','LIAISON_UNIF','FLUX_THM_REP','LIAISON_SOLIDE',
                              'LIAISON_ELEM','ONDE_FLUI','LIAISON_CHAMNO','VECT_ASSE','LIAISON_COQUE',
                              'LIAISON_MAIL','LIAISON_CYCL','FORCE_TUYAU',
-                             'EFFE_FOND','EVOL_CHAR','ARLEQUIN','DDL_POUTRE',),
+                             'EFFE_FOND','EVOL_CHAR','DDL_POUTRE',),
                          ),
          VERI_NORM       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
          MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
@@ -2218,7 +2603,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op=   7,sd_prod=char_meca,
                                  'UO3','VO2','VO3','WO2','WO3','UI4','UI5','VI4','VI5','WI4',
                                  'WI5','UO4','UO5','VO4','VO5','WO4','WO5','UI6','UO6','VI6',
                                  'VO6','WI6','WO6','WO','WI1','WO1','GONF','LIAISON',
-                                 'H1X','H1Y','H1Z','H2X','H2Y','H2Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
+                                 'H1X','H1Y','H1Z','H2X','H2Y','H2Z','H3X','H3Y','H3Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
                                  'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22',
                                  'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23',
                                  'PRES31','PRES32','PRES33',),),
@@ -2279,7 +2664,10 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op=   7,sd_prod=char_meca,
              H1Z             =SIMP(statut='f',typ='R' ),
              H2X             =SIMP(statut='f',typ='R' ),
              H2Y             =SIMP(statut='f',typ='R' ),
-             H2Z             =SIMP(statut='f',typ='R' ),           
+             H2Z             =SIMP(statut='f',typ='R' ),
+             H3X             =SIMP(statut='f',typ='R' ),
+             H3Y             =SIMP(statut='f',typ='R' ),
+             H3Z             =SIMP(statut='f',typ='R' ),
              E1X             =SIMP(statut='f',typ='R' ),
              E1Y             =SIMP(statut='f',typ='R' ),
              E1Z             =SIMP(statut='f',typ='R' ),
@@ -2433,7 +2821,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op=   7,sd_prod=char_meca,
                MAILLE_2        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
                GROUP_NO_1      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
                NOEUD_1         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-               GROUP_NO_2      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+               GROUP_NO_2      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
                NOEUD_2         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
 
              SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
@@ -2694,21 +3082,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op=   7,sd_prod=char_meca,
              KXY             =SIMP(statut='f',typ='R' ),
            ),
 
-         ARLEQUIN        =FACT(statut='f',min=1,max='**',
-           fr="Définit les paramètres de la méthode Arlequin",
-           GROUP_MA_1     =SIMP(statut='o',typ=grma,max='**'),
-           GROUP_MA_2     =SIMP(statut='o',typ=grma,max='**'),
-           GROUP_MA_COLL  =SIMP(statut='f',typ=grma,max='**'),
-           CARA_ELEM      =SIMP(statut='f',typ=cara_elem ),
-           COND_LIM       =SIMP(statut='f',typ=char_meca ),
-           COLLAGE        =SIMP(statut='f',typ='TXM',defaut="GROSSIER",into=("GROSSIER","FIN","GROUP_MA_1","GROUP_MA_2"),),
-           regles         =(UN_PARMI('POIDS_1','POIDS_2','POIDS_GROSSIER','POIDS_FIN',),),
-           POIDS_1        =SIMP(statut='f',typ='R'),
-           POIDS_2        =SIMP(statut='f',typ='R'),
-           POIDS_GROSSIER =SIMP(statut='f',typ='R'),
-           UNITE_GMSH     =SIMP(statut='f',typ='I',defaut=0,max=1),
-           POIDS_FIN      =SIMP(statut='f',typ='R'),),
-
         FORCE_POUTRE    =FACT(statut='f',max='**',
              fr="Applique des forces linéiques sur des éléments de type poutre",
              regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
@@ -3874,10 +4247,10 @@ AFFE_CHAR_THER_F=OPER(nom="AFFE_CHAR_THER_F",op=34,sd_prod=char_ther,
 
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -3938,13 +4311,18 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater,
           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
 
-          NOM_VARC        =SIMP(statut='o',typ='TXM', into=("TEMP","CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC",
-                                                            "EPSA","NEUT1","NEUT2")),
+          NOM_VARC        =SIMP(statut='o',typ='TXM', 
+#                                     champ dans la doc   into=("TEMP","CORR","IRRA","HYDR_ELNO","META_ELNO","NEUT")
+#                                     champ dans rscrsd   into=("IRRA","TEMP","HYDR_ELNO","HYDR_NOEU","EPSA_ELNO","META_ELNO")
+                                                            ),
           CHAMP_GD        =SIMP(statut='f',typ=cham_gd_sdaster,),
           EVOL            =SIMP(statut='f',typ=evol_sdaster,),
 
           B_EVOL          =BLOC(condition="EVOL!=None",
-              NOM_CHAM      =SIMP(statut='f',typ='TXM'),
+              NOM_CHAM      =SIMP(statut='f',typ='TXM',into=("TEMP","CORR","IRRA","NEUT"
+                                                             "HYDR_ELNO","HYDR_NOEU",
+                                                             "META_ELNO","META_NOEU",
+                                                             "EPSA_ELNO","EPSA_NOEU",)),
               PROL_DROITE   =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
               PROL_GAUCHE   =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
               FONC_INST     =SIMP(statut='f',typ=(fonction_sdaster,formule)),
@@ -4043,10 +4421,10 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater,
 )  ;
 
 
-#& MODIF COMMANDE  DATE 08/11/2010   AUTEUR PELLET J.PELLET 
+#& MODIF COMMANDE  DATE 22/03/2011   AUTEUR DESOZA T.DESOZA 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -4065,8 +4443,9 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater,
 AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
             UIinfo={"groupes":("Modélisation",)},
                  fr="Définir le phénomène physique modélisé et le type d'éléments finis sur le maillage",reentrant='n',
-         regles=(AU_MOINS_UN('AFFE','AFFE_SOUS_STRUC'),),
-         MAILLAGE        =SIMP(statut='o',typ=(maillage_sdaster) ),
+         regles=(AU_MOINS_UN('AFFE','AFFE_SOUS_STRUC'),UN_PARMI('MAILLAGE','GRILLE')),
+         MAILLAGE        =SIMP(statut='f',typ=maillage_sdaster),
+         GRILLE          =SIMP(statut='f',typ=grille_sdaster),
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
          VERIF           =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2,into=("MAILLE","NOEUD") ),
 #
@@ -4118,21 +4497,26 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
                                   "3D_FLUI_ABSO",    # RESP. : DEVESA G.DEVESA
                                   "3D_FLUIDE",       # RESP. : GREFFET N.GREFFET
                                   "3D_INCO",         # RESP. : MICHEL S.MICHEL
+                                  "3D_INCO_UP",      # RESP. : SFAYOLLE
                                   "3D_INCO_GD",      # RESP. : MICHEL S.MICHEL
                                   "3D_SI",           # RESP. : DESROCHES X.DESROCHES
                                   "3D_GRAD_EPSI",    # RESP. : MICHEL S.MICHEL
                                   "3D_GRAD_VARI",    # RESP. : MICHEL S.MICHEL
+                                  "3D_GVNO",         # RESP. : BEAURAIN J.BEAURAIN
                                   "3D_XFEM_CONT",    # RESP. : GENIAUT S.GENIAUT
                                   "3D_JOINT",        # RESP. : LAVERNE J.LAVERNE
+                                  "3D_JOINT_HYME",   # RESP. : LAVERNE J.LAVERNE
                                   "3D_INTERFACE",    # RESP. : LAVERNE J.LAVERNE
                                   "AXIS",            # RESP. : LEFEBVRE J.P.LEFEBVRE
                                   "AXIS_FLUI_STRU",  # RESP. : GREFFET N.GREFFET
                                   "AXIS_FLUIDE",     # RESP. : GREFFET N.GREFFET
                                   "AXIS_FOURIER",    # RESP. : DESROCHES X.DESROCHES
                                   "AXIS_INCO",       # RESP. : MICHEL S.MICHEL
+                                  "AXIS_INCO_UP",    # RESP. : SFAYOLLE
                                   "AXIS_INCO_GD",    # RESP. : MICHEL S.MICHEL
                                   "AXIS_SI",         # RESP. : DESROCHES X.DESROCHES
                                   "AXIS_GRAD_VARI",  # RESP. : MICHEL S.MICHEL
+                                  "AXIS_GVNO",       # RESP. : BEAURAIN J.BEAURAIN
                                   "AXIS_JOINT",      # RESP. : LAVERNE J.LAVERNE
                                   "AXIS_INTERFACE",  # RESP. : LAVERNE J.LAVERNE
                                   "AXIS_ELDI",       # RESP. : LAVERNE J.LAVERNE
@@ -4152,12 +4536,15 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
                                   "D_PLAN_XFEM_CONT",# RESP. : GENIAUT S.GENIAUT
                                   "D_PLAN_GRAD_EPSI",# RESP. : MICHEL S.MICHEL
                                   "D_PLAN_GRAD_VARI",# RESP. : MICHEL S.MICHEL
+                                  "D_PLAN_GVNO",     # RESP. : BEAURAIN J.BEAURAIN
                                   "D_PLAN_GRAD_SIGM",# RESP. : GRANET S.GRANET
                                   "PLAN_JOINT",      # RESP. : LAVERNE J.LAVERNE
+                                  "PLAN_JOINT_HYME", # RESP. : LAVERNE J.LAVERNE
                                   "PLAN_INTERFACE",  # RESP. : LAVERNE J.LAVERNE
                                   "PLAN_ELDI",       # RESP. : LAVERNE J.LAVERNE
                                   "D_PLAN_ABSO",     # RESP. : DEVESA G.DEVESA
                                   "D_PLAN_INCO",     # RESP. : MICHEL S.MICHEL
+                                  "D_PLAN_INCO_UP",  # RESP. : SFAYOLLE
                                   "D_PLAN_INCO_GD",  # RESP. : MICHEL S.MICHEL
                                   "D_PLAN_SI",       # RESP. : DESROCHES X.DESROCHES
                                   "DIS_T",           # RESP. : FLEJOU J.L.FLEJOU
@@ -4178,11 +4565,9 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
                                   "Q4G",             # RESP. : DESROCHES X.DESROCHES
                                   "TUYAU_3M",        # RESP. : PROIX J.M.PROIX
                                   "TUYAU_6M",        # RESP. : PROIX J.M.PROIX
-                                  "SHB8",            # RESP. : DESROCHES X.DESROCHES
+                                  "SHB",             # RESP. : DESROCHES X.DESROCHES
                                   "D_PLAN_HHM",      # RESP. : GRANET S.GRANET
                                   "D_PLAN_HM",       # RESP. : GRANET S.GRANET
-                                  "D_PLAN_THH",      # RESP. : GRANET S.GRANET
-                                  "D_PLAN_THHM",     # RESP. : GRANET S.GRANET
                                   "D_PLAN_THM",      # RESP. : GRANET S.GRANET
                                   "D_PLAN_HHMD",     # RESP. : GRANET S.GRANET
                                   "D_PLAN_HH2MD",    # RESP. : GRANET S.GRANET
@@ -4210,8 +4595,6 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
                                   "D_PLAN_HH2S",     # RESP. : GRANET S.GRANET
                                   "D_PLAN_2DG",      # RESP. : GRANET S.GRANET
                                   "D_PLAN_DIL",      # RESP. : GRANET S.GRANET
-                                  "AXIS_THH",        # RESP. : GRANET S.GRANET
-                                  "AXIS_THHM",       # RESP. : GRANET S.GRANET
                                   "AXIS_THM",        # RESP. : GRANET S.GRANET
                                   "AXIS_HHM",        # RESP. : GRANET S.GRANET
                                   "AXIS_HM",         # RESP. : GRANET S.GRANET
@@ -4239,8 +4622,6 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
                                   "AXIS_HH2S",       # RESP. : GRANET S.GRANET
                                   "3D_HHM" ,         # RESP. : GRANET S.GRANET
                                   "3D_HM",           # RESP. : GRANET S.GRANET
-                                  "3D_THH",          # RESP. : GRANET S.GRANET
-                                  "3D_THV",          # RESP. : GRANET S.GRANET
                                   "3D_THHM",         # RESP. : GRANET S.GRANET
                                   "3D_THM",          # RESP. : GRANET S.GRANET
                                   "3D_HHMD",         # RESP. : GRANET S.GRANET
@@ -4273,8 +4654,8 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
                                   "D_PLAN_HH2SUDM",  # RESP. : GRANET S.GRANET
                                   "D_PLAN_HH2SUC",   # RESP. : GRANET S.GRANET
                                   "D_PLAN_HH2SUDA",  # RESP. : GRANET S.GRANET
-                                  "2D_JOINT_HMS",
-                                  "AXIS_JOINT_HMS",
+                                  "PLAN_JHMS",
+                                  "AXIS_JHMS",
                                                                       )  )  ),
 
                 b_thermique     =BLOC( condition = "PHENOMENE=='THERMIQUE'",
@@ -4303,11 +4684,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
 
          PARTITION         =FACT(statut='d',
              PARALLELISME    =SIMP(statut='f',typ='TXM',defaut="GROUP_ELEM",
-                                   into=("MAIL_CONTIGU","MAIL_DISPERSE","SOUS_DOMAINE","CENTRALISE","GROUP_ELEM")),
-             b_dist_sd          =BLOC(condition = "PARALLELISME == 'SOUS_DOMAINE'",
-                 PARTITION       =SIMP(statut='o',typ=sd_feti_sdaster),
-                 CHARGE_PROC0_SD =SIMP(statut='f',typ='I',defaut=0,val_min=0),
-             ),
+                                   into=("MAIL_CONTIGU","MAIL_DISPERSE","CENTRALISE","GROUP_ELEM")),
              b_dist_maille          =BLOC(condition = "PARALLELISME in ('MAIL_DISPERSE','MAIL_CONTIGU')",
                  CHARGE_PROC0_MA =SIMP(statut='f',typ='I',defaut=100,val_min=0,val_max=100),
              ),
@@ -4316,40 +4693,160 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster,
          VERI_JACOBIEN  =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI',
                               fr ="Vérification de la forme des mailles (jacobiens tous de meme signe).",),
 ) ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 25/01/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
 # ======================================================================
-# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
-AIDE=PROC(nom="AIDE",op=42,
-       UIinfo={"groupes":("Utilitaires",)},
-       fr="Interroger et imprimer une documentation partielle sur les noms des concepts déjà définis et sur les couples"
-           +" (type d'éléments, option) disponibles dans la version.",
-       regles=(AU_MOINS_UN('CONCEPT','TYPE_ELEM', ),),
-       UNITE       =SIMP(statut='f',typ='I',defaut=8),
-       TYPE_ELEM   =FACT(fr="couple type_elem option",statut='f',
-         INITEL       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
-                        ),
-       CONCEPT     =FACT(statut='f',max='**',
-         NOM          =SIMP(fr="liste des noms de concept",statut='f',typ='TXM',validators=NoRepeat(),max='**',defaut="*"),
-         OPTION       =SIMP(fr="option d'édition de concept",statut='f',typ='TXM',defaut="TOUT_TYPE",
-                                 into=("TOUT_TYPE","CREER","A_CREER",) ),
+# RESPONSABLE PELLET J.PELLET
+
+def appl_cine_matr_prod(MATR_ASSE,**args):
+  if AsType(MATR_ASSE) == matr_asse_depl_r : return matr_asse_depl_r
+  if AsType(MATR_ASSE) == matr_asse_depl_c : return matr_asse_depl_c
+  if AsType(MATR_ASSE) == matr_asse_temp_r : return matr_asse_temp_r
+  if AsType(MATR_ASSE) == matr_asse_temp_c : return matr_asse_temp_c
+  if AsType(MATR_ASSE) == matr_asse_pres_r : return matr_asse_pres_r
+  if AsType(MATR_ASSE) == matr_asse_pres_c : return matr_asse_pres_c
+  raise AsException("type de concept resultat non prevu")
+
+APPL_CINE_MATR=OPER(nom="APPL_CINE_MATR",op=158,sd_prod=appl_cine_matr_prod,
+               fr="Appliquer les C.L. cinématiques sur la matrice",
+               reentrant='f', UIinfo={"groupes":("Résolution",)},
+         MATR_ASSE       =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,
+                                               matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 25/01/2011   AUTEUR PELLET J.PELLET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+
+APPL_CINE_SCMB=OPER(nom="APPL_CINE_SCMB",op=159,sd_prod=cham_no_sdaster,reentrant='f',
+               fr="Application des C.L. cinématiques au second membre",
+               UIinfo={"groupes":("Résolution",)},
+         CHAM_NO        =SIMP(statut='o',typ=cham_no_sdaster),
+         MATR           =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,
+                                               matr_asse_temp_c,matr_asse_pres_r,matr_asse_pres_c) ),
+         CHAM_CINE       =SIMP(statut='f',typ=cham_no_sdaster),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 03/01/2011   AUTEUR ANDRIAM H.ANDRIAMBOLOLONA 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ANDRIAM H.ANDRIAMBOLOLONA
+
+from Macro.asse_elem_ssd_ops import asse_elem_ssd_ops
+
+def asse_elem_ssd_prod(self,RESU_ASSE_SSD,**args):
+    MTYPES = {
+        'MODELE' : modele_gene,
+        'NUME_DDL_GENE' : nume_ddl_gene,
+        'RIGI_GENE' : matr_asse_gene_r,
+        'MASS_GENE' : matr_asse_gene_r,
+              }
+    for res in RESU_ASSE_SSD:
+        for mc, typ in MTYPES.items():
+            if res[mc]:
+                self.type_sdprod(res[mc], typ)
+    return None
+
+ASSE_ELEM_SSD=MACRO(nom="ASSE_ELEM_SSD",
+        op=asse_elem_ssd_ops,
+        sd_prod=asse_elem_ssd_prod,
+        reentrant='n',
+        fr="Enchainer les commandes DEFI_MODELE_GENE, NUME_DDL_GENE et ASSE_MATR_GENE",
+        UIinfo={"groupes":("Matrices/vecteurs",)},
+
+# pour les concepts de sortie
+        RESU_ASSE_SSD = FACT( statut='o', max=1,
+                          regles=(PRESENT_PRESENT('RIGI_GENE','NUME_DDL_GENE'),
+                                  PRESENT_PRESENT('MASS_GENE','NUME_DDL_GENE'),),
+                              MODELE=SIMP(statut='o',typ=CO,defaut=None),
+                              NUME_DDL_GENE=SIMP(statut='f',typ=CO,defaut=None),
+                              RIGI_GENE=SIMP(statut='f',typ=CO,defaut=None),
+                              MASS_GENE=SIMP(statut='f',typ=CO,defaut=None),
+                           ),
+
+        INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+
+# pour DEFI_MODELE_GENE
+        SOUS_STRUC      =FACT(statut='o',max='**',
+           NOM             =SIMP(statut='o',typ='TXM' ),
+           MACR_ELEM_DYNA  =SIMP(statut='o',typ=macr_elem_dyna ),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+           TRANS           =SIMP(statut='f',typ='R',max=3),
          ),
-) ;
+        LIAISON         =FACT(statut='o',max='**',
+           SOUS_STRUC_1    =SIMP(statut='o',typ='TXM' ),
+           INTERFACE_1     =SIMP(statut='o',typ='TXM' ),
+           SOUS_STRUC_2    =SIMP(statut='o',typ='TXM' ),
+           INTERFACE_2     =SIMP(statut='o',typ='TXM' ),
+           regles=(EXCLUS('GROUP_MA_MAIT_1','GROUP_MA_MAIT_2','MAILLE_MAIT_2'),
+                   EXCLUS('MAILLE_MAIT_1','GROUP_MA_MAIT_2','MAILLE_MAIT_2'),),
+           GROUP_MA_MAIT_1   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_MAIT_1     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA_MAIT_2   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_MAIT_2     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           OPTION            =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("REDUIT","CLASSIQUE") ),
+         ),
+        VERIF           =FACT(statut='d',max=1,
+           STOP_ERREUR     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+         ),
+
+
+# pour NUME_DDL_GENE
+        METHODE      =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","ELIMINE") ),
+        STOCKAGE     =SIMP(statut='f',typ='TXM',defaut="LIGN_CIEL",into=("LIGN_CIEL","PLEIN") ),
+
+)  ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -4471,14 +4968,19 @@ ASSE_MATRICE=OPER(nom="ASSE_MATRICE",op=12,sd_prod=asse_matrice_prod,
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
-# RESPONSABLE PELLET J.PELLET
-
-ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster,
-                  fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n',
+# RESPONSABLE BODEL C.BODEL
+ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene,
+                    fr="Projection des chargements sur la base modale d'une sous structure",
+                    reentrant='n',
             UIinfo={"groupes":("Matrices et vecteurs",)},
-         VECT_ELEM       =SIMP(statut='o',typ=vect_elem,max='**'),
-         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster ),
-         INFO            =SIMP(statut='f',typ='I',into=(1,2,) ),
+         NUME_DDL_GENE   =SIMP(statut='o',typ=nume_ddl_gene ),
+         METHODE          =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","INITIAL") ),
+         b_nume     =BLOC(condition = "METHODE == 'CLASSIQUE'",
+             CHAR_SOUS_STRUC =FACT(statut='o',max='**',
+             SOUS_STRUC      =SIMP(statut='o',typ='TXM' ),
+             VECT_ASSE       =SIMP(statut='o',typ=cham_no_sdaster ),
+           ),
+         ),
 )  ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
@@ -4498,19 +5000,14 @@ ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster,
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
-# RESPONSABLE BODEL C.BODEL
-ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene,
-                    fr="Projection des chargements sur la base modale d'une sous structure",
-                    reentrant='n',
+# RESPONSABLE PELLET J.PELLET
+
+ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster,
+                  fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n',
             UIinfo={"groupes":("Matrices et vecteurs",)},
-         NUME_DDL_GENE   =SIMP(statut='o',typ=nume_ddl_gene ),
-         METHODE          =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","INITIAL") ),
-         b_nume     =BLOC(condition = "METHODE == 'CLASSIQUE'",
-             CHAR_SOUS_STRUC =FACT(statut='o',max='**',
-             SOUS_STRUC      =SIMP(statut='o',typ='TXM' ),
-             VECT_ASSE       =SIMP(statut='o',typ=cham_no_sdaster ),
-           ),
-         ),
+         VECT_ELEM       =SIMP(statut='o',typ=vect_elem,max='**'),
+         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster ),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2,) ),
 )  ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
@@ -4583,10 +5080,10 @@ CALC_AMOR_MODAL=OPER(nom="CALC_AMOR_MODAL",op= 172,sd_prod=listr8_sdaster,
            SEUIL           =SIMP(statut='f',typ='R',defaut= 0.3 ),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 13/01/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -4622,15 +5119,15 @@ CALC_CHAM_ELEM=OPER(nom="CALC_CHAM_ELEM",op=38,sd_prod=cham_elem,
 #
 
          OPTION          =SIMP(statut='o',typ='TXM',
-                               into=("FLUX_ELGA_TEMP","FLUX_ELNO_TEMP",
-                                     "PRES_ELNO_DBEL","PRES_ELNO_REEL","PRES_ELNO_IMAG",
+                               into=("FLUX_ELGA","FLUX_ELNO",
+                                     "PRAC_ELNO",
                                      "COOR_ELGA"), ),
 
-         b_thermique  =BLOC(condition="OPTION in ('FLUX_ELNO_TEMP','FLUX_ELGA_TEMP',)",
+         b_thermique  =BLOC(condition="OPTION in ('FLUX_ELNO','FLUX_ELGA',)",
            TEMP            =SIMP(statut='o',typ=(cham_no_sdaster,)),
          ),
 
-         b_acoustique  =BLOC(condition="OPTION in ('PRES_ELNO_DBEL','PRES_ELNO_REEL','PRES_ELNO_IMAG',)",
+         b_acoustique  =BLOC(condition="OPTION in ('PRAC_ELNO',)",
            PRES            =SIMP(statut='o',typ=(cham_no_sdaster,)),
          ),
 
@@ -4716,10 +5213,10 @@ CALC_CHAR_SEISME=OPER(nom="CALC_CHAR_SEISME",op=  92,sd_prod=calc_char_seisme_pr
          ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 28/02/2011   AUTEUR BOTTONI M.BOTTONI 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -4751,8 +5248,7 @@ def calc_ecrevisse_prod(self,CHARGE_MECA,CHARGE_THER1,CHARGE_THER2,TABLE,DEBIT,*
 
 CALC_ECREVISSE=MACRO(nom="CALC_ECREVISSE",op=calc_ecrevisse_ops,sd_prod=calc_ecrevisse_prod,reentrant='n',
                      UIinfo={"groupes":("Outils-métier",)},fr="Procedure de couplage avec Ecrevisse",
-
-        regles             = (UN_PARMI('LOGICIEL','VERSION'),),
+                      regles   = (UN_PARMI('LOGICIEL','VERSION'),),
 
 #      CONCEPTS SORTANTS : 2 CHARGEMENTS THERMIQUE + 1 MECANIQUE + 2 TABLES POUR LE POST-TRAITEMENT
 #      ********************************************
@@ -4884,16 +5380,16 @@ CALC_ECREVISSE=MACRO(nom="CALC_ECREVISSE",op=calc_ecrevisse_ops,sd_prod=calc_ecr
          COURBES            =SIMP(statut='f',typ='TXM',into=("INTERACTIF","POSTSCRIPT","AUCUNE"),defaut="AUCUNE",
                                   fr="Generation eventuelle des courbes" ),
          LOGICIEL           =SIMP(statut='f',typ='TXM',validators=LongStr(1,255),),
-         VERSION            =SIMP(statut='f',typ='TXM',defaut="3.1.2",into = ("3.1.1","3.1.2")),
+         VERSION            =SIMP(statut='f',typ='TXM',into = ("3.1.1","3.1.2","3.2")),
          ENTETE             =SIMP(statut='f',typ='TXM',max='**',defaut="Titre du calcul Ecrevisse" ),
          IMPRESSION         =SIMP(statut='f',typ='TXM',defaut='NON',into=( 'OUI','NON') ),
          INFO               =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
 
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -4925,8 +5421,7 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f',
 
      regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
                     'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'),
-             CONCEPT_SENSIBLE("SEPARE"),
-             DERIVABLE('RESULTAT'),),
+                    ),
      TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
      NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
      NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
@@ -4984,48 +5479,49 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f',
                                  "INDI_ERREUR","AUTRES","TOUTES"),
                            ),
           b_toutes=BLOC( condition = "TYPE_OPTION == 'TOUTES'",fr="toutes les options evol elas",
-               OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="SIEF_ELNO_ELGA",
+               OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="SIEF_ELNO",
                               #  contraintes
-                           into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL",
-                                  "SIPO_ELNO_DEPL","EFGE_ELNO_DEPL","EFGE_ELNO_CART","SIGM_ELNO_CART",
-                                  "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","SIGM_ELNO_TUYO","PROJ_ELEM_SIGM",
+                           into=( "SIEF_ELNO","SIGM_ELNO","SIEF_ELGA",
+                                  "SIPO_ELNO","EFGE_ELNO","EFCA_ELNO","SICA_ELNO",
+                                  "SITU_ELNO","SIRO_ELEM","SIPM_ELNO",
                               # déformations
-                                 "EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELGA_DEPL","EPSG_ELNO_DEPL",
-                                 "EPME_ELNO_DEPL","EPME_ELGA_DEPL","DEGE_ELNO_DEPL","EPSI_ELNO_TUYO",
+                                 "EPSI_ELNO","EPSI_ELGA","EPSG_ELGA","EPSG_ELNO",
+                                 "EPME_ELNO","EPME_ELGA","DEGE_ELNO","EPTU_ELNO",
                                  "EPVC_ELNO","EPVC_ELGA",
                               #  ENER
-                                 "EPOT_ELEM_DEPL","ECIN_ELEM_DEPL","ENEL_ELGA","ENEL_ELNO_ELGA",
-                                 "ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","DISS_ELGA","DISS_ELNO_ELGA",
+                                 "EPOT_ELEM","ECIN_ELEM","ENEL_ELGA","ENEL_ELNO",
+                                 "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","DISS_ELGA","DISS_ELNO",
                               #  estimateurs erreur
-                                 "SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM",
-                                 "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
-                                 "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
-                                 "SING_ELEM","SING_ELNO_ELEM",
+                                 "SIZ1_ELGA","ERZ1_ELEM","SIZ2_ELGA","ERZ2_ELEM",
+                                 "ERME_ELEM","ERME_ELNO",
+                                 "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM",
+                                 "SING_ELEM","SING_ELNO",
                               #  CRIT
-                                 "EQUI_ELNO_SIGM","EQUI_ELGA_SIGM","CRIT_ELNO_RUPT",
-                                 "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME",
-                                 "ENDO_ELGA","ENDO_ELNO_ELGA",
-                                 "ENDO_ELNO_SIGA","ENDO_ELNO_SINO","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO",
-                              #  derivees
-                                 "DEUL_ELGA_DEPL","DEDE_ELNO_DLDE","DESI_ELNO_DLSI",
+                                 "SIEQ_ELNO","SIEQ_ELGA","CRIT_ELNO",
+                                 "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA",
+                                 "ENDO_ELGA","ENDO_ELNO",
+                                 "SITQ_ELNO","EPTQ_ELNO",
                               #  autres
-                                 "VALE_NCOU_MAXI","PRES_DBEL_DEPL","VARC_ELGA"),),
-
-               NOM_CHAM  =SIMP(statut='f',typ='TXM',fr="nom du champ pour VALE_NCOU_MAXI", ),
-               NOM_CMP   =SIMP(statut='f',typ='TXM',fr="nom de la composante pour VALE_NCOU_MAXI",  ),
-
-                b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \
-                                        (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)",
+                                 "SPMX_ELGA","PRME_ELNO","VARC_ELGA"),),
+
+#              Les 2 mots cles suivants ne sont utiles qu' a l'option SPMX_ELGA
+#              mais  on est obligé de les laisser ici a cause des blocs
+               NOM_CHAM  =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"),
+                               fr="nom du champ pour SPMX_ELGA",),
+               NOM_CMP   =SIMP(statut='f',typ='TXM',fr="nom de la composante pour SPMX_ELGA",  ),
+
+                b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \
+                                        (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)",
                     RESU_DUAL=SIMP(statut='o',typ=evol_elas,fr="resultat du probleme dual"),),
 
                b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \
                                (type(OPTION)==type(()) and  'SING_ELEM' in OPTION)",
                     PREC_ERR=SIMP(statut='o',typ='R',val_min= 0.,
                                   fr="precision demandee pour calculer la carte de taille des elements"),
-                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM",
-                                                              "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",),
+                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM",
+                                                              "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",),
                                    fr="choix de l'estimateur d'erreur"),),
 
                EXCIT           =FACT(statut='f',max='**',
@@ -5046,13 +5542,13 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f',
 
           b_sigm_massif =BLOC( condition = "TYPE_OPTION == 'SIGM_MASSIF'",
                                      fr="options de contraintes elasticite 2D et 3D",
-              OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO_ELGA',
+              OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO',
                             fr="option de calcul des contraintes",
-                           into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL",),),
+                           into=( "SIEF_ELNO","SIGM_ELNO","SIEF_ELGA",),),
 
-                    b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO_DEPL','SIEF_ELGA_DEPL',) or \
-                                      (type(OPTION)==type(()) and  'SIGM_ELNO_DEPL' in OPTION ) or \
-                                      (type(OPTION)==type(()) and  'SIEF_ELGA_DEPL' in OPTION ) ",
+                    b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO','SIEF_ELGA',) or \
+                                      (type(OPTION)==type(()) and  'SIGM_ELNO' in OPTION ) or \
+                                      (type(OPTION)==type(()) and  'SIEF_ELGA' in OPTION ) ",
                                       fr="charge contenant les temperatures ou autre charge",
                          EXCIT           =FACT(statut='f',max='**',
                          CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca) ),),
@@ -5061,18 +5557,18 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f',
 
           b_sigm_struct =BLOC( condition = "TYPE_OPTION == 'SIGM_STRUCT'",
                                       fr="options de contraintes elasticite poutres, coques, tuyaux",
-               OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO_ELGA',
+               OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut='SIEF_ELNO',
                             fr="option de calcul des contraintes ou efforts generalises",
-                            into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL","SIGM_ELNO_TUYO",
-                                   "SIPO_ELNO_DEPL","EFGE_ELNO_DEPL","EFGE_ELNO_CART","SIGM_ELNO_CART",
-                                   "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF"),),
-
-               b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO_DEPL','SIEF_ELGA_DEPL',\
-                                                       'SIPO_ELNO_DEPL','EFGE_ELNO_DEPL',) or \
-                                            (type(OPTION)==type(()) and  'SIGM_ELNO_DEPL' in OPTION ) or \
-                                            (type(OPTION)==type(()) and  'SIEF_ELGA_DEPL' in OPTION ) or \
-                                            (type(OPTION)==type(()) and  'SIPO_ELNO_DEPL' in OPTION ) or \
-                                            (type(OPTION)==type(()) and  'EFGE_ELNO_DEPL' in OPTION ) ",
+                            into=( "SIEF_ELNO","SIGM_ELNO","SIEF_ELGA","SITU_ELNO",
+                                   "SIPO_ELNO","EFGE_ELNO","EFCA_ELNO","SICA_ELNO",
+                                   ),),
+
+               b_charge =BLOC( condition = "OPTION in ('SIGM_ELNO','SIEF_ELGA',\
+                                                       'SIPO_ELNO','EFGE_ELNO',) or \
+                                            (type(OPTION)==type(()) and  'SIGM_ELNO' in OPTION ) or \
+                                            (type(OPTION)==type(()) and  'SIEF_ELGA' in OPTION ) or \
+                                            (type(OPTION)==type(()) and  'SIPO_ELNO' in OPTION ) or \
+                                            (type(OPTION)==type(()) and  'EFGE_ELNO' in OPTION ) ",
                                             fr="charge contenant les temperatures ou les efforts répartis (poutres) ou autre",
                     EXCIT           =FACT(statut='f',max='**',
                                           regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),),
@@ -5092,15 +5588,15 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f',
 
           b_epsi         =BLOC( condition = "TYPE_OPTION=='EPSI'",
                OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPME_ELNO_DEPL","EPME_ELGA_DEPL",
-                                 "DEGE_ELNO_DEPL","EPSI_ELNO_TUYO","EPVC_ELNO","EPVC_ELGA",),
+                           into=("EPSI_ELNO","EPSI_ELGA","EPME_ELNO","EPME_ELGA",
+                                 "DEGE_ELNO","EPTU_ELNO","EPVC_ELNO","EPVC_ELGA",),
                                  ),
-b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ELGA_DEPL','EPSI_ELNO_DEPL','EPSI_ELNO_TUYO' ) or \
-                                      (type(OPTION)==type(()) and  'EPSI_ELNO_DEPL' in OPTION ) or \
-                                      (type(OPTION)==type(()) and  'EPSI_ELNO_TUYO' in OPTION ) or \
-                                      (type(OPTION)==type(()) and  'EPSI_ELGA_DEPL' in OPTION ) or \
-                                      (type(OPTION)==type(()) and  'EPME_ELNO_DEPL' in OPTION ) or \
-                                      (type(OPTION)==type(()) and  'EPME_ELGA_DEPL' in OPTION ) ",
+b_charge =BLOC( condition = "OPTION in ('EPME_ELNO','EPSI_ELGA','EPME_ELGA','EPSI_ELNO','EPTU_ELNO' ) or \
+                                      (type(OPTION)==type(()) and  'EPSI_ELNO' in OPTION ) or \
+                                      (type(OPTION)==type(()) and  'EPTU_ELNO' in OPTION ) or \
+                                      (type(OPTION)==type(()) and  'EPSI_ELGA' in OPTION ) or \
+                                      (type(OPTION)==type(()) and  'EPME_ELNO' in OPTION ) or \
+                                      (type(OPTION)==type(()) and  'EPME_ELGA' in OPTION ) ",
                                       fr="charge contenant les temperatures",
                     EXCIT           =FACT(statut='f',max='**',
                          CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou,char_cine_meca,) ),),
@@ -5108,14 +5604,14 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
                                        ),
           b_ener         =BLOC( condition = "TYPE_OPTION=='ENER'",
                OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("EPOT_ELEM_DEPL","ECIN_ELEM_DEPL","ENEL_ELGA","ENEL_ELNO_ELGA",
-                                 "ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","DISS_ELGA","DISS_ELNO_ELGA",),
+                           into=("EPOT_ELEM","ECIN_ELEM","ENEL_ELGA","ENEL_ELNO",
+                                 "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","DISS_ELGA","DISS_ELNO",),
                                  ),
-               b_charge =BLOC( condition = "OPTION in ('EPOT_ELEM_DEPL','ECIN_ELEM_DEPL','ENEL_ELGA','ENEL_ELNO_ELGA',) or \
-                                      (type(OPTION)==type(()) and  'EPOT_ELEM_DEPL' in OPTION ) or \
+               b_charge =BLOC( condition = "OPTION in ('EPOT_ELEM','ECIN_ELEM','ENEL_ELGA','ENEL_ELNO',) or \
+                                      (type(OPTION)==type(()) and  'EPOT_ELEM' in OPTION ) or \
                                       (type(OPTION)==type(()) and  'ENEL_ELGA' in OPTION ) or \
-                                      (type(OPTION)==type(()) and  'ENEL_ELNO_ELGA' in OPTION ) or \
-                                      (type(OPTION)==type(()) and  'ECIN_ELEM_DEPL' in OPTION ) ",
+                                      (type(OPTION)==type(()) and  'ENEL_ELNO' in OPTION ) or \
+                                      (type(OPTION)==type(()) and  'ECIN_ELEM' in OPTION ) ",
                                       fr="charge contenant les temperatures",
                     EXCIT           =FACT(statut='f',max='**',
                          CHARGE          =SIMP(statut='f',typ=(char_meca,char_ther,char_acou) ),),
@@ -5124,50 +5620,47 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
 
           b_crit         =BLOC( condition = "TYPE_OPTION=='CRIT'",
                OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("EQUI_ELNO_SIGM","EQUI_ELGA_SIGM",
-                                 "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME",
-                                 "ENDO_ELGA","ENDO_ELNO_ELGA",
-                                 "ENDO_ELNO_SIGA","ENDO_ELNO_SINO","CRIT_ELNO_RUPT","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO",
+                           into=("SIEQ_ELNO","SIEQ_ELGA",
+                                 "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA",
+                                 "ENDO_ELGA","ENDO_ELNO",
+                                 "CRIT_ELNO","SITQ_ELNO","EPTQ_ELNO",
                                  ) ),
                 EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
                      CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
                                  ),
 
-          b_derivees         =BLOC( condition = "TYPE_OPTION=='DERIVEES'",
-                  OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("DEUL_ELGA_DEPL","DEDE_ELNO_DLDE","DESI_ELNO_DLSI",
-                                 ) ),),
 
           b_autres         =BLOC( condition = "TYPE_OPTION=='AUTRES'",
                   OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("VALE_NCOU_MAXI","PRES_DBEL_DEPL",
+                           into=("SPMX_ELGA","PRME_ELNO",
                                  ) ),
-               b_maxi    =BLOC( condition = "OPTION=='VALE_NCOU_MAXI' or \
-                                (type(OPTION)==type(()) and 'VALE_NCOU_MAXI' in OPTION)",
-                    NOM_CHAM  =SIMP(statut='o',typ='TXM',fr="Nom du champ pour VALE_NCOU_MAXI" ),
-                    NOM_CMP   =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),),
+               b_maxi    =BLOC( condition = "OPTION=='SPMX_ELGA' or \
+                                (type(OPTION)==type(()) and 'SPMX_ELGA' in OPTION)",
+                    NOM_CHAM  =SIMP(statut='o',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"),
+                                    fr="Nom du champ pour SPMX_ELGA",),
+                    NOM_CMP   =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour SPMX_ELGA"),),
                                  ),
 
           b_indi_erreur        =BLOC( condition = "TYPE_OPTION=='INDI_ERREUR'",
-               OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERRE_ELEM_SIGM",
-                           into=("SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM",
-                                 "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
-                                 "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
-                                 "SING_ELEM","SING_ELNO_ELEM",
+               OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERME_ELEM",
+                           into=("SIZ1_ELGA","ERZ1_ELEM","SIZ2_ELGA","ERZ2_ELEM",
+                                 "ERME_ELEM","ERME_ELNO",
+                                 "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM",
+                                 "SING_ELEM","SING_ELNO",
                                  )),
 
-               b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \
-                                        (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)",
+               b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \
+                                        (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)",
                     RESU_DUAL=SIMP(statut='o',typ=evol_elas,fr="resultat du probleme dual"),),
 
                b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \
                                (type(OPTION)==type(()) and  'SING_ELEM' in OPTION)",
                     PREC_ERR=SIMP(statut='o',typ='R',val_min= 0.,
                                   fr="precision demandee pour calculer la carte de taille des elements" ),
-                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM",
-                                                              "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",),
+                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM",
+                                                              "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",),
                                    fr="choix de l'estimateur d'erreur"),),
 
                EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
@@ -5184,55 +5677,55 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
                           ),
           b_toutes =BLOC( condition = "TYPE_OPTION == 'TOUTES'",fr="toutes les options evol noli",
                OPTION      =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=( "SIEF_ELNO_ELGA","PROJ_ELEM_SIGM",
-                                  "SIGM_ELNO_TUYO","SIGM_ELNO_COQU","PROJ_ELNO_SIGM",
-                                  "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","EFGE_ELNO_CART",
+                           into=( "SIEF_ELNO","SIRO_ELEM",
+                                  "SITU_ELNO","SICO_ELNO",
+                                  "EFCA_ELNO","SIPO_ELNO","SIPM_ELNO",
                                   "FLHN_ELGA",
                                   # EPSI
-                                  "EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL",
-                                 "EPME_ELNO_DEPL","EPME_ELGA_DEPL","EPMG_ELNO_DEPL","EPMG_ELGA_DEPL",
-                                 "DEGE_ELNO_DEPL","EPSI_ELNO_TUYO",
+                                  "EPSI_ELNO","EPSI_ELGA","EPSG_ELNO","EPSG_ELGA",
+                                 "EPME_ELNO","EPME_ELGA","EPMG_ELNO","EPMG_ELGA",
+                                 "DEGE_ELNO","EPTU_ELNO",
                                  "EPSP_ELNO","EPSP_ELGA",
                                  "EPFD_ELNO","EPFD_ELGA","EPVC_ELNO","EPVC_ELGA",
                                  "EPFP_ELNO","EPFP_ELGA",
                                  "VARC_ELGA",
-                                 "VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU","CRIT_ELNO_RUPT",
-                                 "EXTR_ELGA_VARI","EXTR_ELNO_VARI",
+                                 "VARI_ELNO","VATU_ELNO","VACO_ELNO","CRIT_ELNO",
+                                 "VAEX_ELGA","VAEX_ELNO",
                                  # CRIT
-                                 "EQUI_ELNO_SIGM","EQUI_ELGA_SIGM","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO",
-                                 "ERRE_ELEM_SIGM","ERRE_ELNO_ELEM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM",
-                                 "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
-                                 "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME",
-                                 "DCHA_ELNO_SIGM","DCHA_ELGA_SIGM","RADI_ELNO_SIGM","RADI_ELGA_SIGM",
-                                 "ENDO_ELGA","ENDO_ELNO_ELGA","INDI_LOCA_ELGA","SING_ELEM",
-                                 "SING_ELNO_ELEM","ENDO_ELNO_SIGA","ENDO_ELNO_SINO",
-                                 "PMPB_ELNO_SIEF","PMPB_ELGA_SIEF","ENEL_ELGA","ENEL_ELNO_ELGA",
-                                 "ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","VALE_NCOU_MAXI",
-                                 "DISS_ELGA","DISS_ELNO_ELGA"),
+                                 "SIEQ_ELNO","SIEQ_ELGA","SITQ_ELNO","EPTQ_ELNO",
+                                 "ERME_ELEM","ERME_ELNO","ERZ1_ELEM","ERZ2_ELEM",
+                                 "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM",
+                                 "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA",
+                                 "DERA_ELNO","DERA_ELGA",
+                                 "ENDO_ELGA","ENDO_ELNO","INDL_ELGA","SING_ELEM",
+                                 "SING_ELNO",
+                                 "PMPB_ELNO","PMPB_ELGA","ENEL_ELGA","ENEL_ELNO",
+                                 "ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","SPMX_ELGA",
+                                 "DISS_ELGA","DISS_ELNO"),
                                ),
-               NORME =SIMP(statut='f',typ='TXM',defaut="VMIS",
-                                 into=("VMIS","TOTAL","VMIS_CINE","TOTAL_CINE"),
-                                 fr="Type de norme pour les options RADI_ et DCHA_"),
 
-               NOM_CHAM  =SIMP(statut='f',typ='TXM',fr="Nom du champ pour VALE_NCOU_MAXI"),
-               NOM_CMP   =SIMP(statut='f',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),
+#              Les 2 mots cles suivants ne sont utiles qu' a l'option SPMX_ELGA
+#              mais  on est obligé de les laisser ici a cause des blocs
+               NOM_CHAM  =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"),
+                               fr="Nom du champ pour SPMX_ELGA",),
+               NOM_CMP   =SIMP(statut='f',typ='TXM',fr="Nom de la composante pour SPMX_ELGA"),
 
-               b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \
-                                        (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)",
+               b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \
+                                        (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)",
                     RESU_DUAL=SIMP(statut='o',typ=(evol_elas,evol_noli),fr="resultat du probleme dual"),),
 
                b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \
                                (type(OPTION)==type(()) and  'SING_ELEM' in OPTION)",
                     PREC_ERR=SIMP(statut='o',typ='R',val_min= 0.,
                                   fr="precision demandee pour calculer la carte de taille des elements" ),
-                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM",
-                                                              "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",),
+                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM",
+                                                              "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",),
                                    fr="choix de l'estimateur d'erreur"),),
 
 
-               b_extr = BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')",
+               b_extr = BLOC( condition = "OPTION in ('VAEX_ELNO','VAEX_ELGA')",
                              NOM_VARI =SIMP(statut='o',typ='TXM',min= 1,max=1,fr="nom de la variable à extraire",
                          into=("DPORO","DRHOLQ","DPVP","SATLIQ","EVP","IND_ETA","D","IND_END","TEMP_MAX","GAMP","PCR",
                                "SEUIL_HYD","IND_HYD","PCOHE","COMP_ROC","SEUIL_ISO","ANG_DEV","X11","X22","X33","X12","X13","X23",
@@ -5262,29 +5755,29 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
                                       fr="options de contraintes non lin 2D et 3D",
                OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
                               #  contraintes
-                           into=( "SIEF_ELNO_ELGA",),),
+                           into=( "SIEF_ELNO",),),
                             ),
 
           b_sigm_struct =BLOC( condition = "TYPE_OPTION == 'SIGM_STRUCT'",
                                        fr="options de contraintes non lin poutres, coques",
                OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
                               #  contraintes
-                           into=( "SIEF_ELNO_ELGA","EFGE_ELNO_CART","SIGM_ELNO_TUYO","SIGM_ELNO_COQU",
-                           "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF",),),
+                           into=( "SIEF_ELNO","EFCA_ELNO","SITU_ELNO","SICO_ELNO",
+                           ),),
                              ),
 
           b_epsi         =BLOC( condition = "TYPE_OPTION=='EPSI'",
                OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=( "EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL",
-                                 "EPME_ELNO_DEPL","EPME_ELGA_DEPL","EPMG_ELNO_DEPL","EPMG_ELGA_DEPL",
-                                 "EPSP_ELNO","EPSP_ELGA","DEGE_ELNO_DEPL","EPVC_ELNO","EPVC_ELGA",
+                           into=( "EPSI_ELNO","EPSI_ELGA","EPSG_ELNO","EPSG_ELGA",
+                                 "EPME_ELNO","EPME_ELGA","EPMG_ELNO","EPMG_ELGA",
+                                 "EPSP_ELNO","EPSP_ELGA","DEGE_ELNO","EPVC_ELNO","EPVC_ELGA",
                                  "EPFD_ELNO","EPFD_ELGA","EPFP_ELNO","EPFP_ELGA"),
                                  ),
                EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
                     CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
                                  ),
-         b_epstuyo       =BLOC( condition = "OPTION == 'EPSI_ELNO_TUYO' or \
-                                  (type(OPTION)==type(()) and  'EPSI_ELNO_TUYO' in OPTION) ",
+         b_epstuyo       =BLOC( condition = "OPTION == 'EPTU_ELNO' or \
+                                  (type(OPTION)==type(()) and  'EPTU_ELNO' in OPTION) ",
               EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
                     CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
                                ),
@@ -5292,10 +5785,10 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
           b_vari         =BLOC( condition = "TYPE_OPTION=='VARI'",
                                        fr="Calcul et extraction des variables internes",
                    OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                                   into=("VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU",
-                                         "EXTR_ELGA_VARI","EXTR_ELNO_VARI"),
+                                   into=("VARI_ELNO","VATU_ELNO","VACO_ELNO",
+                                         "VAEX_ELGA","VAEX_ELNO"),
                                  ),
-          b_extr         =BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')",
+          b_extr         =BLOC( condition = "OPTION in ('VAEX_ELNO','VAEX_ELGA')",
                    NOM_VARI =SIMP(statut='o',typ='TXM',min= 1,max=1,fr="nom de la variable à extraire",
                          into=("DPORO","DRHOLQ","DPVP","SATLIQ","EVP","IND_ETA","D","IND_END","TEMP_MAX","GAMP","PCR",
                                "SEUIL_HYD","IND_HYD","PCOHE","COMP_ROC","SEUIL_ISO","ANG_DEV","X11","X22","X33","X12","X13","X23",
@@ -5306,8 +5799,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
 
           b_ener         =BLOC( condition = "TYPE_OPTION=='ENER'",
                OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM","ENEL_ELGA","ENEL_ELNO_ELGA",
-                                 "DISS_ELGA","DISS_ELNO_ELGA",),
+                           into=("ETOT_ELGA","ETOT_ELNO","ETOT_ELEM","ENEL_ELGA","ENEL_ELNO",
+                                 "DISS_ELGA","DISS_ELNO",),
                                  ),
                EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
                     CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
@@ -5315,52 +5808,44 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
 
           b_crit         =BLOC( condition = "TYPE_OPTION=='CRIT'",
                OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("EQUI_ELNO_SIGM","EQUI_ELGA_SIGM",
-                                 "EQUI_ELNO_EPSI","EQUI_ELGA_EPSI","EQUI_ELNO_EPME","EQUI_ELGA_EPME",
-                                 "ENDO_ELNO_SIGA","ENDO_ELNO_SINO","CRIT_ELNO_RUPT",
-                                 "ENDO_ELGA","ENDO_ELNO_ELGA",
-                                 "PMPB_ELNO_SIEF","PMPB_ELGA_SIEF","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO",
+                           into=("SIEQ_ELNO","SIEQ_ELGA",
+                                 "EPEQ_ELNO","EPEQ_ELGA","EPMQ_ELNO","EPMQ_ELGA",
+                                 "CRIT_ELNO",
+                                 "ENDO_ELGA","ENDO_ELNO",
+                                 "PMPB_ELNO","PMPB_ELGA","SITQ_ELNO","EPTQ_ELNO",
                                  ) ),
                                  ),
 
           b_autres         =BLOC( condition = "TYPE_OPTION=='AUTRES'",
                   OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("VALE_NCOU_MAXI",) ),
-               b_maxi    =BLOC( condition = "OPTION=='VALE_NCOU_MAXI' or \
-                                (type(OPTION)==type(()) and 'VALE_NCOU_MAXI' in OPTION)",
-                    NOM_CHAM  =SIMP(statut='o',typ='TXM',fr="Nom du champ pour VALE_NCOU_MAXI" ),
-                    NOM_CMP   =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),),
+                           into=("SPMX_ELGA",) ),
+               b_maxi    =BLOC( condition = "OPTION=='SPMX_ELGA' or \
+                                (type(OPTION)==type(()) and 'SPMX_ELGA' in OPTION)",
+                    NOM_CHAM  =SIMP(statut='o',typ='TXM',into=("SIEF_ELGA","EPSI_ELGA","SIEQ_ELGA","EPEQ_ELGA","VARI_ELGA"),
+                                    fr="Nom du champ pour SPMX_ELGA",),
+                    NOM_CMP   =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour SPMX_ELGA"),),
                                  ),
 
           b_indi_erreur         =BLOC( condition = "TYPE_OPTION=='INDI_ERREUR'",
-               OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERRE_ELEM_SIGM",
-                           into=("ERRE_ELEM_SIGM","ERRE_ELNO_ELEM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM",
-                                 "DCHA_ELNO_SIGM","DCHA_ELGA_SIGM","RADI_ELNO_SIGM","RADI_ELGA_SIGM",
-                                 "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
-                                 "SING_ELEM","SING_ELNO_ELEM",) ),
-
-               b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \
-                                        (type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ1_ELEM_SIGM' in OPTION) or \
-                                        (type(OPTION)==type(()) and 'QIZ2_ELEM_SIGM' in OPTION)",
+               OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERME_ELEM",
+                           into=("ERME_ELEM","ERME_ELNO","ERZ1_ELEM","ERZ2_ELEM",
+                                 "DERA_ELNO","DERA_ELGA",
+                                 "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM",
+                                 "SING_ELEM","SING_ELNO",) ),
+
+               b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM','QIZ1_ELEM','QIZ2_ELEM') or \
+                                        (type(OPTION)==type(()) and 'QIRE_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ1_ELEM' in OPTION) or \
+                                        (type(OPTION)==type(()) and 'QIZ2_ELEM' in OPTION)",
                 RESU_DUAL    =SIMP(statut='o',typ=(evol_elas,evol_noli),fr="resultat du probleme dual")),
 
                b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \
                                (type(OPTION)==type(()) and  'SING_ELEM' in OPTION)",
                     PREC_ERR=SIMP(statut='o',typ='R',val_min= 0.,
                                   fr="precision demandee pour calculer la carte de taille des elements" ),
-                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERRE_ELEM_SIGM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM",
-                                                              "QIRE_ELEM_SIGM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",),
+                    TYPE_ESTI=SIMP(statut='f',typ='TXM',into=("ERME_ELEM","ERZ1_ELEM","ERZ2_ELEM",
+                                                              "QIRE_ELEM","QIZ1_ELEM","QIZ2_ELEM",),
                                    fr="choix de l'estimateur d'erreur"),),
-
-               b_indic = BLOC( condition ="OPTION in ('DCHA_ELNO_SIGM','DCHA_ELGA_SIGM','RADI_ELNO_SIGM','RADI_ELGA_SIGM') or\
-                                            (type(OPTION)==type(()) and 'DCHA_ELNO_SIGM' in OPTION) or\
-                                            (type(OPTION)==type(()) and 'DCHA_ELGA_SIGM' in OPTION) or\
-                                            (type(OPTION)==type(()) and 'RADI_ELNO_SIGM' in OPTION) or\
-                                            (type(OPTION)==type(()) and 'RADI_ELGA_SIGM' in OPTION) ",
-                    NORME =SIMP(statut='f',typ='TXM',defaut="VMIS",
-                                 into=("VMIS","TOTAL","VMIS_CINE","TOTAL_CINE") ),
-                                 ),
                                  ),
                                  ),
 #          fin bloc evol_noli
@@ -5368,9 +5853,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
 #           thermique : evol_ther, fourier_ther
      b_ther          =BLOC( condition = "AsType(RESULTAT) in (evol_ther,fourier_ther,)" ,fr="options thermiques",
           OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("DEUL_ELGA_TEMP","DETE_ELNO_DLTE","FLUX_ELGA_TEMP","FLUX_ELNO_TEMP",
-                                  "HYDR_ELNO_ELGA","DURT_ELGA_META","DURT_ELNO_META",
-                                  "SOUR_ELGA_ELEC","ERRE_ELEM_TEMP","ERRE_ELNO_ELEM",),),
+                           into=("FLUX_ELGA","FLUX_ELNO",
+                                  "DURT_ELNO","SOUR_ELGA","ERTH_ELEM","ERTH_ELNO",),),
                EXCIT           =FACT(statut='f',max='**',
                     regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),),
                     CHARGE          =SIMP(statut='o',typ=char_ther ),
@@ -5387,8 +5871,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
 #    acoustique
      b_acou          =BLOC( condition = "AsType(RESULTAT) in (acou_harmo,mode_acou,)",fr="options acoustiques",
           OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                           into=("PRES_ELNO_DBEL","PRES_ELNO_REEL","PRES_ELNO_IMAG",
-                                 "INTE_ELNO_ACTI","INTE_ELNO_REAC",
+                           into=("PRAC_ELNO", "INTE_ELNO",
                                  ),),
           EXCIT           =FACT(statut='f',max='**',
                 regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),),
@@ -5425,26 +5908,24 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_
          TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
          PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
          POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-         RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+         RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
          ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
          PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
          RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
          OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+         LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
          ),
      ),
 
 
 
-     SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
-                           fr="Liste des paramètres de sensibilité.",
-                           ang="List of sensitivity parameters"),
      INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
      TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 ) ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -5558,21 +6039,21 @@ CALC_ESSAI = MACRO(nom       = 'CALC_ESSAI',
                              # Si on realise une modification structurale, on donne les DDL capteurs et interface
                              b_modif   = BLOC( condition="MODIFSTRUCT!=None",
                                    GROUP_NO_CAPTEURS  = FACT( statut='f', max='**',
-                                                              GROUP_NO = SIMP(statut='o',typ='TXM', max='**'),
+                                                              GROUP_NO = SIMP(statut='o',typ=grno, max='**'),
                                                               NOM_CMP  = SIMP(statut='o',typ='TXM', max='**'),
                                                             ),
                                    GROUP_NO_EXTERIEUR = FACT( statut='f', max='**',
-                                                              GROUP_NO = SIMP(statut='o',typ='TXM', max='**'),
+                                                              GROUP_NO = SIMP(statut='o',typ=grno, max='**'),
                                                               NOM_CMP  = SIMP(statut='o',typ='TXM', max='**'),
                                                             ),
                                                ),
                                           ),
                         );
 
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -5600,7 +6081,7 @@ CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",op=calc_europlexus_ops,sd_prod=cal
         UIinfo={"groupes":("Outils-métier","Dynamique",)},
         fr="Chainage Code_Aster-Europlexus",
 
-        LOGICIEL = SIMP(statut='f', typ='TXM', defaut='/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d'),
+        LOGICIEL = SIMP(statut='f', typ='TXM', defaut='/home/europlex/EPXD/bin/europlexus'),
 
         MODELE     = SIMP(statut='o',typ=modele_sdaster),
         CARA_ELEM  = SIMP(statut='o',typ=cara_elem),
@@ -5670,8 +6151,8 @@ CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",op=calc_europlexus_ops,sd_prod=cal
                                         EXCLUS('PAS_NBRE','PAS_INST',),
                                         EXCLUS('GROUP_NO','TOUT_GROUP_NO',),
                                         EXCLUS('GROUP_MA','TOUT_GROUP_MA',), ),
-           NOM_CHAM        = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', defaut = ('DEPL',),
-                                  into=('DEPL','VITE','ACCE','SIEF_ELGA','EPSI_ELGA','VARI_ELGA'),),
+           NOM_CHAM        = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',defaut=('DEPL',),into=('DEPL'
+                                         ,'VITE','ACCE','SIEF_ELGA','EPSI_ELGA','VARI_ELGA'),),
            PAS_INST        = SIMP(statut='f',typ='R'),
            PAS_NBRE        = SIMP(statut='f',typ='I'),
            GROUP_NO        = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
@@ -5682,7 +6163,7 @@ CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",op=calc_europlexus_ops,sd_prod=cal
         ),
 
 
-        ARCHIVAGE        =FACT(statut='f', regles=( AU_MOINS_UN('PAS_NBRE','PAS_INST',), EXCLUS('PAS_NBRE','PAS_INST',), ),
+        ARCHIVAGE        =FACT(statut='o', regles=( AU_MOINS_UN('PAS_NBRE','PAS_INST',), EXCLUS('PAS_NBRE','PAS_INST',), ),
            PAS_INST     = SIMP(statut='f',typ='R'),
            PAS_NBRE     = SIMP(statut='f',typ='I'),
            CONT_GENER   = SIMP(statut='o',typ='TXM',defaut="NON",max=1,into=("OUI","NON")),
@@ -5837,10 +6318,10 @@ CALC_FATIGUE=OPER(nom="CALC_FATIGUE",op= 151,sd_prod=calc_fatigue_prod,reentrant
 
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -5930,7 +6411,7 @@ CALC_FERRAILLAGE=OPER(nom="CALC_FERRAILLAGE",op=175,sd_prod=calc_ferrailage_prod
 #     EPSIBE deformation béton
 
 # arrêt en erreur si:
-# - EFGE_ELNO_DEPL n'a pas été précédemment calculé et n'est donc pas présent dans la structure de données RESULTAT
+# - EFGE_ELNO n'a pas été précédemment calculé et n'est donc pas présent dans la structure de données RESULTAT
 # - si aucun CARA_ELEM n'est récupérable via la structure de données RESULTAT
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
@@ -6038,10 +6519,10 @@ CALC_FONC_INTERP=OPER(nom="CALC_FONC_INTERP",op= 134,sd_prod=calc_fonc_interp_pr
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 22/03/2011   AUTEUR COURTOIS M.COURTOIS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -6194,19 +6675,22 @@ CALC_FONCTION=MACRO(nom="CALC_FONCTION",op=calc_fonction_ops,sd_prod=calc_foncti
          ),
          NOM_PARA        =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ),
          NOM_RESU        =SIMP(statut='f',typ='TXM' ),
-         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG") ),
+         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG"),
+                               fr="Type d'interpolation pour les abscisses et les ordonnées de la " \
+                                  "fonction ou bien pour le paramètre de la nappe."),
          PROL_DROITE     =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
          PROL_GAUCHE     =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
          NOM_PARA_FONC   =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ),
-         INTERPOL_FONC   =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG") ),
+         INTERPOL_FONC   =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG"),
+                                 fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction"),
          PROL_DROITE_FONC=SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
          PROL_GAUCHE_FONC=SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
 )
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -6273,7 +6757,7 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene,
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -6282,11 +6766,12 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.0E-6,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),            
            ),
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
              ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
@@ -6297,7 +6782,7 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene,
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'",
@@ -6309,7 +6794,59 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene,
            ),
         ),
      ) ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 14/12/2010   AUTEUR PELLET J.PELLET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE DEVESA
+
+CALC_FORC_NONL=OPER(nom="CALC_FORC_NONL",op= 183,sd_prod=dyna_trans,reentrant='n',
+            fr="Créer un dyna_trans contenant des champs nommés 'DEPL' correspondant à 'FONL_NOEU' ",
+            UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
+         RESULTAT        =SIMP(statut='o',typ=resultat_sdaster),
+
+         regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                        'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'),
+                 ),
+         TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+         NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+         NOEUD_CMP       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+         NOM_CAS         =SIMP(statut='f',typ='TXM' ),
+         INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+         FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+         LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+         LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster),
+         LIST_ORDRE      =SIMP(statut='f',typ=listis_sdaster),
+         CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),),
+         b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+         b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+             PRECISION       =SIMP(statut='o',typ='R',),),
+         OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1, defaut="FONL_NOEU",
+                               into=("FONL_NOEU",) ),
+
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+
+         COMP_INCR       =C_COMP_INCR(),
+)  ;
+#& MODIF COMMANDE  DATE 07/12/2010   AUTEUR GENIAUT S.GENIAUT 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
@@ -6403,19 +6940,11 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster,
          ),
          SYME_CHAR       =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","ANTI","SANS") ),
 
-         COMP_ELAS       =FACT(statut='f',
-               RELATION        =SIMP(statut='f',typ='TXM',defaut="ELAS",
-                                     into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS") ),
-               CALCUL_CONTRAINTE =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
-               DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ),
-      regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
-               TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-               GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-               MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
-         ),
+         COMP_ELAS       =C_COMP_ELAS('CALC_G'),
+
          COMP_INCR       =FACT(statut='f',
                RELATION        =SIMP(statut='f',typ='TXM',defaut="ELAS",
-                                     into=("ELAS","VMIS_ISOT_TRAC","VMIS_ISOT_LINE","VMIS_CINE_LINE","ELAS_VMIS_PUIS") ),
+                                     into=("ELAS","VMIS_ISOT_TRAC","VMIS_ISOT_LINE","VMIS_CINE_LINE","VMIS_ISOT_PUIS") ),
                DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT",into=("PETIT","PETIT_REAC") ),
       regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
                TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
@@ -6459,11 +6988,262 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster,
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
 );
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GREFFET N.GREFFET
+#
+# MACRO DE COUPLAGE IFS AVEC SATURNE VIA YACS
+#
+from Macro.calc_ifs_dnl_ops import calc_ifs_dnl_ops
+#
+CALC_IFS_DNL= MACRO(nom='CALC_IFS_DNL',op=calc_ifs_dnl_ops,sd_prod=evol_noli,reentrant='f',
+            fr="Calcul de l'évolution dynamique d'une structure couplée à un domaine fluide (résolu avec le code Saturne) via YACS",
+            UIinfo={"groupes":("Résolution","Dynamique",)},
+         regles=(AU_MOINS_UN('COMP_INCR','COMP_ELAS',),
+                 CONCEPT_SENSIBLE('ENSEMBLE'),),
+#IFS
+#=>
+         GROUP_MA_IFS     =SIMP(statut='o',typ=grma,max='**'),
+         NOM_CMP_IFS      =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+         UNITE_NOEUD      =SIMP(statut='f',typ='I',defaut= 81 ),
+         UNITE_ELEM       =SIMP(statut='f',typ='I',defaut= 82 ),
+         PAS_INIT         =SIMP(statut='o',typ='R' ),
+#<=
+#IFS
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
+         MODE_STAT       =SIMP(statut='f',typ=mode_meca),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         MASS_DIAG       =SIMP(statut='f',typ='TXM',into=("OUI","NON",) ),
+#IFS
+#=>
+#(une charge force nodale est fournie par le couplage avec code_saturne
+         EXCIT           =FACT(statut='f',max='**',
+#<=
+#IFS
+           regles=(PRESENT_ABSENT('FONC_MULT','ACCE'),
+                   PRESENT_PRESENT('ACCE','VITE','DEPL'),
+                   # PRESENT_ABSENT('MULT_APPUI','FONC_MULT'),
+                   ),
+           TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE",
+                                 into=("FIXE_CSTE","SUIV","DIDI")),
+#IFS
+#=>
+#(une charge force nodale est fournie par le couplage avec code_saturne
+#           CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca)),
+           CHARGE          =SIMP(statut='f',typ=(char_meca,char_cine_meca)),
+#<=
+#IFS
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           DEPL            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ACCE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           VITE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           MULT_APPUI      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           DIRECTION       =SIMP(statut='f',typ='R',max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+         ),
+         EXCIT_GENE      =FACT(statut='f',max='**',
+           FONC_MULT       =SIMP(statut='f',typ=fonction_sdaster,max='**' ),
+           VECT_GENE       =SIMP(statut='f',typ=vect_asse_gene,max='**' ),
+         ),
+         CONTACT         =SIMP(statut='f',typ=char_contact),
+         SOUS_STRUC      =FACT(statut='f',min=01,max='**',
+                regles=(UN_PARMI('TOUT','SUPER_MAILLE'),),
+                CAS_CHARGE  =SIMP(statut='o',typ='TXM' ),
+                TOUT        =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                SUPER_MAILLE=SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',),
+                FONC_MULT   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+              ),
+         AMOR_RAYL_RIGI = SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE"),),
+         AMOR_MODAL      =FACT(statut='f',
+           regles=(EXCLUS('AMOR_REDUIT','LIST_AMOR'),),
+           MODE_MECA       =SIMP(statut='f',typ=mode_meca),
+           AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**' ),
+           LIST_AMOR       =SIMP(statut='f',typ=listr8_sdaster ),
+           NB_MODE         =SIMP(statut='f',typ='I',defaut= 9999 ),
+           REAC_VITE       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         ),
+         PROJ_MODAL      =FACT(statut='f',max='**',
+           MODE_MECA       =SIMP(statut='o',typ=mode_meca),
+           NB_MODE         =SIMP(statut='f',typ='I',defaut= 9999 ),
+           regles=(PRESENT_PRESENT('MASS_GENE','RIGI_GENE'),),
+           MASS_GENE       =SIMP(statut='f',typ=matr_asse_gene_r),
+           RIGI_GENE       =SIMP(statut='f',typ=matr_asse_gene_r),
+           AMOR_GENE       =SIMP(statut='f',typ=matr_asse_gene_r),
+           DEPL_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene),
+           VITE_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene),
+           ACCE_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene),
+         ),
+#-------------------------------------------------------------------         
+         COMP_INCR       =C_COMP_INCR(),
+#-------------------------------------------------------------------         
+         COMP_ELAS       =C_COMP_ELAS('DYNA_NON_LINE'),
+#-------------------------------------------------------------------
+         b_reuse =BLOC(condition = "reuse",fr="en mode concept reentrant : ETAT_INIT obligatoire",
+         ETAT_INIT       =FACT(statut='o',
+           regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','VITE','ACCE','SIGM','VARI',),
+                   EXCLUS('EVOL_NOLI','DEPL',),
+                   EXCLUS('EVOL_NOLI','VITE'),
+                   EXCLUS('EVOL_NOLI','ACCE'),
+                   EXCLUS('EVOL_NOLI','SIGM',),
+                   EXCLUS('EVOL_NOLI','VARI',),
+                   EXCLUS('NUME_ORDRE','INST'), ),
+           DEPL            =SIMP(statut='f',typ=cham_no_sdaster),
+           VITE            =SIMP(statut='f',typ=cham_no_sdaster),
+           ACCE            =SIMP(statut='f',typ=cham_no_sdaster),
+           SIGM            =SIMP(statut='f',typ=(cham_elem,carte_sdaster)),
+           VARI            =SIMP(statut='f',typ=cham_elem),
+           EVOL_NOLI       =SIMP(statut='f',typ=evol_noli),
+           NUME_ORDRE      =SIMP(statut='f',typ='I'),
+           INST            =SIMP(statut='f',typ='R'),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+               PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+           b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+               PRECISION       =SIMP(statut='o',typ='R',),),
+           NUME_DIDI       =SIMP(statut='f',typ='I'),
+           INST_ETAT_INIT  =SIMP(statut='f',typ='R'),
+         ),),
+         b_not_reuse =BLOC(condition = "not reuse",fr="en mode concept non reentrant : ETAT_INIT facultatif",
+         ETAT_INIT       =FACT(statut='f',
+           regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','VITE','ACCE','SIGM','VARI',),
+                   EXCLUS('EVOL_NOLI','DEPL',),
+                   EXCLUS('EVOL_NOLI','VITE'),
+                   EXCLUS('EVOL_NOLI','ACCE'),
+                   EXCLUS('EVOL_NOLI','SIGM',),
+                   EXCLUS('EVOL_NOLI','VARI',),
+                   EXCLUS('NUME_ORDRE','INST'), ),
+           DEPL            =SIMP(statut='f',typ=cham_no_sdaster),
+           VITE            =SIMP(statut='f',typ=cham_no_sdaster),
+           ACCE            =SIMP(statut='f',typ=cham_no_sdaster),
+           SIGM            =SIMP(statut='f',typ=(cham_elem,carte_sdaster)),
+           VARI            =SIMP(statut='f',typ=cham_elem),
+           EVOL_NOLI       =SIMP(statut='f',typ=evol_noli),
+           NUME_ORDRE      =SIMP(statut='f',typ='I'),
+           INST            =SIMP(statut='f',typ='R'),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+               PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+           b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+               PRECISION       =SIMP(statut='o',typ='R',),),
+           NUME_DIDI       =SIMP(statut='f',typ='I'),
+           INST_ETAT_INIT  =SIMP(statut='f',typ='R'),
+         ),),
+#-------------------------------------------------------------------
+#IFS : pas besoin d'INCREMENT
+#         INCREMENT       =C_INCREMENT(),
+#-------------------------------------------------------------------
+         SCHEMA_TEMPS     =FACT(statut='o',
+            SCHEMA          =SIMP(statut='o',min=1,max=1,typ='TXM',
+            into=("DIFF_CENT","TCHAMWA","NEWMARK","HHT","THETA_METHODE","KRENK"),),
+            COEF_MASS_SHIFT =SIMP(statut='f',typ='R',defaut= 0.0E+0 ),
+            b_tchamwa = BLOC(condition="SCHEMA=='TCHAMWA'",
+               PHI          =SIMP(statut='f',typ='R',defaut= 1.05),),
+               
+            b_newmark = BLOC(condition="SCHEMA=='NEWMARK'",
+               BETA         =SIMP(statut='f',typ='R',defaut= 0.25),
+               GAMMA        =SIMP(statut='f',typ='R',defaut= 0.5),),
+               
+            b_hht     = BLOC(condition="SCHEMA=='HHT'",
+               ALPHA        =SIMP(statut='f',typ='R',defaut= -0.3 ),
+               MODI_EQUI    =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),),
+               
+            b_theta   = BLOC(condition="SCHEMA=='THETA_METHODE'",
+               THETA         =SIMP(statut='f',typ='R',defaut= 1.,val_min=0.5,val_max=100. ),),
+
+            b_krenk   = BLOC(condition="SCHEMA=='KRENK'",
+               KAPPA         =SIMP(statut='f',typ='R',defaut= 1.0,val_min=1.0,val_max=100. ),), 
+               
+            b_explicit= BLOC(condition="SCHEMA=='TCHAMWA'or SCHEMA=='DIFF_CENT'",
+               STOP_CFL     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),),
+               FORMULATION  =SIMP(statut='o',typ='TXM',into=("ACCELERATION",),),),
+               
+            b_implicit= BLOC(condition="SCHEMA!='TCHAMWA'and SCHEMA!='DIFF_CENT'",
+               FORMULATION  =SIMP(statut='o',max=1,typ='TXM',into=("DEPLACEMENT","VITESSE","ACCELERATION"),),),
+         ),
+#-------------------------------------------------------------------         
+         NEWTON          =C_NEWTON(),
+#-------------------------------------------------------------------
+         RECH_LINEAIRE   =C_RECH_LINEAIRE(),
+#-------------------------------------------------------------------
+         CONVERGENCE     =C_CONVERGENCE(),
+#-------------------------------------------------------------------
+         SOLVEUR         =C_SOLVEUR(),
+#-------------------------------------------------------------------
+         OBSERVATION     =C_OBSERVATION(),
+#-------------------------------------------------------------------
+         SUIVI_DDL       =C_SUIVI_DDL(),
+#------------------------------------------------------------------- 
+         AFFICHAGE       =C_AFFICHAGE(),
+#-------------------------------------------------------------------
+         ARCHIVAGE       =C_ARCHIVAGE(),
+#-------------------------------------------------------------------
+         CRIT_FLAMB     =FACT(statut='f',min=1,max=1,
+           NB_FREQ         =SIMP(statut='f',typ='I',max=1,defaut=3),
+           CHAR_CRIT       =SIMP(statut='f',typ='R',min=2,max=2,defaut=(-10.0,10.),
+                            fr="Valeur des deux charges critiques délimitant la bande de recherche en HPP"),
+           RIGI_GEOM     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+           bloc_ddl_exclus=BLOC(condition="(RIGI_GEOM=='NON')",
+              DDL_EXCLUS      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=40,
+                                    into=('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
+                                          'TEMP','PRE1','PRE2','UI2','UI3','VI2','VI3','WI2','WI3','UO2',
+                                          'UO3','VO2','VO3','WO2','WO3','UI4','UI5','VI4','VI5','WI4',
+                                          'WI5','UO4','UO5','VO4','VO5','WO4','WO5','UI6','UO6','VI6',
+                                          'VO6','WI6','WO6','WO','WI1','WO1','GONF','LIAISON','DCX',
+                                          'DCY','DCZ','H1X','H1Y','H1Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
+                                          'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22',
+                                          'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23',
+                                          'PRES31','PRES32','PRES33','VARI','LAG_GV')),),
+           INST_CALCUL       =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ),
+         ),
+         MODE_VIBR     =FACT(statut='f',min=1,max=1,
+           MATR_RIGI        =SIMP(statut='f',typ='TXM',defaut="ELASTIQUE",into=("ELASTIQUE","TANGENTE","SECANTE",) ),
+           NB_FREQ          =SIMP(statut='f',typ='I',max=1,defaut=3,
+                            fr="Nombre de fréquences propres à calculer"),
+           BANDE            =SIMP(statut='f',typ='R',min=2,max=2,
+                            fr="Valeur des deux fréquences délimitant la bande de recherche",),
+           INST_CALCUL       =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ),
+         ),
+#-------------------------------------------------------------------
+           SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des paramètres de sensibilité",
+                               ang="List of sensitivity parameters"),
+#-------------------------------------------------------------------
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+         b_info=BLOC(condition="(INFO==2)",
+               fr="filtre les messages émis dans le .mess selon le type de message demandé",
+               INFO_DBG = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(),
+                               into=("CONTACT",
+                                     "MECA_NON_LINE",
+                                     "PILOTAGE",
+                                     "FACTORISATION",
+                                     "APPARIEMENT"),
+                             ),
+                    ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
 # (AT YOUR OPTION) ANY LATER VERSION.
@@ -6491,10 +7271,10 @@ CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_fonction,
          TITRE           =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1 , 2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -6553,7 +7333,7 @@ CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r,
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -6561,12 +7341,13 @@ CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r,
            b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
-             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.0E-6,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),             
              ),
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
              ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
@@ -6577,10 +7358,10 @@ CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r,
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
-             b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'",
+             b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
                                                                          fr="Paramètres des préconditionneurs JACOBI et SOR",
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
@@ -6744,10 +7525,10 @@ CALC_MATR_ELEM=OPER(nom="CALC_MATR_ELEM",op=   9,sd_prod=calc_matr_elem_prod
            CHARGE            =SIMP(statut='o',typ=char_meca,validators=NoRepeat(),max='**' ),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 13/01/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -6796,12 +7577,12 @@ CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o',
            MAILLE          =SIMP(statut='f',typ=ma, validators=NoRepeat(), max='**'),
          ),
          OPTION          =SIMP(statut='f',typ='TXM'
-                             ,into=("META_ELNO_TEMP",) ),
+                             ,into=("META_ELNO",) ),
 )  ;
-#& MODIF COMMANDE  DATE 23/11/2010   AUTEUR COURTOIS M.COURTOIS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR COURTOIS M.COURTOIS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -6818,51 +7599,155 @@ CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o',
 # ======================================================================
 # RESPONSABLE COURTOIS M.COURTOIS
 
+def calc_miss_sdprod(self, TYPE_RESU, **kwargs):
+    if TYPE_RESU == 'TABLE':
+        return table_sdaster
+    elif TYPE_RESU == 'HARM_GENE':
+        return harm_gene
+    elif TYPE_RESU == 'TRAN_GENE':
+        return tran_gene
+    else:
+        return None
+
 from Macro.calc_miss_ops import calc_miss_ops
 
-CALC_MISS = MACRO(nom="CALC_MISS",op=calc_miss_ops,
-                  fr="Préparation des données puis exécution du logiciel MISS3D",
+CALC_MISS = MACRO(nom="CALC_MISS",
+                  op=calc_miss_ops,
+                  sd_prod=calc_miss_sdprod,
+                  fr="Préparation des données, exécution du logiciel Miss3D, et post-traitement",
                   UIinfo={"groupes":("Résolution","Outils-métier",)},
 
-   OPTION      = FACT(statut='o',
-      MODULE      = SIMP(statut='f',typ='TXM',defaut="MISS_IMPE", into=("MISS_IMPE",)),
-   ),
-   TABLE_SOL   = SIMP(statut='o', typ=table_sdaster),
-
-   PROJET      = SIMP(statut='f', typ='TXM'),
-   REPERTOIRE  = SIMP(statut='f', typ='TXM'),
-   VERSION     = SIMP(statut='f', typ='TXM', into=("V1_4",), defaut="V1_4"),
-
-   UNITE_IMPR_ASTER = SIMP(statut='f',typ='I',defaut=25),
-   UNITE_RESU_IMPE  = SIMP(statut='f',typ='I',defaut=30),
-   UNITE_RESU_FORC  = SIMP(statut='f',typ='I',defaut=0),
-   PARAMETRE   = FACT(statut='o',
-                      regles=(PRESENT_PRESENT('OFFSET_MAX','OFFSET_NB'),
-                              PRESENT_PRESENT('FREQ_MIN','FREQ_MAX','FREQ_PAS'),
-                              PRESENT_PRESENT('LFREQ_NB','LFREQ_LISTE'),
-                              UN_PARMI('FREQ_MIN', 'LFREQ_NB'),
-                              PRESENT_PRESENT('SPEC_MAX','SPEC_NB'),),
-      FREQ_MIN       = SIMP(statut='f',typ='R'),
-      FREQ_MAX       = SIMP(statut='f',typ='R'),
-      FREQ_PAS       = SIMP(statut='f',typ='R'),
-      LFREQ_NB       = SIMP(statut='f',typ='I'),
-      LFREQ_LISTE    = SIMP(statut='f',typ='R',max='**'),
-      Z0             = SIMP(statut='f',typ='R',defaut=0.),
-      SURF           = SIMP(statut='f',typ='TXM',into=("OUI","NON",),defaut="NON"),
-      ISSF           = SIMP(statut='f',typ='TXM',into=("OUI","NON",),defaut="NON"),
-      TYPE           = SIMP(statut='f',typ='TXM',into=("BINAIRE","ASCII",),defaut="ASCII"),
-      RFIC           = SIMP(statut='f',typ='R',defaut=0.),
-
-      ALGO           = SIMP(statut='f',typ='TXM',into=("DEPL","REGU")),
-      DREF           = SIMP(statut='f',typ='R'),
-      SPEC_MAX       = SIMP(statut='f',typ='R'),
-      SPEC_NB        = SIMP(statut='f',typ='I'),
-      OFFSET_MAX     = SIMP(statut='f',typ='R'),
-      OFFSET_NB      = SIMP(statut='f',typ='I'),
-
-      FICH_POST_TRAI = SIMP(statut='f',typ='TXM'),
-   ),
-   INFO        = SIMP(statut='f', typ='I', defaut=1, into=(1,2)),
+    TYPE_RESU   = SIMP(statut='o', typ='TXM', into=('HARM_GENE', 'TRAN_GENE', 'TABLE', 'FICHIER'),
+                       fr="Type de résultat produit en post-traitement. FICHIER : pas de post-traitement"),
+    PROJET      = SIMP(statut='f', typ='TXM', defaut='MODELE',
+                       fr="Nom de l'étude Miss"),
+    REPERTOIRE  = SIMP(statut='f', typ='TXM',
+                       fr="Répertoire de travail de Miss"),
+    VERSION     = SIMP(statut='f', typ='TXM', into=("V6.6","V6.5"), defaut="V6.6",
+                       fr="Version de Miss utilisée"),
+
+    TABLE_SOL   = SIMP(statut='o', typ=table_sdaster,
+                       fr="Table des propriétés du sol"),
+
+    # pas de post-traitement
+    b_fichier   = BLOC(condition="TYPE_RESU == 'FICHIER'",
+                       regles=(UN_PARMI('MACR_ELEM_DYNA', 'BASE_MODALE'),),
+        MACR_ELEM_DYNA  = SIMP(statut='f', typ=macr_elem_dyna,
+                               fr="Macro élément produit en amont"),
+        BASE_MODALE     = SIMP(statut='f', typ=mode_meca,
+                               fr="Base de modes"),
+        b_base_modale = BLOC(condition="BASE_MODALE is not None",
+            MATR_RIGI       = SIMP(statut='f', typ=(matr_asse_depl_r, matr_asse_depl_c),),
+            MATR_MASS       = SIMP(statut='f', typ=matr_asse_depl_r ),
+        ),
+        AMOR_REDUIT     = SIMP(statut='f', typ='R', max='**'),
+        GROUP_MA_INTERF = SIMP(statut='o', typ=grma, max='**',
+                               fr="Groupe de mailles de l'interface"),
+
+        UNITE_IMPR_ASTER = SIMP(statut='f', typ='I', defaut=25,
+                                fr="Unité des résultats transmis par Code_Aster à Miss"),
+        UNITE_RESU_IMPE  = SIMP(statut='f', typ='I', defaut=38,
+                                fr="Unité logique des impédances écrites par Miss"),
+        UNITE_RESU_FORC  = SIMP(statut='f', typ='I', defaut=28,
+                                fr="Unité logique des forces sismiques écrites par Miss"),
+    ),
+    # si post-traitement
+    b_donnees   = BLOC(condition="TYPE_RESU != 'FICHIER'",
+        MACR_ELEM_DYNA  = SIMP(statut='f', typ=macr_elem_dyna,
+                               fr="Macro élément produit en amont"),
+        BASE_MODALE     = SIMP(statut='o', typ=mode_meca,
+                               fr="Base de modes"),
+        MATR_RIGI       = SIMP(statut='o', typ=(matr_asse_depl_r, matr_asse_depl_c),),
+        MATR_MASS       = SIMP(statut='o', typ=matr_asse_depl_r ),
+        AMOR_REDUIT     = SIMP(statut='o', typ='R', max='**'),
+        GROUP_MA_INTERF = SIMP(statut='o', typ=grma, max='**',
+                               fr="Groupe de mailles de l'interface"),
+
+        UNITE_IMPR_ASTER = SIMP(statut='f', typ='I',
+                                fr="Unité des résultats transmis par Code_Aster à Miss"),
+        UNITE_RESU_IMPE  = SIMP(statut='f', typ='I',
+                                fr="Unité logique des impédances à relire."),
+        UNITE_RESU_FORC  = SIMP(statut='f', typ='I',
+                                fr="Unité logique des forces sismiques à relire"),
+    ),
+    # Paramètres du calcul Miss
+    PARAMETRE   = FACT(statut='o',
+                       regles=(PRESENT_PRESENT('OFFSET_MAX', 'OFFSET_NB'),
+                               PRESENT_PRESENT('FREQ_MIN', 'FREQ_MAX','FREQ_PAS'),
+                               UN_PARMI('FREQ_MIN', 'LIST_FREQ'),
+                               PRESENT_PRESENT('SPEC_MAX', 'SPEC_NB'),),
+        FREQ_MIN       = SIMP(statut='f', typ='R'),
+        FREQ_MAX       = SIMP(statut='f', typ='R'),
+        FREQ_PAS       = SIMP(statut='f', typ='R'),
+        LIST_FREQ      = SIMP(statut='f', typ='R', max='**'),
+        Z0             = SIMP(statut='f', typ='R', defaut=0.),
+        SURF           = SIMP(statut='f', typ='TXM', into=("OUI","NON",), defaut="NON"),
+        RFIC           = SIMP(statut='f', typ='R', defaut=0.),
+
+        ALGO           = SIMP(statut='f', typ='TXM', into=("DEPL","REGU")),
+        DREF           = SIMP(statut='f', typ='R'),
+        SPEC_MAX       = SIMP(statut='f', typ='R'),
+        SPEC_NB        = SIMP(statut='f', typ='I'),
+        OFFSET_MAX     = SIMP(statut='f', typ='R'),
+        OFFSET_NB      = SIMP(statut='f', typ='I'),
+        TYPE           = SIMP(statut='f', typ='TXM', into=("BINAIRE","ASCII",), defaut="ASCII"),
+    ),
+    # Post-traitement type 1 - tran_gene
+    b_post_tran_gene = BLOC(condition="TYPE_RESU == 'TRAN_GENE'",
+                       regles=(AU_MOINS_UN('ACCE_X', 'ACCE_Y', 'ACCE_Z'),),
+        MODELE         = SIMP(statut='o', typ=(modele_sdaster),),
+        ACCE_X         = SIMP(statut='f', typ=fonction_sdaster,),
+        ACCE_Y         = SIMP(statut='f', typ=fonction_sdaster,),
+        ACCE_Z         = SIMP(statut='f', typ=fonction_sdaster,),
+        INST_FIN       = SIMP(statut='o', typ='R', fr="Instant final du calcul"),
+        PAS_INST       = SIMP(statut='o', typ='R', fr="Pas de temps du calcul"),
+    ),
+    # Post-traitement type 1 - harm_gene
+    b_post_harm_gene  = BLOC(condition="TYPE_RESU == 'HARM_GENE'",
+                       regles=(AU_MOINS_UN('EXCIT_HARMO', 'ACCE_X', 'ACCE_Y', 'ACCE_Z'),
+                               PRESENT_ABSENT('EXCIT_HARMO', 'ACCE_X', 'ACCE_Y', 'ACCE_Z', 'INST_FIN'),
+                               ENSEMBLE('INST_FIN', 'PAS_INST'),),
+        MODELE         = SIMP(statut='o', typ=(modele_sdaster),),
+        ACCE_X         = SIMP(statut='f', typ=fonction_sdaster,),
+        ACCE_Y         = SIMP(statut='f', typ=fonction_sdaster,),
+        ACCE_Z         = SIMP(statut='f', typ=fonction_sdaster,),
+        INST_FIN       = SIMP(statut='f', typ='R', fr="Instant final du calcul"),
+        PAS_INST       = SIMP(statut='f', typ='R', fr="Pas de temps du calcul"),
+        # identique à EXCIT de DYNA_LINE_HARM au type attendu pour VECT_ASSE près
+        EXCIT_HARMO    = FACT(statut='f', max='**',
+                              regles=(UN_PARMI('VECT_ASSE', 'CHARGE'),
+                                      UN_PARMI('FONC_MULT', 'FONC_MULT_C', 'COEF_MULT', 'COEF_MULT_C'),),
+            VECT_ASSE     = SIMP(statut='f', typ=cham_no_sdaster,),
+            CHARGE        = SIMP(statut='f', typ=char_meca),
+            TYPE_CHARGE   = SIMP(statut='f', typ='TXM', defaut="FIXE", into=("FIXE",),),
+            FONC_MULT_C   = SIMP(statut='f', typ=(fonction_c, formule_c),),
+            COEF_MULT_C   = SIMP(statut='f', typ='C'),
+            FONC_MULT     = SIMP(statut='f', typ=(fonction_sdaster, nappe_sdaster, formule) ),
+            COEF_MULT     = SIMP(statut='f', typ='R'),
+            PHAS_DEG      = SIMP(statut='f', typ='R', defaut=0.),
+            PUIS_PULS     = SIMP(statut='f', typ='I', defaut=0),
+        ),
+    ),
+    # Post-traitement type 2
+    b_post_table = BLOC(condition="TYPE_RESU == 'TABLE'",
+                        regles=(AU_MOINS_UN('ACCE_X', 'ACCE_Y', 'ACCE_Z'),),
+        MODELE         = SIMP(statut='o', typ=(modele_sdaster),),
+        GROUP_NO       = SIMP(statut='o', typ=grno, max='**',
+                              fr="Liste des groupes de noeud de post-traitement"),
+        ACCE_X         = SIMP(statut='f', typ=fonction_sdaster,),
+        ACCE_Y         = SIMP(statut='f', typ=fonction_sdaster,),
+        ACCE_Z         = SIMP(statut='f', typ=fonction_sdaster,),
+        INST_FIN       = SIMP(statut='o', typ='R', fr="Instant final du calcul"),
+        PAS_INST       = SIMP(statut='o', typ='R', fr="Pas de temps du calcul"),
+        NORME          = SIMP(statut='o', typ='R',
+                              fr="Valeur de la norme du spectre d'oscillateur" ),
+        AMOR_SPEC_OSCI = SIMP(statut='o', typ='R', max='**',
+                              fr="Amortissement du spectre d'oscillateur"),
+        LIST_FREQ      = SIMP(statut='f', typ=listr8_sdaster,
+                              fr="Fréquences utilisées pour le calcul du spectre d'oscillateur"),
+    ),
+
+    INFO        = SIMP(statut='f', typ='I', defaut=1, into=(1,2)),
 )
 
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
@@ -7023,10 +7908,10 @@ CALC_MODE_ROTATION=MACRO(nom="CALC_MODE_ROTATION",op=calc_mode_rotation_ops,sd_p
                   PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-3 ),
                   STURM           =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),),
 );
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -7050,14 +7935,10 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='f',
             fr="Enrichir une SD Résultat par des champs aux noeuds calculés à partir de champs aux éléments évalués aux noeuds",
             UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
          RESULTAT        =SIMP(statut='o',typ=resultat_sdaster),
-         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
-                               fr="Liste des paramètres de sensibilité.",
-                               ang="List of sensitivity parameters"),
 
          regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
                         'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'),
-                 CONCEPT_SENSIBLE("SEPARE"),
-                 DERIVABLE('RESULTAT'),),
+                 ),
          TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
          NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
          NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
@@ -7075,46 +7956,31 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='f',
              PRECISION       =SIMP(statut='o',typ='R',),),
          OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
                                into=("FORC_NODA","REAC_NODA",
-                                     "FORC_NODA_NONL",
-                                     "DCHA_NOEU_SIGM",
-                                     "DEGE_NOEU_DEPL",
-                                     "DETE_NOEU_DLTE",
-                                     "DEDE_NOEU_DLDE",
-                                     "DESI_NOEU_DLSI",
-                                     "DURT_NOEU_META",
-                                     "EFGE_NOEU_CART","EFGE_NOEU_DEPL",
-                                     "ENDO_NOEU_SINO",
-                                     "ENEL_NOEU_ELGA",
-                                     "EPMG_NOEU_DEPL",
-                                     "EPSA_NOEU",
-                                     "EPSG_NOEU_DEPL",
-                                     "EPSI_NOEU_DEPL",
+                                     "DERA_NOEU",
+                                     "DURT_NOEU",
+                                     "EFCA_NOEU","EFGE_NOEU",
+                                     "ENDO_NOEU",
+                                     "ENEL_NOEU",
+                                     "EPMG_NOEU",
+                                     "EPSG_NOEU",
+                                     "EPSI_NOEU",
                                      "EPSP_NOEU"     ,
                                      "EPVC_NOEU","EPFD_NOEU","EPFP_NOEU","EPFP_NOEU",
-                                     "EQUI_NOEU_EPME","EQUI_NOEU_EPSI","EQUI_NOEU_SIGM",
-                                     "ERRE_NOEU_ELEM","QIRE_NOEU_ELEM",
-                                     "FLUX_NOEU_TEMP",
-                                     "HYDR_NOEU_ELGA",
-                                     "INTE_NOEU_ACTI","INTE_NOEU_REAC",
-                                     "META_NOEU_TEMP",
-                                     "PMPB_NOEU_SIEF",
-                                     "PRES_NOEU_DBEL","PRES_NOEU_IMAG","PRES_NOEU_REEL",
-                                     "RADI_NOEU_SIGM",
-                                     "SIEF_NOEU_ELGA",
-                                     "SIGM_NOEU_CART","SIGM_NOEU_COQU","SIGM_NOEU_DEPL",
-                                     "SIGM_NOEU_SIEF",
-                                     "SIPO_NOEU_DEPL","SIPO_NOEU_SIEF",
-                                     "VARI_NOEU","EXTR_NOEU_VARI","VARI_NOEU_ELGA",) ),
-
-         b_forc_reac     =BLOC(condition = """(OPTION == 'FORC_NODA') or (type(OPTION) == type(()) and 'FORC_NODA' in OPTION) or\
- (OPTION == 'REAC_NODA') or (type(OPTION) == type(()) and 'REAC_NODA' in OPTION)""",
-             MODELE          =SIMP(statut='f',typ=modele_sdaster),
-         ),
-         b_forc_nonl     =BLOC(condition = """(OPTION == 'FORC_NODA_NONL')""",
-             MODELE          =SIMP(statut='f',typ=modele_sdaster),
-             COMP_INCR       =C_COMP_INCR(),
-         ),
+                                     "EPMQ_NOEU","EPEQ_NOEU","SIEQ_NOEU",
+                                     "ERME_NOEU","ERTH_NOEU","QIRE_NOEU",
+                                     "FLUX_NOEU",
+                                     "HYDR_NOEU",
+                                     "INTE_NOEU",
+                                     "META_NOEU",
+                                     "PMPB_NOEU",
+                                     "PRAC_NOEU",
+                                     "SIEF_NOEU",
+                                     "SICA_NOEU","SICO_NOEU","SIGM_NOEU",
+                                     "SIPO_NOEU",
+                                     "VAEX_NOEU","VARI_NOEU","DISS_NOEU",) ),
+
 
+         MODELE          =SIMP(statut='f',typ=modele_sdaster),
          CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
          CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
          EXCIT           =FACT(statut='f',max='**',
@@ -7123,15 +7989,13 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='f',
            TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE",
                                  into=("FIXE_CSTE","FIXE_PILO","SUIV") ),
          ),
+
          TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
          GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
          MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
-         GROUP_MA_RESU   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-         MAILLE_RESU     =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
-         GROUP_NO_RESU   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-         NOEUD_RESU      =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 07/12/2010   AUTEUR GENIAUT S.GENIAUT 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
@@ -7155,13 +8019,7 @@ CALC_POINT_MAT=OPER(nom="CALC_POINT_MAT",op=33,sd_prod=table_sdaster,reentrant='
             fr="Intégrer une loi de comportement",
      MATER           =SIMP(statut='o',typ=mater_sdaster,max=1),
      COMP_INCR       =C_COMP_INCR(),
-     COMP_ELAS       =FACT(statut='f',max='**',
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-           RELATION        =SIMP(statut='o',typ='TXM',defaut="ELAS",
-                                 into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS","ELAS_HYPER")),
-           DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT",) ),
-         ),
+     COMP_ELAS       =C_COMP_ELAS('CALC_POINT_MAT'),
      INCREMENT       =C_INCREMENT(),
      NEWTON          =C_NEWTON(),
      CONVERGENCE     =C_CONVERGENCE(),
@@ -7234,10 +8092,10 @@ CALC_POINT_MAT=OPER(nom="CALC_POINT_MAT",op=33,sd_prod=table_sdaster,reentrant='
                            ),
      );
 
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 28/02/2011   AUTEUR BARGELLI R.BARGELLINI 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -7275,7 +8133,6 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli,
          CABLE_BP         =SIMP(statut='o',typ=cabl_precont,validators=NoRepeat(),max='**'),
          CABLE_BP_INACTIF =SIMP(statut='f',typ=cabl_precont,validators=NoRepeat(),max='**'),
          INCREMENT        =C_INCREMENT(),
-         NEWTON           =C_NEWTON(),
          RECH_LINEAIRE    =C_RECH_LINEAIRE(),
          CONVERGENCE      =C_CONVERGENCE(),
           ETAT_INIT       =FACT(statut='f',
@@ -7298,9 +8155,16 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli,
             NUME_DIDI       =SIMP(statut='f',typ='I'),
             INST_ETAT_INIT  =SIMP(statut='f',typ='R'),
           ),
-          SOLVEUR         =C_SOLVEUR(),
-          INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
-          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+         METHODE = SIMP(statut='d',typ='TXM',defaut="NEWTON",into=("NEWTON","IMPL_EX")),
+         b_meth_newton = BLOC(condition = "METHODE == 'NEWTON'",
+                           NEWTON = C_NEWTON(),
+                        ),
+         b_meth_impl_ex = BLOC(condition = "METHODE == 'IMPL_EX'",
+                           IMPL_EX = C_IMPL_EX(),
+                        ),
+          SOLVEUR         =C_SOLVEUR(),
+          INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
 
           EXCIT           =FACT(statut='o',max='**',
             CHARGE          =SIMP(statut='o',typ=char_meca),
@@ -7308,6 +8172,88 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli,
 
          COMP_INCR       =C_COMP_INCR(),
   )  ;
+#& MODIF COMMANDE  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# ======================================================================
+# RESPONSABLE GNICOLAS
+def calc_sensi_prod(RESULTAT,**args):
+   if AsType(RESULTAT) != None : return AsType(RESULTAT)
+   raise AsException("type de concept resultat non prevu")
+
+CALC_SENSI=OPER(nom="CALC_SENSI",op=132,sd_prod=calc_sensi_prod,reentrant='f',
+            UIinfo={"groupes":("Post-traitements","Résultats et champs",)},
+            fr="Compléter ou créer un résultat en calculant des champs dérivés )",
+     MODELE          =SIMP(statut='f',typ=modele_sdaster),
+     CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+     CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+
+     RESULTAT        =SIMP(statut='o',typ=resultat_sdaster,
+                                      fr="Résultat d'une commande globale"),
+
+     regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                    'NOEUD_CMP','LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS'),
+             CONCEPT_SENSIBLE("SEPARE"),
+             DERIVABLE('RESULTAT'),),
+     TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+     NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+     NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+     NOEUD_CMP       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+     NOM_CAS         =SIMP(statut='f',typ='TXM' ),
+     INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+     FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+     LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+     LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster),
+     CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ),
+     b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+         PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6),),
+     b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+         PRECISION       =SIMP(statut='o',typ='R'),),
+     LIST_ORDRE      =SIMP(statut='f',typ=listis_sdaster),
+     TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+     GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                           fr="le calcul ne sera effectué que sur ces mailles là"),
+     MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**',
+                           fr="le calcul ne sera effectué que sur ces mailles là"),
+
+     OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
+
+                  into=('DEDE_ELNO','DEDE_NOEU','DESI_ELNO',
+                  'DESI_NOEU','DETE_ELNO','DETE_NOEU',
+                  'EFGE_ELNO','EPSI_ELGA','EPSI_ELNO',
+                  'EPSP_ELNO','FLUX_ELNO','FLUX_NOEU','REAC_NODA','SIEF_ELGA',
+                  'SIEF_ELNO','SIEF_NOEU',
+                  'SIGM_ELNO','SIGM_NOEU',
+                  'SIPO_ELNO','VARI_ELNO'),
+            ),
+
+
+   # -- mots cles inutiles mais qui permettent de reutiliser certaines routines :
+     EXCIT =FACT(statut='f',max='**', CHARGE=SIMP(statut='o',typ=(char_meca,) ),),
+     NORME =SIMP(statut='f',typ='TXM',defaut="XXXX", into=("XXXX",),),
+
+
+     SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                           fr="Liste des paramètres de sensibilité.",
+                           ang="List of sensitivity parameters"),
+     INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+     TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+) ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -7569,63 +8515,6 @@ CALC_THETA=OPER(nom="CALC_THETA",op=54,sd_prod=theta_geom,reentrant='n',
            FORMAT          =SIMP(statut='f',typ='TXM',defaut="EXCEL",into=("EXCEL","AGRAF") ),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
-#            CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-# RESPONSABLE ABBAS M.ABBAS
-
-CALCUL=OPER(nom="CALCUL",op=26,sd_prod=table_container,reentrant='f',
-            UIinfo={"groupes":("Résolution",)},
-            fr="Calculer des objets élémentaires comme une matrice tangente, intégrer une loi de comportement, etc...",
-     OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="COMPORTEMENT",
-                           into=( "COMPORTEMENT","MATR_TANG_ELEM","FORC_INT_ELEM"),),
-     MODELE          =SIMP(statut='o',typ=modele_sdaster),
-     CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
-     CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
-     TABLE           =SIMP(statut='f',typ=table_container),
-     EXCIT           =FACT(statut='o',max='**',
-       CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca)),
-       FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-       TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE",
-                                 into=("FIXE_CSTE",)),
-
-     ),
-     DEPL            =SIMP(statut='o',typ=cham_no_sdaster ),
-     INCR_DEPL       =SIMP(statut='o',typ=cham_no_sdaster ),
-     SIGM            =SIMP(statut='o',typ=cham_elem),
-     VARI            =SIMP(statut='o',typ=cham_elem),
-     INCREMENT       =FACT(statut='o',
-          LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
-          NUME_ORDRE      =SIMP(statut='o',typ='I'),),
-     COMP_INCR       =C_COMP_INCR(),
-     COMP_ELAS       =FACT(statut='f',max='**',
-          RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-          ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-          ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut= 0 ),
-          RESO_INTE       =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",into=("IMPLICITE",)),
-          RELATION        =SIMP(statut='o',typ='TXM',defaut="ELAS",
-                                into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC",
-                                     "ELAS_POUTRE_GR","CABLE","ELAS_HYPER")),
-          DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ),
-          ),
-     INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
-) ;
-
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -7693,10 +8582,58 @@ CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentr
            MODELE            =SIMP(statut='f',typ=modele_sdaster),
          ),
 ) ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 07/12/2010   AUTEUR GENIAUT S.GENIAUT 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE ABBAS M.ABBAS
+
+CALCUL=OPER(nom="CALCUL",op=26,sd_prod=table_container,reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+            fr="Calculer des objets élémentaires comme une matrice tangente, intégrer une loi de comportement, etc...",
+     OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="COMPORTEMENT",
+                           into=( "COMPORTEMENT","MATR_TANG_ELEM","FORC_INT_ELEM"),),
+     MODELE          =SIMP(statut='o',typ=modele_sdaster),
+     CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+     CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
+     TABLE           =SIMP(statut='f',typ=table_container),
+     EXCIT           =FACT(statut='o',max='**',
+       CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca)),
+       FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+       TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE",
+                                 into=("FIXE_CSTE",)),
+
+     ),
+     DEPL            =SIMP(statut='o',typ=cham_no_sdaster ),
+     INCR_DEPL       =SIMP(statut='o',typ=cham_no_sdaster ),
+     SIGM            =SIMP(statut='o',typ=cham_elem),
+     VARI            =SIMP(statut='o',typ=cham_elem),
+     INCREMENT       =FACT(statut='o',
+          LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
+          NUME_ORDRE      =SIMP(statut='o',typ='I'),),
+     COMP_INCR       =C_COMP_INCR(),
+     COMP_ELAS       =C_COMP_ELAS('CALCUL'),
+     INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+) ;
+
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -7717,8 +8654,8 @@ COMB_FOURIER=OPER(nom="COMB_FOURIER",op= 161,sd_prod=comb_fourier,
             UIinfo={"groupes":("Post-traitements",)},
          RESULTAT        =SIMP(statut='o',typ=(fourier_elas,fourier_ther),),
          ANGL            =SIMP(statut='o',typ='R',max='**'),
-         NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=6,
-             into=("DEPL","REAC_NODA","SIEF_ELGA_DEPL","EPSI_ELNO_DEPL","SIGM_ELNO_DEPL","TEMP","FLUX_ELNO_TEMP"),),
+         NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=6,into=("DEPL","REAC_NODA",
+                               "SIEF_ELGA","EPSI_ELNO","SIGM_ELNO","TEMP","FLUX_ELNO"),),
 ) ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
@@ -7782,10 +8719,10 @@ COMB_MATR_ASSE=OPER(nom="COMB_MATR_ASSE",op=  31,sd_prod=comb_matr_asse_prod,
          ),
          SANS_CMP        =SIMP(statut='f',typ='TXM',into=("LAGR",) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 21/03/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -7890,7 +8827,7 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca,
                    AU_MOINS_UN('DX','DY','DZ' ),),
            NOM_CAS         =SIMP(statut='o',typ='TXM',max='**'),
            NUME_CAS        =SIMP(statut='o',typ='I',max='**'),
-           MODE_STAT       =SIMP(statut='f',typ=mode_meca, ),
+           MODE_STAT       =SIMP(statut='o',typ=mode_meca, ),
            NOEUD_REFE      =SIMP(statut='f',typ=no),
            NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
            GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
@@ -7899,9 +8836,9 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca,
            DZ              =SIMP(statut='f',typ='R' ),
          ),
          OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=9,
-                               into=("DEPL","VITE","ACCE_ABSOLU","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL",
-                                     "EFGE_ELNO_DEPL","REAC_NODA","FORC_NODA","EFGE_ELNO_CART",
-                                     "SIPO_ELNO_DEPL") ),
+                               into=("DEPL","VITE","ACCE_ABSOLU","SIGM_ELNO","SIEF_ELGA",
+                                     "EFGE_ELNO","REAC_NODA","FORC_NODA","EFCA_ELNO",
+                                     "SIPO_ELNO") ),
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
          IMPRESSION      =FACT(statut='f',max='**',
            regles=(EXCLUS('TOUT','NIVEAU'),),
@@ -7910,10 +8847,10 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca,
          ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -8042,6 +8979,7 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod,
 #        ------------------------------------------------------------------
          b_extr          =BLOC(condition = "OPERATION == 'EXTR'",
              regles=(AU_MOINS_UN('MAILLAGE','FISSURE','RESULTAT','TABLE'),),
+#                     PRESENT_PRESENT('GRILLE_AUX','FISSURE'),),
              MAILLAGE        =SIMP(statut='f',typ=(maillage_sdaster) ),
              FISSURE         =SIMP(statut='f',typ=(fiss_xfem) ),
              RESULTAT        =SIMP(statut='f',typ=(resultat_sdaster) ),
@@ -8049,9 +8987,13 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod,
              b_extr_maillage =BLOC(condition = "MAILLAGE != None and TABLE == None",
                  NOM_CHAM        =SIMP(statut='o',typ='TXM',into=("GEOMETRIE",)),
              ),
-             b_extr_fissure  =BLOC(condition = "FISSURE != None",
-                 NOM_CHAM        =SIMP(statut='o',typ='TXM',into=("LTNO","LNNO","GRLTNO","GRLNNO","STNO","STNOR","BASLOC")),
+
+             b_extr_fissure  = BLOC(condition = "FISSURE != None",
+                 NOM_CHAM=SIMP(statut='o',typ='TXM',into=("LTNO","LNNO","GRLTNO","GRLNNO","STNO","STNOR","BASLOC",
+                                                                  "GRI.LNNO","GRI.LTNO","GRI.GRLNNO","GRI.GRLTNO")),
+
              ),
+                 
              b_extr_table    =BLOC(condition = "TABLE != None",
                       regles=( EXCLUS('MODELE','MAILLAGE'),
                                EXCLUS('PROL_ZERO','MAILLAGE'),),
@@ -8115,10 +9057,102 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod,
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 03/01/2011   AUTEUR ANDRIAM H.ANDRIAMBOLOLONA 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ANDRIAM H.ANDRIAMBOLOLONA
+
+from Macro.crea_elem_ssd_ops import crea_elem_ssd_ops
+
+def crea_elem_ssd_prod(self,NUME_DDL,**args):
+    if NUME_DDL:
+        self.type_sdprod(NUME_DDL,nume_ddl_sdaster)
+    return macr_elem_dyna
+
+CREA_ELEM_SSD=MACRO(nom="CREA_ELEM_SSD",
+         op=crea_elem_ssd_ops,
+         sd_prod=crea_elem_ssd_prod,
+         reentrant='n',
+         fr="Creation de macro-element dynamique en enchainant les commandes : \
+             CALC_MATR_ELEM, NUME_DDL, ASSE_MATRICE, MODE_ITER_SIMULT, \
+             DEFI_INTERF_DYNA, DEFI_BASE_MODALE et MACR_ELEM_DYNA",
+         UIinfo={"groupes":("Matrices/vecteurs",)},
+
+# pour CAL_MATR_ELEM + NUME_DDL + ASSE_MATRICE + MODE_ITER_SIMULT + MODE_STATIQUE
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         NUME_DDL        =SIMP(statut='f',typ=CO,defaut=None),
+         CHARGE          =SIMP(statut='f',typ=(char_meca,char_ther,char_acou),validators=NoRepeat(),max='**'),
+
+# pour DEFI_INTERF_DYNA
+         INTERFACE       =FACT(statut='o',max='**',
+           regles=(ENSEMBLE('NOM','TYPE'),
+                   UN_PARMI('NOEUD','GROUP_NO'),),
+           NOM             =SIMP(statut='f',typ='TXM' ),
+           TYPE            =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO",) ),
+           NOEUD           =SIMP(statut='f',typ=no,max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+           FREQ            =SIMP(statut='f',typ='R',defaut= 1.),
+         ),
+
+# pour DEFI_BASE_MODALE
+         BASE_MODALE = FACT(statut='o',max = 1,
+           TYPE   =SIMP(statut='o',typ='TXM',max=1,into=('CLASSIQUE','RITZ',)),
+           b_ritz = BLOC(condition = "TYPE == 'RITZ' ",
+             NMAX_MODE_INTF  =SIMP(statut='f',typ='I',defaut=10),
+           ),
+         ),
+
+         INFO          =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+
+         SOLVEUR         =C_SOLVEUR(),
+
+# pour le calcul modal
+         CALC_FREQ       =FACT(statut='d',min=0,
+             OPTION      =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","BANDE","CENTRE"),
+                                   fr="Choix de l option et par consequent du shift du probleme modal" ),
+             b_plus_petite =BLOC(condition = "OPTION == 'PLUS_PETITE'",fr="Recherche des plus petites valeurs propres",
+               NMAX_FREQ       =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
+             ),
+             b_centre       =BLOC(condition = "OPTION == 'CENTRE'",
+                                  fr="Recherche des valeurs propres les plus proches d une valeur donnee",
+               FREQ            =SIMP(statut='o',typ='R',
+                                     fr="Frequence autour de laquelle on cherche les frequences propres"),
+               AMOR_REDUIT     =SIMP(statut='f',typ='R',),
+               NMAX_FREQ       =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
+             ),
+             b_bande         =BLOC(condition = "(OPTION == 'BANDE')",
+                                   fr="Recherche des valeurs propres dans une bande donnee",
+               NMAX_FREQ       =SIMP(statut='f',typ='I',defaut= 9999,val_min=0 ),
+               FREQ            =SIMP(statut='o',typ='R',min=2,validators=NoRepeat(),max='**',
+                                     fr="Valeurs des frequences delimitant les bandes de recherche"),
+             ),
+             APPROCHE        =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG","COMPLEXE"),
+                                   fr="Choix du pseudo-produit scalaire pour la resolution du probleme quadratique" ),
+           ),
+
+
+)  ;
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -8270,16 +9304,16 @@ CREA_MAILLAGE=OPER(nom="CREA_MAILLAGE",op= 167,sd_prod=maillage_sdaster,
            GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
            SHRINK          =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de réduction" ),
            TAILLE_MIN      =SIMP(statut='f',typ='R',defaut= 0.0, fr="Taille minimale d'un coté" ),
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),),
          ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 #
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -8397,7 +9431,7 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f',
 
            ECLA_PG         =FACT(statut='o',
              regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),),
              MODELE_INIT     =SIMP(statut='o',typ=modele_sdaster),
              TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
              MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
@@ -8630,10 +9664,10 @@ DEBUG=PROC(nom="DEBUG",op=137,
      IMPR_MACRO      =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess",
                            statut='f',typ='TXM',into=("OUI","NON")),
  );
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 03/01/2011   AUTEUR COURTOIS M.COURTOIS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -8735,11 +9769,12 @@ DEBUT=MACRO(nom="DEBUT",op=ops.build_debut ,repetable='n',
 
          IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"),
 
+         INFO     = SIMP(statut='f', typ='I', defaut=1, into=(1,2),),
 );
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 25/01/2011   AUTEUR NISTOR I.NISTOR 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -8810,13 +9845,12 @@ DEFI_BASE_MODALE=OPER(nom="DEFI_BASE_MODALE",op=  99,sd_prod=mode_meca,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
-             FILTRAGE_MATRICE =SIMP(statut='f',typ='R',defaut=-1.0,),
-             MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
          ),
 
@@ -8951,10 +9985,10 @@ DEFI_CABLE_OP=OPER(nom="DEFI_CABLE_OP",op= 180,sd_prod=cabl_precont,reentrant='n
            PRESENT           =SIMP(statut='o',typ='TXM',min=2,max=2,into=("OUI","NON") ),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 23/02/2011   AUTEUR LAVERNE J.LAVERNE 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -8981,16 +10015,31 @@ DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster,
           MONOCRISTAL    =FACT(statut='f', max='**',
              MATER           =SIMP(statut='o', typ=mater_sdaster, max=1),
              ECOULEMENT      =SIMP(statut='o', typ='TXM', max=1,
+                                into=('MONO_VISC1', 'MONO_VISC2', 'MONO_VISC3', 'MONO_DD_KR', 'MONO_DD_CFC', 'MONO_DD_CC',),
                    fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écoulement viscoplastique"),
-             ECRO_ISOT       =SIMP(statut='o', typ='TXM', max=1,
-                   fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage isotrope"),
-             ECRO_CINE       =SIMP(statut='o', typ='TXM', max=1,
-                   fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage cinématique"),
              ELAS            =SIMP(statut='f', typ='TXM', max=1,
                    fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le comportement élastique (un et un seul)"),
-             FAMI_SYST_GLIS  =SIMP(statut='o',typ='TXM', max=1,
+             b_non_dd =BLOC(condition="ECOULEMENT=='MONO_VISC1' or ECOULEMENT=='MONO_VISC2' or ECOULEMENT=='MONO_VISC3'",
+                   ECRO_ISOT       =SIMP(statut='f', typ='TXM', max=1,
+                   fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage isotrope"),
+                   ECRO_CINE       =SIMP(statut='f', typ='TXM', max=1,
+                   fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le type d'écrouissage cinématique"),
+                   FAMI_SYST_GLIS  =SIMP(statut='o',typ='TXM', max=1,
                                 into=('BASAL', 'PRISMATIQUE', 'OCTAEDRIQUE', 'PYRAMIDAL1',
-                                'PYRAMIDAL2', 'CUBIQUE1', 'CUBIQUE2', 'MACLAGE', 'JOINT_GRAIN', 'RL', 'UNIAXIAL','BCC24'),),
+                                'PYRAMIDAL2', 'CUBIQUE1', 'CUBIQUE2', 'MACLAGE', 'UNIAXIAL','BCC24'),),
+                                ),
+             b_dd_kr =BLOC(condition="ECOULEMENT=='MONO_DD_KR' ",
+                   FAMI_SYST_GLIS  =SIMP(statut='f',typ='TXM', max=1,
+                                into=('BCC24',),defaut=('BCC24',),),
+                                ),
+             b_dd_cfc =BLOC(condition="ECOULEMENT=='MONO_DD_CFC' ",
+                   FAMI_SYST_GLIS  =SIMP(statut='f',typ='TXM', max=1,
+                                into=('OCTAEDRIQUE',),defaut=('OCTAEDRIQUE',),),
+                                ),
+             b_dd_cc =BLOC(condition="ECOULEMENT=='MONO_DD_CC' ",
+                   FAMI_SYST_GLIS  =SIMP(statut='o',typ='TXM', max=1,
+                                into=('CUBIQUE1',),defaut=('CUBIQUE1',),),
+                                ),
                                 ),
 
           ROTA_RESEAU =SIMP(statut='f', typ='TXM', max=1,into=('NON','POST','CALC'),defaut='NON',
@@ -9042,7 +10091,6 @@ DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster,
                                        "GRANGER_FP_V",
                                        "BETON_UMLV_FP",
                                        "ROUSS_PR",
-                                       "NADAI_B",
                                        "BETON_DOUBLE_DP",
                                        ),),
 # on pourrait ajouter TOUT_GROUP_FIBRE
@@ -9076,10 +10124,10 @@ DEFI_CONSTANTE=OPER(nom="DEFI_CONSTANTE",op=   2,sd_prod=fonction_sdaster,
          VALE            =SIMP(statut='o',typ='R',),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 23/02/2011   AUTEUR MASSIN P.MASSIN 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -9100,6 +10148,7 @@ DEFI_CONTACT=OPER(nom       = "DEFI_CONTACT",
                   op        = 30,
                   sd_prod   = char_contact,
                   fr        = "Définit les zones soumises à des conditions de contact unilatéral avec ou sans frottement",
+                  #en        = "Allows the definition of contact surfaces as well as unilateral conditions",
                   reentrant = 'n',
                   UIinfo    = {"groupes":("Modélisation",)},
 
@@ -9111,63 +10160,59 @@ DEFI_CONTACT=OPER(nom       = "DEFI_CONTACT",
 # FORMULATION (UNIQUE PAR OCCURRENCE DE DEFI_CONTACT)
 
          FORMULATION     =SIMP(statut='o',
-                               typ='TXM',
                                position='global',
+                               typ='TXM',
+                               fr="Choix d'une formulation de contact ou de liaisons unilatérales",
                                defaut="DISCRETE",
                                into=("DISCRETE","CONTINUE","XFEM","LIAISON_UNIL",),),
 
-# PARAMETRE GENERAL: FROTTEMENT
+# PARAMETRE GENERAL : FROTTEMENT
 
          FROTTEMENT      =SIMP(statut='f',
-                               typ='TXM',
                                position='global',
+                               typ='TXM',
+                               fr="Choix d'un modèle de frottement (uniquement pour les formulations de contact)",
                                defaut="SANS",
                                into=("COULOMB","SANS",)),
 
 ### PARAMETRES GENERAUX (UNIQUEMENT POUR LE CONTACT MAILLE, NE DEPENDENT PAS DE LA ZONE DE CONTACT)
 
          b_contact_mail=BLOC(condition = "((FORMULATION == 'CONTINUE') or (FORMULATION == 'DISCRETE'))",
-           STOP_INTERP   = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
-           LISSAGE       = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
-         ),
-
-### PARAMETRES GENERAUX (UNIQUEMENT POUR LE CONTACT, NE DEPENDENT PAS DE LA ZONE DE CONTACT)
-
-         b_contact=BLOC(condition = "FORMULATION != 'LIAISON_UNIL' ",
-
-# PARAMETRE GENERAL: VERIFICATION DE L'ORIENTATION ET DE LA COHERENCE DES NORMALES
-
+#          ARRET DU CALCUL POUR LE MODE SANS RESOLUTION DU CONTACT
+           STOP_INTERP   = SIMP(statut='f',
+                                typ='TXM',
+                                fr="Arrête le calcul dès qu'une interpénétration est détectée en mode RESOLUTION='NON'",
+                                defaut="NON",
+                                into=("OUI","NON")),
+#          LISSAGE DES NORMALES PAR MOYENNATION AUX NOEUDS
+           LISSAGE       = SIMP(statut='f',
+                                typ='TXM',
+                                fr="Lissage des normales par moyennation aux noeuds",
+                                defaut="NON",
+                                into=("OUI","NON")),
+#          VERIFICATION DE L'ORIENTATION ET DE LA COHERENCE DES NORMALES
            VERI_NORM       =SIMP(statut='f',
                                  typ='TXM',
+                                 fr="Vérification de l'orientation (sortante) des normales aux surfaces",
                                  defaut="OUI",
                                  into=("OUI","NON"),),
+           ),
 
-# PARAMETRE GENERAL: BOUCLE SUR GEOMETRIE
+### PARAMETRES GENERAUX (UNIQUEMENT POUR LE CONTACT, NE DEPENDENT PAS DE LA ZONE DE CONTACT)
 
-           b_bouc_geom_disc=BLOC(condition = "FORMULATION == 'DISCRETE' ",
-                                 REAC_GEOM =SIMP(statut='f',
-                                                 typ='TXM',
-                                                 into=("AUTOMATIQUE","CONTROLE","SANS",),
-                                                 defaut="AUTOMATIQUE",
-                                                 ),
-                                 b_automatique = BLOC(condition = "REAC_GEOM == 'AUTOMATIQUE' ",
-                                   ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=5),
-                                   RESI_GEOM      = SIMP(statut='f',typ='R',defaut=0.05),
-                                   ),
-                                 b_controle    = BLOC(condition = "REAC_GEOM == 'CONTROLE' ",
-                                   NB_ITER_GEOM   = SIMP(statut='f',typ='I',defaut = 2),
-                                   ),
-                                 ),
+         b_contact=BLOC(condition = "FORMULATION != 'LIAISON_UNIL' ",
+
+# PARAMETRE GENERAL : BOUCLE DE GEOMETRIE
 
-           b_bouc_geom_cont=BLOC(condition = "FORMULATION == 'CONTINUE' ",
+           b_bouc_geom_mail=BLOC(condition = "(FORMULATION == 'DISCRETE' or FORMULATION == 'CONTINUE')",
                                  REAC_GEOM =SIMP(statut='f',
                                                  typ='TXM',
                                                  into=("AUTOMATIQUE","CONTROLE","SANS",),
                                                  defaut="AUTOMATIQUE",
                                                  ),
                                  b_automatique = BLOC(condition = "REAC_GEOM == 'AUTOMATIQUE' ",
-                                   ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=5),
-                                   RESI_GEOM      = SIMP(statut='f',typ='R',defaut=0.0001),
+                                   ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=10),
+                                   RESI_GEOM      = SIMP(statut='f',typ='R',defaut=0.01),
                                    ),
                                  b_controle    = BLOC(condition = "REAC_GEOM == 'CONTROLE' ",
                                    NB_ITER_GEOM   = SIMP(statut='f',typ='I',defaut = 2),
@@ -9181,7 +10226,7 @@ DEFI_CONTACT=OPER(nom       = "DEFI_CONTACT",
                                                  defaut="SANS",
                                                  ),
                                  b_automatique = BLOC(condition = "REAC_GEOM == 'AUTOMATIQUE' ",
-                                   ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=5),
+                                   ITER_GEOM_MAXI = SIMP(statut='f',typ='I',defaut=10),
                                    RESI_GEOM      = SIMP(statut='f',typ='R',defaut=0.0001),
                                    ),
                                  b_controle    = BLOC(condition = "REAC_GEOM == 'CONTROLE' ",
@@ -9189,7 +10234,8 @@ DEFI_CONTACT=OPER(nom       = "DEFI_CONTACT",
                                    ),
                                  ),
 
-# PARAMETRE GENERAL: BOUCLE SUR CONTACT
+
+# PARAMETRE GENERAL : BOUCLE DE CONTACT
 
            b_bouc_cont_disc=BLOC(condition = "FORMULATION == 'DISCRETE' ",
                                  ITER_CONT_MULT = SIMP(statut='f',typ='I',defaut = 4),
@@ -9210,51 +10256,73 @@ DEFI_CONTACT=OPER(nom       = "DEFI_CONTACT",
                                  ITER_CONT_TYPE= SIMP(statut='f',typ='TXM',defaut="MAXI",
                                                       into=("MULT","MAXI")),
                                  b_bouc_cont_mult = BLOC(condition = "ITER_CONT_TYPE=='MULT'",
-                                   ITER_CONT_MULT = SIMP(statut='f',typ='I',defaut = 4),
+                                                         ITER_CONT_MULT = SIMP(statut='f',typ='I',defaut = 4),
                                    ),
                                  b_bouc_cont_maxi = BLOC(condition = "ITER_CONT_TYPE=='MAXI'",
-                                   ITER_CONT_MAXI = SIMP(statut='f',typ='I',defaut = 30),
+                                                         ITER_CONT_MAXI = SIMP(statut='f',typ='I',defaut = 30),
                                    ),
                                  ),
 
-# PARAMETRE GENERAL: BOUCLE SUR FROTTEMENT
+# PARAMETRE GENERAL : BOUCLE DE FROTTEMENT
 
            b_bouc_frot     = BLOC(condition = "FROTTEMENT=='COULOMB' and ((FORMULATION == 'CONTINUE') or (FORMULATION == 'XFEM')) ",
                                   REAC_FROT =SIMP(statut='f',
                                                   typ='TXM',
+                                                  defaut="AUTOMATIQUE",
                                                   into=("AUTOMATIQUE","CONTROLE",),
-                                                  defaut="AUTOMATIQUE",),
+                                                  ),
                                   b_automatique = BLOC(condition = "REAC_FROT == 'AUTOMATIQUE' ",
-                                    ITER_FROT_MAXI = SIMP(statut='f',typ='I',defaut=2),
-                                    RESI_FROT      = SIMP(statut='f',typ='R',defaut=0.0001),
+                                                       ITER_FROT_MAXI = SIMP(statut='f',typ='I',defaut=10),
+                                                       RESI_FROT      = SIMP(statut='f',typ='R',defaut=0.0001),
                                     ),
                                   b_controle    = BLOC(condition = "REAC_FROT == 'CONTROLE' ",
-                                    NB_ITER_FROT   = SIMP(statut='f',typ='I',defaut = 2),
+                                                       NB_ITER_FROT   = SIMP(statut='f',typ='I',defaut = 2),
                                     ),
-                                 ),
+                                  ),
 
-# PARAMETRE GENERAL: METHODES DISCRETES
+# PARAMETREs GENERAUX : METHODES DISCRETES
 
            b_para_discret  = BLOC(condition = "FORMULATION == 'DISCRETE' ",
-                                  STOP_SINGULIER= SIMP(statut='f',typ='TXM',defaut="OUI",
-                                                       into=("OUI","NON")),
-                                  NB_RESOL      = SIMP(statut='f',typ='I', defaut=10 ),
-                                  RESI_ABSO     = SIMP(statut='f',typ='R',
-                                  fr="Critere de convergence (niveau d'interpenetration autorise)"),
-                                  REAC_ITER     = SIMP(statut='f',typ='I',defaut=3,
-                                   fr="Frequence de reinitialisation de la conjugaison"),
-                                  ITER_GCP_MAXI = SIMP(statut='f',typ='I',defaut=0,
-                                  fr="Nombre d'iterations maximal pour le GCP"),
-
-                                  PRE_COND      = SIMP(statut='f',typ='TXM',defaut="SANS",into=("DIRICHLET","SANS"),
-                                  fr="Choix d'un preconditionneur (accelere la convergence)"),
-                                  ITER_PRE_MAXI = SIMP(statut='f',typ='I',defaut=0,
-                                  fr="Nombre d'iterations maximal pour le preconditionneur"),
-                                  COEF_RESI     = SIMP(statut='f',typ='R',defaut = 1.,
-                                  fr="Critere_Convergence_Preconditionneur = COEF_RESI*Critere_Convergence_GCP",),
-                                  RECH_LINEAIRE = SIMP(statut='f',typ='TXM',defaut="ADMISSIBLE",
-                                                       into=("ADMISSIBLE","NON_ADMISSIBLE"),
-                                                 fr="Autorise-t-on de sortir du domaine admissible lors de la recherche lineaire",),
+#                                 ## METHODES DE DUALISATION ##
+                                  STOP_SINGULIER= SIMP(statut='f',
+                                                       typ='TXM',
+                                                       fr="Tient compte de la singularité de la matrice de contact",
+                                                       defaut="OUI",
+                                                       into=("OUI","NON"),),
+                                  NB_RESOL      = SIMP(statut='f',
+                                                       typ='I',
+                                  fr="Nombre de résolutions simultanées pour la construction du complément de Schur",
+                                                       defaut=10,),
+#                                 ## GCP ##
+                                  RESI_ABSO     = SIMP(statut='f',
+                                                       typ='R',
+                                  fr="Critère de convergence (niveau d'interpénétration autorisé pour 'GCP')",),
+                                  REAC_ITER     = SIMP(statut='f',
+                                                       typ='I',
+                                                       fr="Fréquence de réinitialisation de la conjugaison ('GCP')",
+                                                       defaut=3,),
+                                  ITER_GCP_MAXI = SIMP(statut='f',
+                                                       typ='I',
+                                                       fr="Nombre d'itérations maximal ('GCP')",
+                                                       defaut=0,),
+                                  PRE_COND      = SIMP(statut='f',
+                                                       typ='TXM',
+                                                       fr="Choix d'un préconditionneur (accélère la convergence de 'GCP')",
+                                                       defaut="SANS",
+                                                       into=("DIRICHLET","SANS"),),
+                                  ITER_PRE_MAXI = SIMP(statut='f',
+                                                       typ='I',
+                                                       fr="Nombre d'itérations maximal pour le préconditionneur ('GCP')",
+                                                       defaut=0,),
+                                  COEF_RESI     = SIMP(statut='f',
+                                                       typ='R',
+                                                       fr="Critère de convergence du préconditionneur (COEF_RESI*RESI_ABSO)",
+                                                       defaut = 1.,),
+                                  RECH_LINEAIRE = SIMP(statut='f',
+                                                       typ='TXM',
+                                  fr="Autorisation de sortie du domaine admissible lors de la recherche linéaire",
+                                                       defaut="ADMISSIBLE",
+                                                       into=("ADMISSIBLE","NON_ADMISSIBLE"),),
                                   ),
            ), #fin bloc b_contact
 
@@ -9262,304 +10330,294 @@ DEFI_CONTACT=OPER(nom       = "DEFI_CONTACT",
 
 # AFFECTATION - CAS LIAISON_UNILATERALE
 
-           b_affe_unil     = BLOC(condition = "FORMULATION == 'LIAISON_UNIL'",
-                                  ZONE=FACT(statut='o',
-                                            max='**',
-
+         b_affe_unil     = BLOC(condition = "FORMULATION == 'LIAISON_UNIL'",
+                                ZONE=FACT(statut='o',
+                                          max='**',
 # -- Liaison unilatérale
-                                            regles=(UN_PARMI('GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
-                                            GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
-                                            MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-                                            GROUP_NO        =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
-                                            NOEUD           =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
-
-                                            NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
-                                            COEF_IMPO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),),
-                                            COEF_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
-
+                                          regles=(UN_PARMI('GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
+                                          GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
+                                          MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                                          GROUP_NO        =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
+                                          NOEUD           =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
+#
+                                          NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
+                                          COEF_IMPO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),),
+                                          COEF_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
 # -- Incompatibilité avec CL
-                                            SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
-                                            SANS_GROUP_NO   =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
+                                          SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
+                                          SANS_GROUP_NO   =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
 
 
-                                            ),
-                                  ), #fin bloc b_affe_unil
+                                          ),
+                                ), #fin bloc b_affe_unil
 
 # AFFECTATION - CAS DISCRET
 
-           b_affe_discret  = BLOC(condition = "FORMULATION == 'DISCRETE'",
-                                  ZONE=FACT(statut='o',
-                                            max='**',
-
+         b_affe_discret  = BLOC(condition = "FORMULATION == 'DISCRETE'",
+                                ZONE=FACT(statut='o',
+                                          max='**',
 # -- Appariement
-                                            APPARIEMENT     =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL",
-                                                                  into=("NODAL","MAIT_ESCL"),),
-
-                                            regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),
-                                                    UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),),
-                                            GROUP_MA_MAIT   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
-                                            MAILLE_MAIT     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-                                            GROUP_MA_ESCL   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
-                                            MAILLE_ESCL     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-
-                                            NORMALE         =SIMP(statut='f',typ='TXM',defaut="MAIT",
-                                                                  into=("MAIT","MAIT_ESCL","ESCL"),),
-
-                                            VECT_MAIT       =SIMP(statut='f',typ='TXM',defaut="AUTO",
-                                                                  into=("AUTO","FIXE","VECT_Y")),
-
-                                            b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'",
-                                              MAIT_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
-
-                                            b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'",
-                                              MAIT_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
-
-                                            VECT_ESCL       =SIMP(statut='f',typ='TXM',defaut="AUTO",
-                                                                  into=("AUTO","FIXE","VECT_Y")),
-
-                                            b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'",
-                                              ESCL_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
-
-                                            b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'",
-                                              ESCL_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
+                                          APPARIEMENT     =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL",
+                                                                into=("NODAL","MAIT_ESCL"),),
+#
+                                          regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),
+                                                  UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),),
+                                          GROUP_MA_MAIT   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
+                                          MAILLE_MAIT     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                                          GROUP_MA_ESCL   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
+                                          MAILLE_ESCL     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+#
+                                          NORMALE         =SIMP(statut='f',typ='TXM',defaut="MAIT",
+                                                                into=("MAIT","MAIT_ESCL","ESCL"),),
+#
+                                          VECT_MAIT       =SIMP(statut='f',typ='TXM',defaut="AUTO",
+                                                                into=("AUTO","FIXE","VECT_Y")),
 
-                                            TYPE_APPA       =SIMP(statut='f',typ='TXM',defaut="PROCHE",
-                                                             into  =("PROCHE","FIXE")),
+                                          b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'",
+                                            MAIT_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
 
-                                            b_appa_fixe     =BLOC(condition = "TYPE_APPA == 'FIXE'",
-                                              DIRE_APPA     =SIMP(statut='f',typ='R',min=3,max=3),
-                                              ),
+                                          b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'",
+                                            MAIT_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
+#
+                                          VECT_ESCL       =SIMP(statut='f',typ='TXM',defaut="AUTO",
+                                                                into=("AUTO","FIXE","VECT_Y")),
 
-                                            DIST_POUTRE     =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
-                                            DIST_COQUE      =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
-                                            b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'",
-                                              CARA_ELEM     =SIMP(statut='o',typ=(cara_elem) ),
-                                              ),
+                                          b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'",
+                                            ESCL_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
 
-                                            DIST_MAIT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                            DIST_ESCL       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                          b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'",
+                                            ESCL_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
+#
+                                          TYPE_APPA       =SIMP(statut='f',typ='TXM',defaut="PROCHE",
+                                                           into  =("PROCHE","FIXE")),
 
-                                            TOLE_APPA       =SIMP(statut='f',typ='R'  ,defaut=-1.0),
-                                            TOLE_PROJ_EXT   =SIMP(statut='f',typ='R'  ,defaut=0.50),
+                                          b_appa_fixe     =BLOC(condition = "TYPE_APPA == 'FIXE'",
+                                            DIRE_APPA     =SIMP(statut='f',typ='R',min=3,max=3),
+                                            ),
+#
+                                          DIST_POUTRE     =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
+                                          DIST_COQUE      =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
+                                          b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'",
+                                            CARA_ELEM     =SIMP(statut='o',typ=(cara_elem) ),
+                                            ),
 
+                                          DIST_MAIT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                          DIST_ESCL       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+#
+                                          TOLE_APPA       =SIMP(statut='f',typ='R'  ,defaut=-1.0),
+                                          TOLE_PROJ_EXT   =SIMP(statut='f',typ='R'  ,defaut=0.50),
 # -- Incompatibilité avec CL
-                                            SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
-                                            SANS_GROUP_NO   =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
-                                            SANS_MAILLE     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-                                            SANS_GROUP_MA   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
-
+                                          SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
+                                          SANS_GROUP_NO   =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
+                                          SANS_MAILLE     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                                          SANS_GROUP_MA   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
 # -- Mode sans calcul
-                                            RESOLUTION      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
-                                            b_verif=BLOC(condition = "RESOLUTION == 'NON' ",
-                                               TOLE_INTERP   = SIMP(statut='f',typ='R',defaut = 0.),
+                                          RESOLUTION      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+                                          b_verif=BLOC(condition = "RESOLUTION == 'NON' ",
+                                            TOLE_INTERP   = SIMP(statut='f',typ='R',defaut = 0.),
                                             ),
-
 # -- Résolution
-                                            ALGO_CONT       =SIMP(statut='o',typ='TXM',defaut="CONTRAINTE",
-                                                                  into=("CONTRAINTE","LAGRANGIEN","PENALISATION","GCP"),),
-
-                                            b_active=BLOC(condition = "ALGO_CONT == 'CONTRAINTE' ",
-                                                         fr="Paramètres de la méthode des contraintes actives (contact uniquement)",
-                                              GLISSIERE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
-                                              b_glissiere=BLOC(condition = "GLISSIERE == 'OUI' ",
-                                                ALARME_JEU  =SIMP(statut='f',typ='R',defaut=0.),
-                                                ),
-                                              ),
-
-
-                                            b_penal_contact=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
-                                                                 fr="Paramètres de la méthode pénalisée (contact)",
-                                              E_N           =SIMP(statut='o',typ='R'),
-                                              ),
-
-                                            b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",
-                                                              fr="Paramètres du frottement",
-                                              COULOMB       =SIMP(statut='o',typ='R',),
-                                              COEF_MATR_FROT=SIMP(statut='f',typ='R',defaut=0.E+0),
-                                              ALGO_FROT     =SIMP(statut='o',typ='TXM',defaut="PENALISATION",
-                                                                  into=("PENALISATION","LAGRANGIEN"),),
-
-                                              b_penal_frot=BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
-                                                                fr="Paramètres de la méthode pénalisée (frottement)",
-                                                E_T         =SIMP(statut='o',typ='R'),
-                                                ),
-                                              ),
-                                            ), #fin mot-clé facteur ZONE
-                                  ), #fin bloc b_affe_discret
-
+                                          ALGO_CONT       =SIMP(statut='o',typ='TXM',defaut="CONTRAINTE",
+                                                                into=("CONTRAINTE","LAGRANGIEN","PENALISATION","GCP"),),
+
+                                          b_active=BLOC(condition = "ALGO_CONT == 'CONTRAINTE' ",
+                                                        fr="Paramètres de la méthode des contraintes actives (contact uniquement)",
+                                                        GLISSIERE=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                                                        b_glissiere=BLOC(condition = "GLISSIERE == 'OUI' ",
+                                                                         ALARME_JEU  =SIMP(statut='f',typ='R',defaut=0.),
+                                                                        ),
+                                                        ),
+#
+                                          b_penal_contact=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
+                                                               fr="Paramètres de la méthode pénalisée (contact)",
+                                                               E_N=SIMP(statut='o',typ='R'),
+                                                               ),
+#
+                                          b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",
+                                                            fr="Paramètres du frottement de Coulomb",
+                                                            COULOMB       =SIMP(statut='o',typ='R',),
+                                                            COEF_MATR_FROT=SIMP(statut='f',typ='R',defaut=0.E+0),
+                                                            ALGO_FROT     =SIMP(statut='o',typ='TXM',defaut="PENALISATION",
+                                                                                into=("PENALISATION","LAGRANGIEN"),),
+#
+                                                            b_penal_frot=BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
+                                                                              fr="Paramètres de la méthode pénalisée (frottement)",
+                                                                              E_T=SIMP(statut='o',typ='R'),
+                                                                              ),
+                                                           ),
+                                          ), #fin mot-clé facteur ZONE
+                                ), #fin bloc b_affe_discret
 
 # AFFECTATION - CAS CONTINUE
 
-           b_affe_continue = BLOC(condition = "FORMULATION == 'CONTINUE'",
-                                  ZONE=FACT(statut='o',
-                                            max='**',
-
+         b_affe_continue = BLOC(condition = "FORMULATION == 'CONTINUE'",
+                                ZONE=FACT(statut='o',
+                                          max='**',
 # -- Appariement
-                                            APPARIEMENT     =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL",
-                                                                  into=("MAIT_ESCL",)),
-
-                                            regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),
-                                                    UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),),
-                                            GROUP_MA_MAIT   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
-                                            MAILLE_MAIT     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-                                            GROUP_MA_ESCL   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
-                                            MAILLE_ESCL     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-
-                                            NORMALE         =SIMP(statut='f',typ='TXM',defaut="MAIT",
-                                                                  into=("MAIT","MAIT_ESCL","ESCL"),),
-
-                                            VECT_MAIT       =SIMP(statut='f',typ='TXM',defaut="AUTO",
-                                                                  into=("AUTO","FIXE","VECT_Y")),
-
-                                            b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'",
-                                              MAIT_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
-
-                                            b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'",
-                                              MAIT_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
-
-                                            VECT_ESCL       =SIMP(statut='f',typ='TXM',defaut="AUTO",
-                                                                  into=("AUTO","FIXE","VECT_Y")),
-
-                                            b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'",
-                                              ESCL_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
-
-                                            b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'",
-                                              ESCL_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
-                                              ),
+                                          APPARIEMENT     =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL",
+                                                                into=("MAIT_ESCL",)),
+#
+                                          regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),
+                                                  UN_PARMI('GROUP_MA_MAIT','MAILLE_MAIT'),),
+                                          GROUP_MA_MAIT   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
+                                          MAILLE_MAIT     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                                          GROUP_MA_ESCL   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max=1),
+                                          MAILLE_ESCL     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+#
+                                          NORMALE         =SIMP(statut='f',typ='TXM',defaut="MAIT",
+                                                                into=("MAIT","MAIT_ESCL","ESCL"),),
+#
+                                          VECT_MAIT       =SIMP(statut='f',typ='TXM',defaut="AUTO",
+                                                                into=("AUTO","FIXE","VECT_Y")),
 
-                                            TYPE_APPA       =SIMP(statut='f',typ='TXM',defaut="PROCHE",
-                                                             into  =("PROCHE","FIXE")),
+                                          b_nmait_fixe=BLOC(condition = "VECT_MAIT == 'FIXE'",
+                                            MAIT_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
 
-                                            b_appa_fixe=BLOC(condition = "TYPE_APPA == 'FIXE'",
-                                              DIRE_APPA     =SIMP(statut='f',typ='R',min=3,max=3),
-                                              ),
+                                          b_nmait_vecty=BLOC(condition = "VECT_MAIT == 'VECT_Y'",
+                                            MAIT_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
+#
+                                          VECT_ESCL       =SIMP(statut='f',typ='TXM',defaut="AUTO",
+                                                                into=("AUTO","FIXE","VECT_Y")),
 
-                                            DIST_POUTRE     =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
-                                            DIST_COQUE      =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
-                                            b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'",
-                                              CARA_ELEM     =SIMP(statut='o',typ=(cara_elem) ),
-                                              ),
+                                          b_nescl_fixe=BLOC(condition = "VECT_ESCL == 'FIXE'",
+                                            ESCL_FIXE     =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
 
-                                            DIST_MAIT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                            DIST_ESCL       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                          b_nescl_vecty=BLOC(condition = "VECT_ESCL == 'VECT_Y'",
+                                            ESCL_VECT_Y   =SIMP(statut='o',typ='R',min=3,max=3),
+                                            ),
+#
+                                          TYPE_APPA       =SIMP(statut='f',typ='TXM',defaut="PROCHE",
+                                                           into  =("PROCHE","FIXE")),
 
-                                            TOLE_APPA       =SIMP(statut='f',typ='R'  ,defaut=-1.0),
-                                            TOLE_PROJ_EXT   =SIMP(statut='f',typ='R'  ,defaut=0.50),
+                                          b_appa_fixe=BLOC(condition = "TYPE_APPA == 'FIXE'",
+                                            DIRE_APPA     =SIMP(statut='f',typ='R',min=3,max=3),
+                                            ),
+#
+                                          DIST_POUTRE     =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
+                                          DIST_COQUE      =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
+                                          b_cara=BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'",
+                                            CARA_ELEM     =SIMP(statut='o',typ=(cara_elem) ),
+                                            ),
 
+                                          DIST_MAIT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                          DIST_ESCL       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+#
+                                          TOLE_APPA       =SIMP(statut='f',typ='R'  ,defaut=-1.0),
+                                          TOLE_PROJ_EXT   =SIMP(statut='f',typ='R'  ,defaut=0.50),
 # -- Incompatibilité avec CL
-
-                                            SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
-                                            SANS_GROUP_NO   =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
-                                            SANS_MAILLE     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-                                            SANS_GROUP_MA   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
-
-                                            FOND_FISSURE    =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
-                                            b_fond_fissure =BLOC(condition = "FOND_FISSURE == 'OUI' ",
-                                                                 fr="Traitement en fond de fissure",
-                                              regles=(UN_PARMI('NOEUD_FOND','GROUP_NO_FOND','MAILLE_FOND','GROUP_MA_FOND'),),
-                                              NOEUD_FOND    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-                                              GROUP_NO_FOND =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-                                              MAILLE_FOND   =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-                                              GROUP_MA_FOND =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-                                              ),
-
-                                            RACCORD_LINE_QUAD=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
-                                            b_raccord_surf =BLOC(condition = "RACCORD_LINE_QUAD == 'OUI' ",
-                                                                 fr="Traitement du raccord surfacique",
-                                              regles=(UN_PARMI('NOEUD_RACC','GROUP_NO_RACC'),),
-                                              NOEUD_RACC    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-                                              GROUP_NO_RACC =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-                                              ),
-
-                                            EXCLUSION_PIV_NUL=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),),
-
+                                          SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
+                                          SANS_GROUP_NO   =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
+                                          SANS_MAILLE     =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                                          SANS_GROUP_MA   =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
+#
+                                          FOND_FISSURE    =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
+                                          b_fond_fissure  =BLOC(condition = "FOND_FISSURE == 'OUI' ",
+                                                                fr="Traitement en fond de fissure",
+                                          regles=(UN_PARMI('NOEUD_FOND','GROUP_NO_FOND','MAILLE_FOND','GROUP_MA_FOND'),),
+                                          NOEUD_FOND    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                                          GROUP_NO_FOND =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                                          MAILLE_FOND   =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                                          GROUP_MA_FOND =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                                                                ),
+#
+                                          RACCORD_LINE_QUAD=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
+                                          b_raccord_surf =BLOC(condition = "RACCORD_LINE_QUAD == 'OUI' ",
+                                                               fr="Traitement du raccord surfacique",
+                                                               regles=(UN_PARMI('NOEUD_RACC','GROUP_NO_RACC'),),
+                                          NOEUD_RACC    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                                          GROUP_NO_RACC =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                                                               ),
+#
+                                          EXCLUSION_PIV_NUL=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),),
 # -- Mode sans calcul
-                                            RESOLUTION      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
-                                            b_verif=BLOC(condition = "RESOLUTION == 'NON' ",
-                                               TOLE_INTERP   = SIMP(statut='f',typ='R',defaut = 0.),
-                                            ),
-
+                                          RESOLUTION       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+                                          b_verif=BLOC(condition = "RESOLUTION == 'NON' ",
+                                                       TOLE_INTERP   = SIMP(statut='f',typ='R',defaut = 0.),
+                                                       ),
 # -- Fonctionnalités spécifiques 'CONTINUE'
-                                            INTEGRATION     =SIMP(statut='f',typ='TXM',defaut="NOEUD",
-                                                                   into=("GAUSS","NOEUD","SIMPSON","SIMPSON1","SIMPSON2",
-                                                                                         "NCOTES" ,"NCOTES1" ,"NCOTES2"),),
-
-                                            CONTACT_INIT    =SIMP(statut='f',typ='TXM',defaut="NON",
-                                                                  into=("OUI","INTERPENETRE","NON"),),
-
-                                            GLISSIERE       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
-
-                                            ALGO_CONT       =SIMP(statut='f',typ='TXM',defaut="STANDARD",
-                                                                  into=("STANDARD","AVANCE","PENALISATION"),),
-
-                                            b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD' ",
-                                                            fr="Parametres de la formulation Lagrangienne",
-                                              COEF_CONT     =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                              ),
-                                            b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ",
-                                                            fr="Parametres du Lagrangien augmenté",
-                                              COEF_REGU_CONT=SIMP(statut='f',typ='R',defaut=100.E+0),
-                                              COEF_STAB_CONT=SIMP(statut='f',typ='R',defaut=100.E+0),
-                                              COEF_PENA_CONT=SIMP(statut='f',typ='R',defaut=100.E+0),
-                                              ),
-                                            b_cont_pena =BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
+                                          INTEGRATION     =SIMP(statut='f',typ='TXM',defaut="NOEUD",
+                                                                 into=("GAUSS","NOEUD","SIMPSON","SIMPSON1","SIMPSON2",
+                                                                                       "NCOTES" ,"NCOTES1" ,"NCOTES2"),),
+#
+                                          CONTACT_INIT    =SIMP(statut='f',typ='TXM',defaut="NON",
+                                                                into=("OUI","INTERPENETRE","NON"),),
+#
+                                          GLISSIERE       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
+#
+                                          ALGO_CONT       =SIMP(statut='f',typ='TXM',defaut="STANDARD",
+                                                                into=("STANDARD","AVANCE","PENALISATION"),),
+
+                                          b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD' ",
+                                                          fr="Paramètres de la formulation Lagrangienne",
+                                                          COEF_CONT = SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                          ),
+                                          b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ",
+                                                          fr="Paramètres du Lagrangien augmenté",
+                                                          COEF_REGU_CONT=SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                          COEF_STAB_CONT=SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                          COEF_PENA_CONT=SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                          ),
+                                          b_cont_pena=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
                                                             fr="Paramètres de la méthode pénalisée",
-                                              COEF_PENA_CONT  =SIMP(statut='o',typ='R'),),
-
-                                            COMPLIANCE      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
-                                            b_compliance=BLOC(condition = "COMPLIANCE == 'OUI' ",fr="Parametres de la compliance",
-                                              ASPERITE      =SIMP(statut='o',typ='R',),
-                                              E_N           =SIMP(statut='o',typ='R',),
-                                              E_V           =SIMP(statut='f',typ='R',defaut=0.E+0),
-                                              ),
-
-                                            b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramètres du frottement",
-                                              COULOMB          =SIMP(statut='o',typ='R',),
-                                              SEUIL_INIT     =SIMP(statut='f',typ='R',defaut=0.E+0),
-
-                                              regles=(EXCLUS('SANS_NOEUD_FR','SANS_GROUP_NO_FR'),),
-                                              SANS_NOEUD_FR    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-                                              SANS_GROUP_NO_FR =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-                                              b_sans_group_no_frot=BLOC(condition = " SANS_GROUP_NO_FR != None or \
-                                                                                         SANS_NOEUD_FR != None ",
-                                                fr="Direction de frottement à exclure (uniquement dans le cas 3D)",
-                                                DIRE_EXCL_FROT=SIMP(statut='f',typ='R',min=3,max=3),
-                                                ),
-
-                                              ALGO_FROT       =SIMP(statut='f',typ='TXM',defaut="STANDARD",
-                                                                    into=("STANDARD","AVANCE","PENALISATION"),),
-                                              b_frot_std      =BLOC(condition = "ALGO_FROT == 'STANDARD' ",
-                                                                    fr="Parametres de la formulation Lagrangienne",
-                                                                   COEF_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                                ),
-                                              b_frot_avc      =BLOC(condition = "ALGO_FROT == 'AVANCE' ",
-                                                                    fr="Parametres du Lagrangien augmenté",
-                                                                   COEF_REGU_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                                                   COEF_STAB_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                                                   COEF_PENA_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                                ),
-                                              b_frot_pena =BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
-                                                                    fr="Paramètres de la méthode pénalisée",
-                                                                   COEF_PENA_FROT  =SIMP(statut='o',typ='R'),
-                                                ),
+                                                            COEF_PENA_CONT  =SIMP(statut='o',typ='R'),
+                                                            ),
+#
+                                          COMPLIANCE      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+                                          b_compliance=BLOC(condition = "COMPLIANCE == 'OUI' ",
+                                                            fr="Paramètres de la compliance",
+                                                            ASPERITE = SIMP(statut='o',typ='R',),
+                                                            E_N      = SIMP(statut='o',typ='R',),
+                                                            E_V      = SIMP(statut='f',typ='R',defaut=0.E+0),
+                                            ),
+#
+                                          b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",
+                                                            fr="Paramètres du frottement de Coulomb",
+                                                            COULOMB    = SIMP(statut='o',typ='R',),
+                                                            SEUIL_INIT = SIMP(statut='f',typ='R',defaut=0.E+0),
+#
+                                          regles=(EXCLUS('SANS_NOEUD_FR','SANS_GROUP_NO_FR'),),
+                                          SANS_NOEUD_FR    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                                          SANS_GROUP_NO_FR =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                                                            b_sans_group_no_frot=BLOC(condition = " SANS_GROUP_NO_FR != None or \
+                                                                                                    SANS_NOEUD_FR != None ",
+                                                            fr="Direction de frottement à exclure (uniquement dans le cas 3D)",
+                                                            DIRE_EXCL_FROT=SIMP(statut='f',typ='R',min=3,max=3),
+                                                            ),
 
-                                              USURE          =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","ARCHARD",),),
-                                              b_usure        =BLOC(condition = "USURE == 'ARCHARD' ",
-                                                                   fr="Parametres de la loi d'usure d'Archard",
-                                                                   K =SIMP(statut='o',typ='R',),
-                                                                   H =SIMP(statut='o',typ='R',val_min=1E-8),
-                                                ),
+                                            ALGO_FROT       =SIMP(statut='f',typ='TXM',defaut="STANDARD",
+                                                                  into=("STANDARD","AVANCE","PENALISATION"),),
+                                            b_frot_std      =BLOC(condition = "ALGO_FROT == 'STANDARD' ",
+                                                                  fr="Paramètres de la formulation Lagrangienne",
+                                                                  COEF_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                                  ),
+                                            b_frot_avc      =BLOC(condition = "ALGO_FROT == 'AVANCE' ",
+                                                                  fr="Paramètres du Lagrangien augmenté",
+                                                                  COEF_REGU_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                                  COEF_STAB_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                                  COEF_PENA_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                                  ),
+                                            b_frot_pena     =BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
+                                                                  fr="Paramètres de la méthode pénalisée",
+                                                                  COEF_PENA_FROT  =SIMP(statut='o',typ='R'),
+                                                                  ),
+#
+                                            USURE           =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","ARCHARD",),),
+                                            b_usure         =BLOC(condition = "USURE == 'ARCHARD' ",
+                                                                  fr="Parametres de la loi d'usure d'Archard",
+                                                                  K =SIMP(statut='o',typ='R',),
+                                                                  H =SIMP(statut='o',typ='R',val_min=1E-8),
+                                                                  ),
 
-                                              ), #fin bloc b_frottement
-                                            ), #fin mot-clé facteur ZONE
-                                  ), #fin bloc b_affe_continue
+                                            ), #fin bloc b_frottement
+                                          ), #fin mot-clé facteur ZONE
+                                ), #fin bloc b_affe_continue
 
 
 # AFFECTATION - CAS XFEM
@@ -9578,55 +10636,61 @@ DEFI_CONTACT=OPER(nom       = "DEFI_CONTACT",
                                                              into=("GAUSS","FPG2","FPG3","FPG4","FPG6","FPG7",
                                                                    "NOEUD","SIMPSON","SIMPSON1","NCOTES","NCOTES1","NCOTES2"),),
 
-                                       CONTACT_INIT   = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
 
-                                       GLISSIERE      = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
-                                       RELATION         = SIMP(statut='f',typ='TXM',defaut="NON",into=("CZM_XFEM","NON"),),
+                                       RELATION       = SIMP(statut='f',typ='TXM',defaut="NON",
+                                                             into=("CZM_EXP_REG","CZM_LIN_REG","NON"),),
 
                                        ALGO_LAGR      = SIMP(statut='f',typ='TXM',defaut="VERSION1",
                                                              into=("NON","VERSION1","VERSION2"),),
                                        COEF_ECHELLE   = SIMP(statut='f',typ='R',defaut=1.E+6),
 
-                                       ALGO_CONT      =SIMP(statut='f',typ='TXM',defaut="STANDARD",
-                                                                  into=("STANDARD","AVANCE","PENALISATION"),),
+                                       ALGO_CONT      = SIMP(statut='f',typ='TXM',defaut="STANDARD",
+                                                                  into=("STANDARD","AVANCE","PENALISATION","CZM"),),
+                                                                  
+                                       b_cont_nczm =BLOC(condition = "ALGO_CONT!='CZM'",
+                                                CONTACT_INIT   = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
+                                                GLISSIERE      = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
+                                                ),
 
-                                       b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD' ",
-                                                       fr="Parametres de la formulation Lagrangienne",
-                                         COEF_CONT    =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                         ),
-                                       b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ",fr="Parametres du Lagrangien augmenté",
-                                         COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                         COEF_STAB_CONT =SIMP(statut='f',typ='R',defaut=0.E+0),
-                                         COEF_PENA_CONT =SIMP(statut='f',typ='R',defaut=0.E+0),
-                                         ),
+                                       b_cont_std=BLOC(condition = "ALGO_CONT == 'STANDARD'",
+                                                fr="Parametres de la formulation Lagrangienne",
+                                                COEF_CONT    =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                ),
+             
+                                       b_cont_avc=BLOC(condition = "ALGO_CONT == 'AVANCE' ",
+                                                 fr="Parametres du Lagrangien augmenté",
+                                                 COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                 COEF_STAB_CONT =SIMP(statut='f',typ='R',defaut=0.E+0),
+                                                 COEF_PENA_CONT =SIMP(statut='f',typ='R',defaut=0.E+0),
+                                                 ),
 
                                        b_cont_pen=BLOC(condition = "ALGO_CONT == 'PENALISATION' ",
-                                         fr="Paramètre de la méthode pénalisée",
-                                         COEF_PENA_CONT =SIMP(statut='o',typ='R'),
-                                         ),
-
-                                       b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramètres du frottement",
-                                         COULOMB      =SIMP(statut='o',typ='R',),
-                                         SEUIL_INIT   =SIMP(statut='f',typ='R',defaut=0.E+0),
+                                                 fr="Paramètre de la méthode pénalisée",
+                                                 COEF_PENA_CONT =SIMP(statut='o',typ='R'),
+                                                 ),
 
-                                         ALGO_FROT    =SIMP(statut='f',typ='TXM',defaut="STANDARD",
-                                                                  into=("STANDARD","AVANCE","PENALISATION"),),
+                                       b_frottement=BLOC(condition = "FROTTEMENT == 'COULOMB' and  ALGO_CONT != 'CZM' ",
+                                                 fr="Paramètres du frottement",
+                                                 COULOMB      =SIMP(statut='o',typ='R',),
+                                                 SEUIL_INIT   =SIMP(statut='f',typ='R',defaut=0.E+0),
+                                                 ALGO_FROT    =SIMP(statut='f',typ='TXM',defaut="STANDARD",
+                                                                            into=("STANDARD","AVANCE","PENALISATION"),),
 
-                                         b_frot_std=BLOC(condition = "ALGO_FROT == 'STANDARD' ",
-                                                         fr="Parametres de la formulation Lagrangienne",
-                                           COEF_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                           ),
-                                         b_frot_avc=BLOC(condition = "ALGO_FROT == 'AVANCE' ",
-                                                         fr="Parametres du Lagrangien augmenté",
-                                           COEF_REGU_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
-                                           COEF_STAB_FROT  =SIMP(statut='f',typ='R',defaut=0.E+0),
-                                           COEF_PENA_FROT  =SIMP(statut='f',typ='R',defaut=0.E+0),
-                                           ),
-                                         b_frot_pen=BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
-                                                         fr="Paramètre de la méthode pénalisée",
-                                           COEF_PENA_FROT  =SIMP(statut='o',typ='R'),
-                                           ),
-                                         ), #fin bloc b_frottement
+                                                 b_frot_std=BLOC(condition = "ALGO_FROT == 'STANDARD' ",
+                                                                  fr="Parametres de la formulation Lagrangienne",
+                                                                  COEF_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                                  ),
+                                                 b_frot_avc=BLOC(condition = "ALGO_FROT == 'AVANCE' ",
+                                                                  fr="Parametres du Lagrangien augmenté",
+                                                                  COEF_REGU_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                                                  COEF_STAB_FROT  =SIMP(statut='f',typ='R',defaut=0.E+0),
+                                                                  COEF_PENA_FROT  =SIMP(statut='f',typ='R',defaut=0.E+0),
+                                                                  ),
+                                                 b_frot_pen=BLOC(condition = "ALGO_FROT == 'PENALISATION' ",
+                                                                  fr="Paramètre de la méthode pénalisée",
+                                                                  COEF_PENA_FROT  =SIMP(statut='o',typ='R'),
+                                                                  ),
+                                                        ), #fin bloc b_frottement
                                        ), #fin mot-clé facteur ZONE
                              ), #fin bloc b_affe_xfem
 
@@ -9733,10 +10797,10 @@ DEFI_FICHIER=MACRO(nom="DEFI_FICHIER",op=ops.build_DEFI_FICHIER,sd_prod=DEFIC_pr
 
            INFO          =SIMP(statut='f',typ='I',into=(1,2) ),
            )
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -9762,6 +10826,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op=  41,sd_prod=fiss_xfem,reentrant='n'
 # ------------------------------------------------------------------------------------------------------------------------
 
     MODELE                =SIMP(statut='o',typ=modele_sdaster),
+    MODELE_GRILLE         =SIMP(statut='f',typ=modele_sdaster,max=1,position='global'),
 
 # ------------------------------------------------------------------------------------------------------------------------
 #                       fissure/interface
@@ -9783,7 +10848,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op=  41,sd_prod=fiss_xfem,reentrant='n'
 #                             ENSEMBLE('CHAM_NO_LSN','CHAM_NO_LST'),
 #                             ENSEMBLE('GROUP_MA_FISS','GROUP_MA_FOND')),
 #                                ),
-#
+# 
 #       b_interface           =BLOC(condition = "TYPE_DISCONTINUITE == 'INTERFACE' ",fr="Regles pour les interfaces",
 #                 regles    =(PRESENT_ABSENT('FONC_LN','FONC_LT'),
 #                             PRESENT_ABSENT('CHAM_NO_LSN','CHAM_NO_LST'),
@@ -9840,6 +10905,26 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op=  41,sd_prod=fiss_xfem,reentrant='n'
            VECT_Y         =SIMP(statut='o',typ='R',min=3,max=3),),
                             ),
 
+# ------------------------------------------------------------------------------------------------------------------------
+#                       grille (pour Homard)
+# ------------------------------------------------------------------------------------------------------------------------
+
+    DEFI_FISS_GRILLE       =FACT(statut='f',max=1,
+
+      b_fissure            =BLOC(condition="MODELE_GRILLE == None",
+           FISSURE         =SIMP(statut='f',typ=fiss_xfem,max=1),
+                                ),
+
+      b_levelset_grille    =BLOC(condition="MODELE_GRILLE != None" ,
+           CHAM_NO_LSN_GRILLE  =SIMP(statut='o',typ=cham_no_sdaster,max=1),
+           CHAM_NO_LST_GRILLE  =SIMP(statut='o',typ=cham_no_sdaster,max=1),
+           CHAM_NO_GRLSN_GRILLE=SIMP(statut='o',typ=cham_no_sdaster,max=1),
+           CHAM_NO_GRLST_GRILLE=SIMP(statut='o',typ=cham_no_sdaster,max=1),
+                                 ),
+                                 ),
+
+                           
+
 # ------------------------------------------------------------------------------------------------------------------------
 #                       partie du maillage potentiellement enrichie
 # ------------------------------------------------------------------------------------------------------------------------
@@ -9847,7 +10932,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op=  41,sd_prod=fiss_xfem,reentrant='n'
     GROUP_MA_ENRI         =SIMP(statut='f',typ=grma,max=01),
 
 # ------------------------------------------------------------------------------------------------------------------------
-#                       types d'enrichissement
+#                       types d'enrichissement 
 # ------------------------------------------------------------------------------------------------------------------------
 
     b_enri_inte           =BLOC(condition = "TYPE_DISCONTINUITE == 'INTERFACE' ",
@@ -9869,7 +10954,7 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op=  41,sd_prod=fiss_xfem,reentrant='n'
            NB_COUCHES     =SIMP(statut='f',typ='I',defaut=4,val_min=1),
 
                                ),
-                             ),
+                             ),                        
                           ),
 
 # ------------------------------------------------------------------------------------------------------------------------
@@ -9887,6 +10972,16 @@ DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op=  41,sd_prod=fiss_xfem,reentrant='n'
                              ),
 
 # ------------------------------------------------------------------------------------------------------------------------
+#                       branchement
+# ------------------------------------------------------------------------------------------------------------------------
+
+    b_jonction            =BLOC(condition = "MODELE_GRILLE == None ",
+        JONCTION              =FACT(statut='f',max=1,
+          FISSURE             =SIMP(statut='o',typ=fiss_xfem,min=1,max='**',),
+          POINT               =SIMP(statut='o',typ='R',max=3,),
+                                   ),
+                               ),
+# ------------------------------------------------------------------------------------------------------------------------
 #                       info
 # ------------------------------------------------------------------------------------------------------------------------
 
@@ -10175,10 +11270,10 @@ DEFI_FONCTION=OPER(nom="DEFI_FONCTION",op=3,sd_prod=defi_fonction_prod
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -10236,7 +11331,7 @@ DEFI_FOND_FISS=OPER(nom="DEFI_FOND_FISS",op=55,sd_prod=fond_fiss,reentrant='n',
              NOEUD_ORIG      =SIMP(statut='f',typ=no,),
              GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
              MAILLE_ORIG     =SIMP(statut='f',typ=ma,),
-             GROUP_MA_ORIG   =SIMP(statut='f',typ=ma,),
+             GROUP_MA_ORIG   =SIMP(statut='f',typ=grma,),
            ),
            FOND_INF       =FACT(statut='f',
              GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
@@ -10328,10 +11423,10 @@ DEFI_GEOM_FIBRE=OPER(nom="DEFI_GEOM_FIBRE",op=  119, sd_prod=gfibre_sdaster,
 
 
 ) ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 11/01/2011   AUTEUR SFAYOLLE S.FAYOLLE 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -10348,69 +11443,134 @@ DEFI_GEOM_FIBRE=OPER(nom="DEFI_GEOM_FIBRE",op=  119, sd_prod=gfibre_sdaster,
 # ======================================================================
 # RESPONSABLE SFAYOLLE S.FAYOLLE
 DEFI_GLRC=OPER(nom="DEFI_GLRC",op=57,sd_prod=mater_sdaster,reentrant='f',
-            UIinfo={"groupes":("Modélisation",)},
-                    fr="Determiner les caracteristiques du beton arme homogeneisees a partir des proprietes du beton et de  "
-                        +" plusieurs types d'armature",
-         reuse = SIMP(statut='f',typ=mater_sdaster),
-         BETON          =FACT(statut='o',max=1,
-           MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
-           EPAIS           =SIMP(statut='o',typ='R',val_min=0.E+0 ),
-           GAMMA           =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
-           QP1             =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
-           QP2             =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
-
-           C1N1            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C1N2            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C1N3            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C2N1            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C2N2            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C2N3            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C1M1            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C1M2            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C1M3            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C2M1            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C2M2            =SIMP(statut='o',typ='R',val_min=0.E+0),
-           C2M3            =SIMP(statut='o',typ='R',val_min=0.E+0),
-
-           OMT             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
-           EAT             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
-           BT1             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
-           BT2             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
-
-           MP1X            =SIMP(statut='f',typ=('R',listr8_sdaster)),
-           MP2X            =SIMP(statut='f',typ=('R',listr8_sdaster)),
-           MP1Y            =SIMP(statut='f',typ=('R',listr8_sdaster)),
-           MP2Y            =SIMP(statut='f',typ=('R',listr8_sdaster)),
-         ),
-         NAPPE     =FACT(statut='o',max=10,
-           MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
-           OMX             =SIMP(statut='o',typ='R',val_min=0.E+0),
-           OMY             =SIMP(statut='o',typ='R',val_min=0.E+0),
-           RX              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
-           RY              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
-         ),
-         CABLE_PREC   =FACT(statut='f',max=1,
-           MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
-           OMX             =SIMP(statut='o',typ='R',val_min=0.E+0),
-           OMY             =SIMP(statut='o',typ='R',val_min=0.E+0),
-           RX              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
-           RY              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
-           PREX            =SIMP(statut='o',typ='R'),
-           PREY            =SIMP(statut='o',typ='R'),
-         ),
-         LINER           =FACT(statut='f',max=10,
-           MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
-           OML             =SIMP(statut='o',typ='R',val_min=0.E+0),
-           RLR             =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
-         ),
-         IMPRESSION      =FACT(statut='f',
-           UNITE           =SIMP(statut='f',typ='I',defaut=8),
+               UIinfo={"groupes":("Modélisation",)},
+               fr="Déterminer les caractéristiques homogenéisées du béton armé à partir des propriétés du béton et des  "
+                        +" armatures",
+               reuse = SIMP(statut='f',typ=mater_sdaster),
+               RELATION = SIMP(statut='o',typ='TXM',defaut="GLRC_DAMAGE",
+                          into=("GLRC_DM","GLRC_DAMAGE"),),
+
+               b_glrc_dm=BLOC(condition = "RELATION == 'GLRC_DM'",
+                              fr="Paramètres de la loi GLRC_DM",
+                              BETON = FACT(statut='o',max=1,
+                                MATER = SIMP(statut='o',typ=(mater_sdaster),),
+                                EPAIS = SIMP(statut='o',typ='R',val_min=0.E+0 ),),
+                              NAPPE = FACT(statut='o',max=1,
+                                MATER = SIMP(statut='o',typ=(mater_sdaster),),
+                                OMY   = SIMP(statut='o',typ='R',val_min=0.E+0,),
+                                OMX   = SIMP(statut='o',typ='R',val_min=0.E+0,),
+                                RY    = SIMP(statut='o',typ='R',val_min=-1.0E+0,val_max=1.0E+0,),
+                                RX    = SIMP(statut='o',typ='R',val_min=-1.0E+0,val_max=1.0E+0),),
+                              RHO = SIMP(statut='f',typ='R',val_min=0.E+0,),
+                              AMOR_ALPHA = SIMP(statut='f',typ='R',val_min=0.E+0,),
+                              AMOR_BETA = SIMP(statut='f',typ='R',val_min=0.E+0,),
+                              COMPR = SIMP(statut='o',typ='TXM',defaut="GAMMA",
+                                           into=("GAMMA","SEUIL")),
+                   b_gamma=BLOC(condition = "COMPR == 'GAMMA'",
+                                fr="Paramètre d'endommagement en compression ",
+                                GC = SIMP(statut='o',typ='R',defaut=1.0E+0,val_min=0.0E+0, val_max=1.0E+0),),
+                   b_seuil=BLOC(condition = "COMPR == 'SEUIL'",
+                                fr="Seuil d'endommagement en compression ",
+                                SYC = SIMP(statut='o',typ='R'),),
+                   PENTE = SIMP(statut='o',typ='TXM',defaut="RIGI_ACIER",
+                                into=("PLAS_ACIER","UTIL","RIGI_ACIER")),
+                   b_util = BLOC(condition = "PENTE == 'UTIL'",
+                                 fr="Valeur de la déformation maximale de l'élément",
+                                  EPSI_MEMB = SIMP(statut='o',typ='R',defaut=0.E+0),
+                                  EPSI_FLEX = SIMP(statut='o',typ='R',defaut=0.E+0),),
+                   CISAIL = SIMP(statut='o',typ='TXM',defaut="NON",
+                                 into=("OUI","NON"),),
+                   METHODE_ENDO = SIMP(statut='o',typ='TXM',defaut="ENDO_INTER",
+                                  into=("ENDO_NAISS","ENDO_LIM","ENDO_INTER"),),
+                   INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2),),
+                           ),
+           b_glrc_damage=BLOC(condition = "RELATION == 'GLRC_DAMAGE'",
+                            fr="Paramètres de la loi GLRC_DAMAGE",
+                   BETON            =FACT(statut='o',max=1,
+                     MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
+                     EPAIS           =SIMP(statut='o',typ='R',val_min=0.E+0 ),
+                     GAMMA           =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
+                     QP1             =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
+                     QP2             =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
+
+                     C1N1            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C1N2            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C1N3            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C2N1            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C2N2            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C2N3            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C1M1            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C1M2            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C1M3            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C2M1            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C2M2            =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     C2M3            =SIMP(statut='o',typ='R',val_min=0.E+0),
+
+                     OMT             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
+                     EAT             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
+                     BT1             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
+                     BT2             =SIMP(statut='f',typ='R',val_min=0.E+0,defaut=0.0E+0),
+
+                     MP1X            =SIMP(statut='f',typ=('R',listr8_sdaster)),
+                     MP2X            =SIMP(statut='f',typ=('R',listr8_sdaster)),
+                     MP1Y            =SIMP(statut='f',typ=('R',listr8_sdaster)),
+                     MP2Y            =SIMP(statut='f',typ=('R',listr8_sdaster)),
+         ),
+                   NAPPE     =FACT(statut='o',max=10,
+                     MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
+                     OMX             =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     OMY             =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     RX              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
+                     RY              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
+         ),
+                   CABLE_PREC   =FACT(statut='f',max=1,
+                     MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
+                     OMX             =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     OMY             =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     RX              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
+                     RY              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
+                     PREX            =SIMP(statut='o',typ='R'),
+                     PREY            =SIMP(statut='o',typ='R'),
+         ),
+                   LINER           =FACT(statut='f',max=10,
+                     MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
+                     OML             =SIMP(statut='o',typ='R',val_min=0.E+0),
+                     RLR             =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
+         ),
+                   INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2),),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GENIAUT S.GENIAUT
+DEFI_GRILLE=OPER(nom="DEFI_GRILLE",op=82,sd_prod=grille_sdaster,reentrant='n',
+                UIinfo={"groupes":("Modélisation",)},
+                fr="Définition d'une grille",
+    
+    MAILLAGE       = SIMP(statut='o',typ=maillage_sdaster),
+
+    INFO           = SIMP(statut='f',typ='I',defaut= 0,into=(0,1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 01/03/2011   AUTEUR GENIAUT S.GENIAUT 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -10455,7 +11615,7 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod,
             TYPE_MAILLE     =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","1D","2D","3D"),max=1 ),
 
             OPTION         =SIMP(statut='f',typ='TXM',into=("FACE_NORMALE","SPHERE","CYLINDRE",
-                                                              "BANDE","APPUI_LACHE","APPUI") ),
+                                                              "BANDE","APPUI_LACHE","APPUI","FISS_XFEM") ),
                 b_group_ma      =BLOC(condition = "GROUP_MA != None",
                   regles=(EXCLUS('POSITION','NUME_INIT'),),
                   NUME_INIT       =SIMP(statut='f',typ='I'),
@@ -10515,12 +11675,17 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod,
                   GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
                   TYPE_APPUI      =SIMP(statut='o',typ='TXM',max=1, into=('AU_MOINS_UN','TOUT','SOMMET','MAJORITE')),
                 ),
+                b_fiss_xfem       =BLOC(condition = "OPTION == 'FISS_XFEM'",
+                  TYPE_GROUP      =SIMP(statut='o',typ='TXM',max=1,defaut='XFEM',
+                                          into=('HEAVISIDE','CRACKTIP','MIXTE','FISSUREE','XFEM',),),
+                  FISSURE         =SIMP(statut='o',typ=fiss_xfem,min=1,max='**'),
+                ),
          ),
 
 
          CREA_GROUP_NO   =FACT(statut='f',max='**',
            OPTION          =SIMP(statut='f',typ='TXM',into=("ENV_SPHERE","ENV_CYLINDRE","PLAN",
-                                               "SEGM_DROI_ORDO","NOEUD_ORDO","TUNNEL","INCLUSION") ),
+                                               "SEGM_DROI_ORDO","NOEUD_ORDO","TUNNEL","INCLUSION","FISS_XFEM") ),
 
            b_option =BLOC(condition = "OPTION == None" ,
                           regles=(UN_PARMI('TOUT_GROUP_MA','GROUP_MA','GROUP_NO','NOEUD',
@@ -10632,7 +11797,12 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod,
              GROUP_MA_INCL   =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
              MAILLAGE_INCL   =SIMP(statut='f',typ=maillage_sdaster),
            ),
-         ),
+           b_fiss_xfem            =BLOC(condition = "OPTION == 'FISS_XFEM'",
+                  NOM             =SIMP(statut='o',typ=geom),
+                  TYPE_GROUP      =SIMP(statut='o',typ='TXM',max=1,into=('HEAVISIDE','CRACKTIP','MIXTE','XFEM',)),
+                  FISSURE         =SIMP(statut='o',typ=fiss_xfem,min=1,max='**'),
+           ),
+          ),
          ALARME          =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
          INFO            =SIMP(statut='f',typ='I',into=( 1 , 2 ) ),
 )  ;
@@ -10654,45 +11824,6 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod,
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
-# RESPONSABLE CORUS M.CORUS
-
-DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op=  98,sd_prod=interf_dyna_clas,
-                      reentrant='n',
-            UIinfo={"groupes":("Matrices et vecteurs","Dynamique",)},
-            fr="Définir les interfaces d'une structure et leur affecter un type",
-         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster ),
-         INTERFACE       =FACT(statut='o',max='**',
-           regles=(ENSEMBLE('NOM','TYPE'),
-#  erreur doc U sur la condition qui suit
-                   UN_PARMI('NOEUD','GROUP_NO'),),
-           NOM             =SIMP(statut='f',typ='TXM' ),
-           TYPE            =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ),
-           NOEUD           =SIMP(statut='f',typ=no,max='**'),
-           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
-#           DDL_ACTIF       =SIMP(statut='f',typ='TXM',max='**'),
-           MASQUE          =SIMP(statut='f',typ='TXM',max='**'),
-         ),
-         FREQ            =SIMP(statut='f',typ='R',defaut= 1.),
-         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
-)  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
-#            CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
 # RESPONSABLE ZENTNER I.ZENTNER
 from Macro.defi_inte_spec_ops import defi_inte_spec_ops
 
@@ -10757,23 +11888,62 @@ DEFI_INTE_SPEC=MACRO(nom="DEFI_INTE_SPEC",op= defi_inte_spec_ops,sd_prod=table_f
 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
-# RESPONSABLE COURTOIS M.COURTOIS
-DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster,
-                    fr="Définir une liste d'entiers strictement croissante",
-                    reentrant='n',
-            UIinfo={"groupes":("Fonctions",)},
-
-         OPERATION    =SIMP(statut='o',typ='TXM',defaut='DEFI',into=('DEFI','NUME_ORDRE',)),
-
+# RESPONSABLE CORUS M.CORUS
 
-         # définition d'une liste d'entiers
-         #----------------------------------
-         b_defi       =BLOC(condition = "OPERATION == 'DEFI'",
-             regles=(UN_PARMI('VALE','DEBUT'),
-                     EXCLUS('VALE','INTERVALLE'),),
-             VALE            =SIMP(statut='f',typ='I',max='**'),
-             DEBUT           =SIMP(statut='f',typ='I'),
-             INTERVALLE      =FACT(statut='f',max='**',
+DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op=  98,sd_prod=interf_dyna_clas,
+                      reentrant='n',
+            UIinfo={"groupes":("Matrices et vecteurs","Dynamique",)},
+            fr="Définir les interfaces d'une structure et leur affecter un type",
+         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster ),
+         INTERFACE       =FACT(statut='o',max='**',
+           regles=(ENSEMBLE('NOM','TYPE'),
+#  erreur doc U sur la condition qui suit
+                   UN_PARMI('NOEUD','GROUP_NO'),),
+           NOM             =SIMP(statut='f',typ='TXM' ),
+           TYPE            =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ),
+           NOEUD           =SIMP(statut='f',typ=no,max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+#           DDL_ACTIF       =SIMP(statut='f',typ='TXM',max='**'),
+           MASQUE          =SIMP(statut='f',typ='TXM',max='**'),
+         ),
+         FREQ            =SIMP(statut='f',typ='R',defaut= 1.),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster,
+                    fr="Définir une liste d'entiers strictement croissante",
+                    reentrant='n',
+            UIinfo={"groupes":("Fonctions",)},
+
+         OPERATION    =SIMP(statut='o',typ='TXM',defaut='DEFI',into=('DEFI','NUME_ORDRE',)),
+
+
+         # définition d'une liste d'entiers
+         #----------------------------------
+         b_defi       =BLOC(condition = "OPERATION == 'DEFI'",
+             regles=(UN_PARMI('VALE','DEBUT'),
+                     EXCLUS('VALE','INTERVALLE'),),
+             VALE            =SIMP(statut='f',typ='I',max='**'),
+             DEBUT           =SIMP(statut='f',typ='I'),
+             INTERVALLE      =FACT(statut='f',max='**',
                  regles=(UN_PARMI('NOMBRE','PAS'),),
                  JUSQU_A         =SIMP(statut='o',typ='I'),
                  NOMBRE          =SIMP(statut='f',typ='I',val_min=1,),
@@ -10794,10 +11964,10 @@ DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster,
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 23/11/2010   AUTEUR COURTOIS M.COURTOIS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR GENIAUT S.GENIAUT 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -10814,6 +11984,7 @@ DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster,
 # ======================================================================
 # RESPONSABLE GENIAUT S.GENIAUT
 
+
 # bloc utilisé deux fois à l'identique
 bloc_unif = BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
                 SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,max=1,
@@ -10835,7 +12006,6 @@ bloc_unif = BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
                 ),
             ) # fin si UNIFORME
 
-
 DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op=  28,sd_prod=list_inst,reentrant='n',
             UIinfo={"groupes":("Fonctions",)},
                fr="Définition de la gestion de la liste d'instants",
@@ -10852,27 +12022,21 @@ DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op=  28,sd_prod=list_inst,reentrant='n'
            LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
                                   ),
 
-         b_auto              =BLOC(condition = "METHODE == 'AUTO' ",fr="a compléter",
+         b_auto              =BLOC(condition = "(METHODE == 'AUTO') ",fr="Gestion automatique de la liste d'instants",
            LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
-           PAS_MINI    =SIMP(statut='o',typ='R',val_min=0.0,max=1),
+           PAS_MINI    =SIMP(statut='f',typ='R',val_min=1.e-12,max=1),
            PAS_MAXI    =SIMP(statut='f',typ='R',max=1),
-           NB_PAS_MAXI =SIMP(statut='f',typ='I',max=1),
+           NB_PAS_MAXI =SIMP(statut='f',typ='I',val_max=1000000,max=1,defaut=1000000),
                                   ),
 
-#          b_cfl               =BLOC(condition = "METHODE  == 'CFL' ",fr="Liste d'instants construite sur condition CFL",
-#            COEF            =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut=0.5),
-#            MODELE          =SIMP(statut='o',typ=modele_sdaster),
-#                                   ),
-
-                               ),
-
+                      ),
 # ----------------------------------------------------------------------------------------------------------------------------------
 # mot-cle pour le comportement en cas d'echec (on doit recommencer le meme instant)
 # ----------------------------------------------------------------------------------------------------------------------------------
 
     ECHEC  =FACT(statut='d',max='**',
 
-        EVENEMENT     =SIMP(statut='f',typ='TXM',into=("ERREUR","DELTA_GRANDEUR"),defaut="ERREUR",max=1 ),
+        EVENEMENT     =SIMP(statut='f',typ='TXM',into=("ERREUR","DELTA_GRANDEUR","DIVE_ITER_PILO"),defaut="ERREUR",max=1 ),
 
         b_edelta           =BLOC(condition = "EVENEMENT == 'DELTA_GRANDEUR' ",fr=" ",
 #      event-driven : on sous-decoupe si l'increment d'une composante d'un champ depasse le seuil
@@ -10961,7 +12125,9 @@ DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op=  28,sd_prod=list_inst,reentrant='n'
 #     2) parametre du mode de calcul de dt+
 #     ----------------------------------------
 
-      MODE_CALCUL_TPLUS =SIMP(statut='f',typ='TXM',into=("FIXE","DELTA_GRANDEUR","ITER_NEWTON","FORMULE"),defaut='FIXE',max=1 ),
+      MODE_CALCUL_TPLUS =SIMP(statut='f',typ='TXM',into=("FIXE","DELTA_GRANDEUR","ITER_NEWTON","FORMULE","IMPLEX"),defaut='FIXE',
+                              max=1),
+
          b_mfixe           =BLOC(condition = "MODE_CALCUL_TPLUS == 'FIXE' ",fr="fixe",
 #      dans le cas FIXE :(deltaT+) = (deltaT-)x(1+PCENT_AUGM/100)
       PCENT_AUGM                 =SIMP(statut='f',typ='R',defaut=100.,val_min=-100.,max=1),
@@ -11019,6 +12185,23 @@ DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op=  28,sd_prod=list_inst,reentrant='n'
 
              ),
       ),
+#  b_adaplex  =   BLOC(condition = "METHODE == 'AUTO' and MODE_CALCUL_TPLUS == 'IMPLEX'",
+#
+#    ADAPTATION  =FACT(statut='d',max='**',
+#
+#     1 parametres de l'evenement declencheur
+#     ----------------------------------------
+#
+#      EVENEMENT       =SIMP(statut='f',typ='TXM',into=("TOUT_INST",),defaut="TOUT_INST",max=1 ),
+#
+#                           
+#     2 parametre du mode de calcul de dt+
+#     ----------------------------------------
+#
+#     MODE_CALCUL_TPLUS =SIMP(statut='f',typ='TXM',into=("IMPLEX",),defaut='IMPLEX',max=1,position='global' ),
+#
+#             ),
+#     ),
 
 # ----------------------------------------------------------------------------------------------------------------------------------
 
@@ -11142,10 +12325,10 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op=  88,sd_prod=maillage_sdaster,
            GROUP_NO_FIN    =SIMP(statut='f',typ=grno),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 23/02/2011   AUTEUR LAVERNE J.LAVERNE 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -11184,6 +12367,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
                EXCLUS('META_LEMA_ANI','META_LEMA_ANI_FO'),
                EXCLUS('VMIS_POUTRE','VMIS_POUTRE_FO'),
                EXCLUS('VENDOCHAB','VENDOCHAB_FO'),
+               EXCLUS('VISC_ENDO','VISC_ENDO_FO'),
                PRESENT_PRESENT('BPEL_ACIER','ELAS'),
                EXCLUS('RCCM','RCCM_FO'),
                EXCLUS('WEIBULL','WEIBULL_FO'),
@@ -11904,15 +13088,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
                      PRESENT_PRESENT('ANG1_FO','ANG2_FO','PEN1_FO','PEN2_FO','PEN3_FO',),
                                      ),
            ),
-           NADAI_B         =FACT(statut='f',
-             F_C             =SIMP(statut='o',typ='R',val_min=0.E+0),
-             F_T             =SIMP(statut='o',typ='R',val_min=0.E+0),
-             CRIT_E_C        =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
-             EPSP_P_C        =SIMP(statut='o',typ='R',val_min=0.E+0),
-             EPSP_R_C        =SIMP(statut='o',typ='R',val_min=0.E+0),
-             EPSI_R_T        =SIMP(statut='o',typ='R',val_min=0.E+0),
-             FAC_T_C         =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
-           ),
            BETON_DOUBLE_DP =FACT(statut='f',
              F_C             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
              F_T             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -11970,27 +13145,31 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              BDN             =SIMP(statut='o',typ='R',defaut= 1.E+0,val_min=1.E-1),
            ),
           VENDOCHAB       =FACT(statut='f',
-             S               =SIMP(statut='o',typ='R',defaut= 0.E+0),
+             SY              =SIMP(statut='o',typ='R',defaut= 0.E+0),
              ALPHA_D         =SIMP(statut='o',typ='R',defaut= 0.E+0),
              BETA_D          =SIMP(statut='o',typ='R',defaut= 0.E+0),
-             N               =SIMP(statut='o',typ='R'),
-             UN_SUR_M        =SIMP(statut='o',typ='R',defaut= 0.E+0),
-             UN_SUR_K        =SIMP(statut='o',typ='R'),
              R_D             =SIMP(statut='o',typ='R'),
              A_D             =SIMP(statut='o',typ='R'),
              K_D             =SIMP(statut='o',typ='R'),
            ),
            VENDOCHAB_FO    =FACT(statut='f',
-             S               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SY              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
              ALPHA_D         =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
              BETA_D          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
-             N               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
-             UN_SUR_M        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
-             UN_SUR_K        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
              R_D             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
              A_D             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
              K_D             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
            ),
+           VISC_ENDO      =FACT(statut='f',
+             SY              =SIMP(statut='o',typ='R',defaut= 0.E+0),
+             R_D             =SIMP(statut='o',typ='R'),
+             A_D             =SIMP(statut='o',typ='R'),
+           ),
+           VISC_ENDO_FO   =FACT(statut='f',
+             SY              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R_D             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_D             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
            PINTO_MENEGOTTO =FACT(statut='f',
              SY              =SIMP(statut='o',typ='R'),
              EPSI_ULTM       =SIMP(statut='o',typ='R'),
@@ -12604,7 +13783,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
                                            PRE2          = SIMP(statut='f',typ='R'),
                                            PRES_VAPE     = SIMP(statut='f',typ='R'),
                                            DEGR_SATU     = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO     = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -12659,10 +13837,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
                                            PERM_GAZ        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           SIGMA_T         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_SIGMA_T       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           PERM_G_INTR     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           CHAL_VAPO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -12738,7 +13912,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # ---------------------------------------------------------------------------------
                                            PRES_VAPE        = SIMP(statut='f',typ='R'),
                                            DEGR_SATU        = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -12808,10 +13981,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES INUTILES   ----------------------------------------
 # ---------------------------------------------------------------------------------
                                            EMMAG           = SIMP(statut='f',typ='R'),
-                                           SIGMA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_SIGMA_T        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           PERM_G_INTR      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           CHAL_VAPO        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -12890,7 +14059,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
                                            PRE2             = SIMP(statut='f',typ='R'),
                                            PRES_VAPE        = SIMP(statut='f',typ='R'),
                                            DEGR_SATU        = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -12942,10 +14110,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
                                            PERM_GAZ        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           SIGMA_T         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_SIGMA_T       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           PERM_G_INTR     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           CHAL_VAPO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -13022,7 +14186,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
                                            PRE2             = SIMP(statut='f',typ='R'),
                                            PRES_VAPE        = SIMP(statut='f',typ='R'),
                                            DEGR_SATU        = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -13074,10 +14237,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              PERM_GAZ        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
              D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
              D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-             SIGMA_T         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-             D_SIGMA_T       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-             PERM_G_INTR     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-             CHAL_VAPO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
              FICKV_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
              FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
              FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -13154,7 +14313,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES INUTILES   ----------------------------------------
 # ---------------------------------------------------------------------------------
                                            DEGR_SATU        = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -13224,10 +14382,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES FACULTATIVES   ------------------------------------
 # ---------------------------------------------------------------------------------
                                            EMMAG            = SIMP(statut='f',typ='R'),
-                                           SIGMA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_SIGMA_T        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           PERM_G_INTR      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           CHAL_VAPO        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -13258,11 +14412,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # ---------------------------------------------------------------------------------
                                            ALPHA            = SIMP(statut='f',typ='R'),
                                            CP               = SIMP(statut='f',typ='R'),
-                                           LAMB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_LB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           LAMB_T    = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_LB_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           LAMB_CT        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEES CACHEES -------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -13339,7 +14488,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES INUTILES   ----------------------------------------
 # ---------------------------------------------------------------------------------
                                            DEGR_SATU        = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -13409,10 +14557,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES FACULTATIVE   ----------------------------------
 # ---------------------------------------------------------------------------------
                                            EMMAG            = SIMP(statut='f',typ='R'),
-                                           SIGMA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_SIGMA_T        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           PERM_G_INTR      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           CHAL_VAPO        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -13499,7 +14643,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES INUTILES   ----------------------------------------
 # ---------------------------------------------------------------------------------
                                            DEGR_SATU        = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -13569,10 +14712,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES FACULTATIVES   ------------------------------------
 # ---------------------------------------------------------------------------------
                                            EMMAG            = SIMP(statut='f',typ='R'),
-                                           SIGMA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_SIGMA_T        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           PERM_G_INTR      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           CHAL_VAPO        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -13600,11 +14739,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # ---------------------------------------------------------------------------------
                                            ALPHA            = SIMP(statut='f',typ='R'),
                                            CP               = SIMP(statut='f',typ='R'),
-                                           LAMB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_LB_PHI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           LAMB_T    = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_LB_T = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           LAMB_CT        = SIMP(statut='f',typ='R'),
                                              ),
 # =================================================================================
 # --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
@@ -13671,7 +14805,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # ---------------------------------------------------------------------------------
                                            PRE2             = SIMP(statut='f',typ='R'),
                                            DEGR_SATU        = SIMP(statut='f',typ='R'),
-                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
 # ---------------------------------------------------------------------------------
 # -------------------   DONNEE CACHEE ---------------------------------------------
 # ---------------------------------------------------------------------------------
@@ -13739,10 +14872,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
 # -------------------   DONNEES INUTILES   ----------------------------------------
 # ---------------------------------------------------------------------------------
                                            EMMAG            = SIMP(statut='f',typ='R'),
-                                           SIGMA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           D_SIGMA_T        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           PERM_G_INTR      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
-                                           CHAL_VAPO        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PV         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
                                            FICKV_PG         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
@@ -13894,8 +15023,23 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              PENA_ADHERENCE  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
              PENA_CONTACT    =SIMP(statut='f',typ='R',defaut=1.),
            ),
+           RUPT_DUCT       =FACT(statut='f',
+             GC              =SIMP(statut='o',typ='R'),
+             SIGM_C          =SIMP(statut='o',typ='R'),
+             COEF_EXTR       =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=9.99E-1),
+             COEF_PLAS       =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=9.99E-1),
+             PENA_LAGR       =SIMP(statut='f',typ='R',defaut=1.0E2,val_min=1.01E+0),
+             RIGI_GLIS       =SIMP(statut='f',typ='R',defaut=1.0E1),
+           ),
            JOINT_MECA_RUPT  =FACT(statut='f',
-             regles=(EXCLUS('PRES_FLUIDE','PRES_CLAVAGE'),),
+             regles=(EXCLUS('PRES_FLUIDE','PRES_CLAVAGE'),
+                     PRESENT_PRESENT('RHO_FLUIDE','VISC_FLUIDE','OUV_MIN'),
+                     PRESENT_ABSENT('PRES_FLUIDE','RHO_FLUIDE','VISC_FLUIDE','OUV_MIN'),
+                     PRESENT_ABSENT('PRES_CLAVAGE','RHO_FLUIDE','VISC_FLUIDE','OUV_MIN'),
+                     PRESENT_ABSENT('RHO_FLUIDE','PRES_FLUIDE','PRES_CLAVAGE'),
+                     PRESENT_ABSENT('VISC_FLUIDE','PRES_FLUIDE','PRES_CLAVAGE'),
+                     PRESENT_ABSENT('OUV_MIN','PRES_FLUIDE','PRES_CLAVAGE'),
+                     ),
              K_N             =SIMP(statut='o',typ='R',val_min=1.E-12),
              K_T             =SIMP(statut='f',typ='R',val_min=1.E-12),
              SIGM_MAX        =SIMP(statut='o',typ='R',val_min=0.),
@@ -13904,7 +15048,17 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              PENA_CONTACT    =SIMP(statut='f',typ='R',defaut=1.,val_min=1.E-12),
              PRES_FLUIDE     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
              PRES_CLAVAGE    =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RHO_FLUIDE      =SIMP(statut='f',typ='R',val_min=0.),
+             VISC_FLUIDE     =SIMP(statut='f',typ='R',val_min=1.E-20),
+             OUV_MIN         =SIMP(statut='f',typ='R',val_min=1.E-15), 
            ),
+           JOINT_MECA_FROT   =FACT(statut='f',
+             K_N             =SIMP(statut='o',typ='R',val_min=1.E-12),
+             K_T             =SIMP(statut='f',typ='R',val_min=1.E-12),
+             MU              =SIMP(statut='o',typ='R',val_min=1.E-3),             
+             PENA_TANG       =SIMP(statut='f',typ='R',val_min=0.),
+             ADHESION        =SIMP(statut='f',typ='R',defaut=0., val_min=0.),
+           ),           
            RCCM            =FACT(statut='f',
              regles=(ENSEMBLE('A_AMORC','B_AMORC','D_AMORC','R_AMORC'),),
              SY_02           =SIMP(statut='f',typ='R'),
@@ -14054,13 +15208,13 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
            ),
 ####  MONOCRISTAL
 
-           ECOU_VISC1      =FACT(statut='f',
+           MONO_VISC1      =FACT(statut='f',
              TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
              N               =SIMP(statut='o',typ='R'),
              K               =SIMP(statut='o',typ='R'),
              C               =SIMP(statut='o',typ='R'),
            ),
-           ECOU_VISC2      =FACT(statut='f',
+           MONO_VISC2      =FACT(statut='f',
              TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
              N               =SIMP(statut='o',typ='R'),
              K               =SIMP(statut='o',typ='R'),
@@ -14068,7 +15222,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              D               =SIMP(statut='o',typ='R'),
              A               =SIMP(statut='o',typ='R'),
            ),
-           ECOU_VISC3      =FACT(statut='f',
+           MONO_VISC3      =FACT(statut='f',
              TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
              K               =SIMP(statut='o',typ='R',fr="Constante de Boltzmann, en eV/K"),
              TAUMU           =SIMP(statut='o',typ='R',fr="Seuil d ecoulement, en unite de contraintes"),
@@ -14076,31 +15230,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              DELTAV          =SIMP(statut='o',typ='R',fr="Volume d activation"),
              DELTAG0         =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"),
            ),
-           KOCKS_RAUCH      =FACT(statut='f',
-              regles=(UN_PARMI('H','H1'),
-                      PRESENT_PRESENT('H1','H2','H3','H4'),
-                      PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'),
-                      ),
-             TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
-             K               =SIMP(statut='o',typ='R',fr="Constante de Boltzmann, en eV/K"),
-             TAUR            =SIMP(statut='o',typ='R',fr="Contraintes de cisaillement à T=0K, en unite de contraintes"),
-             TAU0            =SIMP(statut='o',typ='R',fr="Contraintes critique initiale de cisaillement, en unite de contraintes"),
-             GAMMA0          =SIMP(statut='o',typ='R',fr="Vitesse d ecoulement initiale"),
-             DELTAG0         =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"),
-             BSD             =SIMP(statut='o',typ='R',fr="fonction de la taille du grain B/D"),
-             GCB             =SIMP(statut='o',typ='R',fr="distance critique d'annihilation GC/B"),
-             KDCS            =SIMP(statut='o',typ='R',fr="Parametre relatif à la direction principale de la dislocation"),
-             P               =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"),
-             Q               =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"),
-             H               =SIMP(statut='f',typ='R'),
-             H1              =SIMP(statut='f',typ='R'),
-             H2              =SIMP(statut='f',typ='R'),
-             H3              =SIMP(statut='f',typ='R'),
-             H4              =SIMP(statut='f',typ='R'),
-             H5              =SIMP(statut='f',typ='R'),
-             H6              =SIMP(statut='f',typ='R'),
-           ),
-           ECRO_ISOT1      =FACT(statut='f',
+           MONO_ISOT1      =FACT(statut='f',
               regles=(UN_PARMI('H','H1'),
                       PRESENT_PRESENT('H1','H2','H3','H4'),
                       PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'),
@@ -14117,7 +15247,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              H5              =SIMP(statut='f',typ='R'),
              H6              =SIMP(statut='f',typ='R'),
            ),
-           ECRO_ISOT2      =FACT(statut='f',
+           MONO_ISOT2      =FACT(statut='f',
               regles=(UN_PARMI('H','H1'),
                       PRESENT_PRESENT('H1','H2','H3','H4'),
                       PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'),
@@ -14136,30 +15266,53 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
              Q2              =SIMP(statut='o',typ='R'),
              B2              =SIMP(statut='o',typ='R'),
            ),
-           ECRO_CINE1      =FACT(statut='f',
+           MONO_CINE1      =FACT(statut='f',
              TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECRO_CINE",),),
              D               =SIMP(statut='o',typ='R'),
            ),
-           ECRO_CINE2      =FACT(statut='f',
+           MONO_CINE2      =FACT(statut='f',
              TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECRO_CINE",),),
              D               =SIMP(statut='o',typ='R'),
              GM              =SIMP(statut='o',typ='R'),
              PM              =SIMP(statut='o',typ='R'),
              C               =SIMP(statut='o',typ='R'),
            ),
-           ECOU_DD_CFC      =FACT(statut='f',
-             TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
+           MONO_DD_KR      =FACT(statut='f',
+              regles=(UN_PARMI('H','H1'),
+                      PRESENT_PRESENT('H1','H2','H3','H4'),
+                      PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'),
+                      ),
+            # TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
+             K               =SIMP(statut='o',typ='R',fr="Constante de Boltzmann, en eV/K"),
+             TAUR            =SIMP(statut='o',typ='R',fr="Contraintes de cisaillement à T=0K, en unite de contraintes"),
+             TAU0            =SIMP(statut='o',typ='R',fr="Contraintes critique initiale de cisaillement, en unite de contraintes"),
+             GAMMA0          =SIMP(statut='o',typ='R',fr="Vitesse d ecoulement initiale"),
+             DELTAG0         =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"),
+             BSD             =SIMP(statut='o',typ='R',fr="fonction de la taille du grain B/D"),
+             GCB             =SIMP(statut='o',typ='R',fr="distance critique d'annihilation GC/B"),
+             KDCS            =SIMP(statut='o',typ='R',fr="Parametre relatif à la direction principale de la dislocation"),
+             P               =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"),
+             Q               =SIMP(statut='o',typ='R',fr="Parametre materiau dépendant de la forme de l'obstacle"),
+             H               =SIMP(statut='f',typ='R'),
+             H1              =SIMP(statut='f',typ='R'),
+             H2              =SIMP(statut='f',typ='R'),
+             H3              =SIMP(statut='f',typ='R'),
+             H4              =SIMP(statut='f',typ='R'),
+             H5              =SIMP(statut='f',typ='R'),
+             H6              =SIMP(statut='f',typ='R'),
+           ),
+           MONO_DD_CFC      =FACT(statut='f',
+             regles=(UN_PARMI('H','H1'),
+                     PRESENT_PRESENT('H1','H2','H3','H4','H5'),
+                     PRESENT_ABSENT('H','H1','H2','H3','H4','H5'),
+                     ),
+             #TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
              GAMMA0          =SIMP(statut='f',typ='R',defaut=0.001,fr="Vitesse d ecoulement initiale en s**-1"),
              TAU_F           =SIMP(statut='o',typ='R',fr="Contraintes , en unite de contraintes ex 20 MPa"),
              A               =SIMP(statut='f',typ='R',defaut=0.13,fr="paramètre A, sans unité"),
              B               =SIMP(statut='f',typ='R',defaut=0.005,fr="paramètre B, sans unité"),
              N               =SIMP(statut='f',typ='R',defaut=200.,fr="paramètre n, sans unité"),
              Y               =SIMP(statut='o',typ='R',fr="paramète Y, en unité de longueur ex 2.5 A"),
-           ),
-           ECRO_DD_CFC      =FACT(statut='f',
-              regles=(PRESENT_PRESENT('H1','H2','H3','H4','H5'),
-                      ),
-             TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECRO_ISOT",),),
              ALPHA           =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, paramètre alpha"),
              BETA            =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre b, en unite de longueur"),
              RHO_REF         =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre rho_ref, en unité de longueur **-2"),
@@ -14172,6 +15325,31 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
            ),
 
 
+           MONO_DD_CC      =FACT(statut='f',
+              regles=(UN_PARMI('H','H1'),
+                      PRESENT_PRESENT('H1','H2','H3','H4','H5','H6'),
+                      PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'),
+                      ),
+             #TYPE_PARA       =SIMP(statut='f',typ='TXM',into=("ECOU_VISC",),),
+             GAMMA0          =SIMP(statut='f',typ='R',defaut=0.001,fr="Vitesse d ecoulement initiale en s**-1"),
+             TAU_F           =SIMP(statut='o',typ='R',fr="Contraintes , en unite de contraintes ex 20 MPa"),
+             A               =SIMP(statut='f',typ='R',defaut=0.13,fr="paramètre A, sans unité"),
+             B               =SIMP(statut='f',typ='R',defaut=0.005,fr="paramètre B, sans unité"),
+             N               =SIMP(statut='f',typ='R',defaut=200.,fr="paramètre n, sans unité"),
+             Y               =SIMP(statut='o',typ='R',fr="paramète Y, en unité de longueur ex 2.5 A"),
+             ALPHA           =SIMP(statut='f',typ='R',defaut=0.35,fr="ecrouissage, paramètre alpha"),
+             BETA            =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre b, en unite de longueur"),
+             RHO_REF         =SIMP(statut='o',typ='R',fr="ecrouissage, paramètre rho_ref, en unité de longueur **-2"),
+             H               =SIMP(statut='f',typ='R'),
+             H1              =SIMP(statut='f',typ='R'),
+             H2              =SIMP(statut='f',typ='R'),
+             H3              =SIMP(statut='f',typ='R'),
+             H4              =SIMP(statut='f',typ='R'),
+             H5              =SIMP(statut='f',typ='R'),
+             H6              =SIMP(statut='f',typ='R'),
+           ),
+
+
 ####  MONOCRISTAL
 
 ### UMAT
@@ -14335,10 +15513,10 @@ DEFI_MODELE_GENE=OPER(nom="DEFI_MODELE_GENE",op= 126,sd_prod=modele_gene,
          ),
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 22/03/2011   AUTEUR COURTOIS M.COURTOIS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -14367,14 +15545,16 @@ DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op=4,sd_prod=nappe_sdaster,
          NOM_PARA_FONC   =SIMP(statut='f',typ='TXM',into=C_PARA_FONCTION() ),
          DEFI_FONCTION   =FACT(statut='f',max='**',
            VALE            =SIMP(statut='o',typ='R',max='**'),
-           INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ),
+           INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
+                                 fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction."),
            PROL_DROITE     =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
            PROL_GAUCHE     =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
          ),
-         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ),
+         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
+                               fr="Type d'interpolation pour le paramètre de la nappe"),
          PROL_DROITE     =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
          PROL_GAUCHE     =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
-         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1, 2) ),
          VERIF           =SIMP(statut='f',typ='TXM',into=("CROISSANT",) ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
@@ -14779,10 +15959,10 @@ DEFI_SPEC_TURB=OPER(nom="DEFI_SPEC_TURB",op= 145,sd_prod=spectre_sdaster,
          ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 25/01/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -14844,7 +16024,8 @@ DEFI_SQUELETTE=OPER(nom="DEFI_SQUELETTE",op= 110,sd_prod=squelette,
          TRANS           =SIMP(statut='f',typ='R',min=3,max=3),
          ANGL_NAUT       =SIMP(statut='f',typ='R',min=3,max=3),
          SOUS_STRUC      =FACT(statut='f',max='**',
-           NOM             =SIMP(statut='f',typ='TXM' ),
+           regles=(UN_PARMI('TOUT','MAILLE','GROUP_MA'),),
+           NOM             =SIMP(statut='o',typ='TXM' ),
            MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
            GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
            TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
@@ -15070,10 +16251,10 @@ DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_fonction,
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -15089,45 +16270,68 @@ DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_fonction,
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 # RESPONSABLE ZENTNER I.ZENTNER
+
 from Macro.dyna_iss_vari_ops import dyna_iss_vari_ops
 #
-DYNA_ISS_VARI=MACRO(nom="DYNA_ISS_VARI",op=dyna_iss_vari_ops ,sd_prod=table_fonction,
+def dyna_iss_vari_prod(self, FONC_SIGNAL,**args):
+   if FONC_SIGNAL !=None : 
+       return tran_gene
+   else:  
+      return  table_fonction
+   raise AsException("type de concept resultat non prevu")
+#
+    
+      
+DYNA_ISS_VARI=MACRO(nom="DYNA_ISS_VARI",op=dyna_iss_vari_ops ,   sd_prod=dyna_iss_vari_prod,
                     fr="Calcul du spectre de réponse ou de la reponse temporelle sismique incoherente par decomposition spectrale",
                     reentrant='n',
-                    UIinfo={"groupes":("Outils-métier","Dynamique",)},
-         NOM_CMP         =SIMP(statut='o',typ='TXM',into=("DX","DY","DZ") ),
-         PRECISION       =SIMP(statut='f',typ='R',defaut=0.999 ),
+                    UIinfo={"groupes":("Outils métier",)},
+         regles=(UN_PARMI('FONC_SIGNAL','NB_FREQ'),),                                    
+         FONC_SIGNAL     =SIMP(statut='f',typ=(fonction_sdaster) ),
+         NB_FREQ       =SIMP(statut='f',typ='I' ),
+         NOM_CMP       =SIMP(statut='o',typ='TXM',into=("DX","DY","DZ") ),
+         PRECISION     =SIMP(statut='f',typ='R',defaut=0.999 ),
          INTERF           =FACT(statut='o',
-            GROUP_NO_INTERF =SIMP(statut='o',typ=grma ,max='**'),
-            MODE_INTERF  =SIMP(statut='o',typ='TXM',into=("CORP_RIGI","TOUT")),
-         ),
+              GROUP_NO_INTERF =SIMP(statut='o',typ=grno ,max='**'), 
+              MODE_INTERF  =SIMP(statut='o',typ='TXM',into=("CORP_RIGI","TOUT")),
+         ),      
          MATR_COHE       =FACT(statut='o',
-            VITE_ONDE       =SIMP(statut='o',typ='R'),
-            PARA_ALPHA     =SIMP(statut='f',typ='R',defaut=0.5),
+              VITE_ONDE       =SIMP(statut='o',typ='R'),
+              PARA_ALPHA     =SIMP(statut='f',typ='R',defaut=0.5),           
          ),
-#        FONC_MULT     =SIMP(statut='f',typ='R' ),
-         FREQ_INIT       =SIMP(statut='o',typ='R' ),
-         NB_FREQ       =SIMP(statut='o',typ='I' ),
-         PAS             =SIMP(statut='o',typ='R' ),
-#        LIST_FREQ        =SIMP(statut='o',typ='liste' ),
+#        LIST_FREQ        =SIMP(statut='o',typ='liste' ),  
          UNITE_RESU_FORC = SIMP(statut='f',typ='I',defaut=33),
-         UNITE_RESU_IMPE  = SIMP(statut='f',typ='I',defaut=32),
+         UNITE_RESU_IMPE  = SIMP(statut='f',typ='I',defaut=32), 
          TYPE             = SIMP(statut='f',typ='TXM',into=("BINAIRE","ASCII"), defaut="ASCII"),
+#         NOM_CHAM        =SIMP(statut='f',typ='TXM',into=("DEPL","VITE","ACCE") , validators=NoRepeat(),max=3,defaut="DEPL" ),
 #
          MATR_GENE         = FACT(statut='o',
             MATR_MASS     = SIMP(statut='o',typ=(matr_asse_gene_r ) ),
             MATR_RIGI     = SIMP(statut='o',typ=(matr_asse_gene_r,matr_asse_gene_c ) ),
-            MATR_AMOR     = SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c ) ),
-         ),
-#
-         OPTION        = SIMP(statut='f',typ='TXM',into=("TOUT","DIAG"),defaut="TOUT"),
-#
-         INFO           =SIMP(statut='f',typ='I' ,defaut=1,into=( 1 , 2)),
+            MATR_AMOR     = SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c ) ), 
+         ),         
+#         
+        INFO           =SIMP(statut='f',typ='I' ,defaut=1,into=( 1 , 2)),
+#         
+         b_type_trans = BLOC(condition="FONC_SIGNAL !=None",                               
+                        FREQ_MAX       =SIMP(statut='f',typ='R' ),
+                        FREQ_PAS       =SIMP(statut='f',typ='R' ),    
+                        regles=( ENSEMBLE('FREQ_MAX','FREQ_PAS'),  )                                  
+                        
+                        ),
+                              
+        b_type_spec = BLOC(condition="NB_FREQ != None",          
+                       FREQ_INIT       =SIMP(statut='o',typ='R' ),
+                       FREQ_PAS     =SIMP(statut='o',typ='R' ),    
+                       OPTION        = SIMP(statut='f',typ='TXM',into=("TOUT","DIAG"),defaut="TOUT"),
+                       ),
+         
+         
          )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 18/01/2011   AUTEUR BOITEAU O.BOITEAU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -15217,11 +16421,12 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op=  60,sd_prod=dyna_line_harm_prod,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
            ),
           ),
          ),
@@ -15247,11 +16452,12 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op=  60,sd_prod=dyna_line_harm_prod,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),         
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
-             OUT_OF_CORE      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
           ),
          ),
@@ -15264,10 +16470,10 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op=  60,sd_prod=dyna_line_harm_prod,
 # Rajouter test icompatibilite vect_asse et sensibilite
 # Peut-on aussi rajouter ici le test d incompatibilite charge complexe - derivation
 #  presents dans le Fortran
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -15384,7 +16590,7 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op=  48,sd_prod=dyna_trans,
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -15393,12 +16599,13 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op=  48,sd_prod=dyna_trans,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              PARALLELISME    =SIMP(statut='f',typ='TXM',defaut="CENTRALISE",into=("CENTRALISE","CENTRALISE")),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
 
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
@@ -15410,7 +16617,7 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op=  48,sd_prod=dyna_trans,
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -15458,10 +16665,10 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op=  48,sd_prod=dyna_trans,
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
          INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -15533,23 +16740,14 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f',
            MASS_GENE       =SIMP(statut='f',typ=matr_asse_gene_r),
            RIGI_GENE       =SIMP(statut='f',typ=matr_asse_gene_r),
            AMOR_GENE       =SIMP(statut='f',typ=matr_asse_gene_r),
+           DEPL_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene),
+           VITE_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene),
+           ACCE_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene),           
          ),
+#-------------------------------------------------------------------         
          COMP_INCR       =C_COMP_INCR(),
-         COMP_ELAS       =FACT(statut='f',max='**',
-           RELATION        =SIMP(statut='o',typ='TXM',defaut="ELAS",
-                                 into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS",
-                                      "ELAS_POUTRE_GR","CABLE","ELAS_HYPER")),
-           DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ),
-      regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
-           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-           ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut= 0 ),
-           RESO_INTE       =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
-                                 into=("IMPLICITE",)),
-         ),
+#-------------------------------------------------------------------         
+         COMP_ELAS       =C_COMP_ELAS('DYNA_NON_LINE'),
 #-------------------------------------------------------------------
          b_reuse =BLOC(condition = "reuse",fr="en mode concept reentrant : ETAT_INIT obligatoire",
          ETAT_INIT       =FACT(statut='o',
@@ -15632,14 +16830,8 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f',
             b_implicit= BLOC(condition="SCHEMA!='TCHAMWA'and SCHEMA!='DIFF_CENT'",
                FORMULATION  =SIMP(statut='o',max=1,typ='TXM',into=("DEPLACEMENT","VITESSE","ACCELERATION"),),),
          ),
-         NEWTON          =FACT(statut='d',
-           REAC_INCR       =SIMP(statut='f',typ='I',defaut= 1,val_min=0 ),
-           PREDICTION      =SIMP(statut='f',typ='TXM',into=("TANGENTE","ELASTIQUE") ),
-           MATRICE         =SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE") ),
-           REAC_ITER       =SIMP(statut='f',typ='I',defaut= 0,val_min=0),
-           REAC_ITER_ELAS  =SIMP(statut='f',typ='I',defaut=0,val_min=0),
-           PAS_MINI_ELAS   =SIMP(statut='f',typ='R',defaut=0.0E+0),
-         ),
+#-------------------------------------------------------------------         
+         NEWTON          =C_NEWTON(),
 #-------------------------------------------------------------------
          RECH_LINEAIRE   =C_RECH_LINEAIRE(),
 #-------------------------------------------------------------------
@@ -15647,90 +16839,13 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f',
 #-------------------------------------------------------------------
          SOLVEUR         =C_SOLVEUR(),
 #-------------------------------------------------------------------
-         OBSERVATION     =FACT(statut='f',max='**',
-           NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
-           SUIVI_DDL       =SIMP(statut='f',typ='TXM',defaut="NON",max=1,into=("OUI","NON")),
-         b_suivi          =BLOC(condition = "SUIVI_DDL == 'OUI' ",
-                                regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'),
-                                                  PRESENT_PRESENT('MAILLE','POINT'),),
-             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-             POINT           =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'),
-             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
-                                   into=("DEPL","VITE","ACCE","SIEF_ELGA",
-                                         "VARI_ELGA","FORC_NODA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)),
-             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-             NUME_SUIVI      =SIMP(statut='o',typ='I' ,min=1,max=4),
-             VALE_MAX        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),
-             VALE_MIN        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),),
-         b_non_suivi      =BLOC(condition = "SUIVI_DDL == 'NON' ",
-                                regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'),PRESENT_PRESENT('MAILLE','POINT'),),
-             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-             POINT           =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'),
-             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("DEPL","VITE","ACCE","SIEF_ELGA",
-                                              "VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU")),
-             INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-             LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
-             PAS_OBSE        =SIMP(statut='f',typ='I'),
-             LIST_ARCH       =SIMP(statut='f',typ=listis_sdaster),
-             CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
-             b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
-                PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
-             b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
-                PRECISION       =SIMP(statut='o',typ='R',),),),
-         ),
-
-         AFFICHAGE      = FACT(statut='f',max=16,
-
-            UNITE       = SIMP(statut='f',typ='I',val_min=1),
-
-            LONG_R      = SIMP(statut='f',typ='I',defaut=12,val_min=1,val_max=12),
-            PREC_R      = SIMP(statut='f',typ='I',defaut=5, val_min=1,val_max=8),
-            LONG_I      = SIMP(statut='f',typ='I',defaut=6, val_min=1,val_max=12),
-
-            NOM_COLONNE = SIMP(statut='o',typ='TXM',defaut="STANDARD",
-                                into=("STANDARD","MINIMUM",
-                                      "ITER_NEWT",
-                                      "INCR_TPS",
-                                      "RESI_RELA","RELA_NOEU",
-                                      "RESI_MAXI","MAXI_NOEU",
-                                      "RESI_REFE","REFE_NOEU",
-                                      "RELI_ITER","RELI_COEF",
-                                      "PILO_PARA",
-                                      "MATR_ASSE",
-                                      "ITER_DEBO",
-                                      "CTCD_ITER","CTCD_GEOM","CTCD_NOEU",
-                                      "BOUC_GEOM","BOUC_FROT","BOUC_CONT","CTCC_BOUC","CTCC_NOEU",
-                                      "SUIV_1","SUIV_2","SUIV_3","SUIV_4",
-                                     ),
-                               ),
-            b_residu    = BLOC(condition = " NOM_COLONNE == 'RESI_RELA' or \
-                    NOM_COLONNE == 'RESI_MAXI' or\
-                    NOM_COLONNE == 'RESI_REFE' or\
-                    NOM_COLONNE == 'CTCD_GEOM' or\
-                    NOM_COLONNE == 'CTCC_BOUC' or\
-                    NOM_COLONNE == 'STANDARD' ",
-                            INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
-                          ),
-         ),
+         OBSERVATION     =C_OBSERVATION(),
 #-------------------------------------------------------------------
-         ARCHIVAGE       =FACT(statut='f',
-           regles=(EXCLUS('PAS_ARCH','LIST_INST','INST'),
-                   EXCLUS('ARCH_ETAT_INIT','NUME_INIT'), ),
-           LIST_INST       =SIMP(statut='f',typ=(listr8_sdaster) ),
-           INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-           PAS_ARCH        =SIMP(statut='f',typ='I' ),
-           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ARCH_ETAT_INIT  =SIMP(statut='f',typ='TXM',into=("OUI",)),
-           NUME_INIT       =SIMP(statut='f',typ='I'),
-           DETR_NUME_SUIV  =SIMP(statut='f',typ='TXM',into=("OUI",)),
-           CHAM_EXCLU      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',
-           into=("DEPL","SIEF_ELGA","VARI_ELGA","ACCE","VITE",)),
-         ),
-
+         SUIVI_DDL       =C_SUIVI_DDL(),
+#------------------------------------------------------------------- 
+         AFFICHAGE       =C_AFFICHAGE(),
+#-------------------------------------------------------------------
+         ARCHIVAGE       =C_ARCHIVAGE(),
 #-------------------------------------------------------------------
          CRIT_FLAMB     =FACT(statut='f',min=1,max=1,
            NB_FREQ         =SIMP(statut='f',typ='I',max=1,defaut=3),
@@ -15748,7 +16863,15 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f',
                                           'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22',
                                           'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23',
                                           'PRES31','PRES32','PRES33','VARI','LAG_GV')),),
-           INST_CALCUL       =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ),
+           regles         = (EXCLUS('PAS_CALC','LIST_INST','INST'),),
+           LIST_INST      = SIMP(statut='f',typ=(listr8_sdaster) ),
+           INST           = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
+           PAS_CALC       = SIMP(statut='f',typ='I' ),
+           CRITERE        = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+              b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+                 PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+              b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                 PRECISION       =SIMP(statut='o',typ='R',),),
          ),
          MODE_VIBR     =FACT(statut='f',min=1,max=1,
            MATR_RIGI        =SIMP(statut='f',typ='TXM',defaut="ELASTIQUE",into=("ELASTIQUE","TANGENTE","SECANTE",) ),
@@ -15756,7 +16879,15 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f',
                             fr="Nombre de fréquences propres à calculer"),
            BANDE            =SIMP(statut='f',typ='R',min=2,max=2,
                             fr="Valeur des deux fréquences délimitant la bande de recherche",),
-           INST_CALCUL       =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ),
+           regles         = (EXCLUS('PAS_CALC','LIST_INST','INST'),),
+           LIST_INST      = SIMP(statut='f',typ=(listr8_sdaster) ),
+           INST           = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
+           PAS_CALC       = SIMP(statut='f',typ='I' ),
+           CRITERE        = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+              b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+                 PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+              b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                 PRECISION       =SIMP(statut='o',typ='R',),),
          ),
 #-------------------------------------------------------------------
            SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
@@ -15806,10 +16937,10 @@ DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=table_fonction,
          OPTION          =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG") ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 31/01/2011   AUTEUR GREFFET N.GREFFET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -15833,7 +16964,7 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op=  74,sd_prod=tran_gene,
       regles=(EXCLUS('AMOR_REDUIT','AMOR_GENE','LIST_AMOR'),
               PRESENT_ABSENT('MODE_STAT','MODE_CORR'),),
          METHODE         =SIMP(statut='f',typ='TXM',defaut="EULER",
-                               into=("EULER","NEWMARK","DEVOGE","ADAPT","ITMI") ),
+                               into=("EULER","NEWMARK","DEVOGE","ADAPT_ORDRE1","ADAPT_ORDRE2","ITMI") ),
          MASS_GENE       =SIMP(statut='o',typ=matr_asse_gene_r ),
          RIGI_GENE       =SIMP(statut='o',typ=matr_asse_gene_r ),
          AMOR_GENE       =SIMP(statut='f',typ=matr_asse_gene_r ),
@@ -15845,7 +16976,17 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op=  74,sd_prod=tran_gene,
          COUPLAGE_EDYOS     =FACT(statut='f',max=1,         
                              VITE_ROTA          = SIMP(statut='o',typ='R' ),
                              PAS_TPS_EDYOS      = SIMP(statut='o',typ='R' ),
-                             UNITE              = SIMP(statut='f',typ='I',defaut=45),
+         ),
+
+         PALIER_EDYOS      =FACT(statut='f',max='**',
+         regles=(PRESENT_ABSENT('UNITE','GROUP_NO'),
+                 PRESENT_ABSENT('UNITE','TYPE_EDYOS'),
+                 EXCLUS('GROUP_NO','NOEUD'),),
+                                     UNITE       = SIMP(statut='f',typ='I',),
+                                     GROUP_NO    = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                                     NOEUD       = SIMP(statut='f',typ=no),
+                                     TYPE_EDYOS  = SIMP(statut='f',typ='TXM',
+                                     into=("PAPANL","PAFINL","PACONL","PAHYNL",),),
          ),
 
          ETAT_INIT       =FACT(statut='f',
@@ -16052,11 +17193,12 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op=  74,sd_prod=tran_gene,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
          ),
 
@@ -16103,15 +17245,58 @@ ENGENDRE_TEST=PROC(nom="ENGENDRE_TEST",op=178,
             TYPE_TEST       =SIMP(statut='f',typ='TXM',defaut="SOMME",into=("SOMME",) ),
          ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 14/02/2011   AUTEUR GREFFET N.GREFFET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
-# (AT YOUR OPTION) ANY LATER VERSION.                                 
-#
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GREFFET N.GREFFET
+# 
+#  ENVOI DES CHAMPS CINEMATIQUES VIA YACS POUR COUPLAGE IFS 
+#
+ENV_CINE_YACS=PROC(nom             = "ENV_CINE_YACS",
+                   op              = 111,
+                   UIinfo          = {"groupes":("Résultats et champs",)},
+                   fr              = "Envoi des champs de deplacement et vitesse via YACS pour Couplage de Code_Aster et Saturne",
+                   regles          = (EXCLUS('ETAT_INIT','RESULTAT',),),
+                   MATR_PROJECTION = SIMP(statut='o', typ=corresp_2_mailla,),
+                   VIS_A_VIS = FACT(statut='o', max='**',
+                                   GROUP_MA_1=SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                                   GROUP_NO_2=SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),),
+                   RESULTAT  = FACT(statut='f',
+                                   NUME_ORDRE=SIMP(statut='o', typ='I',              validators=NoRepeat()),
+                                   RESU      =SIMP(statut='o', typ=resultat_sdaster, validators=NoRepeat()),),
+                   ETAT_INIT = FACT(statut='f',
+                                    DEPL=SIMP(statut='f', typ=cham_no_sdaster,  validators=NoRepeat()),
+                                    VITE=SIMP(statut='f', typ=cham_no_sdaster,  validators=NoRepeat()),
+                                    ACCE=SIMP(statut='f', typ=cham_no_sdaster,  validators=NoRepeat()),),
+                   INST         = SIMP(statut='o',typ='R', ),
+                   PAS             = SIMP(statut='o',typ='R', ),
+                   NUME_ORDRE_YACS = SIMP(statut='o', typ='I',),
+                   INFO            = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+) ;
+#& MODIF COMMANDE  DATE 01/03/2011   AUTEUR ASSIRE A.ASSIRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
@@ -16134,11 +17319,25 @@ EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",op=exec_logiciel_ops, sd_prod=exec_log
                       fr="Exécute un logiciel ou une commande système depuis Aster",
                       UIinfo={"groupes":("Gestion du travail","Outils-métier",)},
       
-      regles = (AU_MOINS_UN('LOGICIEL', 'MAILLAGE'),),
-      
+      regles = ( AU_MOINS_UN('LOGICIEL', 'MAILLAGE', 'SALOME'), 
+                 EXCLUS('MACHINE_DISTANTE','MAILLAGE'), 
+                 EXCLUS('MAILLAGE','SALOME'),
+                 ),
+
       LOGICIEL = SIMP(statut='f', typ='TXM'),
       ARGUMENT = SIMP(statut='f', max='**', typ='TXM'),
 
+
+      MACHINE_DISTANTE = FACT(statut='f',
+        SSH_ADRESSE  = SIMP(statut='o', typ='TXM', val_min=1, val_max=255,
+                           fr="Adresse IP ou nom de la machine sur laquelle le logiciel/script sera exécuté via SSH"),
+        SSH_LOGIN    = SIMP(statut='f', typ='TXM', val_min=1, val_max=255,
+                           fr="Nom d'utilisateur sur la machine distante"),
+        SSH_PORT     = SIMP(statut='f', typ='I', val_min=1, val_max=65535, defaut=22,
+                           fr="Port SSH de la machien distante"),
+      ),
+
+
       MAILLAGE = FACT(statut='f',
          FORMAT     = SIMP(statut='o', typ='TXM', into=("GMSH", "GIBI", "SALOME")),
          UNITE_GEOM = SIMP(statut='f', typ='I', val_min=10, val_max=90, defaut=16,
@@ -16148,6 +17347,30 @@ EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",op=exec_logiciel_ops, sd_prod=exec_log
          MAILLAGE   = SIMP(statut='o', typ=CO),
       ),
 
+
+      SALOME = FACT(statut='f',
+           regles=(UN_PARMI('CHEMIN_SCRIPT', 'UNITE_SCRIPT'),
+                   PRESENT_PRESENT('NOM_PARA','VALE'),),
+         CHEMIN_SCRIPT     = SIMP(statut='f', typ='TXM',
+                               fr="Chemin du script Salome"),
+         UNITE_SCRIPT      = SIMP(statut='f', typ='I', val_min=80, val_max=99,
+                               fr="Unité logique du script Salome"),
+         SALOME_HOST       = SIMP(statut='f', typ='TXM', defaut='localhost',
+                               fr="Machine sur laquelle tourne Salome"),
+         SALOME_PORT       = SIMP(statut='f', typ='I', val_min=2800, val_max=2900, defaut=2810,
+                               fr="Port de l'instance Salome (2810 ou supérieur)"),
+         SALOME_RUNAPPLI   = SIMP(statut='f', typ='TXM',
+                               fr="Chemin vers le script de lancement runAppli de Salome"),
+         FICHIERS_ENTREE   = SIMP(statut='f', typ='TXM', validators=NoRepeat(),max='**',
+                               fr="Liste des fichiers d'entrée du script Salome"),
+         FICHIERS_SORTIE   = SIMP(statut='f', typ='TXM', validators=NoRepeat(),max='**',
+                               fr="Liste des fichiers générés par le script Salome"),
+         NOM_PARA          = SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(), 
+                               fr="Liste des noms des paramètres à modifier dans le script Salome"),
+         VALE              = SIMP(statut='f',typ='TXM',max='**',
+                               fr="Valeur des paramètres à) modifier dans le script Salome"),
+      ),
+
       CODE_RETOUR_MAXI = SIMP(statut='f', typ='I', defaut=0, val_min=-1,
                               fr="Valeur maximale du code retour toléré (-1 pour l'ignorer)"),
       
@@ -16340,10 +17563,10 @@ EXTR_TABLE=OPER(nom="EXTR_TABLE",op=173,sd_prod=extr_table_prod,reentrant='n',
 
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -16394,6 +17617,7 @@ FACTORISER=OPER(nom="FACTORISER",op=14,sd_prod=factoriser_prod,
          PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
          ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
          OUT_OF_CORE  =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+         LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
          
          # mots clés pour solveur GCPC et PETSc :
          PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR","LDLT_SP"),defaut="LDLT_INC" ),
@@ -16403,7 +17627,7 @@ FACTORISER=OPER(nom="FACTORISER",op=14,sd_prod=factoriser_prod,
            RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
          ),
          b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-           REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+           REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
            RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
          ),
          b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -16864,10 +18088,10 @@ IMPR_FONCTION=MACRO(nom="IMPR_FONCTION",op=impr_fonction_ops,sd_prod=None,
          ),
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -16918,7 +18142,7 @@ IMPR_GENE=PROC(nom="IMPR_GENE",op= 157,
            TOUT_CMP_GENE   =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
            NUME_CMP_GENE   =SIMP(statut='f',typ='I',max='**'),
            TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',max='**'),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',max='**',into=C_NOM_CHAM_INTO(),),
            TOUT_PARA       =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
            NOM_PARA        =SIMP(statut='f',typ='TXM',max='**'),
            SOUS_TITRE      =SIMP(statut='f',typ='TXM',max='**'),
@@ -16987,10 +18211,10 @@ IMPR_JEVEUX=PROC(nom="IMPR_JEVEUX",op=16,
          ),
          COMMENTAIRE     =SIMP(statut='f',typ='TXM' ),  
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 01/03/2011   AUTEUR CORUS M.CORUS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -17012,17 +18236,17 @@ IMPR_MACR_ELEM=PROC(nom="IMPR_MACR_ELEM",op= 160,
          fr="Impression d'une structure de données MACR_ELEM_DYNA au format IDEAS MISS3D PLEXUS ou CADYRO",
          MACR_ELEM_DYNA  =SIMP(statut='o',typ=macr_elem_dyna ),
          FORMAT          =SIMP(statut='f',typ='TXM',defaut="IDEAS",
-                               into=("MISS_3D","IDEAS","CADYRO","PLEXUS") ),
+                               into=("MISS_3D","IDEAS") ),
 
-         b_plexus         =BLOC(condition = "FORMAT == 'IDEAS'",
+         b_ideas         =BLOC(condition = "FORMAT == 'IDEAS'",
            UNITE           =SIMP(statut='f',typ='I',defaut=30),
            VERSION          =SIMP(statut='f',typ='I',defaut= 5,into=( 5 ,) ),
          ),             
 
-         b_ideas         =BLOC(condition = "FORMAT == 'PLEXUS'",
-           UNITE           =SIMP(statut='f',typ='I',defaut=30),
-           VERSION         =SIMP(statut='f',typ='I',defaut= 5,into=( 5 ,) ),
-         ),                      
+#         b_plexus         =BLOC(condition = "FORMAT == 'PLEXUS'",
+#           UNITE           =SIMP(statut='f',typ='I',defaut=30),
+#           VERSION         =SIMP(statut='f',typ='I',defaut= 5,into=( 5 ,) ),
+#         ),                      
 
          b_miss_3d       =BLOC(condition = "FORMAT == 'MISS_3D'",
            regles=(EXCLUS('AMOR_REDUIT','LIST_AMOR'),),
@@ -17040,20 +18264,49 @@ IMPR_MACR_ELEM=PROC(nom="IMPR_MACR_ELEM",op= 160,
            IMPR_MODE_STAT  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
          ),
 
-         b_cadyro        =BLOC(condition = "FORMAT == 'CADYRO'",
-           SQUELETTE       =SIMP(statut='f',typ=squelette ),
-           UNITE_MODE_MECA =SIMP(statut='f',typ='I',defaut= 26 ),
-           UNITE_MODE_STAT =SIMP(statut='f',typ='I',defaut= 27 ),
-           UNITE_MAILLAGE  =SIMP(statut='f',typ='I',defaut= 28 ),
-           IMPR_MODE_MECA  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
-           IMPR_MODE_STAT  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
-         ),
+#         b_cadyro        =BLOC(condition = "FORMAT == 'CADYRO'",
+#           SQUELETTE       =SIMP(statut='f',typ=squelette ),
+#           UNITE_MODE_MECA =SIMP(statut='f',typ='I',defaut= 26 ),
+#           UNITE_MODE_STAT =SIMP(statut='f',typ='I',defaut= 27 ),
+#           UNITE_MAILLAGE  =SIMP(statut='f',typ='I',defaut= 28 ),
+#           IMPR_MODE_MECA  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+#           IMPR_MODE_STAT  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+#         ),
 
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 14/02/2011   AUTEUR GREFFET N.GREFFET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GREFFET N.GREFFET
+#
+# RECUPERATION DES MAILLAGES IFS VENANT DE SATURNE VIA YACS
+#
+IMPR_MAIL_YACS=PROC(nom="IMPR_MAIL_YACS",op=43,
+            UIinfo={"groupes":("Maillage",)},
+               fr="Lecture d'un maillage via YACS lors du Couplage de Code_Aster et Saturne",
+         UNITE_MAILLAGE = SIMP(statut='f',typ='I',defaut=30),
+         TYPE_MAILLAGE = SIMP(statut='o',typ='TXM',into=("SOMMET","MILIEU")),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -17079,27 +18332,24 @@ IMPR_MISS_3D=PROC(nom="IMPR_MISS_3D",op= 162,
          EXCIT           =FACT(statut='f',max='**',
            regles=(UN_PARMI('FONC_MULT','COEF_MULT' ),),
            VECT_ASSE       =SIMP(statut='f',typ=cham_no_sdaster),
-           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),),
            COEF_MULT       =SIMP(statut='f',typ='R' ),
          ),
          EXCIT_SOL       =FACT(statut='f',max='**',
            DIRECTION       =SIMP(statut='o',typ='R',min=3,max=3),
            FONC_SIGNAL     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",
-                                 into=("DEPL","VITE","ACCE","FORC",) ),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","FORC",),),
          ),
          SOURCE_SOL      =FACT(statut='f',max='**',
            POINT           =SIMP(statut='o',typ='R',min=3,max=3),
            DIRECTION       =SIMP(statut='o',typ='R',min=3,max=3),
-           FONC_SIGNAL     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",
-                                 into=("DEPL","VITE","ACCE","FORC",) ),
+           FONC_SIGNAL     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","FORC",),),
          ),
          SOURCE_FLUIDE   =FACT(statut='f',max='**',
            POINT           =SIMP(statut='o',typ='R',min=3,max=3),
-           FONC_SIGNAL     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",
-                                 into=("DEPL","VITE","ACCE","FORC",) ),
+           FONC_SIGNAL     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","FORC",),),
          ),
          DIRE_ONDE       =SIMP(statut='f',typ='R',min=3,max=3),
          INST_INIT       =SIMP(statut='f',typ='R' ),
@@ -17181,10 +18431,10 @@ IMPR_OAR =MACRO(nom="IMPR_OAR",op= impr_oar_ops, sd_prod=None,
    UNITE = SIMP(statut='f',typ='I',defaut=38),
    AJOUT = SIMP(statut='f', typ='TXM', defaut='NON', into=('OUI', 'NON')),
    );
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 11/05/2011   AUTEUR SELLENET N.SELLENET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -17321,7 +18571,7 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39,
 ###
            b_med=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and(FORMAT == 'MED')""",
                                 fr="renommage du champ",
-             NOM_CHAM_MED    =SIMP(statut='f',typ='TXM',validators=(LongStr(1,32),NoRepeat()),max='**'),
+             NOM_CHAM_MED    =SIMP(statut='f',typ='TXM',validators=(LongStr(1,64),NoRepeat()),max='**'),
            ),
 ###
            b_gmsh=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and((FORMAT == 'GMSH'))""",
@@ -17366,10 +18616,10 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39,
          ),
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
 ) ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 18/01/2011   AUTEUR BOITEAU O.BOITEAU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -17422,10 +18672,11 @@ IMPR_STURM=PROC(nom="IMPR_STURM",op=32,fr="Calculer et imprimer le nombre de val
              b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
                TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
                PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
-               RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+               RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
                ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
                PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
                OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+               LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
            ),    
 
@@ -17996,10 +19247,10 @@ LIRE_CHAMP=OPER(nom="LIRE_CHAMP",op= 192,sd_prod=lire_champ_prod,
                   ),
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 22/03/2011   AUTEUR COURTOIS M.COURTOIS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -18046,7 +19297,8 @@ LIRE_FONCTION=MACRO(nom="LIRE_FONCTION",op=lire_fonction_ops,sd_prod=lire_foncti
          b_nappe         =BLOC(condition = "TYPE=='NAPPE' ",
            NOM_PARA_FONC   =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ),
            INDIC_ABSCISSE  =SIMP(statut='o',typ='I',min=2,max=2,),
-           INTERPOL_FONC   =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ),
+           INTERPOL_FONC   =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
+                                 fr="Type d'interpolation pour les abscisses et les ordonnées de la fonction"),
            PROL_DROITE_FONC=SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
            PROL_GAUCHE_FONC=SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
            DEFI_FONCTION   =FACT(statut='f',max='**',
@@ -18054,7 +19306,9 @@ LIRE_FONCTION=MACRO(nom="LIRE_FONCTION",op=lire_fonction_ops,sd_prod=lire_foncti
          UNITE           =SIMP(statut='o',typ='I' ),
          NOM_PARA        =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ),
          NOM_RESU        =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"),
-         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ),
+         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG"),
+                               fr="Type d'interpolation pour les abscisses et les ordonnées de la " \
+                                  "fonction ou bien pour le paramètre de la nappe."),
          PROL_DROITE     =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
          PROL_GAUCHE     =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
          VERIF           =SIMP(statut='f',typ='TXM',defaut="CROISSANT",into=("CROISSANT","NON") ),
@@ -18306,10 +19560,10 @@ LIRE_PLEXUS=OPER(nom="LIRE_PLEXUS",op= 184,sd_prod=evol_char,
                    PRECISION       =SIMP(statut='o',typ='R',),),),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/03/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -18341,33 +19595,112 @@ def lire_resu_prod(TYPE_RESU,**args):
 
 # pour éviter d'écrire 3 fois cette liste :
 def l_nom_cham_pas_elga(): return (
-     "ACCE", "ACCE_ABSOLU", "CRIT_ELNO_RUPT", "DCHA_ELNO_SIGM",
-     "DCHA_NOEU_SIGM", "DEDE_ELNO_DLDE", "DEDE_NOEU_DLDE", "DEGE_ELNO_DEPL", "DEGE_NOEU_DEPL",
-     "DEPL", "DEPL_ABSOLU", "DESI_ELNO_DLSI", "DESI_NOEU_DLSI", "DETE_ELNO_DLTE", "DETE_NOEU_DLTE",
-     "DURT_ELNO_META", "DURT_NOEU_META", "ECIN_ELEM_DEPL", "EFGE_ELNO_CART", "EFGE_ELNO_DEPL",
-     "EFGE_NOEU_CART", "EFGE_NOEU_DEPL", "ENDO_ELNO_SIGA", "ENDO_ELNO_SINO", "ENDO_NOEU_SINO",
-     "ENEL_ELNO_ELGA", "ENEL_NOEU_ELGA", "EPEQ_ELNO_TUYO", "EPGR_ELNO", "EPME_ELNO_DEPL",
-     "EPMG_ELNO_DEPL", "EPMG_NOEU_DEPL", "EPOT_ELEM_DEPL", "EPSA_ELNO", "EPSA_NOEU",
-     "EPSG_ELNO_DEPL", "EPSG_NOEU_DEPL", "EPSI_ELNO_DEPL", "EPSI_ELNO_TUYO", "EPSI_NOEU_DEPL",
-     "EPSP_ELNO", "EPSP_NOEU", "EQUI_ELNO_EPME", "EQUI_ELNO_EPSI",
-     "EQUI_ELNO_SIGM", "EQUI_NOEU_EPME", "EQUI_NOEU_EPSI", "EQUI_NOEU_SIGM", "ERRE_ELEM_NOZ1",
-     "ERRE_ELEM_NOZ2", "ERRE_ELNO_ELGA", "ERRE_NOEU_ELGA", "ERTH_ELEM_TEMP", "ERTH_ELNO_ELEM",
-     "ETOT_ELEM", "ETOT_ELNO_ELGA", "FLUX_ELNO_TEMP", "FLUX_NOEU_TEMP", "FORC_NODA", "FSUR_2D",
-     "FSUR_3D", "FVOL_2D", "FVOL_3D", "GRAD_NOEU_THETA", "HYDR_ELNO_ELGA", "HYDR_NOEU_ELGA",
-     "INTE_ELNO_ACTI", "INTE_ELNO_REAC", "INTE_NOEU_ACTI", "INTE_NOEU_REAC", "IRRA",
-     "META_ELNO_TEMP", "META_NOEU_TEMP", "PMPB_ELNO_SIEF", "PMPB_NOEU_SIEF",
-     "PRES", "PRES_DBEL_DEPL", "PRES_ELNO_DBEL", "PRES_ELNO_IMAG", "PRES_ELNO_REEL",
-     "PRES_NOEU_DBEL", "PRES_NOEU_IMAG", "PRES_NOEU_REEL",
-     "RADI_ELNO_SIGM", "RADI_NOEU_SIGM", "REAC_NODA",
-     "SIEF_ELNO", "SIEF_ELNO_ELGA", "SIEF_NOEU", "SIEF_NOEU_ELGA", "SIEQ_ELNO_TUYO",
-     "SIGM_ELNO_CART", "SIGM_ELNO_COQU", "SIGM_ELNO_DEPL", "SIGM_ELNO_SIEF",
-     "SIGM_ELNO_TUYO", "SIGM_NOEU_CART", "SIGM_NOEU_COQU",
-     "SIGM_NOEU_DEPL", "SIGM_NOEU_SIEF", "SIGM_NOZ1_ELGA",
-     "SIGM_NOZ2_ELGA", "SIPO_ELNO_DEPL", "SIPO_ELNO_SIEF", "SIPO_NOEU_DEPL",
-     "SIPO_NOEU_SIEF", "TEMP", "THETA",
-     "VALE_CONT", "VALE_NCOU_MAXI", "VARI_ELNO", "VARI_ELNO_COQU",
-     "VARI_ELNO_ELGA", "VARI_ELNO_TUYO", "VARI_NOEU", "VARI_NOEU_ELGA",
-     "VITE", "VITE_ABSOLU", "VITE_VENT",
+     "ACCE",
+     "ACCE_ABSOLU",
+     "CRIT_ELNO",
+     "DERA_ELNO",
+     "DERA_NOEU",
+     "DEDE_ELNO",
+     "DEDE_NOEU",
+     "DEGE_ELNO",
+     "DEGE_NOEU",
+     "DEPL",
+     "DEPL_ABSOLU",
+     "DESI_ELNO",
+     "DESI_NOEU",
+     "DETE_ELNO",
+     "DETE_NOEU",
+     "DURT_ELNO",
+     "DURT_NOEU",
+     "ECIN_ELEM",
+     "EFCA_ELNO",
+     "EFGE_ELNO",
+     "EFCA_NOEU",
+     "EFGE_NOEU",
+     "ENDO_ELNO",
+     "ENDO_NOEU",
+     "ENEL_ELNO",
+     "ENEL_NOEU",
+     "EPTQ_ELNO",
+     "EPGR_ELNO",
+     "EPME_ELNO",
+     "EPMG_ELNO",
+     "EPMG_NOEU",
+     "EPOT_ELEM",
+     "EPSA_ELNO",
+     "EPSA_NOEU",
+     "EPSG_ELNO",
+     "EPSG_NOEU",
+     "EPSI_ELNO",
+     "EPTU_ELNO",
+     "EPSI_NOEU",
+     "EPSP_ELNO",
+     "EPSP_NOEU",
+     "EPMQ_ELNO",
+     "EPEQ_ELNO",
+     "SIEQ_ELNO",
+     "EPMQ_NOEU",
+     "EPEQ_NOEU",
+     "SIEQ_NOEU",
+     "ERRE_ELEM_NOZ1",
+     "ERRE_ELEM_NOZ2",
+     "ERRE_ELNO_ELGA",
+     "ERRE_NOEU_ELGA",
+     "ERTH_ELEM_TEMP",
+     "ERTH_ELNO_ELEM",
+     "ETOT_ELEM",
+     "ETOT_ELNO",
+     "FLUX_ELNO",
+     "FLUX_NOEU",
+     "FORC_NODA",
+     "FSUR_2D",
+     "FSUR_3D",
+     "FVOL_2D",
+     "FVOL_3D",
+     "GRAD_NOEU_THETA",
+     "HYDR_ELNO",
+     "HYDR_NOEU",
+     "INTE_ELNO",
+     "INTE_NOEU",
+     "IRRA",
+     "META_ELNO",
+     "META_NOEU",
+     "PMPB_ELNO",
+     "PMPB_NOEU",
+     "PRES",
+     "PRME_ELNO",
+     "PRAC_ELNO",
+     "PRAC_NOEU",
+     "REAC_NODA",
+     "SIEF_ELNO",
+     "SIEF_ELNO",
+     "SIEF_NOEU",
+     "SIEF_NOEU",
+     "SITQ_ELNO",
+     "SICA_ELNO",
+     "SICO_ELNO",
+     "SIGM_ELNO",
+     "SITU_ELNO",
+     "SICA_NOEU",
+     "SICO_NOEU",
+     "SIGM_NOEU",
+     "SIZ1_ELGA",
+     "SIZ2_ELGA",
+     "SIPO_ELNO",
+     "SIPO_NOEU",
+     "TEMP",
+     "THETA",
+     "VALE_CONT",
+     "SPMX_ELGA",
+     "VARI_ELNO",
+     "VACO_ELNO",
+     "VARI_ELNO",
+     "VATU_ELNO",
+     "VARI_NOEU",
+     "VARI_NOEU",
+     "VITE",
+     "VITE_ABSOLU",
+     "VITE_VENT",
                            )
 
 LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n',
@@ -18394,7 +19727,7 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n',
          NB_VARI         =SIMP(statut='f',typ='I' ),
 
          CHAM_MATER      =SIMP(statut='f',typ=cham_mater,),
-         
+
          CARA_ELEM       =SIMP(statut='f',typ=cara_elem,),
 
           b_evol_elas  = BLOC(condition="TYPE_RESU=='EVOL_ELAS'",
@@ -18436,7 +19769,7 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n',
          ),
          b_dataset_58_b = BLOC(condition="(FORMAT=='IDEAS_DS58') and ((TYPE_RESU=='DYNA_TRANS') or\
                                         (TYPE_RESU=='DYNA_HARMO') or (TYPE_RESU=='HARM_GENE'))",
-           NOM_CHAM=SIMP(statut='o',typ='TXM',into=("DEPL","VITE","ACCE","EPSI_NOEU_DEPL","SIEF_NOEU",) ),
+           NOM_CHAM=SIMP(statut='o',typ='TXM',into=("DEPL","VITE","ACCE","EPSI_NOEU","SIEF_NOEU",),max='**' ),
            REDEFI_ORIENT=FACT(statut='f',max='**',
                               regles=(PRESENT_PRESENT('CODE_DIR','DIRECTION','NOEUD',),),
                               CODE_DIR =SIMP(statut='f',typ='I',into=(1,2,3,) ),
@@ -18466,7 +19799,7 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n',
              POSI_INST       =SIMP(statut='f',typ='I',min=2,max=2),
              POSI_FREQ       =SIMP(statut='f',typ='I',min=2,max=2),
              NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),),
-         ),          
+         ),
 
 # 1-3 ensight :
 # -------------
@@ -18494,10 +19827,11 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n',
 # 2) blocs selon le type du résultat :
 #---------------------------------
          b_mode_meca     =BLOC(condition="(TYPE_RESU=='MODE_MECA')or(TYPE_RESU=='MODE_MECA_C')",
+           # Ces mots cles sont stockes dans l'objet .REFD des mode_meca
+           # Ces mots cles sont aussi utilises  pour imposer la numerotation des cham_no de DEPL_R
            MATR_A         =SIMP(statut='f',typ=matr_asse_depl_r,max=1),
            MATR_B         =SIMP(statut='f',typ=matr_asse_depl_r,max=1),
-           NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster),max=1,
-                           fr="Utile en dynamique pour pouvoir imposer la numérotation des cham_no."),
+           NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster),max=1,),
          ),
 
 
@@ -18587,30 +19921,31 @@ MAC_MODES=OPER(nom="MAC_MODES",op=  141,sd_prod=table_sdaster,
          TITRE      =SIMP(statut='f',typ='TXM',max='**'),
          INFO       =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR GNICOLAS G.NICOLAS 
+#& MODIF COMMANDE  DATE 11/05/2011   AUTEUR SELLENET N.SELLENET 
+# -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
-# (AT YOUR OPTION) ANY LATER VERSION.                                 
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
 #
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
 #
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 # RESPONSABLE GNICOLAS G.NICOLAS
 
 
 from Macro.macr_adap_mail_ops import macr_adap_mail_ops
 
-def macr_adap_mail_prod(self,MAJ_CHAM,ADAPTATION,**args):
+def macr_adap_mail_prod(self, MAJ_CHAM, ADAPTATION, **args):
 #
 # 0. Typage des structures produites
 #
@@ -18641,14 +19976,14 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 #
 # 2. Version de HOMARD
 #
-  VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_8",
-                        into=("V9_8", "V9_N", "V9_N_PERSO"),
+  VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V10_1",
+                        into=("V10_1", "V10_N", "V10_N_PERSO"),
                         fr="Version de HOMARD",
                         ang="HOMARD release"),
 #
 # 3. Langue des messages produits par HOMARD
 #
-  LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS",    
+  LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS",
                 into=("FRANCAIS","FRENCH","ANGLAIS","ENGLISH",),
                 fr="Langue des messages produits par HOMARD.",
                 ang="Language for the HOMARD messages." ),
@@ -18663,14 +19998,14 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                       ang="Mesh before adaptation" ),
 #
   MAILLAGE_NP1 = SIMP(statut='o',typ=CO,
-                      fr="Maillage apres adaptation",
+                      fr="Maillage après adaptation",
                       ang="Mesh after adaptation" ),
 #
 # 4.2. Eventuellement, on peut produire un maillage annexe
 #      Actuellement, c'est le maillage n+1, mais de degré différent.
 #
   MAILLAGE_NP1_ANNEXE = SIMP(statut='f',typ=CO,
-                             fr="Maillage annexe apres adaptation",
+                             fr="Maillage annexe après adaptation",
                              ang="Additional mesh after adaptation" ),
 #
 # 5. Le pilotage de l'adaptation, avec les variantes suivantes :
@@ -18711,7 +20046,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 # 6.1.2. Sous forme de concept resultat_sdaster
 #
     RESULTAT_N = SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther) ,
-                      fr="Concept resultat Code_Aster contenant le champ",
+                      fr="Concept résultat Code_Aster contenant le champ",
                       ang="The Code_Aster result with the field" ),
 #
     b_champ_adaptation = BLOC(condition="(RESULTAT_N != None)",
@@ -18755,7 +20090,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 # 6.1.5.1. Soit le numero d'ordre
 #
       NUME_ORDRE = SIMP(statut='f',typ='I',
-                        fr="Numero d ordre",
+                        fr="Numéro d ordre",
                         ang="Rank" ),
 #
 # 6.1.5.2. Soit l'instant
@@ -18801,7 +20136,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 # 6.1.7. Usage du champ : la valeur par maille ou le max du saut entre mailles
 #
     b_usage_champ = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
-                         fr="Usage du champ : direct ou saut",
+                         fr="Usage du champ : par maille ou saut entre mailles voisines",
                          ang="Use type for the field : direct or jump",
 #
       USAGE_CHAMP = SIMP(statut='f',typ='TXM',defaut="MAILLE",into=("MAILLE","SAUT"),
@@ -18860,7 +20195,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                  fr="Pour une adaptation selon une zone à raffiner",
                  ang="For adaptation among a zone",
 #
-    ZONE = FACT(statut='f',max='**',
+    ZONE = FACT(statut='o',min=1,max='**',
                 fr="Définition de zones à raffiner.",
                 ang="Refined zone definition.",
 #
@@ -18935,10 +20270,10 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 ##gn                           fr="X et Y du centre d'un disque plein ou perce, d'une sphere.",
 ##gn                           ang="X and Y of the centre of a disk or of a sphere.",
       X_CENTRE = SIMP(statut='f',typ='R',
-                      fr="Abscisse du centre du disque ou de la sphere",
+                      fr="Abscisse du centre du disque ou de la sphère",
                       ang="X for the center of the disk or of the sphere"),
       Y_CENTRE = SIMP(statut='f',typ='R',
-                      fr="Ordonnee du centre du disque ou de la sphere",
+                      fr="Ordonnée du centre du disque ou de la sphère",
                       ang="Y for the center of the disk or of the sphere"),
 ##gn      ) ,
 #
@@ -18948,7 +20283,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 ##gn                       fr="Cote du centre de la sphere.",
 ##gn                       ang="Z for the center of the sphere.",
        Z_CENTRE = SIMP(statut='f',typ='R',
-                       fr="Cote du centre de la sphere",
+                       fr="Cote du centre de la sphère",
                        ang="Z for the center of the sphere"),
 ##gn      ) ,
 #
@@ -18958,10 +20293,10 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 ##gn                                fr="Le rayon d'un disque perce ou d'un tuyau.",
 ##gn                                ang="The radius of a holed disk or of a pipe.",
       RAYON_INT = SIMP(statut='f',typ='R',
-                       fr="Rayon interieur",
+                       fr="Rayon intérieur",
                        ang="Internal radius"),
       RAYON_EXT = SIMP(statut='f',typ='R',
-                       fr="Rayon exterieur",
+                       fr="Rayon extérieur",
                        ang="External radius"),
 ##gn      ) ,
 #
@@ -18974,7 +20309,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                    fr="Abscisse du vecteur directeur de l'axe",
                    ang="X for the axial vector"),
       Y_AXE = SIMP(statut='f',typ='R',
-                   fr="Ordonnee du vecteur directeur de l'axe",
+                   fr="Ordonnée du vecteur directeur de l'axe",
                    ang="Y for the axial vector"),
       Z_AXE = SIMP(statut='f',typ='R',
                    fr="Cote du vecteur directeur de l'axe",
@@ -18983,7 +20318,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                     fr="Abscisse d'un point de la base, sur l'axe",
                     ang="X for the basis, on the axis"),
       Y_BASE = SIMP(statut='f',typ='R',
-                    fr="Ordonnee d'un point de la base, sur l'axe",
+                    fr="Ordonnée d'un point de la base, sur l'axe",
                     ang="Y for the basis, on the axis"),
       Z_BASE = SIMP(statut='f',typ='R',
                     fr="Cote d'un point de la base, sur l'axe",
@@ -19004,11 +20339,17 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                                          (ADAPTATION == 'RAFFINEMENT') or \
                                          (ADAPTATION == 'RAFFINEMENT_UNIFORME') or \
                                          (ADAPTATION == 'RAFFINEMENT_ZONE') " ,
-                           fr="Niveau maximum de profondeur de raffinement",
-                           ang="Maximum level for the refinement",
+                           fr="Profondeur maximale de raffinement",
+                           ang="Maximum depth for the refinement",
+#
     NIVE_MAX = SIMP(statut='f',typ='I',
                     fr="Niveau maximum de profondeur de raffinement",
                     ang="Maximum level for the refinement"),
+#
+    DIAM_MIN = SIMP(statut='f',typ='R',
+                    fr="Diamètre minimal de maille",
+                    ang="Minimal diameter for the mesh" ),
+#
   ) ,
 #
 # 9.2. Pour le deraffinement :
@@ -19043,46 +20384,46 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                     ang="List of the groups of nodes for filtering of the adaptation." ),
   ) ,
 #
-# 11. Suivi d'une frontiere
+# 11. Suivi d'une frontière
 #
-# 11.1. Definition d'une frontiere par un maillage (valable seulement pour des frontieres 1D)
+# 11.1. Definition d'une frontière par un maillage (valable seulement pour des frontières 1D)
 #
   MAILLAGE_FRONTIERE = SIMP(statut='f',typ=maillage_sdaster,
-                           fr="Maillage de la frontiere à suivre",
-                           ang="Boundary mesh" ),
+                           fr="Maillage de la frontière discrète à suivre",
+                           ang="Discrete boundary mesh" ),
 #
-  b_frontiere = BLOC( condition = " MAILLAGE_FRONTIERE != None " ,
-                      fr="Information complémentaire sur la frontière",
-                      ang="Further information about boundary",
+  b_FRONTIERE = BLOC( condition = " MAILLAGE_FRONTIERE != None " ,
+                      fr="Information complémentaire sur la frontière discrète",
+                      ang="Further information about discrete boundary",
 #
     GROUP_MA_FRONT = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
-                          fr="Liste des groupes de mailles définissant la frontière",
-                          ang="Mesh groups which define the boundary" ),
+                          fr="Liste des groupes de mailles définissant la frontière discrète",
+                          ang="Mesh groups which define the discrete boundary" ),
 #
   ) ,
 #
-# 11.2. Definition analytique d'une frontiere
+# 11.2. Definition analytique d'une frontière
 #
   FRONTIERE_ANALYTIQUE = FACT(statut='f',max='**',
-                              fr="Definition analytique de frontieres a suivre.",
+                              fr="Definition analytique de frontières a suivre.",
                               ang="Analytical definition of a boundary.",
 #
-# 11.2.1. Type de la frontiere
+# 11.2.1. Nom de la frontière
 #
-    TYPE = SIMP(statut='o',typ='TXM',into=("SPHERE", "CYLINDRE"),
-                fr="Type de la frontiere",
-                ang="Type of the boundary" ),
+    NOM = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
+               fr="Nom de la frontière analytique",
+               ang="Name of the analytic boundary" ),
 #
-# 11.2.2. Groupe lie a la frontiere
+# 11.2.2. Type de la frontière
 #
-    GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**',
-                    fr="Liste des groupes de mailles definissant la frontiere",
-                    ang="Groups of meshes which define the boundary" ),
+    TYPE = SIMP(statut='o',typ='TXM',into=("SPHERE", "CYLINDRE"),
+                fr="Type de la frontière analytique",
+                ang="Type of the analytic boundary" ),
 #
 # 11.2.3. Pour une sphere ou un cylindre : rayon et centre
 #
     b_fr_rayon = BLOC( condition = " (TYPE == 'SPHERE') or (TYPE == 'CYLINDRE') " ,
-                       fr="Le rayon et le centre d'une sphere ou d'un cylindre.",
+                       fr="Le rayon et le centre d'une sphère ou d'un cylindre.",
                        ang="The radius and the centre of a sphere or of a cylinder.",
       RAYON = SIMP(statut='o',typ='R',
                    fr="Rayon",
@@ -19091,7 +20432,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                       fr="Abscisse du centre",
                       ang="X for the center"),
       Y_CENTRE = SIMP(statut='o',typ='R',
-                      fr="Ordonnee du centre",
+                      fr="Ordonneée du centre",
                       ang="Y for the center"),
       Z_CENTRE = SIMP(statut='o',typ='R',
                       fr="Cote du centre",
@@ -19107,16 +20448,22 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                    fr="Abscisse du vecteur directeur de l'axe",
                    ang="X for the axial vector"),
       Y_AXE = SIMP(statut='o',typ='R',
-                   fr="Ordonnee du vecteur directeur de l'axe",
+                   fr="Ordonnée du vecteur directeur de l'axe",
                    ang="Y for the axial vector"),
       Z_AXE = SIMP(statut='o',typ='R',
                    fr="Cote du vecteur directeur de l'axe",
                    ang="Z for the axial vector"),
     ) ,
+#
+# 11.2.5. Groupe(s) lie(s) a la frontière
+#
+    GROUP_MA = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**',
+                    fr="Liste des groupes de mailles placées sur la frontière",
+                    ang="Groups of meshes which are located on the boundary" ),
 #
   ) ,
 #
-# 12. Mise à jour de champs sur le nouveau maillage
+# 12. mise à jour de champs sur le nouveau maillage
 #
   MAJ_CHAM = FACT(statut='f',max='**',
                   fr="Mise à jour de champs sur le nouveau maillage.",
@@ -19147,7 +20494,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 # 12.3.2. Sous forme de champ dans un resultat
 #
     RESULTAT = SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther),
-                    fr="Resultat contenant le champ à mettre à jour",
+                    fr="Résultat contenant le champ à mettre à jour",
                     ang="Result with the field to be updated" ),
 #
     b_nom_du_champ = BLOC(condition="(RESULTAT != None)",
@@ -19160,11 +20507,11 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 #
     ),
 #
-# 12.4. Est-ce un champ dérivé
+# 12.4. Les composantes
 #
-    SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),
-                       fr="Paramètre de sensibilité.",
-                       ang="Sensitivity parameter"),
+    NOM_CMP = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                   fr="Liste des composante(s) retenue(s) pour le champ.",
+                   ang="List of the selected component(s) for the field." ),
 #
 # 12.5. Le paramètre temporel pour le champ a interpoler
 #
@@ -19177,7 +20524,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 # 12.5.1. Soit le numero d'ordre
 #
       NUME_ORDRE = SIMP(statut='f',typ='I',
-                        fr="Numero d ordre du champ à mettre à jour",
+                        fr="Numéro d ordre du champ à mettre à jour",
                         ang="Rank of the field to be updated" ),
 #
 # 12.5.2. Soit l'instant
@@ -19208,6 +20555,19 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
       ),
 #
     ),
+#
+# 12.6. Type d'interpolation
+#
+    TYPE_MAJ = SIMP(statut='f',typ='TXM',defaut="AUTO",
+                    into=("AUTO", "ISOP2"),
+                    fr="Type de mise à jour : automatique ou iso-P2",
+                    ang="Type of the updating" ),
+#
+# 12.7. Est-ce un champ dérivé
+#
+    SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),
+                       fr="Paramètre de sensibilité.",
+                       ang="Sensitivity parameter"),
   ),
 #
 # 13. Les Modifications
@@ -19221,7 +20581,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 # 13.1. Changement de degre
 #
       DEGRE         = SIMP(statut='o',typ='TXM',defaut="NON",into=("OUI","NON"),
-                          fr="Changement de degre du maillage",
+                          fr="Changement de degré du maillage",
                           ang="Modification of the degree of the mesh" ),
 #
 # 13.2. Création des joints
@@ -19239,7 +20599,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                         fr="Nombre de noeuds et de mailles du maillage",
                         ang="Number of nodes and meshes in the mesh" ),
 #
-# 14.2. Determination de la qualité des éléments du maillage
+# 14.2. Determination de la qualité des mailles du maillage
 #
   QUALITE        = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
                         fr="Qualité du maillage",
@@ -19271,13 +20631,13 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
 #
 # 15. Unite logique d'un fichier a ajouter a HOMARD.Configuration
 #
-  b_unite = BLOC( condition = " (VERSION_HOMARD == 'V9_N') or \
-                                (VERSION_HOMARD == 'V9_N_PERSO') " ,
-                                fr="Fichier supplementaire.",
+  b_unite = BLOC( condition = " (VERSION_HOMARD == 'V10_N') or \
+                                (VERSION_HOMARD == 'V10_N_PERSO') " ,
+                                fr="Fichier supplémentaire.",
                                 ang="Additional file.",
 #
   UNITE = SIMP(statut='f',typ='I',
-               fr="Unite logique a ajouter a HOMARD.Configuration",
+               fr="Unite logique du fichier à ajouter à HOMARD.Configuration",
                ang="Additional file to HOMARD.Configuration" ),
 #
   ) ,
@@ -19291,10 +20651,10 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada
                              ang="Incompatible meshes for HOMARD" ),
 #
 ) ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -19323,7 +20683,6 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma
                       fr="Réalise l'analyse thermomécanique du coude dont le maillage a été concu par MACR_ASCOUF_MAIL",
                       reentrant='n',
             UIinfo={"groupes":("Résolution","Outils-métier",)},
-         regles=(UN_PARMI('COMP_INCR','COMP_ELAS'),),
 
          TYPE_MAILLAGE   =SIMP(statut='o',typ='TXM',
                                into=("SAIN",
@@ -19347,7 +20706,7 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma
          AFFE_MATERIAU   =FACT(statut='o',max=3,
            regles=(UN_PARMI('TOUT','GROUP_MA'),),
            TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-           GROUP_MA        =SIMP(statut='f',typ='TXM',into=("COUDE","BOL") ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,into=("COUDE","BOL") ),
            MATER           =SIMP(statut='o',typ=mater_sdaster ),
            TEMP_REF        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
          ),
@@ -19375,24 +20734,8 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma
            FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
          ),
 
-         COMP_INCR       =FACT(statut='f',
-           RELATION        =SIMP(statut='o',typ='TXM',into=("VMIS_ISOT_TRAC",) ),
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R'
-                                ,defaut= 1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-           ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut= 0 ),
-           RESO_INTE       =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
-                                 into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")),
-         ),
 
-         COMP_ELAS       =FACT(statut='f',
-           RELATION        =SIMP(statut='o',typ='TXM',into=("ELAS","ELAS_VMIS_TRAC") ),
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-           ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut= 0 ),
-           RESO_INTE       =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
-                                 into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")),
-         ),
+         COMP_ELAS       =C_COMP_ELAS('MACR_ASCOUF_CALC'),
 
          SOLVEUR         =C_SOLVEUR(),
 
@@ -19596,10 +20939,10 @@ MACR_ASCOUF_MAIL=MACRO(nom="MACR_ASCOUF_MAIL",op=macr_ascouf_mail_ops,sd_prod=ma
 
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -19629,7 +20972,6 @@ def macr_aspic_calc_prod(self,MODELE,CHAM_MATER,CARA_ELEM,FOND_FISS_1,FOND_FISS_
 MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_aspic_calc_prod,
             fr="Réalise un calcul prédéfini de piquages sains ou fissurés ainsi que les post-traitements associés ",
             UIinfo={"groupes":("Résolution","Outils-métier",)},reentrant='n',
-         regles=(UN_PARMI('COMP_INCR','COMP_ELAS'),),
 
          TYPE_MAILLAGE   =SIMP(statut='o',typ='TXM',
                                into=("SAIN_FIN","SAIN_GROS","FISS_COUR_DEB","FISS_COUR_NONDEB","FISS_LONG_DEB",
@@ -19649,7 +20991,7 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_
          AFFE_MATERIAU   =FACT(statut='o',max=3,
            regles=(UN_PARMI('TOUT','GROUP_MA'),),
            TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",)),
-           GROUP_MA        =SIMP(statut='f',typ='TXM',into=("TUBU","CORP","SOUD","SOUDCORP","SOUDTUBU") ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,into=("TUBU","CORP","SOUD","SOUDCORP","SOUDTUBU") ),
            MATER           =SIMP(statut='o',typ=mater_sdaster),
            TEMP_REF        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
            RCCM            =SIMP(statut='o',typ='TXM',into=("OUI","NON")),
@@ -19696,23 +21038,7 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_
            FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
          ),
 
-         COMP_INCR       =FACT(statut='f',
-           RELATION        =SIMP(statut='o',typ='TXM',into=("VMIS_ISOT_TRAC",) ),
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut=1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut=10),
-           ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut=0),
-           RESO_INTE       =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
-                                 into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")),
-         ),
-
-         COMP_ELAS       =FACT(statut='f',
-           RELATION        =SIMP(statut='o',typ='TXM',into=("ELAS","ELAS_VMIS_TRAC") ),
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-           ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut= 0 ),
-           RESO_INTE       =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
-                                 into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")),
-         ),
+         COMP_ELAS       =C_COMP_ELAS('MACR_ASPIC_CALC'),
 
          THETA_3D        =FACT(statut='f',max='**',
            R_INF           =SIMP(statut='o',typ='R'),
@@ -19753,8 +21079,7 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_
            b_extrac        =BLOC(condition="((FORMAT=='IDEAS')or(FORMAT=='CASTEM'))",
                                  fr="extraction d un champ de grandeur",
              regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST'),),
-             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,
-                                   into=("DEPL","EQUI_ELNO_SIGM","TEMP")),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,into=("DEPL","SIEQ_ELNO","TEMP")),
 
              TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
              NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
@@ -19940,10 +21265,10 @@ MACR_CARA_POUTRE=MACRO(nom="MACR_CARA_POUTRE",op=macr_cara_poutre_ops,sd_prod=ta
                                  fr="type de conditions aux limites sur le plancher supérieur" ),
             ),
 )
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -19976,7 +21301,7 @@ MACR_ECLA_PG=MACRO(nom="MACR_ECLA_PG",op=macr_ecla_pg_ops,sd_prod=macr_ecla_pg_p
              # SD résultat ,modèle et champs à "éclater" :
              RESU_INIT       =SIMP(statut='o',typ=resultat_sdaster,fr="RESULTAT à éclater",),
              MODELE_INIT     =SIMP(statut='o',typ=modele_sdaster,fr="MODELE à éclater"),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO('ELGA'),),
 
              # paramètres numériques de la commande :
              SHRINK          =SIMP(statut='f',typ='R',defaut= 0.9, fr="Facteur de réduction" ),
@@ -20004,10 +21329,10 @@ MACR_ECLA_PG=MACRO(nom="MACR_ECLA_PG",op=macr_ecla_pg_ops,sd_prod=macr_ecla_pg_p
              b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
                  PRECISION       =SIMP(statut='o',typ='R',),),
             )
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 28/02/2011   AUTEUR BOTTONI M.BOTTONI 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -20035,7 +21360,7 @@ def macr_ecre_calc_prod(self,TABLE,DEBIT,**args):
 MACR_ECRE_CALC=MACRO(nom="MACR_ECRE_CALC",op=macr_ecre_calc_ops,sd_prod=macr_ecre_calc_prod,reentrant='n',
                      UIinfo={"groupes":("Résolution","Outils-métier",)},fr="Procedure de couplage avec Ecrevisse",
 
-         regles             = (UN_PARMI('LOGICIEL','VERSION'),),
+                     regles = (UN_PARMI('LOGICIEL','VERSION'),),
 
 #      CONCEPTS SORTANT : 2 TABLES POUR LE POST-TRAITEMENT
 #      ********************************************
@@ -20180,16 +21505,16 @@ MACR_ECRE_CALC=MACRO(nom="MACR_ECRE_CALC",op=macr_ecre_calc_ops,sd_prod=macr_ecr
          COURBES            =SIMP(statut='f',typ='TXM',into=("INTERACTIF","POSTSCRIPT","AUCUNE"),defaut="AUCUNE",
                                   fr="Generation eventuelle des courbes" ),
          LOGICIEL           =SIMP(statut='f',typ='TXM',validators=LongStr(1,255),),
-         VERSION            =SIMP(statut='f',typ='TXM',defaut="3.1.2",into = ("3.1.1","3.1.2")),
+         VERSION            =SIMP(statut='f',typ='TXM',into = ("3.1.1","3.1.2","3.2")),
          ENTETE             =SIMP(statut='f',typ='TXM',max='**',defaut="Titre du calcul Ecrevisse" ),
          IMPRESSION         =SIMP(statut='f',typ='TXM',defaut='NON',into=( 'OUI','NON') ),
          INFO               =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
 
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 28/02/2011   AUTEUR BOTTONI M.BOTTONI 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -20221,7 +21546,7 @@ def macr_ecrevisse_prod(self,TABLE,TEMPER,DEBIT,**args):
 MACR_ECREVISSE=MACRO(nom="MACR_ECREVISSE",op=macr_ecrevisse_ops,sd_prod=macr_ecrevisse_prod,reentrant='f',
                        UIinfo={"groupes":("Résolution","Outils-métier",)},fr="Procedure de couplage avec Ecrevisse",
 
-       reuse =SIMP(statut='f',typ='evol_noli'),
+       reuse  = SIMP(statut='f',typ='evol_noli'),
        regles = (EXCLUS('TEMPER','ETAT_INIT'),
                  UN_PARMI('LOGICIEL','VERSION'),),
 
@@ -20408,7 +21733,7 @@ MACR_ECREVISSE=MACRO(nom="MACR_ECREVISSE",op=macr_ecrevisse_ops,sd_prod=macr_ecr
          COURBES            = SIMP(statut='f',typ='TXM',into=("INTERACTIF","POSTSCRIPT","AUCUNE"),defaut="AUCUNE",
                                   fr="Generation eventuelle des courbes" ),
          LOGICIEL           = SIMP(statut='f',typ='TXM',validators=LongStr(1,255),),
-         VERSION            = SIMP(statut='f',typ='TXM',defaut="3.1.2",into = ("3.1.1","3.1.2") ),
+         VERSION            =SIMP(statut='f',typ='TXM',into = ("3.1.1","3.1.2","3.2")),
          ENTETE             = SIMP(statut='f',typ='TXM',max='**',defaut="Titre du calcul Ecrevisse" ),
          IMPRESSION         = SIMP(statut='f',typ='TXM',defaut='NON',into=( 'OUI','NON') ),
          INFO               = SIMP(statut='f',typ='I',defaut="1",into=(1,2) ),
@@ -20592,6 +21917,76 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant=
 # ======================================================================
 # RESPONSABLE GNICOLAS G.NICOLAS
 
+from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
+
+MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
+                     docu="U7.04.41",UIinfo={"groupes":("Impression","Outils-métier",)},
+                     fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
+                     ang="Print values for the fiability software",
+#
+# 1. Le niveau d'information
+#
+   INFO           = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+#
+# 2. Impression de la valeur de la cible
+#
+# 2.1. ==> La table contenant la valeur à imprimer
+#
+   TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
+                 fr="Table contenant la valeur cible.",
+                 ang="Table which includes the target value."),
+#
+# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
+#
+   NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM',
+                    fr="Nom du paramètre associé à la valeur cible.",
+                    ang="Name of the parameter connected to the target value."),
+#
+# 3. Impressions des valeurs des éventuels gradients
+#
+   GRADIENTS = FACT(statut='f',min=1,max='**',
+#
+# 3.1. ==> La table contenant la valeur à imprimer
+#
+       TABLE = SIMP(statut='o',typ=table_sdaster,
+                    fr="Table contenant le gradient.",
+                    ang="Table which includes the gradient."),
+#
+# 3.2. ==> Le paramètre sensible
+#
+       PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom),
+                       fr="Paramètre sensible associé au gradient.",
+                       ang="Sensitivity parameter connected to the gradient."),
+#
+# 3.3. ==> Le nom du paramètre associé au gradient dans cette table
+#
+       NOM_PARA = SIMP(statut='o',typ='TXM',
+                       fr="Nom du paramètre associé au gradient.",
+                       ang="Name of the parameter connected to the gradient."),
+#
+         ),
+#
+);
+#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+
 from Macro.macr_fiabilite_ops import macr_fiabilite_ops
 
 #
@@ -20951,97 +22346,28 @@ MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops,
    ),
 #
 );
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 11/05/2011   AUTEUR SELLENET N.SELLENET 
+# -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
 # ======================================================================
 # RESPONSABLE GNICOLAS G.NICOLAS
 
-from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
-
-MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
-                     docu="U7.04.41",UIinfo={"groupes":("Impression","Outils-métier",)},
-                     fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
-                     ang="Print values for the fiability software",
-#
-# 1. Le niveau d'information
-#
-   INFO           = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-#
-# 2. Impression de la valeur de la cible
-#
-# 2.1. ==> La table contenant la valeur à imprimer
-#
-   TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
-                 fr="Table contenant la valeur cible.",
-                 ang="Table which includes the target value."),
-#
-# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
-#
-   NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM',
-                    fr="Nom du paramètre associé à la valeur cible.",
-                    ang="Name of the parameter connected to the target value."),
-#
-# 3. Impressions des valeurs des éventuels gradients
-#
-   GRADIENTS = FACT(statut='f',min=1,max='**',
-#
-# 3.1. ==> La table contenant la valeur à imprimer
-#
-       TABLE = SIMP(statut='o',typ=table_sdaster,
-                    fr="Table contenant le gradient.",
-                    ang="Table which includes the gradient."),
-#
-# 3.2. ==> Le paramètre sensible
-#
-       PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom),
-                       fr="Paramètre sensible associé au gradient.",
-                       ang="Sensitivity parameter connected to the gradient."),
-#
-# 3.3. ==> Le nom du paramètre associé au gradient dans cette table
-#
-       NOM_PARA = SIMP(statut='o',typ='TXM',
-                       fr="Nom du paramètre associé au gradient.",
-                       ang="Name of the parameter connected to the gradient."),
-#
-         ),
-#
-);
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR GNICOLAS G.NICOLAS 
-#            CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
-# (AT YOUR OPTION) ANY LATER VERSION.                                 
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
-# ======================================================================
-# RESPONSABLE GNICOLAS G.NICOLAS
-
-from Macro.macr_adap_mail_ops import macr_adap_mail_ops
+from Macro.macr_adap_mail_ops import macr_adap_mail_ops
 
 MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops,
                      docu="U7.03.02",UIinfo={"groupes":("Maillage",)},
@@ -21054,14 +22380,14 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops,
 #
 # 2. Version de HOMARD
 #
-  VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_8",
-                        into=("V9_8", "V9_N", "V9_N_PERSO"),
+  VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V10_1",
+                        into=("V10_1", "V10_N", "V10_N_PERSO"),
                         fr="Version de HOMARD",
                         ang="HOMARD release"),
 #
 # 3. Langue des messages issus de HOMARD
 #
-  LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS",    
+  LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS",
                 into=("FRANCAIS","FRENCH","ANGLAIS","ENGLISH",),
                 fr="Langue des messages issus de HOMARD.",
                 ang="Language for HOMARD messages." ),
@@ -21088,7 +22414,7 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops,
 #
                     ) ,
 #
-# 6. Les options ; par defaut, on controle tout
+# 6. Les options ; par defaut, on controle tout, sauf l'interpénétration
 # 6.1. Nombre de noeuds et mailles
 #
   NOMBRE         = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),
@@ -21113,10 +22439,10 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops,
                         fr="Tailles des sous-domaines du maillage.",
                         ang="Sizes of mesh sub-domains." ),
 #
-# 6.5. Controle de la non-interpenetration des elements
+# 6.5. Controle de la non-interpénétration des mailles
 #
   INTERPENETRATION=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
-                        fr="Controle de la non interpénétration des éléments.",
+                        fr="Controle de la non interpénétration des mailles.",
                         ang="Overlapping checking." ),
 #
 # 6.6. Propriétés du maillage de calcul
@@ -21125,10 +22451,10 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops,
                         fr="Propriétés du maillage de calcul.",
                         ang="Properties of the calculation mesh." ),
 #
-# 7. Unite logique d'un fichier a ajouter a HOMARD.Configuration
+# 7. Unite logique d'un fichier à ajouter a HOMARD.Configuration
 #
-  b_unite = BLOC( condition = " (VERSION_HOMARD == 'V9_N') or \
-                                (VERSION_HOMARD == 'V9_N_PERSO') " ,
+  b_unite = BLOC( condition = " (VERSION_HOMARD == 'V10_N') or \
+                                (VERSION_HOMARD == 'V10_N_PERSO') " ,
                                 fr="Fichier supplementaire.",
                                 ang="Additional file.",
 #
@@ -21146,10 +22472,11 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops,
                              fr="Acceptation de mailles incompatibles avec HOMARD",
                              ang="Incompatible meshes for HOMARD" ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -21193,13 +22520,19 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table
 
 # extraction des résultats
          b_meca        =BLOC(condition = "AsType(RESULTAT) in (evol_elas,evol_noli)",fr="résultat mécanique",
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut='SIGM_NOEU_DEPL' ),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut='SIGM_NOEU',into=C_NOM_CHAM_INTO(),),
          ),
          b_ther        =BLOC(condition = "AsType(RESULTAT) in (evol_ther,)",fr="résultat thermique",
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut='TEMP' ),
-         ),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut='TEMP',into=("TEMP",
+                                 "FLUX_ELGA","FLUX_ELNO","FLUX_NOEU",
+                                 "META_ELNO","META_NOEU",
+                                 "DURT_ELNO","DURT_NOEU",
+                                 "HYDR_ELNO","HYDR_NOEU",
+                                 "DETE_ELNO","DETE_NOEU",
+                                 "SOUR_ELGA","COMPORTHER",
+                                 "ERTH_ELEM","ERTH_ELNO","ERTH_NOEU",),),),
          b_cham       =BLOC(condition = "CHAM_GD!=None",
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',),),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO(),),),
 
          UNITE_MAILLAGE  =SIMP(statut='f',typ='I',defaut=25),
          MODELE          =SIMP(statut='f',typ=modele_sdaster ),
@@ -21233,7 +22566,7 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table
 
 
            b_local        =BLOC(condition = "REPERE=='LOCAL' ",
-             VECT_Y          =SIMP(statut='o',typ='R',min=2,max=3),),
+             VECT_Y          =SIMP(statut='f',typ='R',min=2,max=3),),
 
            b_utili        =BLOC(condition = "REPERE=='UTILISATEUR'",
              ANGL_NAUT       =SIMP(statut='o',typ='R',min=3,max=3),),
@@ -21269,10 +22602,195 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table
 )  ;
 
 
+#& MODIF COMMANDE  DATE 28/03/2011   AUTEUR ASSIRE A.ASSIRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+
+from Macro.macr_recal_ops import macr_recal_ops
+
+def macr_recal_prod(self,**args ):
+  return listr8_sdaster
+
+MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,
+            UIinfo={"groupes":("Résolution","Résultats et champs",)},
+                      sd_prod=macr_recal_prod,
+                      fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux"
+                        +" ou sur d'autres résultats de calculs",
+
+         UNITE_ESCL      =SIMP(statut='o',typ='I'),
+         RESU_EXP        =SIMP(statut='o',typ=assd,max='**'),
+         POIDS           =SIMP(statut='f',typ=assd,max='**'),
+         RESU_CALC       =SIMP(statut='o',typ=assd,max='**'),
+         LIST_PARA       =SIMP(statut='o',typ=assd,max='**'),
+
+         UNITE_RESU      =SIMP(statut='f',typ='I',defaut=91),
+         PARA_DIFF_FINI  =SIMP(statut='f',typ='R',defaut=0.001),
+
+         GRAPHIQUE       =FACT(statut='f',
+             FORMAT          =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT"),),
+             AFFICHAGE       =SIMP(statut='f',typ='TXM',defaut='TOUTE_ITERATION',into=("TOUTE_ITERATION","ITERATION_FINALE"),),
+             b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", fr="Mots-clés propres à XMGRACE",
+                 PILOTE          =SIMP(statut='f',typ='TXM',defaut='', 
+                                       into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),
+                            fr="Pilote de sortie, PNG/JPEG/PDF ne sont pas disponibles sur toutes les installations de xmgrace"),
+                 UNITE           =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
+                            fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+             ),
+         ),
+
+
+         # Methodes d'optimisation
+         # -----------------------
+         METHODE         =SIMP(statut='f',typ='TXM',defaut='LEVENBERG',into=("LEVENBERG", "FMIN", "FMINBFGS", "FMINNCG",
+                                                                             "GENETIQUE","HYBRIDE")),
+
+         b_genetique_options=BLOC(condition = "METHODE == 'GENETIQUE' or METHODE == 'HYBRIDE'" ,
+             NB_PARENTS       =SIMP(statut='f',typ='I',defaut=10),
+             NB_FILS          =SIMP(statut='f',typ='I',defaut=5),
+             ECART_TYPE       =SIMP(statut='f',typ='R',defaut=1.),
+             GRAINE           =SIMP(statut='f',typ='I'),
+             ITER_ALGO_GENE   =SIMP(statut='f',typ='I',defaut=10),
+             RESI_ALGO_GENE   =SIMP(statut='f',typ='R',defaut=1.E-3),
+         ),
+         
+
+         # Criteres d'arret globaux
+         # -------------------------
+         ITER_MAXI       =SIMP(statut='f',typ='I',defaut=10,    fr="Nombre maximum d'iterations d'optimisation"),
+         ITER_FONC_MAXI  =SIMP(statut='f',typ='I',defaut=1000,  fr="Nombre maximum d'evaluations de la focntionnelle"),
+         RESI_GLOB_RELA  =SIMP(statut='f',typ='R',defaut=1.E-3, fr="Critere d'arret sur la valeur du residu"),
+         TOLE_PARA       =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur des parametres"),
+         TOLE_FONC       =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur de la fonctionnelle"),
+
+
+         # Calculs des gradients
+         # ---------------------
+         b_gradient =BLOC(condition = "METHODE == 'FMINBFGS' or METHODE == 'FMINNCG'" ,
+             GRADIENT        =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )),
+         ),
+
+         b_gradient_levenberg =BLOC(condition = "METHODE == 'LEVENBERG'" ,
+             GRADIENT        =SIMP(statut='f',typ='TXM',defaut='NORMAL', into=( "NORMAL", "ADIMENSIONNE" )),
+         ),
+
+
+         # Mode d'evaluation de l'esclave
+         # ------------------------------
+         CALCUL_ESCLAVE       =FACT(statut='d',
+            LANCEMENT         =SIMP(statut='f', typ='TXM', defaut='INCLUSION',into=("DISTRIBUTION","INCLUSION"),),
+
+            b_eval_distrib =BLOC(condition = "LANCEMENT == 'DISTRIBUTION'",
+                UNITE_SUIVI   =SIMP(statut='f', typ='I',val_min=10,val_max=99,defaut=29, 
+                                  fr="Affichage de l'output et/ou error des jobs esclaves dans ce fichier"),
+                MODE          =SIMP(statut='f', typ='TXM',      into=("INTERACTIF","BATCH"),),
+                MEMOIRE       =SIMP(statut='f', typ='I',        fr="Memoire demandee pour les calculs esclaves (Mo)"),
+                TEMPS         =SIMP(statut='f', typ='I',        fr="Temps demandee pour les calculs esclaves (secondes)"),
+                CLASSE        =SIMP(statut='f', typ='TXM',      fr="Classe demandee pour les calculs en batch"),
+                NMAX_SIMULT   =SIMP(statut='f', typ='I',
+                               fr="Nombre de calculs esclaves lances en paralle en mode distribution (non precise = automatique)"),
+            ),
+         ),
+
+         DYNAMIQUE       =FACT(statut='f',
+               MODE_EXP           =SIMP(statut='o',typ='TXM'),
+               MODE_CALC          =SIMP(statut='o',typ='TXM'),
+               APPARIEMENT_MANUEL =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")),           
+                               ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut=1, into=( 1, 2 ) ),
+);
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE VOLDOIRE F.VOLDOIRE
+
+from Macro.macr_spectre_ops import macr_spectre_ops
+
+MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster,
+                       reentrant='n',
+                       UIinfo={"groupes":("Post-traitements","Outils-métier",)},
+                       fr="Calcul de spectre, post-traitement de séisme",
+         MAILLAGE      =SIMP(statut='o',typ=maillage_sdaster,),
+         PLANCHER      =FACT(statut='o',max='**',
+            regles=(AU_MOINS_UN('NOEUD','GROUP_NO' ),),
+            NOM           =SIMP(statut='o',typ='TXM',),
+            GROUP_NO      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            NOEUD         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'), ),
+         NOM_CHAM      =SIMP(statut='o',typ='TXM' ,into=('ACCE','DEPL')),
+         CALCUL        =SIMP(statut='o',typ='TXM' ,into=('ABSOLU','RELATIF'),position='global'),
+         b_acce  =BLOC( condition = "NOM_CHAM=='ACCE'",
+           regles=(UN_PARMI('LIST_FREQ','FREQ'),),
+           AMOR_SPEC     =SIMP(statut='o',typ='R',max='**'),
+           LIST_INST     =SIMP(statut='f',typ=listr8_sdaster ),
+           LIST_FREQ     =SIMP(statut='f',typ=listr8_sdaster ),
+           FREQ          =SIMP(statut='f',typ='R',max='**'),
+           NORME         =SIMP(statut='o',typ='R'),  
+           RESU          =FACT(statut='o',max='**',
+                regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
+                RESU_GENE     =SIMP(statut='f',typ=tran_gene),
+                RESULTAT      =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
+                b_calc  =BLOC( condition = "CALCUL=='RELATIF'",
+                   ACCE_X        =SIMP(statut='o',typ=fonction_sdaster),
+                   ACCE_Y        =SIMP(statut='o',typ=fonction_sdaster),
+                   ACCE_Z        =SIMP(statut='o',typ=fonction_sdaster),), ),
+           IMPRESSION    =FACT(statut='f',
+                TRI           =SIMP(statut='f',typ='TXM',defaut='AMOR_SPEC',into=("AMOR_SPEC","DIRECTION",),),
+                FORMAT        =SIMP(statut='f',typ='TXM',defaut='TABLEAU',into=("TABLEAU","XMGRACE",),),
+                UNITE         =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
+                                    fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+                b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'",
+                   PILOTE        =SIMP(statut='f',typ='TXM',defaut='',
+                                 into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),),),
+                TOUT          =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON",),),
+                              ),
+         ),
+         b_depl  =BLOC( condition = "NOM_CHAM=='DEPL'",
+           LIST_INST     =SIMP(statut='f',typ=listr8_sdaster),  
+           RESU          =FACT(statut='o',max=3,
+                regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
+                RESU_GENE     =SIMP(statut='f',typ=tran_gene),
+                RESULTAT      =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
+                b_calc  =BLOC( condition = "CALCUL=='ABSOLU'",
+                   DEPL_X        =SIMP(statut='o',typ=fonction_sdaster),
+                   DEPL_Y        =SIMP(statut='o',typ=fonction_sdaster),
+                   DEPL_Z        =SIMP(statut='o',typ=fonction_sdaster),),),
+         ),
+)
+#& MODIF COMMANDE  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -21318,17 +22836,17 @@ MACRO_ELAS_MULT=MACRO(nom="MACRO_ELAS_MULT",op=macro_elas_mult_ops,sd_prod=macro
            TYPE_MODE       =SIMP(statut='f',typ='TXM',defaut="SYME",into=("SYME","ANTI","TOUS") ),
            CHAR_MECA       =SIMP(statut='f',typ=(char_meca),validators=NoRepeat(),max='**'),
            OPTION          =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',
-                                 into=("EFGE_ELNO_DEPL","EPOT_ELEM_DEPL","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL",
-                                       "SIGM_ELNO_CART","EFGE_ELNO_CART","DEGE_ELNO_DEPL","EPSI_ELNO_DEPL",
-                                       "EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL","EPSP_ELNO","EPSP_ELGA",
-                                       "ECIN_ELEM_DEPL","FLUX_ELGA_TEMP","FLUX_ELNO_TEMP","SOUR_ELGA_ELEC",
-                                       "PRES_ELNO_DBEL","PRES_ELNO_REEL","PRES_ELNO_IMAG","INTE_ELNO_ACTI",
-                                       "INTE_ELNO_REAC","SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA",
-                                       "ERZ2_ELEM_SIGM","VNOR_ELEM_DEPL","ERRE_ELNO_ELEM",
-                                       "ERRE_ELEM_SIGM","EQUI_ELNO_SIGM","EQUI_ELGA_SIGM","EQUI_ELNO_EPSI",
-                                       "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
-                                       "EQUI_ELGA_EPSI","FORC_NODA","REAC_NODA","EPSI_NOEU_DEPL","SIGM_NOEU_DEPL",
-                                       "EFGE_NOEU_DEPL","EQUI_NOEU_SIGM","EQUI_NOEU_EPSI","FLUX_NOEU_TEMP") ),
+                                 into=("EFGE_ELNO","EPOT_ELEM","SIGM_ELNO","SIEF_ELGA",
+                                       "SICA_ELNO","EFCA_ELNO","DEGE_ELNO","EPSI_ELNO",
+                                       "EPSI_ELGA","EPSG_ELNO","EPSG_ELGA","EPSP_ELNO","EPSP_ELGA",
+                                       "ECIN_ELEM","FLUX_ELGA","FLUX_ELNO","SOUR_ELGA",
+                                       "PRAC_ELNO","INTE_ELNO",
+                                       "SIZ1_ELGA","ERZ1_ELEM","SIZ2_ELGA",
+                                       "ERZ2_ELEM","VNOR_ELEM_DEPL","ERME_ELNO",
+                                       "ERME_ELEM","SIEQ_ELNO","SIEQ_ELGA","EPEQ_ELNO",
+                                       "QIRE_ELEM","QIRE_ELNO","QIZ1_ELEM","QIZ2_ELEM",
+                                       "EPEQ_ELGA","FORC_NODA","REAC_NODA","EPSI_NOEU","SIGM_NOEU",
+                                       "EFGE_NOEU","SIEQ_NOEU","EPEQ_NOEU","FLUX_NOEU") ),
            NUME_COUCHE     =SIMP(statut='f',typ='I',defaut=1),
            NIVE_COUCHE     =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY")),
            SOUS_TITRE      =SIMP(statut='f',typ='TXM',max='**'),
@@ -21352,10 +22870,10 @@ MACRO_ELAS_MULT=MACRO(nom="MACRO_ELAS_MULT",op=macro_elas_mult_ops,sd_prod=macro
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2)),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 13/01/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -21404,7 +22922,7 @@ MACRO_EXPANS=MACRO(nom="MACRO_EXPANS",
                            MODELE          = SIMP(statut='o',typ=(modele_sdaster) ),
                            MESURE          = SIMP(statut='o',typ=(dyna_trans,dyna_harmo,mode_meca,mode_meca_c,) ),
                            NOM_CHAM        = SIMP(statut='f',typ='TXM',defaut="DEPL",
-                                                  into=("DEPL","VITE","ACCE","SIEF_NOEU","EPSI_NOEU_DEPL",) ),
+                                                  into=("DEPL","VITE","ACCE","SIEF_NOEU","EPSI_NOEU",) ),
                            NUME_MODE       = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0),
                            NUME_ORDRE      = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0),
 
@@ -21427,10 +22945,10 @@ MACRO_EXPANS=MACRO(nom="MACRO_EXPANS",
                                         ),
                                              ),
                    )
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -21529,7 +23047,7 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -21554,7 +23072,7 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -21569,10 +23087,10 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro
          NOEUD_DOUBLE    =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
          AVEC_MODE_STAT  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
 )
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 18/01/2011   AUTEUR BOITEAU O.BOITEAU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -21636,8 +23154,9 @@ MACRO_MATR_ASSE=MACRO(nom="MACRO_MATR_ASSE",op=macro_matr_asse_ops,
            RENUM           =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK"  ),
          ),
          b_mumps         =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
-           RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+           RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
            OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+           LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
          ),
          b_gcpc          =BLOC(condition="METHODE=='GCPC'",fr="Paramètres associés à la méthode gradient conjugué",
            RENUM           =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK"  ),
@@ -21878,209 +23397,26 @@ MACRO_PROJ_BASE=MACRO(nom="MACRO_PROJ_BASE",op=macro_proj_base_ops,
          fr="Projection des matrices et/ou vecteurs assemblés sur une base (modale ou de RITZ)",
          BASE            =SIMP(statut='o',typ=(mode_meca,mode_gene) ),
          NB_VECT         =SIMP(statut='f',typ='I',defaut= 9999),
-         PROFIL          =SIMP(statut='f',typ='TXM',defaut="DIAG",into=("PLEIN","DIAG") ),
-         MATR_ASSE_GENE  =FACT(statut='f',max='**',
-           MATRICE         =SIMP(statut='o',typ=CO,),
-           regles=(UN_PARMI('MATR_ASSE','MATR_ASSE_GENE',),),
-           MATR_ASSE       =SIMP(statut='f',typ=matr_asse_depl_r),
-           MATR_ASSE_GENE  =SIMP(statut='f',typ=matr_asse_gene_r),
-         ),
-         VECT_ASSE_GENE  =FACT(statut='f',max='**',
-           VECTEUR         =SIMP(statut='o',typ=CO,),
-           regles=(UN_PARMI('VECT_ASSE','VECT_ASSE_GENE',),),
-           TYPE_VECT       =SIMP(statut='f',typ='TXM',defaut="FORC"),
-           VECT_ASSE       =SIMP(statut='f',typ=cham_no_sdaster),
-           VECT_ASSE_GENE  =SIMP(statut='f',typ=vect_asse_gene),
-         ),
-         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-)  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
-#            CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
-# ======================================================================
-# RESPONSABLE ASSIRE A.ASSIRE
-
-from Macro.macr_recal_ops import macr_recal_ops
-
-def macr_recal_prod(self,**args ):
-  return listr8_sdaster
-
-MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,
-            UIinfo={"groupes":("Résolution","Résultats et champs",)},
-                      sd_prod=macr_recal_prod,
-                      fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux"
-                        +" ou sur d'autres résultats de calculs",
-
-         UNITE_ESCL      =SIMP(statut='o',typ='I'),
-         RESU_EXP        =SIMP(statut='o',typ=assd,max='**'),
-         POIDS           =SIMP(statut='f',typ=assd,max='**'),
-         RESU_CALC       =SIMP(statut='o',typ=assd,max='**'),
-         LIST_PARA       =SIMP(statut='o',typ=assd,max='**'),
-
-         UNITE_RESU      =SIMP(statut='f',typ='I',defaut=91),
-         PARA_DIFF_FINI  =SIMP(statut='f',typ='R',defaut=0.001),
-
-         GRAPHIQUE       =FACT(statut='f',
-             FORMAT          =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT"),),
-             AFFICHAGE       =SIMP(statut='f',typ='TXM',defaut='TOUTE_ITERATION',into=("TOUTE_ITERATION","ITERATION_FINALE"),),
-             b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'", fr="Mots-clés propres à XMGRACE",
-                 PILOTE          =SIMP(statut='f',typ='TXM',defaut='', 
-                                       into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),
-                            fr="Pilote de sortie, PNG/JPEG/PDF ne sont pas disponibles sur toutes les installations de xmgrace"),
-                 UNITE           =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
-                            fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
-             ),
-         ),
-
-
-         # Methodes d'optimisation
-         # -----------------------
-         METHODE         =SIMP(statut='f',typ='TXM',defaut='LEVENBERG',into=("LEVENBERG", "FMIN", "FMINBFGS", "FMINNCG",
-                                                                             "GENETIQUE","HYBRIDE")),
-
-         b_genetique_options=BLOC(condition = "METHODE == 'GENETIQUE' or METHODE == 'HYBRIDE'" ,
-             NB_PARENTS       =SIMP(statut='f',typ='I',defaut=10),
-             NB_FILS          =SIMP(statut='f',typ='I',defaut=5),
-             ECART_TYPE       =SIMP(statut='f',typ='R',defaut=1.),
-             GRAINE           =SIMP(statut='f',typ='I'),
-             ITER_ALGO_GENE   =SIMP(statut='f',typ='I',defaut=10),
-             RESI_ALGO_GENE   =SIMP(statut='f',typ='R',defaut=1.E-3),
-         ),
-         
-
-         # Criteres d'arret globaux
-         # -------------------------
-         ITER_MAXI       =SIMP(statut='f',typ='I',defaut=10,    fr="Nombre maximum d'iterations d'optimisation"),
-         ITER_FONC_MAXI  =SIMP(statut='f',typ='I',defaut=1000,  fr="Nombre maximum d'evaluations de la focntionnelle"),
-         RESI_GLOB_RELA  =SIMP(statut='f',typ='R',defaut=1.E-3, fr="Critere d'arret sur la valeur du residu"),
-         TOLE_PARA       =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur des parametres"),
-         TOLE_FONC       =SIMP(statut='f',typ='R',defaut=1.E-8, fr="Critere d'arret sur la valeur de la fonctionnelle"),
-
-
-         # Calculs des gradients
-         # ---------------------
-         b_gradient =BLOC(condition = "METHODE == 'FMINBFGS' or METHODE == 'FMINNCG'" ,
-             GRADIENT        =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )),
-         ),
-
-         b_gradient_levenberg =BLOC(condition = "METHODE == 'LEVENBERG'" ,
-             GRADIENT        =SIMP(statut='f',typ='TXM',defaut='NORMAL', into=( "NORMAL", "ADIMENSIONNE" )),
-         ),
-
-
-         # Mode d'evaluation de l'esclave
-         # ------------------------------
-         CALCUL_ESCLAVE       =FACT(statut='d',
-            LANCEMENT         =SIMP(statut='f', typ='TXM', defaut='INCLUSION',into=("DISTRIBUTION","INCLUSION"),),
-
-            b_eval_distrib =BLOC(condition = "LANCEMENT == 'DISTRIBUTION'",
-                MODE          =SIMP(statut='f', typ='TXM',      into=("INTERACTIF","BATCH"),),
-                MEMOIRE       =SIMP(statut='f', typ='I',        fr="Memoire demandee pour les calculs esclaves (Mo)"),
-                TEMPS         =SIMP(statut='f', typ='I',        fr="Temps demandee pour les calculs esclaves (secondes)"),
-                CLASSE        =SIMP(statut='f', typ='TXM',      fr="Classe demandee pour les calculs en batch"),
-                NMAX_SIMULT   =SIMP(statut='f', typ='I',
-                               fr="Nombre de calculs esclaves lances en paralle en mode distribution (non precise = automatique)"),
-            ),
-         ),
-
-         DYNAMIQUE       =FACT(statut='f',
-               MODE_EXP           =SIMP(statut='o',typ='TXM'),
-               MODE_CALC          =SIMP(statut='o',typ='TXM'),
-               APPARIEMENT_MANUEL =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")),           
-                               ),
-
-         INFO            =SIMP(statut='f',typ='I',defaut=2,into=( 1, 2 ) ),
-);
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
-#            CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
-# (AT YOUR OPTION) ANY LATER VERSION.                                                  
-#                                                                       
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
-#                                                                       
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
-#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
-# ======================================================================
-# RESPONSABLE VOLDOIRE F.VOLDOIRE
-
-from Macro.macr_spectre_ops import macr_spectre_ops
-
-MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster,
-                       reentrant='n',
-                       UIinfo={"groupes":("Post-traitements","Outils-métier",)},
-                       fr="Calcul de spectre, post-traitement de séisme",
-         MAILLAGE      =SIMP(statut='o',typ=maillage_sdaster,),
-         PLANCHER      =FACT(statut='o',max='**',
-            regles=(AU_MOINS_UN('NOEUD','GROUP_NO' ),),
-            NOM           =SIMP(statut='o',typ='TXM',),
-            GROUP_NO      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-            NOEUD         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'), ),
-         NOM_CHAM      =SIMP(statut='o',typ='TXM' ,into=('ACCE','DEPL')),
-         CALCUL        =SIMP(statut='o',typ='TXM' ,into=('ABSOLU','RELATIF'),position='global'),
-         b_acce  =BLOC( condition = "NOM_CHAM=='ACCE'",
-           regles=(UN_PARMI('LIST_FREQ','FREQ'),),
-           AMOR_SPEC     =SIMP(statut='o',typ='R',max='**'),
-           LIST_INST     =SIMP(statut='f',typ=listr8_sdaster ),
-           LIST_FREQ     =SIMP(statut='f',typ=listr8_sdaster ),
-           FREQ          =SIMP(statut='f',typ='R',max='**'),
-           NORME         =SIMP(statut='o',typ='R'),  
-           RESU          =FACT(statut='o',max='**',
-                regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
-                RESU_GENE     =SIMP(statut='f',typ=tran_gene),
-                RESULTAT      =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
-                b_calc  =BLOC( condition = "CALCUL=='RELATIF'",
-                   ACCE_X        =SIMP(statut='o',typ=fonction_sdaster),
-                   ACCE_Y        =SIMP(statut='o',typ=fonction_sdaster),
-                   ACCE_Z        =SIMP(statut='o',typ=fonction_sdaster),), ),
-           IMPRESSION    =FACT(statut='f',
-                TRI           =SIMP(statut='f',typ='TXM',defaut='AMOR_SPEC',into=("AMOR_SPEC","DIRECTION",),),
-                FORMAT        =SIMP(statut='f',typ='TXM',defaut='TABLEAU',into=("TABLEAU","XMGRACE",),),
-                UNITE         =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
-                                    fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
-                b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'",
-                   PILOTE        =SIMP(statut='f',typ='TXM',defaut='',
-                                 into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),),),
-                TOUT          =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON",),),
-                              ),
-         ),
-         b_depl  =BLOC( condition = "NOM_CHAM=='DEPL'",
-           LIST_INST     =SIMP(statut='f',typ=listr8_sdaster),  
-           RESU          =FACT(statut='o',max=3,
-                regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
-                RESU_GENE     =SIMP(statut='f',typ=tran_gene),
-                RESULTAT      =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
-                b_calc  =BLOC( condition = "CALCUL=='ABSOLU'",
-                   DEPL_X        =SIMP(statut='o',typ=fonction_sdaster),
-                   DEPL_Y        =SIMP(statut='o',typ=fonction_sdaster),
-                   DEPL_Z        =SIMP(statut='o',typ=fonction_sdaster),),),
+         PROFIL          =SIMP(statut='f',typ='TXM',defaut="DIAG",into=("PLEIN","DIAG") ),
+         MATR_ASSE_GENE  =FACT(statut='f',max='**',
+           MATRICE         =SIMP(statut='o',typ=CO,),
+           regles=(UN_PARMI('MATR_ASSE','MATR_ASSE_GENE',),),
+           MATR_ASSE       =SIMP(statut='f',typ=matr_asse_depl_r),
+           MATR_ASSE_GENE  =SIMP(statut='f',typ=matr_asse_gene_r),
          ),
-)
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+         VECT_ASSE_GENE  =FACT(statut='f',max='**',
+           VECTEUR         =SIMP(statut='o',typ=CO,),
+           regles=(UN_PARMI('VECT_ASSE','VECT_ASSE_GENE',),),
+           TYPE_VECT       =SIMP(statut='f',typ='TXM',defaut="FORC"),
+           VECT_ASSE       =SIMP(statut='f',typ=cham_no_sdaster),
+           VECT_ASSE_GENE  =SIMP(statut='f',typ=vect_asse_gene),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 01/03/2011   AUTEUR LEFEBVRE J-P.LEFEBVRE 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -22096,17 +23432,21 @@ MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster,
 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
 # ======================================================================
 # RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+#
 MAJ_CATA=PROC(nom="MAJ_CATA",op=20,
-            UIinfo={"groupes":("Gestion du travail",)},
-              fr="Compilation des catalogues de commandes et d'éléments",
+              UIinfo={"groupes":("Gestion du travail",)},
+              fr="Compilation des catalogues d'éléments et couverture des calculs élémentaires",
+              regles=(UN_PARMI('ELEMENT','TYPE_ELEM', ),),
 
-         ELEMENT         =FACT(statut='f',),
+              ELEMENT     =FACT(statut='f',),
 
-)  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+              UNITE       =SIMP(statut='f',typ='I',defaut=8),       
+              TYPE_ELEM   =FACT(statut='f',),
+);
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -22144,7 +23484,7 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas,
          INST            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
          LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
          INST_FIN        =SIMP(statut='f',typ='R'),
-         OPTION          =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA_DEPL","SANS"),defaut="SIEF_ELGA_DEPL",max=1,
+         OPTION          =SIMP(statut='f',typ='TXM',into=("SIEF_ELGA","SANS"),defaut="SIEF_ELGA",max=1,
              fr="seule option : contraintes aux points de Gauss. Utiliser CALC_ELEM pour les autres.",
                           ),
          SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
@@ -22194,7 +23534,7 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas,
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -22204,12 +23544,13 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.0E-6,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              MATR_DISTRIBUEE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
 
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
@@ -22221,7 +23562,7 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas,
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -22291,10 +23632,10 @@ MODE_ITER_CYCL=OPER(nom="MODE_ITER_CYCL",op=  80,sd_prod=mode_cycl,
          ),
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 18/01/2011   AUTEUR BOITEAU O.BOITEAU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -22362,11 +23703,12 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op=  44,sd_prod=mode_iter_inv_prod
                  TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
                  PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
                  POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
                  ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
                  PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
                  RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
                  OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                 LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
                ),
              ),
 
@@ -22403,11 +23745,12 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op=  44,sd_prod=mode_iter_inv_prod
                  TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
                  PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
                  POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
                  ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
                  PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
                  RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
                  OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                 LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
                ),
              ),
              
@@ -22434,10 +23777,10 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op=  44,sd_prod=mode_iter_inv_prod
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
          TITRE           =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 18/01/2011   AUTEUR BOITEAU O.BOITEAU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -22546,11 +23889,12 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op=  45,sd_prod=mode_iter_simult_pr
                  TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
                  PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
                  POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
                  ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
                  PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
                  RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
                  OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                 LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
                ),
              ),
          ),
@@ -22599,11 +23943,12 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op=  45,sd_prod=mode_iter_simult_pr
                  TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
                  PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
                  POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+                 RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
                  ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
                  PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
                  RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
                  OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                 LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),               
                ),
              ),
 
@@ -22629,10 +23974,10 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op=  45,sd_prod=mode_iter_simult_pr
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),        
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -22654,7 +23999,6 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca,
                    reentrant='n',
             UIinfo={"groupes":("Résolution","Dynamique",)},
             
-            
          regles=(UN_PARMI('MODE_STAT','FORCE_NODALE','PSEUDO_MODE','MODE_INTERF'),
                  PRESENT_PRESENT('MODE_INTERF','MATR_MASS'),
                  PRESENT_PRESENT('PSEUDO_MODE','MATR_MASS'),
@@ -22736,11 +24080,12 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
 
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
@@ -22752,7 +24097,7 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca,
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -22770,7 +24115,7 @@ MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca,
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -22816,6 +24161,45 @@ MODI_BASE_MODALE=OPER(nom="MODI_BASE_MODALE",op= 149,sd_prod=mode_meca,
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
+#& MODIF COMMANDE  DATE 14/02/2011   AUTEUR GREFFET N.GREFFET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GREFFET N.GREFFET
+#
+#  RECUPERATION DES EFFORTS VIA YACS POUR COUPLAGE IFS
+#
+MODI_CHAR_YACS=OPER(nom            = "MODI_CHAR_YACS",
+                   op              = 112,
+                   sd_prod         = char_meca,
+                   reentrant       = 'o',
+                   UIinfo          = {"groupes":("Résultats et champs",)},
+                   fr              = "Reception des forces nodales via YACS lors du couplage de  Code_Aster et Saturne",
+                   CHAR_MECA       = SIMP(statut ='o', typ = char_meca),
+                   MATR_PROJECTION = SIMP(statut ='o', typ = corresp_2_mailla,),
+                   NOM_CMP_IFS     = SIMP(statut ='o', typ = 'TXM',validators = NoRepeat(), max = '**'),
+                   VIS_A_VIS       = FACT(statut ='o', max = '**',
+                                   GROUP_MA_1 = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+                                   GROUP_NO_2 = SIMP(statut='o',typ=grno,validators=NoRepeat(),max='**'),),
+                   INST            = SIMP(statut='o',typ='R', ),
+                   PAS             = SIMP(statut='o',typ='R', ),
+                   NUME_ORDRE_YACS = SIMP(statut='o', typ='I',),
+                   INFO            = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+);
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -23222,10 +24606,10 @@ NORM_MODE=OPER(nom="NORM_MODE",op=  37,sd_prod=norm_mode_prod,
          TITRE      =SIMP(statut='f',typ='TXM',max='**'),
          INFO       =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 18/01/2011   AUTEUR BOITEAU O.BOITEAU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -23259,7 +24643,7 @@ NUME_DDL=OPER(nom="NUME_DDL",op=11,sd_prod=nume_ddl_sdaster,reentrant='n',
            RENUM           =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK"  ),
          ),
          b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
-           RENUM         =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+           RENUM        =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
          ),
          b_gcpc          =BLOC(condition="METHODE=='GCPC' or METHODE=='PETSC'",fr="paramètres associés à la GCPC ou PETSc",
            RENUM           =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK"  ),
@@ -23301,10 +24685,10 @@ NUME_DDL_GENE=OPER(nom="NUME_DDL_GENE",op= 127,sd_prod=nume_ddl_gene,
                NB_VECT     =SIMP(statut='f',typ='I',defaut= 9999 ),
                              ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2007  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -23344,7 +24728,7 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops,
          MODELE_1        =SIMP(statut='o',typ=modele_sdaster),
          MODELE_2        =SIMP(statut='o',typ=modele_sdaster),
          RESULTAT        =SIMP(statut='o',typ=(mode_meca,evol_elas,dyna_harmo,dyna_trans,) ),
-         NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1),
+         NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(),),
 
 #        ------------------------------------------------------------------
 
@@ -23375,7 +24759,8 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops,
 #                fr="Si le résultat est un mode_xxx ou une base_xxx, on peut prolonger"
 #                   +" les champs par zéro la ou la projection ne donne pas de valeurs."),
 
-         NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster) ),
+         MATR_A          =SIMP(statut='f',typ=(matr_asse_depl_r) ),
+         MATR_B          =SIMP(statut='f',typ=(matr_asse_depl_r) ),
          VIS_A_VIS       =FACT(statut='f',max='**',
              regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
                      AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),),
@@ -23459,6 +24844,8 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops,
            MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
            NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
            TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),into=C_NOM_CHAM_INTO(),),
+
 #
            DDL_ACTIF       =SIMP(statut='f',typ='TXM',max=6),
 # TODO : mettre en place le systeme de masques
@@ -23469,10 +24856,10 @@ OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops,
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
       )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 23/02/2011   AUTEUR BARGELLI R.BARGELLINI 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2010  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -23504,6 +24891,8 @@ POST_BORDET =MACRO(nom="POST_BORDET", op=post_bordet_ops,sd_prod=table_sdaster,
          GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
                            fr="le calcul ne sera effectué que sur ces mailles"),
          INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+         PRECISION =SIMP(statut='f',typ='R',validators=NoRepeat(),val_min=0.,val_max=1E-3,defaut=1E-6),
+         CRITERE   =SIMP(statut='f',typ='TXM',defaut="ABSOLU",into=("RELATIF","ABSOLU") ),
          NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
          PROBA_NUCL      =SIMP(statut='f',typ='TXM',into=("NON","OUI"), defaut="NON",
                       fr="prise en compte du facteur exponentiel"),
@@ -23530,8 +24919,6 @@ POST_BORDET =MACRO(nom="POST_BORDET", op=post_bordet_ops,sd_prod=table_sdaster,
                                   
          RESULTAT        =SIMP(statut='o',typ=resultat_sdaster,
                                       fr="Resultat d'une commande globale STAT_NON_LINE"),
-         MODELE          =SIMP(statut='o',typ=modele_sdaster),
-         CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
          TEMP            =SIMP(statut='o',typ=(fonction_sdaster,'R')),
          COEF_MULT       =SIMP(statut='f',typ='R', defaut=1.),                   
            )
@@ -23739,10 +25126,10 @@ POST_DYNA_MODA_T=OPER(nom="POST_DYNA_MODA_T",op= 130,sd_prod=table_sdaster,
          INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 22/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -23764,7 +25151,7 @@ POST_ELEM=OPER(nom="POST_ELEM",op=107,sd_prod=table_sdaster,reentrant='n',
 
          regles=(UN_PARMI('MASS_INER', 'ENER_POT', 'ENER_CIN','TRAV_EXT','MINMAX',
                           'WEIBULL', 'RICE_TRACEY', 'CARA_GEOM','CHAR_LIMITE',
-                          'CARA_POUTRE', 'INDIC_ENER', 'INDIC_SEUIL',
+                          'CARA_POUTRE', 'INDIC_ENER', 'INDIC_SEUIL','VOLUMOGRAMME',
                           'AIRE_INTERNE','ENER_ELAS','ENER_TOTALE','ENER_DISS','INTEGRALE'),
                 ),
 
@@ -23995,6 +25382,36 @@ POST_ELEM=OPER(nom="POST_ELEM",op=107,sd_prod=table_sdaster,reentrant='n',
                        regles=(UN_PARMI('CHAM_GD','RESULTAT'),
                                EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_ORDRE','LIST_INST'),),
                        MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       RESULTAT       = SIMP(statut='f',typ=(evol_noli,evol_ther,evol_elas,evol_char) ),
+                       CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
+                       CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),),
+                       b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+                          PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+                       b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                          PRECISION       =SIMP(statut='o',typ='R',),),
+                       TOUT_ORDRE     = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                       NUME_ORDRE     = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+                       LIST_ORDRE     = SIMP(statut='f',typ=listis_sdaster),
+                       INST           = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+                       LIST_INST      = SIMP(statut='f',typ=listr8_sdaster),
+         ),
+
+         VOLUMOGRAMME  = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,max=1),
+                               TYPE_MAILLE  = SIMP(statut='f',typ='TXM',into=('2D','3D',)),
+                               NOM_CHAM     = SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+                               NOM_CMP      = SIMP(statut='o',typ='TXM'),
+                               NB_INTERV    = SIMP(statut='f',typ='I',defaut=5),
+                              ),
+         b_volumogramme = BLOC(condition = "( VOLUMOGRAMME != None )",
+                       fr="calcul de la distribution du volume d'une structure vis-à-vis d'une composante",
+                       regles=(UN_PARMI('CHAM_GD','RESULTAT'),
+                               EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_ORDRE','LIST_INST'),),
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
                        RESULTAT       = SIMP(statut='f',typ=(evol_noli,evol_ther,evol_elas,evol_char) ),
                        CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
                        CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),),
@@ -24452,10 +25869,10 @@ POST_FATIGUE=OPER(nom="POST_FATIGUE",op=136,sd_prod=table_sdaster,reentrant='n',
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -24491,8 +25908,7 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod,
               reentrant='n',
               UIinfo={"groupes":("Post-traitements","Rupture",)},
               regles=(UN_PARMI('IDENTIFICATION', 'PREDICTION'),
-                      UN_PARMI('THETA_2D','THETA_3D'),
-                      PRESENT_PRESENT('THETA_2D','DIRECTION'),),
+                      UN_PARMI('THETA_2D','THETA_3D'),),
       
       # Résultat, modèle, comportement, chargement
       RESULTAT     = SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,mode_meca),),
@@ -24500,12 +25916,10 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod,
       MODELE       = SIMP(statut='o',typ=modele_sdaster),
       MATER        = SIMP(statut='o',typ=mater_sdaster),
       
-      COMP_ELAS    = FACT(statut='o',
-            RELATION    = SIMP(statut='f',typ='TXM',defaut="ELAS",
-                            into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC"),),
-           DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ),
-      ),
+      COMP_ELAS    = C_COMP_ELAS('POST_GP'),
       
+      LIST_INST    = SIMP(statut='o',typ=listr8_sdaster),
+
       TYPE_DEF = SIMP(statut='f',typ='TXM', defaut="PETIT", into=("PETIT","GRAND")),
       EXCIT        = FACT(statut='f', max='**',
             CHARGE      = SIMP(statut='o', typ=(char_meca,char_cine_meca)),
@@ -24514,8 +25928,8 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod,
       ),
       SYME_CHAR    = SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","ANTI","SANS")),
       
-      
-      DIRECTION    = SIMP(statut='f', typ='R', max=3),
+      b_direction     =BLOC(condition = "(THETA_2D != None) ",
+          DIRECTION    = SIMP(statut='o', typ='R', max=3),),
       
       THETA_2D     = FACT(statut='f', max='**',
                           fr="paramètres de définition des champs theta",
@@ -24574,15 +25988,12 @@ POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod,
       # table résultat
       TABL_GPMAX    = SIMP(statut='o', typ=CO,),
       TABL_GP       = SIMP(statut='f', typ=CO,),
-      b_tabl_gp=BLOC(condition="(TABL_GP != None)",
-             INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-             LIST_INST  = SIMP(statut='f',typ=listr8_sdaster),),
       INFO         = SIMP(statut='f', typ='I', defaut=1, into=(1, 2),),
 )
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 14/03/2011   AUTEUR GENIAUT S.GENIAUT 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -24614,16 +26025,31 @@ POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",op=post_k1_k2_k3_ops,sd_prod=table_sdast
                    ),
 
          MODELISATION  =SIMP(statut='o',typ='TXM',
-                             into=("3D","AXIS","D_PLAN","C_PLAN"),
+                             into=("3D","AXIS","D_PLAN","C_PLAN"),position='global',
                              fr="Modélisation cohérente avec celle utilisée pour le calcul des déplacements"),
          FOND_FISS     =SIMP(statut='f',typ=fond_fiss),
          FISSURE       =SIMP(statut='f',typ=fiss_xfem),
          NB_NOEUD_COUPE=SIMP(statut='f',typ='I',defaut=5,val_min = 3),
+         SYME_CHAR       =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","SANS")),
 
 #        bloc correspondant a la donnee du fond de fissure pour les fissures maillees
-         b_fond_fiss   =BLOC (condition="(FOND_FISS!= None)",
+         b_fond_fiss_res   =BLOC (condition="((FOND_FISS!= None)and(RESULTAT!= None))",
+                         
+              b_ref_3d     =BLOC (condition="MODELISATION=='3D'",
+                                  TYPE_MAILLAGE = SIMP(statut='f',typ='TXM',into=("LIBRE","REGLE"),defaut="REGLE"),
+                                ),
+                         
+                         NOEUD         = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                         GROUP_NO      = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                         SANS_NOEUD    = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                         SANS_GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                         TOUT          = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                         EVOL_THER     = SIMP(statut='f',typ=(evol_ther),fr="Température sur le fond de fissure")
+                         ),
+
+         b_fond_fiss_tab   =BLOC (condition="((FOND_FISS!= None)and(TABL_DEPL_SUP!= None)and(RESULTAT== None))",
+
                          MAILLAGE      = SIMP(statut='o',typ=maillage_sdaster),
-                         TYPE_MAILLAGE = SIMP(statut='f',typ='TXM',into=("LIBRE","REGLE"),defaut="REGLE"),
                          NOEUD         = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
                          GROUP_NO      = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
                          SANS_NOEUD    = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
@@ -24632,13 +26058,21 @@ POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",op=post_k1_k2_k3_ops,sd_prod=table_sdast
                          EVOL_THER     = SIMP(statut='f',typ=(evol_ther),fr="Température sur le fond de fissure")
                          ),
 #        bloc correspondant a la donnee de la fissure pour les fissures X-FEM
-         b_fissure     =BLOC (condition="(FISSURE!= None)",
+         b_fissure_res     =BLOC (condition="((FISSURE!= None)and(RESULTAT!= None))",
+                         NB_POINT_FOND = SIMP(statut='f',typ='I' ,),
+                         NUME_FOND     = SIMP(statut='f',typ='I',defaut=1),
+                         DTAN_ORIG     = SIMP(statut='f',typ='R',max='**'),
+                         DTAN_EXTR     = SIMP(statut='f',typ='R',max='**'),
+                         ),
+
+         b_fissure_tab     =BLOC (condition="((FISSURE!= None)and(TABL_DEPL_SUP!= None)and(RESULTAT== None))",
                          MAILLAGE      = SIMP(statut='o',typ=maillage_sdaster),
                          NB_POINT_FOND = SIMP(statut='f',typ='I' ,),
                          NUME_FOND     = SIMP(statut='f',typ='I',defaut=1),
                          DTAN_ORIG     = SIMP(statut='f',typ='R',max='**'),
                          DTAN_EXTR     = SIMP(statut='f',typ='R',max='**'),
                          ),
+
          MATER         =SIMP(statut='o',typ=mater_sdaster,
                              fr="Matériau homogène et isotrope cohérent avec celui utilisé pour le calcul des déplacements"),
          RESULTAT      =SIMP(statut='f',typ=(evol_elas,evol_noli),
@@ -24662,7 +26096,6 @@ POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",op=post_k1_k2_k3_ops,sd_prod=table_sdast
                b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
                    PRECISION       =SIMP(statut='o',typ='R',),),
              ),
-         SYME_CHAR       =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","SANS") ),
          INFO          =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
          VECT_K1       =SIMP(statut='f',typ='R',max=3,min=3,
                              fr="Vecteur normal au plan de fissure, orienté de la lèvre inférieure vers la lèvre supérieure"),  
@@ -24809,10 +26242,10 @@ POST_MAIL_XFEM=OPER(nom="POST_MAIL_XFEM",op= 187,sd_prod=maillage_sdaster,
     INFO           =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
 
 );                     
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 02/02/2011   AUTEUR PELLET J.PELLET 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -25011,7 +26444,7 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster,
            b_extrac        =BLOC(condition="RESULTAT != None",
                                  fr="extraction d un champ de grandeur",
              regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','INST','NOEUD_CMP'),),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',into=("EFGE_ELNO_DEPL","SIEF_ELNO_ELGA"),),
+             NOM_CHAM        =SIMP(statut='o',typ='TXM',into=("EFGE_ELNO","SIEF_ELNO"),),
              TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
              NUME_ORDRE      =SIMP(statut='f',typ='I',),
              INST            =SIMP(statut='f',typ='R',),
@@ -25088,10 +26521,10 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster,
                                ),
                ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 # ======================================================================
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -25165,7 +26598,7 @@ POST_RELEVE_T=OPER(nom="POST_RELEVE_T",op=51,sd_prod=table_sdaster,reentrant='f'
            b_extrac        =BLOC(condition = "RESULTAT != None",fr="extraction des résultats",
                                  regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','NUME_MODE','LIST_MODE',         
                                                 'INST','LIST_INST','FREQ','LIST_FREQ','NOEUD_CMP','NOM_CAS'), ),           
-             NOM_CHAM        =SIMP(statut='o',typ='TXM' ),  
+             NOM_CHAM        =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO(),),  
              TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
              NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),  
              LIST_ORDRE      =SIMP(statut='f',typ=listis_sdaster),
@@ -25378,10 +26811,10 @@ POST_USURE=OPER(nom="POST_USURE",op=153,sd_prod=table_sdaster,reentrant='f',
          INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 03/01/2011   AUTEUR COURTOIS M.COURTOIS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -25483,6 +26916,7 @@ POURSUITE=MACRO(nom="POURSUITE",op=ops.build_poursuite,repetable='n',
 
          IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"),
 
+         INFO     = SIMP(statut='f', typ='I', defaut=1, into=(1,2),),
 )  ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
@@ -25590,10 +27024,10 @@ PROD_MATR_CHAM=OPER(nom="PROD_MATR_CHAM",op= 156,sd_prod=cham_no_sdaster,
          CHAM_NO         =SIMP(statut='o',typ=cham_no_sdaster),
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -25610,21 +27044,30 @@ PROD_MATR_CHAM=OPER(nom="PROD_MATR_CHAM",op= 156,sd_prod=cham_no_sdaster,
 # ======================================================================
 # RESPONSABLE PELLET J.PELLET
 def proj_champ_prod(RESULTAT=None,CHAM_GD=None,**args ):
-    if AsType(RESULTAT) != None : return AsType(RESULTAT)
-    if AsType(CHAM_GD)  != None : return AsType(CHAM_GD)
+    if (RESULTAT == None and CHAM_GD == None) : return corresp_2_mailla
+    if  RESULTAT != None                      : return AsType(RESULTAT)
+    if  CHAM_GD  != None                      : return AsType(CHAM_GD)
     raise AsException("type de concept resultat non prevu")
 
 
 
 
 PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f',
-            UIinfo={"groupes":("Résultats et champs",)},
-                fr="Projeter des champs d'un maillage sur un autre",
+        UIinfo={"groupes":("Résultats et champs",)},
+            fr="Projeter des champs d'un maillage sur un autre",
+
+     # faut-il projeter les champs ?
+     PROJECTION      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON",),),
+
+     # pour projeter avec une sd_corresp_2_mailla deja calculée :
+     MATR_PROJECTION   =SIMP(statut='f',typ=corresp_2_mailla,),
 
 
-         METHODE         =SIMP(statut='f',typ='TXM',defaut="AUTO",
-                               into=("NUAGE_DEG_0","NUAGE_DEG_1","AUTO","COLOCATION","ECLA_PG",) ),
 
+     #-----------------------------------------------------------------------------------------------------------
+     # 1er cas : on fait tout d'un coup : creation de la sd_corresp_2_mailla + projection des champs
+     #-----------------------------------------------------------------------------------------------
+     b_1_et_2   =BLOC(condition= "PROJECTION == 'OUI' and MATR_PROJECTION == None",
          regles=(UN_PARMI('RESULTAT','CHAM_GD'),
                  UN_PARMI('MODELE_1','MAILLAGE_1'),
                  UN_PARMI('MODELE_2','MAILLAGE_2'),
@@ -25632,6 +27075,10 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f',
          RESULTAT        =SIMP(statut='f',typ=resultat_sdaster),
          CHAM_GD         =SIMP(statut='f',typ=(cham_no_sdaster,cham_elem)),
 
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="AUTO",
+                               into=("NUAGE_DEG_0","NUAGE_DEG_1","AUTO","COLLOCATION","ECLA_PG",) ),
+
+
          MODELE_1        =SIMP(statut='f',typ=modele_sdaster),
          MAILLAGE_1      =SIMP(statut='f',typ=maillage_sdaster),
 
@@ -25645,29 +27092,180 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f',
          ),
 
 
-         # Cas de la projection COLOCATION :
-         #--------------------------------------------
-         b_elem          =BLOC(condition="METHODE in ('COLOCATION','ECLA_PG','AUTO')",
-             CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",),
-                  fr="Pour indiquer au programme le type de projection souhaité"),
-             DISTANCE_MAX    =SIMP(statut='f',typ='R',
-                  fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."),
+         # Cas de la projection COLLOCATION :
+         #--------------------------------------------
+         b_elem          =BLOC(condition="METHODE in ('COLLOCATION','ECLA_PG','AUTO')",
+             CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",),
+                  fr="Pour indiquer au programme le type de projection souhaité"),
+             DISTANCE_MAX    =SIMP(statut='f',typ='R',
+                  fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."),
+
+             TRANSF_GEOM_1   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                  fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                     " aux noeuds du MODELE_1 avant la projection."),
+             TRANSF_GEOM_2   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                  fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                     " aux noeuds du MODELE_2 avant la projection."),
+
+             ALARME          =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+
+             TYPE_CHAM       =SIMP(statut='f',typ='TXM',into=("NOEU",),
+                  fr="Pour forcer le type des champs projetés. NOEU -> cham_no"),
+
+             PROL_ZERO       =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
+                  fr="Pour prolonger les champs par zéro là ou la projection ne donne pas de valeurs."),
+         ),
+
+
+         # Cas de la projection d'une sd_resultat :
+         #--------------------------------------------
+         b_resultat      =BLOC(condition="RESULTAT != None",
+           regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','LIST_INST','LIST_FREQ','LIST_ORDRE'),
+                   EXCLUS('TOUT_CHAM','NOM_CHAM',),
+                   CONCEPT_SENSIBLE('SEPARE'),
+                   REUSE_SENSIBLE(),
+                   DERIVABLE('RESULTAT'),),
+           SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des paramétres de sensibilité.",
+                               ang="List of sensitivity parameters",),
+
+           NOM_PARA        =SIMP(statut='f',typ='TXM', max='**'),
+           TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(),),
+
+           NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster),
+                fr="Utile en dynamique pour pouvoir imoser la numérotation des cham_no."),
+
+           TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
+           LIST_ORDRE      =SIMP(statut='f',typ=listis_sdaster),
+           INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
+           LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+           FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
+           LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster),
+           NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
+           NOEUD_CMP       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+
+           b_acce_reel     =BLOC(condition="(FREQ != None)or(LIST_FREQ != None)or(INST != None)or(LIST_INST != None)",
+              CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),),
+              b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+                   PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+              b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                   PRECISION       =SIMP(statut='o',typ='R',),),
+           ),
+         ),
+
+
+         VIS_A_VIS       =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
+                   AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),),
+           TOUT_1          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA_1      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_1        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO_1      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD_1         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TOUT_2          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA_2      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_2        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO_2      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD_2         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+
+           # les mots clés suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le vérifier:
+               CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
+               TRANSF_GEOM_1   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                    fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                       " aux noeuds du MODELE_1 avant la projection."),
+               TRANSF_GEOM_2   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                    fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                       " aux noeuds du MODELE_2 avant la projection."),
+         ),
+     ), # fin bloc b_1_et_2
+
+
+
+     #-----------------------------------------------------------------------------------------------------------
+     # 2eme cas : on s'arrete apres la creation de la sd_corresp_2_mailla
+     #-----------------------------------------------------------------------------------------------
+     b_1   =BLOC(condition="PROJECTION == 'NON'",
+
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="COLLOCATION",
+                               into=("COLLOCATION","COUPLAGE",) ),
+
+         regles=(UN_PARMI('MODELE_1','MAILLAGE_1'),
+                 UN_PARMI('MODELE_2','MAILLAGE_2'),
+                 ),
+         MODELE_1        =SIMP(statut='f',typ=modele_sdaster),
+         MAILLAGE_1      =SIMP(statut='f',typ=maillage_sdaster),
+
+         MODELE_2        =SIMP(statut='f',typ=modele_sdaster),
+         MAILLAGE_2      =SIMP(statut='f',typ=maillage_sdaster),
+
+
+         # Cas de la projection COLLOCATION :
+         #--------------------------------------------
+         b_elem          =BLOC(condition="METHODE in ('COLLOCATION',)",
+             CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",),
+                  fr="Pour indiquer au programme le type de projection souhaité"),
+             DISTANCE_MAX    =SIMP(statut='f',typ='R',
+                  fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."),
+
+             TRANSF_GEOM_1   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                  fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                     " aux noeuds du MODELE_1 avant la projection."),
+             TRANSF_GEOM_2   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                  fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                     " aux noeuds du MODELE_2 avant la projection."),
+
+             ALARME          =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+
+         ),
+
+         VIS_A_VIS       =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
+                   AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),),
+           TOUT_1          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA_1      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_1        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO_1      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD_1         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TOUT_2          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA_2      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_2        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO_2      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD_2         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+
+           # les mots clés suivants ne sont actifs que si METHODE='COLLOCATION' mais on ne peut pas le vérifier:
+               CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
+               TRANSF_GEOM_1   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                    fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                       " aux noeuds du MODELE_1 avant la projection."),
+               TRANSF_GEOM_2   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+                    fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+                       " aux noeuds du MODELE_2 avant la projection."),
+         ),
+     ), # fin bloc b_1
+
+
 
-             TRANSF_GEOM_1   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
-                  fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
-                     " aux noeuds du MODELE_1 avant la projection."),
-             TRANSF_GEOM_2   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
-                  fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
-                     " aux noeuds du MODELE_2 avant la projection."),
+     #-----------------------------------------------------------------------------------------------------------
+     # 3eme cas : on projette les champs avec une sd_corresp_2_mailla déjé calculée
+     #-----------------------------------------------------------------------------------------------
+     b_2   =BLOC(condition="MATR_PROJECTION != None",
+         regles=(UN_PARMI('RESULTAT','CHAM_GD'),),
+         RESULTAT        =SIMP(statut='f',typ=resultat_sdaster),
+         CHAM_GD         =SIMP(statut='f',typ=(cham_no_sdaster,cham_elem)),
 
-             ALARME          =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         TYPE_CHAM       =SIMP(statut='f',typ='TXM',into=("NOEU",),
+              fr="Pour forcer le type des champs projetés. NOEU -> cham_no"),
 
-             TYPE_CHAM       =SIMP(statut='f',typ='TXM',into=("NOEU",),
-                  fr="Pour forcer le type des champs projetés. NOEU -> cham_no"),
+         NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster),
+              fr="Parfois utile en dynamique pour pouvoir imposer la numérotation des cham_no."),
 
-             PROL_ZERO       =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
-                  fr="Pour prolonger les champs par zéro là ou la projection ne donne pas de valeurs."),
-         ),
+         # nécessaire si l'on projette des cham_elem :
+         MODELE_2        =SIMP(statut='f',typ=modele_sdaster),
+
+         PROL_ZERO       =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
+              fr="Pour prolonger les champs par zéro là où la projection ne donne pas de valeurs."),
 
 
 
@@ -25680,15 +27278,12 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f',
                    REUSE_SENSIBLE(),
                    DERIVABLE('RESULTAT'),),
            SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
-                               fr="Liste des paramètres de sensibilité.",
+                               fr="Liste des paramétres de sensibilité.",
                                ang="List of sensitivity parameters",),
 
            NOM_PARA        =SIMP(statut='f',typ='TXM', max='**'),
            TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
-
-           NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster),
-                fr="Utile en dynamique pour pouvoir imoser la numérotation des cham_no."),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO(),),
 
 
            TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
@@ -25710,37 +27305,12 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f',
            ),
 
          ),
+     ), # fin bloc b_2
 
 
 
-         # Mots clés utilisables dans tous les cas :
-         #---------------------------------------------
-         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
-         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-
-         VIS_A_VIS       =FACT(statut='f',max='**',
-           regles=(AU_MOINS_UN('TOUT_1','GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
-                   AU_MOINS_UN('TOUT_2','GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),),
-           TOUT_1          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-           GROUP_MA_1      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-           MAILLE_1        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-           GROUP_NO_1      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-           NOEUD_1         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-           TOUT_2          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-           GROUP_MA_2      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-           MAILLE_2        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-           GROUP_NO_2      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-           NOEUD_2         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-
-           # les mots clés suivants ne sont actifs que si METHODE='COLOCATION' mais on ne peut pas le vérifier:
-               CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
-               TRANSF_GEOM_1   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
-                    fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
-                       " aux noeuds du MODELE_1 avant la projection."),
-               TRANSF_GEOM_2   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
-                    fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
-                       " aux noeuds du MODELE_2 avant la projection."),
-         ),
+     TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+     INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
 )  ;
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
@@ -25779,10 +27349,10 @@ PROJ_MATR_BASE=OPER(nom="PROJ_MATR_BASE",op=  71,sd_prod=matr_asse_gene_prod,
          MATR_ASSE_GENE  =SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c) ),
 )  ;
 
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -25822,7 +27392,8 @@ PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193,
            MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
 #           MESURE          =SIMP(statut='o',typ=(dyna_trans,dyna_harmo,base_modale,mode_meca,mode_meca_c,) ),
            MESURE          =SIMP(statut='o',typ=(dyna_trans,dyna_harmo,mode_meca,mode_meca_c,) ),
-           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE","SIEF_NOEU","EPSI_NOEU_DEPL",) ),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE",
+                                 "SIEF_NOEU","EPSI_NOEU",),max='**'),
                          ),
          CORR_MANU       =FACT(statut='f',max='**',
            regles=(PRESENT_PRESENT('NOEU_CALCUL','NOEU_MESURE'),),
@@ -25915,10 +27486,10 @@ PROJ_VECT_BASE=OPER(nom="PROJ_VECT_BASE",op=  72,sd_prod=vect_asse_gene,
          VECT_ASSE       =SIMP(statut='f',typ=cham_no_sdaster),
          VECT_ASSE_GENE  =SIMP(statut='f',typ=vect_asse_gene ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 04/05/2011   AUTEUR MACOCCO K.MACOCCO 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -25974,7 +27545,6 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
                                    FISSURE   = FACT(statut='o',min=1,max='**',
                                                     FISS_ACTUELLE  = SIMP(statut='o',typ=fiss_xfem,max=1),
                                                     FISS_PROPAGEE  = SIMP(statut='o',typ=CO,max=1),
-                                                    GRILLE_AUX     = SIMP(statut='f',typ=modele_sdaster,max=1),
                                                     NB_POINT_FOND  = SIMP(statut='f',typ='I',max='**'),
                                                     TABLE          = SIMP(statut='o',typ=table_sdaster,max=1),
                                                     ),
@@ -25997,7 +27567,6 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
                                    FISSURE   = FACT(statut='o',min=1,max='**',
                                                     FISS_ACTUELLE  = SIMP(statut='o',typ=fiss_xfem,max=1),
                                                     FISS_PROPAGEE  = SIMP(statut='o',typ=CO,max=1),
-                                                    GRILLE_AUX     = SIMP(statut='f',typ=modele_sdaster,max=1),
                                                     ),
                                    ITERATIONS     = SIMP(statut='f',typ='I',max=1,val_min=3,defaut=5),
                                    TOLERANCE      = SIMP(statut='f',typ='R',max=1,val_min=0.0,val_max=100.0,defaut=5.0),
@@ -26012,12 +27581,11 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
                
                FISSURE   = FACT(statut='o',min=1,max='**',
                                 MAIL_ACTUEL    = SIMP(statut='o',typ=maillage_sdaster,max=1),
-                                GROUP_MA_FOND    = SIMP(statut='f',typ='TXM',defaut="FOND"), 
-                                GROUP_MA_FISS    = SIMP(statut='f',typ='TXM',defaut="FISS"), 
+                                GROUP_MA_FOND    = SIMP(statut='f',typ=grma,defaut="FOND"), 
+                                GROUP_MA_FISS    = SIMP(statut='f',typ=grma,defaut="FISS"), 
                                 FISS_ACTUELLE  = SIMP(statut='o',typ=fiss_xfem,max=1),
                                 MAIL_PROPAGE  = SIMP(statut='f',typ=CO,max=1),
                                 TABLE          = SIMP(statut='o',typ=table_sdaster,max=1),
-                                METHODE_POSTK  = SIMP(statut='f',typ='I',into=(1,2,3),max=1),
                                 DTAN_ORIG      = SIMP(statut='f',typ='R',max=3),
                                 DTAN_EXTR      = SIMP(statut='f',typ='R',max=3),
                                                     ),
@@ -26031,8 +27599,8 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
         b_init    =BLOC(condition="(METHODE_PROPA=='INITIALISATION')",
                MAIL_STRUC    = SIMP(statut='o',typ=maillage_sdaster), 
                FORM_FISS   = SIMP(statut='o',typ='TXM', into=("DEMI_DROITE","DEMI_PLAN","ELLIPSE"), ),
-               GROUP_MA_FOND    = SIMP(statut='f',typ='TXM',defaut="FOND"), 
-               GROUP_MA_FISS    = SIMP(statut='f',typ='TXM',defaut="FISS"), 
+               GROUP_MA_FOND    = SIMP(statut='f',typ=grma,defaut="FOND"), 
+               GROUP_MA_FISS    = SIMP(statut='f',typ=grma,defaut="FISS"), 
                MAIL_TOTAL     = SIMP(statut='o',typ=CO), 
                MAIL_FISS       = SIMP(statut='f',typ=CO), 
              
@@ -26045,7 +27613,7 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
                   DTAN        = SIMP(statut='o',typ='R',min=3,max=3),
                   POINT_ORIG        = SIMP(statut='o',typ='R',min=3,max=3),
                   POINT_EXTR        = SIMP(statut='o',typ='R',min=3,max=3),
-                  NB_POINT_FOND     = SIMP(statut='o',typ='I',val_max=26),
+                  NB_POINT_FOND     = SIMP(statut='o',typ='I',),
                ),
                 
                b_ellipse = BLOC(condition = "FORM_FISS == 'ELLIPSE' ",
@@ -26056,7 +27624,7 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
                   VECT_Y         =SIMP(statut='o',typ='R',min=3,max=3),
                   ANGLE_ORIG        = SIMP(statut='o',typ='R',),
                   ANGLE_EXTR        = SIMP(statut='o',typ='R',),
-                  NB_POINT_FOND     = SIMP(statut='o',typ='I',val_max=52,),
+                  NB_POINT_FOND     = SIMP(statut='o',typ='I',)
                ),   
              ),       
 
@@ -26075,10 +27643,10 @@ PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
         INFO = SIMP(statut='f',typ='I',defaut=1,into=(0,1,2)),
 )
 
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/03/2011   AUTEUR MASSIN P.MASSIN 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -26101,8 +27669,6 @@ PROPA_XFEM=OPER(nom="PROPA_XFEM",op=10,sd_prod=fiss_xfem,reentrant='n',
     
     MODELE        =SIMP(statut='o',typ=modele_sdaster),
 
-    GRILLE_AUX    =SIMP(statut='f',typ=modele_sdaster),
-
     TEST_MAIL     =SIMP(statut='f',typ='TXM',into=("NON","OUI",),defaut="NON"),
 
     DA_MAX        =SIMP(statut='o',typ='R'),
@@ -26489,6 +28055,46 @@ RECU_GENE=OPER(nom="RECU_GENE",op=  76,sd_prod=vect_asse_gene,reentrant='n',
          b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
              PRECISION       =SIMP(statut='o',typ='R',),),
 )  ;
+#& MODIF COMMANDE  DATE 14/02/2011   AUTEUR GREFFET N.GREFFET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GREFFET N.GREFFET
+#
+# RECUPERATION DE PARAMETRES DE COUPLAGE VIA YACS
+# 
+RECU_PARA_YACS=OPER(nom="RECU_PARA_YACS",op=114,sd_prod=listr8_sdaster,
+                   reentrant = 'n',
+                    UIinfo={"groupes":("Fonction",)},
+                   fr        = "Gestion des scalaires via YACS pour le coupleur IFS",
+          DONNEES = SIMP(statut='o',typ='TXM',into=("INITIALISATION","CONVERGENCE","FIN","PAS",) ),
+          b_init   = BLOC(condition= "DONNEES=='INITIALISATION'",
+                     PAS             = SIMP(statut='o',typ='R', ),),
+          b_noinit = BLOC(condition= "(DONNEES=='CONVERGENCE')or(DONNEES=='FIN')",
+                     NUME_ORDRE_YACS = SIMP(statut='o', typ='I',),
+                     INST         = SIMP(statut='o',typ='R', ),
+                     PAS             = SIMP(statut='o',typ='R', ),),
+          b_pastps = BLOC(condition= "(DONNEES=='PAS')",
+                     NUME_ORDRE_YACS = SIMP(statut='o', typ='I',),
+                     INST         = SIMP(statut='o',typ='R', ),
+                     PAS             = SIMP(statut='o',typ='R', ),),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+);
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -26563,10 +28169,10 @@ RESOUDRE=OPER(nom="RESOUDRE",op=15,sd_prod=cham_no_sdaster,reentrant='f',
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
          INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -26583,10 +28189,11 @@ RESOUDRE=OPER(nom="RESOUDRE",op=15,sd_prod=cham_no_sdaster,reentrant='f',
 # ======================================================================
  
 # RESPONSABLE DEVESA G.DEVESA
-def rest_cond_tran_prod(RESULTAT,**args ):
+def rest_cond_tran_prod(RESULTAT,TYPE_RESU,**args ):
  
-  if AsType(RESULTAT) == evol_noli  : return dyna_trans
-  if AsType(RESULTAT) == dyna_trans : return dyna_trans
+  if AsType(RESULTAT) == dyna_trans  : return dyna_trans
+  if (AsType(RESULTAT) == evol_noli and TYPE_RESU == "DYNA_TRANS") : return dyna_trans
+  if (AsType(RESULTAT) == evol_noli and TYPE_RESU == "EVOL_NOLI") : return evol_noli
 
   raise AsException("type de concept resultat non prevu")
 
@@ -26594,12 +28201,14 @@ REST_COND_TRAN=OPER(nom="REST_COND_TRAN",op=  78,sd_prod=rest_cond_tran_prod,
                     fr="Restituer dans la base physique des résultats issus d'un calcul" 
                         +"non-lineaire avec projection modale ou d'un calcul transitoire linear"
                         +"avec condensation dynamique",
-                    reentrant='n',
+                    reentrant='f',
             UIinfo={"groupes":("Matrices et vecteurs",)},
         regles=(
                 EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','TOUT_INST'),
                 EXCLUS('MACR_ELEM_DYNA','BASE_MODALE'),),
          RESULTAT        =SIMP(statut='f',typ=(evol_noli,dyna_trans) ),
+         TYPE_RESU       =SIMP(statut='f',typ='TXM',defaut="DYNA_TRANS",
+                          into=("DYNA_TRANS","EVOL_NOLI") ),
          BASE_MODALE     =SIMP(statut='f',typ=mode_meca),
 #         NUME_DDL        =SIMP(statut='f',typ=nume_ddl_sdaster ),
          MACR_ELEM_DYNA  =SIMP(statut='f',typ=macr_elem_dyna),
@@ -26616,14 +28225,18 @@ REST_COND_TRAN=OPER(nom="REST_COND_TRAN",op=  78,sd_prod=rest_cond_tran_prod,
          INTERPOL        =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","LIN") ),
          TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
          b_nom_cham=BLOC(condition="TOUT_CHAM == None",
-             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,defaut="ACCE",   
-                               into=("DEPL","VITE","ACCE",) ),),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,defaut="ACCE",into=("DEPL",
+                                   "VITE","ACCE",),),),
+         b_base_moda=BLOC(condition="BASE_MODALE != None",
+             CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+             CARA_ELEM       =SIMP(statut='f',typ=cara_elem),),
+             RESU_FINAL      =SIMP(statut='f',typ=(evol_noli,dyna_trans) ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -26683,9 +28296,8 @@ REST_GENE_PHYS=OPER(nom="REST_GENE_PHYS",op=  75,sd_prod=rest_gene_phys_prod,
          CORR_STAT       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
          TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
          b_nom_cham=BLOC(condition="TOUT_CHAM == None",
-             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE",   
-                               into=("DEPL","VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO_DEPL","SIPO_ELNO_DEPL",                 
-                                     "SIGM_ELNO_DEPL","FORC_NODA",) ),),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE",into=("DEPL",
+                                   "VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO","SIPO_ELNO","SIGM_ELNO","FORC_NODA",),),),
          GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
          NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
          GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
@@ -26694,10 +28306,10 @@ REST_GENE_PHYS=OPER(nom="REST_GENE_PHYS",op=  75,sd_prod=rest_gene_phys_prod,
          DIRECTION       =SIMP(statut='f',typ='R',min=3,max=3 ),
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2008  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -26762,9 +28374,8 @@ REST_SOUS_STRUC=OPER(nom="REST_SOUS_STRUC",op=  77,sd_prod=rest_sous_struc_prod,
          INTERPOL        =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","LIN") ),
          TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
          b_nom_cham=BLOC(condition="TOUT_CHAM == None",
-             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE",   
-                               into=("DEPL","VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO_DEPL","SIPO_ELNO_DEPL",                 
-                                     "SIGM_ELNO_DEPL","FORC_NODA",) ),),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=8,defaut="ACCE",into=("DEPL",
+                                   "VITE","ACCE","ACCE_ABSOLU","EFGE_ELNO","SIPO_ELNO","SIGM_ELNO","FORC_NODA",) ),),
          GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
          NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
          GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
@@ -26781,10 +28392,10 @@ REST_SOUS_STRUC=OPER(nom="REST_SOUS_STRUC",op=  77,sd_prod=rest_sous_struc_prod,
          SECTEUR         =SIMP(statut='f',typ='I'),  
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 29/03/2011   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
@@ -26814,9 +28425,8 @@ REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_fonction,
          NOEUD           =SIMP(statut='o',typ=no   ,max='**'),
          MAILLE          =SIMP(statut='f',typ=ma   ,max='**'),
          NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),  
-         NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=7,    
-                               into=("DEPL","VITE","ACCE","EFGE_ELNO_DEPL",
-                                     "SIPO_ELNO_DEPL","SIGM_ELNO_DEPL","FORC_NODA") ),
+         NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=7,into=("DEPL",
+                               "VITE","ACCE","EFGE_ELNO","SIPO_ELNO","SIGM_ELNO","FORC_NODA") ),
          MODE_STAT       =SIMP(statut='f',typ=mode_meca ),
          EXCIT           =FACT(statut='f',
            NOEUD           =SIMP(statut='o',typ=no   ,max='**'),
@@ -26866,10 +28476,10 @@ REST_SPEC_TEMP=OPER(nom="REST_SPEC_TEMP",op=181,sd_prod=rest_spec_temp_prod,
          TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI",)),
          NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,into=("DEPL","VITE","ACCE") ),
 );
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
@@ -26894,13 +28504,7 @@ SIMU_POINT_MAT=MACRO(nom="SIMU_POINT_MAT", op=simu_point_mat_ops,sd_prod=table_s
                    fr="Calcul de l'évolution mécanique, en quasi-statique,"
                       +" d'un point matériel en non linéaire",
    COMP_INCR       =C_COMP_INCR(),
-   COMP_ELAS       =FACT(statut='f',max='**',
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-           RELATION        =SIMP(statut='o',typ='TXM',defaut="ELAS",
-                                 into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS","ELAS_HYPER")),
-           DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ),
-         ),
+   COMP_ELAS       =C_COMP_ELAS('SIMU_POINT_MAT'),
    MATER           =SIMP(statut='o',typ=mater_sdaster,max=30),
    
 ## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations imposées.
@@ -26928,37 +28532,22 @@ SIMU_POINT_MAT=MACRO(nom="SIMU_POINT_MAT", op=simu_point_mat_ops,sd_prod=table_s
                ),        
    b_EF = BLOC(condition="SUPPORT ==  'ELEMENT'",fr="Simulation sur un élément fini",                    
       MODELISATION  =SIMP(statut='f',typ='TXM',max=1,into=("3D","C_PLAN","D_PLAN",)),
-      RECH_LINEAIRE   =C_RECH_LINEAIRE(),                                      
-      ARCHIVAGE       =FACT(statut='f',
-       LIST_INST       =SIMP(statut='f',typ=(listr8_sdaster) ),
-       INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-       PAS_ARCH        =SIMP(statut='f',typ='I' ),
-       PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-       ARCH_ETAT_INIT  =SIMP(statut='f',typ='TXM',into=("OUI",),defaut="OUI"),
-       NUME_INIT       =SIMP(statut='f',typ='I'),
-       DETR_NUME_SUIV  =SIMP(statut='f',typ='TXM',into=("OUI",)),
-       CHAM_EXCLU      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',
-                                    into=("DEPL","SIEF_ELGA","VARI_ELGA",)),
-        ),
+      RECH_LINEAIRE   =C_RECH_LINEAIRE(),
+      ARCHIVAGE       =C_ARCHIVAGE(), 
                  ),                                            
    # on permet certaines variables de commandes scalaires, définies par une fonction du temps
    b_EFV = BLOC(condition="SUPPORT ==  'ELEMENT'",fr="variables de commande sur un élément fini",                    
          # un mot clé caché qui ne sert qu'à boucler sur les VARC possibles :
-         LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP",)),
+         LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("TEMP","CORR","IRRA","HYDR","SECH","EPSA",
+                                                           "M_ACIER","M_ZIRC","NEUT1","NEUT2")),
+
          AFFE_VARC    = FACT(statut='f',max='**',
-          NOM_VARC    = SIMP(statut='o',typ='TXM', into=("TEMP",)),
+          NOM_VARC        =SIMP(statut='o',typ='TXM', into=("TEMP","CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC",
+                                                            "EPSA","NEUT1","NEUT2")),
           VALE_FONC   = SIMP(statut='o',typ=(fonction_sdaster,formule) ),
           VALE_REF    = SIMP(statut='f',typ='R'),
          ),
-         #  mots clés cachés pour variable de commande TEMP :
-         #  --------------------------------------------------
-         VARC_TEMP    =FACT(statut='d',
-           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="TEMP"),
-           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="TEMP_R"),
-           CMP_GD          =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("TEMP",)),
-           CMP_VARC        =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("TEMP",)),
-           VALE_DEF        =SIMP(statut='c',typ='R',max=1,min=1,defaut=(0.,)),
-                           ),
+
         SIGM_IMPOSE=FACT(statut='f',
               SIXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
               SIYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
@@ -27072,10 +28661,10 @@ STANLEY=MACRO(nom="STANLEY",op=stanley_ops,sd_prod=None,
                                fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit les md5"),
 
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -27116,23 +28705,11 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli,
                 SUPER_MAILLE=SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',),
                 FONC_MULT   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
               ),
+#-------------------------------------------------------------------               
          COMP_INCR       =C_COMP_INCR(),
-         COMP_ELAS       =FACT(statut='f',max='**',
-           RESI_INTE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ITER_INTE_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
-           ITER_INTE_PAS   =SIMP(statut='f',typ='I',defaut= 0 ),
-           RESO_INTE       =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
-                                 into=("IMPLICITE",)),
-           RELATION        =SIMP(statut='o',typ='TXM',defaut="ELAS",
-                                 into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC","ELAS_VMIS_PUIS",
-                                      "ELAS_POUTRE_GR","CABLE","ELAS_HYPER")),
-          
-           DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GROT_GDEP",) ),
-      regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
-           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-         ),
+#-------------------------------------------------------------------          
+         COMP_ELAS       =C_COMP_ELAS('STAT_NON_LINE'),
+#-------------------------------------------------------------------          
          b_reuse =BLOC(condition = "reuse",fr="en mode concept reentrant : ETAT_INIT obligatoire",
            ETAT_INIT       =FACT(statut='o',
              regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','SIGM','VARI',),
@@ -27175,130 +28752,33 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli,
              NUME_DIDI       =SIMP(statut='f',typ='I'),
              INST_ETAT_INIT  =SIMP(statut='f',typ='R'),
          ),),
+#-------------------------------------------------------------------            
          INCREMENT       =C_INCREMENT(),
- 
-#         **C_ALGO_RESOLUTION()
-         METHODE = SIMP(statut='d',typ='TXM',defaut="NEWTON",into=("NEWTON","IMPL_EX")),
-         b_meth_newton = BLOC(condition = "METHODE == 'NEWTON'",
-                           NEWTON = C_NEWTON(),
-                        ),
-         b_meth_impl_ex = BLOC(condition = "METHODE == 'IMPL_EX'",
-                           IMPL_EX = C_IMPL_EX(),
-                        ),
- 
+#-------------------------------------------------------------------   
+         METHODE         =SIMP(statut='d',typ='TXM',defaut="NEWTON",into=("NEWTON","IMPL_EX")),
+             b_meth_newton = BLOC(condition = "METHODE == 'NEWTON'",
+                                  NEWTON = C_NEWTON(),
+                                  ),
+            b_meth_impl_ex = BLOC(condition = "METHODE == 'IMPL_EX'",
+                                  IMPL_EX = C_IMPL_EX(),
+                          ),
+#-------------------------------------------------------------------    
          RECH_LINEAIRE   =C_RECH_LINEAIRE(),
-         
-         PILOTAGE        =FACT(statut='f',
-           regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
-           TYPE    =SIMP(statut='o',typ='TXM',into=("DDL_IMPO","LONG_ARC","PRED_ELAS","DEFORMATION","ANA_LIM") ),
-           COEF_MULT       =SIMP(statut='f',typ='R',defaut= 1.0E+0),
-           EVOL_PARA       =SIMP(statut='f',typ='TXM',defaut="SANS", into=("SANS","CROISSANT","DECROISSANT") ),
-           
-           
-           ETA_PILO_MAX    =SIMP(statut='f',typ='R'),
-           ETA_PILO_MIN    =SIMP(statut='f',typ='R'),
-           ETA_PILO_R_MAX  =SIMP(statut='f',typ='R'),
-           ETA_PILO_R_MIN  =SIMP(statut='f',typ='R'),
-           PROJ_BORNES     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
-           SELECTION       =SIMP(statut='f',typ='TXM',defaut="NORM_INCR_DEPL", into=("RESIDU","ANGL_INCR_DEPL","NORM_INCR_DEPL") ),
-           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
-           GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
-           MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
-           NOEUD           =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
-           GROUP_NO        =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
-           NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),
-                         ),
-                         
+#-------------------------------------------------------------------            
+         PILOTAGE        =C_PILOTAGE(),
+#-------------------------------------------------------------------                         
          CONVERGENCE     =C_CONVERGENCE(),
- 
+#------------------------------------------------------------------- 
          SOLVEUR         =C_SOLVEUR(),
-          
-         ARCHIVAGE       =FACT(statut='f',
-           regles=(EXCLUS('PAS_ARCH','LIST_INST','INST'),
-                   EXCLUS('ARCH_ETAT_INIT','NUME_INIT'), ),
-           LIST_INST       =SIMP(statut='f',typ=(listr8_sdaster) ),
-           INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-           PAS_ARCH        =SIMP(statut='f',typ='I' ),
-           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           ARCH_ETAT_INIT  =SIMP(statut='f',typ='TXM',into=("OUI",)),
-           NUME_INIT       =SIMP(statut='f',typ='I'),
-           DETR_NUME_SUIV  =SIMP(statut='f',typ='TXM',into=("OUI",)),
-           CHAM_EXCLU      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',
-                                 into=("DEPL","SIEF_ELGA","VARI_ELGA",)),
-         ),
-         OBSERVATION     =FACT(statut='f',max='**',
-           NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
-           SUIVI_DDL       =SIMP(statut='f',typ='TXM',defaut="NON",max=1,into=("OUI","NON")),
-         b_suivi          =BLOC(condition = "SUIVI_DDL == 'OUI' ",
-                                regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'),
-                                                  PRESENT_PRESENT('MAILLE','POINT'),),
-             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-             POINT           =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'),
-             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
-                                   into=("DEPL","VITE","ACCE","SIEF_ELGA",
-                                         "VARI_ELGA","FORC_NODA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)),
-             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
-             NUME_SUIVI      =SIMP(statut='o',typ='I' ,min=1,max=4),
-             VALE_MAX        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),
-             VALE_MIN        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),),
-         b_non_suivi      =BLOC(condition = "SUIVI_DDL == 'NON' ",
-                                regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'),PRESENT_PRESENT('MAILLE','POINT'),),
-             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-             POINT           =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'),
-             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("DEPL","VITE","ACCE","SIEF_ELGA",
-                                              "VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU","VALE_CONT")),
-             INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-             LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
-             PAS_OBSE        =SIMP(statut='f',typ='I'),
-             LIST_ARCH       =SIMP(statut='f',typ=listis_sdaster),
-             CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
-             b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
-                PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
-             b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
-                PRECISION       =SIMP(statut='o',typ='R',),),),
-         ),
-
-         AFFICHAGE      = FACT(statut='f',max=16,
-
-            UNITE       = SIMP(statut='f',typ='I',val_min=1),
-
-            LONG_R      = SIMP(statut='f',typ='I',defaut=12,val_min=1,val_max=12),
-            PREC_R      = SIMP(statut='f',typ='I',defaut=5, val_min=1,val_max=8),
-            LONG_I      = SIMP(statut='f',typ='I',defaut=6, val_min=1,val_max=12),
-
-            NOM_COLONNE = SIMP(statut='o',typ='TXM',defaut="STANDARD",
-                                into=("STANDARD","MINIMUM",
-                                      "ITER_NEWT",
-                                      "INCR_TPS",
-                                      "RESI_RELA","RELA_NOEU",
-                                      "RESI_MAXI","MAXI_NOEU",
-                                      "RESI_REFE","REFE_NOEU",
-                                      "RELI_ITER","RELI_COEF",
-                                      "RESI_COMP","COMP_NOEU",
-                                      "PILO_PARA",
-                                      "MATR_ASSE",
-                                      "ITER_DEBO",
-                                      "CTCD_ITER","CTCD_GEOM","CTCD_NOEU",
-                                      "BOUC_GEOM","BOUC_FROT","BOUC_CONT","CTCC_BOUC","CTCC_NOEU",
-                                      "SUIV_1","SUIV_2","SUIV_3","SUIV_4","ITER_FETI",
-                                     ),
-                               ),
-            b_residu    = BLOC(condition = " NOM_COLONNE == 'RESI_RELA' or \
-                    NOM_COLONNE == 'RESI_MAXI' or\
-                    NOM_COLONNE == 'RESI_REFE' or\
-                    NOM_COLONNE == 'CTCD_GEOM' or\
-                    NOM_COLONNE == 'CTCC_BOUC' or\
-                    NOM_COLONNE == 'STANDARD' ",
-                            INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
-                          ),
-         ),
-
-
-
+#-------------------------------------------------------------------
+         OBSERVATION     =C_OBSERVATION(),
+#-------------------------------------------------------------------
+         SUIVI_DDL       =C_SUIVI_DDL(),
+#-------------------------------------------------------------------
+         ARCHIVAGE       =C_ARCHIVAGE(),
+#-------------------------------------------------------------------   
+         AFFICHAGE      = C_AFFICHAGE(),
+#-------------------------------------------------------------------   
          CRIT_FLAMB     =FACT(statut='f',min=1,max=1,
            NB_FREQ         =SIMP(statut='f',typ='I',max=1,defaut=3),
            CHAR_CRIT       =SIMP(statut='f',typ='R',min=2,max=2,defaut=(-10.0,10),
@@ -27315,7 +28795,15 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli,
                                           'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C','V11','V12','V13','V21','V22',
                                           'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21','PRES22','PRES23',
                                           'PRES31','PRES32','PRES33','VARI','LAG_GV')),),
-           INST_CALCUL       =SIMP(statut='f',typ='TXM',defaut="LISTE_ARCHIVAGE",into=("LISTE_ARCHIVAGE","TOUT_PAS",) ),
+           regles         = (EXCLUS('PAS_CALC','LIST_INST','INST'),),
+           LIST_INST      = SIMP(statut='f',typ=(listr8_sdaster) ),
+           INST           = SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
+           PAS_CALC       = SIMP(statut='f',typ='I' ),
+           CRITERE        = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+              b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+                 PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+              b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                 PRECISION       =SIMP(statut='o',typ='R',),),
          ),
            SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
                                fr="Liste des paramètres de sensibilité",
@@ -27334,6 +28822,88 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli,
          TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
  )
 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR PROIX J-M.PROIX 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE PROIX J.M.PROIX
+
+from Macro.test_compor_ops import test_compor_ops
+
+#              MACRO "TEST_THERMOPLASTIQUE"
+#           ----------------------------
+
+TEST_COMPOR =MACRO(nom="TEST_COMPOR", op=test_compor_ops,sd_prod=table_sdaster,
+                       docu="",reentrant='n',
+                       fr="macro de test des comportements incrementaux dependant de la temperature",         
+
+         OPTION         =SIMP(statut='f',typ='TXM',into=("THER","MECA"),defaut="THER"),
+
+         COMP_INCR       =C_COMP_INCR(),
+         COMP_ELAS       =C_COMP_ELAS('SIMU_POINT_MAT'),
+         NEWTON          =C_NEWTON(),
+         CONVERGENCE     =C_CONVERGENCE(),
+         
+         b_ther          =BLOC(condition = "OPTION == 'THER'",
+            regles=(EXCLUS('C_PRAG','D_SIGM_EPSI'),),
+            MATER           =SIMP(statut='o',typ=mater_sdaster,max=1,fr="materiau dependant de la temperature"),
+            ALPHA           =SIMP(statut='o',typ=fonction_sdaster,
+                                  fr="coefficient de dilatation fonction de la temperature"),
+            YOUNG           =SIMP(statut='o',typ=fonction_sdaster,
+                                  fr="module d'Young fonction de la temperature"),
+            LIST_MATER      =SIMP(statut='o',typ=mater_sdaster,max='**', 
+                                          fr="liste des materiaux constants interpolés à chaque température"),
+            TEMP_INIT       =SIMP(statut='o',typ='R', fr="temperature initiale et de reference"),
+            TEMP_FIN        =SIMP(statut='o',typ='R', fr="temperature finale"),
+            INST_FIN        =SIMP(statut='f',typ='R',defaut=1.,fr="instant final"),
+            NB_VARI         =SIMP(statut='o',typ='I', fr="nombre de variables internes - 0 en elasticité"),
+            VARI_TEST       =SIMP(statut='f',typ='TXM',max='**', 
+                                  fr="liste de variables internes à tester - par defaut, toutes"),
+
+#           special ecrouissage cinematique
+            D_SIGM_EPSI     =SIMP(statut='f',typ=fonction_sdaster,
+                                  fr="module tangent fonction de la temperature- VMIS_CINE_LINE"),
+            C_PRAG          =SIMP(statut='f',typ=fonction_sdaster,
+                                  fr="constante de Prager fonction de la temperature- VMIS_ECMI_*"),
+                        ),
+         b_meca          =BLOC(condition = "OPTION == 'MECA'",
+            LIST_MATER      =SIMP(statut='o',typ=mater_sdaster,max=2,min=2, 
+                                          fr="liste des materiaux en Pa puis MPa "),
+            YOUNG           =SIMP(statut='o',typ='R',fr="module d'Young"),
+            POISSON         =SIMP(statut='o',typ='R',fr="coef de Poisson"),
+            LIST_NPAS       =SIMP(statut='f',typ='I',max='**',
+                                  fr="nombre de pas de temps pour chaque discretisation"),
+            LIST_TOLE       =SIMP(statut='f',typ='R',max='**',),
+            PREC_ZERO       =SIMP(statut='f',typ='R',max='**',),
+            VARI_TEST       =SIMP(statut='f',typ='TXM',max='**',defaut=('V1','VMIS','TRACE'), 
+                                  fr="liste des CMP à tester "),
+            SUPPORT         =SIMP(statut='f',typ='TXM',max=1,into=("POINT","ELEMENT",)),
+            MODELISATION    =SIMP(statut='f',typ='TXM',max=1,into=("3D","C_PLAN"),defaut="3D",),
+            ANGLE           =SIMP(statut='f',typ='R',max=1, defaut=0.,
+             fr='Rotation de ANGLE autour de Z uniquement, et seulement pour les déformations imposées',),
+            MASSIF          =FACT(statut='f',max='**',fr='orientation du materiau (monocristal, orthotropie)',
+              regles=(UN_PARMI('ANGL_REP','ANGL_EULER'),),
+              ANGL_REP        =SIMP(statut='f',typ='R',min=1,max=3),
+              ANGL_EULER      =SIMP(statut='f',typ='R',min=1,max=3),
+                                 ),
+                               ),
+            INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+                 )
 #& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -27762,10 +29332,10 @@ TEST_TEMPS=MACRO(nom="TEST_TEMPS",op=test_temps_ops, sd_prod=None,
    INFO  = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
 )
 
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -27847,7 +29417,7 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f',
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -27856,11 +29426,12 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f',
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
 
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
@@ -27872,7 +29443,7 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f',
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -27884,24 +29455,16 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f',
            ),
          ),
          PARM_THETA      =SIMP(statut='f',typ='R',defaut= 0.57),
-         ARCHIVAGE       =FACT(statut='f',
-           regles=EXCLUS('PAS_ARCH','LIST_INST','INST'),
-           LIST_INST       =SIMP(statut='f',typ=(listr8_sdaster) ),
-           INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-           PAS_ARCH        =SIMP(statut='f',typ='I' ),
-           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           NUME_INIT       =SIMP(statut='f',typ='I'),
-           DETR_NUME_SUIV  =SIMP(statut='f',typ='TXM',into=("OUI",)),
-           CHAM_EXCLU      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',
-                                 into=("VARI",)),
-         ),
+#-------------------------------------------------------------------
+         ARCHIVAGE       =C_ARCHIVAGE(),         
+#-------------------------------------------------------------------
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
          INFO            =SIMP(statut='f',typ='I',into=(1,2)),
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 21/02/2011   AUTEUR ABBAS M.ABBAS 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -28003,7 +29566,7 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f',
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -28012,13 +29575,14 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f',
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),           
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO","SCOTCH",)),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              FILTRAGE_MATRICE=SIMP(statut='f',typ='R',defaut=-1.0,),
              MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE  =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
 
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
@@ -28030,7 +29594,7 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f',
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 
@@ -28043,45 +29607,21 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f',
            SYME            =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
          ),
          PARM_THETA      =SIMP(statut='f',typ='R',defaut= 0.57 ),
-         ARCHIVAGE       =FACT(statut='f',
-           regles=EXCLUS('PAS_ARCH','LIST_INST','INST'),
-           LIST_INST       =SIMP(statut='f',typ=(listr8_sdaster) ),
-           INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-           PAS_ARCH        =SIMP(statut='f',typ='I' ),
-           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-6),
-           NUME_INIT       =SIMP(statut='f',typ='I'),
-           DETR_NUME_SUIV  =SIMP(statut='f',typ='TXM',into=("OUI",)),
-           CHAM_EXCLU      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',
-                                 into=("VARI",)),
-         ),
-         OBSERVATION     =FACT(statut='f',max='**',
-           NOM_CMP         =SIMP(statut='o',typ='TXM',max='**' ),
-           SUIVI_DDL       =SIMP(statut='c',typ='TXM',defaut="NON",max=1,into=("NON",)),
-         b_non_suivi      =BLOC(condition = "SUIVI_DDL == 'NON' ",
-                                regles=(UN_PARMI('NOEUD','GROUP_NO')),
-             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
-             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
-             NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("TEMP",)),
-             INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),
-             LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
-             PAS_OBSE        =SIMP(statut='f',typ='I'),
-             LIST_ARCH       =SIMP(statut='f',typ=listis_sdaster),
-             CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
-             b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
-                PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
-             b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
-                PRECISION       =SIMP(statut='o',typ='R',),),),
-         ),
+#-------------------------------------------------------------------
+         ARCHIVAGE       =C_ARCHIVAGE(),
+#-------------------------------------------------------------------
+         OBSERVATION     =C_OBSERVATION(),
+#------------------------------------------------------------------- 
          TITRE           =SIMP(statut='f',typ='TXM',max='**'),
          OPTION          =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2,
-                               into=("FLUX_ELGA_TEMP","FLUX_ELNO_TEMP") ),
+                               into=("FLUX_ELGA","FLUX_ELNO") ),
          INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
 
 )  ;
-#& MODIF COMMANDE  DATE 09/11/2010   AUTEUR DELMAS J.DELMAS 
+#& MODIF COMMANDE  DATE 08/02/2011   AUTEUR TARDIEU N.TARDIEU 
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
-# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# COPYRIGHT (C) 1991 - 2011  EDF R&D                  WWW.CODE-ASTER.ORG
 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
@@ -28139,7 +29679,7 @@ THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther,
                RENUM               =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
                ),
              b_simple        =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                ),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
              NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
@@ -28148,11 +29688,12 @@ THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther,
              TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
              PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
              POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
-             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","SCOTCH","AUTO")),
              ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
              PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
              RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
              OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             LIBERE_MEMOIRE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
              ),
            b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
              ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
@@ -28163,7 +29704,7 @@ THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther,
                RENUM            =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
              ),
              b_ldlt_sp      =BLOC(condition = "PRE_COND == 'LDLT_SP' ", fr="Paramètres de la factorisation simple précision",
-               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=5, ),
+               REAC_PRECOND        =SIMP(statut='f',typ='I',defaut=30, ),
                RENUM               =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","RCMK") ),
              ),
              b_jacobi_sor   =BLOC(condition = "PRE_COND == 'JACOBI' or PRE_COND == 'SOR'", 

diff --git a/Traducteur/traduitV9V10.py b/Traducteur/traduitV9V10.py
index ec3c7e18c33f936112af106a6f87e03ff927dcd7..0330043fe5150d47df5d32fcbf92d9b8bdbc587a 100755 (executable)
--- a/Traducteur/traduitV9V10.py
+++ b/Traducteur/traduitV9V10.py
@@ -508,8 +508,10 @@ def traduc(infile,outfile,flog=None):
     renameMotCle(jdc,"MACR_ADAP_MAIL","TYPE_VALEUR_INDICA","USAGE_CMP")
     AjouteMotClefDansFacteurCourantSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='BOITE'",((("RAYON",),"nexistepasMCsousMCFcourant"),))
     AjouteMotClefDansFacteurCourantSiRegle(jdc,"MACR_ADAP_MAIL","ZONE","TYPE='SPHERE'",((("RAYON",),"existeMCsousMCFcourant"),))
-    ChangementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_5":"V9_9"})
-    ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_5":"V9_9"})
+    ChangementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_5":"V10_1"})
+    ChangementValeur(jdc,"MACR_ADAP_MAIL","VERSION_HOMARD",{"V9_N":"V10_1_N"})
+    ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_5":"V10_1"})
+    ChangementValeur(jdc,"MACR_INFO_MAIL","VERSION_HOMARD",{"V9_N":"V10_1_N"})
 
     ###################### traitement de POST_CHAM_XFEM  #################
     removeMotCle(jdc,"POST_CHAM_XFEM","MODELE",pasDeRegle(),0)
@@ -593,7 +595,7 @@ def traduc(infile,outfile,flog=None):
              "VARI_NOEU_ELGA":"VARI_NOEU","VARI_ELNO_ELGA":"VARI_ELNO",
              "INDI_LOCA_ELGA":"INDL_ELGA"}
     #"FORC_NODA":"FORC_NOEU","REAC_NODA":"REAC_NOEU"
-    ChangementValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VAR_C","NOM_CHAM",dOPTION)
+    ChangementValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VARC","NOM_CHAM",dOPTION)
     ChangementValeur(jdc,"COMB_FOURIER","NOM_CHAM",dOPTION)
     ChangementValeur(jdc,"CREA_CHAMP","NOM_CHAM",dOPTION)
     ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dOPTION)
@@ -637,7 +639,7 @@ def traduc(infile,outfile,flog=None):
     # Options ambigue :  PRES_ELNO_DBEL --> prac_elno/prme_elno, ERRE* --> ERME_ELNO ou ERTH_ELNO selon PHENOMENE
     # En commentaires les commandes non concernees par rOPTION
     
-    GenereErreurValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VAR_C","NOM_CHAM",rOPTION)
+    GenereErreurValeurDsMCF(jdc,"AFFE_MATERIAU","AFFE_VARC","NOM_CHAM",rOPTION)
     #GenereErreurValeur(jdc,"COMB_FOURIER","NOM_CHAM",rOPTION)
     GenereErreurValeur(jdc,"CREA_CHAMP","NOM_CHAM",rOPTION)
     GenereErreurValeur(jdc,"CREA_RESU","NOM_CHAM",rOPTION)
@@ -686,6 +688,9 @@ def traduc(infile,outfile,flog=None):
     removeMotCle(jdc,"CALC_MISS","UNITE_OPTI_MISS",pasDeRegle())
     removeMotCle(jdc,"CALC_MISS","UNITE_MODELE_SOL",pasDeRegle())
     removeMotCle(jdc,"CALC_MISS","OPTION",pasDeRegle(),1)
+    ChangementValeur(jdc,"CALC_MISS","VERSION",{"V1_4":"V6.5"})
+    ChangementValeur(jdc,"CALC_MISS","VERSION",{"V1_5":"V6.6"})
+    ChangementValeur(jdc,"CALC_MISS","VERSION",{"V1_3":"V6.5"})
 
     macr=""
     interf=""