*** empty log message ***

diff --git a/Aster/Cata/cataSTA10/Macro/__init__.py b/Aster/Cata/cataSTA10/Macro/__init__.py
new file mode 100644 (file)
index 0000000..4aebb58
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/__init__.py
@@ -0,0 +1,21 @@
+#@ MODIF __init__ Macro  DATE 20/09/2004   AUTEUR DURAND C.DURAND 
+# -*- coding: iso-8859-1 -*-
+#            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.      
+#                                                                       
+#                                                                       
+# ======================================================================

diff --git a/Aster/Cata/cataSTA10/Macro/calc_ecrevisse_ops.py b/Aster/Cata/cataSTA10/Macro/calc_ecrevisse_ops.py
new file mode 100644 (file)
index 0000000..b14842d
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_ecrevisse_ops.py
@@ -0,0 +1,799 @@
+#@ MODIF calc_ecrevisse_ops Macro  DATE 05/10/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+
+# Debut de la macro, on impose en parametre les donnees placer dans T_EC, l'appel a ecrevisse
+
+def calc_ecrevisse_ops(self,
+    CHARGE_MECA,
+    CHARGE_THER1,
+    CHARGE_THER2,
+    TABLE,
+    DEBIT,
+    MODELE_MECA,
+    MODELE_THER,
+    RESULTAT,
+    FISSURE,
+    ECOULEMENT,
+    MODELE_ECRE,
+    CONVERGENCE,
+    LOGICIEL,
+    VERSION,
+    ENTETE,
+    IMPRESSION,
+    INFO,
+    COURBES,
+    **args):
+
+    """
+        Procedure de couplage Aster-Ecrevisse
+        Recuperation du profil de la fissure , appel de MACR_ECRE_CALC, 
+        creation des tableaux de resultats et des chargements pour AsterGeneration par Aster
+    """
+
+    import os, string, types, shutil
+    import aster
+    from Accas import _F
+    from Noyau.N_utils import AsType
+    from Utilitai.Utmess import UTMESS
+    from Utilitai.Table import Table, merge
+    from math import atan, pi, sqrt
+
+    ier=0
+
+    # Concepts sortant
+    self.DeclareOut('__TAB',TABLE)
+    self.DeclareOut('__ECR_F1',CHARGE_THER1)
+    self.DeclareOut('__ECR_F2',CHARGE_THER2)
+    self.DeclareOut('__ECR_P',CHARGE_MECA)
+    self.DeclareOut('__DEB',DEBIT)
+
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    # Parametres Developpeur
+    tmp_ecrevisse = "tmp_ecrevisse"
+    fichier_data = "data.dat"
+    defaut = '00'
+    # Niveaux de debug
+    debug1 = (INFO>1)
+    debug2 = (INFO>2)
+    #
+    InfoAster = 1
+    #
+    oldVersion = False  # Permet de retourner un chargement thermique defini selon l'ancien mode (flux thermique)
+
+    # IMPORTATION DE COMMANDES ASTER
+    DEFI_GROUP       = self.get_cmd("DEFI_GROUP")
+    POST_RELEVE_T    = self.get_cmd("POST_RELEVE_T")
+    MACR_ECRE_CALC   = self.get_cmd("MACR_ECRE_CALC")
+    IMPR_TABLE       = self.get_cmd("IMPR_TABLE")
+    DETRUIRE         = self.get_cmd("DETRUIRE")
+    IMPR_CO          = self.get_cmd("IMPR_CO")
+    DEFI_FONCTION    = self.get_cmd("DEFI_FONCTION")
+    CREA_TABLE       = self.get_cmd("CREA_TABLE")
+    CO               = self.get_cmd("CO")
+    AFFE_CHAR_THER_F = self.get_cmd("AFFE_CHAR_THER_F")
+    AFFE_CHAR_MECA_F = self.get_cmd("AFFE_CHAR_MECA_F")
+    DEFI_FICHIER     = self.get_cmd("DEFI_FICHIER")
+
+    # RECUPERATION DES MOTS-CLES FACTEURS
+    dRESULTAT=RESULTAT[0].cree_dict_valeurs(RESULTAT[0].mc_liste)
+    for i in dRESULTAT.keys():
+        if dRESULTAT[i]==None : del dRESULTAT[i]
+
+    dECOULEMENT=ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
+    for i in dECOULEMENT.keys():
+        if dECOULEMENT[i]==None : del dECOULEMENT[i]
+
+    dMODELE_ECRE=MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
+    for i in dMODELE_ECRE.keys():
+        if dMODELE_ECRE[i]==None : dMODELE_ECRE[i]=None #del dMODELE_ECRE[i]
+
+    dCONVERGENCE=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+    for i in dCONVERGENCE.keys():
+        if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
+
+    # Instants
+    _l_inst = dRESULTAT['MECANIQUE'].LIST_VARI_ACCES()
+    if dRESULTAT.has_key('INST'):
+        Inst_Ecrevisse = dRESULTAT['INST']
+    else:
+        pass
+
+    # ancienne version
+    # liste des mots cles facteurs de FLUX_REP pour le flux F1 de chaque fissure (sur GROUP_MA[0])
+    l_FLUX_REP_F1 = []
+    # liste des mots cles facteurs de PRES_REP pour le flux F2 de  chaque fissure (sur GROUP_MA[1])
+    l_FLUX_REP_F2 = []
+    
+    # nouvelle version
+    # liste des mots cles facteurs de ECHANGE pour le flux F1 de chaque fissure (sur GROUP_MA[0])
+    l_ECHANGE_F1 = []
+    # liste des mots cles facteurs de ECHANGE pour le flux F2 de chaque fissure (sur GROUP_MA[1])
+    l_ECHANGE_F2 = []
+    
+    # Toutes versions
+    # liste des mots cles facteurs de PRES_REP pour chaque fissure
+    l_PRES_REP = []
+
+
+    # Liste des noms des groupes de noeuds du maillage
+    _lgno = map(lambda x: x[0], MODELE_MECA['MAILLAGE'].LIST_GROUP_NO() )
+
+    for k, fissure in enumerate(FISSURE):
+        dFISSURE=fissure.cree_dict_valeurs(fissure.mc_liste)
+        for i in dFISSURE.keys():
+            if dFISSURE[i]==None : del dFISSURE[i]
+
+        # On cree les group_no correspondant aux group_ma des levres de la fissure dans le cas ou ils n'existent pas deja
+        if not dFISSURE['GROUP_MA'][0] in _lgno:
+            DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                       MAILLAGE=MODELE_MECA['MAILLAGE'],
+                       CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][0]),),);
+
+        if not dFISSURE['GROUP_MA'][1] in _lgno:
+            DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                       MAILLAGE=MODELE_MECA['MAILLAGE'],
+                       CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),),);
+
+        # Test sur le nombre de caracteres du nom des group_ma
+        if len(dFISSURE['GROUP_MA'][0]) >7:
+            sys.exit(1)
+
+        if len(dFISSURE['GROUP_MA'])>1 and len(dFISSURE['GROUP_MA'][1]) >7:
+            sys.exit(1)
+
+        # Creation des group_no ordonnes des levres des fissures
+        _nom_gno_1 = '_' + dFISSURE['GROUP_MA'][0]
+        if not _nom_gno_1 in _lgno:
+            DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                       MAILLAGE=MODELE_MECA['MAILLAGE'],
+                       CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
+                                        NOM=_nom_gno_1,
+                                        GROUP_NO=dFISSURE['GROUP_MA'][0],
+                                        GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][0],
+                                        GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][0],
+                                        PRECISION=0.001,
+                                        CRITERE='ABSOLU',),
+                       INFO=InfoAster,);
+
+
+        if len(dFISSURE['GROUP_MA'])>1:
+            _nom_gno_2 = '_' + dFISSURE['GROUP_MA'][1]
+            if not _nom_gno_2 in _lgno:
+                DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                           MAILLAGE=MODELE_MECA['MAILLAGE'],
+                           CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
+                                            NOM=_nom_gno_2,
+                                            GROUP_NO=dFISSURE['GROUP_MA'][1],
+                                            GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][1],
+                                            GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][1],
+                                            PRECISION=0.001,
+                                            CRITERE='ABSOLU',),
+                           INFO=InfoAster,);
+
+        _T_DY=POST_RELEVE_T(ACTION=_F(INTITULE='DEPL_FIS',
+                                      GROUP_NO=_nom_gno_1,
+                                      RESULTAT=dRESULTAT['MECANIQUE'],
+                                      NOM_CHAM='DEPL',
+                                      NOM_CMP=('DX','DY',),
+                                      INST = Inst_Ecrevisse,
+                                      OPERATION='EXTRACTION',),
+                                      );
+
+        if len(dFISSURE['GROUP_MA'])>1:
+            # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
+            # represente par une seule levre et l'autre est fixe
+            _T_DY_B=POST_RELEVE_T(ACTION=_F(INTITULE='DX_FIS',
+                                            GROUP_NO=_nom_gno_2,
+                                            RESULTAT=dRESULTAT['MECANIQUE'],
+                                            NOM_CHAM='DEPL',
+                                            NOM_CMP=('DX','DY',),
+                                            INST = Inst_Ecrevisse,
+                                            OPERATION='EXTRACTION',),);
+
+        _T_TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
+                                        GROUP_NO=_nom_gno_1,
+                                        RESULTAT=dRESULTAT['THERMIQUE'],
+                                        NOM_CHAM='TEMP',
+                                        TOUT_CMP='OUI',
+                                        INST = Inst_Ecrevisse,
+                                        OPERATION='EXTRACTION',),);
+
+        if len(dFISSURE['GROUP_MA'])>1:
+            _T_TEMPB=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
+                                             GROUP_NO=_nom_gno_2,
+                                             RESULTAT=dRESULTAT['THERMIQUE'],
+                                             NOM_CHAM='TEMP',
+                                             TOUT_CMP='OUI',
+                                             INST = Inst_Ecrevisse,
+                                             OPERATION='EXTRACTION',),);
+
+        if ( debug2 ) :
+            print '_T_DY ==================================================='
+            print  _T_DY.EXTR_TABLE()
+            print '_T_TEMP ================================================='
+            print  _T_TEMP.EXTR_TABLE()
+
+
+        # Extraction des tables Temperatures + deplacement levres fissure
+        _tbl_temp = _T_TEMP.EXTR_TABLE()
+        _tbl_dy   = _T_DY.EXTR_TABLE()
+        DETRUIRE(CONCEPT=_F(NOM=(_T_DY,_T_TEMP,)),INFO=1,ALARME='NON')
+        
+        # Determination de la direction de la fissure : limitee aux cas horizontal ou vertical a cause
+        # de la creation des chargement pour aster
+        
+        _xih = _tbl_dy.values()['COOR_X'][0] 
+        _yih = _tbl_dy.values()['COOR_Y'][0] 
+        _xeh = _tbl_dy.values()['COOR_X'][-1] 
+        _yeh = _tbl_dy.values()['COOR_Y'][-1]    
+
+        if abs(_xeh -_xih)<1.E-6 : # fissure verticale
+
+           if (_yeh-_yih)<0 : # fluide du haut vers le bas
+              alpha = 180.  
+           else :
+              alpha =0.   # fluide du bas vers le haut
+           DIR_FISS='Y'
+           NORM_FISS='X'
+        elif abs(_yih - _yeh)<1.E-6 : # fissure horizontale
+           alpha = 90.
+           DIR_FISS ='X'
+           NORM_FISS = 'Y'
+        else:
+           UTMESS('F','ECREVISSE0_23')
+        
+#        Determination de l'ouverture de la fissure
+
+        _l_dy1 = _tbl_dy.values()['ABSC_CURV']
+        _l_dy2 = [ x + y for (x,y) in zip(_tbl_dy.values()['D%s' % NORM_FISS], _tbl_dy.values()['COOR_%s' % NORM_FISS]) ]
+
+        # Listes des cotes et ouvertures (deuxieme groupe)
+        if len(dFISSURE['GROUP_MA'])>1:
+            # signifie que l'on prend en compte la deuxieme levre de la fissure,
+            _tbl_dy_b  = _T_DY_B.EXTR_TABLE()
+            _tbl_temp_b = _T_TEMPB.EXTR_TABLE()
+            DETRUIRE(CONCEPT=_F(NOM=(_T_DY_B,_T_TEMPB,)),INFO=1,ALARME='NON')
+            
+            _l_dy1_b = _tbl_dy_b.values()['ABSC_CURV']
+            _l_dy2_b = [ x + y for (x,y) in zip(_tbl_dy_b.values()['D%s' % NORM_FISS], _tbl_dy_b.values()['COOR_%s' % NORM_FISS]) ]
+
+        # Listes des cotes et temperatures (premier groupe)
+        _l_t1  = _tbl_temp.values()['ABSC_CURV']
+        _l_t2  = _tbl_temp.values()['TEMP']
+        
+        # Listes des cotes et temperatures (deuxieme groupe)
+        if len(dFISSURE['GROUP_MA'])>1:
+            # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
+            # represente par une seule levre et l'autre est fixe
+
+            _l_t1_b  = _tbl_temp_b.values()['ABSC_CURV']
+            _l_t2_b  = _tbl_temp_b.values()['TEMP']
+
+
+        if ( debug2 ):
+            print "Informations de debug:\n"
+            print 'Inst_Ecrevisse=', Inst_Ecrevisse
+            print '_l_t1=', len(_l_t1),_l_t1
+            print '_l_t2=', len(_l_t2),_l_t2
+            print '_l_dy1=', len(_l_dy1),_l_dy1
+            print '_l_dy2=', len(_l_dy2),_l_dy2
+
+            if len(dFISSURE['GROUP_MA'])>1:
+                print '_l_t1_b=', len(_l_t1_b),_l_t1_b
+                print '_l_t2_b=', len(_l_t2_b),_l_t2_b
+                print '_l_dy1_b=', len(_l_dy1_b),_l_dy1_b
+                print '_l_dy2_b=', len(_l_dy2_b),_l_dy2_b
+
+
+        # Affichage d'informations que l'on peut voir sur le fichier .mess ou .resu
+
+        if (debug1):
+           UTMESS('I', 'ECREVISSE0_1', valk=["Premiere levre"],
+                valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
+
+           if len(dFISSURE['GROUP_MA'])>1:
+               UTMESS('I', 'ECREVISSE0_1',valk=["Deuxieme levre"],
+                    valr=[Inst_Ecrevisse,min(_l_t1_b), max(_l_t1_b), min(_l_t2_b), max(_l_t2_b), min(_l_dy1_b), max(_l_dy1_b), min(_l_dy2_b), max(_l_dy2_b)])
+
+
+        # ----------------------------------------------------------------------------------
+        # Partie concernant la prise en compte des deux levres
+        if len(dFISSURE['GROUP_MA'])>1:
+
+            # Calcul de l'ouverture entre les deux levres
+            _l_dy2 = map(lambda x,y: abs(y-x), _l_dy2, _l_dy2_b)
+
+            # Pour la temperature, on fait la moyenne des temperatures des deux levres (points a ameliorer peut etre par un autre modele)
+            _l_t2  = map(lambda x,y: 0.5*(x+y), _l_t2_b,_l_t2)
+
+        # ----------------------------------------------------------------------------------
+        
+        if dFISSURE['OUVERT_REMANENTE']:
+            # une fissure refermee a une ouverture egale a l'ouverture remanente
+            _l_dy2 = map(lambda x: max(dFISSURE['OUVERT_REMANENTE'],x), _l_dy2)
+        
+        UTMESS('I', 'ECREVISSE0_2',
+                valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
+
+
+        if ( debug2 ):
+            print "Informations de debug:\n"
+            print 'Inst_Ecrevisse=', Inst_Ecrevisse
+            print '_l_t1=', len(_l_t1),_l_t1
+            print '_l_t2=', len(_l_t2),_l_t2
+            print '_l_dy1=', len(_l_dy1),_l_dy1
+            print '_l_dy2=', len(_l_dy2),_l_dy2
+
+        # Test de non divergence, les messages sont assez explicites
+
+        # Si toutes les listes sont bien definies
+        if len(_l_dy1)*len(_l_dy2)*len(_l_t1)*len(_l_t2) == 0:
+            UTMESS('F','ECREVISSE0_3', valr=[Inst_Ecrevisse])
+            __TAB = None
+            break
+
+        # Si les ouvertures ne sont pas trop faibles
+        elif min(_l_dy2) < 1e-20:
+            UTMESS('F','ECREVISSE0_4', valr=[Inst_Ecrevisse, min(_l_dy2)])
+            __TAB = None
+            break
+
+        elif max(_l_t2) > 700:
+            UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2 )])
+            __TAB = None
+            break
+
+        elif max(_l_t2_b) > 700:
+            UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2_b )])
+            __TAB = None
+            break
+
+        elif min(_l_t2) < 0:
+            UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2 )])
+            __TAB = None
+            break
+
+        elif min(_l_t2_b) < 0:
+            UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2_b )])
+            __TAB = None
+            break
+
+        elif abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) )< 5:
+            UTMESS('F','ECREVISSE0_7', valr=[Inst_Ecrevisse, abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) ) ] )
+            __TAB = None
+            break
+
+        # On lance Ecrevisse
+        else:
+            UTMESS('I','ECREVISSE0_8', valr=[Inst_Ecrevisse])
+
+            # On efface le rep
+            try:
+                for fic in os.listdir(os.path.join(os.getcwd(),tmp_ecrevisse)):
+                    try:
+                        os.remove( os.path.join(os.getcwd(),tmp_ecrevisse) + '/' + fic )
+                    except:
+                        pass
+            except:
+                pass
+
+            if dFISSURE.has_key('LISTE_COTES_BL'):
+                __LISTE_COTES_BL = dFISSURE['LISTE_COTES_BL']
+            else:
+                __LISTE_COTES_BL = (0., max(_l_dy1))
+
+            # Mot-cle ECOULEMENT
+            txt={}
+            txt = { 'PRES_ENTREE' : dECOULEMENT['PRES_ENTREE'],
+                    'PRES_SORTIE' : dECOULEMENT['PRES_SORTIE'],
+                    'FLUIDE_ENTREE'   : dECOULEMENT['FLUIDE_ENTREE'],
+                    }
+            if int(dECOULEMENT['FLUIDE_ENTREE']) in [1, 3, 4, 6]:
+                txt['TEMP_ENTREE'] = dECOULEMENT['TEMP_ENTREE']
+            if int(dECOULEMENT['FLUIDE_ENTREE']) in [2, 5]:
+                txt['TITR_MASS'] = dECOULEMENT['TITR_MASS']
+            if int(dECOULEMENT['FLUIDE_ENTREE']) in [4, 5]:
+                txt['PRES_PART'] = dECOULEMENT['PRES_PART']
+
+
+            # Traitement des cas ou les mots cles reynold, xminch, etc... ne doivent pas apparaitre
+            # Mot-cle MODELE_ECRE
+            txt2 = {}
+            txt2['ECOULEMENT'] = dMODELE_ECRE['ECOULEMENT']
+            if dMODELE_ECRE['ECOULEMENT'] == 'GELE' :
+                txt2['PRESS_EBULLITION'] = dMODELE_ECRE['PRESS_EBULLITION']
+
+            txt2['FROTTEMENT'] = dMODELE_ECRE['FROTTEMENT']
+
+            if int(dMODELE_ECRE['FROTTEMENT']) in [-4,-3,-2,-1] :
+                txt2['REYNOLDS_LIM'] = dMODELE_ECRE['REYNOLDS_LIM']
+                txt2['FROTTEMENT_LIM'] = dMODELE_ECRE['FROTTEMENT_LIM']
+
+            txt2['TRANSFERT_CHAL'] = dMODELE_ECRE['TRANSFERT_CHAL']
+            if int(dMODELE_ECRE['TRANSFERT_CHAL']) in [-2,-1] :
+                txt2['XMINCH'] = dMODELE_ECRE['XMINCH']
+                txt2['XMAXCH'] = dMODELE_ECRE['XMAXCH']
+
+            try :
+                if dMODELE_ECRE['IVENAC'] in [0, 1]:
+                    txt2['IVENAC'] = dMODELE_ECRE['IVENAC']
+                else :
+                    txt2['IVENAC'] = 0
+            except :
+                txt2['IVENAC'] = 0
+
+            motscle2= {'ECOULEMENT': txt, 'MODELE_ECRE' : txt2 }
+
+            DETRUIRE(OBJET=_F(CHAINE = '_TAB2' ),INFO=1,ALARME='NON')
+            DETRUIRE(OBJET=_F(CHAINE = '_DEB2' ),INFO=1,ALARME='NON')
+            __TAB_i = CO('_TAB2')
+            __DEB_i = CO('_DEB2')
+
+            MACR_ECRE_CALC(TABLE = __TAB_i,
+                           DEBIT = __DEB_i,
+                           ENTETE=ENTETE,
+                           COURBES=COURBES,
+                           IMPRESSION=IMPRESSION,
+                           INFO=INFO,
+                           LOGICIEL=LOGICIEL,
+                           VERSION=VERSION,
+                           FISSURE=_F(LONGUEUR           = max(_l_dy1)/dFISSURE['TORTUOSITE'],
+                                   ANGLE              = alpha,
+                                   RUGOSITE           = dFISSURE['RUGOSITE'],
+                                   ZETA               = dFISSURE['ZETA'],
+                                   SECTION            = dFISSURE['SECTION'],
+                                   LISTE_COTES_AH     = _l_dy1,
+                                   LISTE_VAL_AH       = _l_dy2,
+                                   LISTE_COTES_BL     = __LISTE_COTES_BL,
+                                   LISTE_VAL_BL       = dFISSURE['LISTE_VAL_BL'],
+                                   ),
+                           TEMPERATURE=_F(GRADIENT       = 'FOURNI',
+                                       LISTE_COTES_TEMP = _l_t1,
+                                       LISTE_VAL_TEMP   = _l_t2,
+                                       ),
+                           CONVERGENCE=_F(KGTEST         = dCONVERGENCE['KGTEST'],
+                                       ITER_GLOB_MAXI = dCONVERGENCE['ITER_GLOB_MAXI'],
+                                       CRIT_CONV_DEBI = dCONVERGENCE['CRIT_CONV_DEBI'],
+                                       ),
+                           **motscle2
+                           );
+            
+            # Creation de la table resultat sur toutes les fissures:
+
+            # Nom de la fissure
+            nom_fiss = dFISSURE['GROUP_MA'][0] + "-" + dFISSURE['GROUP_MA'][1]
+            # Creation de la table
+            __TABFISS_i = __TAB_i.EXTR_TABLE()
+            __DEBFISS_i = __DEB_i.EXTR_TABLE()
+            # Taille de la table
+            nb_lignes_table = len(__TABFISS_i["COTES"])
+            # Ajout d'une colonne supplementaire
+            __TABFISS_i["FISSURE"] = [nom_fiss] * nb_lignes_table
+            __DEBFISS_i["FISSURE"] = [nom_fiss]
+            if k==0:
+                __TABFISS_tot = __TABFISS_i
+                __DEBFISS_tot = __DEBFISS_i
+            else:
+                __TABFISS_tot = merge(__TABFISS_tot, __TABFISS_i)
+                __DEBFISS_tot = merge(__DEBFISS_tot, __DEBFISS_i)
+            
+            
+            DETRUIRE(OBJET=_F(CHAINE = '__TAB_i' ),INFO=1,ALARME='NON')
+            DETRUIRE(OBJET=_F(CHAINE = '__DEB_i' ),INFO=1,ALARME='NON')
+
+            if ( debug2 ):
+               os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+
+            pref_fic = dFISSURE['PREFIXE_FICHIER']
+
+            # Ecriture du fichier debits en fonction du temps:
+            try:
+                # on lit le fichier debit produit par ecrevisse
+                f_ast = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+                _txt = f_ast.read()
+                f_ast.close()
+                nomfic = str(pref_fic) + '_debits'
+                # on concatene
+                fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic, 'a')
+                fw.write( str(Inst_Ecrevisse) + ' ' + _txt )
+                fw.close()
+                # On recopie le fichier debits pour reprise ulterieure
+                nomfic2 = 'debits_dernier'
+                fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic2, 'w')
+                fw.write( _txt )
+                fw.close()
+            except Exception, e:
+                print e
+
+
+            if COURBES != "AUCUNE":
+              # Pour masquer certaines alarmes
+              from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
+              MasquerAlarme('TABLE0_6')
+ 
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_flux')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','FLUX',),
+                         TITRE='Flux de chaleur a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Flux (W/m2)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_temperature')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','TEMP',),
+                         TITRE='Temperature a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Temperature (degres C)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_coeffconv')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','COEF_CONV',),
+                         TITRE='Coefficient de convection a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Coefficient de convection (W/m2/K)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+              
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_pression')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','PRESSION',),
+                         TITRE='Pression a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Pression (Pa)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+              
+              # Pour la gestion des alarmes
+              RetablirAlarme('TABLE0_6')
+
+
+            # On recopie dans REPE_OUT les fichiers resultats d'Ecrevisse
+            tmp_ecrevisse_absolu = os.path.join(os.getcwd(),tmp_ecrevisse)
+            repe_out_absolu = os.path.join(os.getcwd(),'REPE_OUT')
+            for file in os.listdir(tmp_ecrevisse_absolu):
+                if not file in ['ecrevisse', 'ecrevisse.sh']:
+                    old_file = os.path.join(tmp_ecrevisse_absolu, file)
+                    new_file = os.path.join(repe_out_absolu, str(pref_fic) + '_' + file + '_' + str(Inst_Ecrevisse))
+                    shutil.copy(old_file, new_file)
+
+            if ( debug2 ):
+                os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+
+
+            # Creation des chargements Aster
+            # ******************************
+
+            # Recuperation des valeurs dans la table (voir si il y a plus simple)
+            _lst_c = __TABFISS_i.COTES.values()
+            _lst_f = __TABFISS_i.FLUX.values()
+            _lst_p = __TABFISS_i.PRESSION.values()
+            _lst_t = __TABFISS_i.TEMP.values()
+            _lst_cc = __TABFISS_i.COEF_CONV.values()
+
+            _lis_dtot = __TABFISS_i.DEBTOT.values()
+            _lis_dair = __TABFISS_i.DEBAIR.values()
+            _lis_dvap = __TABFISS_i.DEBVAP.values()
+            _lis_dliq = __TABFISS_i.DEBLIQ.values()
+            _lis_ecou = __TABFISS_i.ECOULEMENT.values()
+            
+            if ( debug2 ):
+                print '_lst_c2=',_lst_c
+                print '_lst_f2=',_lst_f
+                print '_lst_p2=',_lst_p
+                print '_lst_t2=',_lst_t
+                print '_lst_cc2=',_lst_cc
+
+            try:
+                a=len(_lst_c)
+            except:
+                _lst_c = []
+                _lst_f = []
+                _lst_p = []
+                _lst_t = []
+                _lst_cc = []
+            try:
+                if _lst_c[1]==0:
+                    _lst_c = []
+                    _lst_f = []
+                    _lst_p = []
+                    _lst_t = []
+                    _lst_cc = []
+            except:
+                pass
+
+
+            # ------------------------------------------------------
+            # Extraction des conditions limites du calcul Ecrevisse
+            #
+            if len(_lst_c)>=2:
+                if ( debug2 ):
+                  print '_lst_c=',_lst_c
+                  print '_lst_f=',_lst_f
+                  print '_lst_p=',_lst_p
+                  print '_lst_t=',_lst_t
+                  print '_lst_cc=',_lst_cc
+
+                _lst_f=list(_lst_f)
+                _lst_p=list(_lst_p)
+                _lst_t=list(_lst_t)
+                _lst_cc=list(_lst_cc)
+
+                # decalage par rapport a l'abscisse curviligne (a regler)
+                _x0 = 0.001
+
+                # ANCIENNE VERSION (TRANSMISSION DES FLUX THERMIQUES
+                if(oldVersion) :
+                    # Creation des deux listes (x1, y1, x2, y2, ...)
+                    _tmp1=[]
+                    _tmp2=[]
+                    _tmp3=[]
+
+                    for i in range(len(_lst_c)):
+                        _tmp1.append( _x0 + _lst_c[i] )
+                        _tmp1.append( _lst_f[i] )
+                        _tmp3.append( _x0 + _lst_c[i] )
+                        _tmp3.append( -1*_lst_f[i] )
+
+                        _tmp2.append( _x0 + _lst_c[i] )
+                        _tmp2.append( _lst_p[i] )
+
+                    # Flux en provenance d'Ecrevisse
+
+                    _L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp1,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    _L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp3,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT' );
+
+                    l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+                                                            FLUX_X=_L_F1,))
+
+                    l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+                                                            FLUX_X=_L_F2,))
+
+                    # Pressions en provenance d'Ecrevisse
+                    _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp2,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
+                                                            PRES=_L_P,))
+
+                # NOUVELLE VERSION
+                else :
+
+                    # Creation des deux listes (x1, y1, x2, y2, ...)
+                    _tmp1=[]
+                    _tmp2=[]
+                    _tmp3=[]
+
+                    for i in range(len(_lst_c)):
+                        # On cree trois listes :
+                        #  _tmp1=temperature en chaque point du maillage,
+                        #  _tmp3=coefficient d echange en chaque point du maillage
+                        #  _tmp2=pression en chaque point du maillage
+                        _tmp1.append( _x0 + _lst_c[i] )
+                        _tmp1.append( _lst_t[i] )
+                        _tmp3.append( _x0 + _lst_c[i] )
+                        _tmp3.append( _lst_cc[i] )
+
+                        _tmp2.append( _x0 + _lst_c[i] )
+                        _tmp2.append( _lst_p[i] )
+
+                    _L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp1,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    _L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp3,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    l_ECHANGE_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+                                                            TEMP_EXT=_L_F1,
+                                                            COEF_H=_L_F2))
+
+                    l_ECHANGE_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+                                                            TEMP_EXT=_L_F1,
+                                                            COEF_H=_L_F2))
+
+                    # Pressions en provenance d'Ecrevisse
+                    _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp2,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
+                                                            PRES=_L_P,))
+
+            #
+            # Fin extraction des conditions limites du calcul Ecrevisse
+            # ----------------------------------------------------------
+
+        # Fin de la boucle sur les fissures
+
+
+
+    # Assemblage des concepts sortants
+    if(oldVersion) :
+        __ECR_F1=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  FLUX_REP=l_FLUX_REP_F1);
+
+        __ECR_F2=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  FLUX_REP=l_FLUX_REP_F2);
+    else:
+        __ECR_F1=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  ECHANGE=l_ECHANGE_F1);
+
+        __ECR_F2=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  ECHANGE=l_ECHANGE_F2);
+
+    __ECR_P=AFFE_CHAR_MECA_F(MODELE=MODELE_MECA,
+                             PRES_REP=l_PRES_REP);
+
+    # Table resultat
+    try:
+       dprod = __TABFISS_tot.dict_CREA_TABLE()
+       __TAB = CREA_TABLE(**dprod)
+       debprod = __DEBFISS_tot.dict_CREA_TABLE()
+       __DEB = CREA_TABLE(**debprod)
+    except:
+       UTMESS('F','ECREVISSE0_9', valr=[Inst_Ecrevisse])

diff --git a/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py b/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py
new file mode 100644 (file)
index 0000000..7fdadf8
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py
@@ -0,0 +1,274 @@
+#@ MODIF calc_essai_ops Macro  DATE 21/10/2008   AUTEUR NISTOR I.NISTOR 
+# -*- 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.        
+# ======================================================================
+
+## \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
+
+
+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,
+                    GROUP_NO_CAPTEURS   = None,
+                    GROUP_NO_EXTERIEUR  = None,
+                    RESU_FLUDELA        = None,
+                    RESU_TURBULENT      = None,
+                    RESU_IDENTIFICATION = None,
+                    RESU_MODIFSTRU      = None,
+                    **args):
+    import aster
+    from Meidee.meidee_cata import MeideeObjects
+    ier = 0
+    
+    prev = aster.onFatalError()
+    aster.onFatalError("EXCEPTION")
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    
+    # gestion des concepts sortants de la macro, declares a priori
+    table = []
+    table_fonction = []
+
+    if not RESU_MODIFSTRU:
+        out_modifstru = {}
+    else:
+        out_modifstru = RESU_MODIFSTRU[0] # max=1 dans le capy
+
+
+    if not RESU_IDENTIFICATION:
+        RESU_IDENTIFICATION = []
+    else:
+        for res in RESU_IDENTIFICATION:
+            table_fonction.append(res['TABLE'])
+    out_identification = {"DeclareOut" : self.DeclareOut,
+                          "TypeTables" : 'TABLE_FONCTION',
+                          "ComptTable" : 0,
+                          "TablesOut"  : table_fonction}
+
+    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.append(res['FONCTION'])
+    out_meideeturb = {"DeclareOut" : self.DeclareOut,
+                      "FoncOut" : table}
+        
+    
+    # Mode interactif : ouverture d'une fenetre Tk
+    if INTERACTIF == "OUI":
+        create_interactive_window(self,
+                                  UNITE_FIMEN,
+                                  UNITE_RESU,
+                                  out_fludela,
+                                  out_meideeturb,
+                                  out_identification,
+                                  out_modifstru)
+    else:
+        from Meidee.meidee_calcul import MessageBox
+        from Meidee.meidee_test import TestMeidee
+        mess = MessageBox(UNITE_RESU)
+        mess.disp_mess("Mode non intéractif")
+        
+        objects = MeideeObjects(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              
+                   )
+
+        mess.close_file()
+    aster.onFatalError(prev)
+    return ier
+
+
+
+def create_tab_mess_widgets(tk, UNITE_RESU):
+    """Construits les objects table et boîte à messages."""
+    try:
+        from Pmw import PanedWidget
+    except ImportError:
+        PanedWidget = None
+    
+    from Meidee.meidee_iface import MessageBoxInteractif, TabbedWindow
+    
+    if PanedWidget:
+        pw = PanedWidget(tk, orient='vertical',
+                         hull_borderwidth = 1,
+                         hull_relief = 'sunken',
+                         )
+        tabsw = pw.add("main", min=.1, max=.9)
+        msgw = pw.add("msg", min=.1, max=.2)
+        pw.grid(sticky='nsew')
+        tabsw.rowconfigure(0, weight=1)
+        tabsw.columnconfigure(0, weight=1)
+        msgw.rowconfigure(0, weight=1)
+        msgw.columnconfigure(0, weight=1)
+    else:
+        tabsw = tk
+        msgw = tk
+        tk.rowconfigure(1, weight=3)
+        tk.rowconfigure(1, weight=1)
+    
+    tabs = TabbedWindow(tabsw, ["Expansion de modeles",
+                                "Modification structurale",
+                                "MEIDEE mono-modal fludela",
+                                "MEIDEE mono-modal turbulent",
+                                "Identification de chargement",
+                                "Parametres de visualisation"])
+
+    tabs.grid(row=0, column=0, sticky='nsew')
+    # pack(side='top',expand=1,fill='both')
+    
+    # ecriture des message dans un fichier message
+    mess = MessageBoxInteractif(msgw, UNITE_RESU)
+    if PanedWidget:
+        mess.grid(row=0, column=0, sticky='nsew')
+        #mess.pack(side='top',expand=1,fill='both')
+    else:
+        mess.grid(row=1, column=0, sticky='nsew')
+        #mess.pack(side='top',expand=1,fill='both')
+    
+    return tabs, mess
+
+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
+    fenêtre Tk.
+    """
+
+    def __init__(self, main_tk, turbulent):
+        self.main_tk = main_tk
+        self.turbulent = turbulent
+
+    def apply(self):
+        """Enlève les fichiers temporaires de Xmgrace"""
+        if self.turbulent.param_visu.logiciel_courbes is not None:
+            self.turbulent.param_visu.logiciel_courbes.fermer()
+        self.main_tk.quit()
+
+
+def create_interactive_window(macro,
+                              UNITE_FIMEN,
+                              UNITE_RESU,
+                              out_fludela,
+                              out_meideeturb,
+                              out_identification,
+                              out_modifstru):
+    """Construit la fenêtre interactive comprenant une table pour 
+    les 4 domaines de Meidee."""
+    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_fludela import InterfaceFludela, InterfaceTurbMonomod
+    from Meidee.meidee_turbulent import InterfaceTurbulent
+    from Meidee.meidee_parametres import InterfaceParametres
+    
+    # fenetre principale
+    tk = Tk()
+    tk.rowconfigure(0, weight=1)
+    tk.columnconfigure(0,weight=1)
+    
+    tabs, mess = create_tab_mess_widgets(tk, UNITE_RESU)
+    main = tabs.root()
+    
+    # importation des concepts aster de la memoire jeveux    
+    objects = MeideeObjects(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)
+    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)
+    turbulent = InterfaceTurbulent(main, objects, mess, out_identification, param_visu)
+    
+    tabs.set_tab("Expansion de modeles", iface.main)
+    tabs.set_tab("Modification structurale", imodifstruct.main)
+    tabs.set_tab("MEIDEE mono-modal fludela", fludelamonomod )
+    tabs.set_tab("MEIDEE mono-modal turbulent", turbmonomod )
+    tabs.set_tab("Identification de chargement", turbulent)
+    tabs.set_tab("Parametres de visualisation", param_visu)
+    
+    #tabs.set_current_tab("Modifstruct")
+    tabs.set_current_tab("Expansion de modeles")
+
+    tk.protocol("WM_DELETE_WINDOW", FermetureCallback(tk, turbulent).apply)
+    
+    try:
+        tk.mainloop()
+    except :
+        print "MEIDEE : *ERREUR*"
+
+    

diff --git a/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py
new file mode 100644 (file)
index 0000000..d1ebb7d
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py
@@ -0,0 +1,2546 @@
+#@ MODIF calc_europlexus_ops Macro  DATE 16/11/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+
+#-----------------------------------------------------------------------   
+#----------------------------- Importation des modules  ----------------
+#-----------------------------------------------------------------------   
+
+# unite associe au fichier ou le pos-traitement CASTE2000 est fait en commandes epx
+# unite_cast2000 = 0 # il ne fait pas le pos-traitement
+# __temp
+unite_cast2000 = 95
+
+debug = False
+dryrun = False
+
+import types,string
+import os
+import Numeric as N
+import math 
+import copy
+
+# Protection pour Eficas
+try:
+   import aster
+   from Accas import _F
+   from Utilitai.partition import MAIL_PY
+   from Utilitai.Utmess import UTMESS
+except:
+  pass
+      
+#----------------------------- Precision ------------------------------- 
+tst = 1.0E-10
+
+#-----------------------------------------------------------------------   
+#----------------------------- Fonctions de calcul vectoriel -----------
+#-----------------------------------------------------------------------   
+
+def norme(u) :
+  return N.sqrt(N.dot(u,u))
+
+def vecteurs_egaux(v1,v2):
+  diff = v1-v2
+  #print 'v1',v1
+  #print 'v2',v2
+  for v in diff:
+    if abs(v) > tst : return False
+  return True  
+
+#-----------------------------------------------------------------------   
+#----------------------------- Operateur de la Macro-commande ----------
+#-----------------------------------------------------------------------   
+
+ 
+def calc_europlexus_ops(self,MODELE,CARA_ELEM,CHAM_MATER,EXCIT,FONC_PARASOL=None,
+                             DIME=None,OBSERVATION=None,ARCHIVAGE=None,COURBE=None,
+                             CALCUL=None,DOMAINES=None,INTERFACES=None,INFO=1,**args):
+        
+#   import aster
+#   from Accas import _F
+
+  ier=0
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  # Le nom de la variable doit etre obligatoirement le nom de la commande
+  
+  global _F,INFO_EXEC_ASTER,DETRUIRE,IMPR_RESU,DEFI_FICHIER,LIRE_RESU,CREA_MAILLAGE
+  global DEFI_GROUP,LIRE_MAILLAGE,CREA_TABLE,IMPR_TABLE,AFFE_MODELE,EXEC_LOGICIEL
+  global LIRE_CHAMP,CREA_CHAMP,CREA_RESU,FORMULE
+  
+  INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER')
+  DETRUIRE        = self.get_cmd('DETRUIRE')
+  IMPR_RESU       = self.get_cmd('IMPR_RESU')
+  DEFI_FICHIER    = self.get_cmd('DEFI_FICHIER')
+  LIRE_RESU       = self.get_cmd('LIRE_RESU')
+  CREA_MAILLAGE   = self.get_cmd('CREA_MAILLAGE')
+  DEFI_GROUP      = self.get_cmd('DEFI_GROUP')
+  LIRE_MAILLAGE   = self.get_cmd('LIRE_MAILLAGE')
+  CREA_TABLE      = self.get_cmd('CREA_TABLE')
+  IMPR_TABLE      = self.get_cmd('IMPR_TABLE')
+  AFFE_MODELE     = self.get_cmd('AFFE_MODELE')
+  EXEC_LOGICIEL   = self.get_cmd('EXEC_LOGICIEL')
+  LIRE_CHAMP      = self.get_cmd('LIRE_CHAMP')
+  CREA_CHAMP      = self.get_cmd('CREA_CHAMP')
+  CREA_RESU       = self.get_cmd('CREA_RESU')
+  FORMULE         = self.get_cmd('FORMULE')
+
+  # Pour la gestion des Exceptions
+  prev_onFatalError = aster.onFatalError()
+  aster.onFatalError('EXCEPTION')
+
+
+  # Pour masquer certaines alarmes
+  from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
+  MasquerAlarme('MED_1')
+  MasquerAlarme('MED_54')
+
+  # Ligne de commande d'Europlexus
+  if args.has_key('LOGICIEL'): EXEC = args['LOGICIEL']
+  else: EXEC = '/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d'
+  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']
+  else :
+     if debug: print 'PAS NBRE COURBE = nook'
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # classs Europlexus permettant de faire le chainage avec le Code_Aster
+  EPX = EUROPLEXUS(MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,
+# AA                   ECRITURE,CALCUL,REPE='REPE_OUT',EXEC=EXEC)
+                   OBSERVATION,ARCHIVAGE,COURBE,CALCUL,DOMAINES,INTERFACES,
+                   REPE='REPE_OUT',EXEC=EXEC, INFO=INFO, args=args)
+
+  # Eriture du fichier de commande Europlexus
+  EPX.ecrire_fichier()
+
+  # Si dryrun alors on ne lance pas le calcul Europlexus
+  if dryrun: return ier
+
+  # Lancement du calcul Europlexus
+  EPX.lancer_calcul()
+
+  # Recuperer le resulat Europlexus a l'aide d'un concept aster de type evol_noli
+  fichier_med = 'auto'
+  fichier_pun = 'auto'
+#  if debug  : 
+#    fichier_med='fort.81'
+#    fichier_pun ='fort.85'
+
+  self.DeclareOut('resu',self.sd) # Le concept sortant (de type evol_noli) est nomme 'resu'   
+  global resu # pour que le nom du concept prenne celui defini par l'utilisateur
+  EPX.get_resu(fichier_med=fichier_med)
+
+  #Recuperer les concepts table
+  if COURBE is not None:
+    global table
+    # icourbe = 0
+    # for fonc in COURBE['TABLE'] :
+      # icourbe += 1
+    self.DeclareOut('table',args['TABLE_COURBE'])
+    EPX.get_table()
+      # EPX.get_table(icourbe=icourbe,fichier=fichier_pun)
+
+
+  # Pour la gestion des Exceptions
+  aster.onFatalError(prev_onFatalError)
+
+  # Pour la gestion des alarmes
+  RetablirAlarme('MED_1')
+  RetablirAlarme('MED_54')
+
+  return ier
+
+#-----------------------------------------------------------------------   
+#----------------------------- class EUROPLEXUS ------------------------
+#-----------------------------------------------------------------------   
+
+class EUROPLEXUS:
+# AA  def __init__(self,MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,ECRITURE,CALCUL,REPE,EXEC,**args):
+  def __init__(self,MODELE,CARA_ELEM,CHAM_MATER,FONC_PARASOL,EXCIT,DIME,OBSERVATION,ARCHIVAGE,COURBE,CALCUL,DOMAINES,INTERFACES,REPE,EXEC,INFO,args):
+
+    if debug: print 'args_key %s'%args.keys()
+    # Mettre toutes les entrees en attributs
+    self.DIME = DIME
+    self.MODELE = MODELE
+    self.CARA_ELEM = CARA_ELEM
+    self.CHAM_MATER = CHAM_MATER
+    self.FONC_PARASOL = FONC_PARASOL
+    self.EXCIT = EXCIT
+#    self.ECRITURE = ECRITURE
+    self.OBSERVATION = OBSERVATION
+    self.ARCHIVAGE = ARCHIVAGE
+    self.COURBE = COURBE
+    self.CALCUL = CALCUL
+    self.DOMAINES = DOMAINES
+    self.INTERFACES = INTERFACES
+    self.INFO = INFO
+
+    # Repertoire de calcul Europlexus 
+    self.REPE   = REPE 
+    # Commande d'execution de Europlexus
+    self.EXEC   = EXEC
+    
+    if args.has_key('UNITE_COURBE'): self.UNITE_COURBE = args['UNITE_COURBE']
+    else:                            self.UNITE_COURBE = None
+    
+    if args.has_key('PAS_INST_COURBE'): self.PAS_INST_COURBE = args['PAS_INST_COURBE']
+    else:                            self.PAS_INST_COURBE = None
+   
+    if args.has_key('PAS_NBRE_COURBE'): self.PAS_NBRE_COURBE = args['PAS_NBRE_COURBE']
+    else:                            self.PAS_NBRE_COURBE = None
+
+    if args.has_key('TABLE_COURBE'): self.TABLE_COURBE = args['TABLE_COURBE']
+    else:                            self.TABLE_COURBE = None
+    # Dictionnaire contenant le texte associé au fichier de commande Europlexus
+    self.epx = {}
+    
+    if debug: print 'pas nbre courbe = %s'%self.PAS_NBRE_COURBE
+    
+    # Concept pour un nouveau maillage si on utilise RIGI_PARASOL ou 
+    # si on regroupe separement les mailles tria3 et quad4
+    self.NEW_MA = None
+    
+    # Nom des fichiers de Europlexus (commande et sorties)
+    self.nom_fichiers = {'COMMANDE' : 'commandes.epx',
+                         'MAILLAGE' : 'maillage_epx',
+                         'ALIT'     : 'champ.alit',
+                         'MED'      : 'champ.e2m',
+                         'PUN'      : 'courbes.pun',
+                        }
+    
+    # Chemin du repertoire courant ou le calcul Aster est lance
+    self.pwd = os.getcwd() + os.sep                     
+    
+
+  
+#-----------------------------------------------------------------------       
+  def get_unite_libre(self,):
+
+    _UL=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
+    unite=_UL['UNITE_LIBRE',1]
+    DETRUIRE(CONCEPT=(_F(NOM=_UL),), INFO=1)
+    return(unite)
+    
+     
+#-----------------------------------------------------------------------   
+  def reupere_structure(self,concept,mot_cle=None):
+
+    try : structure = concept.etape.valeur
+    except : UTMESS('F','PLEXUS_1') 
+
+    if mot_cle : 
+      if structure.has_key(mot_cle) : return structure[mot_cle]
+      else : return None 
+    return structure
+#-----------------------------------------------------------------------   
+  def get_motcle(self,fact,mot_cle,code_mess='F'):
+    try : 
+      out = fact[mot_cle]
+    except : 
+      out = None
+    if not out is None : return out    
+    if not code_mess is None and code_mess: UTMESS(code_mess,'PLEXUS_2',valk=mot_cle)
+    return None
+
+#-----------------------------------------------------------------------   
+  def get_group_ma(self,fact):
+    group_ma = self.get_motcle(fact,'GROUP_MA',code_mess='F')
+    if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,)
+    # elif types.TypeType(group_ma) == types.ListType   : group_ma = tupel(group_ma)  
+    return group_ma
+    
+#-----------------------------------------------------------------------   
+  def get_group_ma_f(self,fact):
+    group_ma = self.get_motcle(fact,'GROUP_MA',None)
+    if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,)
+    # elif types.TypeType(group_ma) == types.ListType   : group_ma = tupel(group_ma) 
+    if not group_ma : group_ma=[]
+    return group_ma
+    
+#-----------------------------------------------------------------------   
+  def setlist(self,fact):
+    #print 'types.TypeType(fact)',types.TypeType(fact)
+    if fact is None : return fact
+    #if not types.TypeType(fact) in [types.ListType,types.TupleType] : fact= [fact]
+    if not (isinstance(fact,types.ListType) or isinstance(fact,types.TupleType))  : fact= [fact]
+    return fact
+    
+#-----------------------------------------------------------------------   
+  def lire_fichier(self,fichier,):
+    fd = open(fichier,'r')
+    lignes = fd.readlines()
+    fd.close()
+    valeurs = []
+    commentaires = ['#','%','$','*']
+    for ll in lignes:
+      add = 1
+      for comment in commentaires : 
+        if string.find(ll,comment) != -1 : add = 0;break
+      if add :   
+         data = [val for val in ll.split(None)]
+         valeurs.append(data)
+    return valeurs
+    
+#-----------------------------------------------------------------------   
+  def fichier2dic(self,fichier):
+    valeurs = self.lire_fichier(fichier)
+    dic = {}
+    mot_cle = None
+    for ll in valeurs:
+      if len(ll) > 1 :    
+        for mot in ll :
+          try : 
+            val = float(mot)
+            if not mot_cle is None : dic[mot_cle].append(val)
+          except : 
+            mot_cle = mot
+            dic[mot_cle] = []
+            
+    return dic
+    
+#-----------------------------------------------------------------------   
+  def lire_pun(self,fichier):
+    if debug: print 'lire_pun : fichier = %s'%fichier
+    data  = self.lire_fichier(fichier)
+    icourbe = 0
+    courbes = {}
+    for ligne in data:
+      if debug: print 'lire_pun : %s'%ligne
+      if ligne[0] in ('VALEURS','VALUES'):
+         icourbe += 1;
+         nb = int(ligne[1])
+         courbes[icourbe] = []
+      else:
+        ligne_vale = [float(val) for val in ligne]
+        courbes[icourbe].append(ligne_vale)
+    for courbe in courbes :
+        courbes[courbe]=N.transpose(N.array(courbes[courbe]))
+    return courbes
+    
+#-----------------------------------------------------------------------   
+  def export_DEBUT(self):
+    
+    epx = self.epx
+    
+    # Cle identifiant 
+    MODULE = 'DEBUT'
+    
+    # Entete de la commande Europlexus courante
+    epx[MODULE] = ['*--FICHIER CREE PAR CALC_EUROPLEXUS/Code_Aster']
+    
+    # Texte declarant le debut
+    epx[MODULE].append('TITRE')
+    epx[MODULE].append('ECHO')
+    options = 'TRID NONL'
+# AA    champ_fact = self.ECRITURE['CHAMP']
+    champ_fact = self.ARCHIVAGE
+    if champ_fact is not None : options += ' MEDE'
+    epx[MODULE].append(options)
+    epx[MODULE].append('\n')
+    
+    # __temp
+    fichier_cast2000 = 'fort.%i' %unite_cast2000
+    if unite_cast2000 and os.path.isfile(fichier_cast2000) :
+      sorite_cast2000 = self.pwd + 'REPE_OUT/post.k2000'
+      epx[MODULE].append('OPNF 12') 
+      epx[MODULE].append(2*' ' + "'%s'" %sorite_cast2000)
+      epx[MODULE].append('\n')
+
+#-----------------------------------------------------------------------   
+  def export_MAILLAGE(self,format='CASTEM'):
+
+    epx = self.epx
+
+    # Cle identifiant 
+    MODULE = 'MAILLAGE'
+
+    # Entete de la commande Europlexus courante
+    epx[MODULE] = ['*--LECTURE MAILLAGE']
+
+    # Recuperer la concept maillage modifie ou initial 
+    if self.NEW_MA is None :
+      concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
+    else :
+      concept_maillage = copy.copy(self.NEW_MA) 
+
+    # Ecrire le maillage, qui peut etre a ete enrichi avec des commandes Aster, sous le format souhaite (MED ou CASTEM)
+    unite = self.get_unite_libre()
+
+    # Extensions des formats de maillage 
+    extension = {'CASTEM' : '.mgib', 'MED':'.med'}
+
+    # donner un nom au fichier de maillage parce que le fort.unite peut etre ecrase par d'autre operation d'ecriture
+    nom_fichier = self.REPE + os.sep + self.nom_fichiers['MAILLAGE'] + extension[format]
+    DEFI_FICHIER(UNITE=unite,FICHIER=nom_fichier,ACTION='ASSOCIER')
+    IMPR_RESU(UNITE=unite,
+              FORMAT=format,
+              RESU = _F(MAILLAGE=concept_maillage)
+             )
+    DEFI_FICHIER(UNITE=unite,ACTION='LIBERER');    
+
+    # Ecriture de la commande Europlexus associee
+    fichier_maillage = self.pwd + nom_fichier
+
+    #epx[MODULE].append('OPNF FORMAT 9')
+    epx[MODULE].append('%s '%format)
+    epx[MODULE].append("'%s' TOUT" %fichier_maillage)    
+    #epx[MODULE].append('CASTEM 9 TOUT')
+
+    epx[MODULE].append('\n')    
+
+#-----------------------------------------------------------------------   
+  def export_DIME(self,):
+    epx = self.epx
+
+    # Cle identifiant 
+    MODULE = 'DIME'
+
+    # Entete de la commande Europlexus courante
+    epx[MODULE] = ['*--DIMENSIONNEMENT']
+    epx[MODULE].append('\n')
+
+    # Test si des parametres de dime seront introuduites à l'aide d'un fichier externe 
+    try    : unite_dime = self.DIME['UNITE_DIME']
+    except : unite_dime = None
+
+    # Recuperer le dictionnaire issu du fichier associe à UNITE_DIME (s'il existe)
+    if unite_dime is not None : 
+      fort = 'fort.%i' %unite_dime
+      dic_fichier = self.fichier2dic(fort)
+    else:
+      dic_fichier = {}
+
+    # mettre a jour les cles definis dans le fichier par celles qui sont 
+    # definies directement sous le mot-cle facteur DIME
+    cles = ['Q4GS', 'FORCE', 'PT6L', 'ZONE', 'POUT', 
+            'ECRO', 'APPU', 'BLOQ', 'PRESS', 'PMAT', 
+            'FTAB', 'DKT3', 'DEPL', 'FNOM', 'TABLE', 
+            'LIAI', 'MTTI', 'PT1L','NEPE']
+
+    for cle in cles:
+      try:
+        if self.DIME[cle] is not None : 
+          dic_fichier[cle] = self.DIME[cle]
+      except : pass  
+
+    # Imprimer les mot-cles et leurs dans epx
+    epx[MODULE].append('DIME')
+    for cle in dic_fichier:
+      vale = dic_fichier[cle]
+      st = 5*' ' + cle
+      for v in vale:
+        st += ' %i' %v
+      epx[MODULE].append(st)  
+    epx[MODULE].append('TERM')    
+
+    epx[MODULE].append('\n')
+         
+#-----------------------------------------------------------------------   
+  def export_MODELE(self):
+    
+    epx = self.epx
+    
+    # Cle identifiant 
+    MODULE = 'MODELE'
+    
+    epx[MODULE] = ['*--DEFINITION DE LA GEOMETRIE']
+    
+    # Entete de la commande Europlexus courante
+    epx[MODULE].append('GEOMETRIE')
+    
+    # Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MODELE 
+    affe_modele = self.reupere_structure(self.MODELE,'AFFE')
+    affe_modele = self.setlist(affe_modele)
+    
+ 
+    # Correspondance de modelisation aster/europlexus
+    dic_modele = {'DKT':'DKT3','DKTG':'Q4GS','POU_D_E':'POUT'}
+    
+    # Correspondance de modelisation europlexus/aster
+    dic_modele_epx = {}
+    for cle in dic_modele.keys():
+      dic_modele_epx[dic_modele[cle]] = cle
+
+    # initialisation du dictioannaire qui contient les group_ma en fonction de la modelisation
+    dic_gma = {}
+    for cle in dic_modele.values():
+      dic_gma[cle] = []
+      
+    for affe in affe_modele:
+      modelisation = affe['MODELISATION']
+      phenomene = affe['PHENOMENE']
+      if  phenomene == 'MECANIQUE' and modelisation in dic_modele.keys():
+        if affe.has_key('GROUP_MA') :
+          group_ma = self.get_group_ma(affe)
+          dic_gma[dic_modele[modelisation]].extend(group_ma)
+        else : 
+          UTMESS('F','PLEXUS_3') 
+    
+    # Regrouper separement les mailles tria3 et quad4 de la modilisation DKT (s'il y a lieu)
+    # parce que leurs modilisations dans europlexus sont differentes:
+    #                                                                tria3 : DKT3
+    #                                                                quad4 : Q4GS
+    
+    # Initialisation du dictionnaire contenant les elements du modele de type TRIA3 et QUAD4
+    nom_groups= {'TRIA3':[],'QUAD4':[]}
+    
+    if len(dic_gma['DKT3']) > 0:
+      concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
+      class_dkt = DKT(MAILLAGE=concept_maillage,)
+      nom_groups = class_dkt.aster2epx(groups=dic_gma['DKT3'])
+      if debug: print 'nom_groups = %s'%nom_groups
+      # mettre a jour les groups de chaque modelisation
+      dic_gma['DKT3'] = nom_groups['TRIA3']
+      dic_gma['Q4GS'].extend(nom_groups['QUAD4'])
+      
+    
+    # liste comportant les modelisations definis dans le module GEOMETRIE
+    # cette liste va servir à determiner les indices des champs stockes dans le fichier med (get_resu)
+    self.modelisations = []
+    # Ecriture sous format europlexus
+    for modelisation in  dic_gma.keys() :
+      len_groups = len(dic_gma[modelisation])
+      if len_groups > 0 :
+        self.modelisations.append(modelisation)
+        epx[MODULE].append(5*' ' + modelisation + 2*' ' + dic_gma[modelisation][0])
+        if len_groups > 1 :
+          for ig in range(1,len_groups) :
+            group_ma = dic_gma[modelisation][ig]
+            epx[MODULE].append((len(modelisation)+5+2)*' ' + group_ma)
+
+                
+    
+    # Mettre a jour le modele dans le cas ou le maillage a ete modifie pour la seperation de TRIA3 et QUAD4
+    # ce modele va etre utilise dans la lecture du fichier med (get_resu)
+    if len(nom_groups['QUAD4']) == 0 :
+      self.NEW_MODELE = copy.copy(self.MODELE)
+    else :
+      affe_model = []
+      for modelisation in self.modelisations :
+         affe_model.append({'GROUP_MA':dic_gma[modelisation],
+                           'MODELISATION': dic_modele_epx[modelisation],
+                           'PHENOMENE':'MECANIQUE' })
+        
+      __MO = AFFE_MODELE(MAILLAGE = concept_maillage,
+                          AFFE = affe_model,
+                          );
+        
+      self.NEW_MODELE = copy.copy(__MO);
+    
+    # Utiliser dans Ecriture des elements et points du fichier med    
+    self.dic_gma = dic_gma
+    # Il y a une suite dans RIGI_PARSOL
+    
+    #epx[MODULE].append('TERM')
+    #epx[MODULE].append('\n') 
+    
+    
+ #-----------------------------------------------------------------------   
+  def export_CARA_ELEM(self):
+    
+    epx = self.epx
+    
+    # Cle identifiant 
+    MODULE = 'CARA_ELEM'
+
+    # Recuperer la structure du concept sorti de AFFE_CARA_ELEM
+    cara_elem_struc = self.reupere_structure(self.CARA_ELEM)
+
+    epx[MODULE] = ['*--CARACTERISTIQUES DES ELEMENTS DE STRUCTURE']
+
+    # Entete de la commande Europlexus courante
+    epx[MODULE].append('COMPLEMENT')
+
+    # Dictionnaire conteant les donnees associees aux differents elements de structure
+    dic_elem = {}
+    for cle in ['DISCRET','COQUE','POUTRE','RIGI_PARASOL']:
+      if cara_elem_struc.has_key(cle):
+        fact = cara_elem_struc[cle]
+        if fact :
+          dic_elem[cle] = self.setlist(fact)
+     
+    # traduire les masses concentrees si elles existent
+    cle = 'DISCRET'
+    self.discretParasol = {}
+    if dic_elem.has_key(cle):
+      epx[MODULE].append('\n') 
+      epx[MODULE].append('*--MASSES AJOUTEES')
+      for elem in dic_elem[cle]:
+        if elem['CARA'] == 'M_T_D_N' :
+          group_ma = self.get_group_ma(elem)
+          vale = elem['VALE']
+          epx[MODULE].append('MASSE  123456 %s' %vale)
+          epx[MODULE].append(7*' ' + 'LECT')
+          for group in group_ma:
+            epx[MODULE].append(11*' '+group)
+          epx[MODULE].append(7*' ' + 'TERM')
+        if elem['CARA'] == 'K_TR_D_N' :
+          group_ma = self.get_group_ma(elem)
+          vale     = elem['VALE']
+          for gma in group_ma :
+            self.discretParasol[gma] = vale
+           
+    # traduire les elements coques s'ils existent
+    cle = 'COQUE'
+    self.dicOrthotropie={}
+    self.listEpais=[]
+    self.listEpais2=[]
+    if dic_elem.has_key(cle):
+      epx[MODULE].append('\n') 
+      epx[MODULE].append('*--ELEMENTS COQUES')
+      for elem in dic_elem[cle]:
+#        print elem     
+        group_ma = self.get_group_ma(elem)
+        epais = elem['EPAIS']
+        if self.ARCHIVAGE['CONT_GENER'] == 'OUI' :
+            self.listEpais.append({'VALE' : epais, 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X21'})
+            self.listEpais2.append({'VALE' : epais**2/6., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X22'})
+        else :
+            self.listEpais.append({'VALE' : 1., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X21'})
+            self.listEpais2.append({'VALE' : 1., 'GROUP_MA' : group_ma, 'NOM_CMP' : 'X22'})
+        st = 'EPAIS  %s  ' %epais
+        #ajouter les group_ma qui ont ete affecte par ces caracteristiques
+        epx[MODULE].append(st+'LECT')
+        for group in group_ma:
+          epx[MODULE].append((len(st)+4)*' '+group)
+        epx[MODULE].append((len(st))*' '+'TERM')
+        if elem.has_key('VECTEUR'):
+# AA       if elem['VECTEUR'] :
+            for group in group_ma :
+                self.dicOrthotropie[group] = elem['VECTEUR']
+         
+    # traduire les elements poutres s'ils existent
+    cle = 'POUTRE'
+    if dic_elem.has_key(cle):
+      concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
+      #class permettant de calculer et verifier les vecteurs de poutre dans Europlexus
+      class_poutre = POUTRE(MAILLAGE=concept_maillage,CARA_ELEM=self.CARA_ELEM)
+      epx[MODULE].append('\n') 
+      epx[MODULE].append('*--ELEMENTS POUTRES')
+      for elem in dic_elem[cle]:       
+        group_ma = self.get_group_ma(elem)
+        vecteurs = class_poutre.getvecteurs(group_ma,verif='non')
+        vect_y = vecteurs[group_ma[0]]
+        type_section = elem['SECTION']
+        st = 'GEOP %s ' %type_section
+        if type_section == 'RECTANGLE' :
+          # Correspondance de caracteristique de poutre aster/europlexus
+          dic_corresp = {'HY':'AY','HZ':'AZ'}
+          epx[MODULE].append(st)
+          # ajouter le vecteur definisant l'orientation de la section
+          epx[MODULE].append(len(st)*' ' + 'VX %s' %vect_y[0])
+          epx[MODULE].append(len(st)*' ' + 'VY %s' %vect_y[1])
+          epx[MODULE].append(len(st)*' ' + 'VZ %s' %vect_y[2])
+          # ajouter les caracteristiques de la poutre
+          cara = elem['CARA']
+          vale = elem['VALE']
+          for icar in range(len(cara)):
+            car = cara[icar]
+            val = vale[icar]
+            car_epx = dic_corresp[car]
+            epx[MODULE].append(len(st)*' ' + '%s %s' %(car_epx,val))
+          # ajouter les group_ma qui ont ete affecte par ces caracteristiques
+          epx[MODULE].append(5*' '+'LECT')
+          for group in group_ma:
+            epx[MODULE].append(len(st)*' '+group)
+          epx[MODULE].append(5*' '+'TERM')     
+        else : 
+          UTMESS('A','PLEXUS_4',valk=type_section) 
+      
+    epx[MODULE].append('\n') 
+
+#-----------------------------------------------------------------------   
+  def export_RIGI_PARASOL(self):
+
+    epx = self.epx
+    
+    # Cle identifiant 
+    MODULE = 'RIGI_PARASOL'
+    concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
+    self.MApyt = MAIL_PY()
+    self.MApyt.FromAster(concept_maillage)
+
+    # Recuperer la structure du concept sorti de AFFE_CARA_ELEM
+    cara_elem_struc = self.reupere_structure(self.CARA_ELEM)
+    
+    # Recuperer la structure RIGI_PARASOL si elles existe
+    list_rigi_parasol = None
+    if cara_elem_struc.has_key('RIGI_PARASOL'):
+      fact = cara_elem_struc['RIGI_PARASOL']
+      if fact :list_rigi_parasol = self.setlist(fact)
+   
+    # Traduction des fonctions definies dans FONC_PARASOL    
+    #dic_fonc_parasol = self.get_FONC_PARASOL(list_rigi_parasol)
+    dic_fonc_parasol = self.get_FONC_PARASOL()
+#    if not dic_fonc_parasol: return
+
+    epx[MODULE] = ['*--SUPPORT ELASTIQUE']
+   
+    # si l'utilisateur a lui meme fourni des GROUP_MA de discrets : on commence par la
+    gmaParasol=self.get_group_ma_f(self.FONC_PARASOL)
+    group_union = ''
+    for gma in gmaParasol :
+        if gma not in self.discretParasol :
+            if debug: print gma
+            if debug: print self.discretParasol.keys()
+            raise 'Discret non defini'
+        vale = self.discretParasol[gma]
+        epx[MODULE].append('SUPPORT')
+        epx[MODULE].append(6*' '+'KX %s  KY %s  KZ %s'%(vale[0],vale[1],vale[2]))
+        epx[MODULE].append(6*' '+'KRX %s KRY %s KRZ %s'%(vale[3],vale[4],vale[5]))       
+        for cle_fonc_parasol in dic_fonc_parasol.keys() :
+          epx[MODULE].append(6*' ' + '%s %i' %(cle_fonc_parasol,dic_fonc_parasol[cle_fonc_parasol]) )
+        epx[MODULE].append(6*' '+'LECT %s TERM'% gma)
+        group_union += '%s '% gma
+    if len(gmaParasol) > 0 :
+        epx['MODELE'].append(5*' ' + 'APPU  ' + group_union)
+
+    # concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
+    # DEFI_GROUP(reuse         = concept_maillage,
+                 # MAILLAGE      = concept_maillage,
+                 # CREA_GROUP_NO = _F(GROUP_MA = gmaParasol),
+                # );
+        
+   
+   
+    # traduire les rigi_parasol
+# AA    if list_rigi_parasol :   
+    if list_rigi_parasol and dic_fonc_parasol:   
+      # changement de module parce que les supports issus de RIGI_PARASOL  doivent etre imprimes apres les materiaux
+      # fichiers_parasol = []
+      # cles_oblig = ['UNITE_EUROPLEXUS','GROUP_MA_POI1']
+      # for elem in list_rigi_parasol:
+        # elem_cara = elem['CARA']
+        # if elem_cara == 'K_TR_D_N':
+          # for cle_test in cles_oblig:
+            # if not elem.has_key(cle_test):
+              # pass
+          # unite = elem['UNITE_EUROPLEXUS']
+          # fichier = 'fort.%i' %unite
+          # if fichier not in fichiers_parasol : fichiers_parasol.append(fichier)
+        # else :
+        #   pass
+      # Lecture des valeurs de rigidites generees par aster a partir des rigidites globales definis dans PARA_RIGISOL
+      # ressorts = []        
+      # for fichier in fichiers_parasol :
+        # ressorts.extend(self.lire_fichier(fichier))
+      ressorts = self.CARA_ELEM.toEPX()
+      # Creer un maillage qui, pour chaque noeud de l'interface utilisee dans rigi_parsol, asscocie un group_ma asscie
+      # parce que on n'a pas les memes numeros des noeuds dans Europlexus
+      crea_poi1 = []
+      dic_gma = {}
+      igr = -1
+      # Liste des group_ma associes au noeuds ou le RIGI_PARSOL a ete applique 
+      groups_parasol = []
+      
+      for noeud in ressorts.keys() :
+        # noeud = ressor[0]
+        if not dic_gma.has_key(noeud):
+          igr += 1
+          group_ma = 'SUP%i' %igr
+          dic_gma[noeud] = group_ma
+          groups_parasol.append(group_ma)
+          crea_poi1.append(_F(NOEUD=noeud,NOM_GROUP_MA=group_ma)) 
+      
+      # ATTENTION : a deplacer
+      # crea_maillage a faire de facon centraliser pour RIGI_PARASOL et le POST-TRAITEMENT ailleurs
+      courbe_fact = self.COURBE
+      if courbe_fact is None: courbe_fact = []
+      lnoeuds=set()
+      lmailles=set()
+      dicma=[]
+      for courbe in courbe_fact :
+        if courbe['GROUP_NO'] != None :
+            noeuds = courbe['GROUP_NO']
+            if type(noeuds) == tuple :
+                for el in noeuds :
+                    lnoeuds.add(el)
+            else :
+                lnoeuds.add(noeuds)
+        if courbe['GROUP_MA'] != None :
+            mailles = courbe['GROUP_MA']
+            if type(mailles) == tuple :
+                for el in mailles :
+                    lmailles.add(el)
+            else :
+                lmailles.add(mailles)
+      for maille in lmailles :
+        dicma.append({'NOM' : maille, 'MAILLE' : maille})
+
+      for no in lnoeuds :
+        if not self.MApyt.gno.has_key(no) :
+            crea_poi1.append(_F(NOEUD=no,NOM_GROUP_MA=no)) 
+      
+      __NEW = CREA_MAILLAGE(MAILLAGE=concept_maillage,
+                             CREA_POI1 = crea_poi1,
+                            );
+      self.NEW_MA = copy.copy(__NEW)
+ 
+      # Ecriture sous format europlexus
+      # Indices des composantes
+      indices_comps = {'KX':1,'KY':2,'KZ':3,'KRX':4,'KRY':5,'KRZ':6}
+      for noeud in ressorts :
+        valeurs = ressorts[noeud]
+        epx[MODULE].append('SUPPORT')
+        # ecriture des composantes et de leurs valeurs associees
+        for comp in indices_comps.keys():
+          if debug: print len(valeurs),indices_comps[comp]-1          
+          vale = valeurs[indices_comps[comp]-1]
+          epx[MODULE].append(3*' ' + '%s %s' %(comp,vale))
+        # caracteristiques des translations et des rotations  
+        for cle_fonc_parasol in dic_fonc_parasol.keys() :
+          epx[MODULE].append(3*' ' + '%s %i' %(cle_fonc_parasol,dic_fonc_parasol[cle_fonc_parasol]) )
+        
+        # ecriture du group_ma associe
+        # noeud = ressor[0]
+        group_ma = dic_gma[noeud]
+        epx[MODULE].append(3*' ' + 'LECT %s TERM' % group_ma) 
+    
+      epx[MODULE].append('\n')
+      
+      group_union = 'PARASOL'
+      dicma.append({'NOM' : group_union, 'UNION' : groups_parasol})
+      __NEW = DEFI_GROUP(reuse = __NEW, 
+                MAILLAGE = __NEW,
+                CREA_GROUP_MA = dicma
+                )     
+      
+      # Mettre a jour le module modele qd les ressorts existent
+      epx['MODELE'].append(5*' ' + 'APPU  ' + group_union)
+
+    # Fermer le module modele dans tous les cas 
+    self.multidomaine = 0
+    listInterfaces = self.INTERFACES
+    self.gmaInterfaces=[]
+    if listInterfaces :
+        i=0
+        self.multidomaine = 1
+        for interface in listInterfaces :
+            Lgma1 = self.setlist(interface['GROUP_MA_1'])
+            Lgma2 = self.setlist(interface['GROUP_MA_2'])
+            self.gmaInterfaces.extend(Lgma1)
+            self.gmaInterfaces.extend(Lgma2)
+            for gma in Lgma1 :
+                if i==0 :
+                    epx['MODELE'].append(5*' ' + 'CL3L' + 2*' ' + gma)
+                else :
+                    epx['MODELE'].append(11*' ' + gma)
+            for gma in Lgma2 :
+                    epx['MODELE'].append(11*' ' + gma)
+            i+=1
+    epx['MODELE'].append('TERM')
+    epx['MODELE'].append('\n')
+
+    if self.gmaInterfaces :
+        epx['CHAM_MATER'].append('FANTOME 0. LECT')
+        for gma in self.gmaInterfaces :
+            epx['CHAM_MATER'].append(15*' '+'%s'% gma)
+        epx['CHAM_MATER'].append('           TERM')
+    epx['CHAM_MATER'].append('\n')   
+    
+    
+    # DEFINITION REPERES ORTHOTROPIE QUI DOIT ETRE APRES LES SUPPORTS
+    for gma in self.gmaGLRC :
+        if gma not in self.dicOrthotropie :
+            raise "Erreur : %s non affecte par un repere d'orthotropie : ajouter le mot-cle 'VECTEUR' dans AFFE_CARA_ELEM"% gma
+        vale = self.dicOrthotropie[gma]
+        epx[MODULE].append('COMP ORTS %s %s %s'%(vale[0],vale[1],vale[2]))
+        epx[MODULE].append(3*' '+'LECT')
+        epx[MODULE].append(7*' '+'%s'% gma)
+        epx[MODULE].append(3*' '+'TERM')
+ 
+    epx[MODULE].append('\n') 
+ 
+#-----------------------------------------------------------------------   
+  def get_FONC_PARASOL(self,list_rigi_parasol=None) :
+    
+    epx = self.epx
+    
+    MODULE = 'FONC_PARASOL'
+    if list_rigi_parasol is not None :
+      if self.FONC_PARASOL is None : UTMESS('F','PLEXUS_12')
+    # else : return None
+    
+    epx[MODULE] = ['*--DEFINITIONS DES FONCTIONS']
+    
+    # Entete de la commande europlexus
+    epx[MODULE].append('FONC')
+    
+    # Cles de FONC_PARASOL dans l'ordre
+    cles = ['NFKT','NFKR']
+    # Dictionnaire faisant la correspondance entre la fonction et son numero europlexus
+    dic_fonc = {}
+    try : 
+        ifonc = self.ifonc
+        if debug: print 'self.ifonc = %s'%ifonc
+    except : 
+        self.ifonc=0
+        ifonc = self.ifonc     
+        if debug: print 'ifonc = %s'%ifonc
+    if epx.has_key('FONC_MATER') :
+        epx[MODULE].extend(epx['FONC_MATER'])
+    for cle in cles:
+      ifonc += 1
+      dic_fonc[cle] = ifonc
+      fonction = self.get_motcle(self.FONC_PARASOL,cle,code_mess=None)
+      if not fonction: return {}    # Si les mots-cles sont manquants on passe
+      (temps,valeurs) = fonction.Valeurs()
+      # imprimer les valeurs de la table
+      epx[MODULE].append(5*' ' +'NOPA %i TABLE %i' %(ifonc,len(temps)) )
+      for ival in range(len(temps)):
+#         epx[MODULE].append(17*' ' +'%s %s' %(temps[ival],valeurs[ival]))   
+         epx[MODULE].append(17*' ' +'%s %s' %(temps[ival],valeurs[ival]))   
+    self.ifonc = ifonc
+    self.dic_fonc = dic_fonc
+    epx[MODULE].append('\n')
+    return dic_fonc
+
+#-----------------------------------------------------------------------   
+  def export_CHAM_MATER(self): 
+
+    epx = self.epx
+
+    # CLe identifiant
+    MODULE = 'CHAM_MATER'
+
+    epx[MODULE] = ['*--DEFINITION DES MATERIAUX']
+
+    # Entete de la commande Europlexus courante
+    epx[MODULE].append('MATERIAUX')
+
+    # Recuperer la structure sous le mot_cle facteur AFFE de AFFE_MATER 
+    affe_mater = self.reupere_structure(self.CHAM_MATER,'AFFE')
+    affe_mater = self.setlist(affe_mater)
+
+    # Dictionnaire stoquant les caracteristiques mecaniques et les group_ma associe a chaque materiau
+    dic_mater = {}
+    typMat = {}
+    # GLRC impose de définir l'orientation : on stocke dans gmaGLRC les GMA dont il faudra retrouver l'orientation dans MODI_MAILLAGE/ORIE_NORM_COQUE
+    self.gmaGLRC = []
+    epx['FONC_MATER'] = []
+    ref_fonc=[]
+    for affe in affe_mater :
+      # Recuperer le concept du materiau defini par DEFI_MATERIAU
+      concept_mater = affe['MATER']
+      # Recuperer le nom du materiau
+      nom_mater = concept_mater.get_name()
+      # Recuperer le group_ma concerne
+      group_ma = self.get_group_ma(affe)
+      if debug: print 'type(group_ma) = %s'%type(group_ma)
+      if not dic_mater.has_key(nom_mater):
+         dic_mater[nom_mater] = {'GROUP_MA':[]}
+         # Recuperer les caracteristiques elastiques du materiau
+         elas = self.reupere_structure(concept_mater,'ELAS')
+         if elas :
+            typMat[nom_mater] = 'ELAS'
+            for car in ['E','RHO','NU']:
+              dic_mater[nom_mater][car] = elas[car]
+            for car in ['AMOR_ALPHA','AMOR_BETA'] :
+              if elas.has_key(car) :
+                dic_mater[nom_mater][car] = elas[car]
+              else :
+                dic_mater[nom_mater][car] = None                 
+         beton = self.reupere_structure(concept_mater,'BETON')
+         if beton  :
+            typMat[nom_mater] = 'GLRC'
+            self.gmaGLRC.extend(group_ma)
+            dic_mater[nom_mater]['LINER']=[]
+            dic_mater[nom_mater]['NAPPE']=[]
+            materBeton = beton['MATER']
+            elasBeton = self.reupere_structure(materBeton,'ELAS')
+            dic_mater[nom_mater]['BETON']={}
+            for car in ['E','RHO','NU']:
+              dic_mater[nom_mater]['BETON'][car] = self.get_motcle(elasBeton,car)
+            for car in ['AMOR_ALPHA','AMOR_BETA']:
+              dic_mater[nom_mater]['BETON'][car] = self.get_motcle(elasBeton,car,None)
+            ecroBeton = self.reupere_structure(materBeton,'BETON_ECRO_LINE')
+            for car in ['SYT','SYC']:
+              dic_mater[nom_mater]['BETON'][car] = self.get_motcle(ecroBeton,car,None)
+            for car in ['EPAIS','GAMMA','QP1','QP2','C1N1','C1N2','C1N3','C2N1','C2N2','C2N3','C1M1','C1M2','C1M3','C2M1','C2M2','C2M3'] :
+              dic_mater[nom_mater]['BETON'][car] = self.get_motcle(beton,car)
+            for car in ['OMT','EAT','BT1','BT2'] :
+              dic_mater[nom_mater]['BETON'][car] = self.get_motcle(beton,car,None)
+            for car in ['MP1X','MP1Y','MP2X','MP2Y'] :
+              car_temp = self.get_motcle(beton,car,None)
+              if debug: print 'type(car_temp) = %s'%type(car_temp)
+              dic_mater[nom_mater]['BETON'][car] = None
+              if car_temp :
+                  if type(car_temp) == float :
+                    dic_mater[nom_mater]['BETON'][car] = car_temp
+                  else :
+                    if debug: print dir(car_temp)
+                    try : 
+                        ifonc = self.ifonc
+                    except : 
+                        self.ifonc=0
+                        ifonc = self.ifonc     
+                    ifonc += 1
+                    val = car_temp.Valeurs()
+                    x = val[:len(val):2]
+                    y = val[1:len(val):2]
+                    # imprimer les valeurs de la table
+                    epx['FONC_MATER'].append(5*' ' +'%i LSQU 2 TABLE %i' %(ifonc,len(x)) )
+                    for ival in range(len(x)):
+#                       epx['FONC_MATER'].append(17*' ' +'%s %s' %(x[ival],y[ival]))   
+                       epx['FONC_MATER'].append(17*' ' +'%s %s' %(x[ival],y[ival]))   
+                    dic_mater[nom_mater]['BETON'][car] = 'FONC %i'%ifonc
+                    self.ifonc=ifonc
+
+
+         cable = self.reupere_structure(concept_mater,'CABLE_PREC')
+         if cable  :
+            materCable = cable['MATER']
+            elasCable = self.reupere_structure(materCable,'ELAS')
+            ecroCable = self.reupere_structure(materCable,'ECRO_LINE')
+            dic_mater[nom_mater]['CABLE']={}
+            for car in ['E','NU']:
+              dic_mater[nom_mater]['CABLE'][car] = elasCable[car]           
+            for car in ['SY']:
+              dic_mater[nom_mater]['CABLE'][car] = ecroCable[car]
+            for car in ['OMX','OMY','RX','RY','PREX','PREY'] :
+              dic_mater[nom_mater]['CABLE'][car] = cable[car]
+         Lnappes = self.setlist(self.reupere_structure(concept_mater,'NAPPE'))
+         if Lnappes  :
+            for nappe in Lnappes :
+                dic_tmp = {}
+                materNappe = nappe['MATER']
+                elasNappe = self.reupere_structure(materNappe,'ELAS')
+                ecroNappe = self.reupere_structure(materNappe,'ECRO_LINE')
+                for car in ['E','NU']:
+                  dic_tmp[car] = elasNappe[car]           
+                for car in ['SY']:
+                  if ecroNappe :
+                    dic_tmp[car] = ecroNappe[car]
+                  else :
+                    dic_tmp[car] = None
+                for car in ['OMX','OMY','RX','RY'] :
+                  dic_tmp[car] = nappe[car]
+                for car in ['FS',] :
+                  if nappe.has_key(car) :
+                    dic_tmp[car] = nappe[car]
+                  else :
+                    dic_tmp[car] = None
+                dic_mater[nom_mater]['NAPPE'].append(dic_tmp)
+         Lliners = self.setlist(self.reupere_structure(concept_mater,'LINER'))
+         if Lliners :
+            for liner in Lliners :
+                dic_tmp = {}
+                materLiner = liner['MATER']
+                elasLiner = self.reupere_structure(materLiner,'ELAS')
+                ecroLiner = self.reupere_structure(materLiner,'ECRO_LINE')
+                for car in ['E','NU']:
+                  dic_tmp[car] = elasLiner[car]           
+                for car in ['SY']:
+                  dic_tmp[car] = ecroLiner[car]
+                for car in ['OML','RLR'] :
+                  dic_tmp[car] = liner[car]
+                dic_mater[nom_mater]['LINER'].append(dic_tmp)
+                
+
+      if debug: print 'MATER = %s \n type = %s \n dic = %s'%(nom_mater,typMat, dic_mater[nom_mater])
+      dic_mater[nom_mater]['GROUP_MA'].extend(group_ma)
+      
+      # if gmaGLRC :
+          # concept_maillage = self.reupere_structure(self.MODELE,'MAILLAGE')
+          # if debug: print 'ETAPES MAILLAGES'
+          # if debug: print dir(concept_maillage)
+          # if debug: print concept_maillage.executed
+          # if debug: print concept_maillage.etape
+          # if debug: print dir(concept_maillage.etape)
+          # if debug: print concept_maillage.etape.get_liste_etapes()
+          # if debug: print concept_maillage.etape.valeur
+        
+      
+    # Impression au format Europlexus
+    
+    for nom_mater in dic_mater.keys():
+      epx[MODULE].append('*--MATERIAU %s' %nom_mater)
+      # mot cle indicant qu'il s'agit des caracteristiques lineaires du materiau
+      if typMat[nom_mater] == 'ELAS' :
+          dic_corresp = {'E':'YOUNG','NU':'NU','RHO':'RO'}
+          dic_corresp2 ={'AMOR_ALPHA':'KRAY','AMOR_BETA':'MRAY'}
+          epx[MODULE].append('LINE')
+          for car_aster in dic_corresp.keys():
+            vale    = dic_mater[nom_mater][car_aster]
+            car_epx = dic_corresp[car_aster]
+            if vale is not None :
+              epx[MODULE].append('%s %s' %(car_epx,vale))
+          for car_aster in dic_corresp2.keys():
+            vale    = dic_mater[nom_mater][car_aster]
+            car_epx = dic_corresp2[car_aster]
+            if vale is not None :
+              epx[MODULE].append('%s %s' %(car_epx,vale))
+      else : #GLRC
+        dic_corres1 = {'RHO':'RO','EPAIS':'H','E':'EB','NU':'NUB'}
+        dic_corresNapp = {'E' : 'EA','SY':'FY','OMX':'OMX','OMY':'OMY','RX':'RX','RY':'RY','FS':'FS'}
+        dic_corresPrec = {'E' : 'EA','SY':'FY','OMX':'OMX','OMY':'OMY','RX':'RX','RY':'RY'}
+        dic_corresLinr = {'E' : 'EA','SY':'FY','OML':'OMLR','NU':'NULR','RLR':'RLR'}
+        dic_corres2 = {'OMT' : 'OMT','EAT':'EAT','BT1':'BT1','BT2':'BT2','SYT' : 'FT','GAMMA':'GAMM','QP1':'QP1','QP2':'QP2','C1N1':'C1N1','C1N2':'C1N2','C1N3':'C1N3','C2N1':'C2N1','C2N2':'C2N2','C2N3':'C2N3','C1M1':'C1M1','C1M2':'C1M2','C1M3':'C1M3','C2M1':'C2M1','C2M2':'C2M2','C2M3':'C2M3','SYC':'FC'}
+        dic_corres2b = {'MP1X':'MP1X','MP2X':'MP2X','MP1Y':'MP1Y','MP2Y':'MP2Y',}
+        dic_corres3 = {'PREX' : 'PREX', 'PREY' : 'PREY'}
+        dic_corres4 = {'AMOR_ALPHA':'KRAY','AMOR_BETA':'MRAY'}
+        epx[MODULE].append('GLRC DAMA')
+        for car_aster in dic_corres1.keys():
+            vale    = dic_mater[nom_mater]['BETON'][car_aster]
+            car_epx = dic_corres1[car_aster]
+            if vale is not None :
+                epx[MODULE].append('%s %s' %(car_epx,vale))
+        nlit = len(dic_mater[nom_mater]['NAPPE'])+len(dic_mater[nom_mater]['LINER'])
+        if dic_mater[nom_mater].has_key('CABLE') : 
+            nlit+=1
+        if nlit :
+            epx[MODULE].append('%s %s' %('NLIT',nlit))
+        for nappe in dic_mater[nom_mater]['NAPPE'] :
+            epx[MODULE].append('NAPP')
+            for car_aster in dic_corresNapp.keys():
+                if nappe.has_key(car_aster) :
+                    vale    = nappe[car_aster]
+                    car_epx = dic_corresNapp[car_aster]
+                    if vale is not None:
+                        epx[MODULE].append('%s %s' %(car_epx,vale))
+        if dic_mater[nom_mater].has_key('CABLE') : 
+            epx[MODULE].append('PREC')
+            for car_aster in dic_corresPrec.keys():
+                vale    = dic_mater[nom_mater]['CABLE'][car_aster]
+                car_epx = dic_corresPrec[car_aster]
+                if vale is not None :
+                    epx[MODULE].append('%s %s' %(car_epx,vale))
+        for liner in dic_mater[nom_mater]['LINER'] :
+            epx[MODULE].append('LINR')
+            for car_aster in dic_corresLinr.keys():
+                vale    = liner[car_aster]
+                car_epx = dic_corresLinr[car_aster]
+                if vale is not None :
+                    epx[MODULE].append('%s %s' %(car_epx,vale))
+        for car_aster in dic_corres2.keys():
+            vale    = dic_mater[nom_mater]['BETON'][car_aster]
+            car_epx = dic_corres2[car_aster]
+            if vale is not None :
+                if type(vale) == float :
+                    epx[MODULE].append('%s %s' %(car_epx,vale))
+                else :
+                    epx[MODULE].append('%s %s' %(car_epx,vale))
+        for car_aster in dic_corres2b.keys():
+            vale    = dic_mater[nom_mater]['BETON'][car_aster]
+            car_epx = dic_corres2b[car_aster]
+            if vale is not None :
+                if type(vale) == float :
+                    epx[MODULE].append('%s %s' %(car_epx,vale))
+                else :
+                    epx[MODULE].append('%s %s' %(car_epx,vale))
+        if dic_mater[nom_mater].has_key('CABLE') : 
+            for car_aster in dic_corres3.keys():
+                vale    = dic_mater[nom_mater]['CABLE'][car_aster]
+                car_epx = dic_corres3[car_aster]
+                if vale is not None :
+                    epx[MODULE].append('%s %s' %(car_epx,vale))
+        for car_aster in dic_corres4.keys():
+            vale    = dic_mater[nom_mater]['BETON'][car_aster]
+            car_epx = dic_corres4[car_aster]
+            if vale is not None :
+                epx[MODULE].append('%s %s' %(car_epx,vale))
+      
+          # ajouter les group_ma qui ont ete affecte par ces caracteristiques
+      epx[MODULE].append(3*' '+'LECT')
+      for group in dic_mater[nom_mater]['GROUP_MA']:
+        epx[MODULE].append(7*' '+group)
+      epx[MODULE].append(3*' '+'TERM')
+
+    
+    return epx
+    
+#-----------------------------------------------------------------------   
+  def export_EXCIT(self):
+  
+    epx = self.epx
+    
+    # CLe identifiant
+    MODULE = 'EXCIT'
+    
+    epx[MODULE] = ['*--DEFINITION DES CHARGEMENTS et DES CONDITIONS AUX LIMITES']
+    
+    # Entete de la commande Europlexus courante
+    #epx[MODULE].append('CHARGEMENT')
+
+    try : 
+      test = self.EXCIT[0]
+      excit_list = self.EXCIT
+    except :  
+      excit_list = self.setlist(self.EXCIT)
+    
+    #print '<INFO> excit_list = ',excit_list
+    #print '<INFO> type(excit_list) = ', type(excit_list)
+    
+    # Traduction de ddl_impo
+    dic_ddl_impo = {'DX':1,'DY':2,'DZ':3,'DRZ':4,'DRY':5,'DRZ':6}
+
+    # Initialisation des variables decrivant le chargement et les conditions de blocage
+    CHARGEMENT = []
+    LIAISON   = []
+    
+    for excit in excit_list:
+      concept_charge = excit['CHARGE']
+      pres_rep_list = self.reupere_structure(concept_charge,'PRES_REP')
+      ddl_impo_list = self.reupere_structure(concept_charge,'DDL_IMPO')
+      pres_rep_list = self.setlist(pres_rep_list)
+      ddl_impo_list = self.setlist(ddl_impo_list)
+      # PRES_REP
+      if pres_rep_list :
+        if len(CHARGEMENT) == 0 : 
+          CHARGEMENT = ['CHARGEMENT']
+          CHARGEMENT.append(2*' ' + '1 FACTO 2')
+        fonction = self.get_motcle(excit,'FONC_MULT',code_mess='A')
+        if fonction is None:
+          UTMESS('F','PLEXUS_7')
+        (temps,valeurs) = fonction.Valeurs()
+        for pres_rep in  pres_rep_list :
+          pression = pres_rep['PRES']
+          group_ma = self.get_group_ma(pres_rep)
+          CHARGEMENT.append(6*' ' +'PRESS COQU %s' %pression)
+          # ajouter les group_ma qui ont ete affecte par ces caracteristiques
+          CHARGEMENT.append(6*' '+'LECT')
+          for group in group_ma:
+            CHARGEMENT.append(10*' '+group)
+          CHARGEMENT.append(6*' '+'TERM') 
+          # imprimer les valeurs de la table
+          CHARGEMENT.append(6*' ' +'TABLE %i' %len(temps))
+          for ival in range(len(temps)):
+            CHARGEMENT.append(10*' ' +'%s %s' %(temps[ival],valeurs[ival]))
+      # DDL_IMPO
+      #if debug: print 'ddl_impo_list',ddl_impo_list
+      if ddl_impo_list :
+        #UTMESS('A','PLEXUS_8')
+# AA        if len(LIAISON) == 0 : LIAISON = ['LIAISON']
+        if len(LIAISON) == 0 : LIAISON = ['LINK']
+
+        for ddl_impo in ddl_impo_list:
+          blocage = ''
+
+          # DDL_IMPO / DX
+          for cle in dic_ddl_impo.keys() :
+            vale = self.get_motcle(ddl_impo,cle,code_mess=None)
+            if vale is not None:
+              if vale != 0 : UTMESS('F','PLEXUS_13')
+              else : 
+                blocage += `dic_ddl_impo[cle]`
+
+          # LIAISON / ENCASTRE
+          if ddl_impo.has_key('LIAISON'):
+             if ddl_impo['LIAISON']=='ENCASTRE':
+                blocage += ' 123456'
+
+          # recupere les entites geometriques
+          for entite in ['GROUP_MA','GROUP_NO'] :
+            group_ma = self.get_motcle(ddl_impo,entite,code_mess=None)
+            if group_ma is not None : 
+              group_ma = self.setlist(group_ma);break
+          LIAISON.append(' '*2 + 'BLOQ %s' %blocage)
+          # ajouter les group_ma qui ont ete affecte par ces caracteristiques
+          LIAISON.append(6*' '+'LECT')
+          for group in group_ma:
+            LIAISON.append(10*' '+group)
+          LIAISON.append(6*' '+'TERM') 
+
+      if not ddl_impo_list and not pres_rep_list :
+        UTMESS('F','PLEXUS_9')
+    
+    # Transmettre les commandes a la liste global epx
+    for var in [CHARGEMENT,LIAISON] :
+      if len(var) > 0 :
+        epx[MODULE].append('\n')
+        for ligne in var : epx[MODULE].append(ligne)
+    
+    epx[MODULE].append('\n')    
+#-----------------------------------------------------------------------   
+  def Correspondance_champ(self):
+   
+    # Dictionnaire de passage de champs Aster --> Europlexus
+    dic_champ = {'DEPL':'DEPLACEMENT','VITE':'VITESSE','ACCE':'ACCELERATION',
+                 'SIEF_ELGA':'CONT','EPSI_ELGA':'EPST','VARI_ELGA':'ECRO'}
+    
+    # Dictionnaire de passage de composantes Aster --> Europlexus
+    dic_cmp = {}
+    for cham in ['DEPL','VITE','ACCE'] :
+      dic_cmp[cham] = {'DX' : 1,'DY':2,'DZ':3,'DRX':4,'DRY':5,'DRZ':6}
+    
+    dic_cmp['SIEF_ELGA']  = {'SIXX':1,'SIYY':2,'SIZZ':3,'SIXY':4,'SIXZ':5,'SIYZ':6,'NXX':1,'NYY':2,'NXY':3,'MXX':4,'MYY':5,'MXY':6,'QX':7,'QY':8}
+    dic_cmp['VARI_ELGA'] = {}
+    for ii in range(1,25):
+      dic_cmp['VARI_ELGA']['V%i'%ii] = ii
+    
+    self.dic_champ = dic_champ  
+    self.dic_cmp = dic_cmp
+        
+    
+#-----------------------------------------------------------------------   
+  def export_ECRITURE(self):
+    
+    epx = self.epx
+    
+    self.Correspondance_champ()
+             
+    # CLe identifiant
+    MODULE = 'ECRITURE'
+
+    dcles_freq = {'FREQ':'PAS_NBRE', 'TFREQ':'PAS_INST'}
+
+    def get_freq(fact):
+      for cle_freq in dcles_freq.keys(): 
+# AA        vale_freq = self.get_motcle(fact,cle_freq,code_mess=None)
+        vale_freq = self.get_motcle(fact,dcles_freq[cle_freq],code_mess=None)
+        if vale_freq is not None : break
+      return cle_freq,vale_freq  
+      
+    def get_freq2() :
+        if self.PAS_NBRE_COURBE :
+            return 'FREQ',self.PAS_NBRE_COURBE
+        elif self.PAS_INST_COURBE :
+            return 'TFREQ',self.PAS_INST_COURBE
+        else :
+            raise 'Erreur programmation'
+        
+
+    def string2list(var) :
+      if types.TypeType(var) == types.StringType : var = (var,)
+      return var
+
+
+    epx[MODULE] = ['*--ECRITURES DES RESULTATS']
+    epx[MODULE] = ['opti K2GP']
+    # Entete de la commande Europlexus courante
+    epx[MODULE].append('ECRITURE')
+
+
+    # Traitement du mot-cle facteur OBSERVATION (EPX = LISTING)
+# AA    listing_fact = self.ECRITURE['LISTING']
+    listing_fact = self.OBSERVATION
+    nom_cham = string2list(listing_fact['NOM_CHAM'])
+
+    cle_freq_listing, vale_freq_listing = get_freq(listing_fact)
+# AA   cles_entite = ['POINTS','ELEMEMTS']
+    dcles_entite = {'POINT':'GROUP_NO', 'ELEM':'GROUP_MA'}
+# AA    dcles_tout   = {'POINTS':'TOUT_GROUP_NO', 'ELEMEMTS':'GROUP_MA'}
+    cles_entite = dcles_entite.keys()
+
+    # Ecriture format Europlexus
+    
+    # Ecriture LISTING
+    st = 2*' '   
+    for cham_aster in nom_cham:
+      cham_epx = self.dic_champ[cham_aster]
+      st +=  '%s ' % cham_epx  
+    st += ' %s %s' % (cle_freq_listing,vale_freq_listing)
+    st += ' NOPO NOEL'
+    epx[MODULE].append(st)
+    for cle in cles_entite:
+# AA    for cle in cles_entite :
+# AA      entite_geo = self.get_motcle(listing_fact ,cle, code_mess=None)
+# AA       entite_geo = string2list(entite_geo)
+
+       entite_geo = string2list(listing_fact[dcles_entite[cle]])
+       # if listing_fact['TOUT_%s' % dcles_entite[cle]] == 'OUI': epx[MODULE].append(2*' ' +'%s TOUS ' % cle)
+       # elif entite_geo is None:                                 epx[MODULE].append(2*' ' +'NO%s' % cle)
+       # else:
+          # epx[MODULE].append(2*' ' +'%s LECT' %cle)
+          # for group in entite_geo :
+             # epx[MODULE].append(6*' '+group)
+          # epx[MODULE].append(2*' '+'TERM') 
+
+#        if entite_geo is None : 
+#           epx[MODULE].append(2*' ' +'NO%s' %cle)
+#        elif  entite_geo[0] == 'TOUS' :
+#          epx[MODULE].append(2*' ' +'%s TOUS ' %cle)
+#        else :
+#           epx[MODULE].append(2*' ' +'%s LECT' %cle)
+#           for group in entite_geo :
+#              epx[MODULE].append(6*' '+group)
+#           epx[MODULE].append(2*' '+'TERM') 
+#           
+
+    # Ecriture FICHIER ALICE UTILISE par le mot-cle facteur COURBE
+# AA    courbe_fact = self.ECRITURE['COURBE']
+    courbe_fact = self.COURBE
+    if courbe_fact is not None :
+
+      # dcourbe=[]
+      # for j in courbe_fact:
+         # dcourbe.append(j.cree_dict_valeurs(j.mc_liste))
+         # for i in dcourbe[-1].keys():
+            # if dcourbe[-1][i]==None : del dcourbe[-1][i]
+
+      # if debug: print 'dcourbe=', dcourbe
+
+      cle_freq, vale_freq = get_freq2()
+      fichier_alit = self.pwd + self.REPE + os.sep + self.nom_fichiers['ALIT']
+      epx[MODULE].append(2*' ' + "FICH ALIT 11  %s %s" %(cle_freq,vale_freq))
+
+      # Liste les noeuds a postraiter
+      lnoeuds=set()
+      lmailles=set()
+      for courbe in courbe_fact :
+        if courbe['GROUP_NO'] != None :
+            noeuds = courbe['GROUP_NO']
+            if debug: print type(noeuds)
+            # liste de noeud ou un seul noeud ?
+            if type(noeuds) == tuple :
+                for el in noeuds :
+                    lnoeuds.add(el)
+            else :
+                lnoeuds.add(noeuds)
+        elif courbe['GROUP_MA'] != None :
+            mailles = courbe['GROUP_MA']
+            if debug: print type(mailles)
+            # liste de mailles ou une seule maille ?
+            if type(mailles ) == tuple :
+                for el in mailles :
+                    lmailles.add(el)
+            else :
+                lmailles.add(mailles)           
+        else :
+            raise 'Erreur ni noeud ni maille'
+      # sys.exit()
+      # tables = self.get_motcle(courbe_fact,'TABLE',code_mess='F')
+      # tables = self.setlist(tables)
+
+      # icourbe = 0
+      # for table in tables:
+        # icourbe += 1
+        # noeud = table['NOEUD']
+        # list_noeuds.append(noeud)
+      # Ecriture la liste des noeuds sous format epx
+      if lnoeuds :
+          epx[MODULE].append(4*' ' +'POINTS')
+          epx[MODULE].append(6*' ' +'LECT ')
+          for noeud in lnoeuds :
+            epx[MODULE].append(8*' '+noeud)
+          epx[MODULE].append(6*' '+'TERM')   
+      if lmailles :
+          epx[MODULE].append(4*' ' +'ELEM')
+          epx[MODULE].append(6*' ' +'LECT ')
+          for maille in lmailles :
+            epx[MODULE].append(8*' '+maille)
+          epx[MODULE].append(6*' '+'TERM')   
+     
+     
+      # Pas besoin d'elements 
+      # epx[MODULE].append(4*' ' + 'NOELEMENTS')
+    
+    # Ecriture fichier MED representant les champs aux noeuds et aux points de gauss
+    # Traitement du mot-cle facteur ARCHIVAGE
+#    # Traitement du mot-cle facteur CHAMP
+#    champ_fact = self.ECRITURE['CHAMP']
+    champ_fact = self.ARCHIVAGE
+    if champ_fact is not None :
+      cle_freq_champ,vale_freq_champ = get_freq(champ_fact)
+      epx[MODULE].append(2*' ' + 'FICHIER MED')
+      # chemin complet du fichier med
+      fichier_med = self.pwd + self.REPE + os.sep + self.nom_fichiers['MED']
+      epx[MODULE].append(2*' ' + "'%s'" %fichier_med)
+      cle_freq,vale_freq = get_freq(champ_fact)
+      epx[MODULE].append(2*' ' + ' %s %s' %(cle_freq_champ,vale_freq_champ))
+      
+      # groupes de mailles du modele
+      entite_geo={}
+      entite_geo['ELEM'] = []
+      for model in ['DKT3','Q4GS'] :
+         if model in self.modelisations :
+             entite_geo['ELEM'].extend(self.dic_gma[model])
+      entite_geo['POINT'] = []
+      for model in ['DKT3','Q4GS','POUT'] :
+         if model in self.modelisations :
+             entite_geo['POINT'].extend(self.dic_gma[model])
+      for cle in cles_entite :
+       epx[MODULE].append(2*' ' +'%s LECT' %cle)
+       for group in entite_geo[cle] :
+          epx[MODULE].append(6*' '+group)
+       epx[MODULE].append(2*' '+'TERM') 
+    
+    
+    # ecriture CAST2000
+    # __temp
+    fichier_cast2000 = 'fort.%i' %unite_cast2000
+    if unite_cast2000 and os.path.isfile(fichier_cast2000) :
+      # titre
+      epx[MODULE].append('\n*-- CAST2000')
+      fd = open(fichier_cast2000,'r')
+      lst = fd.readlines()
+      fd.close()
+      for st in lst :
+        st = string.replace(st,'\n','')
+        epx[MODULE].append(st)
+          
+    # Une ligne de saut
+    epx[MODULE].append('\n')
+    
+#-----------------------------------------------------------------------   
+
+  def export_POST_COURBE(self):
+
+    # Suite de postraitement permettant d'ecrire des fichiers ASCII 
+    # des grandeurs demandees
+    
+    # Tester si le mot_cle facteur COURBE a ete renseigne
+# AA   courbe_fact = self.ECRITURE['COURBE']
+    courbe_fact = self.COURBE
+    if courbe_fact is None : return
+
+    epx = self.epx
+                 
+    # Cle identifiant
+    MODULE = 'POST_COURBE'
+
+    # Ecriture fort Europlexus
+    # Entete de la commande courante
+    epx[MODULE] = ['SUITE\n']
+    # epx[MODULE].append("'TITRE'")
+#    unite_alit = self.get_motcle(courbe_fact,'UNITE_ALIT',code_mess=None)
+#    if debug: print 'unite_alit=', unite_alit
+    if self.UNITE_COURBE: fichier_courbes = os.path.join(self.pwd, 'fort.%s' % str(self.UNITE_COURBE))
+    else:                 fichier_courbes = self.pwd + self.REPE + os.sep + self.nom_fichiers['PUN']
+    fichier_alit = self.pwd + self.REPE + os.sep + self.nom_fichiers['ALIT']
+    epx[MODULE].append("RESULTAT ALICE TEMPS 11")
+    epx[MODULE].append("OPNF FORMAT 17 '%s'" %fichier_courbes)    
+    epx[MODULE].append("SORTIES GRAPHIQUES")
+    # epx[MODULE].append("PERFO '%s'"%fichier_courbes)
+    epx[MODULE].append("AXTEMPS 1. 'TEMPS(s)'")
+
+    # recuperer le mot-cle facteur COURBE
+# AA    courbe_fact = self.ECRITURE['COURBE']
+    courbe_fact = self.COURBE
+    # recuperer les mot_cle TABLE
+    # tables = self.get_motcle(courbe_fact,'TABLE',code_mess='F')
+    #tables = self.setlist(tables)
+
+    # Dictionnaire decrivant les legendes des abscisses et ordodonnees des courbes imprimees
+    # etl utilisee dans get_tables
+    self.legend_courbes = {}
+    entites_courbe = ['GROUP_NO','GROUP_MA'] 
+    entite_EPX={'GROUP_NO' : 'NOEUD', 'GROUP_MA' : 'ELEM'}
+    icourbe = 0
+    # for table in tables:
+    lnoeuds = []
+    for table in courbe_fact :
+      for entite_type in entites_courbe :
+        try : entite = table[entite_type]
+        except : entite = None
+        if entite is not None :        
+            cham_aster = table['NOM_CHAM']
+            cmp_aster = table['NOM_CMP']
+            cham_epx = self.dic_champ[cham_aster]
+            cmp_epx  = self.dic_cmp[cham_aster][cmp_aster]
+            ylabel   = cham_aster + '_' + cmp_aster
+            #ylabel   = cmp_aster
+            if type(entite) is not tuple : entite = [entite,]
+            for el in entite :
+                icourbe+=1
+                label = ylabel + '_%s'%el
+                if entite_type == 'GROUP_MA' :
+                    label = label+'_%s'%table['NUM_GAUSS']
+                st = "COURBE %i '%s' %s COMP %i "% (icourbe,label,cham_epx,cmp_epx)
+                if entite_type == 'GROUP_MA' :
+                    st=st+"GAUSS %i "%table['NUM_GAUSS']
+                st=st+"%s LECT %s TERM"%(entite_EPX[entite_type],el)
+                if debug: print 'st = %s'%st
+                epx[MODULE].append(st)
+                # epx[MODULE].append("LIST %i AXES 1. '%s'" % (icourbe,ylabel))
+                st = "LIST %s AXES 1. '%s'" % (icourbe,label)
+                if debug: print 'st = %s'%st
+                epx[MODULE].append(st)
+                self.legend_courbes[icourbe] = ['TEMPS',label]
+
+
+
+    # Une ligne de saut
+    epx[MODULE].append('\n')
+
+#-----------------------------------------------------------------------   
+  def export_CALCUL(self):
+    
+    epx = self.epx
+    
+    # CLe identifiant
+    MODULE = 'CALCUL'
+
+    # Entete de la commande Europlexus courante
+    epx[MODULE] = ['*--OPTION DE CALCUL']
+    epx[MODULE].append('')
+    type_discr = self.CALCUL['TYPE_DISCRETISATION']
+    
+    epx[MODULE].append('OPTION PAS %s' %type_discr)
+      
+    if  type_discr == 'AUTO':
+      cstab = self.CALCUL['CSTAB']
+      epx[MODULE].append(7*' ' + 'CSTAB %s' %cstab)
+    
+    listInterfaces = self.INTERFACES
+    listDomaines = self.DOMAINES
+    domaineInterfaces = {}
+    if listDomaines :
+        epx[MODULE].append('\n')
+        epx[MODULE].append('*--DEFINITION DES SOUS DOMAINES')
+        epx[MODULE].append('')
+        epx[MODULE].append('STRUCTURE %s'%len(listDomaines))
+        for interface in listInterfaces :
+            Lgma1 = self.setlist(interface['GROUP_MA_1'])
+            Lgma2 = self.setlist(interface['GROUP_MA_2'])
+            idS1 = interface['IDENT_DOMAINE_1']
+            idS2 = interface['IDENT_DOMAINE_2']
+            if not domaineInterfaces.has_key(idS1) :
+                domaineInterfaces[idS1]= []
+            if not domaineInterfaces.has_key(idS2) :
+                domaineInterfaces[idS2]= []
+            domaineInterfaces[idS1].extend(Lgma1)
+            domaineInterfaces[idS2].extend(Lgma2)
+    else : 
+        listDomaines = []
+    for domaine in listDomaines :
+        Lgma = self.setlist(domaine['GROUP_MA'])
+        id  = domaine['IDENTIFIANT']
+        epx[MODULE].append(3*' '+'DOMA LECT')
+        for gma in Lgma :
+            epx[MODULE].append(12*' '+gma)
+        for gma in domaineInterfaces[id] :
+            epx[MODULE].append(12*' '+gma)
+        epx[MODULE].append(8*' '+'TERM')
+        epx[MODULE].append(8*' '+'IDENTIFIANT %s\n'%id)
+        
+    
+    if listInterfaces :
+        epx[MODULE].append('')
+        epx[MODULE].append('INTERFACE %s'%len(listInterfaces))
+    else :
+        listInterfaces = []
+    for interface in listInterfaces :
+        Lgma1 = self.setlist(interface['GROUP_MA_1'])
+        Lgma2 = self.setlist(interface['GROUP_MA_2'])
+        idS1 = interface['IDENT_DOMAINE_1']
+        idS2 = interface['IDENT_DOMAINE_2']
+        tole = interface['TOLE']
+        epx[MODULE].append(3*' '+'MORTAR TOLE %s'%tole)
+        epx[MODULE].append(7*' '+'DOMA %s LECT'%idS1)
+        for gma in Lgma1 :
+            epx[MODULE].append(13*' '+gma)
+        epx[MODULE].append(10*' '+'TERM')
+        epx[MODULE].append(7*' '+'DOMA %s LECT'%idS2)
+        for gma in Lgma2 :
+            epx[MODULE].append(13*' '+gma)
+        epx[MODULE].append(10*' '+'TERM')
+                
+    epx[MODULE].append('\n')
+    epx[MODULE].append('*--LANCEMENT DE CALCUL')
+    epx[MODULE].append('')
+    calcul = 'CALCUL'
+# AAA    cles = ['INST_INIT','PASFIX','INST_FIN','DTMAX']
+    cles = ['INST_INIT','PASFIX','INST_FIN']
+    dcles = {'INST_INIT':'TINI', 'PASFIX':'PASFIX', 'INST_FIN':'TFIN'}
+    for cle in dcles.keys():
+      try : calcul += ' %s %s' %(dcles[cle], self.CALCUL[cle])
+      except : pass
+    # Doit etre mis en entier
+    try : calcul += ' %s %d' %('NMAX',self.CALCUL['NMAX'])
+    except : pass
+    epx[MODULE].append(calcul) 
+    epx[MODULE].append('\n')
+    #epx[MODULE].append('FIN')  
+    
+  
+#-----------------------------------------------------------------------   
+  def ecrire_fichier(self,):
+    
+    fichier = self.REPE + os.sep + self.nom_fichiers['COMMANDE']
+
+    # ordre des modules de definition du modele EPX
+    modules = ['DEBUT','MAILLAGE','DIME','MODELE','CARA_ELEM','FONC_PARASOL','CHAM_MATER','RIGI_PARASOL','EXCIT','ECRITURE','CALCUL','POST_COURBE']
+    
+    #les modules MODELE et RIGI_PARASOL doivent etre executes avant MAILLAGE 
+    # car le maillage peut etre modifie dans ces modules
+    modules_exe = []
+    modules_exe.extend(modules)
+    modules_exe.remove('MAILLAGE') 
+    modules_exe.append('MAILLAGE')
+    
+    # Excecution des differentes modules
+    for module in modules_exe:
+      fct = 'export_%s' %module
+      if hasattr(self,fct) : 
+        eval('self.'+fct+'()')  
+      else :  
+        print 'module %s pas encore developpe' %fct
+    
+    # Ecriture du fichier texte contenant toutes les commandes Europlexus
+    fd = open(fichier,'w')
+    for module in modules :
+      if self.epx.has_key(module) :
+        for ll in self.epx[module]:
+          if debug: print 'EPX : %s'%ll
+          fd.write('%s\n'%ll)
+    # Fin du fichier de commandes epx      
+    fd.write('FIN')      
+    fd.close()
+
+#-----------------------------------------------------------------------   
+  def get_table(self,icourbe=1,fichier='auto') :
+   
+    global table
+    
+    if not hasattr(self,'courbes'): 
+      if fichier == 'auto' : fichier = self.pwd + self.REPE + os.sep + self.nom_fichiers['PUN']
+      if not os.path.isfile(fichier) : return
+      self.courbes = self.lire_pun(fichier=fichier)
+    
+    if not os.path.isfile(fichier) : return
+    if debug: print self.courbes,type(self.courbes)
+    nc = 0
+    para_ordonnee = []
+    dico = []
+    for icourbe in self.courbes :
+        valeurs = self.courbes[icourbe]
+        if debug: print 'icourbe = %s ; valeurs = %s'%(icourbe, valeurs)
+        if nc == 0 :
+            para_abscisse = self.legend_courbes[icourbe][0]
+            vale_abscisse = valeurs[0,:].tolist()
+            assert (len(para_abscisse)<17)
+            dico.append({'TYPE_K':'K16','LISTE_R' : vale_abscisse , 'PARA' : para_abscisse})
+            para_ordonnee = self.legend_courbes[icourbe][1]
+            vale_ordonnee = valeurs[1,:].tolist()
+            assert (len(para_ordonnee)<17)
+            dico.append({'TYPE_K':'K16','LISTE_R' : vale_ordonnee , 'PARA' : para_ordonnee})
+            nc=1
+        else :
+            if ((self.legend_courbes[icourbe][0] == para_abscisse) and (vale_abscisse == valeurs[0,:].tolist())) :
+                para_ordonnee = self.legend_courbes[icourbe][1]
+                vale_ordonnee = valeurs[1,:].tolist()
+                assert (len(para_ordonnee)<17)
+                dico.append({'TYPE_K':'K16','LISTE_R' : vale_ordonnee , 'PARA' : para_ordonnee})
+            else :
+                raise 'Table non compatible'
+    
+    table = CREA_TABLE( LISTE =dico
+                      );
+    
+    if 0 :
+      unite = self.get_unite_libre()
+      unite = 90
+      DEFI_FICHIER(UNITE=unite,ACTION='ASSOCIER'); 
+                                                
+      IMPR_TABLE(UNITE = unite,
+               FORMAT = 'XMGRACE',
+               TABLE = table,
+               LEGENDE_X = para_abscisse,
+               LEGENDE_Y = para_ordonnee,
+               LEGENDE   = 'test'
+           );
+           
+      os.system('xmgrace fort.%i' %unite) 
+    
+      DEFI_FICHIER(UNITE=unite,ACTION='LIBERER'); 
+           
+                  
+#-----------------------------------------------------------------------
+  def get_resu(self,fichier_med='auto'):
+    
+    # Rendre global le resu pour qu'il soit accepte dans self.DeclareOut 
+    global resu
+    
+    if fichier_med == 'auto' : fichier_med = self.REPE + os.sep + self.nom_fichiers['MED'] 
+    
+    if debug: print fichier_med
+    if not os.path.isfile(fichier_med) :
+       print "Pas de fichier MED !"
+       return
+        
+    # Format med des champs depl, vite et acce
+    format_med =[_F(NOM_CHAM_MED='CHAMP___DEPLACEMENT___001',
+                    NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'),
+                    NOM_CMP_MED=('UX','UY','UZ','RX','RY','RZ'),
+                    NOM_CHAM    ='DEPL' ),
+                 _F(NOM_CHAM_MED='CHAMP___VITESSE___001',
+                    NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'),
+                    NOM_CMP_MED=('VX','VY','VZ','RX','RY','RZ'),
+                    NOM_CHAM    ='VITE' ),
+                 _F(NOM_CHAM_MED='CHAMP___ACCELERATION___001',
+                    NOM_CMP=('DX','DY','DZ','DRX','DRY','DRZ'),
+                    NOM_CMP_MED=('GX','GY','GZ','RX','RY','RZ'),
+                    NOM_CHAM    ='ACCE' ),
+                ]    
+
+    # Dicionnaire permettant de faire la correspondance des champs aux pts de gauss entre le med de europlexus et aster
+    dic_cmp_gauss = {}
+    
+    dic_cmp_gauss['CONTRAINTE'] = {'DKT3': {'NOM_CMP'     : ('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),
+                                            'NOM_CMP_MED' : ('SIG1','SIG2','SIG3','SIG4','SIG5','SIG6',),},
+                                   'Q4GS': {'NOM_CMP'     : ('NXX','NYY','NXY','MXX','MYY','MXY','QX','QY'),
+                                            'NOM_CMP_MED' : ('SIG1','SIG2','SIG3','SIG4','SIG5','SIG6','SIG7','SIG8'),},
+                                   'POUT' : {}        
+                    
+                                   }
+
+    dic_cmp_gauss['DEFORMATION'] = {'DKT3': {'NOM_CMP'     : ('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),
+                                            'NOM_CMP_MED' : ('EPS1','EPS2','EPS3','EPS4','EPS5','EPS6',),},
+                                   'Q4GS': {'NOM_CMP'     : ('EXX','EYY','EXY','KXX','KYY','KXY','GAX','GAY'),
+                                            'NOM_CMP_MED' : ('EPS1','EPS2','EPS3','EPS4','EPS5','EPS6','EPS7','EPS8'),},
+                                   'POUT' : {}        
+                    
+                                   }
+
+    dic_cmp_gauss['ECROUISSAGE'] = {'DKT3': {'NOM_CMP'     : ('V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19'),
+                                            'NOM_CMP_MED'  : ('VAR1','VAR2','VAR3','VAR4','VAR5','VAR6','VAR7','VAR8','VAR9','VAR10','VAR11','VAR12','VAR13','VAR14','VAR15','VAR16','VAR17','VAR18','VAR19'),},
+                                   'Q4GS' : {'NOM_CMP'     : ('V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19'),
+                                            'NOM_CMP_MED'  : ('VAR1','VAR2','VAR3','VAR4','VAR5','VAR6','VAR7','VAR8','VAR9','VAR10','VAR11','VAR12','VAR13','VAR14','VAR15','VAR16','VAR17','VAR18','VAR19'),},
+                                   'POUT' : {}        
+                        
+                                    }
+    tupVar = ('X1','X2','X3','X4','X5','X6','X7','X8','X9','X10','X11','X12','X13','X14','X15','X16','X17','X18','X19')                                
+    
+    # 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'}
+
+# AA : desactive pour le moment
+#     # Enrichir la liste format_med par les champs aux pts de gauss
+#     imode = 0
+#     if debug: print 'self.modelisations',self.modelisations
+#     for modelisation in self.modelisations :
+#       #if modelisation in ['Q4GS','DKT3'] :
+#         imode += 1
+#         numero =  string.replace('%3.i' %imode,' ','0')
+#         for champ in dic_cmp_gauss.keys():
+#           if len(dic_cmp_gauss[champ][modelisation]) > 0 :
+#             nom_cham_med = 'CHAMP___'+ champ + (13-len(champ))*'_' + numero
+#             nom_cham = epx2aster[champ]
+#             nom_cmp = dic_cmp_gauss[champ][modelisation]['NOM_CMP']
+#             nom_cmp_med = dic_cmp_gauss[champ][modelisation]['NOM_CMP_MED']
+#             # ajouer a la list format_med
+#             format_med.append(_F(NOM_CHAM_MED=nom_cham_med,NOM_CMP=nom_cmp,
+#                                NOM_CMP_MED=nom_cmp_med,NOM_CHAM=nom_cham)
+#                            )
+
+    # Lire le fichier med avec les options choisies dans la liste format_med
+    unite = self.get_unite_libre()
+    DEFI_FICHIER(UNITE=unite,ACTION='LIBERER'); 
+    fort = 'fort.%i' %unite
+    if os.path.isfile(fort) : os.remove(fort)
+
+    os.symlink(fichier_med,fort)
+
+    # Regeneration des mots-cles EXCIT passés en argument de la macro
+    dExcit=[]
+    for j in self.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]
+    resu = LIRE_RESU(TYPE_RESU='EVOL_NOLI',
+#                  VERI_ELGA='NON',
+                  FORMAT='MED',
+                  MODELE=self.NEW_MODELE,
+                  FORMAT_MED=format_med,
+                  UNITE=unite,
+                  CHAM_MATER=self.CHAM_MATER,
+                  CARA_ELEM=self.CARA_ELEM,
+                  TOUT_ORDRE='OUI',
+                  EXCIT=dExcit,
+                  INFO=self.INFO,
+                  );
+
+    __EPN = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM = 'ELGA_NEUT_R',
+            OPERATION = 'AFFE',
+            MODELE    = self.NEW_MODELE,
+            PROL_ZERO = 'OUI',
+            AFFE      = self.listEpais,
+            )
+    __EPN2 = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM = 'ELGA_NEUT_R',
+            OPERATION = 'AFFE',
+            MODELE    = self.NEW_MODELE,
+            PROL_ZERO = 'OUI',
+            AFFE      = self.listEpais2,
+            )
+    __UNN = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM = 'ELGA_NEUT_R',
+            OPERATION = 'AFFE',
+            MODELE    = self.NEW_MODELE,
+            PROL_ZERO = 'OUI',
+            AFFE = _F(VALE=(1.,1.), TOUT='OUI', NOM_CMP=('X21','X22')),
+            )
+    __UNDEU = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM = 'ELGA_NEUT_R',
+            OPERATION = 'AFFE',
+            MODELE    = self.NEW_MODELE,
+            PROL_ZERO = 'OUI',
+            AFFE = _F(VALE=(1.,1./2.), TOUT='OUI', NOM_CMP=('X21','X22')),
+            )
+    __FONC1 = FORMULE(VALE='X1*X21',NOM_PARA=('X1','X21'))
+    __FONC2 = FORMULE(VALE='X2*X21',NOM_PARA=('X2','X21'))
+    __FONC3 = FORMULE(VALE='X3*X21',NOM_PARA=('X3','X21'))
+    __FONC4 = FORMULE(VALE='X4*X22',NOM_PARA=('X4','X22'))
+    __FONC5 = FORMULE(VALE='X5*X22',NOM_PARA=('X5','X22'))
+    __FONC6 = FORMULE(VALE='X6*X22',NOM_PARA=('X6','X22'))
+    __FONC7 = FORMULE(VALE='X7*X21',NOM_PARA=('X7','X21'))
+    __FONC8 = FORMULE(VALE='X8*X21',NOM_PARA=('X8','X21'))
+    __FONC11 = FORMULE(VALE='X11*X21',NOM_PARA=('X11','X21'))
+    __FONC12 = FORMULE(VALE='X12*X21',NOM_PARA=('X12','X21'))
+    __FONC13 = FORMULE(VALE='X13*X21',NOM_PARA=('X13','X21'))
+    __FONC14 = FORMULE(VALE='X14*X22',NOM_PARA=('X14','X22'))
+    __FONC15 = FORMULE(VALE='X15*X22',NOM_PARA=('X15','X22'))
+    __FONC16 = FORMULE(VALE='X16*X22',NOM_PARA=('X16','X22'))
+    __FONC17 = FORMULE(VALE='X17*X21',NOM_PARA=('X17','X21'))
+    __FONC18 = FORMULE(VALE='X18*X21',NOM_PARA=('X18','X21'))
+
+    __FONE1 = FORMULE(VALE='X1*X21',NOM_PARA=('X1','X21'))
+    __FONE2 = FORMULE(VALE='X2*X21',NOM_PARA=('X2','X21'))
+    __FONE3 = FORMULE(VALE='X3*X22',NOM_PARA=('X3','X22'))
+    __FONE4 = FORMULE(VALE='X4*X21',NOM_PARA=('X4','X21'))
+    __FONE5 = FORMULE(VALE='X5*X21',NOM_PARA=('X5','X21'))
+    __FONE6 = FORMULE(VALE='X6*X22',NOM_PARA=('X6','X22'))
+    __FONE7 = FORMULE(VALE='X7*X21',NOM_PARA=('X7','X21'))
+    __FONE8 = FORMULE(VALE='X8*X21',NOM_PARA=('X8','X21'))
+    __FONE9 = FORMULE(VALE='X9*X21',NOM_PARA=('X9','X21'))
+    __FONE10 = FORMULE(VALE='X10*X21',NOM_PARA=('X10','X21'))
+    __FONE11 = FORMULE(VALE='X11*X21',NOM_PARA=('X11','X21'))
+    __FONE12 = FORMULE(VALE='X12*X21',NOM_PARA=('X12','X21'))
+    __FONE13 = FORMULE(VALE='X13*X21',NOM_PARA=('X13','X21'))
+    __FONE14 = FORMULE(VALE='X14*X21',NOM_PARA=('X14','X21'))
+    __FONE15 = FORMULE(VALE='X15*X21',NOM_PARA=('X15','X21'))
+    __FONE16 = FORMULE(VALE='X16*X21',NOM_PARA=('X16','X21'))
+    __FONE17 = FORMULE(VALE='X17*X21',NOM_PARA=('X17','X21'))
+    __FONE18 = FORMULE(VALE='X18*X21',NOM_PARA=('X18','X21'))
+    __FONE19 = FORMULE(VALE='X19*X21',NOM_PARA=('X19','X21'))
+    
+    __FONCC = CREA_CHAMP(
+        INFO      = self.INFO,
+        TYPE_CHAM = 'ELGA_NEUT_F',
+        OPERATION = 'AFFE',
+        MODELE    = self.NEW_MODELE,
+        PROL_ZERO = 'OUI',
+        AFFE      = _F(
+               TOUT    = 'OUI',
+               NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8','X11','X12','X13','X14','X15','X16','X17','X18'),
+               VALE_F  = (__FONC1,__FONC2,__FONC3,__FONC4,__FONC5,__FONC6,__FONC7,__FONC8,__FONC11,__FONC12,__FONC13,
+                          __FONC14,__FONC15,__FONC16,__FONC17,__FONC18)),
+                          )
+    __FONCC2 = CREA_CHAMP(
+        INFO      = self.INFO,
+        TYPE_CHAM = 'ELGA_NEUT_F',
+        OPERATION = 'AFFE',
+        MODELE    = self.NEW_MODELE,
+        PROL_ZERO = 'OUI',
+        AFFE      = _F(
+               TOUT    = 'OUI',
+               NOM_CMP = tupVar,
+     #          VALE_F  = (__FONE1,__FONE2)
+               VALE_F  = (__FONE1,__FONE2,__FONE3,__FONE4,__FONE5,__FONE6,__FONE7,__FONE8,__FONE9,__FONE10,__FONE11,__FONE12,__FONE13,__FONE14,__FONE15,__FONE16,__FONE17,__FONE18,__FONE19)
+               ),
+               )
+    listEffg = []
+    i=0
+    listType=[]
+    __SIG11 = [None]*10
+    __SIG21 = [None]*10
+    __ECR11 = [None]*10
+
+    # Pour masquer certaines alarmes
+    from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
+    MasquerAlarme('MED_83')
+    MasquerAlarme('MED_98')
+
+    while 1:
+        # index=1
+        # pas = self.ARCHIVAGE['PAS_NBRE']
+        # dicDetr=[]
+        # if 'Q4GS' in self.modelisations :
+            err = 0
+            try :
+                __SIG11[i] = LIRE_CHAMP(
+                    INFO        = self.INFO,
+                    TYPE_CHAM   = 'ELGA_SIEF_R',
+                    UNITE       = 99,
+                    NUME_PT     = 0,
+                    MODELE      = self.NEW_MODELE,
+                    MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                    PROL_ZERO   = 'OUI',
+                    NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(i+1),
+                    NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP'],
+                    NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP_MED'])
+                # dicDetr.append({'NOM' : __SIG11})
+                DETRUIRE(CONCEPT=_F(NOM = __SIG11[i]), INFO=1)
+                listType.append('Q4GS')
+                # index=2 
+            except :
+                err+=1
+            try :
+                __SIG21[i] = LIRE_CHAMP(
+                    INFO        = self.INFO,
+                    TYPE_CHAM   = 'ELGA_SIEF_R',
+                    UNITE       = 99,
+                    NUME_PT     = 0,
+                    MODELE      = self.NEW_MODELE,
+                    MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                    PROL_ZERO   = 'OUI',
+                    NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(i+1),
+                    NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'],
+                    NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED']),
+                DETRUIRE(CONCEPT=_F(NOM = __SIG21[i]), INFO=1)
+                if len(listType)<i+1 :
+                    listType.append('DKT3')
+            except : 
+                err+=1
+            if err<2 :
+                i+=1
+            else :
+                break
+        # if 'DKT3' in self.modelisations :
+            # try : 
+                # __SIG21 = LIRE_CHAMP(
+                    # INFO        = self.INFO,
+                    # TYPE_CHAM   = 'ELGA_SIEF_R',
+                    # UNITE       = 99,
+                    # NUME_PT     = i*pas,
+                    # MODELE      = self.NEW_MODELE,
+                    # MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                    # PROL_ZERO   = 'OUI',
+                    # NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%index,
+                    # NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'],
+                    # NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED']),
+                # dicDetr.append({'NOM' : __SIG21})
+
+            # except :
+                # err +=1
+        # if err > 1 :
+            # break
+        # DETRUIRE(CONCEPT=dicDetr) 
+        # i+=1
+
+    # Pour la gestion des alarmes
+    RetablirAlarme('MED_83')
+    RetablirAlarme('MED_98')
+
+
+    nbChamp = i
+    
+    listVari = [0]*nbChamp
+    
+    for i in xrange(nbChamp) :
+            if listType[i] == 'Q4GS' :
+               try :
+                   __ECR11[i] = LIRE_CHAMP(
+                       INFO        = self.INFO,
+                       TYPE_CHAM   = 'ELGA_VARI_R',
+                       UNITE       = 99,
+                       NUME_PT     = 0,
+                       MODELE      = self.NEW_MODELE,
+                       MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                       PROL_ZERO   = 'OUI',
+                       NOM_MED     = 'CHAMP___ECROUISSAGE__00%d'%(i+1),
+                       NOM_CMP     = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'],
+                       NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP_MED'])
+                   # dicDetr.append({'NOM' : __SIG11})
+                   DETRUIRE(CONCEPT=_F(NOM = __ECR11[i]), INFO=1)
+                   listVari[i]=1
+               except :
+                   err+=1
+            elif listType[i] == 'DKT3' :
+               try :
+                   __ECR11[i] = LIRE_CHAMP(
+                       INFO        = self.INFO,
+                       TYPE_CHAM   = 'ELGA_VARI_R',
+                       UNITE       = 99,
+                       NUME_PT     = 0,
+                       MODELE      = self.NEW_MODELE,
+                       MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                       PROL_ZERO   = 'OUI',
+                       NOM_MED     = 'CHAMP___ECROUISSAGE__00%d'%(i+1),
+                       NOM_CMP     = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP'],
+                       NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP_MED'])
+                   # dicDetr.append({'NOM' : __SIG11})
+                   DETRUIRE(CONCEPT=_F(NOM = __ECR11[i]), INFO=1)
+                   listVari[i]=1
+               except :
+                  err+=1
+    
+    
+    
+    itot=len(resu.LIST_PARA()['INST'])
+    __EFFG=[None]*itot
+    # __EPSG=[None]*itot
+    __ECRG=[None]*itot
+    __SIG1 = [None]*nbChamp
+    __SIG2 = [None]*nbChamp
+    __ECR1 = [None]*nbChamp
+    __ECR2 = [None]*nbChamp
+    for i in xrange(itot) :
+        dicAffe=[]
+        dicAffe2=[]
+        dicAffe3=[]
+        index=1
+        pas = self.ARCHIVAGE['PAS_NBRE']
+        dicAsse = [{'TOUT' : 'OUI', 'CHAM_GD' : __EPN, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}]
+        dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPN2, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.})
+        dicAsse2 = [{'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}]
+        dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __UNN, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.})
+        dicAsse3 = [{'TOUT' : 'OUI', 'CHAM_GD' : __UNDEU, 'NOM_CMP' : 'X21', 'NOM_CMP_RESU' : 'X21'}]
+        dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __UNDEU, 'NOM_CMP' : 'X22', 'NOM_CMP_RESU' : 'X22', 'CUMUL' : 'OUI','COEF_R':1.})
+        dicDetr=[]
+        # if 'Q4GS' in self.modelisations :
+        for j in xrange(nbChamp) :
+            if listType[j] == 'Q4GS' :
+                __SIG1[j] = LIRE_CHAMP(
+                    INFO        = self.INFO,
+                    TYPE_CHAM   = 'ELGA_SIEF_R',
+                    UNITE       = 99,
+                    NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
+                    MODELE      = self.NEW_MODELE,
+                    MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                    PROL_ZERO   = 'OUI',
+                    NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(j+1),
+                    NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP'],
+                    NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP_MED'],
+                        )
+                dicDetr.append({'NOM' : __SIG1[j]})
+                dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __SIG1[j], 'NOM_CMP' : tuple(dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP']), 
+                            'NOM_CMP_RESU' : ('X1','X2','X3','X4','X5','X6','X7','X8'), 'CUMUL' : 'OUI','COEF_R':1.})
+                # __EPS1 = LIRE_CHAMP(
+                    # INFO        = self.INFO,
+                    # TYPE_CHAM   = 'ELGA_EPSI_R',
+                    # UNITE       = 99,
+                    # NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
+                    # MODELE      = self.NEW_MODELE,
+                    # MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                    # PROL_ZERO   = 'OUI',
+                    # NOM_MED     = 'CHAMP___DEFORM_TOT___001',
+                    # NOM_CMP     = dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP'],
+                    # NOM_CMP_MED = dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP_MED'])
+                if listVari[j] :
+                    __ECR1[j] = LIRE_CHAMP(
+                        INFO     = self.INFO,
+                        TYPE_CHAM   = 'ELGA_VARI_R',
+                        UNITE    = 99,
+                        NUME_PT  = resu.LIST_PARA()['NUME_ORDRE'][i],
+                        MODELE   = self.NEW_MODELE,
+                        MAILLAGE         = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                        PROL_ZERO   = 'OUI',
+                        NOM_MED  = 'CHAMP___ECROUISSAGE__00%d'%(j+1),
+                        NOM_CMP  = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'],
+                        NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP_MED'])
+                    dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __ECR1[j], 'NOM_CMP' : tuple(dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP']), 
+                             'NOM_CMP_RESU' : tupVar, 'CUMUL' : 'OUI','COEF_R':1.})
+                    dicDetr.append({'NOM' : __ECR1[j]})
+                # dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPS1, 'NOM_CMP' : tuple(dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP']), 
+                            # 'NOM_CMP_RESU' : ('X1','X2','X3','X4','X5','X6','X7','X8'), 'CUMUL' : 'OUI','COEF_R':1.})
+            else :
+                __SIG2[j] = LIRE_CHAMP(
+                    INFO        = self.INFO,
+                    TYPE_CHAM   = 'ELGA_SIEF_R',
+                    UNITE       = 99,
+                    NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
+                    MODELE      = self.NEW_MODELE,
+                    MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                    PROL_ZERO   = 'OUI',
+                    NOM_MED     = 'CHAMP___CONTRAINTE___00%d'%(j+1),
+                    NOM_CMP     = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'],
+                    NOM_CMP_MED = dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP_MED'],
+                    )
+                dicAsse.append({'TOUT' : 'OUI', 'CHAM_GD' : __SIG2[j], 'NOM_CMP' : tuple(dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP']),
+                                'NOM_CMP_RESU' : ('X11','X12','X13','X14','X15','X16'), 'CUMUL' : 'OUI','COEF_R':1.})
+                dicDetr.append({'NOM' : __SIG2[j]})
+                # __EPS2 = LIRE_CHAMP(
+                    # INFO        = self.INFO,
+                    # TYPE_CHAM   = 'ELGA_EPSI_R',
+                    # UNITE       = 99,
+                    # NUME_PT     = resu.LIST_PARA()['NUME_ORDRE'][i],
+                    # MODELE      = self.NEW_MODELE,
+                    # MAILLAGE    = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                    # PROL_ZERO   = 'OUI',
+                    # NOM_MED     = 'CHAMP___DEFORM_TOT___00%d'%index,
+                    # NOM_CMP     = dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP'],
+                    # NOM_CMP_MED = dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP_MED']),
+                if listVari[j] :
+
+                   __ECR2[j] = LIRE_CHAMP(
+                       INFO      = self.INFO,
+                       TYPE_CHAM   = 'ELGA_VARI_R',
+                       UNITE     = 99,
+                       NUME_PT   = resu.LIST_PARA()['NUME_ORDRE'][i],
+                       MODELE    = self.NEW_MODELE,
+                       MAILLAGE  = self.reupere_structure(self.MODELE,'MAILLAGE'),
+                       PROL_ZERO   = 'OUI',
+                       NOM_MED   = 'CHAMP___ECROUISSAGE__00%d'%(j+1),
+                       NOM_CMP   = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP'],
+                       NOM_CMP_MED = dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP_MED'])
+                   dicAsse3.append({'TOUT' : 'OUI', 'CHAM_GD' : __ECR2[j], 'NOM_CMP' : tuple(dic_cmp_gauss['ECROUISSAGE']['DKT3']['NOM_CMP']), 
+                                   'NOM_CMP_RESU' : tupVar, 'CUMUL' : 'OUI','COEF_R':1.})
+                   dicDetr.append({'NOM' : __ECR2[j]})
+                # dicAsse2.append({'TOUT' : 'OUI', 'CHAM_GD' : __EPS2, 'NOM_CMP' : tuple(dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP']), 
+                                # 'NOM_CMP_RESU' : ('X11','X12','X13','X14','X15','X16'), 'CUMUL' : 'OUI','COEF_R':1.})
+                # dicDetr.append({'NOM' : __EPS2})
+#                dicDetr.append({'NOM' : __ECR2})
+                # dicDetr.append({'NOM' : __EPS1})
+#                dicDetr.append({'NOM' : __ECR1})
+        # if 'DKT3' in self.modelisations:
+
+        __SIGN = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM = 'ELGA_NEUT_R',
+            OPERATION = 'ASSE',
+            PROL_ZERO = 'OUI',
+            MODELE    = self.NEW_MODELE,
+            ASSE      = dicAsse,
+            )
+        # __EPSN = CREA_CHAMP(
+            # INFO      = self.INFO,
+            # TYPE_CHAM = 'ELGA_NEUT_R',
+            # OPERATION = 'ASSE',
+            # PROL_ZERO = 'OUI',
+            # MODELE    = self.NEW_MODELE,
+            # ASSE      = dicAsse2)
+        __ECRN = CREA_CHAMP(
+             INFO      = self.INFO,
+             TYPE_CHAM = 'ELGA_NEUT_R',
+             OPERATION = 'ASSE',
+             PROL_ZERO = 'OUI',
+             MODELE    = self.NEW_MODELE,
+             ASSE      = dicAsse3)
+        dicDetr.append({'NOM' : __SIGN})
+        # dicDetr.append({'NOM' : __EPSN})
+        dicDetr.append({'NOM' : __ECRN})
+        __EFFGN = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM = 'ELGA_NEUT_R',
+            OPERATION = 'EVAL',
+            CHAM_F    = __FONCC,
+            CHAM_PARA = (__SIGN),
+          )
+        # __EPSGN = CREA_CHAMP(
+            # INFO      = self.INFO,
+            # TYPE_CHAM = 'ELGA_NEUT_R',
+            # OPERATION = 'EVAL',
+            # CHAM_F    = __FONCC,
+            # CHAM_PARA   = (__EPSN))
+        __ECRGN = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM = 'ELGA_NEUT_R',
+            OPERATION = 'EVAL',
+            CHAM_F    = __FONCC2,
+            CHAM_PARA   = (__ECRN))
+        dicDetr.append({'NOM' : __EFFGN})
+        # dicDetr.append({'NOM' : __EPSGN})
+        dicDetr.append({'NOM' : __ECRGN})
+        __EFFG[i] = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM  = 'ELGA_SIEF_R',
+            OPERATION = 'ASSE',
+            PROL_ZERO = 'OUI',
+            MODELE    = self.NEW_MODELE,
+            ASSE      = _F(
+                TOUT = 'OUI',
+                CHAM_GD = __EFFGN,
+                NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8')+('X11','X12','X13','X14','X15','X16'),
+                NOM_CMP_RESU = tuple(dic_cmp_gauss['CONTRAINTE']['Q4GS']['NOM_CMP']+dic_cmp_gauss['CONTRAINTE']['DKT3']['NOM_CMP'])),
+                )
+        # __EPSG[i] = CREA_CHAMP(
+            # INFO      = self.INFO,
+            # TYPE_CHAM  = 'ELGA_EPSI_R',
+            # OPERATION = 'ASSE',
+            # PROL_ZERO = 'OUI',
+            # MODELE    = self.NEW_MODELE,
+            # ASSE      = _F(
+                # TOUT = 'OUI',
+                # CHAM_GD = __EPSGN,
+                # NOM_CMP = ('X1','X2','X3','X4','X5','X6','X7','X8')+('X11','X12','X13','X14','X15','X16'),
+                # NOM_CMP_RESU = tuple(dic_cmp_gauss['DEFORMATION']['Q4GS']['NOM_CMP']+dic_cmp_gauss['DEFORMATION']['DKT3']['NOM_CMP'])))
+        __ECRG[i] = CREA_CHAMP(
+            INFO      = self.INFO,
+            TYPE_CHAM  = 'ELGA_VARI_R',
+            OPERATION = 'ASSE',
+            PROL_ZERO = 'OUI',
+            MODELE    = self.NEW_MODELE,
+            ASSE      = _F(
+                TOUT = 'OUI',
+                CHAM_GD = __ECRGN,
+                NOM_CMP = tupVar,
+                NOM_CMP_RESU = tuple(dic_cmp_gauss['ECROUISSAGE']['Q4GS']['NOM_CMP'])))
+# AA        dicAffe.append({'CHAM_GD' : __EFFG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]})
+        dicAffe.append({'CHAM_GD' : __EFFG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER, 'CARA_ELEM' : self.CARA_ELEM, 'INST': resu.LIST_PARA()['INST'][i]})
+        # dicAffe2.append({'CHAM_GD' : __EPSG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]})
+# AA        dicAffe3.append({'CHAM_GD' : __ECRG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER,'INST': resu.LIST_PARA()['INST'][i]})
+        dicAffe3.append({'CHAM_GD' : __ECRG[i], 'MODELE' : self.NEW_MODELE,'CHAM_MATER' : self.CHAM_MATER, 'CARA_ELEM' : self.CARA_ELEM, 'INST': resu.LIST_PARA()['INST'][i]})
+        DETRUIRE(CONCEPT=dicDetr, INFO=1)
+        resu = CREA_RESU(reuse=resu,
+            OPERATION = 'AFFE',
+            TYPE_RESU = 'EVOL_NOLI',
+            NOM_CHAM  = 'SIEF_ELGA',
+            AFFE = dicAffe,
+            )
+        # resu = CREA_RESU(reuse=resu,
+            # OPERATION = 'AFFE',
+            # TYPE_RESU = 'EVOL_NOLI',
+            # NOM_CHAM  = 'EPSI_ELGA_DEPL',
+            # AFFE = dicAffe2)
+        resu = CREA_RESU(reuse=resu,
+            OPERATION = 'AFFE',
+            TYPE_RESU = 'EVOL_NOLI',
+            NOM_CHAM  = 'VARI_ELGA',
+            AFFE = dicAffe3,
+            )
+
+    DEFI_FICHIER(UNITE=unite,ACTION='LIBERER');              
+
+    os.remove(fort)
+
+#-----------------------------------------------------------------------
+  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),
+                   CODE_RETOUR_MAXI=-1,
+                   INFO=2)
+
+
+#------------------------------------------------------------------------
+#----------------------------- FIN class EUROPLEXUS ---------------------
+#------------------------------------------------------------------------
+
+ 
+#------------------------------------------------------------------------
+#----------------------------- class POUTRE -----------------------------
+#------------------------------------------------------------------------
+
+class POUTRE:
+  def __init__(self,MAILLAGE,CARA_ELEM):
+    
+    # recuperer les infos du maillage sous format python 
+    self.MApyt = MAIL_PY()
+    self.MApyt.FromAster(MAILLAGE)
+    self.CARA_ELEM = CARA_ELEM
+    # un dictionnaire stockant tous orientations definis dans AFF_CARA_ELEM
+    self.dic_gma = self.orientation_cara_elem()
+       
+#------------------------------------------------------------------------
+  def getvecteurs(self,groupes_poutres,verif='non'):
+    vecteurs = {}
+    ig = 0
+    message = 0
+    for gr in groupes_poutres :
+      ig += 1 
+      if not self.dic_gma.has_key(gr): self.dic_gma[gr] = {'ANGL_VRIL':0.0}
+      vecteurs[gr] = self.get_vecty_group_ma(gr)  
+      if verif == 'oui':
+        if ig > 1 :
+          if not vecteurs_egaux(vecteurs[gr],vect_old) : message = 1
+        vect_old = vecteurs[gr]
+    
+    if message : UTMESS('F','PLEXUS_10',valk=groupes_poutres)   
+    
+    return vecteurs   
+  
+#------------------------------------------------------------------------
+  def orientation_cara_elem(self,):
+    
+    dic_gma = {}
+    etapes = self.CARA_ELEM.etape.valeur
+    
+    if not etapes.has_key('ORIENTATION') : return dic_gma
+         
+    orientation = etapes['ORIENTATION']
+    try :
+      test = orientation [0]
+    except :
+      orientation  = [orientation]
+
+    for ll in orientation  :
+      cara = ll['CARA']
+      if cara in ['ANGL_VRIL','ANGL_NAUT','VECT_Y'] : 
+        if ll.has_key('GROUP_MA') :
+          group_ma = ll['GROUP_MA']
+          if types.TypeType(group_ma) == types.StringType : group_ma = (group_ma,) 
+          a = ll['VALE']
+          for gr in group_ma:
+            if not dic_gma.has_key(gr): dic_gma[gr] = {}
+            dic_gma[gr][cara] = a
+    
+    for gr in dic_gma.keys() :
+      if not dic_gma[gr].has_key('VECT_Y'):
+        if not dic_gma[gr].has_key('ANGL_VRIL') : dic_gma[gr]['ANGL_VRIL'] = 0.0
+        if dic_gma[gr].has_key('ANGL_NAUT'):
+          if len(dic_gma[gr]['ANGL_NAUT']) == 2 : 
+            dic_gma[gr]['ANGL_NAUT'] = list(dic_gma[gr]['ANGL_NAUT']) + [dic_gma[gr]['ANGL_VRIL']]
+          
+    return(dic_gma)
+    
+#------------------------------------------------------------------------
+  def get_vecty_group_ma(self,group_ma):
+    
+    #if debug: print '*'*10
+    #if debug: print 'Test de group_ma',group_ma
+    #if debug: print '*'*10
+
+    message = 0
+
+    if self.dic_gma[group_ma].has_key('VECT_Y') : return self.dic_gma[group_ma]['VECT_Y']
+
+    if not self.dic_gma[group_ma].has_key('ANGL_NAUT'):calcul_angle = 1
+    else: calcul_angle = 0
+
+    mailles = self.MApyt.gma[string.rstrip(group_ma)]
+
+    for imaille in range(len(mailles)):
+      maille = mailles[imaille]
+      if calcul_angle:
+        alpha,beta = self.calcul_angles_naut(maille)
+        angl = [alpha,beta,self.dic_gma[group_ma]['ANGL_VRIL']]
+      else:
+        angl = self.dic_gma[group_ma]['ANGL_NAUT']
+
+      vect_y = self.angle2vecty(angl)
+      if imaille > 1 :  
+        if not vecteurs_egaux(vect_y0,vect_y) : message = 1
+      vect_y0 = vect_y   
+
+    self.dic_gma[group_ma]['VECT_Y'] = vect_y 
+
+    if message : 
+      #if debug: print 'group_ma',group_ma
+      UTMESS('F','PLEXUS_11',valk=group_ma) 
+
+    return vect_y        
+
+#------------------------------------------------------------------------
+  def angle2vecty(self,angl):
+    #transformer en rd
+    for iangl in range(len(angl)):
+      angl[iangl] = N.pi*angl[iangl]/180. 
+ 
+    cosa = math.cos( angl[0] )
+    sina = math.sin( angl[0] )
+    cosb = math.cos( angl[1] )
+    sinb = math.sin( angl[1] )
+    cosg = math.cos( angl[2] )
+    sing = math.sin( angl[2] )
+    vect = [ sing*sinb*cosa - cosg*sina , cosg*cosa + sing*sinb*sina , sing*cosb ]
+    for ii in range(len(vect)):
+      if abs(vect[ii]) <= tst : vect[ii] = 0.0
+    vect = N.array(vect)
+    vect = vect/norme(vect)
+    return vect
+    
+#------------------------------------------------------------------------
+  def get_coor_nodes_maille(self,maille):
+    node1,node2 = self.MApyt.co[maille]
+    coor1 = self.MApyt.cn[node1]
+    coor2 = self.MApyt.cn[node2]
+    return [coor1,coor2]
+    
+#------------------------------------------------------------------------
+  def calcul_angles_naut(self,maille):
+    
+    # Angles directeurs d'une poutre (nautiques)
+    
+    a,b = self.get_coor_nodes_maille(maille)
+
+    gx = [ b[0]-a[0] , b[1]-a[1] , b[2]-a[2] ]
+   
+    if( (abs(gx[1]) < tst)  and (abs(gx[0]) <= tst) ):
+      alpha = 0.0
+    else:
+      alpha = math.atan2(gx[1],gx[0])
+
+    p  = math.sqrt( gx[0]*gx[0] + gx[1]*gx[1] )
+    if( (abs(gx[2]) < tst ) and (abs(p) <=tst) ):
+      beta = 0.0
+    else:
+      beta  = -math.atan2(gx[2],p)
+    
+    # alpha et Beta en degre
+    alpha = alpha*180./math.pi
+    beta = beta*180./math.pi
+    
+    return alpha,beta
+
+#------------------------------------------------------------------------
+#----------------------------- FIN class POUTRE -------------------------
+#------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------
+#----------------------------- class DKT --------------------------------
+#------------------------------------------------------------------------
+
+class DKT:
+
+  def __init__(self,MAILLAGE):
+   
+    self.MAILLAGE = MAILLAGE
+    # recuperer les infos du maillage sous format python 
+    self.MApyt = MAIL_PY()
+    self.MApyt.FromAster(MAILLAGE)
+  
+  def aster2epx(self,groups):
+    
+    # initialisations du dic contenant les mailles de tria3 et quad4
+    dic_groups = {}
+    for cle in ['TRIA3','QUAD4']:
+      dic_groups[cle] = []
+    # placer les mailles dans le champ associe
+    for gr in groups:
+      mailles = self.MApyt.gma[string.rstrip(gr)]
+      for maille in mailles:
+        code_maille = self.MApyt.tm[maille]
+        type_maille = self.MApyt.nom[code_maille]
+        maille_initiale = string.rstrip(self.MApyt.correspondance_mailles[maille]) 
+        if not maille_initiale in dic_groups[type_maille] :
+          dic_groups[type_maille].append(maille_initiale) 
+        
+    # creer le mot-cle facteur permettant de creer les groupes de mailles associes au TRIA3 et QUAD4
+    crea_group_ma = []
+    # dictionnair contenant les noms des groups qui vont etre creer au besoin
+    nom_groups = {}
+    for cle in dic_groups.keys() :
+      if len(dic_groups[cle]) > 0 :
+        crea_group_ma.append({'MAILLE':dic_groups[cle],'NOM':cle})
+        nom_groups[cle] = [cle]
+      else:
+        nom_groups[cle] = []
+    # ce n'est pas necessaire de creer les group_ma si on n'a pas de quad4
+    if len(dic_groups['QUAD4']) >0:
+      
+      #global DEFI_GROUP
+      
+      DEFI_GROUP(reuse         = self.MAILLAGE,
+                 MAILLAGE      = self.MAILLAGE,
+                 CREA_GROUP_MA = crea_group_ma,
+                );
+       
+    else :
+      # on affecte au TRIA les groupes deja fournis en argument
+      nom_groups['TRIA3'] = groups
+    
+    return nom_groups
+      
+#------------------------------------------------------------------------
+#----------------------------- FIN class DKT ----------------------------
+#------------------------------------------------------------------------

diff --git a/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py
new file mode 100644 (file)
index 0000000..eabae05
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py
@@ -0,0 +1,427 @@
+#@ MODIF calc_fonction_ops Macro  DATE 16/11/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.        
+# ======================================================================
+
+import copy
+import traceback
+import os
+from math import pi
+
+
+# -----------------------------------------------------------------------------
+def tocomplex(arg):
+    if arg[0]=='RI' : return complex(arg[1],arg[2])
+    if arg[0]=='MP' : return complex(arg[1]*cos(arg[2]),arg[1]*sin(arg[2]))
+
+
+# -----------------------------------------------------------------------------
+def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP,
+                      SPEC_OSCI,ABS,COMB,COMB_C,COMPOSE,EXTRACTION,
+                      ENVELOPPE,FRACTILE,ASSE,CORR_ACCE,PUISSANCE,INVERSE,
+                      NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE,
+                      PROL_GAUCHE,NOM_PARA_FONC,INTERPOL_FONC,PROL_DROITE_FONC,
+                      PROL_GAUCHE_FONC,INFO,**args):
+   """
+      Ecriture de la macro CALC_FONCTION
+   """
+   ier=0
+   from Cata_Utils.t_fonction import t_fonction, t_fonction_c, t_nappe, homo_support_nappe, \
+            FonctionError, ParametreError, InterpolationError, ProlongementError, enveloppe, fractile
+   from Utilitai import liss_enveloppe
+   from Accas import _F
+   from Cata.cata import nappe_sdaster,fonction_sdaster,fonction_c
+   from Utilitai.Utmess import  UTMESS
+   from Numeric import alltrue,less,array,reshape,cos,sin,exp,sqrt
+   from Numeric import choose,zeros,Float
+   import aster_fonctions
+   EnumTypes = (list, tuple)
+   
+   ### On importe les definitions des commandes a utiliser dans la macro
+   DEFI_FONCTION  = self.get_cmd('DEFI_FONCTION')
+   IMPR_FONCTION  = self.get_cmd('IMPR_FONCTION')
+   DEFI_NAPPE     = self.get_cmd('DEFI_NAPPE')
+   
+   ### Comptage commandes + déclaration concept sortant
+   self.set_icmd(1)
+   self.DeclareOut('C_out',self.sd)
+   
+   # éléments de contexte
+   ctxt = Context()
+   ### l'ensemble est dans un try/except pour recuperer les erreurs du module t_fonction
+   try:
+      ###
+      if (INTEGRE     != None):
+         __ff=INTEGRE['FONCTION'].convert()
+         ctxt.f = __ff.nom
+         if INTEGRE['METHODE']=='TRAPEZE' :
+            __ex=__ff.trapeze(INTEGRE['COEF'])
+         elif INTEGRE['METHODE']=='SIMPSON' :
+            __ex=__ff.simpson(INTEGRE['COEF'])
+      ###
+      if (DERIVE      != None):
+         __ff=DERIVE['FONCTION'].convert()
+         ctxt.f = __ff.nom
+         __ex=__ff.derive()
+      ###
+      if (INVERSE     != None):
+         __ff=INVERSE['FONCTION'].convert()
+         ctxt.f = __ff.nom
+         __ex=__ff.inverse()
+      ###
+      if (ABS         != None): 
+         __ff=ABS['FONCTION'].convert()
+         ctxt.f = __ff.nom
+         __ex=__ff.abs()
+      ###
+      if (COMPOSE     != None): 
+         __ff=COMPOSE['FONC_RESU'].convert()
+         __fg=COMPOSE['FONC_PARA'].convert()
+         ctxt.f = [__ff.nom, __fg.nom]
+         __ex=__ff[__fg]
+      ###
+      if (ASSE        != None):
+         __f0=ASSE['FONCTION'][0].convert()
+         __f1=ASSE['FONCTION'][1].convert()
+         ctxt.f = [__f0.nom, __f1.nom]
+         __ex=__f0.cat(__f1,ASSE['SURCHARGE'])
+      ###
+      if (COMB != None):
+         list_fonc=[]
+         if isinstance(self.sd,nappe_sdaster):
+            for mcfact in COMB :
+               list_fonc.append(mcfact['FONCTION'].convert())
+            ctxt.f = [f.nom for f in list_fonc]
+            list_fonc = homo_support_nappe(list_fonc)
+         elif isinstance(self.sd,fonction_sdaster):
+            for mcfact in COMB :
+               __ex=mcfact['FONCTION'].convert()
+               list_fonc.append(__ex)
+         
+         __ex = 0.
+         for item, comb in zip(list_fonc, COMB):
+            ctxt.f = item.nom
+            __ex = item * comb['COEF'] + __ex
+         # on prend les paramètres de la 1ère fonction
+         __ex.para = copy.copy(list_fonc[0].para)
+      ###
+      if (COMB_C != None):
+         list_fonc=[]
+         if isinstance(self.sd,nappe_sdaster):
+            for mcfact in COMB_C:
+               list_fonc.append(mcfact['FONCTION'].convert())
+            ctxt.f = [f.nom for f in list_fonc]
+            list_fonc = homo_support_nappe(list_fonc)
+         elif isinstance(self.sd,fonction_sdaster) or isinstance(self.sd,fonction_c):
+            for mcfact in COMB_C :
+               __ex=mcfact['FONCTION'].convert(arg='complex')
+               list_fonc.append(__ex)
+      
+         __ex = 0.
+         for item, comb in zip(list_fonc, COMB_C):
+            if comb['COEF_R'] != None:
+               coef = complex(comb['COEF_R'])
+            elif comb['COEF_C'] != None:
+               if type(comb['COEF_C']) in EnumTypes:
+                  coef = tocomplex(comb['COEF_C'])
+               else:
+                  coef = comb['COEF_C']
+            ctxt.f = item.nom
+            __ex = item * coef + __ex
+         # on prend les paramètres de la 1ère fonction
+         __ex.para = copy.copy(list_fonc[0].para)
+      
+      ### mot clé LIST_PARA uniquement présent si COMB ou COMB_C
+      if (COMB != None) or (COMB_C != None) :
+         if (args['LIST_PARA'] != None) :
+            __ex=__ex.evalfonc(args['LIST_PARA'].Valeurs())
+      ###
+      if (PUISSANCE   != None): 
+         __ff=PUISSANCE['FONCTION'].convert()
+         ctxt.f = __ff.nom
+         __ex=__ff
+         for i in range(PUISSANCE['EXPOSANT']-1):
+            __ex=__ex*__ff
+      ###
+      if (EXTRACTION  != None):
+         if EXTRACTION['PARTIE']=='REEL':
+            __ex=EXTRACTION['FONCTION'].convert(arg='real')
+         if EXTRACTION['PARTIE']=='IMAG':
+            __ex=EXTRACTION['FONCTION'].convert(arg='imag')
+         if EXTRACTION['PARTIE']=='MODULE':
+            __ex=EXTRACTION['FONCTION'].convert(arg='modul')
+         if EXTRACTION['PARTIE']=='PHASE':
+            __ex=EXTRACTION['FONCTION'].convert(arg='phase')
+      ###
+      if (ENVELOPPE   != None):
+         list_fonc=[]
+         l_env=ENVELOPPE['FONCTION']
+         if type(l_env) not in EnumTypes:
+            l_env=(l_env,)
+         if isinstance(self.sd,nappe_sdaster):
+            for f in l_env:
+               list_fonc.append(f.convert())
+            ctxt.f = [f.nom for f in list_fonc]
+            list_fonc = homo_support_nappe(list_fonc)
+            vale_para=list_fonc[0].vale_para
+            para     =list_fonc[0].para
+            l_fonc_f =[]
+            for i in range(len(vale_para)):
+               __ff=list_fonc[0].l_fonc[i]
+               for nap in list_fonc[1:] :
+                  ctxt.f = nap.l_fonc[i].nom
+                  __ff=enveloppe([__ff,nap.l_fonc[i]], ENVELOPPE['CRITERE'])
+               l_fonc_f.append(__ff)
+            __ex=t_nappe(vale_para,l_fonc_f,para)
+         elif isinstance(self.sd,fonction_sdaster):
+            for f in l_env:
+               list_fonc.append(f.convert())
+            ctxt.f = [f.nom for f in list_fonc]
+            __ex = enveloppe(list_fonc, ENVELOPPE['CRITERE'])
+      ###
+      if (FRACTILE   != None):
+         list_fonc=[]
+         l_frac=FRACTILE['FONCTION']
+         if type(l_frac) not in EnumTypes:
+            l_frac=(l_frac,)
+         if isinstance(self.sd,nappe_sdaster):
+            for f in l_frac:
+               list_fonc.append(f.convert())
+            ctxt.f = [f.nom for f in list_fonc]
+            list_fonc = homo_support_nappe(list_fonc)
+            vale_para=list_fonc[0].vale_para
+            para     =list_fonc[0].para
+            l_fonc_f =[]
+            for i in range(len(vale_para)):
+               ctxt.f = [nap.l_fonc[i].nom for nap in list_fonc]
+               __ff=fractile([nap.l_fonc[i] for nap in list_fonc], FRACTILE['FRACT'])
+               l_fonc_f.append(__ff)
+            __ex=t_nappe(vale_para,l_fonc_f,para)
+         elif isinstance(self.sd,fonction_sdaster):
+            for f in l_frac:
+               list_fonc.append(f.convert())
+            __ex=list_fonc[0]
+            for f in list_fonc[1:]:
+               ctxt.f = [__ex.nom, f.nom]
+               __ex = fractile(list_fonc, FRACTILE['FRACT'])
+      ###
+      if (CORR_ACCE   != None):
+         __ex=CORR_ACCE['FONCTION'].convert()
+         ctxt.f = __ex.nom
+         para=copy.copy(__ex.para)
+         # suppression de la tendance de l accelero
+         __ex=__ex.suppr_tend()
+         # calcul de la vitesse
+         __ex=__ex.trapeze(0.)
+         # calcul de la tendance de la vitesse : y = a1*x +a0
+         __ex=__ex.suppr_tend()
+         if CORR_ACCE['CORR_DEPL']=='OUI':
+            # suppression de la tendance deplacement
+            # calcul du deplacement : integration
+            __ex=__ex.trapeze(0.)
+            # calcul de la tendance du déplacement : y = a1*x +a0
+            __ex=__ex.suppr_tend()
+            # regeneration de la vitesse : derivation
+            __ex=__ex.derive()
+         # regeneration de l accelero : derivation
+         __ex=__ex.derive()
+         __ex.para=para
+      ###
+      if (FFT         != None):
+         if isinstance(self.sd,fonction_c):
+            __ff=FFT['FONCTION'].convert()
+            ctxt.f = __ff.nom
+            __ex=__ff.fft(FFT['METHODE'])
+         if isinstance(self.sd,fonction_sdaster):
+            __ff=FFT['FONCTION'].convert(arg='complex')
+            ctxt.f = __ff.nom
+            __ex=__ff.fft(FFT['METHODE'],FFT['SYME'])
+      ###
+      if (SPEC_OSCI   != None):
+         if SPEC_OSCI['AMOR_REDUIT']==None:
+            l_amor=[0.02, 0.05, 0.1]
+            UTMESS('I','FONCT0_31',valr=l_amor)
+         else:
+            if type(SPEC_OSCI['AMOR_REDUIT']) not in EnumTypes :
+               l_amor=[SPEC_OSCI['AMOR_REDUIT'],]
+            else:
+               l_amor= SPEC_OSCI['AMOR_REDUIT']
+         if SPEC_OSCI['FREQ']==None and SPEC_OSCI['LIST_FREQ']==None:
+            l_freq=[]
+            for i in range(56):
+               l_freq.append( 0.2+0.050*i)
+            for i in range( 8):
+               l_freq.append( 3.0+0.075*i)
+            for i in range(14):
+               l_freq.append( 3.6+0.100*i)
+            for i in range(24):
+               l_freq.append( 5.0+0.125*i)
+            for i in range(28):
+               l_freq.append( 8.0+0.250*i)
+            for i in range( 6):
+               l_freq.append(15.0+0.500*i)
+            for i in range( 4):
+               l_freq.append(18.0+1.000*i)
+            for i in range(10):
+               l_freq.append(22.0+1.500*i)
+            texte=[]
+            for i in range(len(l_freq)/5) :
+               texte.append(' %f %f %f %f %f' %tuple(l_freq[i*5:i*5+5]))
+            UTMESS('I','FONCT0_32',valk=os.linesep.join(texte))
+         elif SPEC_OSCI['LIST_FREQ']!=None:
+            l_freq=SPEC_OSCI['LIST_FREQ'].Valeurs()
+         elif SPEC_OSCI['FREQ']!=None:
+            if type(SPEC_OSCI['FREQ']) not in EnumTypes:
+               l_freq=[SPEC_OSCI['FREQ'],]
+            else:
+               l_freq= SPEC_OSCI['FREQ']
+         if min(l_freq)<1.E-10 :
+            UTMESS('S','FONCT0_43')
+         if abs(SPEC_OSCI['NORME'])<1.E-10 :
+            UTMESS('S','FONCT0_33')
+         if SPEC_OSCI['NATURE_FONC']!='ACCE' :
+            UTMESS('S','FONCT0_34')
+         if SPEC_OSCI['METHODE']!='NIGAM' :
+            UTMESS('S','FONCT0_35')
+         eps=1.e-6
+         for amor in l_amor :
+            if amor>(1-eps) :
+              UTMESS('S','FONCT0_36')
+         __ff=SPEC_OSCI['FONCTION'].convert()
+         ctxt.f = __ff.nom
+         
+         # appel à SPEC_OSCI
+         spectr = aster_fonctions.SPEC_OSCI(__ff.vale_x, __ff.vale_y, l_freq, l_amor)
+      
+         # construction de la nappe
+         vale_para = l_amor
+         para      = { 'INTERPOL'      : ['LIN','LOG'],
+                       'NOM_PARA_FONC' : 'FREQ',
+                       'NOM_PARA'      : 'AMOR',
+                       'PROL_DROITE'   : 'EXCLU',
+                       'PROL_GAUCHE'   : 'EXCLU',
+                       'NOM_RESU'      : SPEC_OSCI['NATURE'] }
+         para_fonc = { 'INTERPOL'      : ['LOG','LOG'],
+                       'NOM_PARA'      : 'FREQ',
+                       'PROL_DROITE'   : 'CONSTANT',
+                       'PROL_GAUCHE'   : 'EXCLU',
+                       'NOM_RESU'      : SPEC_OSCI['NATURE'] }
+         if   SPEC_OSCI['NATURE']=='DEPL':
+            ideb = 0
+         elif SPEC_OSCI['NATURE']=='VITE':
+            ideb = 1
+         else:
+            ideb = 2
+         l_fonc = []
+         for iamor in range(len(l_amor)) :
+            l_fonc.append(t_fonction(l_freq,spectr[iamor,ideb,:]/SPEC_OSCI['NORME'],para_fonc))
+         __ex=t_nappe(vale_para,l_fonc,para)
+      ###
+      if (LISS_ENVELOP!= None):
+         __ff=LISS_ENVELOP['NAPPE'].convert()
+         sp_nappe=liss_enveloppe.nappe(listFreq=__ff.l_fonc[0].vale_x, listeTable=[f.vale_y for f in __ff.l_fonc], listAmor=__ff.vale_para, entete="")
+         sp_lisse=liss_enveloppe.lissage(nappe=sp_nappe,fmin=LISS_ENVELOP['FREQ_MIN'],fmax=LISS_ENVELOP['FREQ_MAX'],elarg=LISS_ENVELOP['ELARG'],tole_liss=LISS_ENVELOP['TOLE_LISS'])
+         para_fonc=__ff.l_fonc[0].para
+         l_fonc=[]
+         for val in sp_lisse.listTable: 
+            l_fonc.append(t_fonction(sp_lisse.listFreq,val,para_fonc))
+         __ex=t_nappe(vale_para=sp_lisse.listAmor,l_fonc=l_fonc,para=__ff.para)
+
+   except InterpolationError, msg:
+      UTMESS('F', 'FONCT0_27', valk=(ctxt.f, str(msg)))
+   except ParametreError, msg:
+      UTMESS('F', 'FONCT0_28', valk=(ctxt.f, str(msg)))
+   except ProlongementError, msg:
+      UTMESS('F', 'FONCT0_29', valk=(ctxt.f, str(msg)))
+   except FonctionError, msg:
+      UTMESS('F', 'FONCT0_30', valk=(ctxt.f, str(msg), traceback.format_exc()))
+  
+   ### creation de la fonction produite par appel à DEFI_FONCTION
+   ### on récupère les paramètres issus du calcul de __ex
+   ### et on les surcharge par ceux imposés par l'utilisateur
+   
+   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   isinstance(__ex,t_fonction_c): para['VALE_C'] = __ex.tabul()
+      elif isinstance(__ex,t_fonction)  : para['VALE']   = __ex.tabul()
+      C_out=DEFI_FONCTION(**para)
+   elif isinstance(__ex,t_nappe):
+      def_fonc=[]
+      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'],))
+      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 INFO > 1:
+      IMPR_FONCTION(FORMAT='TABLEAU',
+                    UNITE=6,
+                    COURBE=_F(FONCTION=C_out),)
+   return ier
+
+
+# -----------------------------------------------------------------------------
+class Context(object):
+   """Permet de stocker des éléments de contexte pour aider au
+   diagnostic lors de l'émission de message.
+   usage :
+      context = Context()
+      context.f = 'nomfon'
+      print context.f
+   """
+   def __init__(self):
+      self.__nomf = None
+   
+   def get_val(self):
+      """Retourne le texte formatté.
+      """
+      nomf = self.__nomf
+      if type(nomf) not in (list, tuple):
+         nomf = [nomf,]
+      pluriel = ''
+      if len(nomf) > 1:
+         pluriel = 's'
+      try:
+         res = """Fonction%(s)s concernée%(s)s : %(nomf)s""" % {
+            's'    : pluriel,
+            'nomf' : ', '.join(nomf),
+         }
+      except:
+         res = 'erreur de programmation !'
+      return res
+   
+   def set_val(self, value):
+      self.__nomf = value
+   
+   def del_val(self):
+      del self.__nomf
+   
+   f = property(get_val, set_val, del_val, "")

diff --git a/Aster/Cata/cataSTA10/Macro/calc_modal_ops.py b/Aster/Cata/cataSTA10/Macro/calc_modal_ops.py
new file mode 100644 (file)
index 0000000..0a7a1ba
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_modal_ops.py
@@ -0,0 +1,162 @@
+#@ MODIF calc_modal_ops Macro  DATE 27/04/2009   AUTEUR NISTOR I.NISTOR 
+
+#            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.        
+# ======================================================================
+#-*- coding: iso-8859-1 -*-
+
+
+def calc_modal_ops(self,MODELE,CHAM_MATER,CARA_ELEM,AMORTISSEMENT,
+                        SOLVEUR,CHARGE,INST,METHODE,CALC_FREQ, MODE_RIGIDE,
+                        VERI_MODE,INFO,**args):
+  """
+     Ecriture de la macro CALC_MODAL
+  """
+  from Accas import _F
+  ier=0
+  from Utilitai.Utmess     import  UTMESS
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  # Le nom de la variable doit etre obligatoirement le nom de la commande
+  CALC_MATR_ELEM=self.get_cmd('CALC_MATR_ELEM')
+  NUME_DDL      =self.get_cmd('NUME_DDL')
+  ASSE_MATRICE  =self.get_cmd('ASSE_MATRICE')  
+  MODE_ITER_SIMULT  =self.get_cmd('MODE_ITER_SIMULT')
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+
+  # on defini la liste des mots cle pour les appels aux CALC_MATR_ELEM
+  motsclece={}
+  if CHARGE     != None: motsclece['CHARGE']      =CHARGE
+  if CHAM_MATER != None: motsclece['CHAM_MATER']  =CHAM_MATER
+  if CARA_ELEM  != None: motsclece['CARA_ELEM']   =CARA_ELEM
+  if INST       != None: motsclece['INST']        =INST
+
+  #c'est avec le mot cle AMORTISSEMENT qu'on decide si on calcule la matrice C
+  # d'amortissement 
+
+  
+  _a=CALC_MATR_ELEM(MODELE=MODELE, OPTION='RIGI_MECA', **motsclece)
+  _b=CALC_MATR_ELEM(MODELE=MODELE, OPTION='MASS_MECA', **motsclece)
+  if AMORTISSEMENT=='OUI':  
+    _c=CALC_MATR_ELEM(MODELE=MODELE, OPTION='AMOR_MECA',
+                       RIGI_MECA=_a, MASS_MECA=_b,**motsclece)
+
+  #on produit en local le concept NUME_DDL, il n'est pas visible pour l'utilisateur
+  
+  # Les mots cles simples sous SOLVEUR sont par defaut MULT_FRONT/METIS
+  methode=SOLVEUR['METHODE']
+  renum=SOLVEUR['RENUM'] 
+
+  _num=NUME_DDL(MATR_RIGI=_a,METHODE=methode,RENUM=renum,INFO=INFO)
+  
+  #assemblages des matrices 
+  _rigas=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=_num)
+  _masas=ASSE_MATRICE(MATR_ELEM=_b,NUME_DDL=_num)
+  if AMORTISSEMENT=='OUI':     
+    _amoras=ASSE_MATRICE(MATR_ELEM=_c,NUME_DDL=_num)
+
+  #lancement du calcul des modes propres
+  # on defini la liste des mots cle pour l'appel au MODE_ITER_SIMULT
+
+  motscit={}
+  motscfa={}
+
+  if METHODE=='TRI_DIAG':
+     if args.has_key('NMAX_ITER_ORTHO'):
+        motscit['NMAX_ITER_ORTHO'] =args['NMAX_ITER_ORTHO']
+     if args.has_key('PREC_ORTHO'):
+        motscit['PREC_ORTHO']      =args['PREC_ORTHO']
+     if args.has_key('PREC_LANCZOS'):
+        motscit['PREC_LANCZOS']    =args['PREC_LANCZOS']
+     if args.has_key('MAX_ITER_QR'):
+        motscit['NMAX_ITER_QR']    =args['NMAX_ITER_QR']
+  elif METHODE=='JACOBI':
+     if args.has_key('NMAX_ITER_BATHE'):
+        motscit['NMAX_ITER_BATHE'] =args['NMAX_ITER_BATHE']
+     if args.has_key('PREC_BATHE'):
+        motscit['PREC_BATHE']      =args['PREC_BATHE']
+     if args.has_key('NMAX_ITER_JACOBI'):
+        motscit['NMAX_ITER_JACOBI']=args['NMAX_ITER_JACOBI']
+     if args.has_key('PREC_JACOBI'):
+        motscit['PREC_JACOBI']     =args['PREC_JACOBI']
+  elif METHODE=='SORENSEN':
+     if args.has_key('NMAX_ITER_SOREN'):
+        motscit['NMAX_ITER_SOREN'] =args['NMAX_ITER_SOREN']
+     if args.has_key('PARA_ORTHO_SOREN'):
+        motscit['PARA_ORTHO_SOREN']=args['PARA_ORTHO_SOREN']
+     if args.has_key('PREC_SOREN'):
+        motscit['PREC_SOREN']      =args['PREC_SOREN']
+  elif METHODE=='QZ':
+     if args.has_key('TYPE_QZ'):
+        motscit['TYPE_QZ'] =args['TYPE_QZ']
+  
+  if CALC_FREQ['DIM_SOUS_ESPACE']: motscfa['DIM_SOUS_ESPACE']=CALC_FREQ['DIM_SOUS_ESPACE']
+  if CALC_FREQ['COEF_DIM_ESPACE']: motscfa['COEF_DIM_ESPACE']=CALC_FREQ['COEF_DIM_ESPACE']
+  
+  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']
+     
+  motscit['CALC_FREQ'] = _F(OPTION          =CALC_FREQ['OPTION'],
+                            SEUIL_FREQ      =CALC_FREQ['SEUIL_FREQ'],
+                            NPREC_SOLVEUR   =CALC_FREQ['NPREC_SOLVEUR'],
+                            NMAX_ITER_SHIFT =CALC_FREQ['NMAX_ITER_SHIFT'],
+                            PREC_SHIFT      =CALC_FREQ['PREC_SHIFT'],
+                            APPROCHE        =CALC_FREQ['APPROCHE'],
+                            **motscfa)
+
+  motscit['VERI_MODE'] = _F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'],
+                            SEUIL      =VERI_MODE['SEUIL'],
+                            STURM      =VERI_MODE['STURM'],
+                            PREC_SHIFT =VERI_MODE['PREC_SHIFT'])
+
+  motscit['STOP_FREQ_VIDE'] = CALC_FREQ['STOP_FREQ_VIDE']
+
+ 
+  if MODE_RIGIDE=='OUI':
+    mode_rigi='MODE_RIGIDE'
+  elif MODE_RIGIDE=='NON':
+    mode_rigi='SANS' 
+ 
+  self.DeclareOut('modes',self.sd)
+  
+  if AMORTISSEMENT=='NON':
+     modes=MODE_ITER_SIMULT(MATR_A  =_rigas,
+                            MATR_B  =_masas,
+                            METHODE =METHODE,
+                            OPTION  =mode_rigi,
+                            INFO    =INFO,
+                            **motscit)
+  elif AMORTISSEMENT=='OUI':
+     modes=MODE_ITER_SIMULT(MATR_A  =_rigas,
+                            MATR_B  =_masas,
+                            MATR_C  =_amoras,
+                            METHODE =METHODE,
+                            OPTION  =mode_rigi,
+                            INFO    =INFO,
+                            **motscit)
+ 
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/calc_mode_rotation_ops.py b/Aster/Cata/cataSTA10/Macro/calc_mode_rotation_ops.py
new file mode 100644 (file)
index 0000000..c976393
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_mode_rotation_ops.py
@@ -0,0 +1,99 @@
+#@ MODIF calc_mode_rotation_ops Macro  DATE 15/09/2009   AUTEUR TORKHANI M.TORKHANI 
+
+#            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.        
+# ======================================================================
+# RESPONSABLE Mohamed TORKHANI
+
+from Numeric import *
+import aster 
+from Accas import _F
+from types import ListType, TupleType
+from Utilitai.Table import Table
+
+
+def calc_mode_rotation_ops(self,MATR_A, MATR_B, MATR_AMOR, MATR_GYRO,
+                         VITE_ROTA,METHODE,CALC_FREQ,VERI_MODE,**args):
+# Macro pour calculer les frequences et modes en fonction des vitesses de rotation
+# MATR_A, matrice de raideur
+# MATR_B, matrice de masse
+# MATR_AMOR, matrice d'amortissement
+# MATR_GYRO, matrice de gyroscopie
+# VITE_ROTA, liste de vitesses de rotation
+# METHODE, methode de calcul, QZ par defaut ou SORENSEN
+# CALC_FREQ
+# VERI_MODE
+    ier=0
+     
+    # On importe les definitions des commandes a utiliser dans la macro
+    MODE_ITER_SIMULT  =self.get_cmd('MODE_ITER_SIMULT')
+    COMB_MATR_ASSE    =self.get_cmd('COMB_MATR_ASSE')
+    IMPR_RESU         =self.get_cmd('IMPR_RESU')
+    DETRUIRE          =self.get_cmd('DETRUIRE')
+    CREA_TABLE        =self.get_cmd('CREA_TABLE')
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    motscit={}
+    if METHODE=='QZ':
+        motscit['CALC_FREQ']=_F(OPTION  ='PLUS_PETITE',
+                             NMAX_FREQ  =CALC_FREQ['NMAX_FREQ'])                         
+        
+    if METHODE=='SORENSEN':        
+        motscit['CALC_FREQ']=_F(OPTION  ='CENTRE',
+                             NMAX_FREQ  =CALC_FREQ['NMAX_FREQ'],
+                             FREQ       =CALC_FREQ['FREQ'])
+    
+    motscit['VERI_MODE']=_F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'],
+                            SEUIL      =VERI_MODE['SEUIL'],
+                            STURM      =VERI_MODE['STURM'],
+                            PREC_SHIFT =VERI_MODE['PREC_SHIFT'])
+
+    
+    self.DeclareOut('tab_out',self.sd)
+    
+    NBV=len(VITE_ROTA);
+    
+    _mod=[None]*NBV;
+    
+    tab=Table()
+    for ii in range(0,NBV):
+        OM=VITE_ROTA[ii]
+        nom = 'OM_'+str(ii)
+
+        # ----------------------------------
+        # Ajout des effets gyroscopiques w*G
+        # dans la matrice d amortissement C
+        # ----------------------------------
+
+        
+        GYOM=COMB_MATR_ASSE(COMB_R=(_F(MATR_ASSE=MATR_GYRO, COEF_R=OM,),
+                            _F(MATR_ASSE=MATR_AMOR, COEF_R=1.,),))
+
+        _mod[ii]=MODE_ITER_SIMULT(MATR_A=MATR_A,
+                       MATR_B=MATR_B,
+                       MATR_C=GYOM,
+                       METHODE=METHODE,
+                       **motscit)
+        
+        DETRUIRE(CONCEPT=_F(NOM=GYOM),INFO=1,)
+        tab.append({'NUME_VITE' : ii, 'VITE_ROTA' : OM, 'NOM_OBJET': 'MODE_MECA', 'TYPE_OBJET': 'MODE_MECA', 'NOM_SD' : _mod[ii].nom})
+
+    motcles=tab.dict_CREA_TABLE()
+    tab_out=CREA_TABLE(TYPE_TABLE = 'TABLE_CONTENEUR', **motcles);
+    return ier

diff --git a/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py
new file mode 100644 (file)
index 0000000..1b17863
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py
@@ -0,0 +1,459 @@
+#@ MODIF calc_precont_ops Macro  DATE 31/03/2008   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.
+# ======================================================================
+
+
+# RESPONSABLE ASSIRE A.ASSIRE
+
+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,
+                                INFO,TITRE,**args):
+
+
+  """
+     Ecriture de la macro CALC_PRECONT
+  """
+  import copy
+  import aster
+  import string
+  import types
+  from Accas import _F
+  from Noyau.N_utils import AsType
+  from Utilitai.Utmess     import  UTMESS
+  ier=0
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  AFFE_MODELE      = self.get_cmd('AFFE_MODELE')
+  CREA_CHAMP       = self.get_cmd('CREA_CHAMP')
+  AFFE_CHAR_MECA   = self.get_cmd('AFFE_CHAR_MECA')
+  DEFI_LIST_REEL   = self.get_cmd('DEFI_LIST_REEL')
+  STAT_NON_LINE    = self.get_cmd('STAT_NON_LINE')
+  CALC_NO          = self.get_cmd('CALC_NO')
+  CREA_CHAMP       = self.get_cmd('CREA_CHAMP')
+  DEFI_FONCTION    = self.get_cmd('DEFI_FONCTION')
+  RECU_TABLE       = self.get_cmd('RECU_TABLE')
+  DEFI_MATERIAU    = self.get_cmd('DEFI_MATERIAU')
+  AFFE_MATERIAU    = self.get_cmd('AFFE_MATERIAU')
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Le concept sortant (de type evol_noli) est nomme RES dans
+  # le contexte de la macro
+
+  self.DeclareOut('RES',self.sd)
+
+  # -------------------------------------------------------------
+  # 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE
+  # ------------------------------------------------------------
+
+
+  # 1.1 Recuperation de la liste d'instants, de l'instant initial et final
+  #     Creation de la nouvelle liste d'instants
+  # ----------------------------------------------------------
+
+  dIncrement=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
+
+  __prec = dIncrement['PRECISION']
+  __L0   = dIncrement['LIST_INST']
+  __L1   = __L0.Valeurs()
+
+  # Traitement de l'etat initial
+  if ETAT_INIT:
+      dEtatInit=ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste)
+      for i in dEtatInit.keys():
+          if dEtatInit[i]==None : del dEtatInit[i]
+
+      __EVINIT = dEtatInit['EVOL_NOLI']
+  else :
+      dEtatInit=None
+
+  # Test de la presence de reuse=
+  if self.reuse == None:
+      dReuse=None
+  else :
+      dReuse='RES'
+
+  # Teste si INST_INIT est donné ou bien recalcule __TMIN
+  if dIncrement['INST_INIT'] == None:
+    if self.reuse == None:
+      __TMIN = __L1[0]
+    else:
+      __dico = __EVINIT.LIST_VARI_ACCES()
+      __TMIN = __dico['INST'][-1]
+  else:
+    __TMIN = dIncrement['INST_INIT']
+
+  # Teste si INST_FIN est donné ou bien recalcule __TMAX
+  if dIncrement['INST_FIN'] == None:
+    __TMAX = __L1[-1]
+  else:
+    __TMAX = dIncrement['INST_FIN']
+
+  # Teste si INST_INIT est bien plus petit que INST_FIN
+  if __TMAX <= __TMIN:
+    UTMESS('F','CABLE0_1')
+
+  # Cree la liste d'instant __L2 allant de __TMIN a __TMAX et contenant
+  # un instant supplementaire __TINT
+  __L2=[]
+  for m in __L1:
+    if m>=__TMIN and m<=__TMAX:
+      __L2.append(m)
+
+  __TINT = (9.*__L2[-1] + __L2[-2])/10.
+  __L2[-1:-1] = [__TINT]
+
+  # __LST0 est la liste d'instants utilisée pour l'etape 1
+  __LST0=DEFI_LIST_REEL( DEBUT = __TMIN,
+                        INTERVALLE = _F(JUSQU_A = __TMAX, NOMBRE = 1),)
+
+  # __LST et __FCT sont utilisés pour les etapes 2 et 3
+  __LST=DEFI_LIST_REEL(VALE=__L2,);
+  __FCT=DEFI_FONCTION(INTERPOL=('LIN','LIN'),
+                         NOM_PARA='INST',
+                         VALE=(__TMIN,0.0,__TINT,1.0,__TMAX,1.0),);
+
+  for i in dIncrement.keys():
+      if dIncrement[i]==None : del dIncrement[i]
+  dIncrement['LIST_INST']= __LST
+  dIncrement['INST_FIN'] = __TINT
+
+
+
+  # 1.2 Recuperation des parametres pour STAT_NON_LINE
+  # -------------------------------------------------------
+
+  dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
+  for i in dNewton.keys():
+      if dNewton[i]==None : del dNewton[i]
+
+  dConvergence=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+  for i in dConvergence.keys():
+      if dConvergence[i]==None : del dConvergence[i]
+
+  dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+  for i in dSolveur.keys():
+      if dSolveur[i]==None : del dSolveur[i]
+
+  if RECH_LINEAIRE:
+    dRech_lin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste)
+    for i in dRech_lin.keys():
+        if dRech_lin[i]==None : del dRech_lin[i]
+  else :
+    dRech_lin=None
+
+
+  # 1.3 Creation des mots-cles pour les 3 AFFE_CHAR_MECA
+  #     Recuperation des cables dans les concepts CABLE_BP
+  #     et CABLE_BP_INACTIF
+  # ------------------------------------------------------
+  if type(CABLE_BP) is not types.NoneType:
+    if type(CABLE_BP) is not types.TupleType:
+      CABLE_BP0 = CABLE_BP
+      CABLE_BP = []
+      CABLE_BP.append ( CABLE_BP0 )
+
+  if type(CABLE_BP_INACTIF) is not types.NoneType:
+    if type(CABLE_BP_INACTIF) is not types.TupleType:
+      CABLE_BP_INACTIF0 = CABLE_BP_INACTIF
+      CABLE_BP_INACTIF = []
+      CABLE_BP_INACTIF.append ( CABLE_BP_INACTIF0 )
+
+  motscles={}
+  motscles['RELA_CINE_BP']=[]
+  motscle2={}
+  motscle2['RELA_CINE_BP']=[]
+  motscle3={}
+  motscle3['RELA_CINE_BP']=[]
+  __GROUP_MA_A=[]
+  Result = [[None]*1]
+  for mcabl in CABLE_BP:
+    # Creation de mots-cles pour les AFFE_CHAR_MECA
+    motscles['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
+                                       SIGM_BPEL = 'OUI',
+                                       RELA_CINE = 'NON',) )
+    motscle2['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
+                                       SIGM_BPEL = 'NON',
+                                       RELA_CINE = 'OUI',) )
+    motscle3['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
+                                       SIGM_BPEL = 'OUI',
+                                       RELA_CINE = 'OUI',) )
+
+    # Creation de __GROUP_MA_A : liste des noms des cables contenus
+    # dans chaque concept CABLE_BP = cables  a activer
+    __TCAB = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP');
+    __nb = 0
+    while 1:
+      try:
+          Result[__nb][0] = __TCAB['NOM_CABLE',__nb+1]
+          __CAB = __TCAB['NOM_CABLE',__nb+1]
+          if __nb == 0:
+            __GROUP_MA_A.append(__CAB)
+          else:
+            i = 0
+            # enlève les doublons
+            for m in __GROUP_MA_A:
+              i=i+1
+              if __CAB == m:
+                break
+              if i == len(__GROUP_MA_A):
+                __GROUP_MA_A.append(__CAB)
+
+          __nb = __nb + 1
+          Result.append([None]*1)
+    #   Si on a lu toutes les valeurs alors on sort de la boucle
+      except KeyError:
+        break
+
+  # Creation de __GROUP_MA_I : liste des noms des cables contenus
+  # dans chaque CABLE_BP_INACTIF
+  # __GROUP_MA_CABLE = liste des cables actifs et inactifs
+  Result = [[None]*1]
+  __GROUP_MA_I=[]
+
+  if CABLE_BP_INACTIF:
+    for mcabl in CABLE_BP_INACTIF:
+      __TCA0 = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP');
+      __nb = 0
+      while 1:
+        try:
+            Result[__nb][0] = __TCA0['NOM_CABLE',__nb+1]
+            __CA0 = __TCA0['NOM_CABLE',__nb+1]
+            if __nb == 0:
+              __GROUP_MA_I.append(__CA0)
+            else:
+              i = 0
+              # enlève les doublons
+              for m in __GROUP_MA_I:
+                i=i+1
+                if __CA0 == m:
+                  break
+                if i == len(__GROUP_MA_I):
+                  __GROUP_MA_I.append(__CA0)
+
+            __nb = __nb + 1
+            Result.append([None]*1)
+      #   Si on a lu toutes les valeurs alors on sort de la boucle
+        except KeyError:
+          break
+    motscle6={}
+    motscle6['RELA_CINE_BP']=[]
+    for mcabl in CABLE_BP_INACTIF:
+      # Creation de mots-cles pour les AFFE_CHAR_MECA
+      motscle6['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
+                                         SIGM_BPEL = 'NON',
+                                         RELA_CINE = 'OUI',) )
+
+  __GROUP_MA_CABLES = __GROUP_MA_A + __GROUP_MA_I
+
+
+  # 1.4 Creation des mots-clés facteurs COMP_INCR
+  # pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1)
+  # ------------------------------------------------------
+
+  dComp_incr=[]
+  for j in COMP_INCR :
+      dComp_incr.append(j.cree_dict_valeurs(j.mc_liste))
+      for i in dComp_incr[-1].keys():
+          if dComp_incr[-1][i]==None : del dComp_incr[-1][i]
+
+  PARM_THETA=0.
+  for j in range(len(COMP_INCR)) :
+     if dComp_incr[j]['RELATION'] == 'ELAS':
+        PARM_THETA=dComp_incr[j]['PARM_THETA']
+
+  if PARM_THETA == 0:
+    PARM_THETA=dComp_incr[0]['PARM_THETA']
+
+  dComp_incr0=copy.copy(dComp_incr)
+  dComp_incr1=copy.copy(dComp_incr)
+
+  dComp_incr0.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_CABLES,) )
+  if __GROUP_MA_I:
+    dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I,) )
+
+
+  # 1.5 Modele contenant uniquement les cables de precontrainte
+  # ---------------------------------------------------------
+
+  __MOD = string.ljust(MODELE.nom,8)
+  __MOD =__MOD+'.MODELE    .LGRF        '
+  __LMAIL = aster.getvectjev(__MOD)
+  __MAIL  = string.strip(__LMAIL[0])
+
+  objma=self.get_sd_avant_etape(__MAIL,self)
+
+  __M_CA=AFFE_MODELE( MAILLAGE=objma,
+                       AFFE    =_F( GROUP_MA     = __GROUP_MA_A,
+                                    PHENOMENE    = 'MECANIQUE',
+                                    MODELISATION = 'BARRE') )
+
+
+  # 1.6 Blocage de tous les noeuds des cables actifs
+  # --------------------------------------------------
+
+  _B_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
+                        DDL_IMPO= _F( GROUP_MA = __GROUP_MA_A,
+                                      DX = 0.,
+                                      DY = 0.,
+                                      DZ = 0.),)
+
+
+  # 1.7 Chargements concernant les cables
+  # -------------------------------------
+  _C_CN=AFFE_CHAR_MECA(MODELE=__M_CA,**motscles)
+  _C_CA=AFFE_CHAR_MECA(MODELE=MODELE,**motscle2)
+  _C_CT=AFFE_CHAR_MECA(MODELE=MODELE,**motscle3)
+  if CABLE_BP_INACTIF:
+    _C_CI=AFFE_CHAR_MECA(MODELE=MODELE,**motscle6)
+
+
+
+  # -------------------------------------------------------------
+  # 2. CALCULS
+  # ------------------------------------------------------------
+
+
+  #-------------------------------------------------------------------
+  # 2.1 Premiere etape : calcul sur le(s) cable(s) et
+  #     recuperation des _F_CAs aux noeuds
+  #     on travaile entre tmin et tmax
+  #-------------------------------------------------------------------
+
+  __EV1=STAT_NON_LINE(
+                         MODELE     = __M_CA,
+                         CHAM_MATER = CHAM_MATER,
+                         CARA_ELEM  = CARA_ELEM,
+                         EXCIT      =(_F(CHARGE = _B_CA),
+                                      _F(CHARGE = _C_CN),),
+                         COMP_INCR  =_F( RELATION = 'ELAS',
+                                         DEFORMATION = 'PETIT',
+                                         PARM_THETA = PARM_THETA,
+                                         TOUT = 'OUI'),
+                         INCREMENT  =_F(LIST_INST = __LST0,
+                                        PRECISION = __prec),
+                         SOLVEUR = dSolveur,
+                         INFO     =INFO,
+                         TITRE = TITRE,  )
+
+  __EV1 = CALC_NO( reuse    = __EV1,
+                   RESULTAT = __EV1,
+                   GROUP_MA = __GROUP_MA_A,
+                   OPTION = 'FORC_NODA' )
+
+  __REA = CREA_CHAMP (
+                     TYPE_CHAM = 'NOEU_DEPL_R',
+                     OPERATION = 'EXTR',
+                     RESULTAT  =  __EV1,
+                     NOM_CHAM  = 'FORC_NODA',
+                     INST      = __TMAX);
+
+  __REAC = CREA_CHAMP (TYPE_CHAM='NOEU_DEPL_R',
+                     OPERATION = 'ASSE',
+                     MODELE    = MODELE,
+                     ASSE= _F(GROUP_MA=__GROUP_MA_A,
+                              CHAM_GD=__REA,
+                              COEF_R = -1.), )
+
+  _F_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
+                          VECT_ASSE = __REAC )
+
+
+
+  #-----------------------------------------------------------------------
+  # 2.2 Deuxieme etape : application de la precontrainte sur le beton
+  #     en desactivant les cables
+  #-----------------------------------------------------------------------
+
+  # Regeneration des mots-cles EXCIT passés en argument de la macro
+  dExcit=[]
+  for j in EXCIT :
+      dExcit.append(j.cree_dict_valeurs(j.mc_liste))
+      for i in dExcit[-1].keys():
+          if dExcit[-1][i]==None : del dExcit[-1][i]
+
+  if CABLE_BP_INACTIF:
+    dExcit.append(_F(CHARGE=_C_CI),)
+
+  # Creation du mots-cle EXCIT pour le STAT_NON_LINE
+  dExcit1=copy.copy(dExcit)
+  dExcit1.append(_F(CHARGE=_C_CA),)
+  dExcit1.append(_F(CHARGE = _F_CA,
+                    FONC_MULT=__FCT ),)
+
+  motscle4={}
+  if dReuse: motscle4['reuse']=[]
+  else:      motscle4['reuse']=dReuse
+
+
+  RES=STAT_NON_LINE(
+                     MODELE      =MODELE,
+                     CARA_ELEM   =CARA_ELEM,
+                     CHAM_MATER  = CHAM_MATER,
+                     COMP_INCR=dComp_incr0,
+                     INCREMENT=dIncrement,
+                     ETAT_INIT = dEtatInit,
+                     NEWTON =dNewton,
+                     CONVERGENCE=dConvergence,
+                     RECH_LINEAIRE = dRech_lin,
+                     SOLVEUR = dSolveur,
+                     ARCHIVAGE = _F(INST = __TINT),
+                     INFO     =INFO,
+                     TITRE = TITRE,
+                     EXCIT = dExcit1,
+                     **motscle4)
+
+  # Recuperation du dernier numero d'ordre pour pouvoir  l'écraser dans RES
+  __dico2 = RES.LIST_VARI_ACCES()
+  __no = __dico2['NUME_ORDRE'][-1]
+
+
+  #-----------------------------------------------------------------------
+  # 2.2 Troisieme etape : on remet la tension dans les cables
+  #-----------------------------------------------------------------------
+
+  # Creation du mots-cles EXCIT pour le STAT_NON_LINE
+  dExcit2=copy.copy(dExcit)
+  dExcit2.append(_F(CHARGE=_C_CT,) )
+
+  # Calcul sur un seul pas (de __TINT a __TMAX)
+  RES=STAT_NON_LINE( reuse      = RES,
+                     ETAT_INIT  = _F(EVOL_NOLI =RES),
+                     MODELE     = MODELE,
+                     CHAM_MATER = CHAM_MATER,
+                     CARA_ELEM  = CARA_ELEM,
+                     COMP_INCR=dComp_incr1,
+                     INCREMENT=_F(LIST_INST = __LST,
+                                  PRECISION = __prec),
+                     NEWTON =dNewton,
+                     RECH_LINEAIRE = dRech_lin,
+                     CONVERGENCE=dConvergence,
+                     SOLVEUR = dSolveur,
+                     ARCHIVAGE = _F(NUME_INIT = __no,
+                                    DETR_NUME_SUIV = 'OUI' ),
+                     INFO  =INFO,
+                     TITRE = TITRE,
+                     EXCIT =dExcit2,
+                     )
+
+  return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/calc_spec_ops.py b/Aster/Cata/cataSTA10/Macro/calc_spec_ops.py
new file mode 100644 (file)
index 0000000..a6d669f
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_spec_ops.py
@@ -0,0 +1,419 @@
+#@ MODIF calc_spec_ops Macro  DATE 21/10/2008   AUTEUR CORUS M.CORUS 
+
+#            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.        
+# ======================================================================
+
+import copy
+import types
+from SD.sd_fonction import sd_fonction
+
+# -----------------------------------------------------------------------------
+class FonctionError(Exception): pass
+class ParametreError(FonctionError):      pass  # probleme de NOM_PARA
+class InterpolationError(FonctionError):  pass
+class ProlongementError(FonctionError):   pass
+
+# -----------------------------------------------------------------------------
+
+
+def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args):
+#  ------------------------------------------------------------------
+#  Calcul d'une matrice interspectrale
+#  a partir de fonctions reelles
+
+   import aster
+   from types import ListType, TupleType
+   EnumTypes = (ListType, TupleType)
+   from Accas               import _F
+   from Utilitai.Utmess     import  UTMESS
+   import Numeric
+   import FFT
+   
+   commande='CALC_SPEC'
+
+   ier = 0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # Le concept sortant (de type table_sdaster ou derive) est tab
+   self.DeclareOut('tabout', self.sd)
+   
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   CREA_TABLE    = self.get_cmd('CREA_TABLE')
+   CALC_TABLE    = self.get_cmd('CALC_TABLE')
+   DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
+
+#--- Verifications sur les entrees --#
+
+   if (ECHANT==None and TAB_ECHANT==None) : 
+      raise FonctionError, 'Vous devez specifier des fonctions en entree'
+
+   if TAB_ECHANT==None : TAB_ECHANT=[]
+   if ECHANT==None : ECHANT=[]
+   if INTERSPE==None : INTERSPE=[]
+   if TRANSFERT==None : TRANSFERT=[]
+   if len(TAB_ECHANT)*len(ECHANT) !=0 :
+      raise FonctionError, 'Vous pouvez specifier une table_fonction ou' + ' une liste de fonctions en entree, mais pas les deux'
+   if len(TRANSFERT)*len(INTERSPE) !=0 :
+      raise FonctionError, 'Vous ne pouvez specifier qu' +"'"+'un type de calcul par appel'
+   
+   
+   
+#-- Recuperation des entrees --#  
+
+   l_f=[]
+   l_t=[]
+   l_G=[]
+   l_H=[]
+#   for occ in TAB_ECHANT : 
+#      l_t.append(('TAB_ECHANT',occ))   
+   if TAB_ECHANT:  #MC
+      l_t = TAB_ECHANT.List_F()[0]
+
+   for occ in ECHANT : 
+      l_f.append(('ECHANT',occ))
+   for occ in INTERSPE : 
+      l_G.append(('INTERSPE',occ))
+   for occ in TRANSFERT : 
+      l_H.append(('TRANSFERT',occ))
+      
+   
+# Pour dimensionner les fenetres :
+# Cas ECHANT : on recupere simplement la premiere fonction
+# Cas_TAB_ECHANT : on recupere toutes les fonctions
+   
+   if len(l_f) >0 :
+      vale_sig=l_f[0][1]['FONCTION'].Valeurs(); 
+      l_ech=len(vale_sig[0])
+      dt=vale_sig[0][1]-vale_sig[0][0]
+   else :
+      #tab_ast=l_t[0][1]['NOM_TAB'];
+      tab_ast=l_t['NOM_TAB']  #MC
+      tab_py=tab_ast.EXTR_TABLE();
+      
+      nom_fonc= tab_py['FONCTION'].values()['FONCTION']
+      fonc_py = [sd_fonction(fonc) for fonc in nom_fonc]
+      temp=fonc_py[0].VALE.get();
+      dt=temp[1]-temp[0];
+      
+      l_ech_temp=l_t['LONGUEUR_ECH'];
+      recouvr_temp=l_t['RECOUVREMENT'];
+      l_ech_t=[l_ech_temp[0]['DUREE'] , l_ech_temp[0]['POURCENT'],l_ech_temp[0]['NB_PTS'] ];
+      recouvr_t=[recouvr_temp[0]['DUREE'] , recouvr_temp[0]['POURCENT'],recouvr_temp[0]['NB_PTS'] ];
+      if l_ech_t.count(None)==3 : l_ech=len(temp)/2;
+      if recouvr_t.count(None)==3 : recouvr=0;
+      if l_ech_t.count(None)<2 : 
+         raise FonctionError, 'Vous ne pouvez utiliser qu'+"'"+ 'un mot clef pour definir la longueur des echantillons'
+      if recouvr_t.count(None)<2 : 
+         raise FonctionError, 'Vous ne pouvez utiliser qu'+"'"+'un mot clef pour definir la longueur de recouvrement des echantillons'
+      for i1 in range(3) :
+          if l_ech_t[i1] !=None :
+             if   i1 == 0 : 
+                l_ech=int(Numeric.floor(l_ech_t[i1]/dt));
+             elif i1 == 1 :
+                l_ech=int(Numeric.floor((len(temp)/2)*l_ech_t[i1]*0.01));
+             elif i1 == 2 :
+                l_ech=int(Numeric.floor(l_ech_t[i1]))
+      if l_ech > len(temp)/2 :
+         raise FonctionError, 'Vous devez specifier une longueur d'+"'"+'echantillon inferieure a la longueur totale de l'+"'"+'acquisition'
+      for i1 in range(3) :
+          if recouvr_t[i1] !=None :
+             if   i1 == 0 : 
+                recouvr=int(Numeric.floor(recouvr_t[i1]/dt));
+             elif i1 == 1 :
+                recouvr=int(Numeric.floor((l_ech)*recouvr_t[i1]*0.01));
+             elif i1 == 2 :
+                recouvr=int(Numeric.floor(recouvr_t[i1]))
+      if recouvr > l_ech :
+         raise FonctionError, 'La longueur de recouvrement ne peut exceder la longueur '
+
+#-- Recuperation des fenetres
+
+   for occ in l_G+l_H :
+      if occ[1]['FENETRE'] == 'RECT' :
+         fene=[1.]*l_ech
+      elif occ[1]['FENETRE'] == 'HAMM' :
+         fene=[0.54-0.46*Numeric.cos(2*Numeric.pi*i1/(l_ech-1)) for i1 in range(l_ech)]
+      elif occ[1]['FENETRE'] == 'HANN' :
+         fene=[0.5-0.5*Numeric.cos(2*Numeric.pi*i1/(l_ech-1)) for i1 in range(l_ech)]
+      elif occ[1]['FENETRE'] == 'EXPO' :
+         para=occ[1]['DEFI_FENE']
+         if len(para) != 2 :
+            raise FonctionError, 'Erreur de taille dans DEFI_FENE : ' + 'la fenetre exponentielle est definie par exactement deux valeurs'
+         fene=[1.]*int(para[0]-1)+[Numeric.exp(para[1]*(i1-int(para[0]-1))*dt) for i1 in range(int(para[0]-1),l_ech)]
+      elif occ[1]['FENETRE'] == 'PART' :
+         fene=occ[1]['DEFI_FENE']
+         if len(fene) != l_ech :
+            raise FonctionError, 'Erreur de taille dans DEFI_FENE : ' + 'La fenetre doit etre definie avec le meme nombre de points que les echantillons'
+   
+   if len(TRANSFERT)+len(INTERSPE) == 0 : #-- on ne rentre rien : interspectre par defaut - fenetre rectangulaire
+      fene=[1.]*l_ech
+      INTERSPE=1.;
+      
+      
+#--          Recuperation des signaux           --#
+#-- Verifications et transformations de Fourier --#
+#--         Entrees sous formes de table        --#
+      
+   tmp=[];
+   lt=[];
+   frq=[];
+   fft=[];
+   df=[];
+   num_ord=[];
+   num_mes=[]; 
+   
+   
+   if TAB_ECHANT : # Cas TAB_ECHANT
+      num_mes_temp= tab_py['NUME_MES'].values()['NUME_MES']
+      max_mes=Numeric.maximum.reduce(num_mes_temp);
+      num_ord_temp= tab_py['NUME_ORDRE_I'].values()['NUME_ORDRE_I']
+      long_fonc=[len(fonc_py[i1].VALE.get()) for i1 in range(len(fonc_py))]
+      
+      N_fen=int(Numeric.floor((Numeric.minimum.reduce(long_fonc)/2-l_ech)/(l_ech-recouvr))+1)
+
+      sig=[]; 
+      dt=[];    
+      for i1 in range(len(fonc_py)) :
+         vale=fonc_py[i1].VALE.get();
+         temp=(list(vale[0:int(len(vale)/2)]));
+         sig.append(list(vale[int(len(vale)/2):]));
+         test_pas=Numeric.subtract(temp[1:],temp[0:-1])
+         crit=test_pas.tolist();
+         crit.sort();
+         dt.append(crit[-1]);
+         if abs((crit[-1]-crit[0])/crit[-1]) > 1.e-5 :
+            raise FonctionError, 'L'+"'"+'echantillonage doit etre fait a pas constant'
+
+      for j1 in range(N_fen) :
+         for i1 in range(len(fonc_py)) :
+            fft.append(FFT.fft(Numeric.multiply(sig[i1][j1*(l_ech-recouvr):(j1*(l_ech-recouvr)+l_ech)],fene)))
+            if j1 == 0 : df.append(1./(dt[i1])/l_ech);
+            num_mes.append(num_mes_temp[i1]+max_mes*j1);
+            num_ord.append(num_ord_temp[i1]); 
+
+      test_df=Numeric.subtract(df[1:],df[0:-1])
+      test_df=test_df.tolist();
+      test_df.sort();
+      if abs(test_df[-1]) > 1.e-5 :
+         raise FonctionError, 'Toutes les fonctions doivent etre definies ' + 'avec la meme frequence d'+"'"+'echantillonage'
+       
+      frq = [df[-1]*i1 for i1 in range(l_ech)]
+
+
+#--          Recuperation des signaux           --#
+#-- Verifications et transformations de Fourier --#
+#--         Entrees sous formes de fonction     --#
+
+   if ECHANT:
+      for occ in l_f :
+         vale_sig=occ[1]['FONCTION'].Valeurs();
+         #-- pour les tests ulterieurs --#
+         lt.append(len(vale_sig[0]))    
+         if len(vale_sig[0]) != len(vale_sig[1]) :
+            raise FonctionError, 'Les vecteurs associes au temps '+'et aux echantillons doivent etre de meme longueur'      
+         num_mes.append(occ[1]['NUME_MES'])
+         num_ord.append(occ[1]['NUME_ORDRE_I'])
+      
+         tmp.append(vale_sig[0])
+         test_pas=Numeric.subtract(vale_sig[0][1:],vale_sig[0][0:-1])
+         crit=test_pas.tolist();
+         crit.sort();
+         if abs((crit[-1]-crit[0])/crit[-1]) > 1.e-5 :
+            raise FonctionError, 'L'+"'"+'echantillonage doit etre fait a pas constant'
+         fft.append(FFT.fft(Numeric.multiply(vale_sig[1],fene)))
+         df.append(1./(crit[-1])/len(vale_sig[0]));
+      
+      
+      #-- Verification des longueurs --#      
+      
+      test_long=Numeric.subtract(lt[1:],lt[0:-1])
+      test_long=test_long.tolist();
+      test_long.sort();
+      if (test_long[-1]-test_long[0]) != 0 :
+         raise FonctionError, 'Toutes les fonctions doivent etre definies avec le meme nombre de points'
+   
+   
+      test_df=Numeric.subtract(df[1:],df[0:-1])
+      test_df=test_df.tolist();
+      test_df.sort();
+      if abs(test_df[-1]) > 1.e-5 :
+         raise FonctionError, 'Toutes les fonctions doivent etre definies '+'avec la meme frequence d'+"'"+'echantillonage'
+       
+      frq = [df[-1]*i1 for i1 in range(lt[-1])]
+   
+   
+#-- index des numeros d'ordre pour le moyennage
+
+   uu=[];
+   vv=[];
+   uu=uu+num_ord;
+   vv=vv+num_ord;
+   uu.sort();
+   ind_ord=[];
+   list_ord=[];
+   while  len(uu) > 0 :
+      list_ord.append(uu[0])
+      tt=[];
+      for i1 in range(uu.count(uu[0])) : 
+         tt.append(vv.index(uu[0]))
+         vv[tt[-1]]=0
+      ind_ord.append(tt)
+      uu=uu[int(uu.count(uu[0])):]  
+   
+#-- Calcul de la matrice inter spectrale
+
+   if len(INTERSPE) != 0 :
+      dimh   = (len(list_ord)*(len(list_ord)+1))/2
+      l_fc=[];
+      nume_i1=[]
+      nume_j1=[]
+      
+      for i1 in range(len(list_ord)) :
+         for j1 in range(i1,len(list_ord)) :
+            #-- on ne calcule les spectres que pour des numeros de mesures correspondants
+            #-- Ca n'a a priori pas de sens de calculer l'interspectre entre deux signaux acquis a des instants differents
+            #-- Par contre, on peut moyenner deux interspectres obtenus a des instants differents, sous reserve
+            #-- de stationnarite et d'ergodicite du signal
+            mes_i1=[num_mes[k1] for k1 in ind_ord[i1]]
+            mes_j1=[num_mes[k1] for k1 in ind_ord[j1]]
+            ind_mes=[];
+            #-- recuperation des indices des fft a prendre en compte pour l'interspectre
+            for k1 in range(len(mes_i1)) :
+               if mes_i1[k1] in mes_j1 :
+                  ind_mes.append([ind_ord[i1][k1],ind_ord[j1][mes_j1.index(mes_i1[k1])]])
+
+            #-- Calcul des interspectres   
+            dsp=[0.j]*l_ech;
+            if len(ind_mes) > 0 :   
+               for l1 in range(len(ind_mes)) :
+                  dsp_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][1]])
+                  dsp_t=Numeric.divide(dsp_t,l_ech*len(ind_mes))
+                  dsp=Numeric.add(dsp,dsp_t)
+               dsp=dsp.tolist();
+               dsp_r=[];
+       
+               for k1 in range(int(Numeric.floor(l_ech/2))) :
+                  dsp_r=dsp_r+[frq[k1],dsp[k1].real,dsp[k1].imag]
+    
+               _fonc = DEFI_FONCTION(NOM_PARA='FREQ',VALE_C=dsp_r,);
+               l_fc.append(_fonc.nom)
+               nume_i1.append(list_ord[i1])
+               nume_j1.append(list_ord[j1])
+   
+      mcfact=[]
+      mcfact.append(_F(PARA='NOM_CHAM'    ,LISTE_K='DSP'  ))
+      mcfact.append(_F(PARA='OPTION'      ,LISTE_K='TOUT' ))
+      mcfact.append(_F(PARA='DIMENSION'   ,LISTE_I=(dimh,) ))
+      mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i1 ))
+      mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j1 ))
+      mcfact.append(_F(PARA='FONCTION_C'  ,LISTE_K=l_fc  ))
+      self.DeclareOut('tab_inte',self.sd)
+      tab_inte=CREA_TABLE(LISTE=mcfact,
+                          TITRE='',
+                          TYPE_TABLE='TABLE_FONCTION')
+
+
+#-- Calcul des transferts
+
+   if len(TRANSFERT) != 0 :
+      
+      l_fc=[];
+      nume_i1=[]
+      nume_j1=[]
+      
+      #-- test sur les entrees pour les references --#
+      if type(l_H[0][1]['REFER'])==int :
+         refer=[];
+         refer.append(l_H[0][1]['REFER'])
+      elif type(l_H[0][1]['REFER'])==tuple :
+         refer=list(l_H[0][1]['REFER'])
+ 
+      ind_refer=[];
+      dimh   = len(refer)*(len(list_ord)-len(refer))
+      for k1 in range(len(refer)) :
+         for l1 in range(len(list_ord)) :
+            if refer[k1] == list_ord[l1] : ind_refer.append(l1);
+
+      #-- H1 : interspectre / autospectre
+      #-- H2 : autospectre / interspectre
+      #-- CO : coherence entre H1 et H2. 
+      
+      if l_H[0][1]['ESTIM']!='HV' :
+         for i1 in range(len(refer)) :
+            for j1 in range(len(list_ord)) : 
+               if refer[i1] != list_ord[j1] :
+                  mes_i1=[num_mes[k1] for k1 in ind_ord[ind_refer[i1]]]  #-- mesures des efforts 
+                  mes_j1=[num_mes[k1] for k1 in ind_ord[j1]]  #-- mesures des reponses
+                  ind_mes=[];
+                  #-- recuperation des indices des mesures a predre en compte pour les spectres
+                  for k1 in range(len(mes_i1)) :
+                     if mes_i1[k1] in mes_j1 :
+                        ind_mes.append([ind_ord[i1][k1],ind_ord[j1][mes_j1.index(mes_i1[k1])]])
+
+                  #-- Calcul des FRF
+                  Guu=[0.j]*l_ech;
+                  Gyy=[0.j]*l_ech;
+                  Gyu=[0.j]*l_ech;
+                  if len(ind_mes) > 0 :   
+                     for l1 in range(len(ind_mes)) :
+                        Guu_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][0]])
+                        Guu=Numeric.add(Guu,Guu_t)
+                        Gyu_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][0]])
+                        Gyu=Numeric.add(Gyu,Gyu_t)
+                        Gyy_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][1]])
+                        Gyy=Numeric.add(Gyy,Gyy_t)
+
+                     if l_H[0][1]['ESTIM']=='H1' :
+                        frf=Numeric.divide(Numeric.conjugate(Gyu),Guu);
+                        nom_frf='FRF-H1';
+                     elif l_H[0][1]['ESTIM']=='H2' :
+                        frf=Numeric.divide(Gyy,Gyu);
+                        nom_frf='FRF-H2';
+                     elif l_H[0][1]['ESTIM']=='CO' :
+                        H1=Numeric.divide(Numeric.conjugate(Gyu),Guu);
+                        H2=Numeric.divide(Gyy,Gyu);
+                        frf=Numeric.divide(H1,H2);
+                        nom_frf='FRF-COH';
+
+                     frf=frf.tolist();
+                     frf_r=[];
+
+                     for k1 in range(int(Numeric.floor(l_ech/2))) :
+                        frf_r=frf_r+[frq[k1],frf[k1].real,frf[k1].imag]
+
+                     _fonc = DEFI_FONCTION(NOM_PARA='FREQ',VALE_C=frf_r,);
+                     l_fc.append(_fonc.nom)
+                     nume_i1.append(refer[i1])
+                     nume_j1.append(list_ord[j1])
+
+      #-- On remplit la table_fonction avec tout ce qui va bien 
+ 
+      mcfact=[]
+      mcfact.append(_F(PARA='NOM_CHAM'    ,LISTE_K=nom_frf ))
+      mcfact.append(_F(PARA='OPTION'      ,LISTE_K='TOUT'  ))
+      mcfact.append(_F(PARA='DIMENSION'   ,LISTE_I=(dimh,) ))
+      mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i1 ))
+      mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j1 ))
+      mcfact.append(_F(PARA='FONCTION_C'  ,LISTE_K=l_fc  ))
+      self.DeclareOut('tab_inte',self.sd)
+      tab_inte=CREA_TABLE(LISTE=mcfact,
+                          TITRE='',
+                          TYPE_TABLE='TABLE_FONCTION')
+

diff --git a/Aster/Cata/cataSTA10/Macro/calc_table_ops.py b/Aster/Cata/cataSTA10/Macro/calc_table_ops.py
new file mode 100644 (file)
index 0000000..2c74374
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/calc_table_ops.py
@@ -0,0 +1,176 @@
+#@ MODIF calc_table_ops Macro  DATE 13/10/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 MCOURTOI M.COURTOIS
+
+def calc_table_ops(self, TABLE, ACTION, INFO, **args):
+   """
+   Macro CALC_TABLE permettant de faire des opérations sur une table
+   """
+   import aster
+
+   macro = 'CALC_TABLE'
+   from Accas                 import _F
+   from Cata.cata             import table_sdaster, table_fonction, table_jeveux
+   from Utilitai.Utmess       import  UTMESS
+   from Utilitai              import transpose
+   from Utilitai.Table        import Table, merge
+
+   ier = 0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # Le concept sortant (de type table_sdaster ou dérivé) est tabout
+   self.DeclareOut('tabout', self.sd)
+   if self.sd.__class__ == table_fonction:
+      typ_tabout = 'TABLE_FONCTION'
+   else:
+      typ_tabout = 'TABLE'
+
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   CREA_TABLE    = self.get_cmd('CREA_TABLE')
+   DETRUIRE      = self.get_cmd('DETRUIRE')
+
+   # 0. faut-il utiliser une table dérivée
+   form_sens='\n... SENSIBILITE AU PARAMETRE %s (SD COMP %s)'
+   if args['SENSIBILITE']:
+      ncomp = self.jdc.memo_sensi.get_nocomp(TABLE.nom, args['SENSIBILITE'].nom)
+      sdtab = table_jeveux(ncomp)
+      tab = sdtab.EXTR_TABLE()
+   else:
+      tab = TABLE.EXTR_TABLE()
+
+   #----------------------------------------------
+   # Boucle sur les actions à effectuer
+   for fOP in ACTION:
+      occ = fOP.cree_dict_valeurs(fOP.mc_liste)
+      for mc, val in occ.items():
+         if val == None:
+            del occ[mc]
+   
+      #----------------------------------------------
+      # 1. Traitement du FILTRE
+      # format pour l'impression des filtres
+      form_filtre = '\nFILTRE -> NOM_PARA: %-16s CRIT_COMP: %-4s VALE: %s'
+      if occ['OPERATION'] == 'FILTRE':
+         # peu importe le type, c'est la meme méthode d'appel
+         opts = [occ[k] for k in ('VALE','VALE_I','VALE_C','VALE_K') if occ.has_key(k)]
+         kargs = {}
+         for k in ('CRITERE','PRECISION'):
+            if occ.has_key(k):
+               kargs[k] = occ[k]
+
+         col = getattr(tab, occ['NOM_PARA'])
+         tab = getattr(col, occ['CRIT_COMP'])(*opts,**kargs)
+
+         # trace l'operation dans le titre
+         #if FORMAT in ('TABLEAU','ASTER'):
+         tab.titr += form_filtre % (occ['NOM_PARA'], occ['CRIT_COMP'], \
+            ' '.join([str(v) for v in opts]))
+
+      #----------------------------------------------
+      # 2. Traitement de EXTR
+      if occ['OPERATION'] == 'EXTR':
+         lpar = occ['NOM_PARA']
+         if type(lpar) not in (list, tuple):
+            lpar = [lpar]
+         for p in lpar:
+            if not p in tab.para:
+              UTMESS('F','TABLE0_2',valk=[p,TABLE.nom])
+         tab = tab[occ['NOM_PARA']]
+
+      #----------------------------------------------
+      # 3. Traitement de RENOMME
+      if occ['OPERATION'] == 'RENOMME':
+         try:
+            tab.Renomme(*occ['NOM_PARA'])
+         except KeyError, msg:
+            UTMESS('F','TABLE0_3',valk=msg)
+
+      #----------------------------------------------
+      # 4. Traitement du TRI
+      if occ['OPERATION'] == 'TRI':
+         tab.sort(CLES=occ['NOM_PARA'], ORDRE=occ['ORDRE'])
+   
+      #----------------------------------------------
+      # 5. Traitement de COMB
+      if occ['OPERATION'] == 'COMB':
+         tab2 = occ['TABLE'].EXTR_TABLE()
+         lpar = []
+         if occ.get('NOM_PARA') != None:
+            lpar = occ['NOM_PARA']
+            if type(lpar) not in (list, tuple):
+               lpar = [lpar]
+            for p in lpar:
+               if not p in tab.para:
+                  UTMESS('F','TABLE0_4',valk=[p, TABLE.nom])
+               if not p in tab2.para:
+                  UTMESS('F','TABLE0_5',valk=[p,occ['TABLE'].nom] )
+         restrict = occ.get('RESTREINT') == 'OUI'
+         tab = merge(tab, tab2, lpar, restrict=restrict)
+   
+      #----------------------------------------------
+      # 6. Traitement de OPER
+      if occ['OPERATION'] == 'OPER':
+         # ajout de la colonne dans la table
+         tab.fromfunction(occ['NOM_PARA'], occ['FORMULE'])
+         if INFO == 2:
+            vectval = getattr(tab, occ['NOM_PARA']).values()
+            aster.affiche('MESSAGE', 'Ajout de la colonne %s : %s' % (occ['NOM_PARA']+repr(vectval))+'\n')
+
+      #----------------------------------------------
+      # 6. Traitement de AJOUT
+      if occ['OPERATION'] == 'AJOUT':
+         if len(occ['NOM_PARA']) != len(occ['VALE']):
+            UTMESS('F', 'TABLE0_14')
+         dnew = dict(zip(occ['NOM_PARA'], occ['VALE']))
+         # ajout de la ligne avec vérification des types
+         tab.append(dnew)
+   
+   #----------------------------------------------
+   # 99. Création de la table_sdaster résultat
+   # cas réentrant : il faut détruire l'ancienne table_sdaster
+   if self.sd.nom == TABLE.nom:
+      DETRUIRE(CONCEPT=_F(NOM=TABLE,), INFO=1)
+
+   dprod = tab.dict_CREA_TABLE()
+   if INFO == 2:
+      echo_mess = []
+      echo_mess.append( '@-'*30+'\n' )
+      echo_mess.append( tab )
+      from pprint import pformat
+      echo_mess.append( pformat(dprod) )
+      echo_mess.append( '@-'*30+'\n' )
+      texte_final = ' '.join(echo_mess)
+      aster.affiche('MESSAGE', texte_final)
+
+   # surcharge par le titre fourni
+   tit = args['TITRE']
+   if tit != None:
+      if type(tit) not in (list, tuple):
+         tit = [tit]
+      dprod['TITRE'] = tuple(['%-80s' % lig for lig in tit])
+   # type de la table de sortie à passer à CREA_TABLE
+   tabout = CREA_TABLE(TYPE_TABLE=typ_tabout,
+                       **dprod)
+   
+   return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py
new file mode 100644 (file)
index 0000000..b3e19a1
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py
@@ -0,0 +1,557 @@
+#@ MODIF creation_donnees_homard Macro  DATE 06/10/2008   AUTEUR GNICOLAS G.NICOLAS 
+# -*- 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 GNICOLAS G.NICOLAS
+"""
+Cette classe crée le fichier de configuration permettant de lancer HOMARD depuis Code_Aster.
+"""
+__revision__ = "V1.4"
+__all__ = [ ]
+ 
+import os
+import os.path
+from types import ListType, TupleType
+EnumTypes = (ListType, TupleType)
+
+try:
+  from Utilitai.Utmess import   UTMESS
+except ImportError:
+  def UTMESS(code, idmess, valk=(), vali=(), valr=()):
+    """Clone de utmess si on ne reussit pas à le charger
+    """
+    fmt = '\n <%s> <%s> %s %s %s\n\n'
+    print fmt % (code, idmess, valk, vali, valr)
+
+# ------------------------------------------------------------------------------
+class creation_donnees_homard:
+  """Cette classe crée les données permettant de lancer HOMARD depuis Code_Aster.
+      Ce sont :
+      . le fichier de configuration
+      . le fichier des données dans le cas d'information
+   
+   Arguments (stockés en tant qu'attribut) :
+      . nom_macro : nom de la macro-commande qui appelle :
+                      'MACR_ADAP_MAIL' pour une adaptation
+                      'MACR_INFO_MAIL' pour une information sur un maillage
+      . mots_cles : mots-clés de la macro-commande
+      . dico_configuration : dictionnaire des options
+
+   Attributs :
+      . Nom_Fichier_Configuration : nom du fichier de configuration (immuable)
+      . Nom_Fichier_Donnees : nom du fichier de données (immuable)
+      . mode_homard : le mode pour filtrer ici ("ADAP" ou "INFO")
+      . ModeHOMA : le mode pour HOMARD (1 ou 2)
+      . mode_homard_texte : le mode d'utilisation, en francais ("ADAPTATION" ou "INFORMATION")
+      . elements_incompatibles : que faire des éléments incompatibles avec HOMARD
+   """
+# ------------------------------------------------------------------------------
+  def __init__(self, nom_macro, mots_cles, dico_configuration ) :
+    """Construction + valeurs par défaut des attributs
+    """
+#
+# 1. Vérification de la macro qui appelle
+#
+    d_aux = {}
+    d_aux["MACR_ADAP_MAIL"] = ( "ADAP", 1, "ADAPTATION" )
+    d_aux["MACR_INFO_MAIL"] = ( "INFO", 2, "INFORMATION" )
+    if d_aux.has_key(nom_macro) :
+      self.mode_homard = d_aux[nom_macro][0]
+      self.ModeHOMA = d_aux[nom_macro][1]
+      self.mode_homard_texte = d_aux[nom_macro][2]
+    else :
+      UTMESS("F",'HOMARD0_1')
+#
+# 2. Données générales de cette initialisation
+#
+#gn    for mot_cle in mots_cles.keys() :
+#gn      print "mots_cles[", mot_cle, "] = ", mots_cles[mot_cle]
+#gn    for mot_cle in dico_configuration.keys() :
+#gn      print "dico_configuration[", mot_cle, "] = ", dico_configuration[mot_cle]
+#
+    self.nom_macro = nom_macro
+    self.mots_cles = mots_cles
+    self.dico_configuration = dico_configuration
+#
+# 3. Quel type de traitement des elemenst incompatibles
+#
+    if mots_cles.has_key("ELEMENTS_NON_HOMARD") :
+      d_aux = {}
+      d_aux["REFUSER"] = "TOUS"
+      d_aux["IGNORER"] = "IGNORE_QUAD"
+      self.elements_incompatibles = d_aux[mots_cles["ELEMENTS_NON_HOMARD"]]
+    else :
+      self.elements_incompatibles = None
+#
+# 4. Attributs immuables
+#
+    self.Nom_Fichier_Configuration = "HOMARD.Configuration"
+    self.Nom_Fichier_Donnees = "HOMARD.Donnees"
+#
+# ------------------------------------------------------------------------------
+  def int_to_str2 (self, entier) :
+    """
+    Transforme un entier compris entre 0 et 99 en une chaine sur deux caractères
+    """
+#    print "\nArguments a l'entree de", __name__, ":", entier
+#
+    try:
+      la_chaine = '%02d' % entier
+    except TypeError:
+      la_chaine = None
+#
+    return la_chaine
+# ------------------------------------------------------------------------------
+  def quel_mode (self) :
+    """Informe sur le mode de lancement de HOMARD
+    """
+###    print self.mode_homard_texte
+    print "Lancement de creation_donnees_homard en mode", self.mode_homard_texte
+    return
+# ------------------------------------------------------------------------------
+  def creation_configuration (self) :
+    """Crée les données nécessaires à la configuration
+    """
+#
+    message_erreur = None
+#
+    while message_erreur is None :
+#
+#     1. Les chaines liées aux numéros d'itération
+#
+      if self.mode_homard == "ADAP" :
+        niter = self.dico_configuration["niter"]
+        self.str_niter = self.int_to_str2 (niter)
+        self.str_niterp1 = self.int_to_str2 (niter+1)
+        self.niter_vers_niterp1 = self.str_niter + ".vers." + self.str_niterp1
+#
+#     2. La liste standard
+#
+      if self.mode_homard == "INFO" :
+        aux = "Liste.info"
+      else :
+        aux = "Liste." + self.niter_vers_niterp1
+      self.ListeStd = aux
+#
+#     3. Le type de bilan : il faut convertir la donnée textuelle en un entier,
+#        produit de nombres premiers.
+#        Si rien n'est demandé, on met 0.
+#
+      aux = 1
+      dico_aux = {}
+      dico_aux["INTERPENETRATION"] = 3
+      dico_aux["NOMBRE"] = 7
+      dico_aux["QUALITE"] = 5
+      dico_aux["CONNEXITE"] = 11
+      dico_aux["TAILLE"] = 13
+      l_aux = dico_aux.keys()
+      for choix in l_aux :
+        if self.mots_cles.has_key(choix) :
+          if self.mots_cles[choix] == "OUI" :
+            aux = aux * dico_aux[choix]
+      if aux == 1 :
+        aux = 0
+      self.TypeBila = aux
+#
+#     4. Les entrées/sorties au format MED
+#
+      self.CCNoMN__ = self.dico_configuration["NOM_MED_MAILLAGE_N"]
+      if self.mode_homard == "ADAP" :
+        self.CCNoMNP1 = self.dico_configuration["NOM_MED_MAILLAGE_NP1"]
+        if self.dico_configuration.has_key("NOM_MED_MAILLAGE_NP1_ANNEXE") :
+          self.CCMaiAnn = self.dico_configuration["NOM_MED_MAILLAGE_NP1_ANNEXE"]
+        else :
+          self.CCMaiAnn = None
+#
+#     5. Les entrées/sorties au format HOMARD
+#
+      if self.mode_homard == "ADAP" :
+        self.fic_homard_niter   = "M_" + self.str_niter   + ".hom.med"
+        self.fic_homard_niterp1 = "M_" + self.str_niterp1 + ".hom.med"
+      else :
+        self.fic_homard_niter = None
+        self.fic_homard_niterp1 = None
+#
+#     6.1. Le pilotage de l'adaptation
+#
+      if self.mode_homard == "ADAP" :
+#
+#     6.1. Le type d'adaptation
+#
+        if self.mots_cles["ADAPTATION"] == "RAFFINEMENT" or self.mots_cles["ADAPTATION"] == "RAFFINEMENT_ZONE" :
+          self.TypeRaff = "libre"
+          self.TypeDera = "non"
+        elif self.mots_cles["ADAPTATION"] == "DERAFFINEMENT" :
+          self.TypeRaff = "non"
+          self.TypeDera = "libre"
+        elif self.mots_cles["ADAPTATION"] == "RAFF_DERA" :
+          self.TypeRaff = "libre"
+          self.TypeDera = "libre"
+        elif self.mots_cles["ADAPTATION"] == "RAFFINEMENT_UNIFORME" :
+          self.TypeRaff = "uniforme"
+          self.TypeDera = "non"
+        elif self.mots_cles["ADAPTATION"] == "DERAFFINEMENT_UNIFORME" :
+          self.TypeRaff = "non"
+          self.TypeDera = "uniforme"
+        elif self.mots_cles["ADAPTATION"] == "RIEN" :
+          self.TypeRaff = "non"
+          self.TypeDera = "non"
+#gn        print "... self.TypeRaff = ",self.TypeRaff
+#gn        print "... self.TypeDera = ",self.TypeDera
+#
+#     6.2. L'éventuel seuil de raffinement
+#
+        if self.TypeRaff == "libre" and self.mots_cles["ADAPTATION"] != "RAFFINEMENT_ZONE" :
+          d_aux = {}
+          d_aux["CRIT_RAFF_ABS"] = ("SeuilHau",   1)
+          d_aux["CRIT_RAFF_REL"] = ("SeuilHRe", 100)
+          d_aux["CRIT_RAFF_PE" ] = ("SeuilHPE", 100)
+          l_aux = d_aux.keys()
+          for mot_cle in l_aux :
+            if self.mots_cles[mot_cle] is not None :
+              aux = self.mots_cles[mot_cle]*d_aux[mot_cle][1]
+              self.critere_raffinement = (d_aux[mot_cle][0], aux)
+        else :
+          self.critere_raffinement = None
+#gn          print "... self.critere_raffinement = ", self.critere_raffinement
+#
+#       6.3. L'éventuel seuil de déraffinement
+#
+        if self.TypeDera == "libre" :
+          d_aux = {}
+          d_aux["CRIT_DERA_ABS"] = ("SeuilBas",   1)
+          d_aux["CRIT_DERA_REL"] = ("SeuilBRe", 100)
+          d_aux["CRIT_DERA_PE" ] = ("SeuilBPE", 100)
+          l_aux = d_aux.keys()
+          for mot_cle in l_aux :
+            if self.mots_cles[mot_cle] is not None :
+              aux = self.mots_cles[mot_cle]*d_aux[mot_cle][1]
+              self.critere_deraffinement = (d_aux[mot_cle][0], aux)
+        else :
+          self.critere_deraffinement = None
+#gn          print "... self.critere_deraffinement = ", self.critere_deraffinement
+#
+#       6.4. Les niveaux extremes
+#
+        self.niveau = []
+        for mot_cle in [ "NIVE_MIN", "NIVE_MAX" ] :
+          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 :
+                aux = "NiveauMa"
+              self.niveau.append((aux, self.mots_cles[mot_cle]))
+        if len(self.niveau) == 2 :
+#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"] :
+            message_erreur = "Le niveau mini ,"+str(self.mots_cles["NIVE_MIN"])+\
+                             ", doit etre < au niveau maxi, "+str(self.mots_cles["NIVE_MAX"])+"."
+            break
+#
+#       6.5. Les éventuelles zones de raffinement
+#
+        if self.dico_configuration.has_key("Zones") :
+          iaux = 0
+          for zone in self.dico_configuration["Zones"] :
+            iaux = iaux + 1
+            s_aux_1 = "Zone numero "+str(iaux)+" : "
+            s_aux_2 = ", doit etre < au "
+            if zone.has_key("X_MINI") :
+              if zone["X_MINI"] > zone["X_MAXI"] :
+                message_erreur = s_aux_1+"X mini ,"+str(zone["X_MINI"])+s_aux_2+"X maxi, "+str(zone["X_MAXI"])+"."
+              if zone["Y_MINI"] > zone["Y_MAXI"] :
+                message_erreur = s_aux_1+"Y mini ,"+str(zone["Y_MINI"])+s_aux_2+"Y maxi, "+str(zone["Y_MAXI"])+"."
+            if zone.has_key("Z_MINI") :
+              if zone["Z_MINI"] > zone["Z_MAXI"] :
+                message_erreur = s_aux_1+"Z mini ,"+str(zone["Z_MINI"])+s_aux_2+"Z maxi, "+str(zone["Z_MAXI"])+"."
+#
+      break
+#
+    if message_erreur is not None :
+      UTMESS("F",'HOMARD0_2',valk=message_erreur)
+#
+    return self.fic_homard_niter, self.fic_homard_niterp1
+# ------------------------------------------------------------------------------
+  def ouvre_fichier (self, nomfic_local) :
+    """Ouvre en écriture un fichier après l'avoir éventuellement détruit
+    """
+    codret_partiel = [0]
+###    print nomfic_local
+    Rep_Calc_HOMARD_global = self.dico_configuration["Rep_Calc_HOMARD_global"]
+    nomfic = os.path.join ( Rep_Calc_HOMARD_global , nomfic_local )
+#
+    if os.path.isfile (nomfic) :
+      try :
+        os.remove (nomfic)
+      except os.error, codret_partiel :
+        print "Probleme au remove, erreur numéro ", codret_partiel[0], ":", codret_partiel[1]
+        UTMESS("F",'HOMARD0_3',valk=nomfic)
+#
+    fichier = open (nomfic,"w")
+    self.fichier = fichier
+#
+    return fichier, nomfic
+  def ecrire_ligne_configuration_0 (self, commentaire) :
+    """Ecrit une ligne de commentaires du fichier de configuration
+   Arguments :
+      . commentaire : le commentaire à écrire
+    """
+#
+    ligne = "#\n"
+    ligne = ligne + "# " + commentaire + "\n"
+    ligne = ligne + "#\n"
+    self.fichier.write(ligne)
+#
+    return
+# ------------------------------------------------------------------------------
+  def ecrire_ligne_configuration_2 (self, motcle, valeur) :
+    """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur
+   Arguments :
+      . motcle : le mot-clé HOMARD à écrire
+      . valeur : la valeur associée
+    """
+#
+    ligne = motcle + " " + str(valeur) + "\n"
+    self.fichier.write(ligne)
+#
+    return
+# ------------------------------------------------------------------------------
+  def ecrire_ligne_configuration_3 (self, motcle, valeur1, valeur2) :
+    """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur1 + valeur2
+   Arguments :
+      . motcle : le mot-clé HOMARD à écrire
+      . valeur : la valeur associée
+    """
+#
+    ligne = motcle + " " + str(valeur1) + " " + str(valeur2) + "\n"
+    self.fichier.write(ligne)
+#
+    return
+# ------------------------------------------------------------------------------
+  def ecrire_fichier_configuration (self) :
+    """Ecrit le fichier de configuration
+    """
+    message_erreur = None
+#
+    while message_erreur is None :
+#
+#     1. Ouverture du fichier
+#
+      fichier, nomfic_global = self.ouvre_fichier(self.Nom_Fichier_Configuration)
+#
+#     2. Généralités
+#
+      self.ecrire_ligne_configuration_0("Generalites")
+      self.ecrire_ligne_configuration_2("ModeHOMA", self.ModeHOMA)
+      self.ecrire_ligne_configuration_2("ListeStd", self.ListeStd)
+      self.ecrire_ligne_configuration_2("TypeBila", self.TypeBila)
+      self.ecrire_ligne_configuration_2("CCAssoci", "MED")
+      self.ecrire_ligne_configuration_2("NumeIter", self.dico_configuration["niter"])
+#
+#     3. Les fichiers externes
+#
+      self.ecrire_ligne_configuration_0("Les fichiers de Code_Aster, au format MED")
+      self.ecrire_ligne_configuration_2("CCNoMN__", self.CCNoMN__)
+      self.ecrire_ligne_configuration_2("CCMaiN__", self.dico_configuration["Fichier_ASTER_vers_HOMARD"])
+      if self.mode_homard == "ADAP" :
+        self.ecrire_ligne_configuration_2("CCNoMNP1", self.CCNoMNP1)
+        self.ecrire_ligne_configuration_2("CCMaiNP1", self.dico_configuration["Fichier_HOMARD_vers_ASTER"])
+#
+      self.ecrire_ligne_configuration_0("Le répertoire des fichiers de bilan")
+      self.ecrire_ligne_configuration_2("RepeInfo", self.dico_configuration["Rep_Calc_HOMARD_global"])
+#
+#     4. Les fichiers HOMARD
+#
+      self.ecrire_ligne_configuration_0("Les fichiers de HOMARD, au format MED")
+      if self.mode_homard == "ADAP" :
+        self.ecrire_ligne_configuration_3("HOMaiN__", "M_"+self.str_niter  , self.fic_homard_niter )
+        self.ecrire_ligne_configuration_3("HOMaiNP1", "M_"+self.str_niterp1, self.fic_homard_niterp1)
+        aux = "oui"
+      else :
+        aux = "non"
+      self.ecrire_ligne_configuration_2("EcriFiHO", aux)
+#
+#     5. Le pilotage de l'adaptation
+#
+      if self.mode_homard == "ADAP" :
+        self.ecrire_ligne_configuration_0("Le pilotage de l'adaptation")
+#
+#     5.1. Type d'adaptation
+#
+        self.ecrire_ligne_configuration_2("TypeRaff", self.TypeRaff)
+        if self.critere_raffinement is not None :
+          self.ecrire_ligne_configuration_2(self.critere_raffinement[0], self.critere_raffinement[1])
+        self.ecrire_ligne_configuration_2("TypeDera", self.TypeDera)
+        if self.critere_deraffinement is not None :
+          self.ecrire_ligne_configuration_2(self.critere_deraffinement[0], self.critere_deraffinement[1])
+#
+#     5.2. L'eventuel indicateur d'erreur
+#
+        if self.dico_configuration.has_key("Indicateur") :
+#
+          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("CCCoChaI", self.dico_configuration["Indicateur"]["COMPOSANTE"])
+          if self.dico_configuration["Indicateur"].has_key("NUME_ORDRE") :
+            self.ecrire_ligne_configuration_2("CCNumOrI", self.dico_configuration["Indicateur"]["NUME_ORDRE"])
+            self.ecrire_ligne_configuration_2("CCNumPTI", self.dico_configuration["Indicateur"]["NUME_ORDRE"])
+          if self.mots_cles.has_key("TYPE_VALEUR_INDICA") :
+            self.ecrire_ligne_configuration_2("CCTyVaIn", self.mots_cles["TYPE_VALEUR_INDICA"])
+#
+#     5.3. Les éventuelles zones de raffinement
+#
+        if self.dico_configuration.has_key("Zones") :
+          iaux = 0
+          for zone in self.dico_configuration["Zones"] :
+            iaux = iaux + 1
+            self.ecrire_ligne_configuration_0("Zone de raffinement numéro "+str(iaux))
+            if zone.has_key("X_MINI") :
+              self.ecrire_ligne_configuration_3("ZoRaXmin", iaux, zone["X_MINI"])
+              self.ecrire_ligne_configuration_3("ZoRaXmax", iaux, zone["X_MAXI"])
+              self.ecrire_ligne_configuration_3("ZoRaYmin", iaux, zone["Y_MINI"])
+              self.ecrire_ligne_configuration_3("ZoRaYmax", iaux, zone["Y_MAXI"])
+            if zone.has_key("Z_MINI") :
+              self.ecrire_ligne_configuration_3("ZoRaZmin", iaux, zone["Z_MINI"])
+              self.ecrire_ligne_configuration_3("ZoRaZmax", iaux, zone["Z_MAXI"])
+            if zone.has_key("X_CENTRE") :
+              self.ecrire_ligne_configuration_3("ZoRaXCen", iaux, zone["X_CENTRE"])
+              self.ecrire_ligne_configuration_3("ZoRaYCen", iaux, zone["Y_CENTRE"])
+              self.ecrire_ligne_configuration_3("ZoRaRayo", iaux, zone["RAYON"])
+            if zone.has_key("Z_CENTRE") :
+              self.ecrire_ligne_configuration_3("ZoRaZCen", iaux, zone["Z_CENTRE"])
+#
+#     5.4. Les niveaux extremes
+#
+        for aux in self.niveau :
+          self.ecrire_ligne_configuration_2(aux[0], aux[1])
+#
+#     5.5. L'usage de l'indicateur
+#
+        if self.mots_cles.has_key("TYPE_OPER_INDICA") :
+          if self.mots_cles["TYPE_OPER_INDICA"] is not None :
+            self.ecrire_ligne_configuration_2("CCModeFI", self.mots_cles["TYPE_OPER_INDICA"])
+#
+#     5.6. Les éventuels groupes de filtrage du raffinement/deraffinement
+#
+        for cle in ( "GROUP_MA", "GROUP_NO" ) :
+          if self.mots_cles.has_key(cle) :
+            if self.mots_cles[cle] is not None :
+              if not type(self.mots_cles[cle]) in EnumTypes :
+                self.ecrire_ligne_configuration_2("CCGroAda", self.mots_cles[cle])
+              else :
+                for group in self.mots_cles[cle] :
+                  self.ecrire_ligne_configuration_2("CCGroAda", group)
+#
+#     6. Les éventuels champs à mettre à jour
+#
+      if self.dico_configuration.has_key("Champs") :
+        self.ecrire_ligne_configuration_0("Champs à mettre à 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 à jour du champ numéro "+str(iaux))
+          self.ecrire_ligne_configuration_3("CCChaNom", iaux, maj_champ["NOM_MED"])
+          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"])
+          elif maj_champ.has_key("INST") :
+            self.ecrire_ligne_configuration_3("CCChaIns", iaux, maj_champ["INST"])
+#
+#     7. L'éventuel maillage de frontière
+#
+      if self.dico_configuration.has_key("NOM_MED_MAILLAGE_FRONTIERE") :
+        self.ecrire_ligne_configuration_0("Maillage de frontière")
+        self.ecrire_ligne_configuration_2("SuivFron", "oui")
+        self.ecrire_ligne_configuration_2("CCFronti", self.dico_configuration["Fichier_ASTER_vers_HOMARD"])
+        self.ecrire_ligne_configuration_2("CCNoMFro", self.dico_configuration["NOM_MED_MAILLAGE_FRONTIERE"])
+        if self.mots_cles.has_key("GROUP_MA_FRONT") :
+          if self.mots_cles["GROUP_MA_FRONT"] is not None :
+            if not type(self.mots_cles["GROUP_MA_FRONT"]) in EnumTypes :
+              self.ecrire_ligne_configuration_2("CCGroFro", self.mots_cles["GROUP_MA_FRONT"])
+            else :
+              for group_ma in self.mots_cles["GROUP_MA_FRONT"] :
+                self.ecrire_ligne_configuration_2("CCGroFro", group_ma)
+#
+#     8. L'éventuel maillage annexe
+#
+      if self.mode_homard == "ADAP" :
+        if self.CCMaiAnn is not None :
+          self.ecrire_ligne_configuration_0("Maillage d'autre degré")
+          self.ecrire_ligne_configuration_2("ModDegre", "oui")
+          self.ecrire_ligne_configuration_2("CCNoMAnn", self.CCMaiAnn)
+          self.ecrire_ligne_configuration_2("CCMaiAnn", self.dico_configuration["Fichier_HOMARD_vers_ASTER"])
+#
+#     9. Options particulières
+#
+      self.ecrire_ligne_configuration_0("Autres options")
+      if self.mots_cles.has_key("LANGUE") :
+        self.ecrire_ligne_configuration_2("Langue", self.mots_cles["LANGUE"])
+      self.ecrire_ligne_configuration_2("MessInfo", self.dico_configuration["INFO"])
+      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")
+#
+#     10. L'usage des éléments incompatibles avec HOMARD
+#
+      if self.elements_incompatibles is not None :
+        self.ecrire_ligne_configuration_0("Les éléments incompatibles avec HOMARD")
+        self.ecrire_ligne_configuration_2("TypeElem", self.elements_incompatibles)
+#
+#     11. Fermeture du fichier
+#
+      fichier.close()
+      break
+#
+    if message_erreur is not None :
+      message_erreur = "Ecriture de "+nomfic_global+". "+message_erreur
+      UTMESS("F",'HOMARD0_2',valk=message_erreur)
+#
+    return
+# ------------------------------------------------------------------------------
+  def ecrire_fichier_donnees (self) :
+    """Ecrit le fichier des donnees dans le cas d'une demande d'information
+    """
+    message_erreur = None
+#
+    while message_erreur is None :
+#
+#     1. Ouverture du fichier
+#
+      fichier, nomfic_global = self.ouvre_fichier(self.Nom_Fichier_Donnees)
+#
+#     2. On ne demande rien pour le moment
+#
+      fichier.write("0\n")
+      fichier.write("0\n")
+      fichier.write("0\n")
+      fichier.write("q\n")
+#
+#     n. Fermeture du fichier
+#
+      fichier.close()
+      break
+#
+    if message_erreur is not None :
+      UTMESS("F",'HOMARD0_2',valk=message_erreur)
+#
+    return nomfic_global

diff --git a/Aster/Cata/cataSTA10/Macro/defi_cable_bp_ops.py b/Aster/Cata/cataSTA10/Macro/defi_cable_bp_ops.py
new file mode 100644 (file)
index 0000000..ae1cc57
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/defi_cable_bp_ops.py
@@ -0,0 +1,288 @@
+#@ MODIF defi_cable_bp_ops Macro  DATE 06/07/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- 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.
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+
+# ===========================================================================
+#           CORPS DE LA MACRO "DEFI_CABLE_BP"
+#           -------------------------------------
+# USAGE :
+# Entrée :
+#  - MODELE
+#  - CABLE
+#  - CHAM_MATER
+#  - CARA_ELEM
+#  - GROUP_MA_BETON
+#  - DEFI_CABLE
+#  - TYPE_ANCRAGE
+#  - TENSION_INIT
+#  - RECUL_ANCRAGE
+#  - RELAXATION
+#  - CONE
+#      RAYON
+#      LONGUEUR
+#      PRESENT          OUI ou NON deux fois
+#  - TITRE
+#  - INFO               1 / 2
+#
+# ===========================================================================
+
+
+
+def defi_cable_bp_ops(self,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON,
+                           DEFI_CABLE,TYPE_ANCRAGE,TENSION_INIT,RECUL_ANCRAGE,
+                           RELAXATION,CONE,TITRE,INFO,**args):
+
+  """
+     Ecriture de la macro DEFI_CABLE_BP
+  """
+  from Accas import _F
+  import aster,string, types
+  from Utilitai.Utmess import UTMESS
+  ier=0
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  DEFI_GROUP      = self.get_cmd('DEFI_GROUP')
+  IMPR_RESU       = self.get_cmd('IMPR_RESU')
+  DEFI_CABLE_OP   = self.get_cmd('DEFI_CABLE_OP')
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Le concept sortant (de type char_meca) est nomme CHCABLE dans
+  # le contexte de la macro
+
+  self.DeclareOut('__DC',self.sd)
+
+  # ---------------------------------------------------------------------------- #
+  #                  Début de la Macro :
+
+  motscles={}
+
+  # RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "CONE"
+
+  if CONE:
+    dCONE=CONE[0].cree_dict_valeurs(CONE[0].mc_liste)
+    for i in dCONE.keys():
+      if dCONE[i]==None : del dCONE[i]
+
+    RAYON    = dCONE['RAYON']
+    LONGUEUR = dCONE['LONGUEUR']
+
+    motscles['CONE']=[]
+    motscles['CONE'].append( dCONE )
+
+    # RECUPERATION DU MAILLAGE A PARTIR DU MODELE
+    __MAIL = aster.getvectjev( string.ljust(MODELE.nom,8) + '.MODELE    .LGRF        ' )
+    __MAIL= __MAIL[0].strip()
+    MAILLAGE = self.get_sd_avant_etape(__MAIL,self)
+
+    # DEFINITION DU NOM DES GROUP_NO
+    __NOM = 'AN__'
+    __LGNO = MAILLAGE.LIST_GROUP_NO()
+    __LGN1 = []
+    for i in __LGNO :
+      __LGN1.append( i[0][:len(__NOM)] )
+
+    __NB  = __LGN1.count(__NOM)
+
+# FIN RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "CONE"
+
+
+  # RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "DEFI_CABLE"
+
+  dDEFI_CABLE=[]
+  for j in DEFI_CABLE :
+      dDEFI_CABLE.append(j.cree_dict_valeurs(j.mc_liste))
+      for i in dDEFI_CABLE[-1].keys():
+          if dDEFI_CABLE[-1][i]==None : del dDEFI_CABLE[-1][i]
+
+
+  # BOUCLE SUR LES FACTEURS DU MOT-CLE "DEFI_CABLE"
+
+  motscles['DEFI_CABLE']=[]
+
+  for i in dDEFI_CABLE:
+
+    # CAS OU L'ON A DEFINI LE MOT-CLE "CONE"
+    if CONE:
+
+      # CREATION DU PREMIER TUNNEL
+
+      if dCONE['PRESENT'][0] == 'OUI':
+        __NB = __NB + 1
+        __NOM1 = __NOM + str( int(__NB) )
+
+        motscle2={}
+        motscle2['CREA_GROUP_NO']=[]
+
+        if i.has_key('GROUP_MA') == 1:
+          __CAB = i['GROUP_MA']
+
+          if type(GROUP_MA_BETON) in [types.TupleType, types.ListType]: gma = list(GROUP_MA_BETON)
+          else:                                                         gma = [ GROUP_MA_BETON ]
+          gma.insert(0, __CAB)
+
+          motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': gma, 'GROUP_MA_AXE': __CAB, 'NOM': __NOM1}]}
+        if i.has_key('MAILLE') == 1:
+          UTMESS('F','CABLE0_2')
+        if i.has_key('GROUP_NO_ANCRAGE') == 1:
+          __PC1 = i['GROUP_NO_ANCRAGE'][0]
+          motscle2['CREA_GROUP_NO'][0]['GROUP_NO_ORIG'] = __PC1
+        if i.has_key('NOEUD_ANCRAGE') == 1:
+          __PC1 = i['NOEUD_ANCRAGE'][0]
+          motscle2['CREA_GROUP_NO'][0]['NOEUD_ORIG'] = __PC1
+
+        DEFI_GROUP( reuse=MAILLAGE,
+                    MAILLAGE=MAILLAGE,
+                    INFO=INFO,
+                    ALARME='NON',
+                    **motscle2
+                   ) ;
+
+      # CREATION DU DEUXIEME TUNNEL
+
+      if dCONE['PRESENT'][1] == 'OUI':
+        __NB = __NB + 1
+        __NOM2 = __NOM + str( int(__NB) )
+
+        motscle2={}
+        motscle2['CREA_GROUP_NO']=[]
+
+        if i.has_key('GROUP_MA') == 1:
+          __CAB = i['GROUP_MA']
+
+          if type(GROUP_MA_BETON) in [types.TupleType, types.ListType]: gma = list(GROUP_MA_BETON)
+          else:                                                         gma = [ GROUP_MA_BETON ]
+          gma.insert(0, __CAB)
+
+          motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': gma, 'GROUP_MA_AXE': __CAB, 'NOM': __NOM2}]}
+        if i.has_key('MAILLE') == 1:
+          UTMESS('F','CABLE0_2')
+        if i.has_key('GROUP_NO_ANCRAGE') == 1:
+          __PC1 = i['GROUP_NO_ANCRAGE'][1]
+          motscle2['CREA_GROUP_NO'][0]['GROUP_NO_ORIG'] = __PC1
+        if i.has_key('NOEUD_ANCRAGE') == 1:
+          __PC1 = i['NOEUD_ANCRAGE'][1]
+          motscle2['CREA_GROUP_NO'][0]['NOEUD_ORIG'] = __PC1
+
+        DEFI_GROUP( reuse=MAILLAGE,
+                    MAILLAGE=MAILLAGE,
+                    INFO=INFO,
+                    ALARME='NON',
+                    **motscle2
+                   ) ;
+
+
+      # CREATION DES NOUVEAUX FACTEURS DU MOT-CLE "DEFI_CABLE" POUR DEFI_CABLE_BP
+
+      if dCONE['PRESENT'][0] == 'OUI' and dCONE['PRESENT'][1] == 'OUI':
+        if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'],
+                                            GROUP_NO_FUT=( __NOM1,__NOM2, ), ), )
+        if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'],
+                                            GROUP_NO_FUT=( __NOM1,__NOM2, ), ), )
+
+      if dCONE['PRESENT'][0] == 'OUI' and dCONE['PRESENT'][1] == 'NON':
+        if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'],
+                                            GROUP_NO_FUT=( __NOM1, ), ), )
+        if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'],
+                                            GROUP_NO_FUT=( __NOM1, ), ), )
+
+      if dCONE['PRESENT'][0] == 'NON' and dCONE['PRESENT'][1] == 'OUI':
+        if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'],
+                                            GROUP_NO_FUT=( __NOM2, ), ), )
+        if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'],
+                                            GROUP_NO_FUT=( __NOM2, ), ), )
+
+      if dCONE['PRESENT'][0] == 'NON' and dCONE['PRESENT'][1] == 'NON':
+        if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), )
+        if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1:
+          motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                            NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), )
+
+
+    # CAS OU L'ON A PAS DEFINI LE MOT-CLE "CONE"
+    else:
+      if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1:
+        motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                          GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), )
+
+      if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1:
+        motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'],
+                                          NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), )
+
+      if i.has_key('MAILLE') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1:
+        motscles['DEFI_CABLE'].append( _F(MAILLE=i['MAILLE'],
+                                          GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), )
+
+      if i.has_key('MAILLE') == 1 and i.has_key('NOEUD_ANCRAGE') == 1:
+        motscles['DEFI_CABLE'].append( _F(MAILLE=i['MAILLE'],
+                                          NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), )
+
+
+# FIN BOUCLE sur i in DEFI_CABLE
+
+
+  # LANCEMENT DE DEFI_CABLE_BP
+
+  if RELAXATION:
+    dRelaxation=RELAXATION[0].cree_dict_valeurs(RELAXATION[0].mc_liste)
+    for i in dRelaxation.keys():
+      if dRelaxation[i]==None : del dRelaxation[i]
+
+    __DC=DEFI_CABLE_OP(MODELE=MODELE,
+                       CHAM_MATER=CHAM_MATER,
+                       CARA_ELEM=CARA_ELEM,
+                       GROUP_MA_BETON=GROUP_MA_BETON,
+                       TYPE_ANCRAGE=TYPE_ANCRAGE,
+                       TENSION_INIT=TENSION_INIT,
+                       RECUL_ANCRAGE=RECUL_ANCRAGE,
+                       RELAXATION=dRelaxation,
+                       INFO=INFO,
+                       **motscles
+                       );
+
+  else:
+
+    __DC=DEFI_CABLE_OP(MODELE=MODELE,
+                       CHAM_MATER=CHAM_MATER,
+                       CARA_ELEM=CARA_ELEM,
+                       GROUP_MA_BETON=GROUP_MA_BETON,
+                       TYPE_ANCRAGE=TYPE_ANCRAGE,
+                       TENSION_INIT=TENSION_INIT,
+                       RECUL_ANCRAGE=RECUL_ANCRAGE,
+                       INFO=INFO,
+                       **motscles
+                       );
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/defi_inte_spec_ops.py b/Aster/Cata/cataSTA10/Macro/defi_inte_spec_ops.py
new file mode 100644 (file)
index 0000000..3d27d59
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/defi_inte_spec_ops.py
@@ -0,0 +1,150 @@
+#@ MODIF defi_inte_spec_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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.        
+# ======================================================================
+
+def tocomplex(arg):
+    if arg[0]=='RI' : return complex(arg[1],arg[2])
+    if arg[0]=='MP' : return complex(arg[1]*cos(arg[2]),arg[1]*sin(arg[2]))
+
+def defi_inte_spec_ops(self,DIMENSION,PAR_FONCTION,KANAI_TAJIMI,
+                       CONSTANT,TITRE,INFO,**args):
+#  ------------------------------------------------------------------
+#  Définition d'une matrice interspectrale
+#  à partir de fonctions complexes
+
+   import aster
+   from types import ListType, TupleType
+   EnumTypes = (ListType, TupleType)
+   from Accas               import _F
+   from Utilitai.Utmess     import  UTMESS
+   import Numeric
+   
+   commande='DEFI_INTE_SPEC'
+
+   ier = 0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # Le concept sortant (de type table_sdaster ou dérivé) est tab
+   self.DeclareOut('tabout', self.sd)
+   
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   CREA_TABLE    = self.get_cmd('CREA_TABLE')
+   CALC_TABLE    = self.get_cmd('CALC_TABLE')
+   DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
+
+#--- Vérifications
+
+   if PAR_FONCTION==None : PAR_FONCTION=[]
+   if KANAI_TAJIMI==None : KANAI_TAJIMI=[]
+   if CONSTANT    ==None : CONSTANT    =[]
+
+   nfntot = len(PAR_FONCTION)+len(KANAI_TAJIMI)+len(CONSTANT)
+   dimh   = (DIMENSION*(DIMENSION+1))/2
+   if dimh!=nfntot :
+      UTMESS('F','SPECTRAL0_1')
+
+   l_f=[]
+   for occ in PAR_FONCTION : l_f.append(('PAR_FONCTION',occ))
+   for occ in KANAI_TAJIMI : l_f.append(('KANAI_TAJIMI',occ))
+   for occ in CONSTANT     : l_f.append(('CONSTANT'    ,occ))
+   for occ in l_f :
+      if occ[0]!='PAR_FONCTION' and occ[1]['FREQ_MAX']<occ[1]['FREQ_MIN'] :
+          UTMESS('F','SPECTRAL0_2',valk=occ[0])
+   l_is=[occ[1]['NUME_ORDRE_I'] for occ in l_f]
+   l_js=[occ[1]['NUME_ORDRE_J'] for occ in l_f]
+   iis=sum(l_is)
+   ijs=sum(l_js)
+
+#--- pour une matrice hermitienne ---
+   l_ih=[k*(DIMENSION-k+1) for k in range(1,DIMENSION+1)]
+   l_jh=[k*k               for k in range(1,DIMENSION+1)]
+   ih=sum(l_ih)
+   jh=sum(l_jh)
+   if ((iis!=ih) or (ijs!=jh)) :
+      UTMESS('F','SPECTRAL0_3')
+
+#--- Construction de la liste de fonctions complexes
+   l_fc=[]
+   for occ in l_f :
+
+#--- PAR_FONCTION
+
+       if occ[0]=='PAR_FONCTION' :
+              l_fc.append(occ[1]['FONCTION'].nom)
+
+#--- KANAI_TAJIMI et CONSTANT
+
+       if occ[0] in ('KANAI_TAJIMI','CONSTANT')     :
+              if occ[1]['VALE_R']!=None :
+                 valr=occ[1]['VALE_R']
+                 vali=0.
+              elif occ[1]['VALE_C']!=None :
+                 cmpl=tocomplex(occ[1]['VALE_C'])
+                 valr=cmpl.real
+                 vali=cmpl.imag
+              else :
+                 valr=1.
+                 vali=0.
+              x1=Numeric.arange(occ[1]['FREQ_MIN'],occ[1]['FREQ_MAX'],occ[1]['PAS'])
+              x1=x1.tolist()+[occ[1]['FREQ_MAX'],]
+              valc=[]
+              for absc in x1 : valc=valc+[absc,valr,vali]
+
+#--- KANAI_TAJIMI
+
+       if occ[0]=='KANAI_TAJIMI'     :
+              amor   = occ[1]['AMOR_REDUIT']
+              frqmoy = occ[1]['FREQ_MOY']
+              x11  =Numeric.array([4*(amor**2)*(frqmoy**2)*FREQ**2 \
+                                   for FREQ in x1 ])
+              xnum =x11+frqmoy**4
+              denom=Numeric.array([ (frqmoy**2-FREQ**2)**2 \
+                                   for FREQ in x1 ])
+              denom=denom+x11
+              g0=Numeric.array([valr]*len(denom))
+              g0=g0*xnum/denom
+              valc=[]
+              for i in range(len(x1)): valc=valc+[x1[i],g0[i],0.]
+       if occ[0] in ('KANAI_TAJIMI','CONSTANT')     :
+              _f=DEFI_FONCTION(PROL_GAUCHE=occ[1]['PROL_GAUCHE'],
+                               PROL_DROITE=occ[1]['PROL_DROITE'],
+                               INTERPOL   =occ[1]['INTERPOL'],
+                               VALE_C     =valc,
+                               NOM_PARA   ='FREQ',
+                               NOM_RESU   ='DSP' )
+              l_fc.append(_f.nom)
+
+   mcfact=[]
+   mcfact.append(_F(PARA='NOM_CHAM'  ,LISTE_K='DSP' ))
+   mcfact.append(_F(PARA='OPTION'    ,LISTE_K='TOUT' ))
+   mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(DIMENSION,) ))
+   tabout=CREA_TABLE(LISTE=mcfact, TITRE='',
+                     TYPE_TABLE='TABLE_FONCTION')
+   mcfact=[]
+   mcfact.append(_F(PARA='NUME_ORDRE_I'  ,LISTE_I=l_is ))
+   mcfact.append(_F(PARA='NUME_ORDRE_J'  ,LISTE_I=l_js ))
+   mcfact.append(_F(PARA='FONCTION_C'    ,LISTE_K=l_fc ,TYPE_K='K24' ))
+   __l_fonc=CREA_TABLE(LISTE=mcfact, TITRE='')
+   tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,
+                     TITRE=self.sd.nom+' : interspectre obtenu par DEFI_INTE_SPEC',
+                     ACTION=_F(OPERATION='COMB',TABLE=__l_fonc,))
+
+   return ier

diff --git a/Aster/Cata/cataSTA10/Macro/defi_part_feti_ops.py b/Aster/Cata/cataSTA10/Macro/defi_part_feti_ops.py
new file mode 100644 (file)
index 0000000..2c1ab0c
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/defi_part_feti_ops.py
@@ -0,0 +1,193 @@
+#@ MODIF defi_part_feti_ops Macro  DATE 06/07/2009   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 ASSIRE A.ASSIRE
+
+
+# ===========================================================================
+#           CORPS DE LA MACRO "DEFI_PART_FETI"
+#           -------------------------------------
+# USAGE :
+#  MAILLAGE        maillage a partitionner
+#  MODELE          modele (facultatif)
+#  NB_PART         nb de sous-domaines
+#  EXCIT           liste des chargements
+#  METHODE         PMETIS, KMETIS ou AUTRE
+#  LOGICIEL        si AUTRE alors on attend un chemin complet vers executable
+#  NOM_GROUP_MA    Un nom de base pour les group_ma contenant les SD
+#  INFO            1,2
+#
+# ===========================================================================
+# script PYTHON : lancement de DEFI_PART_PA_OPS et de DEFI_PART_OPS
+
+
+def defi_part_feti_ops(self,NB_PART,METHODE,TRAITER_BORDS,NOM_GROUP_MA,CORRECTION_CONNEX,INFO,**args):
+
+  import aster, string, sys
+
+  from Accas import _F
+  from Noyau.N_utils import AsType
+  from Utilitai.Utmess import  UTMESS
+
+  from Utilitai import partition
+
+  # DEBUT DE LA MACRO
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+  ier=0
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  DEFI_PART_OPS   = self.get_cmd('DEFI_PART_OPS')
+  INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER')
+  DEFI_FICHIER    = self.get_cmd('DEFI_FICHIER')
+  DEFI_PART_PA_OPS   = self.get_cmd('DEFI_PART_PA_OPS')
+
+  nompro='DEFI_PART_FETI'
+
+  # Maillage
+  if args.has_key('MODELE'):
+    if args['MODELE'] != None:
+      __MOD = string.ljust(args['MODELE'].nom,8)
+      __MOD =__MOD+'.MODELE    .LGRF        '
+      __LMAIL = aster.getvectjev(__MOD)
+      __MAIL  = string.strip(__LMAIL[0])
+      MAILLAGE=self.get_sd_avant_etape(__MAIL,self)
+    else:
+      MAILLAGE=args['MAILLAGE']
+
+  # Nom des GROUP_MA générés
+  NOM_GROUP_MA = string.strip(NOM_GROUP_MA)
+
+  # Test sur le nombre de caractères de NOM_GROUP_MA
+  if ( len(NOM_GROUP_MA)+len(str(NB_PART)) > 7 ):
+    ln=7-len(str(NB_PART))
+    UTMESS('F','FETI0_1',vali=ln)
+
+  # Verification que des GROUP_MA ne portent pas deja les memes noms
+  _lst = []
+  for i in MAILLAGE.LIST_GROUP_MA():
+    _lst.append( string.strip(i[0]) )
+  for i in range(NB_PART):
+    if ( NOM_GROUP_MA+str(i) in _lst ):
+      ngrma=NOM_GROUP_MA+str(i)
+      UTMESS('F','FETI0_2',valk=ngrma)
+    if args.has_key('NOM_GROUP_MA_BORD') :
+      if args['NOM_GROUP_MA_BORD'] != None :
+        if ( args['NOM_GROUP_MA_BORD']+str(i) in _lst ):
+          ngrma=args['NOM_GROUP_MA_BORD']+str(i)
+          UTMESS('F','FETI0_2',valk=ngrma)
+
+  # Le concept sortant dans le contexte de la macro
+  self.DeclareOut('_SDFETI',self.sd)
+
+  # Debut :
+
+  # Regeneration des mots-cles GROUPAGE passés en argument de la macro
+  motscle1= {}
+  if args.has_key('GROUPAGE'):
+    if args['GROUPAGE'] != None :
+      dGroup=[]
+      for j in args['GROUPAGE']:
+        dGroup.append(j.cree_dict_valeurs(j.mc_liste))
+        for i in dGroup[-1].keys():
+          if dGroup[-1][i]==None : del dGroup[-1][i]
+        motscle1['GROUPAGE']=dGroup
+
+  # Regeneration des mots-cles POIDS_MAILLES passés en argument de la macro
+  if args.has_key('POIDS_MAILLES'):
+    if args['POIDS_MAILLES'] != None :
+      dEval=[]
+      for j in args['POIDS_MAILLES']:
+        dEval.append(j.cree_dict_valeurs(j.mc_liste))
+        for i in dEval[-1].keys():
+          if dEval[-1][i]==None : del dEval[-1][i]
+        motscle1['POIDS_MAILLES']=dEval
+
+  # Y a t'il présence du mot clé : NOM_GROUP_MA_BORD
+  if args.has_key('GROUP_MA_BORD'):
+    if args['GROUP_MA_BORD'] != None :
+      motscle1['GROUP_MA_BORD']=args['GROUP_MA_BORD']
+
+  # Y a t'il présence du mot clé : LOGICIEL
+  if args.has_key('LOGICIEL'):
+    if args['LOGICIEL'] != None :
+      motscle1['LOGICIEL']=args['LOGICIEL']
+
+  # Y a t'il présence du mot clé : MODELE
+  if args.has_key('MODELE'):
+    if args['MODELE'] != None :
+      motscle1['MODELE']=args['MODELE']
+
+  # Partitionnement
+  DEFI_PART_PA_OPS(
+                   MAILLAGE=MAILLAGE,
+                   INFO=INFO,
+                   METHODE=METHODE,
+                   NB_PART=NB_PART,
+                   CORRECTION_CONNEX=CORRECTION_CONNEX,
+                   TRAITER_BORDS=TRAITER_BORDS,
+                   NOM_GROUP_MA=NOM_GROUP_MA,
+                   **motscle1
+                     );
+
+  # Liste des groupes de mailles du maillage
+  _LST_GMA = MAILLAGE.LIST_GROUP_MA()
+  _LST_GMA = map(lambda x: x[0], _LST_GMA)
+
+  # Creation de la SDFETI
+  if args.has_key('MODELE'):
+    if args['MODELE'] != None :
+      _tmp  = []
+      for i in range(NB_PART):
+        txt = { 'GROUP_MA': NOM_GROUP_MA + str(i) }
+        _tmp.append( txt )
+
+        if args.has_key('NOM_GROUP_MA_BORD') :
+          if args['NOM_GROUP_MA_BORD'] != None :
+            if ( args['NOM_GROUP_MA_BORD']+str(i) in _LST_GMA ):
+              txt['GROUP_MA_BORD'] = string.strip(args['NOM_GROUP_MA_BORD']) + str(i)
+            _tmp.append( txt )
+
+      motscle2= {'DEFI': _tmp }
+
+      # Regeneration des mots-cles EXCIT passés en argument de la macro
+      if args.has_key('EXCIT'):
+        if args['EXCIT'] != None :
+          dExcit=[]
+          for j in args['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]
+          motscle2['EXCIT']=dExcit
+
+      _SDFETI=DEFI_PART_OPS(NOM='SDD',
+                            MODELE=args['MODELE'],
+                            INFO=1,
+                            **motscle2
+                            );
+    else:
+      _SDFETI=None
+
+  else:
+    _SDFETI=None
+
+
+  # Fin :
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py b/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py
new file mode 100644 (file)
index 0000000..3a27c15
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/dyna_iss_vari_ops.py
@@ -0,0 +1,363 @@
+#@ MODIF dyna_iss_vari_ops Macro  DATE 16/11/2009   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.        
+# ======================================================================
+from Accas import _F
+import string
+
+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,
+                         **args):
+   """
+      Macro DYNA_ISS_VARI
+   """
+   ier=0
+   import Numeric as Num
+   import LinearAlgebra as LinAl
+   import MLab
+   import os
+   import aster
+   diag = MLab.diag
+   max = MLab.max
+   min = MLab.min
+   sum = Num.sum
+   abs = Num.absolute
+   conj = Num.conjugate
+   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 = Num.array(coll_grno.get('%-8s' % group, [])) - 1
+      return Num.take(t_coordo, l_ind)
+
+
+   # 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')
+   CREA_TABLE     = self.get_cmd('CREA_TABLE')
+
+   # Comptage commandes + declaration concept sortant
+   self.set_icmd(1)
+   self.DeclareOut('tab_out', self.sd)
+   macro='DYNA_ISS_VARI'
+#--------------------------------------------------------
+   dgene = MATR_GENE[0].cree_dict_valeurs(MATR_GENE[0].mc_liste)
+   if dgene['MATR_AMOR'] != None:
+     aster.affiche('MESSAGE',' MATR_AMOR existe')
+     __ma_amort = MATR_GENE['MATR_AMOR']
+   else:         
+     __ma_amort=COMB_MATR_ASSE(CALC_AMOR_GENE=_F(MASS_GENE = MATR_GENE['MATR_MASS'] ,
+                                        RIGI_GENE = MATR_GENE['MATR_RIGI'] ,                                       
+                                        AMOR_REDUIT= (  0.0,),
+                                         ),                               
+                                  );
+     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    
+   from SD.sd_mode_meca import sd_mode_meca 
+   from SD.sd_resultat import sd_resultat
+   from SD.sd_cham_gene import sd_cham_gene
+
+   v_refa_rigi = MATR_GENE['MATR_RIGI'].REFA.get()
+   v_refa_mass = MATR_GENE['MATR_MASS'].REFA.get()
+   # MAILLAGE
+   nom_bamo = v_refa_rigi[0]
+   nume_ddl = aster.getvectjev(nom_bamo[0:8] + '           .REFD        ' )[3]
+   nom_mail = aster.getvectjev( nume_ddl[0:19] + '.REFN        ' )[0] 
+   maillage = sd_maillage(nom_mail)
+   # MODELE, DDLGENE
+   nom_ddlgene = v_refa_rigi[1]  
+   nom_modele = aster.getvectjev( nume_ddl[0:19] + '.LILI        ' )[1]   
+   resultat = self.get_concept(nom_bamo)
+   nume_ddlgene = self.get_concept(nom_ddlgene)
+   modele = self.get_concept(nom_modele[0:8])
+
+   #TEST base modale
+   nom_bamo2 = v_refa_mass[0]
+   if nom_bamo.strip() != nom_bamo2.strip():
+      UTMESS('F','ALGORITH5_42')
+   
+   nbnot, nbl, nbma, nbsm, nbsmx, dime = maillage.DIME.get()
+
+   # coordonnees des noeuds
+   l_coordo = maillage.COORDO.VALE.get()
+   t_coordo = Num.array(l_coordo)
+   t_coordo.shape = nbnot, 3
+   # groupes de noeuds
+   coll_grno = maillage.GROUPENO.get()
+   GROUP_NO_INTER=INTERF['GROUP_NO_INTERF']
+   noe_interf = get_group_coord(GROUP_NO_INTER)
+   #  print noe_interf  
+   nbno, nbval = noe_interf.shape
+   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')
+
+   nbmodt2 = MATR_GENE['MATR_RIGI'].DESC.get()[1]
+   if nbmodt2 != nbmodt:
+       UTMESS('F','ALGORITH5_42')
+
+   if INFO==2:
+      texte = 'NOMBRE DE MODES: '+str(nbmodt)+'   MODES DYNAMIQUES: '+str(nbmodd)+'   MODES STATIQUES: '+str(nbmods)
+      aster.affiche('MESSAGE',texte)
+      aster.affiche('MESSAGE','COMPOSANTE '+NOM_CMP)
+   SPEC = Num.zeros((NB_FREQ,nbmodt,nbmodt), Num.Float)+1j
+#
+#---------------------------------------------------------------------
+  # BOUCLE SUR LES FREQUENCES
+   VITE_ONDE = MATR_COHE['VITE_ONDE']
+   alpha = MATR_COHE['PARA_ALPHA']
+   abscisse = [None]*NB_FREQ
+
+   for k in range(0,NB_FREQ):
+      freqk=FREQ_INIT+PAS*k
+      aster.affiche('MESSAGE','FREQUENCE DE CALCUL: '+str(freqk))
+
+      # Matrice de coherence                  
+      XX=noe_interf[:,0]
+      YY=noe_interf[:,1]
+
+      XN=Num.repeat(XX,nbno)
+      YN=Num.repeat(YY,nbno)
+      XR=Num.reshape(XN,(nbno,nbno))
+      YR=Num.reshape(YN,(nbno,nbno))
+      XRT=Num.transpose(XR)
+      YRT=Num.transpose(YR)
+      DX=XR-XRT
+      DY=YR-YRT
+      DIST=DX**2+DY**2
+      COHE=Num.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.))
+      
+      # On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas
+      aster.matfpe(-1)
+      eig, vec =LinAl.eigenvectors(COHE)
+      aster.matfpe(1)
+      eig=eig.real
+      vec=vec.real
+      # on rearrange selon un ordre decroissant
+      eig = Num.where(eig < 1.E-10, 0.0, eig)
+      order = (Num.argsort(eig)[::-1])
+      eig = Num.take(eig, order)
+      vec = Num.take(vec, order, 0)
+
+      #-----------------------
+      # Nombre de modes POD a retenir
+      etot=sum(diag(COHE))
+      ener=0.0
+      nbme=0
+ 
+      if INFO==2:
+         aster.affiche('MESSAGE','ETOT :'+str(etot))
+      while nbme < nbno:
+         ener= eig[nbme]+ener
+         prec=ener/etot
+         nbme=nbme+1
+         if INFO==2:
+            aster.affiche('MESSAGE','VALEUR PROPRE  '+str(nbme)+' : '+str(eig[nbme-1]))
+         if prec > PRECISION :
+            break
+
+      aster.affiche('MESSAGE','NOMBRE DE MODES POD RETENUS : '+str(nbme))
+      aster.affiche('MESSAGE','PRECISION (ENERGIE RETENUE) : '+str(prec))      
+
+      PVEC=Num.zeros((nbme,nbno), Num.Float)
+      for k1 in range(0,nbme):
+         PVEC[k1, 0:nbno]=Num.sqrt(eig[k1])*vec[k1] 
+      # CALCUL DE FS variable-------------------------------
+      XO=Num.zeros((nbme,nbmods), Num.Float)
+      if NOM_CMP=='DX':
+         COMP = 1
+      elif NOM_CMP=='DY':
+         COMP = 2
+      elif NOM_CMP=='DZ': 
+         COMP = 3  
+
+   #---------MODES interface
+      # ----- boucle sur les modes statiques
+      for mods in range(0,nbmods):
+         nmo = nbmodd+mods+1
+         __CHAM=CREA_CHAMP( TYPE_CHAM='NOEU_DEPL_R',
+                OPERATION='EXTR',                  
+                NUME_ORDRE=nmo,
+                RESULTAT = resultat  ,
+                NOM_CHAM = 'DEPL'
+                      );
+         MCMP =__CHAM.EXTR_COMP(NOM_CMP,[GROUP_NO_INTER]).valeurs
+
+         NNO =__CHAM.EXTR_COMP(NOM_CMP,[GROUP_NO_INTER], topo=1).noeud
+
+
+         som=sum(MCMP)
+         max1=max(MCMP)
+         min1=min(MCMP)
+         maxm=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 abs(som)<10.E-6:
+                     XO[modp,mods]=0.0
+                  else :
+                     fact=1./som               
+                     XO[modp,mods]=fact*Num.innerproduct(MCMP,PVEC[modp])
+               #modes de rotation
+               else:
+                  if maxm<10.E-6:
+                     if som<10.E-6:
+                        XO[modp,mods]=0.0 
+                     else :
+                        UTMESS('F','ALGORITH6_86')
+                  else :  
+                     fact = 1./(nbno)                   
+                     XO[modp,mods]=1./(maxm**2.)*fact*Num.innerproduct(MCMP,PVEC[modp])
+
+         # CAS 2: MODES EF
+         if INTERF['MODE_INTERF'] =='TOUT':
+            for modp in range(0,nbme):
+               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*Num.innerproduct(MCMP,PVEC[modp])
+
+         DETRUIRE(CONCEPT=_F(NOM=(__CHAM)),INFO=1)
+
+   #----Impedances etc.----------------------------------------------------------------- 
+
+      if k>0:
+         DETRUIRE(CONCEPT=_F(NOM=(__impe,__fosi,__rito)),INFO=1) 
+
+      __impe = LIRE_IMPE_MISS(BASE=resultat,  
+                           TYPE=TYPE,
+                           NUME_DDL_GENE=nume_ddlgene,               
+                           UNITE_RESU_IMPE= UNITE_RESU_IMPE, 
+                           FREQ_EXTR=freqk, 
+                           );
+      __rito=COMB_MATR_ASSE(COMB_C=(
+                                _F(MATR_ASSE=__impe,
+                                 COEF_C=1.0+0.j,),
+                                _F(MATR_ASSE=MATR_GENE['MATR_RIGI'],
+                                 COEF_C=1.0+0.j,),
+                                 ),
+                                 SANS_CMP='LAGR',
+                                 );                                                                            
+      __fosi = LIRE_FORC_MISS(BASE=resultat,  
+                           NUME_DDL_GENE=nume_ddlgene,
+                           NOM_CMP=NOM_CMP,
+                           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=Num.zeros((nbmodt,nbmodt),Num.Float)
+      for k1 in range(0,nbme):
+         #  calcul de la force sismique mode POD par mode POD
+         FS = Num.matrixmultiply(KRS,XO[k1]) 
+         Fzero=Num.zeros((1,nbmodd),Num.Float) 
+         FS2=Num.concatenate((Fzero,Num.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[0].strip() == 'DEPL', 'Champ DEPL non trouvé'
+         nomcham = __dyge.TACH.get()[1][0].strip()
+         cham = sd_cham_gene(nomcham)
+         RS = Num.array(cham.VALE.get())      
+         SP=SP+RS*conj(RS[:,Num.NewAxis])   
+         DETRUIRE(CONCEPT=_F(NOM=(__dyge)),INFO=1) 
+
+
+      SPEC[k]=SP
+
+      abscisse[k]= freqk
+##---------------------------------------------------------------------
+#  Ecriture des tables
+#--------------------------------------------------------------------- 
+#   ------ 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):
+            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})
+
+   # Creation du concept en sortie
+   dict_keywords = tab.dict_CREA_TABLE()
+   tab_out = CREA_TABLE(TYPE_TABLE='TABLE_FONCTION',
+                        **dict_keywords)                       
+   return ier

diff --git a/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py b/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py
new file mode 100644 (file)
index 0000000..33b5488
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/exec_logiciel_ops.py
@@ -0,0 +1,189 @@
+#@ MODIF exec_logiciel_ops Macro  DATE 16/11/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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
+
+import os.path
+import traceback
+import shutil
+from types import ListType, TupleType
+EnumTypes = (ListType, TupleType)
+
+# ------------------------------------------------------------------------------
+def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO, **args):
+   """
+   Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions,
+   colonnes de table...
+   Erreurs<S> dans IMPR_FONCTION pour ne pas perdre la base.
+   """
+   macro='EXEC_LOGICIEL'
+   import aster
+   from Utilitai.Utmess     import  UTMESS
+   from Utilitai.System     import ExecCommand
+   from Utilitai.UniteAster import UniteAster
+   
+   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)
+
+   #----------------------------------------------
+   # constantes des modes d'exécution
+   CMD_EXTERNE = 1
+   EXECFILE    = 2
+   mode_lancement = None
+
+   # 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,]
+   
+   #----------------------------------------------
+   # 1. Préparation des données
+   # 1.1. EXEC_LOGICIEL standard
+   if MAILLAGE == None:
+      mode_lancement = CMD_EXTERNE
+      cmd = '%(prog)s %(options)s'
+   
+   # 1.2. Cas "lancement d'un mailleur"
+   else:
+      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 dMCF['FORMAT'] == 'GMSH':
+         mode_lancement = CMD_EXTERNE
+         cmd = '%(prog)s %(options)s -o %(fichOUT)s %(fichIN)s'
+         d_para['prog'] = os.path.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'] = os.path.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]
+      
+      else:
+         UTMESS('F', 'EXECLOGICIEL0_2', valk=dMCF['FORMAT'])
+
+   
+   #----------------------------------------------
+   # 2. lecture des mots-clés
+   if LOGICIEL != None:
+      d_para['prog'] = LOGICIEL
+
+   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
+      comment = "Lancement de la commande :\n%s" % scmd
+      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
+
+      # output
+      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:
+      if d_para['prog'] != '':
+         UTMESS('A', 'EXECLOGICIEL0_4')
+      context={}
+      try:
+         execfile(d_para['fichIN'], context)
+      except:
+         traceback.print_exc()
+         txt = open(d_para['fichIN'], 'r').read()
+         UTMESS('F', 'EXECLOGICIEL0_5', valk=txt)
+      
+      if not os.path.exists(d_para['fichMED']):
+         UTMESS('F', 'EXECLOGICIEL0_6', valk=d_para['fichMED'])
+      else:
+         # copie fichMED vers fichOUT pour pouvoir le récupérer
+         shutil.copyfile(d_para['fichMED'], d_para['fichOUT'])
+   
+   else:
+      UTMESS('F','EXECLOGICIEL0_7',valk=mode_lancement)
+   
+   #----------------------------------------------
+   # 4. Conversion du maillage
+   if MAILLAGE != None:
+      UL = UniteAster()
+      umail = UL.Libre(action='ASSOCIER',
+                       nom='exec_logiciel.%s2mail' % dMCF['FORMAT'].lower())
+      
+      # déclaration du concept maillage en sortie
+      self.DeclareOut('mail', dMCF['MAILLAGE'])
+      
+      lire_mail_opts = {}
+      if dMCF['FORMAT'] == 'GMSH':
+         PRE_GMSH(UNITE_GMSH     = dMCF['UNITE'],
+                  UNITE_MAILLAGE = umail)
+
+      elif dMCF['FORMAT'] == 'GIBI':
+         PRE_GIBI(UNITE_GIBI     = dMCF['UNITE'],
+                  UNITE_MAILLAGE = umail)
+
+      elif dMCF['FORMAT'] == 'SALOME':
+         # ici l'unité en entrée de LIRE_MAILLAGE ne correspond pas au .mail
+         # mais au fichier MED en sortie du execfile.
+         umail = dMCF['UNITE']
+         etat = UL.Etat(umail, etat='O', TYPE='LIBRE', nom=d_para['fichMED'])
+         lire_mail_opts['FORMAT']   = 'MED'
+         lire_mail_opts['INFO_MED'] = INFO
+      
+      mail = LIRE_MAILLAGE(UNITE = umail,
+                           INFO  = INFO,
+                           **lire_mail_opts)
+
+      UL.EtatInit()
+   return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/externe_mess.py b/Aster/Cata/cataSTA10/Macro/externe_mess.py
new file mode 100644 (file)
index 0000000..718900f
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/externe_mess.py
@@ -0,0 +1,27 @@
+#@ MODIF externe_mess Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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.        
+# ======================================================================
+import sys
+"""
+Définition de la méthode UTMESS pour reca_xxxx.py, Graph.py, Table.py
+"""
+def UTMESS(code,sprg,texte):
+   fmt='\n <%s> <%s> %s\n\n'
+   print fmt % (code,sprg,texte)
+   if code=='F': sys.exit()

diff --git a/Aster/Cata/cataSTA10/Macro/fiabilite_fichier.py b/Aster/Cata/cataSTA10/Macro/fiabilite_fichier.py
new file mode 100644 (file)
index 0000000..1462a5e
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/fiabilite_fichier.py
@@ -0,0 +1,335 @@
+#@ MODIF fiabilite_fichier Macro  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.        
+# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+#
+class fiabilite_fichier :
+#
+  """ Classe des fichiers de données des logiciels fiabilistes
+      Cette classe a été mise au point pour le couplage entre
+      Code_ASTER et MEFISTO, mais pourrait servir ailleurs.
+  """
+#
+#
+#====
+# 1. Le constructeur
+#====
+#
+#
+  def __init__ ( self, jdc, Rep_Calc_LOGICIEL_global, nomfic, info = 1 ) :
+#
+#   jdc : le jeu de commandes en cours de traitement
+#
+    self.jdc = jdc
+#
+#   Rep_Calc_LOGICIEL_global : le répertoire d'exécution du logiciel de fiabilité
+#
+    self.Rep_Calc_LOGICIEL_global = Rep_Calc_LOGICIEL_global
+#
+#   nomfic : nom local du fichier à créer
+#
+    self.nomfic = nomfic
+#
+#   messages_erreur : messages d'erreur
+#
+    self.messages_erreur = { 0 : "Tout va bien",
+                             1 : "==> Ce fichier est inconnu.",
+                             2 : "==> Ce type d'ouverture est inconnu.",
+                            10 : "==> Problème à l'ouverture.",
+                            11 : "==> Problème à la fermeture.",
+                            20 : "==> Problème à l'impression." }
+#
+#   info : niveau d'information au sens ASTER
+#
+    self.info = info
+#
+#   ligne_sep : ligne de séparation
+#
+    self.ligne_sep = "========================================================="
+    self.ligne_commentaire = "#" + self.ligne_sep + "\n"
+#
+    if info >= 2 :
+      print "Création du fichier : "+self.nomfic
+#
+#====
+# 2. Ouverture du fichier
+#====
+#
+  def Ouvre_Fichier ( self, type_ouvr ) :
+#
+# 2.0. ==> Préalables
+#
+    """
+    Ouvre le fichier en lecture ou écriture.
+    0 : tout s'est bien passé
+    1 : on veut ouvrir en lecture un fichier qui n'existe pas
+    2 : le mode d'ouverture est inconnu
+   10 : impossible d'ouvrir
+    """
+#
+    import os
+#
+# 2.1. ==> Le nom global du fichier
+#
+    self.nomfic_global = os.path.join(self.Rep_Calc_LOGICIEL_global,self.nomfic)
+#
+# 2.2. ==> Controles
+#
+    erreur = 0
+#
+    if ( type_ouvr == "w" or type_ouvr == "r" ) :
+#
+      if ( type_ouvr == "r" ) :
+        if not os.path.isfile(self.nomfic_global) :
+          erreur = 1          
+
+    else :
+#
+      self.jdc.cr.warn("Type d'ouverture : "+type_ouvr)
+      erreur = 2
+#
+# 2.3. ==> Ouverture vraie
+#
+    if not erreur :
+#
+      erreur_partiel = [0]
+      try :
+        self.fic = open( self.nomfic_global, type_ouvr )
+      except os.error,erreur_partiel :
+        self.jdc.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
+        erreur = 10
+#
+# 2.4. ==> C'est fini
+#
+    if erreur :
+      self.jdc.cr.warn("Fichier : "+self.nomfic)
+      self.jdc.cr.warn(self.messages_erreur[erreur])
+#
+    return erreur
+#
+#====
+# 3. Fermeture du fichier
+#====
+#
+  def Ferme_Fichier ( self ) :
+#
+# 3.0. ==> Préalables
+#
+    """
+    Ferme le fichier.
+    0 : tout s'est bien passé
+   20 : impossible d'imprimer
+    """
+#
+    import os
+#
+# 3.1. ==> Controles
+#
+    erreur = 0
+#
+    if not os.path.isfile(self.nomfic_global) :
+      erreur = 1          
+#
+# 3.2. ==> Fermeture vraie
+#
+    if not erreur :
+#
+      erreur_partiel = [0]
+      try :
+        self.fic.close( )
+      except os.error,erreur_partiel :
+        self.jdc.cr.warn("Code d'erreur de close : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
+        erreur = 11
+#
+# 3.3. ==> C'est fini
+#
+    if erreur :
+      self.jdc.cr.warn("Fichier : "+self.nomfic)
+      self.jdc.cr.warn(self.messages_erreur[erreur])
+#
+    return erreur
+#
+#====
+# 4. Impression du contenu du fichier
+#====
+#
+  def Imprime_Fichier ( self ) :
+#
+# 4.0. ==> Préalables
+#
+    """
+    Imprime le fichier.
+    0 : tout s'est bien passé
+   20 : impossible d'imprimer
+    """
+#
+# 4.1. ==> Lecture
+#
+    erreur = self.Ouvre_Fichier ( "r" )         
+    if not erreur :
+      les_lignes = self.fic.readlines()
+      erreur = self.Ferme_Fichier ( )         
+#
+# 4.2. ==> Impression
+#
+    if not erreur :
+#
+      print "\n"+self.ligne_sep
+      print "Contenu du fichier " + self.nomfic," :"
+      for ligne in les_lignes :
+        print ligne[:-1]
+      print self.ligne_sep+"\n"
+#
+# 4.4. ==> C'est fini
+#
+    if erreur :
+      erreur = 20
+      self.jdc.cr.warn("Fichier : "+self.nomfic)
+      self.jdc.cr.warn(self.messages_erreur[erreur])
+#
+    return erreur
+#
+#====
+# 5. Ecriture de lignes de commentaires
+#====
+#
+  def Ecrit_Commentaires ( self, comm ) :
+#
+    """
+    Liste = commentaires à écrire
+    Soit c'est une chaine qu'on écrit sur une ligne ;
+    Soit c'est une liste, qu'on écrit à raison de une par ligne.
+    Remarque : cela suppose que le fichier est ouvert en écriture
+    """
+#
+    if type(comm) == type([ ]) :
+      Liste = comm
+    else :
+      Liste = [comm]
+#
+    for ligne in Liste :
+      self.fic.write("# "+str(ligne)+"\n")
+#
+#====
+# 6. Ecriture de lignes de titres
+#====
+#
+  def Ecrit_Titre ( self, comm ) :
+#
+    """
+    Liste = commentaires à écrire, encadrés par des séparateurs
+    Soit c'est une chaine qu'on écrit sur une ligne ;
+    Soit c'est une liste, qu'on écrit à raison de une par ligne.
+    Remarque : cela suppose que le fichier est ouvert en écriture
+    """
+#
+    self.fic.write(self.ligne_commentaire)
+    self.Ecrit_Commentaires(comm)
+    self.fic.write(self.ligne_commentaire)
+#
+#====
+# 7. Ecriture d'une ligne de valeurs
+#====
+#
+  def Ecrit_Valeurs ( self, val ) :
+#
+    """
+    Liste = liste des valeurs à écrire, représenatn une ligne
+    Remarque : cela suppose que le fichier est ouvert en écriture
+    """
+#
+    if type(val) == type([ ]) :
+      ligne = " "
+      for aux in val :
+        ligne = ligne + " " + str(aux)
+    else :
+      ligne = str(val)
+#
+    self.fic.write(ligne+"\n")
+#
+#
+#=======================================================================================
+#=======================================================================================
+
+
+#
+#
+if __name__ == "__main__" :
+#
+  import os
+  import sys
+  import tempfile
+#
+# 1. ==> Préalable
+#
+  Rep_Calc_LOGICIEL_global = tempfile.mktemp()
+  os.mkdir(Rep_Calc_LOGICIEL_global)
+#
+  jdc = None
+#
+# 2. ==> Création de la classe
+#
+  nomfic = "dataGrad"
+  fic = fiabilite_fichier ( jdc, Rep_Calc_LOGICIEL_global , nomfic )
+#
+# 3. ==> Ouverture du fichier
+#
+  erreur = fic.Ouvre_Fichier ( "w" )
+#
+# 4. ==> Remplissage du fichier
+#
+  if not erreur :
+    aux = ["Titre 1", "Titre 2"]
+    fic.Ecrit_Titre (aux)
+    aux = ["Ligne 1", "Ligne 2"]
+    fic.Ecrit_Commentaires (aux)
+    aux = "Ligne en forme de chaine"
+    fic.Ecrit_Commentaires (aux)
+    aux = 1789.1792
+    fic.Ecrit_Commentaires (aux)
+    aux = [1, 0.0]
+    fic.Ecrit_Valeurs (aux)
+    aux = 1958.
+    fic.Ecrit_Valeurs (aux)
+#
+# 5. ==> Fermeture du fichier
+#
+  if not erreur :
+    erreur = fic.Ferme_Fichier ( )
+#
+# 4. ==> Impression du fichier
+#
+  if not erreur :
+    erreur = fic.Imprime_Fichier ( )
+#
+# 4. ==> La fin
+#
+  Liste = os.listdir(Rep_Calc_LOGICIEL_global)
+#
+  for nomfic in Liste :
+    fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic)
+    os.chmod  (fic_total,0755)
+    os.remove (fic_total)
+  os.rmdir (Rep_Calc_LOGICIEL_global)
+#
+  if erreur :
+    mess = "Erreur " + str(erreur)
+  else :
+    mess = "Fin normale."
+  sys.exit(mess)

diff --git a/Aster/Cata/cataSTA10/Macro/fiabilite_mefisto.py b/Aster/Cata/cataSTA10/Macro/fiabilite_mefisto.py
new file mode 100644 (file)
index 0000000..f6e2dd6
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/fiabilite_mefisto.py
@@ -0,0 +1,461 @@
+#@ MODIF fiabilite_mefisto Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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 GNICOLAS G.NICOLAS
+#
+def fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global,
+                        INFO, VERSION,
+                        SEUIL, SEUIL_TYPE,
+                        VARIABLE,
+                        valeurs_lois,
+                        **args ) :
+#
+#    valeurs_lois est un dictionnaire indexé sur les variables.
+#    Chaque case, valeurs_lois[m], est un dictionnaire contenant :
+#    d["v_moy_physique"] = valeur moyenne physique
+#    d["v_moy_loi"] = valeur moyenne de la loi
+#    d["v_min_loi"] = valeur minimale de la loi
+#    d["v_max_loi"] = valeur maximale de la loi
+#    d["sigma_loi"] = ecart type de la loi
+#
+#    args est le dictionnaire des arguments optionnels
+#    args.keys() est la liste des mots-clés
+#    args.keys()[0] est la premiere valeur de cette liste
+#    args.keys()[1:] est la liste des valeurs suivantes dans cette liste
+#    args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
+#
+  """ Ecriture des données spécifiques à MEFISTO. """
+#
+  from Macro import fiabilite_fichier
+  import os
+  import string
+  import Numeric
+  from Utilitai.Utmess import  UTMESS
+#
+#____________________________________________________________________
+#
+# 1. Préalables
+#____________________________________________________________________
+#
+#
+  messages_erreur = { 0 : "Tout va bien",
+                      1 : "Fichier inconnu.",
+                      2 : "Problème d'ouverture de fichier.",
+                     10 : "Problème d'ouverture de fichier.",
+                     11 : "Problème de fermeture de fichier.",
+                     20 : "Problème d'impression de fichier.",
+                     50 : "Donnée inacceptable.",
+                    100 : "Erreur." }
+#
+  trad_oui_non = { "OUI" : 1,
+                   "NON" : 0 }
+#
+  erreur = 0
+#
+  while not erreur :
+#
+#____________________________________________________________________
+#
+# 2. Les fichiers pour le logiciel de fiabilité
+#    Ils sont créés dans le répertoire d'exécution du logiciel de fiabilité, avec leurs noms officiels
+#____________________________________________________________________
+#
+#
+    fic_dataMenu  = "dataMenu"
+    fic_dataStoch = "dataStoch"
+    fic_dataNum   = "dataNum"
+    fic_dataGrad  = "dataGrad"
+#
+#____________________________________________________________________
+#
+# 3. Construction du fichier 'dataMenu'
+#____________________________________________________________________
+#
+# 3.1 ==> Ouverture du fichier
+#
+    f_menu = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataMenu, INFO )
+    erreur = f_menu.Ouvre_Fichier ( "w" )
+    if erreur :
+      break
+#
+# 3.2 ==> Ecriture des données nécessaires
+#
+    f_menu.Ecrit_Titre ("MENU DU PROGRAMME MEFISTO")
+    f_menu.Ecrit_Titre ("1 <=> OUI et 0 <=> NON (entiers)")
+#
+    f_menu.Ecrit_Titre ("Recherche du point de conception")
+    aux = trad_oui_non[args["RECH_PT_CONCEPT"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("First Order Reliability Analyses")
+    aux = trad_oui_non[args["METHODE_FORM"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("Second Order Reliability Analyses")
+    aux = trad_oui_non[args["METHODE_SORM"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("Importance Sampling Analyses")
+    aux = trad_oui_non[args["TIRAGE_IMPORTANCE"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("Optimality Test (1) : Hessian Test")
+    aux = trad_oui_non[args["T_HESSIEN"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("Optimality Test (2) : Sphere Test")
+    aux = trad_oui_non[args["T_SPHERE"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("Optimality Test (3) : Strong Max Test")
+    aux = trad_oui_non[args["T_MAXIMUM_FORT"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("Experiment Plan")
+    aux = trad_oui_non[args["PLAN_EXPERIENCE"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+    f_menu.Ecrit_Titre ("Polynomial Taylor Approximation (order 2)")
+    aux = trad_oui_non[args["POLYNOME_TAYLOR"]]
+    f_menu.Ecrit_Valeurs (aux)
+#
+# 3.3 ==> Fermeture du fichier
+#
+    erreur = f_menu.Ferme_Fichier ( )
+    if erreur :
+      break
+#
+    if INFO >= 2 :
+      erreur = f_menu.Imprime_Fichier ( )
+      if erreur :
+        break
+#
+#____________________________________________________________________
+#
+# 4. Construction du fichier "dataStoch"
+#____________________________________________________________________
+#
+# 4.1 ==> Ouverture du fichier
+#
+    f_stoch = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataStoch, INFO )
+    erreur = f_stoch.Ouvre_Fichier ( "w" )
+    if erreur :
+      break
+#
+# 4.2 ==> Nombre d'occurence de VARIABLE
+#
+    nb_occu_variable = len(VARIABLE)
+#
+# 4.3 ==> Ecriture des données nécessaires
+#
+    f_stoch.Ecrit_Titre ("Code name")
+    aux=string.replace(VERSION,"_",".")
+    aux=string.replace(aux,"N","n")
+    aux=string.replace(aux,"V","v")
+    f_stoch.Ecrit_Valeurs ( "aster_" + aux )
+#
+    aux = [ "Gradients evaluated by the code" ]
+    aux.append("1 : Au moins 1 ; 0 : aucun")
+    f_stoch.Ecrit_Titre (aux)
+    gradient = 0
+    for m in VARIABLE :
+      if m["GRADIENT"] == "OUI" : gradient = 1
+    f_stoch.Ecrit_Valeurs (gradient)
+#
+    f_stoch.Ecrit_Titre ("Variates number")
+    f_stoch.Ecrit_Valeurs ( nb_occu_variable )
+#
+    aux = [ "Stochastic Variates" ]
+    aux.append("1: Uniforme (min, max)")
+    aux.append("2: Normal (mean, std dev)")
+    aux.append("3: LogNormal (mean, std dev, min)")
+    aux.append("4: Normal Truncated (mean, std dev, min, max)")
+    f_stoch.Ecrit_Titre (aux)
+#
+    for m in VARIABLE :
+#
+      d = valeurs_lois[m]
+      if m["LOI"] == "UNIFORME" :
+        f_stoch.Ecrit_Valeurs ( [ m["NOM"],  1 , d["v_min_loi"] , d["v_max_loi"] ] )
+      elif m["LOI"] == "NORMALE" :
+        f_stoch.Ecrit_Valeurs ( [ m["NOM"],  2 , d["v_moy_loi"] , d["sigma_loi"] ] )
+      elif m["LOI"] == "LOGNORMALE" :
+        f_stoch.Ecrit_Valeurs ( [ m["NOM"],  3 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] ] )
+      elif m["LOI"] == "NORMALE_TRONQUEE" :
+        f_stoch.Ecrit_Valeurs ( [ m["NOM"],  4 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] , d["v_max_loi"] ] )
+      else :
+        erreur = 50
+#
+    if erreur :
+      break
+#
+    f_stoch.Ecrit_Titre ("Initial Points")
+    for m in VARIABLE :
+      if m["POINT_INI"] is None :
+        aux = valeurs_lois[m]["v_moy_physique"]
+      else :
+        aux = m["POINT_INI"]
+      f_stoch.Ecrit_Valeurs ( aux )
+#
+    f_stoch.Ecrit_Titre ("Reference Points")
+    for m in VARIABLE :
+      if m["POINT_REF"] is None :
+        aux = valeurs_lois[m]["v_moy_physique"]
+      else :
+        aux = m["POINT_REF"]
+      f_stoch.Ecrit_Valeurs ( aux )
+#
+    f_stoch.Ecrit_Titre ("Design Points")
+    for m in VARIABLE :
+      if args["RECH_PT_CONCEPT"] == "OUI" :
+        aux = 1792.
+      elif m["POINT_CONCEPT"] is None :
+        aux = valeurs_lois[m]["v_moy_physique"]
+      else :
+        aux = m["POINT_CONCEPT"]
+      f_stoch.Ecrit_Valeurs ( aux )
+#
+    f_stoch.Ecrit_Titre ("Correlation matrix fictive")
+#    if args.has_key('MATRICE'):
+    if args["MATRICE"] != None:
+      if len(args["MATRICE"]) != nb_occu_variable**2:
+#        +' DU MOT CLE MATRICE DOIT ETRE EGAL A : '
+#        +str(nb_occu_variable**2))
+        UTMESS('F','FIABILITE0_1',vali=nb_occu_variable**2)
+      for m in range(nb_occu_variable) :
+        aux = [ ]
+        for n in range(nb_occu_variable) :
+          aux.append(args["MATRICE"][n + m*nb_occu_variable])
+        f_stoch.Ecrit_Valeurs ( aux )
+    else:
+        aux=Numeric.identity(nb_occu_variable)
+        aux=Numeric.concatenate(aux)
+        aux=aux.tolist()
+        f_stoch.Ecrit_Valeurs ( aux )
+#
+    f_stoch.Ecrit_Titre ("Parameter threshold value")
+    if SEUIL_TYPE == "MAXIMUM" :
+      aux = SEUIL
+    else :
+      aux = -SEUIL
+    f_stoch.Ecrit_Valeurs ( aux )
+#
+# 4.4 ==> Fermeture du fichier
+#
+    erreur = f_stoch.Ferme_Fichier ( )
+    if erreur :
+      break
+#
+    if INFO >= 2 :
+      erreur = f_stoch.Imprime_Fichier ( )
+      if erreur :
+        break
+#
+#____________________________________________________________________
+#
+# 5. Construction du fichier 'dataNum'
+#____________________________________________________________________
+#
+# 5.1 ==> Ouverture du fichier
+#
+    f_num = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataNum, INFO )
+    erreur = f_num.Ouvre_Fichier ( "w" )
+    if erreur :
+      break
+#
+# 5.2 ==> Ecriture des données nécessaires
+#
+    f_num.Ecrit_Titre ("Parameters : EpsU, EpsG, Tau, Omega, iterMax")
+    if args["RECH_PT_CONCEPT"] == "OUI" :
+      f_num.Ecrit_Valeurs (args["EPSILON_U"])
+      f_num.Ecrit_Valeurs (args["EPSILON_G"])
+      f_num.Ecrit_Valeurs (args["TAU"])
+      f_num.Ecrit_Valeurs (args["OMEGA"])
+      f_num.Ecrit_Valeurs (args["ITER_MAX"])
+    else :
+      aux = 0.1848
+      for k in range(5) :
+        f_num.Ecrit_Valeurs (aux)
+#
+    f_num.Ecrit_Titre ("Parameters : hgrad, hhess")
+    f_num.Ecrit_Valeurs (args["HGRAD"])
+    f_num.Ecrit_Valeurs (args["HHESS"])
+#
+    aux = [ "Parameter Optimality Test(sphere)" ]
+    aux.append("1: Parametric Method (Point Number in each direction)")
+    aux.append("2: Gaussian Method (Total Point Number)")
+    aux.append("3: Rejection Method (Total Point Number)")
+    f_num.Ecrit_Titre (aux)
+#
+    if args["T_SPHERE"] == "OUI" :
+#
+      if args["METHODE_TEST"] == "PARAMETRIQUE" :
+        aux1 = 1
+      elif args["METHODE_TEST"] == "GAUSSIENNE" :
+        aux1 = 2
+      elif args["METHODE_TEST"] == "REJECTION" :
+        aux1 = 3
+      else :
+        self.cr.warn("METHODE DE TEST : "+args["METHODE_TEST"])
+        erreur = 50
+        break
+#
+      aux2 = args["NB_POINT"]
+#
+    else :
+#
+#     remarque : il faut mettre une valeur plausible en aux1, sinon plantage violent ...
+      aux1 = 1
+      aux2 = 1789
+#
+    f_num.Ecrit_Valeurs ( [ aux1 , aux2 ] )
+#
+    aux = [ "Parameters : alpha, beta" ]
+    aux.append("alpha: common net")
+    aux.append("beta: extreme net")
+    f_num.Ecrit_Titre (aux)
+    if args["PLAN_EXPERIENCE"] == "OUI" :
+      aux1 = args["ALPHA"]
+      aux2 = args["BETA"]
+    else :
+      aux1 = 1789.0
+      aux2 = 1789.0
+    f_num.Ecrit_Valeurs ( aux1 )
+    f_num.Ecrit_Valeurs ( aux2 )
+#
+    f_num.Ecrit_Titre ("Parameters Strong Max Test : cosLim, dProb")
+    if args["T_MAXIMUM_FORT"] == "OUI" :
+      aux1 = args["COS_LIM"]
+      aux2 = args["DPROB"]
+    else :
+      aux1 = 0.1789
+      aux2 = 0.1789
+    f_num.Ecrit_Valeurs ( aux1 )
+    f_num.Ecrit_Valeurs ( aux2 )
+#
+    f_num.Ecrit_Titre ("Parameter Importance Samplings : Simulation Number")
+    if args["TIRAGE_IMPORTANCE"] == "OUI" :
+      aux = args["NB_SIMULATION"]
+    else :
+      aux = 1945
+    f_num.Ecrit_Valeurs ( aux )
+#
+# 5.3 ==> Fermeture du fichier
+#
+    erreur = f_num.Ferme_Fichier ( )
+    if erreur :
+      break
+#
+    if INFO >= 2 :
+      erreur = f_num.Imprime_Fichier ( )
+      if erreur :
+        break
+#
+#____________________________________________________________________
+#
+# 6. Construction du fichier 'dataGrad'
+#____________________________________________________________________
+#
+# 6.1 ==> Création du fichier
+#
+    f_grad = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataGrad, INFO )
+    erreur = f_grad.Ouvre_Fichier ( "w" )
+    if erreur :
+      break
+#
+# 6.2 ==> Ecriture des données nécessaires
+#
+    f_grad.Ecrit_Titre ("Commentaires")
+#
+    for m in VARIABLE :
+      f_grad.Ecrit_Commentaires (m["NOM"])
+      if m["GRADIENT"] == "OUI" :
+        gradient = 1
+        increment = 0.0
+      else :
+        gradient = 0
+        increment = m["INCREMENT"]
+      aux = [gradient,increment]
+      f_grad.Ecrit_Valeurs (aux)
+#
+# 6.3 ==> Fermeture du fichier
+#
+    erreur = f_grad.Ferme_Fichier ( )
+    if erreur :
+      break
+#
+    if INFO >= 2 :
+      erreur = f_grad.Imprime_Fichier ( )
+      if erreur :
+        break
+#
+#____________________________________________________________________
+#
+# 7. C'est fini !
+#____________________________________________________________________
+#
+    break
+#
+  if erreur :
+    if not messages_erreur.has_key(erreur) :
+      erreur = 100
+    self.cr.warn(messages_erreur[erreur])
+    erreur = 11
+#
+  return erreur
+#
+##########################  Fin de la fonction##################################
+#
+##########################   Auto-test##################################
+#
+if __name__ == "__main__" :
+#
+  import os
+  import sys
+  import tempfile
+#
+  Rep_Calc_LOGICIEL_global = tempfile.mktemp()
+  os.mkdir(Rep_Calc_LOGICIEL_global)
+#
+  INFO = 2
+  VERSION = "V3_2"
+  SEUIL = 1789.
+  SEUIL_TYPE = "MAXIMUM"
+  VARIABLE = []
+  args = {}
+  valeurs = {}
+#
+  erreur = fiabilite_mefisto ( None, Rep_Calc_LOGICIEL_global,
+                        INFO, VERSION,
+                        SEUIL, SEUIL_TYPE,
+                        VARIABLE,
+                        valeurs,
+                        **args )
+###  print "Erreur = ", erreur
+  Liste = os.listdir(Rep_Calc_LOGICIEL_global)
+#
+  for nomfic in Liste :
+    fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic)
+    os.chmod  (fic_total,0755)
+    os.remove (fic_total)
+  os.rmdir (Rep_Calc_LOGICIEL_global)
+#
+  sys.exit("blabla")

diff --git a/Aster/Cata/cataSTA10/Macro/gene_vari_alea_ops.py b/Aster/Cata/cataSTA10/Macro/gene_vari_alea_ops.py
new file mode 100644 (file)
index 0000000..4c1ade8
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/gene_vari_alea_ops.py
@@ -0,0 +1,90 @@
+#@ MODIF gene_vari_alea_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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.        
+# ======================================================================
+
+from math import sqrt,log,exp,pi,atan2,tan
+
+def gene_vari_alea_ops(self,**args):
+  self.set_icmd(1)
+  return 0
+
+def gene_vari_alea_init(self,d):
+  from Utilitai.Utmess import  UTMESS
+  a     =self.etape['BORNE_INF']
+  moyen =self.etape['VALE_MOY' ]
+  TYPE  =self.etape['TYPE']
+  if self['INIT_ALEA']!=None :
+     jump =self.etape['INIT_ALEA' ]
+     self.iniran(jump)
+  if   TYPE=='EXP_TRONQUEE' :
+     b     =self.etape['BORNE_SUP']
+     if (a>=b) :
+         UTMESS('F','PROBA0_1',valr=[a,b])
+     elif (moyen<=a)or(moyen>=b) :
+         UTMESS('F','PROBA0_2',valr=[a,moyen,b])
+     k=1./(moyen-a)
+     if (exp(-b*k)<1.E-12) :
+         UTMESS('F','PROBA0_3')
+     # résolution par point fixe
+     eps   =1.E-4
+     nitmax=100000
+     test  =0.
+     while abs((test-k)/k)>eps :
+         test = k
+         k    = 1./(moyen-(a*exp(-a*k) - b*exp(-b*k))/(exp(-a*k) - exp(-b*k)))
+     # génération de la variable aléatoire
+     alpha = exp(-a*k) - exp(-b*k)
+     self.sd.valeur=-( log(exp(-a*k)-alpha*self.getran()[0] ) ) /k
+  elif TYPE=='EXPONENTIELLE' :
+     if (moyen<=a) :
+        UTMESS('F','PROBA0_4',valr=[moyen,a])
+     v = moyen-a
+     u=self.getran()[0]
+     x = -log(1-u)
+     self.sd.valeur=a + v*x
+  elif TYPE=='GAMMA'         :
+     delta =self.etape['COEF_VAR' ]
+     if (moyen<=a) :
+        UTMESS('F','PROBA0_4',valr=[moyen,a])
+     v = moyen-a
+     alpha = 1./(delta**2)
+     if (alpha<=1.) :
+        UTMESS('F','PROBA0_5')
+     gamma2 = alpha-1.
+     gamm1  = 1./gamma2
+     beta   = sqrt(2.*alpha-1.)
+     beta2  = 1./(beta**2)
+     f0     = 0.5+(1./pi)*atan2(-gamma2/beta,1.)
+     c1     = 1.-f0
+     c2     = f0-0.5
+     vref   = 0.
+     vv     = -1.
+#
+     while (-vv>vref) :
+        u=self.getran()[0]
+        gamdev = beta*tan(pi*(u*c1+c2))+gamma2
+        unif=self.getran()[0]
+        if unif<0. :
+           UTMESS('F','PROBA0_6')
+        vv= -log(unif)
+        vref = log(1+beta2*((gamdev-gamma2)**2))+gamma2*log(gamdev*gamm1)-gamdev+gamma2
+#
+     if vv<=0. :
+        UTMESS('F','PROBA0_7')
+     self.sd.valeur = a + v*(delta**2)*gamdev

diff --git a/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py b/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py
new file mode 100644 (file)
index 0000000..445a766
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py
@@ -0,0 +1,2088 @@
+#@ MODIF impr_diag_campbell_ops Macro  DATE 28/07/2009   AUTEUR TORKHANI M.TORKHANI 
+
+#            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.        
+# ======================================================================
+# RESPONSABLE Mohamed TORKHANI
+
+import Numeric
+import aster
+from Accas import _F
+from Numeric import *
+
+def CLASS_MODES(self,L_MODES, NFREQ, NFREQ_camp, L_GR_NOEUD, VITE_ROTA) :
+
+    
+    POST_RELEVE_T     =self.get_cmd('POST_RELEVE_T') 
+    EXTR_MODE         =self.get_cmd('EXTR_MODE')
+    NORM_MODE         =self.get_cmd('NORM_MODE')
+    DETRUIRE          =self.get_cmd('DETRUIRE')
+#  Classification des modes en flexion, en torsion et en traction/compression
+    NFREQ_f=0;
+    NFREQ_t=0;
+    NFREQ_l=0;
+
+    nbF_f=[];
+    nbF_t=[];
+    nbF_l=[];
+    lflex={};
+    ltors={};
+    llong={};
+
+    NBV=len(L_MODES);
+
+    Ntot =Numeric.zeros((NFREQ),Numeric.Float);
+    Nflex=Numeric.zeros((NFREQ),Numeric.Float);
+    Ntors=Numeric.zeros((NFREQ),Numeric.Float);
+    Nlong=Numeric.zeros((NFREQ),Numeric.Float);
+
+    RESULT=[];
+
+    NBV=len(L_MODES);
+    NOEU=len(L_GR_NOEUD);
+    MODEf=[0]*NBV ;
+    MODEt=[0]*NBV ;
+    MODEl=[0]*NBV ;
+    NVT =Numeric.zeros((NFREQ, NBV),Numeric.Float);
+   
+    for ii in range(NBV):
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)
+        chaine = 'Vitesse de rotation : %15.5E' %VITE_ROTA[ii]
+        aster.affiche('RESULTAT', chaine)
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)
+        #IMPR_RESU(
+        #FORMAT='RESULTAT',
+        # RESU=_F(RESULTAT=L_MODES[ii],NOM_PARA=('NUME_MODE','FREQ','OMEGA2'),FORM_TABL='OUI'),
+        # )
+
+        # -------------------------------------------------------------------
+        # Extraire les modes en module, definir les differents types de modes
+        # -------------------------------------------------------------------
+        
+        tabmoN=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE',
+                                NOEUD=L_GR_NOEUD,
+                                RESULTAT=L_MODES[ii],
+                                NOM_CHAM='DEPL',
+                                TOUT_ORDRE='OUI',
+                                NOM_CMP=('DX','DY','DZ', 'DRX', 'DRY', 'DRZ'),
+                                FORMAT_C='MODULE',
+                                OPERATION='EXTRACTION',),);
+
+        #IMPR_TABLE(TABLE=tabmoN);
+        
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)
+        chaine='Rapport de type de modes'
+        aster.affiche('RESULTAT', chaine)
+        chaine='Flexion         Torsion         Traction/compression'
+        aster.affiche('RESULTAT', chaine)
+        #for jj in range(NFREQ):
+        jj =0;
+      
+        for jj in range(NFREQ):
+            Ntot[jj]  =0.0
+            Nflex[jj] =0.0
+            Ntors[jj] =0.0
+            Nlong[jj] =0.0
+            for ll in range(NOEU):
+                nmod=NOEU*jj+ll
+                dx  = tabmoN['DX' ,nmod+1]
+                dy  = tabmoN['DY' ,nmod+1]
+                dz  = tabmoN['DZ' ,nmod+1]
+                drx = tabmoN['DRX',nmod+1]
+                dry = tabmoN['DRY',nmod+1]
+                drz = tabmoN['DRZ',nmod+1]
+            Ntot1  = dx**2+dy**2+dz**2+drx**2+dry**2+drz**2
+            Nflex1 = dy**2+dz**2+dry**2+drz**2
+            Ntors1 = drx**2            
+            Nlong1 = dx**2
+            Ntot[jj]  = Ntot[jj]  + Ntot1
+            Nflex[jj] = Nflex[jj] + Nflex1
+            Ntors[jj] = Ntors[jj] + Ntors1
+            Nlong[jj] = Nlong[jj] + Nlong1
+            Ntot[jj]  = Numeric.sqrt(Ntot[jj])
+            Nflex[jj] = Numeric.sqrt(Nflex[jj])/ Ntot[jj]
+            Ntors[jj] = Numeric.sqrt(Ntors[jj])/ Ntot[jj]
+            Nlong[jj] = Numeric.sqrt(Nlong[jj])/ Ntot[jj]
+            #print Nflex[jj],Ntors[jj],Nlong
+            chaine = '%15.5E %15.5E %15.5E' %(Nflex[jj],Ntors[jj],Nlong[jj])
+            aster.affiche('RESULTAT', chaine)
+        
+        DETRUIRE(CONCEPT=_F(NOM=(tabmoN)),INFO=1)
+
+        jf=0;
+        jt=0;
+        jl=0;
+
+        for jj in range(NFREQ):
+            NVT[jj][ii]=jj+1;  
+            if (Nflex[jj]> Ntors[jj]) and (Nflex[jj]> Nlong[jj]):
+                #print "ii jf jj"
+                lflex[(ii,jf)]=jj+1;
+                #print ii, jf, jj
+                #print lflex
+                jf=jf+1; 
+                 
+            
+            elif (Ntors[jj]> Nflex[jj]) and (Ntors[jj]> Nlong[jj]):
+                ltors[(ii,jt)]=jj+1;
+                jt=jt+1; 
+                     
+            
+            elif (Nlong[jj]> Nflex[jj]) and (Nlong[jj]> Ntors[jj]):
+                llong[(ii,jl)]=jj+1;
+                jl=jl+1; 
+    
+        nbF_f.append(jf);
+        nbF_t.append(jt);
+        nbF_l.append(jl);  
+                
+    NFREQ_f = min(nbF_f)
+    NFREQ_t = min(nbF_t)
+    NFREQ_l = min(nbF_l)
+    
+    if NFREQ_f>0:
+        NVT_f =Numeric.zeros((NFREQ_f, NBV),Numeric.Int); 
+        l_f   =Numeric.zeros((NBV, NFREQ_f),Numeric.Int);  
+    if NFREQ_t>0:
+       NVT_t  =Numeric.zeros((NFREQ_t, NBV),Numeric.Int);
+       l_t    =Numeric.zeros((NBV, NFREQ_t),Numeric.Int); 
+    if NFREQ_l>0:
+       NVT_l  =Numeric.zeros((NFREQ_l, NBV),Numeric.Int);
+       l_l    =Numeric.zeros((NBV, NFREQ_l),Numeric.Int);   
+    else:
+       NVT_l  = 0;
+        
+    for ii in range(NBV):  
+        for jj in range(NFREQ_f): 
+            NVT_f[jj][ii]=lflex[ii,jj]; 
+            l_f[ii][jj]  =lflex[ii,jj]; 
+        
+        for jj in range(NFREQ_t): 
+            NVT_t[jj][ii]=ltors[ii,jj]; 
+            l_t[ii][jj]  =ltors[ii,jj];    
+        
+        for jj in range(NFREQ_l): 
+            NVT_l[jj][ii]=llong[ii,jj];
+            l_l[ii][jj]  =llong[ii,jj]; 
+    
+    for ii in range(NBV):   
+        # ----------------------------------------------
+        # Extraire la base des modes en flexion
+        # ----------------------------------------------
+        if NFREQ_f >0:
+            lmodef =list(l_f[ii]);
+            #print 'lmodef'
+            #print lmodef            
+    
+            MODEf[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], 
+                                                        NUME_MODE = lmodef)
+                                );      
+            
+            MODEf[ii]= NORM_MODE (MODE=MODEf[ii],
+                             reuse = MODEf[ii],                       
+                             NORME='TRAN',
+                             );
+            #IMPR_RESU(
+            #        FORMAT='RESULTAT',
+            #        RESU=_F(RESULTAT=MODEf[ii],NOM_PARA=('NUME_MODE','FREQ'),FORM_TABL='OUI'),
+            #        )
+        # ----------------------------------------------
+        # Extraire la base des modes en torsion
+        # ----------------------------------------------
+        if NFREQ_t >0:
+            lmodet =list(l_t[ii]);
+            #print 'lmodet'
+            #print lmodet  
+            MODEt[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], 
+                                                        NUME_MODE = lmodet)
+                                );
+            MODEt[ii]= NORM_MODE (MODE=MODEt[ii],
+                             reuse = MODEt[ii],                       
+                             AVEC_CMP=('DRX','DRY', 'DRZ'),
+                             );    
+            #IMPR_RESU(
+            #        FORMAT='RESULTAT',
+            #         RESU=_F(RESULTAT=MODEt[ii],NOM_PARA=('NUME_MODE','FREQ'),FORM_TABL='OUI'),
+            #        )
+        # ----------------------------------------------
+        # Extraire la base des modes en longi
+        # ----------------------------------------------
+        if NFREQ_l >0:
+            lmodel =list(l_l[ii]);
+            #print 'lmodel'
+            #print lmodel  
+            MODEl[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], 
+                                                        NUME_MODE = lmodel)
+                                );
+            
+            MODEl[ii]= NORM_MODE (MODE=MODEl[ii],
+                             reuse = MODEl[ii],                       
+                             NORME='TRAN',
+                             );
+            #IMPR_RESU(
+            #        FORMAT='RESULTAT',
+            #         RESU=_F(RESULTAT=MODEl[ii],NOM_PARA=('NUME_MODE','FREQ'),FORM_TABL='OUI'),
+            #        )    
+        
+        
+    # -----------------------------------------------------------
+    # Nombre de frequences par type pour le diagramme de Campbell 
+    # -----------------------------------------------------------
+    NFREQ_fc=0;
+    for jj in range(NFREQ_f): 
+        if NVT_f[jj][NBV-1]<= NFREQ_camp: 
+            NFREQ_fc=NFREQ_fc+1;
+   
+    NFREQ_tc=0;
+    for jj in range(NFREQ_t): 
+        if NVT_t[jj][NBV-1]<= NFREQ_camp: 
+            NFREQ_tc=NFREQ_tc+1;
+ 
+    NFREQ_lc=0;
+    for jj in range(NFREQ_l): 
+        if NVT_l[jj][NBV-1]<= NFREQ_camp: 
+            NFREQ_lc=NFREQ_lc+1;
+      
+    
+
+    RESULT =[NFREQ_f,NFREQ_t,NFREQ_l,MODEf,MODEt,MODEl,NVT,NVT_f,NVT_t,NVT_l,NFREQ_fc,NFREQ_tc,NFREQ_lc]
+    
+   
+    
+    return RESULT
+
+
+#------------------------------------------------------------------------------------------------
+def EXTR_FREQ(self,L_MODES, L_MODEf,L_MODEt,L_MODEl, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l) :
+#Extraire les frequences
+    
+    RECU_TABLE        =self.get_cmd('RECU_TABLE') 
+    IMPR_TABLE        =self.get_cmd('IMPR_TABLE') 
+    DETRUIRE          =self.get_cmd('DETRUIRE')        
+    
+    
+    RESULT=[];
+      
+    NBV   =len(L_MODES); 
+    FRQ   =Numeric.zeros((NFREQ,NBV),Numeric.Float); 
+    FRQ_f =Numeric.zeros((NFREQ_f,NBV),Numeric.Float); 
+    FRQ_t =Numeric.zeros((NFREQ_t,NBV),Numeric.Float);
+    FRQ_l =Numeric.zeros((NFREQ_l,NBV),Numeric.Float); 
+    AMO_f =Numeric.zeros((NFREQ_f,NBV),Numeric.Float); 
+    FRQ_max = 0.0;  
+    EPSI    =1.E-10;
+    for ii in range(NBV):
+            
+        # frequences totales
+        tabfreq = RECU_TABLE(CO=L_MODES[ii],NOM_PARA=('NUME_MODE','FREQ','AMOR_REDUIT'),);
+        IMPR_TABLE(TABLE=tabfreq);
+        
+        for jj in range(NFREQ):
+            FRQ[jj][ii]=tabfreq['FREQ',jj+1]
+            if FRQ_max < FRQ[jj][ii]:
+                FRQ_max=FRQ[jj][ii];
+        
+        if NFREQ_f>0:
+            # frequences des modes en flexion
+            tabfr_f = RECU_TABLE(CO=L_MODEf[ii],NOM_PARA=('FREQ','AMOR_REDUIT'),)
+            IMPR_TABLE(TABLE=tabfr_f);
+            for jj in range(NFREQ_f):
+                FRQ_f[jj][ii]=tabfr_f['FREQ',jj+1];
+                AMO_f[jj][ii]=tabfr_f['AMOR_REDUIT',jj+1];
+                if abs(AMO_f[jj][ii])<EPSI:
+                    AMO_f[jj][ii]=0.0;
+            DETRUIRE(CONCEPT=_F(NOM=(tabfr_f)),INFO=1)
+        
+        if NFREQ_t>0:
+            # frequences des modes en torsion
+            tabfr_t = RECU_TABLE(CO=L_MODEt[ii],NOM_PARA='FREQ',)
+            #IMPR_TABLE(TABLE=tabfr_t);
+            for jj in range(NFREQ_t):
+                FRQ_t[jj][ii]=tabfr_t['FREQ',jj+1]
+            
+            DETRUIRE(CONCEPT=_F(NOM=(tabfr_t)),INFO=1)
+                              
+        if NFREQ_l>0:                 
+            # frequences des modes en traction / compression
+            tabfr_l = RECU_TABLE(CO=L_MODEl[ii],NOM_PARA='FREQ',)
+            #IMPR_TABLE(TABLE=tabfr_l);
+            for jj in range(NFREQ_l):
+                FRQ_l[jj][ii]=tabfr_l['FREQ',jj+1]
+            
+            DETRUIRE(CONCEPT=_F(NOM=(tabfr_l)),INFO=1)
+        
+        DETRUIRE(CONCEPT=_F(NOM=(tabfreq)),INFO=1)
+ 
+
+    RESULT = [FRQ,FRQ_f,FRQ_t, FRQ_l, FRQ_max, AMO_f];
+    return RESULT
+
+
+#------------------------------------------------------------------------------------------------
+
+def TRI_MODE_MACf(self, MACf,NFREQ_f, NVT_f, IV) :
+#Tri des frequences par calcul des coefficients MAC
+
+    
+    DETRUIRE          =self.get_cmd('DETRUIRE')
+    
+    # base mode 1
+    tmacf =Numeric.zeros((NFREQ_f,NFREQ_f),Numeric.Float);
+    #chaine='MAC1111'
+    #aster.affiche('RESULTAT', chaine)
+    #chaine=str(IV);
+    #aster.affiche('RESULTAT', chaine)
+    #IMPR_TABLE(TABLE=MACf)
+    for jj in range(NFREQ_f):
+        # base mode 2
+        for ll in range(NFREQ_f):
+            nmac= NFREQ_f*jj+ll
+            #print nmac
+            tmacf[jj][ll]=MACf['MAC',nmac+1] 
+    chaine='Modes de flexion'
+    aster.affiche('RESULTAT', chaine)
+    affiche_tab(tmacf,NFREQ_f, NFREQ_f);  
+
+    for j2 in range(NFREQ_f):
+        XMAX=0.0
+        JREC=int(NVT_f[j2][IV+1]-1);        
+        #print "JREC"
+        #print JREC
+        for j1 in range(NFREQ_f):
+
+            #print tmacf[j1][JREC] 
+            #print XMAX
+            if tmacf[j1][JREC] > XMAX:
+                XMAX=tmacf[j1][JREC]
+                I1B=j1+1
+        #chaine='XMAX ' + str(XMAX)+ ' I1B ' + str(I1B);
+        #aster.affiche('RESULTAT', chaine) 
+        # test d'existance de I1B dans le tableau de connexion
+        I1B_exist =0;
+        for jj in range(j2):
+            if I1B == NVT_f[jj][IV]:
+                I1B_exist =1;
+        if I1B_exist ==0:     # IB1 n'existe pas
+            NVT_f[j2][IV]= I1B;
+        else:
+            NVT_f[j2][IV]=0;
+    DETRUIRE(CONCEPT=_F(NOM=(MACf)),INFO=1);
+
+    return NVT_f           
+
+#------------------------------------------------------------------------------------------------
+
+def TRI_MODE_MACt(self, MACt,NFREQ_t, NVT_t, IV) :
+#Tri des frequences par calcul des coefficients MAC
+
+    
+    DETRUIRE          =self.get_cmd('DETRUIRE')
+    
+    # base mode 1
+    tmact =Numeric.zeros((NFREQ_t,NFREQ_t),Numeric.Float);
+    #chaine='TRI_MODE_MACt'
+    #aster.affiche('RESULTAT', chaine)
+    #chaine=str(IV);
+    #aster.affiche('RESULTAT', chaine)
+    #IMPR_TABLE(TABLE=MACt)
+    for jj in range(NFREQ_t):
+        # base mode 2
+        for ll in range(NFREQ_t):
+            nmac= NFREQ_t*jj+ll
+            #print nmac
+            tmact[jj][ll]=MACt['MAC',nmac+1] 
+    chaine='Modes en torsion'
+    aster.affiche('RESULTAT', chaine)
+    affiche_tab(tmact,NFREQ_t, NFREQ_t);  
+
+    for j2 in range(NFREQ_t):
+        XMAX=0.0
+        JREC=int(NVT_t[j2][IV+1]-1);        
+        #print "JREC"
+        #print JREC
+        for j1 in range(NFREQ_t):
+
+            #print tmact[j1][JREC] 
+            #print XMAX
+            if tmact[j1][JREC] > XMAX:
+                XMAX=tmact[j1][JREC]
+                I1B=j1+1
+        #NVT_t[j2][IV]= I1B
+        # test d'existance de I1B dans le tableau de connexion
+        I1B_exist =0;
+        for jj in range(j2):
+            if I1B == NVT_t[jj][IV]:
+                I1B_exist =1; # IB1 existe deja
+        if I1B_exist ==0:     # IB1 n'existe pas
+            NVT_t[j2][IV]= I1B;
+        else:
+            NVT_t[j2][IV]=0;
+     
+    DETRUIRE(CONCEPT=_F(NOM=(MACt)),INFO=1);
+
+    return NVT_t           
+
+#------------------------------------------------------------------------------------------------
+
+def TRI_MODE_MACl(self, MACl,NFREQ_l, NVT_l, IV) :
+#Tri des frequences par calcul des coefficients MAC
+    
+    
+    DETRUIRE          =self.get_cmd('DETRUIRE')
+    
+    # base mode 1
+    tmacl =Numeric.zeros((NFREQ_l,NFREQ_l),Numeric.Float);
+    #chaine='TRI_MODE_MACl'
+    #aster.affiche('RESULTAT', chaine)
+    #chaine=str(IV);
+    #aster.affiche('RESULTAT', chaine)
+    #IMPR_TABLE(TABLE=MACl)
+    for jj in range(NFREQ_l):
+        # base mode 2
+        for ll in range(NFREQ_l):
+            nmac= NFREQ_l*jj+ll
+            #print nmac
+            tmacl[jj][ll]=MACl['MAC',nmac+1] 
+    chaine='Modes en traction/compression'
+    aster.affiche('RESULTAT', chaine)
+    affiche_tab(tmacl,NFREQ_l, NFREQ_l);  
+
+    for j2 in range(NFREQ_l):
+        XMAX=0.0
+        JREC=int(NVT_l[j2][IV+1]-1);        
+        #print "JREC"
+        #print JREC
+        for j1 in range(NFREQ_l):
+
+            #print tmacl[j1][JREC] 
+            #print XMAX
+            if tmacl[j1][JREC] > XMAX:
+                XMAX=tmacl[j1][JREC]
+                I1B=j1+1
+        #NVT_l[j2][IV]= I1B
+        # test d'existance de I1B dans le tableau de connexion
+        I1B_exist =0;
+        for jj in range(j2):
+            if I1B == NVT_l[jj][IV]:
+                I1B_exist =1; # IB1 existe deja
+        if I1B_exist ==0:     # IB1 n'existe pas
+            NVT_l[j2][IV]= I1B;
+        else:
+            NVT_l[j2][IV]=0;
+     
+    DETRUIRE(CONCEPT=_F(NOM=(MACl)),INFO=1);
+
+    return NVT_l           
+
+
+#------------------------------------------------------------------------------------------------
+
+def CALC_MACf(self, L_MODEf, NFREQ_f) :
+#Calcul de la matrice MAC entre les deux bases successives 
+
+    MAC_MODES         =self.get_cmd('MAC_MODES')
+    
+    NBV=len(L_MODEf);
+    tmacf =Numeric.zeros((NFREQ_f,NFREQ_f),Numeric.Float);
+    MACf=[0]*NBV
+
+    for ii in range(NBV-1):
+        if NFREQ_f>0:
+             MACf[ii]=MAC_MODES(BASE_1=L_MODEf[ii],
+                   BASE_2=L_MODEf[ii+1],
+                   INFO  =2,
+                   );
+            #IMPR_TABLE(TABLE=MACf[ii])
+
+    return MACf
+
+
+#------------------------------------------------------------------------------------------------
+
+def CALC_MACt(self, L_MODEt, NFREQ_t) :
+#Calcul de la matrice MAC entre les deux bases successives 
+
+    MAC_MODES         =self.get_cmd('MAC_MODES')
+
+    NBV=len(L_MODEt);
+    tmact =Numeric.zeros((NFREQ_t,NFREQ_t),Numeric.Float);
+    MACt=[0]*NBV
+
+    for ii in range(NBV-1):
+        if NFREQ_t>0:
+             MACt[ii]=MAC_MODES(BASE_1=L_MODEt[ii],
+                   BASE_2=L_MODEt[ii+1],
+                   INFO  =2,
+                   );
+            #IMPR_TABLE(TABLE=MACt[ii])
+
+    return MACt
+        
+#-----------------------------------------------------------------------------------------------
+
+def CALC_MACl(self, L_MODEl, NFREQ_l) :
+#Calcul de la matrice MAC entre les deux bases successives 
+
+    MAC_MODES         =self.get_cmd('MAC_MODES')
+
+    NBV=len(L_MODEl);
+    tmacl =Numeric.zeros((NFREQ_l,NFREQ_l),Numeric.Float);
+    MACl=[0]*NBV
+
+    for ii in range(NBV-1):
+        if NFREQ_l>0:
+             MACl[ii]=MAC_MODES(BASE_1=L_MODEl[ii],
+                   BASE_2=L_MODEl[ii+1],
+                   INFO  =2,
+                   );
+            #IMPR_TABLE(TABLE=MACl[ii])
+
+    return MACl
+        
+#-----------------------------------------------------------------------------------------------
+
+def CALC_PREC(self,MODEf,NFREQ_f,L_GR_NOEUD, typ_prec) :        
+#Calcul le sens de precession pour un mode a une vitesse de rotation donnee
+#Type de precession, 1 somme, 2 grande orbite
+    
+    
+    POST_RELEVE_T     =self.get_cmd('POST_RELEVE_T')  
+    DETRUIRE          =self.get_cmd('DETRUIRE')
+
+    XSMIN=1e-2;
+    NBV=len(MODEf);
+    NOEU=len(L_GR_NOEUD);
+    SENS=Numeric.zeros((NFREQ_f, NBV),Numeric.Float); 
+    for ii in range(NBV):
+        # -------------------------------------------------------------------------
+        # Extraire les parties reelles, imaginaires et modules des modes en flexion        
+        # -------------------------------------------------------------------------
+        
+        tabmoR_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_REEL',
+                                #GROUP_NO=L_GR_NOEUD,
+                                NOEUD=L_GR_NOEUD,
+                                RESULTAT=MODEf[ii],
+                                NOM_CHAM='DEPL',
+                                TOUT_ORDRE='OUI',
+                                NOM_CMP=('DX','DY','DZ'),
+                                FORMAT_C='REEL',
+                                OPERATION='EXTRACTION',),);
+        tabmoI_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_IMAG',
+                                #GROUP_NO=L_GR_NOEUD,
+                                NOEUD=L_GR_NOEUD,
+                                RESULTAT=MODEf[ii],
+                                NOM_CHAM='DEPL',
+                                TOUT_ORDRE='OUI',
+                                NOM_CMP=('DX','DY','DZ'),
+                                FORMAT_C='IMAG',
+                                OPERATION='EXTRACTION',),);
+        tabmoN_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE',
+                                #GROUP_NO=L_GR_NOEUD,
+                                NOEUD=L_GR_NOEUD,
+                                RESULTAT=MODEf[ii],
+                                NOM_CHAM='DEPL',
+                                TOUT_ORDRE='OUI',
+                                NOM_CMP=('DX','DY','DZ'),
+                                FORMAT_C='MODULE',
+                                OPERATION='EXTRACTION',),);
+                                
+        #IMPR_TABLE(TABLE=tabmoR_f);
+        #IMPR_TABLE(TABLE=tabmoI_f);
+        #IMPR_TABLE(TABLE=tabmoN_f);
+         
+        for jj in range(NFREQ_f):
+            #Sens de precesion pour un mode a une vitesse donne
+            modul1  =0.0;
+            sens1   =0.0;
+            for ll in range(NOEU):
+                nmod=NOEU*jj+ll
+                dy_r  = tabmoR_f['DY' ,nmod+1];
+                dz_r  = tabmoR_f['DZ' ,nmod+1];
+                dy_i  = tabmoI_f['DY' ,nmod+1];
+                dz_i  = tabmoI_f['DZ' ,nmod+1];
+                dy_m  = tabmoN_f['DY' ,nmod+1];
+                dz_m  = tabmoN_f['DZ' ,nmod+1];
+                
+                if typ_prec == 1 : 
+                    #Sens parcours pour un noeud
+                    preces  = dy_r*dz_i-dy_i*dz_r ;
+                #Sens de precession dominant dans une mode
+                if preces >0:
+                    sens1=sens1+ dy_m + dz_m;
+                elif preces <0:
+                        sens1=sens1- dy_m - dz_m;
+            else:
+                #Sens de precession associe au plus grand orbite
+                if (dy_m + dz_m) >modul1:
+                    # demi diagonale
+                    modul1= Numeric.sqrt(dy_m*dy_m + dz_m*dy_m);
+                preces  = dy_r*dz_i-dy_i*dz_r ; 
+                if preces >0:
+                    sens1=modul1;
+                elif preces <0:             
+                            sens1=-modul1;
+            
+            XS=abs(sens1);
+            if XS>XSMIN:
+                SENS[jj][ii]=sens1/XS; 
+            else:  
+                SENS[jj][ii]=0.0;  
+            
+        DETRUIRE(CONCEPT=_F(NOM=(tabmoR_f, tabmoI_f, tabmoN_f)),INFO=1) 
+        
+    return SENS        
+
+#------------------------------------------------------------------------------------------------
+
+def TRI_MODE_PREC (SENS,NFREQ_f, NVT_f, NBV, OMIN) :
+#Tri des modes par une methode de proche en proche avec verification du sens de precession 
+    # base mode 1
+    chaine='TRI_MODE_PREC'
+    aster.affiche('RESULTAT', chaine)
+   
+    ND=0 
+    NI=0    
+    NBV1 = NBV-1
+    for jj in range(NFREQ_f):
+        jf=NFREQ_f-jj-1;
+        #chaine='jf ' + str(jf);
+        #aster.affiche('RESULTAT', chaine)
+        if SENS[jf][NBV-1]>0.:
+            ND=ND+1;
+            for nb in range(NBV1):
+                nbd=NBV1-nb-1;
+                #chaine='\n'
+                #aster.affiche('RESULTAT', chaine)
+                #chaine='Directe nb ' + str(nb) + ' nbd ' + str(nbd);
+                #aster.affiche('RESULTAT', chaine)
+                NID=0;
+                for ii in range(NFREQ_f):
+                     ifr=NFREQ_f-ii-1;
+                if SENS[ifr][nbd]>0.5:
+                   NID=NID+1;
+                if NID==ND:
+                        NVT_f[jf][nbd]=int(ifr+1);
+                        #chaine='ifr ' + str(ifr) + ' NID ' + str(NID)+ ' ND ' + str(ND);
+                        #aster.affiche('RESULTAT', chaine)
+                        #chaine='jf ' + str(jf) + ' nbd ' + str(nbd)+ ' NVT_f ' + str(NVT_f[jf][nbd]);
+                        #aster.affiche('RESULTAT', chaine)
+                        break;
+                        
+        else :
+            NI=NI+1
+            for nb in range(NBV1):
+                nbi=NBV1-nb-1;
+                #chaine='\n'
+                #aster.affiche('RESULTAT', chaine)
+                #chaine='Inverse nb ' + str(nb) + ' nbi ' + str(nbi);
+                #aster.affiche('RESULTAT', chaine)
+                NIV=0;
+                for ii in range(NFREQ_f):
+                    ifr=NFREQ_f-ii-1;
+                if SENS[ifr][nbi]<-0.5:
+                    NIV=NIV+1;
+                if NIV==NI:
+                        NVT_f[jf][nbi]=int(ifr+1);
+                        #chaine='ifr ' + str(ifr) + ' NIV ' + str(NIV)+ ' NI ' + str(NI);
+                        #aster.affiche('RESULTAT', chaine)
+                        #chaine='jf ' + str(jf) + ' nbi ' + str(nbi)+ ' NVT_f ' + str(NVT_f[jf][nbi]);
+                        #aster.affiche('RESULTAT', chaine)
+                        break;
+    if(OMIN==0) :
+         for ii in range(NFREQ_f):
+            NVT_f[ii][0]=NVT_f[ii][1] 
+    
+    chaine='Tableau de connexion des Modes de flexion'
+    aster.affiche('RESULTAT', chaine)
+    affiche_tabint(NVT_f,NFREQ_f,NBV); 
+    
+    return NVT_f  
+
+#----------------------------------------------------------------------------------------
+
+def TRI_MODE_PREC_DI (SENS,NFREQ_f, NVT_f, NBV, OMIN) :
+#Tri des modes par une methode de proche en proche avec verification du sens de precession 
+    # base mode 1
+    chaine='TRI_MODE_PREC_DI'
+    aster.affiche('RESULTAT', chaine)
+   
+    NVT_fdir =Numeric.zeros((NFREQ_f, NBV),Numeric.Float); 
+    NVT_finv =Numeric.zeros((NFREQ_f, NBV),Numeric.Float);   
+    nb_prec_dir =NFREQ_f;
+    nb_prec_inv =NFREQ_f;
+    for nb in range(NBV):
+        nbv1=NBV-nb-1;
+        jd=0;
+        ji=0;  
+        for jj in range(NFREQ_f):
+            if SENS[jj][nbv1]>0.:
+                NVT_fdir[jd][nbv1]=jj+1;
+                jd=jd+1;
+            elif SENS[jj][nbv1]<0.:
+                NVT_finv[ji][nbv1]=jj+1;
+                ji=ji+1;
+        # Calcul de nombre minimum de precession directe pour les vitesses
+        # Calcul de nombre minimum de precession inverse pour les vitesses
+        
+        if jd>0:
+            if nb_prec_dir >jd:
+                nb_prec_dir =jd; 
+        if ji>0: 
+            if nb_prec_inv >ji:
+                nb_prec_inv= ji; 
+    
+    if(OMIN==0) :
+        for ii in range(NFREQ_f):
+            NVT_fdir[ii][0]=NVT_fdir[ii][1] 
+            NVT_finv[ii][0]=NVT_finv[ii][1]   
+    
+    chaine='nb_prev_dir ' + str(nb_prec_dir);
+    aster.affiche('RESULTAT', chaine)
+    chaine='Tableau de connexion des Modes de flexion precession directe'
+    aster.affiche('RESULTAT', chaine)
+    affiche_tabint(NVT_fdir,NFREQ_f, NBV); 
+
+    chaine='nb_prev_inv ' + str(nb_prec_inv);
+    aster.affiche('RESULTAT', chaine)
+    chaine='Tableau de connexion des Modes de flexion precession inverse'
+    aster.affiche('RESULTAT', chaine)
+    affiche_tabint(NVT_finv,NFREQ_f, NBV); 
+
+    # Rassembler les tableaux de connexion
+    NVTf_prec =Numeric.zeros((NFREQ_f, NBV),Numeric.Int); 
+    for jj in range(NFREQ_f):
+        jf=0;
+        jf=int(NVT_fdir[jj][NBV-1]);
+        if jf>0:
+            for iv in range(NBV):
+                NVTf_prec[jf-1][iv]= NVT_fdir[jj][iv];  
+        jf=0;
+        jf=int(NVT_finv[jj][NBV-1]);
+        if jf>0:
+            for iv in range(NBV):
+                NVTf_prec[jf-1][iv]= NVT_finv[jj][iv]; 
+            
+    chaine='\n'
+    aster.affiche('RESULTAT', chaine)   
+    chaine='NVTf_prec'
+    aster.affiche('RESULTAT', chaine)
+    affiche_tabint(NVTf_prec,NFREQ_f, NBV); 
+    
+    RESULT = [nb_prec_dir,nb_prec_inv, NVTf_prec];
+    
+    return RESULT
+    
+
+#----------------------------------------------------------------------------------------
+def affiche_tab(tab1,nbligne, nbcol) :
+# affiche un taleau tab1 de nbligne lignes et nbcol colonnes
+    for jj in range(nbligne):
+        chaine=''
+        for ii in range(nbcol):
+            str1 = '%15.5E' %tab1[jj][ii]
+            chaine=chaine + ' '+ str1
+        aster.affiche('RESULTAT', chaine)
+
+#----------------------------------------------------------------------------------------            
+
+def affiche_tabint(tab1,nbligne, nbcol) :
+# affiche un taleau tab1 de nbligne lignes et nbcol colonnes
+    for jj in range(nbligne):
+        chaine=''
+        for ii in range(nbcol):
+            str1 = '%5d' %tab1[jj][ii]
+            chaine=chaine + ' '+ str1
+        aster.affiche('RESULTAT', chaine)
+
+#----------------------------------------------------------------------------------------        
+
+def calc_pas(xmin, xmax) :
+# calcul de l'echelle valeurs mini-maxi et le pas
+# On impose entre 5 et 10 intervalles
+# En entree xmin, xmax valeurs mini-maxi, xmin et xmax superieurs ou egaux a zero
+# En sortie VAL1, VAL2 et PAS valeurs mini-maxi de l'echelle et le pas
+    diff=xmax-xmin;
+    PAS=1.;
+    VAL1=0.;
+    C10=10.;
+    
+    # diff < 5.
+    while diff<5.:
+        diff=diff*C10;
+        PAS = PAS/C10;
+    
+    # diff > 50.
+    while diff<50.:
+        diff=diff/C10;
+        PAS = PAS*C10;
+    
+    # 5 <= diff <= 50.
+    N=int(diff);
+    if N>=11 and N<=20 :
+        N=N/2;
+        PAS=PAS*2.;
+    elif N>=21 and N<=30 :
+        N=N/3;
+        PAS=PAS*3.;
+    elif N>=31 and N<=40 :
+        N=N/4;
+        PAS=PAS*4.;
+    elif N>=41 and N<=50 :
+        N=N/5;
+        PAS=PAS*5.;
+    
+    # Calcul des valeurs mini-maxi de l'echelle
+    while abs(xmin-VAL1)>PAS:
+        VAL1=VAL1 + PAS;
+    
+    VAL2=VAL1 + (N*PAS);
+    while VAL2 <= xmax:
+        VAL2=VAL2 + PAS;
+    
+    RESULT=[VAL1, VAL2, PAS];
+    
+    return RESULT
+   
+#----------------------------------------------------------------------------------------            
+
+def color_camp(sens, amortis) :
+# determine la couleur et le style du trait
+# en entree le sens de precession
+# en sortir la couleur, le style du trait ICS IST et le maqueur
+#          DIRECTE,STABLE       vert
+#          DIRECTE,INSTABLE     rouge
+#          INDIRECTE,STABLE     bleu
+#          INDIRECTE,INSTABLE   magenta
+
+    if sens<0:   # precession inverse
+        if amortis<0:   # instable
+            ICS = 10; # magenta
+            IST = 4;  # tiret
+            IMA = 9;  # croix
+        else:           # stable
+            ICS = 4;  # bleu
+            IST = 4;  # tiret
+            IMA = 0; 
+    else:       # precession directe
+        if amortis<0:   # instable
+            ICS = 2;  # rouge
+            IST = 1;  # trait continu
+            IMA = 8;  # plus
+        else:           # stable
+            ICS = 3;  # vert
+            IST = 1;  # trait continu
+            IMA = 0; 
+    RESULT= [ICS,IST,IMA];
+    
+    return RESULT
+    
+#----------------------------------------------------------------------------------------
+def sup_redon_list(LS):
+# Supprimer la redondace dans une liste de reel
+    LS.sort();
+    ii=0
+    len_list=len(LS);
+    while ii < len_list-1:
+        icount = LS.count(LS[ii]);
+        if icount >1:
+            for jj in range(ii+icount-1, ii,-1):
+                LS.pop(jj);
+        ii=ii+1
+        len_list=len(LS);
+
+#------------------------------------------------------------------------------------------
+def save_intersec(L_INTER, FINT):
+# Sauvegarde dans un fichier les points d'intersection des courbes du diagramme de Campbell
+# avec les droites de pente S
+    chaine='\n'
+    FINT.write(chaine)   
+    chaine='Points d'' intersection avec les droites Y=SX'
+    FINT.write(chaine)
+    for ii in range(len(L_INTER)):
+        chaine='\n'
+        FINT.write(chaine)   
+        chaine = 'S = %10.2F' %L_INTER[ii]["pente"]
+        FINT.write(chaine) 
+        chaine='\n'
+        FINT.write(chaine)   
+        L_POINT = L_INTER[ii]["point"]
+        for jj in range(len(L_POINT)):
+            chaine = 'Vitesse   = %10.2F tr/mn' %L_POINT[jj][0]
+            FINT.write(chaine) 
+            FINT.write('\n') 
+            chaine = 'Frequence = %10.2F HZ' %L_POINT[jj][1]
+            FINT.write(chaine) 
+            FINT.write('\n')   
+
+        chaine='----------------------------'
+        FINT.write(chaine) 
+        chaine='\n' 
+        chaine=' '
+
+#------------------------------------------------------------------------------------------            
+        
+
+def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PREC, TYP_TRI,
+                           UNIT_FLE, UNIT_TOR, UNIT_LON, UNIT_TOT, UNIT_INT,L_S, **args) :
+# Macro permettant de tracer le diagramme de Campbell suivant 
+# le type de suivi des modes et le type de calcul de la precession
+#Type de suivi, 0 SANS_TRI, 1 TRI_PREC, 2 TRI_FORM_MOD
+#Type de precession, 1 somme, 2 grande orbite
+
+
+    # On importe les definitions des commandes a utiliser dans la macro
+    
+    POST_RELEVE_T     =self.get_cmd('POST_RELEVE_T')
+    EXTR_MODE         =self.get_cmd('EXTR_MODE')
+    NORM_MODE         =self.get_cmd('NORM_MODE')
+    RECU_TABLE        =self.get_cmd('RECU_TABLE')
+    MAC_MODES         =self.get_cmd('MAC_MODES')
+    DEFI_LIST_REEL    =self.get_cmd('DEFI_LIST_REEL')
+    DEFI_FONCTION     =self.get_cmd('DEFI_FONCTION')
+    IMPR_FONCTION     =self.get_cmd('IMPR_FONCTION')
+    IMPR_RESU         =self.get_cmd('IMPR_RESU')
+    DEFI_FICHIER      =self.get_cmd('DEFI_FICHIER')
+    DETRUIRE          =self.get_cmd('DETRUIRE')
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    L_VIT1=[];
+        
+    if type(VITE_ROTA)==list:
+        L_VIT1=VITE_ROTA;
+    elif type(VITE_ROTA)==tuple:
+        L_VIT1=list(VITE_ROTA);
+    elif type(VITE_ROTA)==float:           
+        L_VIT1.append(VITE_ROTA);
+    
+
+    # Supprimer la redondance dans la liste
+    sup_redon_list(L_VIT1);
+
+
+    nbV=len(L_VIT1);
+
+    #-------------------------------------------------------------------------
+    # Tester le nombre de frequences calculees pour chaque vitesse de rotation
+    #-------------------------------------------------------------------------
+    
+    nb_FREQ=[];
+    for ii in range(nbV):
+        # frequences totales
+        tabfreq = RECU_TABLE(CO= MODES[ii],NOM_PARA='FREQ',);
+        tab2=tabfreq.EXTR_TABLE();
+        tabf=tab2.FREQ;       
+        nb_FREQ_prec=nb_FREQ;
+        nb_FREQ.append(len(tabf));
+        
+        DETRUIRE(CONCEPT=_F(NOM=(tabfreq)),INFO=1)
+        
+    nbf_max=max(nb_FREQ);
+    nbf_min=min(nb_FREQ);
+    NFREQ =nbf_min;
+    if nbf_max!=nbf_min:
+         chaine='\n'
+         aster.affiche('RESULTAT', chaine)
+         chaine='Les nombres de frequences sont differents pour les vitesses de rotation.'
+         aster.affiche('RESULTAT', chaine)
+         chaine='Pour poursuivre le calcul, NFREQ = %d' %NFREQ
+         aster.affiche('RESULTAT', chaine)
+    else:
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)
+        chaine='Nombre de valeurs propres detectees est %d' %NFREQ
+        aster.affiche('RESULTAT', chaine)
+    if NFREQ_camp > NFREQ:
+            chaine='Nombre de frequences demandees pour le trace  %d' %NFREQ_camp
+            aster.affiche('RESULTAT', chaine)
+            NFREQ_camp = NFREQ-4;
+            chaine='Nombre de frequences pour le trace  %d' %NFREQ_camp
+            aster.affiche('RESULTAT', chaine)
+    else: 
+           chaine='Nombre de frequences demandees pour le trace  %d' %NFREQ_camp
+           aster.affiche('RESULTAT', chaine)
+    if NFREQ_camp <=0 :      
+        chaine='Le trace du diagramme de Campbell s''arrete !.'
+        aster.affiche('RESULTAT', chaine)
+       
+  
+    if NFREQ_camp>0:
+    
+# ------------------------------------------------------------------
+# Classe les modes en flexion, en torsion , en traction/ compression
+# ------------------------------------------------------------------
+        MODEf=[];
+        MODEt=[];
+        MODEl=[];
+    
+  
+        # Recuperer les noeuds du maillage
+        # construction des vecteurs jeveux
+        nom_mail=MAILLAGE.nom
+        #print 'nom_mail'
+        #print nom_mail
+        lenm=len(nom_mail)
+        nom_mail=nom_mail+' '*(8-lenm)
+        vectnoeu=nom_mail+'.NOMNOE'
+        #print vectnoeu
+        L_GR_NOEUD=aster.getvectjev(vectnoeu)
+    
+    
+        NOEU=len(L_GR_NOEUD);
+        C_MODES=CLASS_MODES(self,MODES,NFREQ,NFREQ_camp,L_GR_NOEUD,L_VIT1);
+
+        NFREQ_f=C_MODES[0];
+        NFREQ_t=C_MODES[1];
+        NFREQ_l=C_MODES[2];
+        MODEf=C_MODES[3];
+        MODEt=C_MODES[4];
+        MODEl=C_MODES[5];
+    
+        # Initialisation des tableaux de connexion apres classement
+        # en gardant la numerotation globale des modes         
+        NVT=C_MODES[6];
+        NVTf_int=C_MODES[7];
+        NVTt_int=C_MODES[8];
+        NVTl_int=C_MODES[9];
+        NFREQ_fc=C_MODES[10];
+        NFREQ_tc=C_MODES[11];
+        NFREQ_lc=C_MODES[12];
+
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)
+        chaine='Nombre de frequences totale :' + str(NFREQ)
+        aster.affiche('RESULTAT', chaine)
+        chaine='Nombre de frequences en flexion :' + str(NFREQ_f) + ' ' + str(NFREQ_fc)
+        aster.affiche('RESULTAT', chaine)
+        chaine='Nombre de frequences torsion :' + str(NFREQ_t) + ' ' + str(NFREQ_tc)
+        aster.affiche('RESULTAT', chaine)
+        chaine='Nombre de frequences traction/compression :' + str(NFREQ_l) + ' ' + str(NFREQ_lc)
+        aster.affiche('RESULTAT', chaine)
+
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)
+        chaine='Initialisation des tableaux de connexion'
+        aster.affiche('RESULTAT', chaine)
+        chaine='Modes non classes'
+        aster.affiche('RESULTAT', chaine)
+        affiche_tabint(NVT,NFREQ, nbV);
+        if NFREQ_f>0:
+            chaine='Modes de flexion'
+            aster.affiche('RESULTAT', chaine)        
+            affiche_tabint(NVTf_int,NFREQ_f, nbV);
+        if NFREQ_t>0:
+            chaine='Modes de torsion'
+            aster.affiche('RESULTAT', chaine)        
+            affiche_tabint(NVTt_int,NFREQ_t, nbV);
+        if NFREQ_l>0:
+            chaine='Modes de traction/compression'
+            aster.affiche('RESULTAT', chaine)        
+            affiche_tabint(NVTl_int,NFREQ_l, nbV);
+
+    #-----------------------
+    #Extraire les frequences
+    #-----------------------
+        FREQ=EXTR_FREQ(self,MODES,MODEf,MODEt,MODEl, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l);
+        FRQ=FREQ[0]
+        FRQf=FREQ[1]
+        FRQt=FREQ[2]
+        FRQl=FREQ[3]
+        FRQ_max=FREQ[4]
+        AMOf=FREQ[5]
+    
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)
+        chaine='Frequences totales'
+        aster.affiche('RESULTAT', chaine)
+        affiche_tab(FRQ,NFREQ, nbV);
+        if NFREQ_f>0:
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+            chaine='Frequences en flexion'
+            aster.affiche('RESULTAT', chaine)
+            affiche_tab(FRQf,NFREQ_f, nbV);
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+            chaine='Amortissement reduit'
+            aster.affiche('RESULTAT', chaine)
+            affiche_tab(AMOf,NFREQ_f, nbV);
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+        if NFREQ_t>0:
+            chaine='Frequences en torsion'
+            aster.affiche('RESULTAT', chaine)
+            affiche_tab(FRQt,NFREQ_t, nbV);
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+        if NFREQ_l>0:
+            chaine='Frequences en traction/compression'
+            aster.affiche('RESULTAT', chaine)
+            affiche_tab(FRQl,NFREQ_l, nbV);
+
+    # Initialisation des tableaux de connexion 
+    # nouveau numerotation de modes par type de mode 
+    # Sans tri
+        if NFREQ_f>0 :
+            NVTf =Numeric.zeros((NFREQ_f, nbV),Numeric.Int); 
+            for ii in range(nbV):
+                for jj in range(NFREQ_f):
+                    NVTf[jj][ii]=jj+1;
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+            chaine='Tableau de connexion initial en flexion'
+            aster.affiche('RESULTAT', chaine)        
+            affiche_tabint(NVTf,NFREQ_f, nbV);
+
+        if NFREQ_t>0 :    
+            NVTt =Numeric.zeros((NFREQ_t, nbV),Numeric.Int); 
+            for ii in range(nbV):
+                for jj in range(NFREQ_t):
+                    NVTt[jj][ii]=jj+1;
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+            chaine='Tableau de connexion initial en torsion'
+            aster.affiche('RESULTAT', chaine)        
+            affiche_tabint(NVTt,NFREQ_t, nbV);
+
+        if NFREQ_l>0 :     
+            NVTl =Numeric.zeros((NFREQ_l, nbV),Numeric.Int); 
+            for ii in range(nbV):
+                for jj in range(NFREQ_l):
+                    NVTl[jj][ii]=jj+1;
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+            chaine='Tableau de connexion initial en traction/compression'
+            aster.affiche('RESULTAT', chaine)        
+            affiche_tabint(NVTl,NFREQ_l, nbV);
+
+    # ------------------------------------------------------------------
+    # Tri par forme des modes
+    # Tri des frequences par calcul des coefficients MAC
+    # Remplissage du tableau de connexion
+    # ------------------------------------------------------------------
+        if TYP_TRI==2 :
+            # ------------------------------------------------------------------
+            # Calcul de la matrice MAC entre les bases successives en flexion
+            # ------------------------------------------------------------------
+            if NFREQ_f>0:
+                LMACf=CALC_MACf(self, MODEf, NFREQ_f) ;
+
+                chaine=' Tri par forme des modes TRI_FORM_MOD'
+                aster.affiche('RESULTAT', chaine)
+                for ii in range(nbV-1):
+                    chaine='\n'
+                    aster.affiche('RESULTAT', chaine) 
+                    #IMPR_TABLE(TABLE=LMACf[ii])
+                    iv=nbV-ii-2
+
+                    NVTf_mac=TRI_MODE_MACf(self, LMACf[iv],NFREQ_f, NVTf, iv);
+                chaine='\n'
+                aster.affiche('RESULTAT', chaine)
+                chaine='Tableau de connexion en flexion'
+                aster.affiche('RESULTAT', chaine)        
+                affiche_tabint(NVTf_mac,NFREQ_f, nbV);   
+
+            # ------------------------------------------------------------------
+            # Calcul de la matrice MAC entre les bases successives en torsion
+            # ------------------------------------------------------------------
+            if NFREQ_t>0:
+                LMACt=CALC_MACt(self, MODEt, NFREQ_t) ;
+
+                #chaine='Matrices MAC'
+                #aster.affiche('RESULTAT', chaine)
+                for ii in range(nbV-1):
+                    chaine='\n'
+                    aster.affiche('RESULTAT', chaine) 
+                    #IMPR_TABLE(TABLE=LMACt[ii])
+                    iv=nbV-ii-2
+                    #chaine='iv torsion' + str(iv);
+                    #aster.affiche('RESULTAT', chaine)
+                    NVTt=TRI_MODE_MACt(self, LMACt[iv],NFREQ_t, NVTt, iv);
+                chaine='\n'
+                aster.affiche('RESULTAT', chaine)
+                chaine='Tableau de connexion en torsion'
+                aster.affiche('RESULTAT', chaine)        
+                affiche_tabint(NVTt,NFREQ_t, nbV);   
+
+            # ----------------------------------------------------------------------------
+            # Calcul de la matrice MAC entre les bases successives en traction/compression
+            # ----------------------------------------------------------------------------
+            if NFREQ_l>0:
+                LMACl=CALC_MACl(self, MODEl, NFREQ_l) ;
+
+                #chaine='Matrices MAC'
+                #aster.affiche('RESULTAT', chaine)
+                for ii in range(nbV-1):
+                    chaine='\n'
+                    aster.affiche('RESULTAT', chaine) 
+                    #IMPR_TABLE(TABLE=LMACl[ii])
+                    iv=nbV-ii-2
+                    #chaine='iv  traction/compression' + str(iv);
+                    #aster.affiche('RESULTAT', chaine)
+                    NVTl=TRI_MODE_MACl(self, LMACl[iv],NFREQ_l, NVTl, iv);
+                chaine='\n'
+                aster.affiche('RESULTAT', chaine)
+                chaine='Tableau de connexion en traction/compression'
+                aster.affiche('RESULTAT', chaine)        
+                affiche_tabint(NVTl,NFREQ_l, nbV);   
+    
+    
+        #--------------------------------------------------------------------------
+        # Calcul le sens de precession pour les modes en flexion a une vitesse de rotation donnee
+        #--------------------------------------------------------------------------
+        if NFREQ_f>0:
+            SENS=CALC_PREC(self, MODEf,NFREQ_f,L_GR_NOEUD, TYP_PREC);        
+
+            chaine='\n'
+            aster.affiche('RESULTAT', chaine)
+            chaine='Sens de precession pour les modes en flexion'
+            aster.affiche('RESULTAT', chaine)
+            affiche_tab(SENS,NFREQ_f, nbV);
+        # ------------------------------------------------------------------------------------
+        # Remplissage de deux tableaux separes de connexion pour precession directe et inverse
+        # ------------------------------------------------------------------------------------
+        #OMIN = L_VIT1[0]
+        #PREC_DI=TRI_MODE_PREC_DI (SENS,NFREQ_f, NVTf, nbV, OMIN);
+
+        # ------------------------------------------------------------------
+        # Tri des modes en flexion par une methode de proche en proche 
+        # avec verification du sens de precession
+        # Remplissage du tableau de connexion
+        # ------------------------------------------------------------------
+        if TYP_TRI==1 :
+            if NFREQ_f>0:
+                # Vitesses de rotation rangees par ordre croissant
+                OMIN = L_VIT1[0]
+                #NVTf=TRI_MODE_PREC (SENS,NFREQ_f, NVTf, nbV, OMIN);
+                PREC_DI=TRI_MODE_PREC_DI (SENS,NFREQ_f, NVTf, nbV, OMIN);
+                nb_prec_dir=PREC_DI[0];
+                nb_prec_inv=PREC_DI[1];
+                NVTf_prec=PREC_DI[2];
+
+   
+   
+        # --------------------------------
+        # Trace du diagramme de campbell        
+        # --------------------------------
+        chaine='Trace du diagramme de campbell'
+        aster.affiche('RESULTAT', chaine)
+
+        #Conversion de la vitesse de rotation en tr/mn pour l'affichage
+        OM = L_VIT1;  
+        for ii in range(nbV):
+            OM[ii] = OM[ii]*30./pi;
+   
+        #FX=DEFI_LIST_REEL(VALE=L_VIT1);
+        __FX=DEFI_LIST_REEL(VALE=OM);
+    
+        # Mise en page graphique
+        Vmin=min(OM);
+        Vmax=max(OM);
+    
+
+    
+        # Determination de la frequence maximale
+        Fmax=0.0;
+        for jf in range(NFREQ_fc):
+            for iv in range(nbV):
+                if TYP_TRI==0:
+                    jf1=NVTf[jf][iv]-1; 
+                if TYP_TRI==1: 
+                    jf1=NVTf_prec[jf][iv]-1; 
+                if TYP_TRI==2:
+                    jf1=NVTf_mac[jf][iv]-1;
+                F1=FRQf[jf1][iv];
+                if Fmax<F1:
+                    Fmax=F1;
+    
+        for jf in range(NFREQ_tc):
+            for iv in range(nbV):
+                jf1=NVTt[jf][iv]-1;                            
+                F1=FRQt[jf1][iv];
+                if Fmax<F1:
+                    Fmax=F1;
+   
+        for jf in range(NFREQ_lc):
+            for iv in range(nbV):
+                jf1=NVTl[jf][iv]-1;                            
+                F1=FRQl[jf1][iv];
+                if Fmax<F1:
+                    Fmax=F1;
+
+        Fmin=0.0;
+        Fmax=Fmax*1.1;
+
+        # Calcul des bornes et pas de la grille pour les vitesses de rotation
+        BV    = calc_pas(Vmin, Vmax);
+        BVmin = BV[0];
+        BVmax = BV[1];
+        pasV  = BV[2];
+    
+        # Calcul des bornes et pas de la grille pour les frequences
+        BF    = calc_pas(Fmin, Fmax);
+        BFmin = BF[0];
+        BFmax = BF[1];
+        pasF  = BF[2];
+    
+        chaine='\n'
+        aster.affiche('RESULTAT', chaine)   
+        chaine='Fmax ' + str(Fmax) + ' BFmax ' + str(BFmax)
+        aster.affiche('RESULTAT', chaine)
+    
+        TITRE1 = 'Diagramme de Campbell';
+        TITRE2 = 'Modes en flexion'
+    
+        #mfac ={}
+        DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_FLE,)
+        DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_TOR,)
+        DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_LON,)
+        DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_TOT,)
+        # ---------------------------------------------------
+        # Trace du diagramme de campbell des modes en flexion        
+        # ---------------------------------------------------
+        EPSI=1.E-7
+        LFONC =[];
+        FON1  =[];
+        mfac1 ={};
+        ll    =0;
+        if NFREQ_fc>0: 
+            for jf in range(NFREQ_fc):
+                for iv in range(nbV-1):
+                    OM3 = -1.    # OM3 different de -1, Changement de precession
+                    OM4 = -1.    # OM4 different de -1, Changement de stabilite
+                    if TYP_TRI==0:
+                        jf1=NVTf[jf][iv]-1;
+                        jf2=NVTf[jf][iv+1]-1;
+                    if TYP_TRI==1:
+                        jf1=NVTf_prec[jf][iv]-1;
+                        jf2=NVTf_prec[jf][iv+1]-1; 
+                    if TYP_TRI==2:
+                        jf1=NVTf_mac[jf][iv]-1;
+                        jf2=NVTf_mac[jf][iv+1]-1;
+
+                    # Frequences
+                    if jf1>=0 and jf2>=0:
+                        F1=FRQf[jf1][iv];
+                        F2=FRQf[jf2][iv+1];
+                        A1=AMOf[jf1][iv];
+                        A2=AMOf[jf2][iv+1];
+    
+                        # Vitesses
+                        #OM1=L_VIT1[iv];
+                        #OM2=L_VIT1[iv+1];
+                        OM1=OM[iv];
+                        OM2=OM[iv+1];
+                        S1=SENS[jf1][iv];
+                        S2=SENS[jf2][iv+1];
+  
+                        if OM1==0.0 :
+                            S1=S2;
+                        if S1*S2<0 :  # Changement de precession
+                            OM3=(OM1+OM2)/2;
+                            F3 =(F1+F2)/2;
+                        
+                        A0 = abs(EPSI*(F1+F2)/2)
+                        if ((A1-A0)*(A2-A0) <0):   # Changement de stabilite
+                            OM4 = (A2*OM1 - A1*OM2) / (A2 -A1)
+                            aa = (F2 - F1) / (OM2 -OM1)
+                            bb = (F2*OM1 - F1*OM2) / (OM1 -OM2)
+                            F4 = aa* OM4 + bb
+
+                        if (A1 >0) and (A1 < A0):
+                            A1 = 0.0
+                        if (A2 >0) and (A2 < A0):
+                            A2 = 0.0
+
+                        # Tracer le segment pour chaque intervalle avec le code de couleur et
+                        # de style adequats 
+               
+                        # 1 cas, Pas de changement sur la plage de vitesse
+                        if ((OM3 == -1) and (OM4 == -1)):
+                            FX1=DEFI_LIST_REEL(VALE=[OM1,OM2]);
+                            FY1=DEFI_LIST_REEL(VALE=[F1,F2]);
+                            CS2=color_camp(S2,A1);
+                            ICS2=CS2[0];
+                            IST2=CS2[1];
+                            IMA2=CS2[2];
+                    
+                            FON1.append([]);
+                            ll=len(FON1)-1;
+                            FON1[ll]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
+                    
+                            DICO={};
+                            DICO["FONCTION"]=FON1[ll];
+                            DICO["COULEUR"] =ICS2;
+                            DICO["STYLE"]   =IST2;
+                            DICO["MARQUEUR"]=IMA2;
+                            DICO["LEGENDE"] ='';
+                            LFONC.append(DICO);
+ 
+                            #DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FONC)),INFO=1);
+                            DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1)),INFO=1);
+                
+                        # 2 cas, Changement de sens de precession
+                        elif (OM3 >=0) and (OM4 == -1):
+                            FX1=DEFI_LIST_REEL(VALE=[OM1,OM3]); # Premiere partie
+                            FY1=DEFI_LIST_REEL(VALE=[F1,F3]);
+                            FX2=DEFI_LIST_REEL(VALE=[OM3,OM2]); # Deuxieme partie
+                            FY2=DEFI_LIST_REEL(VALE=[F3,F2]);
+                            CS1=color_camp(S1,A1);
+                            ICS1=CS1[0];
+                            IST1=CS1[1];
+                            IMA1=CS1[2];
+                            CS2=color_camp(S2,A1);
+                            ICS2=CS2[0];
+                            IST2=CS2[1];
+                            IMA2=CS2[2];
+                    
+                            FON1.append([]);
+                            ll=len(FON1)-1;
+                            FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
+                                     
+                            DICO={};
+                            DICO["FONCTION"]=FON1[ll];
+                            DICO["COULEUR"] =ICS1;
+                            DICO["STYLE"]   =IST1;
+                            DICO["MARQUEUR"]=IMA1;
+                            DICO["LEGENDE"] ='';
+                            LFONC.append(DICO);
+  
+                            FON1.append([]);
+                            ll=len(FON1)-1;
+                            FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
+
+                            DICO={};
+                            DICO["FONCTION"]=FON1[ll];
+                            DICO["COULEUR"] =ICS2;
+                            DICO["STYLE"]   =IST2;
+                            DICO["MARQUEUR"]=IMA2;
+                            DICO["LEGENDE"] ='';
+                            LFONC.append(DICO);
+                    
+                            DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1);
+                       
+                        # 3 cas, de changement de stabilite
+                    elif (OM3 == -1) and (OM4 >= 0):
+
+                            FX1=DEFI_LIST_REEL(VALE=[OM1,OM4]); # Premiere partie
+                            FY1=DEFI_LIST_REEL(VALE=[F1,F4]);
+                            FX2=DEFI_LIST_REEL(VALE=[OM4,OM2]); # Deuxieme partie
+                            FY2=DEFI_LIST_REEL(VALE=[F4,F2]);
+                            CS1=color_camp(S2,A1);
+                            ICS1=CS1[0];
+                            IST1=CS1[1];
+                            IMA1=CS1[2];
+                            CS2=color_camp(S2,A2);
+                            ICS2=CS2[0];
+                            IST2=CS2[1];
+                            IMA2=CS2[2];
+                    
+                            FON1.append([]);
+                            ll=len(FON1)-1;
+                            FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
+                                     
+                            DICO={};
+                            DICO["FONCTION"]=FON1[ll];
+                            DICO["COULEUR"] =ICS1;
+                            DICO["STYLE"]   =IST1;
+                            DICO["MARQUEUR"]=IMA1;
+                            DICO["LEGENDE"] ='';
+                            LFONC.append(DICO);
+  
+                            FON1.append([]);
+                            ll=len(FON1)-1;
+                            FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
+
+                            DICO={};
+                            DICO["FONCTION"]=FON1[ll];
+                            DICO["COULEUR"] =ICS2;
+                            DICO["STYLE"]   =IST2;
+                            DICO["MARQUEUR"]=IMA2;
+                            DICO["LEGENDE"] ='';
+                            LFONC.append(DICO);
+                    
+                            DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1);
+
+                        # 4 et 5 cas de changement de sens de precession et de stabilite
+                    elif (OM3 >= 0) and (OM4 >= 0):
+                        # 4 eme cas
+                            if (OM4 < OM3):
+                                FX1=DEFI_LIST_REEL(VALE=[OM1,OM4]); # Premiere partie
+                                FY1=DEFI_LIST_REEL(VALE=[F1,F4]);
+                                FX2=DEFI_LIST_REEL(VALE=[OM4,OM3]); # Deuxieme partie
+                                FY2=DEFI_LIST_REEL(VALE=[F4,F3]);
+                                FX2=DEFI_LIST_REEL(VALE=[OM3,OM2]); # Troisieme partie
+                                FY2=DEFI_LIST_REEL(VALE=[F3,F2]);
+                                CS1=color_camp(S1,A1);
+                                ICS1=CS1[0];
+                                IST1=CS1[1];
+                                IMA1=CS1[2];
+                                CS2=color_camp(S1,A2);
+                                ICS2=CS2[0];
+                                IST2=CS2[1];
+                                IMA2=CS2[2];
+                                CS3=color_camp(S2,A2);
+                                ICS3=CS3[0];
+                                IST3=CS3[1];
+                                IMA3=CS3[2];
+                    
+                                FON1.append([]);
+                                ll=len(FON1)-1;
+                                FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
+                                     
+                                DICO={};
+                                DICO["FONCTION"]=FON1[ll];
+                                DICO["COULEUR"] =ICS1;
+                                DICO["STYLE"]   =IST1;
+                                DICO["MARQUEUR"]=IMA1;
+                                DICO["LEGENDE"] ='';
+                                LFONC.append(DICO);
+  
+                                FON1.append([]);
+                                ll=len(FON1)-1;
+                                FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
+
+                                DICO={};
+                                DICO["FONCTION"]=FON1[ll];
+                                DICO["COULEUR"] =ICS2;
+                                DICO["STYLE"]   =IST2;
+                                DICO["MARQUEUR"]=IMA2;
+                                DICO["LEGENDE"] ='';
+                                LFONC.append(DICO);
+                                
+                                FON1.append([]);
+                                ll=len(FON1)-1;
+                                FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX3,VALE_FONC=FY3);
+
+                                DICO={};
+                                DICO["FONCTION"]=FON1[ll];
+                                DICO["COULEUR"] =ICS3;
+                                DICO["STYLE"]   =IST3;
+                                DICO["MARQUEUR"]=IMA3;
+                                DICO["LEGENDE"] ='';
+                                LFONC.append(DICO);
+                    
+                                DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2, FX3,FY3)),INFO=1);
+
+                            # 5 eme cas
+                            else:
+                                FX1=DEFI_LIST_REEL(VALE=[OM1,OM3]); # Premiere partie
+                                FY1=DEFI_LIST_REEL(VALE=[F1,F3]);
+                                FX2=DEFI_LIST_REEL(VALE=[OM3,OM4]); # Deuxieme partie
+                                FY2=DEFI_LIST_REEL(VALE=[F3,F4]);
+                                FX2=DEFI_LIST_REEL(VALE=[OM4,OM2]); # Troisieme partie
+                                FY2=DEFI_LIST_REEL(VALE=[F4,F2]);
+                                CS1=color_camp(S1,A1);
+                                ICS1=CS1[0];
+                                IST1=CS1[1];
+                                IMA1=CS1[2];
+                                CS2=color_camp(S2,A1);
+                                ICS2=CS2[0];
+                                IST2=CS2[1];
+                                IMA2=CS2[2];
+                                CS3=color_camp(S2,A2);
+                                ICS3=CS3[0];
+                                IST3=CS3[1];
+                                IMA3=CS3[2];
+                    
+                                FON1.append([]);
+                                ll=len(FON1)-1;
+                                FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
+                                     
+                                DICO={};
+                                DICO["FONCTION"]=FON1[ll];
+                                DICO["COULEUR"] =ICS1;
+                                DICO["STYLE"]   =IST1;
+                                DICO["MARQUEUR"]=IMA1;
+                                DICO["LEGENDE"] ='';
+                                LFONC.append(DICO);
+  
+                                FON1.append([]);
+                                ll=len(FON1)-1;
+                                FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX2,VALE_FONC=FY2);
+
+                                DICO={};
+                                DICO["FONCTION"]=FON1[ll];
+                                DICO["COULEUR"] =ICS2;
+                                DICO["STYLE"]   =IST2;
+                                DICO["MARQUEUR"]=IMA2;
+                                DICO["LEGENDE"] ='';
+                                LFONC.append(DICO);
+                                
+                                FON1.append([]);
+                                ll=len(FON1)-1;
+                                FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX3,VALE_FONC=FY3);
+
+                                DICO={};
+                                DICO["FONCTION"]=FON1[ll];
+                                DICO["COULEUR"] =ICS3;
+                                DICO["STYLE"]   =IST3;
+                                DICO["MARQUEUR"]=IMA3;
+                                DICO["LEGENDE"] ='';
+                                LFONC.append(DICO);
+                    
+                                DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2, FX3, FY3)),INFO=1);    
+
+
+            
+            mfac1["COURBE"]=LFONC; 
+                
+            IMPR_FONCTION(
+                        UNITE   = UNIT_FLE,
+                        FORMAT  = 'XMGRACE',
+                        BORNE_X = (BVmin,BVmax),
+                        BORNE_Y = (BFmin,BFmax),
+                        TITRE   = TITRE1,
+                        SOUS_TITRE   = TITRE2,
+                        GRILLE_X = pasV,
+                        GRILLE_Y = pasF, 
+                        LEGENDE_X = 'Vitesse (tr/mn)',
+                        LEGENDE_Y = 'FREQ (Hz)',
+                            **mfac1);
+
+            IMPR_FONCTION(
+                        UNITE   = UNIT_TOT,
+                        FORMAT  = 'XMGRACE',
+                        BORNE_X = (BVmin,BVmax),
+                        BORNE_Y = (BFmin,BFmax),
+                        TITRE   = TITRE1,
+                        SOUS_TITRE   = TITRE2,
+                        GRILLE_X = pasV,
+                        GRILLE_Y = pasF, 
+                        LEGENDE_X = 'Vitesse (tr/mn)',
+                        LEGENDE_Y = 'FREQ (Hz)',
+                            **mfac1);
+            nbll = len(FON1) 
+            for ii in range(nbll):    
+                DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
+            del(LFONC)
+            del(mfac1, DICO)
+
+   
+          
+        # ---------------------------------------------------
+        # Trace du diagramme de campbell des modes en torsion        
+        # ---------------------------------------------------
+        TITRE2 = 'Modes en Torsion'
+        if NFREQ_tc>0:
+            LFONC =[];
+            FON1 =[0]*NFREQ_tc;
+            mfac1={};
+            for jj in range(NFREQ_tc):
+       
+               FY1=DEFI_LIST_REEL(VALE=[FRQt[int(NVTt[jj][ii]-1)][ii] for ii in range(nbV)]);
+               FON1[jj]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=__FX,VALE_FONC=FY1);
+            
+            
+               DICO={};
+               DICO["FONCTION"]=FON1[jj];
+               DICO["COULEUR"] =1;
+               DICO["STYLE"]   =6;
+               DICO["MARQUEUR"]=0;
+               DICO["LEGENDE"] ='';
+               LFONC.append(DICO);
+            
+               DETRUIRE(CONCEPT=_F(NOM=(FY1)),INFO=1);
+        
+            mfac1["COURBE"]=LFONC; 
+            IMPR_FONCTION(
+                  UNITE    = UNIT_TOR,
+                  FORMAT   ='XMGRACE',
+                  BORNE_X  =(BVmin,BVmax),
+                  BORNE_Y  =(BFmin,BFmax),
+                  TITRE   = TITRE1,
+                  SOUS_TITRE = TITRE2,
+                  GRILLE_X = pasV,
+                  GRILLE_Y = pasF,
+                  LEGENDE_X = 'Vitesse (tr/mn)',
+                  LEGENDE_Y = 'FREQ (Hz)',
+                  **mfac1);  
+
+            IMPR_FONCTION(
+                  UNITE    = UNIT_TOT,
+                  FORMAT   ='XMGRACE',
+                  BORNE_X  =(BVmin,BVmax),
+                  BORNE_Y  =(BFmin,BFmax),
+                  TITRE   = TITRE1,
+                  GRILLE_X = pasV,
+                  GRILLE_Y = pasF,
+                  LEGENDE_X = 'Vitesse (tr/mn)',
+                  LEGENDE_Y = 'FREQ (Hz)',
+                  **mfac1);  
+                    
+        
+        
+            for ii in range(NFREQ_tc):    
+                DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
+            del(LFONC)
+            del(mfac1, DICO)
+
+                     
+        # ----------------------------------------------------------------
+        # Trace du diagramme de campbell des modes en traction/compression        
+        # ----------------------------------------------------------------
+        TITRE2 = 'Modes en traction/compression'
+        if NFREQ_lc>0:
+            LFONC =[];
+            FON1 =[0]*NFREQ_lc;
+            mfac1={};
+            for jj in range(NFREQ_lc):
+       
+                FY1=DEFI_LIST_REEL(VALE=[FRQl[int(NVTl[jj][ii]-1)][ii] for ii in range(nbV)]);
+                FON1[jj]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=__FX,VALE_FONC=FY1);
+
+                DICO={};
+                DICO["FONCTION"]=FON1[jj];
+                DICO["COULEUR"] =8;
+                DICO["STYLE"]   =8;
+                DICO["MARQUEUR"]=0;
+                DICO["LEGENDE"] ='';
+                LFONC.append(DICO);
+            
+                DETRUIRE(CONCEPT=_F(NOM=(FY1)),INFO=1);
+   
+            mfac1["COURBE"]=LFONC;
+            IMPR_FONCTION(
+                  UNITE    = UNIT_LON,
+                  FORMAT   ='XMGRACE',
+                  BORNE_X  =(BVmin,BVmax),
+                  BORNE_Y  =(BFmin,BFmax),
+                  TITRE   = TITRE1,
+                  SOUS_TITRE = TITRE2,
+                  GRILLE_X = pasV,
+                  GRILLE_Y = pasF,
+                  LEGENDE_X = 'Vitesse (tr/mn)',
+                  LEGENDE_Y = 'FREQ (Hz)',
+                      **mfac1);              
+            IMPR_FONCTION(
+                  UNITE    = UNIT_TOT,
+                  FORMAT   ='XMGRACE',
+                  BORNE_X  =(BVmin,BVmax),
+                  BORNE_Y  =(BFmin,BFmax),
+                  TITRE   = TITRE1,
+                  GRILLE_X = pasV,
+                  GRILLE_Y = pasF,
+                  LEGENDE_X = 'Vitesse (tr/mn)',
+                  LEGENDE_Y = 'FREQ (Hz)',
+                      **mfac1);
+     
+        
+  
+            for ii in range(NFREQ_lc):    
+                DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
+            del(LFONC)
+            del(mfac1, DICO);
+
+        if NFREQ_f>0:
+            for jj in range(nbV):        
+                DETRUIRE(CONCEPT=_F(NOM=(MODEf[jj])),INFO=1)
+        if NFREQ_t>0:
+            for jj in range(nbV):        
+                DETRUIRE(CONCEPT=_F(NOM=(MODEt[jj])),INFO=1)
+        if NFREQ_l>0:
+            for jj in range(nbV):        
+                DETRUIRE(CONCEPT=_F(NOM=(MODEl[jj])),INFO=1)
+    
+     #DETRUIRE(CONCEPT=_F(NOM=(FX)),INFO=1)
+
+
+#------------------------------------------------------------------------------------
+
+        # -----------------------------
+        # Trace des droites de pentes S        
+        # -----------------------------
+        
+        # Pour S=1, on le trace automatiquement
+        S=1.0;
+        L_S1=[];
+        
+        if type(L_S)==list:
+            L_S1=L_S;
+        elif type(L_S)==tuple:
+            L_S1=list(L_S);
+        elif type(L_S)==float:           
+            L_S1.append(L_S);
+        L_S1.append(S);
+    
+        # Supprimer la redondance dans la liste
+        sup_redon_list(L_S1);
+        
+        
+        # Faire une dictionnaire de courbe
+        # Constituer de liste de dictionnaire de fonctions
+        LFONC =[];
+        FON1 =[0]*len(L_S1);
+        mfac1={};
+        for ii in range(len(L_S1)):
+            F1 =BVmin*L_S1[ii]/60.
+            F2 =BVmax*L_S1[ii]/60. 
+            FX1=DEFI_LIST_REEL(VALE=[BVmin,BVmax]);
+            FY1=DEFI_LIST_REEL(VALE=[F1,F2]);
+      
+            FON1[ii]=DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX1,VALE_FONC=FY1);
+
+            DICO={};
+            DICO["FONCTION"]=FON1[ii];
+            DICO["COULEUR"] =1;
+            DICO["STYLE"]   =1;
+            DICO["MARQUEUR"]=0;
+            DICO["LEGENDE"] ='';
+            LFONC.append(DICO);
+       
+            DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1)),INFO=1);
+
+        mfac1["COURBE"]=LFONC;
+        if NFREQ_fc>0: 
+            TITRE2 = 'Modes en flexion'
+            IMPR_FONCTION(
+                        UNITE   = UNIT_FLE,
+                        FORMAT  = 'XMGRACE',
+                        BORNE_X = (BVmin,BVmax),
+                        BORNE_Y = (BFmin,BFmax),
+                        TITRE   = TITRE1,
+                        SOUS_TITRE   = TITRE2,
+                        GRILLE_X = pasV,
+                        GRILLE_Y = pasF, 
+                        LEGENDE_X = 'Vitesse (tr/mn)',
+                        LEGENDE_Y = 'FREQ (Hz)',
+                        **mfac1);
+                                                
+        if NFREQ_tc>0:                 
+            TITRE2 = 'Modes en Torsion'
+            IMPR_FONCTION(
+                        UNITE   = UNIT_TOR,
+                        FORMAT  = 'XMGRACE',
+                        BORNE_X = (BVmin,BVmax),
+                        BORNE_Y = (BFmin,BFmax),
+                        TITRE   = TITRE1,
+                        SOUS_TITRE   = TITRE2,
+                        GRILLE_X = pasV,
+                        GRILLE_Y = pasF, 
+                        LEGENDE_X = 'Vitesse (tr/mn)',
+                        LEGENDE_Y = 'FREQ (Hz)',
+                            **mfac1);
+        if NFREQ_lc>0: 
+            TITRE2 = 'Modes en traction/compression'       
+            IMPR_FONCTION(
+                        UNITE   = UNIT_LON,
+                        FORMAT  = 'XMGRACE',
+                        BORNE_X = (BVmin,BVmax),
+                        BORNE_Y = (BFmin,BFmax),
+                        TITRE   = TITRE1,
+                        SOUS_TITRE   = TITRE2,
+                        GRILLE_X = pasV,
+                        GRILLE_Y = pasF, 
+                        LEGENDE_X = 'Vitesse (tr/mn)',
+                        LEGENDE_Y = 'FREQ (Hz)',
+                            **mfac1);
+  
+        IMPR_FONCTION(
+                        UNITE   = UNIT_TOT,
+                        FORMAT  = 'XMGRACE',
+                        BORNE_X = (BVmin,BVmax),
+                        BORNE_Y = (BFmin,BFmax),
+                        TITRE   = TITRE1,
+                        GRILLE_X = pasV,
+                        GRILLE_Y = pasF, 
+                        LEGENDE_X = 'Vitesse (tr/mn)',
+                        LEGENDE_Y = 'FREQ (Hz)',
+                            **mfac1);
+        
+        for ii in range(len(L_S1)):    
+            DETRUIRE(CONCEPT=_F(NOM=(FON1[ii])),INFO=1);
+        
+        del(LFONC)
+        del(mfac1, DICO)
+        
+        DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_FLE,)
+        DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_TOR,)
+        DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_LON,)
+        DEFI_FICHIER ( ACTION='LIBERER', UNITE=UNIT_TOT,)
+
+#------------------------------------------------------------------------------------
+
+        # --------------------------------------------------------------
+        # Determination des points d'intersection avec les droites Y=AX
+        # Calcul des coordonnees des points
+        # --------------------------------------------------------------
+
+        
+        # Ecrire dans un fichier texte en sortie
+        DEFI_FICHIER(TYPE='ASCII', UNITE=UNIT_INT,);
+        nomfic='fort.'+str(UNIT_INT);
+        #FINT1=open('fort.25', 'w')
+        FINT1=open(nomfic, 'w')
+
+        INTERSEC =[];
+        # Modes en flexion
+
+        for ii in range(len(L_S1)):
+            DICO={};
+            DICO["pente"]=L_S1[ii];
+            ll=0; 
+            XY=[[None]*2];          
+            for jf in range(NFREQ_fc):
+                for iv in range(nbV-1):
+                    if TYP_TRI==0:
+                        jf1=NVTf[jf][iv]-1; 
+                        jf2=NVTf[jf][iv+1]-1; 
+                    if TYP_TRI==1: 
+                        jf1=NVTf_prec[jf][iv]-1;
+                        jf2=NVTf_prec[jf][iv+1]-1; 
+                    if TYP_TRI==2:
+                        jf1=NVTf_mac[jf][iv]-1;
+                        jf2=NVTf_mac[jf][iv+1]-1;
+                    if jf1>=0 and jf2>=0:
+                        X1 = OM[iv];
+                        Y1 = FRQf[jf1][iv];
+                        X2 = OM[iv+1];
+                        Y2 = FRQf[jf2][iv+1];
+                        A  = (Y1-Y2)/(X1-X2);
+                        B  = Y1-(A*X1);
+                        pente = L_S1[ii];
+                        P1 = B*60./(pente-A*60.);
+                        P2 = P1*pente/60.;
+                
+                        if P1 >=X1 and P1<=X2:
+                            if P2 >= Fmin and P2<=Fmax :
+                                XY[ll][0]=P1;
+                                XY[ll][1]=P2;
+                                # On ajoute une ligne supplementaire
+                                XY.append([None]*2);
+                                ll=ll+1;
+                            
+                           
+            L_XY=XY[0:ll];               
+            DICO["point"]=L_XY;
+            INTERSEC.append(DICO);
+        #print "INTERSEC"
+        #print dir(INTERSEC)
+        #print INTERSEC
+              
+        # Sauvegarde des points d'intersection
+        FINT1.write('\n')  
+        chaine = 'Mode en flexion' 
+        FINT1.write(chaine) 
+        save_intersec(INTERSEC, FINT1);
+
+        del(XY, L_XY)
+        del(INTERSEC, DICO)
+         
+        INTERSEC =[];
+        # Modes en torsion
+        for ii in range(len(L_S1)):
+            DICO={};
+            DICO["pente"]=L_S1[ii];
+            ll=0; 
+            XY=[[None]*2];   
+            for jf in range(NFREQ_tc):
+                for iv in range(nbV-1):
+                    jf1=NVTt[jf][iv]-1; 
+                    jf2=NVTt[jf][iv+1]-1; 
+                    if jf1>=0 and jf2>=0:
+                        X1 = OM[iv];
+                        Y1 = FRQt[jf1][iv];
+                        X2 = OM[iv+1];
+                        Y2 = FRQt[jf2][iv+1];
+                        A  = (Y1-Y2)/(X1-X2);
+                        B  = Y1-(A*X1);
+                        pente = L_S1[ii];
+                        P1 = B*60./(pente-A*60.);
+                        P2 = P1*pente/60.;
+                
+                        if P1 >=X1 and P1<=X2:
+                            if P2 >= Fmin and P2<=Fmax :
+                                XY[ll][0]=P1;
+                                XY[ll][1]=P2;
+                                # On ajoute une ligne supplementaire
+                                XY.append([None]*2);
+                                ll=ll+1;                     
+                           
+            L_XY=XY[0:ll];               
+            DICO["point"]=L_XY;
+            INTERSEC.append(DICO);
+            
+        # Sauvegarde des points d'intersection
+        FINT1.write('\n')   
+        FINT1.write('\n')   
+        chaine = 'Mode en Torsion' 
+        FINT1.write(chaine) 
+        save_intersec(INTERSEC, FINT1);
+
+        del(XY, L_XY)
+        del(INTERSEC, DICO)
+
+
+#------------------------------------------------------------------------------------
+
+        INTERSEC =[];
+        # Modes en traction / compression
+        for ii in range(len(L_S1)):
+            DICO={};
+            DICO["pente"]=L_S1[ii];
+            ll=0; 
+            XY=[[None]*2];   
+            for jf in range(NFREQ_lc):
+                for iv in range(nbV-1):
+                    jf1=NVTl[jf][iv]-1; 
+                    jf2=NVTl[jf][iv+1]-1; 
+                    if jf1>=0 and jf2>=0:
+                        X1 = OM[iv];
+                        Y1 = FRQl[jf1][iv];
+                        X2 = OM[iv+1];
+                        Y2 = FRQl[jf2][iv+1];
+                        A  = (Y1-Y2)/(X1-X2);
+                        B  = Y1-(A*X1);
+                        pente = L_S1[ii];
+                        P1 = B*60./(pente-A*60.);
+                        P2 = P1*pente/60.;
+                
+                        if P1 >=X1 and P1<=X2:
+                            if P2 >= Fmin and P2<=Fmax :
+                                XY[ll][0]=P1;
+                                XY[ll][1]=P2;
+                                # On ajoute une ligne supplementaire
+                                XY.append([None]*2);
+                                ll=ll+1;                     
+                           
+            L_XY=XY[0:ll];               
+            DICO["point"]=L_XY;
+            INTERSEC.append(DICO);
+            
+        # Sauvegarde des points d'intersection
+        FINT1.write('\n') 
+        FINT1.write('\n')    
+        chaine = 'Mode en traction / compression' 
+        FINT1.write(chaine) 
+        save_intersec(INTERSEC, FINT1);
+
+        del(XY, L_XY)
+        del(INTERSEC, DICO)
+        #print L_S1, len(L_S1)
+        nbl=len(L_S1)
+        for ii in range(nbl):
+            il =nbl-ii-1;
+            del L_S1[il];
+        FINT1.close()
+
+
+#------------------------------------------------------------------------------------
+

diff --git a/Aster/Cata/cataSTA10/Macro/impr_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/impr_fonction_ops.py
new file mode 100644 (file)
index 0000000..1d7a334
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/impr_fonction_ops.py
@@ -0,0 +1,407 @@
+#@ MODIF impr_fonction_ops Macro  DATE 06/07/2009   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 MCOURTOI M.COURTOIS
+
+import os.path
+
+# ------------------------------------------------------------------------------
+def impr_fonction_ops(self, FORMAT, COURBE, INFO, **args):
+   """
+   Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions,
+   colonnes de table...
+   Erreurs<S> dans IMPR_FONCTION pour ne pas perdre la base.
+   """
+   macro='IMPR_FONCTION'
+   import pprint
+   import aster
+   from Accas               import _F
+   from Cata.cata           import nappe_sdaster, fonction_c, formule, formule_c
+   from Utilitai            import Graph
+   from Utilitai.Utmess     import UTMESS
+   from Utilitai.UniteAster import UniteAster
+   
+   ier=0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   CALC_FONC_INTERP = self.get_cmd('CALC_FONC_INTERP')
+   DEFI_LIST_REEL   = self.get_cmd('DEFI_LIST_REEL')
+   DETRUIRE         = self.get_cmd('DETRUIRE')
+
+   #----------------------------------------------
+   # 0. Traitement des arguments, initialisations
+   # unité logique des fichiers réservés
+   ul_reserve=(8,)
+   UL = UniteAster()
+
+   # 0.1. Fichier
+   nomfich=None
+   if args['UNITE'] and args['UNITE']!=6:
+      nomfich=UL.Nom(args['UNITE'])
+      if INFO==2:
+         aster.affiche('MESSAGE', ' Nom du fichier :'+nomfich)
+   if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size!=0:
+      if FORMAT=='XMGRACE':
+         niv='A'
+      else:
+         niv='I'
+      UTMESS(niv, 'FONCT0_1', valk=nomfich)
+
+   # 0.2. Récupération des valeurs sous COURBE
+   unparmi=('FONCTION','LIST_RESU','FONC_X','ABSCISSE')
+
+   # i0 : indice du mot-clé facteur qui contient LIST_PARA, sinon i0=0
+   i0=0
+   Courbe=[]
+   iocc=-1
+   for Ci in COURBE:
+      iocc+=1
+      dC = Ci.cree_dict_valeurs(Ci.mc_liste)
+      if dC.has_key('LIST_PARA') and dC['LIST_PARA']!=None and i0==0:
+         i0=iocc
+      for mc in dC.keys():
+         if dC[mc]==None: del dC[mc]
+      Courbe.append(dC)
+   if INFO==2:
+      aster.affiche('MESSAGE',' Nombre de fonctions à analyser : '+str(len(Courbe)))
+
+   # 0.3. Devra-t-on interpoler globalement ?
+   #      Dans ce cas, linter__ est le LIST_PARA
+   #      ou, à défaut, les abscisses de la première courbe
+   interp=False
+   if FORMAT=='TABLEAU':
+      interp=True
+      dCi=Courbe[i0]
+      if dCi.has_key('LIST_PARA'):
+         linter__=dCi['LIST_PARA']
+      else:
+         obj=None
+         for typi in unparmi:
+            if dCi.has_key(typi):
+               obj=dCi[typi]
+               break
+         if obj==None:
+            UTMESS('S', 'SUPERVIS_56')
+         if typi=='FONCTION':
+            if isinstance(obj, nappe_sdaster):
+               lpar,lval=obj.Valeurs()
+               linterp=lval[0][0]
+            else:
+               linterp=obj.Valeurs()[0]
+         elif typi=='FONC_X':
+            lbid,linterp=obj.Valeurs()
+         elif typi=='ABSCISSE':
+            linterp=obj
+         linter__=DEFI_LIST_REEL(VALE=linterp)
+      if INFO==2:
+         aster.affiche('MESSAGE', ' Interpolation globale sur la liste :')
+         aster.affiche('MESSAGE', pprint.pformat(linter__.Valeurs()))
+
+
+   #----------------------------------------------
+   # 1. Récupération des valeurs des N courbes sous forme
+   #    d'une liste de N listes
+   #----------------------------------------------
+   graph=Graph.Graph()
+   iocc=-1
+   for dCi in Courbe:
+      iocc+=1
+
+      # 1.1. Type d'objet à traiter
+      obj=None
+      for typi in unparmi:
+         if dCi.has_key(typi):
+            obj=dCi[typi]
+            break
+      if not dCi.has_key('LEGENDE') and hasattr(obj,'get_name'):
+            dCi['LEGENDE']=obj.get_name()
+      if obj==None:
+         UTMESS('S', 'SUPERVIS_56')
+
+      # 1.2. Extraction des valeurs
+
+      # 1.2.1. Mot-clé FONCTION
+      if   typi=='FONCTION':
+         # formule à un paramètre seulement
+         if isinstance(obj, formule):
+            dpar = obj.Parametres()
+            if len(dpar['NOM_PARA']) != 1:
+               UTMESS('S', 'FONCT0_50', valk=obj.nom, vali=len(dpar['NOM_PARA']))
+         
+         if isinstance(obj, nappe_sdaster):
+            lpar,lval=obj.Valeurs()
+            dico,ldicf=obj.Parametres()
+            Leg=dCi['LEGENDE']
+            for i in range(len(lpar)):
+               p=lpar[i]
+               lx=lval[i][0]
+               ly=lval[i][1]
+               # sur quelle liste interpoler chaque fonction
+               if i==0:
+                  if interp:
+                     li__=linter__
+                  elif dCi.has_key('LIST_PARA'):
+                     li__=dCi['LIST_PARA']
+                  else:
+                     li__=DEFI_LIST_REEL(VALE=lx)
+               # compléter les paramètres d'interpolation
+               dic=dico.copy()
+               dic.update(ldicf[i])
+               
+               if (interp or dCi.has_key('LIST_PARA')) and i>0:
+                  ftmp__=CALC_FONC_INTERP(
+                     FONCTION=obj,
+                     VALE_PARA=p,
+                     LIST_PARA_FONC=li__,
+                     **dic
+                  )
+                  pv,lv2=ftmp__.Valeurs()
+                  lx=lv2[0][0]
+                  ly=lv2[0][1]
+               # on stocke les données dans le Graph
+               nomresu=dic['NOM_RESU'].strip()+'_'+str(len(graph.Legendes))
+               dicC={
+                  'Val' : [lx,ly],
+                  'Lab' : [dic['NOM_PARA_FONC'],nomresu]
+               }
+               # ajoute la valeur du paramètre
+               dCi['LEGENDE'] = '%s %s=%g' % (Leg,dic['NOM_PARA'].strip(),p)
+               Graph.AjoutParaCourbe(dicC, args=dCi)
+               graph.AjoutCourbe(**dicC)
+               DETRUIRE(OBJET=_F(CHAINE=('li__','ftmp__'),),ALARME='NON',INFO=1)
+         else:
+            ftmp__=obj
+            dpar=ftmp__.Parametres()
+            # pour les formules à un paramètre (test plus haut)
+            if type(dpar['NOM_PARA']) in (list, tuple):
+               dpar['NOM_PARA'] = dpar['NOM_PARA'][0]
+            if interp:
+               ftmp__=CALC_FONC_INTERP(
+                  FONCTION=obj,
+                  LIST_PARA=linter__,
+                  **dpar
+               )
+            elif dCi.has_key('LIST_PARA'):
+               ftmp__=CALC_FONC_INTERP(
+                  FONCTION=obj,
+                  LIST_PARA=dCi['LIST_PARA'],
+                  **dpar
+               )
+            lval=list(ftmp__.Valeurs())
+            lx=lval[0]
+            lr=lval[1]
+            if isinstance(obj, (fonction_c, formule_c)) and dCi.get('PARTIE') == 'IMAG':
+               lr=lval[2]
+            # on stocke les données dans le Graph
+            if isinstance(obj, (fonction_c, formule_c)) and not dCi.has_key('PARTIE'):
+               nomresu=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes))
+               dicC={
+                  'Val' : lval,
+                  'Lab' : [dpar['NOM_PARA'],nomresu+'_R',nomresu+'_I']
+               }
+            else:
+               nomresu=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes))
+               dicC={
+                  'Val' : [lx,lr],
+                  'Lab' : [dpar['NOM_PARA'],nomresu]
+               }
+            Graph.AjoutParaCourbe(dicC, args=dCi)
+            graph.AjoutCourbe(**dicC)
+
+      # 1.2.2. Mot-clé LIST_RESU
+      elif typi=='LIST_RESU':
+         if interp and iocc>0:
+            UTMESS('S', 'FONCT0_2')
+         lx=dCi['LIST_PARA'].Valeurs()
+         lr=obj.Valeurs()
+         if len(lx)!=len(lr):
+            UTMESS('S', 'FONCT0_3')
+         # on stocke les données dans le Graph
+         dicC={
+            'Val' : [lx,lr],
+            'Lab' : [dCi['LIST_PARA'].get_name(),obj.get_name()]
+         }
+         Graph.AjoutParaCourbe(dicC, args=dCi)
+         graph.AjoutCourbe(**dicC)
+
+      # 1.2.3. Mot-clé FONC_X
+      # exemple : obj(t)=sin(t), on imprime x=sin(t), y=cos(t)
+      #           ob2(t)=cos(t)
+      elif typi=='FONC_X':
+         ob2=dCi['FONC_Y']
+         # peut-on blinder au niveau du catalogue
+         if isinstance(obj, nappe_sdaster) or isinstance(ob2, nappe_sdaster):
+            UTMESS('S', 'FONCT0_4')
+         if interp and iocc>0:
+            UTMESS('S', 'FONCT0_5')
+         ftmp__=obj
+         dpar=ftmp__.Parametres()
+         ftm2__=ob2
+         dpa2=ftm2__.Parametres()
+         intloc=False
+         if interp and not dCi.has_key('LIST_PARA'):
+            # dans ce cas, linter__ contient les ordonnées de FONC_X
+            intloc=False
+            li__=linter__
+         elif dCi.has_key('LIST_PARA'):
+            intloc=True
+            li__=dCi['LIST_PARA']
+         if intloc:
+            ftmp__=CALC_FONC_INTERP(
+               FONCTION=obj,
+               LIST_PARA=li__,
+               **dpar
+            )
+            lt,lx=ftmp__.Valeurs()
+            ftm2__=CALC_FONC_INTERP(
+               FONCTION=ob2,
+               LIST_PARA=li__,
+               **dpa2
+            )
+         else:
+            lt,lx=ftmp__.Valeurs()
+            li__=DEFI_LIST_REEL(VALE=lt)
+            ftm2__=CALC_FONC_INTERP(
+               FONCTION=ob2,
+               LIST_PARA=li__,
+               **dpa2
+            )
+         
+         lbid,ly=ftm2__.Valeurs()
+         # on stocke les données dans le Graph
+         # on imprime la liste des paramètres seulement si LIST_PARA
+         if intloc:
+            nomresur=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes))
+            nomresu2=dpa2['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)+1)
+            dicC={
+               'Val' : [lt,lx,ly],
+               'Lab' : [dpar['NOM_PARA'],nomresur,nomresu2]
+            }
+         else:
+            nomresur=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes))
+            nomresu2=dpa2['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)+1)
+            dicC={
+               'Val' : [lx,ly],
+               'Lab' : [nomresur,nomresu2]
+            }
+         Graph.AjoutParaCourbe(dicC, args=dCi)
+         graph.AjoutCourbe(**dicC)
+
+      # 1.2.4. Mot-clé ABSCISSE / ORDONNEE
+      elif typi=='ABSCISSE':
+         if interp and iocc>0:
+            UTMESS('S', 'FONCT0_6')
+         lx=obj
+         lr=dCi['ORDONNEE']
+         if len(lx)!=len(lr):
+            UTMESS('S', 'FONCT0_7')
+         # on stocke les données dans le Graph
+         dicC={
+            'Val' : [lx,lr],
+            'Lab' : ['Absc','Ordo']
+         }
+         Graph.AjoutParaCourbe(dicC, args=dCi)
+         graph.AjoutCourbe(**dicC)
+
+      # 1.2.9. ménage
+      DETRUIRE(OBJET=_F(CHAINE=('li__','ftmp__','ftm2__'),),ALARME='NON',INFO=1)
+
+   # 1.2.99. ménage hors boucle
+   DETRUIRE(OBJET=_F(CHAINE='linter__',), ALARME='NON',INFO=1)
+
+   # 1.3. dbg
+   if INFO==2:
+      message='\n'+'-'*70+'\n Contenu du Graph : \n'+'-'*70+'\n'
+      message=message+graph.__repr__()
+      message=message+'-'*70+'\n'
+      aster.affiche('MESSAGE',message)
+
+   #----------------------------------------------
+   # 2. Impression du 'tableau' de valeurs
+   #----------------------------------------------
+
+   # 2.0. Surcharge des propriétés du graphique et des axes
+   # (bloc quasiment identique dans Table)
+   if args['TITRE']!=None:          graph.Titre=args['TITRE']
+   if args['SOUS_TITRE']!=None:     graph.SousTitre=args['SOUS_TITRE']
+   if FORMAT in ('XMGRACE','AGRAF'):
+      if args['BORNE_X']!=None:
+                                       graph.Min_X=args['BORNE_X'][0]
+                                       graph.Max_X=args['BORNE_X'][1]
+      if args['BORNE_Y']!=None:
+                                       graph.Min_Y=args['BORNE_Y'][0]
+                                       graph.Max_Y=args['BORNE_Y'][1]
+      if args['LEGENDE_X']!=None:      graph.Legende_X=args['LEGENDE_X']
+      if args['LEGENDE_Y']!=None:      graph.Legende_Y=args['LEGENDE_Y']
+      if args['ECHELLE_X']!=None:      graph.Echelle_X=args['ECHELLE_X']
+      if args['ECHELLE_Y']!=None:      graph.Echelle_Y=args['ECHELLE_Y']
+      if args['GRILLE_X']!=None:       graph.Grille_X=args['GRILLE_X']
+      if args['GRILLE_Y']!=None:       graph.Grille_Y=args['GRILLE_Y']
+
+   kargs={
+      'FORMAT'    : FORMAT,
+      'FICHIER'   : nomfich,
+   }
+   
+   # 2.1. au format TABLEAU
+   if FORMAT=='TABLEAU':
+      # surcharge par les formats de l'utilisateur
+      kargs['dform']={
+         'csep'   : args['SEPARATEUR'],
+         'ccom'   : args['COMMENTAIRE'],
+         'ccpara' : args['COMM_PARA'],
+         'cdeb'   : args['DEBUT_LIGNE'],
+         'cfin'   : args['FIN_LIGNE'],
+      }
+
+   # 2.2. au format AGRAF
+   elif FORMAT=='AGRAF':
+      nomdigr=None
+      if args['UNITE_DIGR']!=6:
+         nomdigr=UL.Nom(args['UNITE_DIGR'])
+      kargs['FICHIER']=[nomfich, nomdigr]
+      kargs['dform']={ 'formR' : '%12.5E' }
+
+   # 2.3. au format XMGRACE et dérivés
+   elif FORMAT=='XMGRACE':
+      kargs['dform']={ 'formR' : '%.8g' }
+      kargs['PILOTE']=args['PILOTE']
+
+   # 2.39. Format inconnu
+   else:
+      UTMESS('S', 'FONCT0_8', valk=FORMAT)
+
+   # Traiter le cas des UL réservées
+   if args['UNITE'] and args['UNITE'] in ul_reserve:
+      UL.Etat(args['UNITE'], etat='F')
+   if FORMAT=='AGRAF' and args['UNITE_DIGR']!=args['UNITE'] \
+         and args['UNITE_DIGR'] in ul_reserve:
+      UL.Etat(args['UNITE_DIGR'], etat='F')
+
+   # 2.4. On trace !
+   graph.Trace(**kargs)
+
+   # 99. Traiter le cas des UL réservées
+   UL.EtatInit()
+
+   return ier

diff --git a/Aster/Cata/cataSTA10/Macro/impr_oar_ops.py b/Aster/Cata/cataSTA10/Macro/impr_oar_ops.py
new file mode 100644 (file)
index 0000000..0a45e20
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/impr_oar_ops.py
@@ -0,0 +1,773 @@
+#@ MODIF impr_oar_ops Macro  DATE 19/11/2007   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.        
+# ======================================================================
+
+# protection pour eficas
+try:
+   import aster
+   from Utilitai.Utmess import  UTMESS
+   from Utilitai.Table import Table
+   from Utilitai.partition import MAIL_PY
+except:
+   pass
+
+def buildTabString(tabLevel):
+   """
+      Construit une chaine de tabulation
+   """
+   chaine = ''
+   for i in range(0, tabLevel) :
+      chaine += '\t'
+      
+   return chaine
+   
+def getBornes(listIn, valTest) :
+   """
+      Retourne un doublet de valeurs qui correspond aux valeurs de la liste qui encadrent la valeur (valTest)
+      Si val n'est pas encadrée par des valeurs de la liste, une des valeurs du doublet est None
+   """
+   v1 = None
+   v2 = None   
+   for val in listIn :
+      if valTest > val : v1 = val
+      if valTest < val : v2 = val
+      
+   # traitement des cas limites
+   if valTest == listIn[0] : v1 = listIn[0]
+   if valTest == listIn[len(listIn)-1] : v2 = listIn[len(listIn)-1]
+   
+   return (v1, v2) 
+
+def interpoleLin(listDoublet, X) :
+   """
+      Interpole linéairement entre deux bornes définies par listDoublets[(X0, Y0), (X1, Y1)] la valeur Y en X
+   """
+   X0 = listDoublet[0][0]
+   Y0 = listDoublet[0][1]
+   X1 = listDoublet[1][0]
+   Y1 = listDoublet[1][1]
+   
+   return Y0 + (X - X0) * (Y1 - Y0) / (X1 - X0)
+
+class interpolationError(Exception) :
+   def __init__(self) :
+      self.mess = 'Interpolation sur une valeur hors bornes'
+      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 XMLNode :
+    """
+        Classe gérant un noeud de l'arborescence XML
+        Un noeud possède :
+            - un nom de balise
+            - un commentaire (optionnel)
+            - un ensemble de "paramètres" (optionnels)
+            - une liste d'élément ou d'autres noeuds (optionnels/possibilité de balises vides) :
+
+        La classe propose : 
+            - une méthode "buildTree" qui parcoure le liste de manière récursive pour
+              produire l'arborescence XML en vu de son enregistrement ou son impression
+            - (TO DO) une methode statique "loadTree" qui produit un arbre XML à partir d'un fichier
+    """
+    def __init__(self, nomBalise, valeur = None, commentaire = None, **listOpt) :
+        self.nomBalise = nomBalise
+        self.commentaire = commentaire
+        self.param = listOpt
+        self.arbre=list()
+        if valeur != None : self.addValue(valeur) # None n'est pas 0 !
+
+    def getCommentaire(self) : return self.commentaire
+
+    def setCommentaire(sel, commentaire) : self.commentaire = commentaire
+
+    def getParametres(self) : return  self.param
+
+    def setParametres(self, parametres) : self.param = parametres    
+
+    def append(self, nodeName, valeur=None, commentaire = None, **listOpt) :
+        """
+            Ajoute un noeud à l'arborescence et retourne une référence sur ce noeud
+            On peut ajouter directement la valeur, si simple, associée à la balise
+        """
+        node = XMLNode(nodeName, valeur, commentaire)
+
+        self.arbre.append(node)
+
+        return self.arbre[len(self.arbre)-1]
+
+    def addValue(self, valeur):
+        """
+            Ajoute un élément "simple" (nombre, texte) à l'arborescence
+        """
+        self.arbre.append(valeur)
+            
+    def buildTree(self, tabLevel=0) :
+        """
+            Construit l'arborescence XML en parcourant récursivement la structure de donnée
+            et la retourne sous la forme d'une chaine de caractères
+
+            tabLevel permet de gérer l'indentation
+        """
+        # Construction de la chaine de tabulations nécessaire à une bonne lecture du fichier XML
+        tabString = buildTabString(tabLevel) 
+
+        XMLString = ''
+        
+        try :
+            # listOpt contient les paramètres optionnels de la balise
+            chaine = ''
+            for v in self.param.keys() :
+                chaine = chaine + ' ' +  v  + '=' + self.param[v] 
+        except : pass
+        
+        baliseOuverture=tabString + "<" + self.nomBalise + chaine +">\n"
+        XMLString += baliseOuverture
+
+        if self.commentaire :
+            XMLString = XMLString + tabString + "\t<!--"+self.commentaire+"-->\n"
+
+        for elem in self.arbre :
+            try :
+                XMLString += elem.buildTree(tabLevel+1)
+            except : # l'élément n'est pas un noeud
+                XMLString = XMLString + tabString + '\t' + str(elem) + '\n'
+
+        XMLString = XMLString + tabString + "</"+self.nomBalise+">\n"
+
+        return XMLString
+
+    def save(self, fileObj) :
+        """ 
+         Construit le l'arborescence XML et l'écrit dans un fichier 
+         pointé par le handler passé en paramètres
+        """ 
+        try :
+            fileObj.write(self.buildTree())
+        except : pass
+
+class OAR_element :
+   """
+      Classe de base des éléments manipulés par IMPR_OAR
+   """
+   def __init__(self) :
+      self.nodeComp = None
+      
+   def buildTree(self) : pass
+
+   def getNode(self) :
+      """
+         Renvoie le noeud XML construit par buildTree
+      """
+      return self.nodeComp
+   
+
+class composant(OAR_element) :
+   """
+      Classe permettant de traiter les composants
+      
+      NB :
+      1. L utilisateur est suppose faire la meme coupe pour le calcul mecanique et le calcul thermo-mecanique 
+      2. Dans le cas d'un revetement, l'utilisateur est supposé définir son plan de coupe de telle sorte 
+         que la coupe de la structure et la coupe du revetement se raccordent
+   """
+   def __init__(self, **args) :
+      self.nodeComp = XMLNode("COMPOSANT") # Racine de l'arborescence composant
+      
+      self.diametre = args['DIAMETRE']
+      self.origine  = args['ORIGINE']
+      self.coef_u   = args['COEF_U']
+      self.angle_c  = args['ANGLE_C']
+      self.revet    = args['REVET']
+      
+      self.lastAbscisse = None # Permet de gerer le recouvrement des points de coupe entre revetement et structure
+      self.num_char = -1
+      self.type_char = ''
+      self.tabAbscisses = list()
+      self.tabAbscisses_S = None
+      self.dictMeca = dict()
+      self.dictMeca_S = None # Pas créé car optionnel
+      self.epaisseur = 0.0
+      self.epaisseur_R = 0.0
+
+      # dictionnaire gérant le résultat contraintes en fonction des instants et des abscisses
+      self.dictInstAbscSig = dict()
+      self.dictInstAbscSig_S = None # Création si nécessaire
+      # dictionnaire gérant le résultat température en fonction des instants et des abscisses
+      self.dictInstAbscTemp = dict()
+      self.dictInstAbscTemp_S = None # facultatif 
+      self.list_inst = None
+      self.num_tran = None    
+
+      self.noResuMeca = False
+      self.noResuTher = False
+      
+      # 1. resultat mecanique
+      try : 
+         # On ne construit qu'une table des abscisses et une table des contraintes.
+         # Le revetement est obligatoirement en interne on commence par lui
+         para_resu_meca = args['RESU_MECA']
+         self.num_char = para_resu_meca['NUM_CHAR']
+         self.type_char = para_resu_meca['TYPE']
+
+         if self.revet == 'OUI' :
+            # Construction de la table complementaire si revetement
+            self.dictMeca_S = dict()
+            self.tabAbscisses_S = list()
+            self.buildTablesMeca('TABLE_S', para_resu_meca, self.tabAbscisses_S, self.dictMeca_S)
+            self.epaisseur_R = abs(self.tabAbscisses_S[len(self.tabAbscisses_S)-1] - self.tabAbscisses_S[0])
+         
+         self.buildTablesMeca('TABLE', para_resu_meca, self.tabAbscisses, self.dictMeca, offset=self.epaisseur_R)
+        
+         if self.revet == 'OUI' :
+            self.mergeDictMeca() # merge les tableaux resultats du revetement et de la structure
+
+         # Calcul de l'épaisseur de la coupe.
+         self.epaisseur = abs(self.tabAbscisses[len(self.tabAbscisses)-1] - self.tabAbscisses[0])
+ 
+      except : 
+         self.noResuMeca = True
+      
+      # 2. Résultat thermique
+      try :
+         para_resu_ther = RESU_THER
+         self.num_tran = para_resu_ther['NUM_TRAN']
+         self.tabAbscisses = list()
+         self.tabAbscisses_S = None
+         
+         listInst = list()
+         if self.revet == 'OUI' :
+            # Le revetement est obligatoirement en interne on commence par lui
+            # 1. Construction champ temperature
+            self.dictInstAbscTemp_S = dict()
+            self.buildTemp('TABLE_ST', para_resu_ther, self.dictInstAbscTemp_S)
+         
+            # 2. Construction de la "table" des contraintes
+            self.dictInstAbscSig_S = dict()
+            self.tabAbscisses_S = list()
+            self.buildTablesTher('TABLE_S', para_resu_ther, self.tabAbscisses_S, self.dictInstAbscSig_S)
+               
+            # 3. calcul de l'épaisseur
+            self.epaisseur_R = abs(self.tabAbscisses_S[len(self.tabAbscisses_S)-1] - self.tabAbscisses_S[0])
+         
+         # Pour la structure
+         # 1. Construction champ température
+         self.buildTemp('TABLE_TEMP', para_resu_ther, self.dictInstAbscTemp, self.epaisseur_R)
+
+         # 2. Construction de la table des contraintes
+         self.buildTablesTher('TABLE_T', para_resu_ther, self.tabAbscisses, self.dictInstAbscSig, offset=self.epaisseur_R)
+        
+         if self.revet == 'OUI' :
+            self.mergeDictTher() # merge les tableaux resultats du revetement et de la structure
+            
+         if  not(self.compareListAbscTher()) :
+            UTMESS('F','OAR0_1')
+            
+         try :
+            self.interpoleInstants() # Interpolation des instants de la table des température sur celle de la table mécanique
+         except interpolationError, err:
+            UTMESS('F','OAR0_2',valk=err.getMess())
+
+         # 3. Calcul de l'épaisseur de la coupe.
+         self.epaisseur = abs(self.tabAbscisses[len(self.tabAbscisses)-1] - self.tabAbscisses[0])
+
+      except :
+         self.noResuTher = True
+      
+      # Construction de l arborescence
+      self.buildTree() 
+           
+                
+   def getAbscisses(self, dicoTable, tableAbsc, offset=0.0) :
+      """
+         Récupère la liste des abscisses
+      """
+      # récupération des abscisses
+      ABSCISSES = dicoTable['ABSC_CURV']
+     
+      valeurAbsc = 0.0
+      for val in ABSCISSES :
+         valeurAbsc = val + offset
+         tableAbsc.append(valeurAbsc)
+         
+   def buildTablesMeca(self, label, para_resu, tableAbsc, dictMeca, offset=0.0) :
+      """
+         Construction des tableaux mécanique 
+      """ 
+      sigma_xml   = ( 'S_RR', 'S_TT', 'S_ZZ', 'S_RT', 'S_TZ', 'S_ZR' )
+      
+      table_meca = para_resu[label].EXTR_TABLE() 
+      
+      # Utilisation des méthodes de la classe table
+      dictTable = table_meca.values()
+
+      # récupération des abscisses
+      self.getAbscisses(dictTable, tableAbsc, offset)
+      
+      # Construction de la table mécanique principale
+      for val in sigma_xml :
+         dictMeca[val] = list()
+
+      S_XX = dictTable['SIXX']
+      S_YY = dictTable['SIYY']
+      S_ZZ = dictTable['SIZZ']
+      S_XY = dictTable['SIXY']
+      S_YZ = dictTable['SIYZ']
+      S_XZ = dictTable['SIXZ']
+      for v1, v2, v3, v4, v5, v6 in zip(S_XX, S_YY, S_ZZ, S_XY, S_YZ, S_XZ) :
+         dictMeca['S_RR'].append(v1)
+         dictMeca['S_TT'].append(v2)
+         dictMeca['S_ZZ'].append(v3)
+         dictMeca['S_RT'].append(v4)
+         dictMeca['S_TZ'].append(v5)
+         dictMeca['S_ZR'].append(v6)
+    
+   def mergeDictMeca(self) :
+      """
+      Merge des résultats mécaniques issus de la structure et du revetement
+      """
+      # Merge des listes d'abscisses
+      # Le revetement est interieur la derniere abscisse du revetement doit etre egal a la premiere de la structure
+      if self.tabAbscisses_S[len(self.tabAbscisses_S)-1] != self.tabAbscisses[0] :
+         UTMESS('F','OAR0_3')
+         
+      # On construit une table des abscisses tempopraire
+      tableAbscTemp = self.tabAbscisses_S
+      
+      # On recopie la table des abscisses en sautant le premier
+      debut = True
+      for val in self.tabAbscisses :
+         if debut :
+            debut = False
+            continue
+         tableAbscTemp.append(val)
+         
+      self.tabAbscisses = tableAbscTemp
+      
+      # On construit des listes de travail intermédiaires que l'on commence par remplir avec les tables "supplémentaires"
+      dictMecaBis = self.dictMeca_S
+      
+      # On recopie les éléments de la structure dans le tableau
+      debut = True
+      for v1, v2, v3, v4, v5, v6 in zip(self.dictMeca['S_RR'], self.dictMeca['S_TT'], self.dictMeca['S_ZZ'], self.dictMeca['S_RT'], self.dictMeca['S_TZ'], self.dictMeca['S_ZR']) :
+         if debut :
+            debut = False
+            continue
+         dictMecaBis['S_RR'].append(v1)
+         dictMecaBis['S_TT'].append(v2)
+         dictMecaBis['S_ZZ'].append(v3)
+         dictMecaBis['S_RT'].append(v4)
+         dictMecaBis['S_TZ'].append(v5)
+         dictMecaBis['S_ZR'].append(v6)
+         
+      # On restitue ensuite la liste globale dans self.dictMeca
+      self.dictMeca = dictMecaBis
+
+  
+   def buildTemp(self, label, para_resu, dictInstAbscTemp, offset=0.0):
+      """
+         Récupération du champ température aux noeuds avec interpolation sur les "instants" du calcul mécanique
+      """
+      table_temp = para_resu[label].EXTR_TABLE()
+
+      # Utilisation des méthodes de la classe table
+      dictTable = table_temp.values()
+      
+      # On construit un dictionnaire associant un "instant" avec un couple ("abscisse", "température")
+
+      # 1. Récupération de la liste des instants
+      INSTANTS = dictTable['INST']
+      for val in INSTANTS :
+         dictInstAbscTemp[val] = 0 # On crée juste les clés du dictionnaire
+         
+      listTables = list() # liste de tables contenant une table pas instant
+      for inst in dictInstAbscTemp.keys():
+         listTables.append(table_temp.INST == inst)
+         
+      # 2. Récupération des abscisses
+      tableAbsc = list()
+      self.getAbscisses(listTables[0].values(), tableAbsc, offset)
+      
+      # 3. Récupération des températures
+      tableTemp = list() # liste de liste de température (1 par instant)
+      for tb in listTables :
+         TEMPERATURE = tb.values()['TEMP']
+         tableTemp.append(TEMPERATURE)
+         
+      # 4. Construction de dictInstAbscTemp
+      for i in range(0, len(dictInstAbscTemp.keys())):
+         listDoublets = list()
+         for absc, temp in zip(tableAbsc, tableTemp[i]) :
+            listDoublets.append((absc,temp))
+            
+         inst = dictInstAbscTemp.keys()[i]
+         dictInstAbscTemp[inst] = listDoublets
+         
+   def buildTablesTher(self, label, para_resu, tabAbscisses, dictInstAbscSig, offset=0.0) :
+      """
+         Construction des tableaux thermo-mécanique
+         listDictTher contient un dictionnaire par numéro d'ordre 
+      """
+      table_temp = para_resu[label].EXTR_TABLE()   
+
+      # On construit un dictionnaire associant un "instant" avec une liste de couples ("abscisse", liste de "sigma")
+
+      # Utilisation des méthodes de la classe table
+      dictTable = table_temp.values()
+      
+      # On construit un dictionnaire associant un "instant" avec un couple ("abscisse", "température")
+
+      # 1. Récupération de la liste des instants
+      INSTANTS = dictTable['INST']
+      for val in INSTANTS :
+         dictInstAbscSig[val] = 0 # On crée juste les clés du dictionnaire
+         
+      listTables = list() # liste de tables contenant une table pas instant
+      for inst in dictInstAbscSig.keys():
+         listTables.append(table_temp.INST == inst)
+         
+      # 2. Récupération des abscisses
+      self.getAbscisses(listTables[0].values(), tabAbscisses, offset)
+         
+      # 3. Récupération des listes de sigma
+      listListListSigAbscInst = list() # liste des sigma par abscisse par instant
+      for tbl in listTables:
+         listListSigAbscInst = list()
+         
+         # On crée une table pour chaque instant
+         S_XX = tbl.values()['SIXX']
+         S_YY = tbl.values()['SIYY']
+         S_ZZ = tbl.values()['SIZZ']
+         S_XY = tbl.values()['SIXY']
+         S_YZ = tbl.values()['SIYZ']
+         S_XZ = tbl.values()['SIXZ']
+         for v1, v2, v3, v4, v5, v6 in zip(S_XX, S_YY, S_ZZ, S_XY, S_YZ, S_XZ) :
+            listSigAbsc = list() # Liste des sigmas pour une abscisse
+            listSigAbsc.append(v1)
+            listSigAbsc.append(v2)
+            listSigAbsc.append(v3)
+            listSigAbsc.append(v4)
+            listSigAbsc.append(v5)
+            listSigAbsc.append(v6)
+            
+            listListSigAbscInst.append(listSigAbsc)
+            
+         listListListSigAbscInst.append(listListSigAbscInst)
+         
+      # 4. Assemblage du dictionnaire
+      for i in range(0, len(dictInstAbscSig.keys())) :
+         listDoublet = list()
+         for j in range(0, len(tabAbscisses)) :
+           listDoublet.append((tabAbscisses[j], listListListSigAbscInst[i][j]))
+               
+         dictInstAbscSig[dictInstAbscSig.keys()[i]] = listDoublet 
+
+   def mergeDictTher(self) : 
+      """
+         Merge les resultats issus de la coupe du revetement avec ceux issus de la coupe de la structure
+      """
+      # Merge des listes d'abscisses
+      # Le revetement est interieur la derniere abscisse du revetement doit etre egal a la premiere de la structure
+      if self.tabAbscisses_S[len(self.tabAbscisses_S)-1] != self.tabAbscisses[0] :
+         UTMESS('F','OAR0_3')
+         
+      # On construit une table des abscisses tempopraire
+      tableAbscTemp = self.tabAbscisses_S
+      
+      # On recopie la table des abscisses en sautant le premier
+      debut = True
+      for val in self.tabAbscisses :
+         if debut :
+            debut = False
+            continue
+         tableAbscTemp.append(val)
+         
+      self.tabAbscisses = tableAbscTemp
+       
+      # On construit des listes de travail intermédiaires que l'on commence par remplir avec les tables "supplémentaires"
+      dictInstAbscSigBis = self.dictInstAbscSig_S
+      dictInstAbscTempBis = self.dictInstAbscTemp_S
+      
+      # On recopie les élément thermiques de la structure principale en sautant la première abscisse de la structure
+      for key in dictInstAbscTempBis.keys() : # Les dictionnaires partagent les memes instants
+         debut = True
+         for valTher in self.dictInstAbscTemp[key] :
+            if debut :
+               debut = False
+               continue
+            dictInstAbscTempBis[key].append(valTher)
+            
+      # On recopie les élément mécaniques de la structure principale en sautant la première abscisse de la structure
+      for key in dictInstAbscSigBis.keys() : # Les dictionnaires partagent les memes instants
+         debut = True
+         for valSig in self.dictInstAbscSig[key] :
+            if debut :
+               debut = False
+               continue
+            dictInstAbscSigBis[key].append(valSig)
+
+      # On restitue ensuite la liste globale dans self.dictInstAbscSig
+      self.dictInstAbscSig = dictInstAbscSigBis
+      self.dictInstAbscTemp = dictInstAbscTempBis
+
+   def compareListAbscTher(self) :
+      """
+         Vérifie que la coupe du champ thermique et la coupe mécanique partagent les memes abscisses
+      """
+      # 1. Récupération des abscisses associées aux températures
+      listAbsc = list()
+      lstDoublet = self.dictInstAbscTemp[self.dictInstAbscTemp.keys()[0]]
+      for val in lstDoublet :
+         listAbsc.append(val[0])
+         
+      # 2. Comparaison des deux listes 
+      for A1, A2 in zip(self.tabAbscisses, listAbsc) :
+         if A1 != A2 : return False
+      
+      return True
+      
+   def interpoleInstants(self) :
+      """
+         Interpole les résultats thermique sur les instants des résultats mécaniques
+      """
+      # 1. récupération des instants des deux tables
+      listInstTher = self.dictInstAbscTemp.keys()
+      listInstMeca = self.dictInstAbscSig.keys()
+      
+      # 2. calcul de la liste des bornes de la table thermique qui encadrent les résultats mécaniques
+      dictInstAbscTemp = dict()
+      listAbscTemp = list()
+      listBornes = list()
+      for inst in listInstMeca :
+         bornes = getBornes(listInstTher, inst)
+         # Si une des bornes n'est pas définie, on lance une exception
+         if not(bornes[0]) or not(bornes[1]) : raise interpolationError
+          
+         abscTempInf = self.dictInstAbscTemp[bornes[0]] # Liste de doublet (abscisse, temperature) pour la borne inférieure
+         abscTempSup = self.dictInstAbscTemp[bornes[1]] # Liste de doublet (abscisse, temperature) pour la borne supérieure
+         
+         listAbscTemp = list() # liste de couples abscisses/Température
+         for A1, A2 in zip(abscTempInf, abscTempSup) : # A1 et A2 sont des doublets abscisse/Temperature
+            temperature = interpoleLin( ((bornes[0], A1[1]), (bornes[1], A2[1])), inst)   
+            listAbscTemp.append((A1[0], temperature)) # on aurait pu tout aussi bien prendre A2[0] (c est pareil ...)
+            
+         dictInstAbscTemp[inst] = listAbscTemp
+         
+      # remplacement de l'ancienne table par la nouvelle
+      self.dictInstAbscTemp = dictInstAbscTemp
+
+   def buildTree(self) :
+      """
+         Construction (en mémoire) de l'arborescence du document XML
+      """
+      sigma_xml   = ( 'S_RR', 'S_TT', 'S_ZZ', 'S_RT', 'S_TZ', 'S_ZR' )
+
+      # Création de l'arborescence "géométrie"
+      nodeGeomComp = self.nodeComp.append("GEOM_COMPO")
+      nodeGeomComp.append("REVETEMENT", valeur=self.revet)
+      if self.revet == 'OUI' :
+         nodeGeomComp.append("EP_REVET", valeur=self.epaisseur_R)
+      nodeLigneCoupe = nodeGeomComp.append("LIGNE_COUPE")
+      nodeLigneCoupe.append("EPAISSEUR_EF", valeur=self.epaisseur)
+      nodeLigneCoupe.append("DIAM_EXT_EF", valeur=self.diametre)
+      nodeLigneCoupe.append("ORI_ABSC", valeur=self.origine)
+      
+      if self.noResuMeca == False :
+         # Création des abscisses
+         for val in self.tabAbscisses :
+            nodeLigneCoupe.append("ABSCISSE", val)
+      
+         nodeLigneCoupe.append('PSI', self.angle_c)
+      
+         # Création des résultats mécaniques
+         nodeSigma_u = self.nodeComp.append("SIGMA_UNITE")
+         nodeSigma_u.append("NUM_MECA", valeur=self.num_char)
+         nodeSigma_u.append("NOM_MECA", valeur=self.type_char)
+         nodeSigma_meca = nodeSigma_u.append("SIGMA_MECA")
+         
+         for i in range(0, len(self.tabAbscisses)) :
+            for val in self.dictMeca.keys() :
+               nodeSigma_meca.append(val, valeur = self.dictMeca[val][i])
+     
+      # Création de l'arborescence "résultat thermo_mécanique"
+      if self.noResuTher == False :
+         # Création des abscisses
+         listDoublet = self.dictInstAbscTemp[self.dictInstAbscTemp.keys()[0]]
+         for val in listDoublet :
+            nodeLigneCoupe.append("ABSCISSE", val[0])
+            
+         nodeLigneCoupe.append('PSI', self.angle_c)
+            
+         # Création des résultats mécaniques
+         nodeSigma_ther_c = self.nodeComp.append("SIGMA_THER_C")
+         nodeSigma_ther_c.append("NUM_TRANSI_THER", valeur=self.num_tran)
+         
+         for inst in self.dictInstAbscTemp.keys() : # boucle sur les instants
+            nodeSigma_ther = nodeSigma_ther_c.append("SIGMA_THER")
+            nodeSigma_ther.append("INSTANT", valeur=inst)
+            
+            # boucle sur les abscisses
+            for doubletAbscSig, doubletAbscTemp in zip(self.dictInstAbscSig[inst], self.dictInstAbscTemp[inst]) : 
+               nodeSigma_point = nodeSigma_ther.append("SIGMA_POINT")
+               for val, label in zip(doubletAbscSig[1], sigma_xml) :
+                  nodeSigma_point.append(label, valeur = val)
+               
+               nodeSigma_point.append("TEMPERATURE", doubletAbscTemp[1]) 
+
+class tuyauterie(OAR_element) :
+   """
+      Classe permettant de traiter les tuyauteries
+   """
+   def __init__(self, **args) :
+      self.nodeComp = XMLNode("TUYAUTERIE")
+      try :
+         self.para_resu_meca = args['RESU_MECA']
+         self.num_char = self.para_resu_meca['NUM_CHAR']
+      
+         #Gestion du maillage
+         self.maillage = self.para_resu_meca['MAILLAGE']
+         mapy = MAIL_PY()
+         mapy.FromAster(self.maillage)
+      
+         self.ma = [val.rstrip() for val in mapy.correspondance_mailles]
+         self.no = [val.rstrip() for val in mapy.correspondance_noeuds]
+      
+         self.dictMailleNoeuds = dict()
+         for val in self.ma :
+            self.dictMailleNoeuds[val] = list()
+      
+         for i in range(0, len(mapy.co)) :
+            self.dictMailleNoeuds[self.ma[i]].append(self.no[mapy.co[i][0]])
+            self.dictMailleNoeuds[self.ma[i]].append(self.no[mapy.co[i][1]])
+      
+         self.dictNoeudValTorseur = dict()
+         self.buildTableTorseur()
+      
+      except :
+         UTMESS('F','OAR0_4')
+
+      # Construction de l arborescence
+      self.buildTree() 
+       
+
+   def buildTableTorseur(self) :
+      """
+         Construit un dictionnaire associant un noeud à un torseur exprimé sous la forme d'une liste de valeurs
+      """
+      table_temp = self.para_resu_meca['TABLE'].EXTR_TABLE()   
+
+      # Utilisation des méthodes de la classe table
+      dictTable = table_temp.values()
+      
+      # 1. Récupération de la liste des noeuds
+      NOEUDS = dictTable['NOEUD']
+      for val in NOEUDS :
+         self.dictNoeudValTorseur[val.rstrip()] = list() # On crée juste les clés du dictionnaire
+         
+      N   = dictTable['N']
+      VY  = dictTable['VY']
+      VZ  = dictTable['VZ']
+      MT  = dictTable['MT']
+      MFY = dictTable['MFY']
+      MFZ = dictTable['MFZ']
+      
+      for no, n, vy, vz, mt, mfy, mfz in zip(NOEUDS, N, VY, VZ, MT, MFY, MFZ):
+         no = no.rstrip()
+         self.dictNoeudValTorseur[no].append(n)
+         self.dictNoeudValTorseur[no].append(vy)
+         self.dictNoeudValTorseur[no].append(vz)
+         self.dictNoeudValTorseur[no].append(mt)
+         self.dictNoeudValTorseur[no].append(mfy)
+         self.dictNoeudValTorseur[no].append(mfz)
+         
+         
+   def buildTree(self) :
+      """
+         Construction (en mémoire) de l'arborescence du document XML
+      """
+      torseur_XML   = ( 'FX', 'FY', 'FZ', 'MX', 'MY', 'MZ' )
+
+      # Création de l'arborescence "torseur"
+      nodeTMG = self.nodeComp.append("TORSEUR_MECA-GRP")
+      nodeTM = nodeTMG.append("TORSEUR_MECA")
+      nodeTM.append("oar:CHAR-REF", self.num_char)
+      nodeMTG = nodeTM.append("MAILLE_TORSEUR-GRP")
+      nodeMT = nodeMTG.append("MAILLE_TORSEUR")
+      for MA in self.dictMailleNoeuds.keys() : # Boucle sur les mailles
+         nodeMT.append("oar:MAILLE-REF", MA)
+         for NO in self.dictMailleNoeuds[MA] : # 2 noeuds
+            nodeTorseur = nodeMT.append("oar:TORSEUR")
+            for val, cle in zip(self.dictNoeudValTorseur[NO], torseur_XML) : # 6 valeurs
+               nodeTorseur.append(cle, val)
+      
+      
+
+def impr_oar_ops(self, TYPE_CALC, **args) :
+   """
+   Macro IMPR_OAR
+   Ecrit des fichiers au format XML selon la DTD OAR Fichier
+   
+   IMPR_OAR va etre utilise en deux fois d abord calcul mecanique, 
+   ensuite calcul thermique ce qui implique qu il ne peut y avoir qu'une seule des deux options a la fois
+   """
+   # La macro compte pour 1 dans la numérotation des commandes
+   self.set_icmd(1)
+   
+   obj = None
+   
+   if TYPE_CALC=='COMPOSANT' :
+      obj = composant(**args)
+   elif TYPE_CALC=='MEF' : 
+      UTMESS('F','OAR0_5')
+   elif TYPE_CALC=='TUYAUTERIE' :
+      obj = tuyauterie(**args) 
+   else :
+      UTMESS('F','OAR0_6')
+
+   # Ecriture dans le fichier
+   # Récupération de la LU du fichier de sortie
+   try :
+      unite = args['UNITE']
+   except :
+      unite = 38
+      
+   try :
+      ajout=args['AJOUT']
+   except :
+      ajout='NON'
+         
+   name = 'fort.'+str(unite)
+   try :
+      if ajout=='NON' :  # nouveau fichier
+         fileObj = open(name, 'wt')
+      else :            # extension du fichier existant
+         fileObj = open(name, 'a+t')
+   except IOError :
+      UTMESS('F','OAR0_7')
+   else :
+      obj.getNode().save(fileObj)
+      fileObj.close()

diff --git a/Aster/Cata/cataSTA10/Macro/impr_table_ops.py b/Aster/Cata/cataSTA10/Macro/impr_table_ops.py
new file mode 100644 (file)
index 0000000..f2de0bd
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/impr_table_ops.py
@@ -0,0 +1,247 @@
+#@ MODIF impr_table_ops Macro  DATE 10/11/2009   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 MCOURTOI M.COURTOIS
+
+import os.path
+import re
+
+
+def impr_table_ops(self, FORMAT, TABLE, INFO, **args):
+   """
+   Macro IMPR_TABLE permettant d'imprimer une table dans un fichier.
+   Erreurs<S> dans IMPR_TABLE pour ne pas perdre la base.
+   """
+   macro='IMPR_TABLE'
+   import aster
+   from Accas import _F
+   from Cata.cata import table_jeveux
+   from Utilitai.Utmess  import  UTMESS
+   from Utilitai.UniteAster import UniteAster
+   ier=0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   DETRUIRE         = self.get_cmd('DETRUIRE')
+   RECU_FONCTION    = self.get_cmd('RECU_FONCTION')
+
+   #----------------------------------------------
+   # 0. Traitement des arguments, initialisations
+   # unité logique des fichiers réservés
+   ul_reserve=(8,)
+   UL = UniteAster()
+
+   # 0.1. Fichier
+   nomfich=None
+   if args['UNITE'] and args['UNITE']<>6:
+      nomfich=UL.Nom(args['UNITE'])
+   if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size<>0:
+      if FORMAT=='XMGRACE':
+         UTMESS('A','TABLE0_6',valk=nomfich)
+
+   # 0.2. Création des dictionnaires des FILTRES
+   Filtre=[]
+   if args['FILTRE']:
+      for Fi in args['FILTRE']:
+         dF = Fi.cree_dict_valeurs(Fi.mc_liste)
+         for mc in dF.keys():
+            if dF[mc]==None: del dF[mc]
+         Filtre.append(dF)
+   # format pour l'impression des filtres
+   form_filtre='\nFILTRE -> NOM_PARA: %-16s CRIT_COMP: %-4s VALE: %s'
+
+   # 0.3. Création de la liste des tables (une seule sans SENSIBILITE)
+   form_sens='\n... SENSIBILITE AU PARAMETRE %s (SD COMP %s)'
+   ltab=[]
+   if args['SENSIBILITE']:
+      lps=args['SENSIBILITE']
+      if not type(lps) in (list, tuple):
+         lps=[lps,]
+      for ps in lps:
+         ncomp = self.jdc.memo_sensi.get_nocomp(TABLE.nom, ps.nom)
+         if ncomp != None:
+            sdtab = table_jeveux(ncomp)
+            tabs = sdtab.EXTR_TABLE()
+            tabs.titr = TABLE.TITRE() + tabs.titr + form_sens % (ps.get_name(), ncomp)
+            ltab.append([tabs, sdtab])
+   else:
+      ltab.append([TABLE.EXTR_TABLE(), TABLE])
+
+   if len(ltab)<1:
+      return ier
+
+   # 0.4.1. liste des paramètres à conserver
+   nom_para=ltab[0][0].para
+   if args['NOM_PARA']:
+      nom_para=args['NOM_PARA']
+   if not type(nom_para) in (list, tuple):
+      nom_para=[nom_para,]
+
+   # 0.4.2. Traiter le cas des UL réservées
+   if args['UNITE'] and args['UNITE'] in ul_reserve:
+      UL.Etat(args['UNITE'], etat='F')
+
+   #----------------------------------------------
+   # Boucle sur les tables
+   for tab, sdtab in ltab:
+
+      # ----- 1. Infos de base
+      if INFO==2:
+         print 'IMPRESSION DE LA TABLE : %s' % sdtab.get_name()
+
+      if args['TITRE']:
+         tab.titr=args['TITRE'] + '\n' + tab.titr
+
+      # ----- 2. Filtres
+      for Fi in Filtre:
+         col = getattr(tab, Fi['NOM_PARA'])
+         # peu importe le type
+         opts=[Fi[k] for k in ('VALE','VALE_I','VALE_C','VALE_K') if Fi.has_key(k)]
+         kargs={}
+         for k in ('CRITERE','PRECISION'):
+            if Fi.has_key(k):
+               kargs[k]=Fi[k]
+         tab = tab & ( getattr(col, Fi['CRIT_COMP'])(*opts,**kargs) )
+         # trace l'operation dans le titre
+         #if FORMAT in ('TABLEAU','ASTER'):
+         tab.titr+=form_filtre % (Fi['NOM_PARA'], Fi['CRIT_COMP'], \
+               ' '.join([str(v) for v in opts]))
+
+      # ----- 3. Tris
+      if args['TRI']:
+         # une seule occurence de TRI
+         T0=args['TRI'][0]
+         dT=T0.cree_dict_valeurs(T0.mc_liste)
+         tab.sort(CLES=dT['NOM_PARA'], ORDRE=dT['ORDRE'])
+
+      # ----- 4. Impression
+      # vérification des paramètres
+      for p in nom_para:
+         if not p in tab.para:
+           UTMESS('A','TABLE0_7',valk=p)
+      
+      # sélection des paramètres et suppression des colonnes vides
+      timp = tab.SansColonneVide(nom_para)
+      
+      # passage des mots-clés de mise en forme à la méthode Impr
+      kargs=args.copy()
+      kargs.update({
+         'FORMAT'    : FORMAT,
+         'FICHIER'   : nomfich,
+         'dform'     : {},
+      })
+      # pour l'impression des fonctions
+      kfonc={
+         'FORMAT'    : FORMAT,
+         'FICHIER'   : nomfich,
+      }
+
+      # 4.1. au format TABLEAU
+      if FORMAT=='TABLEAU':
+         # surcharge par les formats de l'utilisateur
+         kargs['dform']={
+            'csep'   : args['SEPARATEUR'],
+            'ccom'   : args['COMMENTAIRE'],
+            'ccpara' : args['COMM_PARA'],
+            'cdeb'   : args['DEBUT_LIGNE'],
+            'cfin'   : args['FIN_LIGNE'],
+         }
+      
+      # 4.2. au format AGRAF
+      elif FORMAT=='AGRAF':
+         kargs['dform']={ 'formR' : '%12.5E' }
+         kfonc['FORMAT']='TABLEAU'
+      
+      # 4.3. au format XMGRACE et dérivés
+      elif FORMAT=='XMGRACE':
+         kargs['dform']={ 'formR' : '%.8g' }
+         kargs['PILOTE']=args['PILOTE']
+         kfonc['PILOTE']=args['PILOTE']
+
+      # 4.4. format spécifié dans les arguments
+      if args['FORMAT_R']:
+         kargs['dform'].update({ 'formR' : fmtF2PY(args['FORMAT_R']) })
+
+      # 4.5. regroupement par paramètre : PAGINATION
+      if args['PAGINATION']:
+         l_ppag=args['PAGINATION']
+         if not type(l_ppag) in (list, tuple):
+            l_ppag=[l_ppag,]
+         kargs['PAGINATION'] = [p for p in l_ppag if p in nom_para]
+         l_para_err          = [p for p in l_ppag if not p in nom_para]
+         if len(l_para_err)>0:
+             UTMESS('A','TABLE0_8',valk=l_para_err)
+
+      timp.Impr(**kargs)
+
+      # ----- 5. IMPR_FONCTION='OUI'
+      if args['IMPR_FONCTION'] == 'OUI':
+         # cherche parmi les cellules celles qui contiennent un nom de fonction
+         dfon = []
+         p_extr = set(['FONCTION', 'FONCTION_C'])
+         p_extr.intersection_update(timp.para)
+         if len(p_extr) > 0:
+            # on réduit timp aux colonnes FONCTION et FONCTION_C
+            textr = timp.__getitem__(list(p_extr))
+            for row in textr:
+               for par,cell in row.items():
+                  if type(cell) in (str, unicode):
+                     cell = cell.strip()
+                     if aster.getvectjev('%-19s.PROL' % cell) != None:
+                        dfon.append(['%-19s' % cell, par])
+            # impression des fonctions trouvées
+            for f,par in dfon:
+               __fonc=RECU_FONCTION(
+                  TABLE=sdtab,
+                  FILTRE=_F(
+                     NOM_PARA=par,
+                     VALE_K=f,
+                  ),
+                  NOM_PARA_TABL=par,
+                  TITRE = 'Fonction %s' % f,
+               )
+               __fonc.Trace(**kfonc)
+               DETRUIRE(CONCEPT=_F(NOM=(__fonc,),), ALARME='NON', INFO=1,)
+
+   # 99. Traiter le cas des UL réservées
+   UL.EtatInit()
+   return ier
+
+
+def fmtF2PY(fformat):
+   """Convertit un format Fortran en format Python (printf style).
+   Gère uniquement les fortrans réels, par exemple : E12.5, 1PE13.6, D12.5...
+   """
+   fmt=''
+   matP=re.search('([0-9]+)P',fformat)
+   if matP:
+      fmt+=' '*int(matP.group(1))
+   matR=re.search('([eEdDfFgG]{1})([\.0-9]+)',fformat)
+   if matR:
+      fmt+='%'+matR.group(2)+re.sub('[dD]+','E',matR.group(1))
+   try:
+      s=fmt % -0.123
+   except (ValueError, TypeError), msg:
+      fmt='%12.5E'
+      print 'Error :',msg
+      print 'Format par défaut utilisé :',fmt
+   return fmt

diff --git a/Aster/Cata/cataSTA10/Macro/info_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/info_fonction_ops.py
new file mode 100644 (file)
index 0000000..19d0b34
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/info_fonction_ops.py
@@ -0,0 +1,307 @@
+#@ MODIF info_fonction_ops Macro  DATE 16/11/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.        
+# ======================================================================
+def info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,INFO,**args):
+  """
+     Ecriture de la macro INFO_FONCTION
+  """
+  ier=0
+  import string
+  from Cata_Utils.t_fonction import t_fonction,t_fonction_c,t_nappe
+  import math
+  from Accas import _F
+  from Utilitai.Utmess import  UTMESS
+  import types
+  from types import ListType, TupleType
+  EnumTypes = (ListType, TupleType)
+
+  ### On importe les definitions des commandes a utiliser dans la macro
+  CREA_TABLE     = self.get_cmd('CREA_TABLE')
+  CALC_TABLE     = self.get_cmd('CALC_TABLE')
+  IMPR_TABLE     = self.get_cmd('IMPR_TABLE')
+  CALC_FONCTION  = self.get_cmd('CALC_FONCTION')
+  
+  ### Comptage commandes + déclaration concept sortant
+  self.set_icmd(1)
+  self.DeclareOut('C_out',self.sd)
+
+  ### type de traitement
+  
+  ###
+  if (MAX != None): 
+     if type(MAX['FONCTION']) not in EnumTypes : l_fonc=[MAX['FONCTION'],]
+     else                                       : l_fonc=MAX['FONCTION']
+     __tmfonc=[None]*3
+     k=0
+     mfact=[]
+     ltyfo=[]
+     lpara=[]
+     lresu=[]
+     lfnom=[]
+     for fonc in l_fonc :
+        __ff=fonc.convert()
+        __ex=__ff.extreme()
+        ltyfo.append(__ff.__class__)
+        lpara.append(__ff.para['NOM_PARA'])
+        lresu.append(__ff.para['NOM_RESU'])
+        lfnom.append(fonc.nom)
+        n_mini=len(__ex['min'])
+        n_maxi=len(__ex['max'])
+        listeMCF=[_F(LISTE_K=[fonc.nom]*(n_mini+n_maxi),PARA='FONCTION'), 
+                  _F(LISTE_K=['MINI',]*n_mini+['MAXI',]*n_maxi,PARA='TYPE'),]
+        n_resu=__ff.para['NOM_RESU']
+        if isinstance(__ff,t_nappe) :
+           listeMCF=listeMCF+[\
+              _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\
+              _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_PARA_FONC']),\
+              _F(LISTE_R=[i[2] for i in __ex['min']]+[i[2] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])]
+        else :
+           listeMCF=listeMCF+[\
+                  _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\
+                  _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])]
+        __tmfonc[k]=CREA_TABLE(LISTE=listeMCF)
+        if k!=0 :
+           mfact.append(_F(OPERATION = 'COMB',TABLE=__tmfonc[k]))
+        k=k+1
+     ltyfo=dict([(i,0) for i in ltyfo]).keys()
+     lpara=dict([(i,0) for i in lpara]).keys()
+     lresu=dict([(i,0) for i in lresu]).keys()
+     if len(ltyfo)>1 : 
+# n'est pas homogène en type (fonctions et nappes) ''')
+        UTMESS('F','FONCT0_37')
+     if len(lpara)>1 : 
+# n'est pas homogène en label NOM_PARA :'''+' '.join(lpara))
+        UTMESS('F','FONCT0_38',valk=' '.join(lpara))
+     if len(lresu)>1 : 
+# n'est pas homogène en label NOM_RESU : '''+' '.join(lresu))
+        UTMESS('F','FONCT0_39',valk=' '.join(lresu))
+     __tab=CALC_TABLE(TABLE  = __tmfonc[0],
+                      ACTION = mfact        )
+     __min=CALC_TABLE(TABLE  = __tab,
+                      ACTION = _F(OPERATION = 'FILTRE',
+                                  CRIT_COMP = 'MINI',
+                                  NOM_PARA  = lresu[0]  ), )
+     __max=CALC_TABLE(TABLE  = __tab,
+                      ACTION = _F(OPERATION = 'FILTRE',
+                                  CRIT_COMP = 'MAXI',
+                                  NOM_PARA  = lresu[0]  ), )
+     print __min.EXTR_TABLE()
+     print __max.EXTR_TABLE()
+     C_out=CALC_TABLE(TABLE  = __min,
+                      TITRE  = 'Calcul des extrema sur fonction '+' '.join(lfnom),
+                      ACTION = _F(OPERATION = 'COMB',
+                                  TABLE=__max  ), )
+     print C_out.EXTR_TABLE()
+
+  ###
+  if (ECART_TYPE  != None): 
+     __ff=ECART_TYPE['FONCTION'].convert()
+     if ECART_TYPE['INST_INIT']!=None : tini=ECART_TYPE['INST_INIT']
+     else                             : tini=__ff.vale_x[0]
+     if ECART_TYPE['INST_FIN' ]!=None : tfin=ECART_TYPE['INST_FIN' ]
+     else                             : tfin=__ff.vale_x[-1]
+     __ff=__ff.cut(tini,__ff.vale_x[-1],ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE'])
+     __ff=__ff.cut(__ff.vale_x[0],tfin,ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE'])
+     if ECART_TYPE['METHODE'  ]=='SIMPSON' : __ex=__ff.simpson(0.)
+     if ECART_TYPE['METHODE'  ]=='TRAPEZE' : __ex=__ff.trapeze(0.)
+     fmoy=__ex.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0])
+     __ff=__ff+(-1*fmoy)
+     __ff=__ff*__ff
+     if ECART_TYPE['METHODE'  ]=='SIMPSON' : __ez=__ff.simpson(0.)
+     if ECART_TYPE['METHODE'  ]=='TRAPEZE' : __ez=__ff.trapeze(0.)
+     sigma=math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0]))
+     C_out=CREA_TABLE(LISTE=(_F(LISTE_K=ECART_TYPE['FONCTION'].nom,PARA='FONCTION'),
+                             _F(LISTE_K=ECART_TYPE['METHODE']     ,PARA='METHODE'),
+                             _F(LISTE_R=fmoy                      ,PARA='MOYENNE'),
+                             _F(LISTE_R=sigma                     ,PARA='ECART_TYPE'),
+                             _F(LISTE_R=tini                      ,PARA='INST_INIT'),
+                             _F(LISTE_R=tfin                      ,PARA='INST_FIN'),)
+                     )
+
+  ###
+  if (RMS != None):
+     RMS  =list(RMS)
+     sigm =[]
+     tmpi =[]
+     tmpf =[]
+     nomf =[]
+     meth =[]
+     for i_rms in RMS :
+         __ff=i_rms['FONCTION'].convert()
+         if i_rms['INST_INIT']!=None : tini=i_rms['INST_INIT']
+         else                        : tini=__ff.vale_x[0]
+         if i_rms['INST_FIN' ]!=None : tfin=i_rms['INST_FIN' ]
+         else                        : tfin=__ff.vale_x[-1]
+         __ff=__ff.cut(tini,__ff.vale_x[-1],i_rms['PRECISION'],i_rms['CRITERE'])
+         __ff=__ff.cut(__ff.vale_x[0],tfin,i_rms['PRECISION'],i_rms['CRITERE'])
+         __ff=__ff*__ff
+         if i_rms['METHODE'  ]=='SIMPSON' : __ez=__ff.simpson(0.)
+         if i_rms['METHODE'  ]=='TRAPEZE' :
+            __ez=__ff.trapeze(0.)
+         sigm.append(math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0])))
+         tmpi.append(tini)
+         tmpf.append(tfin)
+         nomf.append(i_rms['FONCTION'].nom)
+         meth.append(i_rms['METHODE'])
+     C_out=CREA_TABLE(LISTE=(_F(LISTE_K=nomf ,PARA='FONCTION'),
+                             _F(LISTE_K=meth ,PARA='METHODE'),
+                             _F(LISTE_R=tmpi ,PARA='INST_INIT'),
+                             _F(LISTE_R=tmpf ,PARA='INST_FIN'),
+                             _F(LISTE_R=sigm ,PARA='RMS'), )
+                     )
+
+  ###
+  if (NORME != None):
+     __ff=NORME['FONCTION'].convert()
+     norme=[]
+     for __fi in __ff.l_fonc :
+         norme.append(__fi.normel2())
+     nom=[NORME['FONCTION'].nom,]*len(norme)
+     C_out=CREA_TABLE(LISTE=(_F(LISTE_R=norme ,PARA='NORME'),
+                             _F(LISTE_K=nom   ,PARA='FONCTION'), )
+                     )
+
+  ###
+  if (NOCI_SEISME != None):
+     l_table=[]
+     if NOCI_SEISME['SPEC_OSCI'] !=None :
+        ### cas intensité spectrale d'une nappe de SRO
+        ### la seule option licite est INTE_SPEC
+#intensite spectrale, il est prudent de verifier la norme de la nappe sur laquelle \
+#porte le calcul, ceci peut etre une source d erreurs.''')
+        UTMESS('I','FONCT0_40')
+        amor=NOCI_SEISME['AMOR_REDUIT']
+        fini=NOCI_SEISME['FREQ_INIT'  ]
+        ffin=NOCI_SEISME['FREQ_FIN'   ]
+        __sp  =NOCI_SEISME['SPEC_OSCI'].convert()
+        vale_x=__sp.l_fonc[0].vale_x
+        vale_y=[__sp(amor,f) for f in vale_x]
+        para  =__sp.l_fonc[0].para
+        __srov=t_fonction(vale_x,vale_y,para)
+        if   NOCI_SEISME['NATURE']=='DEPL' : 
+             __srov.vale_y=(__srov.vale_y/__srov.vale_x)*2.*math.pi
+        elif NOCI_SEISME['NATURE']=='VITE' : 
+             __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x
+        elif NOCI_SEISME['NATURE']=='ACCE' : 
+             __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x
+             __srov.vale_y=__srov.vale_y/__srov.vale_x/2./math.pi
+        __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
+        insp=__srov.trapeze(0.).vale_y[-1]
+        l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT'  ))
+        l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN'   ))
+        l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT'))
+        l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' ))
+     if NOCI_SEISME['FONCTION'] !=None :
+        ### cas fonction
+        l_table.append(_F(LISTE_K=NOCI_SEISME['FONCTION'].nom,PARA='FONCTION'))
+        __ac=NOCI_SEISME['FONCTION'].convert()
+        option= NOCI_SEISME['OPTION']
+        if   NOCI_SEISME['INST_INIT']!=None : tdeb=NOCI_SEISME['INST_INIT']
+        else                                : tdeb=__ac.vale_x[0]
+        if   NOCI_SEISME['INST_FIN' ]!=None : tfin=NOCI_SEISME['INST_FIN' ]
+        else                                : tfin=__ac.vale_x[-1]
+        # calcul de la vitesse :
+        __vi=__ac.trapeze(NOCI_SEISME['COEF'])
+        # calcul du déplacement :
+        __de=__vi.trapeze(NOCI_SEISME['COEF'])
+        # calcul de |acceleration| :
+        __aa=__ac.abs()
+        # calcul de integrale(|acceleration|) :
+        ### on "coupe" la fonction entre tdeb et tfin
+        __ac=__ac.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
+        __vi=__vi.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
+        __de=__de.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
+        __aa=__aa.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
+        if   NOCI_SEISME['FREQ'     ]!=None : l_freq=NOCI_SEISME['FREQ']
+        elif NOCI_SEISME['LIST_FREQ']!=None : l_freq=NOCI_SEISME['LIST_FREQ'].Valeurs()
+        else                                :  
+           # fréquences par défaut
+           l_freq=[]
+           for i in range(56) : l_freq.append( 0.2+0.050*i)
+           for i in range( 8) : l_freq.append( 3.0+0.075*i)
+           for i in range(14) : l_freq.append( 3.6+0.100*i)
+           for i in range(24) : l_freq.append( 5.0+0.125*i)
+           for i in range(28) : l_freq.append( 8.0+0.250*i)
+           for i in range( 6) : l_freq.append(15.0+0.500*i)
+           for i in range( 4) : l_freq.append(18.0+1.000*i)
+           for i in range(10) : l_freq.append(22.0+1.500*i)
+        if option in('TOUT','MAXI','ACCE_SUR_VITE') : 
+           #   calcul du max des valeurs absolues
+           maxa_ac=__ac.abs().extreme()['max'][0][1]
+           maxa_vi=__vi.abs().extreme()['max'][0][1]
+           maxa_de=__de.abs().extreme()['max'][0][1]
+           l_table.append(_F(LISTE_R=maxa_ac,PARA='ACCE_MAX'))
+           l_table.append(_F(LISTE_R=maxa_vi,PARA='VITE_MAX'))
+           l_table.append(_F(LISTE_R=maxa_de,PARA='DEPL_MAX'))
+           l_table.append(_F(LISTE_R=maxa_ac/maxa_vi,PARA='ACCE_SUR_VITE'))
+        if option in('TOUT','INTE_ARIAS') : 
+           __a2=__ac*__ac
+           inte_arias=__a2.trapeze(0.).vale_y[-1]
+           inte_arias=inte_arias*math.pi/NOCI_SEISME['PESANTEUR']/2.
+           l_table.append(_F(LISTE_R=inte_arias,PARA='INTE_ARIAS'))
+        if option in('TOUT','POUV_DEST') : 
+           __v2=__vi*__vi
+           pouv_dest=__v2.trapeze(0.).vale_y[-1]
+           pouv_dest=pouv_dest*(math.pi)**3/NOCI_SEISME['PESANTEUR']/2.
+           l_table.append(_F(LISTE_R=pouv_dest,PARA='POUV_DEST'))
+        if option in('TOUT','VITE_ABSO_CUMU') : 
+           __vc=__aa.trapeze(0.)
+           vite_abso=__vc.vale_y[-1]
+           l_table.append(_F(LISTE_R=vite_abso,PARA='VITE_ABSO_CUMU'))
+        if option in('TOUT','INTE_SPEC') :
+           amor=NOCI_SEISME['AMOR_REDUIT']
+           fini=NOCI_SEISME['FREQ_INIT'  ]
+           ffin=NOCI_SEISME['FREQ_FIN'   ]
+           __so= CALC_FONCTION(SPEC_OSCI=_F(
+                                      NATURE     ='VITE',
+                                      NATURE_FONC='ACCE',
+                                      FONCTION   =NOCI_SEISME['FONCTION'],
+                                      METHODE    ='NIGAM',
+                                      NORME      =NOCI_SEISME['NORME'],
+                                      FREQ       =l_freq,
+                                      AMOR_REDUIT=(amor,)
+                                      ), )
+           __srov=__so.convert().l_fonc[0]
+           __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
+           __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x
+           insp=__srov.trapeze(0.).vale_y[-1]
+           l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT'  ))
+           l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN'   ))
+           l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT'))
+           l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' ))
+        if option in('TOUT','DUREE_PHAS_FORT') : 
+           __a2=__ac*__ac
+           __i2=__a2.trapeze(0.)
+           arias = __i2.vale_y[-1]*math.pi/NOCI_SEISME['PESANTEUR']/2.
+           valinf = arias * NOCI_SEISME['BORNE_INF']
+           valsup = arias * NOCI_SEISME['BORNE_SUP']
+           for i in range(len(__i2.vale_x)) :
+               ariask = __i2.vale_y[i]*math.pi/NOCI_SEISME['PESANTEUR']/2.
+               if ariask>=valinf : break
+           for j in range(len(__i2.vale_x)-1,-1,-1) :
+               ariask = __i2.vale_y[j]*math.pi/NOCI_SEISME['PESANTEUR']/2.
+               if ariask<=valsup : break
+           dphfor = __i2.vale_x[j] - __i2.vale_x[i]
+           l_table.append(_F(LISTE_R=dphfor,PARA='DUREE_PHAS_FORT'))
+     C_out=CREA_TABLE(LISTE=l_table)
+
+  if INFO > 1:
+     IMPR_TABLE(UNITE=6,
+                TABLE=C_out)
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py
new file mode 100644 (file)
index 0000000..870ca6b
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py
@@ -0,0 +1,261 @@
+#@ MODIF lire_fonction_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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, Numeric
+
+class LectureBlocError(Exception):
+   pass
+
+# ------------------------------------------------------------------------------
+def lire_blocs(nomfich, SEPAR):
+   """Retourne la liste des blocs
+   """
+   def info(ib, nlig, ncol):
+      """Affiche les infos d'un bloc"""
+      print "   . Bloc %2d : %6d lignes, %6d colonnes" % (ib, nlig, ncol)
+   print "  Lecture des blocs du fichier '%s'" % nomfich
+   fich=open(nomfich, 'r')
+   if SEPAR == 'None':
+      SEPAR=None
+   blocs  = []
+   lignes = []
+   llen=0
+   il=0
+   for line in fich:
+      il+=1
+      try:
+         if line.strip()=='':
+            raise ValueError
+         splin = line.split(SEPAR)
+         lignes.append(map(float, splin))
+         if llen==0:
+            llen=len(splin)
+         elif len(splin) != llen:
+            raise LectureBlocError,  'Ligne %d : %d champs au lieu de %d attendus' % (il, len(splin), llen)
+      except ValueError:
+         if lignes==[]:
+            pass  # dans ce cas, on a plusieurs lignes délimitant 2 fonctions
+         else:
+            blocs.append(Numeric.array(lignes))
+            info(len(blocs), len(lignes), llen)
+            lignes=[]
+            llen=0
+   fich.close()
+   if len(lignes) > 0 :
+      blocs.append(Numeric.array(lignes))
+      info(len(blocs), len(lignes), llen)
+   return blocs
+
+# ------------------------------------------------------------------------------
+def liste_double(nomfich,INDIC_PARA,INDIC_RESU,SEPAR):
+  """Méthode de construction du VALE pour le format libre
+  format LIBRE
+  Les lignes contenant autre chose que des séquences de nombres
+  réels et de séparateurs sont considérées comme délimitant deux
+  fonctions différentes. Cette situation correspond à l exception
+  ValueError levée par le map de float. Le deuxieme indice de
+  INDIC_PARA et INDIC_RESU est l indice permettant de pointer sur la
+  fonction voulue, au sens de ce découpage.
+  """
+  from Utilitai.transpose import transpose
+  blocs = lire_blocs(nomfich, SEPAR)
+
+  # vérifications de cohérences lignes et colonnes
+  nb_blocs = len(blocs)
+  bloc_para = INDIC_PARA[0]
+  col_para  = INDIC_PARA[1]
+  bloc_resu = INDIC_RESU[0]
+  col_resu  = INDIC_RESU[1]
+  if bloc_para > nb_blocs :
+     raise LectureBlocError, "Il y a %d blocs or INDIC_PARA=(%d, .)" % (nb_blocs, bloc_para)
+  if bloc_resu > nb_blocs:
+     raise LectureBlocError, "Il y a %d blocs or INDIC_RESU=(%d, .)" % (nb_blocs, bloc_resu)
+
+  if col_para > len(blocs[bloc_para-1][0]):
+     raise LectureBlocError, "Le bloc %d comporte %d colonnes or INDIC_PARA=(., %d)" % \
+         (bloc_para, len(blocs[bloc_para-1][0]), col_para)
+  if col_resu > len(blocs[bloc_resu-1][0]):
+     raise LectureBlocError, "Le bloc %d comporte %d colonnes or INDIC_RESU=(., %d)" % \
+         (bloc_resu, len(blocs[bloc_resu-1][0]), col_resu)
+
+  # construction du VALE de la fonction par recherche des indices
+  # de colonnes et de fonctions dans le tableau blocs
+  vale_para = blocs[bloc_para-1][:,col_para-1]
+  vale_resu = blocs[bloc_resu-1][:,col_resu-1]
+  if len(vale_para) != len(vale_resu) :
+     print 'VALE_PARA =', vale_para
+     print 'VALE_RESU =', vale_resu
+     message="""Les deux colonnes extraites n'ont pas la meme longueur
+         %d lignes pour PARA
+         %d lignes pour RESU""" % (len(vale_para), len(vale_resu))
+     raise LectureBlocError, message
+
+  laux=transpose([vale_para, vale_resu])
+  liste_vale=[]
+  for v in laux:
+     liste_vale.extend(v)
+  return liste_vale
+
+# ------------------------------------------------------------------------------
+def liste_simple(nomfich,INDIC_PARA,SEPAR):
+  """recherche d'une liste simple
+  """
+  blocs = lire_blocs(nomfich, SEPAR)
+
+  # vérifications de cohérences lignes et colonnes
+  nb_blocs = len(blocs)
+  bloc_para = INDIC_PARA[0]
+  col_para  = INDIC_PARA[1]
+  if bloc_para > nb_blocs :
+     raise LectureBlocError, "Il y a %d blocs or INDIC_PARA=(%d, .)" % (nb_blocs, bloc_para)
+  if col_para > len(blocs[bloc_para-1][0]):
+     raise LectureBlocError, "Le bloc %d comporte %d colonnes or INDIC_PARA=(., %d)" % \
+         (bloc_para, len(blocs[bloc_para-1][0]), col_para)
+
+  # construction du VALE de la fonction par recherche des indices
+  # de colonnes et de fonctions dans le tableau l_fonc
+  vale_1=blocs[bloc_para-1][:,col_para-1]
+  return vale_1.tolist()
+
+# ------------------------------------------------------------------------------
+def lire_fonction_ops(self,FORMAT,TYPE,SEPAR,INDIC_PARA,UNITE,
+                      NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE,
+                      PROL_GAUCHE,VERIF,INFO,TITRE,**args):
+  """Méthode corps de la macro
+  """
+  from Accas import _F
+  from Utilitai.Utmess     import  UTMESS
+  from Utilitai.UniteAster import UniteAster
+
+  ier=0
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # On recopie le mot cle defi_fonction pour le proteger
+  if TYPE=='NAPPE' :
+     mc_DEFI_FONCTION=args['DEFI_FONCTION']
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  DEFI_FONCTION  =self.get_cmd('DEFI_FONCTION')
+  DEFI_NAPPE     =self.get_cmd('DEFI_NAPPE')
+
+  nompro='LIRE_FONCTION'
+
+  # Lecture de la fonction dans un fichier d unité logique UNITE
+  UL = UniteAster()
+  nomfich=UL.Nom(UNITE)
+  if not os.path.isfile(nomfich):
+     UTMESS('F','FONCT0_41',valk=nomfich)
+
+  # fonction(_c) ou nappe en sortie
+  self.DeclareOut('ut_fonc',self.sd)
+
+  if   TYPE=='FONCTION':
+    # mise en forme de la liste de valeurs suivant le format choisi :
+    try:
+       liste_vale = liste_double(nomfich,INDIC_PARA,args['INDIC_RESU'],SEPAR)
+    except LectureBlocError, message:
+       UTMESS('F', 'FONCT0_42', valk=message)
+
+    # création de la fonction ASTER :
+    ut_fonc=DEFI_FONCTION( NOM_PARA   =NOM_PARA,
+                           NOM_RESU   =NOM_RESU,
+                           PROL_DROITE=PROL_DROITE,
+                           PROL_GAUCHE=PROL_GAUCHE,
+                           INTERPOL   =INTERPOL,
+                           INFO       =INFO,
+                           TITRE      =TITRE,
+                           VERIF      =VERIF,
+                           VALE       =liste_vale,)
+
+  elif TYPE=='FONCTION_C':
+    # mise en forme de la liste de valeurs suivant le format choisi :
+    if 'INDIC_REEL' in args :
+                              indic1=args['INDIC_REEL']
+                              indic2=args['INDIC_IMAG']
+    if 'INDIC_MODU' in args :
+                              indic1=args['INDIC_MODU']
+                              indic2=args['INDIC_PHAS']
+    try:
+       liste_vale_r = liste_double(nomfich,INDIC_PARA,indic1,SEPAR)
+    except LectureBlocError, message:
+       UTMESS('F', 'FONCT0_42', valk=message)
+
+    try:
+       liste_vale_i = liste_double(nomfich,INDIC_PARA,indic2,SEPAR)
+    except LectureBlocError, message:
+       UTMESS('F', 'FONCT0_42', valk=message)
+
+    liste=[]
+    if   'INDIC_REEL' in args :
+      for i in range(len(liste_vale_r)/2) :
+        liste.extend([liste_vale_r[2*i],liste_vale_r[2*i+1],liste_vale_i[2*i+1]])
+    elif 'INDIC_MODU' in args :
+      for i in range(len(liste_vale_r)/2) :
+        module=liste_vale_r[2*i+1]
+        phase =liste_vale_i[2*i+1]
+        liste.extend([liste_vale_r[2*i],module*cos(phase),module*sin(phase)])
+
+    # création de la fonction ASTER :
+    ut_fonc=DEFI_FONCTION( NOM_PARA    =NOM_PARA,
+                           NOM_RESU    =NOM_RESU,
+                           PROL_DROITE =PROL_DROITE,
+                           PROL_GAUCHE =PROL_GAUCHE,
+                           INTERPOL    =INTERPOL,
+                           INFO        =INFO,
+                           TITRE       =TITRE,
+                           VERIF       =VERIF,
+                           VALE_C      =liste,)
+
+  elif TYPE=='NAPPE':
+
+    # création de la nappe ASTER :
+    motscles={}
+    motscles['DEFI_FONCTION']=[]
+    for elem in mc_DEFI_FONCTION:
+       try:
+          liste_vale=liste_double(nomfich,args['INDIC_ABSCISSE'],elem['INDIC_RESU'],SEPAR)
+       except LectureBlocError, message:
+          UTMESS('F', 'FONCT0_42', valk=message)
+
+       motscles['DEFI_FONCTION'].append( _F( VALE       =liste_vale,
+                                             INTERPOL   =args['INTERPOL_FONC'],
+                                             PROL_DROITE=args['PROL_DROITE_FONC'],
+                                             PROL_GAUCHE=args['PROL_GAUCHE_FONC'] ) )
+    try:
+       liste_para = liste_simple(nomfich,INDIC_PARA,SEPAR)
+    except LectureBlocError, message:
+       UTMESS('F', 'FONCT0_42', valk=message)
+
+    # création de la nappe
+    ut_fonc=DEFI_NAPPE( PARA          =liste_para,
+                        NOM_PARA      =NOM_PARA,
+                        NOM_PARA_FONC =args['NOM_PARA_FONC'],
+                        NOM_RESU      =NOM_RESU,
+                        PROL_DROITE   =PROL_DROITE,
+                        PROL_GAUCHE   =PROL_GAUCHE,
+                        INTERPOL      =INTERPOL,
+                        INFO          =INFO,
+                        TITRE         =TITRE,
+                        VERIF         =VERIF,
+                        **motscles)
+  # remet UNITE dans son état initial
+  UL.EtatInit()
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py b/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py
new file mode 100644 (file)
index 0000000..708dfef
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/lire_inte_spec_ops.py
@@ -0,0 +1,264 @@
+#@ MODIF lire_inte_spec_ops Macro  DATE 26/03/2008   AUTEUR BODEL C.BODEL 
+# -*- 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.        
+# ======================================================================
+
+def lire_inte_spec_ops(self,
+                       UNITE = None,
+                       FORMAT = None,
+                       FORMAT_C = None,
+                       NOM_PARA = None,
+                       NOM_RESU = None,
+                       INTERPOL = None,
+                       PROL_DROITE = None,
+                       PROL_GAUCHE = None,
+                       TITRE = None,
+                       INFO = None,
+                       **args):
+    ier=0
+
+    from Accas import _F
+    import os
+    from math import cos,sin,sqrt
+    from Utilitai.Utmess     import UTMESS
+    from Utilitai.UniteAster import UniteAster
+    # On importe les definitions des commandes a utiliser dans la macro
+    DEFI_FONCTION  =self.get_cmd('DEFI_FONCTION')
+    CREA_TABLE     =self.get_cmd('CREA_TABLE')
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+    nompro='LIRE_INTE_SPEC'
+
+    # Lecture de la fonction dans un fichier d unité logique UNITE
+    UL = UniteAster()
+    nomfich=UL.Nom(UNITE)
+    if not os.path.isfile(nomfich):
+       UTMESS('F','SPECTRAL0_4',valk=nomfich)
+    file=open(nomfich,'r')
+    texte=file.read()
+    file.close()
+
+
+    if FORMAT == 'IDEAS':
+        # fabrication d'une liste de data sets 58
+        list_fonc = texte.split('    -1')
+        j = 0
+        for ind_fonc in range(len(list_fonc)):
+            try:
+                tmp = list_fonc[j].split()
+                if tmp[0] == '58':
+                    j = j+1
+                else:
+                    list_fonc.pop(j)
+            except IndexError:
+                list_fonc.pop(j)
+
+        nb_fonc = len(list_fonc)
+        if nb_fonc == 0:
+            UTMESS('F', 'SPECTRAL0_9')
+
+        l_fonc = []
+        l_noi  = []
+        l_noj  = []
+        l_cmpi = []
+        l_cmpj = []
+        for ind_fonc in range(nb_fonc):
+            # Extraction des en-tete : nom des noeuds, composantes (=ddl), de leur sens
+            fonc = list_fonc[ind_fonc]
+            ligne = fonc.split('\n')
+
+            record_6 = ligne[7].split()
+            if  record_6[0] != '2' and record_6[0] != '3' and record_6[0] != '9' :
+                UTMESS('F', 'SPECTRAL0_10')
+            nono   = record_6[4]             # nom du noeud
+            nuno   = int(record_6[5])        # numero
+            ddlno  = float(record_6[6])/10   # DDL
+            noref  = record_6[7]             # nom du noeud de reference
+            nuref  = int(record_6[8])        # numero
+            ddlref = float(record_6[9])/10   # DDL
+            # On traduit les ddl "chiffres" en vrais ddl. Avec le sens des capteurs.
+            sens_no,ddl_no = comp(ddlno)
+            sens_ref,ddl_ref = comp(ddlref)
+            signe = sens_no*sens_ref
+
+            # On ne garde que la triang sup de la matrice inter-spectrale
+            crit1 = nuno + ddlno
+            crit2 = nuref + ddlref
+            if crit1 > crit2:
+                continue
+            record_7 = ligne[8].split()
+            nbpairs = int(record_7[1])
+            if record_7[2] == 0:
+                UTMESS('F', 'SPECTRAL0_11')
+            f0 = float(record_7[3])
+            df = float(record_7[4])
+
+            # Liste des valeurs
+            liste = fonc.split('\n')
+            valeurs = ''
+            for ind in range(13):
+                liste.pop(0)
+            for ind_lign in range(len(liste)):
+                valeurs = valeurs + liste[ind_lign]
+            tmp = valeurs.split()
+            valeurs = [signe*float(tmp[ind]) for ind in range(len(tmp))]
+
+            liste = []
+            freq = f0
+            for ind_freq in range(nbpairs):
+                liste.append(freq)
+                liste.append(valeurs[2*ind_freq])
+                liste.append(valeurs[2*ind_freq+1])
+                freq = freq + df
+
+            # création de la fonction ASTER :
+            _fonc=DEFI_FONCTION( NOM_PARA   = NOM_PARA,
+                                 NOM_RESU   = NOM_RESU,
+                                 PROL_DROITE= PROL_DROITE,
+                                 PROL_GAUCHE= PROL_GAUCHE,
+                                 INTERPOL   = INTERPOL,
+                                 INFO       = INFO,
+                                 TITRE      = TITRE,
+                                 VALE_C     = liste,)
+            l_fonc.append(_fonc.nom)     # Liste des fonctions
+            l_noi.append('N'+str(nuno))  # Liste des noeuds de mesure
+            l_cmpi.append(ddl_no)        # DDL associes
+            l_noj.append('N'+str(nuref)) # Liste des noeuds de ref
+            l_cmpj.append(ddl_ref)       # DDL associes
+
+        # 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) 
+
+        if dim != tmp :
+            UTMESS('F', 'SPECTRAL0_6')
+
+            
+        mcfact=[]
+        mcfact.append(_F(PARA='NOM_CHAM'    ,LISTE_K=(NOM_RESU),NUME_LIGN=(1,)))
+        mcfact.append(_F(PARA='OPTION'      ,LISTE_K=('TOUT',) ,NUME_LIGN=(1,)))
+        mcfact.append(_F(PARA='DIMENSION'   ,LISTE_I=(dim)     ,NUME_LIGN=(1,)))
+        mcfact.append(_F(PARA='NOEUD_I'     ,LISTE_K=l_noi     ,NUME_LIGN=range(2,nb_fonc+2)))
+        mcfact.append(_F(PARA='NOM_CMP_I'   ,LISTE_K=l_cmpi    ,NUME_LIGN=range(2,nb_fonc+2)))
+        mcfact.append(_F(PARA='NOEUD_J'     ,LISTE_K=l_noj     ,NUME_LIGN=range(2,nb_fonc+2)))
+        mcfact.append(_F(PARA='NOM_CMP_J'   ,LISTE_K=l_cmpj    ,NUME_LIGN=range(2,nb_fonc+2)))
+        mcfact.append(_F(PARA='FONCTION_C'  ,LISTE_K=l_fonc    ,NUME_LIGN=range(2,nb_fonc+2)))
+        self.DeclareOut('tab_inte',self.sd)
+        tab_inte=CREA_TABLE(LISTE=mcfact,
+                          TITRE=TITRE,
+                          TYPE_TABLE='TABLE_FONCTION')
+
+        
+    elif FORMAT == 'ASTER':
+        list_fonc=texte.split('FONCTION_C')
+        entete=list_fonc.pop(0)
+        try : 
+            entete=entete[entete.index('DIM'):]
+            dim=int(entete[entete.index('=')+1:entete.index('\n')])
+        except ValueError : 
+            UTMESS('F', 'SPECTRAL0_5')
+
+        if len(list_fonc)!=(dim*(dim+1)/2):
+            UTMESS('F', 'SPECTRAL0_6')
+
+        nume_i=[]
+        nume_j=[]
+        l_fonc=[]
+        for i in range(dim*(dim+1)/2):
+            numi=list_fonc[i][list_fonc[i].index('I =')+3:]
+            numi=numi[:numi.index('\n')]
+            nume_i.append(int(numi))
+            numj=list_fonc[i][list_fonc[i].index('J =')+3:]
+            numj=numj[:numj.index('\n')]
+            nume_j.append(int(numj))
+            try : 
+                vale_fonc=list_fonc[i][list_fonc[i].index('VALEUR =\n')+9:list_fonc[i].index('FINSF\n')]
+                vale_fonc=vale_fonc.replace('\n',' ')
+                vale_fonc=map(float,vale_fonc.split())
+            except ValueError : 
+                UTMESS('F', 'SPECTRAL0_7')
+
+            liste=[]
+            if   FORMAT_C=='REEL_IMAG':
+                liste=vale_fonc
+            elif FORMAT_C=='MODULE_PHASE':
+                for i in range(len(vale_fonc)/3) :
+                  module=vale_fonc[3*i+1]
+                  phase =vale_fonc[3*i+2]
+                  liste=liste+[vale_fonc[3*i],module*cos(phase),module*sin(phase)]
+
+
+            # création de la fonction ASTER :
+            _fonc=DEFI_FONCTION( NOM_PARA   =NOM_PARA,
+                                 NOM_RESU   =NOM_RESU,
+                                 PROL_DROITE=PROL_DROITE,
+                                 PROL_GAUCHE=PROL_GAUCHE,
+                                 INTERPOL   =INTERPOL,
+                                 INFO       =INFO,
+                                 TITRE      =TITRE,
+                                 VALE_C     =liste,)
+            l_fonc.append(_fonc.nom)
+
+        nume_ib=[]
+        nume_jb=[]
+        for i in range(dim):
+            for j in range(i,dim):
+                nume_ib.append(i+1)
+                nume_jb.append(j+1)
+        if nume_i!=nume_ib or nume_j!=nume_jb : 
+            UTMESS('F', 'SPECTRAL0_3')
+        mcfact=[]
+        mcfact.append(_F(PARA='NOM_CHAM'    ,LISTE_K=(NOM_RESU),NUME_LIGN=(1,)))
+        mcfact.append(_F(PARA='OPTION'      ,LISTE_K=('TOUT',) ,NUME_LIGN=(1,)))
+        mcfact.append(_F(PARA='DIMENSION'   ,LISTE_I=(dim,)    ,NUME_LIGN=(1,)))
+        mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i    ,NUME_LIGN=range(2,len(nume_i)+2)))
+        mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j    ,NUME_LIGN=range(2,len(nume_j)+2)))
+        mcfact.append(_F(PARA='FONCTION_C'  ,LISTE_K=l_fonc    ,NUME_LIGN=range(2,len(list_fonc)+2)))
+        self.DeclareOut('tab_inte',self.sd)
+        tab_inte=CREA_TABLE(LISTE=mcfact,
+                          TITRE=TITRE,
+                          TYPE_TABLE='TABLE_FONCTION')
+
+    else:
+        # mot-clé != 'ASTER', ou 'IDEAS' => ERREUR !
+        UTMESS('F', 'SPECTRAL0_12')
+        
+
+    # remet UNITE dans son état initial
+    UL.EtatInit()
+    return ier
+        
+        
+    
+def comp(ddlno):
+    sens = 1
+    if ddlno < 0:
+        sens = -1
+    if ddlno == .1:return sens,'DX'
+    elif ddlno == .2:return sens,'DY'
+    elif ddlno == .3:return sens,'DZ'
+    elif ddlno == .4:return sens,'DRX'
+    elif ddlno == .5:return sens,'DRY'
+    elif ddlno == .6:return sens,'DRZ'
+    else:
+        print "Probleme pour l'attribution des composantes"
+    
+    
+

diff --git a/Aster/Cata/cataSTA10/Macro/lire_table_ops.py b/Aster/Cata/cataSTA10/Macro/lire_table_ops.py
new file mode 100644 (file)
index 0000000..80927ff
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/lire_table_ops.py
@@ -0,0 +1,148 @@
+#@ MODIF lire_table_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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
+import re
+
+# ------------------------------------------------------------------------------
+def msplit(chaine, separ):
+   """Equivalent de chaine.split(separ) en acceptant une ou plusieurs
+   occurrences du séparateur.
+   """
+   return re.split('%s+' % re.escape(separ), chaine.strip(separ))
+
+# ------------------------------------------------------------------------------
+def lecture_table(texte, nume, separ):
+   """Méthode de construction de l'objet Table à partir d'un texte d'une table
+   au format ASTER.
+   """
+   from Utilitai.transpose import transpose
+   from Utilitai.Table     import Table
+   from Utilitai.Utmess    import  UTMESS
+   
+   tab_lue = {}
+   nume_lign = []
+   idt_deb = '#DEBUT_TABLE\n'
+   idt_fin = '#FIN_TABLE\n'
+   idt_tit = '#TITRE'
+   id_vide = '-'
+   
+   # expression régulière pour découper les N tables du fichier
+   exp = re.compile(re.escape(idt_deb) + '(.*?)' + re.escape(idt_fin),
+                    re.MULTILINE | re.DOTALL)
+   l_txt = exp.findall(texte)
+   nbbloc = len(l_txt)
+   if nume > nbbloc:
+      UTMESS('F', 'TABLE0_10', vali=(nume, nbbloc))
+   txttab = l_txt[nume - 1]
+  
+   # expression régulière pour extraire le titre
+   exp = re.compile(re.escape(idt_tit) + '(.*)$', re.MULTILINE)
+   titre_tab = os.linesep.join([s.strip(separ) for s in exp.findall(txttab)])
+  
+   # restent dans la table les lignes non vides qui ne sont pas des titres
+   txttab = [line for line in txttab.splitlines() \
+                     if line.strip(separ) != '' and not line.startswith(idt_tit)]
+  
+   # ligne des paramètres et des types
+   list_para = msplit(txttab.pop(0), separ)
+   list_type = msplit(txttab.pop(0), separ)
+   nb_para = len(list_type)
+   
+   # format de lecture
+   fmt = {
+      'I' : '([0-9\-\+]+)',
+      'R' : '([0-9\.,\-\+eEdD]+)',
+      'K' : '(.{%(len)s})'
+   }
+   lfmt = ('%s+' % re.escape(separ)).join(
+      [fmt[typ[0]] % { 'len' : typ[1:] } for typ in list_type]
+   )
+   
+   # construction des lignes de la Table
+   l_rows = []
+   for i, line in enumerate(txttab):
+      mat = re.search(lfmt, line)
+      if mat is None or nb_para != len(mat.groups()):
+         UTMESS('F+', 'TABLE0_11', vali=i + 1)
+         if mat is not None:
+            UTMESS('F+', 'TABLE0_12', vali=len(mat.groups()))
+         UTMESS('F', 'TABLE0_13', vali=nb_para)
+      dico = {}
+      for para, typ, ch in zip(list_para, list_type, mat.groups()):
+         ch = ch.strip()
+         if ch != id_vide:
+            if typ == 'I':
+               val = int(ch)
+            elif typ == 'R':
+               val = float(ch)
+            else:
+               val = ch
+            dico[para] = val
+      l_rows.append(dico)
+   
+   tab = Table(l_rows, list_para, list_type, titre_tab)
+   return tab
+
+
+# ------------------------------------------------------------------------------
+def lire_table_ops(self, **args):
+   """Méthode corps de la macro LIRE_TABLE
+   """
+   from Utilitai.Utmess     import  UTMESS
+   from Utilitai.UniteAster import UniteAster
+   
+   ier = 0
+   nompro = 'LIRE_TABLE'
+   ### On importe les definitions des commandes a utiliser dans la macro
+   CREA_TABLE = self.get_cmd('CREA_TABLE')
+   UNITE      = self['UNITE']
+   FORMAT     = self['FORMAT']
+   NUME_TABLE = self['NUME_TABLE']
+   SEPARATEUR = self['SEPARATEUR']
+   PARA       = self['PARA']
+   TITRE      = self['TITRE']
+   
+   ### La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+   
+   ### Lecture de la table dans un fichier d unité logique UNITE
+   UL = UniteAster()
+   nomfich=UL.Nom(UNITE)
+   if not os.path.isfile(nomfich):
+      UTMESS('F', nompro, "le fichier '%s' est introuvable" % nomfich)
+   
+   texte = open(nomfich,'r').read()
+   # remet UNITE dans son état initial
+   UL.EtatInit()
+   
+   ### mise en forme de la liste de valeurs suivant le format choisi :
+   # pour le moment uniquement ASTER
+   if FORMAT=='ASTER':
+      tab_lue = lecture_table(texte, NUME_TABLE, SEPARATEUR)
+   else:
+      pass
+   
+   ### création de la table ASTER :
+   self.DeclareOut('ut_tab', self.sd)
+   motscles = tab_lue.dict_CREA_TABLE()
+   ut_tab=CREA_TABLE(**motscles)
+   
+   return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py
new file mode 100644 (file)
index 0000000..14874e1
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py
@@ -0,0 +1,872 @@
+#@ MODIF macr_adap_mail_ops Macro  DATE 24/11/2008   AUTEUR GNICOLAS G.NICOLAS 
+# -*- 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.        
+# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+#
+"""
+Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
+"""
+__revision__ = "V1.2"
+#
+def macr_adap_mail_ops ( self,
+                         INFO, VERSION_HOMARD, MAILLAGE_FRONTIERE,
+                         **args):
+  """
+     Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
+  """
+#
+#  1. args est le dictionnaire des arguments
+#     args.keys() est la liste des mots-cles
+#     args.keys()[0] est la premiere valeur de cette liste
+#     args.keys()[1:] est la liste des valeurs suivantes dans cette liste
+#     args.keys(mot_cle) represente le contenu de la variable mot_cle dans la macro appelante.
+#
+###  print args
+###  print args.keys()
+###  if len (args.keys())>0 : print args.keys()[0]
+###  print args["MAILLAGE"]
+#
+#  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.
+#     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
+#
+#  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
+#     dans la liste liste_maillages.
+#     Description du dictionnaire de maillages :
+#        dico["Type_Maillage"] = o ; string ; "MAILLAGE_N", "MAILLAGE_NP1", "MAILLAGE_NP1_ANNEXE" ou "MAILLAGE_FRONTIERE"
+#        dico["Nom_ASTER"]     = o ; concept ASTER associe
+#        dico["Action"]        = o ; string ; "A_ecrire" ou "A_lire"
+#        dico["NOM_MED"]       = o ; string ; Nom MED du maillage
+#
+#  4. Les caracteristiques d'un champ sont conservees dans un dictionnaire. Il y a autant de
+#     dictionnaires que de champs manipules. L'ensemble de ces dictionnaires est conserve
+#     dans la liste liste_champs.
+#     Description du dictionnaire de champs :
+#        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 ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
+#        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["SENSIBILITE"]  = f ; string ; Nom du parametre sensible associe
+#
+#  5. Signification de INFO
+#     INFO = 1 : aucun message
+#     INFO = 2 : les messages des commandes annexes (DEFI_FICHIER, IMPR_RESU, LIRE_MAILLAGE, LIRE_CHAMP)
+#     INFO = 3 : aucun message pour les commandes annexes
+#                1er niveau de message pour l'execution de HOMARD
+#     INFO = 4 : aucun message pour les commandes annexes
+#                2nd niveau de message pour l'execution de HOMARD
+#
+  from Accas import _F
+  from Macro import creation_donnees_homard 
+  from Utilitai.Utmess     import UTMESS, MasquerAlarme, RetablirAlarme
+  import aster 
+  import string
+  import os
+  import shutil
+#
+  global Liste_Passages
+#
+#====================================================================
+# 1. Prealables
+#====================================================================
+#
+# 1.1. ==> La macro compte pour 1 dans la numerotation des commandes
+#
+  self.set_icmd(1)
+#
+# 1.2. ==> Numero du passage dans cette macro
+#
+  try :
+    self.jdc.indice_macro_homard = self.jdc.indice_macro_homard + 1
+  except :
+    self.jdc.indice_macro_homard = 1
+    Liste_Passages = []
+  numero_passage_fonction = self.jdc.indice_macro_homard
+###  print "numero_passage_fonction = ",numero_passage_fonction
+#
+# 1.3. ==> On importe les definitions des commandes a utiliser dans la macro
+#
+  DEFI_FICHIER    = self.get_cmd("DEFI_FICHIER")
+  IMPR_RESU       = self.get_cmd("IMPR_RESU")
+  EXEC_LOGICIEL   = self.get_cmd("EXEC_LOGICIEL")
+  LIRE_MAILLAGE   = self.get_cmd("LIRE_MAILLAGE")
+  LIRE_CHAMP      = self.get_cmd("LIRE_CHAMP")
+#
+# 1.4. ==> Le nom du programme HOMARD e lancer
+#
+  repertoire_outils = aster.repout()
+  homard            = repertoire_outils + "homard"
+#
+# 1.5. ==> Initialisations
+#
+  codret_partiel = [0]
+  Rep_Calc_ASTER = os.getcwd()
+#
+  liste_maillages = []
+  liste_champs    = []
+  liste_zones     = []
+  dico_indi = {}
+#
+  LISTE_ADAPTATION_LIBRE = ("RAFF_DERA" , "RAFFINEMENT" , "DERAFFINEMENT")
+#
+  if ( INFO == 2 ) :
+    infomail = "OUI"
+    infocomm = 2
+  else :
+    infomail = "NON"
+    infocomm = 1
+#
+#====================================================================
+# 2. Decodage des arguments de la macro-commande
+#====================================================================
+# 2.1. ==> Donnees de pilotage de l'adaptation
+#
+  if ( self.nom == "MACR_ADAP_MAIL" ) :
+#
+    mode_homard = "ADAP"
+#
+# 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 = {}
+      dico["Type_Maillage"] = mot_cle
+      if ( args[mot_cle] != None ) :
+#gn        print "==> args[",mot_cle,"] = ",args[mot_cle]
+        dico["Nom_ASTER"] = args[mot_cle]
+        if ( mot_cle == "MAILLAGE_N" ) :
+          dico["Action"] = "A_ecrire"
+        else :
+          dico["Action"] = "A_lire"
+      else :
+        dico["Action"] = "Rien"
+#gn      print "dico = ",dico
+      liste_maillages.append(dico)
+#
+# 2.1.2. ==> L'eventuel indicateur d'erreur
+#
+#gn    print "\n.. Debut de 2.1.2"
+#gn    print "args = ", args
+    if args["ADAPTATION"] in LISTE_ADAPTATION_LIBRE :
+      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["INDICATEUR"]
+        nomsym = dico["NOM_CHAM"]
+        if ( args["NUME_ORDRE"] != None ) :
+          dico["NUME_ORDRE"] = args["NUME_ORDRE"]
+        if ( args["INST"] != None ) :
+          dico["INST"] = args["INST"]
+          for cle in [ "PRECISION", "CRITERE" ] :
+            if ( args[cle] != None ) :
+              dico[cle] = args[cle]
+        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"]
+      dico["COMPOSANTE"] = args["NOM_CMP_INDICA"]
+      liste_champs.append(dico)
+      dico_indi = dico
+###      print dico
+#
+# 2.1.3. ==> Les champs e mettre e jour
+#
+#gn     print "\n.. Debut de 2.1.3."
+#
+    if args.has_key("MAJ_CHAM") :
+#
+      if args["MAJ_CHAM"] is None :
+        les_champs = []
+      else :
+        les_champs = args["MAJ_CHAM"]
+#
+      for maj_cham in les_champs :
+#gn        print maj_cham
+#gn        print type(maj_cham)
+#
+        dico = {}
+        dico["Type_Champ"] = "CHAMP_MAJ"
+        liste_aux = [ "CHAM_MAJ", "TYPE_CHAM" ]
+        if ( maj_cham["RESULTAT"] != None ) :
+          lresu = 1
+          liste_aux.append("RESULTAT")
+          liste_aux.append("NOM_CHAM")
+          if ( maj_cham["NUME_ORDRE"] != None ) :
+            dico["NUME_ORDRE"] = maj_cham["NUME_ORDRE"]
+          elif ( maj_cham["INST"] != None ) :
+            dico["INST"] = maj_cham["INST"]
+            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
+          liste_aux.append("CHAM_GD")
+          noresu = maj_cham["CHAM_GD"].nom
+          nomsym = " "
+        for cle in liste_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"]
+#
+###        print dico
+        liste_champs.append(dico)
+#
+# 2.1.4. ==> Les zones de raffinement
+#
+###    print "\n.. Debut de 2.1.4."
+#
+    if args.has_key("ZONE") :
+#
+      if args["ZONE"] is not None :
+        les_zones = args["ZONE"]
+#
+      for zone in les_zones :
+###        print zone
+###        print type(zone)
+        dico = {}
+        for aux in ['X_MINI', 'X_MAXI', 'Y_MINI', 'Y_MAXI', 'Z_MINI', 'Z_MAXI', 'X_CENTRE', 'Y_CENTRE', 'Z_CENTRE', 'RAYON'] :
+          if ( zone[aux] != None ) :
+            dico[aux] = zone[aux]
+###        print dico
+        liste_zones.append(dico)
+#
+###    print liste_zones
+#
+# 2.2. ==> Donnees de pilotage de l'information
+#
+  else :
+#
+    mode_homard = "INFO"
+#
+    dico = {}
+    dico["Type_Maillage"] = "MAILLAGE_N"
+    dico["Nom_ASTER"]     = args["MAILLAGE"]
+    dico["Action"]        = "A_ecrire"
+    liste_maillages.append(dico)
+#
+# 2.3. ==> Suivi de frontiere
+#
+#gn   print "\n.. Debut de 2.3."
+#
+  if ( MAILLAGE_FRONTIERE != None ) :
+#
+    dico = {}
+    dico["Type_Maillage"] = "MAILLAGE_FRONTIERE"
+    dico["Nom_ASTER"]     = MAILLAGE_FRONTIERE
+    dico["Action"]        = "A_ecrire"
+    liste_maillages.append(dico)
+#
+# 2.4. ==> Le numero de version de HOMARD
+#    Remarque : dans la donnee de la version de HOMARD, il faut remplacer
+#               le _ de la donnee par un ., qui est interdit dans la
+#               syntaxe du langage de commandes ASTER
+#    Remarque : il faut remplacer le N majuscule de la donnee par
+#               un n minuscule, qui est interdit dans la syntaxe du langage
+#               de commandes ASTER
+#
+#gn  print "\n.. Debut de 2.4. avec VERSION_HOMARD = ", VERSION_HOMARD
+  VERSION_HOMARD = string.replace(VERSION_HOMARD,"_" , ".")
+  VERSION_HOMARD = string.replace(VERSION_HOMARD,"N" , "n")
+#
+  if ( VERSION_HOMARD[-6:]==".PERSO" ):
+    VERSION_HOMARD = VERSION_HOMARD[:-6]
+    version_perso = 1
+  else :
+    version_perso = 0
+#gn  print ".... VERSION_HOMARD = ", VERSION_HOMARD
+#gn  print ".... version_perso  = ", version_perso
+#
+#====================================================================
+# 3. Preparation du lancement des commandes
+#====================================================================
+#
+# 3.1. ==> . Elaboration des noms MED des concepts de maillage
+#          . 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.
+#
+#gn  print "\n.. Debut de 3.1."
+#
+  Nom_Concept_Maillage_NP1_ANNEXE = None
+  l_aux = []
+  for dico in liste_maillages :
+#gn    print "\ndico avant = ",dico
+    if ( dico["Action"] != "Rien" ) :
+      dico["NOM_MED"] = aster.mdnoma(dico["Nom_ASTER"].nom)
+      l_aux.append(dico)
+      if ( dico["Type_Maillage"] == "MAILLAGE_N" ) :
+        Nom_Concept_Maillage_N = dico["Nom_ASTER"].nom
+      elif ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) :
+        Nom_Concept_Maillage_NP1 = dico["Nom_ASTER"].nom
+      elif ( dico["Type_Maillage"] == "MAILLAGE_NP1_ANNEXE" ) :
+        Nom_Concept_Maillage_NP1_ANNEXE = dico["Nom_ASTER"].nom
+#gn    print "\ndico apres = ",dico
+  liste_maillages = l_aux
+#
+# 3.2. ==> Recherche du numero d'iteration et du repertoire de travail
+#
+# 3.2.1. ==> Par defaut :
+#            . le numero d'iteration est nul
+#            . le nom du repertoire de lancement de HOMARD est construit sur le nom
+#              du maillage en entree et le numero de passage dans la fonction
+#
+#gn  print "\.. Debut de 3.2.1."
+#
+  niter = 0
+  Nom_Rep_local = Nom_Concept_Maillage_N + "_" + mode_homard + "_" + str(numero_passage_fonction)
+  Rep_Calc_HOMARD_local = os.path.join(".", Nom_Rep_local)
+  Rep_Calc_HOMARD_global = os.path.join(Rep_Calc_ASTER, Nom_Rep_local)
+###  print "Rep_Calc_HOMARD_local  = ", Rep_Calc_HOMARD_local
+###  print "Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
+#
+# 3.2.2. ==> En adaptation : il faut repartir du repertoire de l'iteration precedente
+#
+#gn  print "\.. Debut de 3.2.2."
+#
+  if ( mode_homard == "ADAP" ) :
+#
+# 3.2.2.1. ==> On recherche si dans les passages deje effectues, il en existe un
+#              dont le maillage d'arrivee etait l'actuel maillage d'entree. Si c'est
+#              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.
+#
+#gn     print "\.. Debut de 3.2.2.1."
+#
+    for dico in Liste_Passages :
+      if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
+        niter   = dico["niter"] + 1
+        Rep_Calc_HOMARD_local  = dico["Rep_Calc_HOMARD_local"]
+        Rep_Calc_HOMARD_global = dico["Rep_Calc_HOMARD_global"]
+#
+# 3.2.2.2. ==> Memorisation de ce passage
+#
+#gn     print "\.. Debut de 3.2.2.2."
+#
+# 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure
+#
+    if ( niter == 0 ) :
+      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["Rep_Calc_HOMARD_local"]  = Rep_Calc_HOMARD_local
+      dico["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global
+      dico["niter"]        = niter
+      Liste_Passages.append(dico)
+#
+# 3.2.2.2.2. ==> Modification du cas en cours
+#
+    else :
+      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_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE
+          dico["niter"]        = niter
+        l_aux.append(dico)
+      Liste_Passages = l_aux
+#
+###  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
+#                    d'adaptation ou d'information
+#
+#gn  print "\.. Debut de 3.2.3."
+#
+  if ( niter == 0 ) :
+#
+    try :
+      os.mkdir(Rep_Calc_HOMARD_global)
+    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)
+#
+#====================================================================
+# 4. Ecriture des commandes de creation des donnees MED
+#====================================================================
+#
+#gn  print "\.. Debut de 4."
+#
+#  On doit ecrire : le maillage,
+#                   le champ d'indicateur d'erreur
+#                   les champs e 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
+##
+# 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))
+###  print "fichier_aster_vers_homard = ",fichier_aster_vers_homard
+#
+# 4.1.2. ==> De HOMARD vers ASTER
+#  
+  if ( mode_homard == "ADAP" ) :
+    unite_fichier_homard_vers_aster = unite_fichier_aster_vers_homard + 1
+    fichier_homard_vers_aster = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_homard_vers_aster))
+###    print "fichier_homard_vers_aster = ",fichier_homard_vers_aster
+#
+# 4.2. La definition du fichier de ASTER vers HOMARD
+# 
+  DEFI_FICHIER ( ACTION= "ASSOCIER",
+                 UNITE = unite_fichier_aster_vers_homard,
+                 TYPE = "LIBRE",
+                 INFO = infocomm )
+#
+# 4.3. Le(s) maillage(s)
+# Le maillage de calcul et l'eventuel maillage de la frontiere sont ecrits
+# dans le meme fichier MED
+# En fait, on pourrait s'en passer au dela de la 1ere iteration
+# car HOMARD a memorise. Mais des que l'on ecrit un champ,
+# les conventions MED imposent la presence du maillage dans le fichier.
+# Donc on va toujours ecrire.
+#
+  for dico in liste_maillages :
+    if ( dico["Action"] == "A_ecrire" ) :
+      motscsi = {}
+      motscsi["MAILLAGE"] = dico["Nom_ASTER"]
+      motscfa = {}
+      motscfa["RESU"] = _F( INFO_MAILLAGE=infomail,
+                          **motscsi )
+#
+      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 e jour du champ qui a servi comme
+#                    indicateur d'erreur. 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 ne demande a priori qu'une composante du champ d'indicateur.
+#                   s'il y a demande de mise e jour, toutes les composantes sont concernees. Il faut
+#                   donc dans ce cas imprimer le champ total.
+#        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 ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
+#        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["SENSIBILITE"]  = f ; string ; Nom du parametre sensible associe
+#
+# 4.4.1. Recherche d'un doublon eventuel sur le champ d'indicateur d'erreur
+#
+#gn  print "dico_indi = ",dico_indi
+  if len(dico_indi) > 0 :
+    indic_est_deja_imprime = 0
+    if dico_indi.has_key("RESULTAT") :
+      liste_aux = [ "RESULTAT", "NOM_CHAM" ]
+    else :
+      liste_aux = [ "CHAM_GD" ]
+  else :
+    indic_est_deja_imprime = 1
+    liste_aux = [ ]
+#gn  print ".. Au debut de la boucle, liste_aux = ",liste_aux
+#gn  print ".. Au debut de la boucle, indic_est_deja_imprime = ",indic_est_deja_imprime
+#
+  liste_champs_imprime = []
+  for dico in liste_champs :
+###    print "\n.... dico = ",dico
+#   Pour un champ e mettre e 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 :
+      if not indic_est_deja_imprime :
+#       Est-ce le meme champ ?
+        on_a_le_champ = 1
+        for cle in liste_aux :
+          if ( dico.has_key(cle) ) :
+###            print "...... dico_indi[cle] = ",dico_indi[cle]
+###            print "...... dico[cle]      = ",dico[cle]
+            if ( dico_indi[cle] != dico[cle] ) :
+              on_a_le_champ = 0
+              break
+          else :
+            on_a_le_champ = 0
+            break
+#       Si oui, est-ce un champ sensible ou non ?
+        if on_a_le_champ :
+          cle = "SENSIBILITE"
+          if dico.has_key(cle) :
+            if ( dico[cle] != None ) :
+              if dico_indi.has_key(cle) :
+                if ( dico_indi[cle] != dico[cle] ) :
+                  on_a_le_champ = 0
+                  break
+              else :
+                on_a_le_champ = 0
+                break
+#       Si oui, est-ce au meme moment ? (remarque : si rien n'est designe, c'est qu'il n'y a qu'un
+#       seul instant ... donc c'est le meme ! En revanche, on ne sait pas comparer une donnee
+#       en numero d'ordre et une donnee en instant. On croise les doigts.)
+        if on_a_le_champ :
+          for cle in [ "NUME_ORDRE", "INST" ] :
+            if dico.has_key(cle) :
+              if ( dico[cle] != None ) :
+                if dico_indi.has_key(cle) :
+                  if ( dico_indi[cle] != dico[cle] ) :
+                    on_a_le_champ = 0
+                    break
+        if on_a_le_champ :
+          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
+  if not indic_est_deja_imprime :
+    liste_champs_imprime.append(dico_indi)
+#
+# 4.4.2. Impressions apres le filtrage precedent
+#gn  print "\n.... Debut de 4.2.4.2."
+#
+  for dico in liste_champs_imprime :
+    motscsi = {}
+    for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
+      if dico.has_key(cle) :
+        if ( dico[cle] != None ) :
+          motscsi[cle] = dico[cle]
+    if dico.has_key("COMPOSANTE") :
+      motscsi["NOM_CMP"] = dico["COMPOSANTE"]
+    if dico.has_key("SENSIBILITE") :
+      motscsi["SENSIBILITE"] = dico["SENSIBILITE"]
+    motscfa = {}
+    motscfa["RESU"] = _F( INFO_MAILLAGE=infomail,
+                        **motscsi
+                      )
+#gn    print ".. motscfa = ",motscfa
+#
+    IMPR_RESU ( INFO = infocomm, 
+                FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard,
+                **motscfa )
+#
+#====================================================================
+# 5. ==> Creation des fichiers de donnees pour HOMARD
+#====================================================================
+#
+#gn  print "\.. Debut de 5."
+#
+  dico_configuration = {}
+#
+# 5.1. ==> Les generalites
+#
+  dico_configuration["INFO"] = INFO
+#
+  dico_configuration["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global
+  dico_configuration["VERSION_HOMARD"] = VERSION_HOMARD
+  dico_configuration["version_perso"] = version_perso
+#
+  dico_configuration["niter"] = niter
+  dico_configuration["Fichier_ASTER_vers_HOMARD"] = fichier_aster_vers_homard
+  if ( mode_homard == "ADAP" ) :
+    dico_configuration["Fichier_HOMARD_vers_ASTER"] = fichier_homard_vers_aster
+#  
+# 5.2. ==> Les noms med des maillages
+#
+  for dico in liste_maillages :
+#gn    print "Nom MED de " + dico["Type_Maillage"] + " = " + dico["NOM_MED"]
+    dico_configuration[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"]
+#gn  print dico_configuration
+#
+# 5.3. ==> Les caracteristiques de l'eventuel indicateur d'erreur
+#
+  for dico in liste_champs :
+    dico_aux = {}
+    if ( dico["Type_Champ"] == "INDICATEUR" ) :
+      liste_aux = [ "NOM_MED", "COMPOSANTE" ]
+      if dico.has_key("NUME_ORDRE") :
+        liste_aux.append("NUME_ORDRE")
+      for cle in liste_aux :
+        if ( dico[cle] != None ) :
+          dico_aux[cle] = dico[cle]
+      dico_configuration["Indicateur"] = dico_aux
+#gn  if dico_configuration.has_key("Indicateur") :
+#gn    print "dico_configuration[Indicateur] = ", dico_configuration["Indicateur"]
+#
+# 5.4. ==> Les eventuelles zones de raffinement
+#
+  prem = 1
+  for dico in liste_zones :
+    if prem :
+      l_aux = [dico]
+      prem = 0
+    else :
+      l_aux = dico_configuration["Zones"]
+      l_aux.append(dico)
+    dico_configuration["Zones"] = l_aux
+###  if dico_configuration.has_key("Zones") :
+###    print "dico_configuration[Zones] = ", dico_configuration["Zones"]
+#
+# 5.5. ==> La mise e jour de champs
+#
+  prem = 1
+  for dico in liste_champs :
+    dico_aux = {}
+    if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
+      liste_aux = [ "NOM_MED", "COMPOSANTE" ]
+      if dico.has_key("NUME_ORDRE") :
+        liste_aux.append("NUME_ORDRE")
+      else :
+        for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] :
+          liste_aux.append(cle)
+      for cle in liste_aux :
+        if dico.has_key(cle) :
+          if ( dico[cle] != None ) :
+            dico_aux[cle] = dico[cle]
+#gn      print dico_aux
+      if prem :
+        l_aux = [dico_aux]
+        prem = 0
+      else :
+        l_aux = dico_configuration["Champs"]
+        l_aux.append(dico_aux)
+      dico_configuration["Champs"] = l_aux
+#gn  if dico_configuration.has_key("Champs") :
+#gn   print "dico_configuration[Champs] = ", dico_configuration["Champs"]
+#
+# 5.6. ==> Appel de la fonction de creation
+#
+  donnees_homard = creation_donnees_homard.creation_donnees_homard ( self.nom, args, dico_configuration )
+  if ( INFO >= 4 ) :
+    donnees_homard.quel_mode ( )
+  fic_homard_niter, fic_homard_niterp1 = donnees_homard.creation_configuration ( )
+  donnees_homard.ecrire_fichier_configuration ( )
+  if ( mode_homard == "INFO" ) :
+    Nom_Fichier_Donnees = donnees_homard.ecrire_fichier_donnees ( )
+  else :
+    Nom_Fichier_Donnees = "0"
+#
+# 5.7. ==> 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 :
+    l_aux = [ ]
+  for nomfic in l_aux :
+    fic = os.path.join(Rep_Calc_HOMARD_global, nomfic)
+    if os.path.isfile (fic) :
+      print "\n\n=============================================================="
+      print "Contenu de", nomfic
+      fichier = open (fic,"r")
+      les_lignes = fichier.readlines()
+      fichier.close()
+      for ligne in les_lignes :
+        print ligne[:-1]
+      print "==============================================================\n"
+#gn  if ( mode_homard == "ADAP" ) :
+#gn    if args.has_key("MAJ_CHAM") :
+#gn      if args["MAJ_CHAM"] is not None :
+#gn        import time
+#gn        time.sleep(3600)
+#
+#====================================================================
+# 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)
+#
+  iaux = INFO
+  EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_HOMARD_global, # nom du repertoire
+                              VERSION_HOMARD,         # version de homard
+                              str(iaux),              # niveau d information
+                              Nom_Fichier_Donnees,    # fichier de donnees HOMARD
+                              str(version_perso),     # version personnelle de homard ?
+                             ),
+                  LOGICIEL = homard,
+                  INFO     = INFO,
+                )
+#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
+#        Exemple :
+#        self.DeclareOut("maillage_a_lire",args["MAILLAGE_NP1"])
+#        ==> la variable maillage_a_lire est identifiee e l'argument "MAILLAGE_NP1"
+#====================================================================
+#
+  if ( mode_homard == "ADAP" ) :
+#
+# 7.1. ==> Le maillage
+#          On inhibe l'alarme MODELISA5_49 qui apparait car on fait VERIF=NON
+#
+#gn    print "args = ",args
+    for dico in liste_maillages :
+#gn      print dico
+      if ( dico["Action"] == "A_lire" ) :
+#
+        MasquerAlarme('MODELISA5_49')
+#
+        self.DeclareOut("maillage_a_lire", dico["Nom_ASTER"])
+        maillage_a_lire = LIRE_MAILLAGE ( UNITE = unite_fichier_homard_vers_aster,
+                                       FORMAT = "MED",
+                                       NOM_MED = dico["NOM_MED"],
+                                       VERI_MAIL = _F(VERIF="NON"), INFO_MED = infocomm, INFO = infocomm )
+#
+        RetablirAlarme('MODELISA5_49')
+#
+#gn        print "MAILLAGE = ",maillage_a_lire
+#gn        print "NOM_MED = ",dico["NOM_MED"]
+        if ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) :
+          maillage_np1 = maillage_a_lire
+          maillage_np1_nom_med = dico["NOM_MED"]
+#
+# 7.2. ==> Les champs
+#gn    import time
+#gn    time.sleep(3600)
+#
+    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) :
+            if ( dico[cle] != None ) :
+              motscsi[cle] = dico[cle]
+        if dico.has_key("NUME_ORDRE") :
+          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 "TYPE_CHAM =", dico["TYPE_CHAM"]
+        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"],
+                                 INFO = infocomm, **motscsi )
+#
+#====================================================================
+# 8. Menage des fichiers devenus inutiles
+#    On doit imperativement garder le dernier fichier homard produit
+#    En mode d'information, on garde egalement les fichiers textes
+#====================================================================
+#
+  liste_aux = [fichier_aster_vers_homard]
+  liste_aux_bis = os.listdir(Rep_Calc_HOMARD_global)
+  for fic in liste_aux_bis :
+    fic_total = os.path.join(Rep_Calc_HOMARD_global, fic)
+    liste_aux.append(fic_total)
+  liste_aux_bis = []
+  if ( mode_homard == "ADAP" ) :
+    liste_aux.append(fichier_homard_vers_aster)
+    fic = os.path.join(Rep_Calc_HOMARD_global, fic_homard_niterp1)
+    liste_aux_bis.append(fic)
+#gn  os.system("cp " + Rep_Calc_HOMARD_global + "/* $HOME/aster")
+#
+  for fic in liste_aux :
+    if fic not in liste_aux_bis :
+      if ( INFO >= 3 ) :
+        print "Destruction du fichier ", fic
+      if os.path.isfile(fic) :
+        try :
+          os.remove(fic)
+        except os.error,codret_partiel :
+          self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
+          UTMESS("F",'HOMARD0_5',valk=fic)
+#gn  print "Repertoire ",Rep_Calc_HOMARD_global
+#gn  os.system("ls -la "+Rep_Calc_HOMARD_global)
+#gn  print "Repertoire ",Rep_Calc_ASTER
+#gn  os.system("ls -la "+Rep_Calc_ASTER)
+#gn  print os.listdir(Rep_Calc_HOMARD_global)
+#
+#====================================================================
+#  C'est fini !
+#====================================================================
+#
+###  if ( mode_homard == "ADAP" and niter == 3 ) :
+###  if ( niter == 2 ) :
+###    import time
+###    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
new file mode 100644 (file)
index 0000000..66f2815
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py
@@ -0,0 +1,763 @@
+#@ MODIF macr_ascouf_calc_ops Macro  DATE 03/08/2009   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.
+# ======================================================================
+
+
+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,
+                              SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE,
+                              INCREMENT,THETA_3D,IMPR_TABLE,IMPRESSION,INFO,TITRE ,**args):
+  """
+     Ecriture de la macro MACR_ASCOUF_CALC
+  """
+  from Accas import _F
+  import types
+  import math
+  import aster
+  from math import pi,sin,cos,sqrt,atan2
+  from Utilitai.Utmess     import  UTMESS
+  ier=0
+# On recopie les mots cles affe_materiau et impr_table pour les proteger
+  mc_AFFE_MATERIAU=AFFE_MATERIAU
+  mc_IMPR_TABLE   =IMPR_TABLE
+  # On importe les definitions des commandes a utiliser dans la macro
+  AFFE_MODELE      =self.get_cmd('AFFE_MODELE'     )
+  AFFE_MATERIAU    =self.get_cmd('AFFE_MATERIAU'   )
+  AFFE_CARA_ELEM   =self.get_cmd('AFFE_CARA_ELEM'  )
+  AFFE_CHAR_THER_F =self.get_cmd('AFFE_CHAR_THER_F')
+  THER_LINEAIRE    =self.get_cmd('THER_LINEAIRE'   )
+  AFFE_CHAR_MECA   =self.get_cmd('AFFE_CHAR_MECA'  )
+  STAT_NON_LINE    =self.get_cmd('STAT_NON_LINE'   )
+  CALC_ELEM        =self.get_cmd('CALC_ELEM'       )
+  IMPR_RESU        =self.get_cmd('IMPR_RESU'       )
+  IMPR_TABLE       =self.get_cmd('IMPR_TABLE'      )
+  DEFI_FOND_FISS   =self.get_cmd('DEFI_FOND_FISS'  )
+  CALC_THETA       =self.get_cmd('CALC_THETA'      )
+  CALC_G           =self.get_cmd('CALC_G'          )
+  POST_RCCM        =self.get_cmd('POST_RCCM'       )
+  POST_RELEVE_T    =self.get_cmd('POST_RELEVE_T'   )
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+#------------------------------------------------------------------
+# DATA
+  GRMAIL = ('COUDE','PEAUINT','PEAUEXT','EXTUBE','CLGV','FACE1','FACE2')
+#------------------------------------------------------------------
+#
+  if CL_BOL_P2_GV!=None :
+    if TYPE_MAILLAGE=='SOUS_EPAIS_COUDE' :
+       message=        ' la condition aux limites sur bol a section conique \n'
+       message=message+' est ignoree pour un coude avec sous-epaisseurs \n'
+       UTMESS('A','ASCOUF0_1')
+    elif (TYPE_MAILLAGE[:4]!='FISS') and (CL_BOL_P2_GV['AZIMUT']!=None) :
+       UTMESS('E','ASCOUF0_2')
+ #
+  if mc_IMPR_TABLE!=None :
+    FLAG = 0
+    if (mc_IMPR_TABLE['NOM_PARA']==None) and (mc_IMPR_TABLE['POSI_ANGUL']==None) and (mc_IMPR_TABLE['POSI_CURV_LONGI']==None) :
+       UTMESS('E','ASCOUF0_3')
+       return ier
+    if (mc_IMPR_TABLE['NOM_PARA']!=None) :
+       impr_table_nom_para= mc_IMPR_TABLE['NOM_PARA']
+       for impt in impr_table_nom_para :
+         if impt in ('SI_LONG','SI_CIRC','SI_RADI') :
+           FLAG = 1
+           if (((impt['ANGLE']==None) and (impt['POSI_ANGUL']==None) and (impt['R_CINTR'        ]==None)) or
+               ((impt['ANGLE']==None) and (impt['R_CINTR'   ]==None) and (impt['POSI_CURV_LONGI']==None))   )  :
+             UTMESS('E','ASCOUF0_4')
+    if (mc_IMPR_TABLE['NOM_PARA']==None) : FLAG = 1
+    if not FLAG : UTMESS('A','ASCOUF0_5')
+#
+#------------------------------------------------------------------
+#
+#     --- commande AFFE_MODELE ---
+#
+  self.DeclareOut('modele',MODELE)
+  mcfact=[]
+  if (TYPE_MAILLAGE[:4]=='FISS') :
+     mcfact.append(_F(GROUP_MA=GRMAIL     ,PHENOMENE='MECANIQUE',MODELISATION='3D'    ))
+  else:
+     mcfact.append(_F(GROUP_MA=GRMAIL[:5] ,PHENOMENE='MECANIQUE',MODELISATION='3D'    ))
+  if TORS_P1!=None :
+     mcfact.append(_F(GROUP_MA='P1' ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR'))
+  if CL_BOL_P2_GV==None :
+     mcfact.append(_F(GROUP_MA='P2' ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR'))
+  modele = AFFE_MODELE( MAILLAGE = MAILLAGE ,
+                        AFFE     = mcfact    )
+  if ECHANGE!=None :                                # modele thermique
+     __modthe = AFFE_MODELE( MAILLAGE = MAILLAGE ,
+                             AFFE     = _F(TOUT        ='OUI',
+                                           PHENOMENE   ='THERMIQUE',
+                                           MODELISATION='3D' )       )
+
+#------------------------------------------------------------------
+#
+#     --- commande AFFE_MATERIAU (thermique)---
+#
+  mcfact=[]
+  for mater in mc_AFFE_MATERIAU :
+     if mater['TOUT']!=None :
+       mcfact.append(_F(TOUT    =mater['TOUT'    ],MATER=mater['MATER']))
+       rccmat = mater['MATER']
+     else                   :
+       mcfact.append(_F(GROUP_MA=mater['GROUP_MA'],MATER=mater['MATER']))
+       if    mater['GROUP_MA'][:5]=='COUDE' :
+         if TORS_P1!=None :
+           mcfact.append(_F(GROUP_MA='P1',MATER=mater['MATER']))
+           mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER']))
+         elif (len(mc_AFFE_MATERIAU)==1) and (CL_BOL_P2_GV==None) :
+           mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER']))
+       elif (mater['BOL'     ][:3]=='BOL'  ) and (CL_BOL_P2_GV==None) :
+         mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER']))
+
+  __affmat = AFFE_MATERIAU( MAILLAGE = MAILLAGE ,
+                          MODELE   = modele ,
+                          AFFE     = mcfact    )
+
+#------------------------------------------------------------------
+#
+#     --- commande AFFE_CARA_ELEM ---
+#
+  if (TORS_P1!=None) or (CL_BOL_P2_GV==None) :
+    if CARA_ELEM!=None : self.DeclareOut('carael',CARA_ELEM)
+    motscles={}
+    motscles['DISCRET']=[]
+    if (TORS_P1!=None)      : motscles['DISCRET'].append(_F( GROUP_MA='P1' ,
+                                                             CARA    ='K_TR_D_N',
+                                                             VALE    = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ),)
+    if (CL_BOL_P2_GV==None) : motscles['DISCRET'].append(_F( GROUP_MA='P2' ,
+                                                             CARA    ='K_TR_D_N',
+                                                             VALE    = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ),)
+
+    carael = AFFE_CARA_ELEM( MODELE   = modele ,**motscles)
+#
+  if ECHANGE!=None :
+#------------------------------------------------------------------
+#
+#     --- commande AFFE_CHAR_THER_F ---
+#         condition aux limites
+#
+     __chther = AFFE_CHAR_THER_F( MODELE = __modthe ,
+                                  ECHANGE= _F(GROUP_MA='PEAUINT',
+                                              COEF_H  =ECHANGE['COEF_H'],
+                                              TEMP_EXT=ECHANGE['TEMP_EXT'],), )
+#------------------------------------------------------------------
+#
+#     --- calcul thermique ---
+#
+     if RESU_THER!=None : self.DeclareOut('resuth',RESU_THER)
+     mcsimp={}
+     if INCREMENT['NUME_INST_INIT']!=None : mcsimp['NUME_INST_INIT']=INCREMENT['NUME_INST_INIT']
+     if INCREMENT['NUME_INST_FIN' ]!=None : mcsimp['NUME_INST_FIN' ]=INCREMENT['NUME_INST_FIN' ]
+     mcfact=_F(LIST_INST=INCREMENT['LIST_INST'],**mcsimp)
+     resuth = THER_LINEAIRE( MODELE     = __modthe ,
+                             CHAM_MATER = __affmat ,
+                             ETAT_INIT  = _F(STATIONNAIRE='OUI',),
+                             EXCIT      = _F(CHARGE=__chther,),
+                             INCREMENT  = mcfact, )
+#
+#------------------------------------------------------------------
+#
+#     --- commande AFFE_MATERIAU (mécanique)---
+#
+  if CHAM_MATER!=None : self.DeclareOut('affmth',CHAM_MATER)
+  indther= ECHANGE
+  mcfact=[]
+  mcfac2=[]
+  for mater in mc_AFFE_MATERIAU :
+     if mater['TOUT']!=None :
+       mcfact.append(_F(TOUT    =mater['TOUT'    ],MATER=mater['MATER'],))
+       if indther:
+         mcfac2.append(_F(NOM_VARC='TEMP',TOUT='OUI',
+                        EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF'],),)
+       rccmat = mater['MATER']
+     else                   :
+       mcfact.append(_F(GROUP_MA=mater['GROUP_MA'],MATER=mater['MATER'],))
+       if indther:
+         mcfac2.append(_F(NOM_VARC='TEMP',GROUP_MA=mater['GROUP_MA'],
+                        EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF'],),)
+       if    mater['GROUP_MA'][:5]=='COUDE' :
+         if TORS_P1!=None :
+           mcfact.append(_F(GROUP_MA='P1',MATER=mater['MATER'],))
+           mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER'],))
+           if indther:
+             mcfac2.append(_F(NOM_VARC='TEMP',GROUP_MA='P1',
+                            EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF'],),)
+             mcfac2.append(_F(NOM_VARC='TEMP',GROUP_MA='P2',
+                            EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF'],),)
+         elif (len(mc_AFFE_MATERIAU)==1) and (CL_BOL_P2_GV==None) :
+           mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER'],))
+           if indther:
+             mcfac2.append(_F(NOM_VARC='TEMP',GROUP_MA='P2',
+                            EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF'],),)
+       elif (mater['BOL'     ][:3]=='BOL'  ) and (CL_BOL_P2_GV==None) :
+         mcfact.append(_F(GROUP_MA='P2',MATER=mater['MATER'],))
+         if indther:
+           mcfac2.append(_F(NOM_VARC='TEMP',GROUP_MA='P2',
+                          EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF'],),)
+
+
+  affmth = AFFE_MATERIAU( MAILLAGE = MAILLAGE ,
+                          MODELE   = modele ,
+                          AFFE     = mcfact,
+                          AFFE_VARC= mcfac2,)
+
+
+
+
+#------------------------------------------------------------------
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         condition aux limites de type raccord 3d-poutre
+#         ou bien blocage de mouvements rigides en cas d embout
+#         a section conique, bol de type gv
+#
+  motscles={}
+  motscles['LIAISON_ELEM']=[]
+  if TORS_P1!=None :
+    motscles['LIAISON_ELEM'].append(_F( OPTION    ='3D_POU'  ,
+                                         GROUP_MA_1='EXTUBE',
+                                         GROUP_NO_2='P1') )
+  if CL_BOL_P2_GV==None :
+    motscles['LIAISON_ELEM'].append(_F( OPTION    ='3D_POU'  ,
+                                         GROUP_MA_1='CLGV',
+                                         GROUP_NO_2='P2') )
+    motscles['DDL_IMPO'    ]=_F( GROUP_NO  ='P2' ,
+                                 DX        = 0.0 ,
+                                 DY        = 0.0 ,
+                                 DZ        = 0.0 ,
+                                 DRX       = 0.0 ,
+                                 DRY       = 0.0 ,
+                                 DRZ       = 0.0 , )
+  else :
+    motscles['FACE_IMPO'   ]=_F( GROUP_MA  ='CLGV' ,
+                                 DNOR      = 0.0 , )
+    ALPHA  = CL_BOL_P2_GV['ANGLE' ]
+    AZIM   = CL_BOL_P2_GV['AZIMUT']
+    ALPHAR = ALPHA*pi/180.0
+    AZIMR  = AZIM *pi/180.0
+    DDLB1  = []
+    COEFB1 = []
+    if (AZIM!=0.0) and (AZIM!=180.0) and (ALPHA!=90.0) :
+      DDLB1.append('DX')
+      COEFB1.append(SIN(AZIMR)*COS(ALPHAR))
+    if (AZIM!=90.0) :
+      DDLB1.append('DY')
+      COEFB1.append(COS(AZIMR))
+    if (AZIM!=0.) and (AZIM!=180.) and (ALPHA!=0.):
+      DDLB1.append('DZ')
+      COEFB1.append(-SIN(AZIMR)*SIN(ALPHAR))
+    POINT=['BOUT1',]*len(DDLB1)
+    motscles['LIAISON_DDL']=_F( GROUP_NO  = POINT  ,
+                                DDL       = DDLB1  ,
+                                COEF_MULT = COEFB1 ,
+                                COEF_IMPO = 0.0    , )
+
+  _conlim = AFFE_CHAR_MECA( MODELE   = modele ,**motscles)
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         chargement mecanique :  pres_rep, effet de fond
+#
+  if PRES_REP!=None :
+    motscles={}
+    if (PRES_REP['PRES_LEVRE']=='OUI') and (TYPE_MAILLAGE[:4]=='FISS') :
+      motscles['PRES_REP']=_F( GROUP_MA  = ('PEAUINT','FACE1','FACE2') ,
+                               PRES      = PRES_REP['PRES'] ,)
+    else :
+      motscles['PRES_REP']=_F( GROUP_MA  = 'PEAUINT',
+                               PRES      = PRES_REP['PRES'] ,)
+    if PRES_REP['EFFE_FOND_P1']!='NON' :
+      motscles['EFFE_FOND']=_F( GROUP_MA_INT  = 'BORDTU'  ,
+                                GROUP_MA      = 'EXTUBE'  ,
+                                PRES          = PRES_REP['PRES'] ,)
+#
+    _chpres = AFFE_CHAR_MECA( MODELE   = modele ,**motscles)
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         chargement mecanique : torseur d efforts
+#
+  if TORS_P1!=None :
+    _chtor = [None]*6
+    i=0
+    for tors in TORS_P1:
+      mcsimp={}
+      if tors['FX']!=None : mcsimp['FX']=tors['FX']
+      if tors['FY']!=None : mcsimp['FY']=tors['FY']
+      if tors['FZ']!=None : mcsimp['FZ']=tors['FZ']
+      if tors['MX']!=None : mcsimp['MX']=tors['MX']
+      if tors['MY']!=None : mcsimp['MY']=tors['MY']
+      if tors['MZ']!=None : mcsimp['MZ']=tors['MZ']
+      mcfact=_F(GROUP_NO='P1',**mcsimp)
+      _chtor[i] = AFFE_CHAR_MECA( MODELE       = modele ,
+                                  FORCE_NODALE = mcfact , )
+      i=i+1
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         chargement mecanique :  verif contact levres
+#
+  if TYPE_MAILLAGE in ('FISS_COUDE','FISS_AXIS_DEB'):
+    _chcont = AFFE_CHAR_MECA( MODELE   = modele ,
+                               CONTACT =_F(GROUP_MA_MAIT = 'FACE1',
+                                           GROUP_MA_ESCL = 'FACE2',
+                                           METHODE='VERIF',
+                                           GROUP_MA_FOND='FONDFISS',
+                                           TOLE_INTERP = -1.E-6,),)
+#
+#     --- commande STAT_NON_LINE ---
+#
+  motscles={}
+#
+  mcfex=[]  # mot clé facteur EXCIT
+  mcfex.append(_F(CHARGE=_conlim,))
+  if PRES_REP!=None:
+    if PRES_REP['FONC_MULT']!=None :
+      mcfex.append(_F(CHARGE=_chpres,FONC_MULT=PRES_REP['FONC_MULT']))
+    else :
+      mcfex.append(_F(CHARGE=_chpres,))
+  if TORS_P1!=None:
+     i=0
+     for tors in TORS_P1 :
+       if tors['FONC_MULT']!=None :
+          mcfex.append(_F(CHARGE=_chtor[i],FONC_MULT=tors['FONC_MULT']))
+       else :
+          mcfex.append(_F(CHARGE=_chtor[i],))
+       i=i+1
+  if TYPE_MAILLAGE in ('FISS_COUDE','FISS_AXIS_DEB'):
+    mcfex.append(_F(CHARGE=_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 :
+    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'))
+  motscles['COMP_INCR'] =mcfci
+#
+  dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+  for i in dSolveur.keys():
+      if dSolveur[i]==None : del dSolveur[i]
+#
+  dConverg=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+  for i in dConverg.keys():
+      if dConverg[i]==None : del dConverg[i]
+#
+  dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
+  for i in dNewton.keys():
+      if dNewton[i]==None : del dNewton[i]
+#
+  dRechlin = {}
+  if RECH_LINEAIRE != None:
+     dRechlin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste)
+     for i in dRechlin.keys():
+         if dRechlin[i]==None : del dRechlin[i]
+#
+  dIncrem=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
+  for i in dIncrem.keys():
+      if dIncrem[i]==None : del dIncrem[i]
+#
+  if TITRE!=None :
+    motscles['TITRE'        ] =TITRE
+  motscles  ['SOLVEUR'      ] =dSolveur
+  motscles  ['CONVERGENCE'  ] =dConverg
+  motscles  ['NEWTON'       ] =dNewton
+  motscles  ['RECH_LINEAIRE'] =dRechlin
+  motscles  ['INCREMENT'    ] =dIncrem
+  self.DeclareOut('nomres',self.sd)
+  nomres = STAT_NON_LINE( MODELE     = modele ,
+                          CHAM_MATER = affmth ,
+                          CARA_ELEM  = carael ,
+                          INFO       = INFO   , **motscles)
+#
+#     --- commande CALC_ELEM ---
+#
+  nomres = CALC_ELEM( reuse      = nomres,
+                      RESULTAT   = nomres ,
+                      MODELE     = modele ,
+                      TOUT_ORDRE = 'OUI'  ,
+                      OPTION     = ('SIEF_ELNO_ELGA','EQUI_ELNO_SIGM') ,
+                      INFO       = INFO   ,)
+#
+#     --- post-traitements ---
+#
+  if TYPE_MAILLAGE=='SOUS_EPAIS_COUDE':
+#
+#     --- post traitement sous-epaisseurs:  ligaments  ---
+#
+     if mc_IMPR_TABLE!=None:
+#
+      SECT=('MI','TU','GV')
+      LIG=('FDRO','EXDR','EXTR','EXGA','FGAU','INGA','INTR','INDR')
+      if   mc_IMPR_TABLE['POSI_ANGUL']==None:
+         ASEP=(mc_IMPR_TABLE['POSI_CURV_LONGI']/mc_IMPR_TABLE['R_CINTR'])*(180./pi)
+      else :
+         ASEP=mc_IMPR_TABLE['POSI_ANGUL']
+#
+#     moyenne_rccm, invariant et moyenne sur les ligaments dans
+#     l epaisseur
+#
+      l_grno=MAILLAGE.LIST_GROUP_NO()
+      tabprl=[None]*4
+      tablig=[None]*4
+#
+#     prelevements des ligaments circonferentiels et longitudinaux
+#     de la sous-epaisseur
+#
+      lgrno=[]
+      for tgrno in l_grno :
+        if tgrno[0][:3] in ('CIR','LON')    : lgrno.append(tgrno[0])
+        elif tgrno[0][:5]=='PCENT'          : lgrno.append(tgrno[0])
+        elif (tgrno[0][:4] in LIG) and (tgrno[0][4:6] not in ('GV','TU','MI')): lgrno.append(tgrno[0])
+#
+      motscles={}
+      motscles['ACTION']=[]
+      for grno in lgrno :
+         motscles['ACTION'].append(_F(RESULTAT=nomres,
+                                      NOM_CHAM='SIEF_ELNO_ELGA',
+                                      TOUT_CMP='OUI',
+                                      INTITULE=grno,
+                                      GROUP_NO=grno,
+                                      OPERATION='EXTRACTION',))
+      motscles['TITRE']='TABLE DE POST-TRAITEMENT SECTION SOUS-EPAISSEUR'
+      tabprl[1]=POST_RELEVE_T(**motscles)
+      tablig[1]=POST_RCCM(MATER          = rccmat,
+                          TYPE_RESU_MECA = 'EVOLUTION',
+                          OPTION         = 'PM_PB',
+                          TRANSITOIRE=_F(TABL_RESU_MECA = tabprl[1],),)
+#
+      motscles={}
+      motscles['ACTION']=[]
+      for tgrno in lgrno :
+         motscles['ACTION'].append(_F(RESULTAT=nomres,
+                                      NOM_CHAM='SIEF_ELNO_ELGA',
+                                      INTITULE=tgrno,
+                                      GROUP_NO=tgrno,
+                                      INVARIANT='OUI',
+                                      OPERATION='EXTRACTION',))
+      motscles['TITRE']='TABLE DE POST-TRAITEMENT SECTION SOUS-EPAISSEUR'
+
+      tablig[2]=POST_RELEVE_T(**motscles)
+#
+      motscles={}
+      nommail=MAILLAGE.nom
+      coord   =aster.getvectjev(nommail.ljust(8)+'.COORDO    .VALE')
+      linomno =aster.getvectjev(nommail.ljust(8)+'.NOMNOE')
+      collgrno=aster.getcolljev(nommail.ljust(8)+'.GROUPENO')
+
+      motscles['ACTION']=[]
+      for tgrno in lgrno :
+         if tgrno[:3]!='LON' :
+          if mc_IMPR_TABLE['TRANSFORMEE']=='TUBE': vecty=(0.,0.,1.)
+          else                                   : vecty=(sin(ASEP*pi/180.),0.,cos(ASEP*pi/180.))
+         else :
+          if mc_IMPR_TABLE['TRANSFORMEE']=='TUBE': vecty=(0.,0.,1.)
+          else :
+                 grpn=collgrno['FGAUTU  ']
+                 LT1=coord[3*(grpn[0]-1)+2]
+                 for node in grpn:
+                  X = coord[3*(node-1)]
+                  Y = coord[3*(node-1)+1]
+                  Z = coord[3*(node-1)+2]
+                  RCIN = mc_IMPR_TABLE['R_CINTR']
+                  if   Z<LT1                           : ANGSEC=0.
+                  elif X<(-1*RCIN) : ANGSEC=mc_IMPR_TABLE['ANGLE']*pi/180.
+                  else :
+                      VCOS = cos((-LT1-Z)/(sqrt((X+RCIN)**2+Y**2 )))
+                      VSIN = sin((-LT1-Z)/(sqrt((X+RCIN)**2+Y**2 )))
+                      ANGSEC = atan2(VSIN,VCOS)
+                 vecty=(sin(ANGSEC),0.,cos(ANGSEC))
+         motscles['ACTION'].append(_F(RESULTAT=nomres,
+                                      NOM_CHAM='SIEF_ELNO_ELGA',
+                                      INTITULE=tgrno,
+                                      GROUP_NO=tgrno,
+                                      NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ',),
+                                      REPERE='LOCAL',
+                                      VECT_Y=vecty,
+                                      OPERATION='MOYENNE',))
+      motscles['TITRE']='TABLE DE POST-TRAITEMENT SECTION SOUS-EPAISSEUR'
+      tablig[3]=POST_RELEVE_T(**motscles)
+#
+#     prelevements des ligaments sur les sections MI,TU et GV
+#     les 8 ligaments sont tous les 45 degres
+#
+      ACOUR = mc_IMPR_TABLE['ANGLE']*pi/180.0
+      secprl=[None]*3
+      secrcm=[None]*3
+      secinv=[None]*3
+      secmoy=[None]*3
+      for i in range(3):
+         if mc_IMPR_TABLE['TRANSFORMEE']=='TUBE': vecty=(0.,0.,1.)
+         else :
+             if i==0  : vecty=(sin(ACOUR/2.),0.,cos(ACOUR/2.))
+             if i==1  : vecty=(0.,0.,1.)
+             if i==2  : vecty=(sin(ACOUR),0.,cos(ACOUR))
+         motscles = {}
+         motscles['TITRE']='TABLE DE POST-TRAITEMENT MOYENNE RCCM SECTION '+SECT[i]
+#
+#        moyenne RCCM sur les sections MI,TU et GV
+#
+         motscles={}
+         motscles['ACTION']=[]
+         for j in range(8) :
+            motscles['ACTION'].append(_F(RESULTAT=nomres,
+                                         NOM_CHAM='SIEF_ELNO_ELGA',
+                                         TOUT_CMP='OUI',
+                                         INTITULE=LIG[j]+SECT[i],
+                                         GROUP_NO=LIG[j]+SECT[i],
+                                         OPERATION='EXTRACTION',))
+         motscles['TITRE']='TABLE DE POST-TRAITEMENT MOYENNE RCCM SECTION '+SECT[i]
+         secprl[i]=POST_RELEVE_T(**motscles)
+         secrcm[i]=POST_RCCM(MATER          = rccmat,
+                             TYPE_RESU_MECA = 'EVOLUTION',
+                             OPTION         = 'PM_PB',
+                             TRANSITOIRE=_F(TABL_RESU_MECA = secprl[i],),)
+#
+#        invariants sur les sections MI,TU et GV
+#
+         motscles = {}
+         motscles['TITRE']='TABLE DE POST-TRAITEMENT INVARIANTS SECTION '+SECT[i]
+         motscles['ACTION']=[]
+         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',
+                                                          INVARIANT='OUI',
+                                                          OPERATION='EXTRACTION'))
+         secinv[i] = POST_RELEVE_T(**motscles)
+#
+#        moyennes contraintes sur les sections MI,TU et GV
+#
+         motscles = {}
+         motscles['TITRE']='TABLE DE POST-TRAITEMENT MOYENNE SECTION '+SECT[i]
+         motscles['ACTION']=[]
+         for j in range(8) : motscles['ACTION'].append(_F(INTITULE =LIG[j]+SECT[i],
+                                                          REPERE   ='LOCAL',
+                                                          VECT_Y   =vecty,
+                                                          GROUP_NO =LIG[j]+SECT[i],
+                                                          RESULTAT =nomres,
+                                                          NOM_CHAM ='SIEF_ELNO_ELGA',
+                                                          NOM_CMP  =('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),
+                                                          OPERATION='MOYENNE'))
+         secmoy[i] = POST_RELEVE_T(**motscles)
+
+#
+#     impression des valeurs maximales pour chaque sous-epaisseur
+#
+      if mc_IMPR_TABLE['TOUT_PARA']=='OUI' :
+             list_para=['TRESCA_MEMBRANE','TRESCA_MFLE','TRESCA','SI_LONG','SI_RADI','SI_CIRC']
+      else : list_para=mc_IMPR_TABLE['NOM_PARA']
+      if 'TRESCA_MEMBRANE' in list_para:
+        IMPR_TABLE(TABLE    = tablig[1],
+                   FILTRE   = _F( NOM_PARA  ='PM', CRIT_COMP ='MAXI'),
+                   NOM_PARA = ('INTITULE','PM'));
+      if 'TRESCA_MFLE'     in list_para:
+        IMPR_TABLE(TABLE    = tablig[1],
+                   FILTRE   =(_F( NOM_PARA ='LIEU',VALE_K   ='ORIG'),
+                              _F( NOM_PARA ='PMB', CRIT_COMP='MAXI'),),
+                   NOM_PARA = ('INTITULE','PMB'));
+        IMPR_TABLE(TABLE    = tablig[1],
+                   FILTRE   =(_F( NOM_PARA='LIEU', VALE_K  ='EXTR'),
+                              _F( NOM_PARA ='PMB', CRIT_COMP='MAXI'),),
+                   NOM_PARA = ('INTITULE','PMB'));
+      if 'SI_RADI'         in list_para:
+        IMPR_TABLE(TABLE    = tablig[3],
+                   FILTRE   =(_F( NOM_PARA='QUANTITE',VALE_K  ='MOMENT_0'),
+                              _F( NOM_PARA ='SIXX',   CRIT_COMP='MAXI'),),
+                   NOM_PARA = ('INTITULE','SIXX'));
+      if 'SI_LONG'         in list_para:
+        IMPR_TABLE(TABLE    = tablig[3],
+                   FILTRE   =(_F( NOM_PARA='QUANTITE',VALE_K  ='MOMENT_0'),
+                              _F( NOM_PARA ='SIYY',   CRIT_COMP='MAXI'),),
+                   NOM_PARA = ('INTITULE','SIYY'));
+      if 'SI_CIRC'         in list_para:
+        IMPR_TABLE(TABLE    = tablig[3],
+                   FILTRE   =(_F( NOM_PARA='QUANTITE',VALE_K  ='MOMENT_0'),
+                              _F( NOM_PARA ='SIZZ',   CRIT_COMP='MAXI'),),
+                   NOM_PARA = ('INTITULE','SIZZ'));
+      if 'TRESCA'          in list_para:
+        IMPR_TABLE(TABLE      = tablig[2],
+                   NOM_PARA   = ('INTITULE','NOEUD','TRESCA',),
+                   PAGINATION = 'INTITULE',
+                   FILTRE     = _F( NOM_PARA   = 'TRESCA',
+                                    CRIT_COMP  = 'MAXI'     ) )  ;
+#
+#     impression des resultats pour chaque sous-epaisseur
+#
+      if 'TRESCA_MEMBRANE' in list_para:
+        IMPR_TABLE(TABLE    = tablig[1],
+                   FILTRE   = _F( NOM_PARA='LIEU', VALE_K  ='ORIG'),
+                   NOM_PARA = ('INTITULE','PM'));
+      if 'TRESCA_MFLE'     in list_para:
+        IMPR_TABLE(TABLE    = tablig[1],
+                   FILTRE   = _F( NOM_PARA='LIEU', VALE_K  ='ORIG'),
+                   NOM_PARA = ('INTITULE','PMB'));
+        IMPR_TABLE(TABLE    = tablig[1],
+                   FILTRE   = _F( NOM_PARA='LIEU', VALE_K  ='EXTR'),
+                   NOM_PARA = ('INTITULE','PMB'));
+      if 'SI_RADI'         in list_para:
+        IMPR_TABLE(TABLE    = tablig[3],
+                   FILTRE   = _F( NOM_PARA='QUANTITE', VALE_K  ='MOMENT_0'),
+                   NOM_PARA = ('INTITULE','SIXX'));
+      if 'SI_LONG'         in list_para:
+        IMPR_TABLE(TABLE    = tablig[3],
+                   FILTRE   = _F( NOM_PARA='QUANTITE', VALE_K  ='MOMENT_0'),
+                   NOM_PARA = ('INTITULE','SIYY'));
+      if 'SI_CIRC'         in list_para:
+        IMPR_TABLE(TABLE    = tablig[3],
+                   FILTRE   = _F( NOM_PARA='QUANTITE', VALE_K  ='MOMENT_0'),
+                   NOM_PARA = ('INTITULE','SIZZ'));
+      if 'TRESCA'          in list_para:
+        IMPR_TABLE(TABLE      = tablig[2],
+                   NOM_PARA   = ('INTITULE','NOEUD','TRESCA',),
+                   PAGINATION = 'INTITULE');
+#
+#     impression des resultats pour les sections MI, TU et GV
+#
+      for k in range(3):
+       if 'TRESCA_MEMBRANE' in list_para:
+         IMPR_TABLE(TABLE    = secrcm[k],
+                    FILTRE   = _F( NOM_PARA='LIEU', VALE_K  ='ORIG'),
+                    NOM_PARA = ('INTITULE','PM'));
+       if 'TRESCA_MFLE'     in list_para:
+         IMPR_TABLE(TABLE    = secrcm[k],
+                    FILTRE   = _F( NOM_PARA='LIEU', VALE_K  ='ORIG'),
+                    NOM_PARA = ('INTITULE','PMB'));
+         IMPR_TABLE(TABLE    = secrcm[k],
+                    FILTRE   = _F( NOM_PARA='LIEU', VALE_K  ='EXTR'),
+                    NOM_PARA = ('INTITULE','PMB'));
+       if 'SI_RADI'         in list_para:
+         IMPR_TABLE(TABLE    = secmoy[k],
+                    FILTRE   = _F( NOM_PARA='QUANTITE', VALE_K  ='MOMENT_0'),
+                    NOM_PARA = ('INTITULE','SIXX'));
+       if 'SI_LONG'         in list_para:
+         IMPR_TABLE(TABLE    = secmoy[k],
+                    FILTRE   = _F( NOM_PARA='QUANTITE', VALE_K  ='MOMENT_0'),
+                    NOM_PARA = ('INTITULE','SIYY'));
+       if 'SI_CIRC'         in list_para:
+         IMPR_TABLE(TABLE    = secmoy[k],
+                    FILTRE   = _F( NOM_PARA='QUANTITE', VALE_K  ='MOMENT_0'),
+                    NOM_PARA = ('INTITULE','SIZZ'));
+       if 'TRESCA'          in list_para:
+         IMPR_TABLE(TABLE      = secinv[k],
+                    NOM_PARA   = ('INTITULE','NOEUD','TRESCA',),
+                    PAGINATION = 'INTITULE');
+#
+  if TYPE_MAILLAGE in ('FISS_COUDE','FISS_AXIS_DEB'):
+#
+#   --- post traitement fissure :  interpénétration des lèvres ----
+#
+    __tcont=POST_RELEVE_T( ACTION=_F(  INTITULE = 'Contact levres',
+                                GROUP_NO = 'FACE2',
+                                RESULTAT = nomres,
+                                TOUT_ORDRE = 'OUI',
+                                NOM_CHAM = 'VALE_CONT',
+                                NOM_CMP = 'CONT',
+                                OPERATION = 'EXTRACTION'))
+    tcont=__tcont.EXTR_TABLE()
+    numo = tcont['NUME_ORDRE'].values()['NUME_ORDRE']
+    numo=dict([(i,0) for i in numo]).keys()
+    nbinst = len(numo)
+    for i in range(1,nbinst+1) :
+      tabi = tcont.NUME_ORDRE==i
+      nbtot = len(tabi)
+      cont_actif=tabi.CONT>0.
+      nb_no_cont = len(cont_actif)
+      if nb_no_cont > 0 :
+         UTMESS('A','ASCOUF0_58',vali=[i,nbtot,nb_no_cont])
+#
+#   --- post traitement fissure :  calcul de g ----
+#
+    motscles = {}
+    if FOND_FISS != None : self.DeclareOut('fonfis',FOND_FISS)
+    if TYPE_MAILLAGE =='FISS_COUDE' :
+       motscles['FOND_FISS']=_F(GROUP_NO='FONDFISS')
+       motscles['VECT_GRNO_ORIG']= ('PFOR','THOR')
+       motscles['VECT_GRNO_EXTR']= ('PFEX','THEX')
+    else :
+       motscles['FOND_FERME']=_F(GROUP_MA='FONDFISS',
+                                 GROUP_NO_ORIG='PFOR',
+                                 GROUP_MA_ORIG='MAIL_ORI')
+    fonfis=DEFI_FOND_FISS(MAILLAGE=MAILLAGE,
+                          LEVRE_SUP=_F(GROUP_MA='FACE1'),
+                          LEVRE_INF=_F(GROUP_MA='FACE2'),
+                          INFO=INFO,**motscles
+                          );
+    if THETA_3D!=None :
+      for thet in THETA_3D:
+        _nothet=CALC_THETA(MODELE=modele,
+                           FOND_FISS=fonfis,
+                           THETA_3D=_F(TOUT   = 'OUI',
+                                       MODULE = 1.,
+                                       R_INF  = thet['R_INF'],
+                                       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',
+                        TOUT_ORDRE ='OUI',
+                        THETA      =_F(THETA=_nothet),**motscles);
+#
+        IMPR_TABLE(TABLE=_nogthe,);
+#
+      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',
+                                                    LISSAGE_G='LEGENDRE',
+                                                    DEGRE=4,)
+        elif TYPE_MAILLAGE =='FISS_AXIS_DEB' :
+                             motscles['LISSAGE']=_F(LISSAGE_THETA='LAGRANGE',
+                                                    LISSAGE_G='LAGRANGE',
+                                                    DEGRE=4,)
+        _nogloc=CALC_G (RESULTAT   =nomres,
+                        TOUT_ORDRE ='OUI',
+                        THETA=_F( FOND_FISS  =fonfis,
+                                  R_INF      = thet['R_INF'],
+                                  R_SUP      = thet['R_SUP'],),**motscles);
+
+        IMPR_TABLE(TABLE=_nogloc,);
+#
+#     --- commande IMPR_RESU  ---
+#
+  if IMPRESSION!=None:
+    mcfresu =[]
+    motscles={}
+    if IMPRESSION['FORMAT']=='IDEAS' :
+                                  motscles['VERSION'   ]= IMPRESSION['VERSION']
+    if IMPRESSION['FORMAT']=='CASTEM' :
+                                  motscles['NIVE_GIBI' ]= IMPRESSION['NIVE_GIBI']
+    mcfresu.append(_F(MAILLAGE=MAILLAGE,RESULTAT=nomres,))
+    if ECHANGE!=None:
+      motscles={}
+      if IMPRESSION['FORMAT']=='IDEAS' :
+                                    motscles['VERSION'   ]= IMPRESSION['VERSION']
+      if IMPRESSION['FORMAT']=='CASTEM' :
+                                    motscles['NIVE_GIBI' ]= IMPRESSION['NIVE_GIBI']
+      mcfresu.append(_F(RESULTAT=resuth,))
+    IMPR_RESU( MODELE = modele,
+               RESU   = mcfresu,
+               FORMAT=IMPRESSION['FORMAT'],**motscles)
+#
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macr_ascouf_mail_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ascouf_mail_ops.py
new file mode 100644 (file)
index 0000000..9305fd0
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_ascouf_mail_ops.py
@@ -0,0 +1,2632 @@
+#@ MODIF macr_ascouf_mail_ops Macro  DATE 19/11/2007   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.        
+# ======================================================================
+
+
+import os.path
+from math import sqrt,cos,sin,pi,tan,log,fabs,ceil,fmod,floor
+import string
+
+try:
+   import aster
+   from Utilitai.Utmess     import  UTMESS
+except:
+   pass
+
+# ------------------------------------------------------------------------------
+def ASCFON(RC,RM,EP,ORIEN,AZIM,AXEC,POS,Y):
+  """
+  FONCTION F(CP)=CC
+  OU CC EST LA TAILLE DE LA FISSURE SUR LE COUDE 
+  ET CP LA TAILLE DE FISSURE SUR LA PLAQUE
+  """
+  AZIMR = AZIM*2.*pi/360.
+  if POS=='DEB_INT': X = RM-EP/2.
+  else             : X = RM+EP/2.
+  if abs(ORIEN-45.0)<0.01: SIG =  1.
+  else                   : SIG = -1.
+  f_ASCFON = - SIG*X*RC/(2.*RM*sin(AZIMR)) * (                       \
+                  log ( RM/X+RM/RC*(cos(AZIMR)-                      \
+                         sin(AZIMR)*SIG*Y/(sqrt(2.)*RM)) +           \
+                        sqrt( 1.+( RM/X+RM/RC*(cos(AZIMR)-           \
+                         sin(AZIMR)*SIG*Y/(sqrt(2.)*RM)) )**2 )      \
+                       )                                             \
+                  - log ( RM/X+RM/RC*cos(AZIMR)                      \
+                       + sqrt( 1. +(RM/X+RM/RC*cos(AZIMR))**2)       \
+                                            )      )                 \
+               - SIG*X*RC/(2.*RM*SIN(AZIMR)) *                       \
+      (    ( RM/X+RM/RC* ( cos(AZIMR)-                               \
+                           sin(AZIMR)*SIG*Y/(sqrt(2.0)*RM) )         \
+                    )  * sqrt( 1. + ( RM/X+RM/RC*(cos(AZIMR)-        \
+                         sin(AZIMR)*SIG*Y/(SQRT(2.)*RM)) )**2 )      \
+                    - ( RM/X+RM/RC*COS(AZIMR) )                      \
+                       * sqrt( 1. +(RM/X+RM/RC*cos(AZIMR))**2)       \
+                                                  )                  \
+                    - 2.0*AXEC 
+  return f_ASCFON
+
+# ------------------------------------------------------------------------------
+def ASCFIS(ALPHA, RM, RC, EP, SUREP, GEOM, AXEA,
+           AXEC, AZIM, POS, SF, DSF, BETA, ORIEN):
+  """
+  MACR_ASCOUF_MAIL ASCFIS
+  taille initiale du defaut fissure sur la plaque en
+  fonction des donnees sur le coude ou le tube suivant la
+  transformation choisie
+
+  ------------DONNEES FOURNIES PAR L UTILISATEUR--------------------
+
+  ALPHA = ANGLE DU COUDE
+  RM    = RAYON MOYEN DU COUDE
+  RC    = RAYON DE CINTRAGE DU COUDE
+  EP    = EPAISSEUR DU COUDE
+  SUREP = VALEUR DE LA SUREPAISSEUR
+  GEOM  = TYPE DE GEOMETRIE MODELISEE (COUDE OU TUBE)   
+  AXEA  = PROFONDEUR FISSURE (DEMI PETIT AXE)
+  AXEC  = DEMI GRAND AXE FISSURE
+  AZIM  = POSITION AZIMUTALE DU CENTRE DE LA FISSURE 
+  POS   = POSITION EN PEAU (EXTERNE OU INTERNE)
+  SF    = ABCISSE CURVILIGNE LONGITUDINALE DU CENTRE DE LA FISSURE
+  DSF   = BOOLEEN EXPRESSION POSITION CENTRE FISSURE 
+  BETA  = POSITION ANGULAIRE DU CENTRE DE LA FISSURE
+  ORIEN = ORIENTATION DE LA FISSURE
+
+  -----------------DONNEES RENVOYEES-----------------------
+
+  AXEAP = PROFONDEUR DE LA FISSURE (PETIT AXE) SUR LA PLAQUE
+  AXECP = LONGUEUR DE LA FISSURE (GRAND AXE) SUR LA PLAQUE
+  SFP   = ABCISSE CURVILIGNE LONGITUDINALE CENTRE FISSURE
+          SUR LA PLAQUE
+
+  """
+  from Utilitai import funct_root
+  echo_mess=['MACR_ASCOUF_MAIL ASCFIS \n',]
+  if POS=='DEB_INT':
+     if (AZIM>=120.) and (AZIM<=240.0): X = RM-EP/2.0 - SUREP
+     else:                              X = RM-EP/2.0
+  else:                                 X = RM+EP/2.0
+  AZIMR = AZIM*2.0*pi/360.0 
+#
+# -- CALCUL COTE AXIALE DU CENTRE FISSURE SUR LA PLAQUE EN FONCTION
+#    DE L ABSCISSE CURVILIGNE DONNEE SUR LE COUDE OU DE LA POSITION
+#    ANGULAIRE 
+#
+  if DSF:
+    if GEOM=='COUDE': SFP = SF/(1.0+X/RC*cos(AZIMR))
+    else :            SFP = SF
+  else :
+    BETAR = BETA*2.0*pi/360.0
+    if (GEOM=='COUDE'):
+       SF  = BETAR*(RC+X*cos(AZIMR))
+       SFP = SF/(1.0+X/RC*cos(AZIMR))
+    else:
+       SF  = BETAR*RC
+       SFP = SF
+  if (GEOM=='COUDE'): echo_mess.append( 'COTE AXIALE CENTRE FISSURE SUR COUDE : %.2f \n'%SF)
+  if (GEOM=='TUBE') : echo_mess.append( 'COTE AXIALE CENTRE FISSURE SUR TUBE  : %.2f \n'%SF )
+  echo_mess.append( 'COTE AXIALE CENTRE FISSURE SUR PLAQUE : %.2f \n'%SFP)
+#
+#   ON ENVISAGE LE CAS OU UNE PARTIE DE L AXE EST DANS LES
+#   DROITES DES EMBOUTS. LA TRANSFORMATION N EST FAITE QUE SUR LA 
+#   PARTIE RESTANT DANS LE COUDE.
+#
+  if (GEOM=='COUDE'): DIST = ALPHA*2.0*pi/360.0*(RC+X*cos(AZIMR))
+  else              : DIST = ALPHA*2.0*pi/360.0*RC
+  BCOUD = 0.0
+  BEMB  = 0.0
+  if abs(ORIEN)<0.01:
+# -- FISSURE LONGITUDINALE (0 DEGRE)
+     BSUP = SF + AXEC
+     BINF = SF - AXEC
+     if BSUP>DIST:
+       BCOUD = DIST - BINF
+       BEMB  = BSUP - DIST
+     elif BINF<0. :
+       BCOUD = BSUP 
+       BEMB  = abs(BINF)
+     elif (BINF>=0. and BSUP<=DIST):
+       BCOUD = 2.0*AXEC
+  elif abs(ORIEN-90.)<0.01:
+# -- FISSURE CIRCONFERENTIELLE (90 DEGRES)
+     BSUP = SF
+     BINF = SF
+     if BSUP>DIST:
+       BCOUD = DIST - BINF
+       BEMB  = BSUP - DIST
+     elif BINF<0. :
+       BCOUD = BSUP 
+       BEMB  = abs(BINF)
+     elif (BINF>=0. and BSUP<=DIST):
+       BCOUD = 2.0*AXEC
+  else:
+# -- FISSURE A +/- 45 DEGRES SUR INTRADOS OU EXTRADOS
+     BSUP = SF + sqrt(2.0)/2.0*AXEC
+     BINF = SF - sqrt(2.0)/2.0*AXEC
+     if BSUP>DIST:
+       BCOUD = (DIST - BINF)*sqrt(2.0)
+       BEMB  = (BSUP - DIST)*sqrt(2.0)
+     elif BINF<0. :
+       BCOUD = BSUP *sqrt(2.0)
+       BEMB  = abs(BINF)*sqrt(2.0)
+     elif (BINF>=0. and BSUP<=DIST):
+       BCOUD = 2.0*AXEC
+  echo_mess.append( 'PARTIE DU GRAND AXE DANS LE COUDE  : %.2f \n'%BCOUD)
+  echo_mess.append( 'PARTIE DU GRAND AXE DANS L EMBOUT  : %.2f \n'%BEMB)
+#
+# -- CALCUL DE LA TAILLE DU GRAND AXE FISSURE SUR LA PLAQUE
+#
+  NEWT=0
+  if abs(ORIEN)<0.01:
+# -- FISSURE LONGITUDINALE (0 DEGRE)
+    if GEOM=='COUDE': AXECP = BCOUD/(1.0+X/RC*cos(AZIMR)) + BEMB
+    else            : AXECP = BCOUD + BEMB
+  elif abs(ORIEN-90.)<0.01:
+# -- FISSURE CIRCONFERENTIELLE (90 DEGRES)
+    AXECP = (BCOUD+BEMB)*RM/X
+  else :
+    if GEOM=='COUDE':
+#   ------- TRANSFORMATION COUDE
+       if AZIM in (0.,180.):
+# -- FISSURE A +/- 45 DEGRES SUR INTRADOS OU EXTRADOS
+          AXECP = BCOUD*RM*sqrt(2.)/( X*sqrt(1.+(RM/X+RM/RC*cos(AZIMR))**2) )+\
+                  BEMB*sqrt( (1.0+(X/RM)**2)*0.5 )
+       else :
+# -- FISSURE A +/- 45 DEGRES AILLEURS
+          AXECP = funct_root.root(ASCFON,(BCOUD-1.,BCOUD+1.))
+          AXECP = AXECP + BEMB*sqrt( (1.+(X/RM)**2)*0.5 )
+          AXECC = ASCFON(AXECP)+BCOUD
+          NEWT=1
+    elif GEOM=='TUBE':
+       AXECP = (BCOUD+BEMB)*sqrt( (1.+(X/RM)**2)*0.5 ) 
+    else :
+       AXECP = BCOUD + BEMB
+#
+  if GEOM=='COUDE':
+    echo_mess.append( 'TAILLE GRAND AXE COUDE DONNE : %.2f \n'%(2.*AXEC))
+  elif GEOM=='TUBE':
+    echo_mess.append( 'TAILLE GRAND AXE TUBE  DONNE : %.2f \n'%(2.*AXEC))
+  echo_mess.append( 'TAILLE GRAND AXE PLAQUE DEDUIT : %.2f \n'%AXECP)
+  if NEWT:
+    echo_mess.append( 'METHODE DE NEWTON FISSURE A 45 DEGRES --> \n')
+    echo_mess.append( 'TAILLE GRAND AXE COUDE RECALCULE : %.2f \n'%AXECC)
+  if GEOM=='COUDE' and BEMB>0. and BSUP>DIST :
+    SFP =  ALPHA*2.*pi*RC/360. - AXECP/2. + BEMB
+    echo_mess.append( 'CORRECTION CENTRE : FISSURE A CHEVAL SUR EMBOUT \n')
+    echo_mess.append( 'ABSC. CURV. AXIALE CENTRE FISSURE SUR PLAQUE : %.2f \n'%SFP)
+  if GEOM=='COUDE' and BEMB>0. and BINF<0. :
+    SFP = + AXECP/2. - BEMB
+    echo_mess.append( 'CORRECTION CENTRE : FISSURE A CHEVAL SUR EMBOUT \n')
+    echo_mess.append( 'ABSC. CURV. AXIALE CENTRE FISSURE SUR PLAQUE : %.2f \n'%SFP)
+#
+# -- CORRECTION DU PETIT AXE DE LA FISSURE QUAND CELLE-CI SE TROUVE SUR
+#    LA ZONE DE SUREPAISSEUR
+#
+  ALPHAR = ALPHA*2.*pi/360.
+  ZSUR1  = ALPHAR*RC/10.
+  ZSUR2  = ALPHAR*RC*9./10.
+  YFISS  = (AZIMR-pi/2.)*RM
+  MU = 0.
+  if (AZIM>=120.) and (AZIM<=240.):
+     if (SFP>=ZSUR1) and (SFP<=ZSUR2): MU = 1.
+     elif (SFP<=ZSUR1):                MU = SFP/ZSUR1
+     elif (SFP>ZSUR2):                 MU = (ALPHAR*RC-SFP)/ZSUR1
+  elif (AZIM>=90.) and (AZIM<=120.):
+     if (SFP>=ZSUR1) and (SFP<=ZSUR2): MU = YFISS/(pi/6.*RM) 
+     elif (SFP<=ZSUR1):                MU = YFISS*SFP/(pi/6.*RM*ZSUR1)
+     elif (SFP>ZSUR2):                 MU = YFISS*(ALPHAR*RC-SFP)/(pi/6.*RM*ZSUR1)
+  elif (AZIM>=240.) and (AZIM<=270.):
+     if (SFP>=ZSUR1) and (SFP<=ZSUR2): MU = (YFISS-5.*pi/6.*RM)/(pi/6.*RM) 
+     elif (SFP<=ZSUR1):                MU = (YFISS-5.*pi/6.*RM)*SFP/(pi/6.*RM*ZSUR1)
+     elif (SFP>ZSUR2):                 MU = (YFISS-5.*pi/6.*RM)*(ALPHAR*RC-SFP)/(pi/6.*RM*ZSUR1)
+#
+  if SUREP!=0.:
+     AXEAP = AXEA * EP / ( EP + MU*SUREP )
+     echo_mess.append( '--> CORRECTION DUE A LA SUREPAISSEUR \n' )
+     echo_mess.append( '--> TAILLE PETIT AXE PLAQUE : %.2f \n'%AXEAP )
+  else: AXEAP = AXEA
+#
+  texte_final=string.join(echo_mess)
+  aster.affiche('MESSAGE',texte_final)
+  return AXEAP,AXECP,SFP 
+
+
+# ------------------------------------------------------------------------------
+def ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP,GEOM,SYME):
+  """
+  MACR_ASCOUF_MAIL ASCSEP
+  taille initiale sur la plaque des sous-epaisseurs
+
+  ------------DONNEES FOURNIES PAR L UTILISATEUR--------------------
+
+  ALPHA = ANGLE DU COUDE
+  RM    = RAYON MOYEN DU COUDE
+  RC    = RAYON DE CINTRAGE DU COUDE
+  EP    = EPAISSEUR DU COUDE
+  GEOM  = TYPE DE GEOMETRIE MODELISEE (COUDE OU TUBE)  
+  SYME  = QUART DE STRUCTURE SI 'OUI'
+ 
+  """
+  ier=0
+  CG=pi/180.
+  echo_mess=['MACR_ASCOUF_MAIL ASCSEP \n',]
+#
+# --- BOUCLE SUR L ENSEMBLE DES SOUS-EPAISSEURS
+#
+  i=0
+  for ssep in MCL_SOUS_EPAIS :
+      i=i+1
+      echo_mess.append( '-------------------------------------\n')
+      echo_mess.append( 'SOUS-EPAISSEUR NUMERO %d\n'%i)
+      echo_mess.append( '-------------------------------------\n')
+#
+# --- CAS DES SOUS-EPAISSEURS AXISYMETRIQUES 
+#
+      if ssep['TYPE']=='AXIS':
+         echo_mess.append( 'SOUS-EPAISSEUR AXISYMETRIQUE : \n')
+         echo_mess.append( 'CALCUL DE LA TAILLE LONGI ENVELOPPE EN INTRADOS (AZIMUT PI)\n')
+         ssep.ICIRP = 2.*pi*RM
+         ssep.ISCP  =    pi*RM
+         ssep.IPHIC = 180.
+         AZIMC      = pi
+      else:
+#
+# -- CALCUL DE L ABSCISSE CURVILIGNE CIRCONF.SUR LA PLAQUE  
+#    EN FONCTION DE L AZIMUT OU DE L ABSCISSE CURVIL.CIRCONF
+#    SUR LE COUDE DU CENTRE DE LA SOUS-EPAISSEUR
+#    NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE
+#
+         if ssep['POSI_CURV_CIRC']!=None:
+           ssep.ISCP  = ssep['POSI_CURV_CIRC']*RM/(RM+EP/2.)
+           AZIMC      = ssep.ISCP/RM
+           ssep.IPHIC = ssep['POSI_CURV_CIRC']/(RM+EP/2.)*180./pi
+           echo_mess.append( 'AZIMUT CENTRE SOUS-EPAISSEUR (DEGRES) : %.2f \n'%ssep.IPHIC)
+         else:
+           ssep.ISCP  = ssep['AZIMUT']*pi*RM/180. 
+           AZIMC      = ssep['AZIMUT']*pi/180.
+           echo_mess.append( 'ABSC. CURV. CIRCONF. CENTRE SOUS-EPAISSEUR SUR COUDE : %.2f \n'%(AZIMC*(RM+EP/2.)))
+#
+#    PASSAGE DANS LE REPERE PLAQUE (0,2PI) AVEC ORIGINE FLANC DROIT
+#    CAR L ORIGINE DES DONNEES CIRCONF. EST EN EXTRADOS 
+#
+         if ssep.ISCP>(3.*pi*RM/2.): ssep.ISCP = ssep.ISCP - 3.*pi*RM/2.
+         else:                       ssep.ISCP = ssep.ISCP + pi*RM/2.
+         echo_mess.append( 'ABSC. CURV. CIRCONF. CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISCP)
+#
+# -- CALCUL DE LA TAILLE CIRCONFERENTIELLE 
+#    NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE
+#
+         ssep.ICIRP = ssep['AXE_CIRC']*(RM/(RM+EP/2.))
+         if ssep.ICIRP>(2.*pi*RM) :
+            texte_final=string.join(echo_mess)
+            aster.affiche("MESSAGE",texte_final)
+            UTMESS('F','ASCOUF0_6',vali=[i],valr=[ssep.ICIRP,2*pi*RM])
+         echo_mess.append( 'TAILLE CIRCONFERENTIELLE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ICIRP)
+         echo_mess.append( '<=> TAILLE EQUIVALENTE SUR LA CIRCONFERENCE (DEGRES) : %.2f \n'%(ssep.ICIRP*360./(2.*pi*RM)))  
+
+#
+# -- CALCUL COTE AXIALE DU CENTRE SOUS-EPAISSEUR SUR LA PLAQUE 
+#    EN FONCTION DE L ABSCISSE CURVILIGNE DONNEE SUR LE COUDE 
+#    OU DE LA POSITION ANGULAIRE
+#    NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE
+#
+      if ssep['POSI_CURV_LONGI']!=None:
+         if GEOM=='COUDE':
+            ssep.ISLP = ssep['POSI_CURV_LONGI']/(1.+(RM+EP/2.)/RC*cos(AZIMC))
+            AZIML     = ssep.ISLP/RC
+            echo_mess.append( 'ANGLE COUDE CENTRE SOUS-EPAISSEUR (DEGRES) : %.2f \n'%(AZIML*180./pi))
+         else :
+            ssep.ISLP = ssep['POSI_CURV_LONGI']
+         if (SYME in ('QUART','DEMI')) and (ssep.ISLP!=ALPHA*CG*RC/2.) :
+            texte_final=string.join(echo_mess)
+            aster.affiche("MESSAGE",texte_final)
+            UTMESS('F','ASCOUF0_7')
+      else :
+         if GEOM=='COUDE':
+            echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR COUDE : %.2f \n'%((ssep.BETA)*CG*(RC+(RM+EP/2.)*cos(AZIMC))))
+            AZIML = (ssep.BETA)*CG
+         else :
+            echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR TUBE  : %.2f \n'%((ssep.BETA)*CG*RC) )
+         ssep.ISLP =  (ssep.BETA)*CG*RC
+         if (SYME in ('QUART','DEMI')) and (ssep.BETA!=ALPHA/2.) :
+            texte_final=string.join(echo_mess)
+            aster.affiche("MESSAGE",texte_final)
+            UTMESS('F','ASCOUF0_7')
+      echo_mess.append( 'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISLP)
+#
+# -- CALCUL DE LA TAILLE LONGITUDINALE 
+#    NB : MESURE FAITE EN PEAU EXTERNE SUR LE COUDE
+#
+#   ON ENVISAGE LE CAS OU UNE PARTIE DE L AXE EST DANS LES
+#   DROITES DES EMBOUTS. LA TRANSFORMATION N EST FAITE QUE SUR LA 
+#   PARTIE RESTANT DANS LE COUDE.
+#
+      if GEOM=='COUDE' : DIST = ALPHA*CG*(RC+(RM+EP/2.)*cos(AZIMC))
+      else             : DIST = ALPHA*CG*RC
+      if ssep['POSI_CURV_LONGI']!=None:
+         BSUP = ssep['POSI_CURV_LONGI']+ssep['AXE_LONGI']/2.
+         BINF = ssep['POSI_CURV_LONGI']-ssep['AXE_LONGI']/2.
+      else:
+         if GEOM=='COUDE' :
+            BSUP = ssep.BETA*CG*(RC+(RM+EP/2.)*cos(AZIMC))+ssep['AXE_LONGI']/2.
+            BINF = ssep.BETA*CG*(RC+(RM+EP/2.)*cos(AZIMC))-ssep['AXE_LONGI']/2.
+         else:
+            BSUP = ssep.BETA*CG*RC + ssep['AXE_LONGI']/2.
+            BINF = ssep.BETA*CG*RC - ssep['AXE_LONGI']/2.
+      BCOUD1 = 0.
+      BCOUD2 = 0.
+      BEMB1  = 0.
+      BEMB2  = 0.
+      if BINF<0. and BSUP>DIST :
+         BCOUD1 = DIST
+         BEMB1  =  abs(BINF) + BSUP-DIST
+      elif BSUP>DIST :
+         BCOUD1 = DIST - BINF
+         BEMB1  = BSUP - DIST
+      elif BINF<0 :
+         BCOUD2 = BSUP
+         BEMB2  = abs(BINF)
+      elif (BINF>=0. and BSUP<=DIST) :
+         BCOUD1 = ssep['AXE_LONGI']
+      BCOUD = BCOUD1+ BCOUD2
+      BEMB  = BEMB1 + BEMB2
+      if GEOM=='COUDE' : BPLAQ = BCOUD/(1.+(RM+EP/2.)/RC*cos(AZIMC))
+      else             : BPLAQ = BCOUD
+      ssep.ILONP = BPLAQ+BEMB
+      if BEMB1>0.:
+         ssep.ISLP =  ALPHA*CG*RC - ssep.ILONP/2. + BEMB1
+         echo_mess.append(  'CORRECTION CENTRE : SOUS-EP. A CHEVAL SUR EMBOUT \n')
+         echo_mess.append(  'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISLP)
+      if BEMB2>0.:
+         ssep.ISLP =  ssep.ILONP/2. - BEMB2
+         echo_mess.append(  'CORRECTION CENTRE : SOUS-EP. A CHEVAL SUR EMBOUT \n')
+         echo_mess.append(  'ABSC. CURV. AXIALE CENTRE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ISLP)
+      if ssep.ISLP<0.            : ssep.ISLP = 0.
+      if (ssep.ISLP>ALPHA*CG*RC) : ssep.ISLP = ALPHA*CG*RC 
+#
+#     SI LE CENTRE DE LA SOUS-EP CALCULE SUR LA PLAQUE EST DANS L EMBOUT
+#     ON CORRIGE SA POSITION EN LE METTANT A L INTERFACE SINON CA PLANTE
+#     DANS LA PROC DE MAILLAGE (A AMELIORER)
+#
+      echo_mess.append(  'TAILLE LONGITUDINALE SOUS-EPAISSEUR SUR PLAQUE : %.2f \n'%ssep.ILONP)
+      echo_mess.append(  '<=> TAILLE EQUIVALENTE PAR RAPPORT A L ANGLE DU COUDE (DEGRES): %.2f \n'%(ssep.ILONP*360/(2*pi*RC)))  
+#
+  texte_final=string.join(echo_mess)
+  aster.affiche('MESSAGE',texte_final)
+  return ier,AZIMC
+
+# ------------------------------------------------------------------------------
+def ASCTCI(MCL_SOUS_EPAIS,RM):
+  """
+  MACR_ASCOUF_MAIL ASCTCI
+  APPELEE DANS : ASCSYM et ASCPRE
+  CALCUL TABLEAU TRIE DES ABSCISSES DES CENTRES DE SOUS-EPAISSEURS
+
+  ------------DONNEES FOURNIES PAR L UTILISATEUR--------------------
+
+  RM    = RAYON MOYEN DU COUDE
+
+  -----------------DONNEES RENVOYEES-----------------------
+
+  IABSC1 = CORRESPONDANCE ABSC. CURVI. CIRCONF. SOUS-EP. I
+  IABSC2 = CORRESPONDANCE ABSC. GAUCHE ET DROITE CIRCONF. SOUS-EP. I
+  COORXD = ABSC. DU BORD DROIT DE LA SOUS-EP I
+  COORXG = ABSC. DU BORD GAUCHE DE LA SOUS-EP I
+
+  """
+#
+# --- tri du tableau des abscisses curvilignes circonf. plaque
+#
+  echo_mess=['MACR_ASCOUF_MAIL ASCTCI \n',]
+  TAMPON = []
+  COORXG = []
+  COORYG = []
+  i=0
+  for ssep in MCL_SOUS_EPAIS :
+      i=i+1
+      if (ssep.ISCP>2.*pi*RM) or (ssep.ISCP<0.) : 
+         texte_final=string.join(echo_mess)
+         aster.affiche("MESSAGE",texte_final)
+         UTMESS('F','ASCOUF0_9',vali=[MCL_SOUS_EPAIS.index(ssep)],valr=[ssep.ISCP,2.*pi*RM])
+      TAMPON.append((ssep.ISCP,i))
+  TAMPON.sort()
+  IABSC1=[]
+  for j in range(i):
+    IABSC1.append(TAMPON[j][1])
+  echo_mess.append( ' \n')
+  echo_mess.append( 'TRI DES CENTRES ABSC. CURV. CIRCONF. :\n ')
+  echo_mess.append( '------------------------------------\n')
+  i=0
+  for ssep in TAMPON :
+    i=i+1
+    echo_mess.append( '%d) SOUS-EP NO %d <> XC = %.2f \n'%(i,ssep[1],ssep[0]) )
+#
+# --- calcul des abcisses droites et gauches des sous-epaisseurs
+#
+  COORXD=[]
+  COORXG=[]
+  for bid in TAMPON :
+      XG=bid[0]-MCL_SOUS_EPAIS[bid[1]-1].ICIRP/2.
+      if XG<0.       : XG=XG+2.*pi*RM
+      COORXG.append(XG)
+      XD=bid[0]+MCL_SOUS_EPAIS[bid[1]-1].ICIRP/2.
+      if XD>2.*pi*RM : XD=XD-2.*pi*RM
+      COORXD.append(XD)
+#
+# --- tri des bornes d'intervalles en abscisse
+#
+  TAMPON = []
+  for j in range(len(MCL_SOUS_EPAIS)):
+    TAMPON.append((COORXG[j],2*j+1))
+    TAMPON.append((COORXD[j],2*j+2))
+  TAMPON.sort() 
+  IABSC2=[]
+  for j in range(2*len(MCL_SOUS_EPAIS)):
+    IABSC2.append(TAMPON[j][1])
+  echo_mess.append( '\n')
+  echo_mess.append( 'TRI DES INTERVALLES G ET D ABSC. CURV. CIRCONF. :\n')
+  echo_mess.append( '-----------------------------------------------\n' ) 
+  for j in range(2*len(MCL_SOUS_EPAIS)):
+    if fmod(IABSC2[j],2):
+       echo_mess.append( '%d) SOUS-EP NO %d <> XG = %.2f \n'%(j+1,IABSC1[IABSC2[j]/2],TAMPON[j][0]))
+    else:
+       echo_mess.append( '%d) SOUS-EP NO %d <> XD = %.2f \n'%(j+1,IABSC1[IABSC2[j]/2-1],TAMPON[j][0]))
+#    
+  texte_final=string.join(echo_mess)
+  aster.affiche('MESSAGE',texte_final)
+  return TAMPON,IABSC1,IABSC2,COORXD,COORXG
+
+# ------------------------------------------------------------------------------
+def ASCTLO(MCL_SOUS_EPAIS,RC,ALPHA,LTCHAR,LTCLIM):
+  """
+  MACR_ASCOUF_MAIL ASCTLO
+  APPELEE DANS : ASCSYM et ASCPRE
+  CALCUL TABLEAU TRIE DES ORDONNEES DES CENTRES DE SOUS-EPAISSEURS
+
+  ------------DONNEES FOURNIES PAR L UTILISATEUR--------------------
+
+  RC     = RAYON MOYEN DU COUDE
+  ALPHA  = ANGLE DU COUDE
+  LTCHAR = LONGUEUR DE L'EMBOUT DU COTE CHARGEMENT
+  LTCLIM  = LONGUEUR DE L'EMBOUT DU COTE CONDITIONS AUX LIMITES
+
+  -----------------DONNEES RENVOYEES-----------------------
+
+  IORDO1 = CORRESPONDANCE ORDO. CURVI. LONGIT. SOUS-EP. I
+  IORDO2 = CORRESPONDANCE ORDO. GAUCHE ET DROITE LONGIT. SOUS-EP. I
+  COORYI = ORDONNEE. DU BORD INTERIEUR DE LA SOUS-EP I
+  COORYS = ORDONNEE. DU BORD SUPERIEUR DE LA SOUS-EP I
+
+  """
+#
+# tri du tableau des abscisses curvilignes axiales plaque
+#
+  echo_mess=['MACR_ASCOUF_MAIL ASCTLO \n',]
+  ALPHAR = 2.*ALPHA*pi/360.
+  TAMPON = []
+  i=0
+  for ssep in MCL_SOUS_EPAIS :
+      i=i+1
+      if (ssep.ISLP>ALPHAR*RC) or (ssep.ISLP<0.) : 
+         texte_final=string.join(echo_mess)
+         aster.affiche("MESSAGE",texte_final)
+         UTMESS('F','ASCOUF0_10',vali=[MCL_SOUS_EPAIS.index(ssep)],valr=[ssep.ISLP,ALPHAR*RC])
+      TAMPON.append((ssep.ISLP,i))
+  TAMPON.sort()
+  IORDO1=[]
+  for j in range(i):
+    IORDO1.append(TAMPON[j][1])
+  echo_mess.append( '\n')
+  echo_mess.append( 'TRI DES CENTRES ABSC. CURV. LONGIT. : \n')
+  echo_mess.append( '------------------------------------ \n')
+  i=0
+  for ssep in TAMPON :
+    i=i+1
+    echo_mess.append( '%d) SOUS-EP NO %d <> YC = %.2f \n'%(i,ssep[1],ssep[0]))
+#
+# calcul des abscisses sup. et inf. des sous-ep.
+#
+  COORYI=[]
+  COORYS=[]
+  EPS=0.000000000001
+  for bid in TAMPON :
+      i=i+1
+      YI=bid[0]-MCL_SOUS_EPAIS[bid[1]-1].ILONP/2.
+      YS=bid[0]+MCL_SOUS_EPAIS[bid[1]-1].ILONP/2.
+      if fabs(bid[0])<EPS : 
+         YI=-(MCL_SOUS_EPAIS[bid[1]-1]['AXE_LONGI'])/2.
+         YS=MCL_SOUS_EPAIS[bid[1]-1].ILONP-(MCL_SOUS_EPAIS[bid[1]-1]['AXE_LONGI'])/2.
+      if fabs(bid[0]-ALPHAR*RC)<EPS :
+         YI=ALPHAR*RC-(MCL_SOUS_EPAIS[bid[1]-1].ILONP-(MCL_SOUS_EPAIS[bid[1]-1]['AXE_LONGI'])/2.)
+         YS=ALPHAR*RC+(MCL_SOUS_EPAIS[bid[1]-1]['AXE_LONGI'])/2.
+      if YI<(-LTCHAR):
+         texte_final=string.join(echo_mess)
+         aster.affiche("MESSAGE",texte_final)
+         UTMESS('F','ASCOUF0_11',vali=[bid[1]],valr=[YI,-1*LTCHAR])
+      if YS>(ALPHAR*RC+LTCLIM):
+         texte_final=string.join(echo_mess)
+         aster.affiche("MESSAGE",texte_final)
+         UTMESS('F','ASCOUF0_11',vali=[bid[1]],valr=[YI,ALPHAR*RC+LTCLIM])
+      COORYI.append(YI) 
+      COORYS.append(YS)
+#
+# tri des bornes d'intervalles en abscisse
+#
+  TAMPON = []
+  for j in range(len(MCL_SOUS_EPAIS)):
+    TAMPON.append((COORYI[j],2*j+1))
+    TAMPON.append((COORYS[j],2*j+2))
+  TAMPON.sort() 
+  IORDO2=[]
+  for j in range(2*len(MCL_SOUS_EPAIS)):
+    IORDO2.append(TAMPON[j][1])      
+  echo_mess.append( '\n')
+  echo_mess.append( 'TRI DES INTERVALLES I ET S ABSC. CURV. LONGIT. : \n')
+  echo_mess.append( '----------------------------------------------- \n')
+  for j in range(2*len(MCL_SOUS_EPAIS)):
+    if fmod(IORDO2[j],2):
+       echo_mess.append( '%d) SOUS-EP NO %d <> YI = %.2f \n'%(j+1,IORDO1[IORDO2[j]/2],TAMPON[j][0]))
+    else:
+       echo_mess.append( '%d) SOUS-EP NO %d <> YS = %.2f \n'%(j+1,IORDO1[IORDO2[j]/2-1],TAMPON[j][0]))
+#
+  texte_final=string.join(echo_mess)
+  aster.affiche('MESSAGE',texte_final)
+  return TAMPON,IORDO1,IORDO2,COORYI,COORYS
+#
+#
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL ASCNBE
+#     APPELEE DANS : ASCSYM et ASCPRE
+#     CALCUL DU NOMBRE D'ELEMENTS LONGI ET CIRCONF. DANS LES SOUS-EPAISSEURS
+#
+#-----------------DONNEES FOURNIES PAR L UTILISATEUR--------------------
+#
+#     COORXG = ABSCISSE DU BORD GAUCHE DE LA SOUS-EPAISSEUR I
+#     COORXD = ABSCISSE DU BORD DROIT DE LA SOUS-EPAISSEUR I
+#     COORYI = ORDONNEE DU BORD INFERIEUR DE LA SOUS-EPAISSEUR I
+#     COORYS = ORDONNEE DU BORD SUPERIEUR DE LA SOUS-EPAISSEUR I
+#     BD     = ABSCISSE DU BORD DROIT DE LA ZONE CIRCONF J
+#     BG     = ABSCISSE DU BORD GAUCHE DE LA ZONE CIRCONF J
+#     BS     = ORDONNEE DU BORD SUPERIEUR DE LA ZONE LONGI J
+#     BI     = ORDONNEE DU BORD INFERIEUR DE LA ZONE LONGI J
+#     DNX    = DENSITE ET NOMBRE D'ELEMENTS CIRCONF. DE LA ZONE J
+#     DNY    = DENSITE ET NOMBRE D'ELEMENTS LONGIT. DE LA ZONE J
+#     INDSEX = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE CIRCONF J
+#     INDSEY = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE LONGI J
+#     RM     = RAYON MOYEN DU COUDE
+#     RC     = RAYON DE CINTRAGE DU COUDE
+#     IABSC1 = CORRESPONDANCE ABSCISSE CURVILIGNE CIRCONF. SOUS-EP. I
+#     IORDO1 = CORRESPONDANCE ABSCISSE CURVILIGNE LONGIT. SOUS-EP. I
+#
+#----------------------DONNEES RENVOYEES-----------------------
+#
+#     NLX = NOMBRE TOTAL D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR K
+#     NLY = NOMBRE TOTAL D'ELEMENTS LONGIT. DE LA SOUS-EPAISSEUR K
+#
+# ------------------------------------------------------------------------------
+def ASCNBE(MCL_SOUS_EPAIS,COORXG,COORXD,COORYI,COORYS,BD,BG,BS,BI,DNX,DNY,RM,RC,
+           INDSEX,INDSEY,IABSC1,IORDO1):
+#
+#  calcul du nombre d'elements longi. et circonf. dans les sous-epaisseurs:
+#
+  echo_mess=['MACR_ASCOUF_MAIL ASCNBE \n',]
+  echo_mess.append( '\n')
+  echo_mess.append( 'DETERMINATION DU NOMBRE D''ELEMENTS DANS LES SOUS-EPAISSEURS :\n')
+  echo_mess.append( '------------------------------------------------------------\n')
+  NLX=[0]*len(MCL_SOUS_EPAIS)
+  NLY=[0]*len(MCL_SOUS_EPAIS)
+  for j in range(len(BD)):
+    if INDSEX[j]!=0:
+#      calcul au passage du nombre d'elements sur chaque zone circonf.   
+       RNBEL = (BD[j]-BG[j])*360./(DNX[2*j]*2.*pi*RM)
+       RNBEL2 = RNBEL - floor(RNBEL)
+       if RNBEL2 <= 0.5 : NBEL=int(floor(RNBEL))
+       else             : NBEL=int(floor(RNBEL))+1
+       if NBEL <= 1 :     NBEL=2
+#      calcul au passage du nombre d'elements sur chaque sous-epaisseur circonf.       
+       for i in range(len(MCL_SOUS_EPAIS)):
+         l=IABSC1[i]-1
+         if ((COORXG[l]<COORXD[l] and BG[j]>=COORXG[l] and BD[j]<=COORXD[l])\
+         or (COORXG[l]>=COORXD[l] and (BG[j]<=COORXG[l] or BD[j]>=COORXD[l]))):
+            NLX[i]=NLX[i]+NBEL
+            echo_mess.append( 'SOUS-EP NO %d ZONE CIRC. NO %d NB ELEM. = %d \n'%(i+1,j+1,NBEL))
+
+  for j in range(len(BS)):
+    if INDSEY[j]!=0:
+#      calcul au passage du nombre d'elements sur chaque zone longi.      
+       RNBEL = ((BS[j]-BI[j])*360.)/(DNY[2*j]*2.*pi*RC)
+       RNBEL2 = RNBEL - floor(RNBEL)
+       if RNBEL2 <= 0.5 : NBEL=int(floor(RNBEL))
+       else             : NBEL=int(floor(RNBEL))+1
+       if NBEL <= 1 :     NBEL=2
+#      calcul au passage du nombre d'elements sur chaque sous-epaisseur circonf.       
+       i=0
+       for i in range(len(MCL_SOUS_EPAIS)):
+         l=IORDO1[i]-1
+         if (BI[j]>=COORYI[l] and BS[j]<=COORYS[l]):
+            NLY[i]=NLY[i]+NBEL
+            echo_mess.append( 'SOUS-EP NO %d ZONE LONGI. NO %d NB ELEM. = %d \n'%(i+1,j+1,NBEL) )
+
+  for j in range(len(NLX)):
+    echo_mess.append( 'SOUS-EP NO %d NBE TOTAL ELEMENTS CIRCONF. : %d \n'%(j+1,NLX[j]))
+    echo_mess.append( 'SOUS-EP NO %d NBE TOTAL ELEMENTS LONGI.   : %d \n'%(j+1,NLY[j]))
+
+#
+  texte_final=string.join(echo_mess)
+  aster.affiche('MESSAGE',texte_final)
+  return NLX,NLY
+#
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL ASCSYM
+#     PREPARATION DES DONNEES POUR LE MAILLAGE DE PLAQUE AVEC
+#     SOUS-EPAISSEURS :
+#     CAS D UNE SOUS-EPAISSEUR DANS LE PLAN DE SYMETRIE 
+#     CONSTRUCTION D UN QUART DU MAILLAGE
+#     - CALCUL TABLEAU TRIE DES ABSCISSES ET ORDONNEES DES CENTRES 
+#     - CALCUL TABLEAU DES ZONES COUVERTES PAR LES SOUS-EPAISSEURS
+#
+#-----------------DONNEES FOURNIES PAR L UTILISATEUR--------------------
+#
+#     RM    = RAYON MOYEN DU COUDE
+#     RC    = RAYON DE CINTRAGE DU COUDE
+#     ALPHA = ANGLE DU COUDE
+#     LT    = LONGUEUR DE L EMBOUT DU COTE CHARGEMENT
+#     LGV   = LONGUEUR DE L EMBOUT DU COTE CONDITIONS AUX LIMITES
+#     NBSEP = NOMBRE DE SOUS-EPAISSEURS
+#
+#----------------------DONNEES RENVOYEES-----------------------
+#
+#     NZONEX = NOMBRE DE ZONES CIRCONFERENTIELLES
+#     NZONEY = NOMBRE DE ZONES LONGITUDINALES       
+#
+# ------------------------------------------------------------------------------
+def ASCSYM(MCL_SOUS_EPAIS,RM,RC,ALPHA,LTCHAR,LTCLIM):
+  ier=0
+  echo_mess=['MACR_ASCOUF_MAIL ASCSYM \n',]
+  DERAFC = 18.
+  DERAFL =  5.       
+  INDSEX = []
+  INDSEY = []
+  BG     = []
+  BD     = []
+  INDBG  = []
+  INDBD  = []
+  DNX    = []
+
+#
+# --- tri des donnees sous-ep. en circonferentiel
+  TAMPON,IABSC1,IABSC2,COORXD,COORXG=ASCTCI(MCL_SOUS_EPAIS,RM)
+#
+# --- calcul des zones en circonferentiel
+#
+  ssep=MCL_SOUS_EPAIS[0]
+  if (ssep.ISCP<pi*RM) :
+#
+#     le centre sous-ep est dans la zone flanc droit/extrados/flanc
+#     gauche, on preleve pi*RM a droite de la sous-epaisseur
+#
+#          zone (centre sous-ep , bord droit)
+#
+     BG.append(ssep.ISCP)
+     BG.append(ssep.ISCP+ssep.ICIRP/2.)
+     BD.append(ssep.ISCP+ssep.ICIRP/2.)
+     BD.append(ssep.ISCP+pi*RM)
+     INDBG.append(0)
+     INDBG.append(1)
+     INDBD.append(0)
+     INDBD.append(0)
+     DNX.append(ssep.IDENC)
+     DNX.append(0)
+     DNX.append(DERAFC)
+     DNX.append(0)
+     INDSEX.append(1)
+     INDSEX.append(0)
+  elif (ssep.ISCP+pi*RM==2.*pi*RM) :
+#
+#     sous-ep axisymetrique : on preleve pi*RM a droite
+#
+#       zone (centre sous-ep , bord droit)
+#
+     BG.append(ssep.ISCP)
+     BD.append(ssep.ISCP+ssep.ICIRP/2.)
+     INDBG.append(0)
+     INDBD.append(0)
+     DNX.append(ssep.IDENC)
+     DNX.append(0)
+     INDSEX.append(1)
+     INDSEX.append(0)
+  else :
+#
+#     le centre sous-ep est dans la zone flanc gauche/intrados/flanc 
+#     droit : on preleve pi*RM a gauche de la sous-epaisseur
+#
+#            zone (centre -pi*RM, bord gauche)
+#
+     BG.append(ssep.ISCP-pi*RM)
+     BG.append(ssep.ISCP-ssep.ICIRP/2.)
+     BD.append(ssep.ISCP-ssep.ICIRP/2.)
+     BD.append(ssep.ISCP)
+     INDBG.append(0)
+     INDBG.append(0)
+     INDBD.append(1)
+     INDBD.append(0)
+     DNX.append(DERAFC)
+     DNX.append(0)
+     DNX.append(ssep.IDENC)
+     DNX.append(0)     
+     INDSEX.append(0)
+     INDSEX.append(1)
+
+
+  echo_mess.append( '\n')
+  echo_mess.append( 'ZONES APRES RECOUVREMENT ABSC. CURV. CIRCONF. :\n')
+  echo_mess.append( '--------------------------------------------- \n')
+  EPS=0.000000000001
+  NZONEX=len(BG)
+  for j in range(NZONEX) :
+    if ( fabs(BG[j]) < EPS ) and ( fabs(BD[j]) < EPS ) :
+      echo_mess.append( 'ZONE NO %d BORNE GAUCHE = %.2f'\
+      ' / BORNE DROITE = %.2f * SOUS-EPAISSEUR \n'%(j+1,BG[j],BD[j]) )
+    else:
+      echo_mess.append( 'ZONE NO %d BORNE GAUCHE = %.2f \n'\
+      ' / BORNE DROITE = %.2f \n'%(j+1,BG[j],BD[j]))
+
+    
+# tri des donnees sous-epaisseurs en axial
+  TAMPON,IORDO1,IORDO2,COORYI,COORYS=ASCTLO(MCL_SOUS_EPAIS,RC,ALPHA,LTCHAR,LTCLIM)
+
+# calcul des zones en axial:
+  BI     = []
+  BS     = []
+  INDBI  = []
+  INDBS  = []
+  DNY    = []
+  INDSEY = []
+  ssep   = MCL_SOUS_EPAIS[0]
+  BI.append(0.)
+  BI.append(ssep.ISLP-ssep.ILONP/2.)
+  BS.append(ssep.ISLP-ssep.ILONP/2.)
+  BS.append(ssep.ISLP)
+  INDBI.append(0)  
+  INDBI.append(0)
+  INDBS.append(1)
+  INDBS.append(0)
+  DNY.append(DERAFL)
+  DNY.append(0)
+  DNY.append(ssep.IDENL)
+  DNY.append(0)
+  INDSEY.append(0)
+  INDSEY.append(1)
+  echo_mess.append( '\n')
+  echo_mess.append( 'ZONES APRES RECOUVREMENT ABSC. CURV. LONGIT. : \n')
+  echo_mess.append( '----------------------------------------------- \n')
+  NZONEY=len(BI)
+  for j in range(NZONEY) :
+    if ( fabs(BI[j]) < EPS ) and ( fabs(BS[j]) < EPS ) :
+      echo_mess.append( 'ZONE NO %d <> BORNE INF. = %.2f \n'\
+      ' / BORNE SUP. = %.2f * SOUS-EPAISSEUR'%(j+1,BI[j],BS[j]))
+    else:
+      echo_mess.append( 'ZONE NO %d <> BORNE INF. = %.2f \n'\
+      ' / BORNE SUP. = %.2f'%(j+1,BI[j],BS[j]))
+ 
+# calcul du nombre d'elements longi. et circonf. dans les soue-ep
+  NLX,NLY=ASCNBE(MCL_SOUS_EPAIS,COORXG,COORXD,COORYI,COORYS,BD,BG,BS,BI,
+                 DNX,DNY,RM,RC,INDSEX,INDSEY,IABSC1,IORDO1)
+
+  texte_final=string.join(echo_mess)
+  aster.affiche('MESSAGE',texte_final)
+  return ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY
+################################################################################
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL ASCPRE
+#     PREPARATION DES DONNEES POUR LE MAILLAGE DE PLAQUE 
+#     SOUS-EPAISSEURS :
+#     - CALCUL TABLEAU TRIE DES ABSCISSES ET ORDONNEES DES CENTRES 
+#     - CALCUL TABLEAU DES ZONES COUVERTES PAR LES SOUS-EPAISSEURS
+#
+#-----------------DONNEES FOURNIES PAR L UTILISATEUR--------------------
+#
+#     RM    = RAYON MOYEN DU COUDE
+#     RC    = RAYON DE CINTRAGE DU COUDE
+#     ALPHA = ANGLE DU COUDE
+#     LT    = LONGUEUR DE L EMBOUT DU COTE CHARGEMENT
+#     LGV   = LONGUEUR DE L EMBOUT DU COTE CONDITIONS AUX LIMITES
+#     NBSEP = NOMBRE DE SOUS-EPAISSEURS
+#     SYME  = "QUART" DE STRUCTURE, "DEMI" STRUCTURE OU BIEN "ENTIER"
+#
+#----------------------DONNEES RENVOYEES-----------------------
+#
+#     NZONEX = NOMBRE DE ZONES CIRCONFERENTIELLES
+#     NZONEY = NOMBRE DE ZONES LONGITUDINALES       
+# ------------------------------------------------------------------------------
+def ASCPRE(MCL_SOUS_EPAIS,RM,RC,ALPHA,SYME,LTCHAR,LTCLIM):
+  ier=0
+  echo_mess=['MACR_ASCOUF_MAIL ASCPRE \n',]
+  ALPHAR = 2.*ALPHA*pi/360.
+  DERAFC = 18.
+  DERAFL =  5.
+  EPSI   =  0.001      
+  NBSEP  = len(MCL_SOUS_EPAIS)
+  echo_mess.append( 'RECHERCHE DES ZONES DE SOUS-EPAISSEURS DANS LE COUDE\n' )
+  
+# tri des donnees sous-epaisseurs en circonferentiel
+  TAMPON,IABSC1,IABSC2,COORXD,COORXG=ASCTCI(MCL_SOUS_EPAIS,RM)
+# --- calcul des recouvrements de zones en circonferentiel
+#
+  NZONEX=0
+  j=0
+  ICE=1
+  NBGAU=0
+  NBDRO=0
+  TYPG=0
+  TYPD=0
+  go10=1
+  go20=1
+#
+  BG    =[]
+  BD    =[]
+  INDBG =[]
+  INDBD =[]
+  DNX   =[]
+  INDSEX=[]
+#
+  
+  while go10:
+   
+    j=j+1      
+#
+#   definition de la zone courante (borne gauche, borne droite)
+#    
+#   TYPG = type de la borne:
+#          0 : borne gauche sous-epaisseur
+#          1 : borne droite sous-epaisseur
+#          2 : centre sous-epaisseur
+#
+    if j>2*NBSEP and ICE<NBSEP :
+#     cas ou il ne reste plus que des centres a caser
+      MING = MIND
+      TYPG = TYPD
+      NUMG = NUMD
+      MIND = 2.*pi*RM+1
+    elif TYPD==2 :
+#     cas ou la borne droite de la zone precedente etait un centre
+      MING = MIND
+      TYPG = TYPD
+      NUMG = NUMD
+      MIND = TAMPON[j-1][0]
+      if fmod(IABSC2[j-1],2):
+        TYPD = 0
+        NUMD = IABSC1[IABSC2[j-1]/2]
+      else:
+        TYPD = 1
+        NUMD = IABSC1[IABSC2[j-1]/2-1]
+      j=j-1
+    else:
+      if j>= 2*NBSEP :
+        MIND = TAMPON[2*NBSEP-1][0]
+        MING = MIND
+        if fmod(IABSC2[2*NBSEP-1],2):
+          TYPG = 0
+          NUMG = IABSC1[IABSC2[2*NBSEP-1]/2]
+        else:
+          TYPG = 1
+          NUMG = IABSC1[IABSC2[2*NBSEP-1]/2-1]
+        TYPD=TYPG
+        NUMD=NUMG
+      else:
+        MING=TAMPON[j-1][0]
+        MIND=TAMPON[j][0]
+        if fmod(IABSC2[j-1],2):
+          TYPG = 0
+          NUMG = IABSC1[IABSC2[j-1]/2]
+        else:
+          TYPG = 1
+          NUMG = IABSC1[IABSC2[j-1]/2-1]
+        if fmod(IABSC2[j],2):
+          TYPD = 0
+          NUMD = IABSC1[IABSC2[j]/2]
+        else:
+          TYPD = 1
+          NUMD = IABSC1[IABSC2[j]/2-1]
+    if fabs(MING-MIND)<EPSI : 
+      if j==2*NBSEP:break
+      else:continue
+    if j>2*NBSEP and ICE>=NBSEP: 
+        break #on sort de la boucle
+
+    while go20:
+      i=ICE
+      if i<=NBSEP:
+#       recherche des centres a intercaler
+        INDC=IABSC1[i-1]
+        if i>1:
+#         le centre est deja le meme que precedent
+          if fabs(MCL_SOUS_EPAIS[INDC-1].ISCP-MCL_SOUS_EPAIS[IABSC1[i-2]-1].ISCP) < EPSI :
+            ICE=ICE+1
+            continue
+        if MCL_SOUS_EPAIS[INDC-1].ISCP < MING :
+#          le centre est la nouvelle borne gauche
+           j=j-1
+           MIND = MING
+           TYPD = TYPG
+           NUMD = NUMG
+           MING = MCL_SOUS_EPAIS[INDC-1].ISCP
+           TYPG = 2
+           NUMG = INDC
+           ICE = ICE+1
+        elif MCL_SOUS_EPAIS[INDC-1].ISCP < MIND : 
+#          le centre est la nouvelle borne droite  
+           MIND = MCL_SOUS_EPAIS[INDC-1].ISCP
+           TYPD = 2
+           NUMD = INDC
+           ICE = ICE+1
+           continue
+        else:pass
+      NZONEX=NZONEX+1
+#    
+#     codes d'intervalles de zones
+#        0 0 = zone sous-ep.
+#        0 1 = sous-ep. a droite de la zone
+#        1 0 = sous-ep. a gauche de la zone
+#        1 1 = sous-ep. a droite et a gauche de la zone  
+#
+#     cas ou la premiere zone ne commence pas au bord de la plaque
+      if MING>0. and NZONEX==1 :
+        BG.append(0.)
+        BD.append(MING)
+        if TYPG==0:
+           INDBG.append(0)
+           INDBD.append(1)
+           DNX.append(DERAFC)
+           DNX.append(0)
+           INDSEX.append(0)
+        elif TYPG==1 or TYPG==2:
+           INDBG.append(0)
+           INDBD.append(0)
+           DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC)
+           DNX.append(0)
+           INDSEX.append(NUMG)
+        else: pass
+        NZONEX=NZONEX+1
+#
+      BG.append(MING)
+      BD.append(MIND)  
+#
+      if TYPG == 0:
+#       borne gauche zone = borne gauche ssep       
+        NBGAU=NBGAU+1
+        INDBG.append(0)
+        INDBD.append(0)
+        if TYPD == 0:
+#         borne droite zone = borne gauche ssep
+          DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC)
+          DNX.append(0)
+          INDSEX.append(NUMG)
+        elif TYPD == 1 or TYPD == 2:
+#         borne droite zone = borne droite ssep : TYPD=1
+#         borne droite zone = centre ssep : TYPD=2
+          LTMP=[]
+          LTMP.append((MCL_SOUS_EPAIS[NUMG-1].IDENC,NUMG))
+          LTMP.append((MCL_SOUS_EPAIS[NUMD-1].IDENC,NUMD))
+          LTMP.sort()
+          DNX.append(LTMP[0][0])
+          DNX.append(0)
+          INDSEX.append(LTMP[0][1])
+        else: pass
+#
+      elif TYPG == 1:
+#       borne gauche zone = borne droite ssep  
+        NBDRO = NBDRO+1  
+        if TYPD == 0:
+#         borne droite zone = borne gauche ssep
+          if NBDRO==NBGAU:
+            INDBG.append(1)
+            INDBD.append(1)
+            DNX.append(DERAFC)
+            DNX.append(0)
+            INDSEX.append(0)
+          else:
+#           cas tordu: une sous-ep enveloppe le tout
+            INDBG.append(0)
+            INDBD.append(0)
+            DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC)
+            DNX.append(0)    
+            INDSEX.append(NUMG)
+        elif TYPD == 1 or TYPD == 2:
+#         borne droite zone = borne droite ssep : TYPD=1
+#         borne droite zone = centre ssep : TYPD=2
+          INDBG.append(0)
+          INDBD.append(0)
+          DNX.append(MCL_SOUS_EPAIS[NUMD-1].IDENC)
+          DNX.append(0)
+          INDSEX.append(NUMD)  
+        else: pass
+#                
+      elif TYPG == 2:
+#       borne gauche zone = centre ssep  
+        INDBG.append(0)
+        INDBD.append(0)
+        if TYPD == 0:
+#         borne droite zone = borne gauche ssep
+          DNX.append(MCL_SOUS_EPAIS[NUMG-1].IDENC)
+          DNX.append(0)
+          INDSEX.append(NUMG)  
+        elif TYPD == 1 or TYPD == 2:
+#         borne droite zone = borne droite ssep : TYPD=1
+#         borne droite zone = centre ssep : TYPD=2
+          LTMP=[]
+          LTMP.append((MCL_SOUS_EPAIS[NUMG-1].IDENC,NUMG))
+          LTMP.append((MCL_SOUS_EPAIS[NUMD-1].IDENC,NUMD))
+          LTMP.sort()
+          DNX.append(LTMP[0][0])
+          DNX.append(0)
+          INDSEX.append(LTMP[0][1])
+        else:pass
+      else:pass
+      if j<=(2*NBSEP-2) or ICE<=NBSEP or (TYPD==2 and j<2*NBSEP):
+         iout=0       
+         break #on retourne dans la boucle go10
+      else :
+         iout=1
+         break #on sort definitivement 
+    if iout:break
+      
+  if MIND<2.*pi*RM:
+    NZONEX=NZONEX+1
+    BG.append(MIND)
+    BD.append(2.*pi*RM)
+    if TYPD==0 or TYPD==2:
+      INDBG.append(0)
+      INDBD.append(0)
+      DNX.append(MCL_SOUS_EPAIS[NUMD-1].IDENC)
+      DNX.append(0)
+      INDSEX.append(NUMD)
+    elif TYPD==1:
+      INDBG.append(1)
+      INDBD.append(0)
+      DNX.append(DERAFC)
+      DNX.append(0)
+      INDSEX.append(0)
+    else:pass
+
+# au cas ou 2.*pi*RM correspond a une borne d'intevalle de sous-ep ou a
+#  un centre de sous-ep.
+  if fabs(BG[NZONEX-1]-BD[NZONEX-1])<EPSI: NZONEX = NZONEX-1
+
+  echo_mess.append( '\n')
+  echo_mess.append( 'ZONES APRES RECOUVREMENT ABSC. CURV. CIRCONF. : \n')
+  echo_mess.append( '----------------------------------------------- \n')
+  for j in range(NZONEX) :
+    if INDBG[j]==0 and INDBD[j]==0 :
+      echo_mess.append( 'ZONE NO %d <> BORNE GAUCHE = %.2f \n'\
+      ' / BORNE DROITE = %.2f * SOUS-EPAISSEUR'%(j+1,BG[j],BD[j]))
+    else:
+      echo_mess.append( 'ZONE NO %d <> BORNE GAUCHE = %.2f \n'\
+      ' / BORNE DROITE = %.2f'%(j+1,BG[j],BD[j]))
+
+      
+# --- tri des donnees sous-ep. en axial
+  TAMPON,IORDO1,IORDO2,COORYI,COORYS=ASCTLO(MCL_SOUS_EPAIS,RC,ALPHA,LTCHAR,LTCLIM)
+
+  BI     = []
+  BS     = []
+  INDBI  = []
+  INDBS  = []
+  DNY    = []
+  INDSEY = []
+
+  if SYME == 'DEMI':
+#   calcul des zones en axial :
+#   zones  (0,bord inferieur) et (bord inferieur,centre sous-ep.) 
+    ssep   = MCL_SOUS_EPAIS[0]
+    BI.append(0.)
+    BI.append(ssep.ISLP-ssep.ILONP/2.)
+    BS.append(ssep.ISLP-ssep.ILONP/2.)
+    BS.append(ssep.ISLP)
+    INDBI.append(0)  
+    INDBI.append(0)
+    INDBS.append(1)
+    INDBS.append(0)
+    DNY.append(DERAFL)
+    DNY.append(0)
+    DNY.append(ssep.IDENL)
+    DNY.append(0)
+    INDSEY.append(0)
+    INDSEY.append(1)
+    NZONEY=1
+#     
+  else:
+#
+#   calcul des recouvrements de zones en axial  
+    j = 0
+    ICE = 1
+    NBINF = 0
+    NBSUP = 0
+    TYPI=0
+    TYPS=0
+    go40=1
+    go50=1
+    NZONEY=0
+#
+    while go40:
+      j=j+1      
+#
+#     definition de la zone courante (borne inf, borne sup)
+#
+#     typi = type de la borne
+#            0 : borne inf. sous-ep.
+#            1 : borne sup. sous-ep.
+#            2 : centre sous-ep.   
+#
+      if TYPS==2:
+#       cas ou la borne sup. de la zone prec. etait un centre
+        MINI=MINS
+        TYPI=TYPS
+        NUMI=NUMS
+        MINS=TAMPON[j-1][0]
+        if fmod(IORDO2[j-1],2):
+          TYPS = 0
+          NUMS = IORDO1[IORDO2[j-1]/2]
+        else:
+          TYPS = 1
+          NUMS = IORDO1[IORDO2[j-1]/2-1]
+        j=j-1
+      else:
+        if j>= 2*NBSEP :
+          MINI = TAMPON[2*NBSEP-1][0]
+          MINS = MINI
+          if fmod(IORDO2[2*NBSEP-1],2):
+            TYPI = 0
+            NUMI = IORDO1[IORDO2[2*NBSEP-1]/2]
+          else:
+            TYPI = 1
+            NUMI = IORDO1[IORDO2[2*NBSEP-1]/2-1]
+          TYPS=TYPI
+          NUMS=NUMI
+        else:
+          MINI=TAMPON[j-1][0]
+          MINS=TAMPON[j][0]
+          if fmod(IORDO2[j-1],2):
+            TYPI = 0
+            NUMI = IORDO1[IORDO2[j-1]/2]
+          else:
+            TYPI = 1
+            NUMI = IORDO1[IORDO2[j-1]/2-1]
+          if fmod(IORDO2[j],2):
+            TYPS = 0
+            NUMS = IORDO1[IORDO2[j]/2]
+          else:
+            TYPS = 1
+            NUMS = IORDO1[IORDO2[j]/2-1]
+      if fabs(MINI-MINS)<EPSI:
+        if j==2*NBSEP:break
+        else:continue
+
+      while go50:
+        i=ICE
+        if i<=NBSEP:
+#         recherche des centres a intercaler
+          INDC=IORDO1[i-1]
+          if i>1:
+#           le centre est deja le meme que le precedent
+            if fabs(MCL_SOUS_EPAIS[INDC-1].ISLP-MCL_SOUS_EPAIS[IORDO1[i-2]-1].ISLP)<EPSI:
+             ICE=ICE+1  
+             continue
+          if MCL_SOUS_EPAIS[INDC-1].ISLP<MINI:
+#            le centre est la nouvelle borne inf.
+             j=j-1
+             MINS = MINI
+             TYPS = TYPI
+             NUMS = NUMI
+             MINI = MCL_SOUS_EPAIS[INDC-1].ISLP
+             TYPI = 2
+             NUMI = INDC
+             ICE = ICE+1
+          elif MCL_SOUS_EPAIS[INDC-1].ISLP<MINS:
+#            le centre est la nouvelle borne sup.
+            MINS = MCL_SOUS_EPAIS[INDC-1].ISLP
+            TYPS = 2
+            NUMS = INDC
+            ICE = ICE+1
+            continue
+          else:pass
+        NZONEY=NZONEY+1
+#       
+#       code d'intervalles de zone
+#       0 0  = ZONE SOUS-EPAISSEUR
+#       0 1  = SOUS-EPAISSEUR A SUPERIEURE DE LA ZONE
+#       1 0  = SOUS-EPAISSEUR A INFERIEURE DE LA ZONE
+#       1 1  = SOUS EPAISSEUR A SUPERIEURE ET A INFERIEURE DE LA ZONE
+#
+#       cas ou la premiere zone ne commence pas au bord de la plaque
+        if MINI>0. and NZONEY==1:
+          first=0
+          BI.append(0.)
+          BS.append(MINI)
+          if TYPI==0:
+            INDBI.append(0)
+            INDBS.append(1)
+            DNY.append(DERAFL)
+            DNY.append(0)
+            INDSEY.append(0)
+          elif TYPI==1 or TYPI==2:
+            INDBI.append(0)
+            INDBS.append(0)
+            DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL)
+            DNY.append(0)
+            INDSEY.append(NUMI)
+          else:pass
+          NZONEY = NZONEY+1
+#
+        BI.append(MINI)
+        BS.append(MINS)
+
+        if TYPI==0:
+#         borne inferieure zone = borne inferieure ssep
+          NBINF = NBINF+1
+          INDBI.append(0)
+          INDBS.append(0)
+          if TYPS==0:
+#           borne superieure zone = borne inferieur ssep
+            DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL)
+            DNY.append(0)
+            INDSEY.append(NUMI)
+          elif TYPS==1 or TYPS==2:
+#           borne superieure zone = borne superieure ssep:TYPS==1
+#           borne superieure zone = centre ssep:TYPS==2
+            LTMP=[]
+            LTMP.append((MCL_SOUS_EPAIS[NUMI-1].IDENL,NUMI))
+            LTMP.append((MCL_SOUS_EPAIS[NUMS-1].IDENL,NUMS))
+            LTMP.sort()
+            DNY.append(LTMP[0][0])
+            DNY.append(0)
+            INDSEY.append(LTMP[0][1])
+          else:pass
+        elif TYPI==1:  
+#         borne inferieure zone=borne superieure ssep
+          NBSUP = NBSUP+1
+          if TYPS==0:
+#           borne superieure zone = borne inferieur ssep
+            if NBSUP==NBINF:
+              INDBI.append(1)
+              INDBS.append(1)        
+              DNY.append(DERAFL)
+              DNY.append(0)
+              INDSEY.append(0)
+            else:
+#             cas tordu: une sous-ep. enveloppe le tout
+              INDBI.append(0)
+              INDBS.append(0)        
+              DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL)
+              DNY.append(0)
+              INDSEY.append(NUMI)
+          elif TYPS==1 or TYPS==2:
+#           borne superieure zone = borne superieure ssep:TYPS==1
+#           borne superieure zone = centre ssep:TYPS==2
+            INDBI.append(0)
+            INDBS.append(0)        
+            DNY.append(MCL_SOUS_EPAIS[NUMS-1].IDENL)
+            DNY.append(0)
+            INDSEY.append(NUMS)
+          else:pass
+        elif TYPI==2:
+#         borne inferieure zone = centre ssep  
+          INDBI.append(0)
+          INDBS.append(0)        
+          if TYPS==0:
+#           borne superieure zone = borne inferieure ssep
+            DNY.append(MCL_SOUS_EPAIS[NUMI-1].IDENL)
+            DNY.append(0)
+            INDSEY.append(NUMI)
+          elif TYPS==1 or TYPS==2:
+#           borne superieure zone = borne superieure ssep
+            LTMP=[]
+            LTMP.append((MCL_SOUS_EPAIS[NUMI-1].IDENL,NUMI))
+            LTMP.append((MCL_SOUS_EPAIS[NUMS-1].IDENL,NUMS))
+            LTMP.sort()
+            DNY.append(LTMP[0][0])
+            DNY.append(0)
+            INDSEY.append(LTMP[0][1])
+          else:pass
+        else:pass
+        if j<=(2*NBSEP-2) or TYPS==2:
+          iout=0  
+          break #on retourne dans la boucle go40
+        else:
+          iout=1
+          break #on sort definitivement 
+      if iout:break
+
+#   cas ou la derniere zone ne finit pas au bout de la plaque    
+    if MINS<ALPHAR*RC:
+       NZONEY=NZONEY+1
+       BI.append(MINS)
+       BS.append(ALPHAR*RC) 
+       if TYPS==0 or TYPS==2:
+          INDBI.append(0)
+          INDBS.append(0)        
+          DNY.append(MCL_SOUS_EPAIS[NUMS-1].IDENL)
+          DNY.append(0)
+          INDSEY.append(NUMS)
+       elif TYPS==1:
+          INDBI.append(1)
+          INDBS.append(0)        
+          DNY.append(DERAFL)
+          DNY.append(0)
+          INDSEY.append(0)
+       else:pass
+
+    echo_mess.append( '\n')
+    echo_mess.append( 'ZONES APRES RECOUVREMENT ABSC. CURV. LONGIT. :\n')
+    echo_mess.append( '----------------------------------------------- \n')
+
+    for j in range(NZONEY) :
+      if INDBI[j]==0 and INDBS[j]==0 :
+        echo_mess.append( 'ZONE NO %d <> BORNE INF. = %.2f \n'\
+        ' / BORNE SUP. = %.2f * SOUS-EPAISSEUR'%(j+1,BI[j],BS[j]))
+      else:
+        echo_mess.append( 'ZONE NO %d <> BORNE INF. = %.2f \n'\
+        ' / BORNE SUP. = %.2f '%(j+1,BI[j],BS[j]))
+
+#   calcul du nombre d'elements longi. et circonf. dans les sous-ep
+    NLX,NLY=ASCNBE(MCL_SOUS_EPAIS,COORXG,COORXD,COORYI,COORYS,BD,BG,BS,BI,
+                   DNX,DNY,RM,RC,INDSEX,INDSEY,IABSC1,IORDO1)
+  
+
+  texte_final=string.join(echo_mess)
+  aster.affiche('MESSAGE',texte_final)
+  return ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY
+
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL   write_file_dgib_ASCFDO
+#
+#     ECRIT DANS UN FICHIER LES DONNES GIBI DE LA PROCEDURE 
+#     "PLAQUE FISSUREE"
+#
+
+# ------------------------------------------------------------------------------
+def write_file_dgib_ASCFDO(nomFichierDATG,RM,RC,ALPHA,NBTRAN,EP1,EP2,EPI,TETA1,
+                           TETA2,LTRAN,SUREP,LTCHAR,LTCLIM,TYPBOL,AXEAP,AXECP,NT,NS,NC,
+                           SFP,ORIEN,AZIM,RC0,RC2,RC3,POSIT,EPSI,NIVMAG,SYME, loc_datg) :
+
+  if TYPBOL!= None:
+     if TYPBOL=='CUVE'     : TYPEMB = 'typcuv' 
+     if TYPBOL=='GV'       : TYPEMB = 'typegv' 
+     if TYPBOL=='ASP_MPP'  : TYPEMB = 'typapp' 
+  else: 
+     TYPEMB ='      '
+   
+  if POSIT =='DEB_INT'  :
+         POSIT2 = 'interne'
+  else:
+         POSIT2 = 'externe'
+  if   SYME[:6]=='ENTIER' : ZSYME = 'entier'
+  elif SYME[:5]=='QUART'  : ZSYME = 'quart'
+  else :                    ZSYME = 'demi'
+  C=AXECP/2.
+  TETAF=AZIM*pi/180.
+
+  POIVIR = ' ;\n'
+  texte='* DEBUT PARAMETRES UTILISATEUR\n'
+  texte=texte+'*\n'
+  texte=texte+'c        = '+str(C)            +POIVIR
+  texte=texte+'a        = '+str(AXEAP)        +POIVIR
+  texte=texte+'nt       = '+str(NT)           +POIVIR
+  texte=texte+'ns       = '+str(NS)           +POIVIR
+  texte=texte+'nc       = '+str(NC)           +POIVIR
+  texte=texte+'rm       = '+str(RM)           +POIVIR
+  texte=texte+'rc       = '+str(RC)           +POIVIR
+  texte=texte+'alphac   = '+str(ALPHA)        +POIVIR
+  texte=texte+'nbtranep = '+str(NBTRAN)       +POIVIR
+  texte=texte+'ep1      = '+str(EP1)          +POIVIR
+  texte=texte+'ep2      = '+str(EP2)          +POIVIR
+  texte=texte+'epi      = '+str(EPI)          +POIVIR
+  texte=texte+'teta1    = '+str(TETA1)        +POIVIR
+  texte=texte+'teta2    = '+str(TETA2)        +POIVIR
+  texte=texte+'ltran    = '+str(LTRAN)        +POIVIR
+  texte=texte+'posfis   = '+str(SFP)          +POIVIR
+  texte=texte+'ksiref   = '+str(ORIEN)        +POIVIR
+  texte=texte+'surep    = '+str(SUREP)        +POIVIR       
+  texte=texte+'teta_f   = '+str(TETAF)        +POIVIR
+  texte=texte+'rc0      = '+str(RC0)          +POIVIR
+  texte=texte+'rc2      = '+str(RC2)          +POIVIR
+  texte=texte+'rc3      = '+str(RC3)          +POIVIR
+  texte=texte+"pos      = '"+POSIT2+"'"       +POIVIR
+  texte=texte+'lt       = '+str(LTCHAR)       +POIVIR
+  texte=texte+'lgv      = '+str(LTCLIM)       +POIVIR
+  texte=texte+"typembou = '"+TYPEMB+"'"       +POIVIR
+  texte=texte+"zsyme    = '"+ZSYME+"'"        +POIVIR
+  texte=texte+'epsif    = '+str(EPSI)         +POIVIR
+  texte=texte+'nivmag   = '+str(NIVMAG)       +POIVIR
+  texte=texte+'*\n'
+  texte=texte+'* FIN PARAMETRES UTILISATEUR\n'
+  texte = texte + open(os.path.join(loc_datg, 'ascouf_fiss_v4.datg'), 'r').read()
+  fdgib=open(nomFichierDATG,'w')
+  fdgib.write(texte)
+  fdgib.close()
+
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL   write_file_dgib_ASCSQO
+#
+#     ECRIT DANS UN FICHIER LES DONNEES GIBI DE LA PROCEDURE 
+#     "PLAQUE SOUS-EPAISSEUR"
+#
+#-----------------DONNEES FOURNIES PAR L'UTILISATEUR--------------------
+#
+#     RM    = RAYON MOYEN DU COUDE
+#     RC    = RAYON DE CINTRAGE DU COUDE
+#     ALPHA = ANGLE DU COUDE
+#     NBTRAN = NOMBRE DE TRANSITION D'EPAISSEUR (0, 1 OU 2)
+#     EP1   = EPAISSEUR DU COUDE (COTE EMBOUT 1 SI TRANSITION)
+#     EP2   = EPAISSEUR DU COUDE (COTE EMBOUT 2 SI TRANSITION)
+#     EPI   = EPAISSEUR DU COUDE INTERMEDIAIRE SI TRANSITION A 2 PENTES
+#     TETA1  = ANGLE DE LA PREMIERE TRANSITION D'EPAISSEUR EVENTUELLE
+#     TETA2  = ANGLE DE LA DEUXIEME TRANSITION D'EPAISSEUR EVENTUELLE
+#     LTRAN  = LONGUEUR ENTRE FIN DE L'EMBOUT 1 ET DEBUT DE TRANSITION
+#     LTCHAR = LONGUEUR DE L'EMBOUT DU COTE CHARGEMENT
+#     LCLIM  = LONGUEUR DE L'EMBOUT DU COTE CONDITIONS AUX LIMITES
+#     GEOM  = TYPE DE GEOMETRIE MODELISEE (COUDE OU TUBE)  
+#     SYME = "QUART" DE STRUCTURE, "DEMI" STRUCTURE OU BIEN "ENTIER"
+#     NBEP = NOMBRE D'ELEMENTS DANS LE COUDE
+#     NLX = NOMBRE D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR
+#     NLY = NOMBRE D'ELEMENTS LONGI DE LA SOUS-EPAISSEUR
+#     SUREP = SUR EPAISSEUR
+
+# ------------------------------------------------------------------------------
+def write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2,
+                           EPI,TETA1,MCL_SOUS_EPAIS,TETA2,LTRAN,LTCHAR,LTCLIM,GEOM,
+                           SYME,NBEP,NLX,NLY,NIVMAG,SUREP,AZIMC,loc_datg) :
+
+  ssep= MCL_SOUS_EPAIS[0] 
+  print 'AZIMC', AZIMC;  
+  POIVIR = ' ;\n'
+  texte=' nivmag   = '+str(NIVMAG)       +POIVIR
+  texte=texte+' option dime 3 elem '+TYPELE+' nive nivmag echo 0'+POIVIR
+  texte=texte+'*\n'
+  texte=texte+'coory   = table '+POIVIR
+  texte=texte+'coorz   = table '+POIVIR
+  texte=texte+'prof    = table '+POIVIR
+  texte=texte+'posit   = table '+POIVIR
+  texte=texte+'axisym  = table '+POIVIR
+  texte=texte+'axecir  = table '+POIVIR
+  texte=texte+'axelon  = table '+POIVIR
+  texte=texte+'sousep  = table '+POIVIR
+  texte=texte+'coorzc  = table '+POIVIR
+  texte=texte+'axelonc = table '+POIVIR
+  texte=texte+'*\n'
+  texte=texte+'* DEBUT PARAMETRES UTILISATEUR\n'
+  texte=texte+'*\n'
+  texte=texte+'* parametres generaux\n'
+  texte=texte+'*\n'
+  texte=texte+' pirad    = '+str(pi)            +POIVIR
+  texte=texte+' rm       = '+str(RM)           +POIVIR
+  texte=texte+' rc       = '+str(RC)           +POIVIR
+  texte=texte+' alpha    = '+str(ALPHA)        +POIVIR
+  texte=texte+' lt1      = '+str(LTCHAR)       +POIVIR
+  texte=texte+' lt2      = '+str(LTCLIM)       +POIVIR
+  texte=texte+' nbtranep = '+str(NBTRAN)       +POIVIR
+  texte=texte+' ep1      = '+str(EP1)          +POIVIR
+  texte=texte+' ep2      = '+str(EP2)          +POIVIR
+  texte=texte+' epI      = '+str(EPI)          +POIVIR
+  texte=texte+' teta1    = '+str(TETA1)        +POIVIR
+  texte=texte+' teta2    = '+str(TETA2)        +POIVIR
+  texte=texte+' ltran    = '+repr(LTRAN)       +POIVIR 
+  texte=texte+' surep    = '+str(SUREP)        +POIVIR   
+  if GEOM == 'COUDE':
+    texte=texte+" zcoude = 'oui' "+POIVIR
+  else:
+    texte=texte+" zcoude = 'non' "+POIVIR
+  if SYME == 'ENTIER':
+    texte=texte+" zsyme = 'entier' "+POIVIR
+  elif SYME == 'QUART':
+    texte=texte+" zsyme = 'quart' "+POIVIR
+  else:
+    texte=texte+" zsyme = 'demi' "+POIVIR
+  if TYPELE == 'CU20':
+    texte=texte+" zquad = 'oui' "+POIVIR
+  else:
+    texte=texte+" zquad = 'non' "+POIVIR
+  SCP=pi*RM
+  texte=texte+' nxep   = '+str(NBEP)        +POIVIR
+  texte=texte+'*\n'
+  texte=texte+'* Caracteristiques de la sous-epaisseur\n'
+  texte=texte+'*\n'
+  texte=texte+' azimc = '+str(AZIMC)                                        +POIVIR
+  texte=texte+' tysep = '+str(ssep.ICIRP)                                   +POIVIR
+  texte=texte+' tzsep = '+str(ssep.ILONP)                                   +POIVIR
+  texte=texte+' prof .                      1  = '+str(ssep['PROFONDEUR'])  +POIVIR
+  texte=texte+' ycsep = '+str(SCP-pi*RM)                                    +POIVIR
+  texte=texte+' theta = '+str(ssep.IPHIC)                                   +POIVIR
+  texte=texte+' zcsep = '+repr(ssep.ISLP)                                    +POIVIR
+
+  texte=texte+" posit .                      1  = '"+str(ssep['SOUS_EPAIS'].lower())+"'"+POIVIR
+  texte=texte+' nby   = '+str(int(NLX[0]))                                  +POIVIR
+  texte=texte+' nbz   = '+str(int(NLY[0]))                                  +POIVIR
+  texte=texte+' nbxse = '+str(ssep['NB_ELEM_RADI'])                         +POIVIR
+  texte=texte+' axelonc .                      1  = '+str(ssep['AXE_LONGI'])+POIVIR
+  if ssep['POSI_CURV_LONGI']!=None:
+    texte=texte+' coorzc .                      1  = '+repr(ssep['POSI_CURV_LONGI'])+POIVIR
+  else:
+    DZC=ssep.BETA*pi*(RC+(RM+EP1/2.)*cos(pi/2.))/180.
+    texte=texte+' coorzc .                      1  = '+repr(DZC)+POIVIR
+  if ssep['TYPE']=='AXIS':
+     texte=texte+" zaxis = 'oui' "+POIVIR
+  else:
+     texte=texte+" zaxis = 'non' "+POIVIR
+  if ssep['EMPREINTE'] == 'OUI':
+     texte=texte+" sousep .                      1  = 'oui'"+POIVIR
+  else:
+     texte=texte+" sousep .                      1  = 'non'"+POIVIR
+  texte=texte+'*\n'
+  texte=texte+'* FIN PARAMETRES UTILISATEUR \n'
+  texte = texte + open(os.path.join(loc_datg, 'ascouf_ssep_mono_v1.datg'), 'r').read()
+  fdgib=open(nomFichierDATG,'w')
+  fdgib.write(texte)
+  fdgib.close()
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL   write_subpart_file_pgib_POST
+#
+#     APPELEE DANS : write_file_pgib_ASCSQ2 , write_file_pgib_ASCSD2
+#     DEFINIE UNE CHAINE DE CARACTERES UTILISEE LORS DE L'ECRITURE DU
+#     FICHIER GIBI DE POST-TRAITEMENTS
+#
+#-----------------DONNEES FOURNIES PAR L'UTILISATEUR--------------------
+#
+#     NLX = NOMBRE D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR
+#     NLY = NOMBRE D'ELEMENTS LONGI DE LA SOUS-EPAISSEUR
+#
+#-----------------DONNEE RENVOYEE PAR ASTER-------------------- 
+# 
+#     texte = chaine de caracteres contenant des instructions gibi
+#             de post-traitements
+#
+# ------------------------------------------------------------------------------
+def write_subpart_file_pgib_POST(MCL_SOUS_EPAIS,NLX,NLY):
+  CAR3 = ('fdro','exdr','extr','exga','fgau','inga','intr','indr')
+  
+  POIVIR = ' ;\n'
+  texte='* DEBUT POINTS DE POST-TRAITEMENT\n'
+  texte=texte+'*\n'
+  issep=0
+  for ssep in MCL_SOUS_EPAIS:
+    issep=issep+1
+    texte=texte+'*\n'
+    texte=texte+'* sous-epaisseur No '+str( issep)+'\n'
+    texte=texte+'*\n'
+    if ssep['TYPE'] == 'ELLI':
+      texte=texte+'*\n'
+      texte=texte+'* plans circonf longi et colonne centrale \n'
+      texte=texte+'*\n'
+      texte=texte+'pcirc'+str( issep)+' = circo .'+str(issep).rjust(4)+POIVIR
+      texte=texte+'plong'+str( issep)+' = longi .'+str(issep).rjust(4)+POIVIR
+      texte=texte+'pcent'+str( issep)+' = centr .'+str(issep).rjust(4)+POIVIR
+    texte=texte+'*\n'
+    texte=texte+'* ligaments tous les 45 degres a epaisseur minimale \n'
+    texte=texte+'*\n'
+    texte=texte+'isep = '+str( issep)+POIVIR
+    for k in range(8):
+      texte=texte+'ilig = '+str(k+1)+POIVIR
+      texte=texte+'rlig = ilig/10. + isep'+POIVIR
+      texte=texte+str(CAR3[k])+str( issep)+' = lig45 . rlig'+POIVIR
+    if ssep['TYPE'] == 'ELLI':
+      texte=texte+'*\n'
+      texte=texte+"* ligaments circonferentiels a l'epaisseur minimale\n"
+      texte=texte+'*\n'
+      texte=texte+'isep = '+str(issep)+POIVIR
+      for k in range(2*NLX[issep-1]+1):
+        texte=texte+'ilig = '+str(k+1)+POIVIR
+        texte=texte+'rlig = ilig/100. + isep'+POIVIR
+        texte=texte+'cir'+str(issep)+'_'+str(k+1)+' = ligcir . rlig'+POIVIR
+      texte=texte+'*\n'
+      texte=texte+"* ligaments longitudinaux a l'epaisseur minimale\n"                        
+      texte=texte+'* \n'
+      for k in range(2*NLY[issep-1]+1):
+        texte=texte+'ilig = '+str(k+1)+POIVIR
+        texte=texte+'rlig = ilig/100. + isep'+POIVIR
+        texte=texte+'lon'+str(issep)+'_'+str(k+1)+' = liglon . rlig'+POIVIR
+  texte=texte+'* FIN POINTS DE POST-TRAITEMENT\n'
+  return texte
+
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL   write_file_pgib_ASCSQ2
+#
+#     ECRIT DANS UN FICHIER  LES DONNEES GIBI DE LA PROCEDURE
+#     "PLAQUE SOUS-EPAISSEURS"
+#     IL S'AGIT DE LA DEUXIEME PARTIE ( APRES LES DONNEES UTILISATEUR )
+#
+#
+#-----------------DONNEES FOURNIES PAR L'UTILISATEUR--------------------
+#
+#     NLX = NOMBRE TOTAL D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR K
+#     NLY = NOMBRE TOTAL D'ELEMENTS LONGIT. DE LA SOUS-EPAISSEUR K
+
+# ------------------------------------------------------------------------------
+def write_file_pgib_ASCSQ2(MCL_SOUS_EPAIS,NLX,NLY):
+  POIVIR = ' ;\n'
+  texte=write_subpart_file_pgib_POST(MCL_SOUS_EPAIS,NLX,NLY)
+  texte=texte+'*\n'
+  texte=texte+'p1 = 0. 0. (-1.*lt1)'+POIVIR
+  texte=texte+'p2 = 0. 0. (coor 3 bou3)'+POIVIR
+  texte=texte+'ma = coude et p1 et p2'+POIVIR
+  texte=texte+"opti sauv form 'fort.8'"+POIVIR
+  texte=texte+'sort ma'+POIVIR
+  texte=texte+'sauv form ma'+POIVIR
+  texte=texte+'fin'+POIVIR
+  fpgib=open('fort.71','w')
+  fpgib.write(texte)
+  fpgib.close()
+
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL   write_file_pgib_ASCSP1
+#
+#     ECRIT DANS UN FICHIER  LES DONNEES GIBI DE LA PROCEDURE
+#     "PLAQUE SOUS-EPAISSEURS"
+#     IL S'AGIT DE LA PREMIERE PARTIE ( AVANT LES DONNEES UTILISATEUR )
+#
+#
+# ------------------------------------------------------------------------------
+def write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg):
+
+  POIVIR = ' ;\n'
+  texte=' nivmag = '+str(NIVMAG)+POIVIR
+  texte=texte+' option dime 3 elem '+TYPELE+' nive nivmag echo 0 '+POIVIR
+  texte=texte+'*\n'
+  texte=texte+'bg      = table '+POIVIR
+  texte=texte+'bd      = table '+POIVIR
+  texte=texte+'bi      = table '+POIVIR
+  texte=texte+'bs      = table '+POIVIR
+  texte=texte+'indbg   = table '+POIVIR
+  texte=texte+'indbd   = table '+POIVIR
+  texte=texte+'indbi   = table '+POIVIR
+  texte=texte+'indbs   = table '+POIVIR
+  texte=texte+'axecir  = table '+POIVIR
+  texte=texte+'axelon  = table '+POIVIR
+  texte=texte+'axelonc = table '+POIVIR
+  texte=texte+'coorzc  = table '+POIVIR
+  texte=texte+'prof    = table '+POIVIR
+  texte=texte+'posit   = table '+POIVIR
+  texte=texte+'coory   = table '+POIVIR
+  texte=texte+'coorz   = table '+POIVIR   
+  texte=texte+'deny    = table '+POIVIR
+  texte=texte+'nbely   = table '+POIVIR
+  texte=texte+'denz    = table '+POIVIR
+  texte=texte+'nbelz   = table '+POIVIR
+  texte=texte+'axisym  = table '+POIVIR
+  texte=texte+'sousep  = table '+POIVIR
+  texte=texte+'* \n'  
+  texte = texte + open(os.path.join(loc_datg, 'ascouf_ssep_mult_v1.datg'), 'r').read()
+  fdgib=open(nomFichierDATG,'w')
+  fdgib.write(texte)
+  fdgib.close()
+  
+################################################################################
+################################################################################
+################################################################################
+#     MACR_ASCOUF_MAIL   write_file_pgib_ASCSDO
+#
+#     ECRIT DANS UN FICHIER  LES DONNEES GIBI DE LA PROCEDURE
+#     "PLAQUE SOUS-EPAISSEURS"
+#
+#-----------------DONNEES FOURNIES PAR L'UTILISATEUR--------------------
+#
+#     RM    = RAYON MOYEN DU COUDE
+#     RC    = RAYON DE CINTRAGE DU COUDE
+#     ALPHA = ANGLE DU COUDE
+#     EP    = EPAISSEUR DU COUDE
+#     LTCHAR = LONGUEUR DE L'EMBOUT DU COTE CHARGEMENT
+#     LCLIM  = LONGUEUR DE L'EMBOUT DU COTE CONDITIONS AUX LIMITES
+#     GEOM  = TYPE DE GEOMETRIE MODELISEE (COUDE OU TUBE)  
+#     SYME = QUART DE STRUCTURE SI 'OUI'
+#     INDBG = INDICATEUR BORD GAUCHE DE LA ZONE CIRCONF J
+#     INDBD = INDICATEUR BORD DROIT DE LA ZONE CIRCONF J
+#     BG = ABSCISSE DU BORD GAUCHE DE LA ZONE CIRCONF J
+#     BD = ABSCISSE DU BORD DROIT DE LA ZONE CIRCONF J
+#     BI = ORDONNEE DU BORD INFERIEUR DE LA ZONE LONGI J
+#     BS = ORDONNEE DU BORD SUPERIEUR DE LA ZONE LONGI J
+#     INDBI = INDICATEUR BORD INFERIEUR DE LA ZONE LONGI J
+#     INDBS = INDICATEUR BORD SUPERIEUR DE LA ZONE LONGI J
+#     INDSEX = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE CIRCONF J
+#     INDSEY = NUMERO DE SOUS-EPAISSEUR CONTENU DANS LA ZONE LONGI J
+#     DNX = DENSITE ET NOMBRE D'ELEMENTS CIRCONF. DE LA ZONE J
+#     DNY = DENSITE ET NOMBRE D'ELEMENTS LONGIT. DE LA ZONE J
+#     NZONEX = NOMBRE DE ZONES CIRCONFERENTIELLES
+#     NZONEY = NOMBRE DE ZONES LONGITUDINALES  
+#
+# ------------------------------------------------------------------------------
+def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP,SUREP,
+                           NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,
+                           DNX,DNY,MCL_SOUS_EPAIS,GEOM,SYME):
+
+  POIVIR = ' ;\n'
+  NY=20
+  DELTAY=2.*pi*RM/NY
+
+  def nint(x):
+    if 0<ceil(x)-x<=0.5:
+      return int(ceil(x))
+    else:
+      return int(floor(x))
+
+# conversion des densites de raffinement des embout en degres par rapport
+# a l'angle du coude
+  RTMP=nint(LTCHAR/DELTAY)*DELTAY/4.
+  DENSTU = RTMP*360./(2.*pi*RC)
+  DENSGV = DENSTU
+  NZT=0
+  NZGV=0
+
+  texte='* DEBUT PARAMETRES UTILISATEUR \n'
+  texte=texte+'*\n'
+  texte=texte+'* parametres generaux\n'
+  texte=texte+'*\n'
+  texte=texte+'rm       = '+str(RM)               +POIVIR
+  texte=texte+'rc       = '+str(RC)               +POIVIR
+  texte=texte+'alphac   = '+str(ALPHA)            +POIVIR
+  texte=texte+'epc      = '+str(EP)               +POIVIR
+  texte=texte+'pirad    = '+str(pi)               +POIVIR
+  texte=texte+'lgv      = '+str(LTCLIM)           +POIVIR
+  texte=texte+'lt       = '+str(LTCHAR)           +POIVIR
+  texte=texte+'lcoude   = '+str(ALPHA*pi/180.*RC) +POIVIR
+  if GEOM == 'COUDE':
+    texte=texte+"zcoude = 'oui' "     +POIVIR
+  else:
+    texte=texte+"zcoude = 'non' "     +POIVIR
+  if SYME == 'ENTIER':
+    texte=texte+"zsyme = 'entier' "   +POIVIR
+  elif SYME == 'QUART':
+    texte=texte+"zsyme = 'quart' "    +POIVIR
+  else:
+    texte=texte+"zsyme = 'demi' "     +POIVIR
+  texte=texte+'nxep   = '+str(NBEP)   +POIVIR
+  texte=texte+'nzt    = '+str(NZT)    +POIVIR
+  texte=texte+'nzgv   = '+str(NZGV)   +POIVIR
+  texte=texte+'daxhtu = '+str(DENSTU) +POIVIR
+  texte=texte+'daxhgv = '+str(DENSGV) +POIVIR
+  texte=texte+'*\n'
+  
+  texte=texte+'* Zones couvertes en circonference\n'
+  texte=texte+'*\n'
+  for j in range(NZONEX):
+    texte=texte+'bg .'   +str(j+1).rjust(23)+' = '+str(BG[j]-pi*RM)     +POIVIR
+    texte=texte+'bd .'   +str(j+1).rjust(23)+' = '+str(BD[j]-pi*RM)     +POIVIR
+    texte=texte+'indbg .'+str(j+1).rjust(23)+' = '+str(INDBG[j])        +POIVIR
+    texte=texte+'indbd .'+str(j+1).rjust(23)+' = '+str(INDBD[j])        +POIVIR
+    texte=texte+'deny .' +str(j+1).rjust(23)+' = '+str(DNX[2*j])        +POIVIR
+    texte=texte+'nbely .'+str(j+1).rjust(23)+' = '+str(int(DNX[2*j+1])) +POIVIR
+    texte=texte+'*\n'
+    
+  texte=texte+'* Zones couvertes longitudinalement\n'
+  texte=texte+'*\n'
+  for j in range(NZONEY):
+    texte=texte+'bi .'   +str(j+1).rjust(23)+' = '+str(BI[j])           +POIVIR
+    texte=texte+'bs .'   +str(j+1).rjust(23)+' = '+str(BS[j])           +POIVIR
+    texte=texte+'indbi .'+str(j+1).rjust(23)+' = '+str(INDBI[j])        +POIVIR
+    texte=texte+'indbs .'+str(j+1).rjust(23)+' = '+str(INDBS[j])        +POIVIR
+    texte=texte+'denz .' +str(j+1).rjust(23)+' = '+str(DNY[2*j])        +POIVIR
+    texte=texte+'nbelz .'+str(j+1).rjust(23)+' = '+str(int(DNY[2*j+1])) +POIVIR
+    texte=texte+'*\n'
+ 
+  texte=texte+'* Caracteristiques des sous-epaisseurs\n'
+  texte=texte+'*\n'
+  issep=0
+  for ssep in MCL_SOUS_EPAIS:
+     issep=issep+1
+     texte=texte+'axecir .' +str(issep).rjust(23)+' = '+str(ssep.ICIRP)        +POIVIR
+     texte=texte+'axelon .' +str(issep).rjust(23)+' = '+str(ssep.ILONP)        +POIVIR
+     texte=texte+'prof .'   +str(issep).rjust(23)+' = '+str(ssep['PROFONDEUR'])+POIVIR
+     texte=texte+'coory .'  +str(issep).rjust(23)+' = '+str(ssep.ISCP-pi*RM)   +POIVIR
+     texte=texte+'coorz .'  +str(issep).rjust(23)+' = '+str(ssep.ISLP)         +POIVIR
+     texte=texte+'posit .'  +str(issep).rjust(23)+" = '"+str(ssep['SOUS_EPAIS'].lower())+"'"+POIVIR
+     texte=texte+'axelonc .'+str(issep).rjust(23)+' = '+str(ssep['AXE_LONGI']) +POIVIR
+     if ssep['POSI_CURV_LONGI']!=None:
+       texte=texte+'coorzc .'+str(issep).rjust(23)+' = '+str(ssep['POSI_CURV_LONGI'])+POIVIR
+     else:
+       DZC=ssep.BETA*pi*(RC+(RM+EP/2.)*cos(pi/2.))/180.
+       texte=texte+'coorzc .'+str(issep).rjust(23)+' = '+str(DZC)+POIVIR
+     if ssep['TYPE']=='AXIS':
+       texte=texte+'axisym .'+str(issep).rjust(23)+" = 'oui'"+POIVIR
+     else:
+       texte=texte+'axisym .'+str(issep).rjust(23)+" = 'non'"+POIVIR
+     if ssep['EMPREINTE'] == 'OUI':
+       texte=texte+'sousep .'+str(issep).rjust(23)+" = 'oui'"+POIVIR
+     else:
+       texte=texte+'sousep .'+str(issep).rjust(23)+" = 'non'"+POIVIR
+  texte=texte+'*\n'  
+
+  texte=texte+'* Caracteristique de sur-epaisseur\n'
+  texte=texte+'surep    = '+str(SUREP)            +POIVIR
+  texte=texte+'* \n'
+  texte=texte+'* FIN PARAMETRES UTILISATEUR\n'
+  fpgib=open('fort.71','w') 
+  fpgib.write(texte)
+  fpgib.close()
+  
+ 
+################################################################################
+################################################################################
+################################################################################
+
+# ------------------------------------------------------------------------------
+def write_file_pgib_ASCSP2(MCL_SOUS_EPAIS,NLX,NLY):
+
+  POIVIR = ' ;\n'
+  texte='*\n'
+  texte=texte+'coude extube bord1 clgv  bord2 peauext peauint placoude platube\n'
+  texte=texte+'plagv  longi  circo centr bou1  bou3  ligmed  ligtub liggv lig45\n'
+  texte=texte+'ligcir liglon bordtu\n'
+  texte=texte+'= PLAQSEP bg bd bi bs indbg indbd indbi indbs rm rc\n'
+  texte=texte+'alphac pirad epc lt lgv coory coorz axecir axelon prof zsyme posit\n'
+  texte=texte+'lcoude nxep sousep deny nbely denz nbelz axelonc coorzc axisym\n'
+  texte=texte+'daxhtu daxhgv nzt nzgv zcoude surep'+POIVIR
+  texte=texte+'fdromi   = ligmed .   1'+POIVIR
+  texte=texte+'exdrmi   = ligmed .   2'+POIVIR
+  texte=texte+'extrmi   = ligmed .   3'+POIVIR
+  texte=texte+'exgami   = ligmed .   4'+POIVIR
+  texte=texte+'fgaumi   = ligmed .   5'+POIVIR
+  texte=texte+'ingami   = ligmed .   6'+POIVIR
+  texte=texte+'intrmi   = ligmed .   7'+POIVIR
+  texte=texte+'indrmi   = ligmed .   8'+POIVIR
+  texte=texte+'fdrotu   = ligtub .   1'+POIVIR
+  texte=texte+'exdrtu   = ligtub .   2'+POIVIR
+  texte=texte+'extrtu   = ligtub .   3'+POIVIR
+  texte=texte+'exgatu   = ligtub .   4'+POIVIR
+  texte=texte+'fgautu   = ligtub .   5'+POIVIR
+  texte=texte+'ingatu   = ligtub .   6'+POIVIR
+  texte=texte+'intrtu   = ligtub .   7'+POIVIR
+  texte=texte+'indrtu   = ligtub .   8'+POIVIR
+  texte=texte+"si (ega zsyme 'entier')"+POIVIR
+  texte=texte+'   fdrogv   = liggv  .  1'+POIVIR
+  texte=texte+'   exdrgv   = liggv .   2'+POIVIR
+  texte=texte+'   extrgv   = liggv .   3'+POIVIR
+  texte=texte+'   exgagv   = liggv .   4'+POIVIR
+  texte=texte+'   fgaugv   = liggv .   5'+POIVIR
+  texte=texte+'   ingagv   = liggv .   6'+POIVIR
+  texte=texte+'   intrgv   = liggv .   7'+POIVIR
+  texte=texte+'   indrgv   = liggv .   8'+POIVIR
+  texte=texte+'finsi'+POIVIR
+  texte=texte+'*\n'
+  
+  text2=write_subpart_file_pgib_POST(MCL_SOUS_EPAIS,NLX,NLY)
+  texte=texte+text2
+  
+  texte=texte+'*\n'
+  texte=texte+'*oeil = 10000. 0. 0.' +POIVIR
+  texte=texte+'*trac oeil cach coude'+POIVIR
+  texte=texte+'*opti donn 5'         +POIVIR
+  texte=texte+'p1 = 0. 0. (-1.*lt)'+POIVIR
+  texte=texte+'p2 = 0. 0. (coor 3 bou3)'+POIVIR
+  texte=texte+'ma = coude et p1 et p2'+POIVIR
+  texte=texte+'sort ma'+POIVIR
+  texte=texte+'neu = nbno ma'+POIVIR
+  texte=texte+"mess 'nombre de noeuds : 'neu"+POIVIR
+  texte=texte+"opti sauv form 'fort.8'"+POIVIR
+  texte=texte+'sauv form ma'+POIVIR
+  texte=texte+'fin'+POIVIR
+  fpgib=open('fort.71','a') 
+  fpgib.write(texte)
+  fpgib.close()  
+
+################################################################################
+################################################################################
+################################################################################
+
+# ------------------------------------------------------------------------------
+def write_file_dgib_ASCRDO(nomFichierDATG,TYPELE,NIVMAG,TYPBOL,ALPHA,RC,RM,EP,SUREP,
+                           LTCLIM,LTCHAR,NBEP,loc_datg):
+
+  NY=20
+  CZ=ALPHA*RC*pi/180.
+  NZC=int((ALPHA+0.00001)/5.)
+  DELTAY=2.*pi*RM/20
+  DELTAZ=CZ/NZC
+  DENEXT=int(LTCHAR/DELTAY)*DELTAY/4.
+  NZT=0
+  NZGV=0
+  
+  if TYPBOL!=None:
+     if TYPBOL=='CUVE'     : TYPEMB = 'typcuv' 
+     if TYPBOL=='GV'       : TYPEMB = 'typegv' 
+     if TYPBOL=='ASP_MPP'  : TYPEMB = 'typapp' 
+  else: 
+     TYPEMB ='      '
+   
+  POIVIR = ' ;\n'
+  texte='* DEBUT PARAMETRES UTILISATEUR\n'
+  texte=texte+'*\n'
+  texte=texte+'* Parametres generaux\n'
+  texte=texte+'*\n'
+  texte=texte+'nivmag   = '+str(NIVMAG)       +POIVIR
+  texte=texte+'option dime 3 elem '+TYPELE+' nive nivmag echo 0'+POIVIR
+  texte=texte+'rm       = '+str(RM)           +POIVIR
+  texte=texte+'rc       = '+str(RC)           +POIVIR
+  texte=texte+'alphac   = '+str(ALPHA)        +POIVIR
+  texte=texte+'epc      = '+str(EP)           +POIVIR
+  texte=texte+'surep    = '+str(SUREP)        +POIVIR       
+  texte=texte+'lgv      = '+str(LTCLIM)       +POIVIR
+  texte=texte+'lt       = '+str(LTCHAR)       +POIVIR
+  texte=texte+"typembou = '"+TYPEMB+"'"       +POIVIR
+  texte=texte+'nx       = '+str(NBEP)         +POIVIR
+  texte=texte+'ny       = '+str(NY)           +POIVIR
+  texte=texte+"pos      = 'bidon'"            +POIVIR
+  texte=texte+'l1       = 0.'                 +POIVIR
+  texte=texte+'lbloc    = 0.'                 +POIVIR
+  texte=texte+'crit     = 0.0001'             +POIVIR
+  texte=texte+'crit2    = 0.01'               +POIVIR
+  texte=texte+'epsit    = 1.e-3'              +POIVIR
+  texte=texte+'pirad    = '+str(pi)           +POIVIR
+  texte=texte+'nzc      = '+str(NZC)          +POIVIR
+  texte=texte+'teta_f   = '+str(pi/2.)        +POIVIR
+  texte=texte+'zpp31    = '+str(CZ)           +POIVIR
+  texte=texte+'daxbtu   = '+str(DENEXT)       +POIVIR
+  texte=texte+'daxhtu   = '+str(DELTAZ)       +POIVIR
+  texte=texte+'daxbgv   = '+str(DELTAZ)       +POIVIR
+  texte=texte+'daxhgv   = '+str(DENEXT)       +POIVIR
+  texte=texte+'nzt      = '+str(NZT)          +POIVIR
+  texte=texte+'nzgv     = '+str(NZGV)         +POIVIR
+  texte=texte+'*\n'
+  texte=texte+'* FIN PARAMETRES UTILISATEUR\n'
+  texte = texte + open(os.path.join(loc_datg, 'ascouf_regl_v1.datg'), 'r').read()
+  fdgib=open(nomFichierDATG,'w')
+  fdgib.write(texte)
+  fdgib.close()
+  
+################################################################################
+################################################################################
+################################################################################
+# ------------------------------------------------------------------------------
+def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE,
+                              SOUS_EPAIS_COUDE,SOUS_EPAIS_MULTI,
+                              FISS_COUDE,IMPRESSION,INFO,**args):
+  """
+     Ecriture de la macro MACR_ASCOUF_MAIL
+  """
+  from Accas import _F
+  import types
+  import aster 
+
+  ier=0
+  
+# On importe les definitions des commandes a utiliser dans la macro
+  EXEC_LOGICIEL =self.get_cmd('EXEC_LOGICIEL')
+  PRE_GIBI      =self.get_cmd('PRE_GIBI')
+  LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE')
+  DEFI_GROUP    =self.get_cmd('DEFI_GROUP')
+  MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE')
+  CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE')
+  DEFI_FICHIER  =self.get_cmd('DEFI_FICHIER')
+  IMPR_RESU     =self.get_cmd('IMPR_RESU')
+
+# La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  
+  TYPELE = TYPE_ELEM
+  NIVMAG = EXEC_MAILLAGE['NIVE_GIBI']
+  PRECIS = 0.01
+  CRITER = 'RELATIF'
+  CAR3   = ('IFDRO','IEXDR','IEXTR','IEXGA','IFGAU','IINGA','IINTR','IINDR')
+  CAR4   = ('NOFDRO','NOEXDR','NOEXTR','NOEXGA','NOFGAU','NOINGA','NOINTR','NOINDR')
+  CAR5   = ('NEFDRO','NEEXDR','NEEXTR','NEEXGA','NEFGAU','NEINGA','NEINTR','NEINDR')
+  CAR6   = ('FDRO','EXDR','EXTR','EXGA','FGAU','INGA','INTR','INDR')
+  SECT   = ('MI','TU','GV')  
+  
+#
+################################################################################
+#     --- caracteristiques du coude ---
+################################################################################
+#
+  GEOM    =COUDE['TRANSFORMEE']
+  ALPHA   =COUDE['ANGLE']
+  RC      =COUDE['R_CINTR']
+  LTCHAR  =COUDE['L_TUBE_P1']
+  LTCLIM  =COUDE['L_TUBE_P2']
+  NBEP    =COUDE['NB_ELEM_EPAIS']
+  SYME    =COUDE['SYME']
+  SUREP   =0.0
+  TYPBOL  = None
+#
+  if COUDE['TRANSFORMEE']=='COUDE' or COUDE['TRAN_EPAIS']=='NON' :
+     SUREP=COUDE['SUR_EPAIS']
+     TYPBOL  =COUDE['BOL_P2']
+     DEXT   = COUDE['DEXT']
+     EP1    = COUDE['EPAIS']
+     EP2    = EP1
+     EPI    = 0.0
+     TETA1  = 0.0
+     TETA2  = 0.0
+     LTRAN  = 0.0
+     NBTRAN = 0
+  else:
+     NBTRAN = 1
+     if COUDE['SYME']!='ENTIER':
+        UTMESS('F','ASCOUF0_13')
+#
+     DEXT  = COUDE['DEXT_T1']
+     EP1   = COUDE['EPAIS_T1']
+     EP2   = COUDE['EPAIS_T2']
+     TETA1 = COUDE['ANGL_TETA1']
+     TETA2 = 0.0
+     EPI   = 0.0
+     if COUDE['ANGL_TETA2']!=None :
+       NBTRAN = 2
+       TETA2 = COUDE['ANGL_TETA2']
+       EPI   = COUDE['EPAIS_TI']
+#
+     if COUDE['ABSC_CURV_TRAN']!=None :
+       LTRAN   = COUDE['ABSC_CURV_TRAN']
+     else :
+       LTRAN   = COUDE['POSI_ANGU_TRAN']* RC * pi / 180.0
+#
+  RM  = (DEXT-EP1)/2.0
+  RM2 = RM + (EP2-EP1)/2.0
+  R1  = RC
+  R2  = RM
+  E   = EP1
+#
+  if COUDE['SYME']!='ENTIER' and (LTCHAR!=LTCLIM) :
+     UTMESS('F','ASCOUF0_14')
+#
+  LAMOR = 3.0/2.0 * sqrt( RM*RM*RM / EP1)
+  if LTCHAR<LAMOR :
+     UTMESS('A','ASCOUF0_15',valr=LAMOR)
+#
+  LAMOR = 3.0/2.0 * sqrt( RM2*RM2*RM2 / EP2)
+  if LTCLIM<LAMOR :
+     UTMESS('A','ASCOUF0_16',valr=LAMOR)
+#
+  if TYPBOL!=None:
+   if TYPBOL[:1]=='GV' :
+     UTMESS('A','ASCOUF0_17')
+#
+################################################################################
+#     --- caracteristiques de la fissure ---
+################################################################################
+#
+  if FISS_COUDE!=None:
+     if NBEP!=3:
+        UTMESS('A','ASCOUF0_18')
+     FPROF = FISS_COUDE['PROFONDEUR']
+     FAXI  = FISS_COUDE['AXIS']
+     if FAXI=='NON' and FISS_COUDE['LONGUEUR']==None :
+        UTMESS('F','ASCOUF0_19')
+     if FAXI=='OUI' and FISS_COUDE['LONGUEUR']!=None :
+        UTMESS('A','ASCOUF0_20')
+     if FISS_COUDE['LONGUEUR']!=None : FLONG = FISS_COUDE['LONGUEUR']
+     if FAXI=='OUI' :
+####    on prend une marge de securite a cause des modifs dans ascfis
+        FLONG = 2.0 * pi * (RM + EP1)
+     if FISS_COUDE['ABSC_CURV']!=None :
+         SF     = FISS_COUDE['ABSC_CURV']
+         LDEFAU = SF
+         BETA   = 0.0
+     else:
+         SF     = 0.0
+         BETA   = FISS_COUDE['POSI_ANGUL']
+         LDEFAU = BETA * RC * pi / 180.0
+     AZIM   = FISS_COUDE['AZIMUT']
+     ORIEN  = FISS_COUDE['ORIEN']
+     POSIT  = FISS_COUDE['FISSURE']
+     NT     = FISS_COUDE['NB_TRANCHE']
+     NS     = FISS_COUDE['NB_SECTEUR']
+     NC     = FISS_COUDE['NB_COURONNE']
+     if FISS_COUDE['RAYON_TORE']!=None    : RC0 = FISS_COUDE['RAYON_TORE']
+     else :                                 RC0 = 0.
+     if FISS_COUDE['COEF_MULT_RC2']!=None : RC2 = FISS_COUDE['COEF_MULT_RC2']
+     else :                                 RC2 = 0.
+     if FISS_COUDE['COEF_MULT_RC3']!=None : RC3 = FISS_COUDE['COEF_MULT_RC3']
+     else :                                 RC3 = 0.
+     EPSI   = FISS_COUDE['ANGL_OUVERTURE']
+     OR     = ORIEN
+     AZ     = AZIM
+     POS    = POSIT
+     DGAXEC = FLONG/2.0
+     DC     = DGAXEC
+     if ORIEN!=90.0 and NBTRAN!=0 :
+        UTMESS('F','ASCOUF0_21')
+     if ORIEN!=90.0 and NBTRAN!=0 :
+        UTMESS('F','ASCOUF0_21')
+     if ORIEN!=90.0 and COUDE['SYME']!='ENTIER' :
+        UTMESS('F','ASCOUF0_23')
+     if ORIEN!=90.0 and FAXI=='OUI' :
+        UTMESS('F','ASCOUF0_24')
+#
+################################################################################
+#     --- caracteristiques des sous epaisseurs ---
+################################################################################
+#
+  isep = 0
+  MCL_SOUS_EPAIS = None
+  if SOUS_EPAIS_MULTI!=None : MCL_SOUS_EPAIS = SOUS_EPAIS_MULTI
+  if SOUS_EPAIS_COUDE!=None : MCL_SOUS_EPAIS = SOUS_EPAIS_COUDE
+  if SOUS_EPAIS_MULTI!=None and NBTRAN!=0 :
+     UTMESS('F','ASCOUF0_25')
+  if SOUS_EPAIS_COUDE!=None and FISS_COUDE!=None and NBTRAN!=0 :
+     UTMESS('F','ASCOUF0_26')
+  if MCL_SOUS_EPAIS!=None :
+     AZIM = 90.0
+     if MCL_SOUS_EPAIS.__class__.__name__  !='MCList' : MCL_SOUS_EPAIS=[MCL_SOUS_EPAIS,]
+     if len(MCL_SOUS_EPAIS)!=1 and COUDE['SYME']!='ENTIER' :
+        UTMESS('F','ASCOUF0_27')
+     for ssep in MCL_SOUS_EPAIS :
+        isep=isep+1
+        if ssep['AXE_CIRC']!=None and ssep['TYPE']=='AXIS' :
+           UTMESS('F','ASCOUF0_28')
+        if ssep['AXE_CIRC']==None and ssep['TYPE']=='ELLI' :
+           UTMESS('F','ASCOUF0_29')
+        if ssep['POSI_CURV_LONGI']!=None:
+           if ssep['POSI_CURV_LONGI']>(ALPHA*RC*pi/180.0) :
+              UTMESS('F','ASCOUF0_30',vali=[isep],valr=[ssep['POSI_CURV_LONGI'],ALPHA*RC*pi/180.0])
+           LDEFAU = ssep['POSI_CURV_LONGI'] + ssep['AXE_LONGI']/2.0
+           BETA = 0.0
+        else:
+           BETA=ssep['POSI_ANGUL']
+           if (BETA<0.) or (BETA>ALPHA) :
+              UTMESS('F','ASCOUF0_31',vali=[isep],valr=[BETA,ALPHA])
+           LDEFAU = (BETA*RC*pi/180.0) + ssep['AXE_LONGI']/2.0
+#
+        if ssep['POSI_CURV_CIRC']!=None:
+           if ssep['POSI_CURV_CIRC']>(2*pi*RM) :
+              UTMESS('F','ASCOUF0_32',vali=[isep],valr=[ssep['POSI_CURV_CIRC'],2*pi*RM])
+           if ssep['POSI_CURV_CIRC']!=(pi*RM) and ssep['TYPE']=='AXIS':
+              UTMESS('F','ASCOUF0_33')
+        else:
+           ssep.IPHIC=ssep['AZIMUT']
+           if ssep['AZIMUT']!=180. and ssep['TYPE']=='AXIS':
+              UTMESS('F','ASCOUF0_34')
+#        l_ITYPE.append(ssep['TYPE'           ])
+#        l_ICIRC.append(ssep['AXE_CIRC'       ])
+#        l_ILONC.append(ssep['AXE_LONGI'      ])
+#        l_IPROC.append(ssep['PROFONDEUR'     ])
+#        l_ISLC.append( ssep['POSI_CURV_LONGI'])
+#        l_IBETC.append(BETA)
+        ssep.BETA=BETA
+#        l_ISCC.append( ssep['POSI_CURV_CIRC' ])
+#        l_IPHIC.append(ssep['AZIMUT'         ])
+#        l_IPOS.append( ssep['SOUS_EPAIS'     ])
+#        l_INBEL.append(ssep['NB_ELEM_LONGI'  ])
+#        l_INBEC.append(ssep['NB_ELEM_CIRC'   ])
+#        l_IEVID.append(ssep['EMPREINTE'      ])
+
+     if SOUS_EPAIS_COUDE!=None and COUDE['NB_ELEM_EPAIS']!=3 :
+        UTMESS('A','ASCOUF0_35')
+#
+################################################################################
+#     --- verifications de coherences ---
+################################################################################
+#
+# donnees globales
+  if COUDE['TRANSFORMEE']=='COUDE' or COUDE['TRAN_EPAIS']=='NON' :
+    if SUREP<0. or SUREP>(RM-EP1/2.0):
+
+       UTMESS('F','ASCOUF0_36',vali=SUREP,valr=RM-EP1/2.0)
+  if RC<=(RM+EP1/2.0):
+     UTMESS('F','ASCOUF0_37',valr=[RC,RM+EP1/2.0])
+#
+# coude fissure
+#
+  if FISS_COUDE!=None:
+    if (RM/EP1)<5. or (RM/EP1)>50.:
+       UTMESS('F','ASCOUF0_38',valr=RM/EP1)
+    if FISS_COUDE['ABSC_CURV']!=None:
+     if SF<0. or SF>(ALPHA*RC*pi/180.0) :
+       UTMESS('F','ASCOUF0_39',valr=[SF,ALPHA*RC*pi/180.0])
+    if (NT-2*(NT/2))!=0:
+       UTMESS('F','ASCOUF0_40',vali=NT)
+    if FISS_COUDE['ABSC_CURV'] and ((BETA<0.) or (BETA>ALPHA)):
+       UTMESS('F','ASCOUF0_41',valr=[BETA,ALPHA])
+#
+# transition d epaisseur
+#
+  if NBTRAN!=0:
+    LCOUDE = ALPHA * RC * pi / 180.0
+    DEXT = 2.0*RM + EP1
+    if (LTRAN<LDEFAU) and (LTRAN>LCOUDE) :
+       UTMESS('F','ASCOUF0_42',valr=[LTRAN,LDEFAU,LCOUDE])
+    if (TETA1<0.) or (TETA1>30.) :
+       UTMESS('F','ASCOUF0_43',valr=[TETA1])  
+#
+# transition d epaisseur a une pente
+#
+    if NBTRAN==1:
+       if (EP1<12.) or (EP1>80.) :
+          UTMESS('F','ASCOUF0_44',valr=[EP1])
+       if (EP2<20.) or (EP2>110.) :
+          UTMESS('F','ASCOUF0_45',valr=[EP2])
+       if (EP1>EP2) :
+          UTMESS('F','ASCOUF0_46')
+       LTRANF = LTRAN + ((EP2-EP1)/(tan(TETA1)))
+       if (LTRANF>LCOUDE) :
+          UTMESS('F','ASCOUF0_47',valr=[LTRANF,LCOUDE])
+       if DEXT<112. or DEXT>880. :
+          UTMESS('F','ASCOUF0_48',valr=[DEXT])
+#
+# transition d epaisseur a une pente
+#
+    else:
+       if (TETA2<0.) or (TETA2>45.) :
+          UTMESS('F','ASCOUF0_49',valr=[TETA2])
+       if (EP1<7.) or (EP1>35.) :
+          UTMESS('F','ASCOUF0_50',valr=[EP1])
+       if (EP2<15.) or (EP2>40.) :
+          UTMESS('F','ASCOUF0_51',valr=[EP2])
+       if (EPI<15.) or (EPI>40.) :
+          UTMESS('F','ASCOUF0_52',valr=[EPI])
+       if (EP1>EPI) :
+          UTMESS('F','ASCOUF0_53')
+       if (EP2<EPI) :
+          UTMESS('F','ASCOUF0_54')
+       LTRANF = LTRAN  + (EPI-EP1)/(tan(TETA1))
+       LTRANF = LTRANF + (EP2-EPI)/(tan(TETA2))
+       if (LTRANF>LCOUDE) :
+          UTMESS('F','ASCOUF0_55',valr=[LTRANF,LCOUDE])
+       if (DEXT<77.) or (DEXT>355.) :
+          UTMESS('F','ASCOUF0_56',valr=[LTRANF])
+#
+################################################################################
+#     --- calcul taille initiale des defauts sur la plaque ---
+################################################################################
+#
+#
+  if FISS_COUDE!=None:
+     DSF=(FISS_COUDE['ABSC_CURV']!=None)
+     AXEAP,AXECP,SFP = ASCFIS(ALPHA, RM, RC, EP1, SUREP, GEOM, FPROF,
+                              DGAXEC, AZIM, POSIT, SF, DSF, BETA, ORIEN)
+  elif MCL_SOUS_EPAIS!=None :
+     ier,AZIMC= ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP1,GEOM,SYME)
+     for ssep in MCL_SOUS_EPAIS:
+         ssep.IDENL = ssep.ILONP/ssep['NB_ELEM_LONGI']*180./(pi*RC)
+         ssep.IDENC = ssep.ICIRP/ssep['NB_ELEM_CIRC']*180./(pi*RM)
+     if SYME=='QUART' :
+#       quart de structure     
+        ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY\
+        = ASCSYM(MCL_SOUS_EPAIS,RM,RC,ALPHA,LTCHAR,LTCLIM)
+     else :
+#       demi-structure ou entiere
+        ier,NLX,NLY,NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,DNX,DNY\
+        = ASCPRE(MCL_SOUS_EPAIS,RM,RC,ALPHA,SYME,LTCHAR,LTCLIM)
+#
+#
+  loc_gibi=aster.repout()
+  logiel = EXEC_MAILLAGE['LOGICIEL'  ]
+  UNITD  = EXEC_MAILLAGE['UNITE_DATG']
+  UNITP  = EXEC_MAILLAGE['UNITE_MGIB']
+  if   logiel=='GIBI98'  : logiel = loc_gibi+'gibi98'
+  elif logiel=='GIBI2000': logiel = loc_gibi+'gibi2000'
+  
+  else                   :
+       UTMESS('F','ASCOUF0_57')
+#
+#     --- ecriture sur le fichier .datg  de la procedure ---
+#
+# Nom du fichier de commandes pour GIBI
+  nomFichierDATG = 'fort.'+str(UNITD)
+# Nom du fichier de maillage GIBI
+  nomFichierGIBI = 'fort.'+str(UNITP)
+  loc_datg = aster.repdex()
+#
+  if FISS_COUDE!=None:
+#   procedure coude fissure (MOT-CLE FISS_COUDE)
+    write_file_dgib_ASCFDO(nomFichierDATG,RM,RC,ALPHA,NBTRAN,EP1,EP2,EPI,TETA1,
+                           TETA2,LTRAN,SUREP,LTCHAR,LTCLIM,TYPBOL,AXEAP,AXECP,NT,NS,NC,SFP,
+                           ORIEN,AZIM,RC0,RC2,RC3,POSIT,EPSI,NIVMAG,SYME,loc_datg)
+  elif MCL_SOUS_EPAIS!=None :
+     if SOUS_EPAIS_MULTI==None :
+#      procedure coude sous-ep.: (MOT-CLE SOUS_EPAIS_COUDE)  
+       write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2,
+                              EPI,TETA1,MCL_SOUS_EPAIS,TETA2,LTRAN,LTCHAR,LTCLIM,GEOM,
+                              SYME,NBEP,NLX,NLY,NIVMAG,SUREP,AZIMC,loc_datg)
+       write_file_pgib_ASCSQ2(MCL_SOUS_EPAIS,NLX,NLY)
+     else:
+#      procedure coude sous-ep.:(MOT-CLE SOUS_EPAIS_MULTI)
+       write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg)
+       write_file_pgib_ASCSDO(RM,RC,ALPHA,EP1,LTCLIM,LTCHAR,NBEP,SUREP,
+                              NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,
+                              DNX,DNY,MCL_SOUS_EPAIS,GEOM,SYME)
+       write_file_pgib_ASCSP2(MCL_SOUS_EPAIS,NLX,NLY)
+  else:
+#   procedure coude regle
+    write_file_dgib_ASCRDO(nomFichierDATG,TYPELE,NIVMAG,TYPBOL,ALPHA,RC,RM,EP1,SUREP,
+                           LTCLIM,LTCHAR,NBEP,loc_datg)
+
+  
+# GIBI  
+  DEFI_FICHIER(ACTION='LIBERER',UNITE=19)
+  DEFI_FICHIER(ACTION='LIBERER',UNITE=20)
+  EXEC_LOGICIEL( LOGICIEL = logiel ,
+                 ARGUMENT = (nomFichierDATG,
+                             nomFichierGIBI), )
+# PRE_GIBI
+  PRE_GIBI()
+
+# LIRE_MAILLAGE
+  __nomres=LIRE_MAILLAGE(INFO=INFO)
+
+# DEFI_GROUP  1
+
+  motscles={}
+  l_CREA_GROUP_NO=[]
+  l_CREA_GROUP_NO.append('BORD1')
+  l_CREA_GROUP_NO.append('CLGV')
+  l_CREA_GROUP_NO.append('BORD2')
+  l_CREA_GROUP_NO.append('PEAUINT')
+  l_CREA_GROUP_NO.append('PEAUEXT') 
+
+# cas des fissures axisymetriques
+  if FISS_COUDE!=None:
+    if FISS_COUDE['AXIS']=='OUI':
+      motscles['CREA_GROUP_MA']=[]
+      motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS',
+                                          NOM      = 'MAIL_ORI',
+                                          POSITION = 'INIT'    , ),) 
+
+# conversion des groupes de mailles en groupes du bloc fissure  
+  if FISS_COUDE!=None:
+    if SYME == 'ENTIER':
+      l_CREA_GROUP_NO.append('NOLIG1')
+      l_CREA_GROUP_NO.append('FACE1')
+    l_CREA_GROUP_NO.append('NOLIG2')
+    l_CREA_GROUP_NO.append('FACE2')
+    l_CREA_GROUP_NO.append('FONDFISS')
+
+  motscles['CREA_GROUP_NO']=[]
+  motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=tuple(l_CREA_GROUP_NO)))
+
+# conversion des groupes de mailles en groupes de noeuds pour les
+# ligaments des sous-ep.
+  if MCL_SOUS_EPAIS!=None:
+    issep=0
+    for ssep in MCL_SOUS_EPAIS:
+      issep=issep+1
+      if ssep['TYPE']=='ELLI':
+        for k in range(2*NLX[issep-1]+1):
+          chtmp=str(issep)+'_'+str(k+1)
+          ch1='CIR'+chtmp
+          ch2='ICI'+chtmp
+          motscles['CREA_GROUP_NO'].append(_F(NOM      = ch2,
+                                              GROUP_MA = ch1,),)
+        motscles['CREA_GROUP_NO'].append(_F(NOM      = 'IPCEN'+str(issep),
+                                            GROUP_MA = 'PCENT'+str(issep),),)
+        for k in range(2*NLY[issep-1]+1):
+          chtmp=str(issep)+'_'+str(k+1)
+          ch1='LON'+chtmp
+          ch2='ILO'+chtmp
+          motscles['CREA_GROUP_NO'].append(_F(NOM      = ch2,
+                                              GROUP_MA = ch1,),)
+        for k in range(2*NLX[issep-1]+1):
+          chtmp=str(issep)+'_'+str(k+1)
+          ch1='ICI'+chtmp
+          ch2='OCI'+chtmp
+          ch3='ECI'+chtmp
+          motscles['CREA_GROUP_NO'].append(_F(NOM      = ch2,
+                                              INTERSEC = ('PEAUEXT',ch1),),)
+          motscles['CREA_GROUP_NO'].append(_F(NOM      = ch3,
+                                              INTERSEC = ('PEAUINT',ch1),),)
+        motscles['CREA_GROUP_NO'].append(_F(NOM      = 'OPCEN'+str(issep),
+                                            INTERSEC = ('PEAUEXT','IPCEN'+str(issep),),),)
+        motscles['CREA_GROUP_NO'].append(_F(NOM      = 'EPCEN'+str(issep),
+                                            INTERSEC = ('PEAUINT','IPCEN'+str(issep),),),)
+        for k in range(2*NLY[issep-1]+1):
+          chtmp=str(issep)+'_'+str(k+1)
+          ch1='ILO'+chtmp
+          ch2='OLO'+chtmp
+          ch3='ELO'+chtmp
+          motscles['CREA_GROUP_NO'].append(_F(NOM      = ch2,
+                                              INTERSEC =  ('PEAUEXT',ch1),),)
+          motscles['CREA_GROUP_NO'].append(_F(NOM      = ch3,
+                                              INTERSEC =  ('PEAUINT',ch1),),)
+        for k in range(2*NLX[issep-1]+1):
+          chtmp=str(issep)+'_'+str(k+1)
+          ch1='CIR'+chtmp
+          ch2='ICI'+chtmp
+          ch3='OCI'+chtmp
+          ch4='ECI'+chtmp  
+          motscles['CREA_GROUP_NO'].append(_F(OPTION        = 'SEGM_DROI_ORDO',
+                                              NOM           = ch1,
+                                              GROUP_NO      = ch2,
+                                              GROUP_NO_ORIG = ch3,
+                                              GROUP_NO_EXTR = ch4,
+                                              PRECISION     = PRECIS,
+                                              CRITERE       = CRITER,),)
+        motscles['CREA_GROUP_NO'].append(_F(OPTION        = 'SEGM_DROI_ORDO',
+                                            NOM           = 'PCENT'+str(issep),
+                                            GROUP_NO      = 'IPCEN'+str(issep),
+                                            GROUP_NO_ORIG = 'OPCEN'+str(issep),
+                                            GROUP_NO_EXTR = 'EPCEN'+str(issep),
+                                            PRECISION     =  PRECIS,
+                                            CRITERE       =  CRITER,),)
+        for k in range(2*NLY[issep-1]+1):
+           chtmp=str(issep)+'_'+str(k+1)
+           ch1='LON'+chtmp
+           ch2='ILO'+chtmp
+           ch3='OLO'+chtmp
+           ch4='ELO'+chtmp  
+           motscles['CREA_GROUP_NO'].append(_F(OPTION        = 'SEGM_DROI_ORDO',
+                                               NOM           = ch1,
+                                               GROUP_NO      = ch2,
+                                               GROUP_NO_ORIG = ch3,
+                                               GROUP_NO_EXTR = ch4,
+                                               PRECISION     = PRECIS,
+                                               CRITERE       = CRITER,),)
+#     1/ noms intermediaires des groupes de noeuds representant les ligaments
+#        des sections: TU,MI,GV et sous-ep.     
+      for k in range(8):
+        motscles['CREA_GROUP_NO'].append(_F( NOM      = CAR3[k]+str(issep),
+                                             GROUP_MA = CAR6[k]+str(issep),),)
+
+    for k in range(3):
+      if SYME == 'ENTIER' or k!=2:
+        for j in range(8):
+          motscles['CREA_GROUP_NO'].append(_F( NOM      = CAR3[j]+SECT[k],
+                                               GROUP_MA = CAR6[j]+SECT[k],),)
+
+#   2/ determination et nommage des noeuds origine et extremite des groupes de noeuds
+#      representant les ligaments de la ou des sections: sous-ep.
+    issep=0
+    for ssep in MCL_SOUS_EPAIS:
+      issep=issep+1
+      for k in range(8):
+        motscles['CREA_GROUP_NO'].append(_F( NOM      = CAR4[k]+str(issep),
+                                             INTERSEC = ('PEAUEXT',CAR3[k]+str(issep),),),)
+        motscles['CREA_GROUP_NO'].append(_F( NOM      = CAR5[k]+str(issep),
+                                             INTERSEC = ('PEAUINT',CAR3[k]+str(issep),),),)        
+#     3/ nommage final des groupes de noeuds representant les ligaments 
+#        de la ou des sections: sous-ep.
+      for k in range(8):
+        motscles['CREA_GROUP_NO'].append(_F(OPTION        = 'SEGM_DROI_ORDO',
+                                            NOM           = CAR6[k]+str(issep),
+                                            GROUP_NO      = CAR3[k]+str(issep),
+                                            GROUP_NO_ORIG = CAR4[k]+str(issep),
+                                            GROUP_NO_EXTR = CAR5[k]+str(issep),
+                                            PRECISION     = PRECIS,
+                                            CRITERE       = CRITER,),)
+
+#   4/ determination et nommage des noeuds origine et extremite des groupes de noeuds
+#      representant les ligaments des sections: TU,MI,GV
+    for k in range(3):
+      if SYME == 'ENTIER' or k!=2:
+        for j in range(8):
+           motscles['CREA_GROUP_NO'].append(_F( NOM      = CAR4[j]+SECT[k],
+                                                INTERSEC = ('PEAUEXT',CAR3[j]+SECT[k],),),) 
+           motscles['CREA_GROUP_NO'].append(_F( NOM      = CAR5[j]+SECT[k],
+                                                INTERSEC = ('PEAUINT',CAR3[j]+SECT[k],),),) 
+#       5/ nommage final des groupes de noeuds representant les ligaments des sections: TU,MI,GV   
+        for j in range(8):    
+           motscles['CREA_GROUP_NO'].append(_F(OPTION        = 'SEGM_DROI_ORDO',
+                                               NOM           = CAR6[j]+SECT[k],
+                                               GROUP_NO      = CAR3[j]+SECT[k],
+                                               GROUP_NO_ORIG = CAR4[j]+SECT[k],
+                                               GROUP_NO_EXTR = CAR5[j]+SECT[k],
+                                               PRECISION     = PRECIS,
+                                               CRITERE       = CRITER,),)
+    
+
+  __nomres=DEFI_GROUP(reuse   =__nomres,
+                      MAILLAGE=__nomres,
+                      **motscles )
+#
+# DEFI_GROUP  2
+  if FISS_COUDE!=None:
+# creation des groupes petit axe et grand axe fissure par
+# intersection de groupes existants
+    motscles={}
+    motscles['CREA_GROUP_NO']=[]
+    l_peau=[]
+    l_intersec=[]
+    if POSIT == 'DEB_INT':
+        l_peau.append('PEAUINT')
+    else:
+        l_peau.append('PEAUEXT')
+    
+    if SYME == 'ENTIER' :
+      l_intersec.append('FACE1')
+      motscles['CREA_GROUP_NO'].append(_F(NOM      = 'P_AXE_1',
+                                          INTERSEC = ('NOLIG1','FACE1'),),)
+      motscles['CREA_GROUP_NO'].append(_F(NOM      = 'G_AXE_1',
+                                          INTERSEC =  tuple(l_peau+l_intersec),),)  
+    l_intersec=[]
+    l_intersec.append('FACE2')  
+    motscles['CREA_GROUP_NO'].append(_F(NOM      = 'P_AXE_2',
+                                        INTERSEC = ('NOLIG2','FACE2'),),)
+    motscles['CREA_GROUP_NO'].append(_F(NOM      = 'G_AXE_2',
+                                        INTERSEC =  tuple(l_peau+l_intersec),),)
+   
+    __nomres=DEFI_GROUP(reuse   =__nomres,
+                        MAILLAGE=__nomres,
+                        **motscles )    
+ 
+# MODI_MAILLAGE  1
+  motscles={}
+  if GEOM == 'COUDE':
+    motscles['TUBE_COUDE']=[]
+    motscles['TUBE_COUDE'].append(_F(ANGLE=ALPHA,
+                                    R_CINTR=RC,
+                                    L_TUBE_P1=LTCHAR),)
+  motscles['PLAQ_TUBE']=[]
+  D_PLAQ_TUBE={}
+  D_PLAQ_TUBE['DEXT']=DEXT
+  D_PLAQ_TUBE['EPAIS']=EP1
+  D_PLAQ_TUBE['L_TUBE_P1']=LTCHAR
+  if SYME == 'QUART' : D_PLAQ_TUBE['COUTURE']='NON'
+  if FISS_COUDE!=None:
+      D_PLAQ_TUBE['AZIMUT']=AZIM
+  elif SOUS_EPAIS_COUDE!=None :
+      D_PLAQ_TUBE['AZIMUT']=MCL_SOUS_EPAIS[0].IPHIC
+  else:pass
+  motscles['PLAQ_TUBE'].append(_F(**D_PLAQ_TUBE),) 
+  __nomres=MODI_MAILLAGE( reuse   =__nomres,
+                          MAILLAGE=__nomres,
+                          **motscles )
+ 
+# MODI_MAILLAGE  2
+  motscles={}
+  motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXTUBE'),)
+  if FISS_COUDE!=None:
+    if FISS_COUDE['FISSURE'] == 'DEB_INIT':
+      motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXTUBE','FACE1','FACE2'),)  
+  __nomres=MODI_MAILLAGE(reuse   =__nomres,
+                       MAILLAGE=__nomres,
+                       **motscles)
+
+# CREA_MAILLAGE
+  self.DeclareOut('nomre2',self.sd)
+  motscles={}
+  motscles['CREA_POI1']=[]
+  motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P1',
+                                  GROUP_NO='P1'),)
+  if TYPBOL == None :
+    motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P2',
+                                  GROUP_NO='P2'),)    
+  nomre2=CREA_MAILLAGE( MAILLAGE=__nomres,
+                          **motscles)
+
+ 
+# IMPRESSSION
+  if IMPRESSION!=None:
+     if IMPRESSION.__class__.__name__  !='MCList' : IMPRESSION  =[IMPRESSION,]
+     for impr in IMPRESSION :
+#
+         motscles={}
+         if impr['FORMAT']=='IDEAS'  : motscles['VERSION']   =impr['VERSION']
+         if impr['FORMAT']=='CASTEM' : motscles['NIVE_GIBI'] =impr['NIVE_GIBI']
+         if impr['UNITE']!=None      : motscles['UNITE']     =impr['UNITE']
+         impr_resu = _F( MAILLAGE = nomre2,)
+#
+         IMPR_RESU( RESU = impr_resu,
+                    FORMAT= impr['FORMAT'],**motscles)
+
+
+
+  return ier
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py
new file mode 100644 (file)
index 0000000..2ab5b99
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py
@@ -0,0 +1,863 @@
+#@ MODIF macr_aspic_calc_ops Macro  DATE 03/08/2009   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.
+# ======================================================================
+
+
+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,
+                             THETA_3D,OPTION,SOLVEUR,CONVERGENCE,NEWTON,RECH_LINEAIRE,
+                             INCREMENT,PAS_AZIMUT,IMPRESSION,INFO,TITRE,BORNES ,**args):
+  """
+     Ecriture de la macro MACR_ASPIC_CALC
+  """
+  from Accas import _F
+  import types
+  from Utilitai.Utmess     import  UTMESS
+  ier=0
+#------------------------------------------------------------------
+  # On recopie le mot cle affe_materiau pour le proteger
+  mc_AFFE_MATERIAU=AFFE_MATERIAU
+#------------------------------------------------------------------
+  # On importe les definitions des commandes a utiliser dans la macro
+  AFFE_MODELE      =self.get_cmd('AFFE_MODELE'     )
+  AFFE_MATERIAU    =self.get_cmd('AFFE_MATERIAU'   )
+  AFFE_CARA_ELEM   =self.get_cmd('AFFE_CARA_ELEM'  )
+  AFFE_CHAR_THER_F =self.get_cmd('AFFE_CHAR_THER_F')
+  THER_LINEAIRE    =self.get_cmd('THER_LINEAIRE'   )
+  AFFE_CHAR_MECA   =self.get_cmd('AFFE_CHAR_MECA'  )
+  STAT_NON_LINE    =self.get_cmd('STAT_NON_LINE'   )
+  CALC_ELEM        =self.get_cmd('CALC_ELEM'       )
+  POST_RELEVE_T    =self.get_cmd('POST_RELEVE_T'   )
+  IMPR_TABLE       =self.get_cmd('IMPR_TABLE'      )
+  POST_RCCM        =self.get_cmd('POST_RCCM'       )
+  DEFI_FOND_FISS   =self.get_cmd('DEFI_FOND_FISS'  )
+  CALC_THETA       =self.get_cmd('CALC_THETA'      )
+  CALC_G           =self.get_cmd('CALC_G'          )
+  IMPR_RESU        =self.get_cmd('IMPR_RESU'       )
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+#------------------------------------------------------------------
+# data
+  GRMAIL= ('EQUERRE','PEAUINT','EXCORP1','EXCORP2','EXTUBU','LEVRTUBU','LEVRCORP')
+  NOMNOE= ('P1_CORP','P2_CORP','P_TUBU ')
+  IMPRT1= ('NUME_ORDRE','INTITULE','RESU'  ,'NOM_CHAM',
+           'ABSC_CURV' ,'COOR_X'  ,'COOR_Y','COOR_Z'  ,
+           'SIXX'      ,'SIXY'    ,'SIXZ'   )
+  IMPRT2= ('NUME_ORDRE','INTITULE','RESU'  ,'NOM_CHAM',
+           'ABSC_CURV' ,'COOR_X'  ,'COOR_Y','COOR_Z'  ,
+           'SIYY'      ,'SIXY'    ,'SIYZ'   )
+  IMPRT3= ('NUME_ORDRE','INTITULE','RESU'  ,'NOM_CHAM',
+           'ABSC_CURV' ,'COOR_X'  ,'COOR_Y','COOR_Z'  ,
+           'TEMP'   )
+  APPRES= ('PEAUINT ','LEVRTUBU','LEVRCORP')
+#------------------------------------------------------------------
+#
+  i=0
+  for mate in mc_AFFE_MATERIAU:
+     if mate['RCCM']=='OUI' :
+        i=i+1
+        MRCCM=mate['MATER']
+  if i>1 :
+     UTMESS('E','ASPIC0_1')
+#
+  if (TYPE_MAILLAGE[:4]=='SAIN') and (TUBULURE==None) :
+     UTMESS('E','ASPIC0_2')
+#
+  if EQUILIBRE['NOEUD'] not in ('P1_CORP','P2_CORP') :
+     UTMESS('E','ASPIC0_3')
+#
+  if PRES_REP['EFFE_FOND']=='OUI' :
+     if PRES_REP['NOEUD']==None :
+       UTMESS('E','ASPIC0_4')
+     if PRES_REP['NOEUD'] not in ('P1_CORP','P2_CORP') :
+       UTMESS('E','ASPIC0_5')
+     if PRES_REP['NOEUD']==EQUILIBRE['NOEUD'] :
+       UTMESS('E','ASPIC0_6')
+#
+  if TORS_CORP!=None :
+     for tors in TORS_CORP :
+         if tors['NOEUD'] not in ('P1_CORP','P2_CORP') :
+            UTMESS('E','ASPIC0_7')
+         if tors['NOEUD']==EQUILIBRE['NOEUD'] :
+            UTMESS('E','ASPIC0_8')
+#
+  if (TYPE_MAILLAGE[:4]=='SAIN') and (THETA_3D!=None) :
+     UTMESS('E','ASPIC0_9')
+#
+  if OPTION in ('CALC_G_MAX','CALC_G_MAX_LOCAL') :
+    if BORNES==None :
+       UTMESS('E','ASPIC0_10')
+#
+  if IMPRESSION!=None :
+    if IMPRESSION['FORMAT'] in ('IDEAS','CASTEM') :
+      if IMPRESSION['NOM_CHAM']==None :
+       UTMESS('E','ASPIC0_11')
+#
+#------------------------------------------------------------------
+#
+#     --- commande AFFE_MODELE ---
+#
+  if MODELE!=None : self.DeclareOut('modele',MODELE)
+  mcfact=[]
+  if (PRES_REP['PRES_LEVRE']=='OUI') and (TYPE_MAILLAGE[-4:]=='_DEB') :
+     mcfact.append(_F(GROUP_MA=GRMAIL,     PHENOMENE='MECANIQUE',MODELISATION='3D'    ))
+  else:
+     mcfact.append(_F(GROUP_MA=GRMAIL[:-2],PHENOMENE='MECANIQUE',MODELISATION='3D'    ))
+  mcfact.append(   _F(GROUP_MA='P1_CORP'  ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR'))
+  mcfact.append(   _F(GROUP_MA='P2_CORP'  ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR'))
+  mcfact.append(   _F(GROUP_MA='P_TUBU'   ,PHENOMENE='MECANIQUE',MODELISATION='DIS_TR'))
+  modele = AFFE_MODELE( MAILLAGE = MAILLAGE ,
+                        AFFE     = mcfact    )
+  if ECHANGE!=None :                                # modele thermique
+     __modthe = AFFE_MODELE( MAILLAGE = MAILLAGE ,
+                             AFFE     = _F(GROUP_MA    =GRMAIL[:-2],
+                                           PHENOMENE   ='THERMIQUE',
+                                           MODELISATION='3D' )       )
+#
+#     --- commande AFFE_MATERIAU (thermique)---
+#
+  mcfact=[]
+  for mater in mc_AFFE_MATERIAU :
+     if mater['TOUT']!=None : mcfact.append(_F(TOUT    =mater['TOUT'    ],MATER=mater['MATER']))
+     else                   : mcfact.append(_F(GROUP_MA=mater['GROUP_MA'],MATER=mater['MATER']))
+  __affmat = AFFE_MATERIAU( MAILLAGE = MAILLAGE ,
+                          MODELE   = modele ,
+                          AFFE     = mcfact    )
+#
+#     --- commande AFFE_CARA_ELEM ---
+#
+  if CARA_ELEM!=None : self.DeclareOut('carael',CARA_ELEM)
+  carael = AFFE_CARA_ELEM( MODELE   = modele ,
+                           DISCRET  = ( _F( GROUP_MA='P1_CORP' ,
+                                            CARA    ='K_TR_D_N',
+                                            VALE    = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ),
+                                        _F( GROUP_MA='P2_CORP' ,
+                                            CARA    ='K_TR_D_N',
+                                            VALE    = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ),
+                                        _F( GROUP_MA='P_TUBU' ,
+                                            CARA    ='K_TR_D_N',
+                                            VALE    = ( 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 ) ), ) )
+#
+#     --- commande AFFE_CHAR_THER_F ---
+#         condition aux limites
+#
+  if ECHANGE!=None :
+     __chther = AFFE_CHAR_THER_F( MODELE = __modthe ,
+                                  ECHANGE=( _F(GROUP_MA='PEAUTUBU',
+                                               COEF_H  =ECHANGE['COEF_H_TUBU'],
+                                               TEMP_EXT=ECHANGE['TEMP_EXT'],),
+                                            _F(GROUP_MA='PEAUCORP',
+                                               COEF_H  =ECHANGE['COEF_H_CORP'],
+                                               TEMP_EXT=ECHANGE['TEMP_EXT'],),))
+#
+#     --- calcul thermique ---
+#
+     if RESU_THER!=None : self.DeclareOut('resuth',RESU_THER)
+     mcsimp={}
+     if INCREMENT['NUME_INST_INIT']!=None : mcsimp['NUME_INST_INIT']=INCREMENT['NUME_INST_INIT']
+     if INCREMENT['NUME_INST_FIN' ]!=None : mcsimp['NUME_INST_FIN' ]=INCREMENT['NUME_INST_FIN' ]
+     mcfact=_F(LIST_INST=INCREMENT['LIST_INST'],**mcsimp)
+     resuth = THER_LINEAIRE( MODELE     = __modthe ,
+                             CHAM_MATER = __affmat ,
+                             ETAT_INIT  = _F(STATIONNAIRE='OUI',),
+                             EXCIT      = _F(CHARGE=__chther,),
+                             INCREMENT  = mcfact, )
+#
+#     --- commande AFFE_MATERIAU (mécanique)---
+#
+  if CHAM_MATER!=None : self.DeclareOut('affmth',CHAM_MATER)
+  indther=0
+  if ECHANGE!=None and RESU_THER!=None : indther=1
+  mcfact=[]
+  mcfac2=[]
+  for mater in mc_AFFE_MATERIAU :
+     if mater['TOUT']!=None :
+       mcfact.append(_F(TOUT    =mater['TOUT'    ],MATER=mater['MATER'],))
+       if indther==1:
+         mcfac2.append(_F(NOM_VARC='TEMP',TOUT='OUI',
+                        EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF']),)
+     else:
+       mcfact.append(_F(GROUP_MA=mater['GROUP_MA'],MATER=mater['MATER'],))
+       if indther==1:
+         mcfac2.append(_F(NOM_VARC='TEMP',GROUP_MA=mater['GROUP_MA'],
+                        EVOL=resuth,NOM_CHAM='TEMP',VALE_REF=mater['TEMP_REF']),)
+  affmth = AFFE_MATERIAU( MAILLAGE = MAILLAGE ,
+                          MODELE   = modele ,
+                          AFFE     = mcfact,
+                          AFFE_VARC= mcfac2,)
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         condition aux limites
+#
+  if     EQUILIBRE['NOEUD']=='P1_CORP' :
+         NENCAS = EQUILIBRE['NOEUD']
+         AEFOCO = 'EXCORP2'
+         ATORCO = 'P2_CORP'
+         LINTC  = 'L_INT_C2'
+  elif   EQUILIBRE['NOEUD']=='P2_CORP' :
+         NENCAS = EQUILIBRE['NOEUD']
+         AEFOCO = 'EXCORP1'
+         ATORCO = 'P1_CORP'
+         LINTC  = 'L_INT_C1'
+  _conlim = AFFE_CHAR_MECA(  MODELE   = modele ,
+                             LIAISON_ELEM  = ( _F( OPTION    ='3D_POU'  ,
+                                                   GROUP_MA_1='EXCORP1',
+                                                   GROUP_NO_2='P1_CORP'),
+                                               _F( OPTION    ='3D_POU'  ,
+                                                   GROUP_MA_1='EXCORP2' ,
+                                                   GROUP_NO_2='P2_CORP'),
+                                               _F( OPTION    ='3D_POU'  ,
+                                                   GROUP_MA_1='EXTUBU',
+                                                   GROUP_NO_2='P_TUBU'), ),
+                             DDL_IMPO      =   _F( GROUP_NO  = NENCAS  ,
+                                                   DX        = 0.0 ,
+                                                   DY        = 0.0 ,
+                                                   DZ        = 0.0 ,
+                                                   DRX       = 0.0 ,
+                                                   DRY       = 0.0 ,
+                                                   DRZ       = 0.0 , ) )
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         chargement mecanique : pres_rep, effet de fond
+#
+  motscles={}
+  if (PRES_REP['PRES_LEVRE']=='OUI') and (TYPE_MAILLAGE[-4:]=='_DEB') :
+      motscles['PRES_REP'  ]= _F(GROUP_MA=APPRES,   PRES=PRES_REP['PRES'])
+  else :
+      motscles['PRES_REP'  ]= _F(GROUP_MA=APPRES[0],PRES=PRES_REP['PRES'])
+  if  PRES_REP['EFFE_FOND' ]=='OUI' :
+      motscles['EFFE_FOND' ]=(_F(GROUP_MA    ='EXTUBU  ',
+                                 GROUP_MA_INT='L_INT_TU',
+                                 PRES        =PRES_REP['PRES']),
+                              _F(GROUP_MA    =AEFOCO,
+                                 GROUP_MA_INT=LINTC,
+                                 PRES        =PRES_REP['PRES']))
+  _chpres = AFFE_CHAR_MECA( MODELE   = modele ,**motscles)
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         chargement mecanique : torseur sur le corps
+#
+  if TORS_CORP!=None:
+     _chtrc = [None]*6
+     i=0
+     for tors in TORS_CORP :
+       mcsimp={}
+       if tors['FX']!=None : mcsimp['FX']=tors['FX']
+       if tors['FY']!=None : mcsimp['FY']=tors['FY']
+       if tors['FZ']!=None : mcsimp['FZ']=tors['FZ']
+       if tors['MX']!=None : mcsimp['MX']=tors['MX']
+       if tors['MY']!=None : mcsimp['MY']=tors['MY']
+       if tors['MZ']!=None : mcsimp['MZ']=tors['MZ']
+       mcfact=_F(GROUP_NO=ATORCO,**mcsimp)
+       _chtrc[i] = AFFE_CHAR_MECA(  MODELE       = modele ,
+                                    FORCE_NODALE = mcfact , )
+       i=i+1
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         chargement mecanique : torseur sur la tubulure
+#
+  if TORS_TUBU!=None:
+     _chtrt = [None]*6
+     i=0
+     for tors in TORS_TUBU :
+       mcsimp={}
+       if tors['FX']!=None : mcsimp['FX']=tors['FX']
+       if tors['FY']!=None : mcsimp['FY']=tors['FY']
+       if tors['FZ']!=None : mcsimp['FZ']=tors['FZ']
+       if tors['MX']!=None : mcsimp['MX']=tors['MX']
+       if tors['MY']!=None : mcsimp['MY']=tors['MY']
+       if tors['MZ']!=None : mcsimp['MZ']=tors['MZ']
+       mcfact=_F(GROUP_NO='P_TUBU  ',**mcsimp)
+       _chtrt[i] = AFFE_CHAR_MECA( MODELE       = modele ,
+                                    FORCE_NODALE = mcfact , )
+       i=i+1
+
+#
+#     --- commande AFFE_CHAR_MECA ---
+#         chargement mecanique :  verif contact levres
+#
+  if TYPE_MAILLAGE[:4]=='FISS' :
+    if TYPE_MAILLAGE in ('FISS_LONG_NONDEB','FISS_AXIS_NONDEB') :
+       mcfond = ('FOND_SUP','FOND_INF')
+    else :
+       mcfond = ('FONDFISS')
+    _chcont = AFFE_CHAR_MECA( MODELE   = modele ,
+                               CONTACT =_F(GROUP_MA_MAIT = 'LEVRCORP',
+                                           GROUP_MA_ESCL = 'LEVRTUBU',
+                                           METHODE='VERIF',
+                                           TOLE_INTERP = -1.e-6,
+                                           GROUP_MA_FOND=mcfond,),)
+
+
+#
+#     --- commande STAT_NON_LINE ---
+#
+  motscles={}
+#
+  mcfex=[]  # mot clé facteur EXCIT
+  mcfex.append(_F(CHARGE=_conlim,))
+  if PRES_REP['FONC_MULT']!=None :
+     mcfex.append(_F(CHARGE=_chpres,FONC_MULT=PRES_REP['FONC_MULT']))
+  else :
+     mcfex.append(_F(CHARGE=_chpres,))
+  if TORS_CORP!=None:
+     i=0
+     for tors in TORS_CORP :
+       if tors['FONC_MULT']!=None :
+          mcfex.append(_F(CHARGE=_chtrc[i],FONC_MULT=tors['FONC_MULT']))
+       else :
+          mcfex.append(_F(CHARGE=_chtrc[i],))
+       i=i+1
+  if TORS_TUBU!=None:
+     i=0
+     for tors in TORS_TUBU :
+       if tors['FONC_MULT']!=None :
+          mcfex.append(_F(CHARGE=_chtrt[i],FONC_MULT=tors['FONC_MULT']))
+       else :
+          mcfex.append(_F(CHARGE=_chtrt[i],))
+       i=i+1
+  if TYPE_MAILLAGE[:4]=='FISS' :
+     mcfex.append(_F(CHARGE=_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']))
+  mcfci.append(  _F(GROUP_MA=NOMNOE,RELATION='ELAS'))
+  motscles['COMP_INCR'] =mcfci
+#
+  if COMP_ELAS!=None :
+    motscles['COMP_ELAS'] =_F(GROUP_MA=GRMAIL[:-2] ,RELATION=COMP_ELAS['RELATION'])
+#
+  dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+  for i in dSolveur.keys():
+      if dSolveur[i]==None : del dSolveur[i]
+#
+  dConverg=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+  for i in dConverg.keys():
+      if dConverg[i]==None : del dConverg[i]
+#
+  dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
+  for i in dNewton.keys():
+      if dNewton[i]==None : del dNewton[i]
+#
+  dRechlin = {}
+  if RECH_LINEAIRE != None:
+     dRechlin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste)
+     for i in dRechlin.keys():
+         if dRechlin[i]==None : del dRechlin[i]
+#
+  dIncrem=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
+  for i in dIncrem.keys():
+      if dIncrem[i]==None : del dIncrem[i]
+#
+  if TITRE!=None :
+    motscles['TITRE'        ] =TITRE
+  motscles  ['SOLVEUR'      ] =dSolveur
+  motscles  ['CONVERGENCE'  ] =dConverg
+  motscles  ['NEWTON'       ] =dNewton
+  motscles  ['RECH_LINEAIRE'] =dRechlin
+  motscles  ['INCREMENT'    ] =dIncrem
+  self.DeclareOut('nomres',self.sd)
+  nomres = STAT_NON_LINE( MODELE     = modele ,
+                          CHAM_MATER = affmth ,
+                          CARA_ELEM  = carael ,
+                          INFO       = INFO   , **motscles)
+#
+  nomres = CALC_ELEM( reuse      = nomres,
+                      RESULTAT   = nomres ,
+                      TOUT_ORDRE = 'OUI'  ,
+                      OPTION     = ('SIEF_ELNO_ELGA','VARI_ELNO_ELGA','EQUI_ELNO_SIGM') ,
+                      INFO       = INFO ,)
+#
+#-----------------------------------------------------------------------
+  if TYPE_MAILLAGE[:4]=='SAIN' :
+#-----------------------------------------------------------------------
+#
+#     --- post traitement :  POST_RELEVE_T  --- azimuts droits
+#
+#     ----  champs de contrainte SI, SII ET SIII  ----
+#
+    if TYPE_MAILLAGE=='SAIN_GROS' : NBAZIM = 40
+    else                          : NBAZIM = 48
+    mcfact=[]
+    TYPSOU=None
+    if TUBULURE!=None : TYPSOU = TUBULURE['TYPE']
+    for i in range(1,NBAZIM+1,PAS_AZIMUT):
+      if i<10 : NUME = '0'+str(i)
+      else    : NUME =     str(i)
+      mcsimp={}
+      if TYPSOU=='TYPE_1':
+          mcsimp['REPERE' ]='CYLINDRIQUE',
+          mcsimp['ORIGINE']=( 0.0 , 0.0 , 0.0 )
+          mcsimp['AXE_Z'  ]=( 0.0 , 0.0 , 1.0 )
+          INTITD = 'AZI_'+NUME+'_D-REP_CYL'
+      else:
+          mcsimp['REPERE' ]='LOCAL'
+          mcsimp['VECT_Y' ]=( 0.0 , 0.0 , 1.0 )
+          INTITD = 'AZI_'+NUME+'_D-REP_LOC'
+      mcsimp['INTITULE' ]=INTITD
+      mcsimp['GROUP_NO' ]='LD'+str(i)
+      mcfact.append( _F( RESULTAT   = nomres,
+                         TOUT_ORDRE ='OUI',
+                         NOM_CHAM   ='SIEF_ELNO_ELGA',
+                         PRECISION  =55.E-1,
+                         TOUT_CMP   ='OUI',
+                         OPERATION  ='EXTRACTION',**mcsimp))
+    __noposd=POST_RELEVE_T(ACTION = mcfact,
+                           TITRE  = '-- TRAITEMENT DES AZIMUTS DROITS --')
+#
+#     --- IMPR_TABLE dans un repere cylindrique ou local
+#         des champs de contrainte SI, SII ET SIII
+#
+    if TYPSOU=='TYPE_1' : nompara=IMPRT1
+    else                : nompara=IMPRT2
+    IMPR_TABLE(TABLE    = __noposd,
+               NOM_PARA = nompara   )
+#
+#     ----  Pm, Pm+Pb sur les lignes de depouillement  ----
+#
+    if mc_AFFE_MATERIAU[0]['RCCM']=='OUI':
+      mcfact=[]
+      for i in range(1,NBAZIM+1,PAS_AZIMUT):
+        if i<10 : NUME = '0'+str(i)
+        else    : NUME =     str(i)
+        mcsimp={}
+        mcsimp['INTITULE'   ]='LD'+str(i)
+        mcsimp['GROUP_NO'   ]='LD'+str(i)
+        mcsimp['RESULTAT'   ]=nomres
+        mcsimp['TOUT_ORDRE' ]='OUI'
+        mcsimp['NOM_CHAM'   ]='SIEF_ELNO_ELGA'
+        mcsimp['PRECISION'  ]=55.E-1
+        mcsimp['TOUT_CMP'   ]='OUI'
+        mcsimp['OPERATION'  ]='EXTRACTION'
+        mcfact.append( _F(**mcsimp) )
+      __prelsd=POST_RELEVE_T(ACTION=mcfact)
+      __pmpbsd=POST_RCCM(OPTION         = 'PM_PB',
+                         TYPE_RESU_MECA = 'EVOLUTION',
+                         TYPE_RESU      = 'VALE_MAX',
+                         MATER          = MRCCM,
+                         TRANSITOIRE = _F(TABL_RESU_MECA = __prelsd,),
+                         TITRE       = '-- TRAITEMENT DES AZIMUTS DROITS --',)
+      IMPR_TABLE(TABLE = __pmpbsd, )
+#
+#     ----  champ de temperature, si il a ete calcule, sur les lignes de depouillement  ----
+#
+    if ECHANGE!=None :
+      mcfact=[]
+      for i in range(1,NBAZIM+1,PAS_AZIMUT):
+        if i<10 : NUME = '0'+str(i)
+        else    : NUME =     str(i)
+        mcsimp={}
+        mcsimp['GROUP_NO'   ]='LD'+str(i)
+        mcsimp['RESULTAT'   ]=resuth
+        mcsimp['TOUT_ORDRE' ]='OUI'
+        mcsimp['NOM_CHAM'   ]='TEMP'
+        mcsimp['PRECISION'  ]=55.E-1
+        mcsimp['TOUT_CMP'   ]='OUI'
+        mcsimp['INTITULE'   ]='AZI_'+NUME+'_D'
+        mcsimp['OPERATION'  ]='EXTRACTION'
+        mcfact.append( _F(**mcsimp) )
+      __rthazd=POST_RELEVE_T(ACTION=mcfact)
+      IMPR_TABLE(TABLE = __rthazd, )
+#
+#     ----  parametres caracterisant la distribution de temperature,
+#           si elle a ete calculee, dans l epaisseur du ligament  ----
+#
+      mcfact=[]
+      for i in range(1,NBAZIM+1,PAS_AZIMUT):
+        if i<10 : NUME = '0'+str(i)
+        else    : NUME =     str(i)
+        mcsimp={}
+        mcsimp['GROUP_NO'   ]='LD'+str(i)
+        mcsimp['RESULTAT'   ]=resuth
+        mcsimp['TOUT_ORDRE' ]='OUI'
+        mcsimp['NOM_CHAM'   ]='TEMP'
+        mcsimp['PRECISION'  ]=55.E-1
+        mcsimp['TOUT_CMP'   ]='OUI'
+        mcsimp['INTITULE'   ]='AZI_'+NUME+'_D'
+        mcsimp['OPERATION'  ]='MOYENNE'
+        mcfact.append( _F(**mcsimp) )
+      __rmothd=POST_RELEVE_T(ACTION=mcfact)
+      IMPR_TABLE(TABLE = __rmothd, )
+#
+#-----------------------------------------------------------------------
+#
+#     --- post traitement :  POST_RELEVE_T  --- azimuts inclines
+#     --- champs de contrainte SI, SII ET SIII  ----
+#
+    mcfact=[]
+    for i in range(1,NBAZIM+1,PAS_AZIMUT):
+      if i<10 : NUME = '0'+str(i)
+      else    : NUME =     str(i)
+      mcsimp={}
+      mcsimp['GROUP_NO'   ]='LI'+str(i)
+      mcsimp['RESULTAT'   ]=nomres
+      mcsimp['TOUT_ORDRE' ]='OUI'
+      mcsimp['NOM_CHAM'   ]='SIEF_ELNO_ELGA'
+      mcsimp['PRECISION'  ]=55.E-1
+      mcsimp['TOUT_CMP'   ]='OUI'
+      mcsimp['REPERE'     ]='LOCAL'
+      mcsimp['VECT_Y'     ]=( 0.0 , 0.0 , 1.0 )
+      mcsimp['INTITULE'   ]='AZI_'+NUME+'_I-REP_LOC'
+      mcsimp['OPERATION'  ]='EXTRACTION'
+      mcfact.append( _F(**mcsimp) )
+    __noposi=POST_RELEVE_T(ACTION=mcfact)
+    IMPR_TABLE(TABLE = __noposi, )
+#
+#     ----  Pm, Pm+Pb sur les lignes de depouillement  ----
+#
+    if mc_AFFE_MATERIAU[0]['RCCM']=='OUI':
+      mcfact=[]
+      for i in range(1,NBAZIM+1,PAS_AZIMUT):
+        if i<10 : NUME = '0'+str(i)
+        else    : NUME =     str(i)
+        mcsimp={}
+        mcsimp['INTITULE'   ]='LI'+str(i)
+        mcsimp['GROUP_NO'   ]='LI'+str(i)
+        mcsimp['RESULTAT'   ]=nomres
+        mcsimp['TOUT_ORDRE' ]='OUI'
+        mcsimp['NOM_CHAM'   ]='SIEF_ELNO_ELGA'
+        mcsimp['PRECISION'  ]=55.E-1
+        mcsimp['TOUT_CMP'   ]='OUI'
+        mcsimp['OPERATION'  ]='EXTRACTION'
+        mcfact.append( _F(**mcsimp) )
+      __prelsi=POST_RELEVE_T(ACTION=mcfact)
+      __pmpbsi=POST_RCCM(OPTION         = 'PM_PB',
+                         TYPE_RESU_MECA = 'EVOLUTION',
+                         TYPE_RESU      = 'VALE_MAX',
+                         MATER          = MRCCM,
+                         TRANSITOIRE = _F(TABL_RESU_MECA = __prelsi,),
+                         TITRE       = '-- TRAITEMENT DES AZIMUTS INCLINES --',)
+      IMPR_TABLE(TABLE = __pmpbsi, )
+#
+#     ----  champs de temperature,si il a ete calcule, sur les lignes de depouillement  ----
+#
+    if ECHANGE!=None :
+      mcfact=[]
+      for i in range(1,NBAZIM+1,PAS_AZIMUT):
+        if i<10 : NUME = '0'+str(i)
+        else    : NUME =     str(i)
+        mcsimp={}
+        mcsimp['GROUP_NO'   ]='LI'+str(i)
+        mcsimp['RESULTAT'   ]=resuth
+        mcsimp['TOUT_ORDRE' ]='OUI'
+        mcsimp['NOM_CHAM'   ]='TEMP'
+        mcsimp['PRECISION'  ]=55.E-1
+        mcsimp['TOUT_CMP'   ]='OUI'
+        mcsimp['INTITULE'   ]='AZI_'+NUME+'_I'
+        mcsimp['OPERATION'  ]='EXTRACTION'
+        mcfact.append( _F(**mcsimp) )
+      __rthazi=POST_RELEVE_T(ACTION=mcfact)
+      IMPR_TABLE(TABLE    = __rthazi,
+                 NOM_PARA = IMPRT3 )
+#
+#     ----  parametres caracterisant la distribution de temperature,
+#           si elle a ete calculee, dans l epaisseur du ligament  ----
+#
+      mcfact=[]
+      for i in range(1,NBAZIM+1,PAS_AZIMUT):
+        if i<10 : NUME = '0'+str(i)
+        else    : NUME =     str(i)
+        mcsimp={}
+        mcsimp['GROUP_NO'   ]='LI'+str(i)
+        mcsimp['RESULTAT'   ]=resuth
+        mcsimp['TOUT_ORDRE' ]='OUI'
+        mcsimp['NOM_CHAM'   ]='TEMP'
+        mcsimp['PRECISION'  ]=55.E-1
+        mcsimp['TOUT_CMP'   ]='OUI'
+        mcsimp['INTITULE'   ]='AZI_'+NUME+'_I'
+        mcsimp['OPERATION'  ]='MOYENNE'
+        mcfact.append( _F(**mcsimp) )
+      __rmothi=POST_RELEVE_T(ACTION=mcfact)
+      IMPR_TABLE(TABLE = __rmothi, )
+#
+#-----------------------------------------------------------------------
+  elif TYPE_MAILLAGE[:4]=='FISS' :
+#-----------------------------------------------------------------------
+#
+    NOMGRO=[]
+    NOMGRE=[]
+    TABMA8=[]
+    NOMMA =[]
+    if TYPE_MAILLAGE in ('FISS_COUR_DEB','FISS_LONG_DEB','FISS_AXIS_DEB','FISS_COUR_NONDEB') :
+       NBFIS = 1
+       NOMGRO.append(('P_FON1' ,'P_FIS1' ),)
+       NOMGRE.append(('P_FON2' ,'P_FIS2' ),)
+       TABMA8.append('FONDFISS')
+       if TYPE_MAILLAGE in ('FISS_COUR_DEB','FISS_LONG_DEB') : FERME=0
+       else :
+          FERME=1
+          NOMMA.append('MAIL_ORI')
+    elif TYPE_MAILLAGE in ('FISS_LONG_NONDEB','FISS_AXIS_NONDEB') :
+       NBFIS = 2
+#       NOMGRO.append(('P_FON1' ,'P_FIS1' ),)
+#       NOMGRE.append(('P_FON2' ,'P_FIS2' ),)
+       NOMGRO.append(('PS_FON1','PS_FIS1'),)
+       NOMGRO.append(('PI_FON1','PI_FIS1'),)
+       NOMGRE.append(('PS_FON2','PS_FIS2'),)
+       NOMGRE.append(('PI_FON2','PI_FIS2'),)
+       TABMA8.append('FOND_SUP')
+       TABMA8.append('FOND_INF')
+       if TYPE_MAILLAGE=='FISS_LONG_NONDEB' : FERME=0
+       else :
+          FERME=1
+          NOMMA.append('MA_ORI_S')
+          NOMMA.append('MA_ORI_I')
+#
+    if ECHANGE!=None:
+#
+#     ----  champs de temperature en fond de fissure
+#           si il a ete calcule, cas 1 fond de fissure  ----
+#
+      if NBFIS==1:
+        __rthfis=POST_RELEVE_T(ACTION=_F(GROUP_NO   ='FONDFISS',
+                                         RESULTAT   =resuth,
+                                         TOUT_ORDRE ='OUI',
+                                         NOM_CHAM   ='TEMP',
+                                         PRECISION  =55.E-1,
+                                         TOUT_CMP   ='OUI',
+                                         INTITULE   ='FONDFISS',
+                                         OPERATION  ='EXTRACTION',))
+        IMPR_TABLE(TABLE = __rthfis, )
+#
+#     ----  champs de temperature en fond de fissure
+#           si il a ete calcule, cas 2 fonds de fissure  ----
+#
+      elif NBFIS==2:
+#
+        __rthfis1=POST_RELEVE_T(ACTION=_F(GROUP_NO   ='FOND_SUP',
+                                          RESULTAT   =resuth,
+                                          TOUT_ORDRE ='OUI',
+                                          NOM_CHAM   ='TEMP',
+                                          PRECISION  =55.E-1,
+                                          TOUT_CMP   ='OUI',
+                                          INTITULE   ='FOND_SUP',
+                                          OPERATION  ='EXTRACTION',))
+        IMPR_TABLE(TABLE = __rthfis1, )
+        __rthfis2=POST_RELEVE_T(ACTION=_F(GROUP_NO   ='FOND_INF',
+                                          RESULTAT   =resuth,
+                                          TOUT_ORDRE ='OUI',
+                                          NOM_CHAM   ='TEMP',
+                                          PRECISION  =55.E-1,
+                                          TOUT_CMP   ='OUI',
+                                          INTITULE   ='FOND_INF',
+                                          OPERATION  ='EXTRACTION',))
+        IMPR_TABLE(TABLE = __rthfis2, )
+#
+#   --- post traitement fissure :  interpénétration des lèvres ----
+#
+
+    if TYPE_MAILLAGE[:4]=='FISS' :
+      __tcont=POST_RELEVE_T( ACTION=_F(  INTITULE = 'Contact levres',
+                                GROUP_NO = 'LEVRTUBU',
+                                RESULTAT = nomres,
+                                TOUT_ORDRE = 'OUI',
+                                NOM_CHAM = 'VALE_CONT',
+                                NOM_CMP = 'CONT',
+                                OPERATION = 'EXTRACTION'))
+      tcont=__tcont.EXTR_TABLE()
+#      print tcont
+      numo = tcont['NUME_ORDRE'].values()['NUME_ORDRE']
+      numo=dict([(i,0) for i in numo]).keys()
+      nbinst = len(numo)
+      for i in range(1,nbinst+1) :
+        tabi = tcont.NUME_ORDRE==i
+        nbtot = len(tabi)
+        cont_actif=tabi.CONT>0.
+        nb_no_cont = len(cont_actif)
+        if nb_no_cont > 0 :
+           UTMESS('A','ASPIC0_22',vali=[i,nbtot,nb_no_cont])
+
+
+#
+#        boucle sur le nombre de fond de fissure
+#
+    fond3d = [None]*2
+    for j in range(NBFIS):
+      if FOND_FISS_1!=None : self.DeclareOut('fond3d_0',FOND_FISS_1)
+      if FOND_FISS_2!=None : self.DeclareOut('fond3d_1',FOND_FISS_2)
+#
+#          --- commande DEFI_FOND_FISS ---
+#
+      motscles={}
+      if not FERME:
+         motscles['FOND_FISS']=_F(GROUP_MA     =TABMA8[j],
+                                  GROUP_NO_ORIG=NOMGRO[j][0],
+                                  GROUP_NO_EXTR=NOMGRE[j][0],)
+         motscles['VECT_GRNO_ORIG']=NOMGRO[j]
+         motscles['VECT_GRNO_EXTR']=NOMGRE[j]
+      else:
+         if TYPE_MAILLAGE.find('AXIS')!=-1  : grnoorig=NOMGRE[j][0]
+#                  si AXIS, P_FON1 est remplace par P_FON2 pour
+#                  fermer le fond de fissure
+         else                               : grnoorig=NOMGRO[j][0]
+         motscles['FOND_FERME']=_F(GROUP_MA     =TABMA8[j],
+                                   GROUP_NO_ORIG=grnoorig,
+                                   GROUP_MA_ORIG=NOMMA[j],)
+      fond3d[j]=DEFI_FOND_FISS( MAILLAGE  = MAILLAGE,
+                                LEVRE_SUP = _F(GROUP_MA='LEVRCORP',),
+                                LEVRE_INF = _F(GROUP_MA='LEVRTUBU',),**motscles)
+      if THETA_3D!=None:
+        for tht3d in THETA_3D :
+#
+#          --- commande CALC_THETA ---
+#
+          __theta = CALC_THETA( MODELE    = modele,
+                                FOND_FISS = fond3d[j],
+                                THETA_3D  = _F( TOUT    = 'OUI',
+                                                MODULE  =  1.0 ,
+                                                R_INF   = tht3d['R_INF'],
+                                                R_SUP   = tht3d['R_SUP'], ) )
+#
+#          --- commande CALC_G (3D GLOBAL) ---
+#
+          montit = 'G_THETA 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'],)
+          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,
+                              TOUT_ORDRE = 'OUI',
+                              TITRE      = montit,**motscles)
+          IMPR_TABLE(TABLE = __gtheta, )
+#
+#           recherche du g max
+#
+          if OPTION=='CALC_G_MAX' :
+            if BORNES!=None:
+              mcfact=[]
+              for born in BORNES :
+                mcfact.append(_F( NUME_ORDRE = born['NUME_ORDRE'] ,
+                                  VALE_MIN   = born['VALE_MIN'  ] ,
+                                  VALE_MAX   = born['VALE_MAX'  ]   ) )
+              __gbil = CALC_G( THETA      = _F(THETA=__theta),
+                               RESULTAT   = nomres,
+                               TOUT_ORDRE = 'OUI',
+                               COMP_ELAS  =  _F(TOUT     = 'OUI',
+                                                RELATION = COMP_ELAS['RELATION'],),
+                               TITRE    = montit,
+                               OPTION   = 'G_MAX_GLOB',
+                               BORNES   = mcfact,)
+              IMPR_TABLE(TABLE = __gbil, )
+#
+#          --- commande CALC_G (3D LOCAL) ---
+#
+          montit = 'G_LOCAL 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'],)
+          if FERME:
+                               motscles['LISSAGE']=_F(LISSAGE_THETA= 'LAGRANGE',
+                                                      LISSAGE_G= 'LAGRANGE',)
+          __glocal = CALC_G( THETA=_F( FOND_FISS  = fond3d[j],
+                                       R_INF      = tht3d['R_INF'],
+                                       R_SUP      = tht3d['R_SUP'],),
+                             RESULTAT   = nomres,
+                             TOUT_ORDRE = 'OUI',
+                             TITRE      = montit,**motscles)
+          IMPR_TABLE(TABLE = __glocal, )
+#
+#          recherche du g max local
+#
+          if OPTION=='CALC_G_MAX_LOCAL' :
+            if BORNES!=None:
+              motscles={}
+              mcfact=[]
+              if FERME:
+                motscles['LISSAGE']=_F(LISSAGE_THETA= 'LAGRANGE',
+                                       LISSAGE_G= 'LAGRANGE',)
+              for born in BORNES :
+                mcfact.append(_F( NUME_ORDRE = born['NUME_ORDRE'] ,
+                                  VALE_MIN   = born['VALE_MIN'  ] ,
+                                  VALE_MAX   = born['VALE_MAX'  ]   ) )
+              motscles['BORNES']=mcfact
+              __glbil = CALC_G( THETA=_F( FOND_FISS  = fond3d[j],
+                                          R_INF      = tht3d['R_INF'],
+                                          R_SUP      = tht3d['R_SUP'],),
+                                RESULTAT   = nomres,
+                                TOUT_ORDRE = 'OUI',
+                                COMP_ELAS  =  _F(TOUT     = 'OUI',
+                                                 RELATION = COMP_ELAS['RELATION'],),
+                                TITRE      = montit,
+                                OPTION     = 'G_MAX',**motscles)
+              IMPR_TABLE(TABLE = __glbil, )
+#
+#     --- commande IMPR_RESU  ---
+#
+  if IMPRESSION!=None:
+    mcfresu =[]
+    motscles={}
+    motsclei={}
+    if IMPRESSION['FORMAT'] in ('IDEAS','CASTEM') :
+      ncham   =[]
+      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')
+      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')  :
+                                  motscles['NOM_CHAM'  ]=(ncham[0],ncham[1])
+      elif (len(ncham)==2) and (ncham[0][:4]=='TEMP')  :
+                                  motscles['NOM_CHAM'  ]= ncham[1]
+      elif (len(ncham)==2) and (ncham[1][:4]=='TEMP') :
+                                  motscles['NOM_CHAM'  ]= ncham[0]
+      if   IMPRESSION['TOUT_ORDRE']!=None :
+                                  motscles['TOUT_ORDRE']= IMPRESSION['TOUT_ORDRE']
+      elif IMPRESSION['NUME_ORDRE']!=None :
+                                  motscles['NUME_ORDRE']= IMPRESSION['NUME_ORDRE']
+      elif IMPRESSION['INST']!=None :
+                                  motscles['INST'      ]= IMPRESSION['INST']
+    if IMPRESSION['FORMAT']=='IDEAS' :
+                                  motsclei['VERSION'   ]= IMPRESSION['VERSION']
+    if IMPRESSION['FORMAT']=='CASTEM' :
+                                  motsclei['NIVE_GIBI' ]= IMPRESSION['NIVE_GIBI']
+    mcfresu.append(_F(MAILLAGE=MAILLAGE,RESULTAT=nomres,**motscles))
+    if ECHANGE!=None:
+      motscles={}
+      if IMPRESSION['FORMAT'] in ('IDEAS','CASTEM') :
+        if    len(ncham)==3       : motscles['NOM_CHAM'  ]=('TEMP',)
+        elif (len(ncham)==1) and (ncham[0][:4]=='TEMP') :
+                                    motscles['NOM_CHAM'  ]= ncham[0]
+        elif (len(ncham)==2) and (ncham[0][:4]=='TEMP') :
+                                    motscles['NOM_CHAM'  ]= ncham[0]
+        elif (len(ncham)==2) and (ncham[1][:4]=='TEMP') :
+                                    motscles['NOM_CHAM'  ]= ncham[1]
+        if   IMPRESSION['TOUT_ORDRE']!=None :
+                                    motscles['TOUT_ORDRE']= IMPRESSION['TOUT_ORDRE']
+        elif IMPRESSION['NUME_ORDRE']!=None :
+                                    motscles['NUME_ORDRE']= IMPRESSION['NUME_ORDRE']
+        elif IMPRESSION['INST']!=None :
+                                    motscles['INST'      ]= IMPRESSION['INST']
+      if IMPRESSION['FORMAT']=='IDEAS' :
+                                    motsclei['VERSION'   ]= IMPRESSION['VERSION']
+      if IMPRESSION['FORMAT']=='CASTEM' :
+                                    motsclei['NIVE_GIBI' ]= IMPRESSION['NIVE_GIBI']
+      mcfresu.append(_F(RESULTAT=resuth,**motscles))
+    IMPR_RESU( MODELE = modele,
+               RESU   = mcfresu,
+               FORMAT=IMPRESSION['FORMAT'],**motsclei)
+#
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macr_aspic_mail_ops.py b/Aster/Cata/cataSTA10/Macro/macr_aspic_mail_ops.py
new file mode 100644 (file)
index 0000000..c04e209
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_aspic_mail_ops.py
@@ -0,0 +1,906 @@
+#@ MODIF macr_aspic_mail_ops Macro  DATE 14/04/2008   AUTEUR GALENNE E.GALENNE 
+# -*- 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
+from math import sqrt, cos, sin, pi, pow, tan
+
+# Ecriture du fichier GIBI principal (dgib) - ASPID0
+def write_file_dgib_ASPID0(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H,
+                           ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, THETA, TYPELE,
+                           ITYPSO, DPENE, NIVMAG, loc_datg):
+  import aster
+# Ouverture du fichier d'entrée de commandes
+  fdgib=open(nomFichierDATG,'w')
+  texte = """
+****************************************************************
+opti echo 0;
+epT1     = %s;
+DeT1     = %s;
+d1       = %s;
+d2       = %s;
+epT2     = %s;
+DeT2     = %s;
+Zmax     = %s;
+type_s   = %s;
+d_pene   = %s;
+h        = %s;
+angl_s   = %s;
+jeu      = %s;
+epC      = %s;
+DeC      = %s;
+Xmax     = %s;
+typmai   = MOT %s;
+theta    = %s;
+typele   = MOT %s;
+typ_eque = MOT SAINE;
+nivmag   = %s;
+****************************************************************
+""" % (EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, ITYPSO, DPENE, H,
+       ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, THETA, TYPELE, NIVMAG)
+  aster.affiche('MESSAGE',texte + ' + aspic.datg...\n')
+  texte = texte + open(os.path.join(loc_datg, 'aspic.datg'), 'r').read()
+  fdgib.write(texte)
+  fdgib.close()
+
+# Ecriture du fichier GIBI principal (dgib) - ASPID1
+def write_file_dgib_ASPID1(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H,
+                           ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,THETA,
+                           A,C,EPS, RC0, NS,NC,NT,POSI, NDT,FETIRF,FETIRP,
+                           TFISS,ZETA,ITYPSO,DPENE, NIVMAG, loc_datg) :
+
+  import aster
+# Ouverture du fichier d'entrée de commandes
+  fdgib=open(nomFichierDATG,'w')
+  POIVIR = ' ;                                         \n'
+  texte='****************************************************************\n'
+  texte=texte+'opti echo 0 ;                                                   \n'
+  texte=texte+'epT1   = '+str(EPT1)         +POIVIR
+  texte=texte+'DeT1   = '+str(DET1)         +POIVIR
+  texte=texte+'d1     = '+str(D1)           +POIVIR
+  texte=texte+'d2     = '+str(D2)           +POIVIR
+  texte=texte+'epT2   = '+str(EPT2)         +POIVIR
+  texte=texte+'DeT2   = '+str(DET2)         +POIVIR
+  texte=texte+'Zmax   = '+str(ZMAX)         +POIVIR
+  texte=texte+'type_s = '+str(ITYPSO)       +POIVIR
+  texte=texte+'d_pene = '+str(DPENE)        +POIVIR
+  texte=texte+'h      = '+str(H)            +POIVIR
+  texte=texte+'angl_s = '+str(ALPHA)        +POIVIR
+  texte=texte+'jeu    = '+str(JEU)          +POIVIR
+  texte=texte+'epC    = '+str(EPC)          +POIVIR
+  texte=texte+'DeC    = '+str(DEC)          +POIVIR
+  texte=texte+'Xmax   = '+str(XMAX)         +POIVIR
+  texte=texte+'typmai =  MOT '+TYPMAI       +POIVIR
+  texte=texte+'theta  = '+str(THETA)        +POIVIR
+  texte=texte+'a      = '+str(A)            +POIVIR
+  texte=texte+'c      = '+str(C)            +POIVIR
+  texte=texte+'zeta   = '+str(ZETA)         +POIVIR
+  texte=texte+'eps    = '+str(EPS)          +POIVIR
+  texte=texte+'rc0    = '+str(RC0)          +POIVIR
+  texte=texte+'ns     = '+str(NS)           +POIVIR
+  texte=texte+'nc     = '+str(NC)           +POIVIR
+  texte=texte+'nt     = '+str(NT)           +POIVIR
+  texte=texte+'dir_fiss = MOT '+POSI        +POIVIR
+  texte=texte+'pos_fiss = MOT '+TFISS       +POIVIR
+  texte=texte+'ndt    = '+str(NDT)          +POIVIR
+  texte=texte+'f_etir_f = '+str(FETIRF)     +POIVIR
+  texte=texte+'f_etir_p = '+str(FETIRP)     +POIVIR
+  texte=texte+'typ_eque = MOT '+'FISS_LON'  +POIVIR
+  texte=texte+'nivmag = '+str(NIVMAG)       +POIVIR
+  texte=texte+'*                                                               \n'
+  aster.affiche('MESSAGE',texte + ' + aspic_v2.datg...\n')
+  texte = texte + open(os.path.join(loc_datg, 'aspic_v2.datg'), 'r').read()
+  fdgib.write(texte)
+  fdgib.close()
+
+# Ecriture du fichier GIBI principal (dgib) - ASPID2
+def write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX,
+                           H, ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,
+                           THETA, A, C, EPS, RC0, RC1, RC2, RC3,
+                           ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS,
+                           ZETA,ITYPSO,DPENE, NIVMAG, loc_datg) :
+# 
+  import aster
+  CALPHA = cos(ALPHA*pi/180.)
+  SALPHA = sin(ALPHA*pi/180.)
+  CTHETA = cos(THETA*pi/180.)
+  STHETA = sin(THETA*pi/180.)
+#
+  AOLD = A
+#
+  if (ITYPSO == 1) :
+# PIQUAGE TYPE 1
+     if (POSI == 'DROIT') :
+#    PIQUAGE DROIT
+        if (TFISS == 'DEB_INT') :
+#       POSITION INTERNE
+           SGAMMA = STHETA * (DET1/2.0)/( (DEC/2.0) -EPC)
+           SGAMME = STHETA * (DET1/2.0)/( (DEC/2.0) )
+           RAPPA = sqrt(1.0 - pow(SGAMMA,2))
+           RAPPE = sqrt(1.0 - pow(SGAMME,2))
+           AP =  A - (1.0 - RAPPA)*A  
+           RAPP = (AP/EPC*RAPPE) + (1.0-(AP/EPC))*RAPPA
+           XA = (DET1/2.0) * CTHETA 
+           YA = (DET1/2.0) * STHETA      
+           ZA = ((DEC/2.0) -EPC) * sqrt(1.0 - pow(SGAMMA,2))
+           ZA0 = (DEC/2.0) - EPC
+           XA0 = DET1/2.0
+           XN0 = XA0
+           YN0 = 0.0 
+           ZN0 = ZA0 + A
+           XN = XN0 * CTHETA 
+           YN = XN0 * STHETA
+           SGAMN = YN / ZN0
+           ZN = ZN0 * sqrt(1.0 - (SGAMN*SGAMN))
+           D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) )
+           DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) )
+           RAPP = D0N0 / DN
+           ECART = (1.0 - RAPP) * D0N0
+           A = A - ECART
+        elif (TFISS == 'DEB_EXT') :
+#       POSITION EXTERNE
+           SGAMME = STHETA * (DET1/2.0)/ (DEC/2.0) 
+           RAPPE = sqrt(1.0 - pow(SGAMME,2))
+           A =  A  -(1.0 - RAPPE)*A  
+
+     elif (POSI == 'INCLINE') :
+#    PIQUAGE INCLINE
+        SGAMMA = STHETA * (DET1/2.0)/ ( (DEC/2.0) -EPC)
+        XA = (DET1/2.0) * CTHETA 
+        YA = (DET1/2.0) * STHETA     
+        ZA = ((DEC/2.0) - EPC) * sqrt(1.0 - pow(SGAMMA,2))
+        ZA0 = (DEC/2.0) - EPC
+        ZD0 = DEC/2.0
+        XA0 = DET1/2.0
+        XD0 = XA0 + (tan(ALPHA*pi/180.0) * EPC)   
+        A0D0 = sqrt( pow((ZD0 - ZA0),2) + pow((XD0 - XA0),2) )
+        EPSIL = STHETA * tan(ALPHA*pi/180.0) 
+        PHI = (EPSIL * ZA) - YA
+        DELTA = pow(PHI,2) - ((1 + pow(EPSIL,2))*(pow(PHI,2) - (pow((DEC/2.0),2)*pow(EPSIL,2))))
+        if (STHETA > 0) :          
+           YD = ( sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2))
+        else :
+           YD = ( -1.0*sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2))
+
+        ZD = sqrt(pow((DEC/2.0),2) - pow(YD,2))  
+
+        if ( (abs(THETA - 0.0) < 1.e-3) or ((abs(THETA - 180.0)) < 1.e-3) ) :
+           XD = CTHETA * XD0
+        else :
+           XD = YD / tan(THETA*pi/180.0)
+
+        AD = sqrt( pow((XA - XD),2) + pow((YA - YD),2) + pow((ZA - ZD),2) )       
+        RAPP =  A0D0 / AD          
+
+        if (TFISS == 'DEB_EXT') :       
+           XN0 = XD0 - A*SALPHA 
+           YN0 = 0.0 
+           ZN0 = ZD0 - A*CALPHA 
+           XN = XN0 * CTHETA 
+           YN = XN0 * STHETA
+           DNXY = sqrt(pow(XD,2) + pow(YD,2)) - sqrt(pow(XN,2) + pow(YN,2))
+           DNXY0 = XD0 - XN0
+           RAPP = DNXY/DNXY0
+           # Correction necessaire dans le cas theta et/ou alpha grand
+           if (RAPP < 0.5) :
+              DXY = sqrt(pow(XD,2) + pow(YD,2) ) 
+              XN = XN * DXY/XD0
+              YN = YN * DXY/XD0
+           SGAMN = YN / ZN0
+           ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+           D0N0 = sqrt( pow((XD0 - XN0),2) + pow((ZD0 - ZN0),2) )
+           DN = sqrt( pow((XD - XN),2) + pow((YD - YN),2) + pow((ZD - ZN),2) )       
+           RAPP = D0N0 / DN
+           ECART = (RAPP - 1.0) * D0N0
+           A = A + ECART
+           
+        if (TFISS == 'DEB_INT') :
+           XN0 = XA0 + A*SALPHA 
+           YN0 = 0.0
+           ZN0 = ZA0 + A*CALPHA 
+           XN = XN0 * CTHETA 
+           YN = XN0 * STHETA           
+           SGAMN = YN / ZN0
+           ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+           D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) )
+           DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) )       
+           RAPP = D0N0 / DN
+           ECART = (RAPP - 1.0) * D0N0
+           # Correction necessaire dans le cas theta grand (cf. AL9679)
+           if ( abs(STHETA) > 0.8) :
+              DXY = sqrt(pow(XD,2) + pow(YD,2) ) 
+              XN = XN * DXY/XD0
+              YN = YN * DXY/XD0
+              SGAMN = YN / ZN0
+              ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+              D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) )
+              DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) )       
+              RAPP = D0N0 / DN
+              ECART = (ECART + (RAPP - 1.0) * D0N0)/2
+           A = A + ECART
+
+
+  elif (ITYPSO == 2) :
+# PIQUAGE TYPE 2
+     if (POSI == 'DROIT') :
+#    PIQUAGE DROIT
+        SGAMMI = STHETA * ((DET1/2.0) - EPT1)/(DEC/2.0)
+        XI = ((DET1/2.0) - EPT1) * CTHETA 
+        YI = ((DET1/2.0) - EPT1) * STHETA
+        ZI =  (DEC/2.0)  * sqrt(1.0 - pow(SGAMMI,2))
+        XI0 = (DET1/2.0) -EPT1
+        YI0 = 0.0 
+        ZI0 = (DEC/2.0)
+        
+        SGAMMA = STHETA * (DET1/2.0)/((DEC/2.0) -EPC)
+        YA = (DET1/2.0) * STHETA     
+        ZA = ((DEC/2.0) - EPC) * sqrt(1.0 - pow(SGAMMA,2))
+        TGALP = H / EPC
+        EPSIL =  STHETA * TGALP
+        PHI = (EPSIL * ZA) - YA
+        DELTA = pow(PHI,2) - (1.0 + pow(EPSIL,2))*(pow(PHI,2) - pow((DEC/2.0),2)*pow(EPSIL,2)) 
+        if (STHETA > 0) :          
+           YD = (sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2))
+        else :
+           YD = (-1.0*sqrt(DELTA) - PHI) / (1.0 + pow(EPSIL,2))
+
+        ZD = sqrt( pow((DEC/2.0),2) - pow(YD,2) )
+        if ( (abs(THETA - 0.0) < 1.0e-3) or
+             (abs(THETA - 180.0) < 1.0e-3) or
+             (abs(THETA + 180.0) < 1.0e-3) or
+             (abs(THETA + 90.0) < 1.0e-3) or
+             (abs(THETA - 90.0) < 1.0e-3) ) :
+           XD = CTHETA * ((DET1/2.0) + H)
+        else :
+           XD = YD / (tan(THETA*pi/180.0))
+
+        XD0 = (DET1/2.0) + H 
+        YD0 = 0.0 
+        ZD0 = (DEC/2.0) 
+        
+        if (TFISS == 'DEB_EXT') :
+           XN0 = XD0 - A
+           YN0 = 0.0 
+           ZN0 = ZI0 
+           XN = XN0 * CTHETA 
+           YN = XN0 * STHETA 
+           DZID = abs(ZI - ZD) 
+           DXYID = sqrt( pow((XD - XI),2) + pow((YD - YI),2) )
+           DXYIN = sqrt( pow((XN - XI),2) + pow((YN - YI),2) )
+           DZIN = (DXYIN * DZID) / DXYID
+           ZN = ZI - DZIN         
+           D0N0 = sqrt( pow((XD0 - XN0),2) + pow((ZD0 - ZN0),2) )
+           DN = sqrt( pow((XD - XN),2) + pow((YD - YN),2) + pow((ZD - ZN),2) ) 
+           RAPP = D0N0 / DN 
+           ECART = DN - D0N0 
+           A = A - ECART
+
+        if (TFISS == 'DEB_INT') :
+           XN0 = XI0 + A
+           YN0 = 0.0 
+           ZN0 = ZI0 
+           XN = XN0 * CTHETA
+           YN = XN0 * STHETA 
+           SGAMN = YN / ZN0 
+           ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+           I0N0 = sqrt( pow((XI0 - XN0),2) + pow((ZI0 - ZN0),2) ) 
+           IN = sqrt( pow((XI - XN),2) + pow((YI - YN),2) + pow((ZI - ZN),2) ) 
+           RAPP = I0N0 / IN 
+           ECART = I0N0 * ( 1.0 - RAPP ) 
+           A = A - ECART
+        
+     elif (POSI == 'INCLINE') :
+#    PIQUAGE INCLINE
+        TGALPHA = SALPHA/CALPHA
+        REPB = (DEC/2.0) + JEU + (EPT1*TGALPHA) 
+        SGAMB = (STHETA * DET1/2.0 ) / REPB 
+        CGAMB = sqrt(1.0 - pow(SGAMB,2)) 
+        XB = (DET1/2.0) * CTHETA
+        YB = (DET1/2.0) * STHETA
+        ZB = ( (DEC/2.0) + JEU + (EPT1*TGALPHA) ) * CGAMB
+        XB0 = (DET1/2.0)
+        YB0 = 0.0
+        ZB0 = (DEC/2.0) + JEU + (EPT1*TGALPHA)
+#
+        RIT1 = (DET1/2.0) - EPT1 
+        REPG = (DEC/2.0) + JEU 
+        SGAMG = ((STHETA ) * RIT1) / REPG
+        CGAMG = sqrt(1.0 - pow(SGAMG,2))
+        XG = RIT1 * CTHETA
+        YG = RIT1 * STHETA
+        ZG = ((DEC/2.0) + JEU) * CGAMG
+        XG0 = RIT1
+        YG0 = 0.0
+        ZG0 = (DEC/2.0) + JEU
+#
+        if (TFISS == 'DEB_INT')  :
+           XN0 = XG0 + A*CALPHA 
+           YN0 = 0.0
+           ZN0 = ZG0 + A*SALPHA 
+           XN = XN0 * CTHETA 
+           YN = XN0 * STHETA
+           SGAMN = YN / ZN0
+           ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+           G0N0 = sqrt( pow((XG0 - XN0),2) + pow((ZG0 - ZN0),2) )
+           GN = sqrt( pow((XG - XN),2) + pow((YG - YN),2) + pow((ZG - ZN),2) )
+           RAPP = G0N0 / GN
+           ECART = (RAPP - 1.0) * G0N0
+           A = A + ECART
+
+        if (TFISS == 'DEB_EXT') :
+           XN0 = XB0 - A*CALPHA
+           YN0 = 0.0
+           ZN0 = ZB0 - A*SALPHA
+           XN = XN0 * CTHETA
+           YN = XN0 * STHETA
+           SGAMN = YN / ZN0
+           ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+           B0N0 = sqrt( pow((XB0 - XN0),2) + pow((ZB0 - ZN0),2) )
+           BN = sqrt( pow((XB - XN),2) + pow((YB - YN),2) + pow((ZB - ZN),2) )
+           RAPP = B0N0 / BN
+           ECART = (RAPP - 1.0) * B0N0
+           A = A + ECART
+
+  message= ' <MACR_ASPIC_MAIL> CORRECTION PROFONDEUR DEFAUT \n'
+  message=message+ ' PROFONDEUR SUR PIQUAGE   : %.2f \n'%AOLD
+  message=message+ ' PROFONDEUR SUR EQUERRE   : %.2f \n'%A
+  aster.affiche('MESSAGE',message)
+
+# Ouverture du fichier d'entrée de commandes
+
+  fdgib=open(nomFichierDATG,'w')
+  POIVIR = ' ;                                         \n'
+  texte='****************************************************************\n'
+  texte=texte+'opti echo 0 ;                                                   \n'
+  texte=texte+'epT1   = '+str(EPT1)         +POIVIR
+  texte=texte+'DeT1   = '+str(DET1)         +POIVIR
+  texte=texte+'d1     = '+str(D1)           +POIVIR
+  texte=texte+'d2     = '+str(D2)           +POIVIR
+  texte=texte+'epT2   = '+str(EPT2)         +POIVIR
+  texte=texte+'DeT2   = '+str(DET2)         +POIVIR
+  texte=texte+'Zmax   = '+str(ZMAX)         +POIVIR
+  texte=texte+'type_s = '+str(ITYPSO)       +POIVIR
+  texte=texte+'d_pene = '+str(DPENE)        +POIVIR
+  texte=texte+'h      = '+str(H)            +POIVIR
+  texte=texte+'angl_s = '+str(ALPHA)        +POIVIR
+  texte=texte+'jeu    = '+str(JEU)          +POIVIR
+  texte=texte+'epC    = '+str(EPC)          +POIVIR
+  texte=texte+'DeC    = '+str(DEC)          +POIVIR
+  texte=texte+'Xmax   = '+str(XMAX)         +POIVIR
+  texte=texte+'typmai =  MOT '+TYPMAI       +POIVIR
+  texte=texte+'theta  = '+str(THETA)        +POIVIR
+  texte=texte+'a      = '+str(A)            +POIVIR
+  texte=texte+'c      = '+str(C)            +POIVIR
+  texte=texte+'zeta   = '+str(ZETA)         +POIVIR
+  texte=texte+'eps    = '+str(EPS)          +POIVIR
+  texte=texte+'rc0    = '+str(RC0)          +POIVIR
+  texte=texte+'rc1    = '+str(RC1)          +POIVIR
+  texte=texte+'rc2    = '+str(RC2)          +POIVIR
+  texte=texte+'rc3    = '+str(RC3)          +POIVIR
+  texte=texte+'alpha  = '+str(ALP)          +POIVIR
+  texte=texte+'beta   = '+str(BETA)         +POIVIR
+  texte=texte+'ns     = '+str(NS)           +POIVIR
+  texte=texte+'nc     = '+str(NC)           +POIVIR
+  texte=texte+'nt     = '+str(NT)           +POIVIR
+  texte=texte+'dir_fiss = MOT '+POSI        +POIVIR
+  texte=texte+'pos_fiss = MOT '+TFISS       +POIVIR
+  texte=texte+'ndt    = '+str(NDT)          +POIVIR
+  texte=texte+'nsdt   = '+str(NSDT)         +POIVIR
+  texte=texte+'typ_eque = MOT '+'FISS_COU'  +POIVIR
+  texte=texte+'nivmag = '+str(NIVMAG)       +POIVIR
+  texte=texte+'*                                                               \n'
+  texte=texte+'list epc ;\n'
+  aster.affiche('MESSAGE',texte + ' + aspic.datg...\n')
+  texte = texte + open(os.path.join(loc_datg, 'aspic.datg'), 'r').read()
+  fdgib.write(texte)
+  fdgib.close()
+
+def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE,
+                             SOUDURE,CORPS,FISS_SOUDURE,IMPRESSION,INFO,
+                        **args):
+  """
+     Ecriture de la macro MACR_ASPIC_MAIL
+  """
+  from Accas import _F
+  import types
+  import aster 
+  from Utilitai.Utmess import  UTMESS
+  ier=0
+  
+# On importe les definitions des commandes a utiliser dans la macro
+  EXEC_LOGICIEL =self.get_cmd('EXEC_LOGICIEL')
+  PRE_GIBI      =self.get_cmd('PRE_GIBI')
+  LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE')
+  DEFI_GROUP    =self.get_cmd('DEFI_GROUP')
+  MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE')
+  CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE')
+  IMPR_RESU     =self.get_cmd('IMPR_RESU')
+  DEFI_FICHIER  =self.get_cmd('DEFI_FICHIER')
+
+# La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  TYPELE = TYPE_ELEM
+  NIVMAG = EXEC_MAILLAGE['NIVE_GIBI']
+#
+#     --- raffinement maillage ---
+#
+  TYPMAI = RAFF_MAIL
+  GROS   = (TYPMAI=='GROS')
+  if GROS : NBAZIT = 40
+  else    : NBAZIT = 48
+#
+#     --- caracteristiques de la tubulure ---
+#
+  EPT1  = TUBULURE['E_BASE'   ]
+  DET1  = TUBULURE['DEXT_BASE']
+  D1    = TUBULURE['L_BASE'   ]
+  D2    = TUBULURE['L_CHANF'  ]
+  EPT2  = TUBULURE['E_TUBU'   ]
+  DET2  = TUBULURE['DEXT_TUBU']
+  ZMAX  = TUBULURE['Z_MAX'    ]
+  TYPSOU= TUBULURE['TYPE'     ]
+  DPENE = TUBULURE['L_PENETR' ]
+  if TYPSOU=='TYPE_2' and DPENE>0.0 : 
+    UTMESS('F','ASPIC0_12')
+  if TYPSOU=='TYPE_2' :
+     ITYPSO = 2
+  else :
+     ITYPSO = 1
+#
+#     --- caracteristiques de la soudure ---
+#
+  H     = SOUDURE['H_SOUD'   ]
+  ALPHA = SOUDURE['ANGL_SOUD']
+  JEU   = SOUDURE['JEU_SOUD' ]
+#
+#     --- caracteristiques du corps ---
+#
+  EPC   = CORPS  ['E_CORP'   ]
+  DEC   = CORPS  ['DEXT_CORP']
+  XMAX  = CORPS  ['X_MAX'    ]
+  EPSI  = 1.E-03
+  RMB   = ( DET1 - EPT1 ) / 2.0
+  VAL1  = 1.5 * sqrt( RMB**3 / EPT1 )
+  VAL3  = 3.0 * sqrt( RMB    * EPT1 )
+  RMT   = ( DET2 - EPT2 ) / 2.0
+  VAL2  = 1.5 * sqrt( RMT**3 / EPT2 )
+  VAL4  = 3.0 * sqrt( RMT    * EPT2 )
+  LZMAX = max ( VAL1 , VAL2, VAL3, VAL4 )
+  ZMAXC = LZMAX + ( DEC/2.0 ) + D1 + D2
+  LOK = ( (ZMAX-ZMAXC) >= -1.* EPSI * abs(ZMAXC) )
+  if not LOK :
+    UTMESS('A','ASPIC0_13',valr=[ZMAX,ZMAXC])
+  RMC   = ( DEC - EPC ) / 2.0
+  VAL1  = 1.5 * sqrt( RMC**3 / EPC )
+  VAL2  = 3.0 * sqrt( RMC    * EPC )
+  LXMAX = max( VAL1 , VAL2 )
+  XMAXC = LXMAX + ( DET1 / 2.0 )
+  LOK = ( (XMAX-XMAXC) >= -1.* EPSI * abs(XMAXC) )
+  if not LOK :
+    UTMESS('A','ASPIC0_23',valr=[XMAX,XMAXC])
+  message=         ' MACR_ASPIC_MAIL : X_MAX CALCULEE : %.2f  X_MAX FOURNI : %.2f\n'%(XMAXC,XMAX)
+  message=message+ ' MACR_ASPIC_MAIL : Z_MAX CALCULEE : %.2f  Z_MAX FOURNI : %.2f\n'%(ZMAXC,ZMAX)
+  aster.affiche('MESSAGE',message)
+#
+#     --- caracteristiques de la fissure ---
+#
+  SAIN   = 0
+  FISLON = 0
+  FISCOU = 0
+  THETA  = 0.0
+  TFISS  = None
+  if FISS_SOUDURE==None :
+     SAIN = 1
+  else :
+     if   FISS_SOUDURE['TYPE']=='LONGUE' : FISLON = 1
+     elif FISS_SOUDURE['TYPE']=='COURTE' : FISCOU = 1
+     THETA = FISS_SOUDURE['AZIMUT'        ]
+     EPS   = FISS_SOUDURE['ANGL_OUVERTURE']
+     AXIS  = FISS_SOUDURE['AXIS'          ]
+     POSI  = FISS_SOUDURE['POSITION'      ]
+     TFISS = FISS_SOUDURE['FISSURE'       ]
+     A     = FISS_SOUDURE['PROFONDEUR'    ]
+     if      FISS_SOUDURE['LONGUEUR'      ]!=None :
+        C  = FISS_SOUDURE['LONGUEUR'      ]
+        N1 = 1
+     else : N1 = 0
+     if (TFISS=='DEB_INT') and (POSI=='INCLINE') and (DPENE>0.0) and (JEU>0.0) : 
+       UTMESS('F','ASPIC0_14')
+     ZETA = 0.5
+     if TFISS not in ('DEB_INT','DEB_EXT') :
+        if FISS_SOUDURE['LIGA_INT']==None : 
+           UTMESS('F','ASPIC0_15')
+        LIGA  = FISS_SOUDURE['LIGA_INT']
+        if POSI=='DROIT' :
+           if ITYPSO==1 : ZETA = (A+LIGA)/(EPC+H)
+           else         : ZETA = (A+LIGA)/(EPT1+H)
+        else :
+           if ITYPSO==1 : ZETA = (A+LIGA)*cos(ALPHA*pi/180.0)/EPC
+           else         : ZETA = (A+LIGA)*cos(ALPHA*pi/180.0)/EPT1
+        if ZETA < 0.1   :
+           UTMESS('F','ASPIC0_16')
+        if ZETA > 0.9   :
+           UTMESS('F','ASPIC0_17')
+        if LIGA < 0.1*EPC :
+           UTMESS('F','ASPIC0_16')
+        if (LIGA + 2.0*A) > 0.9*EPC :
+           UTMESS('F','ASPIC0_17')
+     if N1==0 :
+        if FISCOU      :
+           UTMESS('F','ASPIC0_18')
+        if AXIS=='NON' :
+           UTMESS('F','ASPIC0_19')
+        C = 0.0
+     else :
+        if AXIS=='OUI' : UTMESS('A','ASPIC0_20')
+     C = 0.5 * C
+     LEQU=2.*(pi*(DEC-EPC)-DET1+2.*EPT1)
+#
+# LPIQ est une valeur qui depend theoriquement de la fissure. la valeur
+# ci-dessous est approchee car elle ne sert qu'a calculer les facteurs d'etirement
+#
+     LPIQ=pi*(DET1)
+     if AXIS=='OUI' : C=100.0*LPIQ
+     RAPL=LEQU/LPIQ
+     if FISCOU :
+        RAP=A/C
+        CAS1=RAP<0.3499
+        CAS3=RAP>0.4999
+        CAS2= not (CAS1 or CAS3)
+        if CAS1 : ALP=0.8
+        if CAS2 : ALP=0.4
+        if CAS3 : ALP=0.0
+        BETA=1.0
+        if GROS and not CAS1 :
+          NDT=1
+          NSDT=2
+        else :
+          NDT=2
+          NSDT=4
+#
+     if FISLON :
+       if GROS :
+         NDT=2
+         FETIRF=30.*RAPL
+         FETIRP=60.*RAPL
+       else :
+         NDT=3
+         FETIRF=15.*RAPL
+         FETIRP=30.*RAPL
+#
+     RC0 = FISS_SOUDURE['RAYON_TORE']
+     if (FISCOU and RC0==None) :
+       if GROS : RC0=0.12
+       else    : RC0=0.10
+       if CAS1 : RC0=0.08
+       RC0=RC0*A
+     if (FISLON and RC0==None) : RC0=A/(NDT+1)
+#
+     RC1 = FISS_SOUDURE['COEF_MULT_RC1']
+     if (FISCOU and RC1==None) :
+       if GROS : RC1=1.2
+       else    : RC1=1.0
+#
+     RC2 = FISS_SOUDURE['COEF_MULT_RC2']
+     if (FISCOU and RC2==None) :
+       if GROS : RC2=1.4
+       else    : RC2=1.2
+#
+     RC3 = FISS_SOUDURE['COEF_MULT_RC3']
+     if (FISCOU and RC3==None) :
+       if GROS :
+          if CAS1 : RC3=2.5
+          else    : RC3=1.0  # valeur non utilisee
+       else : 
+          if CAS3 : RC3=2.2
+          else    : RC3=2.0
+#
+     NT = FISS_SOUDURE['NB_TRANCHE']
+     if (FISCOU and NT==None) :
+       if GROS : NT = 8
+       else    : NT = 16
+       if CAS1 : NT = NT*2
+     if (FISLON and NT==None) : NT=0
+#
+     NS = FISS_SOUDURE['NB_SECTEUR']
+     if (FISCOU and NS==None) :
+       if GROS : NS = 2
+       else    : NS = 4
+     if (FISLON and NS==None) :
+       if GROS : NS = 2
+       else    : NS = 4
+#
+     NC = FISS_SOUDURE['NB_COURONNE']
+     if (FISCOU and NC==None) :
+       if GROS : NC = 3
+       else    : NC = 4
+     if (FISLON and NC==None) :
+       if GROS : NC = 3
+       else    : NC = 4
+#
+  loc_gibi=aster.repout()
+  logiel = EXEC_MAILLAGE['LOGICIEL'  ]
+  UNITD  = EXEC_MAILLAGE['UNITE_DATG']
+  UNITS  = EXEC_MAILLAGE['UNITE_MGIB']
+  if   logiel=='GIBI98'  : logiel = loc_gibi+'gibi98'
+  elif logiel=='GIBI2000': logiel = loc_gibi+'gibi2000'
+  else                   :
+       UTMESS('F','ASPIC0_21')
+#
+#     --- ecriture sur le fichier .datg  de la procedure ---
+#
+# Nom du fichier de commandes pour GIBI
+  nomFichierDATG = 'fort.'+str(UNITD)
+# Nom du fichier de maillage GIBI
+  nomFichierGIBI = 'fort.'+str(UNITS)
+  loc_datg = aster.repdex()
+  if SAIN   : write_file_dgib_ASPID0(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H,
+                                     ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, THETA, TYPELE,
+                                     ITYPSO, DPENE, NIVMAG,loc_datg)
+  if FISLON : write_file_dgib_ASPID1(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H,
+                                     ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,THETA,
+                                     A,C,EPS, RC0,NS,NC,NT,POSI, NDT,FETIRF,FETIRP,
+                                     TFISS,ZETA,ITYPSO,DPENE, NIVMAG,loc_datg)
+  if FISCOU : write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX,
+                                     H, ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,
+                                     THETA, A, C, EPS, RC0, RC1, RC2, RC3,
+                                     ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS,
+                                     ZETA,ITYPSO,DPENE, NIVMAG,loc_datg)
+# 
+  DEFI_FICHIER(ACTION='LIBERER',UNITE=19)
+  DEFI_FICHIER(ACTION='LIBERER',UNITE=20)
+  EXEC_LOGICIEL( LOGICIEL = logiel ,
+                 ARGUMENT = (nomFichierDATG,
+                             nomFichierGIBI), )
+#
+  PRE_GIBI()
+#
+  __MAPROV=LIRE_MAILLAGE(INFO=INFO)
+#
+  motscles={}
+  motscles['CREA_GROUP_MA']=[]
+  l_CREA_GROUP_NO=[]
+  if SAIN :
+     l_CREA_GROUP_NO.append('S_LAT1')
+     l_CREA_GROUP_NO.append('S_LAT2')
+  else :
+     l_CREA_GROUP_NO.append('S_LAT1_C')
+     l_CREA_GROUP_NO.append('S_LAT2_C')
+     l_CREA_GROUP_NO.append('S_LAT1_T')
+     l_CREA_GROUP_NO.append('S_LAT2_T')
+     l_CREA_GROUP_NO.append('LEVRTUBU')
+     if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') :
+        l_CREA_GROUP_NO.append('PFONDINF')
+        l_CREA_GROUP_NO.append('PFONDSUP')
+     else :
+        l_CREA_GROUP_NO.append('PFONDFIS')
+     if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='COURTE') :
+        motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS',
+                                            NOM      = 'MAIL_ORI',
+                                            POSITION = 'INIT'     ))
+     if (TFISS[:4]=='DEB_') and (AXIS=='OUI') :
+        motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS',
+                                            NOM      = 'MAIL_ORI',
+                                            POSITION = 'INIT'     ))
+     if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') :
+        motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FOND_SUP',
+                                            NOM      = 'MA_ORI_S',
+                                            POSITION = 'INIT'     ))
+        motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FOND_INF',
+                                            NOM      = 'MA_ORI_I',
+                                            POSITION = 'INIT'     ))
+  l_CREA_GROUP_NO.append('S_FOND1')
+  l_CREA_GROUP_NO.append('S_FOND2')
+  l_CREA_GROUP_NO.append('EQUERRE')
+  motscles['CREA_GROUP_NO']=_F(GROUP_MA=l_CREA_GROUP_NO)
+#
+  __MAPROV=DEFI_GROUP(reuse   =__MAPROV,
+                      MAILLAGE=__MAPROV,
+                      **motscles )
+#
+  if not SAIN :
+     motscles={}
+     motscles['CREA_GROUP_NO']=[]
+     if not (TFISS=='NON_DEB')  :
+        motscles['CREA_GROUP_NO'].append(_F(GROUP_MA = 'FONDFISS',))
+     if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') :
+        motscles['CREA_GROUP_NO'].append(_F(GROUP_MA = ('FOND_SUP','FOND_INF',),))
+     if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='COURTE') :
+        motscles['CREA_GROUP_NO'].append(_F(GROUP_MA = 'FONDFISS',))
+     __MAPROV=DEFI_GROUP(reuse   =__MAPROV,
+                         MAILLAGE=__MAPROV,
+                         **motscles )
+#
+  __MAPROV=MODI_MAILLAGE(reuse   =__MAPROV,
+                         MAILLAGE=__MAPROV,
+                         EQUE_PIQUA=_F( GROUP_NO  = 'EQUERRE' ,
+                                        E_BASE    = EPT1  ,
+                                        DEXT_BASE = DET1  ,
+                                        L_BASE    = D1    ,
+                                        L_CHANF   = D2    ,
+                                        TYPE      = TYPSOU,
+                                        H_SOUD    = H     , 
+                                        ANGL_SOUD = ALPHA ,
+                                        JEU_SOUD  = JEU   ,
+                                        E_CORP    = EPC   , 
+                                        DEXT_CORP = DEC   ,
+                                        AZIMUT    = THETA ,
+                                        RAFF_MAIL = TYPMAI,
+                                        X_MAX     = XMAX  , )
+                         )
+#
+
+  motscles={}
+  if not SAIN :
+     motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU','LEVRTUBU','LEVRCORP'),)
+  else :
+     motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU',),)
+  __MAPROV=MODI_MAILLAGE(reuse   =__MAPROV,
+                         MAILLAGE=__MAPROV,
+                         **motscles
+                         )
+#
+  if SAIN :
+     __MAPROV=DEFI_GROUP(reuse         = __MAPROV,
+                         MAILLAGE      = __MAPROV,
+                         CREA_GROUP_NO = _F(GROUP_MA=('NIDXT','NEDXT','NIIXT','NEIXT')) )
+#
+     for i in range(1,NBAZIT+1):
+       prec = EPC / 5.0
+       __MAPROV=DEFI_GROUP(reuse         = __MAPROV,
+                           MAILLAGE      = __MAPROV,
+                         CREA_GROUP_NO = ( _F( NOM       = 'NID'+str(i) ,
+                                               GROUP_NO  = 'NIDXT'      ,
+                                               NUME_INIT = i            ,
+                                               NUME_FIN  = i            ,),
+                                           _F( NOM       = 'NED'+str(i) ,
+                                               GROUP_NO  = 'NEDXT'      ,
+                                               NUME_INIT = i            ,
+                                               NUME_FIN  = i            ,),
+                                           _F( NOM       = 'NII'+str(i) ,
+                                               GROUP_NO  = 'NIIXT'      ,
+                                               NUME_INIT = i            ,
+                                               NUME_FIN  = i            ,),
+                                           _F( NOM       = 'NEI'+str(i) ,
+                                               GROUP_NO  = 'NEIXT'      ,
+                                               NUME_INIT = i            ,
+                                               NUME_FIN  = i            ,),
+                                           _F( NOM       = 'LDN'+str(i) ,
+                                               GROUP_MA  = 'LD' +str(i) ,),
+                                           _F( NOM       = 'LD' +str(i) ,
+                                               GROUP_NO  = 'LDN'+str(i) ,
+                                               OPTION    = 'SEGM_DROI_ORDO',
+                                               PRECISION =  prec        ,
+                                               CRITERE   = 'ABSOLU'     ,
+                                               GROUP_NO_ORIG   = 'NID'+str(i),
+                                               GROUP_NO_EXTR   = 'NED'+str(i),),
+                                           _F( NOM       = 'LIN'+str(i) ,
+                                               GROUP_MA  = 'LI' +str(i) ,),
+                                           _F( NOM       = 'LI' +str(i) ,
+                                               GROUP_NO  = 'LIN'+str(i) ,
+                                               OPTION    = 'SEGM_DROI_ORDO',
+                                               PRECISION =  prec        ,
+                                               CRITERE   = 'ABSOLU'     ,
+                                               GROUP_NO_ORIG   = 'NII'+str(i),
+                                               GROUP_NO_EXTR   = 'NEI'+str(i),),))
+#
+#
+#     --- commande CREA_MAILLAGE ---
+#
+  self.DeclareOut('nomres',self.sd)
+  nomres=CREA_MAILLAGE( MAILLAGE=__MAPROV,
+                        CREA_POI1 = ( _F( NOM_GROUP_MA = 'P1_CORP ' ,
+                                          GROUP_NO     = 'P1_CORP ' , ),
+                                      _F( NOM_GROUP_MA = 'P2_CORP ' ,
+                                          GROUP_NO     = 'P2_CORP ' , ),
+                                      _F( NOM_GROUP_MA = 'P_TUBU ' ,
+                                          GROUP_NO     = 'P_TUBU ' ,  ),)
+                         )
+#
+  if IMPRESSION!=None:
+     for impr in IMPRESSION :
+#
+         motscles={}
+         if impr['FORMAT']=='IDEAS'  : motscles['VERSION']  =impr['VERSION']
+         if impr['FORMAT']=='CASTEM' : motscles['NIVE_GIBI']=impr['NIVE_GIBI']
+         if impr['UNITE']!=None      : motscles['UNITE']    =impr['UNITE']
+         impr_resu = _F( MAILLAGE = nomres,)
+#
+         IMPR_RESU( RESU = impr_resu, 
+                    FORMAT = impr['FORMAT'],**motscles )
+#
+#
+#     --- Verification profondeur fissure (courte débouchante) ---
+#
+  if FISCOU  and not (TFISS=='NON_DEB')    :
+      nomres=DEFI_GROUP( reuse=nomres,
+                         MAILLAGE=nomres,
+                         CREA_GROUP_NO=(_F( GROUP_MA = 'LEVRTUBU',),
+                                        _F( NOM = 'FONDORDO',
+                                            GROUP_MA = 'FONDFISS',
+                                            OPTION = 'NOEUD_ORDO',),),);
+
+      nommail=nomres.nom
+      coord   =aster.getvectjev(nommail.ljust(8)+'.COORDO    .VALE')
+      collgrno=aster.getcolljev(nommail.ljust(8)+'.GROUPENO')
+
+      grfo=collgrno['FONDORDO']
+      Nbno = len(grfo)  
+      listx = [None]*Nbno
+      listy = [None]*Nbno
+      listz = [None]*Nbno
+      k = 0
+      for node in grfo:
+         listx[k] = coord[3*(node-1)]
+         listy[k] = coord[3*(node-1)+1]
+         listz[k] = coord[3*(node-1)+2]
+         k = k+1
+
+      XAB = listx[Nbno-1] - listx[0]
+      YAB = listy[Nbno-1] - listy[0]
+      ZAB = listz[Nbno-1] - listz[0]
+      AB = sqrt(XAB*XAB + YAB*YAB +ZAB*ZAB)
+      d = 0
+      for k in range(0,Nbno) :
+         XAM = listx[k] - listx[0]
+         YAM = listy[k] - listy[0]
+         ZAM = listz[k] - listz[0]
+         Xvect = YAB*ZAM-ZAB*YAM
+         Yvect = ZAB*XAM-XAB*ZAM
+         Zvect = XAB*YAM-YAB*XAM
+         AM = sqrt(Xvect*Xvect+ Yvect*Yvect +Zvect*Zvect)
+         dk = AM/AB
+         if dk > d :
+            XC = listx[k]
+            YC = listy[k]
+            ZC = listz[k]
+         d = max(dk, d)
+   
+      grlev=collgrno['LEVRTUBU']
+      Nbnol = len(grlev)  
+      listxl = [None]*Nbnol
+      listyl = [None]*Nbnol
+      listzl = [None]*Nbnol
+      k = 0
+      for node in grlev:
+         listxl[k] = coord[3*(node-1)]
+         listyl[k] = coord[3*(node-1)+1]
+         listzl[k] = coord[3*(node-1)+2]
+         k = k+1
+      dist = 0
+      for k in range(0,Nbnol) :
+         XAM = listxl[k] - listx[0]
+         YAM = listyl[k] - listy[0]
+         ZAM = listzl[k] - listz[0]
+         Scal = (XAB*XAM + YAB*YAM + ZAB*ZAM)/(AB*AB)
+         if (abs(Scal) < 0.51) and (abs(Scal) > 0.49) :
+            Xk = listxl[k] -XC
+            Yk = listyl[k] -YC
+            Zk = listzl[k] -ZC
+            dk = sqrt(Xk**2+ Yk**2 +Zk**2)
+            dist = max(dk, dist)
+      
+      texte="<MACR_ASPIC_MAIL> PROFONDEUR DE LA FISSURE DANS LE MAILLAGE : %.2f \n"%dist
+      aster.affiche('MESSAGE',texte)
+#      
+  return ier
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py b/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py
new file mode 100644 (file)
index 0000000..30fc9ad
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_cara_poutre_ops.py
@@ -0,0 +1,848 @@
+#@ MODIF macr_cara_poutre_ops Macro  DATE 30/06/2008   AUTEUR FLEJOU J-L.FLEJOU 
+# -*- 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.
+# ======================================================================
+# RESPONSABLE JMBHH01 J.M.PROIX
+
+def macr_cara_poutre_ops(self,MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD,
+                              GROUP_MA,ORIG_INER,**args):
+  """
+     Ecriture de la macro MACR_CARA_POUTRE
+  """
+  import types,string
+  from Accas import _F
+  import aster
+  from Utilitai.Utmess     import  UTMESS
+  ier=0
+  # On importe les definitions des commandes a utiliser dans la macro
+  # Le nom de la variable doit etre obligatoirement le nom de la commande
+  LIRE_MAILLAGE   =self.get_cmd('LIRE_MAILLAGE')
+  DEFI_GROUP      =self.get_cmd('DEFI_GROUP')
+  CREA_MAILLAGE   =self.get_cmd('CREA_MAILLAGE')
+  AFFE_MODELE     =self.get_cmd('AFFE_MODELE')
+  DEFI_MATERIAU   =self.get_cmd('DEFI_MATERIAU')
+  AFFE_MATERIAU   =self.get_cmd('AFFE_MATERIAU')
+  DEFI_FONCTION   =self.get_cmd('DEFI_FONCTION')
+  DEFI_CONSTANTE  =self.get_cmd('DEFI_CONSTANTE')
+  AFFE_CHAR_THER  =self.get_cmd('AFFE_CHAR_THER')
+  AFFE_CHAR_THER_F=self.get_cmd('AFFE_CHAR_THER_F')
+  THER_LINEAIRE   =self.get_cmd('THER_LINEAIRE')
+  CALC_VECT_ELEM  =self.get_cmd('CALC_VECT_ELEM')
+  CALC_MATR_ELEM  =self.get_cmd('CALC_MATR_ELEM')
+  NUME_DDL        =self.get_cmd('NUME_DDL')
+  ASSE_VECTEUR    =self.get_cmd('ASSE_VECTEUR')
+  POST_ELEM       =self.get_cmd('POST_ELEM')
+  CALC_ELEM       =self.get_cmd('CALC_ELEM')
+  INTE_MAIL_2D    =self.get_cmd('INTE_MAIL_2D')
+  POST_RELEVE_T   =self.get_cmd('POST_RELEVE_T')
+  IMPR_TABLE      =self.get_cmd('IMPR_TABLE')
+  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 table_sdaster) est nommé 'nomres' dans le contexte de la macro
+  self.DeclareOut('nomres',self.sd)
+  #
+  if ( MAILLAGE != None ):
+      __nomlma=CREA_MAILLAGE(MAILLAGE=MAILLAGE)
+  elif ( args.has_key('UNITE') and args.has_key('FORMAT') ):
+      __nomlma=LIRE_MAILLAGE(UNITE=args['UNITE'],FORMAT=args['FORMAT'])
+  else:
+      assert False, "Erreur dans les options UNITE, FORMAT, MAILLAGE"
+
+  __nomamo=AFFE_MODELE(MAILLAGE=__nomlma,
+                       AFFE=_F(TOUT='OUI',
+                               PHENOMENE='MECANIQUE',
+                               MODELISATION='D_PLAN',),   )
+
+  __nomdma=DEFI_MATERIAU(ELAS=_F(E=1.0,NU=0.,RHO=1.0),)
+
+
+  __nomama=AFFE_MATERIAU(MAILLAGE=__nomlma,
+                         AFFE=_F(TOUT='OUI',
+                                 MATER=__nomdma,),  )
+
+
+# --- CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION :
+#     ------------------------------------------------------
+
+  motsimps={}
+  if GROUP_MA  : motsimps['GROUP_MA']  = GROUP_MA
+  if SYME_X    : motsimps['SYME_X']    = SYME_X
+  if SYME_Y    : motsimps['SYME_Y']    = SYME_Y
+  motsimps['ORIG_INER'] = ORIG_INER
+  mfact=_F(TOUT='OUI',**motsimps)
+  __cageo=POST_ELEM(MODELE=__nomamo,
+                    CHAM_MATER=__nomama,
+                    CARA_GEOM=mfact    )
+# nb  :  si GROUP_MA n existe pas : le mot clé est ignoré
+
+#
+#     ==================================================================
+# --- = CALCUL DE LA CONSTANTE DE TORSION SUR TOUT LE MAILLAGE         =
+# --- =     OU DU  CENTRE DE TORSION/CISAILLEMENT                      =
+# --- =        DES COEFFICIENTS DE CISAILLEMENT                        =
+# --- =     ET DE L INERTIE DE GAUCHISSEMENT                           =
+# --- =        DU RAYON DE TORSION SUR TOUT LE MAILLAGE
+# --- = ON CREE UN MODELE PLAN 2D THERMIQUE REPRESENTANT LA SECTION    =
+# --- = DE LA POUTRE CAR ON A A RESOUDRE DES E.D.P. AVEC DES LAPLACIENS=
+#     ==================================================================
+
+  if GROUP_MA_BORD and not GROUP_MA:
+
+# --- TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS
+# --- ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE :
+#     ---------------------------------------------------------
+     motscles={}
+     if type(GROUP_MA_BORD)==types.StringType:
+        motscles['CREA_GROUP_NO']=_F(GROUP_MA=GROUP_MA_BORD,)
+     else:
+        motscles['CREA_GROUP_NO']=[]
+        for grma in GROUP_MA_BORD:
+           motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=grma,))
+     __nomlma=DEFI_GROUP(reuse=__nomlma,
+                         MAILLAGE=__nomlma,
+                         **motscles)
+
+
+
+# --- CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES
+# --- QUE LES COORDONNEES SONT EXPRIMEES DANS LE REPERE PRINCIPAL
+# --- D INERTIE DONT L ORIGINE EST LE CENTRE DE GRAVITE DE LA SECTION :
+#     ---------------------------------------------------------------
+
+     __nomapi=CREA_MAILLAGE(MAILLAGE=__nomlma,
+                            REPERE=_F(TABLE=__cageo,
+                                      NOM_ORIG='CDG',  ),  )
+
+# --- AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE
+# --- LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE :
+#     ------------------------------------------------------
+
+     __nomoth=AFFE_MODELE(MAILLAGE=__nomapi,
+                          AFFE=_F(TOUT='OUI',
+                                  PHENOMENE='THERMIQUE',
+                                  MODELISATION='PLAN',), )
+
+# --- POUR LA CONSTRUCTION DU LAPLACIEN, ON  DEFINIT UN
+# --- PSEUDO-MATERIAU DONT LES CARACTERISTIQUES THERMIQUES SONT :
+# --- LAMBDA = 1, RHO*CP = 0 :
+#     ----------------------
+
+     __nomath=DEFI_MATERIAU(THER=_F(LAMBDA=1.0,RHO_CP=0.,),)
+
+# --- DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT :
+#     ---------------------------------------------------------
+
+     __chmath=AFFE_MATERIAU(MAILLAGE=__nomapi,
+                            AFFE=_F(TOUT='OUI',
+                                    MATER=__nomath,),   )
+
+#
+#     ------------------------------------------------------------
+# --- - CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION         -
+# --- - D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2            -
+# --- - L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION :    -
+# --- -    LAPLACIEN(PHI) = -2 DANS LA SECTION                   -
+# --- -    PHI = 0 SUR LE CONTOUR :                              -
+#     ------------------------------------------------------------
+#
+# --- ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR
+# --- DE LA SECTION
+# --- ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION :
+#     -------------------------------------------------------
+
+     motscles={}
+     if args.has_key('GROUP_MA_INTE'):
+        if args['GROUP_MA_INTE'] != None :
+           motscles['LIAISON_UNIF']=_F(GROUP_MA=args['GROUP_MA_INTE'],DDL='TEMP'),
+     __chart1=AFFE_CHAR_THER(MODELE=__nomoth,
+                             TEMP_IMPO   =_F(GROUP_NO=GROUP_MA_BORD,
+                                             TEMP=0. ),
+                             SOURCE      =_F(TOUT='OUI',
+                                             SOUR=2.0),
+                             **motscles  )
+
+# ---  POUR CHAQUE TROU DE LA SECTION :
+# ---  .ON A IMPOSE QUE PHI EST CONSTANT SUR LE CONTOUR INTERIEUR
+# ---   EN FAISANT LE LIAISON_UNIF DANS LE AFFE_CHAR_THER PRECEDENT
+# ---  .ON IMPOSE EN PLUS D(PHI)/DN = 2*AIRE(TROU)/L(TROU)
+# ---        OU D/DN DESIGNE LA DERIVEE PAR RAPPORT A LA
+# ---        NORMALE ET L DESIGNE LA LONGUEUR DU BORD DU TROU :
+#     -------------------------------------------------------
+
+     if args.has_key('GROUP_MA_INTE'):
+        lgmaint=args['GROUP_MA_INTE']
+        if lgmaint != None :
+           __tbaire=POST_ELEM(MODELE=__nomoth,
+                           AIRE_INTERNE=_F(GROUP_MA_BORD=args['GROUP_MA_INTE'],),  )
+
+           motscles={}
+           motscles['FLUX_REP']=[]
+
+           if type(lgmaint)==types.StringType:
+              motscles['FLUX_REP']=_F(GROUP_MA=args['GROUP_MA_INTE'],CARA_TORSION=__tbaire)
+           else:
+              motscles['FLUX_REP']=[]
+              for grma in lgmaint:
+                 motscles['FLUX_REP'].append(_F(GROUP_MA=grma,CARA_TORSION=__tbaire),)
+           __chart2=AFFE_CHAR_THER(MODELE=__nomoth,**motscles)
+
+# --- RESOLUTION DE LAPLACIEN(PHI) = -2
+# --- AVEC PHI = 0 SUR LE CONTOUR :
+#     ----------------------------------------
+
+     motscles={}
+     motscles['EXCIT']=[_F(CHARGE=__chart1,),]
+     if args.has_key('GROUP_MA_INTE'):
+        if lgmaint != None :
+           motscles['EXCIT'].append(_F(CHARGE=__chart2,))
+     __tempe1=THER_LINEAIRE(MODELE=__nomoth,
+                            CHAM_MATER=__chmath,
+                            SOLVEUR=_F(STOP_SINGULIER='NON',),
+                            **motscles   )
+
+#
+#     ----------------------------------------------
+# --- - CALCUL DU  CENTRE DE TORSION/CISAILLEMENT  -
+# --- - ET DES COEFFICIENTS DE CISAILLEMENT :      -
+#     ----------------------------------------------
+#
+# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR
+# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE
+# --- PAR UNE FONCTION EGALE A Y :
+#     --------------------------
+
+     __fnsec1=DEFI_FONCTION(NOM_PARA='X',
+                            VALE=(0.,0.,10.,10.),
+                            PROL_DROITE='LINEAIRE',
+                            PROL_GAUCHE='LINEAIRE',
+                           )
+
+     __fnsec0=DEFI_CONSTANTE(VALE=0.,)
+
+# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION
+# --- DE LAPLACE EST PRIS EGAL A Y DANS TOUTE LA SECTION :
+#     --------------------------------------------------
+
+
+     motscles={}
+     if args['NOEUD']!=None:
+        nthno = args['NOEUD']
+        if type(nthno)!=types.StringType : UTMESS('F','POUTRE0_3')
+        motscles['TEMP_IMPO']=(_F(NOEUD=nthno,TEMP=__fnsec0))
+     if args['GROUP_NO']!=None:
+        collgrno=aster.getcolljev(string.ljust(__nomapi.nom,8)+'.GROUPENO')
+        nomnoe  =aster.getvectjev(string.ljust(__nomapi.nom,8)+'.NOMNOE')
+        l_no=collgrno[string.ljust(args['GROUP_NO'],8)]
+        if len(l_no)!=1 : UTMESS('F','POUTRE0_3')
+        nthno=nomnoe[l_no[0]-1]
+        motscles['TEMP_IMPO']=(_F(NOEUD=nthno,TEMP=__fnsec0))
+     __chart2=AFFE_CHAR_THER_F(MODELE=__nomoth,
+                               SOURCE=_F(TOUT='OUI',
+                                         SOUR=__fnsec1,),
+                               **motscles   )
+
+# --- RESOLUTION DE     LAPLACIEN(PHI) = -Y
+# ---              AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR :
+#     ------------------------------------------------
+
+     __tempe2=THER_LINEAIRE(MODELE=__nomoth,
+                            CHAM_MATER=__chmath,
+                            EXCIT=_F(CHARGE=__chart2,),
+                            SOLVEUR=_F(STOP_SINGULIER='NON',),
+                           )
+
+# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR
+# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE
+# --- PAR UNE FONCTION EGALE A Z :
+#     --------------------------
+
+     __fnsec2=DEFI_FONCTION(NOM_PARA='Y',
+                            VALE=(0.,0.,10.,10.),
+                            PROL_DROITE='LINEAIRE',
+                            PROL_GAUCHE='LINEAIRE',
+                           )
+
+# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION
+# --- DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION :
+#     --------------------------------------------------
+
+     motscles={}
+     if args['NOEUD']!=None:
+        nthno = args['NOEUD']
+        motscles['TEMP_IMPO']=_F(NOEUD=nthno,TEMP=__fnsec0)
+     if args['GROUP_NO']!=None:
+        collgrno=aster.getcolljev(string.ljust(__nomapi.nom,8)+'.GROUPENO')
+        nomnoe  =aster.getvectjev(string.ljust(__nomapi.nom,8)+'.NOMNOE')
+        l_no=collgrno[string.ljust(args['GROUP_NO'],8)]
+        if len(l_no)!=1 : UTMESS('F','POUTRE0_3')
+        nthno=nomnoe[l_no[0]-1]
+        motscles['TEMP_IMPO']=_F(NOEUD=nthno,TEMP=__fnsec0)
+     __chart3=AFFE_CHAR_THER_F(MODELE=__nomoth,
+                               SOURCE=_F(TOUT='OUI',
+                                         SOUR=__fnsec2,),
+                               **motscles)
+
+# --- RESOLUTION DE     LAPLACIEN(PHI) = -Z
+# ---              AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR :
+#     ------------------------------------------------
+
+     __tempe3=THER_LINEAIRE(MODELE=__nomoth,
+                            CHAM_MATER=__chmath,
+                            EXCIT=_F(CHARGE=__chart3,),
+                            SOLVEUR=_F(STOP_SINGULIER='NON',),
+                           )
+
+# --- CALCUL DU RAYON DE TORSION :
+#     --------------------------
+
+#    CALCUL DU RAYON DE TORSION EXTERNE : rtext
+
+     __tempe1=CALC_ELEM(reuse=__tempe1,
+                       RESULTAT=__tempe1,
+                       MODELE=__nomoth,
+                       CHAM_MATER=__chmath,
+                       TOUT_ORDRE='OUI',
+                       OPTION='FLUX_ELNO_TEMP',
+                      )
+
+     __chem=INTE_MAIL_2D(MAILLAGE=__nomapi,
+                         DEFI_CHEMIN=_F(GROUP_MA=GROUP_MA_BORD),
+                         INFO=2,)
+
+     __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
+                             CHEMIN=__chem,
+                             RESULTAT=__tempe1,
+                             NOM_CHAM='FLUX_ELNO_TEMP',
+                             TRAC_NOR='OUI',
+                             NOM_CMP=('FLUX','FLUY'),
+                             OPERATION='MOYENNE'))
+
+     __m1=abs(__flun['TRAC_NOR',3])
+     __m2=abs(__flun['TRAC_NOR',4])
+     __rtext=max(__m1,__m2)
+
+ #    CALCUL DU RAYON DE TORSION : rt
+ #    rt = max ( rtext , 2*AIRE(TROU)/L(TROU) )
+
+     if args.has_key('GROUP_MA_INTE'):
+       if args['GROUP_MA_INTE'] != None :
+         if type(args['GROUP_MA_INTE'])==types.StringType :
+           l_group_ma_inte=[args['GROUP_MA_INTE'],]
+         else:
+           l_group_ma_inte=args['GROUP_MA_INTE']
+         for i in range(0,len(l_group_ma_inte)):
+           __chem=INTE_MAIL_2D(MAILLAGE=__nomapi,
+                               DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_inte[i]),
+                               INFO=2,)
+           __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
+                                          CHEMIN=__chem,
+                                          RESULTAT=__tempe1,
+                                          NOM_CHAM='FLUX_ELNO_TEMP',
+                                          TRAC_NOR='OUI',
+                                          NOM_CMP=('FLUX','FLUY'),
+                                          OPERATION='MOYENNE'))
+           __m1=(abs(__flun['TRAC_NOR',3])+abs(__flun['TRAC_NOR',4]))/2.
+           if __m1 > __rtext :
+             __rtext=__m1
+
+     __rt=__rtext
+
+# --- CALCUL DE LA CONSTANTE DE TORSION :
+#     ---------------------------------
+
+     motscles={}
+     if args.has_key('GROUP_MA_INTE'):
+        lgmaint=args['GROUP_MA_INTE']
+        if lgmaint != None :
+           motscles['CARA_POUTRE']=_F(CARA_GEOM=__cageo,
+                                   LAPL_PHI=__tempe1,
+                                   RT=__rt,
+                                   TOUT='OUI',
+                                   OPTION='CARA_TORSION',
+                                   GROUP_MA_INTE=args['GROUP_MA_INTE'],)
+        else:
+           motscles['CARA_POUTRE']=_F(CARA_GEOM=__cageo,
+                                    LAPL_PHI=__tempe1,
+                                    RT=__rt,
+                                    TOUT='OUI',
+                                    OPTION='CARA_TORSION',      )
+     __cator=POST_ELEM(MODELE=__nomoth,
+                       CHAM_MATER=__chmath,
+                       **motscles  )
+
+
+# --- CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU
+# --- CENTRE DE CISAILLEMENT/TORSION :
+#     ------------------------------
+
+     __cacis=POST_ELEM(MODELE=__nomoth,
+                       CHAM_MATER=__chmath,
+                       CARA_POUTRE=_F(CARA_GEOM=__cator,
+                                      LAPL_PHI_Y=__tempe2,
+                                      LAPL_PHI_Z=__tempe3,
+                                      TOUT='OUI',
+                                      OPTION='CARA_CISAILLEMENT',),  )
+
+
+#
+#     ------------------------------------------------------------
+# --- - CALCUL DE L INERTIE DE GAUCHISSEMENT PAR RESOLUTION  DE  -
+# --- -    LAPLACIEN(OMEGA) = 0     DANS LA SECTION              -
+# --- -    AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ   SUR LE               -
+# --- -    CONTOUR DE LA SECTION                                 -
+# --- -    NY ET NZ SONT LES COMPOSANTES DU VECTEUR N NORMAL     -
+# --- -    A CE CONTOUR                                          -
+# --- -    ET SOMME_S(OMEGA.DS) = 0                              -
+# --- -    OMEGA EST LA FONCTION DE GAUCHISSEMENT                -
+# --- -    L INERTIE DE GAUCHISSEMENT EST SOMME_S(OMEGA**2.DS)   -
+#     ------------------------------------------------------------
+#
+# --- CREATION D UN MAILLAGE DONT LES COORDONNEES SONT EXPRIMEES
+# --- DANS LE REPERE PRINCIPAL D INERTIE MAIS AVEC COMME ORIGINE
+# --- LE CENTRE DE TORSION DE LA SECTION, ON VA DONC UTILISER
+# --- LE MAILLAGE DE NOM NOMAPI DONT LES COORDONNEES SONT
+# --- EXPRIMEES DANS LE REPERE PRINCIPAL D'INERTIE, L'ORIGINE
+# --- ETANT LE CENTRE DE GRAVITE DE LA SECTION (QUI EST DONC
+# --- A CHANGER)  :
+#     ----------
+
+     __nomapt=CREA_MAILLAGE(MAILLAGE=__nomapi,
+                            REPERE=_F(TABLE=__cacis,
+                                      NOM_ORIG='TORSION',)  )
+
+# --- AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE
+# --- LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE :
+#     ------------------------------------------------------
+
+     __nomot2=AFFE_MODELE(MAILLAGE=__nomapt,
+                          AFFE=_F(TOUT='OUI',
+                                  PHENOMENE='THERMIQUE',
+                                  MODELISATION='PLAN', )  )
+
+# --- DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT :
+#     ---------------------------------------------------------
+
+     __chmat2=AFFE_MATERIAU(MAILLAGE=__nomapt,
+                            AFFE=_F(TOUT='OUI',
+                                    MATER=__nomath, ), )
+
+# --- POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR
+# --- LA COMPOSANTE SELON Y DU FLUX A IMPOSER SUR LE CONTOUR
+# --- PAR UNE FONCTION EGALE A -X :
+#     ---------------------------
+
+     __fnsec3=DEFI_FONCTION(NOM_PARA='X',
+                            VALE=(0.,0.,10.,-10.),
+                            PROL_DROITE='LINEAIRE',
+                            PROL_GAUCHE='LINEAIRE',
+                           )
+
+# --- POUR LE CALCUL DE L INERTIE DE GAUCHISSEMENT, ON VA DEFINIR
+# --- LA COMPOSANTE SELON X DU FLUX A IMPOSER SUR LE CONTOUR
+# --- PAR UNE FONCTION EGALE A Y :
+#     --------------------------
+
+     __fnsec4=DEFI_FONCTION(NOM_PARA='Y',
+                            VALE=(0.,0.,10.,10.),
+                            PROL_DROITE='LINEAIRE',
+                            PROL_GAUCHE='LINEAIRE',
+                           )
+
+# --- DANS LE BUT D IMPOSER LA RELATION LINEAIRE ENTRE DDLS
+# ---  SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION
+# --- VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE
+# --- N = 0, N ETANT L EFFORT NORMAL)
+# --- ON CALCULE LE VECTEUR DE CHARGEMENT DU A UN TERME SOURCE EGAL
+# --- A 1., LES TERMES DE CE VECTEUR SONT EGAUX A
+# --- SOMME_SECTION(NI.DS) ET SONT DONC LES COEFFICIENTS DE
+# --- LA RELATION LINEAIRE A IMPOSER.
+# --- ON DEFINIT DONC UN CHARGEMENT DU A UN TERME SOURCE EGAL A 1 :
+#     -----------------------------------------------------------
+
+     __chart4=AFFE_CHAR_THER(MODELE=__nomot2,
+                             SOURCE=_F(TOUT='OUI',
+                                       SOUR=1.0),  )
+
+# --- ON CALCULE LE VECT_ELEM DU AU CHARGEMENT PRECEDENT
+# --- IL S AGIT DES VECTEURS ELEMENTAIRES DONT LE TERME
+# --- AU NOEUD COURANT I EST EGAL A SOMME_SECTION(NI.DS) :
+#     --------------------------------------------------
+
+     __vecel=CALC_VECT_ELEM(CHARGE=__chart4,
+                            OPTION='CHAR_THER'
+                            )
+
+# --- ON CALCULE LE MATR_ELEM DES MATRICES ELEMENTAIRES
+# --- DE CONDUCTIVITE UNIQUEMENT POUR GENERER LE NUME_DDL
+# --- SUR-LEQUEL S APPUIERA LE CHAMNO UTILISE POUR ECRIRE LA
+# --- RELATION LINEAIRE ENTRE DDLS :
+#     ----------------------------
+
+     __matel=CALC_MATR_ELEM(MODELE=__nomot2,
+                            CHAM_MATER=__chmat2,
+                            CHARGE=__chart4,
+                            OPTION='RIGI_THER',)
+
+# --- ON DEFINIT LE NUME_DDL ASSOCIE AU MATR_ELEM DEFINI
+# --- PRECEDEMMENT POUR CONSTRUIRE LE CHAMNO UTILISE POUR ECRIRE LA
+# --- RELATION LINEAIRE ENTRE DDLS :
+#     ----------------------------
+
+     __numddl=NUME_DDL(MATR_RIGI=__matel,
+                       METHODE='LDLT',    )
+
+# --- ON CONSTRUIT LE CHAMNO QUI VA ETRE UTILISE POUR ECRIRE LA
+# --- RELATION LINEAIRE ENTRE DDLS :
+#     ----------------------------
+
+     __chamno=ASSE_VECTEUR(VECT_ELEM=__vecel,
+                           NUME_DDL=__numddl,    )
+
+# --- ON IMPOSE LA RELATION LINEAIRE ENTRE DDLS
+# ---  SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION
+# --- VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE
+# --- N = 0, N ETANT L EFFORT NORMAL)
+# --- POUR IMPOSER CETTE RELATION ON PASSE PAR LIAISON_CHAMNO,
+# --- LES TERMES DU CHAMNO (I.E. SOMME_SECTION(NI.DS))
+# --- SONT LES COEFFICIENTS DE LA RELATION LINEAIRE :
+#     ---------------------------------------------
+
+     __chart5=AFFE_CHAR_THER(MODELE=__nomot2,
+                             LIAISON_CHAMNO=_F(CHAM_NO=__chamno,
+                                               COEF_IMPO=0.),    )
+
+# --- LE CHARGEMENT EST UN FLUX REPARTI NORMAL AU CONTOUR
+# --- DONT LES COMPOSANTES SONT +Z (I.E. +Y) ET -Y (I.E. -X)
+# --- SELON LA DIRECTION NORMALE AU CONTOUR :
+#     -------------------------------------
+
+     __chart6=AFFE_CHAR_THER_F(MODELE=__nomot2,
+                               FLUX_REP=_F(GROUP_MA=GROUP_MA_BORD,
+                                           FLUX_X  =__fnsec4,
+                                           FLUX_Y  =__fnsec3,),    )
+
+# --- RESOLUTION DE     LAPLACIEN(OMEGA) = 0
+# --- AVEC D(OMEGA)/D(N) = Z*NY-Y*NZ   SUR LE CONTOUR DE LA SECTION
+# --- ET SOMME_SECTION(OMEGA.DS) = 0 ( CETTE CONDITION
+# --- VENANT DE L EQUATION D EQUILIBRE SELON L AXE DE LA POUTRE
+# --- N = 0, N ETANT L EFFORT NORMAL)  :
+#     -------------------------------
+
+     __tempe4=THER_LINEAIRE(MODELE=__nomot2,
+                            CHAM_MATER=__chmat2,
+                            EXCIT=(_F(CHARGE=__chart5,),
+                                   _F(CHARGE=__chart6,),),
+                            SOLVEUR=_F(METHODE='LDLT',
+                                       RENUM='SANS',
+                                       STOP_SINGULIER='NON',),   )
+
+# --- CALCUL DE L INERTIE DE GAUCHISSEMENT :
+#     -------------------------------------
+
+     nomres=POST_ELEM(MODELE=__nomot2,
+                      CHAM_MATER=__chmat2,
+                      CARA_POUTRE=_F(CARA_GEOM=__cacis,
+                                     LAPL_PHI=__tempe4,
+                                     TOUT='OUI',
+                                     OPTION='CARA_GAUCHI'),  )
+
+
+#
+#     ==================================================================
+# --- = CALCUL DE LA CONSTANTE DE TORSION SUR CHAQUE GROUPE            =
+# --- =     ET DU RAYON DE TORSION SUR CHAQUE GROUPE                   =
+# --- =        DU  CENTRE DE TORSION/CISAILLEMENT                      =
+# --- =        DES COEFFICIENTS DE CISAILLEMENT                        =
+#     ==================================================================
+
+
+#
+
+
+  if GROUP_MA_BORD and GROUP_MA:
+
+# --- CALCUL DES CARACTERISTIQUES GEOMETRIQUES DE LA SECTION :
+#     ------------------------------------------------------
+
+     if type(GROUP_MA_BORD)==types.StringType :
+        l_group_ma_bord=[GROUP_MA_BORD,]
+     else:
+        l_group_ma_bord= GROUP_MA_BORD
+     if type(GROUP_MA)==types.StringType :
+        l_group_ma=[GROUP_MA,]
+     else:
+        l_group_ma= GROUP_MA
+
+     l_noeud=None
+
+     if args['NOEUD']!=None:
+       if type(args['NOEUD'])==types.StringType :
+          l_noeud=[args['NOEUD'],]
+       else:
+          l_noeud= args['NOEUD']
+
+     if args['GROUP_NO']!=None:
+       collgrno=aster.getcolljev(string.ljust(__nomlma.nom,8)+'.GROUPENO')
+       nomnoe  =aster.getvectjev(string.ljust(__nomlma.nom,8)+'.NOMNOE')
+       l_nu_no =[]
+       if type(args['GROUP_NO'])==types.StringType :
+          l_gr_no=[args['GROUP_NO'],]
+       else:
+          l_gr_no= args['GROUP_NO']
+       for grno in l_gr_no:
+          l_nu_no =l_nu_no+list(collgrno[string.ljust(grno,8)])
+       l_noeud =[nomnoe[no_i-1] for no_i in l_nu_no]
+
+     if len(l_group_ma)!=len(l_group_ma_bord):
+        UTMESS('F','POUTRE0_1')
+     if l_noeud!=None and (len(l_group_ma)!=len(l_noeud)):
+        UTMESS('F','POUTRE0_2')
+
+     __catp2=__cageo
+     for i in range(0,len(l_group_ma_bord)):
+
+# --- TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS
+# --- ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE :
+#     ---------------------------------------------------------
+
+        __nomlma=DEFI_GROUP(reuse=__nomlma,
+                            MAILLAGE=__nomlma,
+                            CREA_GROUP_NO=_F(GROUP_MA=l_group_ma_bord[i],)  )
+
+
+# --- CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES
+# --- QUE LES COORDONNEES SONT EXPRIMEES DANS LE REPERE PRINCIPAL
+# --- D INERTIE DONT L ORIGINE EST LE CENTRE DE GRAVITE DE LA SECTION :
+#     ---------------------------------------------------------------
+
+        __nomapi=CREA_MAILLAGE(MAILLAGE=__nomlma,
+                               REPERE=_F(TABLE=__cageo,
+                                         NOM_ORIG='CDG',
+                                         GROUP_MA=l_group_ma[i],  ),  )
+
+# --- AFFECTATION DU PHENOMENE 'THERMIQUE' AU MODELE EN VUE DE
+# --- LA CONSTRUCTION D UN OPERATEUR LAPLACIEN SUR CE MODELE :
+#     ------------------------------------------------------
+
+        __nomoth=AFFE_MODELE(MAILLAGE=__nomapi,
+                             AFFE=_F(GROUP_MA=l_group_ma[i],
+                                     PHENOMENE='THERMIQUE',
+                                     MODELISATION='PLAN',  )  )
+
+# --- POUR LA CONSTRUCTION DU LAPLACIEN, ON  DEFINIT UN
+# --- PSEUDO-MATERIAU DONT LES CARACTERISTIQUES THERMIQUES SONT :
+# --- LAMBDA = 1, RHO*CP = 0 :
+#     ----------------------
+
+        __nomath=DEFI_MATERIAU(THER=_F(LAMBDA=1.0,
+                                       RHO_CP=0.0,  ),  )
+
+# --- DEFINITION D UN CHAM_MATER A PARTIR DU MATERIAU PRECEDENT :
+#     ---------------------------------------------------------
+
+        __chmath=AFFE_MATERIAU(MAILLAGE=__nomapi,
+                               AFFE=_F(TOUT='OUI',
+                                       MATER=__nomath ),  )
+
+#
+#     ------------------------------------------------------------
+# --- - CALCUL DE LA CONSTANTE DE TORSION PAR RESOLUTION         -
+# --- - D UN LAPLACIEN AVEC UN TERME SOURCE EGAL A -2            -
+# --- - L INCONNUE ETANT NULLE SUR LE CONTOUR DE LA SECTION :    -
+# --- -    LAPLACIEN(PHI) = -2 DANS LA SECTION                   -
+# --- -    PHI = 0 SUR LE CONTOUR :                              -
+#     ------------------------------------------------------------
+#
+# --- ON IMPOSE LA VALEUR 0 A L INCONNUE SCALAIRE SUR LE CONTOUR
+# --- DE LA SECTION
+# --- ET ON A UN TERME SOURCE EGAL A -2 DANS TOUTE LA SECTION :
+#     -------------------------------------------------------
+
+        __chart1=AFFE_CHAR_THER(MODELE=__nomoth,
+                                TEMP_IMPO=_F(GROUP_NO=l_group_ma_bord[i],
+                                             TEMP=0.0       ),
+                                SOURCE=_F(TOUT='OUI',
+                                          SOUR=2.0       )          )
+
+# --- RESOLUTION DE     LAPLACIEN(PHI) = -2
+# ---              AVEC PHI = 0 SUR LE CONTOUR :
+#     ----------------------------------------
+
+        __tempe1=THER_LINEAIRE(MODELE=__nomoth,
+                               CHAM_MATER=__chmath,
+                               EXCIT=_F(CHARGE=__chart1, ),
+                               SOLVEUR=_F(STOP_SINGULIER='NON',)    )
+
+#
+#     ----------------------------------------------
+# --- - CALCUL DU  CENTRE DE TORSION/CISAILLEMENT  -
+# --- - ET DES COEFFICIENTS DE CISAILLEMENT :      -
+#     ----------------------------------------------
+#
+# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR
+# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE
+# --- PAR UNE FONCTION EGALE A Y :
+#     --------------------------
+
+        __fnsec1=DEFI_FONCTION(NOM_PARA='X',
+                               VALE=(0.,0.,10.,10.),
+                               PROL_DROITE='LINEAIRE',
+                               PROL_GAUCHE='LINEAIRE',        )
+
+        __fnsec0=DEFI_CONSTANTE(VALE=0.,)
+
+# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION
+# --- DE LAPLACE EST PRIS EGAL A Y DANS TOUTE LA SECTION :
+#     --------------------------------------------------
+
+        __chart2=AFFE_CHAR_THER_F(MODELE=__nomoth,
+                                  TEMP_IMPO=_F(NOEUD=l_noeud[i],
+                                               TEMP=__fnsec0),
+                                  SOURCE=_F(TOUT='OUI',
+                                            SOUR=__fnsec1)       )
+
+# --- RESOLUTION DE     LAPLACIEN(PHI) = -Y
+# ---              AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR :
+#     ------------------------------------------------
+
+        __tempe2=THER_LINEAIRE(MODELE=__nomoth,
+                               CHAM_MATER=__chmath,
+                               EXCIT=_F(CHARGE=__chart2, ),
+                               SOLVEUR=_F(STOP_SINGULIER='NON',)         )
+
+# --- POUR LE CALCUL DES CONSTANTES DE CISAILLEMENT, ON VA DEFINIR
+# --- UN PREMIER TERME SOURCE, SECOND MEMBRE DE L EQUATION DE LAPLACE
+# --- PAR UNE FONCTION EGALE A Z :
+#     --------------------------
+
+        __fnsec2=DEFI_FONCTION(NOM_PARA='Y',
+                               VALE=(0.,0.,10.,10.),
+                               PROL_DROITE='LINEAIRE',
+                               PROL_GAUCHE='LINEAIRE',        )
+
+# --- LE TERME SOURCE CONSTITUANT LE SECOND MEMBRE DE L EQUATION
+# --- DE LAPLACE EST PRIS EGAL A Z DANS TOUTE LA SECTION :
+#     --------------------------------------------------
+
+        __chart3=AFFE_CHAR_THER_F(MODELE=__nomoth,
+                                  TEMP_IMPO=_F(NOEUD=l_noeud[i],
+                                               TEMP=__fnsec0),
+                                  SOURCE=_F(TOUT='OUI',
+                                            SOUR=__fnsec2)       )
+
+# --- RESOLUTION DE     LAPLACIEN(PHI) = -Z
+# ---              AVEC D(PHI)/D(N) = 0 SUR LE CONTOUR :
+#     ------------------------------------------------
+
+        __tempe3=THER_LINEAIRE(MODELE=__nomoth,
+                               CHAM_MATER=__chmath,
+                               EXCIT=_F(CHARGE=__chart3, ),
+                               SOLVEUR=_F(STOP_SINGULIER='NON',)         )
+
+# --- CALCUL DU RAYON DE TORSION :
+#     --------------------------
+
+#    CALCUL DU RAYON DE TORSION EXTERNE : rtext
+
+        __tempe1=CALC_ELEM(reuse=__tempe1,
+                            RESULTAT=__tempe1,
+                            MODELE=__nomoth,
+                            CHAM_MATER=__chmath,
+                            TOUT_ORDRE='OUI',
+                            OPTION='FLUX_ELNO_TEMP',
+                           )
+
+        __chem=INTE_MAIL_2D(MAILLAGE=__nomapi,
+                            DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_bord[i]),
+                            INFO=2,)
+
+        __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
+                                       CHEMIN=__chem,
+                                       RESULTAT=__tempe1,
+                                       NOM_CHAM='FLUX_ELNO_TEMP',
+                                       TRAC_NOR='OUI',
+                                       NOM_CMP=('FLUX','FLUY'),
+                                       OPERATION='MOYENNE'))
+
+        __m1=abs(__flun['TRAC_NOR',3])
+        __m2=abs(__flun['TRAC_NOR',4])
+        __rtext=max(__m1,__m2)
+
+#    CALCUL DU RAYON DE TORSION : rt
+#    rt = max ( rtext , 2*AIRE(TROU)/L(TROU) )
+
+        if args.has_key('GROUP_MA_INTE'):
+          if args['GROUP_MA_INTE'] != None :
+            if type(args['GROUP_MA_INTE'])==types.StringType :
+              l_group_ma_inte=[args['GROUP_MA_INTE'],]
+            else:
+              l_group_ma_inte=args['GROUP_MA_INTE']
+            for j in range(0,len(l_group_ma_inte)):
+              __chem=INTE_MAIL_2D(MAILLAGE=__nomapi,
+                                  DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_inte[j]),
+                                  INFO=2,)
+              __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM',
+                                             CHEMIN=__chem,
+                                             RESULTAT=__tempe1,
+                                             NOM_CHAM='FLUX_ELNO_TEMP',
+                                             TRAC_NOR='OUI',
+                                             NOM_CMP=('FLUX','FLUY'),
+                                             OPERATION='MOYENNE'))
+              __m1=(abs(__flun['TRAC_NOR',3])+abs(__flun['TRAC_NOR',4]))/2.
+              if __m1 > __rtext :
+                __rtext=__m1
+
+        __rt=__rtext
+
+# --- CALCUL DE LA CONSTANTE DE TORSION :
+#     ---------------------------------
+
+        __catp1=POST_ELEM(MODELE=__nomoth,
+                          CHAM_MATER=__chmath,
+                          CARA_POUTRE=_F(CARA_GEOM=__catp2,
+                                         LAPL_PHI=__tempe1,
+                                         RT=__rt,
+                                         GROUP_MA=l_group_ma[i],
+                                         OPTION='CARA_TORSION' ),     )
+
+# --- CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU
+# --- CENTRE DE CISAILLEMENT/TORSION :
+#     ------------------------------
+
+        __catp2=POST_ELEM(MODELE=__nomoth,
+                          CHAM_MATER=__chmath,
+                          CARA_POUTRE=_F(CARA_GEOM=__catp1,
+                                         LAPL_PHI_Y=__tempe2,
+                                         LAPL_PHI_Z=__tempe3,
+                                         GROUP_MA=l_group_ma[i],
+                                         LONGUEUR=args['LONGUEUR'],
+                                         MATERIAU=args['MATERIAU'],
+                                         LIAISON =args['LIAISON'],
+                                         OPTION='CARA_CISAILLEMENT' ),   )
+        IMPR_TABLE(TABLE=__catp2)
+     dprod  = __catp2.EXTR_TABLE().dict_CREA_TABLE()
+     nomres = CREA_TABLE(**dprod)
+  if not GROUP_MA_BORD :
+     nomres=POST_ELEM(MODELE=__nomamo,
+                      CHAM_MATER=__nomama,
+                      CARA_GEOM=mfact    )
+  IMPR_TABLE(TABLE=nomres)
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecla_pg_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecla_pg_ops.py
new file mode 100644 (file)
index 0000000..8bfada7
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_ecla_pg_ops.py
@@ -0,0 +1,71 @@
+#@ MODIF macr_ecla_pg_ops Macro  DATE 09/11/2004   AUTEUR VABHHTS J.PELLET 
+# -*- 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.        
+# ======================================================================
+
+########################################################################
+def macr_ecla_pg_ops(self,RESULTAT,MAILLAGE,RESU_INIT,MODELE_INIT,
+                     TOUT, GROUP_MA, MAILLE,
+                     SHRINK, TAILLE_MIN,
+                     NOM_CHAM, TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, INST, LIST_INST, PRECISION, CRITERE,  
+                     **args):
+    """
+       Ecriture de la macro macr_ecla_pg
+    """
+    import os, string
+    from Accas import _F
+    from Noyau.N_utils import AsType
+    ier=0
+
+    # On importe les definitions des commandes a utiliser dans la macro
+    CREA_MAILLAGE  =self.get_cmd('CREA_MAILLAGE')
+    CREA_RESU      =self.get_cmd('CREA_RESU')
+
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+    
+
+    # Appel à CREA_MAILLAGE :
+    motscles={}
+    if   TOUT      : motscles['TOUT']       =TOUT
+    if   GROUP_MA  : motscles['GROUP_MA']   =GROUP_MA
+    if   MAILLE    : motscles['MAILLE']     =MAILLE
+    
+    self.DeclareOut('ma2',MAILLAGE)
+    ma2=CREA_MAILLAGE(ECLA_PG=_F( MODELE = MODELE_INIT,  NOM_CHAM=NOM_CHAM,
+                                  SHRINK = SHRINK, TAILLE_MIN=TAILLE_MIN, **motscles ));
+                                   
+                                   
+
+    # Appel à CREA_RESU :
+    typ2=AsType(RESU_INIT).__name__ 
+    if   TOUT_ORDRE    : motscles['TOUT_ORDRE']     =TOUT_ORDRE
+    if   NUME_ORDRE    : motscles['NUME_ORDRE']     =NUME_ORDRE
+    if   LIST_ORDRE    : motscles['LIST_ORDRE']     =LIST_ORDRE
+    if   LIST_INST     : motscles['LIST_INST']      =LIST_INST
+    if   INST          : motscles['INST']           =INST
+    if   TOUT_ORDRE    : motscles['TOUT_ORDRE']     =TOUT_ORDRE
+
+    self.DeclareOut('resu2',RESULTAT)
+    resu2=CREA_RESU( OPERATION='ECLA_PG', TYPE_RESU=string.upper(typ2),
+                    ECLA_PG=_F( MODELE_INIT= MODELE_INIT, RESU_INIT=RESU_INIT, NOM_CHAM=NOM_CHAM,
+                                MAILLAGE= ma2, **motscles ));
+    return ier                                                           
+############################################################################################
+

diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py
new file mode 100644 (file)
index 0000000..afef7e7
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py
@@ -0,0 +1,638 @@
+#@ MODIF macr_ecre_calc_ops Macro  DATE 05/10/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+
+
+def macr_ecre_calc_ops(
+  self,
+  TABLE,
+  DEBIT,
+  FISSURE,
+  ECOULEMENT,
+  TEMPERATURE,
+  MODELE_ECRE,
+  CONVERGENCE,
+  LOGICIEL,
+  VERSION,
+  ENTETE,
+  COURBES,
+  IMPRESSION,
+  INFO,
+  **args):
+
+  """
+     Procedure de couplage Aster-Ecrevisse
+     Generation par Aster du fichier de donnees d'Ecrevisse et lancement d'Ecrevisse
+  """
+
+  import os, string, types, shutil
+  import aster
+  from Accas import _F
+  from Noyau.N_utils import AsType
+  from Utilitai.Utmess import UTMESS
+  from Utilitai.System import ExecCommand
+
+  ier=0
+
+  # Concept sortant
+  self.DeclareOut('__TAB',TABLE)
+  self.DeclareOut('__DEB',DEBIT)
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Parametres
+  # Niveaux de debug
+  debug1 = (INFO>1)
+  debug2 = (INFO>2)
+    
+
+  # Parametres Developpeur
+  tmp_ecrevisse = "tmp_ecrevisse"
+  fichier_data = "data.dat"
+  defaut = '00'
+
+  # IMPORTATION DE COMMANDES ASTER
+  EXEC_LOGICIEL  = self.get_cmd("EXEC_LOGICIEL")
+  CREA_TABLE     = self.get_cmd("CREA_TABLE")
+#  IMPR_TABLE     = self.get_cmd("IMPR_TABLE")
+  IMPR_FONCTION  = self.get_cmd("IMPR_FONCTION")
+
+  # RECUPERATION DES MOTS-CLES FACTEURS
+  dFISSURE=FISSURE[0].cree_dict_valeurs(FISSURE[0].mc_liste)
+  for i in dFISSURE.keys():
+    if dFISSURE[i]==None : del dFISSURE[i]
+
+  dECOULEMENT=ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
+  for i in dECOULEMENT.keys():
+    if dECOULEMENT[i]==None : del dECOULEMENT[i]
+
+  dTEMPERATURE=TEMPERATURE[0].cree_dict_valeurs(TEMPERATURE[0].mc_liste)
+  for i in dTEMPERATURE.keys():
+    if dTEMPERATURE[i]==None : del dTEMPERATURE[i]
+
+  dMODELE_ECRE=MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
+  for i in dMODELE_ECRE.keys():
+    if dMODELE_ECRE[i]==None : del dMODELE_ECRE[i]
+
+  dCONVERGENCE=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+  for i in dCONVERGENCE.keys():
+    if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
+
+  if debug2:
+    print 'dFISSURE = ', dFISSURE
+    print 'dECOULEMENT = ', dECOULEMENT
+    print 'dTEMPERATURE = ', dTEMPERATURE
+    print 'dMODELE_ECRE = ', dMODELE_ECRE
+    print 'dCONVERGENCE = ', dCONVERGENCE
+    print 'ENTETE = ', ENTETE
+    print 'IMPRESSION = ', IMPRESSION
+    print 'INFO = ', INFO
+
+# ---------------------------------------------------------------------
+
+  # CONSTRUCTION DU JEU DE PARAMETRES
+
+  d = {}
+  d[ 0 ] = ENTETE,
+
+  # FISSURE
+  d[ 1 ]  = defaut,
+  d[ 2 ]  = str(len(dFISSURE['LISTE_COTES_AH'])),
+  d[ 3 ]  = dFISSURE['LISTE_COTES_AH'],
+  d[ 4 ]  = dFISSURE['LISTE_VAL_AH'],
+  d[ 5 ]  = str(len(dFISSURE['LISTE_COTES_BL'])),
+  d[ 6 ]  = dFISSURE['LISTE_COTES_BL'],
+  d[ 7 ]  = dFISSURE['LISTE_VAL_BL'],
+  d[ 8 ]  = dFISSURE['LONGUEUR'],
+  d[ 9 ]  = dFISSURE['ANGLE'],
+  d[ 10 ] = dFISSURE['RUGOSITE'],
+  d[ 11 ] = dFISSURE['ZETA'],
+  if dFISSURE['SECTION'] == 'ELLIPSE':
+    d[ 1 ]  = 1,
+  if dFISSURE['SECTION'] == 'RECTANGLE':
+    d[ 1 ]  = 2,
+
+  # ECOULEMENT
+  d[ 20 ] = dECOULEMENT['PRES_ENTREE'],
+  d[ 21 ] = dECOULEMENT['PRES_SORTIE'],
+  d[ 22 ] = dECOULEMENT['FLUIDE_ENTREE'],
+  d[ 23 ] = defaut,
+  d[ 24 ] = defaut,
+  d[ 25 ] = defaut,
+  if dECOULEMENT['FLUIDE_ENTREE'] in [1, 3, 4, 6]:
+    d[ 23 ] = dECOULEMENT['TEMP_ENTREE'],
+  if dECOULEMENT['FLUIDE_ENTREE'] in [2, 5]:
+    d[ 24 ] = dECOULEMENT['TITR_MASS'],
+  if dECOULEMENT['FLUIDE_ENTREE'] in [4, 5]:
+    d[ 25 ] = dECOULEMENT['PRES_PART'],
+
+  # TEMPERATURE
+  d[ 30 ] = defaut,
+  d[ 31 ] = defaut,
+  d[ 32 ] = defaut,
+  d[ 33 ] = defaut,
+  d[ 34 ] = defaut,
+  d[ 35 ] = defaut,
+  d[ 36 ] = defaut,
+  d[ 37 ] = defaut,
+  d[ 38 ] = defaut,
+  d[ 39 ] = defaut,
+  d[ 40 ] = defaut,
+  if dTEMPERATURE['GRADIENT'] == 'FOURNI':
+    d[ 30 ] = -1
+    d[ 31 ] = len(dTEMPERATURE['LISTE_COTES_TEMP'])
+    d[ 32 ] = dTEMPERATURE['LISTE_COTES_TEMP']
+    d[ 33 ] = dTEMPERATURE['LISTE_VAL_TEMP']
+  if dTEMPERATURE['GRADIENT'] == 'IMPOSE':
+    d[ 30 ] = 0
+    d[ 34 ] = dTEMPERATURE['TEMP1']
+    d[ 35 ] = dTEMPERATURE['TEMP2']
+  if dTEMPERATURE['GRADIENT'] == 'CALCULE':
+    d[ 30 ] = 1
+    d[ 36 ] = dTEMPERATURE['EPAISSEUR_PAROI']
+    d[ 37 ] = dTEMPERATURE['CONVECTION_AMONT']
+    d[ 38 ] = dTEMPERATURE['CONVECTION_AVAL']
+    d[ 39 ] = dTEMPERATURE['LAMBDA']
+    d[ 40 ] = dTEMPERATURE['TEMP_FLUIDE_AVAL']
+
+  # MODELE_ECRE
+  d[ 60 ] = defaut,
+  d[ 61 ] = defaut,
+  if dMODELE_ECRE['ECOULEMENT'] == 'SATURATION':
+    d[ 60 ] = 1,
+  if dMODELE_ECRE['ECOULEMENT'] == 'GELE':
+    d[ 60 ] = 2,
+    d[ 61 ] = dMODELE_ECRE['PRESS_EBULLITION'],
+
+  d[ 70 ] = dMODELE_ECRE['FROTTEMENT'],
+  d[ 71 ] = defaut,
+  d[ 72 ] = defaut,
+  d[ 73 ] = defaut,
+  d[ 74 ] = defaut,
+  d[ 75 ] = defaut,
+  if dMODELE_ECRE['FROTTEMENT'] < 0:
+    d[ 71 ] = dMODELE_ECRE['REYNOLDS_LIM'],
+    d[ 72 ] = dMODELE_ECRE['FROTTEMENT_LIM'],
+
+  d[ 73 ] = dMODELE_ECRE['TRANSFERT_CHAL'],
+
+  if dMODELE_ECRE['TRANSFERT_CHAL'] == 0: pass # Pour memoire 3 cas >0, =0, <0
+  if dMODELE_ECRE['TRANSFERT_CHAL']  > 0: pass # Pour memoire 3 cas >0, =0, <0
+  if dMODELE_ECRE['TRANSFERT_CHAL']  < 0:
+    d[74] = dMODELE_ECRE['XMINCH'],
+    d[75] = dMODELE_ECRE['XMAXCH'],
+
+  d[79] = dMODELE_ECRE['IVENAC'],
+
+  if IMPRESSION == 'OUI':
+    d[ 84 ] = 1,
+  if IMPRESSION == 'NON':
+    d[ 84 ] = 0,
+
+  # CONVERGENCE
+  d[ 88 ] = dCONVERGENCE['KGTEST'],
+  d[ 89 ] = dCONVERGENCE['ITER_GLOB_MAXI'],
+  d[ 90 ] = dCONVERGENCE['CRIT_CONV_DEBI'],
+
+  if debug2: print d
+
+# ---------------------------------------------------------------------
+
+  # GENERATION DU FICHIER DATA.DAT
+  txt = fichier_data_ecrevisse()
+
+  for num_param in d.keys():
+    if type(d[num_param]) in [int, float]:
+      txt0 = str(d[num_param])
+    elif type(d[num_param]) in [tuple, list]:
+      txt0 = str(d[num_param]).replace('(', '')
+      txt0 = txt0.replace(')', '')
+      txt0 = txt0.replace(',', '')
+      txt0 = txt0.replace("'", '')
+      txt0 = txt0.replace("[", '')
+      txt0 = txt0.replace("]", '')
+    else:
+      try:    txt0 = str(d[num_param])
+      except: UTMESS('F','ECREVISSE0_11')
+
+    # On remplace la variable dans le fichier par sa valeur
+    txt = txt.replace( '$V['+str(num_param)+']', txt0 )
+
+  if debug1: print txt
+
+
+# ---------------------------------------------------------------------
+
+  # CREATION DE L'ENVIRONNEMENT D'ETUDE POUR ECREVISSE
+
+  # Repertoire temporaire d'execution d'Ecrevisse
+  tmp_ecrevisse = os.path.join(os.getcwd(),tmp_ecrevisse)
+
+  if not os.path.isdir(tmp_ecrevisse):
+    try :
+      os.mkdir(tmp_ecrevisse)
+    except os.error,erreur :
+      print "Code d'erreur de mkdir : " + str(erreur[0]) + " : " + str(erreur[1])
+      UTMESS('F','ECREVISSE0_12',valk=[tmp_ecrevisse])
+
+  # On recopie eventuellement l'ancien fichier debits
+  src = os.path.join('.', 'REPE_OUT', 'debits_dernier')
+  dst = os.path.join(tmp_ecrevisse, 'debits')
+  if os.path.isfile(src):
+     try:
+        shutil.copyfile(src, dst)
+     except Exception, e:
+        print "ERREUR : copyfile %s -> %s" % (src, dst)
+
+  # Executable Ecrevisse
+  if LOGICIEL:
+    if not os.path.isfile(str(LOGICIEL)):
+      UTMESS('F','ECREVISSE0_13')
+    else:
+      chemin_executable = str(LOGICIEL)
+  else:
+    chemin_executable = os.path.join(aster.repout(), 'ecrevisse')
+
+  # Soit on fait un lien symbolique (incompatible avec certaines plate-formes) soit on recopie l'executable
+  if not os.path.isfile(os.path.join(tmp_ecrevisse, 'ecrevisse')):
+    try:
+      os.symlink( chemin_executable, os.path.join(tmp_ecrevisse, 'ecrevisse') )
+    except:
+      UTMESS('A','ECREVISSE0_14')
+      cmd = 'cp ' + chemin_executable + ' ' + os.path.join(tmp_ecrevisse, 'ecrevisse')
+      res = os.system(cmd)
+      os.chmod( os.path.join(tmp_ecrevisse, 'ecrevisse') ,0755)
+      if (res!=0): UTMESS('F','ECREVISSE0_15')
+
+  # Ecriture du fichier de donnees pour Ecrevisse
+  fw = open(os.path.join(tmp_ecrevisse, fichier_data),'w')
+  fw.write(txt)
+  fw.close()
+
+  # Sauvegarde dans REPE_OUT du data.dat
+  os.system('cp ' + tmp_ecrevisse + '/data.dat REPE_OUT/')
+
+
+# ---------------------------------------------------------------------
+
+  # EXECUTION D'ECREVISSE
+
+  # Choix du shell
+  cmd = '#!sh'
+  for shell in ['/bin/sh', '/bin/bash', '/usr/bin/sh']:
+    if os.path.isfile(shell):
+      cmd = '#!' + shell
+      break
+
+#   #Ligne suivante a ajouter avec la version LINUX compilee avec GFORTRAN
+#   cmd = cmd + '\nexport LD_LIBRARY_PATH=/logiciels/aster/Linux/GF4/public/gcc-4.1.1/lib:$LD_LIBRARY_PATH'
+
+  # Creation du contenu du script de lancement ecrevisse.sh
+  cmd = cmd + '\ncd ' + tmp_ecrevisse + '\n' + os.path.join(tmp_ecrevisse, 'ecrevisse') + '\nset iret=$?\ncd ..\nexit $iret'
+  fw = open(os.path.join(tmp_ecrevisse, 'ecrevisse.sh'),'w')
+  fw.write(cmd)
+  fw.close()
+  os.chmod(os.path.join(tmp_ecrevisse, 'ecrevisse.sh') ,0755)
+
+  # Lancement d'Ecrevisse
+  UTMESS('I','ECREVISSE0_16')
+  res = ExecCommand(os.path.join(tmp_ecrevisse, 'ecrevisse.sh'),follow_output=True,verbose=True)
+  UTMESS('I','ECREVISSE0_17')
+
+
+  if debug1: os.system('ls -al ' + tmp_ecrevisse)
+
+
+# ---------------------------------------------------------------------
+
+  # RECUPERATION DU RESULTAT DEPUIS ECREVISSE
+
+
+  try:
+    f_ast = open(os.path.join(tmp_ecrevisse, 'pour_aster'),'r')
+    _txt = f_ast.read()
+    f_ast.close()
+    # transforme le texte en liste
+    _lst = _txt.split()
+    # transforme la liste de textes en liste de float
+    _lst = map( float, _lst )
+
+    # 5 colonnes (a partir de ECREVISSE 3.1.e)
+    #    cote z (m), flux thermique (W/m2), pression totale absolue (Pa), temperature fluide (degres C), coefficient de convection (W/m2/K)
+    _ecr_c  = _lst[1:len(_lst):5]
+    _ecr_f  = _lst[2:len(_lst):5]
+    _ecr_p  = _lst[3:len(_lst):5]
+    _ecr_t  = _lst[4:len(_lst):5]
+    _ecr_cc = _lst[5:len(_lst):5]
+
+
+  except:
+      UTMESS('F','ECREVISSE0_18')
+      _ecr_c = [-1]
+      _ecr_f = [-1]
+      _ecr_p = [-1]
+      _ecr_t = [-1]
+      _ecr_cc = [-1]
+
+  else:
+      # Generation de la table resultat
+      if debug1: print "Chargement donne par Ecrevisse"
+      if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
+      if debug1:
+        print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
+        print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
+        print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
+        print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
+        print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
+
+
+      # Formule permettant de redefinir les chargements par mailles
+      lx_ast = dFISSURE['LISTE_COTES_AH']
+
+      # epsilon pour le decalage
+      eps = 1.e-8
+
+      lx = []
+      ly = []
+      ly2 = []
+      ly3 = []
+      ly4 = []
+
+      lx.append( lx_ast[0] )
+      ly.append( _ecr_f[0] )
+      ly2.append( _ecr_p[0] )
+      ly3.append( _ecr_t[0] )
+      ly4.append( _ecr_cc[0] )
+
+      for i in range(len(lx_ast)-2):
+        x = lx_ast[i+1]
+        lx.append( x - eps )
+        lx.append( x + eps )
+        ly.append( _ecr_f[i] )
+        ly.append( _ecr_f[i+1] )
+        ly2.append( _ecr_p[i] )
+        ly2.append( _ecr_p[i+1] )
+        ly3.append( _ecr_t[i] )
+        ly3.append( _ecr_t[i+1] )
+        ly4.append( _ecr_cc[i] )
+        ly4.append( _ecr_cc[i+1] )
+      #
+      lx.append( lx_ast[-1] )
+      ly.append( _ecr_f[-1] )
+      ly2.append( _ecr_p[-1] )
+      ly3.append( _ecr_t[-1] )
+      ly4.append( _ecr_cc[-1] )
+
+      _ecr_c = lx
+      _ecr_f = ly
+      _ecr_p = ly2
+      _ecr_t = ly3
+      _ecr_cc = ly4
+
+
+  # Generation de la table resultat
+  if debug1: print "Chargement par mailles pour Aster"
+  if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
+  if debug1:
+    print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
+    print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
+    print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
+    print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
+    print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
+
+  # Creation de la SD table (resultat de CALC_ECREVISSE)
+  __TAB=CREA_TABLE(LISTE=(_F(LISTE_R=_ecr_c,
+                           PARA='COTES'),
+                        _F(LISTE_R=_ecr_f,
+                           PARA='FLUX'),
+                        _F(LISTE_R=_ecr_p,
+                           PARA='PRESSION'),
+                        _F(LISTE_R=_ecr_t,
+                           PARA='TEMP'),
+                        _F(LISTE_R=_ecr_cc,
+                           PARA='COEF_CONV'),
+                         ));
+
+
+#  if debug: IMPR_TABLE(TABLE=__TAB, FORMAT='TABLEAU',);
+
+# ---------------------------------------------------------------------
+
+  # RECUPERATION DU DEBIT DEPUIS ECREVISSE
+
+  try:
+    f_deb = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+    _tex = f_deb.read()
+    f_deb.close()
+    # transforme le texte en liste
+    _lis = _tex.split()
+    # transforme la liste de textes en liste de float
+    _lis = map( float, _lis )
+
+    # 5 colonnes (a partir de ECREVISSE 3.1.e)
+    # debit total (kg/s), debit d'air (kg/s), debit de vapeur (kg/s), debit de liquide (kg/s), type d'ecoulement
+    _dtot  = _lis[0:len(_lis):5]
+    _dair  = _lis[1:len(_lis):5]
+    _dvap  = _lis[2:len(_lis):5]
+    _dliq  = _lis[3:len(_lis):5]
+    _ecou  = _lis[4:len(_lis):5]
+
+
+  except:
+      UTMESS('A','ECREVISSE0_18')
+      _dtot = [-1]
+      _dair = [-1]
+      _dvap = [-1]
+      _dliq = [-1]
+      _ecou = [-1]
+
+
+      # Formule permettant de redefinir les chargements par mailles
+      ly_deb = LIST_INST
+
+
+      # epsilon pour le decalage
+      eps = 1.e-8
+
+      ly = []
+      ly1 = []
+      ly2 = []
+      ly3 = []
+      ly4 = []
+
+      ly.append( _dtot[0] )
+      ly1.append( _dair[0] )
+      ly2.append( _dvap[0] )
+      ly3.append( _dliq[0] )
+      ly4.append( _ecou[0] )
+
+      for i in range(len(ly_deb)-2):
+        ly.append( _dtot[i] )
+        ly.append( _dtot[i+1] )
+        ly1.append( _dair[i] )
+        ly1.append( _dair[i+1] )
+        ly2.append( _dvap[i] )
+        ly2.append( _dvap[i+1] )
+        ly3.append( _dliq[i] )
+        ly3.append( _dliq[i+1] )
+        ly4.append( _ecou[i] )
+        ly4.append( _ecou[i+1] )
+      #
+      ly.append( _dtot[-1] )
+      ly1.append( _dair[-1] )
+      ly2.append( _dvap[-1] )
+      ly3.append( _dliq[-1] )
+      ly4.append( _ecou[-1] )
+
+      _dtot = ly
+      _dair = ly1
+      _dvap = ly2
+      _dliq = ly3
+      _ecou = ly4
+
+  # Creation de la SD table (resultat de CALC_ECREVISSE)
+  __DEB=CREA_TABLE(LISTE=(_F(LISTE_R=_dtot,
+                           PARA='DEBTOT'),
+                        _F(LISTE_R=_dair,
+                           PARA='DEBAIR'),
+                        _F(LISTE_R=_dvap,
+                           PARA='DEBVAP'),
+                        _F(LISTE_R=_dliq,
+                           PARA='DEBLIQ'),
+                        _F(LISTE_I=_ecou,
+                           PARA='ECOULEMENT'),
+                         ));
+
+
+#  if debug: IMPR_TABLE(TABLE=__DEB, FORMAT='TABLEAU',);
+
+# ---------------------------------------------------------------------
+
+  # RECUPERATION DES RESULTATS OPTIONNELS DEPUIS ECREVISSE
+
+# A finir
+
+#  lst_fic = os.listdir(tmp_ecrevisse)
+
+# ---------------------------------------------------------------------
+
+  # FIN MACR_ECRE_CALC
+
+  return ier
+
+# ---------------------------------------------------------------------
+
+def fichier_data_ecrevisse():
+
+  """
+     Modele du fichier data.dat a la syntaxe Ecrevisse 3.0
+     Cette chaine de caractere est l'exacte replique d'un fichier de donnees
+     Ecrevisse 3.0 dans lequel toutes les donnees numeriques ont ete
+     remplacees par $V[x].
+  """
+
+  txt = """$V[0]
+
+
+      DONNEES GEOMETRIQUES RELATIVES A LA FISSURE
+      *******************************************
+
+$V[1]        is: type de section  (is=1 ellipse is=2 rectangle)
+$V[2]        nb points decrivant ah: grand axe  (m)
+$V[3]
+$V[4]
+$V[5]        nb points decrivant bl: petit axe (m)
+$V[6]
+$V[7]
+$V[8]        zl: longueur totale de la fissure (m)
+$V[9]        theta: angle par rapport a la verticale ascendante (en degres)
+$V[10]       eps: rugosite absolu (m)
+$V[11]       zeta: coefficient de la perte de charge singuliere a l'entree
+
+      DONNEES RELATIVES A L"ECOULEMENT
+      ********************************
+
+$V[20]       pe: pression de stagnation a l'entree (Pa)
+$V[21]       ps: pression de stagnation a la sortie (Pa)
+$V[22]       iflow : condition du fluide a l'entree
+               iflow=1  : eau sous-refroidie ou saturee
+               iflow=2  : fluide diphasique
+               iflow=3  : vapeur saturee ou surchauffee
+               iflow=4  : air + vapeur surchauffee
+               iflow=5  : air + vapeur saturee
+               iflow=6  : air seul
+$V[23]       te: temperature a l'entree (deg C) (utilise si iflow=1,3,4,6)
+$V[24]       xe: titre m. eau vap/eau tot a l'entree (utilise si iflow=2 ou 5)
+$V[25]       pae : pression partielle air en entree (Pa) (utilise si iflow>3)
+
+      DONNEES RELATIVES AU PROFIL DE TEMPERATURE A TRAVERS LA PAROI
+      *************************************************************
+
+$V[30]       imograd : modele de calcul du gradient de temperature
+               imograd=-1/ distribution imposee de temperature (max 100pts)
+               imograd=0 : profil impose de la temperature
+               imograd=1 : calcul du profil
+$V[31]       cas imograd = -1 : ntmat, nb de points donnes ensuite (max=100)
+$V[32]
+$V[33]
+$V[34]       tm1: grad. temp. paroi le lg de l'ecoul.(utilise si imograd=0) (degC/m)
+$V[35]       tm2: temperature de la paroi a l'entree (utilise si imograd=0) (degC)
+$V[36]       epp: epaisseur de la paroi (utilise si imograd=1) (m)
+$V[37]       alphe: coeff. convection face amont (utilise si imograd=1) (W/degC/m2)
+$V[38]       alphs: coeff. convection face aval  (utilise si imograd=1) (W/degC/m2)
+$V[39]       lambd: conduct. thermique de la paroi (utilise si imograd=1) (W/degC/m)
+$V[40]       ts: temperature du fluide cote aval (utilise si imograd=1) (degC)
+
+      CHOIX DES MODELES
+      *****************
+
+Modeles d'ecoulement diphasique
+-------------------------------
+$V[60]       imod : type de modele d'ecoulement diphasique
+               imod=1 : modele d'ecoulement a saturation a l'entree
+               imod=2 : modele d'ecoulement 'gele' a l'entree
+$V[61]       corrp: press. d'ebullition = corrp*psat(t)
+
+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
+
+Modelisation de la vena contracta
+---------------------------------
+$V[79]       ivenac : avec = 1, sans = 0
+
+Procedure d'impression
+----------------------
+$V[84]       iprint : impression profils ecran ( oui:1 non:0 )
+
+      DONNEES RELATIVES A LA CONVERGENCE NUMERIQUE
+      ********************************************
+
+$V[88]       kgtest (0 < kgtest < 1) tel que g=kgtest*gmax+(1-kgtest)*gmin
+$V[89]       itnmax : nombre maximum iterations methode newton
+$V[90]       precdb : critere de convergence en debit
+"""
+
+  return txt

diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py
new file mode 100644 (file)
index 0000000..2cbd64a
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py
@@ -0,0 +1,711 @@
+#@ MODIF macr_ecrevisse_ops Macro  DATE 05/10/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+
+def macr_ecrevisse_ops(self,reuse,
+   CONV_CRITERE,
+   TABLE,
+   TEMPER,
+   DEBIT,
+   MODELE_MECA,
+   MODELE_THER,
+   FISSURE,
+   ECOULEMENT,
+   LIST_INST,
+   MODELE_ECRE,
+   CONVERGENCE_ECREVISSE,
+   COURBES,
+   LOGICIEL,
+   VERSION,
+   ENTETE,
+   IMPRESSION,
+   CHAM_MATER,
+   CARA_ELEM,
+   EXCIT_MECA,
+   EXCIT_THER,
+   COMP_INCR,
+   NEWTON,
+   CONVERGENCE,
+   ETAT_INIT,
+   INFO,
+   **args):
+   """
+        Procedure de couplage Aster-Ecrevisse
+        Execution pour tous les pas de temps des calculs thermiques, mécaniques puis hydraulique
+        DecoupageGeneration par Aster du fichier de donnees d'Ecrevisse et lancement d'Ecrevisse
+   """
+
+
+   from Utilitai.Utmess import UTMESS
+   from Utilitai.Table import Table, merge
+   from Accas import _F
+   import os, aster, copy
+
+   ier=0
+   # Niveaux de debug
+   debug1 = (INFO>1)
+   debug2 = (INFO>2)
+  
+   #
+   InfoAster = 1
+   #
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # IMPORTATION DE COMMANDES ASTER
+   DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
+   THER_LINEAIRE  = self.get_cmd("THER_LINEAIRE")
+   PROJ_CHAMP     = self.get_cmd("PROJ_CHAMP")
+   DETRUIRE       = self.get_cmd("DETRUIRE")
+   AFFE_MATERIAU  = self.get_cmd("AFFE_MATERIAU")
+   STAT_NON_LINE  = self.get_cmd("STAT_NON_LINE")
+   POST_RELEVE_T  = self.get_cmd("POST_RELEVE_T")
+   CALC_ECREVISSE = self.get_cmd("CALC_ECREVISSE")
+   CO             = self.get_cmd("CO")
+   CREA_TABLE     = self.get_cmd("CREA_TABLE")
+   CREA_RESU      = self.get_cmd("CREA_RESU")
+   CREA_CHAMP     = self.get_cmd("CREA_CHAMP")
+
+   # Concepts sortants
+   # TABLE creees par concatenation des tables sorties par CALC_ECREVISSE a chaque iteration
+   self.DeclareOut('TABL_RES',TABLE)
+   self.DeclareOut('DEB_RES',DEBIT)
+   # Concepts sortant: les resultats de STAT_NON_LINE et de THER_LINEAIRE valides vis-a-vis du calcul ecrevisse
+   self.DeclareOut('RTHERM',TEMPER)
+   self.DeclareOut('MECANIC', self.sd)
+   
+   IsPoursuite = False
+   IsInit = True
+   # Traitement de l'etat initial en cas de poursuite
+   if ETAT_INIT:
+       dEtatInit=ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste)
+       for i in dEtatInit.keys():
+           if dEtatInit[i]==None : del dEtatInit[i]
+       __EVINIT = dEtatInit['EVOL_NOLI']
+       __THINIT = dEtatInit['EVOL_THER']
+       _nume_ordre = dEtatInit['NUME_ORDRE']
+       IsPoursuite= True
+   else :
+       dEtatInit=None
+ 
+   # Valeur par defaut du mot cle LOGICIEL
+   if not LOGICIEL: LOGICIEL = os.path.join(aster.repout(), 'ecrevisse')
+
+   # RECUPERATION DES MOTS-CLES FACTEURS
+
+   l_dFISSURE=[]
+   for fissure in FISSURE:
+      dFISSURE=fissure.cree_dict_valeurs(fissure.mc_liste)
+      for i in dFISSURE.keys():
+         if dFISSURE[i]==None : del dFISSURE[i]
+      l_dFISSURE.append(dFISSURE)
+
+   dECOULEMENT=ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
+   for i in dECOULEMENT.keys():
+      if dECOULEMENT[i]==None : del dECOULEMENT[i]
+
+   dMODELE_ECRE=MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
+   for i in dMODELE_ECRE.keys():
+      if dMODELE_ECRE[i]==None : dMODELE_ECRE[i]=None #del dMODELE_ECRE[i]
+
+   dCONVERGENCE_ECREVISSE=CONVERGENCE_ECREVISSE[0].cree_dict_valeurs(CONVERGENCE_ECREVISSE[0].mc_liste)
+   for i in dCONVERGENCE_ECREVISSE.keys():
+      if dCONVERGENCE_ECREVISSE[i]==None : del dCONVERGENCE_ECREVISSE[i]
+
+   dCOMP_INCR=COMP_INCR[0].cree_dict_valeurs(COMP_INCR[0].mc_liste)
+   for i in dCOMP_INCR.keys():
+      if dCOMP_INCR[i]==None : del dCOMP_INCR[i]
+
+   dNEWTON=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
+   for i in dNEWTON.keys():
+      if dNEWTON[i]==None : del dNEWTON[i]
+
+   dCONVERGENCE=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+   for i in dCONVERGENCE.keys():
+      if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
+
+   # Recuperation des infos pour la convergence de la macro
+   dMacr_Conv = CONV_CRITERE[0].cree_dict_valeurs(CONV_CRITERE[0].mc_liste)
+   for i in dMacr_Conv.keys():
+      if dMacr_Conv[i]==None : del dMacr_Conv[i]
+
+   motclefsCALC_ECREVISSE = {}
+   motclefsCALC_ECREVISSE['COURBES'] = COURBES,
+
+   # -----------------------------------------------------------------------------------------------------
+   # Debut de la macro
+
+   # Si LIST_INST est un DEFI_LIST_REEL :
+   _liste_inst = LIST_INST.Valeurs()
+   if ( debug1 ):
+      print 'liste des instants liste_inst = ', _liste_inst
+
+   # Drapeaux pour les 1ers calculs et les 1eres definitions
+   IsDefineMaterMeca  = False
+   EcrevisseExe       = False  # si l'execution d'Ecrevisse n'a pas plantee ou a ete realisee
+
+   # Table python devant contenir toutes les tables Ecrevisse
+   T_TABL_RES = None
+   T_DEB_RES  = None
+   # Precision demandee pour converger sur le critere de la macro
+   # Nombre de decoupages succesifs d'un pas de temps
+   # Pas de temps en dessous duquel on ne decoupe plus
+   if dMacr_Conv.has_key('SUBD_NIVEAU'):
+       MacrNbDecoupage   = dMacr_Conv['SUBD_NIVEAU']
+   if dMacr_Conv.has_key('SUBD_PAS_MINI'):
+       MacrPasMini       = dMacr_Conv['SUBD_PAS_MINI']
+   MacrTempRef       = dMacr_Conv['TEMP_REF']
+   MacrPresRef       = dMacr_Conv['PRES_REF']
+   MacrCritere       = dMacr_Conv['CRITERE']
+   if dMacr_Conv.has_key('PREC_CRIT'):
+      MacrPrecisCritere = dMacr_Conv['PREC_CRIT']
+   else:
+      MacrPrecisCritere = None
+   if dMacr_Conv.has_key('NUME_ORDRE_MIN'):
+      MacrNumeOrdre     = dMacr_Conv['NUME_ORDRE_MIN']
+
+   #
+   # il faut 2 pas au minimum dans la liste
+   if (len(_liste_inst) < 2 ):
+      UTMESS('F','ECREVISSE0_20', vali=[2])
+
+   if (not IsPoursuite) :
+     _nume_ordre = 0
+   else :
+     # Dans le cas d'une poursuite :
+     # n reconstruit une nouvelle liste d'instant composee de l'ancienne liste jusqu'a l'instant recherche, 
+     # puis de la nouvelle a partir de cet instant
+     # ainsi le _nume_ordre de la nouvelle liste correspond au nume_ordre de l'ancienne
+     __dico1 = __THINIT.LIST_VARI_ACCES()
+     _list_precedente = __dico1['INST']
+     _inst_init  = _list_precedente[_nume_ordre-1]
+     try:
+        # si l'instant est dans la liste, on recupere l'index
+        _idx = _liste_inst.index(_inst_init)
+     except:
+        # on cherche le plus proche
+        idx = 0
+        found = False
+        for t in _liste_inst:
+           if t > _inst_init:
+              found = True
+              idx += 1
+              break
+           idx += 1
+     new_list = _list_precedente[0:_nume_ordre]  # liste precedent jusqu'a l'instant a recalculer (inclu, ca permet de gerer le cas ou l'instant a recalculer n'est pas dans la nouvelle liste : il sera ajoute)
+     new_list.extend( _liste_inst[_idx+1:] )  # on lui ajoute la nouvelle liste a partir du l'instant a recalculer 
+     _liste_inst = copy.copy(new_list)
+     
+   ########################################################################################  
+   # Debut boucle sur la liste d'instant
+   ########################################################################################
+   FinBoucle = False
+   while ( not FinBoucle ):
+      _inst      = _liste_inst[_nume_ordre]
+      if (debug1):
+         print 'instant debut boucle', _inst
+
+      # On boucle jusqu'a convergence
+      NbIter = 0
+      while True:
+
+
+         if ( (not IsPoursuite) or EcrevisseExe) : 
+         # Le temps que l'on traite
+           _inst_p_un = _liste_inst[_nume_ordre+1]
+           IsInitEcre= False
+           # Construction de la liste des pas
+           LES_PAS = DEFI_LIST_REEL( VALE=_liste_inst, )
+           if ( debug1 ):
+              print '=====> ===== ===== ===== <===='
+              print 'Iteration numero : ', NbIter
+              print 'Instant          : ', _inst
+              print 'Instant+1        : ', _inst_p_un
+              print 'nume_ordre       : ', _nume_ordre+1
+              print 'Donnee Ecrevisse : ', EcrevisseExe
+
+           # ---------------------
+           #        THERMIQUE
+           # ---------------------
+           # Recuperation des chargements thermiques
+           _dEXCIT_THER = []
+           if EXCIT_THER:
+             for excit_i in EXCIT_THER:
+               dEXCIT_THER_i = excit_i.cree_dict_valeurs(excit_i.mc_liste)
+               for j in dEXCIT_THER_i.keys():
+                  if dEXCIT_THER_i[j]==None : del dEXCIT_THER_i[j]
+               _dEXCIT_THER.append(dEXCIT_THER_i)
+
+         #
+         # Definition des chargements thermiques venant d Ecrevisse
+           if ( EcrevisseExe ):
+              _dEXCIT_THER.append( _F(CHARGE=FLU1ECR0) )
+              _dEXCIT_THER.append( _F(CHARGE=FLU2ECR0) )
+ 
+           # Definition de l'etat initial 
+           motclefs = {}
+           if (_nume_ordre == 0) :
+              # On verifie que temp_ref est bien renseigne dans AFFE_MATERIAU            
+              try:
+                 tref = CHAM_MATER['AFFE_VARC']['VALE_REF']
+              except:
+                 UTMESS('F','ECREVISSE0_22',)
+            
+              motclefs['ETAT_INIT']=[_F(VALE=tref, NUME_ORDRE=_nume_ordre)]
+              if ( debug2 ):
+                 print 'thermique initialise avec tref'
+           else:
+              if (IsInit) :
+                 motclefs['reuse']=__THINIT  
+                 motclefs['ETAT_INIT']=[_F(EVOL_THER=__THINIT,  NUME_ORDRE=_nume_ordre)]
+                 if (debug2):
+                    print 'thermique initialise avec etat_initial'
+              else :
+                 motclefs['reuse']=RTHERM
+                 motclefs['ETAT_INIT']=[_F(EVOL_THER=RTHERM,  NUME_ORDRE=_nume_ordre)]
+                 if (debug2):
+                    print 'thermique initialise avec instant precedent'
+           if ( debug1 ):
+              print '====> THER_LINEAIRE <===='
+           if ( debug2 ):
+              print '   Les charges thermiques'
+              print EXCIT_THER
+         #
+           if IsPoursuite :
+              __THINIT = THER_LINEAIRE(
+                MODELE     = MODELE_THER,
+                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'),
+                INFO       = InfoAster,
+                **motclefs )
+            
+              RTHERMPJ=PROJ_CHAMP(RESULTAT=__THINIT, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
+                     VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
+                     INFO=2,
+                      )
+              RTHERM=__THINIT
+           else : 
+              RTHERM=THER_LINEAIRE(
+               MODELE     = MODELE_THER,
+               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'),
+               INFO       = InfoAster,
+               **motclefs
+               )
+
+           # Projection du champ thermique, à tous les instants sinon pas de deformations thermiques
+              RTHERMPJ=PROJ_CHAMP(RESULTAT=RTHERM, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
+                VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
+                INFO=2,
+                 )
+
+         # Definition du materiau pour la mecanique : a faire une seule fois
+           if ( not IsDefineMaterMeca ):
+              motclefmater = {}
+              motclefmater['AFFE'] = []
+              motclefmater['AFFE_VARC'] = []
+
+              for j in CHAM_MATER['AFFE_VARC'] :
+                 dvarc = j.cree_dict_valeurs(j.mc_liste)
+                 for mc, val in dvarc.items():
+                    if val == None:
+                       del dvarc[mc]
+                 motclefmater['AFFE_VARC'].append(dvarc)
+
+              for j in CHAM_MATER['AFFE'] :
+                 daffe = j.cree_dict_valeurs(j.mc_liste)
+                 for mc, val in daffe.items():
+                    if val == None:
+                       del daffe[mc]
+                 motclefmater['AFFE'].append(daffe)
+
+
+              dvarc['EVOL'] = RTHERMPJ
+              motclefmater['MAILLAGE'] = CHAM_MATER['MAILLAGE']
+              __MATMEC=AFFE_MATERIAU(
+                 **motclefmater
+              )
+              IsDefineMaterMeca = True
+
+           # ---------------------
+           #        MECANIQUE
+           # ---------------------
+           _dEXCIT_MECA = []
+           # Recuperation des chargements mecaniques
+           if EXCIT_MECA:
+              for excit_i in EXCIT_MECA:
+                 dEXCIT_MECA_i = excit_i.cree_dict_valeurs(excit_i.mc_liste)
+                 for j in dEXCIT_MECA_i.keys():
+                    if dEXCIT_MECA_i[j]==None : del dEXCIT_MECA_i[j]
+                 _dEXCIT_MECA.append(dEXCIT_MECA_i)
+         
+         
+           # Definition des chargements venant d'Ecrevisse
+           if ( EcrevisseExe ):
+              _dEXCIT_MECA.append( _F(CHARGE=MECAECR0) )
+
+           motclefs = {}
+
+           if (not IsPoursuite) :
+             if (_nume_ordre != 0):
+                motclefs['reuse'] = MECANIC
+                motclefs['ETAT_INIT']=[_F(EVOL_NOLI=MECANIC, NUME_ORDRE=_nume_ordre)]
+                if (debug2):
+                   print 'etat meca initial = pas precedent'
+             else:
+                if (debug2):
+                   print 'etat meca initial : vierge'   
+           else:   
+              motclefs['reuse']=__EVINIT
+              motclefs['ETAT_INIT']=[_F(EVOL_NOLI=__EVINIT, NUME_ORDRE=_nume_ordre)]
+              if (debug2):
+                 print 'etat meca initial dReuseM', motclefs
+            
+            
+           if ( debug1 ):
+              print '====> STAT_NON_LINE <===='
+           if ( debug2 ):
+              print '   Les charges mecaniques'
+              print _dEXCIT_MECA
+            
+            
+           MECANIC=STAT_NON_LINE(
+              MODELE      = MODELE_MECA,
+              CHAM_MATER  = __MATMEC,
+              CARA_ELEM   = CARA_ELEM,
+              EXCIT       = _dEXCIT_MECA,
+              COMP_INCR   = _F(**dCOMP_INCR),
+              INCREMENT   = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,),
+              NEWTON      = _F(**dNEWTON),
+              CONVERGENCE = _F(**dCONVERGENCE),
+              SOLVEUR     = _F(SYME='OUI'),
+              ARCHIVAGE   = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
+              INFO        = InfoAster,
+              **motclefs
+           )
+           # Destruction des concepts
+           #  Thermique projete
+           #  Liste des pas
+           DETRUIRE( CONCEPT=(_F(NOM=RTHERMPJ),_F(NOM=LES_PAS),),INFO=1,ALARME='NON',)
+         
+         else :
+           #      CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE 
+           #     LES CHARGEMENT A UTILISER POUR LES PROBLEMES THERMIQUES ET MECANIQUES
+           _inst_p_un=_inst
+           IsInitEcre = True
+           
+         # -----------------------------------------------------------------------
+         #        ECREVISSE : ATTENTION SI REPRISE CALCUL, ON RECALCULE LE DERNIER INSTANT
+         # -------------------------------------------------------------------------
+         # Si Ecrevisse a deja ete fait une fois.
+         #   ==> Efface les concepts qui sont en sortie
+         if ( EcrevisseExe ):
+            DETRUIRE(
+               CONCEPT=(
+                  _F(NOM=MECAECR1),
+                  _F(NOM=FLU1ECR1),
+                  _F(NOM=FLU2ECR1),
+                  _F(NOM=TABLECR1),
+                  _F(NOM=DEBIECR1),
+               ),INFO=1,ALARME='NON',
+            )
+
+         # On remplace FONC_XXX par la valeur XXX correspondante a l'instant _inst_p_un
+         dECOULEMENT_ecrevisse = copy.copy(dECOULEMENT)
+         for fonc_name in ["PRES_ENTREE_FO", "PRES_SORTIE_FO", "PRES_PART_FO", "TITR_MASS_FO", "TEMP_ENTREE_FO"]:
+            if dECOULEMENT.has_key(fonc_name):
+               fonc = dECOULEMENT_ecrevisse.pop(fonc_name)
+               vale_name = fonc_name.replace('_FO', '')
+               dECOULEMENT_ecrevisse[vale_name] = fonc(_inst_p_un)
+
+
+         # Initialisation des concepts en sortie
+         MECAECR1=CO('MECAECR1')
+         FLU1ECR1=CO('FLU1ECR1')
+         FLU2ECR1=CO('FLU2ECR1')
+         TABLECR1=CO('TABLECR1')
+         DEBIECR1=CO('DEBIECR1')
+
+         if ( debug1 ):
+            print '====> ECREVISSE entree dans CALC_ECREVISSE <===='
+         
+         if (not IsPoursuite) : 
+                  
+           CALC_ECREVISSE(
+              CHARGE_MECA      = MECAECR1,
+              CHARGE_THER1     = FLU1ECR1,
+              CHARGE_THER2     = FLU2ECR1,
+              TABLE            = TABLECR1,
+              DEBIT            = DEBIECR1,
+              MODELE_MECA      = MODELE_MECA,
+              MODELE_THER      = MODELE_THER,
+              ENTETE           = ENTETE,
+              IMPRESSION       = IMPRESSION,
+              INFO             = INFO,
+              RESULTAT=_F(THERMIQUE  = RTHERM,
+                        MECANIQUE  = MECANIC,
+                        INST       = _inst_p_un, ),
+              # chemin d acces a Ecrevisse
+              LOGICIEL         = LOGICIEL,
+              VERSION          = VERSION,
+              # donnees necessaire pour ecrevisse
+              # assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
+              # activation eventuelle de TITR_VA et P_AIR
+
+              FISSURE=l_dFISSURE, # TODO a verifier
+              ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
+              MODELE_ECRE=_F( **dMODELE_ECRE),
+
+              CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
+              **motclefsCALC_ECREVISSE
+              );
+         else :
+           CALC_ECREVISSE(
+              CHARGE_MECA      = MECAECR1,
+              CHARGE_THER1     = FLU1ECR1,
+              CHARGE_THER2     = FLU2ECR1,
+              TABLE            = TABLECR1,
+              DEBIT            = DEBIECR1,
+              MODELE_MECA      = MODELE_MECA,
+              MODELE_THER      = MODELE_THER,
+              ENTETE           = ENTETE,
+              IMPRESSION       = IMPRESSION,
+              INFO             = INFO,
+              RESULTAT=_F(THERMIQUE  = __THINIT,
+                          MECANIQUE  = __EVINIT,
+                          INST       = _inst_p_un, ),
+              # chemin d acces a Ecrevisse
+              LOGICIEL         = LOGICIEL,
+              VERSION          = VERSION,
+              # donnees necessaire pour ecrevisse
+              # assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
+              # activation eventuelle de TITR_VA et P_AIR
+
+              FISSURE=l_dFISSURE, # TODO a verifier
+              ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
+              MODELE_ECRE=_F( **dMODELE_ECRE),
+
+              CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
+              **motclefsCALC_ECREVISSE
+              );
+                
+         if ( debug1 ):
+            print '====> ECREVISSE sortie de CALC_ECREVISSE <===='
+
+
+         # Recuperation des infos de la table resultat Ecrevisse
+         T_TABL_TMP1 = TABLECR1.EXTR_TABLE()
+         T_DEB_TMP1  = DEBIECR1.EXTR_TABLE()
+#         # Ajout de deux colonnes supplementaires
+#         _nb_ligne = len(T_DEB_TMP1["DEBTOT"])
+#         T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*_nb_ligne
+#         T_DEB_TMP1["INST"]       = [_inst_p_un]*_nb_ligne
+         
+         # Le calcul Ecrevisse c'est bien passe ?
+         EcrevisseExe = ( T_TABL_TMP1.values()['COTES'][0] != -1 )
+         #
+         if ( not EcrevisseExe ):
+            # Destruction des concepts de sortie, et on arrete tout
+            DETRUIRE(
+               CONCEPT=( _F(NOM=MECAECR1),
+                         _F(NOM=FLU1ECR1),
+                         _F(NOM=FLU2ECR1),
+                         _F(NOM=TABLECR1),
+                         _F(NOM=DEBIECR1),
+               ),
+               INFO=1,ALARME='NON',
+            )
+            if ( not IsInit ):
+               DETRUIRE(
+                  CONCEPT=( _F(NOM=MECAECR0),
+                            _F(NOM=FLU1ECR0),
+                            _F(NOM=FLU2ECR0),
+                            _F(NOM=TABLECR0),
+                            _F(NOM=DEBIECR0),
+                  ),
+                  INFO=1,ALARME='NON',
+               )
+            FinBoucle = True
+            break
+         #
+         # A t'on atteint la convergence
+         #  TABLECR0 table Ecrevisse a _inst
+         #  TABLECR1 table Ecrevisse a _inst_p_un
+         # --------------------
+         
+         if ( not IsInit ):
+            # On recupere la liste des temperatures a t et t+1
+            lst_T_0 = T_TABL_TMP0.values()['TEMP']
+            lst_T_1 = T_TABL_TMP1.values()['TEMP']
+            # Le maximum des ecarts
+            lst_T_diff_01 = []
+            for v1, v2 in zip(lst_T_0,lst_T_1):
+               lst_T_diff_01.append(abs(v1-v2))
+            max_T_diff_01 = max(lst_T_diff_01)
+
+            # On recupere la liste des pressions a t et t+1
+            lst_P_0 = T_TABL_TMP0.values()['PRESSION']
+            lst_P_1 = T_TABL_TMP1.values()['PRESSION']
+            # Le maximum des ecarts
+            lst_P_diff_01 = []
+            for v1, v2 in zip(lst_P_0,lst_P_1):
+               lst_P_diff_01.append(abs(v1-v2))
+            max_P_diff_01 = max(lst_P_diff_01)
+            #
+            # "TEMP_PRESS","EXPLICITE","TEMP","PRESS"
+            ErreurT = (max_T_diff_01/MacrTempRef)
+            ErreurP = (max_P_diff_01/MacrPresRef)
+            ErreurG = (ErreurT**2+ErreurP**2)**0.5
+            if   ( MacrCritere == 'TEMP' ):
+               Erreur = ErreurT
+            elif ( MacrCritere == 'PRESS' ):
+               Erreur = ErreurP
+            else:
+               Erreur = ErreurG
+            #
+            print 'CONVERGENCE_MACR_ECREVISSE. Instant de calcul : %.3f .' % (_inst_p_un)
+            print '  Erreur en Temperature : %f . Ecart en Temperature : %.3f' % (ErreurT,max_T_diff_01)
+            print '  Erreur en Pression    : %f . Ecart en Pression    : %.3f' % (ErreurP,max_P_diff_01)
+            print '  Erreur Temp-Press     : %f' % (ErreurG)
+            if ( MacrCritere != 'EXPLICITE' ):
+               Convergence = ( Erreur <= MacrPrecisCritere )
+               print 'CONVERGENCE_MACR_ECREVISSE . Nature du Critere %s . Valeur du critere %s . Convergence %s ' % (MacrCritere,MacrPrecisCritere,Convergence,)
+
+         else:
+            Convergence = True
+            print 'CONVERGENCE_MACR_ECREVISSE. 1er Instant de calcul : %f . Pas de calcul de critere.' % (_inst_p_un)
+         # --------------------
+
+         #
+
+         if ( MacrCritere == 'EXPLICITE' ):
+            Convergence = True
+         else:
+            if ( (_nume_ordre != 0) and (_nume_ordre+1 <= MacrNumeOrdre) ):
+               UTMESS('A','ECREVISSE0_33', vali=[_nume_ordre+1,MacrNumeOrdre],valr=[_inst_p_un])
+               Convergence = True
+
+         if ( Convergence ):
+            nb_lignes_t1 = len(T_TABL_TMP1["COTES"])
+            # Ajout de deux colonnes supplementaires
+            # POUR LA TABLE ECREVISSE
+            T_TABL_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_lignes_t1
+            T_TABL_TMP1["INST"]       = [_inst_p_un]*nb_lignes_t1
+
+            # POUR LA TABLE DES DEBITS  
+            nb_ligne_t2 = len(T_DEB_TMP1["DEBTOT"])
+            T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_ligne_t2
+            T_DEB_TMP1["INST"]       = [_inst_p_un]*nb_ligne_t2
+
+            #
+            # Ajout des infos dans la table finale
+            if ( IsInit ):
+               T_TABL_RES = T_TABL_TMP1
+               T_DEB_RES  = T_DEB_TMP1
+            else:
+               T_TABL_RES = merge(T_TABL_RES, T_TABL_TMP1)
+               T_DEB_RES = merge(T_DEB_RES, T_DEB_TMP1)
+               T_TABL_RES.titr = 'TABLE_SDASTER CHARGEMENT ECREVISSE'
+               T_DEB_RES.titr = 'TABLE_SDASTER DEBIT ECREVISSE'
+            #
+            # RAZ des compteurs de division
+            NbIter = 0
+            # On memorise les concepts valides
+            MECAECR0 = MECAECR1
+            FLU1ECR0 = FLU1ECR1
+            FLU2ECR0 = FLU2ECR1
+            TABLECR0 = TABLECR1
+            DEBIECR0 = DEBIECR1
+            #
+            T_TABL_TMP0 = T_TABL_TMP1
+            if (not IsInitEcre) :
+              IsInit = False
+            if ( debug1 ):
+               print 'Convergence atteinte, on passe au pas de temps suivant'
+            break
+            
+         else:
+            NbIter += 1
+            # A t'on le droit de decouper, par rapport au nombre de division
+            if ( NbIter > MacrNbDecoupage ):
+               FinBoucle = True
+               UTMESS('A','ECREVISSE0_30', valr=[_inst,_inst_p_un],vali=[MacrNbDecoupage])
+               break
+            #
+            # on divise le pas de temps par 2
+            tmp = (_inst + _inst_p_un )*0.5
+            # A t'on le droit de continuer, par rapport au pas de temps minimum
+            if ( (tmp - _inst) <= MacrPasMini ):
+               FinBoucle = True
+               UTMESS('A','ECREVISSE0_31', valr=[_inst,_inst_p_un,tmp,MacrPasMini])
+               break
+            #
+            if ( debug1 ):
+               UTMESS('A','ECREVISSE0_32', valr=[_inst,_inst_p_un,tmp],vali=[NbIter])
+            # on insere le nouveau temps dans la liste des instants avant "_inst_p_un"
+            _liste_inst.insert(_nume_ordre+1,tmp)
+
+
+      # Convergence atteinte, on passe au pas de temps suivant, s'il en reste
+      if IsInitEcre :
+         continue
+      elif (_nume_ordre + 2 < len(_liste_inst)):
+         _nume_ordre += 1
+      else:
+         # On a fait tous les pas de temps
+         FinBoucle = True
+   #######################################################################################
+   #     Fin boucle sur les pas de temps
+   #######################################################################################
+
+   # Creation du concept de la table en sortie
+   if ( T_TABL_RES != None ):
+      dprod = T_TABL_RES.dict_CREA_TABLE()
+      TABL_RES = CREA_TABLE(**dprod)
+   if ( T_DEB_RES != None ):
+      debprod = T_DEB_RES.dict_CREA_TABLE()
+      DEB_RES = CREA_TABLE(**debprod)
+
+   # Destruction des concepts temporaires
+   DETRUIRE(
+            CONCEPT=( _F(NOM=MECAECR1),
+                      _F(NOM=FLU1ECR1),
+                      _F(NOM=FLU2ECR1),
+                      _F(NOM=TABLECR1),
+                      _F(NOM=DEBIECR1),
+            ),
+            INFO=1,ALARME='NON',
+   )
+   
+   if (_nume_ordre != 0 ):
+       DETRUIRE(
+                CONCEPT=( _F(NOM=MECAECR0),
+                          _F(NOM=FLU1ECR0),
+                          _F(NOM=FLU2ECR0),
+                          _F(NOM=TABLECR0),
+                          _F(NOM=DEBIECR0),
+                ),
+                INFO=1,ALARME='NON',
+       )
+
+   return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macr_fiab_impr_ops.py b/Aster/Cata/cataSTA10/Macro/macr_fiab_impr_ops.py
new file mode 100644 (file)
index 0000000..08ac8d1
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_fiab_impr_ops.py
@@ -0,0 +1,110 @@
+#@ MODIF macr_fiab_impr_ops Macro  DATE 24/01/2005   AUTEUR DURAND C.DURAND 
+# -*- 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 GNICOLAS G.NICOLAS
+#
+def macr_fiab_impr_ops(self, INFO,
+                       TABLE_CIBLE, NOM_PARA_CIBLE, GRADIENTS, **args):
+#
+#
+#  1. args est le dictionnaire des arguments
+#    args.keys() est la liste des mots-clés
+#    args.keys()[0] est la premiere valeur de cette liste
+#    args.keys()[1:] est la liste des valeurs suivantes dans cette liste
+#    args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
+#
+  """ Macro-commande réalisant l'impression des valeurs pour le logiciel de fiabilite. """
+#
+# On charge les modules nécessaires
+  from Accas import _F
+#
+#____________________________________________________________________
+#
+# 1. Préalables
+#____________________________________________________________________
+#
+  erreur = 0
+#
+# 1.1 ==> La macro compte pour 1 dans l'exécution des commandes
+#
+  self.set_icmd(1)
+#
+# 1.2 ==> On importe les définitions des commandes Aster utilisées
+#         dans la macro
+#
+  DEFI_FICHIER = self.get_cmd("DEFI_FICHIER")
+  IMPR_TABLE   = self.get_cmd("IMPR_TABLE")
+#
+# 1.3. ==> Des constantes
+#          Atention : le numéro d'unité utilisé ici et celui
+#                     utlisé dans le python d'échange lance_aster_5
+#                     doivent correspondre.
+#
+  Unite_Fichier_ASTER_vers_FIABILITE = 91
+  Nom_Symbolique_Fichier_ASTER_vers_FIABILITE = "ASTER_vers_FIABILITE"
+  FORMAT_R="1PE17.10"
+#____________________________________________________________________
+#
+# 2. Définition d'un fichier d'échange
+#____________________________________________________________________
+# 
+  DEFI_FICHIER ( ACTION= "ASSOCIER",
+#                FICHIER = Nom_Symbolique_Fichier_ASTER_vers_FIABILITE,
+                 UNITE = Unite_Fichier_ASTER_vers_FIABILITE,
+                 TYPE = "ASCII",
+                 INFO = INFO )
+#____________________________________________________________________
+#
+# 4. Ecriture de la valeur cible
+#____________________________________________________________________
+#
+  IMPR_TABLE ( TABLE = TABLE_CIBLE,
+               NOM_PARA = NOM_PARA_CIBLE,
+               UNITE = Unite_Fichier_ASTER_vers_FIABILITE,
+               FORMAT_R = FORMAT_R,
+               INFO = INFO )
+#____________________________________________________________________
+#
+# 5. Ecritures des gradients
+#____________________________________________________________________
+#
+  if GRADIENTS is not None :
+#
+    for val in GRADIENTS :
+#
+      IMPR_TABLE ( TABLE = val["TABLE"],
+                   SENSIBILITE = val["PARA_SENSI"],
+                   NOM_PARA = (val["NOM_PARA"]),
+                   UNITE = Unite_Fichier_ASTER_vers_FIABILITE,
+                   FORMAT_R = FORMAT_R,
+                   INFO = INFO )
+#____________________________________________________________________
+#
+# 6. Libération du fichier d'échange
+#____________________________________________________________________
+# 
+  DEFI_FICHIER ( ACTION= "LIBERER",
+                 UNITE = Unite_Fichier_ASTER_vers_FIABILITE,
+                 INFO = INFO )
+#
+#--------------------------------------------------------------------
+# 7. C'est fini !
+#--------------------------------------------------------------------
+#
+  return erreur

diff --git a/Aster/Cata/cataSTA10/Macro/macr_fiabilite_ops.py b/Aster/Cata/cataSTA10/Macro/macr_fiabilite_ops.py
new file mode 100644 (file)
index 0000000..fae5047
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_fiabilite_ops.py
@@ -0,0 +1,359 @@
+#@ MODIF macr_fiabilite_ops Macro  DATE 27/11/2006   AUTEUR GNICOLAS G.NICOLAS 
+# -*- 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 GNICOLAS G.NICOLAS
+#
+def macr_fiabilite_ops(self, INFO,
+                       LOGICIEL, VERSION,
+                       UNITE_ESCL, MESS_ASTER,
+                       SEUIL, SEUIL_TYPE,
+                       VARIABLE,
+                       **args ) :
+#
+#    args est le dictionnaire des arguments optionnels
+#    args.keys() est la liste des mots-clés
+#    args.keys()[0] est la premiere valeur de cette liste
+#    args.keys()[1:] est la liste des valeurs suivantes dans cette liste
+#    args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
+###  print args
+###  print args.keys()
+###  if len (args.keys())>0 : print args.keys()[0]
+#
+  """ Macro-commande réalisant le pilotage du logiciel de fiabilite. """
+#
+# On charge les modules nécessaires
+  from Accas import _F
+  from Macro import fiabilite_mefisto
+  import aster
+  import os
+  import string
+  import sys
+  import Numeric
+#
+#____________________________________________________________________
+#
+# 1. Préalables
+#____________________________________________________________________
+#
+# 1.1 ==> La macro compte pour 1 dans l'exécution des commandes
+#
+  self.set_icmd(1)
+#
+# 1.2 ==> On importe les définitions des commandes Aster utilisées
+#         dans la macro
+#
+  EXEC_LOGICIEL  = self.get_cmd("EXEC_LOGICIEL")
+  DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
+#
+# 1.3 ==> Le nom du programme de fiabilite à lancer
+#
+  repertoire_outils = aster.repout()
+  fiabilite      = repertoire_outils + "fiabilite"
+#
+# 1.4 ==> Initialisations
+#
+  erreur = 0
+  erreur_partiel = [0]
+  Rep_Calc_ASTER = os.getcwd()
+  Nom_Exec_ASTER = sys.executable
+#
+  messages_erreur = { 0 : "Tout va bien",
+                      1 : "Impossible de créer le répertoire de travail pour le logiciel de fiabilité.",
+                      2 : "Probleme d'ouverture du fichier.",
+                     10 : "Erreur dans le choix du logiciel de fiabilité.",
+                     11 : "Erreur dans la création des données pour le logiciel de fiabilité.",
+                    100 : "Erreur." }
+#
+  while not erreur :
+#
+#____________________________________________________________________
+#
+# 2. Répertoires et fichiers
+#____________________________________________________________________
+#
+# 2.1. ==> Création du répertoire pour l'exécution du logiciel de fiabilité
+#
+    Nom_Rep_local = "tmp_fiabilite"
+    Rep_Calc_LOGICIEL_local = os.path.join(".", Nom_Rep_local)
+    Rep_Calc_LOGICIEL_global = os.path.join(Rep_Calc_ASTER, Nom_Rep_local)
+#
+    try :
+      os.mkdir(Rep_Calc_LOGICIEL_global)
+    except os.error, erreur_partiel :
+      self.cr.warn("Code d'erreur de mkdir : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
+      self.cr.fatal("Impossible de créer le répertoire de travail pour le logiciel de fiabilité : "+Rep_Calc_LOGICIEL_global)
+      erreur = erreur + 1
+      break
+#
+# 2.2. ==> On définit un fichier pour les résultats du calcul de fiabilité
+#
+    FIC_RESU_FIABILITE = os.path.join(Rep_Calc_LOGICIEL_global, "resu_fiabilite")
+#
+# 2.3. ==> On crée un fichier annexe pour transmettre des données à la procédure
+#          de lancement des calculs ASTER par le LOGICIEL.
+#          Ce fichier est créé dans le répertoire d'exécution du logiciel de fiabilité.
+#          On fait ainsi car les arguments passés ont du mal à transiter via l'exécutable.
+#          On stocke :
+#          1. Le niveau d'information
+#          2. L'unité logique associée au jeu de commandes déterministes
+#          3. La gestion des sorties ASTER
+#          4. Le nom de l'exécutable ASTER
+#          5. Le type de seuil du problème (maximum ou minimum)
+#
+    fic_Info_ASTER = os.path.join(Rep_Calc_LOGICIEL_global,"InfoExecASTER")
+    try :
+      f_execAster = open(fic_Info_ASTER, "w")
+    except os.error,erreur_partiel :
+      self.cr.warn("Fichier : "+fic_Info_ASTER)
+      self.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
+      erreur = 2
+      break
+#
+    f_execAster.write(str(INFO)+"\n")
+    f_execAster.write(str(UNITE_ESCL)+"\n")
+    f_execAster.write(str(MESS_ASTER)+"\n")
+    f_execAster.write(str(Nom_Exec_ASTER)+"\n")
+    f_execAster.write(str(SEUIL_TYPE))
+    f_execAster.close()
+    fichier = open (fic_Info_ASTER,"r")
+#
+    if INFO >= 2 :
+      print "\nContenu du fichier " + fic_Info_ASTER," :"
+      les_lignes = fichier.readlines()
+      fichier.close()
+      print les_lignes, "\n"
+#
+#____________________________________________________________________
+#
+# 3. Les variables par defaut
+#____________________________________________________________________
+#
+# 3.1. ==> Dictionnaire des valeurs physiques et liées à la loi
+#
+    valeurs_lois = { }
+#
+    for la_variable in VARIABLE :
+#
+      v_moy_physique = None
+      v_moy_loi = None
+      v_min_loi = None
+      v_max_loi = None
+      sigma_loi = None
+#
+# 3.1.1. ==> loi uniforme : transfert des min et max
+#            on définit une moyennne comme étant la médiane des extremes.
+#
+      if la_variable["LOI"] == "UNIFORME" :
+        v_moy_physique = 0.5 * ( la_variable["VALE_MIN"] + la_variable["VALE_MAX"] )
+        v_min_loi = la_variable["VALE_MIN"]
+        v_max_loi = la_variable["VALE_MAX"]
+#
+# 3.1.2. ==> loi normale : transfert des moyennne et écart-type.
+#
+      elif la_variable["LOI"] == "NORMALE" :
+        v_moy_loi = la_variable["VALE_MOY"]
+        v_moy_physique = v_moy_loi
+        sigma_loi = la_variable["ECART_TYPE"]
+#
+# 3.1.3. ==> loi lognormale : identité du min, conversion pour le reste
+#
+      elif la_variable["LOI"] == "LOGNORMALE" :
+        v_min_loi = la_variable["VALE_MIN"]
+        if la_variable["VALE_MOY_PHY"] is None :
+          v_moy_loi = la_variable["VALE_MOY"]
+          sigma_loi = la_variable["ECART_TYPE"]
+          aux = Numeric.exp(0.5*sigma_loi*sigma_loi+v_moy_loi)
+          v_moy_physique = v_min_loi + aux
+        else :
+          v_moy_physique = la_variable["VALE_MOY_PHY"]
+          aux = la_variable["ECART_TYPE_PHY"]/(la_variable["VALE_MOY_PHY"]-la_variable["VALE_MIN"])
+          aux1 = 1. + aux*aux
+          aux2 = Numeric.sqrt(aux1)
+          v_moy_loi = Numeric.log((la_variable["VALE_MOY_PHY"]-la_variable["VALE_MIN"])/aux2)
+          aux2 = Numeric.log(aux1)
+          sigma_loi = Numeric.sqrt(aux2)
+#
+# 3.1.4. ==> loi normale tronquée : transfert des moyenne, mini/maxi et écart-type
+#            on définit une moyennne comme étant la médiane des extremes.
+#
+      else :
+        v_moy_loi = la_variable["VALE_MOY"]
+        v_min_loi = la_variable["VALE_MIN"]
+        v_max_loi = la_variable["VALE_MAX"]
+        sigma_loi = la_variable["ECART_TYPE"]
+        v_moy_physique = 0.5 * ( la_variable["VALE_MIN"] + la_variable["VALE_MAX"] )
+#
+      dico = { }
+      dico["v_moy_physique"] = v_moy_physique
+      dico["v_moy_loi"] = v_moy_loi
+      dico["v_min_loi"] = v_min_loi
+      dico["v_max_loi"] = v_max_loi
+      dico["sigma_loi"] = sigma_loi
+      valeurs_lois[la_variable] = dico
+#
+#____________________________________________________________________
+#
+# 4. Création des fichiers de donnees pour le logiciel de fiabilite
+#____________________________________________________________________
+#
+    if ( LOGICIEL == "MEFISTO" ) :
+#
+# 4.1. ==> MEFISTO
+#
+      erreur = fiabilite_mefisto.fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global,
+                                                     INFO, VERSION,
+                                                     SEUIL, SEUIL_TYPE,
+                                                     VARIABLE,
+                                                     valeurs_lois,
+                                                     **args )
+#
+# 4.2. ==> Erreur si autre logiciel
+#
+    else :
+#
+      self.cr.warn("Logiciel de fiabilité : "+LOGICIEL)
+      erreur = 10
+#
+# 4.3. ==> Arret en cas d'erreur
+#
+    if erreur :
+      break
+#
+#____________________________________________________________________
+#
+# 5. Ecriture de la commande d"exécution du logiciel de fiabilité
+#
+#   Remarque : dans la donnée de la version du logiciel de fiabilité, il faut remplacer
+#              le _ de la donnée par un ., qui
+#              est interdit dans la syntaxe du langage de commandes ASTER
+#   Remarque : il faut remplacer le N majuscule de la donnee par
+#              un n minuscule, qui est interdit dans la syntaxe du langage
+#              de commandes ASTER
+#____________________________________________________________________
+#
+#
+    VERSION = string.replace(VERSION, "_", ".")
+    VERSION = string.replace(VERSION, "N", "n")
+#
+    EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_LOGICIEL_global, # nom du repertoire
+                                LOGICIEL,                 # nom du logiciel de fiabilité
+                                VERSION,                  # version du logiciel de fiabilité
+                                FIC_RESU_FIABILITE,       # fichier des résultats du logiciel de fiabilité
+                               ),
+                    LOGICIEL = fiabilite
+                   )
+#
+#--------------------------------------------------------------------
+# 6. C'est fini !
+#--------------------------------------------------------------------
+#
+    break
+#
+# 6.1. ==> Arret en cas d'erreur
+#
+  if erreur :
+    if not messages_erreur.has_key(erreur) :
+      erreur = 100
+    self.cr.fatal(messages_erreur[erreur])
+#
+# 6.2. ==> Si tout va bien, on crée une liste de réels pour le retour.
+#          Si le fichier n'a pas été rempli, on met une valeur nulle unique.
+#
+  if os.path.isfile(FIC_RESU_FIABILITE) :
+    liste_reel = []
+    fic = open(FIC_RESU_FIABILITE, "r")
+    tout = fic.readlines()
+    fic.close
+    for ligne in tout:
+      liste_reel.append(float(ligne[:-1]))
+  else :
+    liste_reel = [0.]
+#
+  self.DeclareOut("nomres", self.sd)
+  nomres = DEFI_LIST_REEL( VALE = liste_reel , INFO = 1 )
+#
+# 6.3. ==> Menage du répertoire créé pour le calcul fiabiliste
+#
+  liste = os.listdir(Rep_Calc_LOGICIEL_global)
+##  print liste
+#
+  for nomfic in liste :
+    fic_total = os.path.join(Rep_Calc_LOGICIEL_global, nomfic)
+#
+    if os.path.isdir(fic_total) :
+      liste_bis = os.listdir(fic_total)
+      for nomfic_bis in liste_bis :
+        fic_total_bis = os.path.join(fic_total, nomfic_bis)
+        if os.path.islink(fic_total_bis) :
+          os.unlink (fic_total_bis)
+        else :
+          os.chmod  (fic_total_bis, 0755)
+          os.remove (fic_total_bis)
+      os.rmdir (fic_total)
+#
+    elif os.path.isfile(fic_total) :
+      os.chmod  (fic_total, 0755)
+      os.remove (fic_total)
+#
+  os.rmdir (Rep_Calc_LOGICIEL_global)
+#
+  return
+#
+##########################  Fin de la fonction##################################
+#
+##########################   Auto-test##################################
+#
+if __name__ == "__main__" :
+#
+  import os
+  import sys
+  import tempfile
+#
+  Rep_Calc_LOGICIEL_global = tempfile.mktemp()
+  os.mkdir(Rep_Calc_LOGICIEL_global)
+#
+  classe = None
+  INFO = 2
+  LOGICIEL = "MEFISTO"
+  VERSION = "V3_2"
+  UNITE_ESCL = 38
+  MESS_ASTER = "DERNIER"
+  SEUIL = 1789.
+  SEUIL_TYPE = "MAXIMUM"
+  VARIABLE = []
+  args = {}
+#
+  lr8 = macr_fiabilite_ops(classe, INFO,
+                       LOGICIEL, VERSION,
+                       UNITE_ESCL, MESS_ASTER,
+                       SEUIL, SEUIL_TYPE,
+                       VARIABLE,
+                       **args )
+###  print "lr8 = ", lr8
+  Liste = os.listdir(Rep_Calc_LOGICIEL_global)
+#
+  for nomfic in Liste :
+    fic_total = os.path.join(Rep_Calc_LOGICIEL_global, nomfic)
+    os.chmod  (fic_total, 0755)
+    os.remove (fic_total)
+  os.rmdir (Rep_Calc_LOGICIEL_global)
+#
+  sys.exit("blabla")

diff --git a/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py
new file mode 100644 (file)
index 0000000..ec6285f
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py
@@ -0,0 +1,958 @@
+#@ MODIF macr_lign_coupe_ops Macro  DATE 16/11/2009   AUTEUR DURAND C.DURAND 
+# -*- coding: iso-8859-1 -*-
+#            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.
+# ======================================================================
+
+########################################################################
+# script PYTHON de creation du résultat local
+
+def crea_resu_local(self,dime,NOM_CHAM,m,resin,mail,nomgrma):
+
+  from Utilitai.Utmess     import  UTMESS
+  from math import pi,sqrt,atan2,asin
+  import os,string,types
+  import aster
+  from Accas import _F
+  MODI_REPERE = self.get_cmd('MODI_REPERE')
+
+  epsi=0.00000001
+
+  if NOM_CHAM == 'DEPL':
+       if dime == 2:
+          LCMP=['DX','DY']
+          TYPE_CHAM='VECT_2D'
+       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'):
+       if dime == 2:
+          LCMP=['SIXX','SIYY','SIZZ','SIXY']
+          TYPE_CHAM='TENS_2D'
+       elif dime ==3 :
+          LCMP=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ']
+          TYPE_CHAM='TENS_3D'
+
+
+  if m['TYPE']=='SEGMENT' and m['REPERE'] != 'CYLINDRIQUE' :
+
+    if m['REPERE'] == 'LOCAL':
+      # --- determination des angles nautiques
+      cx1=m['COOR_EXTR'][0]-m['COOR_ORIG'][0]
+      cx2=m['COOR_EXTR'][1]-m['COOR_ORIG'][1]
+      cx3=0.
+      if dime == 3:
+        cx3=m['COOR_EXTR'][2]-m['COOR_ORIG'][2]
+      nvx=sqrt(cx1**2+cx2**2+cx3**2)
+      if abs(nvx) < epsi:
+         UTMESS('F','POST0_1')
+      cx1=cx1/nvx
+      cx2=cx2/nvx
+      cx3=cx3/nvx
+      cy1=m['VECT_Y'][0]
+      cy2=m['VECT_Y'][1]
+      cy3=0.
+      if dime == 3:
+        cy3=m['VECT_Y'][2]
+      nvy=sqrt(cy1**2+cy2**2+cy3**2)
+      if abs(nvy) < epsi:
+         UTMESS('F','POST0_2')
+      cy1=cy1/nvy
+      cy2=cy2/nvy
+      cy3=cy3/nvy
+      if ((abs(cx1-cy1)<epsi and abs(cx2-cy2)<epsi and  abs(cx3-cy3)<epsi) or \
+         (abs(cx1+cy1)<epsi and abs(cx2+cy2)<epsi and  abs(cx3+cy3)<epsi)):
+         UTMESS('F','POST0_3')
+      if abs(cx1*cy1+cx2*cy2+cx3*cy3) > epsi  :
+        cz1=cx2*cy3-cx3*cy2
+        cz2=cx3*cy1-cx1*cy3
+        cz3=cx1*cy2-cx2*cy1
+        nvz=sqrt(cz1**2+cz2**2+cz3**2)
+        cz1=cz1/nvz
+        cz2=cz2/nvz
+        cz3=cz3/nvz
+        cy1=cz2*cx3-cz3*cx2
+        cy2=cz3*cx1-cz1*cx3
+        cy3=cz1*cx2-cz2*cx1
+        nvy=sqrt(cy1**2+cy2**2+cy3**2)
+        cy1=cy1/nvy
+        cy2=cy2/nvy
+        cy3=cy3/nvy
+        UTMESS('A','POST0_4',valr=[cy1,cy2,cy3])
+      else:
+        cz1=cx2*cy3-cx3*cy2
+        cz2=cx3*cy1-cx1*cy3
+        cz3=cx1*cy2-cx2*cy1
+      beta=0.
+      gamma=0.
+      if dime ==2:
+        alpha = atan2(cx2,cx1)
+      else:
+        if cx1**2 + cx2**2 > epsi :
+          alpha=atan2(cx2,cx1)
+          beta=-asin(cx3)
+          gamma=atan2(cy3,cz3)
+        else:
+          alpha=atan2(-cy1,cy2)
+          beta=-asin(cx3)
+          gamma=0.
+      alpha=alpha*180/pi
+      beta=beta*180/pi
+      gamma=gamma*180/pi
+
+    elif m['REPERE'] == 'UTILISATEUR':
+      alpha=m['ANGL_NAUT'][0]
+      beta =m['ANGL_NAUT'][1]
+      gamma=m['ANGL_NAUT'][2]
+
+    motscles={}
+    motscles['MODI_CHAM']=[]
+    motscles['DEFI_REPERE']=[]
+    motscles['MODI_CHAM'].append(_F(NOM_CHAM=NOM_CHAM,NOM_CMP=LCMP,TYPE_CHAM=TYPE_CHAM),)
+    ANGL_NAUT=[]
+    ANGL_NAUT.append(alpha)
+    if dime ==3:
+       ANGL_NAUT.append(beta)
+       ANGL_NAUT.append(gamma)
+    motscles['DEFI_REPERE'].append(_F(REPERE='UTILISATEUR',ANGL_NAUT=ANGL_NAUT),)
+    __remodr=MODI_REPERE(RESULTAT=resin,**motscles)
+
+
+  if m['TYPE']=='ARC':
+    if m['REPERE'] == 'CYLINDRIQUE' :
+      motscles={}
+      motscles['MODI_CHAM']=[]
+      motscles['DEFI_REPERE']=[]
+      motscles['MODI_CHAM'].append(_F(NOM_CHAM=NOM_CHAM,NOM_CMP=LCMP,TYPE_CHAM=TYPE_CHAM),)
+      ORIGINE=[]
+      ORIGINE.append(m['CENTRE'][0])
+      ORIGINE.append(m['CENTRE'][1])
+      if dime ==3:
+        ORIGINE.append(m['CENTRE'][2])
+        AXE_Z=[]
+        AXE_Z.append(m['DNOR'][0])
+        AXE_Z.append(m['DNOR'][1])
+        AXE_Z.append(m['DNOR'][2])
+        motscles['DEFI_REPERE'].append(_F(REPERE='CYLINDRIQUE',ORIGINE=ORIGINE,AXE_Z=AXE_Z),)
+      elif dime ==2:
+        motscles['DEFI_REPERE'].append(_F(REPERE='CYLINDRIQUE',ORIGINE=ORIGINE,),)
+      __remodr=MODI_REPERE(RESULTAT=resin,**motscles)
+    else :
+      UTMESS('F','POST0_5',valk=[m['TYPE'],m['REPERE']])
+
+
+
+  if m['TYPE'][:5]=='GROUP' or m['TYPE']=='SEGMENT':
+
+    if m['TYPE'][:5]=='GROUP' and m['REPERE'] == 'LOCAL':
+     # determination du repère local (v1,v2,v3)
+     # ---------------------------------------
+      noma=mail.nom
+      collgrma=aster.getcolljev(noma.ljust(8)+'.GROUPEMA')
+      collcnx =aster.getcolljev(noma.ljust(8)+'.CONNEX')
+      coord   =aster.getvectjev(noma.ljust(8)+'.COORDO    .VALE')
+      cnom    =aster.getvectjev(noma.ljust(8)+'.NOMNOE')
+
+      numa=collgrma[nomgrma.ljust(8)]
+      dictu={}
+#     initialisations
+      for ima in numa:
+        n1=collcnx[ima][0]
+        n2=collcnx[ima][1]
+        dictu[n1]=[]
+        dictu[n2]=[]
+#     determination du vecteur tangent (v1) + normalisation
+      for ima in numa:
+        vectu1=[]
+        vectu2=[]
+        n1=collcnx[ima][0]
+        n2=collcnx[ima][1]
+        ux=coord[3*(n2-1)]-coord[3*(n1-1)]
+        uy=coord[3*(n2-1)+1]-coord[3*(n1-1)+1]
+        vectu1.append(ux)
+        vectu1.append(uy)
+        vectu2.append(ux)
+        vectu2.append(uy)
+        if dime ==3 :
+          uz=coord[3*(n2-1)+2]-coord[3*(n1-1)+2]
+          vectu1.append(uz)
+          vectu2.append(uz)
+        dictu[n1].append(vectu1)
+        dictu[n2].append(vectu2)
+      for i in dictu:
+        if len(dictu[i])==2:
+          dictu[i][0][0]=dictu[i][0][0]+dictu[i][1][0]
+          dictu[i][0][1]=dictu[i][0][1]+dictu[i][1][1]
+          if dime==3:dictu[i][0][2]=dictu[i][0][2]+dictu[i][1][2]
+          del dictu[i][1]
+      for i in dictu:
+        if dime==2:
+          norm=sqrt(dictu[i][0][0]**2+dictu[i][0][1]**2)
+          dictu[i][0][0]=dictu[i][0][0]/norm
+          dictu[i][0][1]=dictu[i][0][1]/norm
+        elif dime==3:
+          norm=sqrt(dictu[i][0][0]**2+dictu[i][0][1]**2+dictu[i][0][2]**2)
+          dictu[i][0][0]=dictu[i][0][0]/norm
+          dictu[i][0][1]=dictu[i][0][1]/norm
+          dictu[i][0][2]=dictu[i][0][2]/norm
+#     determination du vecteur normal (v2):
+#     on projete VECT_Y sur le plan orthogonal au vecteur v1.
+#     (ce vecteur normal est obtenu par 2 produits vectoriels successifs en 3D)
+      if dime==3:
+        norm=sqrt(m['VECT_Y'][0]**2+m['VECT_Y'][1]**2+m['VECT_Y'][2]**2)
+        tmpy=[m['VECT_Y'][0]/norm,m['VECT_Y'][1]/norm,m['VECT_Y'][2]/norm]
+      j=0
+      __resu=[None]*(len(dictu)+1)
+      __resu[0]=resin
+      for i in dictu:
+          j=j+1
+          vecty=[]
+          if dime==2:
+             vecty.append(-dictu[i][0][1])
+             vecty.append(dictu[i][0][0])
+             dictu[i].append(vecty)
+          elif dime==3:
+             # v3= v1 vectoriel vect_y
+             vectz=[]
+             vectz.append(dictu[i][0][1]*tmpy[2]-dictu[i][0][2]*tmpy[1])
+             vectz.append(dictu[i][0][2]*tmpy[0]-dictu[i][0][0]*tmpy[2])
+             vectz.append(dictu[i][0][0]*tmpy[1]-dictu[i][0][1]*tmpy[0])
+             normz=sqrt(vectz[0]**2+vectz[1]**2+vectz[2]**2)
+             vectz[0]=vectz[0]/normz
+             vectz[1]=vectz[1]/normz
+             vectz[2]=vectz[2]/normz
+             vecty.append(vectz[1]*dictu[i][0][2]-vectz[2]*dictu[i][0][1])
+             vecty.append(vectz[2]*dictu[i][0][0]-vectz[0]*dictu[i][0][2])
+             vecty.append(vectz[0]*dictu[i][0][1]-vectz[1]*dictu[i][0][0])
+             normy=sqrt(vecty[0]**2+vecty[1]**2+vecty[2]**2)
+             vecty[0]=vecty[0]/normy
+             vecty[1]=vecty[1]/normy
+             vecty[2]=vecty[2]/normy
+             dictu[i].append(vecty)
+             dictu[i].append(vectz)
+          cx1=dictu[i][0][0]
+          cx2=dictu[i][0][1]
+          cy1=dictu[i][1][0]
+          cy2=dictu[i][1][1]
+          if dime==3:
+             cx3=dictu[i][0][2]
+             cy3=dictu[i][1][2]
+             cz1=dictu[i][2][0]
+             cz2=dictu[i][2][1]
+             cz3=dictu[i][2][2]
+
+     # determination des angles nautiques (alpha,beta,gamma)
+     # ----------------------------------------------------
+          beta=0.
+          gamma=0.
+          if dime ==2:
+            alpha = atan2(cx2,cx1)
+          else:
+            if cx1**2 + cx2**2 > epsi :
+              alpha=atan2(cx2,cx1)
+              beta=-asin(cx3)
+              gamma=atan2(cy3,cz3)
+            else:
+              alpha=atan2(-cy1,cy2)
+              beta=-asin(cx3)
+              gamma=0.
+          alpha=alpha*180/pi
+          beta=beta*180/pi
+          gamma=gamma*180/pi
+          motscles={}
+          motscles['MODI_CHAM']=[]
+          motscles['DEFI_REPERE']=[]
+          noeu=dictu.keys()
+          motscles['MODI_CHAM'].append(_F(NOM_CHAM=NOM_CHAM,NOM_CMP=LCMP,TYPE_CHAM=TYPE_CHAM,NOEUD=cnom[noeu[j-1]-1]),)
+          ANGL_NAUT=[]
+          ANGL_NAUT.append(alpha)
+          if dime ==3:
+            ANGL_NAUT.append(beta)
+            ANGL_NAUT.append(gamma)
+          motscles['DEFI_REPERE'].append(_F(REPERE='UTILISATEUR',ANGL_NAUT=ANGL_NAUT),)
+          __resu[j]=MODI_REPERE(RESULTAT=__resu[j-1],**motscles)
+      __remodr=__resu[j]
+
+
+    motscles={}
+    motscles['MODI_CHAM']=[]
+    motscles['DEFI_REPERE']=[]
+    motscles['MODI_CHAM'].append(_F(NOM_CHAM=NOM_CHAM,NOM_CMP=LCMP,TYPE_CHAM=TYPE_CHAM),)
+    if m['REPERE'] == 'CYLINDRIQUE' :
+      if dime ==3:
+        motscles['DEFI_REPERE'].append(_F(REPERE='CYLINDRIQUE',ORIGINE=m['ORIGINE'],AXE_Z=m['AXE_Z']),)
+      elif dime ==2:
+        motscles['DEFI_REPERE'].append(_F(REPERE='CYLINDRIQUE',ORIGINE=m['ORIGINE'],),)
+      __remodr=MODI_REPERE(RESULTAT=resin,**motscles)
+    elif m['REPERE'] == 'UTILISATEUR':
+      alpha=m['ANGL_NAUT'][0]
+      beta =m['ANGL_NAUT'][1]
+      gamma=m['ANGL_NAUT'][2]
+      ANGL_NAUT=[]
+      ANGL_NAUT.append(alpha)
+      if dime ==3:
+        ANGL_NAUT.append(beta)
+        ANGL_NAUT.append(gamma)
+      motscles['DEFI_REPERE'].append(_F(REPERE='UTILISATEUR',ANGL_NAUT=ANGL_NAUT),)
+      __remodr=MODI_REPERE(RESULTAT=resin,**motscles)
+
+
+  return __remodr
+
+########################################################################
+# script PYTHON de creation des noeuds d'une ligne de coupe 'arc'
+
+def crea_noeu_lig_coup(dimension,pt1,pt2,anglj,dnor):
+  from Utilitai.Utmess     import  UTMESS
+  from math import pi,sin,cos,sqrt
+
+  a=pt1[0]-pt2[0]
+  b=pt1[1]-pt2[1]
+  eps=0.00000001
+  anglr=anglj*pi/180.
+  if dimension==2:
+    r=sqrt(a**2+b**2)
+    if abs(r)<eps:
+      UTMESS('F','POST0_6')
+    x=pt2[0]+a*cos(anglr)-b*sin(anglr)
+    y=pt2[1]+b*cos(anglr)+a*sin(anglr)
+    return x,y
+  elif dimension==3:
+    c=pt1[2]-pt2[2]
+    r=sqrt(a**2+b**2+c**2)
+    if abs(r)<eps:
+      UTMESS('F','POST0_6')
+    d1=dnor[0]
+    d2=dnor[1]
+    d3=dnor[2]
+    d=sqrt(d1**2+d2**2+d3**2)
+    if abs(r)<eps:
+      UTMESS('F','POST0_7')
+    x=pt2[0]+a*cos(anglr)+sin(anglr)*(c*d2-b*d3)/d
+    y=pt2[1]+b*cos(anglr)+sin(anglr)*(a*d3-c*d1)/d
+    z=pt2[2]+c*cos(anglr)+sin(anglr)*(b*d1-a*d2)/d
+    return x,y,z
+########################################################################
+# determination de la distance min entre 2 points consécutifs de la ligne de coupe
+
+def dist_min_deux_points(mail):
+  from math import sqrt
+  import aster
+  nno=aster.getvectjev(mail.nom.ljust(8)+'.DIME')[0]
+  l_coor1=[]
+  l_coor2=[]
+  for i in range(nno-1):
+    l_coor1=aster.getvectjev(mail.nom.ljust(8)+'.COORDO    .VALE',3*(i),3)
+    l_coor2=aster.getvectjev(mail.nom.ljust(8)+'.COORDO    .VALE',3*(i+1),3)
+    d=sqrt( (l_coor1[0]-l_coor2[0])**2+(l_coor1[1]-l_coor2[1])**2+(l_coor1[2]-l_coor2[2])**2)
+    if i == 0 : dist=d
+    else      : dist=min(d,dist)
+  return dist
+
+########################################################################
+# verification que les points de la ligne de coupe sont dans la matiere
+def crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou):
+
+  import aster
+  from Accas import _F
+  from Utilitai.Utmess import  UTMESS
+  import os
+  POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+  DEFI_GROUP    = self.get_cmd('DEFI_GROUP')
+
+  motscles={}
+  if m['NOM_CMP']!=None:
+     motscles['NOM_CMP']=m['NOM_CMP']
+  else:
+     motscles['TOUT_CMP']='OUI'
+  motscles['OPERATION']='EXTRACTION'
+
+  __tab=POST_RELEVE_T(ACTION=_F(  INTITULE=newgrp,
+                           RESULTAT  = __remodr,
+                           NOM_CHAM=NOM_CHAM,
+                           GROUP_NO  = groupe,**motscles ))
+
+  # dictb=table initiale (contenant éventuellement des noeuds hors matière)
+  dictb=__tab.EXTR_TABLE()
+  # listenoe_b=liste ordonnee des noeuds de la ligne de coupe (avec doublons)
+  listenoe_b = dictb.NOEUD.values()
+  # lno_b2=liste des noeuds de la ligne de coupe après élimination des doublons
+  # (attention, on perd l'ordre des noeuds)
+  lno_b2 = set(listenoe_b)
+
+  # dictc=table (extraite de dictb) contenant uniquement des noeuds dans la matière
+  if m['NOM_CMP']!=None:
+     dictc=getattr(dictb,m['NOM_CMP'][0]).NON_VIDE()
+     lno_c2 = set(dictc.NOEUD.values())
+  else:# TOUT_CMP='OUI'
+     # on garde uniquement les composantes pour conserver les noeuds où il y a des valeurs
+     a_suppr = set(['INTITULE', 'RESU', 'NOM_CHAM', 'NUME_ORDRE', 'INST', 'ABSC_CURV', 'COOR_X', 'COOR_Y', 'COOR_Z'])
+     new_para = set(dictb.para)
+     new_para.difference_update(a_suppr)
+
+     lno_c2 = set()
+     for comp in new_para.difference(['NOEUD']):
+        dictc = getattr(dictb, comp).NON_VIDE()
+        lno_c2.update(dictc.NOEUD.values())
+
+  # on réordonne la liste des noeuds de lno_c2 (selon leur position dans listenoe_b) => l_matiere
+  # l_horsmat=liste des noeuds hors matière
+  l_matiere = [j for j in listenoe_b if j in lno_c2]
+  nderm=l_matiere.index(l_matiere[len(l_matiere)-1])
+  l_horsmat = [j for j in listenoe_b if j not in lno_c2]
+
+  # si on est en présence de noeuds hors matière,
+  # on emet une alarme pour informer l'utilisateur
+  if len(l_horsmat) > 0:
+
+       nderh=l_horsmat.index(l_horsmat[len(l_horsmat)-1])
+       cnom = list(__macou.NOMNOE.get())
+       l_coor = __macou.COORDO.VALE.get()
+       indent=os.linesep+' '*12
+       l_surlig = []
+       l_horslig = []
+       for j in l_matiere[:nderm+1]:
+          nuno=cnom.index(j.ljust(8))
+          text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+          l_surlig.append(text_coordo)
+       for j in l_horsmat[:nderh+1]:
+          nuno=cnom.index(j.ljust(8))
+          text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+          l_horslig.append(text_coordo)
+       UTMESS('A','POST0_8',valk=[indent.join(l_surlig),indent.join(l_horslig)])
+
+  __macou=DEFI_GROUP( reuse =__macou , MAILLAGE=__macou ,
+                   CREA_GROUP_NO=_F(NOM=newgrp,NOEUD=l_matiere[:nderm+1]),)
+
+  return
+########################################################################
+# script PYTHON de creation d un maillage de ligne de coupe
+
+def crea_mail_lig_coup(dimension,lignes,groups,arcs):
+
+  import os,sys,copy
+  from Utilitai.Utmess     import  UTMESS
+
+# construction du maillage au format Aster des segments de lignes de coupe
+
+  nblig=len(lignes)
+  nbngr=len(groups)
+  nbarc=len(arcs)
+
+  resu='TITRE\n'
+  titre='Maillage ligne de coupe'+'\n'
+  resu=resu+'FINSF\n'
+  resu=resu+'COOR_'+str(dimension)+'D\n'
+  epsi=0.00000001
+
+# creation des noeuds
+  nbno=0
+  for i in range(nblig):
+    pt1           = lignes[i][0]
+    pt2           = lignes[i][1]
+    nbp_lig_coupe = lignes[i][2]
+    for j in range(nbp_lig_coupe):
+      if dimension==2:
+        x=pt1[0]+j*(pt2[0]-pt1[0])/(nbp_lig_coupe-1)
+        y=pt1[1]+j*(pt2[1]-pt1[1])/(nbp_lig_coupe-1)
+        nbno=nbno+1
+        noeud='  N'+str(nbno)+'   '+str(x)+'    '+str(y)+'\n'
+        resu=resu+noeud
+      elif dimension==3:
+        x=pt1[0]+j*(pt2[0]-pt1[0])/(nbp_lig_coupe-1)
+        y=pt1[1]+j*(pt2[1]-pt1[1])/(nbp_lig_coupe-1)
+        z=pt1[2]+j*(pt2[2]-pt1[2])/(nbp_lig_coupe-1)
+        nbno=nbno+1
+        noeud='  N'+str(nbno)+'   '+str(x)+'   '+str(y)+'   '+str(z)+'\n'
+        resu=resu+noeud
+  for i in range(nbngr):
+    for pt in groups[i][1:]:
+      if dimension==2:
+        nbno=nbno+1
+        noeud='  N'+str(nbno)+' '+str(pt[0])+'    '+str(pt[1])+'\n'
+        resu=resu+noeud
+      elif dimension==3:
+        nbno=nbno+1
+        noeud='  N'+str(nbno)+' '+str(pt[0])+'    '+str(pt[1])+'    '+str(pt[2])+'\n'
+        resu=resu+noeud
+  angles=[None]*nbarc
+  for i in range(nbarc):
+    pt1           = arcs[i][0]
+    pt2           = arcs[i][1]
+    nbp_lig_coupe = arcs[i][2]
+    angle         = arcs[i][3]
+    if abs(angle-360.)<epsi: nbpt=nbp_lig_coupe+1
+    else                   : nbpt=nbp_lig_coupe
+    if dimension==3:dnor=arcs[i][4]
+    angles[i] = []
+    for j in range(nbp_lig_coupe):
+      anglj       = j*angle/(nbpt-1)
+      angles[i].append(anglj)
+      if dimension==2:
+        nbno=nbno+1
+        x,y=crea_noeu_lig_coup(dimension,pt1,pt2,anglj,dnor=[])
+        noeud='  N'+str(nbno)+'   '+str(x)+'    '+str(y)+'\n'
+        resu=resu+noeud
+      elif dimension==3:
+        nbno=nbno+1
+        x,y,z=crea_noeu_lig_coup(dimension,pt1,pt2,anglj,dnor)
+        noeud='  N'+str(nbno)+'   '+str(x)+'   '+str(y)+'   '+str(z)+'\n'
+        resu=resu+noeud
+  resu=resu+'FINSF\n'
+
+# creation des mailles
+  nbma=0
+  for i in range(nblig):
+    nbp_lig_coupe = lignes[i][2]
+    resu=resu+'SEG2\n'
+    for j in range(nbp_lig_coupe-1):
+        nbma=nbma+1
+        maille='  M'+str(nbma)+' N'+str(nbma+i)+' N'+str(nbma+1+i)+'\n'
+        resu=resu+maille
+    resu=resu+'FINSF\n'
+  for i in range(nbngr):
+    resu=resu+'SEG2\n'
+    for pt in groups[i][1:-1]:
+        nbma=nbma+1
+        maille='  M'+str(nbma)+' N'+str(nbma+nblig+i)+' N'+str(nbma+nblig+1+i)+'\n'
+        resu=resu+maille
+    resu=resu+'FINSF\n'
+  nprec=0
+
+  for i in range(nbarc):
+    nbp_lig_coupe = arcs[i][2]
+    angle         = arcs[i][3]
+    resu=resu+'SEG2\n'
+    nbmai=nbma+nblig+nbngr+nprec+i+1
+    for j in range(nbp_lig_coupe-1):
+        nbma=nbma+1
+        maille='  M'+str(nbma)+' N'+str(nbma+nblig+nbngr+nprec+i)+' N'+str(nbma+nblig+nbngr+nprec+1+i)+'\n'
+        resu=resu+maille
+    if abs(angle-360.)<epsi:
+        nbma=nbma+1
+        maille='  M'+str(nbma)+' N'+str(nbma+nblig+nbngr+nprec+i)+' N'+str(nbmai)+'\n'
+        nprec=nprec-1
+        resu=resu+maille
+    resu=resu+'FINSF\n'
+
+# creation des groupes de mailles (1 par ligne de coupe)
+  nbma=0
+  for i in range(nblig):
+    resu=resu+'GROUP_MA\n'
+    resu=resu+'  LICOU'+str(i+1)
+    nbp_lig_coupe = lignes[i][2]
+    for j in range(nbp_lig_coupe-1):
+        nbma=nbma+1
+        resu=resu+'  M'+str(nbma)+'\n'
+    resu=resu+'\n'
+    resu=resu+'FINSF\n'
+  for i in range(nbngr):
+    resu=resu+'GROUP_MA\n'
+    resu=resu+groups[i][0]
+    nbp_lig_coupe = len(groups[i])-1
+    for j in range(nbp_lig_coupe-1):
+        nbma=nbma+1
+        resu=resu+'  M'+str(nbma)+'\n'
+    resu=resu+'\n'
+    resu=resu+'FINSF\n'
+  arcgma=[]
+  for i in range(nbarc):
+    resu=resu+'GROUP_MA\n'
+    k=nblig+i
+    resu=resu+'  LICOU'+str(k+1)
+    arcgma.append('LICOU'+str(k+1))
+    nbp_lig_coupe = arcs[i][2]
+    angle         = arcs[i][3]
+    if abs(angle-360.)<epsi: nbpt=nbp_lig_coupe+1
+    else                   : nbpt=nbp_lig_coupe
+    for j in range(nbpt-1):
+        nbma=nbma+1
+        resu=resu+'  M'+str(nbma)+'\n'
+    resu=resu+'\n'
+    resu=resu+'FINSF\n'
+  resu=resu+'FIN\n'
+
+  return resu,arcgma,angles,nbno
+
+
+########################################################################
+def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE,
+              NOM_CHAM,MODELE,**args):
+
+  """
+     Ecriture de la macro MACR_LIGN_COUPE
+  """
+  import os,string,types
+  from Accas import _F
+  from Noyau.N_utils import AsType
+  import aster,math
+  from Utilitai.UniteAster import UniteAster
+  from Utilitai.Utmess import  UTMESS, MasquerAlarme, RetablirAlarme
+  ier=0
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  LIRE_MAILLAGE  =self.get_cmd('LIRE_MAILLAGE')
+  DEFI_GROUP     =self.get_cmd('DEFI_GROUP')
+  AFFE_MODELE    =self.get_cmd('AFFE_MODELE')
+  PROJ_CHAMP     =self.get_cmd('PROJ_CHAMP')
+  POST_RELEVE_T  =self.get_cmd('POST_RELEVE_T')
+  CREA_TABLE     =self.get_cmd('CREA_TABLE')
+  CREA_RESU      =self.get_cmd('CREA_RESU')
+  CREA_MAILLAGE  =self.get_cmd('CREA_MAILLAGE')
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  #
+  MasquerAlarme('CALCULEL2_63')
+  MasquerAlarme('CALCULEL2_64')
+  MasquerAlarme('MODELISA5_53')
+
+  mcORDR={}
+
+  if RESULTAT != None:
+    if args['NUME_ORDRE'] != None :
+      mcORDR['NUME_ORDRE']=args['NUME_ORDRE']
+    elif args['LIST_ORDRE']  != None:
+      mcORDR['LIST_ORDRE']=args['LIST_ORDRE']
+    elif args['INST']  != None:
+      mcORDR['INST']=args['INST']
+    elif args['INST']  != None:
+      mcORDR['INST']=args['INST']
+    elif args['LIST_INST']  != None:
+      mcORDR['LIST_INST']=args['LIST_INST']
+    else :
+      mcORDR['TOUT_ORDRE']='OUI'
+
+    nomresu=RESULTAT.nom
+    iret,ibid,n_modele = aster.dismoi('F','MODELE',nomresu,'RESULTAT')
+    n_modele=n_modele.strip()
+    if n_modele=='' :
+      if MODELE==None:
+        UTMESS('F','POST0_9',valk=nomresu)
+      else : n_modele=MODELE.nom
+
+  elif CHAM_GD != None:
+    mcORDR['TOUT_ORDRE']='OUI'
+    if MODELE==None:
+      UTMESS('F','POST0_10')
+    else : n_modele=MODELE.nom
+    # récupération de la grandeur du champ
+    n_cham=CHAM_GD.nom
+    catagd=aster.getvectjev("&CATA.GD.NOMGD")
+    desc=aster.getvectjev(string.ljust(n_cham,19)+'.DESC')
+    if desc!= None:
+      nomgd=catagd[desc[0]-1]
+    else:
+      celd=aster.getvectjev(string.ljust(n_cham,19)+'.CELD')
+      nomgd=catagd[celd[0]-1]
+    # détermination du type de résultat à créer
+    if   nomgd[:6] == 'TEMP_R' : TYPE_RESU='EVOL_THER'
+    elif nomgd[:6] == 'DEPL_R' : TYPE_RESU='EVOL_ELAS'
+    elif nomgd[:6] == 'EPSI_R' : TYPE_RESU='EVOL_ELAS'
+    elif nomgd[:6] == 'SIEF_R' :
+       if   NOM_CHAM[:4]=='SIGM':TYPE_RESU='EVOL_ELAS'
+       elif NOM_CHAM[:4]=='SIEF':TYPE_RESU='EVOL_NOLI'
+    # création d'un concept résultat à partir du champ CHAM_GD
+    __resuch=CREA_RESU(OPERATION='AFFE',
+                       NOM_CHAM=NOM_CHAM, TYPE_RESU=TYPE_RESU,
+                       AFFE=_F(CHAM_GD=CHAM_GD,INST=0.),)
+    RESULTAT=__resuch
+  l_mailla=aster.getvectjev(n_modele.ljust(8)+'.MODELE    .LGRF')
+  n_mailla=string.strip(l_mailla[0])
+  dime=aster.getvectjev(n_mailla.ljust(8)+'.DIME')[5]
+  collgrma=aster.getcolljev(n_mailla.ljust(8)+'.GROUPEMA')
+  typma=aster.getvectjev(n_mailla.ljust(8)+'.TYPMAIL')
+  connex=aster.getcolljev(n_mailla.ljust(8)+'.CONNEX')
+  ltyma =aster.getvectjev("&CATA.TM.NOMTM")
+
+  lignes=[]
+  groups=[]
+  arcs=[]
+  minidim=dime
+
+  for m in LIGN_COUPE :
+      if m['TYPE'] =='SEGMENT' :
+         lignes.append((m['COOR_ORIG'],m['COOR_EXTR'],m['NB_POINTS']))
+         minidim=min(minidim,len(m['COOR_ORIG']),len(m['COOR_EXTR']))
+         if minidim!=dime:
+           UTMESS('F','POST0_11')
+      elif m['TYPE'] =='ARC' :
+         minidim=min(minidim,len(m['COOR_ORIG']),len(m['CENTRE']))
+         if minidim!=dime:
+           UTMESS('F','POST0_11')
+         if dime==2:
+           arcs.append((m['COOR_ORIG'],m['CENTRE'],m['NB_POINTS'],m['ANGLE'],))
+         elif dime==3:
+           if str(m['DNOR'])=='None':
+              UTMESS('F','POST0_12')
+           arcs.append((m['COOR_ORIG'],m['CENTRE'],m['NB_POINTS'],m['ANGLE'],m['DNOR']))
+      elif m['TYPE']=='GROUP_NO':
+        ngrno=m['GROUP_NO'].ljust(8).upper()
+        collgrno=aster.getcolljev(n_mailla.ljust(8)+'.GROUPENO')
+        if ngrno not in collgrno.keys() :
+          UTMESS('F','POST0_13',valk=[ngrno,n_mailla])
+        grpn=collgrno[ngrno]
+        l_coor_group=[ngrno,]
+        for node in grpn:
+          l_coor_group.append(aster.getvectjev(n_mailla.ljust(8)+'.COORDO    .VALE',3*(node-1),3))
+        groups.append(l_coor_group)
+      elif m['TYPE']=='GROUP_MA':
+        ngrma=m['GROUP_MA'].ljust(8).upper()
+        if ngrma not in collgrma.keys() :
+          UTMESS('F','POST0_14',valk=[ngrma,n_mailla])
+        grpm=collgrma[ngrma]
+        for ma in grpm:
+          if ltyma[typma[ma-1]-1][:3] != 'SEG' :
+             nomma=aster.getvectjev(n_mailla.ljust(8)+'.NOMMAI')
+             UTMESS('F','POST0_15',valk=[ngrma,nomma[ma-1]])
+        __mailla=CREA_MAILLAGE(MAILLAGE= m['MAILLAGE'],)
+        __mailla=DEFI_GROUP( reuse=__mailla,MAILLAGE= __mailla,
+                            CREA_GROUP_NO=_F(OPTION='NOEUD_ORDO',NOM=str(m['GROUP_MA']),GROUP_MA=m['GROUP_MA']),)
+        collgrno=aster.getcolljev(__mailla.nom.ljust(8)+'.GROUPENO')
+        grpn=collgrno[str(m['GROUP_MA']).ljust(8)]
+        l_coor_group=[ngrma,]
+        for node in grpn:
+          l_coor_group.append(aster.getvectjev(n_mailla.ljust(8)+'.COORDO    .VALE',3*(node-1),3))
+        groups.append(l_coor_group)
+
+
+  if arcs!=[] and (lignes!=[] or groups!=[]) :
+    UTMESS('F','POST0_16')
+
+  # Création du maillage des NB_POINTS segments entre COOR_ORIG et COOR_EXTR
+  # ainsi que des segments reliant les noeuds issus des group_no demandés
+  # par appel au script python crea_mail_lig_coup
+  # le maillage est ensuite recopié dans l unité logique UNITE_MAILLAGE
+
+  resu_mail,arcgma,angles,nbno=crea_mail_lig_coup(dime,lignes,groups,arcs)
+  UL = UniteAster()
+  nomFichierSortie = UL.Nom(UNITE_MAILLAGE)
+  fproc=open(nomFichierSortie,'w')
+  fproc.write(resu_mail)
+  fproc.close()
+  UL.EtatInit(UNITE_MAILLAGE)
+
+  # Lecture du maillage de seg2 contenant toutes les lignes de coupe
+  __macou=LIRE_MAILLAGE(UNITE=UNITE_MAILLAGE,);
+
+  # distance min entre 2 points de la ligne de coupe (utile pour PROJ_CHAMP)
+  dmin=dist_min_deux_points(__macou)
+
+  motscles={}
+  iocc=1
+  motscles['CREA_GROUP_NO']=[]
+  for m in LIGN_COUPE :
+      if m['TYPE'] in ('GROUP_NO','GROUP_MA') :
+        motscles['CREA_GROUP_NO'].append(_F(GROUP_MA=m[m['TYPE']].ljust(8).upper(),) )
+      else :
+        motscles['CREA_GROUP_NO'].append(_F(GROUP_MA='LICOU'+str(iocc),) )
+        iocc=iocc+1
+
+  __macou=DEFI_GROUP( reuse =__macou , MAILLAGE=__macou , **motscles );
+
+  if AsType(RESULTAT).__name__ in ('evol_elas','evol_noli') :
+    __mocou=AFFE_MODELE(MAILLAGE=__macou,
+                        AFFE=_F(TOUT='OUI',
+                                PHENOMENE='MECANIQUE',
+                                MODELISATION='BARRE',),);
+  elif AsType(RESULTAT).__name__ in ('evol_ther',) :
+    __mocou=AFFE_MODELE(MAILLAGE=__macou,
+                        AFFE=_F(TOUT='OUI',
+                                PHENOMENE='THERMIQUE',
+                                MODELISATION='PLAN',),);
+
+  motscles={}
+  motscles['VIS_A_VIS']=[]
+  motscles[mcORDR.keys()[0]]=mcORDR.values()[0]
+  if args['VIS_A_VIS']!=None:
+    for v in args['VIS_A_VIS']:
+      if v['GROUP_MA_1']!=None:
+         motscles['VIS_A_VIS'].append(_F(GROUP_MA_1 = v['GROUP_MA_1'],TOUT_2='OUI'),)
+      elif v['MAILLE_1']!=None:
+         motscles['VIS_A_VIS'].append(_F(MAILLE_1 = v['MAILLE_1'],TOUT_2='OUI'),)
+
+  if n_modele in self.get_global_contexte().keys() : MODELE_1=self.get_global_contexte()[n_modele]
+  else                                             : MODELE_1=self.jdc.current_context[n_modele]
+
+
+  if NOM_CHAM[5:9]=='ELGA' : UTMESS('F','POST0_18',valk=[NOM_CHAM,])
+
+  __recou=PROJ_CHAMP(METHODE='ELEM',
+                     RESULTAT=RESULTAT,
+                     MODELE_1=MODELE_1,
+                     DISTANCE_MAX=m['DISTANCE_MAX'],
+                     MODELE_2=__mocou,
+                     TYPE_CHAM='NOEU',
+                     NOM_CHAM=NOM_CHAM, **motscles);
+
+  __remodr=__recou
+  icham=0
+  ioc2=0
+  mcACTION=[]
+  angtab=[]
+
+  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
+
+   for m in LIGN_COUPE :
+
+     motscles={}
+     motscles['OPERATION']=m['OPERATION']
+     if m['NOM_CMP']!=None:
+       motscles['NOM_CMP']=m['NOM_CMP']
+       if m['TRAC_NOR']!=None:
+          motscles['TRAC_NOR']=m['TRAC_NOR']
+       elif m['TRAC_DIR']!=None:
+          motscles['TRAC_DIR']=m['TRAC_DIR']
+          motscles['DIRECTION']=m['DIRECTION']
+     elif m['INVARIANT']!=None:
+       motscles['INVARIANT']=m['INVARIANT']
+     elif m['RESULTANTE']!=None:
+       motscles['RESULTANTE']=m['RESULTANTE']
+     elif m['ELEM_PRINCIPAUX']!=None:
+       motscles['ELEM_PRINCIPAUX']=m['ELEM_PRINCIPAUX']
+     else:
+       motscles['TOUT_CMP']='OUI'
+
+     # on définit le groupe de noeud pour post_releve_t
+     if m['TYPE'] in ('GROUP_NO','GROUP_MA'):
+         groupe=m[m['TYPE']].ljust(8).upper()
+         nomgrma=groupe
+     else:
+         ioc2=ioc2+1
+         groupe='LICOU'+str(ioc2)
+         nomgrma=' '
+         newgrp='LICOF'+str(ioc2)
+         crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou)
+         groupe=newgrp
+
+     # on definit l'intitulé
+     if m['INTITULE'] !=None                    : intitl=m['INTITULE']
+     elif  m['TYPE'] in ('GROUP_NO','GROUP_MA') : intitl=groupe
+     else                                       : intitl='l.coupe'+str(ioc2)
+
+
+     # Expression des contraintes aux noeuds ou des déplacements dans le repere local
+     if m['REPERE'] != 'GLOBAL':
+
+        if  icham==1:
+
+          if m['REPERE']=='POLAIRE':
+            mcACTION.append( _F(INTITULE  = intitl,
+                            RESULTAT  = __remodr,
+                            REPERE    = m['REPERE'],
+                            GROUP_NO  = groupe,
+                            NOM_CHAM  = NOM_CHAM,**motscles ),)
+          else:
+            __remodr=crea_resu_local(self,dime,NOM_CHAM,m,__recou,__macou,nomgrma)
+            mcACTION.append( _F(INTITULE  = intitl,
+                            RESULTAT  = __remodr,
+                            GROUP_NO  = groupe,
+                            NOM_CHAM  = NOM_CHAM,**motscles ),)
+
+        else:
+          UTMESS('A','POST0_17',valk=[NOM_CHAM,m['REPERE']])
+          mcACTION.append( _F(INTITULE  = intitl,
+                            RESULTAT  = __recou,
+                            GROUP_NO  = groupe,
+                            NOM_CHAM  = NOM_CHAM,**motscles ),)
+
+     # Expression des contraintes aux noeuds ou des déplacements dans le repere global
+     else:
+
+          mcACTION.append( _F(INTITULE  = intitl,
+                            RESULTAT  = __recou,
+                            GROUP_NO  = groupe,
+                            NOM_CHAM  = NOM_CHAM,**motscles ),)
+
+
+  elif AsType(RESULTAT).__name__ in ('evol_ther',) :
+
+     for m in LIGN_COUPE :
+
+        motscles={}
+        motscles['OPERATION']=m['OPERATION']
+        if m['NOM_CMP']!=None:
+          motscles['NOM_CMP']=m['NOM_CMP']
+          if m['TRAC_NOR']!=None:
+             motscles['TRAC_NOR']=m['TRAC_NOR']
+          elif m['TRAC_DIR']!=None:
+             motscles['TRAC_DIR']=m['TRAC_DIR']
+             motscles['DIRECTION']=m['DIRECTION']
+        elif m['INVARIANT']!=None:
+          motscles['INVARIANT']=m['INVARIANT']
+        elif m['RESULTANTE']!=None:
+          motscles['RESULTANTE']=m['RESULTANTE']
+        elif m['ELEM_PRINCIPAUX']!=None:
+          motscles['ELEM_PRINCIPAUX']=m['ELEM_PRINCIPAUX']
+        else:
+          motscles['TOUT_CMP']='OUI'
+
+        if m['TYPE'] not in ('GROUP_NO','GROUP_MA') :
+          ioc2=ioc2+1
+          groupe='LICOU'+str(ioc2)
+          newgrp='LICOF'+str(ioc2)
+          crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou)
+          groupe=newgrp
+          if m['INTITULE'] !=None : intitl=m['INTITULE']
+          else                    : intitl='l.coupe'+str(ioc2)
+        else:
+          groupe=m[m['TYPE']].ljust(8).upper()
+          if m['INTITULE'] !=None : intitl=m['INTITULE']
+          else                    : intitl=groupe
+        mcACTION.append( _F(INTITULE  = intitl,
+                            RESULTAT  = __recou,
+                            GROUP_NO  = groupe,
+                            NOM_CHAM  = NOM_CHAM, **motscles ),)
+
+  __tabitm=POST_RELEVE_T(ACTION=mcACTION,);
+
+  # on repasse par les tables python pour supprimer les paramètres inutiles
+  # NOEUD (car il est propre au maillage de la ligne) et RESU
+
+  self.DeclareOut('nomres',self.sd)
+  dictab=__tabitm.EXTR_TABLE()
+
+### Ajout de la colonne theta
+  if len(arcgma)>0:
+    coltab=[]
+    val =  dictab['ABSC_CURV'].values()['ABSC_CURV']
+    nbi = len(val) / nbno
+    nba = len(angles)
+    tmp =[]
+    for k in range(nba) :
+      for j in range(nbi) :
+        for i in range(len(angles[k])) :
+          tmp.append(angles[k][i])
+    dictab['ANGLE']=tmp
+
+###
+
+  if 'RESU' in dictab.para:
+    del dictab['RESU']
+  if 'NOEUD' in dictab.para:
+    del dictab['NOEUD']
+  dprod = dictab.dict_CREA_TABLE()
+
+  nomres=CREA_TABLE(**dprod)
+
+  RetablirAlarme('CALCULEL2_63')
+  RetablirAlarme('CALCULEL2_64')
+  RetablirAlarme('MODELISA5_53')
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py
new file mode 100644 (file)
index 0000000..472a818
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py
@@ -0,0 +1,1036 @@
+#@ MODIF macr_recal_ops Macro  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            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
+
+import os, sys, copy, math
+from glob import glob
+import Numeric
+
+debug = False
+
+INFO = 1
+NOMPRO = 'MACR_RECAL'
+
+fichier_export = None
+mode_python = False
+type_fonctionnelle = 'float'
+
+
+# --------------------------------------------------------------------------------------------------
+def Ecriture_Fonctionnelle(output_file, type_fonctionnelle, fonctionnelle):
+
+   try:    os.remove(output_file)
+   except: pass
+
+   f=open(output_file, 'w')
+   if type_fonctionnelle == 'vector':
+      fonctionnelle = str(fonctionnelle.tolist())
+      fonctionnelle = fonctionnelle.replace('[','')
+      fonctionnelle = fonctionnelle.replace(']','')
+   f.write(str(fonctionnelle))
+   f.close()
+
+
+# --------------------------------------------------------------------------------------------------
+def Ecriture_Derivees(output_file, derivees):
+
+   try:    os.remove(output_file)
+   except: pass
+
+   # On sort si il n'y a pas de derivees a imprimer
+   if not derivees: return
+
+   txt = ''
+   a = derivees
+   for l in range(len(a[:,0])):
+      ligne = []
+      for c in range(len(a[0,:])):
+         ligne.append( str(a[l,c]) )
+      txt += ','.join(ligne) + '\n'
+
+   f=open(output_file, 'w')
+   f.write(txt)
+   f.close()
+
+
+# --------------------------------------------------------------------------------------------------
+def Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess):
+   """ Sortie de la macro, on renvoie les parametres obtenus """
+
+   import Cata, aster, Macro
+   from Cata.cata import DEFI_LIST_REEL
+   from Accas import _F
+   from Macro import reca_message
+   from Macro import reca_algo
+   from Macro import reca_interp
+   from Macro import reca_utilitaires
+   from Macro import reca_calcul_aster
+   from Macro.reca_controles import gestion
+   from Utilitai.Utmess import UTMESS, MessageLog
+
+   if CALCUL_ASTER.METHODE != 'EXTERNE':
+      UTMESS('I','RECAL0_1', valk=str(CALCUL_ASTER.evaluation_fonction), cc=Mess.get_filename())
+
+   LIST_NOM_PARA_ALPHA = [ para[0] for para in LIST_PARA ]
+   LIST_NOM_PARA_ALPHA.sort()
+   lival=[]
+   for i in LIST_NOM_PARA:
+      lival.append( val[ LIST_NOM_PARA_ALPHA.index(i) ] )
+   nomres = DEFI_LIST_REEL(VALE=lival)
+
+   return nomres
+
+
+# --------------------------------------------------------------------------------------------------
+def macr_recal_externe( RESU_EXP, LIST_PARA, RESU_CALC, UNITE_ESCL=3, POIDS=None, LIST_DERIV=None, 
+               ITER_MAXI=10, ITER_FONC_MAXI=100, RESI_GLOB_RELA=1.e-6, UNITE_RESU=91, PARA_DIFF_FINI=0.001,
+               GRAPHIQUE=None, SUIVI_ESCLAVE='NON', METHODE='EXTERNE', INFO=1, **args ):
+   """
+   Entree du mode EXTERNE (ici macr_recal_ops.py est traite comme un fichier Python et non pas par le superviseur Aster)
+   """
+
+   METHODE='EXTERNE'
+
+   # Mot-cle GRAPHIQUE
+   if GRAPHIQUE:
+      GRAPHIQUE0 = {'PILOTE': '', 'AFFICHAGE': 'TOUTE_ITERATION', 'UNITE': 90, 'FORMAT': 'XMGRACE'}
+      for k in GRAPHIQUE0.keys():
+         if not GRAPHIQUE.has_key(k): GRAPHIQUE[k] = GRAPHIQUE0[k]
+
+      if optparse_prefix_graph: args['prefix_graph'] = opts.prefix_graph
+      else:                     args['prefix_graph'] = os.getcwd() + os.sep + 'graph'
+
+   # Les parametres passes sur la ligne de commande surchargent les parametres de la commande MACR_RECAL
+   if optparse_INFO: INFO=opts.INFO
+   if optparse_follow_output:
+      if opts.follow_output == True: SUIVI_ESCLAVE='OUI'
+      else:                          SUIVI_ESCLAVE='NON'
+
+   if optparse_objective:
+      if type_fonctionnelle=='vector': args['FONCTIONNELLE']='VECTORIELLE'
+      else:                            args['FONCTIONNELLE']='SCALAIRE'
+
+   if optparse_gradient:
+      if   opts.gradient=='normal': args['GRADIENT']='NORMAL'
+      elif opts.gradient=='adim':   args['GRADIENT']='ADIMENSIONNE'
+      else:                         args['GRADIENT']='NON_CALCULE'
+
+
+   fonctionnelle, gradient = macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, 
+                                        ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA, UNITE_RESU, PARA_DIFF_FINI,
+                                        GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args )
+
+   return fonctionnelle, gradient
+
+# --------------------------------------------------------------------------------------------------
+def force_list(obj, typref=list):
+   """Retourne 'obj' sous forme d'une liste de 'typref'.
+   """
+   if type(obj) not in (list, tuple):
+      assert type(obj) == typref, '%s != %s' % (type(obj), typref)
+      obj = [obj,]
+   elif len(obj) > 0:
+      elt = obj[0]
+      if type(elt) != typref:
+         obj = [obj,]
+   return obj
+
+# --------------------------------------------------------------------------------------------------
+def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, 
+                        ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI,
+                        GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args ):
+   """Macro commande realisant le recalage de modeles Aster"""
+   # Initialisation du compteur d'erreurs
+   ier=0
+
+   import aster
+   import Macro
+   from Cata import cata
+   from Cata.cata import DEFI_LIST_REEL, CREA_TABLE, TEST_TABLE
+   from Cata.cata import OPER, MACRO
+
+   from Macro import reca_message
+   from Macro import reca_algo
+   from Macro import reca_interp
+   from Macro import reca_utilitaires
+   from Macro import reca_calcul_aster
+   from Macro.reca_controles import gestion
+
+   # Gestion des Exceptions
+   prev_onFatalError = aster.onFatalError()
+   aster.onFatalError('EXCEPTION')
+
+   # La macro compte pour 1 dans l'execution des commandes
+   self.set_icmd(1)
+
+   # Concept en sortir
+   self.DeclareOut('nomres',self.sd)
+
+   # Declaration de toutes les commandes Aster
+   for k,v in cata.__dict__.items() :
+      if isinstance(v, (OPER, MACRO)):
+         self.current_context[k]= v
+   self.current_context['_F']=cata.__dict__['_F']
+
+   macr_recal(UNITE_ESCL, force_list(RESU_EXP, Numeric.ArrayType), POIDS, force_list(LIST_PARA), LIST_DERIV, force_list(RESU_CALC), 
+             ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI,
+             GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args)
+
+   aster.onFatalError(prev_onFatalError)
+   return
+
+
+# --------------------------------------------------------------------------------------------------
+def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, 
+               ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI,
+               GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args ):
+
+   from Utilitai.Utmess import UTMESS
+   # Import d'as_profil
+   if os.environ.has_key('ASTER_ROOT'):
+      sys.path.append(os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'lib'))
+   else:
+      try:    sys.path.append(os.path.join(aster.repout, '..', 'ASTK', 'ASTK_SERV', 'lib'))
+      except: pass
+   try:
+      from as_profil import ASTER_PROFIL
+   except:
+      UTMESS('F','RECAL0_2')
+
+   import Macro, Utilitai
+   from Macro import reca_message
+   from Macro import reca_algo
+   from Macro import reca_interp
+   from Macro import reca_utilitaires
+   from Macro import reca_calcul_aster
+   from Macro.reca_controles import gestion
+   if( METHODE != 'EXTERNE'):
+      from Utilitai.optimize import fmin, line_search, line_search_BFGS, approx_fprime, approx_fhess_p, fminBFGS, fminNCG
+
+   if( METHODE == 'EXTERNE'):
+      pass
+   else:
+      if GRAPHIQUE:
+        dGRAPHIQUE=GRAPHIQUE[0].cree_dict_valeurs(GRAPHIQUE[0].mc_liste)
+        if dGRAPHIQUE.has_key('FORMAT') and dGRAPHIQUE['FORMAT'] == 'GNUPLOT':
+          # On essaie d'importer Gnuplot -> PAS DE GRAPHIQUE
+          try:
+            import Gnuplot
+          except ImportError:
+            GRAPHIQUE == None
+            if INFO>=1: UTMESS('A','RECAL0_3')
+
+
+   #_____________________________________________
+   #
+   # VERIFICATION PREALABLE SUR MEM_ASTER
+   #_____________________________________________
+
+   # Lecture du fichier .export
+   list_export = glob('*.export')
+   if len(list_export) == 0:
+      UTMESS('F','RECAL0_4')
+   elif len(list_export) >1:
+      UTMESS('F','RECAL0_5')
+
+   prof = ASTER_PROFIL(list_export[0])
+
+   try:
+      mem_aster = float(prof['mem_aster'][0])
+   except ValueError:
+      mem_aster = 100.0
+   memjeveux = prof.args.get('memjeveux')
+
+   if mem_aster in (0., 100.):
+      if INFO>=1: UTMESS('A','RECAL0_6')
+      mem_aster = 0.
+   if not memjeveux:
+      UTMESS('F','RECAL0_7')
+
+   try:
+      if mem_aster == 0.:
+         memjeveux_esclave = float(memjeveux)
+      else:
+         memjeveux_esclave = float(memjeveux) / float(mem_aster) * 100. - float(memjeveux)
+   except:
+      UTMESS('F','RECAL0_8')
+
+   if INFO>=1: UTMESS('I','RECAL0_9', valr=memjeveux_esclave)
+
+
+   #_____________________________________________
+   #
+   # INITIALISATIONS
+   #_____________________________________________
+
+   # Liste des parametres utilisant la sensibilité
+   if not LIST_DERIV: LIST_DERIV = {}
+   LIST_SENSI = LIST_DERIV.keys()
+
+   # Stocke l'ordre initial des parametres pour restituer dans le bon ordre les valeurs en sortie de la macro
+   LIST_NOM_PARA = [ para[0] for para in LIST_PARA ]
+
+   # On classe les parametres
+   LIST_SENSI.sort()
+   LIST_PARA.sort()
+
+   # Defini si on utilise le mot-clé SENSIBILITE pour IMPR_TABLE ou non
+   if len(LIST_SENSI) >0: table_sensibilite = True
+   else:                  table_sensibilite = False
+
+   # Defini si on ajoute l'echo des calculs esclaves dans le mess du calcul maitre
+   follow_output = False
+   if SUIVI_ESCLAVE and SUIVI_ESCLAVE=='OUI': follow_output = True
+#   if( METHODE == 'EXTERNE') and mode_python: follow_output = opts.follow_output
+
+   # Pour les algorithmes d'optimize, on a des limitations
+   if METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']:
+      # On ne peut tracer qu'a la derniere iteration
+      if GRAPHIQUE:
+         if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION': UTMESS('I', 'RECAL0_10', valk=METHODE)
+      # Les bornes ne sont pas gerees
+      UTMESS('I','RECAL0_11', valk=METHODE)
+
+   #_______________________________________________
+   #
+   # GESTION DE L'OPTION FACULTATIVE POUR LES POIDS
+   #_______________________________________________
+   if( POIDS == None):
+      POIDS=Numeric.ones(len(RESU_EXP))
+
+
+   #_____________________________________________
+   #
+   # GESTION DES ERREURS DE SYNTAXE
+   #_____________________________________________
+   texte_erreur, texte_alarme = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU,METHODE)
+   if (texte_erreur != ""):
+      UTMESS('F', "RECAL0_12", valk=texte_erreur)
+   if (texte_alarme != ""):
+      UTMESS('A', "RECAL0_12", valk=texte_alarme)
+
+
+   #_____________________________________________
+   #
+   # INITIALISATIONS
+   #_____________________________________________
+
+   if( METHODE != 'EXTERNE'):
+     iter = 0
+     restant,temps_iter=0.,0.
+     restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter)
+
+   para,val,borne_inf,borne_sup = reca_utilitaires.transforme_list_Num(LIST_PARA,RESU_EXP)
+
+   # Pour l'algorithme externe, les valeurs sont celles lues dans le fichier input.txt
+   if( METHODE == 'EXTERNE') and mode_python: val = val_externe
+
+   val_init = copy.copy(val)
+
+   # OBJET "PARAMETRES GLOBAUX"
+   PARAMETRES = reca_calcul_aster.PARAMETRES(
+                                             METHODE=METHODE,
+                                             UNITE_RESU=UNITE_RESU,
+                                             INFO=INFO,
+                                             fich_output='./REPE_OUT/output_esclave.txt',
+                                             mode_include=False,
+                                             follow_output=follow_output,
+                                             table_sensibilite=table_sensibilite,
+                                             memjeveux_esclave=memjeveux_esclave,
+                                             PARA_DIFF_FINI=PARA_DIFF_FINI,
+                                             ITER_MAXI=ITER_MAXI,
+                                             ITER_FONC_MAXI=ITER_FONC_MAXI,
+                                             )
+
+   if( METHODE == 'EXTERNE'):
+      PARAMETRES.fich_output = './tmp_macr_recal/output_esclave.txt'
+      type_fonctionnelle = 'float'
+      if args.has_key('FONCTIONNELLE') and args['FONCTIONNELLE'] == 'VECTORIELLE':
+         PARAMETRES.vector_output = True
+         type_fonctionnelle = 'vector'
+
+   # On utilise le critere en erreur plutot que normalise
+   elif METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']: PARAMETRES.error_output = True
+
+   # OBJET "CALCUL"
+   CALCUL_ASTER = reca_calcul_aster.CALCUL_ASTER(PARAMETRES, UL=UNITE_ESCL, para=para, reponses=RESU_CALC, LIST_SENSI=LIST_SENSI, LIST_DERIV=LIST_DERIV)
+
+   # Instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim
+   Simul = reca_interp.Sim_exp(RESU_EXP,POIDS)
+   Dim = reca_algo.Dimension(copy.copy(val_init),para)
+
+   CALCUL_ASTER.Simul     = Simul
+   CALCUL_ASTER.Dim       = Dim
+   CALCUL_ASTER.reca_algo = reca_algo
+
+   if (GRAPHIQUE):
+      CALCUL_ASTER.UNITE_GRAPHIQUE = GRAPHIQUE['UNITE']
+
+
+   # Instance de la classe gérant l'affichage des resultats du calcul de l'optimisation
+   Mess = reca_message.Message(para,RESU_EXP,copy.copy(val_init),UNITE_RESU) 
+
+   if( METHODE != 'EXTERNE'):
+      Mess.initialise()
+      if INFO>=1: UTMESS('I','RECAL0_13', valk=METHODE, cc=Mess.get_filename())
+
+
+
+   #-------------------------------------------------------------------------------
+   # Methode EXTERNE (en fait juste une evaluation de la fonction puis on sort)
+   #
+   if( METHODE == 'EXTERNE'):
+
+      # On sauvegarde le fichier esclave si celui-ci est fort.UL (sinon il sera ecrase)
+      fic_esclave = './fort.'+str(UNITE_ESCL)
+      txt_old_esclave = None
+      if os.path.isfile(fic_esclave):
+         f = open(fic_esclave,'r')
+         txt_old_esclave = f.read()
+         f.close()
+      
+#       try:    os.remove('./fort.'+str(UNITE_ESCL))
+#       except: pass
+
+      # Fichier bilan
+      txt = '\nPARAMETRES : ' + str([ para[0] for para in LIST_PARA ]) + ' ' + str(val)
+      Mess.ecrire(txt)
+  
+      # Execution de l'esclave
+      if args.has_key('GRADIENT') and args['GRADIENT']!='NON_CALCULE':
+  
+         # Calcul de F et G
+         fonctionnelle, residu, A_nodim, A = CALCUL_ASTER.calcul_FG(val)
+
+         # Ecriture du fichier grad.txt contenant les derivees
+         if args['GRADIENT'] == 'ADIMENSIONNE': gradient = A
+         else:                                  gradient = A_nodim
+  
+         # Ecriture du fichier contenant le gradient
+         if not mode_python: Ecriture_Derivees(output_file='./fort.1901', derivees=gradient)
+
+      else:
+         # Calcul de F
+         fonctionnelle = CALCUL_ASTER.calcul_F(val)
+         gradient = None
+
+      # Ecriture du fichier contenant la fonctionnelle
+      if not mode_python: Ecriture_Fonctionnelle(output_file='./fort.1900', type_fonctionnelle=type_fonctionnelle, fonctionnelle=fonctionnelle)
+
+      # Fichier bilan
+      if type(fonctionnelle) == float: txt = '---> fonctionnelle : '       + str(fonctionnelle)
+      else:                            txt = '---> norme fonctionnelle : ' + str( math.sqrt( (Numeric.sum( [x**2 for x in fonctionnelle] )) ) )
+      Mess.ecrire(txt)
+
+      # Affichage de la valeur de la fonctionnelle
+      if mode_python and opts.INFO==-1: print txt
+
+      # Affichage de la norme du gradient (AA: a remplacer par une formule de norme L2 !!)
+      if gradient:
+         norme = 0
+         for l in range(len(gradient[:,0])):
+            for c in range(len(gradient[0,:])):
+               norme += ( gradient[l,c] * gradient[l,c] )
+         norme = math.sqrt(norme)
+         txt = '---> norme du gradient : ' + str(norme)
+         Mess.ecrire(txt)
+         if mode_python and opts.INFO==-1: print txt
+
+  
+      try:    os.remove('./fort.'+str(UNITE_ESCL))
+      except: pass
+
+      # On remet l'ancien fichier esclave si c'etait fort.UL
+      if txt_old_esclave:
+         f = open(fic_esclave,'w')
+         f.write(txt_old_esclave)
+         f.close()
+
+  
+      L_F = CALCUL_ASTER.L
+      iter = None
+
+      # On va ensuite jusqu'au bout (pour l'impression des graphes)
+
+
+
+   #-------------------------------------------------------------------------------
+   # Algorithme FMIN (pas d'adimensionnement car n'utilise pas de gradient)
+   #
+   elif( METHODE == 'FMIN'):
+      val, fval, warnflag = fmin(CALCUL_ASTER.calcul_F, val, maxiter=ITER_MAXI, maxfun=ITER_FONC_MAXI, fulloutput=1)
+
+      iter_fonc = CALCUL_ASTER.evaluation_fonction
+
+      Mess.ecrire("\nDerniere iteration : ")
+      Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu=0,Act=[])
+      Mess.affiche_fonctionnelle(fval)
+      Mess.affiche_valeurs(val)
+      if warnflag==1: Mess.ecrire("Attention : le nombre maximum d'evaluations de la fonction (ITER_FONC_MAXI) a ete atteint")
+      if warnflag==2: Mess.ecrire("Attention : le nombre maximum d'iteration de l'algorithme (ITER_MAXI) a ete atteint")
+
+      nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess)
+      return
+
+   else:
+       #-------------------------------------------------------------------------------
+       # Pour tous les autres methodes, on adimensionne
+    
+       # Calcul d'initialisation de F, ici L_deriv_sensible ne contient que les termes calculés par la sensibilité, les autres termes sont nuls
+       L_init, L_deriv_sensible = CALCUL_ASTER.calcul_Aster(val, INFO)
+    
+       L_J_init, erreur = Simul.multi_interpole(L_init, RESU_CALC)
+       J_init = Simul.norme_J(copy.copy(L_J_init),copy.copy(L_J_init),UNITE_RESU)
+       J = J_init
+
+       A = Simul.sensibilite(CALCUL_ASTER, L_init, L_deriv_sensible, val, PARA_DIFF_FINI)
+       A = Dim.adim_sensi(A)
+
+       l = reca_algo.lambda_init(Numeric.matrixmultiply(Numeric.transpose(A),A))
+
+       gradient_init =reca_algo.calcul_gradient(A,erreur)  #utile pour le test de convergence, on prend les valeurs dimensionnées
+       residu = reca_algo.test_convergence(gradient_init,erreur,A,Numeric.zeros(len(gradient_init),Numeric.Float))
+    
+       Mess.affiche_result_iter(iter,J,val,residu,Numeric.array([]))
+       # On teste un manque de temps CPU
+       restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter)
+       if (err==1):
+          ier=ier+1
+          return ier
+
+       CALCUL_ASTER.L_init         = L_init
+       CALCUL_ASTER.L_J_init       = L_J_init
+       CALCUL_ASTER.J_init         = J_init
+       CALCUL_ASTER.A_init         = A
+       CALCUL_ASTER.gradient_init  = gradient_init
+       CALCUL_ASTER.residu_init    = residu
+
+
+       #-------------------------------------------------------------------------------
+       # Methode FMINBFGS et FMINNCG
+
+       if METHODE in ['FMINBFGS', 'FMINNCG']:
+          # Derivees
+          fprime=CALCUL_ASTER.calcul_G
+          warnflag=0
+
+          if args.has_key('GRADIENT') and args['GRADIENT'] == 'NON_CALCULE': fprime=None
+
+          if fprime: UTMESS('I','RECAL0_14')
+          else:      UTMESS('I','RECAL0_15')
+
+          # Lancement de l'optimisation
+          if METHODE == 'FMINBFGS':
+             val, fval, func_calls, grad_calls, warnflag = fminBFGS(CALCUL_ASTER.calcul_F, val, fprime=fprime, maxiter=ITER_MAXI, avegtol=RESI_GLOB_RELA, fulloutput=1)
+
+          elif METHODE == 'FMINNCG':
+             val, fval, func_calls, grad_calls, hcalls, warnflag = fminNCG(CALCUL_ASTER.calcul_F, val, fprime=fprime, fhess_p=None, fhess=None, maxiter=ITER_MAXI, avextol=RESI_GLOB_RELA, fulloutput=1)
+
+          # Affichage des messages de sortie
+          iter_fonc = CALCUL_ASTER.evaluation_fonction
+          Mess.ecrire("\nDerniere iteration : ")
+          Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu=0,Act=[])
+          Mess.affiche_fonctionnelle(fval)
+          Mess.affiche_valeurs(val)
+#           if warnflag==1: Mess.ecrire("\nAttention : le nombre maximum d'evaluations de la fonction (ITER_FONC_MAXI) a ete atteint")
+#           if warnflag==2: Mess.ecrire("\nAttention : le nombre maximum d'iteration de la methode (ITER_MAXI) a ete atteint")
+
+          # Permet d'avoir un diagnostic NOOK pour le job
+          if warnflag: iter=ITER_MAXI
+
+          L_F = CALCUL_ASTER.L
+          residu = fval
+
+
+
+
+       #-------------------------------------------------------------------------------
+       # Methode Levenberg-Marquardt
+       else:
+    
+             #_____________________________________________
+             #
+             # BOUCLE PRINCIPALE DE L'ALGORITHME
+             #_____________________________________________
+             epsilon = 10.*RESI_GLOB_RELA
+             while((residu > RESI_GLOB_RELA) & (iter<ITER_MAXI)):  
+                iter = iter +1
+                new_val, s, l, Act = reca_algo.Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,UNITE_RESU) 
+
+                # Calcul de F, ici L_deriv_sensible ne contient que les termes calculés par la sensibilité, les autres termes sont nuls
+                L_F, L_deriv_sensible = CALCUL_ASTER.calcul_Aster(new_val, INFO)
+
+                new_L_J,new_erreur = Simul.multi_interpole(L_F, RESU_CALC)
+                new_J = Simul.norme_J(L_J_init,new_L_J,UNITE_RESU)
+                l = reca_algo.actualise_lambda(l,Dim.adim(val),Dim.adim(new_val),A,erreur,new_J,J)
+
+                val = copy.copy(new_val)
+                erreur = copy.copy(new_erreur)
+                J = new_J
+
+                # Calcul de la matrice des sensibilites
+                A = Simul.sensibilite(CALCUL_ASTER, L_F, L_deriv_sensible, val, PARA_DIFF_FINI)
+                A = Dim.adim_sensi(A)
+
+                # Calcul du residu
+                residu = reca_algo.test_convergence(gradient_init,erreur,A,s)
+
+                # Affichage iteration
+                Mess.affiche_result_iter(iter,J,val,residu,Act)
+                if INFO>=1: UTMESS('I','RECAL0_16',vali=iter, valr=(J, residu))
+
+                if (GRAPHIQUE):
+                   if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION':
+                      GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+                      pilote=GRAPHIQUE['PILOTE']
+                      reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,pilote)
+
+                # On teste un manque de temps CPU
+                restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter)
+                if (err==1):
+                   ier=ier+1
+                   return ier
+
+
+             #_____________________________________________
+             #
+             # FIN DES ITERATIONS
+             # CONVERGENCE OU ECHEC
+             #_____________________________________________
+             iter_fonc = CALCUL_ASTER.evaluation_fonction
+             Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu,Act)
+             reca_algo.calcul_etat_final(para,A,iter,ITER_MAXI,RESI_GLOB_RELA,residu,Mess)
+
+
+       #-------------------------------------------------------------------------------
+
+
+   #_____________________________________________
+   #
+   # FIN DES ITERATIONS POUR TOUS LES ALGOS
+   #_____________________________________________
+   
+   if (GRAPHIQUE):
+      trace = False
+      fichier = None
+      # Pour les algorithmes d'optimize.py, on ne peut tracer qu'a la derniere iteration
+      if (GRAPHIQUE['AFFICHAGE']=='ITERATION_FINALE') or (METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']):
+         trace = True
+      if (METHODE=='EXTERNE' and GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION'): 
+         trace = True
+         if not args.has_key('prefix_graph'): fichier='graph'
+         else:                                fichier = args['prefix_graph']
+      if trace:
+         if INFO>=1: UTMESS('I','RECAL0_17')
+         GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+         pilote=GRAPHIQUE['PILOTE']
+         reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,pilote,fichier)
+
+   if( METHODE == 'EXTERNE'):
+#      if mode_python: return fonctionnelle, gradient
+      return fonctionnelle, gradient
+
+   # Si pas de convergence alors diagnostic NOOK_TEST_RESU
+   if residu > RESI_GLOB_RELA:
+      from Cata.cata import CREA_TABLE, TEST_TABLE
+      _tmp = []
+      _tmp.append( { 'PARA': 'ITER_MAXI', 'LISTE_R': 0.0, } )
+      motscle= {'LISTE': _tmp }
+
+      TBL=CREA_TABLE(**motscle);
+   
+      TEST_TABLE(TABLE=TBL,
+                 TYPE_TEST='SOMM',
+                 NOM_PARA='ITER_MAXI',
+                 VALE=1.,);
+
+   #_____________________________________________
+   #
+   # CREATIONS DE LA LISTE DE REELS CONTENANT 
+   # LES VALEURS DES PARAMETRES A CONVERGENCE
+   #_____________________________________________
+
+   
+   nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess)
+   return 
+
+
+
+
+
+
+
+
+
+
+
+def get_absolute_path(path):
+   """Retourne le chemin absolu en suivant les liens éventuels.
+   """
+   if os.path.islink(path):
+      path = os.path.realpath(path)
+   res = os.path.normpath(os.path.abspath(path))
+   return res
+
+
+#-------------------------------------------------------------------------------
+if __name__ == '__main__':
+
+    mode_python = True
+
+    from optparse import OptionParser, OptionGroup
+    # récupère "bibpyt" à partir de "bibpyt/Macro/macr_recal_ops.py"
+    sys.path.append(get_absolute_path(os.path.join(sys.argv[0], '..', '..')))
+    from Utilitai.Utmess import UTMESS
+
+    p = OptionParser(usage='usage: %s fichier_export [options]' % sys.argv[0])
+    p.add_option('-i', '--input',        action='store',   dest='input',         type='string',   default='input.txt',   help='fichier contenant les parametres')
+    p.add_option('-o', '--output',       action='store',   dest='output',        type='string',   default='output.txt',  help='fichier contenant la fonctionnelle')
+    p.add_option('-g', '--output_grad',  action='store',   dest='output_grad',   type='string',   default='grad.txt',    help='fichier contenant le gradient')
+    p.add_option('-p', '--prefix_graph', action='store',   dest='prefix_graph',  type='string',   default='graph',       help='prefixe des fichiers contenant les courbes')
+    p.add_option('-v', '--info',         action='store',   dest='INFO',          type='int',                             help='niveau de message (-1, 0, 1, 2)')
+    p.add_option('-f', '--follow',       action='store',   dest='follow_output', type='string',                          help="affiche ou non l'output du fichier Aster (True/False)")
+    p.add_option('-F', '--objective',    action='store',   dest='objective',     type='string',                          help="type de la fonctionnelle (float/vector)")
+    p.add_option('-G', '--gradient',     action='store',   dest='gradient' ,     type='string',   default='no',          help="calcul du gradient par Aster (no/normal/adim)")
+    p.add_option('-d', '--display',      action='store',   dest='display' ,      type='string',                          help="renvoi du DISPLAY (pour que la creation des courbes soit moins genante)")
+
+#    p.add_option('-n', '--name',         action='store',   dest='name',          type='string',   default='optim',       help="prefixe du fichier de bilan")
+
+    opts, args = p.parse_args()
+
+    # renvoi du DISPLAY (pour que la creation des courbes soit moins genante)
+    if opts.display: os.environ['DISPLAY'] = opts.display
+
+
+    # Options par defaut
+    optparse_input = optparse_output = optparse_output_grad = optparse_prefix_graph = optparse_INFO = optparse_follow_output = optparse_objective = optparse_gradient = optparse_name = None
+
+    if opts.INFO==None: opts.INFO=0
+
+    if opts.input:                                 optparse_input         = True
+    if opts.output:                                optparse_output        = True
+    if opts.output_grad:                           optparse_output_grad   = True
+    if opts.prefix_graph:                          optparse_prefix_graph  = True
+    if opts.INFO in [-1, 0, 1, 2]:                 optparse_INFO          = True
+    if opts.follow_output in ['True', 'False']:    optparse_follow_output = True
+    if opts.objective in ['float', 'vector']:      optparse_objective     = True
+    if opts.gradient in ['no', 'normal', 'adim']:  optparse_gradient      = True
+#    if opts.name:                                  optparse_name          = True
+
+    if opts.follow_output=='True':  opts.follow_output=True
+    if opts.follow_output=='False': opts.follow_output=False
+
+
+    # Fichier .export
+    if args:
+       fichier_export =  args[0]
+       if not os.path.isfile(fichier_export): fichier_export = None
+
+    INFO = opts.INFO
+    input_file  = opts.input
+    output_file = opts.output
+    output_grad = opts.output_grad
+    type_fonctionnelle = opts.objective
+
+    # Import d'as_profil
+    if os.environ.has_key('ASTER_ROOT'):
+      sys.path.append(os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'lib'))
+    try:
+      from as_profil import ASTER_PROFIL
+    except:
+      UTMESS('F','RECAL0_99')
+
+    # Efface les fichiers resultats
+    try:    os.remove(output)
+    except: pass
+    try:    os.remove(output_grad)
+    except: pass
+
+
+    # Si le fichier export n'est pas en argument on prend l'export qui est dans le rep courant
+    if not fichier_export:
+      # Lecture du fichier .export
+      list_export = glob('*.export')
+      if len(list_export) != 1:
+         UTMESS('F','RECAL0_98')
+      else:
+         fichier_export = list_export[0]
+    prof = ASTER_PROFIL(fichier_export)
+
+    # Execution du fichier .comm
+    nom_comm = None
+    # fichier/répertoire
+    for lab in ('data', 'resu'):
+      l_fr = getattr(prof, lab)
+      l_tmp = l_fr[:]
+
+      for dico in l_tmp:
+        # fichiers
+        if not dico['isrep']:
+          # Ancien .comm a executer
+          if dico['type'] == 'comm' and dico['ul'] == '1':
+            nom_comm = dico['path']
+
+    # parametres
+    for lab in ('param',):
+      l_fr = getattr(prof, lab)
+#      print l_fr
+#      print l_fr['version']
+      try:    os.environ['ASTER_VERSION'] = l_fr['version'][0]
+      except: pass
+
+
+    if not nom_comm:
+       UTMESS('F','RECAL0_97')
+    if not os.path.isfile(nom_comm):
+       UTMESS('F','RECAL0_96', valk=nom_comm)
+
+
+
+    # -------------------------------------------------------------------
+    # Lecture des valeurs d'entree
+    if INFO==2: UTMESS('I','RECAL0_95',valk=input_file)
+    try:
+       f = open(input_file, 'r')
+       txt = f.read()
+       f.close()
+       txt = txt.replace(',', ' ')
+       val_externe = [ float(x) for x in txt.strip().split() ]
+    except:
+       UTMESS('F','RECAL0_94',valk=input_file)
+    if INFO>=2: UTMESS('I','RECAL0_93', valk=str(val_externe))
+    if optparse_INFO and opts.INFO == -1: print '\n'+ str(val_externe)
+
+
+    # -------------------------------------------------------------------
+    # Efface les fichiers d'entree et de sortie
+    try:    os.remove(input_file)
+    except: pass
+    try:    os.remove(output_file)
+    except: pass
+    try:    os.remove(output_grad)
+    except: pass
+
+
+
+
+    # --------------------------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------------------------
+    # Ci-dessous on extrait le fichier de commande jusqu'a la commande MACR_RECAL exclue (fichiernew)
+    # Puis la commande MACR_RECAL (commandenew)
+    # Ensuite on annule l'effet des commandes Aster et on evalue en Python les deux chaines de textes
+
+    # Lecture du fichier .comm
+    f=open(nom_comm,'r')
+    fichier=f.read()
+    f.close
+
+    # Extraction des deux parties dans le fichier de commande
+    fichiernew=None
+    commandenew=None
+    nb_par=-99
+    txt1='MACR_RECAL'
+    txt2='('
+    txt3=')'
+    for ligne in fichier.split('\n'):
+       if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1 and ligne.strip()[0]!='#':
+          nb_par=0
+          index_deb1 = fichier.index(ligne)
+          fichiernew=fichier[:index_deb1]
+#          if debug: print 80*'*' + 2*'\n'+fichiernew+80*'*' + 2*'\n'
+       if fichiernew and ligne.find( txt2 )!=-1: nb_par+=1
+       if fichiernew and ligne.find( txt3 )!=-1: nb_par-=1
+       if fichiernew and nb_par==0:
+          index_fin1 = fichier.index(ligne)+len(ligne)
+          commandenew=fichier[index_deb1:index_fin1]
+
+          # Remplace le nom de concept a gauche du signe egal
+          index_deb2 = commandenew.index(txt1)
+          commandenew='fonctionnelle, gradient='+commandenew[index_deb2:]+ '\n'
+
+          if debug: print 80*'*' + 2*'\n'+commandenew+80*'*' + 2*'\n'
+          break
+    if not fichiernew or not commandenew:
+       UTMESS('F','RECAL0_92', valk=nom_comm)
+
+
+    # -------------------------------------------------------------------
+    # Import du module Utilitai
+    sys.path.append(os.path.join(os.getcwd(), 'Python'))
+    sys.path.append(os.path.join(os.environ['ASTER_ROOT'], os.environ['ASTER_VERSION'], 'bibpyt'))
+    try:
+       import Utilitai
+       from Utilitai.System import ExecCommand
+    except:
+       UTMESS('F','RECAL0_91')
+
+
+    # -------------------------------------------------------------------
+    # On annule les commandes Aster du fichier maitre .comm
+    def DEBUT(*args, **kwargs): pass
+    def FIN(*args, **kwargs): pass
+    def MACR_RECAL(*args, **kwargs): pass
+    def _F(*args, **kwargs): return kwargs
+    def DEFI_LIST_REEL(*args, **kwargs): pass
+    def DEFI_FONCTION(*args, **kwargs): pass
+    def TEST_FONCTION(*args, **kwargs): pass
+    def DEFI_CONSTANTE(*args, **kwargs): pass
+
+
+    # -------------------------------------------------------------------
+    # Evaluation du fichier de commande Aster jusqu'a MACR_RECAL
+    lance_aster = False
+    try:
+       exec(fichiernew)
+    except:
+       txt = "Le mode EXTERNE tourne en mode degrade. Lire la documentation."
+       UTMESS('A','RECAL0_90')
+       lance_aster = True
+    else:
+       exec(commandenew.replace(txt1, 'macr_recal_externe'))
+#        try:
+#           exec(commandenew.replace(txt1, 'macr_recal_externe'))
+#        except Exception, err:
+#           print err
+#           txt = "Erreur lors de l'execution de la commande MACR_RECAL" 
+#           UTMESS('F','RECAL0_12',valk=txt)
+
+       Ecriture_Fonctionnelle(output_file, type_fonctionnelle, fonctionnelle)
+       Ecriture_Derivees(output_grad, gradient)
+
+
+
+    # --------------------------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------------------------
+    # --------------------------------------------------------------------------------------------------------
+    # Si l'evaluation du fichier de commande Aster jusqu'a MACR_RECAL a echoue, on execute Aster "normalement"
+    if lance_aster:
+
+       _PARAM_ = '_PARAM_'
+       new_fichier_comm = os.getcwd() + os.sep + 'tmp_comm'
+       new_fichier_export  = os.getcwd() + os.sep + fichier_export.split('/')[-1] + '_new'
+
+       # Lecture du fichier .comm
+       f=open(nom_comm,'r')
+       fichier=f.read()
+       f.close
+    
+       # -------------------------------------------------------------------
+       # Modification du fichier .comm (changement des valeurs, ecriture du resultat dans un fichier)
+       if INFO==2: UTMESS('I','RECAL0_89',valk=nom_comm)
+       f = open(nom_comm, 'r')
+       ok1 = ok3 = ok4 = False
+       txt = ''
+       for ligne in f:
+          if ligne.find('MACR_RECAL')!=-1 and ligne.strip()[0]!='#':            # On determine le nom du concept sortant de MACR_RECAL
+             ok3 = True
+             _RESU_ = ligne.split('=')[0].strip()
+             txt += ligne
+          elif ligne.strip()[:len(_PARAM_)] == _PARAM_:                        # On change les parametres : la variables _PARAM_
+             ok1 = True
+             txt += _PARAM_ + " = " + str(val_externe) + '\n'
+          elif ligne.find('METHODE')!=-1 and ligne.strip()[0]!='#':         # On verifie bien que la methode externe est choisi
+             if ligne.find("EXTERNE")!=-1:
+                ok4 = True
+                txt += ligne
+          else: txt += ligne
+       f.close()
+
+       if not ok1:  UTMESS('F','RECAL0_88',valk=_PARAM_)
+       if not ok3:  UTMESS('F','RECAL0_87')
+       if not ok4:  UTMESS('F','RECAL0_86')
+
+       txt = txt.replace('_RESU_', _RESU_)
+
+       # Ecriture du nouveau fichier comm temporaire
+       if INFO==2: UTMESS('I','RECAL0_85',valk=new_fichier_comm)
+       f = open(new_fichier_comm, 'w')
+       f.write(txt)
+       f.close()
+
+       # On remplace dans l'export par le nouveau .comm
+       prof = ASTER_PROFIL(fichier_export)
+       for lab in ('data', 'resu'):
+          l_fr = getattr(prof, lab)
+          l_tmp = l_fr[:]
+          for dico in l_tmp:
+             # fichiers
+             if not dico['isrep']:
+                # On remplace par le nouveau .comm
+                if dico['type'] == 'comm' and dico['ul'] == '1':
+                   dico['path'] = new_fichier_comm
+
+#              if lab == 'resu':
+#                 dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
+
+       # On ajoute au profil le fichier output.txt (unite logique 1900)
+       try:    os.remove('./fort.1900')
+       except: pass
+       if not output_file.find(os.sep)!=-1: output_file = os.getcwd() + os.sep + output_file
+       prof.Set('R', {'type':'libr', 'isrep':False, 'path': output_file, 'ul':1900, 'compr': False} )
+
+       # On ajoute au profil le fichier grad.txt (unite logique 1901)
+       if optparse_gradient and opts.gradient!='no':
+          try:    os.remove('./fort.1901')
+          except: pass
+          output_grad = opts.gradient
+          if not output_grad.find(os.sep)!=-1: output_grad = os.getcwd() + os.sep + output_grad
+          prof.Set('R', {'type':'libr', 'isrep':False, 'path': output_grad, 'ul':1901, 'compr': False} )
+
+
+       # Ecriture du nouveau fichier export
+       try:
+          if INFO==2: UTMESS('I','RECAL0_85',valk=new_fichier_export)
+          prof.WriteExportTo(new_fichier_export)
+       except:
+          UTMESS('F','RECAL0_84',valk=new_fichier_export)
+       if debug: prof.WriteExportTo('/tmp/exp')
+
+
+       # chemin vers as_run
+       if os.environ.has_key('ASTER_ROOT'):
+          as_run = os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'bin', 'as_run')
+       else:
+          as_run = 'as_run'
+          if INFO>=1: UTMESS('A', 'RECAL0_83')
+
+
+       # Import du module Utilitai
+       sys.path.append(os.path.join(os.environ['ASTER_ROOT'], os.environ['ASTER_VERSION'], 'bibpyt'))
+       try:
+          import Utilitai
+          from Utilitai.System import ExecCommand
+       except:
+          UTMESS('F','RECAL0_91')
+
+
+       # Lancement d'Aster avec le deuxieme export
+       cmd = '%s %s' % (as_run, new_fichier_export)
+       if INFO>=2: UTMESS('I','EXECLOGICIEL0_8',valk=cmd)
+       iret, txt_output = ExecCommand(cmd, follow_output=opts.follow_output,verbose=opts.follow_output)
+       if INFO>=2: UTMESS('I','EXECLOGICIEL0_12',valk=cmd)
+
+       try:    os.remove(new_fichier_comm)
+       except: pass
+       try:    os.remove(new_fichier_export)
+       except: pass
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/macr_spectre_ops.py b/Aster/Cata/cataSTA10/Macro/macr_spectre_ops.py
new file mode 100644 (file)
index 0000000..44fb67d
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macr_spectre_ops.py
@@ -0,0 +1,362 @@
+#@ MODIF macr_spectre_ops Macro  DATE 19/11/2007   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.        
+# ======================================================================
+
+from Accas import _F
+import string
+
+try:
+   import aster
+   from Utilitai.Utmess import  UTMESS
+except:
+   pass
+
+def macr_spectre_ops(self,MAILLAGE,PLANCHER,NOM_CHAM,CALCUL,RESU,IMPRESSION=None,
+                     FREQ=None,LIST_FREQ=None,LIST_INST=None,AMOR_SPEC=None,**args):
+  """
+     Ecriture de la macro MACR_SPECTRE
+  """
+  ier=0
+  import string
+  from types import ListType,TupleType,StringType
+  EnumType=(ListType,TupleType)
+  
+  ### On importe les definitions des commandes a utiliser dans la macro
+  RECU_FONCTION    = self.get_cmd('RECU_FONCTION')
+  CALC_FONCTION    = self.get_cmd('CALC_FONCTION')
+  IMPR_FONCTION    = self.get_cmd('IMPR_FONCTION')
+  CREA_TABLE       = self.get_cmd('CREA_TABLE')
+
+  ### Comptage commandes + déclaration concept sortant
+  self.set_icmd(1)
+  self.DeclareOut('tab',self.sd)
+  macro='MACR_SPECTRE'
+
+  ### construction de la liste des noeuds à traiter
+  planch_nodes={}
+  dic_gpno=aster.getcolljev(MAILLAGE.nom.ljust(8)+".GROUPENO")
+  l_nodes =aster.getvectjev(MAILLAGE.nom.ljust(8)+".NOMNOE")
+  l_plancher=[]
+  for plancher in PLANCHER :
+      liste_no=[]
+      if plancher['NOEUD']!=None :
+         if type(plancher['NOEUD'])==StringType :
+                 liste_no.append(plancher['NOEUD'])
+         else :
+                 for noeud in plancher['NOEUD'] :
+                     liste_no.append(plancher['NOEUD'])
+      if plancher['GROUP_NO']!=None :
+         if type(plancher['GROUP_NO'])==StringType :
+                noms_no =[string.strip(l_nodes[n-1]) \
+                          for n in dic_gpno[plancher['GROUP_NO'].ljust(8)]]
+                liste_no=liste_no+noms_no
+         else :
+             for group_no in plancher['GROUP_NO'] :
+                noms_no =[string.strip(l_nodes[n-1]) \
+                          for n in dic_gpno[group_no.ljust(8)]]
+                liste_no=liste_no+noms_no
+      planch_nodes[plancher['NOM']]=liste_no
+      l_plancher.append(plancher['NOM'])
+
+  if AMOR_SPEC!=None and type(AMOR_SPEC) not in EnumType :
+     AMOR_SPEC=(AMOR_SPEC,)
+
+  if NOM_CHAM=='ACCE' : dico_glob={}
+  if NOM_CHAM=='DEPL' : dico_glob={'DX_max'   :[] ,
+                                   'DY_max'   :[] ,
+                                   'DZ_max'   :[] ,
+                                   'DH_max'   :[] , }
+
+  ############################################################
+  ### boucle 1 sur les planchers
+  for plancher in l_plancher :
+
+      if NOM_CHAM=='ACCE' :
+         __moy_x=[None]*len(planch_nodes[plancher])
+         __moy_y=[None]*len(planch_nodes[plancher])
+         __moy_z=[None]*len(planch_nodes[plancher])
+      if NOM_CHAM=='DEPL' :
+         dicDmax={}
+  ############################################################
+  ### boucle 2 sur les noeuds du plancher
+      indexn=0
+      for node in planch_nodes[plancher] :
+
+  ############################################################
+  ### boucle 3 sur les directions (X,Y,Z)
+          for dd in ('X','Y','Z') :
+
+  ############################################################
+  ### boucle 4 sur les résultats
+              l_fonc=[]
+              for resu in RESU :
+                  ### Récupération des fonctions
+                  motscles={}
+                  if resu['RESU_GENE']!=None :
+                     if CALCUL=='ABSOLU' :
+                        UTMESS('F','SPECTRAL0_8')
+                     motscles['RESU_GENE'] = resu['RESU_GENE']
+
+                  if resu['RESULTAT' ]!=None :
+                    motscles['RESULTAT']  = resu['RESULTAT']
+                  
+                  __spo=RECU_FONCTION(NOM_CHAM     = NOM_CHAM,
+                                      TOUT_ORDRE   = 'OUI',
+                                      NOM_CMP      = 'D'+dd,
+                                      INTERPOL     = 'LIN',
+                                      PROL_GAUCHE  = 'CONSTANT',
+                                      PROL_DROITE  = 'CONSTANT',
+                                      NOEUD        = node , **motscles )
+
+                  if NOM_CHAM=='ACCE' :
+                     ### Accelerations relatives
+                     if CALCUL=='RELATIF' :
+                        ### Combinaison avec fonction d acceleration
+                        motscles={}
+                        if LIST_INST!=None : motscles['LIST_PARA']=LIST_INST
+                        __spo=CALC_FONCTION(COMB=(_F(FONCTION=__spo,
+                                                     COEF= 1.0      ),
+                                                  _F(FONCTION=resu['ACCE_'+dd],
+                                                     COEF= 1.0)              ),**motscles )
+
+                     ### Calcul des spectres d'oscillateur
+                     motscles={}
+                     if FREQ     !=None : motscles['FREQ']     =FREQ
+                     if LIST_FREQ!=None : motscles['LIST_FREQ']=LIST_FREQ
+                     __spo=CALC_FONCTION(
+                            SPEC_OSCI=_F(FONCTION    = __spo,
+                                         AMOR_REDUIT = AMOR_SPEC,
+                                         NORME       = args['NORME'],
+                                         **motscles                  ) )
+                     l_fonc.append(__spo)
+
+                  if NOM_CHAM=='DEPL' :
+                     if CALCUL=='ABSOLU' :
+                        ### On retranche les deplacements d entrainement
+                        motscles={}
+                        if LIST_INST!=None : motscles['LIST_PARA']=LIST_INST
+                        __spo=CALC_FONCTION(COMB=(_F(FONCTION=__spo,
+                                                     COEF= 1.0      ),
+                                                  _F(FONCTION=resu['DEPL_'+dd],
+                                                     COEF= -1.0)              ),**motscles )
+
+                     l_fonc.append(__spo)
+
+  ### fin boucle 4 sur les résultats
+  ############################################################
+
+  ############################################################
+  ### calcul de la moyenne sur les resultats à noeud et direction fixes
+              nbresu=len(RESU)
+              if NOM_CHAM=='ACCE' :
+                 mcfCMBx=[]
+                 mcfCMBy=[]
+                 mcfCMBz=[]
+                 for spo in l_fonc :
+                     mcfCMBx.append(_F(FONCTION=spo,
+                                       COEF=1./float(nbresu),))
+                     mcfCMBy.append(_F(FONCTION=spo,
+                                       COEF=1./float(nbresu),))
+                     mcfCMBz.append(_F(FONCTION=spo,
+                                       COEF=1./float(nbresu),))
+                 motscles={}
+                 if LIST_FREQ!=None : motscles['LIST_PARA']=LIST_FREQ
+                 if dd=='X' : __moy_x[indexn]=CALC_FONCTION(COMB=mcfCMBx,**motscles)
+                 if dd=='Y' : __moy_y[indexn]=CALC_FONCTION(COMB=mcfCMBy,**motscles)
+                 if dd=='Z' : __moy_z[indexn]=CALC_FONCTION(COMB=mcfCMBz,**motscles)
+
+              if NOM_CHAM=='DEPL' :
+                 moy = 0.
+                 for spo in l_fonc :
+                     fspo = spo.convert()
+                     aspo = fspo.abs()
+                     vmax  = aspo.extreme()['max']
+                     moy   = moy + vmax[-1][-1]
+                 dicDmax[(node,dd)]=moy/nbresu
+
+  ### fin boucle 3 sur les directions
+  ############################################################
+
+          ################################
+          ### impressions en chaque noeud
+          if NOM_CHAM=='ACCE' and IMPRESSION!=None :
+            if IMPRESSION['TOUT']=='OUI' :
+              __moyxa=[None]*len(AMOR_SPEC)
+              __moyya=[None]*len(AMOR_SPEC)
+              __moyza=[None]*len(AMOR_SPEC)
+              for i in range(len(AMOR_SPEC)) : 
+                 amor = AMOR_SPEC[i]
+                 __moyxa[i]=RECU_FONCTION(NAPPE          = __moy_x[indexn],
+                                          VALE_PARA_FONC = AMOR_SPEC[i]   )
+                 __moyya[i]=RECU_FONCTION(NAPPE          = __moy_y[indexn],
+                                          VALE_PARA_FONC = AMOR_SPEC[i]   )
+                 __moyza[i]=RECU_FONCTION(NAPPE          = __moy_z[indexn],
+                                          VALE_PARA_FONC = AMOR_SPEC[i]   )
+              motscles={}
+              dI = IMPRESSION[0].cree_dict_valeurs(IMPRESSION[0].mc_liste)
+              if dI.has_key('PILOTE')            : motscles['PILOTE'   ]=IMPRESSION['PILOTE']
+              if IMPRESSION['FORMAT']!='TABLEAU' : motscles['ECHELLE_X']='LOG'
+              if IMPRESSION['TRI']=='AMOR_SPEC' :
+                 for i in range(len(AMOR_SPEC)) : 
+                    TITRE   ='Spectres / Plancher = '+plancher+\
+                                       ' / amor='+str(AMOR_SPEC[i])+\
+                                       ' / noeud='+node
+                    IMPR_FONCTION(
+                      FORMAT=IMPRESSION['FORMAT'],
+                      UNITE =IMPRESSION['UNITE' ],
+                      COURBE=( _F(FONCTION=__moyxa[i], LEGENDE ='X',),
+                               _F(FONCTION=__moyya[i], LEGENDE ='Y',),
+                               _F(FONCTION=__moyza[i], LEGENDE ='Z',),),
+                      TITRE   =TITRE,
+                      **motscles)
+              elif IMPRESSION['TRI']=='DIRECTION' :
+                 lfonc=[]
+                 for dd in ('X','Y','Z') :
+                    TITRE   ='Spectres / Plancher = '+plancher+\
+                                       ' / direction = '+dd+\
+                                       ' / noeud = '+node
+                    if dd=='X' : l_fonc=[_F(FONCTION=__moyxa[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+                                         for i in range(len(AMOR_SPEC))          ]
+                    if dd=='Y' : l_fonc=[_F(FONCTION=__moyya[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+                                         for i in range(len(AMOR_SPEC))          ]
+                    if dd=='Z' : l_fonc=[_F(FONCTION=__moyza[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+                                         for i in range(len(AMOR_SPEC))          ]
+                    IMPR_FONCTION(
+                      FORMAT=IMPRESSION['FORMAT'],
+                      UNITE =IMPRESSION['UNITE' ],
+                      COURBE=l_fonc,
+                      TITRE   =TITRE,
+                      **motscles)
+
+          ### increment de l'indice de noeud
+          indexn=indexn+1
+
+  ### fin boucle 2 sur les noeuds du plancher
+  ############################################################
+
+  ############################################################
+  ### Calcul des enveloppes des spectres ou des deplacements max
+      if NOM_CHAM=='ACCE' :
+         mcslx=[]
+         mcsly=[]
+         mcslz=[]
+         indexn=0
+         for node in planch_nodes[plancher] :
+             mcslx.append(__moy_x[indexn])
+             mcsly.append(__moy_y[indexn])
+             mcslz.append(__moy_z[indexn])
+             indexn=indexn+1
+         __snx=CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslx))
+         __sny=CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcsly))
+         __snz=CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslz))
+         __snh=CALC_FONCTION(ENVELOPPE=_F(FONCTION=(__snx,__sny)))
+      if NOM_CHAM=='DEPL' :
+         DRmX = max([dicDmax[(node,'X')] for node in planch_nodes[plancher]])
+         DRmY = max([dicDmax[(node,'Y')] for node in planch_nodes[plancher]])
+         DRmZ = max([dicDmax[(node,'Z')] for node in planch_nodes[plancher]])
+         DRmH = max([DRmX,DRmY])
+
+  ############################################################
+  ### Renseignement de la table finale des résultats
+      if   NOM_CHAM=='ACCE' :
+           nbind=len(AMOR_SPEC)
+           for i in range(nbind) :  
+              dico_glob['FREQ'                    ]=__snx.Valeurs()[1][i][0]
+              dico_glob['eX_%d_%s' % (i, plancher)]=__snx.Valeurs()[1][i][1]
+              dico_glob['eY_%d_%s' % (i, plancher)]=__sny.Valeurs()[1][i][1]
+              dico_glob['eZ_%d_%s' % (i, plancher)]=__snz.Valeurs()[1][i][1]
+              dico_glob['eH_%d_%s' % (i, plancher)]=__snh.Valeurs()[1][i][1]
+      elif NOM_CHAM=='DEPL' :
+              dico_glob['DX_max'].append(DRmX)
+              dico_glob['DY_max'].append(DRmY)
+              dico_glob['DZ_max'].append(DRmZ)
+              dico_glob['DH_max'].append(DRmH)
+
+  ############################################################
+  ### Impression des courbes
+      if   NOM_CHAM=='ACCE' and IMPRESSION!=None :
+        motscles={}
+        dI = IMPRESSION[0].cree_dict_valeurs(IMPRESSION[0].mc_liste)
+        if dI.has_key('PILOTE') : motscles['PILOTE']=IMPRESSION['PILOTE']
+        if IMPRESSION['FORMAT']!='TABLEAU' : motscles['ECHELLE_X']='LOG'
+        __snxa=[None]*len(AMOR_SPEC)
+        __snya=[None]*len(AMOR_SPEC)
+        __snza=[None]*len(AMOR_SPEC)
+        __snha=[None]*len(AMOR_SPEC)
+        for i in range(nbind) : 
+           __snxa[i]=RECU_FONCTION(NAPPE          = __snx,
+                                   VALE_PARA_FONC = AMOR_SPEC[i], )
+           __snya[i]=RECU_FONCTION(NAPPE          = __sny,
+                                   VALE_PARA_FONC = AMOR_SPEC[i], )
+           __snza[i]=RECU_FONCTION(NAPPE          = __snz,
+                                   VALE_PARA_FONC = AMOR_SPEC[i], )
+           __snha[i]=RECU_FONCTION(NAPPE          = __snh,
+                                   VALE_PARA_FONC = AMOR_SPEC[i], )
+        if IMPRESSION['TRI']=='AMOR_SPEC' :
+           for i in range(nbind) : 
+              TITRE   ='Spectres moyens / Plancher = '+plancher+' / amor='+str(AMOR_SPEC[i])
+              IMPR_FONCTION(
+                 FORMAT=IMPRESSION['FORMAT'],
+                 UNITE =IMPRESSION['UNITE' ],
+                 COURBE=( _F(FONCTION=__snxa[i], LEGENDE ='X',),
+                          _F(FONCTION=__snya[i], LEGENDE ='Y',),
+                          _F(FONCTION=__snza[i], LEGENDE ='Z',),
+                          _F(FONCTION=__snha[i], LEGENDE ='H',),),
+                 TITRE   =TITRE,
+                 **motscles
+                 )
+        elif IMPRESSION['TRI']=='DIRECTION' :
+              for dd in ('X','Y','Z','H'):
+                TITRE   ='Spectres moyens / Plancher = '+plancher+' / direction = '+dd
+                l_fonc  =[]
+                if dd=='X' : l_fonc=[_F(FONCTION=__snxa[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+                                     for i in range(len(AMOR_SPEC))          ]
+                if dd=='Y' : l_fonc=[_F(FONCTION=__snya[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+                                     for i in range(len(AMOR_SPEC))          ]
+                if dd=='Z' : l_fonc=[_F(FONCTION=__snza[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+                                     for i in range(len(AMOR_SPEC))          ]
+                if dd=='H' : l_fonc=[_F(FONCTION=__snha[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+                                     for i in range(len(AMOR_SPEC))          ]
+                IMPR_FONCTION(
+                   FORMAT=IMPRESSION['FORMAT'],
+                   UNITE =IMPRESSION['UNITE' ],
+                   COURBE=l_fonc,
+                   TITRE =TITRE,
+                   **motscles
+                   )
+
+  ### fin boucle 1 sur les planchers
+  ############################################################
+
+  ############################################################
+  ### Renseignement de la table finale des résultats
+  lListe=[]
+  if   NOM_CHAM=='DEPL' :
+      lListe.append(_F(LISTE_K=l_plancher,PARA='PLANCHER'))
+      titre = 'Calcul des spectres enveloppes'
+  if   NOM_CHAM=='ACCE' :
+      titre = ['Calcul des spectres enveloppes par planchers pour les amortissements numérotés :',]
+      b=[' %d : %g ' % (i,AMOR_SPEC[i]) for i in range(len(AMOR_SPEC)) ]
+      titre.append('/'.join(b))
+  lkeys=dico_glob.keys()
+  lkeys.sort()
+  for key in lkeys :
+      lListe.append(_F(LISTE_R=dico_glob[key],PARA=key))
+  tab = CREA_TABLE(LISTE=lListe,TITRE=titre)
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py b/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py
new file mode 100644 (file)
index 0000000..0d5a413
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py
@@ -0,0 +1,277 @@
+#@ MODIF macro_elas_mult_ops Macro  DATE 22/10/2007   AUTEUR PELLET J.PELLET 
+# -*- coding: iso-8859-1 -*-
+#            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.        
+# ======================================================================
+
+
+
+def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL,
+                        CHAR_MECA_GLOBAL,CHAR_CINE_GLOBAL,LIAISON_DISCRET,
+                        CAS_CHARGE,SOLVEUR,**args):
+  """
+     Ecriture de la macro MACRO_ELAS_MULT
+  """
+  ier=0
+  import types
+  from Accas import _F
+  from Utilitai.Utmess     import UTMESS
+
+  # On met le mot cle NUME_DDL dans une variable locale pour le proteger
+  numeddl=NUME_DDL
+  # On importe les definitions des commandes a utiliser dans la macro
+  CALC_MATR_ELEM  =self.get_cmd('CALC_MATR_ELEM')
+  NUME_DDL        =self.get_cmd('NUME_DDL')
+  ASSE_MATRICE    =self.get_cmd('ASSE_MATRICE')
+  FACTORISER      =self.get_cmd('FACTORISER')
+  CALC_VECT_ELEM  =self.get_cmd('CALC_VECT_ELEM')
+  ASSE_VECTEUR    =self.get_cmd('ASSE_VECTEUR')
+  RESOUDRE        =self.get_cmd('RESOUDRE')
+  CREA_RESU       =self.get_cmd('CREA_RESU')
+  CALC_ELEM       =self.get_cmd('CALC_ELEM')
+  CALC_NO         =self.get_cmd('CALC_NO')
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Le concept sortant (de type mult_elas ou fourier_elas) est nommé
+  # 'nomres' dans le contexte de la macro
+  
+  self.DeclareOut('nomres',self.sd)
+
+  ielas = 0
+  ifour = 0
+  for m in CAS_CHARGE:
+     if m['NOM_CAS']:
+        ielas=1                 # mot clé NOM_CAS      présent sous CAS_CHARGE
+        tyresu = 'MULT_ELAS'
+     else:
+        ifour=1                 # mot clé MODE_FOURIER présent sous CAS_CHARGE
+        tyresu = 'FOURIER_ELAS'
+  if ielas==1 and ifour==1:
+     UTMESS('F','ELASMULT0_1')
+
+  if (numeddl in self.sdprods) or (numeddl==None):
+    # Si le concept numeddl est dans self.sdprods ou n est pas nommé
+    # il doit etre  produit par la macro
+    # il faudra donc appeler la commande NUME_DDL
+    lnume = 1
+  else:
+    lnume = 0
+
+  if ielas==1 :
+     motscles={}
+     if   CHAR_MECA_GLOBAL: motscles['CHARGE']    =CHAR_MECA_GLOBAL
+     elif CHAR_CINE_GLOBAL: motscles['CHARGE']    =CHAR_CINE_GLOBAL
+     if   CHAM_MATER      : motscles['CHAM_MATER']=CHAM_MATER
+     if   CARA_ELEM       : motscles['CARA_ELEM'] =CARA_ELEM
+     __nomrig=CALC_MATR_ELEM(OPTION='RIGI_MECA',MODELE=MODELE,**motscles)
+  
+     if lnume:
+       # On peut passer des mots cles egaux a None. Ils sont ignores
+       motscles={}
+       if SOLVEUR:
+          motscles['METHODE'] =SOLVEUR['METHODE']
+          motscles['RENUM']   =SOLVEUR['RENUM']
+       else:
+          motscles['METHODE'] ='MULT_FRONT'
+          motscles['RENUM']   ='METIS'
+       if numeddl!=None:
+          self.DeclareOut('num',numeddl)
+          num=NUME_DDL(MATR_RIGI=__nomrig,**motscles)
+       else:
+          _num=NUME_DDL(MATR_RIGI=__nomrig,**motscles)
+          num=_num
+     else:
+       num=numeddl
+
+     __nomras=ASSE_MATRICE(MATR_ELEM=__nomrig,NUME_DDL=num)
+
+     __nomraf=FACTORISER(MATR_ASSE=__nomras,NPREC=SOLVEUR['NPREC'],STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'])
+
+#####################################################################
+# boucle sur les items de CAS_CHARGE
+
+  nomchn=[]
+  iocc=0
+  for m in CAS_CHARGE:
+     iocc=iocc+1
+
+     if ifour:
+        motscles={}
+        if   CHAR_MECA_GLOBAL: motscles['CHARGE']       =CHAR_MECA_GLOBAL
+        elif CHAR_CINE_GLOBAL: motscles['CHARGE']       =CHAR_CINE_GLOBAL
+        if   CHAM_MATER      : motscles['CHAM_MATER']   =CHAM_MATER
+        if   CARA_ELEM       : motscles['CARA_ELEM']    =CARA_ELEM
+        motscles['MODE_FOURIER'] =m['MODE_FOURIER']
+        __nomrig=CALC_MATR_ELEM(OPTION='RIGI_MECA',MODELE=MODELE,**motscles)
+
+        if lnume:
+           _num=NUME_DDL(MATR_RIGI=__nomrig,METHODE=SOLVEUR['METHODE'],RENUM=SOLVEUR['RENUM'])
+           num=_num
+           lnume=0
+
+        __nomras=ASSE_MATRICE(MATR_ELEM=__nomrig,NUME_DDL=num)
+
+        __nomraf=FACTORISER(MATR_ASSE=__nomras,NPREC=SOLVEUR['NPREC'],STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'])
+
+
+     if m['VECT_ASSE']==None :
+        motscles={}
+        if   CHAM_MATER      : motscles['CHAM_MATER']   =CHAM_MATER
+        if   CARA_ELEM       : motscles['CARA_ELEM']    =CARA_ELEM
+        if   ifour           : motscles['MODE_FOURIER'] =m['MODE_FOURIER']
+        if   m['CHAR_MECA']  : motscles['CHARGE']       =m['CHAR_MECA']
+        elif m['CHAR_CINE']  : motscles['CHARGE']       =m['CHAR_CINE']
+        __nomvel=CALC_VECT_ELEM(OPTION='CHAR_MECA',**motscles)
+        __nomasv=ASSE_VECTEUR(VECT_ELEM=__nomvel,NUME_DDL=num)
+     else :
+        __nomasv=m['VECT_ASSE']
+
+
+     __nomchn=RESOUDRE(MATR=__nomraf,CHAM_NO=__nomasv,TITRE=m['SOUS_TITRE'])
+     nomchn.append(__nomchn)
+
+# fin de la boucle sur les items de CAS_CHARGE
+#####################################################################
+
+  motscles={}
+  iocc=0
+  motscle2={}
+  if CHAM_MATER : motscle2['CHAM_MATER']=CHAM_MATER
+  if CARA_ELEM  : motscle2['CARA_ELEM']=CARA_ELEM
+  if CHAM_MATER or CARA_ELEM :
+    if ielas : 
+       motscles['AFFE']=[]
+       for m in CAS_CHARGE:
+          motscles['AFFE'].append(_F(MODELE=MODELE,
+                                     CHAM_GD=nomchn[iocc],
+                                     NOM_CAS=m['NOM_CAS'],
+                                     **motscle2) )
+          iocc=iocc+1
+    else :
+       motscles['AFFE']=[]
+       for m in CAS_CHARGE:
+          motscles['AFFE'].append(_F(MODELE=MODELE,
+                                     CHAM_GD=nomchn[iocc],
+                                     NUME_MODE=m['MODE_FOURIER'],
+                                     TYPE_MODE=m['TYPE_MODE'],
+                                     **motscle2) )
+          iocc=iocc+1
+  else:
+    if ielas : 
+       motscles['AFFE']=[]
+       for m in CAS_CHARGE:
+          motscles['AFFE'].append(_F(MODELE=MODELE,
+                                     CHAM_GD=nomchn[iocc],
+                                     NOM_CAS=m['NOM_CAS'],) )
+          iocc=iocc+1
+    else :
+       motscles['AFFE']=[]
+       for m in CAS_CHARGE:
+          motscles['AFFE'].append(_F(MODELE=MODELE,
+                                     CHAM_GD=nomchn[iocc],
+                                     NUME_MODE=m['MODE_FOURIER'],
+                                     TYPE_MODE=m['TYPE_MODE'],) )
+          iocc=iocc+1
+
+
+  nomres=CREA_RESU(OPERATION='AFFE',TYPE_RESU=tyresu,NOM_CHAM='DEPL',**motscles)
+
+#####################################################################
+# boucle sur les items de CAS_CHARGE pour CALC_ELEM ete CALC_NO
+
+  iocc=0
+  for m in CAS_CHARGE:
+     iocc=iocc+1
+
+     if m['OPTION']:
+        nbel=0
+        nbno=0
+        liste_el=[]
+        liste_no=[]
+        if type(m['OPTION'])==types.StringType:
+           if m['OPTION'] in ('FORC_NODA','REAC_NODA',
+                              'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL',
+                              'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI','FLUX_NOEU_TEMP',):
+              nbno=nbno+1
+              liste_no.append(m['OPTION'])
+           else:
+              nbel=nbel+1
+              liste_el.append(m['OPTION'])
+        else:
+           for opt in m['OPTION']:
+              if opt in ('FORC_NODA','REAC_NODA',
+                         'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL',
+                         'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI','FLUX_NOEU_TEMP',):
+                 nbno=nbno+1
+                 liste_no.append(opt)
+              else:
+                 nbel=nbel+1
+                 liste_el.append(opt)
+
+        lreac=0
+        if nbel:
+           motscles={}
+           if   CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER
+           if   CARA_ELEM  : motscles['CARA_ELEM']  =CARA_ELEM
+           if ielas:
+              motscles['NOM_CAS']=m['NOM_CAS']
+           else:
+              motscles['NUME_MODE']=m['MODE_FOURIER']
+           motscles['EXCIT']=[]
+           if   m['CHAR_MECA'] :
+              for chargt in m['CHAR_MECA']   : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           elif m['CHAR_CINE'] :
+              for chargt in m['CHAR_CINE']   : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           if   CHAR_MECA_GLOBAL:
+              for chargt in CHAR_MECA_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           elif CHAR_CINE_GLOBAL:
+              for chargt in CHAR_CINE_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           CALC_ELEM(reuse=nomres,
+                     RESULTAT=nomres,
+                     MODELE=MODELE,
+                     REPE_COQUE=_F(NIVE_COUCHE=m['NIVE_COUCHE'],
+                                   NUME_COUCHE=m['NUME_COUCHE'],),
+                     OPTION=tuple(liste_el),
+                     **motscles)
+        if nbno:
+           motscles={}
+           if   CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER
+           if   CARA_ELEM  : motscles['CARA_ELEM']  =CARA_ELEM
+           if ielas:
+              motscles['NOM_CAS']=m['NOM_CAS']
+           else:
+              motscles['NUME_MODE']=m['MODE_FOURIER']
+           motscles['EXCIT']=[]
+           if   m['CHAR_MECA'] :
+              for chargt in m['CHAR_MECA']   : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           elif m['CHAR_CINE'] :
+              for chargt in m['CHAR_CINE']   : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           if   CHAR_MECA_GLOBAL:
+              for chargt in CHAR_MECA_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           elif CHAR_CINE_GLOBAL:
+              for chargt in CHAR_CINE_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
+           CALC_NO(reuse=nomres,
+                   RESULTAT=nomres,
+                   MODELE=MODELE,
+                   OPTION=tuple(liste_no),
+                   **motscles)
+
+# fin de la boucle sur les items de CAS_CHARGE
+#####################################################################
+  return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py
new file mode 100644 (file)
index 0000000..96da78d
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py
@@ -0,0 +1,190 @@
+#@ MODIF macro_expans_ops Macro  DATE 16/11/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.
+# ======================================================================
+
+
+# MODIF : 24/07/2007. BODEL : suppression du mc NUME_DDL. Le nume_ddl par
+# defaut pour PROJ_CHAMP est celui du modèle expérimental.
+
+def macro_expans_ops( self,
+                      MODELE_CALCUL,
+                      MODELE_MESURE,
+                      NUME_DDL=None,
+                      RESU_NX=None,
+                      RESU_EX=None,
+                      RESU_ET=None,
+                      RESU_RD=None,
+                      MODES_NUM=None,
+                      MODES_EXP=None,
+                      RESOLUTION=None,
+                      *args
+                     ):
+    """!macro MACRO_EXPANS """
+    from Accas import _F
+    from Cata.cata import CO, mode_meca, dyna_harmo
+    from Utilitai.Utmess import UTMESS
+    from types import ListType, TupleType
+    ier = 0
+
+    import aster
+    EXTR_MODE = self.get_cmd('EXTR_MODE')
+    PROJ_MESU_MODAL = self.get_cmd('PROJ_MESU_MODAL')
+    REST_GENE_PHYS = self.get_cmd('REST_GENE_PHYS')
+    PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
+    NORM_MODE = self.get_cmd('NORM_MODE')
+
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    is_nume_num = is_nume_exp = 0
+    if MODELE_CALCUL['NUME_MODE'] or  MODELE_CALCUL['NUME_ORDRE']:
+        # on cree un resultat RESU_NX par extraction de NUME_ORDREs
+        is_nume_num = 1
+    else:
+        if RESU_NX: UTMESS('A','MEIDEE0_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
+    else:
+        if RESU_EX: UTMESS('A','MEIDEE0_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
+    # -------------------------------
+    if not is_nume_num:
+        RESU_NX = RESU_NUM
+    else:
+        self.DeclareOut( "RESU_NX", RESU_NX )
+        mfact = {'MODE':RESU_NUM}
+        if MODELE_CALCUL['NUME_MODE']:
+            mfact.update({'NUME_MODE':MODELE_CALCUL['NUME_MODE']})
+        elif MODELE_CALCUL['NUME_ORDRE']:
+            mfact.update({'NUME_ORDRE':MODELE_CALCUL['NUME_ORDRE']})
+
+        RESU_NX = EXTR_MODE( FILTRE_MODE = mfact )
+
+
+    # Extraction des modes expérimentaux
+    # ----------------------------------
+    if not is_nume_exp:
+        RESU_EX = RESU_EXP
+    else:
+        self.DeclareOut( "RESU_EX", RESU_EX )
+        mfact = {'MODE':RESU_EXP}
+        if MODELE_MESURE['NUME_MODE']:
+            mfact.update({'NUME_MODE':MODELE_MESURE['NUME_MODE']})
+        elif MODELE_MESURE['NUME_ORDRE']:
+            mfact.update({'NUME_ORDRE':MODELE_MESURE['NUME_ORDRE']})
+
+        RESU_EX = EXTR_MODE( FILTRE_MODE = mfact )
+
+
+
+    # Projection des modes experimentaux - on passe le mot-clef
+    # RESOLUTION directement à PROJ_MESU_MODAL
+    # ---------------------------------------------------------
+
+    # Mot-clé facteur de résolution
+    mfact = []
+    for m in RESOLUTION:
+        if m['METHODE'] == 'SVD':
+            mfact.append({'METHODE':'SVD','EPS':m['EPS']})
+        if m['METHODE'] == 'LU':
+            mfact.append({'METHODE':'LU'})
+        if m['REGUL'] != 'NON':
+            if m['COEF_PONDER']:
+                mfact.append({'COEF_PONDER':m['COEF_PONDER']})
+            if m['COEF_PONDER_F']:
+                mfact.append({'COEF_PONDER_F':m['COEF_PONDER_F']})
+
+    # Paramètres à garder : si on étend des mode_meca, on conserve les
+    # freq propres, amortissements réduits, et masses généralisées. Pour
+    # les dyna_harmo, on conserve les fréquences uniquement
+    if isinstance(RESU_EXP, mode_meca):
+        paras = ('FREQ','AMOR_REDUIT','MASS_GENE',)
+    elif isinstance(RESU_EXP, dyna_harmo):
+        paras = ('FREQ')
+    else:
+        paras = None
+        #"LE MODELE MEDURE DOIT ETRE UN CONCEPT DE TYPE DYNA_HARMO OU MODE_MECA")
+        UTMESS('A','MEIDEE0_1')
+
+
+    try:
+        __PROJ = PROJ_MESU_MODAL(MODELE_CALCUL = _F( BASE=RESU_NX,
+                                                     MODELE=MOD_CALCUL,
+                                                   ),
+                                 MODELE_MESURE = _F( MESURE=RESU_EX,
+                                                     MODELE=MOD_MESURE,
+                                                     NOM_CHAM=NOM_CHAM,
+                                                   ),
+                                 RESOLUTION=mfact,
+                                 NOM_PARA=paras,
+                                 );
+    except Exception, err:
+        raise Exception, err
+
+    # Phase de reconstruction des donnees mesurees sur le maillage
+    # numerique
+    # ------------------------------------------------------------
+    self.DeclareOut( "RESU_ET", RESU_ET )
+    RESU_ET = REST_GENE_PHYS( RESU_GENE  = __PROJ,
+                              MODE_MECA   = RESU_NX,
+                              TOUT_ORDRE  = 'OUI',
+                              NOM_CHAM    = NOM_CHAM);
+
+
+
+    # Restriction des modes mesures etendus sur le maillage capteur
+    # -------------------------------------------------------------
+    self.DeclareOut( "RESU_RD", RESU_RD )
+    refd1 = aster.getvectjev(RESU_EXP.nom.ljust(19)+".REFD")
+    refd2 = aster.getvectjev(RESU_EX.nom.ljust(19)+".REFD")
+
+    nume=None
+    if RESU_EX.REFD.get():
+        tmp = RESU_EX.REFD.get()[3]
+        if tmp.strip() :
+            nume = self.get_concept(tmp)
+    elif NUME_DDL:
+        nume = NUME_DDL
+    if not nume :
+        UTMESS('A','MEIDEE0_5')
+    RESU_RD = PROJ_CHAMP( METHODE    = 'ELEM',
+                          RESULTAT   = RESU_ET,
+                          MODELE_1   = MOD_CALCUL,
+                          MODELE_2   = MOD_MESURE,
+                          NOM_CHAM   = NOM_CHAM,
+                          TOUT_ORDRE = 'OUI',
+                          NUME_DDL   = nume,
+                          VIS_A_VIS  =_F( TOUT_1='OUI',
+                                          TOUT_2='OUI',),
+                          NOM_PARA   = paras,
+                        );
+
+
+    return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macro_matr_ajou_ops.py b/Aster/Cata/cataSTA10/Macro/macro_matr_ajou_ops.py
new file mode 100644 (file)
index 0000000..aa8b0d6
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macro_matr_ajou_ops.py
@@ -0,0 +1,256 @@
+#@ MODIF macro_matr_ajou_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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.        
+# ======================================================================
+
+
+def macro_matr_ajou_ops(self,MAILLAGE,GROUP_MA_FLUIDE,GROUP_MA_INTERF,MODELISATION,MODE_MECA,DEPL_IMPO,
+                             NUME_DDL_GENE,MODELE_GENE,MATR_MASS_AJOU,MATR_AMOR_AJOU,MATR_RIGI_AJOU,
+                             NOEUD_DOUBLE,FLUIDE,DDL_IMPO,DIST_REFE,SOLVEUR,INFO,AVEC_MODE_STAT,
+                             MODE_STAT,MONO_APPUI,
+                             FORC_AJOU,ECOULEMENT,**args):
+  """
+     Ecriture de la macro MACRO_MATR_AJOU
+  """
+  from Accas import _F
+  import types
+  import aster
+  from Utilitai.Utmess     import  UTMESS
+  ier=0
+  
+  # On importe les definitions des commandes a utiliser dans la macro
+  DEFI_MATERIAU      =self.get_cmd('DEFI_MATERIAU')
+  AFFE_MATERIAU      =self.get_cmd('AFFE_MATERIAU')
+  AFFE_MODELE        =self.get_cmd('AFFE_MODELE')
+  AFFE_CHAR_THER     =self.get_cmd('AFFE_CHAR_THER')
+  CALC_MATR_AJOU     =self.get_cmd('CALC_MATR_AJOU')
+  THER_LINEAIRE      =self.get_cmd('THER_LINEAIRE')
+  CALC_FORC_AJOU     =self.get_cmd('CALC_FORC_AJOU')
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+ 
+  if len(FLUIDE)==1 :
+     message=         '<I> <MACRO_MATR_AJOU> tout le domaine fluide specifie dans GROUP_MA_INTERF et GROUP_MA_FLUIDE \n'
+     message=message+ '                      sera affecte par la masse volumique RHO = '+str(FLUIDE['RHO'])+' \n'
+     aster.affiche('MESSAGE',message)
+     if FLUIDE['GROUP_MA']!=None :
+       message=         '<I> <MACRO_MATR_AJOU> cas fluide simple : le group_ma dans lequel vous affectez la masse \n'
+       message=message+ 'volumique RHO doit etre la reunion de GROUP_MA_INTERF et GROUP_MA_FLUIDE. \n'
+       aster.affiche('MESSAGE',message)
+  else :
+     for flu in FLUIDE :
+         if flu['GROUP_MA']==None :
+            UTMESS('F','MATRICE0_1')
+
+  IOCFLU=len(FLUIDE)
+
+#  ---------------------------------------------------------------
+#  definition du materiau fluide par caracteristique
+#  thermique equivalente
+
+# CAS FLUIDE SIMPLE
+  if IOCFLU==1 :
+     __NOMMAT=DEFI_MATERIAU( THER = _F( LAMBDA = 1.0,
+                                        RHO_CP = FLUIDE[0]['RHO']))
+     __NOMCMA=AFFE_MATERIAU( MAILLAGE = MAILLAGE,
+                             AFFE     = _F( GROUP_MA = (GROUP_MA_FLUIDE,GROUP_MA_INTERF),
+                                            MATER    =  __NOMMAT),    )
+
+#  ---------------------------------------------------------------
+#  cas fluides multiples
+  else :
+     affmat=[]
+     for flu in FLUIDE:
+        __NOMMAT=DEFI_MATERIAU( THER = _F( LAMBDA = 1.0,
+                                           RHO_CP = flu['RHO']))
+        mfact=_F(GROUP_MA=flu['GROUP_MA'],MATER=__NOMMAT)
+        affmat.append(mfact)
+
+     __NOMCMA=AFFE_MATERIAU( MAILLAGE = MAILLAGE,
+                             AFFE     = affmat  )
+
+#  ---------------------------------------------------------------
+#  commande AFFE_MODELE modele fluide
+  __NOMFLU=AFFE_MODELE( MAILLAGE = MAILLAGE,
+                        AFFE     = _F( GROUP_MA     = (GROUP_MA_FLUIDE,GROUP_MA_INTERF),
+                                       MODELISATION = MODELISATION,
+                                       PHENOMENE    = 'THERMIQUE'    ), )
+
+#  ---------------------------------------------------------------
+#  commande AFFE_MODELE modele interface
+  __NOMINT=AFFE_MODELE( MAILLAGE = MAILLAGE,
+                        AFFE     = _F( GROUP_MA     = GROUP_MA_INTERF,
+                                       MODELISATION = MODELISATION,
+                                       PHENOMENE    = 'THERMIQUE'    ), )
+
+#  ---------------------------------------------------------------
+#  commande AFFE_CHAR_THER condition de pression imposee
+#  en un point ou un groupe du fluide
+  affimp=[]
+  nflui=0
+  for DDL in DDL_IMPO :
+     if DDL['PRES_FLUIDE']!=None :
+        nflui=nflui+1
+        if DDL['NOEUD']   !=None : mfact=_F(NOEUD   =DDL['NOEUD'],   TEMP=DDL['PRES_FLUIDE'])
+        if DDL['GROUP_NO']!=None : mfact=_F(GROUP_NO=DDL['GROUP_NO'],TEMP=DDL['PRES_FLUIDE'])
+        affimp.append(mfact)
+  if nflui==0:
+     UTMESS('F','MATRICE0_2')
+
+  __CHARGE=AFFE_CHAR_THER( MODELE    = __NOMFLU,
+                           TEMP_IMPO = affimp )
+
+#  ---------------------------------------------------------------
+#  calcul des masses, rigidites et amortissements ajoutes en theorie
+#  potentielle
+#  commande CALC_MATR_AJOU, calcul de la masse ajoutee
+
+  if MATR_MASS_AJOU!=None :
+     self.DeclareOut('MASSAJ',MATR_MASS_AJOU)
+     solveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+     mostcles={}
+     if   NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE
+     if   INFO         !=None : mostcles['INFO']          =INFO
+     if   MODE_MECA    !=None : mostcles['MODE_MECA']     =MODE_MECA
+     elif DEPL_IMPO    !=None : mostcles['CHAM_NO']       =DEPL_IMPO
+     elif MODELE_GENE  !=None :
+                                mostcles['MODELE_GENE']   =MODELE_GENE
+                                mostcles['AVEC_MODE_STAT']=AVEC_MODE_STAT
+                                mostcles['DIST_REFE']     =DIST_REFE
+     if   NOEUD_DOUBLE !=None : mostcles['NOEUD_DOUBLE']  =NOEUD_DOUBLE
+
+     MASSAJ = CALC_MATR_AJOU(MODELE_FLUIDE    = __NOMFLU,
+                             MODELE_INTERFACE = __NOMINT,
+                             CHARGE           = __CHARGE,
+                             CHAM_MATER       = __NOMCMA,
+                             OPTION           = 'MASS_AJOU',
+                             SOLVEUR          = solveur,
+                             **mostcles)
+
+#  ---------------------------------------------------------------
+#  calcul de l amortissement ajoute
+  if (MATR_AMOR_AJOU!=None ) or (MATR_RIGI_AJOU!=None ):
+
+#  ---------------------------------------------------------------
+#  on definit un nouveau modele fluide pour calculer
+#  le potentiel stationnaire - AFFE_MODELE
+     grma=[GROUP_MA_FLUIDE,]
+     if ECOULEMENT!=None :
+        grma.append(ECOULEMENT['GROUP_MA_1'])
+        grma.append(ECOULEMENT['GROUP_MA_2'])
+     __NOFLUI=AFFE_MODELE( MAILLAGE = MAILLAGE,
+                           AFFE     = _F( GROUP_MA     = grma,
+                                          MODELISATION = MODELISATION,
+                                          PHENOMENE    = 'THERMIQUE'    ), )
+     affimp=[]
+     for DDL in DDL_IMPO :
+        if DDL['PRES_SORTIE']!=None :
+           if DDL['NOEUD']   !=None : mfact=_F(NOEUD   =DDL['NOEUD'],   TEMP=DDL['PRES_SORTIE'])
+           if DDL['GROUP_NO']!=None : mfact=_F(GROUP_NO=DDL['GROUP_NO'],TEMP=DDL['PRES_SORTIE'])
+           affimp.append(mfact)
+
+     affecl=[]
+     for ECL in ECOULEMENT :
+           mfact=_F(GROUP_MA=ECL['GROUP_MA_1'],FLUN=ECL['VNOR_1'])
+           affecl.append(mfact)
+           mfact=_F(GROUP_MA=ECL['GROUP_MA_2'],FLUN=ECL['VNOR_2'])
+           affecl.append(mfact)
+     __CHARG2=AFFE_CHAR_THER( MODELE    = __NOFLUI,
+                              TEMP_IMPO = affimp ,
+                              FLUX_REP  = affecl )
+
+     __POTEN = THER_LINEAIRE( MODELE     = __NOFLUI,
+                              CHAM_MATER = __NOMCMA ,
+                              EXCIT      = _F( CHARGE = __CHARG2 ) )
+
+#  ---------------------------------------------------------------
+#  calcul amortissement proprement dit
+  if MATR_AMOR_AJOU!=None :
+     self.DeclareOut('AMORAJ',MATR_AMOR_AJOU)
+     solveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+     mostcles={}
+     if   NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE
+     if   INFO         !=None : mostcles['INFO']          =INFO
+     if   MODE_MECA    !=None : mostcles['MODE_MECA']     =MODE_MECA
+     elif DEPL_IMPO    !=None : mostcles['CHAM_NO']       =DEPL_IMPO
+     else :
+       UTMESS('F','MATRICE0_3')
+
+     AMORAJ = CALC_MATR_AJOU(MODELE_FLUIDE    = __NOMFLU,
+                             MODELE_INTERFACE = __NOMINT,
+                             CHARGE           = __CHARGE,
+                             CHAM_MATER       = __NOMCMA,
+                             OPTION           = 'AMOR_AJOU',
+                             SOLVEUR          = solveur,
+                             POTENTIEL        = __POTEN,
+                             **mostcles)
+
+#  ---------------------------------------------------------------
+#  calcul de la rigidite ajoutee
+  if MATR_RIGI_AJOU!=None :
+     self.DeclareOut('RIGIAJ',MATR_RIGI_AJOU)
+     solveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+     mostcles={}
+     if   NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE
+     if   INFO         !=None : mostcles['INFO']          =INFO
+     if   MODE_MECA    !=None : mostcles['MODE_MECA']     =MODE_MECA
+     elif DEPL_IMPO    !=None : mostcles['CHAM_NO']       =DEPL_IMPO
+     else :
+       UTMESS('F','MATRICE0_4')
+
+     RIGIAJ = CALC_MATR_AJOU(MODELE_FLUIDE    = __NOMFLU,
+                             MODELE_INTERFACE = __NOMINT,
+                             CHARGE           = __CHARGE,
+                             CHAM_MATER       = __NOMCMA,
+                             OPTION           = 'RIGI_AJOU',
+                             SOLVEUR          = solveur,
+                             POTENTIEL        = __POTEN,
+                             **mostcles)
+
+#  ---------------------------------------------------------------
+#  boucle sur le nombre de vecteurs a projeter, commande CALC_FORC_AJOU
+  if FORC_AJOU!=None :
+     for FORCAJ in FORC_AJOU:
+       self.DeclareOut('VECTAJ',FORCAJ['VECTEUR'])
+       solveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
+       mostcles={}
+       if   NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE
+       if   MODE_MECA    !=None : mostcles['MODE_MECA']     =MODE_MECA
+       elif MODELE_GENE  !=None :
+                                  mostcles['MODELE_GENE']   =MODELE_GENE
+                                  mostcles['AVEC_MODE_STAT']=AVEC_MODE_STAT
+                                  mostcles['DIST_REFE']     =DIST_REFE
+       if   NOEUD_DOUBLE !=None : mostcles['NOEUD_DOUBLE']  =NOEUD_DOUBLE
+       if   MODE_STAT    !=None :
+         mostcles['MODE_STAT']                                =MODE_STAT
+         if FORCAJ['NOEUD']    !=None : mostcles['NOEUD']     =FORCAJ['NOEUD']
+         if FORCAJ['GROUP_NO'] !=None : mostcles['GROUP_NO']  =FORCAJ['GROUP_NO']
+       else                     :
+                                  mostcles['MONO_APPUI']    =MONO_APPUI
+
+       VECTAJ = CALC_FORC_AJOU(DIRECTION        = FORCAJ['DIRECTION'],
+                               MODELE_FLUIDE    = __NOMFLU,
+                               MODELE_INTERFACE = __NOMINT,
+                               CHARGE           = __CHARGE,
+                               CHAM_MATER       = __NOMCMA,
+                               SOLVEUR          = solveur,
+                               **mostcles)
+
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macro_matr_asse_ops.py b/Aster/Cata/cataSTA10/Macro/macro_matr_asse_ops.py
new file mode 100644 (file)
index 0000000..a308949
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macro_matr_asse_ops.py
@@ -0,0 +1,129 @@
+#@ MODIF macro_matr_asse_ops Macro  DATE 17/11/2008   AUTEUR DELMAS J.DELMAS 
+# -*- coding: iso-8859-1 -*-
+#            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.
+# ======================================================================
+
+
+
+def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE,
+                        SOLVEUR,NUME_DDL,CHARGE,CHAR_CINE,INST,INFO,**args):
+  """
+     Ecriture de la macro MACRO_MATR_ASSE
+  """
+  ier=0
+  from Utilitai.Utmess     import  UTMESS
+
+  # On met le mot cle NUME_DDL dans une variable locale pour le proteger
+  numeddl=NUME_DDL
+  info=INFO
+  # On importe les definitions des commandes a utiliser dans la macro
+  # Le nom de la variable doit etre obligatoirement le nom de la commande
+  CALC_MATR_ELEM=self.get_cmd('CALC_MATR_ELEM')
+  NUME_DDL      =self.get_cmd('NUME_DDL')
+  ASSE_MATRICE  =self.get_cmd('ASSE_MATRICE')
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Les mots cles simples sous SOLVEUR sont par defaut MULT_FRONT/METIS
+  methode=SOLVEUR['METHODE']
+  renum=SOLVEUR['RENUM']
+
+  if numeddl in self.sdprods:
+    # Si le concept numeddl est dans self.sdprods
+    # il doit etre  produit par la macro
+    # il faudra donc appeler la commande NUME_DDL
+    lnume = 1
+  else:
+    lnume = 0
+  lrigel = 0
+  lmasel = 0
+
+# decalage eventuel en premiere position dans la liste de l occurence de MATR_ASSE contenant
+# l option de rigidite
+  try :
+    for m in MATR_ASSE:
+      option=m['OPTION']
+      if option in ('RIGI_MECA','RIGI_MECA_LAGR','RIGI_THER','RIGI_ACOU') :
+         decal=m
+         MATR_ASSE.remove(decal)
+         MATR_ASSE.insert(0,decal)
+         break
+  except: pass
+
+  iocc=0
+  for m in MATR_ASSE:
+    iocc=iocc+1
+    option=m['OPTION']
+    if iocc == 1 and lnume == 1 and option not in ('RIGI_MECA','RIGI_MECA_LAGR',
+                                                   'RIGI_THER','RIGI_ACOU')      :
+      UTMESS('F','MATRICE0_9')
+
+
+    motscles={'OPTION':option}
+    if option == 'RIGI_MECA_HYST':
+       if (not lrigel):
+          UTMESS('F','MATRICE0_10')
+       motscles['RIGI_MECA']   =rigel
+    if option == 'AMOR_MECA':
+       if (not lrigel or not lmasel):
+          UTMESS('F','MATRICE0_11')
+       if CHAM_MATER != None:
+          motscles['RIGI_MECA']   =rigel
+          motscles['MASS_MECA']   =masel
+    if CHARGE     != None:
+       if option[0:9] not in ('MASS_THER','RIGI_GEOM'):
+                           motscles['CHARGE']      =CHARGE
+    if CHAM_MATER != None: motscles['CHAM_MATER']  =CHAM_MATER
+    if CARA_ELEM  != None: motscles['CARA_ELEM']   =CARA_ELEM
+    if INST       != None: motscles['INST']        =INST
+
+    try : motscles['SIEF_ELGA']   =m['SIEF_ELGA']
+    except IndexError : pass
+
+    try : motscles['MODE_FOURIER']   =m['MODE_FOURIER']
+    except IndexError : pass
+
+    try : motscles['THETA']   =m['THETA']
+    except IndexError : pass
+
+    try : motscles['PROPAGATION']   =m['PROPAGATION']
+    except IndexError : pass
+    _a=CALC_MATR_ELEM(MODELE=MODELE,**motscles)
+
+    if option == 'RIGI_MECA':
+      rigel  = _a
+      lrigel = 1
+    if option == 'MASS_MECA':
+      masel  = _a
+      lmasel = 1
+
+    if lnume and option in ('RIGI_MECA','RIGI_THER','RIGI_ACOU','RIGI_MECA_LAGR'):
+      self.DeclareOut('num',numeddl)
+      # On peut passer des mots cles egaux a None. Ils sont ignores
+      num=NUME_DDL(MATR_RIGI=_a,METHODE=methode,RENUM=renum,INFO=info)
+    else:
+      num=numeddl
+
+    self.DeclareOut('mm',m['MATRICE'])
+    motscles={'OPTION':option}
+    if CHAR_CINE != None: 
+      mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num,CHAR_CINE=CHAR_CINE)
+    else:
+      mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num)
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py
new file mode 100644 (file)
index 0000000..7e01575
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py
@@ -0,0 +1,149 @@
+#@ MODIF macro_miss_3d_ops Macro  DATE 13/05/2008   AUTEUR DEVESA G.DEVESA 
+# -*- coding: iso-8859-1 -*-
+#            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.        
+# ======================================================================
+
+
+
+def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS,
+                           UNITE_MODELE_SOL,UNITE_RESU_IMPE,
+                           PROJET,REPERTOIRE,OPTION,VERSION,
+                           UNITE_RESU_FORC,PARAMETRE,**args):
+  """
+     Ecriture de la macro MACRO_MISS_3D
+  """
+  import types
+  from Accas import _F
+  from Utilitai.Utmess import  UTMESS
+  from types import TupleType, ListType
+
+  ier=0
+  # On importe les definitions des commandes a utiliser dans la macro
+  # Le nom de la variable doit etre obligatoirement le nom de la commande
+  DEFI_FICHIER  =self.get_cmd('DEFI_FICHIER')
+  EXEC_LOGICIEL =self.get_cmd('EXEC_LOGICIEL')
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  DEFI_FICHIER(ACTION='LIBERER',UNITE=UNITE_IMPR_ASTER)
+
+  import aster 
+  loc_fic=aster.repout()
+  tv = aster.__version__.split('.')
+  if len(tv) < 3:
+      tv.extend(['x']*(3-len(tv)))
+  elif len(tv) > 3:
+      tv = tv[:3]
+  vers = '%2s.%2s.%2s' % tuple(tv)
+
+  # if vers > ' 8. 3.11':
+  #    miss3d='/aster/logiciels/MISS3D/NEW/miss3d.csh'
+  # else:
+  #    miss3d=loc_fic+'miss3d'
+     
+  miss3d=loc_fic+'miss3d'
+ 
+  # miss3d='/aster/logiciels/MISS3D/miss3d.csh-beta-modif'
+  
+  # if VERSION=='V1_2':
+  #    if PARAMETRE != None and PARAMETRE['TYPE']=='BINAIRE':
+  #       raise AsException("MACRO_MISS_3D/PARAMETRE : type incompatible avec version")
+        
+  if OPTION['TOUT']!=None:
+      MODUL2='COMPLET'
+  elif OPTION['MODULE']=='MISS_IMPE':
+      MODUL2='CALC_IMPE'
+  elif OPTION['MODULE']=='MISS_EVOL':
+      MODUL2='MISS_PTAS'
+  elif OPTION['MODULE']=='PRE_MISS':
+      MODUL2='GTASTER'
+
+  ETUDE = PROJET
+  BASE  = REPERTOIRE
+  paste = 'fort.'+str(UNITE_IMPR_ASTER)
+  popti = 'fort.'+str(UNITE_OPTI_MISS)
+  pdsol = 'fort.'+str(UNITE_MODELE_SOL)
+  primp = 'fort.'+str(UNITE_RESU_IMPE)
+  prfor = 'fort.'+str(UNITE_RESU_FORC)
+  
+  l_para = ['FREQ_MIN','FREQ_MAX','FREQ_PAS','Z0','RFIC','SURF',
+            'FICH_RESU_IMPE','FICH_RESU_FORC','TYPE','DREF','ALGO',
+            'OFFSET_MAX','OFFSET_NB','SPEC_MAX','SPEC_NB','ISSF',
+            'FICH_POST_TRAI','CONTR_NB','CONTR_LISTE','LFREQ_NB',
+            'LFREQ_LISTE','DIRE_ONDE']
+  if PARAMETRE != None and PARAMETRE['LFREQ_NB'] != None:
+    if len(PARAMETRE['LFREQ_LISTE']) != PARAMETRE['LFREQ_NB']:
+      UTMESS('F','MISS0_1')
+  if PARAMETRE != None and PARAMETRE['CONTR_NB'] != None:
+    if len(PARAMETRE['CONTR_LISTE']) != 3*PARAMETRE['CONTR_NB']:
+      UTMESS('F','MISS0_2')
+  
+  pndio = '0'
+  dpara = {}
+  for cle in l_para:
+    if cle in ('SURF', 'ISSF', ):
+      dpara[cle] = 'NON'
+    else:
+      dpara[cle] = '0'
+    if PARAMETRE != None and PARAMETRE[cle] != None:
+      if type(PARAMETRE[cle]) in (TupleType, ListType):
+        dpara[cle] = repr(' '.join([str(s) for s in PARAMETRE[cle]]))
+      else:
+        dpara[cle] = str(PARAMETRE[cle])
+      if cle in ('DIRE_ONDE', ):
+        pndio = '1'
+        dpara['SURF'] = 'NON'
+        
+  EXEC_LOGICIEL(
+                LOGICIEL=miss3d,
+                ARGUMENT=(MODUL2,
+                          ETUDE,
+                          BASE,
+                          paste,
+                          popti,
+                          pdsol,
+                          primp,
+                          VERSION,
+                          dpara['FREQ_MIN'], 
+                          dpara['FREQ_MAX'],
+                          dpara['FREQ_PAS'],
+                          dpara['Z0'], 
+                          dpara['SURF'], 
+                          dpara['RFIC'],
+                          dpara['FICH_RESU_IMPE'],
+                          dpara['FICH_RESU_FORC'],
+                          dpara['DREF'], 
+                          dpara['ALGO'],
+                          dpara['OFFSET_MAX'],
+                          dpara['OFFSET_NB'],
+                          dpara['SPEC_MAX'],
+                          dpara['SPEC_NB'],
+                          dpara['ISSF'],
+                          dpara['FICH_POST_TRAI'],
+                          dpara['CONTR_NB'],
+                          dpara['CONTR_LISTE'],
+                          dpara['LFREQ_NB'],
+                          dpara['LFREQ_LISTE'],
+                          dpara['TYPE'], 
+                          prfor,
+                          pndio,
+                          dpara['DIRE_ONDE'],
+                         ),
+                )
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macro_mode_meca_ops.py b/Aster/Cata/cataSTA10/Macro/macro_mode_meca_ops.py
new file mode 100644 (file)
index 0000000..6da742f
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macro_mode_meca_ops.py
@@ -0,0 +1,135 @@
+#@ MODIF macro_mode_meca_ops Macro  DATE 06/07/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            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.        
+# ======================================================================
+
+
+
+def macro_mode_meca_ops(self,MATR_A,MATR_B,INFO,METHODE,OPTION,CALC_FREQ,
+                        VERI_MODE,NORM_MODE,FILTRE_MODE,IMPRESSION,**args):
+  """
+     Ecriture de la macro MACRO_MODE_MECA
+  """
+  from Accas import _F
+  ier=0
+    
+  #  on protege le contenu du mot cle NORM_MODE pour eviter les confusions
+  #  avec la commande du meme nom
+  
+  normode=NORM_MODE
+  
+  # On importe les definitions des commandes a utiliser dans la macro
+  MODE_ITER_SIMULT  =self.get_cmd('MODE_ITER_SIMULT')
+  NORM_MODE         =self.get_cmd('NORM_MODE')
+  IMPR_RESU         =self.get_cmd('IMPR_RESU')
+  EXTR_MODE         =self.get_cmd('EXTR_MODE')
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  nompro=None
+  iocc=0
+  if CALC_FREQ['FREQ']:
+     nnfreq=len(CALC_FREQ['FREQ'])
+  else:
+     lborne=[]
+     nnfreq= CALC_FREQ['NB_BLOC_FREQ']+1
+     zlborn=(CALC_FREQ['FREQ_MAX']-CALC_FREQ['FREQ_MIN'])/(nnfreq-1)
+     for i in range(0,nnfreq):
+         lborne.append(CALC_FREQ['FREQ_MIN']+i*zlborn)
+
+  motscles={}
+  motscles['FILTRE_MODE']=[]
+  for i in range(0,nnfreq-1):
+     motscit={}
+     motscfa={}
+     if CALC_FREQ['DIM_SOUS_ESPACE']: motscfa['DIM_SOUS_ESPACE']=CALC_FREQ['DIM_SOUS_ESPACE']
+     if CALC_FREQ['COEF_DIM_ESPACE']: motscfa['COEF_DIM_ESPACE']=CALC_FREQ['COEF_DIM_ESPACE']
+     if CALC_FREQ['FREQ']:
+        motscfa['FREQ']=(CALC_FREQ['FREQ'][i],CALC_FREQ['FREQ'][i+1])
+     else:
+        motscfa['FREQ']=(lborne[i],lborne[i+1])
+     motscit['CALC_FREQ']=_F(OPTION          ='BANDE',
+                             SEUIL_FREQ      =CALC_FREQ['SEUIL_FREQ'],
+                             NPREC_SOLVEUR   =CALC_FREQ['NPREC_SOLVEUR'],
+                             NMAX_ITER_SHIFT =CALC_FREQ['NMAX_ITER_SHIFT'],
+                             PREC_SHIFT      =CALC_FREQ['PREC_SHIFT'],
+                             **motscfa)
+     motscit['VERI_MODE']=_F(STOP_ERREUR=VERI_MODE['STOP_ERREUR'],
+                             SEUIL      =VERI_MODE['SEUIL'],
+                             STURM      =VERI_MODE['STURM'],
+                             PREC_SHIFT =VERI_MODE['PREC_SHIFT'])
+     motscit['STOP_FREQ_VIDE']=CALC_FREQ['STOP_FREQ_VIDE']
+
+     if METHODE=='TRI_DIAG':
+        if args.has_key('NMAX_ITER_ORTHO'):
+           motscit['NMAX_ITER_ORTHO'] =args['NMAX_ITER_ORTHO']
+        if args.has_key('PREC_ORTHO'):
+           motscit['PREC_ORTHO']      =args['PREC_ORTHO']
+        if args.has_key('PREC_LANCZOS'):
+           motscit['PREC_LANCZOS']    =args['PREC_LANCZOS']
+        if args.has_key('MAX_ITER_QR'):
+           motscit['NMAX_ITER_QR']    =args['NMAX_ITER_QR']
+     elif METHODE=='JACOBI':
+        if args.has_key('NMAX_ITER_BATHE'):
+           motscit['NMAX_ITER_BATHE'] =args['NMAX_ITER_BATHE']
+        if args.has_key('PREC_BATHE'):
+           motscit['PREC_BATHE']      =args['PREC_BATHE']
+        if args.has_key('NMAX_ITER_JACOBI'):
+           motscit['NMAX_ITER_JACOBI']=args['NMAX_ITER_JACOBI']
+        if args.has_key('PREC_JACOBI'):
+           motscit['PREC_JACOBI']     =args['PREC_JACOBI']
+     elif METHODE=='SORENSEN':
+        if args.has_key('NMAX_ITER_SOREN'):
+           motscit['NMAX_ITER_SOREN'] =args['NMAX_ITER_SOREN']
+        if args.has_key('PARA_ORTHO_SOREN'):
+           motscit['PARA_ORTHO_SOREN']=args['PARA_ORTHO_SOREN']
+        if args.has_key('PREC_SOREN'):
+           motscit['PREC_SOREN']      =args['PREC_SOREN']
+
+     __nomre0=MODE_ITER_SIMULT(MATR_A  =MATR_A,
+                                  MATR_B  =MATR_B,
+                                  INFO    =INFO,
+                                  METHODE =METHODE,
+                                  OPTION  =OPTION,
+                                  **motscit)
+
+     __nomre0=NORM_MODE(reuse     =__nomre0,
+                        MODE      =__nomre0,
+                        NORME     =normode['NORME'],
+                        INFO      =normode['INFO'],)
+
+     if IMPRESSION['TOUT_PARA']=='OUI':
+        IMPR_RESU(RESU=_F(RESULTAT=__nomre0,
+                          TOUT_ORDRE='OUI',
+                          TOUT_CHAM ='NON',
+                          TOUT_PARA ='OUI',) )
+
+     if FILTRE_MODE :
+        motscles['FILTRE_MODE'].append(_F(MODE      =__nomre0,
+                                          CRIT_EXTR =FILTRE_MODE['CRIT_EXTR'],
+                                          SEUIL     =FILTRE_MODE['SEUIL'], ))
+     else:
+        motscles['FILTRE_MODE'].append(_F(MODE      =__nomre0,
+                                          TOUT_ORDRE='OUI',) )
+     
+
+  motscles['IMPRESSION']=_F(CUMUL    =IMPRESSION['CUMUL'],
+                            CRIT_EXTR=IMPRESSION['CRIT_EXTR'],)
+  self.DeclareOut('nomres',self.sd)
+  nomres=EXTR_MODE(**motscles)
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/macro_proj_base_ops.py b/Aster/Cata/cataSTA10/Macro/macro_proj_base_ops.py
new file mode 100644 (file)
index 0000000..89ffe2c
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/macro_proj_base_ops.py
@@ -0,0 +1,59 @@
+#@ MODIF macro_proj_base_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- coding: iso-8859-1 -*-
+#            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.        
+# ======================================================================
+
+
+
+def macro_proj_base_ops(self,BASE,NB_VECT,MATR_ASSE_GENE,VECT_ASSE_GENE,PROFIL,**args):
+  """
+     Ecriture de la macro MACRO_PROJ_BASE
+  """
+  ier=0
+  from Utilitai.Utmess     import  UTMESS
+  # On importe les definitions des commandes a utiliser dans la macro
+  NUME_DDL_GENE  =self.get_cmd('NUME_DDL_GENE')
+  PROJ_MATR_BASE =self.get_cmd('PROJ_MATR_BASE')
+  PROJ_VECT_BASE =self.get_cmd('PROJ_VECT_BASE')
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  _num=NUME_DDL_GENE(BASE=BASE,NB_VECT=NB_VECT,STOCKAGE=PROFIL)
+  if MATR_ASSE_GENE:
+    for m in MATR_ASSE_GENE:
+      motscles={}
+      if   m['MATR_ASSE']     :  motscles['MATR_ASSE']     =m['MATR_ASSE']
+      elif m['MATR_ASSE_GENE']:  motscles['MATR_ASSE_GENE']=m['MATR_ASSE_GENE']
+      else:
+          UTMESS('F','MODAL0_1')
+      self.DeclareOut('mm',m['MATRICE'])
+      mm=PROJ_MATR_BASE(BASE=BASE,NUME_DDL_GENE=_num,**motscles)
+
+  if VECT_ASSE_GENE:
+    _num=NUME_DDL_GENE(BASE=BASE,NB_VECT=NB_VECT,STOCKAGE=PROFIL)
+    for v in VECT_ASSE_GENE:
+      motscles={}
+      if   v['VECT_ASSE']     :  motscles['VECT_ASSE']     =v['VECT_ASSE']
+      elif v['VECT_ASSE_GENE']:  motscles['VECT_ASSE_GENE']=v['VECT_ASSE_GENE']
+      else:
+          UTMESS('F','MODAL0_1')
+      motscles['TYPE_VECT']=v['TYPE_VECT']
+      self.DeclareOut('vv',v['VECTEUR'])
+      vv=PROJ_VECT_BASE(BASE=BASE,NUME_DDL_GENE=_num,**motscles)
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/observation_ops.py b/Aster/Cata/cataSTA10/Macro/observation_ops.py
new file mode 100644 (file)
index 0000000..4efc403
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/observation_ops.py
@@ -0,0 +1,619 @@
+#@ MODIF observation_ops Macro  DATE 16/11/2009   AUTEUR COURTOIS M.COURTOIS 
+
+#            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.
+# ======================================================================
+
+
+
+
+
+def observation_ops(self,
+                    PROJECTION   = None,
+                    MODELE_1     = None,
+                    MODELE_2     = None,
+                    RESULTAT     = None,
+                    NUME_DDL     = None,
+                    MODI_REPERE  = None,
+                    NOM_CHAM     = None,
+                    FILTRE       = None,
+                    **args):
+
+    """
+     Ecriture de la macro MACRO_OBSERVATION
+    """
+    ier=0
+
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    # on transforme le mc MODI_REPERE pour ne pas le confondre avec l'operateur
+    # du meme nom
+    MODIF_REPERE = MODI_REPERE
+
+    # importation de commandes
+    import aster
+    import Numeric
+    from Accas import _F
+    from Utilitai.UniteAster import UniteAster
+    from Utilitai.Utmess     import UTMESS
+    from Cata.cata import mode_meca, dyna_harmo, evol_elas
+    MODI_REPERE = self.get_cmd('MODI_REPERE')
+    PROJ_CHAMP  = self.get_cmd('PROJ_CHAMP')
+    CREA_CHAMP  = self.get_cmd('CREA_CHAMP')
+    CREA_RESU   = self.get_cmd('CREA_RESU')
+    DEFI_BASE_MODALE = self.get_cmd('DEFI_BASE_MODALE')
+    DETRUIRE = self.get_cmd('DETRUIRE')
+
+    # dans **args, on range les options de PROJ_CHAMP facultatives, et dont on
+    # ne sert pas par la suite
+    mcfact = args
+
+    # La macro n'est pas encoire capable de traiter les resultats dyna_harmo
+    if isinstance(RESULTAT, dyna_harmo):
+        UTMESS('E','UTILITAI7_8')
+
+
+#***********************************************
+#  PHASE DE PROJECTION
+#***********************************************
+
+    if PROJECTION == 'OUI' :
+        __proj=PROJ_CHAMP(RESULTAT = RESULTAT,
+                          MODELE_1 = MODELE_1,
+                          MODELE_2 = MODELE_2,
+                          NUME_DDL = NUME_DDL,
+                          NOM_CHAM = NOM_CHAM,
+                          **mcfact
+                         );
+
+    else :
+        __proj = RESULTAT
+
+
+#***********************************************
+#  PHASE DE CHANGEMENT DE REPERE
+#***********************************************
+# Le changement de repere se fait dans les routines exterieures crea_normale et crea_repere
+
+# On range dans le mcfact MODI_REPERE une liste de modifications. ex :
+#     MODI_REPERE = ( _F( GROUP_NO  = toto,
+#                         REPERE    = 'NORMALE' ),
+#                         CONDITION = (1.0,0.0,0.0),
+#                         NOM_PARA  = 'X')
+#                     _F( NOEUD   = ('a','z','e'...),
+#                         REPERE  = 'CYLINDRIQUE',
+#                         ORIGINE = (0.,0.,0.),
+#                         AXE_Z   = (0.,1.,0.), ),
+#                     _F( GROUP_NO = titi,
+#                         REPERE   = 'UTILISATEUR',
+#                         ANGL_NAUT = (alpha, beta, gamma), )
+#                    )
+
+
+    # cham_mater et cara_elem pour le resultat a projeter
+    jdc = CONTEXT.get_current_step().jdc
+    iret,ibid,nom_cara_elem = aster.dismoi('F','CARA_ELEM',RESULTAT.nom,'RESULTAT')
+    if len(nom_cara_elem) > 0    :
+        assert nom_cara_elem.strip() != "#PLUSIEURS" , nom_cara_elem
+        if nom_cara_elem.strip() == "#AUCUN" :
+            cara_elem = None
+        else :
+            cara_elem = self.get_concept(nom_cara_elem.strip())
+    else:
+        cara_elem = None
+
+    iret,ibid,nom_cham_mater = aster.dismoi('F','CHAM_MATER',RESULTAT.nom,'RESULTAT')
+    if len(nom_cham_mater) > 0 :
+        assert nom_cham_mater.strip() != "#PLUSIEURS" , nom_cham_mater
+        if nom_cham_mater.strip() == "#AUCUN" :
+            cham_mater = None
+        else :
+            cham_mater = self.get_concept(nom_cham_mater.strip())
+    else:
+        cham_mater = None
+
+    # recuperation du maillage associe au modele experimental
+    _maillag = aster.getvectjev( MODELE_2.nom.ljust(8) + '.MODELE    .LGRF' )
+    maillage = _maillag[0].strip()
+    jdc = CONTEXT.get_current_step().jdc
+    mayaexp = self.get_concept(maillage)
+
+    _maillag = aster.getvectjev( MODELE_1.nom.ljust(8) + '.MODELE    .LGRF' )
+    maillage = _maillag[0].strip()
+    jdc = CONTEXT.get_current_step().jdc
+    mayanum = self.get_concept(maillage)
+
+
+    if MODIF_REPERE != None :
+        for modi_rep in MODIF_REPERE :
+            type_cham = modi_rep['TYPE_CHAM']
+            nom_cmp = modi_rep['NOM_CMP']
+            mcfact1 = { 'NOM_CMP'   : nom_cmp,
+                        'TYPE_CHAM' : type_cham,
+                        'NOM_CHAM'  : NOM_CHAM }
+
+            mcfact2 = { }
+            modi_rep = modi_rep.val
+
+            if modi_rep['REPERE'] == 'NORMALE' :
+                # Cas ou l'utilisateur choisit de creer les reperes locaux
+                # selon la normale. On fait un changement de repere local
+                # par noeud
+                for option in ['VECT_X','VECT_Y','CONDITION_X','CONDITION_Y'] :
+                    if modi_rep.has_key(option):
+                        vect = { option : modi_rep[option] }
+                if len(vect) != 1 :
+                    UTMESS('E','UTILITAI7_9')
+
+                chnorm = crea_normale(self, MODELE_1, MODELE_2, NUME_DDL,
+                                                      cham_mater, cara_elem)
+                chnormx = chnorm.EXTR_COMP('DX',[],1)
+                ind_noeuds = chnormx.noeud
+                nom_allno = [mayaexp.NOMNOE.get()[k-1] for k in ind_noeuds]
+
+                # on met les noeuds conernes sous forme de liste et on va
+                # chercher les noeuds des mailles pour 'MAILLE' et 'GROUP_MA'
+                for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA','TOUT']:
+                    if modi_rep.has_key(typ) :
+                        list_no_exp = find_no(mayaexp, {typ : modi_rep[typ]})
+
+                # boucle sur les noeuds pour modifier les reperes.
+                __bid = [None]*(len(list_no_exp) + 1)
+                __bid[0] = __proj
+                k = 0
+                for nomnoe in list_no_exp:
+                    ind_no = nom_allno.index(nomnoe)
+                    angl_naut = crea_repere(chnorm, ind_no, vect)
+
+                    mcfact1.update({ 'NOEUD'     : nomnoe })
+                    mcfact2.update({ 'REPERE'    : 'UTILISATEUR',
+                                     'ANGL_NAUT' : angl_naut})
+                    args = {'MODI_CHAM'   : mcfact1,
+                            'DEFI_REPERE' : mcfact2 }
+                    __bid[k+1] = MODI_REPERE( RESULTAT    = __bid[k],
+                                              TOUT_ORDRE  = 'OUI',
+                                              CRITERE     = 'RELATIF',
+                                              **args)
+                    k = k + 1
+
+                __proj = __bid[-1:][0]
+
+
+            else:
+                for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA','TOUT']:
+                    if modi_rep.has_key(typ) :
+                        mcfact1.update({typ : modi_rep[typ]})
+                if modi_rep['REPERE'] == 'CYLINDRIQUE' :
+                    origine = modi_rep['ORIGINE']
+                    axe_z   = modi_rep['AXE_Z']
+                    mcfact2.update({ 'REPERE'  : 'CYLINDRIQUE',
+                                     'ORIGINE' : origine,
+                                     'AXE_Z'   : axe_z })
+
+                elif modi_rep['REPERE'] == 'UTILISATEUR' :
+                    angl_naut = modi_rep['ANGL_NAUT']
+                    mcfact2.update({ 'REPERE'    : 'UTILISATEUR',
+                                     'ANGL_NAUT' : angl_naut })
+                args = {'MODI_CHAM'   : mcfact1,
+                        'DEFI_REPERE' : mcfact2 }
+                __bid = MODI_REPERE( RESULTAT    = __proj,
+                                     CRITERE     = 'RELATIF',
+                                     **args)
+                __proj = __bid
+
+
+    else: # pas de modif de repere demandee
+        pass
+
+
+#*************************************************
+# Phase de selection des DDL de mesure
+#*************************************************
+    # les numeros d'ordre de la sd_resu
+    num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']
+    __cham = [None]*len(num_ordr)
+    list_cham = []
+
+    if FILTRE != None:
+        nb_fi = len(FILTRE)
+        liste = []
+
+        for ind in num_ordr:
+            filtres = []
+            __chamex = CREA_CHAMP(TYPE_CHAM  = 'NOEU_DEPL_R',
+                                  OPERATION  = 'EXTR',
+                                  RESULTAT   = __proj,
+                                  NOM_CHAM   = 'DEPL',
+                                  NUME_ORDRE = ind,);
+
+            for filtre in FILTRE :
+                mcfact1 = {}
+                filtre = filtre.val
+                for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA']:
+                    if filtre.has_key(typ) :
+                        mcfact1.update({typ : filtre[typ]})
+                mcfact1.update({'NOM_CMP' : filtre['DDL_ACTIF'],
+                                'CHAM_GD' : __chamex })
+                filtres.append(mcfact1)
+
+            __cham[ind-1] = CREA_CHAMP(TYPE_CHAM = 'NOEU_DEPL_R',
+                                       OPERATION = 'ASSE',
+                                       MODELE    = MODELE_2,
+                                       PROL_ZERO = 'NON',
+                                       ASSE      = filtres
+                                       );
+
+
+            mcfact2 = {'CHAM_GD'    : __cham[ind-1],
+                       'MODELE'     : MODELE_2,
+                       'NOM_CAS'    : str(ind)}
+            if cham_mater is not None:
+                mcfact2['CHAM_MATER'] = cham_mater
+            if cara_elem is not None:
+                mcfact2['CARA_ELEM'] = cara_elem
+
+            liste.append(mcfact2)
+            DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1)
+
+
+        self.DeclareOut( 'RESU', self.sd)
+        if   isinstance( RESULTAT, evol_elas):
+            # Fabrication de l'evol_elas (cas le plus simple)
+            RESU = CREA_RESU( OPERATION = 'AFFE',
+                              TYPE_RESU = 'EVOL_ELAS',
+                              NOM_CHAM  = 'DEPL',
+                              AFFE      = liste,
+                             );
+
+        if isinstance( RESULTAT, mode_meca):
+            # Fabrication de la base modale resultat. On doit tricher un peu (encore!!), en
+            # faisant un defi_base_modale dans lequel on met zero modes du concept RESULTAT
+            # TODO : permettre la creation directement d'un resu de type mode_meca avec
+            # CREA_RESU
+            _RESBID = CREA_RESU( OPERATION = 'AFFE',
+                                TYPE_RESU = 'MULT_ELAS',
+                                NOM_CHAM  = 'DEPL',
+                                AFFE      = liste,
+                               );
+
+            RESU = DEFI_BASE_MODALE( RITZ = (
+                                             _F( MODE_MECA = RESULTAT,
+                                                 NMAX_MODE = 0,),
+                                             _F( MODE_INTF = _RESBID),
+                                            ),
+                                     NUME_REF=NUME_DDL
+                                   );
+
+
+        elif isinstance( RESULTAT, dyna_harmo):
+            # TODO : a faire
+            pass
+
+
+    return ier
+
+
+
+
+#**********************************************
+# RECUPERATION DES NORMALES
+#**********************************************
+
+def crea_normale(self, modele_1, modele_2,
+                 nume_ddl, cham_mater=None, cara_elem=None):
+    """Cree un champ de vecteurs normaux sur le maillage experimental, par
+       projection du champ de normales cree sur le maillage numerique
+    """
+    import Numeric
+    PROJ_CHAMP  = self.get_cmd('PROJ_CHAMP')
+    CREA_CHAMP  = self.get_cmd('CREA_CHAMP')
+    CREA_RESU   = self.get_cmd('CREA_RESU')
+    DEFI_GROUP  = self.get_cmd('DEFI_GROUP')
+    import aster
+    from Accas import _F
+    # recherche du maillage associe au modele numerique
+    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)
+
+
+    DEFI_GROUP( reuse = mayanum,
+                MAILLAGE      = mayanum,
+                CREA_GROUP_MA = _F( NOM  = '&&TOUMAI',
+                                    TOUT = 'OUI' )
+               );
+
+    __norm1 = CREA_CHAMP( MODELE    = modele_1,
+                          OPERATION = 'NORMALE',
+                          TYPE_CHAM = 'NOEU_GEOM_R',
+                          GROUP_MA  = '&&TOUMAI',
+                         );
+
+    DEFI_GROUP( reuse = mayanum,
+                MAILLAGE      = mayanum,
+                DETR_GROUP_MA = _F( NOM  = '&&TOUMAI' )
+               );
+
+
+    __norm2 = CREA_CHAMP( OPERATION = 'ASSE',
+                          TYPE_CHAM = 'NOEU_DEPL_R',
+                          MODELE    = modele_1,
+                          ASSE      = _F( TOUT='OUI',
+                                          CHAM_GD=__norm1,
+                                          NOM_CMP=('X','Y','Z'),
+                                          NOM_CMP_RESU=('DX','DY','DZ')
+                                         )
+                         );
+
+    affe_dct = {'CHAM_GD' : __norm2,
+                'INST' : 1,
+                'MODELE' : modele_1}
+    if cham_mater is not None:
+        affe_dct["CHAM_MATER"] = cham_mater
+    if cara_elem is not None:
+        affe_dct["CARA_ELEM"] = cara_elem
+
+    __norm3 = CREA_RESU( OPERATION = 'AFFE',
+                         TYPE_RESU = 'EVOL_ELAS',
+                         NOM_CHAM  = 'DEPL',
+                         AFFE      = _F(**affe_dct)
+                       );
+
+
+    __norm4 = PROJ_CHAMP( RESULTAT   = __norm3,
+                          MODELE_1   = modele_1,
+                          MODELE_2   = modele_2,
+                          NOM_CHAM   = 'DEPL',
+                          TOUT_ORDRE = 'OUI',
+                          NUME_DDL   = nume_ddl,
+                          );
+
+    # __norm5 : toutes les normales au maillage au niveau des capteurs
+    __norm5 = CREA_CHAMP( RESULTAT   = __norm4,
+                          OPERATION  = 'EXTR',
+                          NUME_ORDRE = 1,
+                          NOM_CHAM   = 'DEPL',
+                          TYPE_CHAM  = 'NOEU_DEPL_R',
+                          );
+
+
+    return __norm5
+
+
+#**********************************************************************
+# Calcul des angles nautiques pour le repere local associe a la normale
+#**********************************************************************
+
+def crea_repere(chnorm, ind_no, vect):
+
+    """Creation d'un repere orthonormal a partir du vecteur normale et
+       d'une equation supplementaire donnee par l'utilisateur sous forme
+       de trois parametres et du vecteur de base concerne.
+    """
+
+    import Numeric
+
+    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
+    chnormx = chnorm.EXTR_COMP('DX',[],1)
+    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]]
+
+    # 2.1) soit l'utilisateur a donne un deuxieme vecteur explicitement
+    # (option VECT_X Ou VECT_Y). Dans ce cas la, le 3e est le produit
+    # vectoriel des deux premiers.
+    if nom_para == 'VECT_X' :
+        vect1 = Numeric.array(list(vect[nom_para])) # vect x du reploc
+        vect2 = cross_product(normale,vect1)
+        reploc = Numeric.array([vect1.tolist(), vect2.tolist(), normale])
+        reploc = Numeric.transpose(reploc)
+
+    elif nom_para == 'VECT_Y' :
+        vect2 = Numeric.array(list(vect[nom_para])) # vect y du reploc
+        vect1 = cross_product(vect2, normale)
+        reploc = Numeric.array([vect1.tolist(), vect2.tolist(), normale])
+        reploc = Numeric.transpose(reploc)
+
+    # 2.2) TODO : plutot que de donner explicitement un vecteur du repere
+    # local avec VECT_X/Y, on devrait aussi pouvoir donner une condition
+    # sous forme d'une equation sur un de ces vecteurs. Par exemple,
+    # CONDITION_X = (0.,1.,0.) signifierait que le vecteur X1 verifie
+    #x(X1) + y(X1) + z(X1) = 0
+    elif nom_para == 'CONDITION_X':
+        pass
+    elif nom_para == 'CONDITION_Y':
+        pass
+
+    # 3) Calcul de l'angle nautique associe au repere local
+    angl_naut = anglnaut(reploc)
+
+    return angl_naut
+
+#*****************************************************************************
+# Aller chercher une liste de noeuds pour un mot cle 'NOEUD', 'GROUP_NO'
+# 'MAILLE' ou 'GROUP_MA'
+#*****************************************************************************
+
+def find_no(maya,mcsimp):
+    """ Si on demande une liste de noeuds, c'est simple, on retourne les noeuds
+        Si on demande une liste de groupes de noeuds, on va chercher les noeuds
+          dans ces groupes, en faisant attention a ne pas etre redondant
+        Si on demande un liste de mailles, on va chercher dans le .CONNEX
+          du maillage les indices, puis les noms des noeuds concernes
+        etc...
+    """
+
+    import Numeric
+
+    list_no = []
+    list_ma = []
+    if mcsimp.has_key('GROUP_NO') and type(mcsimp['GROUP_NO']) != tuple :
+        mcsimp['GROUP_NO'] = [mcsimp['GROUP_NO']]
+    if mcsimp.has_key('GROUP_MA') and type(mcsimp['GROUP_MA']) != tuple :
+        mcsimp['GROUP_MA'] = [mcsimp['GROUP_MA']]
+
+    if mcsimp.has_key('NOEUD') :
+        list_no = list(mcsimp['NOEUD'])
+    elif mcsimp.has_key('GROUP_NO') :
+        for group in mcsimp['GROUP_NO'] :
+            list_ind_no = list(Numeric.array(maya.GROUPENO.get()[group.ljust(8)])-1)
+            for ind_no in list_ind_no :
+                nomnoe = maya.NOMNOE.get()[ind_no]
+                if nomnoe not in list_no :
+                    list_no.append(nomnoe)
+    elif mcsimp.has_key('MAILLE') :
+        for mail in mcsimp['MAILLE'] :
+            ind_ma = maya.NOMMAI.get().index(mail.ljust(8))
+            for ind_no in mayaexp.CONNEX[ind_ma] :
+                nomnoe = mayaexp.NOMNOE.get()[ind_no]
+                if nomnoe not in list_no :
+                    list_no.append(nomnoe)
+    elif mcsimp.has_key('GROUP_MA') :
+        for group in mcsimp['GROUP_MA'] :
+            list_ma.append(maya.GROUPEMA.get()[group.ljust(8)])
+        for mail in list_ma :
+            tmp = list(maya.NOMMAI.get())
+            ind_ma = tmp.index(mail.ljust(8))
+            for ind_no in maya.CONNEX[ind_ma] :
+                nomnoe = maya.NOMNOE.get()[ind_no]
+                if nomnoe not in list_no :
+                    list_no.append(nomnoe)
+
+
+    return list_no
+
+
+#************************************************************************************
+# Quelques utilitaires de calculs d'angles nautiques (viennent de zmat004a.comm
+#************************************************************************************
+
+
+def cross_product(a, b):
+    """Return the cross product of two vectors.
+    For a dimension of 2,
+    the z-component of the equivalent three-dimensional cross product is
+    returned.
+
+    For backward compatibility with Numeric <= 23
+    """
+    from Numeric import asarray, array
+    a = asarray(a)
+    b = asarray(b)
+    dim =  a.shape[0]
+    assert 2<= dim <=3 and dim == b.shape[0], "incompatible dimensions for cross product"
+    if dim == 2:
+        result = a[0]*b[1] - a[1]*b[0]
+    elif dim == 3:
+        x = a[1]*b[2] - a[2]*b[1]
+        y = a[2]*b[0] - a[0]*b[2]
+        z = a[0]*b[1] - a[1]*b[0]
+        result = array([x,y,z])
+    return result
+
+def norm(x):
+    """Calcul de la norme euclidienne d'un vecteur"""
+    import Numeric
+    tmp = Numeric.sqrt(Numeric.dot(x,x))
+    return tmp
+
+def anglnaut(P):
+
+
+    """Calcule les angles nautiques correspondant a un repere local
+       NB : seuls les deux premiers vecteurs de P (les images respectives
+       de X et Y) sont utiles pour le calcul des angles
+    """
+
+    import copy
+    import Numeric
+    # expression des coordonnees globales des 3 vecteurs de base locale
+    x = Numeric.array([1.,0.,0.])
+    y = Numeric.array([0.,1.,0.])
+    z = Numeric.array([0.,0.,1.])
+
+    xg = P[:,0]
+    yg = P[:,1]
+    zg = P[:,2]
+
+    # calcul des angles nautiques
+    x1=copy.copy(xg)
+    # x1 projection de xg sur la plan xy, non norme
+    x1[2]=0.
+    # produit scalaire X xg
+    COSA=x1[0]/norm(x1)
+    #produit vectoriel X xg
+    SINA=x1[1]/norm(x1)
+    ar=Numeric.arctan2(SINA,COSA)
+    alpha=ar*180/Numeric.pi
+
+    COSB=norm(x1)
+    SINB=-xg[2]
+    beta=Numeric.arctan2(SINB,COSB)*180/Numeric.pi
+
+    P2=Numeric.zeros((3,3),Numeric.Float)
+    P2[0,0]=Numeric.cos(ar)
+    P2[1,0]=Numeric.sin(ar)
+    P2[1,1]=Numeric.cos(ar)
+    P2[0,1]=-Numeric.sin(ar)
+    y1=Numeric.dot(P2,y)
+    y1n=y1/norm(y1)
+
+    # calcul de gamma
+    COSG=Numeric.dot(y1n,yg)
+    SING=Numeric.dot(xg,cross_product(y1n,yg))
+    gamma=Numeric.arctan2(SING,COSG)*180/Numeric.pi
+
+    return alpha,beta,gamma
+
+
+##  NB : Equations de passage : un vecteur de coordonnees globales (X,Y,Z) a pour
+##  coordonnees locales (X1,Y1,Z1) avec
+##  _                  _  _                   _  _                   _  _ _     _  _
+## | 1     0      0     || cos(B) 0    -sin(B) ||  cos(A)  sin(A)   0 || X |   | X1 |
+## | 0   cos(G)  sin(G) ||   0    1      0     || -sin(A)  cos(A)   0 || Y | = | Y1 |
+## |_0  -sin(G)  cos(G)_||_sin(B) 0     cos(B)_||_   0       0      1_||_Z_|   |_Z1_|
+##
+##  A (alpha), B(beta), gamma (G) sont les angle nautiques que l'on donne habituellemet
+##  dans les MODI_REPERE. Les equations a resoudre sont les suivantes :
+##       cos(A)cos(B)                      = reploc[0][0]
+##      -cos(G)sin(A) + sin(G)cos(A)sin(B) = reploc[0][1]
+##       sin(A)sin(G) + cos(A)sin(B)cos(G) = reploc[0][2]
+##
+##       sin(A)cos(B)                      = reploc[1][0]
+##       cos(A)cos(G) + sin(A)sin(B)sin(G) = reploc[1][1]
+##      -cos(A)sin(G) + sin(A)sin(B)cos(G) = reploc[1][2]
+##
+##                                 -sin(B) = reploc[2][0]
+##                            cos(B)sin(G) = reploc[2][1]
+##                            cos(B)cos(G) = reploc[2][2]
+
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/post_dyna_alea_ops.py b/Aster/Cata/cataSTA10/Macro/post_dyna_alea_ops.py
new file mode 100644 (file)
index 0000000..1ce2ed7
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/post_dyna_alea_ops.py
@@ -0,0 +1,431 @@
+#@ MODIF post_dyna_alea_ops Macro  DATE 16/11/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.
+# ======================================================================
+
+import random
+import Numeric
+from types import ListType, TupleType
+from math  import pi,sqrt,log,exp
+
+EnumTypes = (ListType, TupleType)
+
+
+def post_dyna_alea_ops(self,INTE_SPEC, FRAGILITE,TITRE,INFO,**args):
+   import aster
+   from Accas                 import _F
+   from Utilitai.Utmess       import UTMESS
+   from Cata_Utils.t_fonction import t_fonction
+   from Utilitai.Table        import Table
+
+   commande='POST_DYNA_ALEA'
+
+   ier = 0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # Le concept sortant (de type table_sdaster ou dérivé) est tab
+   self.DeclareOut('tabout', self.sd)
+
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   CREA_TABLE    = self.get_cmd('CREA_TABLE')
+   CALC_TABLE    = self.get_cmd('CALC_TABLE')
+   IMPR_TABLE    = self.get_cmd('IMPR_TABLE')
+   RECU_FONCTION = self.get_cmd('RECU_FONCTION')
+   IMPR_FONCTION = self.get_cmd('IMPR_FONCTION')
+   DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
+   DEFI_FONCTION  = self.get_cmd('DEFI_FONCTION')
+   CALC_FONCTION  = self.get_cmd('CALC_FONCTION')
+
+
+#  ------------------------------------------------------------------
+#---------algorithme d'optimisation pour le  maximum de vraisemblance
+   def vrais(x):
+      am=x[0]
+      beta=x[1]
+#       assert am >0.000, 'optimize.py: beta negatif'
+#       assert am >0.000, 'optimize.py: am negatif'
+      if am <=0.000:
+          am=0.01
+      if beta <=0.000:
+          beta=0.001          
+      res=1.0
+      for k in range(Nbval):
+         ai=liste_indic[k]
+         xi=float(liste_def[k])
+         val=log(ai/am)
+         pfa=normcdf(val/beta)
+         f0=pfa**xi*(1.-pfa)**(1-xi)
+         res=res*f0
+      return -res
+
+   def boot_vrais(x):
+      am=x[0]
+      beta=x[1]
+      res=1.0
+      for k in range(Nbval):
+         ai=liste_indic[list_rand[k]]
+         xi=float(liste_def[list_rand[k]])
+         val=log(ai/am)
+         pfa=normcdf(val/beta)
+         f0=pfa**xi*(1.-pfa)**(1-xi)
+         res=res*f0
+      return -res
+
+#  ------------------------------------------------------------------
+#  OPTION FRAGILITE
+# ------------------------------------------------------------------
+   if FRAGILITE !=None :
+      from Utilitai.optimize   import fmin
+      from Utilitai.stats   import normcdf
+
+      if FRAGILITE['LIST_PARA'] != None :
+         liste_a = FRAGILITE['LIST_PARA'].VALE.get()
+      elif FRAGILITE['VALE'] != None :
+         liste_a =FRAGILITE['VALE']
+
+
+      Nba=len(liste_a)
+      lpfa=[]
+      tab2 = FRAGILITE['TABL_RESU'].EXTR_TABLE()
+      dicta = tab2.values()
+
+      if dicta.has_key('DEFA') :
+         liste_def = dicta['DEFA']
+      else:
+         UTMESS('F','TABLE0_1',valk=('DEFA'))
+      if dicta.has_key('PARA_NOCI') :
+        liste_indic = dicta['PARA_NOCI']
+      else:
+        UTMESS('F','TABLE0_1',valk=('PARA_NOCI'))
+
+      Nbval=len(liste_indic)
+
+      test1 = Numeric.equal(None,liste_indic)
+      test2 = Numeric.equal(None,liste_def)
+      if test1 >=1 or test2 >=1:
+         UTMESS('F','TABLE0_15')
+
+      # estimation paramètres
+      x0 = [FRAGILITE['AM_INI'],FRAGILITE['BETA_INI']]
+      xopt = fmin(vrais,x0)
+
+      texte='PARAMETRES Am, beta ESTIMES : '+str(xopt)+'\n'
+      aster.affiche('MESSAGE',texte)      #print 'parametres Am, beta estimes: ', xopt
+
+      #courbe de fragilité
+      vec_a=Numeric.array(liste_a)
+      vecval=(Numeric.log(vec_a/xopt[0]))/xopt[1]
+      for m in range(Nba):
+         lpfa.append(normcdf(vecval[m]))
+
+      # table sortie
+
+      mcfact=[]
+      if  TITRE !=None :
+           mcfact.append(_F(PARA= 'TITRE' , LISTE_K= TITRE  ))
+
+      mcfact.append(_F(PARA= 'AM' ,LISTE_R=xopt[0] ))
+      mcfact.append(_F(PARA= 'BETA' ,LISTE_R=xopt[1] ))
+      mcfact.append(_F(PARA= 'PARA_NOCI' ,LISTE_R =liste_a  ))
+      mcfact.append(_F(PARA= 'PFA' ,LISTE_R = lpfa ))
+
+
+      # si calcul de fractiles (intervalles de confiance) par bootstrap
+
+      x0 = xopt
+      if FRAGILITE['FRACTILE']!= None :
+         if INFO==2 :
+            texte='FRACTILES A CALCULER PAR BOOTSTRAP '+ str(FRAGILITE['FRACTILE']) +'\n'
+            aster.affiche('MESSAGE',texte)
+         if FRAGILITE['NB_TIRAGE']!= None :
+            Nboot = FRAGILITE['NB_TIRAGE']
+            if Nboot > Nbval :
+               UTMESS('F','PROBA0_11')     #assert Nboot <= Nbval , 'ERREUR: nombre de tirages demandes trop grand'
+         else:
+            Nboot = Nbval
+
+         list_fonc = []
+         lfract =FRAGILITE['FRACTILE']
+         __F1=[None]*Nbval
+         __ABS=[None]*Nbval
+         __ORDO=[None]*Nbval
+
+         for kb in range(Nboot) : #in range(Nbval)
+
+            lpfa = []
+            list_rand = []
+
+            for kb2 in range(Nbval) :
+               list_rand.append(random.randint(0,Nbval-1))
+
+            xopt = fmin(boot_vrais,x0)
+            if INFO==2 :
+               texte1='BOOTSTRAP TIRAGE '+ str(kb+1)
+               texte2='  PARAMETRES Am, beta ESTIMES : '+str(xopt)+'\n'
+               aster.affiche('MESSAGE',texte1) 
+               aster.affiche('MESSAGE',texte2)
+            vecval=(Numeric.log(vec_a/xopt[0]))/xopt[1]
+            for m in range(Nba):
+               lpfa.append(normcdf(vecval[m]))
+
+            __ABS[kb]=DEFI_LIST_REEL( VALE = liste_a  );
+            __ORDO[kb]=DEFI_LIST_REEL( VALE = lpfa );
+
+            __F1[kb]=DEFI_FONCTION(  NOM_PARA='PGAZ',
+                                     NOM_RESU = 'PFA',
+                                     VALE_PARA = __ABS[kb],
+                                     VALE_FONC = __ORDO[kb],);
+            list_fonc.append(__F1[kb],)
+
+
+         #__FRACTILE = [None]*len(lfract)
+         liste = [None]*len(lfract)
+         for kb in range(len(lfract)):
+            __FRACTILE=CALC_FONCTION(FRACTILE=_F(FONCTION=(list_fonc),
+                             FRACT=lfract[kb]), );
+            liste[kb]= __FRACTILE.Ordo()
+            mcfact.append(_F(PARA= str(lfract[kb]) ,LISTE_R =liste[kb]  ))
+
+
+      #   fin FRAGILITE
+      tabout = CREA_TABLE(LISTE=mcfact,TITRE = 'POST_DYNA_ALEA concept : '+self.sd.nom)
+
+#  ------------------------------------------------------------------
+
+
+#  ------------------------------------------------------------------
+#  OPTION INTESPEC
+# ------------------------------------------------------------------
+   if INTE_SPEC !=None :
+
+      TOUT_ORDRE = args['TOUT_ORDRE']
+      NUME_VITE_FLUI=args['NUME_VITE_FLUI']
+
+      NUME_ORDRE_I=args['NUME_ORDRE_I']
+      NOEUD_I=args['NOEUD_I']
+      OPTION=args['OPTION']
+
+      MOMENT=args['MOMENT']
+
+      intespec=INTE_SPEC.EXTR_TABLE()
+      # pour la clarté !
+      NUME_VITE_FLUI_present = 'NUME_VITE_FLUI' in intespec.para
+      NUME_ORDRE_I_present   = 'NUME_ORDRE_I'   in intespec.para
+      NOEUD_I_present        = 'NOEUD_I'        in intespec.para
+
+      # table résultat
+      tabres = Table(titr='POST_DYNA_ALEA concept : %s' % self.sd.nom)
+
+#     ------------------------------------------------------------------
+#     Liste des moments spectraux
+#     repérer le type de l'interspectre et son nom
+#                   1- concept interspectre
+#                   2- table de table d interspectre
+
+      if NUME_VITE_FLUI_present :
+         if TOUT_ORDRE != None :
+            jvite = list(set(intespec.NUME_VITE_FLUI.not_none_values()))
+            jvite.sort()
+         else :
+            jvite=[NUME_VITE_FLUI,]
+      else :
+         jvite  =[None]
+
+#     ------------------------------------------------------------------
+#     Repérer les couples d'indices selectionnés
+#     vérification de l'égalité du nombre d indices en i et j
+
+      if NUME_ORDRE_I!=None :
+        l_ind_i=NUME_ORDRE_I
+        l_ind_j=args['NUME_ORDRE_J']
+        if type(l_ind_i) not in EnumTypes : l_ind_i=[l_ind_i]
+        if type(l_ind_j) not in EnumTypes : l_ind_j=[l_ind_j]
+        if len(l_ind_i)!=len(l_ind_j) :
+           UTMESS('F','PROBA0_8')
+        # paramètres fixes de la table
+        tabres.add_para(['NUME_ORDRE_I','NUME_ORDRE_J'], 'I')
+      elif NOEUD_I!=None :
+        l_ind_i=NOEUD_I
+        l_ind_j=args['NOEUD_J']
+        l_cmp_i=args['NOM_CMP_I']
+        l_cmp_j=args['NOM_CMP_J']
+        if type(l_cmp_i) not in EnumTypes : l_cmp_i=[l_cmp_i]
+        if type(l_cmp_j) not in EnumTypes : l_cmp_j=[l_cmp_j]
+        if type(l_ind_i) not in EnumTypes : l_ind_i=[l_ind_i]
+        if type(l_ind_j) not in EnumTypes : l_ind_j=[l_ind_j]
+        if len(l_ind_i)!=len(l_ind_j) :
+           UTMESS('F','PROBA0_8')
+        if len(l_cmp_i)!=len(l_cmp_j) :
+           UTMESS('F','PROBA0_9')
+        if len(l_ind_i)!=len(l_cmp_i) :
+           UTMESS('F','PROBA0_10')
+        # paramètres fixes de la table
+        tabres.add_para(['NOEUD_I','NOEUD_J','NOM_CMP_I','NOM_CMP_J'], 'K8')
+
+#     ------------------------------------------------------------------
+#     Cas de tous les indices centraux
+
+      elif OPTION!=None :
+         if NUME_VITE_FLUI_present :
+               intespec = intespec.NUME_VITE_FLUI == jvite[0]
+
+         if NUME_ORDRE_I_present :
+            imode = list(set(intespec.NUME_ORDRE_I.not_none_values()))
+            l_ind_i=imode
+            l_ind_j=imode
+            # paramètres fixes de la table
+            tabres.add_para(['NUME_ORDRE_I','NUME_ORDRE_J'], 'I')
+         else :
+            l_ind_i = intespec.NOEUD_I.values()
+            l_ind_j = intespec.NOEUD_J.values()
+            if len(l_ind_i) != len(l_ind_j) :
+               UTMESS('F','PROBA0_8')
+            l_cmp_i = intespec.NOM_CMP_I.values()
+            l_cmp_j = intespec.NOM_CMP_J.values()
+            if (len(l_ind_i) != len(l_cmp_i) or len(l_ind_j) != len(l_cmp_j)) :
+               UTMESS('F','PROBA0_10')
+            l_l=zip(zip(l_ind_i,l_cmp_i),zip(l_ind_j,l_cmp_j))
+            l_ind_i=[]
+            l_ind_j=[]
+            l_cmp_i=[]
+            l_cmp_j=[]
+            for ai,aj in l_l :
+                if ai==aj :
+                   l_ind_i.append(ai[0])
+                   l_ind_j.append(aj[0])
+                   l_cmp_i.append(ai[1])
+                   l_cmp_j.append(aj[1])
+            # paramètres fixes de la table
+            tabres.add_para(['NOEUD_I','NOEUD_J','NOM_CMP_I','NOM_CMP_J'], 'K8')
+
+      if jvite[0]!=None :
+         tabres.add_para('NUME_VITE_FLUI', 'I')
+
+
+#     ------------------------------------------------------------------
+#     Liste des moments spectraux
+
+      l_moments=[0,1,2,3,4]
+      if MOMENT!=None :
+         l_moments.extend(list(MOMENT))
+         l_moments=list(set(l_moments))
+
+#     ------------------------------------------------------------------
+#     Boucle sur les fonctions
+
+      if NOEUD_I_present :
+         l_ind=zip(l_ind_i,l_ind_j, l_cmp_i,l_cmp_j)
+      else :
+         l_ind=zip(l_ind_i, l_ind_j )
+
+
+      # pour la présentation de la table finale, on stocke le nbre de paramètres "initiaux"
+      nbpara0 = len(tabres.para)
+
+      for vite in jvite :
+        if INFO==2 :
+           texte='POUR LA MATRICE INTERSPECTRALE '+INTE_SPEC.nom+'\n'
+           aster.affiche('MESSAGE',texte)
+        for ind in l_ind :
+           dlign = {}
+           mcfact=[]
+           if vite!=None :
+             dlign['NUME_VITE_FLUI'] = vite
+             mcfact.append(_F(NOM_PARA='NUME_VITE_FLUI',VALE_I=vite))
+           if NOEUD_I_present :
+             i_foncstat = ind[0] == ind[1] and  ind[2] == ind[3]
+             dlign['NOEUD_I'], dlign['NOEUD_J'], dlign['NOM_CMP_I'], dlign['NOM_CMP_J'] = \
+                  ind[0], ind[1], ind[2], ind[3]
+             mcfact.append(_F(NOM_PARA='NOEUD_I',VALE_K=ind[0]))
+             mcfact.append(_F(NOM_PARA='NOEUD_J',VALE_K=ind[1]))
+             mcfact.append(_F(NOM_PARA='NOM_CMP_I',VALE_K=ind[2]))
+             mcfact.append(_F(NOM_PARA='NOM_CMP_J',VALE_K=ind[3]))
+             if INFO==2 :
+                aster.affiche('MESSAGE','INDICES :'+ind[0]+' - '+ind[1])
+                aster.affiche('MESSAGE','INDICES :'+ind[2]+' - '+ind[3]+'\n')                
+           else :
+             i_foncstat = ind[0] == ind[1]
+             dlign['NUME_ORDRE_I'], dlign['NUME_ORDRE_J'] = ind[0], ind[1]
+             mcfact.append(_F(NOM_PARA='NUME_ORDRE_I',VALE_I=ind[0]))
+             mcfact.append(_F(NOM_PARA='NUME_ORDRE_J',VALE_I=ind[1]))
+             if INFO==2 :
+                aster.affiche('MESSAGE','INDICES :'+str(ind[0])+' - '\
+                                                   +str(ind[1])+'\n')
+                                                   
+           __fon1=RECU_FONCTION(TABLE        = INTE_SPEC,
+                                NOM_PARA_TABL= 'FONCTION_C',
+                                FILTRE       = mcfact, )
+
+           val  = __fon1.Valeurs()
+           fvalx= Numeric.array(val[0])
+           fvaly= Numeric.array(val[1])
+           frez = fvalx[0]
+
+           # -- moments spectraux
+
+           val_mom={}
+           for i_mom in l_moments :
+               n         = len(fvaly)
+               trapz     = Numeric.zeros(n,Numeric.Float)
+               trapz[0]  = 0.
+               valy      = fvaly*(2*pi*fvalx)**i_mom
+               trapz[1:n] = (valy[1:n]+valy[:-1])/2*(fvalx[1:n]-fvalx[:-1])
+               prim_y    = Numeric.cumsum(trapz)
+               val_mom[i_mom] = prim_y[-1]
+           for i_mom in l_moments :
+             chmo='LAMBDA_'+str(i_mom).zfill(2)
+             dlign[chmo] = val_mom[i_mom]
+
+        #--- si auto-spectre:
+           if i_foncstat:
+              # test si le spectre est bien à valeurs positives                    
+              if min(fvaly) < 0.0 :
+                 aster.affiche('MESSAGE', str(ind)+'\n')
+                 UTMESS('F','MODELISA9_95')
+              # -- fonctions statistiques              
+              if NUME_VITE_FLUI or frez >= 0. :
+                  # -- cas NUME_VITE_FLUI, seule la partie positive du spectre est utilisée
+                  # -- Il faut donc doubler lambda  pour calculer le bon écart type
+                  dlign['ECART'] = sqrt(val_mom[0]*2.)
+              else :
+                  dlign['ECART'] = sqrt(val_mom[0])
+              if abs(val_mom[2])>=1e-20 :
+                    dlign['NB_EXTREMA_P_S'] = 1./pi*sqrt(val_mom[4]/val_mom[2])
+              if abs(val_mom[0])>=1e-20 :
+                 dlign['NB_PASS_ZERO_P_S'] = 1./pi*sqrt(val_mom[2]/val_mom[0])
+                 dlign['FREQ_APPAR'] = 0.5*dlign['NB_PASS_ZERO_P_S']
+                 if abs(val_mom[4])>=1e-20 :
+                    dlign['FACT_IRRE'] = sqrt( val_mom[2]*val_mom[2]/val_mom[0]/val_mom[4])
+
+           # ajoute la ligne à la Table
+           tabres.append(dlign)
+
+#--- construction de la table produite
+
+      # tri des paramètres
+      ord_para = tabres.para[nbpara0:]
+      ord_para.sort()
+      ord_para = tabres.para[:nbpara0] + ord_para
+      dprod = tabres[ord_para].dict_CREA_TABLE()
+
+      tabout = CREA_TABLE(**dprod)
+
+   return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/post_gp_ops.py b/Aster/Cata/cataSTA10/Macro/post_gp_ops.py
new file mode 100644 (file)
index 0000000..875a37f
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/post_gp_ops.py
@@ -0,0 +1,930 @@
+#@ MODIF post_gp_ops Macro  DATE 16/11/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.        
+# ======================================================================
+
+EnumTypes = (list, tuple)
+
+# -----------------------------------------------------------------------------
+def post_gp_ops(self, **args):
+   """
+      Corps de la macro POST_GP
+   """
+   import pdb
+   macro = 'POST_GP'
+   ier=0
+   from Accas import _F
+   from Utilitai.Utmess       import UTMESS
+   from Utilitai.Table        import Table, merge, Colonne
+   from Cata_Utils.t_fonction import t_fonction
+   from Cata.cata             import evol_noli
+   import aster
+   
+   # ----- On importe les definitions des commandes a utiliser dans la macro
+   CALC_THETA    = self.get_cmd('CALC_THETA')
+   CALC_G        = self.get_cmd('CALC_G')
+   POST_ELEM     = self.get_cmd('POST_ELEM')
+   POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+   CREA_TABLE    = self.get_cmd('CREA_TABLE')
+   DEFI_LIST_ENTI= self.get_cmd('DEFI_LIST_ENTI')
+   CALC_ELEM     = self.get_cmd('CALC_ELEM')
+   RECU_FONCTION = self.get_cmd('RECU_FONCTION')
+   DEFI_GROUP    = self.get_cmd('DEFI_GROUP')
+   FIN           = self.get_cmd('FIN')
+   
+   # ----- Comptage, commandes + déclaration concept sortant
+   self.set_icmd(1)
+   self.DeclareOut('result', self.sd)
+   self.DeclareOut('tabresult', self['TABL_RESU'])
+   info = self['INFO']
+   
+   # 0. ----- Type de calcul
+   identification = self['IDENTIFICATION'] != None
+   if identification:
+      # 0.1. --- identification : on boucle sur les valeurs de TEMP.
+      #          Pour chaque couple (T, Kjc(T)), on évalue les Ki, Kmoy et
+      #          les valeurs de Gpmax, DeltaLmax, inst.max correspondantes.
+      mccalc = self['IDENTIFICATION']
+      l_crit = mccalc['KJ_CRIT']
+      lv_ident = []
+      l_temp = mccalc['TEMP']
+   else:
+      # 0.2. --- prédiction : on ne fait qu'une itération.
+      #          Il faut un RESU_THER (sinon on utilise la température du
+      #          premier Gpcrit et cà n'a pas trop d'intéret).
+      #          A chaque instant, on regarde à quelle température est le
+      #          fond d'entaille et on compare Gpmax à cet instant au Gpcrit.
+      mccalc = self['PREDICTION']
+      l_crit = mccalc['GP_CRIT']
+      lv_pred = []
+      l_temp = mccalc['TEMP'][0]
+   
+   if not type(l_temp) in EnumTypes:
+      l_temp = [l_temp,]
+   if not type(l_crit) in EnumTypes:
+      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)
+   
+   # Excitation 
+   args={}                    
+   if self['EXCIT']:args={'EXCIT'   : self['EXCIT'].List_F()}
+
+   # 1. ----- calcul de G-theta
+   
+   # Cas 2D
+   if self['THETA_2D'] is not None:
+      is_2D = True
+   else:
+      is_2D = False
+   
+   if is_2D:
+      nbcour = len(self['THETA_2D'])
+      nb_tranches = 1
+      ep_z = 1
+      l_tab = []
+      for occ in self['THETA_2D']:
+         dMC = occ.cree_dict_valeurs(occ.mc_liste)
+         
+         __theta = CALC_THETA(MODELE=self['MODELE'],
+                              DIRECTION=self['DIRECTION'],
+                              THETA_2D=_F(GROUP_NO=dMC['GROUP_NO'],
+                                          MODULE=1.0,
+                                          R_INF=dMC['R_INF'],
+                                          R_SUP=dMC['R_SUP']),)
+   
+         __gtheta = CALC_G(THETA=_F(THETA=__theta),
+                           RESULTAT=self['RESULTAT'],
+                           TOUT_ORDRE='OUI',
+                           SYME_CHAR=self['SYME_CHAR'],
+                           COMP_ELAS=self['COMP_ELAS'].List_F(),
+                           **args)
+   
+         tab = __gtheta.EXTR_TABLE()
+         
+         # une Table par couronne
+         l_tab.append(tab)
+         
+   else:
+      #Cas 3D
+      nbcour = len(self['THETA_3D'])
+      nb_tranches = self['NB_TRANCHES']
+      l_tab = []
+      l_noeuds_fissure, pas = getFondFissInfo(self['FOND_FISS'])
+      nb_noeuds_fissure = len(l_noeuds_fissure)
+      
+      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'],
+                                    R_SUP=dMC['R_SUP'],
+                                    MODULE=1.0,
+                                    FOND_FISS=self['FOND_FISS'],
+                                    **dpar_theta),
+                           RESULTAT=self['RESULTAT'],
+                           TOUT_ORDRE='OUI',
+                           SYME_CHAR=self['SYME_CHAR'],
+                           COMP_ELAS=self['COMP_ELAS'].List_F(),
+                           LISSAGE=self['LISSAGE'].List_F(),
+                           **args)
+
+ 
+         tab = __gtheta.EXTR_TABLE()
+ 
+         
+         # une Table par couronne
+         l_tab.append(tab)
+
+   
+
+   # 2. ----- Calcul de l'energie élastique en exploitant les groupes de
+   #          mailles fournis par la procedure de maillage
+
+   l_copo_tot = [grma.strip() for grma in self['GROUP_MA']]
+   nbcop_tot = len(l_copo_tot)
+   nbcop = nbcop_tot/nb_tranches
+   
+   if self['LIST_EP_COPEAUX'] is not None:
+      l_ep_copeaux_tot = self['LIST_EP_COPEAUX']
+   
+   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'],
+                     )
+                     
+      # indices des mailles du dernier group_ma
+      # (pour avoir le nombre de mailles par tranche)
+      l_mailles_last_gm = maya.GROUPEMA.get()[l_copo_tot[-1].ljust(8)]
+      
+      # initialisation des concepts reutilises dans la boucle
+      # on suppose que chaque tranche a le meme nombre de mailles
+      
+      kk = 0
+      
+      E_el = [None]*len(l_mailles_last_gm)*nb_tranches
+
+      T_el = [None]*len(l_mailles_last_gm)*nb_tranches
+      
+      # on recupere les sd en dehors de la boucle
+      maya_GROUPEMA = maya.GROUPEMA.get()
+      maya_NOMMAI = maya.NOMMAI.get()
+      maya_CONNEX = maya.CONNEX.get()
+      maya_NOMNOE = maya.NOMNOE.get()
+
+   # liste des tables tb_Gpmax repartie aux noeuds
+   l_tb_Gpmax_noeuds = []
+      
+   # Charges 
+   args={}
+   if self['EXCIT']:args={'CHARGE': [charg['CHARGE'] for charg in self['EXCIT']]}
+   for i in range(0,nb_tranches):
+      l_copo = l_copo_tot[i*nbcop:(i+1)*nbcop]   
+      
+      if info >= 2 and not is_2D:
+         print "<I> Calcul de la tranche %i"%(i+1)
+      
+      if self['TRAC_COMP']=='OUI':
+         
+         # l_copo est une liste commulative de mailles
+         # il faut lancer POST_ELEM sur chaque maille de chaque copeau
+         # puis regarder la trace de SIEF_ELGA sur ce copeau
+         
+         # on fera attention a ne pas lancer POST_ELEM sur une maille qui 
+         # a deja ete calculee en stockant son resultat pour la maille en question
+         d_groupma={}
+         d_nomma={}
+         
+         # indices des mailles des copeaux
+         for group_ma in l_copo:
+            d_groupma[group_ma] = maya_GROUPEMA[group_ma.ljust(8)]
+         
+         # le dernier copeau contient tous les elements
+         # on calcule l energie de chaque element de ce copeau
+         last_copo = l_copo[-1]
+         
+         d_ener = {}
+         
+         d_nomma = {}
+         
+         for k, id_elem in enumerate(d_groupma[last_copo]):
+            
+            
+            # les id des elements dans Aster commencent a 1
+            # la liste python commence a 0
+            elem = maya_NOMMAI[id_elem-1]
+            d_nomma[id_elem]=elem
+            
+            E_el[kk] = POST_ELEM(MODELE=self['MODELE'],
+                                 RESULTAT=self['RESULTAT'],
+                                 TOUT_ORDRE='OUI',
+                                 ENER_ELAS=_F(MAILLE=elem),
+                                 TITRE='Energie élastique',
+                                 **args)
+            
+            T_el[kk] = E_el[kk].EXTR_TABLE()
+            
+            l_enel = T_el[kk].TOTALE.values()
+            
+            # signe de la trace <=> signe de la composante VMIS_SG du tenseur EQUI_ELNO_SIGM,
+            # mais E_enel est par element => on fait une moyenne sur les noeuds de l'element
+            
+            list_no = []
+            for ind_no in maya_CONNEX[id_elem] :
+               nomnoe = maya_NOMNOE[ind_no-1]
+               if nomnoe not in list_no :
+                  list_no.append(nomnoe)
+            
+            # print "liste des noeuds de la maille ", id_elem, ": ", list_no
+            
+            l_inst = T_el[kk].INST.values()
+            nb_inst = len(l_inst)
+            
+            T_noeuds = Table()
+            T_noeuds['INST']=l_inst
+               
+            # pour chaque noeud de l'element on recupere sa trace
+            for noeud in list_no:
+               
+               __VM=RECU_FONCTION(RESULTAT=resu2,
+                                    TOUT_INST='OUI',
+                                    NOM_CHAM='EQUI_ELNO_SIGM',
+                                    NOM_CMP='VMIS_SG',
+                                    MAILLE=elem,
+                                    NOEUD=noeud);
+   
+               T_noeuds[noeud]=__VM.Ordo()
+               
+            T_noeuds.fromfunction('VM_MAIL', moyenne, list_no)
+            
+            l_VM_MAIL = T_noeuds.VM_MAIL.values()
+            
+            for j, vm in enumerate(l_VM_MAIL):
+               if vm < 0:
+                  l_enel[j]=-l_enel[j]
+                  
+            del T_el[kk]['TOTALE']
+            T_el[kk][elem]=l_enel
+   
+            if k==0:
+            
+               # Table de l'energie elastique sur le GROUP_MA
+               T_el_gm = Table()
+               T_el_gm['NUME_ORDRE'] = T_el[kk].NUME_ORDRE.values()
+               T_el_gm['INST'] = T_el[kk].INST.values()
+               T_el_gm['LIEU'] = [last_copo]*nb_inst
+               T_el_gm['ENTITE'] = ['GROUP_MA']*nb_inst
+               
+            T_el_gm[elem]=l_enel
+            
+            kk+=1
+         
+         # sommation sur les mailles du group_ma:
+         l_nomma = d_nomma.values()
+         T_el_gm.fromfunction('TOTALE', mysum, l_nomma)
+         
+         # Table totale
+         t_enel=Table(titr="Energie élastique")
+         t_enel['NUME_ORDRE']=T_el_gm.NUME_ORDRE.values()
+         t_enel['INST']=T_el_gm.INST.values()
+         t_enel['LIEU']=T_el_gm.LIEU.values()
+         t_enel['ENTITE']=T_el_gm.ENTITE.values()
+         t_enel['TOTALE']=T_el_gm.TOTALE.values()
+   
+         # t_enel ne contient jusqu'ici que l'energie elastique du dernier copeau
+         
+         # calcul de l'energie elastique pour les autres copeaux
+         T_el_sub = T_el_gm.copy()
+         
+         for k in range(len(l_copo)-2,-1,-1):
+            group_ma = l_copo[k]
+            T_el_sub = T_el_sub.copy()
+            del T_el_sub['LIEU']
+            del T_el_sub['TOTALE']
+            T_el_sub['LIEU']=[group_ma]*nb_inst
+            l_id_elem = d_groupma[group_ma]
+            l_nom_elem = []
+            
+            for id_elem, nom_elem in d_nomma.items():
+               if not id_elem in l_id_elem:
+                  # colonne a supprimer
+                  del T_el_sub[nom_elem]
+                  del d_nomma[id_elem]
+               else:
+                  l_nom_elem.append(nom_elem)
+            
+            T_el_sub.fromfunction('TOTALE', sum_and_check, l_nom_elem)
+            
+            # Table de l'energie elastique sur le GROUP_MA               
+            T_el_gm_k = Table()
+            T_el_gm_k['NUME_ORDRE'] =T_el_sub.NUME_ORDRE.values()
+            T_el_gm_k['INST'] = T_el_sub.INST.values()
+            T_el_gm_k['LIEU'] = [group_ma]*nb_inst
+            T_el_gm_k['ENTITE'] = ['GROUP_MA']*nb_inst
+            T_el_gm_k['TOTALE'] = T_el_sub.TOTALE.values()
+            
+            # contribution du group_ma a la table totale:
+            t_enel = merge(t_enel, T_el_gm_k)
+   
+         t_enel.sort('NUME_ORDRE')
+      
+      else:
+         # si self['TRAC_COMP']!='OUI'
+         # calcul classique de l'energie elastique
+      
+         __ener = POST_ELEM(MODELE=self['MODELE'],
+                                 RESULTAT=self['RESULTAT'],
+                                 TOUT_ORDRE='OUI',
+                                 ENER_ELAS=_F(GROUP_MA=l_copo),
+                                 TITRE='Energie élastique',
+                                 **args)
+      
+         t_enel = __ener.EXTR_TABLE()
+   
+      # 2.1. ----- Indice de chaque copeau et deltaL
+      d_icop = dict(zip(l_copo, range(1, nbcop + 1)))
+      
+      l_lieu = [grma.strip() for grma in t_enel.LIEU.values()]
+      
+      l_icop = [d_icop[grma] for grma in l_lieu]
+      
+      t_enel['ICOP'] = l_icop
+   
+      l_numord = list(set(t_enel.NUME_ORDRE.values()))
+      l_numord.sort()
+
+      if self['PAS_ENTAILLE'] is not None:
+         t_enel.fromfunction('DELTAL', fDL, 'ICOP', { 'pascop' : self['PAS_ENTAILLE'] })
+      else:
+         l_ep_copeaux_tranche = l_ep_copeaux_tot[i*nbcop:(i+1)*nbcop]
+         t_enel['DELTAL'] = l_ep_copeaux_tranche*len(l_numord)
+
+      # 2.2. ----- Calcul de Gp fonction de Ener.Totale et de deltaL
+      if is_2D:
+         t_enel.fromfunction('GP', fGp_Etot, ('TOTALE', 'DELTAL'),
+            {'syme'   : self['SYME_CHAR'] != 'SANS',
+             'R'      : self['RAYON_AXIS'],})
+      else:
+         ep_tranche = largeur_tranche(nom_maillage, l_noeuds_fissure, pas, i)
+         #print "ep_tranche %i: "%i, ep_tranche
+         t_enel.fromfunction('GP', fGp_Etot, ('TOTALE', 'DELTAL'),
+               {'syme'   : self['SYME_CHAR'] != 'SANS',
+                'R'      : ep_tranche })
+      
+      #if info >= 2:
+      #   print "Table de l'énergie élastique: ", t_enel
+      
+      l_t_enel.append(t_enel)
+      # 2.3. ----- Tableau de Gp = f(icop) pour chaque instant
+      if info >= 2:
+         tGp_t_icop = t_enel['INST', 'DELTAL', 'GP']
+         tGp_t_icop.titr = "Gp à chaque instant en fonction de la distance au " \
+                           "fond d'entaille"
+         tGp_t_icop.ImprTabCroise()
+   
+      # 2.4. ----- Table Gpmax
+      ttmp = t_enel['NUME_ORDRE', 'INST', 'ICOP', 'DELTAL', 'GP']
+
+      for j in l_numord:
+         tj = ttmp.NUME_ORDRE == j
+         
+         ## pour tester le comportement de Gpmax quand GP est identiquement nul
+         #del tj['GP']
+         #tj['GP']=[0]*len(tj.GP.values())
+         
+         if self['CRIT_MAXI_GP'] == 'ABSOLU':
+            t = tj.GP.MAXI()
+         else:
+            t = MaxRelatif(tj, 'GP')
+         
+ 
+         # cas GP identiquement nul: plusieurs max de GP
+         # on prend le DELTAL minimum
+         if len(t.GP.values())>1:
+            t = t.DELTAL.MINI()
+         
+         if j == 1:
+            tb_Gpmax_i = t
+         else:
+            tb_Gpmax_i = tb_Gpmax_i | t
+      
+      
+      tb_Gpmax_i.Renomme('GP', 'GPMAX')
+      tb_Gpmax_i.Renomme('ICOP', 'ICOPMAX')
+      tb_Gpmax_i.Renomme('DELTAL', 'DELTALMAX')
+      tb_Gpmax_i.titr = 'Gpmax à chaque instant'
+      
+      # On transfert Gpmax au noeud sommet à gauche et au milieu (si cas quadratique)
+      # sauf pour la dernière tranche où on transfère également au noeud sommet de droite.
+      # Tout cela pour pouvoir avoir une table complète avec les G et les Gpmax.
+      if not is_2D:
+         tb_Gpmax_i['NUME_TRANCHE']=[i+1]*len(tb_Gpmax_i['GPMAX'])
+         if i==0:
+            l_inst = tb_Gpmax_i.INST.values()
+            nb_inst = len(l_inst)
+         if pas==1:
+            tb_Gpmax_i_noeuds = tb_Gpmax_i.copy()
+            tb_Gpmax_i_noeuds['NOEUD']=[l_noeuds_fissure[i]]*nb_inst
+            l_tb_Gpmax_noeuds.append(tb_Gpmax_i_noeuds)
+         else:
+            tb_Gpmax_i_noeuds_1 = tb_Gpmax_i.copy()
+            tb_Gpmax_i_noeuds_1['NOEUD'] = [l_noeuds_fissure[pas*i]]*nb_inst
+            l_tb_Gpmax_noeuds.append(tb_Gpmax_i_noeuds_1)
+            tb_Gpmax_i_noeuds_2 = tb_Gpmax_i.copy()
+            tb_Gpmax_i_noeuds_2['NOEUD'] = [l_noeuds_fissure[pas*i+1]]*nb_inst
+            l_tb_Gpmax_noeuds.append(tb_Gpmax_i_noeuds_2)
+         if i==nb_tranches-1:
+            tb_Gpmax_i_noeuds_3 = tb_Gpmax_i.copy()
+            tb_Gpmax_i_noeuds_3['NOEUD'] = [l_noeuds_fissure[-1]]*nb_inst
+            l_tb_Gpmax_noeuds.append(tb_Gpmax_i_noeuds_3)
+            
+
+      
+      if i == 0:
+         tb_Gpmax = tb_Gpmax_i
+      else:
+         tb_Gpmax = merge(tb_Gpmax, tb_Gpmax_i)
+   
+   # FIN BOUCLE SUR LES TRANCHES
+   
+   if not is_2D:
+      tb_Gpmax_noeuds = Table(para=tb_Gpmax.para+['NOEUD'])
+      for j, tb in enumerate(l_tb_Gpmax_noeuds):
+         if j==0:
+            tb_Gpmax_noeuds = tb
+         else:
+            tb_Gpmax_noeuds = merge(tb_Gpmax_noeuds, tb)
+   
+   
+   # 2.5. ----- extraction de la température en fond d'entaille
+   #voir le cas 3D => THETA_3D, mais qu'en est-il des tranches?
+   if self['RESU_THER']:
+      #sur un seul noeud ou sur tous les noeuds du fond d'entaille?
+      
+      if is_2D:
+         grno_fond = self['THETA_2D'][0]['GROUP_NO']
+      else:
+         grma_fond = self['THETA_3D'][0]['GROUP_MA']
+         grno_fond = "GRNOFOND"
+         DEFI_GROUP(reuse =maya,
+                    MAILLAGE=maya,
+                    CREA_GROUP_NO=_F(GROUP_MA=grma_fond,
+                                     NOM=grno_fond,),);
+      
+      l_ordres = DEFI_LIST_ENTI(VALE=l_numord)
+      __relev = POST_RELEVE_T(ACTION=_F(RESULTAT=self['RESU_THER'],
+                                        OPERATION='EXTRACTION',
+                                        INTITULE='Temperature',
+                                        NOM_CHAM='TEMP',
+                                        LIST_ORDRE=l_ordres,
+                                        NOM_CMP='TEMP',
+                                        GROUP_NO=grno_fond,),)
+
+      t_relev = __relev.EXTR_TABLE()['NUME_ORDRE', 'NOEUD', 'TEMP']
+   
+   # 3. ----- boucle sur les mots-clés facteurs
+   #          opérations dépendant de la température
+   MATER = self['MATER']
+   flag_mat = True
+   
+   for iocc, TEMP in enumerate(l_temp):
+      # 3.0. ----- Temperature fonction du temps : si on n'a pas de RESU_THER,
+      #            on prend la température d'identification.
+      if not self['RESU_THER']:
+         l_rows = [{'NUME_ORDRE' : j, 'TEMP' : TEMP} for j in l_numord]
+         t_relev = Table(rows=l_rows, para=('NUME_ORDRE', 'TEMP'), typ=('R', 'R'))
+         flag_mat = True
+      
+      # 3.1. ----- extrait du matériau E(TEMP) et NU(TEMP) (si nécessaire)
+      if flag_mat:
+         t_relev.fromfunction('YOUNG', CallRCVALE, 'TEMP',
+               { 'para' : 'E', 'MATER' : MATER })
+         t_relev.fromfunction('NU', CallRCVALE, 'TEMP',
+               { 'para' : 'NU', 'MATER' : MATER })
+         flag_mat = False
+      
+      # 3.2. ----- paramètres
+      dict_constantes = {
+         'YOUNG' : CallRCVALE(TEMP, 'E', MATER),
+         'NU'    : CallRCVALE(TEMP, 'NU', MATER),
+      }
+      
+      # 3.3. ----- calcul de Kj(G)
+      l_tabi = []
+      for k, tab in enumerate(l_tab):
+         #tab: table de la couronne k
+         
+         # calcul de Kj(G) = K_i
+         new_para = 'K_%d' % (k + 1)
+         if is_2D:
+            # fusion avec TEMP, E et nu
+            tab = merge(tab, t_relev, 'NUME_ORDRE')
+            tab.fromfunction(new_para, fKj, ('G', 'YOUNG', 'NU'))
+            # renomme G en G_i
+            tab.Renomme('G', 'G_%d' % (k + 1))
+         else:
+            if self['RESU_THER']:
+               tab=merge(tab, t_relev, ['NUME_ORDRE', 'NOEUD'])
+            else:
+               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))
+
+         l_tabi.append(tab)
+      
+      # 3.4 ----- Table des Gi, Ki sur les differentes couronnes + Kmoyen
+      if is_2D:
+         tabK_G = l_tabi[0]['NUME_ORDRE']
+         for tab in l_tabi:
+            tabK_G = merge(tabK_G, tab, 'NUME_ORDRE')
+      else:
+         tabK_G=l_tabi[0]
+         for i in range(1,len(l_tabi)):
+            tabK_G = merge(tabK_G, l_tabi[i], ['NUME_ORDRE', 'NOEUD'])
+      tabK_G.titr = 'G et K sur les differentes couronnes + moyennes'
+      tabK_G.fromfunction('GMOY', moyenne_positive, ['G_%d' % (k + 1) for k in range(nbcour)])
+      tabK_G.fromfunction('KMOY', moyenne, ['K_%d' % (k + 1) for k in range(nbcour)])
+      
+      # 3.5. ----- Contribution à la table globale
+      
+      if is_2D:
+         tabres = merge(tabK_G, tb_Gpmax, 'NUME_ORDRE')
+         tabres['OCCURRENCE'] = [iocc + 1] * len(l_numord)
+      else:
+         # tb_Gpmax est une table sur les tranches, 
+         # on l'ajoute dans la table aux noeuds tabres avec la convention:
+         # au 1er noeud et noeud milieu de la tranche on affecte la valeur de la tranche
+         # sauf pour la derniere tranche où on affecte la valeur sur les 3 noeuds de la tranche
+         tabres = tabK_G         
+         tabres = merge(tabK_G, tb_Gpmax_noeuds, ['NUME_ORDRE', 'NOEUD'])
+         tabres['OCCURRENCE'] = [iocc + 1] * len(l_numord) * nb_noeuds_fissure
+      #if info >= 2:
+      #   print tabres
+      
+      # 3.5.1. --- Table globale
+      if iocc == 0:
+         tabl_glob = tabres
+      else:
+         tabl_glob = merge(tabl_glob, tabres)
+      tabl_glob.titr = 'G, K sur les differentes couronnes, Gmoy, Kmoy et ' \
+                       'Gpmax fonctions du temps'
+      
+      # 3.6. ----- traitement selon identification / prédiction
+      d_para = {
+         'INTERPOL' : ['LIN', 'LIN'],
+         'NOM_PARA' : 'INST',
+         'PROL_DROITE' : 'CONSTANT',
+         'PROL_GAUCHE' : 'CONSTANT',
+      }
+      
+      # 3.6.1. --- identification
+      if identification:
+         KJ_CRIT = l_crit[iocc]
+         # on verifie que KJ_CRIT soit compris dans l'intervalle [KMOY_min, KMOY_max]
+         valkmoy = tabres.KMOY.values()            
+         if not (min(valkmoy) <= KJ_CRIT <= max(valkmoy)):
+#                               'constant utilisé).')
+            UTMESS('A','RUPTURE0_1')
+         if is_2D:
+            # définition des fonctions pour faire les interpolations
+            d_para.update({ 'NOM_RESU' : 'DELTALMAX' })
+            # DeltaMax en fonction du temps
+            fdL = t_fonction(tb_Gpmax.INST.values(), tb_Gpmax.DELTALMAX.values(), d_para)
+            # Gpmax fonction du temps
+            d_para.update({ 'NOM_RESU' : 'GPMAX' })
+            fGp = t_fonction(tb_Gpmax.INST.values(), tb_Gpmax.GPMAX.values(), d_para)
+            
+            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)
+
+            # valeurs à mettre dans la table
+            # temps correspondant à KJ_CRIT
+            ti   = finv(KJ_CRIT)
+            # GP correspondant au temps critique
+            Gpi  = fGp(ti)
+            d_ident = {
+               'KJ_CRIT'   : KJ_CRIT,
+               'INST'      : ti,
+               'GPMAX'     : Gpi,
+               'KGPMAX'    : fKj(Gpi, **dict_constantes),
+               'DELTALMAX' : fdL(ti),
+            }
+            lv_ident.append(d_ident)
+         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            
+            tabres_NoeudCrit = tabres.NOEUD==noeud_KMOY_max
+            
+            # la suite est idem 2D, seuls les noms des tables changent
+    
+            # définition des fonctions pour faire les interpolations
+            d_para.update({ 'NOM_RESU' : 'DELTALMAX' })
+            # DeltaMax en fonction du temps
+            fdL = t_fonction(tb_Gpmax_TrancheCrit.INST.values(),
+                              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)
+            # GP correspondant au temps critique
+            Gpi  = fGp(ti)
+            # par rapport a 2D, on ajoute 'NUME_TRANCHE'
+            d_ident = {
+               'KJ_CRIT'      : KJ_CRIT,
+               'INST'         : ti,
+               'NUME_TRANCHE' : int(nume_tranche_Gpmax),
+               'GPMAX'        : Gpi,
+               'KGPMAX'       : fKj(Gpi, **dict_constantes),
+               'DELTALMAX'    : fdL(ti),
+            }
+            lv_ident.append(d_ident)
+            
+      # 3.6.2. --- prédiction
+      else:
+         pass
+   
+   # 4. ----- Construction de la table résultat si demandée
+   # 4.1. --- identification
+   if identification:
+      if is_2D:
+         para_tab_ident=('KJ_CRIT', 'INST', 'GPMAX', 'KGPMAX', 'DELTALMAX')
+      else:
+         para_tab_ident=('KJ_CRIT', 'INST', 'NUME_TRANCHE', 'GPMAX', 'KGPMAX', 'DELTALMAX')
+      tab_ident = Table(rows=lv_ident,
+                        para=para_tab_ident,
+                        typ = ('R')*len(para_tab_ident),
+                        titr='Identification aux valeurs de tenacités critiques')
+      dprod_result = tab_ident.dict_CREA_TABLE()
+      if info >= 2:
+         print tab_ident
+   
+   # 4.2. --- prédiction
+   else:
+      # définition de la fonction GPcrit = f(TEMP)
+      d_para.update({ 'NOM_PARA' : 'TEMP',
+                      'NOM_RESU' : 'GP_CRIT', })
+      fGpc = t_fonction(mccalc['TEMP'], mccalc['GP_CRIT'], d_para)
+      
+      # en 3D, GPMAX et DELTALMAX ne sont pas dans tab_glob: les recuperer de tb_Gpmax
+      
+      if is_2D:
+         tab_pred = tabl_glob['NUME_ORDRE', 'INST', 'TEMP', 'DELTALMAX', 'GPMAX']
+      else:
+         tab_pred = tb_Gpmax['NUME_ORDRE', 'INST', 'NUME_TRANCHE', 'DELTALMAX', 'GPMAX']
+         # on recupere TEMP de tabl_glob
+         tab_temp_tranche=Table(para=['NUME_ORDRE', 'NUME_TRANCHE', 'TEMP'])
+         # on fait une moyenne de la temperature sur les noeuds d'une tranche
+         for ordre in l_numord:
+            tabl_glob_ORDRE_i = tabl_glob.NUME_ORDRE==ordre
+            temp_ORDRE_i = tabl_glob_ORDRE_i.TEMP.values()
+            for i_tranche in range(nb_tranches):
+               l_temp_noeuds_tranche_i = temp_ORDRE_i[i_tranche : i_tranche+pas+1]
+               temp_tranche_i = moyenne(*l_temp_noeuds_tranche_i)
+               d = {'NUME_ORDRE': ordre, 'NUME_TRANCHE': i_tranche+1, 'TEMP': temp_tranche_i}
+               tab_temp_tranche.append(d)
+         tab_pred = merge(tab_pred, tab_temp_tranche, ['NUME_ORDRE', 'NUME_TRANCHE'])
+      
+      tab_pred.fromfunction('GP_CRIT', fGpc, 'TEMP')
+      tab_pred.fromfunction('PREDICTION', crit, ('GP_CRIT', 'GPMAX'))
+      tab_pred.titr = 'Comparaison Gpmax à Gpcrit(T)'
+      dprod_result = tab_pred.dict_CREA_TABLE()
+   
+   # 9. ----- création de la table_sdaster résultat
+   dprod = tabl_glob.dict_CREA_TABLE()
+   result = CREA_TABLE(**dprod)
+   tabresult = CREA_TABLE(**dprod_result)
+
+
+
+# -----------------------------------------------------------------------------
+def CallRCVALE(TEMP, para, MATER):
+   """Fonction appelant RCVALE et retourne la valeur d'un paramètre.
+   """
+   valres, flag_ok = MATER.RCVALE('ELAS', 'TEMP', TEMP, para)
+   assert list(flag_ok).count('OK') != 1, \
+         'Erreur lors de la récupération des valeurs du matériau.'
+   return valres
+
+# -----------------------------------------------------------------------------
+def fKj(G, YOUNG, NU):
+   """Calcul de Kj à partir de G (formule d'Irwin)
+   """
+   Kj=(abs(G * YOUNG / (1.0 - NU**2)))**0.5
+   return Kj
+
+# -----------------------------------------------------------------------------
+def fDL(ICOP, pascop):
+   """DeltaL = numéro copeau * pas d'entaille
+   """
+   return ICOP * pascop
+
+# -----------------------------------------------------------------------------
+def fGp_Etot(TOTALE, DELTAL, R, syme=False):
+   """Gp(Etotale, K), deltal pris dans le context global.
+      ICOP      : numéro du copeau,
+      DELTAL    : liste des epaisseurs des copeaux
+      R         : rayon en axisymetrique,
+                  longueur de l'élément 1D situé sur le front d'entaille si modèle 3D.
+      syme      : True s'il y a symétrie.
+   """
+   import types
+   fact_syme = 1.
+   if syme:
+      fact_syme = 2.
+   Gp_Etot = fact_syme * TOTALE / (DELTAL * R )
+   return Gp_Etot
+
+# -----------------------------------------------------------------------------
+def MaxRelatif(table, nom_para):
+   """Extrait le dernier maxi du champ `nom_para` de la table.
+   """
+   l_val = getattr(table, nom_para).values()
+   l_val.reverse()
+   Vlast = l_val[0]
+   for val in l_val:
+      if val < Vlast:
+         break
+      Vlast = val
+   return getattr(table, nom_para) == Vlast
+
+# -----------------------------------------------------------------------------
+def crit(GP_CRIT, GPMAX):
+   """Retourne 1 quand GP_CRIT > GPMAX
+   """
+   if GPMAX > GP_CRIT:
+      return 1
+   else:
+      return 0
+
+# -----------------------------------------------------------------------------
+def moyenne(*args):
+   """Fonction moyenne
+   """
+   return sum(args)/len(args)
+
+def moyenne_positive(*args):
+   """Fonction moyenne
+   """
+   return sum([abs(a) for a in args])/len(args)
+
+def mysum(*args):
+   """Fonction sum.
+      La fonction sum ne peut pas etre appelee sur une liste de parametre
+      d'une table via fromfunction
+   """
+   return sum(args)
+
+def sum_and_check(*args):
+   """Fonction sum.
+      Verifie si la somme est positive.
+      Si la somme est negative, on la met egale a zero
+   """
+   somme = sum(args)
+   if somme<0:
+      somme=0
+   return somme
+
+# On recupere des infos sur le fond de fissure
+def getFondFissInfo(fondfiss):
+   # >FONFISS .FOND      .NOEU        <
+   # >FONFISS .FOND      .TYPE        < 
+   import aster
+   l_noeuds_fissure = aster.getvectjev(fondfiss.nom.ljust(8)+'.FOND      .NOEU        ')
+   type_mailles = aster.getvectjev(fondfiss.nom.ljust(8)+'.FOND      .TYPE        ')
+   if (type_mailles[0].strip() == 'SEG3' ):
+      pas = 2
+   else:
+      pas = 1
+   return l_noeuds_fissure, pas
+
+########################################################################
+# determination de la distance min entre 2 points consécutifs de la ligne de coupe
+
+def largeur_tranche(nom_maillage, l_noms_noeuds_fissure, pas, i_tranche):
+   # >MA      .COORDO    .VALE        <
+   from math import sqrt
+   import aster
+   
+   # tuple des noms des noeuds du maillage
+   t_noms_noeuds_maillage = aster.getvectjev(nom_maillage.ljust(8)+'.NOMNOE')
+   # on convertit en liste pour utiliser la methode index
+   # qui est plus optimal qu'une boucle sur les indices du tuple
+   l_noms_noeuds_maillage = list(t_noms_noeuds_maillage)
+   
+   l_numeros_noeuds_fissure = []
+   for i in range(0,len(l_noms_noeuds_fissure),pas):
+      nom = l_noms_noeuds_fissure[i]
+      index = l_noms_noeuds_maillage.index(nom)
+      l_numeros_noeuds_fissure.append(index)
+   
+   coor1=aster.getvectjev(nom_maillage.ljust(8)+'.COORDO    .VALE        ',
+                        l_numeros_noeuds_fissure[i_tranche]*3,3)
+   coor2=aster.getvectjev(nom_maillage.ljust(8)+'.COORDO    .VALE        ',
+                        l_numeros_noeuds_fissure[i_tranche+1]*3,3)
+   
+   d=sqrt( (coor1[0]-coor2[0])**2+(coor1[1]-coor2[1])**2+(coor1[2]-coor2[2])**2)
+   return d
+   
+def mergeLineInTable(multiTable, lineTable, nb_noeuds):
+   # on ajoute a la table multiTable les colonnes de lineTable
+   # pour chaque nume_ordre autant de fois qu'il y a de nb_noeuds
+   from Utilitai.Table      import Table, merge
+   
+   l_ordre = lineTable.NUME_ORDRE
+   l_para = lineTable.copy().para
+   l_para.remove('NUME_ORDRE')
+   for i, ordre in enumerate(l_ordre):
+      multiTable_i = multiTable.NUME_ORDRE==ordre
+      row_i = lineTable.rows[i]
+      for para in l_para:
+         valeur_i = row_i[para]
+         multiTable_i[para] = [valeur_i] * nb_noeuds
+      if i==0:
+         newTable=multiTable_i
+      else:
+         newTable = merge(newTable, multiTable_i)
+         
+   return newTable

diff --git a/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py b/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py
new file mode 100644 (file)
index 0000000..f91608a
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py
@@ -0,0 +1,1276 @@
+#@ MODIF post_k1_k2_k3_ops Macro  DATE 16/11/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.        
+# ======================================================================
+
+def veri_tab(tab,nom,ndim) :
+   from Utilitai.Utmess     import  UTMESS
+   macro = 'POST_K1_K2_K3'
+   for label in ('DX','DY','COOR_X','COOR_Y','ABSC_CURV') :
+       if label not in tab.para :
+          UTMESS('F','RUPTURE0_2',valk=[label,nom])
+   if ndim==3 :
+      if 'DZ'     not in tab.para :
+          label='DZ'
+          UTMESS('F','RUPTURE0_2',valk=[label,nom])
+      if 'COOR_Z' not in tab.para :
+          label='COOR_Z'
+          UTMESS('F','RUPTURE0_2',valk=[label,nom])
+
+def cross_product(a,b):
+    cross = [0]*3
+    cross[0] = a[1]*b[2]-a[2]*b[1]
+    cross[1] = a[2]*b[0]-a[0]*b[2]
+    cross[2] = a[0]*b[1]-a[1]*b[0]
+    return cross
+
+def complete(Tab):
+    n = len(Tab)
+    for i in range(n) :
+      if Tab[i]==None : Tab[i] = 0.
+    return Tab
+ 
+def moy(t):
+    m = 0
+    for value in t :
+      m += value
+    return (m/len(t))
+
+def InterpolFondFiss(s0, Coorfo) :
+# Interpolation des points du fond de fissure (xfem)
+# s0     = abscisse curviligne du point considere 
+# Coorfo = Coordonnees du fond (extrait de la sd fiss_xfem)
+# en sortie : xyza = Coordonnees du point et abscisse
+   n = len(Coorfo) / 4
+   if ( s0 < Coorfo[3] )  :
+     xyz =  [Coorfo[0],Coorfo[1],Coorfo[2]]
+     return xyz
+   if ( s0 > Coorfo[-1]  ) :
+     xyz =  [Coorfo[-4],Coorfo[-3],Coorfo[-2]]
+     return xyz
+   i = 1
+   while s0 > Coorfo[4*i+3]:
+      i = i+1
+   xyz = [0.]*4
+   xyz[0] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+0]-Coorfo[4*(i-1)+0]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+0]
+   xyz[1] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+1]-Coorfo[4*(i-1)+1]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+1]
+   xyz[2] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+2]-Coorfo[4*(i-1)+2]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+2]
+   xyz[3] = s0
+   return xyz
+
+def InterpolBaseFiss(s0, Basefo, Coorfo) :
+# Interpolation de la base locale en fond de fissure
+# s0     = abscisse curviligne du point considere     
+# Basefo = base locale du fond (VNx,VNy,VNz,VPx,VPy,VPz)
+# Coorfo = Coordonnees et abscisses du fond (extrait de la sd fiss_xfem)
+# en sortie : VPVNi = base locale au point considere (6 coordonnes)
+   n = len(Coorfo) / 4
+   if ( s0 < Coorfo[3] )  :
+     VPVNi =  Basefo[0:6]
+     return VPVNi
+   if ( s0 > Coorfo[-1]  ) :
+     VPVNi = [Basefo[i] for i in range(-6,0)] 
+     return VPVNi
+   i = 1
+   while s0 > Coorfo[4*i+3]:
+      i = i+1
+   VPVNi = [0.]*6
+   for k in range(6) :
+      VPVNi[k] = (s0-Coorfo[4*(i-1)+3]) * (Basefo[6*i+k]-Basefo[6*(i-1)+k]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Basefo[6*(i-1)+k]
+   return VPVNi
+    
+     
+def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT,
+                   TABL_DEPL_SUP,TABL_DEPL_INF,ABSC_CURV_MAXI,PREC_VIS_A_VIS,
+                   TOUT_ORDRE,NUME_ORDRE,LIST_ORDRE,INST,LIST_INST,SYME_CHAR,
+                   INFO,VECT_K1,TITRE,**args):
+   """
+   Macro POST_K1_K2_K3
+   Calcul des facteurs d'intensité de contraintes en 2D et en 3D
+   par extrapolation des sauts de déplacements sur les lèvres de
+   la fissure. Produit une table.
+   """
+   import aster
+   import string
+   import copy
+   import math
+   import Numeric
+   from Numeric import array,asarray,Float,sqrt,matrixmultiply,transpose,sign,resize,dot,multiply
+   from math import pi
+   from types import ListType, TupleType
+   from Accas import _F
+   from Utilitai.Table      import Table, merge
+   from SD.sd_l_charges import sd_l_charges
+   from SD.sd_mater     import sd_compor1
+   EnumTypes = (ListType, TupleType)
+
+   macro = 'POST_K1_K2_K3'
+   from Accas               import _F
+   from Utilitai.Utmess     import  UTMESS
+
+   ier = 0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # Le concept sortant (de type table_sdaster ou dérivé) est tab
+   self.DeclareOut('tabout', self.sd)
+   
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   CREA_TABLE    = self.get_cmd('CREA_TABLE')
+   CALC_TABLE    = self.get_cmd('CALC_TABLE')
+   POST_RELEVE_T    = self.get_cmd('POST_RELEVE_T')
+   DETRUIRE      = self.get_cmd('DETRUIRE')
+   DEFI_GROUP      = self.get_cmd('DEFI_GROUP')
+   MACR_LIGN_COUPE      = self.get_cmd('MACR_LIGN_COUPE')
+
+   AFFE_MODELE      = self.get_cmd('AFFE_MODELE')
+   PROJ_CHAMP      = self.get_cmd('PROJ_CHAMP')
+      
+#   ------------------------------------------------------------------
+#                         CARACTERISTIQUES MATERIAUX
+#   ------------------------------------------------------------------
+   matph = MATER.NOMRC.get()  
+   phenom=None
+   for cmpt in matph :
+       if cmpt[:4]=='ELAS' :
+          phenom=cmpt
+          break
+   if phenom==None : UTMESS('F','RUPTURE0_5')
+#   --- RECHERCHE SI LE MATERIAU DEPEND DE LA TEMPERATURE:
+   compor = sd_compor1('%-8s.%s' % (MATER.nom, phenom))
+   valk = [s.strip() for s in compor.VALK.get()]
+   valr = compor.VALR.get()
+   dicmat=dict(zip(valk,valr))
+#   --- PROPRIETES MATERIAUX DEPENDANTES DE LA TEMPERATURE
+   Tempe3D = False
+   if FOND_FISS and args['EVOL_THER'] : 
+# on recupere juste le nom du resultat thermique (la température est variable de commande)
+      ndim   = 3
+      Tempe3D=True
+      resuth=string.ljust(args['EVOL_THER'].nom,8).rstrip()
+   if dicmat.has_key('TEMP_DEF') and not args['EVOL_THER'] :
+      nompar = ('TEMP',)
+      valpar = (dicmat['TEMP_DEF'],)
+      UTMESS('A','RUPTURE0_6',valr=valpar)
+      nomres=['E','NU']
+      valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F')
+      e = valres[0]
+      nu = valres[1]
+      
+
+#   --- PROPRIETES MATERIAUX INDEPENDANTES DE LA TEMPERATURE
+   else :
+      e  = dicmat['E']
+      nu = dicmat['NU']  
+   
+   if not Tempe3D :
+      coefd3 = 0.
+      coefd  = e * sqrt(2.*pi)
+      unmnu2 = 1. - nu**2
+      unpnu  = 1. + nu
+      if MODELISATION=='3D' :
+         coefk='K1 K2 K3'
+         ndim   = 3
+         coefd  = coefd      / ( 8.0 * unmnu2 )
+         coefd3 = e*sqrt(2*pi) / ( 8.0 * unpnu )
+         coefg  = unmnu2 / e
+         coefg3 = unpnu  / e
+      elif MODELISATION=='AXIS' :
+         ndim   = 2
+         coefd  = coefd  / ( 8. * unmnu2 )
+         coefg  = unmnu2 / e
+         coefg3 = unpnu  / e
+      elif MODELISATION=='D_PLAN' :
+         coefk='K1 K2'
+         ndim   = 2
+         coefd  = coefd / ( 8. * unmnu2 )
+         coefg  = unmnu2 / e
+         coefg3 = unpnu  / e
+      elif MODELISATION=='C_PLAN' :
+         coefk='K1 K2'
+         ndim   = 2
+         coefd  = coefd / 8.
+         coefg  = 1. / e
+         coefg3 = unpnu / e
+      else :
+         UTMESS('F','RUPTURE0_10')
+
+
+#   ------------------------------------------------------------------
+#                        CAS FOND_FISS
+#   ------------------------------------------------------------------
+   if FOND_FISS : 
+      MAILLAGE = args['MAILLAGE']
+      NOEUD = args['NOEUD']
+      SANS_NOEUD = args['SANS_NOEUD']
+      GROUP_NO = args['GROUP_NO']
+      SANS_GROUP_NO = args['SANS_GROUP_NO']
+      TOUT = args['TOUT']
+      TYPE_MAILLAGE = args['TYPE_MAILLAGE']
+      NB_NOEUD_COUPE = args['NB_NOEUD_COUPE']
+      if NB_NOEUD_COUPE ==None : NB_NOEUD_COUPE = 5
+      LNOFO = FOND_FISS.FOND_______NOEU.get()
+      RECOL = False
+# Cas double fond de fissure : par convention les noeuds sont ceux de fond_inf
+      if LNOFO==None :
+         RECOL = True
+         LNOFO = FOND_FISS.FONDINF____NOEU.get()
+         if LNOFO==None : UTMESS('F','RUPTURE0_11')
+      LNOFO = map(string.rstrip,LNOFO)
+      Nbfond = len(LNOFO)
+
+      if MODELISATION=='3D' :
+#   ----------Mots cles TOUT, NOEUD, SANS_NOEUD -------------
+        Typ = FOND_FISS.FOND_______TYPE.get()
+        if (Typ[0]=='SEG2    ') or (Typ[0]=='SEG3    ' and TOUT=='OUI') :
+           pas = 1
+        elif (Typ[0]=='SEG3    ') : 
+           pas = 2
+        else :
+           UTMESS('F','RUPTURE0_12')
+####
+        NO_SANS = []
+        NO_AVEC = []
+        if GROUP_NO!=None :
+          collgrno = MAILLAGE.GROUPENO.get()
+          cnom = MAILLAGE.NOMNOE.get()
+          if type(GROUP_NO) not in EnumTypes : GROUP_NO = (GROUP_NO,)
+          for m in range(len(GROUP_NO)) :
+            ngrno=GROUP_NO[m].ljust(8).upper()
+            if ngrno not in collgrno.keys() :
+              UTMESS('F','RUPTURE0_13',valk=ngrno)
+            for i in range(len(collgrno[ngrno])) : NO_AVEC.append(cnom[collgrno[ngrno][i]-1])
+          NO_AVEC= map(string.rstrip,NO_AVEC)
+        if NOEUD!=None : 
+          if type(NOEUD) not in EnumTypes : NO_AVEC = (NOEUD,)
+          else : NO_AVEC = NOEUD
+        if SANS_GROUP_NO!=None :
+          collgrno = MAILLAGE.GROUPENO.get()
+          cnom = MAILLAGE.NOMNOE.get()
+          if type(SANS_GROUP_NO) not in EnumTypes : SANS_GROUP_NO = (SANS_GROUP_NO,)
+          for m in range(len(SANS_GROUP_NO)) :
+            ngrno=SANS_GROUP_NO[m].ljust(8).upper()
+            if ngrno not in collgrno.keys() :
+              UTMESS('F','RUPTURE0_13',valk=ngrno)
+            for i in range(len(collgrno[ngrno])) : NO_SANS.append(cnom[collgrno[ngrno][i]-1])
+          NO_SANS= map(string.rstrip,NO_SANS)
+        if SANS_NOEUD!=None : 
+          if type(SANS_NOEUD) not in EnumTypes : NO_SANS = (SANS_NOEUD,)
+          else : NO_SANS = SANS_NOEUD
+# Creation de la liste des noeuds du fond a traiter : Lnf1
+        Lnf1 = []
+        Nbf1 = 0
+        if len(NO_AVEC)!=0 :
+          for i in range(len(NO_AVEC)) :
+            if NO_AVEC[i] in LNOFO : 
+              Lnf1.append(NO_AVEC[i])
+              Nbf1 = Nbf1 +1
+            else : 
+              UTMESS('F','RUPTURE0_15',valk=NO_AVEC[i])
+        else :
+           for i in range(0,Nbfond,pas) :
+              if not (LNOFO[i] in NO_SANS) :
+                 Lnf1.append(LNOFO[i])
+                 Nbf1 = Nbf1 +1
+      else :
+        Lnf1 = LNOFO
+        Nbf1 = 1
+        
+##### Cas maillage libre###########
+# creation des directions normales et macr_lign_coup
+      if TYPE_MAILLAGE =='LIBRE':
+        if not RESULTAT : UTMESS('F','RUPTURE0_16')
+        Lnofon = Lnf1
+        Nbnofo = Nbf1
+        ListmaS = FOND_FISS.LEVRESUP___MAIL.get()
+        if ListmaS==None :  UTMESS('F','RUPTURE0_19')
+        if SYME_CHAR=='SANS':
+          ListmaI = FOND_FISS.LEVREINF___MAIL.get()
+        __NCOFON=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds du fond',
+                                            NOEUD=LNOFO,
+                                            RESULTAT=RESULTAT,
+                                            NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',),
+                                            OPERATION='EXTRACTION',),);
+        tcoorf=__NCOFON.EXTR_TABLE()
+        DETRUIRE(CONCEPT=_F(NOM=__NCOFON),INFO=1) 
+        nbt = len(tcoorf['NOEUD'].values()['NOEUD'])
+        xs=array(tcoorf['COOR_X'].values()['COOR_X'][:nbt],Float)
+        ys=array(tcoorf['COOR_Y'].values()['COOR_Y'][:nbt],Float)
+        if ndim==2 : zs=Numeric.zeros(nbt,Float)
+        elif ndim==3 : zs=array(tcoorf['COOR_Z'].values()['COOR_Z'][:nbt],Float)
+        ns = tcoorf['NOEUD'].values()['NOEUD'][:nbt]
+        ns = map(string.rstrip,ns)
+        l_coorf =  [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)]
+        l_coorf = [(i[0],i[1:]) for i in l_coorf]
+        d_coorf = dict(l_coorf) 
+# Coordonnee d un pt quelconque des levres pr determination sens de propagation
+        cmail=MAILLAGE.NOMMAI.get()
+        for i in range(len(cmail)) :
+            if cmail[i] == ListmaS[0] : break
+        colcnx=MAILLAGE.CONNEX.get()
+        cnom = MAILLAGE.NOMNOE.get()
+        NO_TMP = []
+        for k in range(len(colcnx[i+1])) : NO_TMP.append(cnom[colcnx[i+1][k]-1])
+        __NCOLEV=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees pt levre',
+                                          NOEUD = NO_TMP,
+                                           RESULTAT=RESULTAT,
+                                           NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',),
+                                           OPERATION='EXTRACTION',),);
+        tcoorl=__NCOLEV.EXTR_TABLE()
+        DETRUIRE(CONCEPT=_F(NOM=__NCOLEV),INFO=1) 
+        nbt = len(tcoorl['NOEUD'].values()['NOEUD'])
+        xl=moy(tcoorl['COOR_X'].values()['COOR_X'][:nbt])
+        yl=moy(tcoorl['COOR_Y'].values()['COOR_Y'][:nbt])
+        zl=moy(tcoorl['COOR_Z'].values()['COOR_Z'][:nbt])
+        Plev = array([xl, yl, zl])
+# Calcul des normales a chaque noeud du fond
+        v1 =  array(VECT_K1)
+        VN = [None]*Nbfond
+        absfon = [0,]
+        if MODELISATION=='3D' :
+          DTANOR = FOND_FISS.DTAN_ORIGINE.get()
+          Pfon2 = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]])
+          VLori = Pfon2 - Plev
+          if DTANOR != None :
+            VN[0] = array(DTANOR)
+          else :
+            Pfon3 = array([d_coorf[LNOFO[1]][0],d_coorf[LNOFO[1]][1],d_coorf[LNOFO[1]][2]])
+            VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+            VN[0] = array(cross_product(VT,v1))
+          for i in range(1,Nbfond-1):
+            Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]])
+            Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]])
+            Pfon3 = array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]])
+            absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
+            absfon.append(absf)
+            VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+            VT = VT+(Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+            VN[i] = array(cross_product(VT,v1)) 
+            VN[i] = VN[i]/sqrt(dot(transpose(VN[i]),VN[i]))
+          i = Nbfond-1
+          Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]])
+          Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]])
+          VLextr = Pfon2 - Plev
+          absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
+          absfon.append(absf)
+          DTANEX = FOND_FISS.DTAN_EXTREMITE.get()
+          if DTANEX != None :
+            VN[i] = array(DTANEX)
+          else :
+            VT = (Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+            VN[i] = array(cross_product(VT,v1))
+          dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)])  
+          dicVN = dict([(LNOFO[i],VN[i]) for i in range(Nbfond)])
+#Sens de la tangente       
+          v = cross_product(VLori,VLextr)
+          sens = sign(dot(transpose(v),v1))
+#Cas 2D              
+        if MODELISATION!='3D' :
+          DTANOR = False
+          DTANEX = False
+          VT = array([0.,0.,1.])
+          VN = array(cross_product(v1,VT))
+          dicVN = dict([(LNOFO[0],VN)])
+          Pfon = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]])
+          VLori = Pfon - Plev
+          sens = sign(dot(transpose(VN),VLori))
+#Extraction dep sup/inf sur les normales          
+        TlibS = [None]*Nbf1
+        TlibI = [None]*Nbf1
+        if NB_NOEUD_COUPE < 3 : 
+          UTMESS('A','RUPTURE0_17')
+          NB_NOEUD_COUPE = 5
+        iret,ibid,n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT')
+        n_modele=n_modele.rstrip()
+        if len(n_modele)==0 : UTMESS('F','RUPTURE0_18')
+        MODEL = self.get_concept(n_modele)
+        dmax  = PREC_VIS_A_VIS * ABSC_CURV_MAXI
+        for i in range(Nbf1):
+          Porig = array(d_coorf[Lnf1[i]] )
+          if Lnf1[i]==LNOFO[0] and DTANOR : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]
+          elif Lnf1[i]==LNOFO[Nbfond-1] and DTANEX : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]
+          else : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]*sens
+          TlibS[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
+                NOM_CHAM='DEPL',MODELE=MODEL, VIS_A_VIS=_F(MAILLE_1 = ListmaS),
+                LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+                               TYPE='SEGMENT', COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+                               DISTANCE_MAX=dmax),);
+          if SYME_CHAR=='SANS':
+            TlibI[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
+                  NOM_CHAM='DEPL',MODELE=MODEL, VIS_A_VIS=_F(MAILLE_1 = ListmaI),
+                LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+                               TYPE='SEGMENT',COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+                               DISTANCE_MAX=dmax),);
+
+
+##### Cas maillage regle###########
+      else:
+#   ---------- Dictionnaires des levres  -------------  
+        NnormS = FOND_FISS.SUPNORM____NOEU.get()
+        if NnormS==None : 
+          UTMESS('F','RUPTURE0_19')
+        NnormS = map(string.rstrip,NnormS)
+        if LNOFO[0]==LNOFO[-1] and MODELISATION=='3D' : Nbfond=Nbfond-1  # Cas fond de fissure ferme
+        NnormS = [[LNOFO[i],NnormS[i*20:(i+1)*20]] for i in range(0,Nbfond)]
+        NnormS = [(i[0],i[1][0:]) for i in NnormS]
+        dicoS = dict(NnormS)
+        if SYME_CHAR=='SANS':
+           NnormI = FOND_FISS.INFNORM____NOEU.get()
+           if NnormI==None : 
+             UTMESS('F','RUPTURE0_20')
+           NnormI = map(string.rstrip,NnormI)
+           NnormI = [[LNOFO[i],NnormI[i*20:(i+1)*20]] for i in range(0,Nbfond)]
+           NnormI = [(i[0],i[1][0:]) for i in NnormI]
+           dicoI = dict(NnormI)
+
+#   ---------- Dictionnaire des coordonnees  -------------  
+        if RESULTAT :
+          Ltot = LNOFO
+          for i in range(Nbf1) :
+            for k in range(0,20) :
+              if dicoS[Lnf1[i]][k] !='': Ltot.append(dicoS[Lnf1[i]][k])
+          if SYME_CHAR=='SANS':
+            for i in range(Nbf1) :
+              for k in range(0,20) :
+                if dicoI[Lnf1[i]][k] !='': Ltot.append(dicoI[Lnf1[i]][k])
+          Ltot=dict([(i,0) for i in Ltot]).keys()
+          __NCOOR=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees noeuds des levres',
+                                            NOEUD=Ltot,
+                                            RESULTAT=RESULTAT,
+                                            NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',),
+                                            OPERATION='EXTRACTION',),);
+          tcoor=__NCOOR.EXTR_TABLE()
+          DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1)  
+        else :  
+          if SYME_CHAR=='SANS':
+            __NCOOR=CALC_TABLE(TABLE=TABL_DEPL_SUP,
+                        ACTION=_F(OPERATION = 'COMB',NOM_PARA='NOEUD',TABLE=TABL_DEPL_INF,))
+            tcoor=__NCOOR.EXTR_TABLE()
+            DETRUIRE(CONCEPT=_F(NOM=__NCOOR),INFO=1)  
+          else :
+            tcoor=TABL_DEPL_SUP.EXTR_TABLE()
+        nbt = len(tcoor['NOEUD'].values()['NOEUD'])
+        xs=array(tcoor['COOR_X'].values()['COOR_X'][:nbt],Float)
+        ys=array(tcoor['COOR_Y'].values()['COOR_Y'][:nbt],Float)
+        if ndim==2 : zs=Numeric.zeros(nbt,Float)
+        elif ndim==3 : zs=array(tcoor['COOR_Z'].values()['COOR_Z'][:nbt],Float)
+        ns = tcoor['NOEUD'].values()['NOEUD'][:nbt]
+        ns = map(string.rstrip,ns)
+        l_coor =  [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)]
+        l_coor = [(i[0],i[1:]) for i in l_coor]
+        d_coor = dict(l_coor)
+
+#   ---------- Abscisse curviligne du fond  -------------  
+        absfon = [0,]
+        for i in range(Nbfond-1) :
+          Pfon1 = array([d_coor[LNOFO[i]][0],d_coor[LNOFO[i]][1],d_coor[LNOFO[i]][2]])
+          Pfon2 = array([d_coor[LNOFO[i+1]][0],d_coor[LNOFO[i+1]][1],d_coor[LNOFO[i+1]][2]])
+          absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i]
+          absfon.append(absf)
+        dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)])
+
+     
+# ---Noeuds LEVRE_SUP et LEVRE_INF: ABSC_CURV_MAXI et PREC_VIS_A_VIS-----
+   
+        NBTRLS = 0
+        NBTRLI = 0
+        Lnosup = [None]*Nbf1
+        Lnoinf = [None]*Nbf1
+        Nbnofo = 0
+        Lnofon = []
+        precv = PREC_VIS_A_VIS
+        if ABSC_CURV_MAXI!=None : rmax = ABSC_CURV_MAXI
+        else                   : rmax = 100
+        precn = precv * rmax
+        rmprec= rmax*(1.+precv/10.)
+        for i in range(0,Nbf1) :
+           Pfon = array([d_coor[Lnf1[i]][0],d_coor[Lnf1[i]][1],d_coor[Lnf1[i]][2]])
+           Tmpsup = []
+           Tmpinf = []
+           itots = 0
+           itoti = 0
+           NBTRLS = 0
+           NBTRLI = 0
+           for k in range(0,20) :
+              if dicoS[Lnf1[i]][k] !='':
+                 itots = itots +1
+                 Nsup =  dicoS[Lnf1[i]][k]
+                 Psup = array([d_coor[Nsup][0],d_coor[Nsup][1],d_coor[Nsup][2]])
+                 abss = sqrt(dot(transpose(Pfon-Psup),Pfon-Psup))
+                 if abss<rmprec :
+                    NBTRLS = NBTRLS +1
+                    Tmpsup.append(dicoS[Lnf1[i]][k])
+              if SYME_CHAR=='SANS':
+                 if dicoI[Lnf1[i]][k] !='':
+                    itoti = itoti +1
+                    Ninf =  dicoI[Lnf1[i]][k]
+                    Pinf = array([d_coor[Ninf][0],d_coor[Ninf][1],d_coor[Ninf][2]])
+                    absi = sqrt(dot(transpose(Pfon-Pinf),Pfon-Pinf))
+# On verifie que les noeuds sont en vis a vis
+                    if abss<rmprec :
+                      dist = sqrt(dot(transpose(Psup-Pinf),Psup-Pinf))
+                      if dist>precn : 
+                        UTMESS('A','RUPTURE0_21',valk=Lnf1[i])
+                      else :
+                        NBTRLI = NBTRLI +1
+                        Tmpinf.append(dicoI[Lnf1[i]][k])
+# On verifie qu il y a assez de noeuds
+           if NBTRLS < 3 : 
+              UTMESS('A+','RUPTURE0_22',valk=Lnf1[i])
+              if Lnf1[i]==LNOFO[0] or Lnf1[i]==LNOFO[-1]: UTMESS('A+','RUPTURE0_23')
+              if itots<3 : UTMESS('A','RUPTURE0_24')
+              else : UTMESS('A','RUPTURE0_25')
+           elif (SYME_CHAR=='SANS') and (NBTRLI < 3) :
+              UTMESS('A+','RUPTURE0_26',valk=Lnf1[i])
+              if Lnf1[i]==LNOFO[0] or Lnf1[i]==LNOFO[-1]: UTMESS('A+','RUPTURE0_23')
+              if itoti<3 : UTMESS('A','RUPTURE0_24')
+              else :UTMESS('A','RUPTURE0_25')
+#              UTMESS('A','RUPTURE0_23')
+           else :
+              Lnosup[Nbnofo] = Tmpsup
+              if SYME_CHAR=='SANS' : Lnoinf[Nbnofo] = Tmpinf
+              Lnofon.append(Lnf1[i])
+              Nbnofo = Nbnofo+1
+        if Nbnofo == 0 :
+          UTMESS('F','RUPTURE0_30')
+
+#------------- Cas X-FEM ---------------------------------
+   elif FISSURE :
+     MAILLAGE = args['MAILLAGE']
+     DTAN_ORIG = args['DTAN_ORIG']
+     DTAN_EXTR = args['DTAN_EXTR']
+     dmax  = PREC_VIS_A_VIS * ABSC_CURV_MAXI
+#Projection du resultat sur le maillage lineaire initial     
+     iret,ibid,n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT')
+     n_modele=n_modele.rstrip()
+     if len(n_modele)==0 : UTMESS('F','RUPTURE0_18')
+     MODEL = self.get_concept(n_modele)
+     xcont = MODEL.xfem.XFEM_CONT.get()
+     if xcont[0] == 0 :
+       __RESX = RESULTAT
+# Si XFEM + contact : il faut reprojeter sur le maillage lineaire
+     if xcont[0] != 0 :
+       __MODLINE=AFFE_MODELE(MAILLAGE=MAILLAGE,
+                           AFFE=(_F(TOUT='OUI',
+                            PHENOMENE='MECANIQUE',
+                            MODELISATION=MODELISATION,),),);        
+       __RESX=PROJ_CHAMP(METHODE='ELEM',TYPE_CHAM='NOEU',NOM_CHAM='DEPL',
+                     RESULTAT=RESULTAT,
+                     MODELE_1=MODEL,
+                     MODELE_2=__MODLINE, );   
+#Recuperation des coordonnees des points du fond de fissure (x,y,z,absc_curv)
+     Listfo = FISSURE.FONDFISS.get()
+     Basefo = FISSURE.BASEFOND.get()
+     NB_POINT_FOND = args['NB_POINT_FOND']
+#Traitement du cas fond multiple
+     Fissmult = FISSURE.FONDMULT.get()
+     Nbfiss = len(Fissmult)/2
+     Numfiss = args['NUME_FOND']
+     if  Numfiss <= Nbfiss and Nbfiss > 1 :
+       Ptinit = Fissmult[2*(Numfiss-1)]
+       Ptfin = Fissmult[2*(Numfiss-1)+1]
+       Listfo2 = Listfo[((Ptinit-1)*4):(Ptfin*4)]
+       Listfo = Listfo2
+       Basefo2 = Basefo[((Ptinit-1)*(2*ndim)):(Ptfin*(2*ndim))]
+       Basefo = Basefo2
+     elif  Numfiss > Nbfiss :
+       UTMESS('F','RUPTURE1_38',vali=[Nbfiss,Numfiss])
+####     
+     
+     if NB_POINT_FOND != None and MODELISATION=='3D' :
+       Nbfond = NB_POINT_FOND
+       absmax = Listfo[-1]
+       Coorfo = [None]*4*Nbfond
+       Vpropa = [None]*3*Nbfond
+       for i in range(0,Nbfond) :
+         absci = i*absmax/(Nbfond-1)
+         Coorfo[(4*i):(4*(i+1))] = InterpolFondFiss(absci, Listfo)
+         Vpropa[(6*i):(6*(i+1))] = InterpolBaseFiss(absci,Basefo, Listfo)
+     else :
+       Coorfo = Listfo
+       Vpropa = Basefo
+       Nbfond = len(Coorfo)/4
+# Calcul de la direction de propagation en chaque point du fond
+     VP = [None]*Nbfond
+     VN = [None]*Nbfond
+     absfon = [0,]
+# Cas fissure non necessairement plane     
+     if VECT_K1 == None :
+       i = 0
+       if MODELISATION=='3D' :
+         if DTAN_ORIG != None :
+           VP[0] = array(DTAN_ORIG)
+           VP[0] = VP[0]/sqrt(VP[0][0]**2+VP[0][1]**2+VP[0][2]**2)
+           VN[0] = array([Vpropa[0],Vpropa[1],Vpropa[2]])
+           verif = dot(transpose(VP[0]),VN[0]) 
+           if abs(verif) > 0.01:
+             UTMESS('A','RUPTURE1_33',valr=[VN[0][0],VN[0][1],VN[0][2]])
+         else :
+           VN[0] = array([Vpropa[0],Vpropa[1],Vpropa[2]])
+           VP[0] = array([Vpropa[3+0],Vpropa[3+1],Vpropa[3+2]])
+         for i in range(1,Nbfond-1):
+           absf = Coorfo[4*i+3]
+           absfon.append(absf)
+           VN[i] = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+           VP[i] = array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]])
+           verif = dot(transpose(VN[i]),VN[i-1]) 
+           if abs(verif) < 0.98:
+             UTMESS('A','RUPTURE1_35',vali=[i-1,i])
+         i = Nbfond-1
+         absf =  Coorfo[4*i+3]
+         absfon.append(absf)
+         if DTAN_EXTR != None :
+           VP[i] = array(DTAN_EXTR)
+           VN[i] = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+           verif = dot(transpose(VP[i]),VN[0]) 
+           if abs(verif) > 0.01:
+             UTMESS('A','RUPTURE1_34',valr=[VN[i][0],VN[i][1],VN[i][2]])
+         else :
+           VN[i] = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+           VP[i] = array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]])
+       else : 
+         for i in range(0,Nbfond):
+           VP[i] = array([Vpropa[2+4*i],Vpropa[3+4*i],0.])
+           VN[i] = array([Vpropa[0+4*i],Vpropa[1+4*i],0.])
+# Cas fissure plane (VECT_K1 donne)
+     if VECT_K1 != None :
+       v1 =  array(VECT_K1)
+       v1  = v1/sqrt(v1[0]**2+v1[1]**2+v1[2]**2)
+       v1 =  array(VECT_K1)
+       i = 0
+       if MODELISATION=='3D' :
+# Sens du vecteur VECT_K1       
+         v1x =array([Vpropa[0],Vpropa[1],Vpropa[2]])
+         verif = dot(transpose(v1),v1x) 
+         if verif < 0 : v1 = -v1
+         VN = [v1]*Nbfond
+         if DTAN_ORIG != None :
+           VP[i] = array(DTAN_ORIG)
+           VP[i] = VP[i]/sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2)
+           verif = dot(transpose(VP[i]),VN[0]) 
+           if abs(verif) > 0.01:
+             UTMESS('A','RUPTURE1_36')
+         else :
+           Pfon2 = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+           Pfon3 = array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]])
+           VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+           VP[0] = array(cross_product(VT,v1))
+           VNi = array([Vpropa[3],Vpropa[4],Vpropa[5]])
+           verif = dot(transpose(VP[i]),VNi) 
+           if abs(verif) < 0.99:
+             vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+             UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+         for i in range(1,Nbfond-1):
+           Pfon1 = array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]])
+           Pfon2 = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+           Pfon3 = array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]])
+           absf =  Coorfo[4*i+3]
+           absfon.append(absf)
+           VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+           VT = VT+(Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+           VP[i] = array(cross_product(VT,v1)) 
+           VP[i] = VP[i]/sqrt(dot(transpose(VP[i]),VP[i]))
+           VNi = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+           verif = dot(transpose(VN[i]),VNi) 
+           if abs(verif) < 0.99:
+             vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+             UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+         i = Nbfond-1
+         Pfon1 = array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]])
+         Pfon2 = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+         absf =  Coorfo[4*i+3]
+         absfon.append(absf)
+         if DTAN_EXTR != None :
+           VP[i] = array(DTAN_EXTR)
+           VP[i] = VP[i]/sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2)
+           verif = dot(transpose(VP[i]),VN[i]) 
+           if abs(verif) > 0.01:
+             UTMESS('A','RUPTURE1_37')
+         else :
+           VT = (Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+           VP[i] = array(cross_product(VT,v1))
+           VNi = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]])
+           verif = dot(transpose(VN[i]),VNi) 
+           if abs(verif) < 0.99 :
+             vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+             UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+       else :  
+         VT = array([0.,0.,1.])
+         for i in range(0,Nbfond):
+           VP[i] = array(cross_product(v1,VT))  
+           VN[i] = v1
+           VNi = array([Vpropa[0+4*i],Vpropa[1+4*i],0.])
+           verif = dot(transpose(VN[i]),VNi) 
+           if abs(verif) < 0.99 :
+             vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],]
+             UTMESS('A','RUPTURE0_32',vali=[i],valr=vv)
+#Sens de la tangente   
+     if MODELISATION=='3D' : i = Nbfond/2
+     else : i = 0
+     Po =  array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+     Porig = Po + ABSC_CURV_MAXI*VP[i]
+     Pextr = Po - ABSC_CURV_MAXI*VP[i]
+     __Tabg = MACR_LIGN_COUPE(RESULTAT=__RESX,NOM_CHAM='DEPL',
+                   LIGN_COUPE=_F(NB_POINTS=3,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+                                  TYPE='SEGMENT',COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+                                  DISTANCE_MAX=dmax),);
+     tmp=__Tabg.EXTR_TABLE()
+#     a sam
+     test = getattr(tmp,'H1X').values()
+#     test = getattr(tmp,'E1X').values()
+     if test==[None]*3 : 
+        UTMESS('F','RUPTURE0_33')
+     if test[0]!=None :
+       sens = 1
+     else :
+       sens = -1
+     DETRUIRE(CONCEPT=_F(NOM=__Tabg),INFO=1) 
+# Extraction des sauts sur la fissure          
+     NB_NOEUD_COUPE = args['NB_NOEUD_COUPE']
+     if NB_NOEUD_COUPE < 3 : 
+       UTMESS('A','RUPTURE0_34')
+       NB_NOEUD_COUPE = 5
+     mcfact=[]
+     for i in range(Nbfond):
+        Porig = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]])
+        if i==0 and DTAN_ORIG!=None : Pextr = Porig - ABSC_CURV_MAXI*VP[i]
+        elif i==(Nbfond-1) and DTAN_EXTR!=None : Pextr = Porig - ABSC_CURV_MAXI*VP[i]
+        else : Pextr = Porig + ABSC_CURV_MAXI*VP[i]*sens
+        mcfact.append(_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
+                          TYPE='SEGMENT',COOR_EXTR=(Pextr[0],Pextr[1],Pextr[2]),
+                          DISTANCE_MAX=dmax),)
+     TSo = MACR_LIGN_COUPE(RESULTAT=__RESX,NOM_CHAM='DEPL',
+                         LIGN_COUPE=mcfact);
+
+     TTSo = TSo.EXTR_TABLE()
+     DETRUIRE(CONCEPT=_F(NOM=TSo),INFO=1) 
+     Nbnofo = Nbfond
+     if xcont[0] != 0 :  
+       DETRUIRE(CONCEPT=_F(NOM=__MODLINE),INFO=1) 
+       DETRUIRE(CONCEPT=_F(NOM=__RESX),INFO=1) 
+   
+     if INFO==2 :
+        mcfact=[]
+        mcfact.append(_F(PARA='PT_FOND',LISTE_I=range(Nbfond)))
+        mcfact.append(_F(PARA='VN_X'        ,LISTE_R=[VN[i][0] for i in range(Nbfond)]))
+        mcfact.append(_F(PARA='VN_Y'        ,LISTE_R=[VN[i][1] for i in range(Nbfond)]))
+        mcfact.append(_F(PARA='VN_Z'        ,LISTE_R=[VN[i][2] for i in range(Nbfond)]))
+        mcfact.append(_F(PARA='VP_X'        ,LISTE_R=[VP[i][0] for i in range(Nbfond)]))
+        mcfact.append(_F(PARA='VP_Y'        ,LISTE_R=[VP[i][1] for i in range(Nbfond)]))
+        mcfact.append(_F(PARA='VP_Z'        ,LISTE_R=[VP[i][2] for i in range(Nbfond)]))
+        __resu2=CREA_TABLE(LISTE=mcfact,TITRE='             VECTEUR NORMAL A LA FISSURE    -    DIRECTION DE PROPAGATION')
+        aster.affiche('MESSAGE',__resu2.EXTR_TABLE().__repr__())
+        DETRUIRE(CONCEPT=_F(NOM=__resu2),INFO=1)
+   
+   else :
+     Nbnofo = 1 
+     
+#   ----------Recuperation de la temperature au fond -------------  
+   if Tempe3D :
+      Rth = self.get_concept(resuth)
+      __TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='Temperature fond de fissure',
+                                       NOEUD=Lnofon,TOUT_CMP='OUI',
+                                       RESULTAT=Rth,NOM_CHAM='TEMP',TOUT_ORDRE='OUI',
+                                       OPERATION='EXTRACTION',),);
+      tabtemp=__TEMP.EXTR_TABLE()
+      DETRUIRE(CONCEPT=_F(NOM=__TEMP),INFO=1) 
+   
+
+#   ------------------------------------------------------------------
+#                         BOUCLE SUR NOEUDS DU FOND
+#   ------------------------------------------------------------------
+   for ino in range(0,Nbnofo) :
+      if FOND_FISS and INFO==2 :
+            texte="\n\n--> TRAITEMENT DU NOEUD DU FOND DE FISSURE: %s"%Lnofon[ino]
+            aster.affiche('MESSAGE',texte)
+      if FISSURE and INFO==2 :
+            texte="\n\n--> TRAITEMENT DU POINT DU FOND DE FISSURE NUMERO %s"%(ino+1)
+            aster.affiche('MESSAGE',texte)
+#   ------------------------------------------------------------------
+#                         TABLE 'DEPSUP'
+#   ------------------------------------------------------------------
+      if FOND_FISS : 
+         if TYPE_MAILLAGE =='LIBRE':
+            tabsup=TlibS[ino].EXTR_TABLE()
+            DETRUIRE(CONCEPT=_F(NOM=TlibS[ino]),INFO=1)
+         elif RESULTAT :
+            __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
+                                          NOEUD=Lnosup[ino],
+                                          RESULTAT=RESULTAT,
+                                          NOM_CHAM='DEPL',
+                                          TOUT_ORDRE='OUI',
+                                          NOM_CMP=('DX','DY','DZ',),
+                                          OPERATION='EXTRACTION',),);
+            tabsup=__TSUP.EXTR_TABLE()
+            DETRUIRE(CONCEPT=_F(NOM=__TSUP),INFO=1)      
+         else :
+            tabsup=TABL_DEPL_SUP.EXTR_TABLE()
+            veri_tab(tabsup,TABL_DEPL_SUP.nom,ndim)
+            Ls = [string.ljust(Lnosup[ino][i],8) for i in range(len(Lnosup[ino]))]
+            tabsup=tabsup.NOEUD==Ls
+      elif FISSURE :
+         tabsup = TTSo.INTITULE=='l.coupe%i'%(ino+1)
+      else :
+         tabsup=TABL_DEPL_SUP.EXTR_TABLE()
+         veri_tab(tabsup,TABL_DEPL_SUP.nom,ndim)
+
+#   ------------------------------------------------------------------
+#                          TABLE 'DEPINF'
+#   ------------------------------------------------------------------
+      if SYME_CHAR=='SANS' and not FISSURE : 
+         if FOND_FISS : 
+            if TYPE_MAILLAGE =='LIBRE':
+               tabinf=TlibI[ino].EXTR_TABLE()
+               DETRUIRE(CONCEPT=_F(NOM=TlibI[ino]),INFO=1)
+            elif RESULTAT :
+               __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
+                                          NOEUD=Lnoinf[ino],
+                                          RESULTAT=RESULTAT,
+                                          NOM_CHAM='DEPL',
+                                          TOUT_ORDRE='OUI',
+                                          NOM_CMP=('DX','DY','DZ',),
+                                          OPERATION='EXTRACTION',),);
+               tabinf=__TINF.EXTR_TABLE()   
+               DETRUIRE(CONCEPT=_F(NOM=__TINF),INFO=1)                 
+            else :
+               tabinf=TABL_DEPL_INF.EXTR_TABLE()
+               if TABL_DEPL_INF==None : UTMESS('F','RUPTURE0_35')
+               veri_tab(tabinf,TABL_DEPL_INF.nom,ndim)
+               Li = [string.ljust(Lnoinf[ino][i],8) for i in range(len(Lnoinf[ino]))]
+               tabinf=tabinf.NOEUD==Li
+         else :
+            if TABL_DEPL_INF==None : UTMESS('F','RUPTURE0_35')
+            tabinf=TABL_DEPL_INF.EXTR_TABLE()
+            veri_tab(tabinf,TABL_DEPL_INF.nom,ndim)
+
+
+#   ------------------------------------------------------------------
+#               LES INSTANTS DE POST-TRAITEMENT
+#   ------------------------------------------------------------------
+      if 'INST' in tabsup.para : 
+         l_inst=None
+         l_inst_tab=tabsup['INST'].values()['INST']
+         l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() #elimine les doublons
+         l_inst_tab.sort()
+         if LIST_ORDRE !=None or NUME_ORDRE !=None :
+           l_ord_tab = tabsup['NUME_ORDRE'].values()['NUME_ORDRE']
+           l_ord_tab.sort()
+           l_ord_tab=dict([(i,0) for i in l_ord_tab]).keys() 
+           d_ord_tab= [[l_ord_tab[i],l_inst_tab[i]] for i in range(0,len(l_ord_tab))]
+           d_ord_tab= [(i[0],i[1]) for i in d_ord_tab]
+           d_ord_tab = dict(d_ord_tab)
+           if NUME_ORDRE !=None : 
+             if type(NUME_ORDRE) not in EnumTypes : NUME_ORDRE=(NUME_ORDRE,)
+             l_ord=list(NUME_ORDRE)
+           elif LIST_ORDRE !=None : 
+              l_ord = LIST_ORDRE.VALE.get() 
+           l_inst = []
+           for ord in l_ord :
+             if ord in l_ord_tab : l_inst.append(d_ord_tab[ord])
+             else :  
+               UTMESS('F','RUPTURE0_37',vali=ord)
+           PRECISION = 1.E-6
+           CRITERE='ABSOLU'
+         elif INST !=None or LIST_INST !=None :
+            CRITERE = args['CRITERE']
+            PRECISION = args['PRECISION']
+            if  INST !=None : 
+              if type(INST) not in EnumTypes : INST=(INST,)
+              l_inst=list(INST)
+            elif LIST_INST !=None : l_inst=LIST_INST.Valeurs()
+            for inst in l_inst  :
+               if CRITERE=='RELATIF' and inst!=0.: match=[x for x in l_inst_tab if abs((inst-x)/inst)<PRECISION]
+               else                              : match=[x for x in l_inst_tab if abs(inst-x)<PRECISION]
+               if len(match)==0 : 
+                 UTMESS('F','RUPTURE0_38',valr=inst)
+               if len(match)>=2 :
+                 UTMESS('F','RUPTURE0_39',valr=inst)
+         else :
+            l_inst=l_inst_tab
+            PRECISION = 1.E-6
+            CRITERE='ABSOLU'
+      else :
+         l_inst  = [None,]
+   
+#   ------------------------------------------------------------------
+#                         BOUCLE SUR LES INSTANTS
+#   ------------------------------------------------------------------
+      for iord in range(len(l_inst)) :
+        inst=l_inst[iord]
+        if INFO==2 and inst!=None:
+            texte="#=================================================================================\n"
+            texte=texte+"==> INSTANT: %f"%inst
+            aster.affiche('MESSAGE',texte)
+        if inst!=None:
+           if PRECISION == None : PRECISION = 1.E-6
+           if CRITERE == None : CRITERE='ABSOLU'
+           if inst==0. :
+             tabsupi=tabsup.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION)
+             if SYME_CHAR=='SANS'and not FISSURE: tabinfi=tabinf.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION)
+           else :
+             tabsupi=tabsup.INST.__eq__(VALE=inst,CRITERE=CRITERE,PRECISION=PRECISION)
+             if SYME_CHAR=='SANS' and not FISSURE: tabinfi=tabinf.INST.__eq__(VALE=inst,CRITERE=CRITERE,PRECISION=PRECISION)
+        else :
+           tabsupi=tabsup
+           if SYME_CHAR=='SANS' and not FISSURE : tabinfi=tabinf
+
+#     --- LEVRE SUP :  "ABSC_CURV" CROISSANTES, < RMAX ET DEP ---
+        abscs = getattr(tabsupi,'ABSC_CURV').values()
+        if not FISSURE :
+          if not FOND_FISS :
+            refs=copy.copy(abscs)
+            refs.sort()
+            if refs!=abscs :
+               mctabl='TABL_DEPL_INF' 
+               UTMESS('F','RUPTURE0_40',valk=mctabl)
+            if ABSC_CURV_MAXI!=None : rmax = ABSC_CURV_MAXI
+            else                    : rmax = abscs[-1]
+            precv = PREC_VIS_A_VIS
+            rmprec= rmax*(1.+precv/10.)
+            refsc=[x for x in refs if x<rmprec]
+            nbval = len(refsc)
+          else :
+            nbval=len(abscs)
+          abscs=array(abscs[:nbval])
+          coxs=array(tabsupi['COOR_X'].values()['COOR_X'][:nbval],Float)
+          coys=array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval],Float)
+          if ndim==2 :  cozs=Numeric.zeros(nbval,Float)
+          elif ndim==3 :  cozs=array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval],Float)
+          
+          if FOND_FISS and not RESULTAT : #tri des noeuds avec abscisse
+            Pfon = array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]])
+            abscs = sqrt((coxs-Pfon[0])**2+(coys-Pfon[1])**2+(cozs-Pfon[2])**2)
+            tabsupi['Abs_fo'] = abscs
+            tabsupi.sort('Abs_fo')
+            abscs = getattr(tabsupi,'Abs_fo').values()
+            abscs=array(abscs[:nbval])
+            coxs=array(tabsupi['COOR_X'].values()['COOR_X'][:nbval],Float)
+            coys=array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval],Float)
+            if ndim==2 :  cozs=Numeric.zeros(nbval,Float)
+            elif ndim==3 :  cozs=array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval],Float)
+            
+          if FOND_FISS and INFO==2 and iord==0 and not TYPE_MAILLAGE =='LIBRE':
+            for ks in range(0,nbval) :
+              texte="NOEUD RETENU POUR LA LEVRE SUP: %s  %f"%(Lnosup[ino][ks],abscs[ks])
+              aster.affiche('MESSAGE',texte)
+          dxs=array(tabsupi['DX'].values()['DX'][:nbval],Float)
+          dys=array(tabsupi['DY'].values()['DY'][:nbval],Float)
+          if ndim==2 : dzs=Numeric.zeros(nbval,Float)
+          elif ndim==3 : dzs=array(tabsupi['DZ'].values()['DZ'][:nbval],Float)
+          
+#     --- LEVRE INF :  "ABSC_CURV" CROISSANTES et < RMAX ---
+        if SYME_CHAR=='SANS' and not FISSURE : 
+          absci = getattr(tabinfi,'ABSC_CURV').values()
+          if not FOND_FISS :
+            refi=copy.copy(absci)
+            refi.sort()
+            if refi!=absci :
+                mctabl='TABL_DEPL_SUP' 
+                UTMESS('F','RUPTURE0_40',valk=mctabl)
+            refic=[x for x in refi if x<rmprec]
+            nbvali=len(refic)
+          else :
+            nbvali=len(absci)
+          if nbvali!=nbval :
+             if FOND_FISS : 
+                UTMESS('A+','RUPTURE0_42')
+                UTMESS('A','RUPTURE0_43',valk=Lnofon[i],vali=[len(refsc),len(refic)])
+             else:
+                UTMESS('A','RUPTURE0_42')
+          nbval=min(nbval,nbvali)
+          absci=array(absci[:nbval])
+          coxi=array(tabinfi['COOR_X'].values()['COOR_X'][:nbval],Float)
+          coyi=array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval],Float)
+          if ndim==2 : cozi=Numeric.zeros(nbval,Float)
+          elif ndim==3 : cozi=array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval],Float)
+#     --- ON VERIFIE QUE LES NOEUDS SONT EN VIS_A_VIS  (SYME=SANS)   ---
+          if not FOND_FISS :
+            precn = precv * rmax
+            dist=(coxs-coxi)**2+(coys-coyi)**2+(cozs-cozi)**2
+            dist=sqrt(dist)
+            for d in dist :
+               if d>precn : UTMESS('F','RUPTURE0_44')
+          
+          if FOND_FISS and not RESULTAT :#tri des noeuds avec abscisse
+            Pfon = array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]])
+            absci = sqrt((coxi-Pfon[0])**2+(coyi-Pfon[1])**2+(cozi-Pfon[2])**2)
+            tabinfi['Abs_fo'] = absci
+            tabinfi.sort('Abs_fo')
+            absci = getattr(tabinfi,'Abs_fo').values()
+            absci=array(abscs[:nbval])
+            coxi=array(tabinfi['COOR_X'].values()['COOR_X'][:nbval],Float)
+            coyi=array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval],Float)
+            if ndim==2 :  cozi=Numeric.zeros(nbval,Float)
+            elif ndim==3 :  cozi=array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval],Float)
+
+          dxi=array(tabinfi['DX'].values()['DX'][:nbval],Float)
+          dyi=array(tabinfi['DY'].values()['DY'][:nbval],Float)
+          if ndim==2 : dzi=Numeric.zeros(nbval,Float)
+          elif ndim==3 : dzi=array(tabinfi['DZ'].values()['DZ'][:nbval],Float)
+          
+          if FOND_FISS and INFO==2 and iord==0 and not TYPE_MAILLAGE =='LIBRE':
+            for ki in range(0,nbval) :
+               texte="NOEUD RETENU POUR LA LEVRE INF: %s  %f"%(Lnoinf[ino][ki],absci[ki])
+               aster.affiche('MESSAGE',texte)
+
+#     --- CAS FISSURE X-FEM ---
+        if  FISSURE : 
+           H1 = getattr(tabsupi,'H1X').values()
+           nbval = len(H1)
+           H1 = complete(H1)
+           E1 = getattr(tabsupi,'E1X').values()
+           E1 = complete(E1)
+           dxs = 2*(H1 + sqrt(abscs)*E1)
+           H1 = getattr(tabsupi,'H1Y').values()
+           E1 = getattr(tabsupi,'E1Y').values()
+           H1 = complete(H1)
+           E1 = complete(E1)
+           dys = 2*(H1 + sqrt(abscs)*E1)
+           H1 = getattr(tabsupi,'H1Z').values()
+           E1 = getattr(tabsupi,'E1Z').values()
+           H1 = complete(H1)
+           E1 = complete(E1)
+           dzs = 2*(H1 + sqrt(abscs)*E1)
+           abscs=array(abscs[:nbval])
+
+#   ---------- CALCUL PROP. MATERIAU AVEC TEMPERATURE -----------  
+        if Tempe3D :
+           tempeno=tabtemp.NOEUD==Lnofon[ino]
+           tempeno=tempeno.INST.__eq__(VALE=inst,CRITERE='ABSOLU',PRECISION=PRECISION)
+           nompar = ('TEMP',)
+           valpar = (tempeno.TEMP.values()[0],)
+           nomres=['E','NU']
+           valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F')
+           e = valres[0]
+           nu = valres[1] 
+           coefd  = e * sqrt(2.*pi)      / ( 8.0 * (1. - nu**2))
+           coefd3 = e*sqrt(2*pi) / ( 8.0 * (1. + nu))
+           coefg  = (1. - nu**2) / e
+           coefg3 = (1. + nu)  / e
+
+#     --- TESTS NOMBRE DE NOEUDS---
+        if nbval<3 :
+           UTMESS('A+','RUPTURE0_46')
+           if FOND_FISS :
+               UTMESS('A+','RUPTURE0_47',valk=Lnofon[ino])
+           if FISSURE :
+               UTMESS('A+','RUPTURE0_99',vali=ino)
+           UTMESS('A','RUPTURE0_25')
+           kg1 = [0.]*8
+           kg2 =[0.]*8
+           kg3 =[0.]*8
+         
+        else :  
+#     SI NBVAL >= 3 : 
+
+#     ------------------------------------------------------------------
+#                    CHANGEMENT DE REPERE
+#     ------------------------------------------------------------------
+#
+#       1 : VECTEUR NORMAL AU PLAN DE LA FISSURE
+#           ORIENTE LEVRE INFERIEURE VERS LEVRE SUPERIEURE
+#       2 : VECTEUR NORMAL AU FOND DE FISSURE EN M
+#       3 : VECTEUR TANGENT AU FOND DE FISSURE EN M
+#
+         if FISSURE :
+            v2 = VP[ino]
+            v1 = VN[ino]
+         elif SYME_CHAR=='SANS' :
+            vo =  array([( coxs[-1]+coxi[-1] )/2.,( coys[-1]+coyi[-1] )/2.,( cozs[-1]+cozi[-1] )/2.])
+            ve =  array([( coxs[0 ]+coxi[0 ] )/2.,( coys[0 ]+coyi[0 ] )/2.,( cozs[0 ]+cozi[0 ] )/2.])
+            v2 =  ve-vo
+         else :
+            vo = array([ coxs[-1], coys[-1], cozs[-1]])
+            ve = array([ coxs[0], coys[0], cozs[0]])
+            v2 =  ve-vo
+         if not FISSURE :  v1 =  array(VECT_K1)
+         v2 =  v2/sqrt(v2[0]**2+v2[1]**2+v2[2]**2)
+         v1p = sum(v2*v1)
+         if SYME_CHAR=='SANS' : v1  = v1-v1p*v2
+         else : v2  = v2-v1p*v1 
+         v1  = v1/sqrt(v1[0]**2+v1[1]**2+v1[2]**2)
+         v2 =  v2/sqrt(v2[0]**2+v2[1]**2+v2[2]**2)
+         v3  = array([v1[1]*v2[2]-v2[1]*v1[2],v1[2]*v2[0]-v2[2]*v1[0],v1[0]*v2[1]-v2[0]*v1[1]])
+         pgl  = asarray([v1,v2,v3])
+         dpls = asarray([dxs,dys,dzs])
+         dpls = matrixmultiply(pgl,dpls)
+         if SYME_CHAR!='SANS' and abs(dpls[0][0]) > 1.e-10 :
+           UTMESS('A','RUPTURE0_49',valk=[Lnofon[ino],SYME_CHAR])
+         if FISSURE :
+            saut=dpls
+         elif SYME_CHAR=='SANS' :
+            dpli = asarray([dxi,dyi,dzi])
+            dpli = matrixmultiply(pgl,dpli)
+            saut=(dpls-dpli)
+         else :
+            dpli = [multiply(dpls[0],-1.),dpls[1],dpls[2]]
+            saut=(dpls-dpli)
+         if INFO==2 :
+           mcfact=[]
+           mcfact.append(_F(PARA='ABSC_CURV'  ,LISTE_R=abscs.tolist() ))
+           if not FISSURE :
+             mcfact.append(_F(PARA='DEPL_SUP_1',LISTE_R=dpls[0].tolist() ))
+             mcfact.append(_F(PARA='DEPL_INF_1',LISTE_R=dpli[0].tolist() ))
+           mcfact.append(_F(PARA='SAUT_1'    ,LISTE_R=saut[0].tolist() ))
+           if not FISSURE :
+             mcfact.append(_F(PARA='DEPL_SUP_2',LISTE_R=dpls[1].tolist() ))
+             mcfact.append(_F(PARA='DEPL_INF_2',LISTE_R=dpli[1].tolist() ))
+           mcfact.append(_F(PARA='SAUT_2'    ,LISTE_R=saut[1].tolist() ))
+           if ndim==3 :
+             if not FISSURE :
+               mcfact.append(_F(PARA='DEPL_SUP_3',LISTE_R=dpls[2].tolist() ))
+               mcfact.append(_F(PARA='DEPL_INF_3',LISTE_R=dpli[2].tolist() ))
+             mcfact.append(_F(PARA='SAUT_3'    ,LISTE_R=saut[2].tolist() ))
+           __resu0=CREA_TABLE(LISTE=mcfact,TITRE='--> SAUTS')
+           aster.affiche('MESSAGE',__resu0.EXTR_TABLE().__repr__())
+           DETRUIRE(CONCEPT=_F(NOM=__resu0),INFO=1)
+#     ------------------------------------------------------------------
+#                           CALCUL DES K1, K2, K3
+#     ------------------------------------------------------------------
+         isig=sign(transpose(resize(saut[:,-1],(nbval-1,3))))
+         isig=sign(isig+0.001)
+         saut=saut*array([[coefd]*nbval,[coefd]*nbval,[coefd3]*nbval])
+         saut=saut**2
+         ksig = isig[:,1]
+         ksig = array([ksig,ksig])
+         ksig = transpose(ksig)
+         kgsig=resize(ksig,(1,6))[0]
+#     ------------------------------------------------------------------
+#                           --- METHODE 1 ---
+#     ------------------------------------------------------------------
+         nabs = len(abscs)
+         x1 = abscs[1:-1]
+         x2 = abscs[2:nabs]
+         y1 = saut[:,1:-1]/x1
+         y2 = saut[:,2:nabs]/x2
+         k  = abs(y1-x1*(y2-y1)/(x2-x1))
+         g  = coefg*(k[0]+k[1])+coefg3*k[2]
+         kg1 = [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])]
+         kg1 = sqrt(kg1)*kgsig
+         kg1=Numeric.concatenate([kg1,[max(g),min(g)]])
+         vk  = sqrt(k)*isig[:,:-1]
+         if INFO==2 :
+           mcfact=[]
+           mcfact.append(_F(PARA='ABSC_CURV_1' ,LISTE_R=x1.tolist() ))
+           mcfact.append(_F(PARA='ABSC_CURV_2' ,LISTE_R=x2.tolist() ))
+           mcfact.append(_F(PARA='K1'          ,LISTE_R=vk[0].tolist() ))
+           mcfact.append(_F(PARA='K2'          ,LISTE_R=vk[1].tolist() ))
+           if ndim==3 :
+             mcfact.append(_F(PARA='K3'        ,LISTE_R=vk[2].tolist() ))
+           mcfact.append(_F(PARA='G'           ,LISTE_R=g.tolist() ))
+           __resu1=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 1')
+           aster.affiche('MESSAGE',__resu1.EXTR_TABLE().__repr__())
+           DETRUIRE(CONCEPT=_F(NOM=__resu1),INFO=1)
+#     ------------------------------------------------------------------
+#                           --- METHODE 2 ---
+#     ------------------------------------------------------------------
+         nabs = len(abscs)
+         x1 = abscs[1:nabs]
+         y1 = saut[:,1:nabs]
+         k  = abs(y1/x1)
+         g  = coefg*(k[0]+k[1])+coefg3*k[2]
+         kg2= [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])]
+         kg2 = sqrt(kg2)*kgsig
+         kg2=Numeric.concatenate([kg2,[max(g),min(g)]])
+         vk = sqrt(k)*isig
+         if INFO==2 :
+           mcfact=[]
+           mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=x1.tolist() ))
+           mcfact.append(_F(PARA='K1'        ,LISTE_R=vk[0].tolist() ))
+           mcfact.append(_F(PARA='K2'        ,LISTE_R=vk[1].tolist() ))
+           if ndim==3 :
+             mcfact.append(_F(PARA='K3'      ,LISTE_R=vk[2].tolist() ))
+           mcfact.append(_F(PARA='G'         ,LISTE_R=g.tolist() ))
+           __resu2=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 2')
+           aster.affiche('MESSAGE',__resu2.EXTR_TABLE().__repr__())
+           DETRUIRE(CONCEPT=_F(NOM=__resu2),INFO=1)
+#     ------------------------------------------------------------------
+#                           --- METHODE 3 ---
+#     ------------------------------------------------------------------
+         nabs = len(abscs)
+         x1 = abscs[:-1]
+         x2 = abscs[1:nabs]
+         y1 = saut[:,:-1]
+         y2 = saut[:,1:nabs]
+         k  = (sqrt(y2)*sqrt(x2)+sqrt(y1)*sqrt(x1))*(x2-x1)
+         k  = Numeric.sum(transpose(k))
+         de = abscs[-1]
+         vk = (k/de**2)*isig[:,0]
+         g  = coefg*(vk[0]**2+vk[1]**2)+coefg3*vk[2]**2
+         kg3=Numeric.concatenate([[vk[0]]*2,[vk[1]]*2,[vk[2]]*2,[g]*2])
+         if INFO==2 :
+           mcfact=[]
+           mcfact.append(_F(PARA='K1'        ,LISTE_R=vk[0] ))
+           mcfact.append(_F(PARA='K2'        ,LISTE_R=vk[1] ))
+           if ndim==3 :
+             mcfact.append(_F(PARA='K3'      ,LISTE_R=vk[2] ))
+           mcfact.append(_F(PARA='G'         ,LISTE_R=g ))
+           __resu3=CREA_TABLE(LISTE=mcfact,TITRE='--> METHODE 3')
+           aster.affiche('MESSAGE',__resu3.EXTR_TABLE().__repr__())
+           DETRUIRE(CONCEPT=_F(NOM=__resu3),INFO=1)
+#     ------------------------------------------------------------------
+#                           CREATION DE LA TABLE 
+#     ------------------------------------------------------------------
+        kg=array([kg1,kg2,kg3])
+        kg=transpose(kg)
+        mcfact=[]
+        if TITRE != None :
+          titre = TITRE
+        else :
+          v = aster.__version__
+          titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K1_K2_K3 LE &DATE A &HEURE \n'%v
+        if FOND_FISS and MODELISATION=='3D': 
+          mcfact.append(_F(PARA='NOEUD_FOND',LISTE_K=[Lnofon[ino],]*3))
+          mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[dicoF[Lnofon[ino]]]*3))
+        if FISSURE and MODELISATION=='3D': 
+          mcfact.append(_F(PARA='PT_FOND',LISTE_I=[ino+1,]*3))
+          mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[absfon[ino],]*3))
+        if FISSURE  and MODELISATION!='3D' and Nbfond!=1 :
+          mcfact.append(_F(PARA='PT_FOND',LISTE_I=[ino+1,]*3))
+        mcfact.append(_F(PARA='METHODE',LISTE_I=(1,2,3)))
+        mcfact.append(_F(PARA='K1_MAX' ,LISTE_R=kg[0].tolist() ))
+        mcfact.append(_F(PARA='K1_MIN' ,LISTE_R=kg[1].tolist() ))
+        mcfact.append(_F(PARA='K2_MAX' ,LISTE_R=kg[2].tolist() ))
+        mcfact.append(_F(PARA='K2_MIN' ,LISTE_R=kg[3].tolist() ))
+        if ndim==3 :
+          mcfact.append(_F(PARA='K3_MAX' ,LISTE_R=kg[4].tolist() ))
+          mcfact.append(_F(PARA='K3_MIN' ,LISTE_R=kg[5].tolist() ))
+        mcfact.append(_F(PARA='G_MAX'  ,LISTE_R=kg[6].tolist() ))
+        mcfact.append(_F(PARA='G_MIN'  ,LISTE_R=kg[7].tolist() ))
+        if  (ino==0 and iord==0) and inst==None :
+           tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre)
+        elif iord==0 and ino==0 and inst!=None :
+           mcfact=[_F(PARA='INST'  ,LISTE_R=[inst,]*3      )]+mcfact
+           tabout=CREA_TABLE(LISTE=mcfact,TITRE = titre)
+        else :
+           if inst!=None : mcfact=[_F(PARA='INST'  ,LISTE_R=[inst,]*3     )]+mcfact
+           __tabi=CREA_TABLE(LISTE=mcfact,)
+           npara = ['K1_MAX','METHODE']
+           if inst!=None : npara.append('INST')
+           if FOND_FISS and MODELISATION=='3D' : npara.append('NOEUD_FOND')
+           tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,TITRE = titre,
+                              ACTION=_F(OPERATION = 'COMB',NOM_PARA=npara,TABLE=__tabi,))
+
+# Tri de la table
+   if len(l_inst)!=1 and MODELISATION=='3D':
+      tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,
+                      ACTION=_F(OPERATION = 'TRI',NOM_PARA=('INST','ABSC_CURV','METHODE'),ORDRE='CROISSANT'))
+
+   return ier
+ 

diff --git a/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py b/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py
new file mode 100644 (file)
index 0000000..d0a3b89
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/post_k_trans_ops.py
@@ -0,0 +1,240 @@
+#@ MODIF post_k_trans_ops Macro  DATE 07/10/2008   AUTEUR PELLET J.PELLET 
+# -*- 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.        
+# ======================================================================
+
+def post_k_trans_ops(self,RESU_TRANS,K_MODAL,TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, 
+                 INST, LIST_INST,INFO,**args):          
+  """
+     Ecriture de la macro post_k_trans
+  """
+  import aster
+  import string
+  from Accas import _F
+  from Utilitai.Utmess     import  UTMESS
+  from types import ListType, TupleType
+  from Utilitai.Table      import Table, merge
+  EnumTypes = (ListType, TupleType)
+  
+  macro = 'POST_K_TRANS'
+  ier=0
+#------------------------------------------------------------------
+  # On importe les definitions des commandes a utiliser dans la macro
+  CALC_G           =self.get_cmd('CALC_G'  )
+  IMPR_TABLE       =self.get_cmd('IMPR_TABLE'      )
+  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 table_sdaster ou dérivé) est tab
+  self.DeclareOut('tabout', self.sd)
+
+#------------------------------------------------------------------
+  TABK = K_MODAL['TABL_K_MODA']
+  F2D = K_MODAL['FOND_FISS']
+  F3D = K_MODAL['FISSURE']
+#
+# Calcul du tableau des K modaux
+#
+  if TABK == None :
+    montit = 'Calcul des K modaux'
+    resumod = K_MODAL['RESU_MODA']
+    thet = K_MODAL['THETA']
+
+    motscles={}
+    motscles2={}
+    motscles['THETA'] = []
+    mcthet = {}
+    if F2D != None :    mcthet['FOND_FISS'] = F2D
+    if thet != None :   mcthet['THETA'] = thet
+    if F3D != None :   mcthet['FISSURE'] = F3D
+    if K_MODAL['DIRECTION']!=None :  mcthet['DIRECTION'] = K_MODAL['DIRECTION']
+    if K_MODAL['DIRE_THETA']!=None: mcthet['DIRE_THETA'] = K_MODAL['DIRE_THETA']
+    if K_MODAL['R_SUP']!=None : mcthet['R_SUP'] = K_MODAL['R_SUP']
+    if K_MODAL['R_SUP_FO']!=None : mcthet['R_SUP_FO'] = K_MODAL['R_SUP_FO']
+    if K_MODAL['R_INF']!=None : mcthet['R_INF'] = K_MODAL['R_INF']
+    if K_MODAL['R_INF_FO']!=None : mcthet['R_INF_FO'] = K_MODAL['R_INF_FO']
+    if K_MODAL['MODULE']!=None : mcthet['MODULE'] = K_MODAL['MODULE']
+    if K_MODAL['MODULE']==None and  F2D : mcthet['MODULE'] = 1
+    if K_MODAL['MODULE_FO']!=None : mcthet['MODULE_FO'] = K_MODAL['MODULE_FO']
+    
+    if thet == None and F3D :  
+        motscles2['LISSAGE'] = [] 
+        if K_MODAL['LISSAGE_G'] == None :  K_MODAL['LISSAGE_G']='LEGENDRE'
+        if K_MODAL['LISSAGE_THETA'] == None :  K_MODAL['LISSAGE_THETA']='LEGENDRE'
+        if K_MODAL['DEGRE'] :   K_MODAL['DEGRE'] = 5
+        motscles2['LISSAGE'].append(_F(LISSAGE_G =K_MODAL['LISSAGE_G'],
+                        LISSAGE_THETA =K_MODAL['LISSAGE_G'], 
+                        DEGRE = K_MODAL['DEGRE'] ))
+    
+    __kgtheta = CALC_G(       RESULTAT   = resumod,
+                            OPTION = 'K_G_MODA',
+                            TOUT_MODE = 'OUI',
+                            INFO       = INFO, 
+                            TITRE      = montit, 
+                            THETA=mcthet,
+                            **motscles2)
+
+
+#
+# Recuperation du tableau des K modaux
+#
+  else :
+    __kgtheta=TABK
+    
+#-----------------------------------------
+#  
+# Verification de cohérence sur le nombre de modes
+#  
+# RESULTAT TRANSITOIRE
+  nomresu=RESU_TRANS.nom
+  coef=aster.getvectjev(nomresu.ljust(19)+'.DEPL')
+  nmodtr=aster.getvectjev(nomresu.ljust(19)+'.DESC')[1]
+# BASE MODALE
+  if F2D : 
+    n_mode = len((__kgtheta.EXTR_TABLE())['K1'])
+    nbno = 1
+  if F3D : 
+    n_mode = max((__kgtheta.EXTR_TABLE())['NUME_MODE'].values()['NUME_MODE'])
+    nbno = max((__kgtheta.EXTR_TABLE())['NUM_PT'].values()['NUM_PT'])
+    labsc = (__kgtheta.EXTR_TABLE())['ABSC_CURV'].values()['ABSC_CURV'][0:nbno]
+      
+  if nmodtr != n_mode : 
+      n_mode = min(nmodtr,n_mode)
+      UTMESS('A','RUPTURE0_50',valk=nomresu,vali=n_mode)
+
+#  
+# Traitement des mots clés ORDRE/INST/LIST_INST et LIST_ORDRE
+#  
+  l0_inst = aster.getvectjev(nomresu.ljust(19)+'.INST')
+  l0_ord = aster.getvectjev(nomresu.ljust(19)+'.ORDR')
+  nbtrans = len(l0_ord)
+  li =  [[l0_ord[i],l0_inst[i]] for i in range(nbtrans)]
+  ln =  [[l0_ord[i],i] for i in range(nbtrans)]
+  lo =  [[l0_inst[i],l0_ord[i]] for i in range(nbtrans)]
+  li = [(i[0],i[1:]) for i in li]
+  ln = [(i[0],i[1:]) for i in ln]
+  lo = [(i[0],i[1:]) for i in lo]
+  d_ord = dict(lo) 
+  d_ins = dict(li) 
+  d_num = dict(ln) 
+
+
+  l_ord =[]
+  l_inst =[]
+  if LIST_ORDRE or NUME_ORDRE :
+    if  NUME_ORDRE  :
+      if type(NUME_ORDRE) not in EnumTypes : NUME_ORDRE=(NUME_ORDRE,)
+      ltmp = list(NUME_ORDRE)
+    elif LIST_ORDRE :
+      ltmp = aster.getvectjev(string.ljust(LIST_ORDRE.nom,19)+'.VALE') 
+    for ord in ltmp :
+      if ord in l0_ord :
+         l_ord.append(ord)
+         l_inst.append(d_ins[ord][0])
+      else :
+         UTMESS('A','RUPTURE0_51',vali=ord,valk=nomresu)
+  elif LIST_INST or INST :
+    CRITERE = args['CRITERE']
+    PRECISION = args['PRECISION']
+    if INST :
+      if type(INST) not in EnumTypes : INST=(INST,)
+      ltmp = list(INST)
+    elif LIST_INST :
+      ltmp = aster.getvectjev(string.ljust(LIST_INST.nom,19)+'.VALE') 
+    for ins in ltmp :
+      if CRITERE=='RELATIF' and ins!=0.: match=[x for x in l0_inst if abs((ins-x)/ins)<PRECISION]
+      else                             : match=[x for x in l0_inst if abs(ins-x)<PRECISION]
+      if len(match)==0 : 
+         UTMESS('A','RUPTURE0_38',valr=ins)
+      elif len(match)>=2 :
+         UTMESS('A','RUPTURE0_39',valr=ins)
+      else :
+         l_inst.append(match[0])
+         l_ord.append(d_ord[match[0]][0])
+  else :
+      l_ord = l0_ord
+      l_inst = l0_inst
+  nbarch = len(l_ord)
+  if nbarch ==0 : UTMESS('F','RUPTURE0_54')
+  
+
+#  
+# Calcul des K(t)
+#  
+
+  K1mod = [None]*n_mode*nbno
+  K2mod = [None]*n_mode*nbno
+  K1t = [None]*nbarch*nbno
+  K2t = [None]*nbarch*nbno
+  if F3D : 
+    K3mod = [None]*n_mode*nbno
+    K3t = [None]*nbarch*nbno
+    k1 = 'K1_LOCAL'
+    k2 = 'K2_LOCAL'
+    k3 = 'K3_LOCAL'
+  else :
+    k1 = 'K1'
+    k2 = 'K2'
+  
+  
+  for x in range(0,nbno) :
+    for k in range(0,n_mode) :
+      K1mod[k*nbno + x] = __kgtheta[k1,k*nbno + x+1]
+      K2mod[k*nbno + x] = __kgtheta[k2,k*nbno + x+1]
+      if F3D : K3mod[k*nbno + x] = __kgtheta[k3,k*nbno + x+1]
+   
+    for num in range(0,nbarch) :
+      K1t[num*nbno + x] = 0.0
+      K2t[num*nbno + x] = 0.0
+      if F3D : K3t[num*nbno + x] = 0.0
+      for k in range(0,n_mode) :
+        num_ord = d_num[l_ord[num]][0]
+        alpha = coef[n_mode*num_ord+k]
+        K1t[num*nbno + x] = K1t[num*nbno + x] + alpha*K1mod[k*nbno + x]
+        K2t[num*nbno + x] = K2t[num*nbno + x] + alpha*K2mod[k*nbno + x]
+        if F3D : K3t[num*nbno + x] = K3t[num*nbno + x] + alpha*K3mod[k*nbno + x]
+ 
+  v = aster.__version__
+  titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K_TRANS LE &DATE A &HEURE \n'%v
+  if F2D :
+    tabout = CREA_TABLE(LISTE = (_F(LISTE_I =l_ord, PARA = 'NUME_ORDRE'),
+                           _F(LISTE_R =l_inst, PARA = 'INST'),
+                           _F(LISTE_R =K1t, PARA = k1),
+                           _F(LISTE_R =K2t, PARA = k2),),
+                        TITRE = titre,  );
+  if F3D : 
+   lo = []
+   li = []
+   for i in range(nbarch) :
+     for j in range(nbno) :
+        lo.append(l_ord[i])
+        li.append(l_inst[i])
+   tabout = CREA_TABLE(LISTE = (_F(LISTE_I =lo, PARA = 'NUME_ORDRE'),
+                           _F(LISTE_R =li, PARA = 'INST'),
+                           _F(LISTE_I =range(nbno)*nbarch, PARA ='NUM_PT' ),
+                           _F(LISTE_R =labsc*nbarch, PARA = 'ABSC_CURV'),
+                           _F(LISTE_R =K1t, PARA = k1),
+                           _F(LISTE_R =K2t, PARA = k2),
+                           _F(LISTE_R =K3t, PARA = k3),),
+                        TITRE = titre,
+                  );
+   
+#------------------------------------------------------------------
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py
new file mode 100644 (file)
index 0000000..b481f30
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py
@@ -0,0 +1,833 @@
+#@ MODIF propa_fiss_ops Macro  DATE 24/08/2009   AUTEUR GENIAUT S.GENIAUT 
+# -*- 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.        
+# ======================================================================
+
+
+def InterpolationLineaire(x0, points) :
+   """
+       Interpolation Lineaire de x0 sur la fonction discretisee yi=points(xi) i=1,..,n
+   """
+   # x0     = Une abscisse        (1 colonne, 1 ligne)
+   # points = Tableau de n points (2 colonnes, n lignes)
+   # on suppose qu'il existe au moins 2 points, 
+   # et que les points sont classes selon les abscisses croissantes
+
+   n = len(points)
+   if ( x0 < points[0][0] )  :
+     y0 =  points[0][1]
+     return y0
+   if ( x0 > points[n-1][0] ) :
+     y0 =  points[n-1][1]
+     return y0
+   i = 1
+   while x0 > points[i][0]:
+      i = i+1
+   y0 = (x0-points[i-1][0]) * (points[i][1]-points[i-1][1]) / (points[i][0]-points[i-1][0]) + points[i-1][1]
+   return y0
+
+def InterpolFondFiss(s0, Coorfo) :
+   """
+       Interpolation des points du fond de fissure
+   """
+   # s0     = abscisse curviligne du point considere      (0 < s0 > 1)
+   # Coorfo = Coordonnees du fond (extrait de la sd fiss_xfem)
+   # xyz = Coordonnees du point
+
+   n = len(Coorfo) / 4
+   if ( s0 < Coorfo[3] )  :
+     xyz =  [Coorfo[0],Coorfo[1],Coorfo[2]]
+     return xyz
+   if ( s0 > Coorfo[-1]  ) :
+     xyz =  [Coorfo[-4],Coorfo[-3],Coorfo[-2]]
+     return xyz
+   i = 1
+   while s0 > Coorfo[4*i+3]:
+      i = i+1
+   xyz = [0.]*3
+   xyz[0] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+0]-Coorfo[4*(i-1)+0]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+0]
+   xyz[1] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+1]-Coorfo[4*(i-1)+1]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+1]
+   xyz[2] = (s0-Coorfo[4*(i-1)+3]) * (Coorfo[4*i+2]-Coorfo[4*(i-1)+2]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Coorfo[4*(i-1)+2]
+   return xyz
+
+def InterpolBaseFiss(s0, Basefo, Coorfo) :
+# Interpolation de la base locale en fond de fissure
+# s0     = abscisse curviligne du point considere     
+# Basefo = base locale du fond (VNx,VNy,VNz,VPx,VPy,VPz)
+# Coorfo = Coordonnees et abscisses du fond (extrait de la sd fiss_xfem)
+# en sortie : VPVNi = base locale au point considere (6 coordonnes)
+   n = len(Coorfo) / 4
+   if ( s0 < Coorfo[3] )  :
+     VPVNi =  Basefo[0:6]
+     return VPVNi
+   if ( s0 > Coorfo[-1]  ) :
+     VPVNi = [Basefo[i] for i in range(-6,0)] 
+     return VPVNi
+   i = 1
+   while s0 > Coorfo[4*i+3]:
+      i = i+1
+   VPVNi = [0.]*6
+   for k in range(6) :
+      VPVNi[k] = (s0-Coorfo[4*(i-1)+3]) * (Basefo[6*i+k]-Basefo[6*(i-1)+k]) / (Coorfo[4*i+3]-Coorfo[4*(i-1)+3]) + Basefo[6*(i-1)+k]
+   return VPVNi
+
+
+#def propa_fiss_ops(self,METHODE_PROPA,TEST_MAIL,INFO,**args):
+def propa_fiss_ops(self,METHODE_PROPA,INFO,**args):
+  """
+  Macro PROPA_FISS
+  Propagation de fissure pour les modeles X-FEM : propagation par la methode de HAMILTON 
+  ou par projection sur un maillage
+  """
+  import aster
+  import string
+  import copy
+  from Accas import _F
+  from Utilitai.Utmess     import  UTMESS
+  from types import ListType, TupleType
+  from Utilitai.Table      import Table, merge
+  from Utilitai.partition import MAIL_PY
+  import Numeric
+  from Numeric import array,asarray,Float,concatenate,sqrt,sign,resize,dot,zeros
+  from math import atan, atan2, cos, sin
+  from SD.sd_mater     import sd_compor1
+  from Cata.cata import table_sdaster,fiss_xfem,modele_sdaster
+
+
+  EnumTypes = (ListType, TupleType)
+  
+  macro = 'PROPA_FISS'
+  ier=0
+#------------------------------------------------------------------
+  # On importe les definitions des commandes a utiliser dans la macro
+  ASSE_MAILLAGE         =self.get_cmd('ASSE_MAILLAGE'  )
+  LIRE_MAILLAGE    =self.get_cmd('LIRE_MAILLAGE'  )
+  CREA_TABLE    =self.get_cmd('CREA_TABLE'  )
+  CALC_TABLE    =self.get_cmd('CALC_TABLE'  )
+  PROPA_XFEM = self.get_cmd('PROPA_XFEM'  )
+  DEFI_FISS_XFEM = self.get_cmd('DEFI_FISS_XFEM'  )
+  MODI_MODELE_XFEM = self.get_cmd('MODI_MODELE_XFEM'  )
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+#------------------------------------------------------------------
+# Loi de propagation 
+  ##if (METHODE_PROPA != 'INITIALISATION') and (TEST_MAIL == 'NON' ) :
+  #if (METHODE_PROPA == 'SIMPLEXE') or (METHODE_PROPA == 'UPWIND') : 
+    #TEST_MAIL=args['TEST_MAIL']
+    #if (TEST_MAIL == 'NON' ) :
+      #LOI= args['LOI_PROPA']
+      #if LOI == None :
+         #print 'MESSAGE D ERREUR : IL FAUT UNE LOI DE PROPAGATION' 
+      #dLoi=LOI[0].cree_dict_valeurs(LOI[0].mc_liste)
+## Recuperation de E et de Nu
+      ##fiss =    args['FISSURE']
+      ##self.DeclareOut('nomfiss',fiss)
+      #mat = dLoi['MATER']
+      #matph = mat.NOMRC.get()  
+      #phenom=None
+      #for cmpt in matph :
+         #if cmpt[:4]=='ELAS' :
+            #phenom=cmpt
+            #break
+      #if phenom==None : UTMESS('F','RUPTURE0_5')
+      #compor = sd_compor1('%-8s.%s' % (mat.nom, phenom))
+      #valk = [s.strip() for s in compor.VALK.get()]
+      #valr = compor.VALR.get()
+      #dicmat=dict(zip(valk,valr))
+      #if dicmat.has_key('TEMP_DEF')  :
+        #nompar = ('TEMP',)
+        #valpar = (dicmat['TEMP_DEF'],)
+        #UTMESS('A','XFEM2_85',valr=valpar)
+        #nomres=['E','NU']
+        #valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F')
+        #e = valres[0]
+        #nu = valres[1]
+      #else :
+        #e  = dicmat['E']
+        #nu = dicmat['NU']  
+## Construction catalogue PROPA_XFEM
+      #dLoix = {}
+      #dLoix['LOI'] = 'PARIS'
+      #dLoix['E'] = e
+      #dLoix['NU'] = nu
+      #dLoix['C'] = dLoi['C']
+      #dLoix['M'] = dLoi['M']
+      #dLoix['N'] = dLoi['N']
+
+#------------------------------------------------------------------
+# CAS 1 : METHODE_PROPA = 'SIMPLEXE' OU 'UPWIND'
+#
+
+  if (METHODE_PROPA == 'SIMPLEXE') or (METHODE_PROPA == 'UPWIND'):
+
+    TEST_MAIL=args['TEST_MAIL']
+    
+    if (TEST_MAIL == 'NON' ) :
+      LOI= args['LOI_PROPA']
+      if LOI == None :
+         print 'MESSAGE D ERREUR : IL FAUT UNE LOI DE PROPAGATION' 
+      dLoi=LOI[0].cree_dict_valeurs(LOI[0].mc_liste)
+      #fiss =    args['FISSURE']
+      #self.DeclareOut('nomfiss',fiss)
+      mat = dLoi['MATER']
+      matph = mat.NOMRC.get()  
+      phenom=None
+      for cmpt in matph :
+         if cmpt[:4]=='ELAS' :
+            phenom=cmpt
+            break
+      if phenom==None : UTMESS('F','RUPTURE0_5')
+      compor = sd_compor1('%-8s.%s' % (mat.nom, phenom))
+      valk = [s.strip() for s in compor.VALK.get()]
+      valr = compor.VALR.get()
+      dicmat=dict(zip(valk,valr))
+      if dicmat.has_key('TEMP_DEF')  :
+        nompar = ('TEMP',)
+        valpar = (dicmat['TEMP_DEF'],)
+        UTMESS('A','XFEM2_85',valr=valpar)
+        nomres=['E','NU']
+        valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F')
+        e = valres[0]
+        nu = valres[1]
+      else :
+        e  = dicmat['E']
+        nu = dicmat['NU']  
+# Construction catalogue PROPA_XFEM
+      dLoix = {}
+      dLoix['LOI'] = 'PARIS'
+      dLoix['E'] = e
+      dLoix['NU'] = nu
+      dLoix['C'] = dLoi['C']
+      dLoix['M'] = dLoi['M']
+      dLoix['N'] = dLoi['N']
+     
+    # Retreive all the parameters of PROPA_FISS
+    mcsimp = {}
+    mcsimp['MODELE'] =  args['MODELE']
+    mcsimp['RAYON'] =  args['RAYON']
+    mcsimp['DA_MAX'] =  args['DA_MAX']
+    mcsimp['TEST_MAIL']=TEST_MAIL
+    Fissures = args['FISSURE']
+
+#   Build the list for the PROPA_XFEM operateur
+    Table = []
+    GrilleAux = []
+    FissAct = []
+    FissNou = []
+    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':
+            Table.append(Fiss['TABLE'])
+            if Fiss['NB_POINT_FOND']!=None :
+               if isinstance(Fiss['NB_POINT_FOND'],int) :
+                  NbPointFond.append(Fiss['NB_POINT_FOND'])
+               else :
+                  for nbptfo in range(0,len(Fiss['NB_POINT_FOND'])) :
+                      NbPointFond.append(Fiss['NB_POINT_FOND'][nbptfo])
+            else :
+               NbPointFond.append(-1)
+        
+    mcsimp['LISTE_FISS'] = FissAct
+    
+    if TEST_MAIL == 'NON':
+       mcsimp['TABLE'] = Table
+       mcsimp['NB_POINT_FOND'] = NbPointFond
+       mcsimp['LOI_PROPA'      ] =dLoix
+       
+       COMP_LINE = args['COMP_LINE']
+       if  COMP_LINE !=None : 
+           dcomp=COMP_LINE[0].cree_dict_valeurs(COMP_LINE[0].mc_liste)
+           mcsimp  ['COMP_LINE'      ] =dcomp
+
+    if TEST_MAIL != 'CONSTANT' :
+#      Ok. It's time for propagation! Let's call PROPA_XFEM for each
+#      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 )
+           
+    else :
+#      Ok. I should make several crack propagation and check for the
+#      distance between each propagated front and the corresponding one
+#      at the beginning of the propagation.
+       UTMESS('A','XFEM2_60')
+       StepTot = args['ITERATIONS']
+       __Fis = [None]*(StepTot*len(FissAct))
+       __Mod = [None]*StepTot
+       mcsimp['TOLERANCE'] = args['TOLERANCE']
+       for NumStep in range(0,StepTot) :
+         
+           aster.affiche('MESSAGE',' ------------------------')
+           texte=' TEST_MAIL - ITERATION %d'%(NumStep+1)
+           aster.affiche('MESSAGE',texte)
+           aster.affiche('MESSAGE',' ------------------------')
+           
+           ListeFiss = []
+           mcsimp['DISTANCE'] = args['DA_MAX']*(NumStep+1)
+
+           for NumFiss in range(0,len(FissAct)) :
+              if NumStep==0 :
+                 mcsimp['FISS_PROP'] = FissAct[NumFiss]
+              else :
+                 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 )
+              else:
+                 __Fis[NumFiss+NumStep*len(FissAct)] = PROPA_XFEM(METHODE=METHODE_PROPA,INFO=INFO,**mcsimp )
+                 ListeFiss.append(__Fis[NumFiss+NumStep*len(FissAct)])
+              
+           if NumStep<StepTot-1 :
+              aster.affiche('MESSAGE',' ------------------------')
+              aster.affiche('MESSAGE',' CREATION DU MODELE FISSURE TEMPORAIRE')
+              aster.affiche('MESSAGE',' ')
+              __Mod[NumStep] = MODI_MODELE_XFEM(MODELE_IN=args['MODELE'],FISSURE=(ListeFiss))
+              mcsimp['LISTE_FISS'] = ListeFiss
+              aster.affiche('MESSAGE',' ')
+              aster.affiche('MESSAGE',' ------------------------')
+              aster.affiche('MESSAGE',' ')
+
+
+#------------------------------------------------------------------
+# CAS 2 : METHODE_PROPA = 'MAILLAGE'
+#
+  ALPHABET=['A','B','C','D','E','F','G','H','I','J','K','L','O','P','Q','R','S','T','U','V','W','X','Y','Z'];
+  
+  if METHODE_PROPA == 'MAILLAGE' :
+    fiss =    args['FISSURE1']
+    LOI_PROPA = args['LOI_PROPA']
+    MA_XFEM1 =  args['MA_XFEM1']
+    if LOI_PROPA != None :
+      coef_paris =  LOI_PROPA['M']
+      Damax = LOI_PROPA['DA_MAX']
+      coef_C =  LOI_PROPA['C']
+    it = args['ITERATION']
+    typmod= MA_XFEM1.DIME.get()
+    typmod = typmod[5]
+    
+#    Verification qu on a bien un fond unique
+    Fissmult = fiss.FONDMULT.get()
+    Nbfiss = len(Fissmult)/2
+    if Nbfiss >1 :
+       UTMESS('F','RUPTURE1_48',vali=Nbfiss)
+
+# Recuperation des K et calcul de DeltaK
+    Nmeth = args['METHODE_POSTK']
+    SIF = args['TABLE']
+    hypo = args['HYPOTHESE']
+    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()
+       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 nbinst > 1 :
+          nbfis = len(__tab1['K1_MAX']) / nbinst
+          DK1 = [None]*nbfis
+          DKmax = 0.
+          for k in range(nbfis) :
+             DK1[k]=[0.]*2
+             __tmp = __tabp.PT_FOND==(k+1)
+             if (typmod == 3) : DK1[k][0]=__tmp.values()['ABSC_CURV'][0]
+             DK1[k][1]=max(__tmp.values()['K1_MAX'])-min(__tmp.values()['K1_MAX'])
+             DKmax = max(DKmax,DK1[k][1])
+       else :
+          nbfis = len(__tab1['K1_MAX'])
+          if hypo == 'NON_PLAN' :
+             BETA = [None]*nbfis
+             if (min(__tab1['G_MAX']) < 0.) :
+               UTMESS('F','RUPTURE1_46')
+             DKmax = max(sqrt(__tab1['G_MAX']))
+             BETA = [0.]*nbfis
+             absc = [0.]*nbfis
+             for i in range(nbfis) :
+                k1 = __tab1['K1_MAX'][i]
+                k2 = __tab1['K2_MAX'][i]
+                if (typmod == 3) : absc[i]=__tab1['ABSC_CURV'][i]
+                BETA[i] = [absc[i] , 2*atan(0.25*(k1/k2-abs(k2)/k2*sqrt((k1/k2)**2+8)))]
+             DK1 = [[absc[i],sqrt(__tab1['G_MAX'][i])] for i in range(nbfis)]
+          else :
+             DKmax = max(__tab1['K1_MAX'])
+             if (typmod == 3) :
+               DK1 = [[__tab1['ABSC_CURV'][i],__tab1['K1_MAX'][i]] for i in range(nbfis)]
+             else :
+               DK1 = [[0.,__tab1['K1_MAX'][i]] for i in range(nbfis)]
+             if (min(__tab1['K1_MAX']) < 0.) :
+               UTMESS('F','RUPTURE1_49')
+# B- TABLEAU ISSSU DE CALC_G (option CALC_K_G)
+    else :
+       __tabp = SIF.EXTR_TABLE()
+       if (typmod == 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 (typmod == 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 nbinst > 1 :
+          nbfiss = 1
+          if (typmod == 3) : nbfis = len(__tab1['K1_LOCAL']) / nbinst
+          DK1 = [None]*nbfis
+          DKmax = 0.
+          for k in range(nbfis) :
+             DK1[k]=[None]*2
+             __tmp = __tabp.NUM_PT==(k+1)
+             if (typmod == 3) : 
+               DK1[k][0]=__tmp.values()['ABSC_CURV'][0]
+               DK1[k][1]=max(__tmp.values()['K1_LOCAL'])-min(__tmp.values()['K1_LOCAL'])
+             else :
+               DK1[k][0]=0.
+               DK1[k][1]=max(__tmp.values()['K1'])-min(__tmp.values()['K1'])
+             DKmax = max(DKmax,DK1[k][1])
+       elif typmod == 3 :
+          nbfis = len(__tab1['K1_LOCAL'])
+          if hypo == 'NON_PLAN' :
+             if (min(__tab1['G_LOCAL']) < 0.) :
+               UTMESS('F','RUPTURE1_46')
+             DKmax = max(sqrt(__tab1['G_LOCAL']))
+             DK1 = [[__tab1['ABSC_CURV'][i],sqrt(__tab1['G_LOCAL'][i])] for i in range(nbfis)]
+             BETA = [[__tab1['ABSC_CURV'][i],__tab1['BETA_LOCAL'][i]] for i in range(nbfis)]
+          else :
+             DKmax = max(__tab1['K1_LOCAL'])
+             DK1 = [[__tab1['ABSC_CURV'][i],__tab1['K1_LOCAL'][i]] for i in range(nbfis)]
+             if (min(__tab1['K1_LOCAL']) < 0.) :
+               UTMESS('F','RUPTURE1_49')
+       else :
+          nbfis = 1
+          if hypo == 'NON_PLAN' :
+             if (min(__tab1['G']) < 0.) :
+               UTMESS('F','RUPTURE1_46')
+             DKmax = max(sqrt(__tab1['G']))
+             DK1 = [[0.,DKmax],]
+             k1 = __tab1['K1'][0]
+             k2 = __tab1['K2'][0]
+             beta = 2*atan(0.25*(k1/k2-abs(k2)/k2*sqrt((k1/k2)**2+8)))
+             BETA = [[0.,beta] ]
+          else :
+             DKmax = max(__tab1['K1'])
+             DK1 = [[0.,DKmax ] ,]
+             if (min(__tab1['K1']) < 0.) :
+               UTMESS('F','RUPTURE1_49')
+
+    if hypo == 'NON_PLAN'  and nbinst > 1 :
+       UTMESS('F','RUPTURE1_47')
+
+#------------------------------------------------------------------
+# CAS 2a : MODELE 3D
+#
+    if typmod == 3 :
+      mm = MAIL_PY()
+      mm.FromAster(MA_XFEM1)
+
+# Recuperation des informations sur le maillage
+      nbno = mm.dime_maillage[0]
+      nbma = mm.dime_maillage[2]
+      collgrma = mm.gma
+      nbnofo = len(collgrma['FOND_0'])+1
+
+# Correction de la position des noeuds (equirepartition)
+      Coorfo = fiss.FONDFISS.get()
+      absmax = Coorfo[-1]
+      abscf = [0.]*nbnofo
+      for i in range(nbnofo) :
+        abscf[i] = i * absmax / (nbnofo-1)
+        xyzi = InterpolFondFiss(abscf[i], Coorfo)
+        mm.cn[nbno-nbnofo+i][0] = xyzi[0]
+        mm.cn[nbno-nbnofo+i][1] = xyzi[1]
+        mm.cn[nbno-nbnofo+i][2] = xyzi[2]
+
+# Maillage apres correction
+      coord    = mm.cn
+      linomno  = list(mm.correspondance_noeuds)
+      linomno = map(string.rstrip,linomno)
+      l_coorf =  [[linomno[i],coord[i]] for i in range(0,nbno)]
+      d_coorf = dict(l_coorf)     
+      
+# Boucle sur le fond : coordonnees du point propage            
+      Basefo = fiss.BASEFOND.get()
+      Listfo = fiss.FONDFISS.get()
+      Vorig = args['DTAN_ORIG']
+      Vextr = args['DTAN_EXTR']
+      if (Damax ==None) :
+         DKmax = 1
+      if (coef_C ==None) :
+         coef_C = Damax
+      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]     
+         Zf =  d_coorf['NX%s%i' %(ALPHABET[ifond],it)][2]  
+          
+         VPVNi = InterpolBaseFiss(abscf[ifond],Basefo, Listfo)
+        
+         k1 = InterpolationLineaire(abscf[ifond], DK1)
+         if k1<=0 :
+           UTMESS('F','RUPTURE1_49')
+
+# Correction pour reduire le risque de maille aplatie (pilotage par Damax uniquement)
+         if (Damax !=None) :
+            Damin = Damax /10.
+            if ((k1/DKmax)**coef_paris <= Damin )  :
+               k1 = Damin**(1/coef_paris)*DKmax
+
+# Tangentes aux extremites     
+         if (ifond == 0) and (Vorig != None) :
+           VPVNi[3] = Vorig[0]
+           VPVNi[4] = Vorig[1]
+           VPVNi[5] = Vorig[2]
+         if (ifond == nbnofo-1) and (Vextr != None) :
+           VPVNi[3] = Vextr[0]
+           VPVNi[4] = Vextr[1]
+           VPVNi[5] = Vextr[2]
+         
+         if hypo == 'NON_PLAN' :
+            beta = InterpolationLineaire(abscf[ifond], BETA)
+            Xf2 = Xf + coef_C*(VPVNi[3]*cos(beta)+VPVNi[0]*sin(beta))*(k1/DKmax)**coef_paris
+            Yf2 = Yf + coef_C*(VPVNi[4]*cos(beta)+VPVNi[1]*sin(beta))*(k1/DKmax)**coef_paris
+            Zf2 = Zf + coef_C*(VPVNi[5]*cos(beta)+VPVNi[2]*sin(beta))*(k1/DKmax)**coef_paris
+         else :
+            Xf2 = Xf + coef_C*VPVNi[3]*(k1/DKmax)**coef_paris
+            Yf2 = Yf + coef_C*VPVNi[4]*(k1/DKmax)**coef_paris
+            Zf2 = Zf + coef_C*VPVNi[5]*(k1/DKmax)**coef_paris
+         
+         LesNoeudsEnPlus = array([[Xf2,Yf2,Zf2]])
+         if ifond ==0 :
+            Pini = (Xf2,Yf2,Zf2)
+            vectorie = (VPVNi[0],VPVNi[1],VPVNi[2],)
+         NomNoeudsEnPlus =     ['NX%s%i' %(ALPHABET[ifond],it+1)]
+         mm.cn = concatenate((mm.cn,LesNoeudsEnPlus))
+         mm.correspondance_noeuds = tuple( list(mm.correspondance_noeuds) + NomNoeudsEnPlus )
+  
+# Ajout Maille levre (quad4)      
+      nbnotot = len(mm.correspondance_noeuds)
+      NomMaillesEnPlus = []
+      num_maille = []
+      NoeudsMailles = []
+      for ifond in range(nbnofo-1) :
+         NomMaillesEnPlus.append( 'MX%s%i' %(ALPHABET[ifond], it+1) )
+         num_maille.append( [ nbma + ifond +1 ] )
+         num_maille.append( nbma +ifond + 1 )
+         i1 = nbnotot - 2*nbnofo  + ifond
+         i2 = nbnotot - 2*nbnofo  + ifond +1
+         i3 = nbnotot - nbnofo  + ifond +1
+         i4 = nbnotot - nbnofo  + ifond 
+         NoeudsMailles.append( array([i1,i2,i3,i4]))
+
+      typ_maille = mm.dic['QUAD4']
+      NbMailleAjoute = nbnofo-1
+      mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      fsi = mm.gma['FISS_%i' %(it-1)]
+      for ifond in range(nbnofo-1) :
+        fsi = concatenate((fsi,array([nbma+ifond])))
+      mm.gma['FISS_%i' %it] = fsi
+     
+# Ajout Maille fond (SEG2)      
+      NomMaillesEnPlus = []
+      num_maille = []
+      NoeudsMailles = []
+      for ifond in range(nbnofo-1) :
+         NomMaillesEnPlus.append( 'MF%s%i' %(ALPHABET[ifond], it+1) )
+         num_maille.append( [ nbma + ifond +nbnofo ] )
+         num_maille.append( nbma + ifond + nbnofo )
+         i3 = nbnotot - nbnofo  + ifond 
+         i4 = nbnotot - nbnofo  + ifond +1
+         NoeudsMailles.append( array([i3,i4]))
+
+      typ_maille = mm.dic['SEG2']
+      NbMailleAjoute = nbnofo-1
+      mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      fsi = []
+      for ifond in range(nbnofo-1) :
+        fsi = concatenate((fsi,array([nbma+ifond+nbnofo-1])))
+      mm.gma['FOND_%i' %it] = fsi
+     
+#------------------------------------------------------------------
+# CAS 2b : MODELE 2D
+#
+    if typmod == 2 :
+      mm = MAIL_PY()
+      mm.FromAster(MA_XFEM1)
+      
+      (nno,ndim) = mm.cn.shape
+
+# Recuperation des informations sur le maillage
+      nbno = mm.dime_maillage[0]
+      nbma = mm.dime_maillage[2]
+      coord    = mm.cn
+      linomno  = list(mm.correspondance_noeuds)
+      linomno = map(string.rstrip,linomno)
+      l_coorf =  [[linomno[i],coord[i]] for i in range(0,nbno)]
+      d_coorf = dict(l_coorf) 
+      
+# Coordonnees du point propage       
+      Xf =  d_coorf['NXA%i' %(it)][0]    
+      Yf =  d_coorf['NXA%i' %(it)][1]
+      if (Damax ==None) :
+         DKmax = 1
+      if (coef_C ==None) :
+         coef_C = Damax
+
+      VPVNi = fiss.BASEFOND.get()
+      k1 = DK1[0][1]
+      if hypo == 'NON_PLAN' :
+         beta = BETA[0][1]
+         Xf2 = Xf + coef_C*(VPVNi[2]*cos(beta)+VPVNi[0]*sin(beta))*(k1/DKmax)**coef_paris
+         Yf2 = Yf + coef_C*(VPVNi[3]*cos(beta)+VPVNi[1]*sin(beta))*(k1/DKmax)**coef_paris
+      else :
+         Xf2 = Xf + coef_C*VPVNi[2]*(k1/DKmax)**coef_paris
+         Yf2 = Yf + coef_C*VPVNi[3]*(k1/DKmax)**coef_paris
+      
+      LesNoeudsEnPlus = array([[Xf2,Yf2]])
+      NomNoeudsEnPlus =     ['NXA%i' %(it+1)]
+      mm.cn = concatenate((mm.cn,LesNoeudsEnPlus))
+      mm.correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus )
+      
+# Ajout Maille levre (SEG2)
+      NomMaillesEnPlus =     ['MX%s%i' %(ALPHABET[0], it+1)]
+      num_maille = [ nbma + 1 ]
+      num_maille.append( nbma + 1 )
+      NoeudsMailles = [array([nbno-1,nbno])]
+      typ_maille = mm.dic['SEG2']
+      NbMailleAjoute = 1
+      mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      fsi = mm.gma['FISS_%i' %(it-1)]
+      fsi = concatenate((fsi,array([nbma])))
+      mm.gma['FISS_%i' %it] = fsi
+
+# Ajout Maille fond (POI1)
+      NomMaillesEnPlus =     ['MF%s%i' %(ALPHABET[0], it+1)]
+      num_maille = [ nbma + 2 ]
+      NoeudsMailles = [array([nbno])]
+      typ_maille = mm.dic['POI1']
+      mm.tm = concatenate((mm.tm,array([typ_maille]*1)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      mm.gma['FOND_%i' %it] = array(nbma+1)
+
+# Fin du 2D      
+    if INFO==2 :
+      texte="Maillage produit par l operateur PROPA_FISS"
+      aster.affiche('MESSAGE',texte)
+      print mm
+           
+# Sauvegarde (maillage xfem et maillage concatene)
+    MA_XFEM2 = args['MA_XFEM2']
+    if MA_XFEM2 != None : self.DeclareOut('ma_xfem2',MA_XFEM2)
+    __MA = mm.ToAster(unite=39)
+    self.DeclareOut('ma_xfem2',MA_XFEM2)
+    ma_xfem2=LIRE_MAILLAGE(UNITE=39);
+
+    MA_TOT2 = args['MA_TOT2']
+    if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2)
+    MA_STRUC = args['MA_STRUC']
+    ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MA_STRUC,
+                      MAILLAGE_2 = ma_xfem2,
+                      OPERATION='SUPERPOSE')
+
+#------------------------------------------------------------------
+# CAS 3 : METHODE_PROPA = 'INITIALISATION'
+#
+  if METHODE_PROPA == 'INITIALISATION' :
+    form = args['FORM_FISS']
+    
+# 3-a : demi-droite    
+    if form == 'DEMI_DROITE' :
+      PF = args['PFON']
+      DTAN = args['DTAN']
+      PI = array([[PF[0]-DTAN[0],PF[1]-DTAN[1]],])
+
+      ndim = 2
+      mm = MAIL_PY()
+      mm.__init__()
+     
+# Ajout des noeuds 
+      LesNoeudsEnPlus = concatenate((PI,array([PF[0:2]])))
+      NomNoeudsEnPlus =     ['NXA0','NXA1']
+      mm.cn = LesNoeudsEnPlus
+      mm.correspondance_noeuds = tuple( NomNoeudsEnPlus )
+
+# Ajout Maille levre (SEG2)
+      it = 1
+      nbma = 0
+      nbno = 0
+      NomMaillesEnPlus =     ['MX%s%i' %(ALPHABET[0], it)]
+      num_maille = [ nbma + 1 ]
+      num_maille.append( nbma + 1 )
+      NoeudsMailles = [array([nbno,nbno+1])]
+      typ_maille = mm.dic['SEG2']
+      NbMailleAjoute = 1
+      mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      mm.gma['FISS_0'] = array(nbma)
+
+# Ajout Maille fond (POI1)
+      NomMaillesEnPlus =     ['MF%s%i' %(ALPHABET[0], it)]
+      num_maille = [ nbma + 2 ]
+      NoeudsMailles = [array([nbno+1])]
+      typ_maille = mm.dic['POI1']
+      mm.tm = concatenate((mm.tm,array([typ_maille]*1)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      mm.gma['FOND_0'] = array(nbma+1)
+
+
+# 3-b : demi-plan    
+    if form == 'DEMI_PLAN' :
+      P0 = args['POINT_ORIG']
+      P1 = args['POINT_EXTR']
+      dpropa = args['DTAN']
+      nbpt = args['NB_POINT_FOND']
+      Q0 = array([[P0[0]-dpropa[0],P0[1]-dpropa[1],P0[2]-dpropa[2]]])
+      
+      mm = MAIL_PY()
+      mm.__init__()
+      x=[None]*nbpt
+      y=[None]*nbpt
+      z=[None]*nbpt
+      xx=[None]*nbpt
+      yy=[None]*nbpt
+      zz=[None]*nbpt
+      LesNoeudsEnPlus = Q0
+      NomNoeudsEnPlus =     ['NXA0']
+      mm.cn = LesNoeudsEnPlus
+      mm.correspondance_noeuds = tuple( NomNoeudsEnPlus )
+
+      for i in range(1,nbpt) :
+        x[i] = P0[0]+i*(P1[0]-P0[0])/(nbpt-1)
+        y[i] = P0[1]+i*(P1[1]-P0[1])/(nbpt-1)
+        z[i] = P0[2]+i*(P1[2]-P0[2])/(nbpt-1)
+        xx[i] = x[i] - dpropa[0]
+        yy[i] = y[i] - dpropa[1]
+        zz[i] = z[i] - dpropa[2]
+        LesNoeudsEnPlus = array([[xx[i],yy[i],zz[i]]])
+        NomNoeudsEnPlus =     ['NX%s0' %(ALPHABET[i]) ]
+        mm.cn = concatenate((mm.cn,LesNoeudsEnPlus))
+        mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds)  +NomNoeudsEnPlus )
+      LesNoeudsEnPlus = array([P0])
+      NomNoeudsEnPlus =     ['NXA1']
+      mm.cn = concatenate((mm.cn,LesNoeudsEnPlus))
+      mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds)  + NomNoeudsEnPlus )
+      for i in range(1,nbpt) :
+        LesNoeudsEnPlus = array([[x[i],y[i],z[i]]])
+        NomNoeudsEnPlus =     ['NX%s1' %(ALPHABET[i]) ]
+        mm.cn = concatenate((mm.cn,LesNoeudsEnPlus))
+        mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds)  +NomNoeudsEnPlus )
+
+# Ajout Maille levre (quad4)      
+      NomMaillesEnPlus = []
+      num_maille = []
+      NoeudsMailles = []
+      for ifond in range(nbpt-1) :
+         NomMaillesEnPlus.append( 'MX%s1' %(ALPHABET[ifond]) )
+         num_maille.append( [ ifond +1 ] )
+         num_maille.append( ifond + 1 )
+         i1 = ifond
+         i2 = ifond+1
+         i3 = nbpt+ifond
+         i4 = nbpt+ifond+1
+         NoeudsMailles.append( array([i1,i2,i4,i3]))
+
+      typ_maille = mm.dic['QUAD4']
+      NbMailleAjoute = nbpt-1
+      mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      fsi =[]
+      for ifond in range(nbpt-1) :
+        fsi = concatenate((fsi,array([ifond])))
+      mm.gma['FISS_0' ] = fsi
+    
+# Ajout Maille fond (SEG2)      
+      NomMaillesEnPlus = []
+      num_maille = []
+      NoeudsMailles = []
+      for ifond in range(nbpt-1) :
+         NomMaillesEnPlus.append( 'MF%s1' %(ALPHABET[ifond]) )
+         num_maille.append( [ ifond +nbpt ] )
+         num_maille.append( ifond + nbpt )
+         i3 = nbpt+ifond
+         i4 = nbpt+ifond+1
+         NoeudsMailles.append( array([i3,i4]))
+
+      typ_maille = mm.dic['SEG2']
+      NbMailleAjoute = nbpt-1
+      mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute)))
+      mm.correspondance_mailles += tuple(NomMaillesEnPlus)
+      mm.co += NoeudsMailles
+      fsi = []
+      for ifond in range(nbpt-1) :
+        fsi = concatenate((fsi,array([ifond+nbpt-1])))
+      mm.gma['FOND_0'] = fsi
+        
+    
+    if INFO==2 :
+      texte="Maillage produit par l operateur PROPA_FISS"
+      aster.affiche('MESSAGE',texte)
+      print mm
+           
+# Sauvegarde (maillage xfem et maillage concatene)
+    MA_XFEM2 = args['MA_XFEM2']
+    if MA_XFEM2 != None : self.DeclareOut('ma_xfem2',MA_XFEM2)
+    __MA = mm.ToAster(unite=39)
+    self.DeclareOut('ma_xfem2',MA_XFEM2)
+    ma_xfem2=LIRE_MAILLAGE(UNITE=39);
+
+    MA_TOT2 = args['MA_TOT2']
+    if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2)
+    MA_STRUC = args['MA_STRUC']
+    ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MA_STRUC,
+                      MAILLAGE_2 = ma_xfem2,
+                      OPERATION='SUPERPOSE')
+                      
+  return                    

diff --git a/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py
new file mode 100644 (file)
index 0000000..e83fc33
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py
@@ -0,0 +1,199 @@
+#@ MODIF raff_xfem_ops Macro  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.        
+# ======================================================================
+
+
+     
+def raff_xfem_ops(self,FISSURE,INFO,**args):
+   """
+   Macro RAFF_XFEM
+   Calcul de la distance au fond de fissure le plus proche
+   """
+   import aster
+   import string
+   import copy
+   import math
+   import Numeric
+   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'
+   from Accas               import _F
+   from Utilitai.Utmess     import  UTMESS
+
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # Le concept sortant (de type cham_no_sdaster ou derive)
+   self.DeclareOut('chamout', self.sd)
+   
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   FORMULE       = self.get_cmd('FORMULE')
+   CREA_CHAMP    = self.get_cmd('CREA_CHAMP')
+   DETRUIRE      = self.get_cmd('DETRUIRE')
+
+#  recuperation de la liste des fissures
+   if type(FISSURE) == tuple :
+      nbfiss = len(FISSURE)
+   else :
+      nbfiss = 1
+
+#  formule distance pour une fissure: 1/exp(r)
+   __MDISTF=FORMULE(NOM_PARA=('X1','X2'),VALE= '1./exp(sqrt(X1**2+X2**2))');
+#  formule distance pour une interface: 1/exp(lsn)
+   __MDISTI=FORMULE(NOM_PARA=('X1'),VALE= '1./exp(sqrt(X1**2))');
+
+   __CERR= [None]*nbfiss
+   list_err=[]
+   list_nom_cmp=[]
+   for_max = 'max('
+
+   for i in range(0,nbfiss) :
+
+      if nbfiss == 1 :
+         fiss = FISSURE
+      else :
+         fiss = FISSURE[i]
+
+      # recuperation du type de discontinuite :'FISSURE' ou 'INTERFACE'
+      # si FISSURE   : l'erreur est la distance au fond de fissure
+      # si INTERFACE : l'erreur est la distance a l'interface 
+      iret,ibid,typ_ds = aster.dismoi('F','TYPE_DISCONTINUITE',fiss.nom,'FISS_XFEM')
+      typ_ds=typ_ds.rstrip()
+
+      # extraction des champs level sets
+      __CHLN=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
+                      OPERATION='EXTR',
+                      NOM_CHAM='LNNO',
+                      FISSURE=fiss);
+
+      # on recupere le concept maillage associe a la level set normale
+      iret,ibid,nom_ma = aster.dismoi('F','NOM_MAILLA',__CHLN.nom,'CHAM_NO')
+      nom_ma=nom_ma.strip()
+      MA = self.get_concept(nom_ma)
+
+      if typ_ds == 'FISSURE' : 
+         __CHLTB=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
+                          OPERATION='EXTR',
+                          NOM_CHAM='LTNO',
+                          FISSURE=fiss);
+
+         # on renomme le composante X1 en X2
+         __CHLT=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
+                         OPERATION='ASSE',
+                         MAILLAGE=MA,
+                         ASSE=_F(TOUT='OUI',
+                                 CHAM_GD = __CHLTB,
+                                 NOM_CMP='X1',
+                                 NOM_CMP_RESU='X2',),
+                           );
+
+         DETRUIRE(CONCEPT=_F(NOM=__CHLTB),INFO=1) 
+
+      # On affecte à chaque noeud du maillage MA la formule __MDISTF ou __MDISTI
+      if typ_ds == 'FISSURE' : 
+         __CHFOR=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_F',
+                           OPERATION='AFFE',
+                           MAILLAGE=MA,
+                           AFFE=_F(TOUT='OUI',
+                                   NOM_CMP='X1',
+                                   VALE_F=__MDISTF,),
+                          );
+      elif typ_ds == 'INTERFACE' : 
+         __CHFOR=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_F',
+                           OPERATION='AFFE',
+                           MAILLAGE=MA,
+                           AFFE=_F(TOUT='OUI',
+                                   NOM_CMP='X1',
+                                   VALE_F=__MDISTI,),
+                          );  
+      
+      # on evalue en tout noeud le champ de formules
+      if typ_ds == 'FISSURE' : 
+         __CERRB=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
+                       OPERATION='EVAL',
+                       CHAM_F=__CHFOR,
+                       CHAM_PARA=(__CHLN,__CHLT,));
+
+         DETRUIRE(CONCEPT=_F(NOM=__CHLT),INFO=1) 
+
+      elif typ_ds == 'INTERFACE' : 
+         __CERRB=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
+                       OPERATION='EVAL',
+                       CHAM_F=__CHFOR,
+                       CHAM_PARA=(__CHLN,));
+
+      DETRUIRE(CONCEPT=_F(NOM=__CHLN),INFO=1) 
+      DETRUIRE(CONCEPT=_F(NOM=__CHFOR),INFO=1) 
+
+      # champ d'Erreur de la fissure i
+      __CERR[i]=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
+                          OPERATION='ASSE',
+                          MAILLAGE=MA,
+                          ASSE=_F(TOUT='OUI',
+                                  CHAM_GD = __CERRB,
+                                  NOM_CMP='X1',
+                                  NOM_CMP_RESU='X'+str(i+1),
+                                ),
+                        ); 
+
+      list_err.append(__CERR[i])
+      list_nom_cmp.append('X'+str(i+1))
+      for_max = for_max+'X'+str(i+1)+','
+
+      DETRUIRE(CONCEPT=_F(NOM=__CERRB),INFO=1) 
+
+   # si nbfiss = 1, c'est directement X1
+   # si nbfiss > 1 : on prend le max des erreurs de chaque fissure 
+   for_max = for_max+')'
+
+   if nbfiss == 1 :
+      __Erreur=FORMULE(NOM_PARA=(list_nom_cmp),VALE= 'X1');
+   else :
+      __Erreur=FORMULE(NOM_PARA=(list_nom_cmp),VALE= for_max);
+
+   # Définition de l'erreur en chaque noeud du maillage           
+   __CHFORM=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_F',
+                     OPERATION='AFFE',
+                     MAILLAGE=MA,
+                     AFFE=_F(TOUT='OUI',
+                             NOM_CMP='X1',
+                             VALE_F=__Erreur,),
+                    );
+
+   # champ de sortie
+   chamout=CREA_CHAMP(TYPE_CHAM='NOEU_NEUT_R',
+                     OPERATION='EVAL',
+                     CHAM_F=__CHFORM,
+                     CHAM_PARA=(list_err));
+
+   for i in range(0,nbfiss) :
+      DETRUIRE(CONCEPT=_F(NOM=__CERR[i]),INFO=1) 
+
+   DETRUIRE(CONCEPT=_F(NOM=__MDISTF),INFO=1) 
+   DETRUIRE(CONCEPT=_F(NOM=__MDISTI),INFO=1) 
+   DETRUIRE(CONCEPT=_F(NOM=__Erreur),INFO=1) 
+   DETRUIRE(CONCEPT=_F(NOM=__CHFORM),INFO=1) 
+
+   return
+ 

diff --git a/Aster/Cata/cataSTA10/Macro/reca_algo.py b/Aster/Cata/cataSTA10/Macro/reca_algo.py
new file mode 100644 (file)
index 0000000..9320a7a
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/reca_algo.py
@@ -0,0 +1,297 @@
+#@ MODIF reca_algo Macro  DATE 21/09/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+import Numeric, MLab
+from Numeric import take, size
+import copy, os
+import LinearAlgebra 
+
+try:
+  import aster
+  from Cata.cata import INFO_EXEC_ASTER
+  from Cata.cata import DETRUIRE
+  from Accas import _F
+  from Utilitai.Utmess import UTMESS
+except: pass
+
+
+def calcul_gradient(A,erreur):
+   grad = Numeric.dot(Numeric.transpose(A),erreur)
+   return grad
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+class Dimension:
+   """
+      Classe gérant l'adimensionnement et le dimensionnement
+   """
+
+   def __init__(self,val_initiales,para):
+      """
+         Le constructeur calcul la matrice D et son inverse
+      """
+      self.val_init = val_initiales
+      dim =len(self.val_init)
+      self.D = Numeric.zeros((dim,dim),Numeric.Float)
+      for i in range(dim):
+         self.D[i][i] = self.val_init[i]
+      self.inv_D=LinearAlgebra.inverse(self.D)
+   
+
+# ------------------------------------------------------------------------------
+
+   def adim_sensi(self,A):
+      for i in range(A.shape[0]):
+         for j in range(A.shape[1]):
+            A[i,j] = A[i,j] * self.val_init[j]
+      return A
+
+
+# ------------------------------------------------------------------------------
+
+   def redim_sensi(self,A):
+      for i in range(A.shape[0]):
+         for j in range(A.shape[1]):
+            A[i,j] = A[i,j] / self.val_init[j]
+      return A
+
+
+# ------------------------------------------------------------------------------
+
+   def adim(self,tab):
+      tab_adim = Numeric.dot(self.inv_D,copy.copy(tab))
+      return tab_adim
+
+
+# ------------------------------------------------------------------------------
+
+   def redim(self,tab_adim):
+      tab = Numeric.dot(self.D,tab_adim)
+      return tab
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+
+
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def cond(matrix):
+    e1=LinearAlgebra.eigenvalues(matrix)
+    e=map(abs,e1)
+    size=len(e)
+    e=Numeric.sort(e)
+    try:
+      condi=e[size-1]/e[0]
+    except ZeroDivisionError:
+      condi=0.0
+    return condi,e[size-1],e[0]
+
+
+
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def norm(matrix):
+    e=LinearAlgebra.Heigenvalues(matrix)
+    size=len(e)
+    e=Numeric.sort(e)
+    norm=e[size-1]
+    return norm
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def lambda_init(matrix):
+     """
+        Routine qui calcule la valeur initial du parametre de regularisation l.
+     """
+     condi,emax,emin=cond(matrix)
+     id=Numeric.identity(matrix.shape[0])
+     if (condi==0.0):
+         l=1.e-3*norm(matrix)
+     elif (condi<=10000):
+         l=1.e-16*norm(matrix)
+     elif (condi>10000):
+         l=abs(10000.*emin-emax)/10001.
+     return l
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out):  
+   """
+      On resoud le système par contraintes actives:
+         Q.dval + s + d =0
+         soumis à :
+         borne_inf < dval < borne_sup 
+                 0 <  s
+                 s.(borne_inf - dval)=0
+                 s.(borne_sup - dval)=0
+   """
+   dim = len(val)
+   id = Numeric.identity(dim)
+   # Matrice du système
+   Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id
+   # Second membre du système
+   d=Numeric.matrixmultiply(Numeric.transpose(A),erreur)
+   # Ens. de liaisons actives
+   Act=Numeric.array([])
+   k=0
+   done=0
+   # Increment des parametres 
+   dval=Numeric.zeros(dim,Numeric.Float)
+   while done <1 :
+      k=k+1
+      I=Numeric.ones(dim)
+      for i in Act:
+         I[i]=0
+      I=Numeric.nonzero(Numeric.greater(I,0))
+      s=Numeric.zeros(dim,Numeric.Float)
+      for i in Act:
+         # test sur les bornes (on stocke si on est en butée haute ou basse)
+         if (val[i]+dval[i]>=borne_sup[i]):
+            dval[i]=borne_sup[i]-val[i]
+            s[i]=1.
+         if (val[i]+dval[i]<=borne_inf[i]):
+            dval[i]=borne_inf[i]-val[i]
+            s[i]=-1.
+      if (len(I)!=0):
+          # xi=-Q(I)-1.(d(I)+Q(I,Act).dval(Act))
+          t_QI = take(Q, I)
+          t_tQI_Act = take(t_QI, Act, 1)
+          t_adim_Act = take(Dim.adim(dval), Act)
+          if size(t_tQI_Act) > 0 and size(t_adim_Act) > 0:
+             smemb = take(d, I) + Numeric.dot(t_tQI_Act, t_adim_Act)
+          else:
+             smemb = take(d, I)
+          xi=-LinearAlgebra.solve_linear_equations(take(t_QI, I, 1), smemb)
+          for i in Numeric.arange(len(I)):
+             dval[I[i]]=xi[i]*val_init[I[i]]
+      if (len(Act)!=0):
+         # s(Av)=-d(Act)-Q(Act,:).dval
+         sa=-take(d,Act)-Numeric.dot(take(Q,Act),Dim.adim(dval))
+         for i in range(len(Act)):
+            if (s[Act[i]]==-1.):
+               s[Act[i]]=-sa[i]
+            else:
+               s[Act[i]]=sa[i]
+      # Nouvel ens. de liaisons actives
+      Act=Numeric.concatenate((Numeric.nonzero(Numeric.greater(dval,borne_sup-val)),Numeric.nonzero(Numeric.less(dval,borne_inf-val)),Numeric.nonzero(Numeric.greater(s,0.))))
+      done=(max(val+dval-borne_sup)<=0)&(min(val+dval-borne_inf)>=0)&(min(s)>=0.0)
+      # Pour éviter le cyclage
+      if (k>50):
+         try:
+            l=l*2
+            Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id
+            k=0
+         except:
+             res=open(os.getcwd()+'/fort.'+str(ul_out),'a')
+             res.write('\n\nQ = \n'+Numeric.array2string(Q-l*id,array_output=1,separator=','))
+             res.write('\n\nd = '+Numeric.array2string(d,array_output=1,separator=','))
+             res.write('\n\nval = '+Numeric.array2string(val,array_output=1,separator=','))
+             res.write('\n\nval_ini= '+Numeric.array2string(val_init,array_output=1,separator=','))
+             res.write('\n\nborne_inf= '+Numeric.array2string(borne_inf,array_output=1,separator=','))
+             res.write('\n\nborne_sup= '+Numeric.array2string(borne_sup,array_output=1,separator=','))
+             UTMESS('F','RECAL0_18')
+             return 
+   newval=copy.copy(val+dval)
+   return newval,s,l,Act
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J):
+   dim = len(val)
+   id = Numeric.identity(dim)
+   # Matrice du système
+   Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id
+   # Second membre du système
+   d=Numeric.matrixmultiply(Numeric.transpose(A),erreur)
+   old_Q=old_J
+   new_Q=old_J+0.5*Numeric.dot(Numeric.transpose(new_val-val),Numeric.dot(Q,new_val-val))+Numeric.dot(Numeric.transpose(new_val-val),d)
+   # Ratio de la décroissance réelle et de l'approx. quad.
+   try:
+      R=(old_J-new_J)/(old_Q-new_Q)
+      if (R<0.25):
+         l = l*10.
+      elif (R>0.75):
+         l = l/15.
+   except ZeroDivisionError:
+      if (old_J>new_J):
+         l = l*10.
+      else:
+         l = l/10.
+   return l
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def test_convergence(gradient_init,erreur,A,s):
+   """
+      Renvoie le residu
+   """
+   gradient = calcul_gradient(A,erreur)+s
+   try:
+      epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init)
+   except:
+       UTMESS('F', "RECAL0_19")
+       return 
+   epsilon = epsilon**0.5
+   return epsilon
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def calcul_etat_final(para,A,iter,max_iter,prec,residu,Messg):
+   """
+      Fonction appelée quand la convergence est atteinte
+      on calcule le Hessien et les valeurs propres et vecteurs 
+      propre associés au Hessien
+      A    = sensibilite
+      At*A = hessien
+   """
+
+   if ((iter < max_iter) or (residu < prec)):
+      Hessien = Numeric.matrixmultiply(Numeric.transpose(A),A)
+
+      # Desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas
+      aster.matfpe(-1)
+      valeurs_propres,vecteurs_propres = LinearAlgebra.eigenvectors(Hessien) 
+#      valeurs_propres,vecteurs_propres = MLab.eig(Hessien) 
+      sensible=Numeric.nonzero(Numeric.greater(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-1))
+      insensible=Numeric.nonzero(Numeric.less(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-2))
+      # Reactive les FPE
+      aster.matfpe(1)
+
+      Messg.affiche_calcul_etat_final(para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible)

diff --git a/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py
new file mode 100644 (file)
index 0000000..b06ece5
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py
@@ -0,0 +1,844 @@
+#@ MODIF reca_calcul_aster Macro  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+#            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.        
+# ======================================================================
+
+# mode_include = False
+# __follow_output = False
+# table_sensibilite = False
+__commandes_aster__ = False
+
+debug = False
+
+import copy, Numeric, types, os, sys, pprint, math
+from glob import glob
+
+from Utilitai.System import ExecCommand
+from Utilitai.Utmess import UTMESS
+
+# Nom de la routine
+nompro = 'MACR_RECAL'
+
+
+# ------------------------------------------------------------------------------
+
+class PARAMETRES:
+
+  def __init__(self, METHODE, UNITE_RESU, INFO=1, fich_output='./REPE_OUT/output_esclave.txt', mode_include=False, follow_output=False, table_sensibilite=False, memjeveux_esclave=None, PARA_DIFF_FINI=1.E-3, ITER_MAXI=10, ITER_FONC_MAXI=100):
+
+    self.METHODE        = METHODE
+    self.UNITE_RESU     = UNITE_RESU
+    self.INFO           = INFO
+    self.fich_output    = fich_output
+    self.PARA_DIFF_FINI = PARA_DIFF_FINI
+    self.ITER_FONC_MAXI = ITER_FONC_MAXI
+    self.ITER_MAXI      = ITER_MAXI,
+
+    try:
+      import Cata, aster
+      from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE
+      from Accas import _F
+    except:
+      mode_include = False
+
+    if not mode_include:
+      try:
+        from Macro.lire_table_ops import lecture_table
+        mode_aster = True
+      except:
+        try:
+          sys.path.append( './Python/Macro' )
+          from Macro.lire_table_ops import lecture_table
+          mode_aster = False
+        except:
+          UTMESS('F','RECAL0_20')
+    self.mode_include      = mode_include
+    self.follow_output     = follow_output
+    self.mode_aster        = mode_aster
+    self.memjeveux_esclave = memjeveux_esclave    
+    self.table_sensibilite = table_sensibilite
+
+    self.vector_output     = False
+    self.error_output      = False
+
+
+# ------------------------------------------------------------------------------
+
+class CALCUL_ASTER:
+
+  def __init__(self, PARAMETRES, UL, para, reponses, LIST_SENSI=[], LIST_DERIV=[]):
+
+    self.UL                    = UL
+    self.para                  = para
+    self.reponses              = reponses
+    self.LIST_SENSI            = LIST_SENSI
+    self.LIST_DERIV            = LIST_DERIV
+
+    self.METHODE               = PARAMETRES.METHODE
+    self.UNITE_RESU            = PARAMETRES.UNITE_RESU
+    self.INFO                  = PARAMETRES.INFO
+    self.fich_output           = PARAMETRES.fich_output
+    self.mode_include          = PARAMETRES.mode_include
+    self.follow_output         = PARAMETRES.follow_output
+    self.table_sensibilite     = PARAMETRES.table_sensibilite
+    self.mode_aster            = PARAMETRES.mode_aster
+    self.memjeveux_esclave     = PARAMETRES.memjeveux_esclave    
+    self.PARA_DIFF_FINI        = PARAMETRES.PARA_DIFF_FINI
+    self.ITER_FONC_MAXI        = PARAMETRES.ITER_FONC_MAXI
+    self.vector_output         = PARAMETRES.vector_output
+    self.error_output          = PARAMETRES.vector_output
+
+    self.UNITE_GRAPHIQUE       = None
+    self.new_export            = 'tmp_export'
+    self.nom_fichier_mess_fils = None
+    self.nom_fichier_resu_fils = None
+
+    self.fichier_esclave       = None
+
+    self.evaluation_fonction   = 0
+
+    self.L_J_init              = None
+    self.val                   = None
+    self.L                     = None
+    self.L_deriv_sensible      = None
+
+
+
+  # ------------------------------------------------------------------------------
+
+  def Lancement_Commande(self, cmd):
+
+          if self.INFO>=1: UTMESS('I','EXECLOGICIEL0_8',valk=cmd)
+
+          fich_output       = self.fich_output
+          follow_output     = self.follow_output
+
+          # Lancement d'Aster avec le deuxieme export
+          iret, txt_output = ExecCommand(cmd, follow_output=self.follow_output,verbose=False)
+
+          if fich_output:
+             # Recuperation du .mess 'fils'
+             f=open(fich_output, 'w')
+             f.write( txt_output )
+             f.close()
+
+          if self.INFO>=1: UTMESS('I','EXECLOGICIEL0_12',valk=cmd)
+
+          diag = self.Recuperation_Diagnostic(txt_output)
+
+          return
+
+
+  # ------------------------------------------------------------------------------
+
+  def Recuperation_Diagnostic(self, output):
+
+    txt = '--- DIAGNOSTIC JOB :'
+    diag = ''
+    for ligne in output.splitlines():
+      if ligne.find(txt) > -1:
+        diag = ligne.split(txt)[-1].strip()
+        break
+
+    if self.INFO>=1: UTMESS('I','RECAL0_21',valk=diag)
+
+    if diag in ['OK', 'NOOK_TEST_RESU', '<A>_ALARM', '<F>_COPY_ERROR']: return True
+    else:
+      UTMESS('F','RECAL0_22')
+
+
+  # ------------------------------------------------------------------------------
+
+  def Remplace_fichier_esclave(self, val_in): pass
+
+
+  # ------------------------------------------------------------------------------
+
+  def calcul_Aster(self, val, INFO=0):
+
+        self.val   = val
+        UL         = self.UL
+        para       = self.para
+        reponses   = self.reponses
+        UNITE_RESU = self.UNITE_RESU
+        LIST_SENSI = self.LIST_SENSI
+        LIST_DERIV = self.LIST_DERIV
+
+        mode_include      = self.mode_include
+        follow_output     = self.follow_output
+        table_sensibilite = self.table_sensibilite
+
+        if self.evaluation_fonction > self.ITER_FONC_MAXI:
+           UTMESS('F', 'RECAL0_23')
+        self.evaluation_fonction += 1
+
+
+        if not mode_include:
+
+          # Creation du repertoire temporaire pour l'execution de l'esclave
+          tmp_macr_recal = self.Creation_Temporaire_Esclave()
+
+          # Creation du fichier .export de l'esclave
+          self.Creation_Fichier_Export_Esclave(tmp_macr_recal)  
+
+        # Fichier esclave a modifier (si methode EXTERNE alors on prend directement le fichier esclave, sinon c'est le fort.UL dans le repertoire d'execution
+        try:
+           if self.METHODE=='EXTERNE':
+              fic = open(self.fichier_esclave,'r')
+           else:
+              fic = open('fort.'+str(UL),'r')
+
+           # On stocke le contenu de fort.UL dans la variable fichier qui est une string 
+           fichier=fic.read()
+           # On stocke le contenu initial de fort.UL dans la variable fichiersauv 
+           fichiersauv=copy.copy(fichier)
+           fic.close()
+        except:
+           UTMESS('F', 'RECAL0_24', valk=self.fichier_esclave)
+
+        # chemin vers as_run
+        if os.environ.has_key('ASTER_ROOT'):
+           as_run = os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'bin', 'as_run')
+        elif os.path.isfile(aster.repout() + os.sep + 'as_run'):
+           as_run = aster.repout() + os.sep + 'as_run'
+        else:
+           as_run = 'as_run'
+           if INFO>=1: UTMESS('A', 'RECAL0_83')
+
+        if __commandes_aster__:
+          try:
+            from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE
+          except: 
+            message = "Erreur"
+            UTMESS('F', 'DVP_1')
+
+        # Utilisation du module Python de LIRE_TABLE
+        if self.mode_aster:
+          from Macro.lire_table_ops import lecture_table
+        else:
+          try:
+            sys.path.append( './Python/Macro' )
+            from lire_table_ops import lecture_table
+          except:
+            UTMESS('F','RECAL0_20')
+
+        txt = []
+        for i in para:
+          txt.append( "\t\t\t%s : %s" % (i, val[para.index(i)]) )
+        if INFO>=1: UTMESS('I','RECAL0_25',valk='\n'.join(txt))
+  
+  
+  # MARCHE PAS !!
+#         # Quelques verifications/modifications sur le fichier esclave, pour blindage
+#         fichiernew=[]
+#         for ligne in fichier.split('\n'):
+#            # DEBUT et FIN (on retire les espaces entre le mot-clé et la premiere parenthese)
+#            for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]:
+#               if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1:
+#                  index_deb1 = ligne.index(txt1)
+#                  ligne1 = ligne[ index_deb1+len(txt1):]
+#                  if ligne.find( txt1 )!=-1:
+# 
+# 
+#            for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]:
+#               if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1:
+#                  index_deb1 = ligne.index(txt1)
+#                  index_fin1 = index_deb1 + len(txt1)
+#                  index_deb2 = ligne.index(txt2)
+#                  index_fin2 = index_deb1 + len(txt2)
+#                  ligne = ligne[:index_fin1]+ligne[index_deb2:]
+#               # on retire les parametes en commentaires
+#               for txt in para:
+#                  if ligne.find(txt)!=-1:
+#                    if ligne.replace(' ', '')[0] == '#': ligne = ''
+#            fichiernew.append(ligne)
+#         fichier = '\n'.join(fichiernew)
+
+
+
+        # On supprime tous les commentaires du fichier esclave
+        fichiernew=[]
+        for ligne in fichier.split('\n'):
+           if ligne.strip() != '':
+              if ligne.replace(' ', '')[0] == '#': ligne = ''
+              fichiernew.append(ligne)
+        fichier = '\n'.join(fichiernew)
+
+
+        #Fichier_Resu est une liste ou l'on va stocker le fichier modifié
+        #idée générale :on délimite des 'blocs' dans fichier
+        #on modifie ou non ces blocs suivant les besoins 
+        #on ajoute ces blocs dans la liste Fichier_Resu
+        Fichier_Resu=[]                      
+
+        # Dans le cas du mode INCLUDE on enleve le mot-clé DEBUT
+        if mode_include:
+          try: 
+             #cherche l'indice de DEBUT()
+             index_deb=fichier.index('DEBUT(')
+             while( fichier[index_deb]!='\n'):
+                index_deb=index_deb+1
+             #on restreint fichier en enlevant 'DEBUT();'
+             fichier = fichier[index_deb+1:]   
+          except:
+             #on va dans l'except si on a modifié le fichier au moins une fois
+             pass 
+  
+#         print 60*'o'
+#         print fichier
+#         print 60*'o'
+
+        # On enleve le mot-clé FIN()
+        try:
+           #cherche l'indice de FIN()
+           index_fin = fichier.index('FIN(')
+           #on restreint fichier en enlevant 'FIN();'
+           fichier = fichier[:index_fin]
+        except : pass
+
+#         print 60*'o'
+#         print fichier
+#         print 60*'o'
+
+        #--------------------------------------------------------------------------------
+        #on cherche à délimiter le bloc des parametres dans le fichier
+        #Tout d'abord on cherche les indices d'apparition des paras dans le fichier 
+        #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise
+        #avec le meme ordre que son fichier de commande
+        index_para = Numeric.zeros(len(para))
+        for i in range(len(para)):
+           index_para[i] = fichier.index(para[i])
+
+        #On range les indices par ordre croissant afin de déterminer
+        #les indice_max et indice_min
+        index_para = Numeric.sort(index_para)
+        index_first_para = index_para[0]
+        index_last_para = index_para[len(index_para)-1]
+  
+  
+        #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation
+        bloc_inter ='\n'
+        for i in range(len(para)-1):
+           j = index_para[i]
+           k = index_para[i+1]
+           while(fichier[j]!= '\n'):
+              j=j+1
+           bloc_inter=bloc_inter + fichier[j:k] + '\n'
+  
+        #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para
+        i = index_last_para 
+        while(fichier[i] != '\n'):
+           i = i + 1
+        index_last_para  = i
+        #on délimite les blocs suivants:
+        pre_bloc = fichier[:index_first_para]        #fichier avant premier parametre
+        post_bloc = fichier[ index_last_para+ 1:]    #fichier après dernier parametre
+  
+        #on ajoute dans L tous ce qui est avant le premier paramètre 
+        Fichier_Resu.append(pre_bloc)
+        Fichier_Resu.append('\n')
+  
+        # Liste des parametres utilisant la SENSIBILITE
+        liste_sensibilite = []
+        if len(LIST_SENSI)>0:
+          for i in LIST_SENSI:
+            liste_sensibilite.append( i )
+  
+        #On ajoute la nouvelle valeur des parametres
+        dim_para=len(para)
+        for j in range(dim_para):
+           if not para[j] in liste_sensibilite:
+             Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n')
+           else:
+             Fichier_Resu.append(para[j]+'=DEFI_PARA_SENSI(VALE='+str(val[j]) + ',);' + '\n')
+
+
+        #On ajoute à Fichier_Resu tous ce qui est entre les parametres
+        Fichier_Resu.append(bloc_inter)
+        
+        Fichier_Resu.append(post_bloc)
+  
+        #--------------------------------------------------------------------------------
+        #on va ajouter la fonction d'extraction du numarray de la table par la méthode Array 
+        #et on stocke les réponses calculées dans la liste Lrep
+        #qui va etre retournée par la fonction calcul_Aster
+        if mode_include:
+          self.g_context['Lrep'] = []
+          Fichier_Resu.append('Lrep=[]'+'\n')
+          for i in range(len(reponses)):
+             Fichier_Resu.append('t'+str(reponses[i][0])+'='+str(reponses[i][0])+'.EXTR_TABLE()'+'\n')
+             Fichier_Resu.append('F = '+'t'+str(reponses[i][0])+'.Array('+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n')
+             Fichier_Resu.append('Lrep.append(F)'+'\n')
+
+        #ouverture du fichier fort.3 et mise a jour de celui ci
+        x=open('fort.'+str(UL),'w')
+        if mode_include:
+          x.writelines('from Accas import _F \nfrom Cata.cata import * \n')
+        x.writelines(Fichier_Resu)
+        x.close()
+
+        del(pre_bloc)
+        del(post_bloc)
+        del(fichier)
+
+        # ----------------------------------------------------------------------------------
+        # Execution d'une deuxieme instance d'Aster
+
+        if not mode_include:
+
+          # Ajout des commandes d'impression des tables Resultats et Derivees à la fin du fichier esclave
+          Fichier_Resu = []
+          num_ul = '99'
+
+          # Tables correspondant aux Resultats
+          for i in range(len(reponses)):
+             _ul = str(int(100+i))
+
+             try:    os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul )
+             except: pass
+
+             Fichier_Resu.append("\n# Recuperation de la table : " + str(reponses[i][0]) + "\n")
+             Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n")
+             Fichier_Resu.append("IMPR_TABLE(TABLE="+str(reponses[i][0])+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
+             Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n")
+
+          # Tables correspondant aux Derivees
+          if len(LIST_SENSI)>0:
+              i = 0
+              for _para in LIST_SENSI:
+                  _lst_tbl  = LIST_DERIV[_para][0]
+                  for _lst_tbl in LIST_DERIV[_para]:
+                     i += 1
+                     _tbl = _lst_tbl[0]
+  
+                     _ul = str(int(100+len(reponses)+i))
+                     try:    os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul )
+                     except: pass
+  
+                     Fichier_Resu.append("\n# Recuperation de la table derivee : " + _tbl + " (parametre " + _para + ")\n")
+                     Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n")
+                     if table_sensibilite:
+                       Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", SENSIBILITE="+_para+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
+                     else:
+                       Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
+                     Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n")
+
+          # Ecriture du "nouveau" fichier .comm
+          x=open('fort.'+str(UL),'a')
+          x.write( '\n'.join(Fichier_Resu) )
+          x.write('\nFIN();\n')
+          x.close()
+
+#          os.system("cat %s" % self.new_export)
+
+          # Lancement du calcul Aster esclave
+          cmd = '%s %s' % (as_run, self.new_export)
+          self.Lancement_Commande(cmd)
+
+          # Recuperation du .mess et du .resu 'fils'
+          if self.METHODE != 'EXTERNE':
+             if self.nom_fichier_mess_fils:
+                 cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_mess_fils + ' ./REPE_OUT/'
+                 os.system( cmd )
+             if self.nom_fichier_resu_fils:
+                 cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_resu_fils + ' ./REPE_OUT/'
+                 os.system( cmd )
+  
+          if __commandes_aster__:
+              # Unite logique libre
+              _tbul_libre=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
+              _ul_libre=_tbul_libre['UNITE_LIBRE',1]
+
+
+          # ------------------------------------------------------
+          # Recuperation des tableaux resultats
+          Lrep=[]
+          _TB = [None]*len(reponses)
+          for i in range(len(reponses)):
+
+            if __commandes_aster__:
+
+                # Version par des commandes Aster
+                # -------
+
+
+                DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i)), );
+                try:
+                  _TB[i]=LIRE_TABLE(UNITE=_ul_libre,
+                                    FORMAT='ASTER',
+                                    NUME_TABLE=1,
+                                    SEPARATEUR=' ',);
+                  DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,);
+                  tREPONSE=_TB[i].EXTR_TABLE()
+  
+                  F = tREPONSE.Array( str(reponses[i][1]), str(reponses[i][2]) )
+                  Lrep.append(F)
+                except:
+                  UTMESS('F', 'RECAL0_26')
+
+            else:
+
+                # Version par utilisation directe du python de lire_table
+                # -------
+
+                # Chemin vers le fichier contenant la table
+                _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i))
+
+                try:
+                   file=open(_fic_table,'r')
+                   texte=file.read()
+                   file.close()
+                except Exception, err:
+                   ier=1
+                   UTMESS('F', 'RECAL0_27', valk=str(err))
+
+                try:
+                   table_lue = lecture_table(texte, 1, ' ')
+                   list_para = table_lue.para
+                   tab_lue   = table_lue.values()
+                except Exception, err:
+                   UTMESS('F', 'RECAL0_28', valk=str(err))
+
+                try:
+                    nb_val = len(tab_lue[ list_para[0] ])
+                    F = Numeric.zeros((nb_val,2), Numeric.Float)
+                    for k in range(nb_val):
+#                       F[k][0] = tab_lue[ list_para[0] ][1][k]
+#                       F[k][1] = tab_lue[ list_para[1] ][1][k]
+                      F[k][0] = tab_lue[ str(reponses[i][1]) ][k]
+                      F[k][1] = tab_lue[ str(reponses[i][2]) ][k]
+                    Lrep.append(F)
+                except Exception, err:
+                    UTMESS('F', 'RECAL0_29', valk=str(err))
+
+
+          # ------------------------------------------------------
+          # Recuperation des tableaux des derivees (SENSIBILITE)
+          L_deriv={}
+          if len(LIST_SENSI)>0:
+              _lon = 0
+              for _para in LIST_SENSI:
+                  _lon += len(LIST_DERIV[_para])
+              _TBD = [None]*_lon
+
+              i = 0
+              for _para in LIST_SENSI:
+
+                  L_deriv[_para] = []
+                  _lst_tbl  = LIST_DERIV[_para][0]
+
+                  for _lst_tbl in LIST_DERIV[_para]:
+                      j = LIST_DERIV[_para].index(_lst_tbl)
+                      _tbl = _lst_tbl[0]
+
+                      if __commandes_aster__:
+
+                          # Version par des commandes Aster
+                          # -------
+
+                          DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i)),);
+                          _TBD[i]=LIRE_TABLE(UNITE=_ul_libre,
+                                           FORMAT='ASTER',
+                                           NUME_TABLE=1,
+                                           SEPARATEUR=' ',);
+                          DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,);
+                          tREPONSE=_TBD[i].EXTR_TABLE()
+                          DF = tREPONSE.Array( str(LIST_DERIV[_para][j][1]), str(LIST_DERIV[_para][j][2]) )
+                          L_deriv[_para].append(DF)
+                          i+=1
+
+                      else:
+
+                          # Version par utilisation directe du python de lire_table
+                          # -------
+      
+                          # Chemin vers le fichier contenant la table
+                          _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i))
+
+                          try:
+                             file=open(_fic_table,'r')
+                             texte=file.read()
+                             file.close()
+                          except Exception, err:
+                             UTMESS('F', 'RECAL0_27', valk=str(err))
+
+                          try:
+                             table_lue = lecture_table(texte, 1, ' ')
+                             list_para = table_lue.para
+                             tab_lue   = table_lue.values()
+                          except Exception, err:
+                             UTMESS('F', 'RECAL0_28', valk=str(err))
+
+                          try:
+                              nb_val = len(tab_lue[ list_para[0] ])
+                              DF = Numeric.zeros((nb_val,2), Numeric.Float)
+                              for k in range(nb_val):
+#                                 DF[k][0] = tab_lue[ list_para[0] ][1][k]
+#                                 DF[k][1] = tab_lue[ list_para[1] ][1][k]
+                                DF[k][0] = tab_lue[ str(LIST_DERIV[_para][j][1]) ][k]
+                                DF[k][1] = tab_lue[ str(LIST_DERIV[_para][j][2]) ][k]
+                              L_deriv[_para].append(DF)
+                              i+=1
+                          except Exception, err:
+                             UTMESS('F', 'RECAL0_29', valk=str(err))
+
+
+          # Nettoyage du export
+          try:    os.remove(self.new_export)
+          except: pass
+  
+          # Nettoyage du repertoire temporaire
+          if self.METHODE == 'EXTERNE': listdir =  ['REPE_TABLE', 'base', 'REPE_IN']
+          else:                         listdir =  ['.', 'REPE_TABLE', 'base', 'REPE_OUT', 'REPE_IN']
+          for dir in listdir:
+            try:
+              for fic in os.listdir(tmp_macr_recal+os.sep+dir):
+                try:    os.remove(tmp_macr_recal+os.sep+dir+os.sep+fic)
+                except: pass
+            except: pass
+
+
+
+        # ----------------------------------------------------------------------------------
+        # Ou bien on inclue le fichier Esclave
+
+        elif mode_include:
+
+          if debug: os.system('cp fort.'+str(UL)+' REPE_OUT/')
+  
+          INCLUDE(UNITE = UL)
+  
+          Lrep = self.g_context['Lrep']
+          L_deriv = None
+  
+          # Destruction des concepts Aster
+          reca_utilitaires.detr_concepts(self)
+  
+  
+        # ----------------------------------------------------------------------------------
+        # Ou alors probleme ?
+        else: sys.exit(1)
+  
+  
+        del(Fichier_Resu)
+  
+        # on remet le fichier dans son etat initial
+        x=open('fort.'+str(UL),'w')
+        x.writelines(fichiersauv)
+        x.close()
+
+        return Lrep, L_deriv
+
+
+
+  # ------------------------------------------------------------------------------
+
+  def calcul_FG(self, val):
+
+     self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
+     self.L_J, self.erreur = self.Simul.multi_interpole(self.L, self.reponses)
+     if not self.L_J_init: self.L_J_init = copy.copy(self.L_J)
+     self.J = self.Simul.norme_J(self.L_J_init, self.L_J, self.UNITE_RESU)
+
+     # Calcul des derivees
+     self.A_nodim = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI)
+
+     self.A = self.Dim.adim_sensi( copy.copy(self.A_nodim) )
+#     self.residu = self.reca_algo.test_convergence(self.gradient_init, self.erreur, self.A, Numeric.zeros(len(self.gradient_init),Numeric.Float) )
+     self.residu = 0.
+
+     if self.vector_output:
+        return self.erreur, self.residu, self.A_nodim, self.A
+     else:
+        # norme de l'erreur
+        self.norme = Numeric.dot(self.erreur, self.erreur)**0.5
+
+        self.norme_A_nodim = Numeric.zeros( (1,len(self.para)), Numeric.Float )
+        self.norme_A       = Numeric.zeros( (1,len(self.para)), Numeric.Float )
+        for c in range(len(self.A[0,:])):
+           norme_A_nodim = 0
+           norme_A        = 0
+           for l in range(len(self.A[:,0])):
+              norme_A_nodim += self.A_nodim[l,c] * self.A_nodim[l,c]
+              norme_A       += self.A[l,c] * self.A[l,c]
+           self.norme_A_nodim[0,c] = math.sqrt( norme_A_nodim ) 
+           self.norme_A[0,c] = math.sqrt( norme_A )
+
+        return self.norme, self.residu, self.norme_A_nodim, self.norme_A
+
+
+  # ------------------------------------------------------------------------------
+
+  def calcul_F(self, val):
+
+     self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
+     L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses)
+     if not self.L_J_init: self.L_J_init = copy.copy(L_J)
+     J = self.Simul.norme_J(self.L_J_init, L_J, self.UNITE_RESU)
+
+     # norme de l'erreur
+     norme = Numeric.sum( [x**2 for x in erreur] )
+
+     if debug:
+        print 'erreur=', erreur
+        print "norme de l'erreur=", norme
+        print "norme de J (fonctionnelle)=", str(J)
+
+     if self.INFO>=1: 
+        UTMESS('I', 'RECAL0_30')
+        if self.evaluation_fonction >1:
+           UTMESS('I', 'RECAL0_1', valk=str(self.evaluation_fonction))
+        UTMESS('I', 'RECAL0_31', valk=J)
+
+     if self.vector_output:
+        if self.INFO>=1:
+           UTMESS('I', 'RECAL0_32', valk=str(norme))
+        return erreur
+     else:
+        if self.INFO>=1:
+           UTMESS('I', 'RECAL0_33', valk=str(norme))
+        return norme
+
+
+
+  # ------------------------------------------------------------------------------
+
+  def calcul_G(self, val):
+
+     # Si le calcul Aster est deja effectue pour val on ne le refait pas
+     if (self.val == val) and self.L and self.L_deriv_sensible: pass
+     else:
+        self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
+     A = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI)
+     A = self.Dim.adim_sensi(A)
+     L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses)
+     grad = Numeric.dot(Numeric.transpose(A),erreur) 
+     if debug: print 'grad=', grad
+     return grad
+
+
+  # ------------------------------------------------------------------------------
+
+  def Creation_Temporaire_Esclave(self):
+     """
+        Creation du repertoire temporaire d'execution du calcul esclace
+     """
+
+     # Creation du repertoire temporaire
+     tmp_macr_recal = os.getcwd() + os.sep + 'tmp_macr_recal'
+     try:    os.mkdir(tmp_macr_recal)
+     except: pass
+     if not os.path.exists(tmp_macr_recal): UTMESS('F','RECAL0_34',valk=tmp_macr_recal)
+     try:    os.mkdir(tmp_macr_recal + os.sep + 'REPE_TABLE')
+     except: pass
+     if not os.path.exists(tmp_macr_recal + os.sep + 'REPE_TABLE'): UTMESS('F','RECAL0_34',valk=tmp_macr_recal + os.sep + 'REPE_TABLE')
+
+     return tmp_macr_recal
+
+
+  # ------------------------------------------------------------------------------
+
+  def Creation_Fichier_Export_Esclave(self, tmp_macr_recal):
+     """
+        Creation du fichier .export pour le calcul esclave
+     """
+
+     from as_profil import ASTER_PROFIL
+
+     # Recuperation du fichier .export
+     list_export = glob('*.export')
+
+     if len(list_export) == 0: UTMESS('F','RECAL0_4')
+     elif len(list_export) >1: UTMESS('F','RECAL0_5')
+
+     # On modifie le profil
+     prof = ASTER_PROFIL(list_export[0])
+
+     # xterm
+     if prof.param.has_key('xterm'):
+        del prof.param['xterm']
+     # memjeveux
+     prof.args['memjeveux'] = self.memjeveux_esclave
+
+     # fichier/répertoire
+     for lab in ('data', 'resu'):
+       l_fr = getattr(prof, lab)
+       l_tmp = l_fr[:]
+
+       for dico in l_tmp:
+
+         # répertoires
+         if dico['isrep']:
+
+           # base non prise en compte
+           if dico['type'] in ('base', 'bhdf'):
+             l_fr.remove(dico)
+
+           if lab == 'resu':
+             dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
+
+         # fichiers
+         else:
+
+           # Nom du fichier .mess (pour recuperation dans REPE_OUT)
+           if dico['ul'] == '6':
+             self.nom_fichier_mess_fils = os.path.basename(dico['path'])
+#             self.nom_fichier_mess_fils = os.path.join(os.getcwd(), 'fort.%d' % self.UL)
+
+           # Nom du fichier .resu (pour recuperation dans REPE_OUT)
+           if dico['ul'] == '8':
+             self.nom_fichier_resu_fils = os.path.basename(dico['path'])
+
+           # Ancien .comm non pris en compte
+           # Fichier d'unite logique UNITE_RESU (rapport de MACR_RECAL) non pris en compte
+           if dico['type'] == 'comm' or (dico['ul'] == str(self.UNITE_RESU) and lab == 'resu'):
+             l_fr.remove(dico)
+
+           # Fichier d'unite logique UL devient le nouveau .comm
+           elif dico['ul'] == str(self.UL):
+             self.fichier_esclave = dico['path']
+             dico['type'] = 'comm'
+             dico['ul']   = '1'
+             dico['path'] = os.path.join(os.getcwd(), 'fort.%d' % self.UL)
+
+           # Tous les autres fichiers en Resultat
+           elif lab == 'resu':
+              if self.UNITE_GRAPHIQUE and dico['ul'] == str(self.UNITE_GRAPHIQUE): l_fr.remove(dico)
+              else:
+                 dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
+
+           # Tous les autres fichiers en Donnees
+           elif lab == 'data':
+              if dico['type'] not in ('exec', 'ele'):
+                 if dico['ul']   != '0':   # Traite le cas des sources python sourchargees
+                    if self.METHODE !='EXTERNE': 
+                       dico['path'] = os.path.join(os.getcwd(), 'fort.%s' % dico['ul'])
+
+           # sinon on garde la ligne telle quelle
+       setattr(prof, lab, l_fr)
+
+     # Ecriture du nouveau fichier export
+     prof.WriteExportTo(self.new_export)
+
+     if debug: os.system('cp ' + self.new_export + ' /tmp')
+
+  # --FIN CLASSE  ----------------------------------------------------------------------------
+
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/reca_controles.py b/Aster/Cata/cataSTA10/Macro/reca_controles.py
new file mode 100644 (file)
index 0000000..a3c61e1
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/reca_controles.py
@@ -0,0 +1,244 @@
+#@ MODIF reca_controles Macro  DATE 21/09/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+#            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.        
+# ======================================================================
+
+import string, copy, Numeric, types, os, sys, pprint
+
+# Nom de la routine
+nompro = 'MACR_RECAL'
+
+
+
+#_____________________________________________
+#
+# CONTROLE DES ENTREES UTILISATEUR
+#_____________________________________________
+
+# ------------------------------------------------------------------------------
+
+def erreur_de_type(code_erreur,X):
+   """
+   code_erreur ==0 --> X est une liste
+   code erreur ==1 --> X est un char
+   code erreur ==2 --> X est un float
+   test est un boolean (test = 0 défaut et 1 si un test if est verifier
+   """
+
+   txt = ""
+   if(code_erreur == 0 ):
+      if type(X) is not types.ListType:
+         txt="\nCette entrée: " +str(X)+" n'est pas une liste valide"
+   if(code_erreur == 1 ):
+      if type(X) is not types.StringType:
+         txt="\nCette entrée: " +str(X)+" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python"
+   if(code_erreur == 2 ):
+      if type(X) is not types.FloatType:
+         txt="\nCette entrée:  " +str(X)+" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python"
+   return txt
+   
+
+# ------------------------------------------------------------------------------
+   
+def erreur_dimension(PARAMETRES,REPONSES):
+   """
+   On verifie que la dimension de chaque sous_liste de parametre est 4
+   et que la dimension de chaque sous_liste de REPONSES est 3
+   """
+
+   txt = ""
+   for i in range(len(PARAMETRES)):
+      if (len(PARAMETRES[i]) != 4):
+         txt=txt + "\nLa sous-liste de la variable paramètre numéro " + str(i+1)+" n'est pas de longueur 4"
+   for i in range(len(REPONSES)):
+      if (len(REPONSES[i]) != 3):
+         txt=txt + "\nLa sous-liste de la variable réponse numéro " + str(i+1)+" n'est pas de longueur 3"
+   return txt
+
+
+# ------------------------------------------------------------------------------
+
+def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP):
+   """
+   X et Y sont deux arguments qui doivent avoir la meme dimension
+   pour éviter l'arret du programme
+   """
+
+   txt = ""
+   if( len(REPONSES) != len(RESU_EXP)):
+      txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux"
+   return txt
+
+
+# ------------------------------------------------------------------------------
+
+def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
+   """
+   POIDS et Y sont deux arguments qui doivent avoir la meme dimension
+   pour éviter l'arret du programme
+   """
+
+   txt = ""
+   if( len(POIDS) != len(RESU_EXP)):
+      txt="\nVous avez entré " +str(len(POIDS))+ " poids et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de poids que de résultats expérimentaux"
+   return txt
+
+
+# ------------------------------------------------------------------------------
+
+def verif_fichier(UL,PARAMETRES,REPONSES):
+   """
+   On verifie les occurences des noms des PARAMETRES et REPONSES 
+   dans le fichier de commande ASTER
+   """
+
+   txt = ""
+   txt_alarme = ""
+   try:
+      fichier = open('fort.'+str(UL),'r')
+      fic=fichier.read()
+   except:
+      txt += "\nImpossible d'ouvrir le fichier esclave declare avec l'unite logique " + str(UL)
+      return txt, txt_alarme
+   for i in range(len(PARAMETRES)):
+      if((string.find(fic,PARAMETRES[i][0])==-1) or ((string.find(fic,PARAMETRES[i][0]+'=')==-1) and (string.find(fic,PARAMETRES[i][0]+' ')==-1))):
+         txt += "\nLe paramètre "+PARAMETRES[i][0]+" que vous avez entré pour la phase d'optimisation n'a pas été trouvé dans votre fichier de commandes ASTER"
+   for i in range(len(REPONSES)):
+      if((string.find(fic,REPONSES[i][0])==-1) or ((string.find(fic,REPONSES[i][0]+'=')==-1) and (string.find(fic,REPONSES[i][0]+' ')==-1))):
+         txt_alarme += "\nLa réponse  "+REPONSES[i][0]+" que vous avez entrée pour la phase d'optimisation n'a pas été trouvée dans votre fichier de commandes ASTER"
+   return txt, txt_alarme
+
+
+# ------------------------------------------------------------------------------
+
+def verif_valeurs_des_PARAMETRES(PARAMETRES):
+   """
+   On verifie que pour chaque PARAMETRES de l'optimisation
+   les valeurs entrées par l'utilisateur sont telles que :
+              val_inf<val_sup
+              val_init appartient à [borne_inf, borne_sup] 
+              val_init!=0         
+              borne_sup!=0         
+              borne_inf!=0         
+   """
+
+   txt = ""
+   # verification des bornes
+   for i in range(len(PARAMETRES)):
+      if( PARAMETRES[i][2] >PARAMETRES[i][3]):
+         txt=txt + "\nLa borne inférieure "+str(PARAMETRES[i][2])+" de  "+PARAMETRES[i][0]+ "est plus grande que sa borne supérieure"+str(PARAMETRES[i][3])
+   # verification de l'encadrement de val_init 
+   for i in range(len(PARAMETRES)):
+      if( (PARAMETRES[i][1] < PARAMETRES[i][2]) or (PARAMETRES[i][1] > PARAMETRES[i][3])):
+         txt=txt + "\nLa valeur initiale "+str(PARAMETRES[i][1])+" de "+PARAMETRES[i][0]+ " n'est pas dans l'intervalle [borne_inf,born_inf]=["+str(PARAMETRES[i][2])+" , "+str(PARAMETRES[i][3])+"]"
+   # verification que val_init !=0
+   for  i in range(len(PARAMETRES)):
+      if (PARAMETRES[i][1] == 0. ):
+         txt=txt + "\nProblème de valeurs initiales pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur initiale nulle mais un ordre de grandeur."
+   # verification que borne_sup !=0
+   for  i in range(len(PARAMETRES)):
+      if (PARAMETRES[i][3] == 0. ):
+         txt=txt + "\nProblème de borne supérieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
+   # verification que borne_inf !=0
+   for  i in range(len(PARAMETRES)):
+      if (PARAMETRES[i][2] == 0. ):
+         txt=txt + "\nProblème de borne inférieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
+   return txt
+
+
+# ------------------------------------------------------------------------------
+
+def verif_UNITE(GRAPHIQUE,UNITE_RESU):
+   """
+   On vérifie que les unités de résultat et 
+   de graphique sont différentes
+   """
+   txt=""
+   if GRAPHIQUE:
+      GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+      if (GRAPHE_UL_OUT==UNITE_RESU):
+          txt=txt + "\nLes unités logiques des fichiers de résultats graphiques et de résultats d'optimisation sont les memes."
+   return txt
+
+
+# ------------------------------------------------------------------------------
+
+def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU,METHODE):
+   """
+   Cette methode va utiliser les methodes de cette classe declarée ci-dessus
+   test  est un boolean: test=0 -> pas d'erreur
+                         test=1 -> erreur détectée
+   """
+
+   texte = ""
+   texte_alarme = ""
+
+   # On vérifie d'abord si PARAMETRES, REPONSES, RESU_EXP sont bien des listes au sens python
+   # test de PARAMETRES
+   texte = texte + erreur_de_type(0,PARAMETRES)
+   # test de REPONSES
+   texte = texte + erreur_de_type(0,REPONSES)
+   # test de RESU_EXP
+   texte = texte + erreur_de_type(0,RESU_EXP) 
+   
+   # On vérifie si chaque sous liste de PARAMETRES, REPONSES,  possède le type adéquat
+   # test des sous_listes de PARAMETRES
+   for i in range(len(PARAMETRES)):
+      texte = texte +  erreur_de_type(0,PARAMETRES[i]) 
+   # test des sous_listes de REPONSES
+   for i in range(len(REPONSES)):
+      texte = texte + erreur_de_type(0,REPONSES[i])
+
+   # On verifie si la dimension de chaque sous-liste de : PARAMETRES, REPONSES
+   # il faut que: la dimension d'une sous-liste de PARAMETRES = 4
+   # et   que     la dimension d'une sous liste de REPONSES   = 3
+   texte = texte + erreur_dimension(PARAMETRES,REPONSES)
+
+   # on verifie que l'on a autant de réponses que de résultats expérimentaux
+   texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP)
+   #on verifie que l'on a autant de poids que de résultats expérimentaux
+   texte = texte + compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP)
+
+   # on verifie les types des arguments de chaque sous liste de PARAMETRES et REPONSES
+      # verification du type stringet type float des arguments de PARAMETRES
+   for i in range(len(PARAMETRES)):
+      texte = texte + erreur_de_type(1,PARAMETRES[i][0])
+      for k in [1,2,3]:
+         texte = texte + erreur_de_type(2,PARAMETRES[i][k])
+
+   # verification du type string pour les arguments  de REPONSES
+   for i in range(len(REPONSES)):
+      for j in range(len(REPONSES[i])):
+         texte = texte + erreur_de_type(1,REPONSES[i][j])
+   
+   # verification du fichier de commandes Esclave ASTER
+   if METHODE != 'EXTERNE': # pour celui-ci le fort.UL n'est pas l'esclave... voir comment faire
+      texte_fatal, texte_alarme = verif_fichier(UL,PARAMETRES,REPONSES)
+      texte += texte_fatal
+
+   # verification des valeurs des PARAMETRES entrées par l'utilisateur (pour fmin* les bornes ne sont pas prises en compte)
+   if METHODE == 'LEVENBERG':
+      texte = texte + verif_valeurs_des_PARAMETRES(PARAMETRES)
+
+   # verification des unités logiques renseignées par l'utilisateur
+   if METHODE != 'EXTERNE':
+      texte = texte + verif_UNITE(GRAPHIQUE,UNITE_RESU)
+
+   return texte, texte_alarme
+   

diff --git a/Aster/Cata/cataSTA10/Macro/reca_graphique.py b/Aster/Cata/cataSTA10/Macro/reca_graphique.py
new file mode 100644 (file)
index 0000000..c3ce8c8
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/reca_graphique.py
@@ -0,0 +1,92 @@
+#@ MODIF reca_graphique Macro  DATE 16/05/2007   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+
+import string, copy, Numeric, types
+import Cata
+from Cata.cata import DEFI_FICHIER, IMPR_FONCTION
+from Utilitai.Utmess import UTMESS
+from Accas import _F
+
+try:
+  import Gnuplot
+except:
+  pass
+
+
+#_____________________________________________
+#
+# IMPRESSIONS GRAPHIQUES
+#_____________________________________________
+
+def graphique(FORMAT, L_F, res_exp, reponses, iter, UL_out, interactif):
+
+   if FORMAT=='XMGRACE':
+       for i in range(len(L_F)):
+           _tmp = []
+           courbe1 = res_exp[i]
+           _tmp.append( { 'ABSCISSE': courbe1[:,0].tolist(), 'ORDONNEE': courbe1[:,1].tolist(), 'COULEUR': 1 } )
+           courbe2 = L_F[i]
+           _tmp.append( { 'ABSCISSE': courbe2[:,0].tolist(), 'ORDONNEE': courbe2[:,1].tolist(), 'COULEUR': 2 } )
+
+           motscle2= {'COURBE': _tmp }
+           if interactif: motscle2['PILOTE']= 'INTERACTIF'
+           else:          motscle2['PILOTE']= 'POSTSCRIPT'
+
+#           DEFI_FICHIER(UNITE=int(UL_out), ACCES='NEW',)
+
+           IMPR_FONCTION(FORMAT='XMGRACE',
+                         UNITE=int(UL_out),
+                         TITRE='Courbe de : ' + reponses[i][0],
+                         SOUS_TITRE='Iteration : ' + str(iter),
+                         LEGENDE_X=reponses[i][1],
+                         LEGENDE_Y=reponses[i][2],
+                         **motscle2
+                         );
+#           DEFI_FICHIER(ACTION='LIBERER',UNITE=int(UL_out),)
+
+   elif FORMAT=='GNUPLOT':
+       graphe=[]
+       impr=Gnuplot.Gnuplot()
+       Gnuplot.GnuplotOpts.prefer_inline_data=1
+       impr('set data style linespoints')
+       impr('set grid')
+       impr('set pointsize 2.')
+       impr('set terminal postscript color')
+       impr('set output "fort.'+str(UL_out)+'"')
+
+       for i in range(len(L_F)):
+             if interactif:
+                graphe.append(Gnuplot.Gnuplot(persist=0))
+                graphe[i]('set data style linespoints')
+                graphe[i]('set grid')
+                graphe[i]('set pointsize 2.')
+                graphe[i].xlabel(reponses[i][1])
+                graphe[i].ylabel(reponses[i][2])
+                graphe[i].title(reponses[i][0]+'  Iteration '+str(iter))
+                graphe[i].plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
+                graphe[i]('pause 5')
+
+             impr.xlabel(reponses[i][1])
+             impr.ylabel(reponses[i][2])
+             impr.title(reponses[i][0]+'  Iteration '+str(iter))
+             impr.plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
+
+   else:
+     pass

diff --git a/Aster/Cata/cataSTA10/Macro/reca_interp.py b/Aster/Cata/cataSTA10/Macro/reca_interp.py
new file mode 100644 (file)
index 0000000..5b14f4e
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/reca_interp.py
@@ -0,0 +1,313 @@
+#@ MODIF reca_interp Macro  DATE 21/09/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+import os, sys, pprint
+import Numeric
+from Utilitai.Utmess import UTMESS
+
+try: import Macro
+except: pass
+
+
+#===========================================================================================
+
+
+# INTERPOLATION, CALCUL DE SENSIBILITE, ETC....
+
+#--------------------------------------
+class Sim_exp :
+
+   def __init__ (self,result_exp,poids) :
+      self.resu_exp = result_exp
+      self.poids = poids
+
+# ------------------------------------------------------------------------------
+
+   def InterpolationLineaire (self, x0, points) :
+      """
+          Interpolation Lineaire de x0 sur la fonction discrétisée yi=points(xi) i=1,..,n
+      """
+      # x0     = Une abscisse        (1 colonne, 1 ligne)
+      # points = Tableau de n points (2 colonnes, n lignes)
+      # on suppose qu'il existe au moins 2 points, 
+      # et que les points sont classés selon les abscisses croissantes
+
+      n = len(points)
+      if ( x0 < points[0][0] ) or ( x0 > points[n-1][0] ) :
+        UTMESS('F','RECAL0_35', valk=(str(x0), str(points[0][0]), str(points[n-1][0])))
+
+      i = 1
+      while x0 > points[i][0]:
+         i = i+1
+
+      y0 = (x0-points[i-1][0]) * (points[i][1]-points[i-1][1]) / (points[i][0]-points[i-1][0]) + points[i-1][1]
+
+      return y0
+
+
+
+
+# ------------------------------------------------------------------------------
+
+   def DistVertAdimPointLigneBrisee (self, M, points) :
+      """
+          Distance verticale d'un point M à une ligne brisée composée de n points
+      """
+      # M      = Point               (2 colonnes, 1 ligne)
+      # points = Tableau de n points (2 colonnes, n lignes)
+      # on suppose qu'il existe au moins 2 points, 
+      # et que les points sont classés selon les abscisses croissantes
+      n = len(points)
+      if ( M[0] < points[0][0] ) or ( M[0] > points[n-1][0] ):
+        return 0.
+      i = 1
+      while M[0] > points[i][0]:
+         i = i+1
+      y_proj_vert = (M[0]-points[i-1][0]) * (points[i][1]-points[i-1][1]) / (points[i][0]-points[i-1][0]) + points[i-1][1]  
+      d = (M[1] - y_proj_vert)
+           # Attention: la distance n'est pas normalisée
+           # Attention: problème si points[0][0] = points[1][0] = M[0]
+           # Attention: problème si M[1] = 0
+      return d
+
+
+# ------------------------------------------------------------------------------
+
+   def _Interpole(self, F_calc,experience,poids) :   #ici on passe en argument "une" experience
+      """
+         La Fonction Interpole interpole une et une seule F_calc sur F_exp et renvoie l'erreur seulement
+      """
+
+      n = 0
+      resu_num = F_calc
+      n_exp = len(experience)    # nombre de points sur la courbe expérimentale num.i    
+      stockage = Numeric.ones(n_exp, Numeric.Float)     # matrice de stockage des erreurs en chaque point
+      for j in xrange(n_exp) :
+         d = self.DistVertAdimPointLigneBrisee(experience[j], resu_num)
+         try:
+            stockage[n] = d/experience[j][1]
+         except ZeroDivisionError:
+            stockage[n] = d
+
+         n = n + 1         # on totalise le nombre de points valables
+      err = Numeric.ones(n, Numeric.Float) 
+
+      for i in xrange(n) :
+          err[i] = poids*stockage[i]
+      return  err
+
+
+# ------------------------------------------------------------------------------
+
+   def multi_interpole(self, L_F, reponses):
+      """
+         Cette fonction appelle la fonction interpole et retourne les sous-fonctionnelles J et l'erreur.
+         On interpole toutes les reponses une à une en appelant la methode interpole.
+      """
+
+      L_erreur=[]
+      for i in range(len(reponses)):   
+         err = self._Interpole(L_F[i],self.resu_exp[i],self.poids[i])
+         L_erreur.append(err)
+
+#      print "L_erreur=", L_erreur
+
+      # On transforme L_erreur en tab num
+      dim=[]
+      J=[]
+      for i in range(len(L_erreur)):
+         dim.append(len(L_erreur[i]))
+      dim_totale = Numeric.sum(dim)
+      L_J = self.calcul_J(L_erreur)
+      a=0
+      erreur = Numeric.zeros((dim_totale),Numeric.Float)
+      for n in range(len(L_erreur)):
+         for i in range(dim[n]):
+            erreur[i+a] = L_erreur[n][i]
+         a = dim[n]
+      del(L_erreur) #on vide la liste puisqu'on n'en a plus besoin
+      return L_J,erreur
+
+
+# ------------------------------------------------------------------------------
+
+   def multi_interpole_sensib(self, L_F, reponses):    
+      """
+         Cette fonction retourne seulement l'erreur, elle est appelée dans la methode sensibilité.
+         On interpole toutes les reponses une à une en appelant la methode interpole.
+      """
+
+      L_erreur=[]
+      for i in range(len(reponses)):   
+         err = self._Interpole(L_F[i], self.resu_exp[i], self.poids[i])
+         L_erreur.append(err)
+      # On transforme L_erreur en tab num
+      return L_erreur
+       
+
+# ------------------------------------------------------------------------------
+
+   def calcul_J(self,L_erreur):
+      L_J = []
+      for i in range(len(L_erreur)):
+         total = 0
+         for j in range(len(L_erreur[i])):
+            total = total + L_erreur[i][j]**2
+         L_J.append(total)
+      return L_J
+
+
+# ------------------------------------------------------------------------------
+
+   def norme_J(self,L_J_init,L_J,unite_resu=None):
+      """
+         Cette fonction calcul une valeur normée de J
+      """
+      for i in range(len(L_J)):
+         try:
+            L_J[i] = L_J[i]/L_J_init[i]
+         except ZeroDivisionError:
+            if unite_resu:
+               fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+               fic.write(message)
+               fic.close()
+            UTMESS('F', "RECAL0_36", valr=L_J_init)
+            return
+
+      J = Numeric.sum(L_J)
+      J = J/len(L_J)
+      return J
+
+
+# ------------------------------------------------------------------------------
+
+#   def sensibilite(self,objet,UL,F,L_deriv_sensible,val,para,reponses,pas,unite_resu,LIST_SENSI=[],LIST_DERIV=[],INFO=1):
+
+   def sensibilite(self, CALCUL_ASTER, F, L_deriv_sensible, val, pas):
+
+      # CALCUL_ASTER est l'objet regroupant le calcul de F et des derivées, ainsi que les options
+      UL         = CALCUL_ASTER.UL
+      para       = CALCUL_ASTER.para
+      reponses   = CALCUL_ASTER.reponses
+      unite_resu = CALCUL_ASTER.UNITE_RESU
+      LIST_SENSI = CALCUL_ASTER.LIST_SENSI
+      LIST_DERIV = CALCUL_ASTER.LIST_DERIV
+      INFO       = CALCUL_ASTER.INFO
+
+
+
+      # Erreur de l'interpolation de F_interp : valeur de F interpolée sur les valeurs experimentales
+      F_interp = self.multi_interpole_sensib(F, reponses)  #F_interp est une liste contenant des tab num des reponses interpolés
+
+      # Creation de la liste des matrices de sensibilités
+      L_A=[]
+      for i in range(len(reponses)):     
+         L_A.append(Numeric.zeros((len(self.resu_exp[i]),len(val)),Numeric.Float) )
+
+      for k in range(len(val)): # pour une colone de A (dim = nb parametres)
+
+         # On utilise les differences finies pour calculer la sensibilité
+         # --------------------------------------------------------------
+         # Dans ce cas, un premier calcul_Aster pour val[k] a deja ete effectué, on effectue un autre calcul_Aster pour val[k]+h
+
+         if para[k] not in LIST_SENSI:
+
+             # Message
+             if INFO>=2: UTMESS('I','RECAL0_37',valk=para[k])
+
+             fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+             fic.write('\nCalcul de la sensibilité par differences finies pour : '+para[k])
+             fic.close() 
+
+             # Perturbation
+             h = val[k]*pas
+             val[k] = val[k] + h
+
+             # Calcul_Aster pour la valeur perturbée
+             F_perturbe, L_deriv = CALCUL_ASTER.calcul_Aster(val)
+
+             # Erreur de l'interpolation de F_perturb : valeur de F (perturbée) interpolée sur les valeurs experimentales
+             F_perturbe_interp =self.multi_interpole_sensib(F_perturbe, reponses)
+
+             # On replace les parametres a leurs valeurs initiales
+             val[k] = val[k] - h
+
+             # Calcul de L_A (matrice sensibilité des erreurs sur F interpolée)
+             for j in range(len(reponses)):
+                for i in range(len(self.resu_exp[j])):
+                   try:
+                      L_A[j][i,k] = -1*(F_interp[j][i] - F_perturbe_interp[j][i])/h
+                   except ZeroDivisionError:
+                      fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+                      fic.write('\n Probleme de division par zéro dans le calcul de la matrice de sensiblité')
+                      fic.write('\n Le parametre '+para[k]+'est nul ou plus petit que la précision machine')
+                      fic.close() 
+                      UTMESS('F','RECAL0_38',valk=para[k])
+                      return
+
+
+         # On utilise le calcul de SENSIBILITE
+         # --------------------------------------------------------------
+         # Dans ce cas, L_deriv_sensible a deja ete calculé pour le premier calcul pour val[k], aucun autre calcul_F n'est a lancer
+         else:
+             if INFO>=2: UTMESS('I','RECAL0_39',valk=para[k])
+
+             # Message
+             fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+             fic.write('\nCalcul de la sensibilité par la SENSIBILITE pour : '+para[k])
+             fic.close() 
+
+             L_deriv_sensible_interp = L_deriv_sensible
+
+             # Calcul de L_A (matrice sensibilité des erreurs sur F interpolée)
+             for j in range(len(reponses)):
+                for i in range(len(self.resu_exp[j])):
+
+                   # On interpole la fonction derivée aux points experimentaux
+                   val_derivee_interpolee = self.InterpolationLineaire( self.resu_exp[j][i][0], L_deriv_sensible_interp[ para[k] ][:][j] )
+
+                   # Application du poids de la reponse courante j
+                   val_derivee_interpolee = val_derivee_interpolee*self.poids[j]
+
+                   try:
+                     L_A[j][i,k] =  -1.* ( val_derivee_interpolee ) / self.resu_exp[j][i][1]
+                   except ZeroDivisionError:
+                     L_A[j][i,k] =  -1.* ( val_derivee_interpolee )
+
+         # fin
+         # --------------------------------------------------------------
+
+      # On construit la matrice de sensiblité sous forme d'un tab num
+      dim =[]
+      for i in range(len(L_A)):
+         dim.append(len(L_A[i]))
+      dim_totale = Numeric.sum(dim)
+      a=0
+      A = Numeric.zeros((dim_totale,len(val)),Numeric.Float)
+      for n in range(len(L_A)):
+         for k in range(len(val)):
+            for i in range(dim[n]):
+               A[i+a][k] = L_A[n][i,k]
+         a=dim[n]
+
+      del(L_A) # On ecrase tout ce qu'il y a dans L_A puisqu'on n'en a plus besoin   
+
+      return A

diff --git a/Aster/Cata/cataSTA10/Macro/reca_message.py b/Aster/Cata/cataSTA10/Macro/reca_message.py
new file mode 100644 (file)
index 0000000..49e05cc
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/reca_message.py
@@ -0,0 +1,168 @@
+#@ MODIF reca_message Macro  DATE 21/09/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+
+import os, Numeric
+
+#===========================================================================================
+
+
+# AFFICHAGE DES MESSAGES
+
+class Message :
+   """classe gérant l'affichage des messages concernant le déroulement de l'optmisation """
+   #Constructeur de la classe
+
+# ------------------------------------------------------------------------------
+
+   def __init__(self,para,val_init,resu_exp,ul_out):
+      self.nom_para = para
+      self.resu_exp = resu_exp
+      self.val_init = val_init
+      self.resu_exp = resu_exp
+      self.ul_out = ul_out
+
+# ------------------------------------------------------------------------------
+   def get_filename(self):
+      return os.getcwd()+'/fort.'+str(self.ul_out)
+   
+   
+   def initialise(self):
+      res=open(self.get_filename(), 'w')
+      res.close()
+
+      txt = ' <INFO>  MACR_RECAL\n\n'
+      self.ecrire(txt)
+
+# ------------------------------------------------------------------------------
+   
+   def ecrire(self,txt):
+      res=open(self.get_filename(), 'a')
+      res.write(txt+'\n')
+      res.flush()
+      res.close()
+
+
+# ------------------------------------------------------------------------------
+   
+   def affiche_valeurs(self,val):
+
+      txt = '\n=> Paramètres    = '
+      for i in range(len(val)):
+         txt += '\n         '+ self.nom_para[i]+' = '+str(val[i])
+      self.ecrire(txt)
+
+# ------------------------------------------------------------------------------
+   
+   def affiche_fonctionnelle(self,J):
+
+      txt = '\n=> Fonctionnelle = '+str(J)
+      self.ecrire(txt)
+
+# ------------------------------------------------------------------------------
+   
+   def affiche_result_iter(self,iter,J,val,residu,Act=[],):
+
+      txt  = '\n=======================================================\n'
+      txt += 'Iteration '+str(iter)+' :\n'
+      txt += '\n=> Fonctionnelle = '+str(J)
+      txt += '\n=> Résidu        = '+str(residu)
+
+      self.ecrire(txt)
+
+      txt = ''
+      self.affiche_valeurs(val)
+
+      if (len(Act)!=0):
+         if (len(Act)==1):
+            txt += '\n\n Le paramètre '
+         else:
+            txt += '\n\n Les paramètres '
+         for i in Act:
+            txt += self.nom_para[i]+' '
+         if (len(Act)==1):
+            txt += '\n est en butée sur un bord de leur domaine admissible.'
+         else:
+            txt += '\n sont en butée sur un bord de leur domaine admissible.'
+      txt += '\n=======================================================\n\n'
+      self.ecrire(txt)
+
+
+# ------------------------------------------------------------------------------
+
+   def affiche_etat_final_convergence(self,iter,max_iter,iter_fonc,max_iter_fonc,prec,residu,Act=[]):
+
+      txt = ''
+      if ((iter <= max_iter) or (residu <= prec) or (iter_fonc <= max_iter_fonc) ):
+        txt += '\n=======================================================\n'
+        txt += '                   CONVERGENCE ATTEINTE                '
+        if (len(Act)!=0):
+           txt += "\n\n         ATTENTION : L'OPTIMUM EST ATTEINT AVEC      "
+           txt += "\n           DES PARAMETRES EN BUTEE SUR LE BORD     "
+           txt += "\n               DU DOMAINE ADMISSIBLE                 "
+        txt += '\n=======================================================\n'
+      else:
+        txt += "\n=======================================================\n"
+        txt += '               CONVERGENCE  NON ATTEINTE              '
+        if (iter > max_iter):
+          txt += "\n  Le nombre maximal  d'itération ("+str(max_iter)+") a été dépassé"
+        if (iter_fonc > max_iter_fonc):
+          txt += "\n  Le nombre maximal  d'evaluation de la fonction ("+str(max_iter_fonc)+") a été dépassé"
+        txt += '\n=======================================================\n'
+      self.ecrire(txt)
+
+
+# ------------------------------------------------------------------------------
+
+   def affiche_calcul_etat_final(self,para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible):
+
+        txt  = '\n\nValeurs propres du Hessien:\n'
+        txt += str( valeurs_propres)
+        txt += '\n\nVecteurs propres associés:\n'
+        txt += str( vecteurs_propres)
+        txt += '\n\n              --------'
+        txt += '\n\nOn peut en déduire que :'
+        # Paramètres sensibles
+        if (len(sensible)!=0):
+           txt += '\n\nLes combinaisons suivantes de paramètres sont prépondérantes pour votre calcul :\n'
+           k=0
+           for i in sensible:
+              k=k+1
+              colonne=vecteurs_propres[:,i]
+              numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1))
+              txt += '\n   '+str(k)+') '
+              for j in numero:
+                 txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' '
+              txt += '\n      associée à la valeur propre %3.1E \n' %valeurs_propres[i]
+        # Paramètres insensibles
+        if (len(insensible)!=0):
+           txt += '\n\nLes combinaisons suivantes de paramètres sont insensibles pour votre calcul :\n'
+           k=0
+           for i in insensible:
+              k=k+1
+              colonne=vecteurs_propres[:,i]
+              numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1))
+              txt += '\n   '+str(k)+') '
+              for j in numero:
+                 txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' '
+              txt += '\n      associée à la valeur propre %3.1E \n' %valeurs_propres[i]
+      
+        self.ecrire(txt)
+

diff --git a/Aster/Cata/cataSTA10/Macro/reca_utilitaires.py b/Aster/Cata/cataSTA10/Macro/reca_utilitaires.py
new file mode 100644 (file)
index 0000000..c44e696
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/reca_utilitaires.py
@@ -0,0 +1,234 @@
+#@ MODIF reca_utilitaires Macro  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+#            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.        
+# ======================================================================
+
+import Numeric, LinearAlgebra, copy, os, string, types, sys, glob
+from Numeric import take
+
+try:    import Gnuplot
+except: pass
+
+try:
+   import aster
+   CPU_Exception = aster.ArretCPUError
+   from Cata.cata import INFO_EXEC_ASTER, DEFI_FICHIER, IMPR_FONCTION, DETRUIRE
+   from Accas import _F
+   from Utilitai.Utmess import UTMESS, MessageLog
+except:
+   CPU_Exception = StandardError
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+#_____________________________________________
+#
+# DIVERS UTILITAIRES POUR LA MACRO
+#_____________________________________________
+
+
+def transforme_list_Num(parametres,res_exp):
+   """
+      Transforme les données entrées par l'utilisateur en tableau Numeric
+   """
+
+   dim_para = len(parametres)  #donne le nb de parametres
+   val_para = Numeric.zeros(dim_para,Numeric.Float)
+   borne_inf = Numeric.zeros(dim_para,Numeric.Float)
+   borne_sup = Numeric.zeros(dim_para,Numeric.Float)
+   para = []
+   for i in range(dim_para):
+      para.append(parametres[i][0])
+      val_para[i] = parametres[i][1]
+      borne_inf[i] = parametres[i][2]
+      borne_sup[i] = parametres[i][3]
+   return para,val_para,borne_inf,borne_sup
+
+
+# ------------------------------------------------------------------------------
+
+def mes_concepts(list_concepts=[],base=None):
+   """
+      Fonction qui liste les concepts créés
+   """
+   for e in base.etapes:
+      if e.nom in ('INCLUDE','MACR_RECAL',) :
+        list_concepts=list(mes_concepts(list_concepts=list_concepts,base=e))
+      elif (e.sd != None) and (e.parent.nom=='INCLUDE') :
+        nom_concept=e.sd.get_name()
+        if not(nom_concept in list_concepts):
+          list_concepts.append( nom_concept )
+   return tuple(list_concepts)
+
+
+# ------------------------------------------------------------------------------
+
+def detr_concepts(self):
+   """
+      Fonction qui detruit les concepts créés
+   """
+   liste_concepts=mes_concepts(base=self.parent)
+   for e in liste_concepts:
+      nom = string.strip(e)
+      DETRUIRE( OBJET =self.g_context['_F'](CHAINE = nom), INFO=1, ALARME='NON')
+      if self.jdc.g_context.has_key(nom) : del self.jdc.g_context[nom]
+   del(liste_concepts)
+
+
+# ------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+#_____________________________________________
+#
+# CALCUL DU TEMPS CPU RESTANT
+#_____________________________________________
+
+
+#def temps_CPU(self,restant_old,temps_iter_old):
+def temps_CPU(restant_old,temps_iter_old):
+   """
+      Fonction controlant le temps CPU restant
+   """
+   CPU=INFO_EXEC_ASTER(LISTE_INFO = ("CPU_RESTANT",))
+   TEMPS=CPU['CPU_RESTANT',1]
+   DETRUIRE(CONCEPT=_F(NOM=CPU),INFO=1)
+   err=0
+   # Indique une execution interactive
+   if (TEMPS>1.E+9):
+     return 0.,0.,0
+   # Indique une execution en batch
+   else:
+      restant=TEMPS
+      # Initialisation
+      if (restant_old==0.):
+         temps_iter=-1.
+      else:
+         # Première mesure
+         if (temps_iter_old==-1.):
+            temps_iter=(restant_old-restant)
+         # Mesure courante
+         else:
+            temps_iter=(temps_iter_old + (restant_old-restant))/2.
+         if ((temps_iter>0.96*restant)or(restant<0.)):
+            err=1
+            msg = MessageLog.GetText('F', 'RECAL0_40')
+            raise CPU_Exception, msg
+
+   return restant,temps_iter,err
+
+
+
+
+#_____________________________________________
+#
+# IMPRESSIONS GRAPHIQUES
+#_____________________________________________
+
+
+def graphique(FORMAT, L_F, res_exp, reponses, iter, UL_out, pilote, fichier=None, INFO=0):
+
+  if iter: txt_iter = 'Iteration : ' + str(iter)
+  else:    txt_iter = ''
+
+  # Le try/except est la pour eviter de planter betement dans un trace de courbes (DISPLAY non defini, etc...)
+  try:
+     if FORMAT=='XMGRACE':
+         for i in range(len(L_F)):
+             _tmp = []
+             courbe1 = res_exp[i]
+             _tmp.append( { 'ABSCISSE': courbe1[:,0].tolist(), 'ORDONNEE': courbe1[:,1].tolist(), 'COULEUR': 1, 'LEGENDE' : 'Expérience'} )
+             courbe2 = L_F[i]
+             _tmp.append( { 'ABSCISSE': courbe2[:,0].tolist(), 'ORDONNEE': courbe2[:,1].tolist(), 'COULEUR': 2, 'LEGENDE' : 'Calcul'} )
+
+             motscle2= {'COURBE': _tmp }
+             motscle2['PILOTE']= pilote
+
+             IMPR_FONCTION(FORMAT='XMGRACE',
+                           UNITE=int(UL_out),
+                           TITRE='Courbe : ' + reponses[i][0],
+                           SOUS_TITRE=txt_iter,
+                           LEGENDE_X=reponses[i][1],
+                           LEGENDE_Y=reponses[i][2],
+                           **motscle2
+                           );
+             dic = {''           : '',
+                    'POSTSCRIPT' : '.ps',
+                    'EPS'        : '.eps',
+                    'MIF'        : '.mif',
+                    'SVG'        : '.svg',
+                    'PNM'        : '.pnm',
+                    'PNG'        : '.png',
+                    'JPEG'       : '.jpg',
+                    'PDF'        : '.pdf', 
+                    'INTERACTIF' : '.agr'
+                    }
+             ext = dic[pilote]
+             if ext!='':
+               os.system('mv ./fort.%s ./REPE_OUT/courbes_%s_iter_%s%s' % (str(UL_out), reponses[i][0], str(iter), ext ) )
+
+     elif FORMAT=='GNUPLOT':
+
+         if fichier:
+            if INFO>=2: UTMESS('I','RECAL0_41',valk=fichier )
+            # On efface les anciens graphes
+            liste = glob.glob(fichier + '*.ps')
+            for fic in liste:
+               try:    os.remove(fic)
+               except: pass
+
+         graphe=[]
+         impr=Gnuplot.Gnuplot()
+         Gnuplot.GnuplotOpts.prefer_inline_data=1
+         impr('set data style linespoints')
+         impr('set grid')
+         impr('set pointsize 1.')
+         impr('set terminal postscript color')
+         impr('set output "fort.'+str(UL_out)+'"')
+
+         for i in range(len(L_F)):
+               graphe.append(Gnuplot.Gnuplot(persist=0))
+               graphe[i]('set data style linespoints')
+               graphe[i]('set grid')
+               graphe[i]('set pointsize 1.')
+               graphe[i].xlabel(reponses[i][1])
+               graphe[i].ylabel(reponses[i][2])
+               graphe[i].title(reponses[i][0]+'  ' + txt_iter)
+               graphe[i].plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
+               if pilote=='INTERACTIF':
+                  graphe[i]('pause 5')
+               else:
+                  if fichier:
+                     if INFO>=2: UTMESS('I','RECAL0_41',valk=fichier + '_' + str(i) + '.ps' )
+                     graphe[i].hardcopy(fichier + '_' + str(i) + '.ps', enhanced=1, color=1)
+
+               impr.xlabel(reponses[i][1])
+               impr.ylabel(reponses[i][2])
+               impr.title(reponses[i][0]+'  Iteration '+str(iter))
+               impr.plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
+
+  except Exception, err:
+     UTMESS('A','RECAL0_42',valk=str(err) )
+

diff --git a/Aster/Cata/cataSTA10/Macro/recal.py b/Aster/Cata/cataSTA10/Macro/recal.py
new file mode 100644 (file)
index 0000000..d582a57
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/recal.py
@@ -0,0 +1,358 @@
+#@ MODIF recal Macro  DATE 06/07/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            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.        
+# ======================================================================
+
+
+
+
+import string, copy, Numeric, types
+import Cata
+from Cata.cata import INCLUDE, DETRUIRE
+
+
+#_____________________________________________
+#
+# DIVERS UTILITAIRES POUR LA MACRO
+#_____________________________________________
+
+
+# Transforme les données entrées par l'utilisateur en tableau Numeric
+def transforme_list_Num(parametres,res_exp):
+   dim_para = len(parametres)  #donne le nb de parametres
+   val_para = Numeric.zeros(dim_para,Numeric.Float)
+   borne_inf = Numeric.zeros(dim_para,Numeric.Float)
+   borne_sup = Numeric.zeros(dim_para,Numeric.Float)
+   para = []
+   for i in range(dim_para):
+      para.append(parametres[i][0])
+      val_para[i] = parametres[i][1]
+      borne_inf[i] = parametres[i][2]
+      borne_sup[i] = parametres[i][3]
+   return para,val_para,borne_inf,borne_sup
+
+def mes_concepts(list_concepts=[],base=None):
+  # Fonction qui liste les concepts créés
+   for e in base.etapes:
+      if e.nom in ('INCLUDE','MACR_RECAL',) :
+        list_concepts=list(mes_concepts(list_concepts=list_concepts,base=e))
+      elif (e.sd != None) and (e.parent.nom=='INCLUDE') :
+        nom_concept=e.sd.get_name()
+        if not(nom_concept in list_concepts):
+          list_concepts.append( nom_concept )
+   return tuple(list_concepts)
+
+
+def detr_concepts(self):
+     liste_concepts=mes_concepts(base=self.parent)
+     for e in liste_concepts:
+        nom = string.strip(e)
+        DETRUIRE( OBJET =self.g_context['_F'](CHAINE = nom),INFO=1)
+        if self.jdc.g_context.has_key(nom) : del self.jdc.g_context[nom]
+     del(liste_concepts)
+
+
+def calcul_F(self,UL,para,val,reponses):
+      fic = open('fort.'+str(UL),'r')
+      #On stocke le contenu de fort.UL dans la variable fichier qui est un string 
+      fichier=fic.read()
+      #On stocke le contenu initial de fort.UL dans la variable fichiersauv 
+      fichiersauv=copy.copy(fichier)
+      fic.close()
+
+      #Fichier_Resu est une liste ou l'on va stocker le fichier modifié
+      #idée générale :on délimite des 'blocs' dans fichier
+      #on modifie ou non ces blocs suivant les besoins 
+      #on ajoute ces blocs dans la liste Fichier_Resu
+      Fichier_Resu=[]                      
+      
+      try: 
+         #cherche l'indice de DEBUT()
+         index_deb=string.index(fichier,'DEBUT(')
+         while( fichier[index_deb]!='\n'):
+            index_deb=index_deb+1
+         #on restreind fichier en enlevant 'DEBUT();'
+         fichier = fichier[index_deb+1:]   
+      except :
+         #on va dans l'except si on a modifié le fichier au moins une fois
+         pass 
+         
+      try:
+         #cherche l'indice de FIN()
+         index_fin = string.index(fichier,'FIN(')
+         #on restreind fichier en enlevant 'FIN();'
+         fichier = fichier[:index_fin]   
+      except : pass
+      #--------------------------------------------------------------------------------
+      #on cherche à délimiter le bloc des parametres dans le fichier
+      #Tout d'abord on cherche les indices  d'apparition des paras dans le fichier 
+      #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise
+      #avec le meme ordre de son fichier de commande
+      index_para = Numeric.zeros(len(para))
+      for i in range(len(para)):
+         index_para[i] = string.index(fichier,para[i])
+      #On range les indices par ordre croissant afin de déterminer
+      #les indice_max et indice_min
+      index_para = Numeric.sort(index_para)
+      index_first_para = index_para[0]
+      index_last_para = index_para[len(index_para)-1]
+      
+      
+      #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation
+      bloc_inter ='\n'
+      for i in range(len(para)-1):
+         j = index_para[i]
+         k = index_para[i+1]
+         while(fichier[j]!= '\n'):
+            j=j+1
+         bloc_inter=bloc_inter + fichier[j:k] + '\n'
+         
+      #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para
+      i = index_last_para 
+      while(fichier[i] != '\n'):
+         i = i + 1
+      index_last_para  = i
+      #on délimite les blocs suivants:
+      pre_bloc = fichier[:index_first_para]       #fichier avant premier parametre
+      post_bloc = fichier[ index_last_para+ 1:]    #fichier après dernier parametre
+      
+      #on ajoute dans L tous ce qui est avant le premier paramètre 
+      Fichier_Resu.append(pre_bloc)
+      Fichier_Resu.append('\n')
+      #On ajoute la nouvelle valeur des parametres
+      dim_para=len(para)
+      for j in range(dim_para):
+         Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n')
+      #On ajoute à Fichier_Resu tous ce qui est entre les parametres
+      Fichier_Resu.append(bloc_inter)
+      
+      Fichier_Resu.append(post_bloc)
+      #--------------------------------------------------------------------------------
+      #on va ajouter la fonction d'extraction du numarray de la table par la méthode Array 
+      #et on stocke les réponses calculées dans la liste Lrep
+      #qui va etre retournée par la fonction calcul_F
+      self.g_context['Lrep'] = []
+      Fichier_Resu.append('Lrep=[]'+'\n')
+      for i in range(len(reponses)):
+         Fichier_Resu.append('t'+str(reponses[i][0])+'='+str(reponses[i][0])+'.EXTR_TABLE()'+'\n')
+         Fichier_Resu.append('_F_ = '+'t'+str(reponses[i][0])+'.Array('+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n')
+         Fichier_Resu.append('Lrep.append(_F_)'+'\n')
+      
+      #ouverture du fichier fort.3 et mise a jour de celui ci
+      x=open('fort.'+str(UL),'w')
+      x.writelines('from Accas import _F \nfrom Cata.cata import * \n')
+      x.writelines(Fichier_Resu)
+      x.close()
+      del(Fichier_Resu)
+      del(pre_bloc)
+      del(post_bloc)
+      del(fichier)
+      
+      INCLUDE(UNITE = UL)
+      detr_concepts(self)
+      # on remet le fichier dans son etat initial
+      x=open('fort.'+str(UL),'w')
+      x.writelines(fichiersauv)
+      x.close()
+      return self.g_context['Lrep']
+
+
+#_____________________________________________
+#
+# CONTROLE DES ENTREES UTILISATEUR
+#_____________________________________________
+
+def erreur_de_type(code_erreur,X):
+   #code_erreur ==0 --> X est une liste
+   #code erreur ==1 --> X est un char
+   #code erreur ==2 --> X est un float
+   #test est un boolean (test = 0 défaut et 1 si un test if est verifier
+   txt=""
+   if(code_erreur == 0 ):
+      if type(X) is not types.ListType:
+         txt="\nCette entrée: " +str(X)+" n'est pas une liste valide"
+   if(code_erreur == 1 ):
+      if type(X) is not types.StringType:
+         txt="\nCette entrée: " +str(X)+" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python"
+   if(code_erreur == 2 ):
+      if type(X) is not types.FloatType:
+         txt="\nCette entrée:  " +str(X)+" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python"
+   return txt
+   
+   
+def erreur_dimension(PARAMETRES,REPONSES):
+#On verifie que la dimension de chaque sous_liste de parametre est 4
+#et que la dimension de chaque sous_liste de REPONSES est 3
+   txt=""
+   for i in range(len(PARAMETRES)):
+      if (len(PARAMETRES[i]) != 4):
+         txt=txt + "\nLa sous-liste de la variable paramètre numéro " + str(i+1)+" n'est pas de longueur 4"
+   for i in range(len(REPONSES)):
+      if (len(REPONSES[i]) != 3):
+         txt=txt + "\nLa sous-liste de la variable réponse numéro " + str(i+1)+" n'est pas de longueur 3"
+   return txt
+
+
+def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP):
+   # X et Y sont deux arguments qui doivent avoir la meme dimension
+   # pour éviter l'arret du programme
+   txt=""
+   if( len(REPONSES) != len(RESU_EXP)):
+      txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux"
+   return txt
+
+def verif_RESU_EXP(RESU_EXP):
+   # RESU_EXP doit etre une liste de tableaux Numeric de taille Nx2
+   # pour éviter l'arret du programme
+   txt=""
+   for index,resu in enumerate(RESU_EXP):
+      if (isinstance(resu,Numeric.ArrayType)):
+         if (len(Numeric.shape(resu)) != 2):                                                                                                                                                                               
+            txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."                                             
+         else:
+            if (Numeric.shape(resu)[1] != 2):                                                                                                                                                                               
+               txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."                                             
+      else:
+         txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau Numeric."                                             
+   return txt
+
+def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
+   # POIDS et Y sont deux arguments qui doivent avoir la meme dimension
+   # pour éviter l'arret du programme
+   txt=""
+   if( len(POIDS) != len(RESU_EXP)):
+      txt="\nVous avez entré " +str(len(POIDS))+ " poids et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de poids que de résultats expérimentaux"
+   return txt
+
+
+def verif_fichier(UL,PARAMETRES,REPONSES):
+#On verifie les occurences des noms des PARAMETRES et REPONSES 
+#dans le fichier de commande ASTER
+   txt=""
+   fichier = open('fort.'+str(UL),'r')
+   fic=fichier.read()
+   for i in range(len(PARAMETRES)):
+      if((string.find(fic,PARAMETRES[i][0])==-1) or ((string.find(fic,PARAMETRES[i][0]+'=')==-1) and (string.find(fic,PARAMETRES[i][0]+' ')==-1))):
+         txt=txt + "\nLe paramètre "+PARAMETRES[i][0]+" que vous avez entré pour la phase d'optimisation n'a pas été trouvé dans votre fichier de commandes ASTER"
+   for i in range(len(REPONSES)):
+      if((string.find(fic,REPONSES[i][0])==-1) or ((string.find(fic,REPONSES[i][0]+'=')==-1) and (string.find(fic,REPONSES[i][0]+' ')==-1))):
+         txt=txt + "\nLa réponse  "+REPONSES[i][0]+" que vous avez entrée pour la phase d'optimisation n'a pas été trouvée dans votre fichier de commandes ASTER"
+   return txt
+
+
+def verif_valeurs_des_PARAMETRES(PARAMETRES):
+#On verifie que pour chaque PARAMETRES de l'optimisation
+# les valeurs entrées par l'utilisateur sont telles que :
+#              val_inf<val_sup
+#              val_init appartient à [borne_inf, borne_sup] 
+#              val_init!=0         
+#              borne_sup!=0         
+#              borne_inf!=0         
+   txt=""
+   #verification des bornes
+   for i in range(len(PARAMETRES)):
+      if( PARAMETRES[i][2] >PARAMETRES[i][3]):
+         txt=txt + "\nLa borne inférieure "+str(PARAMETRES[i][2])+" de  "+PARAMETRES[i][0]+ "est plus grande que sa borne supérieure"+str(PARAMETRES[i][3])
+   #verification de l'encadrement de val_init 
+   for i in range(len(PARAMETRES)):
+      if( (PARAMETRES[i][1] < PARAMETRES[i][2]) or (PARAMETRES[i][1] > PARAMETRES[i][3])):
+         txt=txt + "\nLa valeur initiale "+str(PARAMETRES[i][1])+" de "+PARAMETRES[i][0]+ " n'est pas dans l'intervalle [borne_inf,born_inf]=["+str(PARAMETRES[i][2])+" , "+str(PARAMETRES[i][3])+"]"
+   #verification que val_init !=0
+   for  i in range(len(PARAMETRES)):
+      if (PARAMETRES[i][1] == 0. ):
+         txt=txt + "\nProblème de valeurs initiales pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur initiale nulle mais un ordre de grandeur."
+   #verification que borne_sup !=0
+   for  i in range(len(PARAMETRES)):
+      if (PARAMETRES[i][3] == 0. ):
+         txt=txt + "\nProblème de borne supérieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
+   #verification que borne_inf !=0
+   for  i in range(len(PARAMETRES)):
+      if (PARAMETRES[i][2] == 0. ):
+         txt=txt + "\nProblème de borne inférieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
+   return txt
+
+
+def verif_UNITE(GRAPHIQUE,UNITE_RESU):
+   # On vérifie que les unités de résultat et 
+   # de graphique sont différentes
+   txt=""
+   GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+   if (GRAPHE_UL_OUT==UNITE_RESU):
+       txt=txt + "\nLes unités logiques des fichiers de résultats graphiques et de résultats d'optimisation sont les memes."
+   return txt
+
+
+
+def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU):
+   #Cette methode va utiliser les methodes de cette classe declarée ci_dessus
+   #test  est un boolean: test=0 -> pas d'erreur
+   #                      test=1 -> erreur détectée
+
+   texte=""
+   #On vérifie d'abord si PARAMETRES, REPONSES, RESU_EXP sont bien des listes au sens python
+   #test de PARAMETRES
+   texte = texte + erreur_de_type(0,PARAMETRES)
+   #test de REPONSES
+   texte = texte + erreur_de_type(0,REPONSES)
+   #test de RESU_EXP
+   texte = texte + erreur_de_type(0,RESU_EXP) 
+   
+   #On vérifie si chaque sous liste de PARAMETRES, REPONSES,  possède le type adéquat
+   #test des sous_listes de PARAMETRES
+   for i in range(len(PARAMETRES)):
+      texte = texte +  erreur_de_type(0,PARAMETRES[i]) 
+   #test des sous_listes de REPONSES
+   for i in range(len(REPONSES)):
+      texte = texte + erreur_de_type(0,REPONSES[i])
+ 
+   #On verifie si la dimension de chaque sous-liste de : PARAMETRES, REPONSES
+   #il faut que:la dimension d'une sous-liste de PARAMETRES = 4
+   #et   que    la dimension d'une sous liste de REPONSES   = 3
+   texte = texte + erreur_dimension(PARAMETRES,REPONSES)
+
+   #on verifie le type et la dimension des résultats expérimentaux
+   texte = texte + verif_RESU_EXP(RESU_EXP)
+   #on verifie que l'on a autant de réponses que de résultats expérimentaux
+   texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP)
+   #on verifie que l'on a autant de poids que de résultats expérimentaux
+   texte = texte + compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP)
+
+   #on verifie les types des arguments de chaque sous liste de PARAMETRES et REPONSES
+      #verification du type stringet type float des arguments de PARAMETRES
+   for i in range(len(PARAMETRES)):
+      texte = texte + erreur_de_type(1,PARAMETRES[i][0])
+      for k in [1,2,3]:
+         texte = texte + erreur_de_type(2,PARAMETRES[i][k])
+         
+   #verification du type string pour les arguments  de REPONSES
+   for i in range(len(REPONSES)):
+      for j in range(len(REPONSES[i])):
+         texte = texte + erreur_de_type(1,REPONSES[i][j])
+   
+   #verification du fichier de commndes ASTER
+   texte = texte + verif_fichier(UL,PARAMETRES,REPONSES)
+
+   #verifiaction des valeurs des PARAMETRES entrées par l'utilisteur 
+   texte = texte + verif_valeurs_des_PARAMETRES(PARAMETRES)
+
+   #verifiaction des unités logiques renseignées par l'utilisateur
+   texte = texte + verif_UNITE(GRAPHIQUE,UNITE_RESU)
+
+   return texte
+   
+

diff --git a/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py
new file mode 100644 (file)
index 0000000..ee3487b
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py
@@ -0,0 +1,501 @@
+#@ MODIF simu_point_mat_ops Macro  DATE 18/05/2009   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
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# 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 simu_point_mat_ops(self, COMP_INCR, MATER, INCREMENT, NEWTON,CONVERGENCE,RECH_LINEAIRE,SIGM_INIT,EPSI_INIT,VARI_INIT,
+          COMP_ELAS,SUIVI_DDL,ARCHIVAGE,SIGM_IMPOSE,EPSI_IMPOSE,MODELISATION, ANGLE, MASSIF,INFO, **args) :
+
+  """Simulation de la reponse d'un point materiel"""
+
+  ier = 0
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+  
+  import Numeric
+
+  # On importe les definitions des commandes a utiliser dans la macro
+  # Le nom de la variable doit etre obligatoirement le nom de la commande
+  DEFI_FONCTION   = self.get_cmd('DEFI_FONCTION')
+  LIRE_MAILLAGE   = self.get_cmd('LIRE_MAILLAGE')
+  AFFE_MATERIAU   = self.get_cmd('AFFE_MATERIAU')
+  AFFE_MODELE     = self.get_cmd('AFFE_MODELE')
+  AFFE_CHAR_MECA  = self.get_cmd('AFFE_CHAR_MECA')
+  AFFE_CARA_ELEM  = self.get_cmd('AFFE_CARA_ELEM')
+  STAT_NON_LINE   = self.get_cmd('STAT_NON_LINE')
+  POST_RELEVE_T   = self.get_cmd('POST_RELEVE_T')
+  CALC_TABLE      = self.get_cmd('CALC_TABLE')
+  CALC_ELEM       = self.get_cmd('CALC_ELEM')
+  CREA_CHAMP       = self.get_cmd('CREA_CHAMP')
+  MODI_REPERE       = self.get_cmd('MODI_REPERE')
+  MODI_MAILLAGE       = self.get_cmd('MODI_MAILLAGE')
+
+  from Accas import _F
+  from Utilitai.UniteAster import UniteAster
+
+
+# -- Tests de cohérence
+  __fonczero = DEFI_FONCTION(NOM_PARA = 'INST',
+  VALE     = ( 0,0, 10,0 ),PROL_DROITE='CONSTANT',PROL_GAUCHE='CONSTANT')
+  
+  EPS={}
+  SIG={}
+  
+  if MODELISATION=="3D":
+      nbsig=6
+      CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ']
+      CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ']
+  else:
+      nbsig=3
+      CMP_EPS=['EPXX','EPYY','EPXY']
+      CMP_SIG=['SIXX','SIYY','SIXY']
+      
+  if SIGM_IMPOSE:        
+     SIG=SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
+     for i in SIG.keys():
+         if SIG[i]==None : SIG[i]=__fonczero
+  else:
+     for i in range(nbsig):
+         SIG[CMP_SIG[i]]=__fonczero
+
+  if EPSI_IMPOSE:        
+     EPS=EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
+  else:
+     for i in range(nbsig):
+         EPS[CMP_EPS[i]]=None
+         
+  for index in range(nbsig):
+      iks=CMP_SIG[index]
+      ike=CMP_EPS[index]
+      if EPS[ike]!=None and SIG[iks] != __fonczero :
+         raise ' un seul parmi :' + str(iks) +' '+ str(ike)
+         
+#   print 'EPS=',EPS
+#   print 'SIG=',SIG
+# -- Definition du maillage
+  if MODELISATION=="3D":
+
+     texte_ma = """
+       COOR_3D                                            
+         P0  0.0   0.0   0.0       
+         P1  1.0   0.0   0.0      
+         P2  0.0   1.0   0.0      
+         P3  0.0   0.0   1.0      
+       FINSF
+       TRIA3
+         F1   P0 P3 P2
+         F2   P0 P1 P3
+         F3   P0 P2 P1
+         F4   P1 P2 P3    
+       FINSF
+       TETRA4
+         VOLUME = P0 P1 P2 P3
+       FINSF
+       GROUP_MA
+       TOUT  VOLUME
+       FINSF
+       GROUP_NO
+       TOUT  P1 P2 P0 P3
+       FINSF
+       FIN
+     """
+  
+  else :
+  
+     texte_ma = """
+       COOR_2D                                            
+         P0  0.0   0.0
+         P1  1.0   0.0
+         P2  0.0   1.0
+       FINSF
+       SEG2
+         S1   P2 P0
+         S2   P0 P1
+         S3   P1 P2
+       FINSF
+       TRIA3
+         VOLUME = P0 P1 P2
+       FINSF
+       GROUP_MA
+       TOUT  VOLUME
+       FINSF
+       GROUP_NO
+       TOUT  P1 P2 P0
+       FINSF
+       FIN
+     """
+  
+  fi_mail = open('simu.mail','w')
+  fi_mail.write(texte_ma)
+  fi_mail.close()
+  
+  UL = UniteAster()
+  umail = UL.Libre(action='ASSOCIER', nom='simu.mail' )
+  
+  __MA  =  LIRE_MAILLAGE(UNITE=umail)
+  UL.EtatInit()
+
+
+
+  if MODELISATION=="3D":
+     __MO = AFFE_MODELE(  MAILLAGE = __MA, 
+       AFFE=_F(MAILLE=('VOLUME','F1','F2','F3','F4'),PHENOMENE='MECANIQUE',MODELISATION='3D',))
+## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
+##         imposées.
+     if ANGLE != 0. :
+        __MA=MODI_MAILLAGE(reuse=__MA ,MAILLAGE = __MA ,ROTATION=_F(POIN_1=(0.,0. ),ANGL = ANGLE),)
+        c=Numeric.cos(ANGLE*Numeric.pi/180.)
+        s=Numeric.sin(ANGLE*Numeric.pi/180.)
+        __C_RIGIDE=AFFE_CHAR_MECA(MODELE=__MO, 
+              DDL_IMPO=_F(NOEUD='P0',DX=0,DY=0.,DZ=0.),
+              LIAISON_DDL = (
+        _F(NOEUD=('P1','P1','P2','P2'),DDL=('DX','DY','DX','DY'),COEF_MULT=(s,-c,c,s),COEF_IMPO=0),
+        _F(NOEUD=('P1','P3','P3'),DDL=('DZ','DX','DY'),COEF_MULT=(-1.0,c,s),COEF_IMPO=0),
+        _F(NOEUD=('P2','P3','P3'),DDL=('DZ','DX','DY'),COEF_MULT=(-1.0,-s,c),COEF_IMPO=0),),)
+     else :
+# -- Mouvement de corps rigide
+        __C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO,
+              DDL_IMPO = _F(NOEUD = 'P0',DX = 0,DY = 0,DZ = 0),
+              LIAISON_DDL = (
+        _F(NOEUD=('P2','P1'),DDL=('DX','DY'),COEF_MULT=(1,-1),COEF_IMPO=0),
+        _F(NOEUD=('P3','P1'),DDL=('DX','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0),
+        _F(NOEUD=('P3','P2'),DDL=('DY','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0),))
+  else:
+  # MODELISATION 2D
+     __MO=AFFE_MODELE(MAILLAGE=__MA, 
+          AFFE=_F(MAILLE=('VOLUME','S1','S2','S3'),PHENOMENE='MECANIQUE',MODELISATION=MODELISATION))
+## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations
+##         imposées.
+     if ANGLE != 0. :
+        __MA=MODI_MAILLAGE(reuse=__MA ,MAILLAGE=__MA,ROTATION=_F(POIN_1=(0.,0.),ANGL=ANGLE),)
+        c=Numeric.cos(ANGLE*Numeric.pi/180.)
+        s=Numeric.sin(ANGLE*Numeric.pi/180.)
+        __C_RIGIDE = AFFE_CHAR_MECA(MODELE = __MO, 
+              DDL_IMPO=_F(NOEUD='P0',DX=0,DY=0.),
+              LIAISON_DDL=(_F(NOEUD=('P1','P1','P2','P2'),DDL=('DX','DY','DX','DY'),
+                   COEF_MULT=(s,-c,c,s),COEF_IMPO=0),),)
+     else :
+        __C_RIGIDE = AFFE_CHAR_MECA(MODELE = __MO,
+            DDL_IMPO = _F(NOEUD = 'P0',DX = 0,DY = 0),
+            LIAISON_DDL = (_F(NOEUD=('P2','P1'),DDL=('DX','DY'),COEF_MULT=(1,-1),COEF_IMPO=0),))
+            
+# --MASSIF : orientation du materiau (monocristal, orthotropie)
+  if MASSIF:        
+      ANGMAS=MASSIF[0].cree_dict_valeurs(MASSIF[0].mc_liste)
+      print "ANGMAS",ANGMAS  
+      if ANGMAS["ANGL_REP"]==None :                                     
+         __CARA=AFFE_CARA_ELEM(MODELE=__MO,MASSIF=_F(MAILLE='VOLUME',ANGL_EULER=ANGMAS["ANGL_EULER"]),);
+      else :                                        
+         __CARA=AFFE_CARA_ELEM(MODELE=__MO,MASSIF=_F(MAILLE='VOLUME',ANGL_REP=ANGMAS["ANGL_REP"]),);
+         
+# -- Chargement en deformation
+
+  __E = [None]*nbsig
+
+  __E[0] = AFFE_CHAR_MECA(MODELE = __MO,
+    LIAISON_OBLIQUE = _F(NOEUD='P1', DX=1, ANGL_NAUT=ANGLE))
+     
+  __E[1] = AFFE_CHAR_MECA(MODELE = __MO,
+    LIAISON_OBLIQUE = _F(NOEUD='P2', DY=1, ANGL_NAUT=ANGLE))
+    
+  if MODELISATION=="3D": 
+     
+      __E[2] = AFFE_CHAR_MECA(MODELE = __MO,
+         LIAISON_OBLIQUE = _F(NOEUD='P3', DZ=1, ANGL_NAUT=ANGLE))
+    
+      __E[3] = AFFE_CHAR_MECA(MODELE = __MO,
+        LIAISON_OBLIQUE = _F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE))
+         
+      __E[4] = AFFE_CHAR_MECA(MODELE = __MO,
+        LIAISON_OBLIQUE = _F(NOEUD='P1', DZ=1, ANGL_NAUT=ANGLE))
+         
+      __E[5] = AFFE_CHAR_MECA(MODELE = __MO,
+        LIAISON_OBLIQUE = _F(NOEUD='P2', DZ=1, ANGL_NAUT=ANGLE))
+        
+  else:
+      c=Numeric.cos(ANGLE*Numeric.pi/180.)
+      s=Numeric.sin(ANGLE*Numeric.pi/180.)
+      __E[2] = AFFE_CHAR_MECA(MODELE = __MO,
+        LIAISON_OBLIQUE = _F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE),)
+
+# -- Chargement en contrainte
+
+  __S = [None]*nbsig
+  
+  if MODELISATION=="3D": 
+   
+      r33 = 3**-0.5
+      __S[0] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = (
+          _F(MAILLE='F1', FX=-1),
+          _F(MAILLE='F4', FX= r33),))
+         
+      __S[1] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = (
+          _F(MAILLE='F2', FY=-1),
+          _F(MAILLE='F4', FY= r33),))
+         
+      __S[2] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = (
+          _F(MAILLE='F3', FZ=-1),
+          _F(MAILLE='F4', FZ= r33),))
+         
+      __S[3] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = (
+          _F(MAILLE='F1', FY=-1),
+          _F(MAILLE='F2', FX=-1),
+          _F(MAILLE='F4', FX= r33, FY=r33),))
+         
+      __S[4] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = (
+          _F(MAILLE='F1', FZ=-1),
+          _F(MAILLE='F3', FX=-1),
+          _F(MAILLE='F4', FX= r33, FZ=r33),))
+         
+      __S[5] = AFFE_CHAR_MECA( MODELE = __MO, FORCE_FACE = (
+          _F(MAILLE='F2', FZ=-1),
+          _F(MAILLE='F3', FY=-1),
+          _F(MAILLE='F4', FY= r33, FZ=r33), ) )
+     
+  else:
+      r22 = 2**-0.5
+      __S[0] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = (
+          _F(MAILLE='S1', FX=-1),
+          _F(MAILLE='S3', FX= r22), ))
+         
+      __S[1] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = (
+          _F(MAILLE='S2', FY=-1),
+          _F(MAILLE='S3', FY= r22), ) )
+         
+      __S[2] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = (
+          _F(MAILLE='S1', FY=-1),
+          _F(MAILLE='S2', FX=-1),
+          _F(MAILLE='S3', FX= r22, FY=r22), ) )
+        
+# -- Construction de la charge
+
+  l_char = [  _F(CHARGE=__C_RIGIDE)  ]
+  
+  for i in xrange(nbsig) :
+    ike=CMP_EPS[i]
+    if EPS[ike]:
+       l_char.append(  _F(CHARGE=__E[i],FONC_MULT=EPS[ike])  )
+       
+  for i in xrange(nbsig) :
+    iks=CMP_SIG[i]
+    l_char.append(  _F(CHARGE=__S[i],FONC_MULT=SIG[iks])  )
+
+#  -- Materiau et modele
+  __CHMAT=AFFE_MATERIAU(MAILLAGE=__MA,AFFE = _F(MAILLE='VOLUME',MATER=MATER))
+
+# Etat initial
+  SIGINI={}
+  VARINI={}
+  LCSIG=[]
+  LVSIG=[]
+  init_dico={}
+  etatinit=0
+
+# --contraintes initiales
+  if SIGM_INIT:        
+      etatinit=1                                                     
+      SIGINI=SIGM_INIT[0].cree_dict_valeurs(SIGM_INIT[0].mc_liste)   
+      for i in SIGINI.keys():                                        
+          if SIGINI[i]!=None :                                       
+              LCSIG.append(i)                                        
+              LVSIG.append(SIGINI[i])                                
+
+      __SIG_INIT=CREA_CHAMP(MAILLAGE=__MA,OPERATION='AFFE',TYPE_CHAM='CART_SIEF_R',                             
+                AFFE=_F(TOUT='OUI', NOM_CMP=LCSIG, VALE=LVSIG,))                                
+      init_dico['SIGM']=__SIG_INIT                                   
+          
+# --variables internes initiales
+  if VARI_INIT:        
+      etatinit=1
+      lnomneu=[]
+      lnomvar=[]
+      VARINI=VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste)
+      nbvari=len(VARINI['VALE'])
+      for i in range(nbvari):
+          lnomneu.append('X'+str(i+1))
+          lnomvar.append('V'+str(i+1))
+
+      __NEUT=CREA_CHAMP(OPERATION='AFFE', TYPE_CHAM='CART_NEUT_R', MAILLAGE=__MA,
+        AFFE=_F( MAILLE ='VOLUME', NOM_CMP = lnomneu, VALE = VARINI['VALE']))
+        
+      __VAR_INIT=CREA_CHAMP(MODELE=__MO,OPERATION='ASSE',TYPE_CHAM='ELGA_VARI_R',
+                   ASSE=_F(TOUT='OUI',CHAM_GD=__NEUT,NOM_CMP=lnomneu,NOM_CMP_RESU=lnomvar))
+      init_dico['VARI']=__VAR_INIT
+          
+  # --deformations initiales
+  if EPSI_INIT:
+      etatinit=1
+      EPSINI={}
+      LCDEPL=[]
+      LNDEPL=[]
+      LVDEPL=[]
+      LIST_AFFE=[]
+      mon_dico={}
+      mon_dico["NOEUD"]='P0'
+      mon_dico["NOM_CMP"]=("DX","DY","DZ")
+      mon_dico["VALE"]=(0.,0.,0.)
+      LIST_AFFE.append(mon_dico)
+      
+      EPSINI=EPSI_INIT[0].cree_dict_valeurs(EPSI_INIT[0].mc_liste)
+      mon_dico={}
+      mon_dico["NOEUD"]='P1'
+      mon_dico["NOM_CMP"]='DX'
+      mon_dico["VALE"]=EPSINI['EPXX']
+      LIST_AFFE.append(mon_dico)
+      mon_dico={}
+      mon_dico["NOEUD"]='P2'
+      mon_dico["NOM_CMP"]='DY'
+      mon_dico["VALE"]=EPSINI['EPYY']
+      LIST_AFFE.append(mon_dico)
+      if MODELISATION=="3D": 
+          mon_dico={}
+          mon_dico["NOEUD"]='P3'
+          mon_dico["NOM_CMP"]='DZ'
+          mon_dico["VALE"]=EPSINI['EPZZ']
+          LIST_AFFE.append(mon_dico)
+          mon_dico={}
+          mon_dico["NOEUD"]='P1'
+          mon_dico["NOM_CMP"]='DY'
+          mon_dico["VALE"]=EPSINI['EPXY']
+          LIST_AFFE.append(mon_dico)
+          mon_dico={}
+          mon_dico["NOEUD"]='P2'
+          mon_dico["NOM_CMP"]='DX'
+          mon_dico["VALE"]=EPSINI['EPXY']
+          LIST_AFFE.append(mon_dico)
+          mon_dico={}
+          mon_dico["NOEUD"]='P1'
+          mon_dico["NOM_CMP"]='DZ'
+          mon_dico["VALE"]=EPSINI['EPXZ']
+          LIST_AFFE.append(mon_dico)
+          mon_dico={}
+          mon_dico["NOEUD"]='P3'
+          mon_dico["NOM_CMP"]='DX'
+          mon_dico["VALE"]=EPSINI['EPXZ']
+          LIST_AFFE.append(mon_dico)
+          mon_dico={}
+          mon_dico["NOEUD"]='P2'
+          mon_dico["NOM_CMP"]='DZ'
+          mon_dico["VALE"]=EPSINI['EPYZ']
+          LIST_AFFE.append(mon_dico)
+          mon_dico={}
+          mon_dico["NOEUD"]='P3'
+          mon_dico["NOM_CMP"]='DY'
+          mon_dico["VALE"]=EPSINI['EPYZ']
+          LIST_AFFE.append(mon_dico)
+      else:
+          mon_dico={}
+          mon_dico["NOEUD"]='P1',
+          mon_dico["NOM_CMP"]='DY'
+          mon_dico["VALE"]=EPSINI['EPXY']
+          LIST_AFFE.append(mon_dico)
+          mon_dico={}
+          mon_dico["NOEUD"]='P2'
+          mon_dico["NOM_CMP"]='DX'
+          mon_dico["VALE"]=EPSINI['EPXY']
+          LIST_AFFE.append(mon_dico)
+      __DEP_INI=CREA_CHAMP(MAILLAGE=__MA,OPERATION='AFFE',TYPE_CHAM='NOEU_DEPL_R',AFFE=LIST_AFFE)
+      init_dico['DEPL']=__DEP_INI
+      
+# -- Deroulement du calcul
+  motscles={} 
+  if   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   RECH_LINEAIRE   : 
+      motscles['RECH_LINEAIRE']      = RECH_LINEAIRE.List_F()
+  motscles['INCREMENT']   = INCREMENT.List_F()
+  
+  if   SUIVI_DDL   : 
+     motscles['SUIVI_DDL']   = SUIVI_DDL.List_F()
+     
+  if   ARCHIVAGE   : 
+     motscles['ARCHIVAGE']   = ARCHIVAGE.List_F()
+
+  if   etatinit == 1  : 
+
+     if MASSIF:        
+      __EVOL1 = STAT_NON_LINE(INFO = INFO,CARA_ELEM=__CARA,MODELE = __MO,CHAM_MATER = __CHMAT,
+        ETAT_INIT=init_dico, EXCIT = l_char,**motscles)
+     else:
+      __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO,CHAM_MATER = __CHMAT,
+        ETAT_INIT=init_dico, EXCIT = l_char,**motscles)
+
+  else:  
+
+     if MASSIF:        
+         __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO, CARA_ELEM=__CARA,CHAM_MATER = __CHMAT,
+                             EXCIT = l_char,**motscles)
+     else:
+         __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO, CHAM_MATER = __CHMAT,
+                             EXCIT = l_char,**motscles)
+
+
+  __EVOL1 = CALC_ELEM(reuse = __EVOL1,RESULTAT = __EVOL1,
+    OPTION = ('SIEF_ELNO_ELGA','EPSI_ELNO_DEPL','VARI_ELNO_ELGA'))
+    
+  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',),
+                              ),
+                 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',),
+                              ),
+                 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',
+        TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD='P0'),))
+
+    
+  __REP_EPSI = POST_RELEVE_T(ACTION = (
+      _F(INTITULE='EPSILON',RESULTAT=__EVOL,NOM_CHAM='EPSI_ELNO_DEPL',
+        TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD     = 'P0'),))
+
+  __REP_SIGM = POST_RELEVE_T(ACTION = (
+      _F(INTITULE  = 'SIGMA',RESULTAT  =  __EVOL,NOM_CHAM  = 'SIEF_ELNO_ELGA',
+        TOUT_CMP  = 'OUI',OPERATION = 'EXTRACTION',NOEUD     = 'P0'),))
+    
+  __REP_INV = POST_RELEVE_T(ACTION = (
+      _F(INTITULE  = 'INV',RESULTAT  =  __EVOL,NOM_CHAM  = 'SIEF_ELNO_ELGA',
+        INVARIANT  = 'OUI',OPERATION = 'EXTRACTION',NOEUD     = 'P0'),))
+        
+  __REP_INV=CALC_TABLE( TABLE=__REP_INV,reuse=__REP_INV,
+           ACTION=_F(OPERATION='EXTR',NOM_PARA=('INST','TRACE','VMIS'), ) )
+
+  self.DeclareOut('REPONSE',self.sd)
+  
+  REPONSE=CALC_TABLE( TABLE=__REP_EPSI,TITRE='TABLE ',ACTION=(
+                   _F(OPERATION='COMB',TABLE=__REP_SIGM,NOM_PARA=('INST'), ),
+                   _F(OPERATION='COMB',TABLE=__REP_INV ,NOM_PARA=('INST'), ),
+                   _F(OPERATION='COMB',TABLE=__REP_VARI,NOM_PARA=('INST'), ),))
+
+  return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/stanley_ops.py b/Aster/Cata/cataSTA10/Macro/stanley_ops.py
new file mode 100644 (file)
index 0000000..e8c0eab
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/stanley_ops.py
@@ -0,0 +1,79 @@
+#@ MODIF stanley_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE 
+# -*- 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.
+# ======================================================================
+
+
+
+def stanley_ops(self,RESULTAT,MODELE,CHAM_MATER,CARA_ELEM,DISPLAY,**args):
+
+  """
+     Importation et lancement de Stanley
+  """
+
+  import os,string
+  import aster
+  from Accas import _F
+  from Noyau.N_utils import AsType
+  from Utilitai.Utmess import  UTMESS
+  from Utilitai.UniteAster import UniteAster
+
+  prev_onFatalError = aster.onFatalError()
+  aster.onFatalError('EXCEPTION')
+
+  ier=0
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Redefinition eventuelle du DISPLAY
+  if DISPLAY:
+    UTMESS('I','STANLEY_1',valk=DISPLAY)
+    os.environ['DISPLAY'] = DISPLAY
+
+  # Mode validation de la non-regression
+  if args['UNITE_VALIDATION']:
+     UTMESS('I','STANLEY_2')
+     UL = UniteAster()
+     FICHIER_VALID=UL.Nom(args['UNITE_VALIDATION'])
+  else:
+     FICHIER_VALID=None
+
+  # On ne lance Stanley que si la variable DISPLAY est définie
+  if os.environ.has_key('DISPLAY'):
+
+    import Stanley
+    from Stanley import stanley
+
+    if (RESULTAT and MODELE and CHAM_MATER):
+      _MAIL = aster.getvectjev( string.ljust(MODELE.nom,8) + '.MODELE    .LGRF        ' )
+      _MAIL = string.strip(_MAIL[0])
+      MAILLAGE = self.jdc.g_context[_MAIL]
+      if CARA_ELEM:
+        stanley.STANLEY(RESULTAT,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM)
+      else:
+        stanley.STANLEY(RESULTAT,MAILLAGE,MODELE,CHAM_MATER,None)
+    else:
+      stanley.PRE_STANLEY(FICHIER_VALID)
+
+  else:
+      UTMESS('A','STANLEY_3',valk=['STANLEY'])
+
+  aster.onFatalError(prev_onFatalError)
+
+  return ier

diff --git a/Aster/Cata/cataSTA10/Macro/test_fichier_ops.py b/Aster/Cata/cataSTA10/Macro/test_fichier_ops.py
new file mode 100644 (file)
index 0000000..5ae34da
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/test_fichier_ops.py
@@ -0,0 +1,324 @@
+#@ MODIF test_fichier_ops Macro  DATE 10/11/2009   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.        
+# ======================================================================
+
+import sys
+import os
+import re
+
+# hashlib only exists in python>=2.5
+def hash_new():
+   try:
+      import hashlib
+      _hash_new = hashlib.md5()
+      print 'hashlib'
+   except ImportError:
+      import md5
+      _hash_new = md5.new()
+      print 'md5'
+   return _hash_new
+
+
+class TestFichierError(Exception):
+   pass
+
+
+def convert(x):
+   return float(x)
+
+def f_SOMM(somme, lx):
+   return somme + sum([convert(x) for x in lx])
+
+def f_SOMM_ABS(somme, lx):
+   return somme + sum([abs(convert(x)) for x in lx])
+
+def f_MINI(val, lx):
+   return min(val, min([convert(x) for x in lx]))
+
+def f_MAXI(val, lx):
+   return max(val, max([convert(x) for x in lx]))
+
+def f_MINI_ABS(val, lx):
+   return min(val, min([abs(convert(x)) for x in lx]))
+
+def f_MAXI_ABS(val, lx):
+   return max(val, max([abs(convert(x)) for x in lx]))
+
+dict_func_test = {
+   'SOMM'     : f_SOMM,
+   'SOMM_ABS' : f_SOMM_ABS,
+   'MINI'     : f_MINI,
+   'MAXI'     : f_MAXI,
+   'MINI_ABS' : f_MINI_ABS,
+   'MAXI_ABS' : f_MAXI_ABS,
+}
+
+#-------------------------------------------------------------------------------
+def test_fichier_ops(self, FICHIER, NB_VALE, VALE, VALE_K, TYPE_TEST,
+                           CRITERE, PRECISION, INFO, **kwargs):
+   """
+     Macro permettant de tester la non-regression d'un fichier.
+     On teste le nombre de réels présents, et, facultativement, la
+     somme de ces nombres et le texte du fichier.
+   """
+   ier = 0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER')
+   DETRUIRE        = self.get_cmd('DETRUIRE')
+   CREA_TABLE      = self.get_cmd('CREA_TABLE')
+   TEST_TABLE      = self.get_cmd('TEST_TABLE')
+   
+   import aster
+   from Accas import _F
+   from Utilitai.Utmess import  UTMESS
+
+   is_ok = 0
+
+   # vérifier que le fichier a été fermé
+   tinfo__ = INFO_EXEC_ASTER(LISTE_INFO='ETAT_UNITE', FICHIER=FICHIER)
+   if tinfo__['ETAT_UNITE', 1].find('OUVERT') > -1:
+      UTMESS('S','TEST0_2',valk=FICHIER)
+
+   # lecture du fichier
+   if not os.path.isfile(FICHIER):
+      UTMESS('S', 'TEST0_3', valk=FICHIER)
+   fileobj = open(FICHIER, 'r')
+
+   # filtre par expression régulière
+   try:
+      fileobj = regexp_filter(fileobj, kwargs['EXPR_IGNORE'])
+   except TestFichierError, valk:
+      UTMESS('S', 'TEST0_1', valk=valk)
+
+   # calcule le nombre de réels et la somme ou min/max
+   nbval, valeur, chksum = test_iter(fileobj, function=dict_func_test[TYPE_TEST], verbose=(INFO > 1))
+   fileobj.close()
+
+   # produit le TEST_TABLE
+   refsum = VALE_K or 'non testé'
+   is_ok = int(chksum == refsum)
+   tab1__ = CREA_TABLE(LISTE=(_F(PARA='NBVAL',  LISTE_I=nbval,),
+                              _F(PARA='VALEUR', LISTE_R=valeur,),
+                              _F(PARA='TEXTE',  LISTE_I=is_ok),),)
+   if VALE is not None:
+      sVALE = '%20.13e' % VALE
+   else:
+      sVALE = 'non testé'
+   UTMESS('I', 'TEST0_4', vali=(nbval, NB_VALE), valr=valeur, valk=(chksum, refsum, FICHIER, sVALE))
+   
+   kwopt = { 'REFERENCE' : kwargs['REFERENCE'], }
+   if kwargs['REFERENCE'] == 'NON_REGRESSION':
+      kwopt['VERSION'] = kwargs['VERSION']
+   
+   TEST_TABLE(TABLE=tab1__,
+              NOM_PARA='NBVAL',
+              VALE_I=NB_VALE,
+              CRITERE='ABSOLU',
+              PRECISION=0,
+              **kwopt)
+
+   if VALE:
+      TEST_TABLE(TABLE=tab1__,
+                 NOM_PARA='VALEUR',
+                 VALE=VALE,
+                 CRITERE=CRITERE,
+                 PRECISION=PRECISION,
+                 **kwopt)
+
+   if VALE_K:
+      TEST_TABLE(TABLE=tab1__,
+                 NOM_PARA='TEXTE',
+                 VALE_I=int(True),
+                 PRECISION=0,
+                 CRITERE='ABSOLU',
+                 **kwopt)
+
+   DETRUIRE(CONCEPT=_F(NOM=(tinfo__, tab1__),),
+            ALARME='NON',INFO=1,)
+   return ier
+
+#-------------------------------------------------------------------------------
+def regexp_filter(file_in, regexp_ignore, debug=False):
+   """Filtre le fichier fourni (file descriptor) en utilisant les
+   expressions régulières fournies.
+   On retourne l'objet file vers le fichier modifié (ou non).
+   """
+   if not regexp_ignore:      # None or []
+      return file_in
+   # vérification des expressions régulières
+   if type(regexp_ignore) not in (list, tuple):
+      regexp_ignore = [regexp_ignore,]
+   l_regexp = []
+   for exp in regexp_ignore:
+      try:
+         obj = re.compile(exp)
+      except re.error, s:
+         raise TestFichierError, (s, str(exp))
+      else:
+         l_regexp.append(obj)
+   # filtre du fichier
+   file_out = os.tmpfile()
+   file_in.seek(0)
+   for i, line in enumerate(file_in):
+      if debug:
+         print 'LIGNE', i,
+      keep = True
+      for exp in l_regexp:
+         if exp.search(line):
+            keep = False
+            if debug:
+               print ' >>>>>>>>>> IGNOREE <<<<<<<<<<'
+            break
+      if keep:
+         file_out.write(line)
+         if debug:
+            print
+   file_out.seek(0)
+   return file_out
+
+
+#-------------------------------------------------------------------------------
+re_float_expo = re.compile('[-+]?[0-9\.]+[eED][\-\+]{0,1}[0-9]+')
+re_float      = re.compile('[-+]?[0-9]+?\.[0-9]*')
+re_int        = re.compile('[0-9]+')
+
+re_fortran    = re.compile('([0-9]+)[dD]([\-\+]{0,1}[0-9]+)')
+
+#-------------------------------------------------------------------------------
+def test_iter(obj, function, verbose=False):
+   """
+   Cette fonction compte le nombre de réels dans le fichier et une grandeur
+   à partir des valeurs (somme, sommes des valeurs absolues, min/max...).
+   IN :
+      obj      : objet 'file' ou 'string' sur le lequel on peut itérer
+      function : fonction de test   val = func_test(val, [xi, ...])
+      verbose  : on affiche le résumé si info>0
+   OUT :
+      nombre de valeurs, valeur résultat
+   """
+   max_buff_size = 1000
+   nbval = 0
+   val = 0.
+   hfile = hash_new()
+   
+   # Si on lit tout le fichier d'un coup, on va environ 3 fois plus vite
+   # que si on le lit ligne à ligne, mais on consomme en mémoire environ
+   # 5 fois la taille du fichier...
+   # En lisant par paquet de 1000 (ou 10000), on va quasiment aussi vite
+   # en consommant très peu de mémoire.
+   
+   #    fichier     tout   ligne/ligne   1000 lignes
+   #     10 Mo       3 s      10 s       3 s
+   #     50 Mo      17 s      48 s      17 s
+   #    100 Mo      34 s      96 s      35 s
+   
+   # l'itérateur est l'objet file lui-même ou on le crée sur la liste
+   if type(obj) is file:
+      obj.seek(0)
+      iterator = obj
+   else:
+      iterator = iter(obj)
+   
+   ok = True
+   buff = []
+   while ok:
+      try:
+         text = iterator.next()
+      except StopIteration:
+         ok = False
+         text = ''
+      buff.append(text)
+      if ok and len(buff) < max_buff_size:
+         continue
+      else:
+         text = ''.join(buff)
+         buff = []
+
+      l_float = re_float_expo.findall(text)
+      l_float = [s.replace('D', 'E') for s in l_float]
+      text =    re_float_expo.sub('', text)
+      l_float.extend(re_float.findall(text))
+      text =         re_float.sub('', text)
+      l_float.extend(  re_int.findall(text))
+      text =           re_int.sub('', text)
+      
+      nbval += len(l_float)
+      val    = function(val, l_float)
+
+      text = ''.join([s.strip() for s in text.split()])
+      hfile.update(text)
+      
+      if verbose:
+         print 'Nombres réels et entiers :'
+         print l_float
+         print 'Texte :'
+         print text
+   
+   chksum = hfile.hexdigest()
+   
+   return nbval, val, chksum
+
+#-------------------------------------------------------------------------------
+def test_file(filename, regexp_ignore=[], type_test='SOMM', verbose=False):
+   """Raccourci pour tester rapidement un fichier (utilisé par stanley.py).
+   """
+   if type(regexp_ignore) not in (list, tuple):
+      regexp_ignore = [regexp_ignore,]
+
+   fileobj = open(filename, 'r')
+   fileobj = regexp_filter(fileobj, regexp_ignore)
+
+   nbv, val, chksum = test_iter(fileobj, function=dict_func_test[type_test], verbose=verbose)
+
+   return nbv, val, chksum
+
+#-------------------------------------------------------------------------------
+if __name__ == '__main__':
+   from optparse import OptionParser, OptionGroup
+
+   p = OptionParser(usage='usage: %s fichier [options]' % sys.argv[0])
+   p.add_option('--type_test',
+      action='store', dest='type_test', default='SOMM',
+      help='type du test : SOMM, SOMM_ABS, MIN, MAX')
+   p.add_option('--expr_ignore',
+      action='store', dest='exp', type='string',
+      help='expression régulière à ignorer')
+   p.add_option('-v', '--verbose',
+      action='store_true', dest='verbose', default=False,
+      help='mode bavard')
+   opts, args = p.parse_args()
+
+   if len(args) == 0:
+      p.error('fichier à tester ?')
+
+   if opts.exp is None:
+      exp = []
+   else:
+      exp = [opts.exp]
+
+   fileobj = open(args[0], 'r')
+   fileobj = regexp_filter(fileobj, exp)
+   nbv2, sumv2, chksum2 = test_iter(fileobj, function=dict_func_test[opts.type_test], verbose=opts.verbose)
+   print '%6d valeurs, resultat = %f, texte : %s' % (nbv2, sumv2, chksum2)
+
+

diff --git a/Aster/Cata/cataSTA10/Macro/test_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/test_fonction_ops.py
new file mode 100644 (file)
index 0000000..d1aed4f
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/test_fonction_ops.py
@@ -0,0 +1,724 @@
+#@ MODIF test_fonction_ops Macro  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.        
+# ======================================================================
+# RESPONSABLE SELLENET N.SELLENET
+
+import os
+
+epsi = 1e-15
+
+# Format
+ligne_separatrice = 80*'-'
+ligne_nappe = """ ---- NAPPE: %(nom_nappe)s, NOM_PARA: %(nom_para)s, PARA: %(vale_para)16.14f """
+ligne_fct   = """ ---- FONCTION: %(nom_fct)s %(titre)s """
+ligne_ref   = """REFERENCE: %(typ_ref)s %(version)s """
+ligne_res1  = """%(testOk)s %(nomPara)s %(critere)s %(erreur)9.3f %(pourcent)s VALE:%(valeur)20.13E"""
+ligne_res2  = """      %(para)7.5E TOLE %(epsilon)9.3f %(pourcent)s REFE:%(refere)20.13E"""
+
+ligne_res1C = """%(testOk)s %(nomPara)s %(critere)s %(erreur)9.3f %(pourcent)s VALE:%(valR)20.13E %(valI)20.13E"""
+ligne_res2C  = """      %(para)7.5E TOLE %(epsilon)9.3f %(pourcent)s REFE:%(refR)20.13E %(refI)20.13E"""
+
+ligne_res_attr  = """%(testOk)s %(nomPara)s VALE:%(valPara)s"""
+ligne_res_att2  = """                                 REFE:%(valeRefe)s"""
+
+ligne_intspc   = """ ---- INTERSPECTRE: %(nom_intspc)s"""
+
+def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne):
+   """
+      Teste de la valeur calculee par rapport a la valeur de reference
+   """
+   import aster, cmath, math
+   
+   isTestOk = 0
+   vtc = valRef[0]
+   if type(vtc) in (list, tuple):
+      assert( (vtc[0]=='RI')|(vtc[0]=='MP' ) )
+      if vtc[0]=='RI':
+         vtc = vtc[1]+1j*vtc[2]
+      else:
+         vtc = vtc[1]*cmath.exp(1j*math.pi*vtc[2]/180)
+   if sSigne == 'OUI':
+      res = abs(res)
+      if type(valRef[0]) == complex:
+         vtc = abs(vtc)
+   
+   # Recherche de la valeur la plus proche de la valeur calculee
+   # dans le tableau valRef
+   minTmp = abs(res - vtc)
+   curI = 0
+   for i in range(len(valRef)):
+      vtc = valRef[i]
+      if type(vtc) in (list, tuple):
+         assert( (vtc[0]=='RI')|(vtc[0]=='MP' ) )
+         if vtc[0]=='RI':
+            vtc = vtc[1]+1j*vtc[2]
+         else:
+            vtc = vtc[1]*cmath.exp(1j*math.pi*vtc[2]/180)
+      if sSigne == 'OUI' and type(vtc) == complex:
+         vtc = abs(vtc)
+      valTmp = abs(res-vtc)
+      if valTmp < minTmp:
+         valTmp = minTmp
+         curI = i
+   
+   vtc = valRef[curI]
+   if type(vtc) in (list, tuple):
+      assert( (vtc[0]=='RI')|(vtc[0]=='MP' ) )
+      if vtc[0]=='RI':
+         vtc = vtc[1]+1j*vtc[2]
+      else:
+         vtc = vtc[1]*cmath.exp(1j*math.pi*vtc[2]/180)
+   if sSigne == 'OUI' and type(vtc) == complex:
+      vtc = abs(vtc)
+
+   testOk = 'NOOK'
+   curEps = 0
+   err = 0
+   pourcent = ' '
+   # Calcul de l'erreur commise
+   if crit[0:4] == 'RELA':
+      isTestOk = ( abs(res-vtc) <= epsi*abs(vtc) )
+      if vtc != 0:
+         if type(res) == complex or type(vtc) == complex:
+            err = abs(res - vtc)/abs(vtc)*100
+         else:
+            err = (res - vtc)/vtc*100
+      else:
+         err = 999.999999
+      if isTestOk: testOk = ' OK '
+      curEps = epsi*100
+      pourcent = '%'
+   else:
+      isTestOk = ( abs(res-vtc) <= epsi )
+      if type(res) == complex or type(vtc) == complex:
+         err = abs(res - vtc)
+      else:
+         err = res - vtc
+      if isTestOk: testOk = ' OK '
+      curEps = epsi
+   
+   return {'testOk' : testOk, 'erreur' : err, 'epsilon' : curEps, 'valeurRef' :vtc}
+
+def AfficherResultat(dicoValeur, nomPara, crit, res, valPu, txt):
+   """
+      Gestion de l'affichage par ajout de texte au tableau txt
+      passe en parametre
+   """
+   testOk = dicoValeur['testOk']
+   err = dicoValeur['erreur']
+   curEps = dicoValeur['epsilon']
+   vtc = dicoValeur['valeurRef']
+   
+   pourcent = ' '
+   if crit[0:4] == 'RELA':
+      pourcent = '%'
+   
+   # Ajout du texte en fonction du resultat
+   espace = (12 - len(nomPara))*' '
+   current = { 'testOk'  : testOk,
+               'nomPara' : nomPara+espace,
+               'critere' : crit[0:4],
+               'erreur'  : err,
+               'pourcent': pourcent}
+   if type(res) != complex:
+      current['valeur'] = res
+      txt.append(ligne_res1 % current)
+   else:
+      current['valR'] = res.real
+      current['valI'] = res.imag
+      txt.append(ligne_res1C % current)
+   
+   current = { 'para'    : valPu,
+               'epsilon' : curEps,
+               'pourcent': pourcent}
+   if type(vtc) != complex:
+      current['refere'] = vtc
+      txt.append(ligne_res2 % current)
+   else:
+      current['refR'] = vtc.real
+      current['refI'] = vtc.imag
+      txt.append(ligne_res2C % current)
+
+# -----------------------------------------------------------------------------
+def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args):
+   """
+      Corps de la macro TEST_FONCTION
+   """
+   macro='TEST_FONCTION'
+   import aster
+   from Accas import _F
+   from Utilitai.Utmess import UTMESS
+   from Noyau.N_FONCTION import formule, formule_c
+   from SD.co_fonction import fonction_sdaster, fonction_c, nappe_sdaster
+   from SD.sd_fonction import sd_fonction
+   from Cata_Utils.t_fonction import t_fonction_c
+   
+   CALC_FONCTION = self.get_cmd('CALC_FONCTION')
+   DETRUIRE = self.get_cmd('DETRUIRE')
+   
+   ier=0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+   
+   if ( TEST_NOOK=='OUI' ) & ( TABL_INTSP != None ):
+      UTMESS('F','PREPOST3_92')
+   
+   # txt sert a l'affichage dans le fichier RESULTAT
+   txt = ['',]
+   txt.append(ligne_separatrice)
+
+   if VALEUR != None:
+      # Boucle sur les VALEURS
+      for val in VALEUR:
+         dres = val.cree_dict_valeurs(val.mc_liste)
+         
+         # Recherche des mots-cles simples
+         ssigne = dres['VALE_ABS']
+         epsi = dres['PRECISION']
+         crit = dres['CRITERE']
+         fct = dres['FONCTION']
+         sensi = dres['SENSIBILITE']
+         nompara = dres['NOM_PARA']
+         if nompara == None:
+            nompara = ''
+         ref = dres['REFERENCE']
+         ver = None
+         if ref == 'NON_REGRESSION':
+            ver = dres['VERSION']
+         nomfct = fct.nomj.nomj
+         
+         # Transformation de nompara en liste
+         if (not type(nompara) in (list, tuple)) and nompara != None:
+            nompara = [nompara,]
+         
+         bcle = []
+         pres_sensi = 0
+         # Si on a des parametres sensibles, on boucle dessus
+         # sinon, on boucle uniquement sur la fonction a tester
+         if sensi == None:
+            bcle = [fct,]
+         else:
+            pres_sensi = 1
+            if not type(sensi) in (list, tuple):
+               bcle = [sensi,]
+         
+         for ps in bcle:
+            # Suivant le cas, la foction est soit issue des parametres
+            # sensibles soit directement de dres['FONCTION']
+            lafonc = None
+            titre = ''
+            # Si on a des parametres sensible la fonction n'est pas ps
+            if pres_sensi == 1:
+               ncomp = self.jdc.memo_sensi.get_nocomp(fct.nom, ps.nom)
+               lafonc = self.jdc.memo_sensi.d_sd[ncomp]
+               titre = ' ... SENSIBILITE AU PARAMETRE '+ps.nomj.nomj
+            else:
+               lafonc = ps
+            
+            res = 0.
+            typeFct = ''
+            valpu = dres['VALE_PARA']
+            if not type(valpu) in (list, tuple): valpu = [valpu,]
+            
+            valref  = None
+            if (type(lafonc) == formule_c) or (type(lafonc) == fonction_c):
+               valref = dres['VALE_REFE_C']
+            else:
+               valref = dres['VALE_REFE']
+            # L'enjeu est de transformer valref en tableau
+            if not type(valref) in (list, tuple): valref = [valref,]
+            else:
+               if type(valref[0]) == str:
+                  valref = [valref,]
+            
+            intervalle = dres['INTERVALLE']
+            
+            ier = 0
+            # Distinction des cas
+            # - "fonction" sur un intervalle
+            # - "formule",
+            # - "fonction" ou "nappe"
+            if (type(lafonc) == (fonction_sdaster)) and intervalle != None:
+               fctProl = lafonc.PROL.get()
+               prolG = 'rien'
+               if fctProl[4][0:1] == 'C':
+                  prolG = 'CONSTANT'
+               elif fctProl[4][0:1] == 'E':
+                  prolG = 'EXCLU'
+               elif fctProl[4][0:1] == 'L':
+                  prolG = 'LINEAIRE'
+               prolD = 'rien'
+               if fctProl[4][1:2] == 'C':
+                  prolD = 'CONSTANT'
+               elif fctProl[4][1:2] == 'E':
+                  prolD = 'EXCLU'
+               elif fctProl[4][1:2] == 'L':
+                  prolD = 'LINEAIRE'
+               curInterpol = [fctProl[1][0:3], fctProl[1][4:7]]
+               
+               fctInt = CALC_FONCTION(INTEGRE = _F(FONCTION=lafonc,),
+                                      PROL_DROITE = prolD,
+                                      PROL_GAUCHE = prolG,
+                                      INTERPOL = curInterpol)
+               
+               res1 = fctInt(intervalle[0])
+               res2 = fctInt(intervalle[1])
+               
+               DETRUIRE(CONCEPT = _F(NOM = fctInt),INFO = 1)
+               
+               res = (res2-res1)/(intervalle[1]-intervalle[0])
+               valpu[0] = intervalle[0]
+               
+            elif type(lafonc) in (formule, formule_c):
+               # Lecture des valeurs de reference dans les mots-cles simples
+               if type(lafonc) == formule_c: typeFct = 'formule_c'
+               else: typeFct = 'formule'
+               
+               # On cherche les valeurs de reference passees a TEST_FONCTION et
+               # on les trie grace a ceux de la formule
+               paramFormule = lafonc.Parametres()['NOM_PARA']
+               if not type(paramFormule) in (list, tuple):
+                  paramFormule = [paramFormule,]
+               if nompara[0] == '':
+                  nompara = paramFormule
+               
+               # On verifie que la formule a bien le meme nombre de parametres
+               # que ceux passes a la fonction TEST_FONCTION
+               if len(nompara) != len(paramFormule):
+                  ier = 160
+                  UTMESS('A+','FONCT0_9',valk=(lafonc.nomj.nomj))
+                  UTMESS('A','FONCT0_14',vali=(len(nompara),len(paramFormule)))
+                  return 0.
+               
+               # Trie des parametres passes a la fonction TEST_FONCTION pour
+               # correspondre a l'ordre de ceux de la formule
+               nParamOrdo = []
+               vParamOrdo = []
+               for iPN in range(len(paramFormule)):
+                  nParamOrdo.append('')
+                  #vParamOrdo.append('')
+               
+               compteur = 0
+               for iPN in range(len(paramFormule)):
+                  i = 0
+                  for iPU in range(len(nompara)):
+                     if paramFormule[iPN] == nompara[iPU]:
+                        if nParamOrdo[iPN] == '':
+                           vParamOrdo.append(valpu[iPU])
+                           nParamOrdo[iPN] = paramFormule[iPN]
+                           compteur = compteur + 1
+                        else:
+                           ier = 120
+                           UTMESS('A+','FONCT0_9',valk=(lafonc.nomj.nomj))
+                           UTMESS('A','FONCT0_15',valk=nompara)
+                           res = 0.
+                     i = i + 1
+                  if nParamOrdo[iPN] == '':
+                     ier = 130
+                     UTMESS('A+','FONCT0_9',valk=(lafonc.nomj.nomj))
+                     UTMESS('A','FONCT0_16',valk=paramFormule)
+                     UTMESS('A','FONCT0_17',valk=nompara)
+                     return 0.
+               
+               # Si tout est Ok, on calcul la valeur de la formule
+               if ier == 0:
+                  res = lafonc(*vParamOrdo)
+               
+            # Cas fonction et nappe
+            elif type(lafonc) in (fonction_sdaster, fonction_c, nappe_sdaster):
+               # Recuperation du .PROL de la fonction
+               fct_prol = lafonc.PROL.get_stripped()
+               if lafonc.PROL == None: UTMESS('F','PREPOST3_93')
+               
+               nompu = ''
+               if nompara[0] != '':
+                  nompu = nompara[0]
+               else:
+                  nompu = fct_prol[2]
+                  nompara = [nompu,]
+               
+               # Une nappe a forcement 2 parametres
+               if (fct_prol[0] == 'NAPPE') & (len(nompara) == 1):
+                  UTMESS('A','PREPOST3_94')
+                  break
+               
+               # Lecture de la valeur de reference
+               if fct_prol[0] == 'FONCT_C':
+                  typeFct = 'fonction_c'
+               else:
+                  if fct_prol[0] == 'NAPPE': typeFct = 'nappe'
+                  else: typeFct = 'fonction'
+               
+               # Calcul de la fonction
+               res = 0
+               if type(lafonc) in (fonction_sdaster, fonction_c):
+                  res = lafonc(valpu[0])
+               else:
+                  # Remise dans l'ordre des param
+                  paramNappe = [fct_prol[2], fct_prol[6]]
+                  vParamOrdo = ['','']
+                  for iPN in range(len(paramNappe)):
+                     i = 0
+                     for iPU in range(len(nompara)):
+                        if paramNappe[iPN] == nompara[iPU]:
+                           if vParamOrdo[iPN] != '':
+                              ier = 120
+                              UTMESS('A+','FONCT0_9',valk=(lafonc.nomj.nomj))
+                              UTMESS('A','FONCT0_15',valk=nompara)
+                           else:
+                              vParamOrdo[iPN] = valpu[iPU]
+                        i = i + 1
+                     if vParamOrdo[iPN] == '':
+                        ier = 130
+                        UTMESS('A+','FONCT0_9',valk=(lafonc.nomj.nomj))
+                        UTMESS('A','FONCT0_16',valk=paramNappe)
+                        UTMESS('A','FONCT0_17',valk=nompara)
+                  res = lafonc(vParamOrdo[0],vParamOrdo[1])
+            else: ier = 150
+            
+            # Construction de l'affiche du resultat
+            current = {}
+            if (typeFct == 'nappe'):
+               current['nom_nappe'] = nomfct
+               current['nom_para']  = nompu
+               current['vale_para'] = valpu[0]
+               txt.append(ligne_nappe % current)
+            else:
+               nb_espace = 19-len(nomfct)
+               espace = nb_espace*' '
+               current['nom_fct'] = nomfct+espace
+               current['titre']   = titre
+               txt.append(ligne_fct % current)
+            
+            current = {}
+            if ref != None:
+               current['typ_ref'] = ref
+               if ver != None:
+                  current['version'] = 'VERSION: '+ver
+               else:
+                  current['version'] = ''
+            else:
+               a_ecrire = 'REFERENCE: NON_DEFINI'
+               current['typ_ref'] = 'NON_DEFINI'
+               current['version'] = ''
+            txt.append(ligne_ref % current)
+            
+            nomLastPara = nompara[len(nompara)-1]
+            valLastPara = valpu[len(valpu)-1]
+            # Test des valeurs calculees
+            curDict=TesterValeur(nomLastPara,valLastPara,valref,res,epsi,crit,ssigne)
+            
+            if TEST_NOOK == 'OUI':
+               if ier == 0:
+                  testOk = curDict['testOk']
+                  if testOk == ' OK ':
+                     txt.append('NOOK PAS DE CHANCE LE TEST EST CORRECT !!!')
+                  else:
+                     AfficherResultat(curDict, nomLastPara, crit, res, valLastPara, txt)
+               elif ier == 120:
+                  txt.append(' OK  PARAMETRE EN DOUBLE')
+               elif ier == 130:
+                  txt.append(' OK  PARAMETRE NON CORRECT')
+               elif ier == 150:
+                  txt.append(' OK  TYPE DE FONCTION NON TRAITE')
+               elif ier == 160:
+                  txt.append(' OK  PAS ASSEZ DE PARAMETRES')
+            else:
+               if ier != 0:
+                  txt.append('NOOK PB INTERPOLATION. VOIR MESSAGE CI-DESSUS')
+               else:
+                  AfficherResultat(curDict,nomLastPara,crit,res,valLastPara,txt)
+   
+   if ATTRIBUT != None:
+      # Boucle sur le mot-cle ATTRIBUT
+      for attr in ATTRIBUT:
+         dres = attr.cree_dict_valeurs(attr.mc_liste)
+         # Lecture des mots-cles simples
+         ref = dres['REFERENCE']
+         ver = None
+         if ref == 'NON_REGRESSION':
+            ver = dres['VERSION']
+         fonction = dres['FONCTION']
+         fctProl = fonction.PROL.get_stripped()
+         typeFct = fctProl[0]
+         para = dres['PARA']
+         fctPara = fonction.PARA.get()
+         
+         pos = 0
+         # Cas particulier d'une nappe qui a 2 dimensions
+         if typeFct == 'NAPPE':
+            if para != None:
+               # Recherche de la fonction liee a para
+               precPara = dres['PREC_PARA']
+               critPara = dres['CRIT_PARA']
+               LOK = 0
+               compteur = 0
+               for curPara in fctPara:
+                  if critPara[0:4] == 'RELA':
+                     LOK = ( abs(para-curPara) <= precPara*abs(curPara) )
+                  else:
+                     LOK = ( abs(para-curPara) <= precPara )
+                  if LOK:
+                     pos = compteur
+                     break
+                  compteur = compteur + 1
+               if not LOK:
+                  UTMESS('A','PREPOST3_95')
+            else:
+               para = fctPara[0]
+         
+         # Lecture des parametres de reference
+         nomAttr = dres['ATTR']
+         valAttrRef = dres['ATTR_REFE']
+         
+         # Recherche de la valeur de l'attribut dans le .PROL
+         nompu = ''
+         testOk = 'NOOK'
+         if nomAttr == 'INTERPOL_FONC':
+            nompu = fctProl[7+2*(pos)]+' '
+         elif nomAttr == 'INTERPOL':
+            nompu = fctProl[1]+' '
+         elif nomAttr == 'NOM_PARA_FONC':
+            nompu = fctProl[6]
+         elif nomAttr == 'NOM_PARA':
+            nompu = fctProl[2]
+         elif nomAttr == 'NOM_RESU':
+            nompu = fctProl[3]
+         elif nomAttr == 'PROL_GAUCHE_FONC':
+            prolFonc = fctProl[7+2*(pos)+1]
+            nompu = prolFonc[0:1]
+            if nompu == 'E':
+               nompu = 'EXCLU'
+            elif nompu == 'C':
+               nompu = 'CONSTANT'
+            elif nompu == 'L':
+               nompu = 'LINEAIRE'
+         elif nomAttr == 'PROL_DROITE_FONC':
+            prolFonc = fctProl[7+2*(pos)+1]
+            nompu = prolFonc[1:2]
+            if nompu == 'E':
+               nompu = 'EXCLU'
+            elif nompu == 'C':
+               nompu = 'CONSTANT'
+            elif nompu == 'L':
+               nompu = 'LINEAIRE'
+         elif nomAttr == 'PROL_GAUCHE':
+            prolFonc = fctProl[4]
+            nompu = prolFonc[0:1]
+            if nompu == 'E':
+               nompu = 'EXCLU'
+            elif nompu == 'C':
+               nompu = 'CONSTANT'
+            elif nompu == 'L':
+               nompu = 'LINEAIRE'
+         elif nomAttr == 'PROL_DROITE':
+            prolFonc = fctProl[4]
+            nompu = prolFonc[1:2]
+            if nompu == 'E':
+               nompu = 'EXCLU'
+            elif nompu == 'C':
+               nompu = 'CONSTANT'
+            elif nompu == 'L':
+               nompu = 'LINEAIRE'
+         
+         # Test de la valeur
+         if ( nompu == valAttrRef ): testOk = ' OK '
+         if TEST_NOOK == 'OUI':
+            if testOk == ' OK ': testOk = 'NOOK'
+            else: testOk = ' OK '
+         
+         # Construction de l'affichage
+         nomFct = fonction.nomj.nomj
+         current = {}
+         if typeFct == 'NAPPE':
+            current['nom_nappe'] = nomFct
+            current['nom_para']  = nompu
+            current['vale_para'] = para
+            txt.append(ligne_nappe % current)
+         else:
+            nb_espace = 19-len(nomFct)
+            espace = nb_espace*' '
+            current['nom_fct'] = nomFct+espace
+            current['titre']   = ''
+            txt.append(ligne_fct % current)
+         
+         current = {}
+         if ref != None:
+            current['typ_ref'] = ref
+            if ver != None:
+               current['version'] = 'VERSION: '+ver
+            else:
+               current['version'] = ''
+         else:
+            a_ecrire = 'REFERENCE: NON_DEFINI'
+            current['typ_ref'] = 'NON_DEFINI'
+            current['version'] = ''
+         txt.append(ligne_ref % current)
+         
+         current = {}
+         nb_espace = 27-len(nomAttr)
+         espace = nb_espace*' '
+         current['testOk']  = testOk
+         current['nomPara'] = nomAttr+espace
+         current['valPara'] = nompu
+         txt.append(ligne_res_attr % current)
+         
+         current = {}
+         current['valeRefe'] = valAttrRef
+         txt.append(ligne_res_att2 % current)
+   
+   if TABL_INTSP != None:
+      # Boucle sur interspectres
+      for intSpec in TABL_INTSP:
+         dres = intSpec.cree_dict_valeurs(intSpec.mc_liste)
+         ref = dres['REFERENCE']
+         ver = None
+         if ref == 'NON_REGRESSION':
+            ver = dres['VERSION']
+         crit = dres['CRITERE']
+         epsi = dres['PRECISION']
+         
+         table = dres['INTE_SPEC']
+         
+         dataTable = table.EXTR_TABLE().values()
+         valePara = dres['VALE_PARA']
+         valeRef = dres['VALE_REFE_C']
+         numeOrdreI = dres['NUME_ORDRE_I']
+         noeudI = dres['NOEUD_I']
+         numeOrdreJ = None
+         noeudJ = None
+         nomCmpI = None
+         nomCmpJ = None
+         
+         i = -1
+         numeViteF = dres['NUME_VITE_FLUI']
+         presNumeVF = False
+         dTNumVF = None
+         if numeViteF != None:
+            presNumeVF = True
+            dTNumVF = dataTable['NUME_VITE_FLUI']
+         if numeOrdreI != None:
+            numeOrdreJ = dres['NUME_ORDRE_J']
+            
+            dTNumOrdreI = dataTable['NUME_ORDRE_I']
+            dTNumOrdreJ = dataTable['NUME_ORDRE_J']
+            
+            for i in range(len(dTNumOrdreI)):
+               if dTNumOrdreI[i] == None: continue
+               test1 = (dTNumOrdreI[i] == numeOrdreI)
+               test2 = (dTNumOrdreJ[i] == numeOrdreJ)
+               test3 = False
+               if presNumeVF:
+                  test3 = (dTNumVF[i] == numeViteF)
+               else:
+                  test3 = True
+               if test1 and test2 and test3:
+                  break
+         elif noeudI != None:
+            noeudJ = dres['NOEUD_J']
+            nomCmpI = dres['NOM_CMP_I']
+            nomCmpJ = dres['NOM_CMP_J']
+            
+            dTNoeudI = dataTable['NOEUD_I']
+            dTNoeudJ = dataTable['NOEUD_J']
+            dTNomCmpI = dataTable['NOM_CMP_I']
+            dTNomCmpJ = dataTable['NOM_CMP_J']
+            
+            for i in range(len(dTNoeudI)):
+               if dTNoeudI[i] == None: continue
+               nom1 = dTNoeudI[i]
+               nom1 = nom1[0:len(noeudI)]
+               nom2 = dTNoeudJ[i]
+               nom2 = nom2[0:len(noeudJ)]
+               nom3 = dTNomCmpI[i]
+               nom3 = nom3[0:len(nomCmpI)]
+               nom4 = dTNomCmpJ[i]
+               nom4 = nom4[0:len(nomCmpJ)]
+               test1 = (nom1 == noeudI)
+               test2 = (nom2 == noeudJ)
+               test3 = (nom3 == nomCmpI)
+               test4 = (nom4 == nomCmpJ)
+               test5 = False
+               if presNumeVF:
+                  test5 = (dTNumVF[i] == numeViteF)
+               else:
+                  test5 = True
+               if test1 and test2 and test3 and test4 and test5:
+                  break
+         
+         if i == -1: UTMESS('F','MODELISA2_91',valk=('FONCTION_C',table.nomj.nomj))
+         nomFctC = dataTable['FONCTION_C'][i]
+         
+         # Lecture JEVEUX du .PROL et .VALE
+         fctProl = aster.getvectjev(nomFctC[0:19]+'.PROL')
+         fctVale = aster.getvectjev(nomFctC[0:19]+'.VALE')
+         
+         TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
+         dico={
+          'INTERPOL'    : [fctProl[1][0:3],fctProl[1][4:7]],
+          'NOM_PARA'    : fctProl[2][0:16].strip(),
+          'NOM_RESU'    : fctProl[3][0:16].strip(),
+          'PROL_DROITE' : TypeProl[fctProl[4][1]],
+          'PROL_GAUCHE' : TypeProl[fctProl[4][0]],
+         }
+         sdf = sd_fonction(nomFctC)
+         val = sdf.VALE.get()
+         dim = len(val)/3
+         lx = val[0:dim]
+         lr = []
+         li = []
+         for i in range(dim):
+            lr.append(val[dim+2*i])
+            li.append(val[dim+2*i+1])
+         fctIntSp = t_fonction_c(lx, map(complex,lr,li),dico,nomFctC)
+         
+         # Affichage
+         current = {}
+         current['nom_intspc'] = nomFctC
+         txt.append(ligne_intspc % current)
+         
+         current = {}
+         if ref != None:
+            current['typ_ref'] = ref
+            if ver != None:
+               current['version'] = 'VERSION: '+ver
+            else:
+               current['version'] = ''
+         else:
+            a_ecrire = 'REFERENCE: NON_DEFINI'
+            current['typ_ref'] = 'NON_DEFINI'
+            current['version'] = ''
+         txt.append(ligne_ref % current)
+         
+         # Calcul de la valeur de l'interspectre
+         x = valePara
+         res = fctIntSp(x)
+         
+         if ier != 0:
+            txt.append('NOOK PB INTERPOLATION. VOIR MESSAGE CI-DESSUS')
+         else:
+            # Test et affichage de la valeur
+            curDict=TesterValeur(fctProl[2],valePara,[valeRef,],res,epsi,crit,'NON')
+            AfficherResultat(curDict,fctProl[2].strip(),crit,res,valePara,txt)
+   
+   # On affiche txt dans le fichier RESULTAT
+   aster.affiche('RESULTAT', os.linesep.join(txt))
+   
+   return ier
+

diff --git a/Aster/Cata/cataSTA10/Macro/test_temps_ops.py b/Aster/Cata/cataSTA10/Macro/test_temps_ops.py
new file mode 100644 (file)
index 0000000..680da0c
--- /dev/null
+++ b/Aster/Cata/cataSTA10/Macro/test_temps_ops.py
@@ -0,0 +1,251 @@
+#@ MODIF test_temps_ops Macro  DATE 13/10/2009   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.        
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+"""
+for m in clpaster clp50a8 claut626 clau5aaa aster
+do
+   echo "------ $m   :  `ssh $m hostid` -------"
+   ssh $m cat /proc/cpuinfo > $m.cpuinfo
+   ssh $m python -c '"import os ; print os.uname()[-1]"'
+   grep 'cpu MHz' $m.cpuinfo | head -1
+   grep -i bogomips $m.cpuinfo | head -1
+done
+"""
+
+import sys
+import os
+import re
+from glob import glob
+
+#-------------------------------------------------------------------------------
+# formats
+tab_header = """
+   !--------------------------------------------------------------------------------------------------!
+   ! Commande               ! Ordre  ! Reference  ! Mesure     ! Difference ! Tolerance  ! Diagnostic !
+   !--------------------------------------------------------------------------------------------------!"""
+tab_line = """   ! %(cmde)-22s ! %(nume)6d ! %(refe)10.2f ! %(vale)10.2f ! %(diff)10.2f ! %(prec)10.2f !    %(diag)4s    !"""
+tab_footer = """   !--------------------------------------------------------------------------------------------------!
+"""
+
+#-------------------------------------------------------------------------------
+def get_idperf(conf):
+   """Retourne l'identifiant utilisé pour la mesure des performances.
+   Soit on le trouve dans le fichier config.txt de la version utilisée,
+   soit on le détermine à partir de : "kernel name - hardware name"
+   """
+   machine = ''
+   compiler = 'unknown'
+   if conf is not None:
+      machine = conf['ID_PERF'][0]
+      compiler = os.path.basename(conf['F77'][0].split()[0])
+   
+   if machine == '':
+      machine = '%s-%s-%s' %(os.uname()[0], os.uname()[4], compiler)
+   return machine
+
+#-------------------------------------------------------------------------------
+def as_list(value):
+   """Retourne 'value' si c'est une liste, sinon le singleton [value,]."""
+   if type(value) not in (list, tuple):
+      value = [value,]
+   return value
+
+#-------------------------------------------------------------------------------
+def test_temps_ops(self, RESU, INFO, **args):
+   """
+   Macro TEST_TEMPS permettant de vérifier le temps passé dans les commandes.
+   """
+   import aster
+   from Accas import _F
+   from Utilitai.Utmess import UTMESS, MessageLog
+
+   # On importe les definitions des commandes a utiliser dans la macro
+   # Le nom de la variable doit etre obligatoirement le nom de la commande
+   DETRUIRE        = self.get_cmd('DETRUIRE')
+   CREA_TABLE      = self.get_cmd('CREA_TABLE')
+   TEST_TABLE      = self.get_cmd('TEST_TABLE')
+   
+   #----------------------------------------------
+   ier = 0
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # ----- récupération du fichier de config
+   ficconf = '?'
+   conf = None
+   try:
+      # recuperation de la variable ASTER_ROOT
+      aster_root = os.environ.get('ASTER_ROOT')
+      assert aster_root != None, "<TEST_TEMPS> Variable d'environnement ASTER_ROOT non definie."
+      sys.path.append(os.path.join(aster_root, 'ASTK', 'ASTK_SERV', 'lib'))
+      from as_profil import ASTER_PROFIL
+      from as_config import ASTER_CONFIG
+      
+      l_export = glob('*.export')
+      assert len(l_export) > 0, "<TEST_TEMPS> pas de fichier export dans le repertoire de travail."
+      
+      ficconf = 'config.txt'
+      if not os.path.isfile(ficconf):         # if as_run.__version__ < 1.6.3
+         prof = ASTER_PROFIL(l_export[0])
+         if prof.Get('D', typ='conf'):
+            print '<TEST_TEMPS> Surcharge du fichier config.txt non supportée.'
+         REPREF  = os.path.join(aster_root, prof['version'][0])
+         ficconf = os.path.join(REPREF, 'config.txt')
+      conf = ASTER_CONFIG(ficconf)
+   except Exception, err:
+      print err
+      
+   machine = get_idperf(conf)
+   
+   # liste des timers par ordre d'apparition : dict_cmde['commande'] = [timer1, timer2, ...]
+   dict_cmde = {}
+   for num, timer in self.jdc.timer.getsortedtimers():
+      cmde  = timer['name']
+      dict_cmde[cmde] = dict_cmde.get(cmde, [])
+      dict_cmde[cmde].append(timer)
+   
+   tab = get_cmde_timers(self.jdc)
+   if INFO == 2:
+      aster.affiche('MESSAGE', repr(tab))
+   
+   #----------------------------------------------
+   # boucle sur les commandes a tester
+   alarm9 = True
+   infos = []
+   for res_i in RESU:
+         dres = res_i.cree_dict_valeurs(res_i.mc_liste)
+         current = {
+            'cmde' : dres['COMMANDE'],
+            'nume' : dres['NUME_ORDRE'],
+            'refe' : 0.,
+            'vale' : 0.,
+            'diff' : 0.,
+            'prec' : 0.,
+            'diag' : 'NOOK',
+         }
+         error = False
+         l_mach = as_list(dres['MACHINE'])
+         l_vale = as_list(dres['VALE'])
+         if len(l_mach) != len(l_vale):
+            UTMESS('E', 'TEST0_10')
+            error = True
+
+         l_prec = as_list(dres['PRECISION'])
+         if len(l_prec) == 1:
+            l_prec = l_prec * len(l_vale)
+         if len(l_prec) != len(l_vale):
+            UTMESS('E', 'TEST0_8')
+            error = True
+
+         tres = (tab.COMMANDE == dres['COMMANDE']) & (tab.NUME_ORDRE == dres['NUME_ORDRE'])
+         if len(tres) != 1:
+            UTMESS('E', 'TEST0_7', valk=dres['COMMANDE'], vali=dres['NUME_ORDRE'])
+            error = True
+         
+         if error:
+            infos.append(current)
+            continue
+
+         # comparaison des valeurs
+         valtest = getattr(tres, dres['TYPE_TEST'])
+         assert len(valtest) == 1, 'TYPE_TEST invalide'
+         valtest = valtest[0]
+         
+         current['vale'] = valtest
+
+         # reference, precision
+         dref = {}
+         for mach, vale, precision in zip(l_mach, l_vale, l_prec):
+            if dres['CRITERE'] == 'RELATIF':
+               precision = precision * vale
+            dref[mach.upper()] = {
+               'vale'   : vale,
+               'prec'   : precision,
+               'valmin' : vale - precision,
+               'valmax' : vale + precision
+            }
+         dmach = dref.get(machine.upper())
+         # si on n'a pas de référence pour cette machine, on prend la première
+         if not dmach:
+            dmach = dref[l_mach[0].upper()]
+            if alarm9:
+               alarm9 = False
+               UTMESS('A', 'TEST0_9', valk=(machine, l_mach[0]))
+         current['refe'] = dmach['vale']
+         current['prec'] = dmach['prec']
+         current['diff'] = valtest - dmach['vale']
+         if dmach['valmin'] < valtest < dmach['valmax']:
+            current['diag'] = 'OK'
+         infos.append(current)
+   
+   # tableau de resultats
+   text_id = MessageLog.GetText('I', 'TEST0_5', valk=(ficconf, machine))
+   is_ok = 1
+   txt = [text_id, tab_header,]
+   for line in infos:
+      txt.append(tab_line % line)
+      if line['diag'] != 'OK':
+         is_ok = 0
+   txt.append(tab_footer)
+   for unit in ('MESSAGE', 'RESULTAT'):
+      aster.affiche(unit, os.linesep.join(txt))
+
+   # test_resu
+   tab1__ = CREA_TABLE(LISTE=(_F(PARA='DIAGNOSTIC',  LISTE_I=is_ok),),)
+   
+   TEST_TABLE(TABLE=tab1__,
+              NOM_PARA='DIAGNOSTIC',
+              VALE_I=1,
+              CRITERE='ABSOLU',
+              PRECISION=0,
+              REFERENCE='NON_REGRESSION')
+
+   return ier
+
+
+#-------------------------------------------------------------------------------
+def get_cmde_timers(jdc):
+   """Retourne un objet Table contenant les mesures de temps pour
+   les commandes terminées.
+   """
+   from Utilitai.Table import Table
+   tab = Table()
+
+   # liste des timers par ordre d'apparition
+   dnum = {}
+   for num, timer in jdc.timer.getsortedtimers():
+      if timer['state'] != 'stop' \
+            or re.sub('[A-Z_]', '', timer['name']).strip() != '':  # timers superviseur
+         continue
+      line = {}
+      for k in ('name', 'cpu_dt', 'sys_dt', 'tot_dt'):
+         line[k] = timer[k]
+      line['USER+SYS'] = timer['cpu_dt'] + timer['sys_dt']
+      dnum[line['name']] = dnum.get(line['name'], 0) + 1
+      line['NUME_ORDRE'] = dnum[line['name']]
+      tab.append(line)
+   tab.Renomme('name',   'COMMANDE')
+   tab.Renomme('cpu_dt', 'USER')
+   tab.Renomme('sys_dt', 'SYSTEM')
+   tab.Renomme('tot_dt', 'ELAPSED')
+   tab = tab['NUME_ORDRE', 'COMMANDE', 'USER', 'SYSTEM', 'USER+SYS', 'ELAPSED']
+   return tab
+

diff --git a/Aster/Cata/cataSTA10/__init__.py b/Aster/Cata/cataSTA10/__init__.py
new file mode 100644 (file)
index 0000000..f681691
--- /dev/null
+++ b/Aster/Cata/cataSTA10/__init__.py
@@ -0,0 +1,11 @@
+import os,sys
+sys.modules["Cata"]=sys.modules[__name__]
+rep_macro = os.path.dirname(__file__)
+sys.path.insert(0,rep_macro)
+rep_macro=os.path.join(rep_macro,'Macro')
+sys.path.insert(0,rep_macro)
+
+from cata import *
+from math import ceil
+from Extensions import param2
+pi=param2.Variable('pi',pi)

diff --git a/Aster/Cata/cataSTA10/cata.py b/Aster/Cata/cataSTA10/cata.py
new file mode 100755 (executable)
index 0000000..cba954b
--- /dev/null
+++ b/Aster/Cata/cataSTA10/cata.py
@@ -0,0 +1,26146 @@
+#& MODIF ENTETE  DATE 16/11/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            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
+
+# faire que la division soit toujours réelle
+from __future__ import division
+
+__version__ = "$Name:  $"
+__Id__ = "$Id: cata_aster_v6.py,v 1.12 2001/01/16 15:55:05 iliade Exp $"
+
+import Accas
+from Accas import *
+from Accas import _F
+import Numeric
+from math import sin,cos,tan,asin,acos,atan2,atan,sinh,cosh,tanh,exp,log,log10
+from math import sqrt,pi
+import ops
+
+try:
+  import aster
+except:
+  pass
+
+# -----------------------------------------------------------------------------
+JdC = JDC_CATA(code='ASTER',
+               execmodul=None,
+               regles = (AU_MOINS_UN('DEBUT','POURSUITE'),
+                         AU_MOINS_UN('FIN'),
+                         A_CLASSER(('DEBUT','POURSUITE'),'FIN')))
+# Type le plus general
+class entier   (ASSD):
+   def __init__(self,valeur=None,**args):
+      ASSD.__init__(self,**args)
+      self.valeur=valeur
+
+   def __adapt__(self,validator):
+      if validator.name == "list":
+         #validateur liste,cardinalité
+         return (self,)
+      elif validator.name == "type":
+         #validateur type
+         return validator.adapt(self.valeur or 0)
+      else:
+         #validateur into et valid
+         return self
+
+class reel(ASSD):
+   def __init__(self,valeur=None,**args):
+      ASSD.__init__(self,**args)
+      self.valeur=valeur
+
+   def __call__(self):
+      return self.valeur
+
+   def __adapt__(self,validator):
+      if validator.name == "list":
+         #validateur liste,cardinalité
+         return (self,)
+      elif validator.name == "type":
+         #validateur type
+         return validator.adapt(self.valeur or 0.)
+      else:
+         #validateur into et valid
+         return self
+
+# -----------------------------------------------------------------------------
+# Type geometriques
+class no  (GEOM):pass
+class grno(GEOM):pass
+class ma  (GEOM):pass
+class grma(GEOM):pass
+
+# -----------------------------------------------------------------------------
+from SD.co_cabl_precont     import cabl_precont
+from SD.co_cara_elem        import cara_elem
+from SD.co_cham_mater       import cham_mater
+from SD.co_char_acou        import char_acou
+from SD.co_char_cine_acou   import char_cine_acou
+from SD.co_char_cine_meca   import char_cine_meca
+from SD.co_char_cine_ther   import char_cine_ther
+from SD.co_char_meca        import char_meca
+from SD.co_char_ther        import char_ther
+from SD.co_compor           import compor_sdaster
+from SD.co_courbe           import courbe_sdaster
+from SD.co_fiss_xfem        import fiss_xfem
+from SD.co_fond_fiss        import fond_fiss
+from SD.co_interf_dyna_clas import interf_dyna_clas
+from SD.co_gfibre           import gfibre_sdaster
+from SD.co_listis           import listis_sdaster
+from SD.co_list_inst        import list_inst
+from SD.co_melasflu         import melasflu_sdaster
+from SD.co_mode_cycl        import mode_cycl
+from SD.co_nume_ddl_gene    import nume_ddl_gene
+from SD.co_nume_ddl         import nume_ddl_sdaster
+from SD.co_sd_feti          import sd_feti_sdaster
+from SD.co_spectre          import spectre_sdaster
+from SD.co_surface          import surface_sdaster
+from SD.co_tran_gene        import tran_gene
+from SD.co_type_flui_stru   import type_flui_stru
+
+# -----------------------------------------------------------------------------
+# modeles :
+from SD.co_modele      import modele_sdaster
+from SD.co_modele_gene import modele_gene
+
+# -----------------------------------------------------------------------------
+# materiau
+from SD.co_mater import mater_sdaster
+
+# -----------------------------------------------------------------------------
+# macro-elements :
+from SD.co_macr_elem_dyna import macr_elem_dyna
+from SD.co_macr_elem_stat import macr_elem_stat
+
+# -----------------------------------------------------------------------------
+# liste :
+from SD.co_listr8 import listr8_sdaster
+
+# -----------------------------------------------------------------------------
+# maillage :
+from SD.co_maillage  import maillage_sdaster
+from SD.co_squelette import squelette
+
+# -----------------------------------------------------------------------------
+# champs
+from SD.co_champ     import cham_gd_sdaster
+from SD.co_cham_no   import cham_no_sdaster
+from SD.co_carte     import carte_sdaster
+from SD.co_cham_elem import cham_elem
+
+# -----------------------------------------------------------------------------
+# resultat : (evol_sdaster,mode_stat,mode_meca)
+from SD.co_resultat     import resultat_sdaster, resultat_jeveux
+from SD.co_resultat_dyn import resultat_dyn
+from SD.co_mode_meca  import mode_meca
+
+# -----------------------------------------------------------------------------
+class acou_harmo    (resultat_dyn):pass
+class dyna_harmo    (resultat_dyn):pass
+class dyna_trans    (resultat_dyn):pass
+class harm_gene     (resultat_dyn):pass
+class mode_acou     (resultat_dyn):pass
+class mode_flamb    (resultat_dyn):pass
+class mode_gene     (resultat_dyn):pass
+
+# -----------------------------------------------------------------------------
+class comb_fourier  (resultat_sdaster):pass
+class fourier_elas  (resultat_sdaster):pass
+class fourier_ther  (resultat_sdaster):pass
+class mult_elas     (resultat_sdaster):pass
+class theta_geom    (resultat_sdaster):pass
+
+# -----------------------------------------------------------------------------
+# resultat_sdaster/evol_sdaster :
+class evol_sdaster(resultat_sdaster):pass
+class evol_char(evol_sdaster):pass
+class evol_elas(evol_sdaster):pass
+class evol_noli(evol_sdaster):pass
+class evol_ther(evol_sdaster):pass
+class evol_varc(evol_sdaster):pass
+
+
+# -----------------------------------------------------------------------------
+# resultat_sdaster/mode_meca :
+class mode_meca_c(mode_meca):pass
+
+# -----------------------------------------------------------------------------
+# fonctions / nappe / para_sensi
+from SD.co_fonction import fonction_sdaster, para_sensi, fonction_c, nappe_sdaster
+
+# -----------------------------------------------------------------------------
+# matr_asse :
+from SD.co_matr_asse      import matr_asse
+from SD.co_matr_asse_gene import matr_asse_gene
+from SD.co_matr_asse_gene import matr_asse_gene_r
+from SD.co_matr_asse_gene import matr_asse_gene_c
+
+from SD.co_matr_asse_gd import matr_asse_gd, \
+                               matr_asse_depl_r, matr_asse_depl_c, \
+                               matr_asse_pres_r, matr_asse_pres_c, \
+                               matr_asse_temp_r, matr_asse_temp_c
+
+# -----------------------------------------------------------------------------
+# matr_elem :
+from SD.co_matr_elem import matr_elem, \
+                            matr_elem_depl_r, matr_elem_depl_c, \
+                                              matr_elem_pres_c, \
+                            matr_elem_temp_r
+
+# -----------------------------------------------------------------------------
+# table :
+from SD.co_table import table_sdaster, table_jeveux
+from SD.co_table_fonction import table_fonction
+from SD.co_table_container import table_container
+
+# -----------------------------------------------------------------------------
+# vect_asse_gene :
+from SD.co_vect_asse_gene import vect_asse_gene
+
+# -----------------------------------------------------------------------------
+# vect_elem :
+from SD.co_vect_elem import vect_elem, \
+                            vect_elem_depl_r, \
+                            vect_elem_pres_r, vect_elem_pres_c, \
+                            vect_elem_temp_r
+
+#& MODIF COMMUN  DATE 22/09/2009   AUTEUR PROIX J-M.PROIX 
+#            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.
+# ======================================================================
+# RESPONSABLE PROIX J.M.PROIX
+def C_COMP_INCR() : return FACT(statut='f',min=1,max='**',  #COMMUN#
+           RELATION  =SIMP( statut='o',typ='TXM',defaut="ELAS",into=C_RELATION()),
+           b_monox     = BLOC(condition = "RELATION == 'MONOCRISTAL' ",
+                                 fr="SD issue de DEFI_COMPOR",
+                   COMPOR =SIMP(statut='o',typ=compor_sdaster,max=1),),
+           b_polyx     = BLOC(condition = "RELATION == 'POLYCRISTAL' ",
+                                 fr="SD issue de DEFI_COMPOR",
+                   COMPOR =SIMP(statut='o',typ=compor_sdaster,max=1),),
+           b_zmat      = BLOC(condition = "RELATION == 'ZMAT' ",
+                                 fr="Comportement de la bibliotheque Zmat",
+                   NB_VARI =SIMP(statut='o',typ='I',max=1),
+                   UNITE =SIMP(statut='o',typ='I',max=1),),
+
+# KITs
+           b_kit_ddi = BLOC(condition = "RELATION == 'KIT_DDI' ",
+                            fr="relations de couplage fluage-plasticite",
+               RELATION_KIT    =SIMP(statut='o',typ='TXM',min=2,max=2,validators=NoRepeat(),
+                                 into=(
+                                       "VMIS_CINE_LINE",
+                                       "VMIS_ISOT_TRAC",
+                                       "VMIS_ISOT_LINE",
+                                       "VMIS_ISOT_PUIS",
+                                       "GLRC_DM",
+                                       "GRANGER_FP",
+                                       "GRANGER_FP_INDT",
+                                       "GRANGER_FP_V",
+                                       "BETON_UMLV_FP",
+                                       "ROUSS_PR",
+                                       "BETON_DOUBLE_DP",
+                                       "ENDO_ISOT_BETON",
+                                       "MAZARS"
+                                       ),),
+                   ),
+           b_kit_thm = BLOC(condition = "RELATION in ['KIT_HHM','KIT_HH','KIT_HM','KIT_THHM','KIT_THH','KIT_THM','KIT_THV']",
+                            fr="lois de comportements thermo-hydro-mecaniques",
+               RELATION_KIT    =SIMP(statut='o',typ='TXM',max=9,validators=NoRepeat(),
+                                 into=(
+# MECA
+                                       "ELAS",
+                                       "CJS",
+                                       "HUJEUX",
+                                       "CAM_CLAY",
+                                       "BARCELONE",
+                                       "LAIGLE",
+                                       "LETK",
+                                       "DRUCK_PRAGER",
+                                       "DRUCK_PRAG_N_A",
+                                       "VISC_DRUC_PRAG",
+                                       "ELAS_GONF",
+                                       "HOEK_BROWN_EFF",
+                                       "HOEK_BROWN_TOT",
+                                       "MAZARS",
+                                       "ENDO_ISOT_BETON",
+# THMC
+                                       "GAZ",
+                                       "LIQU_SATU",
+                                       "LIQU_GAZ_ATM",
+                                       "LIQU_VAPE_GAZ",
+                                       "LIQU_AD_GAZ_VAPE",
+                                       "LIQU_VAPE",
+                                       "LIQU_GAZ",
+# HYDR
+                                       "HYDR_UTIL",
+                                       "HYDR_VGM",
+                                       "HYDR",
+                                       "HYDR_ENDO",
+                                       ),),
+                                       ),
+           b_kit_meta = BLOC(condition = "RELATION in ('META_LEMA_ANI','META_P_CL_PT_RE','META_P_CL_PT','META_P_CL_RE','META_P_CL',\
+       'META_P_IL_PT_RE','META_P_IL_PT','META_P_IL_RE','META_P_IL','META_P_INL_PT_RE','META_P_INL_PT','META_P_INL_RE','META_P_INL',\
+           'META_V_CL_PT_RE','META_V_CL_PT','META_V_CL_RE','META_V_CL','META_V_IL_PT_RE','META_V_IL_PT','META_V_IL_RE','META_V_IL',\
+           'META_V_INL_PT_RE','META_V_INL_PT','META_V_INL_RE','META_V_INL')",
+                            fr="nombre de phases metallurgiques",
+               RELATION_KIT    =SIMP(statut='o',typ='TXM',max=1,validators=NoRepeat(),
+                                 into=("ACIER","ZIRC"),),
+                                 ),
+
+           DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT",
+                             into=("PETIT","PETIT_REAC","SIMO_MIEHE","GREEN_GR","GREEN","COROTATIONNEL",
+                                   "REAC_GEOM","EULER_ALMANSI")),
+
+           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",
+           ),
+           b_resideborst      = BLOC(condition = " RESI_DEBO_MAXI == None ",
+           fr="Critère d'arret relatif pour assurer la condition de contraintes planes",
+                            RESI_DEBO_RELA = SIMP(statut='f',typ='R',defaut= 1.0E-6),
+                            ),
+           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 ),
+           b_redec_local      = BLOC(condition = "DEFORMATION in ('PETIT','PETIT_REAC','GREEN')",
+                        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")),
+           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') ",
+                        fr="Calcul de la matrice tangente par perturbation, valeur de la perturbation",
+                 VALE_PERT_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-5),
+                                ),
+           b_tangsec      = BLOC(condition = " TYPE_MATR_TANG == 'TANGENTE_SECANTE' ",
+                        fr="Modification evolutive de la matrice tangente/secante",
+                 SEUIL        =SIMP(statut='f',typ='R',defaut= 3. ),
+                 AMPLITUDE    =SIMP(statut='f',typ='R',defaut= 1.5 ),
+                 TAUX_RETOUR  =SIMP(statut='f',typ='R',defaut= 0.05 ),
+                                ),
+           PARM_THETA      =SIMP(statut='f',typ='R',defaut= 1. ),
+
+           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='**'),
+
+         ) ;
+#& MODIF COMMUN  DATE 27/10/2009   AUTEUR TARDIEU N.TARDIEU 
+#            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.
+# ======================================================================
+# RESPONSABLE DESOZA T.DESOZA
+def C_CONTACT() : return FACT(statut='f',max='**',
+           fr="Définit les zones soumises à des conditions de contact unilatéral avec ou sans frottement",
+
+
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="CONTRAINTE",
+                                 into  =("VERIF","CONTRAINTE","LAGRANGIEN","PENALISATION","CONTINUE","GCP","XFEM") ),
+#
+# OPTIONS D'APPARIEMENT
+#
+
+           b_notxfem         =BLOC(condition = "METHODE != 'XFEM' ",
+                                   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='**'),
+
+             APPARIEMENT     =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL",
+                                   into  =("NODAL","MAIT_ESCL")),
+
+             LISSAGE         =SIMP(statut='f',typ='TXM',defaut="NON",
+                                   into  =("OUI","NON")),
+
+             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),
+             ),
+
+
+             TYPE_APPA       =SIMP(statut='f',typ='TXM',defaut="PROCHE",
+                                   into  =("PROCHE","FIXE")),
+
+             b_appa_fixe     =BLOC(condition = "TYPE_APPA == 'FIXE'",
+               DIRE_APPA     =SIMP(statut='f',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)),
+
+             TOLE_APPA       =SIMP(statut='f',typ='R'  ,defaut=-1.0),
+
+           ),
+
+
+           b_dist_struct   =BLOC(condition = "METHODE != 'CONTINUE' and METHODE != 'XFEM'",
+             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) ),
+             ),
+           ),
+
+           TOLE_PROJ_EXT   =SIMP(statut='f',typ='R'  ,defaut=0.50),
+
+#
+# FIN OPTIONS D'APPARIEMENT
+#
+
+           b_xfem         =BLOC(condition = "METHODE == 'XFEM' ",
+             FISS_MAIT      = SIMP(statut='o',typ=fiss_xfem,max=1),
+             INTEGRATION    = SIMP(statut='f',typ='TXM',defaut="FPG4",into=("GAUSS","FPG2","FPG3","FPG4","FPG6",
+                                               "FPG7","NOEUD","SIMPSON","SIMPSON1","NCOTES","NCOTES1","NCOTES2") ),
+             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),
+             ITER_CONT_MAXI = SIMP(statut='f',typ='I',defaut=30),
+             ITER_GEOM_MAXI  =SIMP(statut='f',typ='I',defaut=0),
+
+             CONTACT_INIT   = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","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),
+             FROTTEMENT     = SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
+             GLISSIERE      = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             b_frotxfem    =BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramètres du frottement de Coulomb",
+               COULOMB        = SIMP(statut='o',typ='R',),
+               ITER_FROT_MAXI = SIMP(statut='f',typ='I',defaut=2),
+               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),
+               SEUIL_INIT     = SIMP(statut='f',typ='R',defaut=0.E+0),
+               ),
+           ),
+
+
+
+           b_verif         =BLOC(condition = "METHODE == 'VERIF' ",
+                                 fr="Paramètres de la méthode sans calcul de contact",
+                STOP_INTERP     =SIMP(statut='f',typ='TXM',defaut="NON",
+                                      into=("OUI","NON")),
+                TOLE_INTERP     =SIMP(statut='f',typ='R',defaut = 0.),
+
+                GROUP_MA_FOND   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           ),
+
+           b_active        =BLOC(condition = "METHODE == '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.),
+                                 ),
+
+                STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",
+                                      into=("OUI","NON")),
+                NB_RESOL        =SIMP(statut='f',typ='I', defaut=10 ),
+                REAC_GEOM       =SIMP(statut='f',typ='TXM',defaut="AUTOMATIQUE",
+                        into=("AUTOMATIQUE","CONTROLE","SANS")),
+
+                b_reac_geom     =BLOC(condition = "REAC_GEOM == 'CONTROLE' ",
+                                 fr="Paramètre de la réactualisation géométrique",
+                      NB_REAC_GEOM   =SIMP(statut='o',typ='I'),
+                                 ),
+
+                SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+
+           ),
+           b_lagrangien    =BLOC(condition = "METHODE == 'LAGRANGIEN' ",
+                                 fr="Paramètres de la méthode Lagrangienne (contact avec ou sans frottement)",
+                FROTTEMENT      =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
+                STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",
+                                      into=("OUI","NON")),
+                NB_RESOL        =SIMP(statut='f',typ='I', defaut=10 ),
+                ITER_MULT_MAXI  =SIMP(statut='f',typ='I'  ,defaut=4),
+
+                REAC_GEOM       =SIMP(statut='f',typ='TXM',defaut="AUTOMATIQUE",
+                                      into=("AUTOMATIQUE","CONTROLE","SANS")),
+
+                b_reac_geom     =BLOC(condition = "REAC_GEOM == 'CONTROLE' ",fr="Paramètre de la réactualisation géométrique",
+                      NB_REAC_GEOM   =SIMP(statut='o',typ='I'),
+
+                                 ),
+
+
+                SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+
+                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),
+                     ),),
+
+           b_penalisation       =BLOC(condition = "METHODE == 'PENALISATION' ",
+                                      fr="Paramètres de la méthode pénalisée (contact avec ou sans frottement)",
+                E_N             =SIMP(statut='f',typ='R'),
+                FROTTEMENT      =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
+                b_dualisation   =BLOC(condition = "E_N == None",
+                  STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",
+                                        into=("OUI","NON")),
+                  NB_RESOL        =SIMP(statut='f',typ='I', defaut=10 ),
+                  ITER_MULT_MAXI  =SIMP(statut='f',typ='I',defaut=4),
+                ),
+
+                REAC_GEOM       =SIMP(statut='f',typ='TXM',defaut="AUTOMATIQUE",
+                                      into=("AUTOMATIQUE","CONTROLE","SANS")),
+
+                b_reac_geom     =BLOC(condition = "REAC_GEOM == 'CONTROLE' ",fr="Paramètre de la réactualisation géométrique",
+                      NB_REAC_GEOM   =SIMP(statut='o',typ='I'),
+                                 ),
+
+                SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+
+
+
+                b_frottement    =BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramètres du frottement de Coulomb",
+                     COULOMB         =SIMP(statut='o',typ='R',),
+                     E_T             =SIMP(statut='o',typ='R',
+                                           fr="Active la pénalisation sur le frottement et définit le coefficient de pénalisation"),
+                     COEF_MATR_FROT  =SIMP(statut='f',typ='R',defaut=0.E+0),
+                     ),),
+
+           b_continue      =BLOC(condition = "METHODE == 'CONTINUE' ",
+                                 fr="Paramètres de la méthode continue (contact avec ou sans frottement)",
+#                regles=(UN_PARMI('GLISSIERE','FROTTEMENT'),),
+
+# -------------------------------- CHOIX DE LA FORMULATION DE LA METHODE CONTINUE
+                ALGO_CONT   =SIMP(statut='f',typ='TXM',defaut="LAGRANGIEN",into=("LAGRANGIEN","AUGMENTE","STABILISE"),),
+                b_CONT_LAGR =BLOC(condition = "ALGO_CONT == 'LAGRANGIEN' ",fr="Parametres de la formulation Lagrangienne",
+                                  COEF_REGU_CONT  =SIMP(statut='f',typ='R',defaut=100.E+0),),
+                b_CONT_STAB =BLOC(condition = "ALGO_CONT == 'STABILISE' ",fr="Parametres du Lagrangien stabilisé",
+                                  COEF_REGU_CONT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                  COEF_STAB_CONT  =SIMP(statut='f',typ='R',defaut=100.E+0),),
+                b_CONT_AUGM =BLOC(condition = "ALGO_CONT == 'AUGMENTE' ",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),),
+# --------------------------------
+                GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),),
+# --------------------------------
+                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),),
+# --------------------------------
+                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='**'),),
+# -------------------------------- MOTS-CLEF CONTACT
+                INTEGRATION      =SIMP(statut='f',typ='TXM',defaut="NOEUD",
+                                       into=("GAUSS","NOEUD","SIMPSON","SIMPSON1","SIMPSON2",
+                                             "NCOTES","NCOTES1","NCOTES2"),),
+                FORMULATION      =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE"),),
+
+                ITER_GEOM_MAXI   =SIMP(statut='f',typ='I',defaut=2),
+                ITER_CONT_MAXI   =SIMP(statut='f',typ='I',defaut=30),
+                CONTACT_INIT     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),),
+# -------------------------------- détection automatique et exclusion des noeuds impliqués dans le pivot nul
+                EXCLUSION_PIV_NUL=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),),
+# -------------------------------- exclusion manuelle des noeuds impliqués dans le pivot nul;
+#                                  prévaut sur la fonctionnalité précédente sans pour autant interférer avec elle
+                SANS_NOEUD    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                regles        =(EXCLUS('SANS_NOEUD','SANS_GROUP_NO'),),
+# -------------------------------- MOTS-CLEF FROTTEMENT
+                FROTTEMENT      =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
+                b_frottement    =BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramètres du frottement de Coulomb",
+                     ALGO_FROT       =SIMP(statut='f',typ='TXM',defaut="LAGRANGIEN",
+                                      into=("LAGRANGIEN","AUGMENTE","STABILISE") ),
+                     b_FROT_LAGR =BLOC(condition = "ALGO_FROT == 'LAGRANGIEN' ",fr="Parametres de la formulation Lagrangienne",
+                                       COEF_REGU_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),),
+                     b_FROT_STAB =BLOC(condition = "ALGO_FROT == 'STABILISE' ",fr="Parametres du Lagrangien stabilisé",
+                                       COEF_REGU_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),
+                                       COEF_STAB_FROT  =SIMP(statut='f',typ='R',defaut=100.E+0),),
+                     b_FROT_AUGM =BLOC(condition = "ALGO_FROT == 'AUGMENTE' ",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),),
+                     COULOMB            =SIMP(statut='o',typ='R',),
+                     SANS_NOEUD_FR    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                     SANS_GROUP_NO_FR =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                     regles             =(EXCLUS('SANS_NOEUD_FR','SANS_GROUP_NO_FR'),),
+                     b_sans_group_no_frot =BLOC(condition = "SANS_GROUP_NO_FR != None or SANS_NO_FR != None",
+                                                fr="Direction(s) de frottement à exclure",
+                                                EXCL_FROT_1 =SIMP(statut='f',typ='R',min=3,max=3),
+                                                EXCL_FROT_2 =SIMP(statut='f',typ='R',min=3,max=3),),
+                     ITER_FROT_MAXI =SIMP(statut='f',typ='I',defaut=2),
+                     SEUIL_INIT     =SIMP(statut='f',typ='R',defaut=0.E+0),
+                     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',),),),),
+
+           b_gcp        =BLOC(condition = "METHODE == 'GCP' ",
+                                 fr="Paramètres de la méthode du gradient conjugué projeté (contact uniquement)",
+                RESI_ABSO       =SIMP(statut='o',typ='R',
+                                      fr="Critère de convergence (niveau d'interpénétration autorisé)"),
+                REAC_ITER       =SIMP(statut='f',typ='I',defaut=20, fr="Fréquence de réinitialisation de la conjugaison"),
+                ITER_GCP_MAXI   =SIMP(statut='f',typ='I',defaut=0, fr="Nombre d'itérations maximal pour le GCP"),
+                REAC_GEOM       =SIMP(statut='f',typ='TXM',defaut="AUTOMATIQUE",
+                                      into=("AUTOMATIQUE","CONTROLE","SANS")),
+
+                b_reac_geom     =BLOC(condition = "REAC_GEOM == 'CONTROLE' ",fr="Paramètre de la réactualisation géométrique",
+                      NB_REAC_GEOM   =SIMP(statut='o',typ='I'),
+
+                                 ),
+                PRE_COND         =SIMP(statut='f',typ='TXM',defaut="SANS",
+                      into=("DIRICHLET","SANS"),fr="Choix d'un préconditionneur (accélère la convergence)"),
+                ITER_PRE_MAXI   =SIMP(statut='f',typ='I',defaut=0, fr="Nombre d'itérations maximal pour le préconditionneur"),
+                COEF_RESI       =SIMP(statut='f',typ='R',defaut = 1.,
+                                        fr="Critère_Convergence_Préconditionneur = COEF_RESI*Critère_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 linéaire",),
+                SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           ),
+         );
+
+
+
+#& MODIF COMMUN  DATE 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#            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.        
+# ======================================================================
+# RESPONSABLE REZETTE C.REZETTE
+def C_CONVERGENCE() : return FACT(statut='d',
+           regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),),
+           b_refe_rela    =BLOC(condition = "RESI_REFE_RELA != None",
+             regles=(AU_MOINS_UN('SIGM_REFE','EPSI_REFE','FLUX_THER_REFE','FORC_REFE',
+                                  'FLUX_HYD1_REFE','FLUX_HYD2_REFE','VARI_REFE','DEPL_REFE'),),
+             FORC_REFE       =SIMP(statut='f',typ='R',min=2,max=2,
+                fr="Force et Moment de référence pour les éléments de structure."),
+             SIGM_REFE       =SIMP(statut='f',typ='R'),
+             DEPL_REFE       =SIMP(statut='f',typ='R'),
+             EPSI_REFE       =SIMP(statut='f',typ='R'),
+             FLUX_THER_REFE  =SIMP(statut='f',typ='R'),
+             FLUX_HYD1_REFE  =SIMP(statut='f',typ='R'),
+             FLUX_HYD2_REFE  =SIMP(statut='f',typ='R'),
+             VARI_REFE       =SIMP(statut='f',typ='R'),
+           ),
+           RESI_REFE_RELA  =SIMP(statut='f',typ='R'),
+           RESI_GLOB_MAXI  =SIMP(statut='f',typ='R'),
+           RESI_GLOB_RELA  =SIMP(statut='f',typ='R'),
+           ITER_GLOB_MAXI  =SIMP(statut='f',typ='I',defaut=10),
+           ITER_GLOB_ELAS  =SIMP(statut='f',typ='I',defaut=25),
+           TYPE            =SIMP(statut='f',typ='TXM',defaut="PIC",into=("PIC","PLATEAU")),
+           b_plateau    =BLOC(condition = "TYPE == 'PLATEAU' ",
+
+             PLATEAU_ITER    =SIMP(statut='f',typ='I',defaut=3, val_min =2),
+             PLATEAU_RELA    =SIMP(statut='f',typ='R',defaut=1E-3),
+           ),
+
+
+           ARRET           =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+         );
+#& MODIF COMMUN  DATE 08/09/2009   AUTEUR SFAYOLLE S.FAYOLLE 
+#            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.        
+# ======================================================================
+# RESPONSABLE SFAYOLLE
+
+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 
+#            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.        
+# ======================================================================
+# RESPONSABLE REZETTE C.REZETTE
+def C_INCREMENT() : return FACT(statut='o',
+           regles=(EXCLUS('NUME_INST_INIT','INST_INIT'),
+                   EXCLUS('NUME_INST_FIN','INST_FIN'),),
+           LIST_INST       =SIMP(statut='o',typ=(listr8_sdaster,list_inst)),
+           NUME_INST_INIT  =SIMP(statut='f',typ='I'),
+           INST_INIT       =SIMP(statut='f',typ='R'),
+           NUME_INST_FIN   =SIMP(statut='f',typ='I'),
+           INST_FIN        =SIMP(statut='f',typ='R'),
+           ERRE_TEMPS      =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
+                                 fr="Adaptation temporelle pour les modélisations HM instationnaires",
+                                 ang="Time adaptation for unstationary HM models"),
+           PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-6 ),
+         );
+#& MODIF COMMUN  DATE 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#            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.        
+# ======================================================================
+# RESPONSABLE REZETTE C.REZETTE
+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") ),
+           MATRICE         =SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE") ),
+           PAS_MINI_ELAS   =SIMP(statut='f',typ='R',val_min=0.0),
+           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),
+           EVOL_NOLI       =SIMP(statut='f',typ=evol_noli),
+         );
+#& MODIF COMMUN  DATE 29/09/2009   AUTEUR GNICOLAS G.NICOLAS 
+#            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.        
+# ======================================================================
+# 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#
+                        "ACCE_ABSOLU",
+                        "ALPH0_ELGA_EPSP",
+                        "ALPHP_ELGA_ALPH0",
+                        "ARCO_ELNO_SIGM",
+                        "ARCO_NOEU_SIGM",
+                        "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",
+                        "DEPL",
+                        "DEPL_ABSOLU",
+                        "DESI_ELNO_DLSI",
+                        "DESI_NOEU_DLSI",
+                        "DETE_ELNO_DLTE",
+                        "DETE_NOEU_DLTE",
+                        "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",
+                        "ENDO_ELGA",
+                        "ENDO_ELNO_ELGA",
+                        "ENDO_ELNO_SIGA",
+                        "ENDO_ELNO_SINO",
+                        "ENDO_NOEU_SINO",
+                        "ENEL_ELGA",
+                        "ENEL_ELNO_ELGA",
+                        "ENEL_NOEU_ELGA",
+                        "EPEQ_ELNO_TUYO",
+                        "EPVC_ELGA",
+                        "EPVC_ELNO",
+                        "EPFD_ELGA",
+                        "EPFD_ELNO",
+                        "EPFP_ELGA",
+                        "EPFP_ELNO",
+                        "EPME_ELGA_DEPL",
+                        "EPME_ELNO_DEPL",
+                        "EPMG_ELGA_DEPL",
+                        "EPMG_ELNO_DEPL",
+                        "EPMG_NOEU_DEPL",
+                        "EPOT_ELEM_DEPL",
+                        "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",
+                        "EPSP_ELGA",
+                        "EPSP_ELNO",
+                        "EPSP_ELNO_ZAC",
+                        "EPSP_NOEU",
+                        "EPSP_NOEU_ZAC",
+                        "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",
+                        "QIRE_ELEM_SIGM",
+                        "QIRE_ELNO_ELEM",
+                        "QIRE_NOEU_ELEM",
+                        "QIZ1_ELEM_SIGM",
+                        "QIZ2_ELEM_SIGM",
+                        "SING_ELEM",
+                        "SING_ELNO_ELEM",
+                        "ETOT_ELEM",
+                        "ETOT_ELGA",
+                        "ETOT_ELNO_ELGA",
+                        "EXTR_ELGA_VARI",
+                        "EXTR_ELNO_VARI",
+                        "EXTR_NOEU_VARI",
+                        "FLUX_ELGA_TEMP",
+                        "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",
+                        "INDI_LOCA_ELGA",
+                        "INTE_ELNO_ACTI",
+                        "INTE_ELNO_REAC",
+                        "INTE_NOEU_ACTI",
+                        "INTE_NOEU_REAC",
+                        "IRRA",
+                        "LANL_ELGA",
+                        "META_ELGA_TEMP",
+                        "META_ELNO_TEMP",
+                        "META_NOEU_TEMP",
+                        "MODE_FLAMB",
+                        "PMPB_ELGA_SIEF",
+                        "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_ELGA_SIGM",
+                        "RADI_ELNO_SIGM",
+                        "RADI_NOEU_SIGM",
+                        "REAC_NODA",
+                        "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_ELNO_ZAC",
+                        "SIGM_NOEU_CART",
+                        "SIGM_NOEU_COQU",
+                        "SIGM_NOEU_DEPL",
+                        "SIGM_NOEU_SIEF",
+                        "SIGM_NOEU_ZAC",
+                        "SIGM_NOZ1_ELGA",
+                        "SIGM_NOZ2_ELGA",
+                        "SIPO_ELNO_DEPL",
+                        "SIPO_ELNO_SIEF",
+                        "SIPO_NOEU_DEPL",
+                        "SIPO_NOEU_SIEF",
+                        "SIRE_ELNO_DEPL",
+                        "SIRE_NOEU_DEPL",
+                        "SOUR_ELGA_ELEC",
+                        "TEMP",
+                        "THETA",
+                        "VALE_CONT",
+                        "VALE_NCOU_MAXI",
+                        "VARI_ELGA",
+                        "VARI_ELGA_ZAC",
+                        "VARI_ELNO",
+                        "VARI_ELNO_COQU",
+                        "VARI_ELNO_ELGA",
+                        "VARI_ELNO_TUYO",
+                        "VARI_NOEU",
+                        "VARI_NOEU_ELGA",
+                        "VITE",
+                        "VITE_ABSOLU",
+                        "VITE_VENT",
+                        )
+#& MODIF COMMUN  DATE 05/05/2009   AUTEUR DESROCHES X.DESROCHES 
+# 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.        
+# ======================================================================
+# ce fichier contient la liste des  noms des grandeurs de CODE_ASTER
+def C_NOM_GRANDEUR() : return  ( #COMMUN# 
+"ABSC_R",
+"ADRSJEVE",
+"ADRSJEVN",
+"CAARPO",
+"CACABL",
+"CACOQU",
+"CADISA",
+"CADISK",
+"CADISM",
+"CAFI_R",
+"CAGEBA",
+"CAGEPO",
+"CAGNBA",
+"CAGNPO",
+"CAMASS",
+"CAORIE",
+"CAPOUF",
+"CARCRI",
+"CASECT",
+"CHLI_R",
+"CODE_I",
+"COEH_F",
+"COEH_R",
+"COMPOR",
+"CORR_R",
+"CRRU_R",
+"DBEL_R",
+"DCEL_I",
+"DDLI_C",
+"DDLI_F",
+"DDLI_R",
+"DDLM_C",
+"DDLM_R",
+"DEPL_C",
+"DEPL_F",
+"DEPL_R",
+"DISS_R",
+"DOMMAG",
+"DURT_R",
+"ENER_R",
+"EPSI_F",
+"EPSI_R",
+"ERRE_R",
+"FACY_R",
+"FELECR",
+"FISS_R",
+"FLAPLA",
+"FLUN_F",
+"FLUN_R",
+"FLUX_F",
+"FLUX_R",
+"FORC_C",
+"FORC_F",
+"FORC_R",
+"FREQ_R",
+"FTHM_F",
+"FTHM_R",
+"G",
+"GEOM_R",
+"G_DEPL_R",
+"HARMON",
+"HYDR_R",
+"IMPE_C",
+"IMPE_F",
+"IMPE_R",
+"IND_LOCA",
+"INFC_R",
+"INST_R",
+"INTE_R",
+"INTLOC",
+"IRRA_R",
+"ITECREL",
+"ITEDEC",
+"J",
+"LISTMA",
+"MACOMP",
+"MASS_R",
+"MATE_F",
+"NBSP_I",
+"NEUT_F",
+"NEUT_I",
+"NEUT_K16",
+"NEUT_K24",
+"NEUT_K8",
+"NEUT_R",
+"NUMC_I",
+"NUMMOD",
+"ONDE_F",
+"ONDE_R",
+"PESA_R",
+"PILO_K",
+"PILO_R",
+"POSI",
+"PREC",
+"PRES_C",
+"PRES_F",
+"PRES_R",
+"RAYO_F",
+"RAYO_R",
+"RCCM_K",
+"RCCM_R",
+"RESCREL",
+"RICE_TRA",
+"ROTA_R",
+"SECTION",
+"SIEF_C",
+"SIEF_R",
+"SIZZ_R",
+"SOUR_F",
+"SOUR_R",
+"SPMA_R",
+"STAOUDYN",
+"TEMP_C",
+"TEMP_F",
+"TEMP_R",
+"THETA",
+"VALO_R",
+"VANL_R",
+"VAR2_R",
+"VARI_R",
+"VENTCX_F",
+"VNOR_C",
+"VNOR_F",
+"VOISIN",
+"WEIBULL",
+"XCONTAC",
+                                 )
+#& MODIF COMMUN  DATE 29/03/2007   AUTEUR GRANET S.GRANET 
+#            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.        
+# ======================================================================
+# ce fichier contient la liste des PARA possibles pour les fonctions et les nappes
+def C_PARA_FONCTION() : return  ( #COMMUN#
+                   "DX","DY","DZ","DRX","DRY","DRZ","TEMP","TSEC",
+                   "INST","X","Y","Z","EPSI","META","FREQ","PULS","DSP",
+                   "AMOR","ABSC","SIGM","HYDR","SECH","PORO","SAT",
+                   "PGAZ","PCAP","PLIQ","PVAP","PAD","VITE","ENDO",
+                   "NORM","EPAIS","NEUT1","NEUT2",)
+#& MODIF COMMUN  DATE 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#            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.        
+# ======================================================================
+# RESPONSABLE REZETTE C.REZETTE
+def C_RECH_LINEAIRE() : return FACT(statut='f',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="CORDE",into=("CORDE","MIXTE") ),
+           RESI_LINE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-1 ),
+           ITER_LINE_MAXI  =SIMP(statut='f',typ='I',defaut= 3,val_max=999),
+           ITER_LINE_CRIT  =SIMP(statut='f',typ='I',defaut= 20),
+           PAS_MINI_CRIT   =SIMP(statut='f',typ='R',defaut=0.0E+0),
+           RHO_MIN         =SIMP(statut='f',typ='R',defaut=1.0E-2),
+           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 22/09/2009   AUTEUR PROIX J-M.PROIX 
+#            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.        
+# ======================================================================
+# RESPONSABLE PROIX J.M.PROIX
+def C_RELATION() : return (             "ELAS",            # RESP. : PROIX J.M.PROIX   #COMMUN#
+                                        "ARME",            # RESP. : PEYRARD C.PEYRARD
+                                        "ASSE_CORN",       # RESP. : PEYRARD C.PEYRARD
+                                        "BARCELONE",       # RESP. : ELGHARIB J.ELGHARIB
+                                        "BETON_DOUBLE_DP", # RESP. : ELGHARIB J.ELGHARIB
+                                        "BETON_REGLE_PR",  # RESP. : NECS
+                                        "BETON_UMLV_FP",   # RESP. : LEPAPE Y.LEPAPE
+                                        "CAM_CLAY",        # RESP. : ELGHARIB J.ELGHARIB
+                                        "CJS",             # RESP. : CHAVANT C.CHAVANT
+                                        "CORR_ACIER",      # RESP. : LEPAPE Y.LEPAPE
+                                        "CZM_EXP_REG",     # RESP. : LAVERNE J.LAVERNE
+                                        "CZM_EXP",         # RESP. : LAVERNE J.LAVERNE
+                                        "CZM_LIN_REG",     # RESP. : LAVERNE J.LAVERNE
+                                        "CZM_OUV_MIX",     # RESP. : LAVERNE J.LAVERNE
+                                        "CZM_TAC_MIX",     # RESP. : LAVERNE J.LAVERNE
+                                        "CZM_FAT_MIX",     # RESP. : LAVERNE J.LAVERNE
+                                        "DIS_BILI_ELAS",   # RESP. : FLEJOU J.L.FLEJOU
+                                        "DIS_CHOC",        # RESP. : DEVESA G.DEVESA
+                                        "DIS_ECRO_CINE",   # RESP. : FLEJOU J.L.FLEJOU
+                                        "DIS_GOUJ2E_ELAS", # RESP. : ANGLES J.ANGLES
+                                        "DIS_GOUJ2E_PLAS", # RESP. : ANGLES J.ANGLES
+                                        "DIS_GRICRA",      # RESP. : FERNANDES R.FERNANDES
+                                        "DIS_VISC",        # RESP. : FLEJOU J.L.FLEJOU
+                                        "DRUCK_PRAGER",    # RESP. : FERNANDES R.FERNANDES
+                                        "DRUCK_PRAG_N_A",  # RESP. : FERNANDES R.FERNANDES
+                                        "VISC_DRUC_PRAG",  # RESP. : ELGHARIB J.ELGHARIB
+                                        "ELAS_GONF",       # RESP. : GRANET S.GRANET
+                                        "ELAS_HYPER",      # RESP. : ABBAS M.ABBAS
+                                        "ENDO_FRAGILE",    # RESP. : MICHEL S.MICHEL
+                                        "ENDO_ISOT_BETON", # RESP. : MICHEL S.MICHEL
+                                        "ENDO_ORTH_BETON", # RESP. : MICHEL S.MICHEL
+                                        "GATT_MONERIE",    # RESP. : DEBONNIERES P.DEBONNIERES
+                                        "GLRC_DAMAGE",     # RESP. : MARKOVIC D.MARKOVIC
+                                        "GLRC_DM",         # RESP. : MARKOVIC D.MARKOVIC
+                                        "GRANGER_FP_INDT", # RESP. : ROSPARS C.ROSPARS
+                                        "GRANGER_FP",      # RESP. : ROSPARS C.ROSPARS
+                                        "GRANGER_FP_V",    # RESP. : ROSPARS C.ROSPARS
+                                        "GRAN_IRRA_LOG",   # RESP. : FERNANDES R.FERNANDES
+                                        "GRILLE_CINE_LINE",# RESP. : ROSPARS C.ROSPARS
+                                        "GRILLE_ISOT_LINE",# RESP. : ROSPARS C.ROSPARS
+                                        "GRILLE_PINTO_MEN",# RESP. : ROSPARS C.ROSPARS
+                                        "HOEK_BROWN_EFF",  # RESP. : CHAVANT C.CHAVANT
+                                        "HOEK_BROWN",      # RESP. : CHAVANT C.CHAVANT
+                                        "HOEK_BROWN_TOT",  # RESP. : CHAVANT C.CHAVANT
+                                        "HUJEUX",          # RESP. : FOUCAULT A.FOUCAULT
+                                        "IRRAD3M",         # RESP. : FLEJOU J.L.FLEJOU
+                                        "JOINT_BA",        # RESP. : MICHEL S.MICHEL
+                                        "KIT_DDI",         # RESP. : CHAVANT C.CHAVANT
+                                        "KIT_HHM",         # RESP. : GRANET S.GRANET
+                                        "KIT_HH",          # RESP. : GRANET S.GRANET
+                                        "KIT_HM",          # RESP. : GRANET S.GRANET
+                                        "KIT_THHM",        # RESP. : GRANET S.GRANET
+                                        "KIT_THH",         # RESP. : GRANET S.GRANET
+                                        "KIT_THM",         # RESP. : GRANET S.GRANET
+                                        "KIT_THV",         # RESP. : GRANET S.GRANET
+                                        "LABORD_1D",       # RESP. : VOLDOIRE F.VOLDOIRE
+                                        "LAIGLE",          # RESP. : ELGHARIB J.ELGHARIB
+                                        "LEMAITRE_IRRA",   # RESP. : FERNANDES R.FERNANDES
+                                        "LEMAITRE",        # RESP. : DEBONNIERES P.DEBONNIERES
+                                        "LEMA_SEUIL",      # RESP. : LECLERC S.LECLERC
+                                        "LETK",            # RESP. : ELGHARIB J.ELGHARIB
+                                        "LMARC_IRRA",      # RESP. : FERNANDES R.FERNANDES
+                                        "LMARC",           # RESP. : None
+                                        "MAZARS",          # RESP. : MICHEL S.MICHEL
+                                        "META_LEMA_ANI",   # RESP. : CANO V.CANO
+                                        "META_P_CL_PT_RE", # RESP. : CANO V.CANO
+                                        "META_P_CL_PT",    # RESP. : CANO V.CANO
+                                        "META_P_CL_RE",    # RESP. : CANO V.CANO
+                                        "META_P_CL",       # RESP. : CANO V.CANO
+                                        "META_P_IL_PT_RE", # RESP. : CANO V.CANO
+                                        "META_P_IL_PT",    # RESP. : CANO V.CANO
+                                        "META_P_IL_RE",    # RESP. : CANO V.CANO
+                                        "META_P_IL",       # RESP. : CANO V.CANO
+                                        "META_P_INL_PT_RE",# RESP. : CANO V.CANO
+                                        "META_P_INL_PT",   # RESP. : CANO V.CANO
+                                        "META_P_INL_RE",   # RESP. : CANO V.CANO
+                                        "META_P_INL",      # RESP. : CANO V.CANO
+                                        "META_V_CL_PT_RE", # RESP. : CANO V.CANO
+                                        "META_V_CL_PT",    # RESP. : CANO V.CANO
+                                        "META_V_CL_RE",    # RESP. : CANO V.CANO
+                                        "META_V_CL",       # RESP. : CANO V.CANO
+                                        "META_V_IL_PT_RE", # RESP. : CANO V.CANO
+                                        "META_V_IL_PT",    # RESP. : CANO V.CANO
+                                        "META_V_IL_RE",    # RESP. : CANO V.CANO
+                                        "META_V_IL",       # RESP. : CANO V.CANO
+                                        "META_V_INL_PT_RE",# RESP. : CANO V.CANO
+                                        "META_V_INL_PT",   # RESP. : CANO V.CANO
+                                        "META_V_INL_RE",   # RESP. : CANO V.CANO
+                                        "META_V_INL",      # RESP. : CANO V.CANO
+                                        "MONOCRISTAL",     # RESP. : PROIX J.M.PROIX
+                                        "MULTIFIBRE",      # RESP. : FLEJOU J.L.FLEJOU
+                                        "NORTON_HOFF",     # RESP. : MICHEL S.MICHEL
+                                        "PINTO_MENEGOTTO", # RESP. : ROSPARS C.ROSPARS
+                                        "POLYCRISTAL",     # RESP. : PROIX J.M.PROIX
+                                        "ROUSSELIER",      # RESP. : CANO V.CANO
+                                        "ROUSS_PR",        # RESP. : PARROT A.PARROT
+                                        "ROUSS_VISC",      # RESP. : CANO V.CANO
+                                        "RUPT_FRAG",       # RESP. : LAVERNE J.LAVERNE
+                                        "SANS",            # RESP. : MICHEL S.MICHEL
+                                        "VENDOCHAB",       # RESP. : PROIX J.M.PROIX
+                                        "VISC_CIN1_CHAB",  # RESP. : PROIX J.M.PROIX
+                                        "VISC_CIN2_CHAB",  # RESP. : PROIX J.M.PROIX
+                                        "VISC_CIN2_MEMO",  # RESP. : PROIX J.M.PROIX
+                                        "VISC_IRRA_LOG",   # RESP. : FERNANDES R.FERNANDES
+                                        "VISC_ISOT_LINE",  # RESP. : MICHEL S.MICHEL
+                                        "VISC_ISOT_TRAC",  # RESP. : PROIX J.M.PROIX
+                                        "VISCOCHAB",       # RESP. : GENIAUT S.GENIAUT
+                                        "VISC_TAHERI",     # RESP. : TAHERI S.TAHERI
+                                        "VMIS_ASYM_LINE",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_CIN1_CHAB",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_CIN2_CHAB",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_CIN2_MEMO",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_CINE_LINE",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_ECMI_LINE",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_ECMI_TRAC",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_ISOT_LINE",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_ISOT_PUIS",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_ISOT_TRAC",  # RESP. : PROIX J.M.PROIX
+                                        "VMIS_POU_FLEJOU", # RESP. : FLEJOU J.L.FLEJOU
+                                        "VMIS_POU_LINE",   # RESP. : PROIX J.M.PROIX
+                                        "ZMAT",            # RESP. : PROIX J.M.PROIX
+                                        "IMPLEX_FRAG",     # RESP. : BARGELLINI R.BARGELLINI
+                                        "IMPLEX_ISOT_BETO",# RESP. : BARGELLINI R.BARGELLINI
+                                        "IMPLEX_ISOT_LINE",# RESP. : BARGELLINI R.BARGELLINI
+                                     ) 
+#& MODIF COMMUN  DATE 20/10/2009   AUTEUR BOITEAU O.BOITEAU 
+#            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.        
+# ======================================================================
+# RESPONSABLE REZETTE C.REZETTE
+def C_SOLVEUR() : return FACT(statut='d',
+           METHODE=SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","FETI","PETSC") ),
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt         =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' or METHODE=='FETI' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON","DECOUPE") ),
+           ),
+           b_gcpc         =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             FILTRAGE_MATRICE =SIMP(statut='f',typ='R',defaut=-1.0,),
+             MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+           b_feti          =BLOC(condition = "METHODE == 'FETI' ",fr="Paramètres de la méthode FETI 1",
+             PARTITION       =SIMP(statut='o',typ=sd_feti_sdaster),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.E-6,val_min=0.),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             REAC_RESI       =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             TYPE_REORTHO_DD =SIMP(statut='f',typ='TXM',defaut="GSM",into=("SANS","GS","GSM","IGSM") ),
+             NB_REORTHO_DD   =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             NB_REORTHO_INST =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             PRE_COND        =SIMP(statut='f',typ='TXM',defaut="LUMPE",into=("LUMPE","SANS") ),
+             SCALING         =SIMP(statut='f',typ='TXM',defaut="MULT",into=("SANS","MULT") ),
+             VERIF_SDFETI    =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+             TEST_CONTINU    =SIMP(statut='f',typ='R',defaut=1.E-8,val_min=0.),
+             INFO_FETI       =SIMP(statut='f',typ='TXM',defaut='FFFFFFFFFFFFFFFFFFFFFFFF'),
+             STOCKAGE_GI     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON","CAL") ),
+             NB_SD_PROC0     =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             ACCELERATION_SM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+
+
+           SYME            =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         );
+#& MODIF COMMUN  DATE 27/06/2005   AUTEUR D6BHHJP J.P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+#
+# ce fichier contient la liste des "into" possibles pour le mot cle TYPE_CHAM
+def C_TYPE_CHAM_INTO() : #COMMUN#
+   l=[]
+   for gd in C_NOM_GRANDEUR() :
+        for typ in ("ELEM","ELNO","ELGA","CART","NOEU") :
+             l.append(typ+"_"+gd)
+   return tuple(l)
+
+#& MODIF COMMANDE  DATE 22/09/2009   AUTEUR SELLENET N.SELLENET 
+#            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 FLEJOU J-L.FLEJOU
+AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op=  19,sd_prod=cara_elem,
+   fr="Affectation de caractéristiques à des éléments de structure",
+   reentrant='n',
+   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'),),
+   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") ),
+
+#  ============================================================================
+   POUTRE               = FACT(statut= 'f',max= '**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA'),),
+      MAILLE               = SIMP(statut= 'f',typ= ma  ,validators= NoRepeat(),max= '**'),
+      GROUP_MA             = SIMP(statut= 'f',typ= grma,validators= NoRepeat(),max= '**'),
+      SECTION              = SIMP(statut= 'o',typ= 'TXM' ,into= ("GENERALE","RECTANGLE","CERCLE") ),
+      PREC_AIRE            = SIMP(statut= 'f',typ= 'R',defaut= 0.01),
+      PREC_INERTIE         = SIMP(statut= 'f',typ= 'R',defaut= 0.1),
+      b_generale           = BLOC(condition = "SECTION == 'GENERALE'",
+         VARI_SECT            = SIMP(statut= 'f',typ= 'TXM',into= ("CONSTANT","HOMOTHETIQUE"),defaut= "CONSTANT"),
+         b_constant           = BLOC(condition = "VARI_SECT == 'CONSTANT'",
+            CARA                 = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 4 ,max= 15,
+                                       fr= "A,IY,IZ,JX sont des paramètres obligatoires",
+                                       into= ("A","IY","IZ","AY","AZ","EY","EZ","JX","RY","RZ","RT",
+                                             "JG","IYR2","IZR2","AI") ),
+            VALE                    = SIMP(statut= 'o',typ= 'R',min= 4 ,max= 15), ),
+         b_homothetique       = BLOC(condition = "VARI_SECT == 'HOMOTHETIQUE'",
+            CARA                 = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 8 ,max= 30,
+                                       fr= "A1,A2,IY1,IY2,IZ1,IZ2,JX1,JX2 sont des paramètres obligatoires",
+                                       into= ("A1","IY1","IZ1","AY1","AZ1","EY1","EZ1","JX1","RY1",
+                                             "RZ1","RT1","JG1","IYR21","IZR21","AI1",
+                                             "A2","IY2","IZ2","AY2","AZ2","EY2","EZ2","JX2","RY2",
+                                             "RZ2","RT2","JG2","IYR22","IZR22","AI2") ),
+            VALE                 = SIMP(statut= 'o',typ= 'R',min= 8 ,max= 30),),
+      ),
+      b_rectangle          = BLOC(condition = "SECTION == 'RECTANGLE'",
+         VARI_SECT            = SIMP(statut= 'f',typ= 'TXM',into= ("CONSTANT","HOMOTHETIQUE","AFFINE"),defaut= "CONSTANT"),
+         b_constant           = BLOC(condition = "VARI_SECT == 'CONSTANT'",
+            CARA                 = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 1 ,max= 4,
+                                       into= ("H","EP", "HY","HZ","EPY","EPZ") ),
+            VALE                 = SIMP(statut= 'o',typ= 'R',min= 1 ,max= 4), ),
+         b_homothetique       = BLOC(condition = "VARI_SECT == 'HOMOTHETIQUE'",
+            CARA                 = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 2 ,max= 8,
+                                       into= ("H1","HZ1","HY1","EP1","EPY1","EPZ1",
+                                          "H2","HZ2","HY2","EP2","EPY2","EPZ2") ),
+            VALE                 = SIMP(statut= 'o',typ= 'R',min= 2 ,max= 8), ),
+         b_affine             = BLOC(condition = "VARI_SECT == 'AFFINE'",
+            CARA                 = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 3 ,max= 6,
+                                       into= ("HY","EPY", "HZ1","EPZ1","HZ2","EPZ2") ),
+            VALE                 = SIMP(statut= 'o',typ= 'R',min= 3 ,max= 6), ),
+      ),
+      b_cercle             = BLOC(condition = "SECTION == 'CERCLE'",
+         VARI_SECT            = SIMP(statut= 'f',typ= 'TXM',into= ("CONSTANT","HOMOTHETIQUE"),defaut= "CONSTANT"),
+         b_constant           = BLOC(condition = "VARI_SECT == 'CONSTANT'",
+            CARA                 = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 1 ,max= 2,
+                                       fr= "R est un paramètre obligatoire",
+                                       into= ("R","EP") ),
+            VALE                 = SIMP(statut= 'o',typ= 'R',min= 1 ,max= 2), ),
+         b_homothetique       = BLOC(condition = "VARI_SECT == 'HOMOTHETIQUE'",
+            CARA                 = SIMP(statut= 'o',typ= 'TXM',validators= NoRepeat(),min= 2 ,max= 4,
+                                       fr= "R1, R2 sont des paramètres obligatoires",
+                                       into= ("R1","R2","EP1","EP2") ),
+            VALE                 = SIMP(statut= 'o',typ= 'R',min= 2 ,max= 4), ),
+         MODI_METRIQUE     = SIMP(statut= 'f',typ= 'TXM',defaut= "NON",into= ("OUI","NON") ),
+         FCX               = SIMP(statut= 'f',typ= (fonction_sdaster,nappe_sdaster,formule) ),
+         TUYAU_NSEC        = SIMP(statut= 'f',typ= 'I',val_max= 32,defaut= 16),
+         TUYAU_NCOU        = SIMP(statut= 'f',typ= 'I',val_max= 10,defaut= 3),
+      ),
+   ),
+
+#  ============================================================================
+   BARRE                = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA'),),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      SECTION              = SIMP(statut='o',typ='TXM',into=("GENERALE","RECTANGLE","CERCLE") ),
+      b_generale           = BLOC(condition = "SECTION=='GENERALE'",
+         CARA                 = SIMP(statut='o',typ='TXM',into=("A",) ),
+         VALE                 = SIMP(statut='o',typ='R',min=1,max=1 ), ),
+      b_rectangle          = BLOC(condition = "SECTION=='RECTANGLE'",
+         CARA                 = SIMP(statut='o',typ='TXM',
+                                    into=("H","EP","HZ","HY","EPY","EPZ"),
+                                    validators=NoRepeat(),min=1,max=4 ),
+         VALE                 = SIMP(statut='o',typ='R',min=1,max=4 ), ),
+      b_cercle             =  BLOC(condition = "SECTION=='CERCLE'",
+         CARA                 = SIMP(statut='o',typ='TXM',validators=NoRepeat(),min=1,max=2,into=("R","EP") ),
+         VALE                 = SIMP(statut='o',typ='R',min=1,max=2 ), ),
+      FCX                  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+   ),
+
+#  ============================================================================
+   COQUE                = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA' ),
+                              PRESENT_PRESENT( 'EXCENTREMENT','INER_ROTA' ),
+                              AU_MOINS_UN('EPAIS','EPAIS_F',),
+                              PRESENT_ABSENT('EPAIS','EPAIS_F',),
+                              EXCLUS('ANGL_REP','VECTEUR'),),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      EPAIS                = SIMP(statut='f',typ='R' ),
+      EPAIS_F              = SIMP(statut='f',typ=(para_sensi,),min=1 ,max=1 ),
+      ANGL_REP             = SIMP(statut='f',typ='R',min=2,max=2),
+      VECTEUR              = SIMP(statut='f',typ='R',min=3,max=3),
+      A_CIS                = SIMP(statut='f',typ='R',defaut= 0.8333333E0),
+      COEF_RIGI_DRZ        = SIMP(statut='f',typ='R',defaut= 1.0E-5 ),
+      COQUE_NCOU           = SIMP(statut='f',typ='I',defaut= 1 ),
+      EXCENTREMENT         = SIMP(statut='f',typ='R' ),
+      INER_ROTA            = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+      MODI_METRIQUE        = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+   ),
+
+#  ============================================================================
+   CABLE                = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA'),),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      N_INIT               = SIMP(statut='f',typ='R',defaut= 5000. ),
+      SECTION              = SIMP(statut='f',typ='R' ),
+      FCX                  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+   ),
+
+#  ============================================================================
+   DISCRET              = FACT(statut='f',max='**',
+      REPERE               = SIMP(statut='f',typ='TXM',into=("LOCAL","GLOBAL") ),
+      AMOR_HYST            = SIMP(statut='f',typ='R' ),
+
+      SYME                 = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),),
+      b_SYME_OUI           = BLOC(condition="SYME=='OUI'",
+         fr="SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+         CARA                 = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
+            into=("K_T_D_N", "K_T_D_L", "K_TR_D_N", "K_TR_D_L", "K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
+                  "M_T_D_N",            "M_TR_D_N",             "M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
+                  "A_T_D_N", "A_T_D_L", "A_TR_D_N", "A_TR_D_L", "A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
+         #  Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE
+         b_AK_T_D_N            = BLOC(condition = "((CARA=='K_T_D_N')or(CARA=='A_T_D_N'))",
+            fr="NOEUD: 3 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=3 ,max=3 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
+         b_AK_T_D_L            = BLOC(condition = "((CARA=='K_T_D_L')or(CARA=='A_T_D_L'))",
+            fr="SEGMENT: 3 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=3 ,max=3 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
+         b_AK_TR_D_N           = BLOC(condition = "((CARA=='K_TR_D_N')or(CARA=='A_TR_D_N'))",
+            fr="NOEUD: 6 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=6 ,max=6 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
+         b_AK_TR_D_L           = BLOC(condition = "((CARA=='K_TR_D_L')or(CARA=='A_TR_D_L'))",
+            fr="SEGMENT: 6 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=6 ,max=6 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
+         b_MAK_T_N              = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
+            fr="NOEUD: 6 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=6 ,max=6 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
+         b_MAK_T_L              = BLOC(condition = "((CARA=='K_T_L')or(CARA=='A_T_L')or(CARA=='M_T_L'))",
+            fr="SEGMENT: 21 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=21,max=21),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
+         b_MAK_TR_N             = BLOC(condition = "((CARA=='K_TR_N')or(CARA=='A_TR_N')or(CARA=='M_TR_N'))",
+            fr="NOEUD: 21 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=21,max=21),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
+         b_MAK_TR_L             = BLOC(condition = "((CARA=='K_TR_L')or(CARA=='A_TR_L')or(CARA=='M_TR_L'))",
+            fr="SEGMENT: 78 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=78,max=78),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=78 ,max=78 ),),
+         #  Affection des caractéristiques de MASSE
+         b_M_T_D_N           = BLOC(condition = "(CARA=='M_T_D_N')",
+            fr="NOEUD: 1 valeur de masse",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=1 ,max=1 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=1 ,max=1 ),),
+         b_M_TR_D_N           = BLOC(condition = "(CARA=='M_TR_D_N')",
+            fr="NOEUD: 1 valeur de masse, 6 valeurs du tenseur d'inertie, 3 composantes du vecteur d'excentrement",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=10,max=10),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),),
+      ),
+      #     éléments à matrice non-symétrique
+      #        b_MAK_T_N_NS       'K_T_N'     'A_T_N'    'M_T_N'
+      #        b_MAK_T_L_NS       'K_T_L'     'A_T_L'    'M_T_L'
+      #        b_MAK_TR_N_NS      'K_TR_N'    'A_TR_N'   'M_TR_N'
+      #        b_MAK_TR_L_NS      'K_TR_L'    'A_TR_L'   'M_TR_L'
+      b_SYME_NON           = BLOC(condition="SYME=='NON'",
+         fr="NON-SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+         CARA                 = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
+            into=("K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
+                  "M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
+                  "A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
+         #  Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE : NON-SYMETRIQUE
+         b_MAK_T_N_NS           = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
+            fr="NOEUD: 9 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=9 ,max=9 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=9 ,max=9 ),),
+         b_MAK_T_L_NS           = BLOC(condition = "((CARA=='K_T_L')or(CARA=='A_T_L')or(CARA=='M_T_L'))",
+            fr="SEGMENT: 36 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=36,max=36),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=36 ,max=36 ),),
+         b_MAK_TR_N_NS          = BLOC(condition = "((CARA=='K_TR_N')or(CARA=='A_TR_N')or(CARA=='M_TR_N'))",
+            fr="NOEUD: 36 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=36,max=36),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=36 ,max=36 ),),
+         b_MAK_TR_L_NS          = BLOC(condition = "((CARA=='K_TR_L')or(CARA=='A_TR_L')or(CARA=='M_TR_L'))",
+            fr="SEGMENT: 144 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=144,max=144),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=144 ,max=144 ),),
+      ),
+   ),
+#  ============================================================================
+   DISCRET_2D           = FACT(statut='f',max='**',
+      REPERE               = SIMP(statut='f',typ='TXM',into=("LOCAL","GLOBAL") ),
+      AMOR_HYST            = SIMP(statut='f',typ='R' ),
+      SYME                 = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),),
+      b_SYME_OUI           = BLOC(condition="SYME=='OUI'",
+         fr="SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+         CARA                 = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
+            into=("K_T_D_N", "K_T_D_L", "K_TR_D_N", "K_TR_D_L", "K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
+                  "M_T_D_N",            "M_TR_D_N",             "M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
+                  "A_T_D_N", "A_T_D_L", "A_TR_D_N", "A_TR_D_L", "A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
+         #  Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE
+         b_AK_T_D_N            = BLOC(condition = "((CARA=='K_T_D_N')or(CARA=='A_T_D_N'))",
+            fr="NOEUD: 2 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=2 ,max=2 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=2 ,max=2 ),),
+         b_AK_T_D_L            = BLOC(condition = "((CARA=='K_T_D_L')or(CARA=='A_T_D_L'))",
+            fr="SEGMENT: 2 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=2 ,max=2 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=2 ,max=2 ),),
+         b_AK_TR_D_N           = BLOC(condition = "((CARA=='K_TR_D_N')or(CARA=='A_TR_D_N'))",
+            fr="NOEUD: 3 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=3 ,max=3 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
+         b_AK_TR_D_L           = BLOC(condition = "((CARA=='K_TR_D_L')or(CARA=='A_TR_D_L'))",
+            fr="SEGMENT: 3 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=3 ,max=3 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
+         b_MAK_T_N              = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
+            fr="NOEUD: 3 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=3 ,max=3 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
+         b_MAK_T_L              = BLOC(condition = "((CARA=='K_T_L')or(CARA=='A_T_L')or(CARA=='M_T_L'))",
+            fr="SEGMENT: 10 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=10,max=10),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),),
+         b_MAK_TR_N             = BLOC(condition = "((CARA=='K_TR_N')or(CARA=='A_TR_N')or(CARA=='M_TR_N'))",
+            fr="NOEUD: 6 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=6 ,max=6),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
+         b_MAK_TR_L             = BLOC(condition = "((CARA=='K_TR_L')or(CARA=='A_TR_L')or(CARA=='M_TR_L'))",
+            fr="SEGMENT: 21 valeurs (triangulaire supérieure par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=21,max=21),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
+         #  Affection des caractéristiques de MASSE
+         b_M_T_D_N            = BLOC(condition = "(CARA=='M_T_D_N')",
+            fr="NOEUD: 1 valeur de masse",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=1 ,max=1 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=1 ,max=1 ),),
+         b_M_TR_D_N           = BLOC(condition = "(CARA=='M_TR_D_N')",
+            fr="NOEUD: 1 valeur de masse (m), 1 valeur d'inertie (Izz), 2 composantes du vecteur d'excentrement",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=4 ,max=4 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=4 ,max=4 ),),
+      ),
+      #     éléments à matrice non-symétrique
+      #        b_MAK_T_N_NS       'K_T_N'     'A_T_N'    'M_T_N'
+      #        b_MAK_T_L_NS       'K_T_L'     'A_T_L'    'M_T_L'
+      #        b_MAK_TR_N_NS      'K_TR_N'    'A_TR_N'   'M_TR_N'
+      #        b_MAK_TR_L_NS      'K_TR_L'    'A_TR_L'   'M_TR_L'
+      b_SYME_NON           = BLOC(condition="SYME=='NON'",
+         fr="NON-SYMETRIQUE: Affectation de matrices de rigidité, de masse ou d'amortissement à des mailles ou noeuds",
+         CARA                 = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,defaut="None",
+            into=("K_T_N", "K_T_L", "K_TR_N", "K_TR_L",
+                  "M_T_N", "M_T_L", "M_TR_N", "M_TR_L",
+                  "A_T_N", "A_T_L", "A_TR_N", "A_TR_L",),),
+         #  Affection des caractéristiques de RIGIDITE/AMORTISSEMENT/MASSE : NON-SYMETRIQUE
+         b_MAK_T_N_NS           = BLOC(condition = "((CARA=='K_T_N')or(CARA=='A_T_N')or(CARA=='M_T_N'))",
+            fr="NOEUD: 4 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=4 ,max=4 ),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=4 ,max=4 ),),
+         b_MAK_T_L_NS           = BLOC(condition = "((CARA=='K_T_L')or(CARA=='A_T_L')or(CARA=='M_T_L'))",
+            fr="SEGMENT: 16 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=16,max=16),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=16 ,max=16 ),),
+         b_MAK_TR_N_NS          = BLOC(condition = "((CARA=='K_TR_N')or(CARA=='A_TR_N')or(CARA=='M_TR_N'))",
+            fr="NOEUD: 9 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=9 ,max=9),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=9 ,max=9 ),),
+         b_MAK_TR_L_NS          = BLOC(condition = "((CARA=='K_TR_L')or(CARA=='A_TR_L')or(CARA=='M_TR_L'))",
+            fr="SEGMENT: 36 valeurs (matrice pleine par colonne)",
+            regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                                    UN_PARMI('VALE','VALE_F'),),
+            MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+            GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+            VALE                 = SIMP(statut='f',typ='R',min=36,max=36),
+            VALE_F               = SIMP(statut='f',typ=(para_sensi,),min=36 ,max=36 ),),
+      ),
+   ),
+#  ============================================================================
+   ORIENTATION          = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO' ),),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      NOEUD                = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+      GROUP_NO             = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+      CARA                 = SIMP(statut='o',typ='TXM',
+                                 into=("VECT_Y","ANGL_VRIL","VECT_X_Y","ANGL_NAUT","GENE_TUYAU") ),
+      VALE                 = SIMP(statut='o',typ='R',max='**'),
+      PRECISION            = SIMP(statut='f',typ='R',defaut= 1.0E-4 ),
+      CRITERE              = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+   ),
+
+# ============================================================================
+   DEFI_ARC             = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                              UN_PARMI('ORIE_ARC','CENTRE','NOEUD_CENTRE','GROUP_NO_CENTRE',
+                                       'POIN_TANG','NOEUD_POIN_TANG','GROUP_NO_POIN_TG'),
+                              PRESENT_PRESENT('ORIE_ARC','RAYON'),
+                              EXCLUS('COEF_FLEX','COEF_FLEX_XY'),
+                              EXCLUS('COEF_FLEX','COEF_FLEX_XZ'),
+                              EXCLUS('INDI_SIGM','INDI_SIGM_XY'),
+                              EXCLUS('INDI_SIGM','INDI_SIGM_XZ'),
+                              PRESENT_PRESENT('COEF_FLEX_XY','COEF_FLEX_XZ'),
+                              PRESENT_PRESENT('INDI_SIGM_XY','INDI_SIGM_XZ'),),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      ORIE_ARC             = SIMP(statut='f',typ='R'),
+      CENTRE               = SIMP(statut='f',typ='R',max='**'),
+      NOEUD_CENTRE         = SIMP(statut='f',typ=no),
+      GROUP_NO_CENTRE      = SIMP(statut='f',typ=grno),
+      POIN_TANG            = SIMP(statut='f',typ='R',max='**'),
+      NOEUD_POIN_TANG      = SIMP(statut='f',typ=no),
+      GROUP_NO_POIN_TG     = SIMP(statut='f',typ=grno),
+      RAYON                = SIMP(statut='f',typ='R'),
+      COEF_FLEX            = SIMP(statut='f',typ='R'),
+      INDI_SIGM            = SIMP(statut='f',typ='R'),
+      COEF_FLEX_XY         = SIMP(statut='f',typ='R'),
+      INDI_SIGM_XY         = SIMP(statut='f',typ='R'),
+      COEF_FLEX_XZ         = SIMP(statut='f',typ='R'),
+      INDI_SIGM_XZ         = SIMP(statut='f',typ='R'),
+      PRECISION            = SIMP(statut='f',typ='R',defaut= 1.0E-3),
+      CRITERE              = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+   ),
+
+#============================================================================
+   MASSIF               = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                              UN_PARMI('ANGL_REP','ANGL_AXE','ANGL_EULER'),
+                              EXCLUS('ANGL_REP','ANGL_EULER'),
+                              EXCLUS('ANGL_REP','ANGL_AXE'),
+                              EXCLUS('ANGL_REP','ORIG_AXE'),
+                              PRESENT_PRESENT('ANGL_AXE','ORIG_AXE'), ),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      ANGL_REP             = SIMP(statut='f',typ='R',max=3),
+      ANGL_EULER           = SIMP(statut='f',typ='R',min=3,max=3),
+      ANGL_AXE             = SIMP(statut='f',typ='R',max=2),
+      ORIG_AXE             = SIMP(statut='f',typ='R',max=3),
+   ),
+
+#  ============================================================================
+   POUTRE_FLUI          = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA'),),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      B_T                  = SIMP(statut='o',typ='R'),
+      B_N                  = SIMP(statut='o',typ='R'),
+      B_TN                 = SIMP(statut='o',typ='R',defaut= 0.E+0 ),
+      A_FLUI               = SIMP(statut='o',typ='R'),
+      A_CELL               = SIMP(statut='o',typ='R'),
+      COEF_ECHELLE         = SIMP(statut='o',typ='R'),
+   ),
+
+#  ============================================================================
+   GRILLE               = FACT(statut='f',max='**',
+      regles               = (UN_PARMI('MAILLE','GROUP_MA'),
+                              EXCLUS('ANGL_REP','ORIG_AXE'),
+                              ENSEMBLE('ORIG_AXE','AXE')),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      SECTION              = SIMP(statut='o',typ='R'),
+      ANGL_REP             = SIMP(statut='f',typ='R',max=2),
+      EXCENTREMENT         = SIMP(statut='f',typ='R'),
+      ORIG_AXE             = SIMP(statut='f',typ='R',max='**'),
+      AXE                  = SIMP(statut='f',typ='R',max='**'),
+      COEF_RIGI_DRZ        = SIMP(statut='f',typ='R',defaut= 1.0E-10 ),
+      GRILLE_NCOU          = SIMP(statut='f',typ='I',defaut= 1,),
+   ),
+
+#============================================================================
+   RIGI_PARASOL         = FACT(statut='f',max='**',
+      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='**',
+         fr="Surface servant à répartir les caractéristiques des discrets"),
+      GROUP_MA_POI1        = SIMP(statut='f',typ=ma,validators=NoRepeat(),max=1,
+         fr="Mailles de type point correspondant aux discrets"),
+      GROUP_MA_SEG2        = SIMP(statut='f',typ=ma,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='**'),
+      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),
+      EUROPLEXUS           = SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON"),
+   ),
+
+#============================================================================
+   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),
+      FREQ_EXTR            = SIMP(statut='o',typ='R',max=1),
+      UNITE_RESU_IMPE      = SIMP(statut='f',typ='I',defaut=30),
+   ),
+
+#============================================================================
+   GEOM_FIBRE           = SIMP(statut='f',max=1,typ=gfibre_sdaster,
+      fr="Donner le nom de la SD regroupant tous les groupes de fibres (issue de DEFI_GEOM_FIBRE)"),
+   MULTIFIBRE           = FACT(statut='f',max='**',
+      regles               = (AU_MOINS_UN('GROUP_MA','MAILLE'),),
+      GROUP_MA             = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+      MAILLE               = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+      GROUP_FIBRE          = SIMP(statut='o',typ='TXM',max='**'),
+   ),
+);
+#& MODIF COMMANDE  DATE 16/09/2008   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.
+# ======================================================================
+# RESPONSABLE None
+AFFE_CHAR_ACOU=OPER(nom="AFFE_CHAR_ACOU",op=  68,sd_prod=char_acou,
+                    fr="Affectation de charges et conditions aux limites acoustiques constantes",
+                    reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+         regles=(AU_MOINS_UN('PRES_IMPO','VITE_FACE','IMPE_FACE','LIAISON_UNIF' ),),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         VERI_DDL        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         METHODE         =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les pressions imposées",
+                               into=('DUALISATION',),defaut='DUALISATION',),
+                               # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+         PRES_IMPO       =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           PRES            =SIMP(statut='o',typ='C' ),
+         ),
+         VITE_FACE       =FACT(statut='f',max='**',
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     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='**'),
+           VNOR            =SIMP(statut='o',typ='C' ),
+         ),
+         IMPE_FACE       =FACT(statut='f',max='**',
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     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='**'),
+           IMPE            =SIMP(statut='o',typ='C' ),
+         ),
+         LIAISON_UNIF    =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE' ),),
+           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='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           DDL             =SIMP(statut='o',typ='TXM',max='**'),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def affe_char_cine_prod(MECA_IMPO,THER_IMPO,ACOU_IMPO,EVOL_IMPO,**args):
+  if MECA_IMPO != None  : return char_cine_meca
+  if THER_IMPO != None  : return char_cine_ther
+  if ACOU_IMPO != None  : return char_cine_acou
+  if EVOL_IMPO != None  :
+      if AsType(EVOL_IMPO) in (evol_elas,evol_noli) :
+          return char_cine_meca
+      elif AsType(EVOL_IMPO) in (evol_ther,) :
+          return char_cine_ther
+      else :
+          raise AsException("Extension à faire ...")
+
+  raise AsException("type de concept resultat non prevu")
+
+
+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",
+                     reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+         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',
+                               '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','DCX','DCY','DCZ',
+                               'H1X','H1Y','H1Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
+                               'E3X','E3Y','E3Z','E4X','E4Y','E4Z','V11','V12','V13','V21','V22',
+                               'V23','V31','V32','V33','PRES11','PRES12','PRES13','PRES21',
+                               'PRES22','PRES23','PRES31','PRES32','PRES33'),),
+             TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+             DX              =SIMP(statut='f',typ='R' ),
+             DY              =SIMP(statut='f',typ='R' ),
+             DZ              =SIMP(statut='f',typ='R' ),
+             DRX             =SIMP(statut='f',typ='R' ),
+             DRY             =SIMP(statut='f',typ='R' ),
+             DRZ             =SIMP(statut='f',typ='R' ),
+             GRX             =SIMP(statut='f',typ='R' ),
+             PRES            =SIMP(statut='f',typ='R' ),
+             PHI             =SIMP(statut='f',typ='R' ),
+             TEMP            =SIMP(statut='f',typ='R' ),
+             PRE1            =SIMP(statut='f',typ='R' ),
+             PRE2            =SIMP(statut='f',typ='R' ),
+             UI2             =SIMP(statut='f',typ='R' ),
+             UI3             =SIMP(statut='f',typ='R' ),
+             UI4             =SIMP(statut='f',typ='R' ),
+             UI5             =SIMP(statut='f',typ='R' ),
+             UI6             =SIMP(statut='f',typ='R' ),
+             UO2             =SIMP(statut='f',typ='R' ),
+             UO3             =SIMP(statut='f',typ='R' ),
+             UO4             =SIMP(statut='f',typ='R' ),
+             UO5             =SIMP(statut='f',typ='R' ),
+             UO6             =SIMP(statut='f',typ='R' ),
+             VI2             =SIMP(statut='f',typ='R' ),
+             VI3             =SIMP(statut='f',typ='R' ),
+             VI4             =SIMP(statut='f',typ='R' ),
+             VI5             =SIMP(statut='f',typ='R' ),
+             VI6             =SIMP(statut='f',typ='R' ),
+             VO2             =SIMP(statut='f',typ='R' ),
+             VO3             =SIMP(statut='f',typ='R' ),
+             VO4             =SIMP(statut='f',typ='R' ),
+             VO5             =SIMP(statut='f',typ='R' ),
+             VO6             =SIMP(statut='f',typ='R' ),
+             WI2             =SIMP(statut='f',typ='R' ),
+             WI3             =SIMP(statut='f',typ='R' ),
+             WI4             =SIMP(statut='f',typ='R' ),
+             WI5             =SIMP(statut='f',typ='R' ),
+             WI6             =SIMP(statut='f',typ='R' ),
+             WO2             =SIMP(statut='f',typ='R' ),
+             WO3             =SIMP(statut='f',typ='R' ),
+             WO4             =SIMP(statut='f',typ='R' ),
+             WO5             =SIMP(statut='f',typ='R' ),
+             WO6             =SIMP(statut='f',typ='R' ),
+             WO              =SIMP(statut='f',typ='R' ),
+             WI1             =SIMP(statut='f',typ='R' ),
+             WO1             =SIMP(statut='f',typ='R' ),
+             GONF            =SIMP(statut='f',typ='R' ),
+             DCX             =SIMP(statut='f',typ='R' ),
+             DCY             =SIMP(statut='f',typ='R' ),
+             DCZ             =SIMP(statut='f',typ='R' ),
+             H1X             =SIMP(statut='f',typ='R' ),
+             H1Y             =SIMP(statut='f',typ='R' ),
+             H1Z             =SIMP(statut='f',typ='R' ),
+             E1X             =SIMP(statut='f',typ='R' ),
+             E1Y             =SIMP(statut='f',typ='R' ),
+             E1Z             =SIMP(statut='f',typ='R' ),
+             E2X             =SIMP(statut='f',typ='R' ),
+             E2Y             =SIMP(statut='f',typ='R' ),
+             E2Z             =SIMP(statut='f',typ='R' ),
+             E3X             =SIMP(statut='f',typ='R' ),
+             E3Y             =SIMP(statut='f',typ='R' ),
+             E3Z             =SIMP(statut='f',typ='R' ),
+             E4X             =SIMP(statut='f',typ='R' ),
+             E4Y             =SIMP(statut='f',typ='R' ),
+             E4Z             =SIMP(statut='f',typ='R' ),
+             V11             =SIMP(statut='f',typ='R' ),
+             V12             =SIMP(statut='f',typ='R' ),
+             V13             =SIMP(statut='f',typ='R' ),
+             V21             =SIMP(statut='f',typ='R' ),
+             V22             =SIMP(statut='f',typ='R' ),
+             V23             =SIMP(statut='f',typ='R' ),
+             V31             =SIMP(statut='f',typ='R' ),
+             V32             =SIMP(statut='f',typ='R' ),
+             V33             =SIMP(statut='f',typ='R' ),
+             PRES11          =SIMP(statut='f',typ='R' ),
+             PRES12          =SIMP(statut='f',typ='R' ),
+             PRES13          =SIMP(statut='f',typ='R' ),
+             PRES21          =SIMP(statut='f',typ='R' ),
+             PRES22          =SIMP(statut='f',typ='R' ),
+             PRES23          =SIMP(statut='f',typ='R' ),
+             PRES31          =SIMP(statut='f',typ='R' ),
+             PRES32          =SIMP(statut='f',typ='R' ),
+             PRES33          =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'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TEMP_SUP        =SIMP(statut='f',typ='R' ),
+           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",) ),
+           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='**'),
+           PRES            =SIMP(statut='o',typ='C' ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def affe_char_cine_f_prod(MECA_IMPO,THER_IMPO,**args):
+  if MECA_IMPO != None  : return char_cine_meca
+  if THER_IMPO != None  : return char_cine_ther
+  raise AsException("type de concept resultat non prevu")
+
+AFFE_CHAR_CINE_F=OPER(nom="AFFE_CHAR_CINE_F",op= 101,sd_prod=affe_char_cine_f_prod,
+                      fr="Affectation de conditions aux limites cinématiques fonction d'un (ou plusieurs) paramètres"
+                        +" pour un traitement sans dualisation",
+                     reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+         regles=(UN_PARMI('MECA_IMPO','THER_IMPO')),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         MECA_IMPO       =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
+                   AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','TEMP','PHI'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           DX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRY             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRZ             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           GRX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRES            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PHI             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         THER_IMPO       =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
+                   AU_MOINS_UN('TEMP','TEMP_INF','TEMP_SUP' ),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TEMP_SUP        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_INF        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 DESROCHES X.DESROCHES
+AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op=   7,sd_prod=char_meca,
+                    fr="Affectation de charges et conditions aux limites mécaniques constantes",
+                     reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+         regles=(AU_MOINS_UN('DDL_IMPO','FACE_IMPO','CHAMNO_IMPO','LIAISON_DDL','LIAISON_XFEM','FORCE_NODALE',
+                             'FORCE_FACE','FORCE_ARETE','FORCE_CONTOUR','FORCE_INTERNE',
+                             'PRES_REP','FORCE_POUTRE','FORCE_COQUE','LIAISON_OBLIQUE',
+                             'FORCE_ELEC','INTE_ELEC','PESANTEUR','ROTATION','IMPE_FACE',
+                             'VITE_FACE','RELA_CINE_BP','EPSI_INIT','CONTACT',
+                             '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',
+                             'LIAISON_UNILATER'),
+                         ),
+         VERI_NORM       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+         EVOL_CHAR       =SIMP(statut='f',fr="Champ de pression issu d'un autre calcul",
+                               typ=evol_char ),
+
+         PESANTEUR       =SIMP(statut='f',typ='R',fr="Champ de pesanteur",min=4,max=4),
+         METHODE         =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les déplacements imposés",
+                               into=('DUALISATION',),defaut='DUALISATION',),
+                               # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+         ROTATION        =SIMP(statut='f',typ='R',fr="Champ de rotation", min=4,max=4),
+         b_rotation      =BLOC ( condition = "ROTATION != None",
+           CENTRE          =SIMP(statut='f',typ='R',defaut=(0.,0.,0.),max=3),),
+
+         DDL_IMPO        =FACT(statut='f',max='**',
+             fr="Impose à des noeuds une ou plusieurs valeurs de déplacement (ou de certaines grandeurs asscociées)",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
+                     AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
+                                 'TEMP','PRE1','PRE2','UI2','UI3','VI2','VI3','WI2','WI3','UO2',
+                                 'UO3','VO2','VO3','WO2','WO3','UI4','UI5','VI4','VI5','WI4',
+                                 'WI5','UO4','UO5','VO4','VO5','WO4','WO5','UI6','UO6','VI6',
+                                 'VO6','WI6','WO6','WO','WI1','WO1','GONF','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',),),
+             TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             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='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             LIAISON         =SIMP(statut='f',typ='TXM',into=('ENCASTRE',)),
+             DX              =SIMP(statut='f',typ='R' ),
+             DY              =SIMP(statut='f',typ='R' ),
+             DZ              =SIMP(statut='f',typ='R' ),
+             DRX             =SIMP(statut='f',typ='R' ),
+             DRY             =SIMP(statut='f',typ='R' ),
+             DRZ             =SIMP(statut='f',typ='R' ),
+             GRX             =SIMP(statut='f',typ='R' ),
+             PRES            =SIMP(statut='f',typ='R' ),
+             PHI             =SIMP(statut='f',typ='R' ),
+             TEMP            =SIMP(statut='f',typ='R' ),
+             PRE1            =SIMP(statut='f',typ='R' ),
+             PRE2            =SIMP(statut='f',typ='R' ),
+             UI2             =SIMP(statut='f',typ='R' ),
+             UI3             =SIMP(statut='f',typ='R' ),
+             UI4             =SIMP(statut='f',typ='R' ),
+             UI5             =SIMP(statut='f',typ='R' ),
+             UI6             =SIMP(statut='f',typ='R' ),
+             UO2             =SIMP(statut='f',typ='R' ),
+             UO3             =SIMP(statut='f',typ='R' ),
+             UO4             =SIMP(statut='f',typ='R' ),
+             UO5             =SIMP(statut='f',typ='R' ),
+             UO6             =SIMP(statut='f',typ='R' ),
+             VI2             =SIMP(statut='f',typ='R' ),
+             VI3             =SIMP(statut='f',typ='R' ),
+             VI4             =SIMP(statut='f',typ='R' ),
+             VI5             =SIMP(statut='f',typ='R' ),
+             VI6             =SIMP(statut='f',typ='R' ),
+             VO2             =SIMP(statut='f',typ='R' ),
+             VO3             =SIMP(statut='f',typ='R' ),
+             VO4             =SIMP(statut='f',typ='R' ),
+             VO5             =SIMP(statut='f',typ='R' ),
+             VO6             =SIMP(statut='f',typ='R' ),
+             WI2             =SIMP(statut='f',typ='R' ),
+             WI3             =SIMP(statut='f',typ='R' ),
+             WI4             =SIMP(statut='f',typ='R' ),
+             WI5             =SIMP(statut='f',typ='R' ),
+             WI6             =SIMP(statut='f',typ='R' ),
+             WO2             =SIMP(statut='f',typ='R' ),
+             WO3             =SIMP(statut='f',typ='R' ),
+             WO4             =SIMP(statut='f',typ='R' ),
+             WO5             =SIMP(statut='f',typ='R' ),
+             WO6             =SIMP(statut='f',typ='R' ),
+             WO              =SIMP(statut='f',typ='R' ),
+             WI1             =SIMP(statut='f',typ='R' ),
+             WO1             =SIMP(statut='f',typ='R' ),
+             GONF            =SIMP(statut='f',typ='R' ),
+             DCX             =SIMP(statut='f',typ='R' ),
+             DCY             =SIMP(statut='f',typ='R' ),
+             DCZ             =SIMP(statut='f',typ='R' ),
+             H1X             =SIMP(statut='f',typ='R' ),
+             H1Y             =SIMP(statut='f',typ='R' ),
+             H1Z             =SIMP(statut='f',typ='R' ),
+             E1X             =SIMP(statut='f',typ='R' ),
+             E1Y             =SIMP(statut='f',typ='R' ),
+             E1Z             =SIMP(statut='f',typ='R' ),
+             E2X             =SIMP(statut='f',typ='R' ),
+             E2Y             =SIMP(statut='f',typ='R' ),
+             E2Z             =SIMP(statut='f',typ='R' ),
+             E3X             =SIMP(statut='f',typ='R' ),
+             E3Y             =SIMP(statut='f',typ='R' ),
+             E3Z             =SIMP(statut='f',typ='R' ),
+             E4X             =SIMP(statut='f',typ='R' ),
+             E4Y             =SIMP(statut='f',typ='R' ),
+             E4Z             =SIMP(statut='f',typ='R' ),
+             LAGS_C          =SIMP(statut='f',typ='R' ),
+             V11             =SIMP(statut='f',typ='R' ),
+             V12             =SIMP(statut='f',typ='R' ),
+             V13             =SIMP(statut='f',typ='R' ),
+             V21             =SIMP(statut='f',typ='R' ),
+             V22             =SIMP(statut='f',typ='R' ),
+             V23             =SIMP(statut='f',typ='R' ),
+             V31             =SIMP(statut='f',typ='R' ),
+             V32             =SIMP(statut='f',typ='R' ),
+             V33             =SIMP(statut='f',typ='R' ),
+             PRES11          =SIMP(statut='f',typ='R' ),
+             PRES12          =SIMP(statut='f',typ='R' ),
+             PRES13          =SIMP(statut='f',typ='R' ),
+             PRES21          =SIMP(statut='f',typ='R' ),
+             PRES22          =SIMP(statut='f',typ='R' ),
+             PRES23          =SIMP(statut='f',typ='R' ),
+             PRES31          =SIMP(statut='f',typ='R' ),
+             PRES32          =SIMP(statut='f',typ='R' ),
+             PRES33          =SIMP(statut='f',typ='R' ),
+           ),
+
+
+
+         DDL_POUTRE    =FACT(statut='f',max='**',
+             fr="Bloque des DDLs dans un repère local d'une poutre",
+             regles=(AU_MOINS_UN('GROUP_NO','NOEUD'),
+                     AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ'),
+                     UN_PARMI('VECT_Y','ANGL_VRIL'),),
+             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+             DX              =SIMP(statut='f',typ='R' ),
+             DY              =SIMP(statut='f',typ='R' ),
+             DZ              =SIMP(statut='f',typ='R' ),
+             DRX             =SIMP(statut='f',typ='R' ),
+             DRY             =SIMP(statut='f',typ='R' ),
+             DRZ             =SIMP(statut='f',typ='R' ),
+#  définition du repère local
+             VECT_Y          =SIMP(statut='f',typ='R',min=3,max=3),
+             ANGL_VRIL       =SIMP(statut='f',typ='R',),
+#  restriction sur les mailles servant à définir le repère local
+             GROUP_MA        =SIMP(statut='f',typ=grma,),
+             MAILLE          =SIMP(statut='f',typ=ma,),
+                            ),
+
+
+
+           FACE_IMPO       =FACT(statut='f',max='**',
+             fr="Impose à tous les noeuds d'une face une ou plusieurs valeurs de déplacement (ou de certaines grandeurs associées)",
+             regles=(UN_PARMI('GROUP_MA','MAILLE',),
+                     AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
+                                 'TEMP','PRE1','PRE2','DNOR','DTAN'),
+                     EXCLUS('DNOR','DX'),
+                     EXCLUS('DNOR','DY'),
+                     EXCLUS('DNOR','DZ'),
+                     EXCLUS('DNOR','DRX'),
+                     EXCLUS('DNOR','DRY'),
+                     EXCLUS('DNOR','DRZ'),
+                     EXCLUS('DTAN','DX'),
+                     EXCLUS('DTAN','DY'),
+                     EXCLUS('DTAN','DZ'),
+                     EXCLUS('DTAN','DRX'),
+                     EXCLUS('DTAN','DRY'),
+                     EXCLUS('DTAN','DRZ'),),
+#  rajout d'un mot clé REPERE :/ LOCAL /GLOBAL
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             SANS_GROUP_MA   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             SANS_MAILLE     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+             SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+             DX              =SIMP(statut='f',typ='R' ),
+             DY              =SIMP(statut='f',typ='R' ),
+             DZ              =SIMP(statut='f',typ='R' ),
+             DRX             =SIMP(statut='f',typ='R' ),
+             DRY             =SIMP(statut='f',typ='R' ),
+             DRZ             =SIMP(statut='f',typ='R' ),
+             DNOR            =SIMP(statut='f',typ='R' ),
+             DTAN            =SIMP(statut='f',typ='R' ),
+             GRX             =SIMP(statut='f',typ='R' ),
+             PRES            =SIMP(statut='f',typ='R' ),
+             PHI             =SIMP(statut='f',typ='R' ),
+             TEMP            =SIMP(statut='f',typ='R' ),
+             PRE1            =SIMP(statut='f',typ='R' ),
+             PRE2            =SIMP(statut='f',typ='R' ),
+           ),
+
+         CHAMNO_IMPO  =FACT(statut='f',max='**',
+             fr="Impose des DDLs aux valeurs d'un concept cham_no_sdaster",
+#  type de cham_no_sdaster CO()
+             CHAM_NO         =SIMP(statut='o',typ=cham_no_sdaster), #CO()
+             COEF_MULT       =SIMP(statut='o',typ='R' ),
+             NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+           ),
+
+
+           LIAISON_DDL     =FACT(statut='f',max='**',
+             fr="Définit une relation linéaire entre des DDLs de deux ou plusieurs noeuds",
+             regles=(UN_PARMI('GROUP_NO','NOEUD'),),
+             GROUP_NO        =SIMP(statut='f',typ=grno ,max='**'),
+             NOEUD           =SIMP(statut='f',typ=no   ,max='**'),
+             DDL             =SIMP(statut='o',typ='TXM',max='**'),
+             COEF_MULT       =SIMP(statut='o',typ='R'  ,max='**'),
+             COEF_IMPO       =SIMP(statut='o',typ='R' ),
+           ),
+
+           LIAISON_OBLIQUE =FACT(statut='f',max='**',
+             fr="Applique à des noeuds la meme valeur de déplacement définie composante par composante"
+              +" dans un repère oblique quelconque",
+             regles=(UN_PARMI('GROUP_NO','NOEUD'),
+                     UN_PARMI('DX','DY','DZ','DRX','DRY','DRZ'),),
+             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+             ANGL_NAUT       =SIMP(statut='o',typ='R',max=3),
+             DX              =SIMP(statut='f',typ='R' ),
+             DY              =SIMP(statut='f',typ='R' ),
+             DZ              =SIMP(statut='f',typ='R' ),
+             DRX             =SIMP(statut='f',typ='R' ),
+             DRY             =SIMP(statut='f',typ='R' ),
+             DRZ             =SIMP(statut='f',typ='R' ),
+           ),
+
+           LIAISON_GROUP   =FACT(statut='f',max='**',
+             fr="Définit la meme relation linéaire entre certains DDLs de couples de noeuds",
+             regles=(UN_PARMI('GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
+                     UN_PARMI('GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),
+                     EXCLUS('GROUP_MA_1','GROUP_NO_2'),
+                     EXCLUS('GROUP_MA_1','NOEUD_2'),
+                     EXCLUS('GROUP_NO_1','GROUP_MA_2'),
+                     EXCLUS('GROUP_NO_1','MAILLE_2'),
+                     EXCLUS('MAILLE_1','GROUP_NO_2'),
+                     EXCLUS('MAILLE_1','NOEUD_2'),
+                     EXCLUS('NOEUD_1','GROUP_MA_2'),
+                     EXCLUS('NOEUD_1','MAILLE_2'),
+                     EXCLUS('SANS_NOEUD','SANS_GROUP_NO'),),
+
+               GROUP_MA_1      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+               MAILLE_1        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+               GROUP_MA_2      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+               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='**'),
+               NOEUD_2         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+
+             SANS_NOEUD      =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
+             SANS_GROUP_NO   =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
+             DDL_1           =SIMP(statut='o',typ='TXM',max='**'),
+             COEF_MULT_1     =SIMP(statut='o',typ='R'  ,max='**'),
+             DDL_2           =SIMP(statut='o',typ='TXM',max='**'),
+             COEF_MULT_2     =SIMP(statut='o',typ='R'  ,max='**'),
+             COEF_IMPO       =SIMP(statut='o',typ='R' ),
+             SOMMET          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             TRAN            =SIMP(statut='f',typ='R',max=3),
+             ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+             CENTRE          =SIMP(statut='f',typ='R',max=3),
+           ),
+
+           LIAISON_MAIL    =FACT(statut='f',max='**',
+             fr="Définit des relations linéaires permettant de recoller deux bords d'une structure",
+             regles=(AU_MOINS_UN('GROUP_MA_MAIT','MAILLE_MAIT'),
+                     AU_MOINS_UN('GROUP_MA_ESCL','MAILLE_ESCL','GROUP_NO_ESCL','NOEUD_ESCL'),
+                     PRESENT_PRESENT('DDL_MAIT','DDL_ESCL'),),
+              GROUP_MA_MAIT   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE_MAIT     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_MA_ESCL   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE_ESCL     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_NO_ESCL   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              NOEUD_ESCL      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+              TRAN            =SIMP(statut='f',typ='R',max=3 ),
+              ANGL_NAUT       =SIMP(statut='f',typ='R',max=3 ),
+              CENTRE          =SIMP(statut='f',typ='R',max=3 ),
+              DDL_MAIT        =SIMP(statut='f',typ='TXM',into=("DNOR",) ),
+              DDL_ESCL        =SIMP(statut='f',typ='TXM',into=("DNOR",) ),
+              ELIM_MULT       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         ),
+
+           LIAISON_CYCL    =FACT(statut='f',max='**',
+             fr="Définit des relations linéaires permettant de recoller les bords de deux parties symétriquement cycliques",
+             regles=(AU_MOINS_UN('GROUP_MA_MAIT1','MAILLE_MAIT1'),
+                     AU_MOINS_UN('GROUP_MA_ESCL','MAILLE_ESCL','GROUP_NO_ESCL','NOEUD_ESCL'),
+                     PRESENT_PRESENT('DDL_MAIT','DDL_ESCL'),
+                     ),
+              GROUP_MA_MAIT1   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE_MAIT1     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_MA_MAIT2   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE_MAIT2     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_MA_ESCL   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE_ESCL     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_NO_ESCL   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              NOEUD_ESCL     =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+              TRAN            =SIMP(statut='f',typ='R',max=3 ),
+              ANGL_NAUT       =SIMP(statut='f',typ='R',max=3 ),
+              CENTRE          =SIMP(statut='f',typ='R',max=3 ),
+              COEF_MAIT1            =SIMP(statut='f',typ='R',max=1 ),
+              COEF_MAIT2            =SIMP(statut='f',typ='R',max=1 ),
+              COEF_ESCL            =SIMP(statut='f',typ='R',max=1 ),
+              DDL_MAIT        =SIMP(statut='f',typ='TXM',into=("DNOR",) ),
+              DDL_ESCL        =SIMP(statut='f',typ='TXM',into=("DNOR",) ),
+         ),
+
+
+           LIAISON_SOLIDE  =FACT(statut='f',max='**',
+             fr="Modélise une partie indéformable d'une structure."
+              +" Les mots clés TRAN et ANGL_NAUT permettent d'imposer le déplacement de la partie indéformable.",
+             regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),
+                     ENSEMBLE('CENTRE','ANGL_NAUT'),),
+             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='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             TRAN            =SIMP(statut='f',typ='R',max=3 ),
+             ANGL_NAUT       =SIMP(statut='f',typ='R',max=3 ),
+             CENTRE          =SIMP(statut='f',typ='R',max=3 ),
+             DIST_MIN        =SIMP(statut='f',typ='R'),
+             NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+           ),
+
+           LIAISON_ELEM    =FACT(statut='f',max='**',
+             fr="Modélise le raccord d'une partie massive 3D avec une poutre ou avec un tuyau, le raccord d'une coque"
+              +" avec une poutre ou avec un tuyau",
+             regles=(UN_PARMI('GROUP_MA_1','MAILLE_1'),
+                     UN_PARMI('GROUP_NO_2','NOEUD_2'),),
+             OPTION          =SIMP(statut='o',typ='TXM',into=("3D_TUYAU","3D_POU","COQ_POU","COQ_TUYAU") ),
+             GROUP_MA_1      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE_1        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             GROUP_NO_2      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+             NOEUD_2         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+             NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+             CARA_ELEM       =SIMP(statut='f',typ=(cara_elem) ),
+             AXE_POUTRE      =SIMP(statut='f',typ='R',max=3),
+             ANGL_MAX        =SIMP(statut='f',typ='R',defaut= 1. ),
+           ),
+
+           LIAISON_UNIF    =FACT(statut='f',max='**',
+             fr="Impose une meme valeur (inconnue) à des DDLs d'un ensemble de noeuds",
+             regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
+             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='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             DDL             =SIMP(statut='o',typ='TXM',max='**'),
+           ),
+
+         LIAISON_CHAMNO  =FACT(statut='f',max='**',
+             fr="Définit une relation linéaire entre tous les DDLs présents dans un concept CHAM_NO",
+#  type de cham_no_sdaster CO()
+             CHAM_NO         =SIMP(statut='o',typ=cham_no_sdaster), #CO()
+             COEF_IMPO       =SIMP(statut='o',typ='R' ),
+             NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+           ),
+
+         LIAISON_XFEM      =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON" ),
+
+         CONTACT_XFEM      =SIMP(statut='f',typ=char_meca,min=1,max=1,),
+
+
+#         SIMP(statut='f',typ='TXM',defaut="NON" ),
+
+         VECT_ASSE       =SIMP(statut='f',typ=cham_no_sdaster ),
+#
+# LIAISON UNILATERALE
+#
+         LIAISON_UNILATER=FACT(statut='f',max='**',
+           fr="Définit les zones soumises à des conditions de liaison unilaterale (inegalite sur un DDL)",
+           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='**'),
+
+           SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+
+           NB_RESOL        =SIMP(statut='f',typ='I', defaut=10 ),
+
+           NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
+
+           COEF_IMPO       =SIMP(statut='f',typ='R'),
+           COEF_MULT       =SIMP(statut='f',typ='R',max='**'),
+
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="CONTRAINTE",
+                                 into=("CONTRAINTE",) ),
+
+
+        ),
+#
+# CONTACT
+#
+         CONTACT         = C_CONTACT(),
+#
+# FORCES
+#
+         FORCE_NODALE    =FACT(statut='f',fr="Applique à des noeuds des forces nodales",max='**',
+           regles=(AU_MOINS_UN('GROUP_NO','NOEUD'),
+                   AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ' ),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           FX              =SIMP(statut='f',typ='R' ),
+           FY              =SIMP(statut='f',typ='R' ),
+           FZ              =SIMP(statut='f',typ='R' ),
+           MX              =SIMP(statut='f',typ='R' ),
+           MY              =SIMP(statut='f',typ='R' ),
+           MZ              =SIMP(statut='f',typ='R' ),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+         ),
+
+         FORCE_FACE      =FACT(statut='f',max='**',
+             fr="Applique des forces surfaciques sur une face d'élément volumique",
+             regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('FX','FY','FZ'),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             FX              =SIMP(statut='f',typ='R' ),
+             FY              =SIMP(statut='f',typ='R' ),
+             FZ              =SIMP(statut='f',typ='R' ),
+           ),
+
+         FORCE_ARETE     =FACT(statut='f',max='**',
+         fr="Applique des forces linéiques à une arete d'élément volumique ou de coque",
+             regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),
+                     AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ' ),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             FX              =SIMP(statut='f',typ='R' ),
+             FY              =SIMP(statut='f',typ='R' ),
+             FZ              =SIMP(statut='f',typ='R' ),
+             MX              =SIMP(statut='f',typ='R' ),
+             MY              =SIMP(statut='f',typ='R' ),
+             MZ              =SIMP(statut='f',typ='R' ),
+           ),
+
+         FORCE_CONTOUR   =FACT(statut='f',max='**',
+             fr="Applique des forces linéiques au bord d'un domaine 2D ou AXIS ou AXIS_FOURIER",
+             regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             FX              =SIMP(statut='f',typ='R' ),
+             FY              =SIMP(statut='f',typ='R' ),
+             FZ              =SIMP(statut='f',typ='R' ),
+             MX              =SIMP(statut='f',typ='R' ),
+             MY              =SIMP(statut='f',typ='R' ),
+             MZ              =SIMP(statut='f',typ='R' ),
+           ),
+
+         FORCE_INTERNE   =FACT(statut='f',max='**',
+             fr="Applique des forces volumiques (2D ou 3D) à un domaine volumique",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('FX','FY','FZ' ),),
+             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='**'),
+             FX              =SIMP(statut='f',typ='R' ),
+             FY              =SIMP(statut='f',typ='R' ),
+             FZ              =SIMP(statut='f',typ='R' ),
+           ),
+
+         SIGM_INTERNE   =FACT(statut='f',max='**',
+             fr="Applique des contraintes volumiques (2D ou 3D) à un domaine volumique",
+             #INST            =SIMP(statut='f',typ='R' ),
+             SIGM            =SIMP(statut='o',typ=(cham_elem,carte_sdaster)),
+           ),
+
+         PRES_REP        =FACT(statut='f',max='**',
+             fr="Applique une pression à un domaine de milieu continu 2D ou 3D, ou à un domaine de coques et tuyaux",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','FISSURE'),
+                     PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE','FISSURE'),
+                     AU_MOINS_UN('PRES','CISA_2D' ),),
+             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='**'),
+             FISSURE         =SIMP(statut='f',typ=fiss_xfem,min=1,max=100,),
+             PRES            =SIMP(statut='f',typ='R' ),
+             CISA_2D         =SIMP(statut='f',typ='R' ),
+           ),
+
+         EFFE_FOND       =FACT(statut='f',max='**',
+           fr="Calcul l'effet de fond sur une branche de tuyauterie (modélisation 3D) soumise à une pression",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
+           GROUP_MA_INT    =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           PRES            =SIMP(statut='o',typ='R' ),
+         ),
+
+         EPSI_INIT       =FACT(statut='f',max='**',
+             fr="Applique un chargement de déformation initiale à un élément 2D, 3D ou de structure",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ','EPX',
+                                 'KY','KZ','EXX','EYY','EXY','KXX','KYY','KXY'),),
+             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='**'),
+             EPXX            =SIMP(statut='f',typ='R' ),
+             EPYY            =SIMP(statut='f',typ='R' ),
+             EPZZ            =SIMP(statut='f',typ='R' ),
+             EPXY            =SIMP(statut='f',typ='R' ),
+             EPXZ            =SIMP(statut='f',typ='R' ),
+             EPYZ            =SIMP(statut='f',typ='R' ),
+             EPX             =SIMP(statut='f',typ='R' ),
+             KY              =SIMP(statut='f',typ='R' ),
+             KZ              =SIMP(statut='f',typ='R' ),
+             EXX             =SIMP(statut='f',typ='R' ),
+             EYY             =SIMP(statut='f',typ='R' ),
+             EXY             =SIMP(statut='f',typ='R' ),
+             KXX             =SIMP(statut='f',typ='R' ),
+             KYY             =SIMP(statut='f',typ='R' ),
+             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'),
+                     PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('FX','FY','FZ','N','VY','VZ'),
+                     PRESENT_ABSENT('FX','N','VY','VZ'),
+                     PRESENT_ABSENT('FY','N','VY','VZ'),
+                     PRESENT_ABSENT('FZ','N','VY','VZ'),
+                     PRESENT_ABSENT('N','FX','FY','FZ'),
+                     PRESENT_ABSENT('VY','FX','FY','FZ'),
+                     PRESENT_ABSENT('VZ','FX','FY','FZ'),),
+             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='**'),
+             TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FORCE",into=("VENT","FORCE",) ),
+#  rajour d'un mot clé REPERE :/ LOCAL /GLOBAL
+               FX              =SIMP(statut='f',typ='R' ),
+               FY              =SIMP(statut='f',typ='R' ),
+               FZ              =SIMP(statut='f',typ='R' ),
+
+               N               =SIMP(statut='f',typ='R' ),
+               VY              =SIMP(statut='f',typ='R' ),
+               VZ              =SIMP(statut='f',typ='R' ),
+
+           ),
+
+         FORCE_TUYAU     =FACT(statut='f',max='**',
+             fr="Applique une pression sur des éléments TUYAU",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     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='**'),
+             PRES            =SIMP(statut='f',typ='R' ),
+           ),
+
+         FORCE_COQUE     =FACT(statut='f',max='**',
+             fr="Applique des forces surfaciques sur des éléments de types coques",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ','PRES','F1','F2','F3','MF1','MF2'),
+                     PRESENT_ABSENT('FX','PRES','F1','F2','F3','MF1','MF2'),
+                     PRESENT_ABSENT('FY','PRES','F1','F2','F3','MF1','MF2'),
+                     PRESENT_ABSENT('FZ','PRES','F1','F2','F3','MF1','MF2'),
+                     PRESENT_ABSENT('MX','PRES','F1','F2','F3','MF1','MF2'),
+                     PRESENT_ABSENT('MY','PRES','F1','F2','F3','MF1','MF2'),
+                     PRESENT_ABSENT('MZ','PRES','F1','F2','F3','MF1','MF2'),
+                     PRESENT_ABSENT('F1','FX','FY','FZ','MX','MY','MZ','PRES'),
+                     PRESENT_ABSENT('F2','FX','FY','FZ','MX','MY','MZ','PRES'),
+                     PRESENT_ABSENT('F3','FX','FY','FZ','MX','MY','MZ','PRES'),
+                     PRESENT_ABSENT('MF1','FX','FY','FZ','MX','MY','MZ','PRES'),
+                     PRESENT_ABSENT('MF2','FX','FY','FZ','MX','MY','MZ','PRES'),
+                     PRESENT_ABSENT('PRES','FX','FY','FZ','MX','MY','MZ','F1','F2','F3','MF1','MF2'),),
+#  rajour d'un mot clé REPERE :/ LOCAL /GLOBAL
+             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='**'),
+
+               FX              =SIMP(statut='f',typ='R' ),
+               FY              =SIMP(statut='f',typ='R' ),
+               FZ              =SIMP(statut='f',typ='R' ),
+               MX              =SIMP(statut='f',typ='R' ),
+               MY              =SIMP(statut='f',typ='R' ),
+               MZ              =SIMP(statut='f',typ='R' ),
+
+               F1              =SIMP(statut='f',typ='R' ),
+               F2              =SIMP(statut='f',typ='R' ),
+               F3              =SIMP(statut='f',typ='R' ),
+               MF1             =SIMP(statut='f',typ='R' ),
+               MF2             =SIMP(statut='f',typ='R' ),
+
+             PRES            =SIMP(statut='f',typ='R' ),
+             PLAN            =SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL",) ),
+           ),
+
+
+
+           LIAISON_COQUE   =FACT(statut='f',max='**',
+             fr="Permet de représenter le raccord entre des éléments de coques au moyen des relations linéaires",
+             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='**'),
+             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='**'),
+             NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+           ),
+
+         RELA_CINE_BP    =FACT(statut='f',max='**',
+           fr="Etablir des relations cinématiques permettant de relier les noeuds cable aux noeuds du béton, et spécifier"
+              +" la prise en compte des contraintes initiales dans les cables",
+           CABLE_BP        =SIMP(statut='o',typ=cabl_precont ),
+           SIGM_BPEL       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           RELA_CINE       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           DIST_MIN        =SIMP(statut='f',typ='R'),
+         ),
+
+         FORCE_ELEC      =FACT(statut='f',max='**',
+             fr="Appliquer la force de LAPLACE agissant sur un conducteur principal, due à la présence d'un conducteur"
+                 +" secondaire droit",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     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='**'),
+
+             POSITION        =SIMP(statut='f',typ='TXM',fr="Direction prédéfinie",into=("PARA","INFI","FINI",) ),
+             b_fxyz  =BLOC ( condition = "POSITION == None",
+                  FX   =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+                  FY   =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+                  FZ   =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+                       ),
+
+             b_para     =BLOC ( condition = "POSITION == 'PARA'",
+               regles=(UN_PARMI('TRANS','DIST'),),
+               TRANS           =SIMP(statut='f',typ='R',max=3),
+               DIST            =SIMP(statut='f',typ='R' ),
+               b_point2        =BLOC ( condition = "DIST != None",
+                 POINT2           =SIMP(statut='o',typ='R',max=3),
+               ),
+             ),
+             b_fini_infi     =BLOC ( condition = "(POSITION == 'FINI') or (POSITION == 'INFI')",
+               POINT1          =SIMP(statut='o',typ='R',max=3),
+               POINT2          =SIMP(statut='o',typ='R',max=3),
+             ),
+           ),
+
+
+
+
+        INTE_ELEC       =FACT(statut='f',max='**',
+             fr="Appliquer la force de LAPLACE agissant sur un conducteur principal, due à la présence d'un conducteur"
+               +" secondaire non nécessairement droit",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('GROUP_MA_2','MAILLE_2','TRANS','SYME'),
+                     EXCLUS('TRANS','SYME'),),
+             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_2      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE_2        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             TRANS           =SIMP(statut='f',typ='R' ,max='**'),
+             SYME            =SIMP(statut='f',typ='R' ,max='**'),
+           ),
+
+
+         IMPE_FACE       =FACT(statut='f',fr="Applique une impédance acoustique à une face",max='**',
+             regles=(AU_MOINS_UN('GROUP_MA','MAILLE' ),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             IMPE            =SIMP(statut='o',typ='R' ),
+           ),
+
+         VITE_FACE       =FACT(statut='f',fr="Impose des vitesses normales à une face (phénomène ACOUSTIQUE), ",max='**',
+             regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             VNOR            =SIMP(statut='o',typ='R' ),
+           ),
+
+
+
+         ONDE_FLUI       =FACT(statut='f',max='**',
+             fr="Applique une amplitude de pression d'onde incidente sinusoidale arrivant normalement à une face",
+             regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             PRES            =SIMP(statut='o',typ='R' ),
+           ),
+
+         FLUX_THM_REP    =FACT(statut='f',max='**',
+             fr="Applique à un domaine de milieu continu 2D ou 3D un flux de chaleur et/ou un apport de masse fluide"
+                 +" (flux hydraulique)",
+             regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                     PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                     AU_MOINS_UN('FLUN','FLUN_HYDR1','FLUN_HYDR2'),),
+             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='**'),
+             FLUN            =SIMP(statut='f',typ='R' ),
+             FLUN_HYDR1      =SIMP(statut='f',typ='R' ),
+             FLUN_HYDR2      =SIMP(statut='f',typ='R' ),
+           ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+
+
+#& MODIF COMMANDE  DATE 16/09/2008   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.
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+AFFE_CHAR_MECA_C=OPER(nom="AFFE_CHAR_MECA_C",op=   7,sd_prod=char_meca,
+                     fr="Affectation de charges et conditions aux limites mécaniques complexes",
+                     reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+         regles=(AU_MOINS_UN('DDL_IMPO','FORCE_POUTRE','LIAISON_DDL', ),),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         VERI_DDL        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         METHODE         =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les déplacements imposés",
+                               into=('DUALISATION',),defaut='DUALISATION',),
+                               # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+         DDL_IMPO        =FACT(statut='f',max='**',
+           fr="Impose à des noeuds une ou plusieurs valeurs de déplacement (ou de certaines grandeurs asscociées)",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD',),
+                   AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI','LIAISON', ),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           LIAISON         =SIMP(statut='f',typ='TXM',into=('ENCASTRE',)),
+           DX              =SIMP(statut='f',typ='C' ),
+           DY              =SIMP(statut='f',typ='C' ),
+           DZ              =SIMP(statut='f',typ='C' ),
+           DRX             =SIMP(statut='f',typ='C' ),
+           DRY             =SIMP(statut='f',typ='C' ),
+           DRZ             =SIMP(statut='f',typ='C' ),
+           GRX             =SIMP(statut='f',typ='C' ),
+           PRES            =SIMP(statut='f',typ='C' ),
+           PHI             =SIMP(statut='f',typ='C' ),
+         ),
+         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'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FX','FY','FZ','N','VY','VZ',),
+                   PRESENT_ABSENT('FX','N','VY','VZ',),
+                   PRESENT_ABSENT('FY','N','VY','VZ',),
+                   PRESENT_ABSENT('FZ','N','VY','VZ',),
+                   PRESENT_ABSENT('N','FX','FY','FZ',),
+                   PRESENT_ABSENT('VY', 'FX','FY','FZ',),
+                   PRESENT_ABSENT('VZ','FX','FY','FZ', ),),
+           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='**'),
+           TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FORCE",into=("VENT","FORCE") ),
+           FX              =SIMP(statut='f',typ='C' ),
+           FY              =SIMP(statut='f',typ='C' ),
+           FZ              =SIMP(statut='f',typ='C' ),
+           N               =SIMP(statut='f',typ='C' ),
+           VY              =SIMP(statut='f',typ='C' ),
+           VZ              =SIMP(statut='f',typ='C' ),
+         ),
+         LIAISON_DDL     =FACT(statut='f',max='**',
+           fr="Définit une relation linéaire entre les DDLs de deux ou plusieurs noeuds",
+           regles=(UN_PARMI('GROUP_NO','NOEUD', ),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,max='**'),
+           DDL             =SIMP(statut='o',typ='TXM',max='**'),
+           COEF_MULT       =SIMP(statut='o',typ='R'  ,max='**'),
+           COEF_IMPO       =SIMP(statut='o',typ='C' ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 05/05/2009   AUTEUR DESOZA T.DESOZA 
+#            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 DESROCHES X.DESROCHES
+AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca,
+                      fr="Affectation de charges et conditions aux limites mécaniques fonction d'un (ou plusieurs) paramètres",
+                      reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+        regles=(AU_MOINS_UN('DDL_IMPO','FACE_IMPO','LIAISON_DDL','FORCE_NODALE',
+                            'FORCE_FACE','FORCE_ARETE','FORCE_CONTOUR','FORCE_INTERNE',
+                            'PRES_REP','FORCE_POUTRE','VITE_FACE','IMPE_FACE','ONDE_PLANE',
+                            'LIAISON_OBLIQUE','EPSI_INIT','LIAISON_GROUP','LIAISON_UNIF',
+                            'LIAISON_SOLIDE','FORCE_COQUE','LIAISON_COQUE','FORCE_TUYAU',
+                            'EFFE_FOND','FLUX_THM_REP','LIAISON_UNILATER'),),
+         VERI_DDL        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         VERI_NORM       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         METHODE         =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les déplacements imposés",
+                               into=('DUALISATION',),defaut='DUALISATION',),
+                               # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+
+         DDL_IMPO        =FACT(statut='f',max='**',
+           fr="Impose à des noeuds une ou plusieurs valeurs de déplacement (ou de certaines grandeurs asscociées) fournies"
+               +" par l'intermédiaire d'un concept fonction ",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
+                   AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
+                               'TEMP','PRE1','PRE2','LIAISON','DCX','DCY','DCZ','H1X',
+                               'H1Y','H1Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
+                               'E3X','E3Y','E3Z','E4X','E4Y','E4Z','LAGS_C'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           LIAISON         =SIMP(statut='f',typ='TXM',into=('ENCASTRE',)),
+           DX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRY             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRZ             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           GRX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRES            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PHI             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRE1            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRE2            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DCX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DCY             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DCZ             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           H1X             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           H1Y             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           H1Z             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E1X             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E1Y             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E1Z             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E2X             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E2Y             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E2Z             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E3X             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E3Y             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E3Z             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E4X             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E4Y             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           E4Z             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           LAGS_C          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         FACE_IMPO       =FACT(statut='f',max='**',
+           fr="Impose à tous les noeuds d'une face une ou plusieurs valeurs de déplacement (ou de certaines grandeurs associées)"
+              +" fournies par l'intérmédiaire d'un concept fonction",
+           regles=(UN_PARMI('GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI','TEMP','PRE1','PRE2','DNOR','DTAN'),
+                   EXCLUS('DNOR','DX'),
+                   EXCLUS('DNOR','DY'),
+                   EXCLUS('DNOR','DZ'),
+                   EXCLUS('DNOR','DRX'),
+                   EXCLUS('DNOR','DRY'),
+                   EXCLUS('DNOR','DRZ'),
+                   EXCLUS('DTAN','DX'),
+                   EXCLUS('DTAN','DY'),
+                   EXCLUS('DTAN','DZ'),
+                   EXCLUS('DTAN','DRX'),
+                   EXCLUS('DTAN','DRY'),
+                   EXCLUS('DTAN','DRZ'),),
+#  rajout d un mot cle REPERE : / GLOBAL / LOCAL
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           SANS_GROUP_MA   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           SANS_MAILLE     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           DX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRY             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRZ             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           GRX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRES            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PHI             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRE1            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRE2            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DNOR            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DTAN            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         LIAISON_DDL     =FACT(statut='f',max='**',
+           fr="Définit une relation linéaire entre des DDLs de deux ou plusieurs noeuds, les valeurs sont fournies par"
+               +" l'intermediaire d'un concept de type fonction",
+           regles=(UN_PARMI('GROUP_NO','NOEUD'),UN_PARMI('COEF_MULT','COEF_MULT_FONC'),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,max='**'),
+           DDL             =SIMP(statut='o',typ='TXM',max='**'),
+           COEF_MULT       =SIMP(statut='f',typ='R',max='**'),
+           COEF_MULT_FONC  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
+           COEF_IMPO       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         LIAISON_OBLIQUE =FACT(statut='f',max='**',
+           fr="Applique à des noeuds la meme valeur de déplacement définie composante par composante dans un repère oblique"
+              +" quelconque, les valeurs sont fournis par l'intermédiaire d'un concept fonction",
+           regles=(UN_PARMI('GROUP_NO','NOEUD'),
+                   UN_PARMI('DX','DY','DZ','DRX','DRY','DRZ'),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,max='**'),
+           ANGL_NAUT       =SIMP(statut='o',typ='R',max=3),
+           DX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRX             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRY             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DRZ             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         LIAISON_GROUP   =FACT(statut='f',max='**',
+           fr="Définit la meme relation linéaire entre certains DDLs de couples de noeuds, les valeurs sont fournies par"
+               +" l'intermédiaire de concept fonction",
+           regles=(UN_PARMI('GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
+                   UN_PARMI('GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),
+                   EXCLUS('GROUP_MA_1','GROUP_NO_2'),
+                   EXCLUS('GROUP_MA_1','NOEUD_2'),
+                   EXCLUS('GROUP_NO_1','GROUP_MA_2'),
+                   EXCLUS('GROUP_NO_1','MAILLE_2'),
+                   EXCLUS('MAILLE_1','GROUP_NO_2'),
+                   EXCLUS('MAILLE_1','NOEUD_2'),
+                   EXCLUS('NOEUD_1','GROUP_MA_2'),
+                   EXCLUS('NOEUD_1','MAILLE_2'),
+                   EXCLUS('SANS_NOEUD','SANS_GROUP_NO'),),
+           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='**'),
+           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='**'),
+           SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           DDL_1           =SIMP(statut='o',typ='TXM',max='**'),
+           COEF_MULT_1     =SIMP(statut='o',typ='R',max='**'),
+           DDL_2           =SIMP(statut='o',typ='TXM',max='**'),
+           COEF_MULT_2     =SIMP(statut='o',typ='R',max='**'),
+           COEF_IMPO       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           SOMMET          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           TRAN            =SIMP(statut='f',typ='R',max=3),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+           CENTRE          =SIMP(statut='f',typ='R',max=3),
+         ),
+#
+# LIAISON UNILATERALE
+#
+         LIAISON_UNILATER=FACT(statut='f',max='**',
+           fr="Définit les zones soumises à des conditions de liaison unilaterale (inegalite sur un DDL)",
+           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='**'),
+
+           SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+
+           NB_RESOL        =SIMP(statut='f',typ='I', defaut=10 ),
+
+           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='**'),
+
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="CONTRAINTE",
+                                 into=("CONTRAINTE",) ),
+
+
+        ),
+
+          LIAISON_UNIF    =FACT(statut='f',max='**',
+           fr="Impose une meme valeur (inconnue) à des DDLs d'un ensemble de noeuds",
+           regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
+           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='**'),
+           DDL             =SIMP(statut='o',typ='TXM',max='**'),
+         ),
+
+
+         LIAISON_SOLIDE  =FACT(statut='f',max='**',
+           fr="Modélise une partie indéformable d'une structure."
+            +" Les mots clés TRAN et ANGL_NAUT permettent d'imposer le déplacement de la partie indéformable.",
+           regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),
+                   ENSEMBLE('CENTRE','ANGL_NAUT'),),
+           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='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           TRAN            =SIMP(statut='f',typ='R',max=3 ),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3 ),
+           CENTRE          =SIMP(statut='f',typ='R',max=3 ),
+           DIST_MIN        =SIMP(statut='f',typ='R'),
+           NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+         ),
+
+
+
+         FORCE_NODALE    =FACT(statut='f',max='**',
+           fr="Applique à des noeuds des forces nodales dont les valeurs des composantes sont fournies par l'intermédiaire"
+               +" d'un concept fonction",
+           regles=(UN_PARMI('GROUP_NO','NOEUD'),
+                   AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           FX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           ANGL_NAUT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max=3 ),
+         ),
+
+         FORCE_FACE      =FACT(statut='f',max='**',
+           fr="Applique des forces surfaciques sur une face d'élément volumique dont les valeurs des composantes sont fournies"
+               +" par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FX','FY','FZ'),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           FX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         FORCE_ARETE     =FACT(statut='f',max='**',
+           fr="Applique des forces linéiques à une arete d'élément volumique ou de coque dont les valeurs des composantes sont"
+               +" fournies par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           FX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         FORCE_CONTOUR   =FACT(statut='f',max='**',
+           fr="Applique des forces linéiques au bord d'un domaine 2D ou AXIS ou AXIS_FOURIER, dont les valeurs des composantes"
+               +" sont fournies par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           FX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         FORCE_INTERNE   =FACT(statut='f',max='**',
+           fr="Applique des forces volumiques (2D ou 3D) à un domaine volumique, dont les valeurs des composantes sont fournies"
+               +" par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FX','FY','FZ'),),
+           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='**'),
+           FX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         PRES_REP        =FACT(statut='f',max='**',
+           fr="Applique une pression à un domaine de milieu continu 2D ou 3D ou à un domaine de coques et tuyaux, dont les"
+               +" valeurs imposées (pression et/ou cisaillement) sont fournies par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','FISSURE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE','FISSURE'),
+                   AU_MOINS_UN('PRES','CISA_2D'),),
+           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='**'),
+           FISSURE         =SIMP(statut='f',typ=fiss_xfem,min=1,max=100,),
+           PRES            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           CISA_2D         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         EFFE_FOND       =FACT(statut='f',max='**',
+           fr="Calcul l'effet de fond sur une branche de tuyauterie (modélisation 3D) soumise"
+               +" à une pression dont la valeur est fournie par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),),
+           GROUP_MA_INT    =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           PRES            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         EPSI_INIT       =FACT(statut='f',max='**',
+           fr="Applique un chargement de déformation initiale à un élément 2D, 3D ou de structure dont les composantes"
+               +" du tenseur de déformation sont fournies par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),),
+           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='**'),
+           EPXX            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           EPYY            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           EPZZ            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           EPXY            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           EPXZ            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           EPYZ            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         FORCE_POUTRE    =FACT(statut='f',max='**',
+           fr="Applique des forces linéiques sur des éléments de type poutre dont les valeurs sont fournies par"
+               +" l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FX','FY','FZ','N','VY','VZ'),
+                   PRESENT_ABSENT('FX','N','VY','VZ'),
+                   PRESENT_ABSENT('FY','N','VY','VZ'),
+                   PRESENT_ABSENT('FZ','N','VY','VZ'),
+                   PRESENT_ABSENT('N','FX','FY','FZ'),
+                   PRESENT_ABSENT('VY','FX','FY','FZ'),
+                   PRESENT_ABSENT('VZ','FX','FY','FZ'),),
+#  rajout d un mot cle REPERE : / GLOBAL / LOCAL
+           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='**'),
+           TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FORCE",into=("VENT","FORCE") ),
+           FX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           N               =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           VY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           VZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         FORCE_TUYAU     =FACT(statut='f',max='**',
+           fr="Applique une pression sur des éléments TUYAU, la valeur est fournie par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   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='**'),
+           PRES            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         FORCE_COQUE     =FACT(statut='f',max='**',
+           fr="Applique des forces surfaciques sur des éléments de types coques dont les valeurs sont fournies par"
+               +" l'intermédiaires d'un concept fonction",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ','PRES','F1','F2','F3','MF1','MF2'),
+                   PRESENT_ABSENT('FX','PRES','F1','F2','F3','MF1','MF2'),
+                   PRESENT_ABSENT('FY','PRES','F1','F2','F3','MF1','MF2'),
+                   PRESENT_ABSENT('FZ','PRES','F1','F2','F3','MF1','MF2'),
+                   PRESENT_ABSENT('MX','PRES','F1','F2','F3','MF1','MF2'),
+                   PRESENT_ABSENT('MY','PRES','F1','F2','F3','MF1','MF2'),
+                   PRESENT_ABSENT('MZ','PRES','F1','F2','F3','MF1','MF2'),
+                   PRESENT_ABSENT('F1','PRES','FX','FY','FZ','MX','MY','MZ'),
+                   PRESENT_ABSENT('F2','PRES','FX','FY','FZ','MX','MY','MZ'),
+                   PRESENT_ABSENT('F3','PRES','FX','FY','FZ','MX','MY','MZ'),
+                   PRESENT_ABSENT('MF1','PRES','FX','FY','FZ','MX','MY','MZ'),
+                   PRESENT_ABSENT('MF2','PRES','FX','FY','FZ','MX','MY','MZ'),
+                   PRESENT_ABSENT('PRES','FX','FY','FZ','MX','MY','MZ','F1','F2','F3','MF1','MF2'),),
+#  rajout d un mot cle REPERE : / GLOBAL / LOCAL
+           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='**'),
+           FX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MX              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MY              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MZ              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           F1              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           F2              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           F3              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MF1             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MF2             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PRES            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PLAN            =SIMP(statut='f',typ='TXM',defaut="MAIL",
+                                 into=("SUP","INF","MOY","MAIL") ),
+         ),
+
+         LIAISON_COQUE   =FACT(statut='f',max='**',
+           fr="Permet de représenter le raccord entre des éléments de coques au moyen des relations linéaires",
+           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='**'),
+           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='**'),
+           NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES",) ),
+         ),
+
+
+         VITE_FACE       =FACT(statut='f',max='**',
+           fr="Impose des vitesses normales à une face (phénomène ACOUSTIQUE) dont les valeurs sont fournies par"
+               +" l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('GROUP_MA','MAILLE'),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           VNOR            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         IMPE_FACE       =FACT(statut='f',max='**',
+           fr="Applique à une face une impédance acoustique dont la valeur est fournie par l'intermédiaire"
+               +" d'un concept fonction",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('GROUP_MA','MAILLE'),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           IMPE            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         ONDE_PLANE      =FACT(statut='f',max='**',
+           fr="Impose un chargement sismique par onde plane dont la valeur est fournie par l'intermédiaire"
+               +" d'un concept fonction",
+           DIRECTION       =SIMP(statut='o',typ='R',max='**'),
+           TYPE_ONDE       =SIMP(statut='o',typ='TXM' ),
+           FONC_SIGNAL     =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DIST_ORIG       =SIMP(statut='o',typ='R' ),
+         ),
+
+
+
+         FLUX_THM_REP    =FACT(statut='f',max='**',
+           fr="Applique à un domaine continue 2D ou 3D un flux de chaleur et/ou un apport de masse fluide (flux hydraulique)"
+               +" dont les valeurs des flux sont fournies par l'intermédiaire d'un concept fonction",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FLUN','FLUN_HYDR1','FLUN_HYDR2'),),
+           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='**'),
+           FLUN            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUN_HYDR1      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUN_HYDR2      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+
+
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE None
+AFFE_CHAR_OPS011=OPER(nom="AFFE_CHAR_OPS011",op= 190,sd_prod=char_ther,
+                      fr="Affectation de charges et conditions limites thermiques spécifique à CARA_TORSION",
+                      reentrant='n',
+            UIinfo={"groupes":("Outils métier",)},
+         regles=(AU_MOINS_UN('CARA_TORSION', ),),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         VERI_DDL        =SIMP(statut='f',typ='TXM',defaut="OUI",
+                               into=("OUI","NON") ),
+         CARA_TORSION    =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_MA'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 16/09/2008   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.
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+AFFE_CHAR_THER=OPER(nom="AFFE_CHAR_THER",op=34,sd_prod=char_ther
+                    ,fr="Affectation de charges et conditions aux limites thermiques constantes",
+                    reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+      regles=(AU_MOINS_UN('TEMP_IMPO','SOURCE','FLUX_REP','ECHANGE',
+                          'ECHANGE_PAROI','GRAD_TEMP_INIT','LIAISON_DDL','LIAISON_GROUP',
+                          'LIAISON_UNIF','LIAISON_CHAMNO','RAYONNEMENT','LIAISON_MAIL' ),),
+         MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+         METHODE         =SIMP(statut='c',typ='TXM',fr="Stratégie de résolution pour les températures imposées",
+                               into=('DUALISATION',),defaut='DUALISATION',),
+                               # METHODE='ELIMINATION' est traité dans le fortran mais dangereux actuellement
+
+         TEMP_IMPO       =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
+                   AU_MOINS_UN('TEMP_SUP','TEMP','TEMP_INF'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TEMP            =SIMP(statut='f',typ='R'),
+           TEMP_INF        =SIMP(statut='f',typ='R'),
+           TEMP_SUP        =SIMP(statut='f',typ='R'), ),
+
+         FLUX_REP        =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_PRESENT('CARA_TORSION','GROUP_MA'),
+                   AU_MOINS_UN('FLUN','FLUN_INF','FLUN_SUP','CARA_TORSION') ),
+           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='**'),
+           FLUN            =SIMP(statut='f',typ='R'),
+           FLUN_INF        =SIMP(statut='f',typ='R'),
+           FLUN_SUP        =SIMP(statut='f',typ='R'),
+           CARA_TORSION    =SIMP(statut='f',typ=table_sdaster),
+         ),
+
+
+         RAYONNEMENT     =FACT(statut='f',max='**',
+           fr="Attention, exprimer les températures en Celsius si rayonnement",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   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='**'),
+           SIGMA           =SIMP(statut='o',typ='R'),
+           EPSILON         =SIMP(statut='o',typ='R'),
+           TEMP_EXT        =SIMP(statut='o',typ='R'),
+         ),
+
+         ECHANGE         =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('COEF_H','COEF_H_INF','COEF_H_SUP'),
+                   ENSEMBLE('COEF_H','TEMP_EXT',),
+                   ENSEMBLE('COEF_H_INF','TEMP_EXT_INF'),
+                             ENSEMBLE('COEF_H_SUP','TEMP_EXT_SUP'),),
+           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='**'),
+           COEF_H          =SIMP(statut='f',typ='R'),
+           TEMP_EXT        =SIMP(statut='f',typ='R'),
+           COEF_H_INF      =SIMP(statut='f',typ='R'),
+           TEMP_EXT_INF    =SIMP(statut='f',typ='R'),
+           COEF_H_SUP      =SIMP(statut='f',typ='R'),
+           TEMP_EXT_SUP    =SIMP(statut='f',typ='R'),
+         ),
+
+         SOURCE          =FACT(statut='f',max='**',
+           regles=(UN_PARMI('SOUR','SOUR_CALCULEE',),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('SOUR_CALCULEE','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='**'),
+           SOUR            =SIMP(statut='f',typ='R'),
+           SOUR_CALCULEE   =SIMP(statut='f',typ=(cham_elem) ),
+         ),
+
+         GRAD_TEMP_INIT  =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FLUX_X','FLUX_Y','FLUX_Z'),),
+           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='**'),
+           FLUX_X          =SIMP(statut='f',typ='R' ),
+           FLUX_Y          =SIMP(statut='f',typ='R' ),
+           FLUX_Z          =SIMP(statut='f',typ='R' ),
+                         ),
+
+         LIAISON_DDL     =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_NO','NOEUD', ),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,max='**'),
+           DDL             =SIMP(statut='f',typ='TXM',max='**',
+                                 into=("TEMP","TEMP_INF","TEMP_SUP") ),
+           COEF_MULT       =SIMP(statut='o',typ='R',max='**'),
+           COEF_IMPO       =SIMP(statut='o',typ='R' ),
+         ),
+
+         LIAISON_GROUP   =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
+                   UN_PARMI('GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),
+                             EXCLUS('GROUP_MA_1','GROUP_NO_2'),
+                             EXCLUS('GROUP_MA_1','NOEUD_2'),
+                   EXCLUS('GROUP_NO_1','GROUP_MA_2'),
+                             EXCLUS('GROUP_NO_1','MAILLE_2'),
+                             EXCLUS('MAILLE_1','GROUP_NO_2'),
+                             EXCLUS('MAILLE_1','NOEUD_2'),
+                             EXCLUS('NOEUD_1','GROUP_MA_2'),
+                             EXCLUS('NOEUD_1','MAILLE_2'),
+                             EXCLUS('SANS_NOEUD','SANS_GROUP_NO'),),
+           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='**'),
+           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='**'),
+           SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           DDL_1           =SIMP(statut='f',typ='TXM',max='**',defaut="TEMP",
+                                 into=("TEMP","TEMP_INF","TEMP_SUP") ),
+           COEF_MULT_1     =SIMP(statut='o',typ='R',max='**'),
+           DDL_2           =SIMP(statut='f',typ='TXM',max='**',defaut="TEMP",
+                                 into=("TEMP","TEMP_INF","TEMP_SUP",) ),
+           COEF_MULT_2     =SIMP(statut='o',typ='R',max='**'),
+           COEF_IMPO       =SIMP(statut='o',typ='R' ),
+           SOMMET          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           TRAN            =SIMP(statut='f',typ='R',max='**'),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max='**'),
+           CENTRE          =SIMP(statut='f',typ='R',max='**'),
+         ),
+
+         LIAISON_MAIL    =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('GROUP_MA_MAIT','MAILLE_MAIT'),
+                   AU_MOINS_UN('GROUP_MA_ESCL','MAILLE_ESCL','GROUP_NO_ESCL',
+                               'NOEUD_ESCL'),),
+           GROUP_MA_MAIT   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_MAIT     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA_ESCL   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_ESCL     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO_ESCL   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD_ESCL      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TRAN            =SIMP(statut='f',typ='R',max='**' ),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max='**' ),
+           CENTRE          =SIMP(statut='f',typ='R',max='**' ),
+           ELIM_MULT       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         ),
+
+         ECHANGE_PAROI   =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_MA_1','MAILLE_1'),
+                   UN_PARMI('GROUP_MA_2','MAILLE_2'),),
+           GROUP_MA_1      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_1        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA_2      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_2        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           COEF_H          =SIMP(statut='f',typ='R'),
+           TRAN            =SIMP(statut='f',typ='R',min=2,max=3),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+           CENTRE          =SIMP(statut='f',typ='R',min=2,max=3),
+                         ),
+
+         LIAISON_UNIF    =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
+           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='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           DDL             =SIMP(statut='f',typ='TXM',max='**',defaut="TEMP",
+                                 into=("TEMP","TEMP_INF","TEMP_SUP") ),
+         ),
+
+         LIAISON_CHAMNO  =FACT(statut='f',max='**',
+           CHAM_NO         =SIMP(statut='o',typ=cham_no_sdaster),# CO()# "il faut definir une structure de donnee generique chamno"
+           COEF_IMPO       =SIMP(statut='o',typ='R' ),
+           NUME_LAGR       =SIMP(statut='f',typ='TXM',defaut="NORMAL",into=("NORMAL","APRES") ),
+         ),
+
+         CONVECTION      =FACT(statut='f',max='**',
+           VITESSE         =SIMP(statut='o',typ=(cham_no_sdaster) ),
+         ),
+
+
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 16/09/2008   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.
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+AFFE_CHAR_THER_F=OPER(nom="AFFE_CHAR_THER_F",op=34,sd_prod=char_ther,
+                     fr="Affectation de charges et conditions aux limites thermiques fonction d'un (ou plusieurs)"
+                         +" paramètres (temps, ...)",
+                     reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+      regles=(AU_MOINS_UN('TEMP_IMPO','SOURCE','FLUX_REP','FLUX_NL','ECHANGE',
+                          'ECHANGE_PAROI','LIAISON_DDL','LIAISON_GROUP','LIAISON_UNIF',
+                          'GRAD_TEMP_INIT','RAYONNEMENT'),),
+         MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+
+         TEMP_IMPO       =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
+                   AU_MOINS_UN('TEMP_SUP','TEMP','TEMP_INF'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           DDL             =SIMP(statut='f',typ='TXM',into=("TEMP",) ),
+           TEMP            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_INF        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_SUP        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         FLUX_REP        =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FLUN','FLUN_INF','FLUN_SUP','FLUX_X','FLUX_Y','FLUX_Z'),),
+           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='**'),
+           FLUN            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUN_INF        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUN_SUP        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUX_X          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUX_Y          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUX_Z          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         FLUX_NL         =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   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='**'),
+           FLUN            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+
+         RAYONNEMENT     =FACT(statut='f',max='**',
+           fr="Attention, exprimer les températures en Celsius si rayonnement",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   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='**'),
+           SIGMA           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           EPSILON         =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_EXT        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+
+
+         ECHANGE         =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('COEF_H','COEF_H_INF','COEF_H_SUP'),
+                   ENSEMBLE('COEF_H','TEMP_EXT'),
+                   ENSEMBLE('COEF_H_INF','TEMP_EXT_INF'),
+                   ENSEMBLE('COEF_H_SUP','TEMP_EXT_SUP'),),
+           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='**'),
+           COEF_H          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_EXT        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           COEF_H_INF      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_EXT_INF    =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           COEF_H_SUP      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_EXT_SUP    =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+
+         SOURCE          =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           SOUR            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         GRAD_TEMP_INIT  =FACT(statut='f',max='**',
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),
+                   PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                   AU_MOINS_UN('FLUX_X','FLUX_Y','FLUX_Z'),),
+           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='**'),
+           FLUX_X          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUX_Y          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FLUX_Z          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         ECHANGE_PAROI   =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_MA_1','MAILLE_1'),
+                        UN_PARMI('GROUP_MA_2','MAILLE_2'),),
+           GROUP_MA_1      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_1        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA_2      =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE_2        =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           COEF_H          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TRAN            =SIMP(statut='f',typ='R',min=2,max=3),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+           CENTRE          =SIMP(statut='f',typ='R',min=2,max=3),
+         ),
+
+        LIAISON_DDL     =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_NO','NOEUD'),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,max='**'),
+           DDL             =SIMP(statut='f',typ='TXM',max='**',into=("TEMP","TEMP_INF","TEMP_SUP") ),
+           COEF_MULT       =SIMP(statut='o',typ='R',max='**'),
+           COEF_IMPO       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         LIAISON_GROUP   =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_MA_1','MAILLE_1','GROUP_NO_1','NOEUD_1'),
+                   UN_PARMI('GROUP_MA_2','MAILLE_2','GROUP_NO_2','NOEUD_2'),
+                             EXCLUS('GROUP_MA_1','GROUP_NO_2'),
+                        EXCLUS('GROUP_MA_1','NOEUD_2'),
+                   EXCLUS('GROUP_NO_1','GROUP_MA_2'),
+                        EXCLUS('GROUP_NO_1','MAILLE_2'),
+                        EXCLUS('MAILLE_1','GROUP_NO_2'),
+                        EXCLUS('MAILLE_1','NOEUD_2'),
+                        EXCLUS('NOEUD_1','GROUP_MA_2'),
+                        EXCLUS('NOEUD_1','MAILLE_2'),
+                        EXCLUS('SANS_NOEUD','SANS_GROUP_NO'),),
+           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='**'),
+           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='**'),
+           SANS_NOEUD      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           SANS_GROUP_NO   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           DDL_1           =SIMP(statut='f',typ='TXM',max='**',defaut="TEMP",
+                                 into=("TEMP","TEMP_INF","TEMP_SUP") ),
+           COEF_MULT_1     =SIMP(statut='o',typ='R',max='**'),
+           DDL_2           =SIMP(statut='f',typ='TXM',max='**',defaut="TEMP",
+                                 into=("TEMP","TEMP_INF","TEMP_SUP") ),
+           COEF_MULT_2     =SIMP(statut='o',typ='R',max='**'),
+           COEF_IMPO       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           SOMMET          =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           TRAN            =SIMP(statut='f',typ='R',max='**'),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max='**'),
+           CENTRE          =SIMP(statut='f',typ='R',max='**'),
+         ),
+
+         LIAISON_UNIF    =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
+           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='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           DDL             =SIMP(statut='f',typ='TXM',defaut="TEMP",
+                                 into=("TEMP","TEMP_INF","TEMP_SUP") ),
+         ),
+
+         CONVECTION      =FACT(statut='f',max='**',
+           VITESSE         =SIMP(statut='o',typ=cham_no_sdaster ),
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 12/05/2009   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.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater,
+                   fr="Affecter des matériaux à des zones géométriques d'un maillage",
+                         reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster),
+         MODELE          =SIMP(statut='f',typ=modele_sdaster),
+
+         #  affectation du nom du matériau (par mailles):
+         #  ----------------------------------------------
+         AFFE            =FACT(statut='o',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           MATER           =SIMP(statut='o',typ=mater_sdaster,max=30),
+         ),
+
+         #  affectation de comportement (multifibres pour l'instant):
+         #  ----------------------------------------------
+         AFFE_COMPOR        =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           COMPOR          =SIMP(statut='o',typ=compor_sdaster,max=1),
+         ),
+
+         #  affectation des variables de commande :
+         #  --------------------------------------------------
+         # un mot clé caché qui ne sert qu'à boucler sur les VARC possibles :
+         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='**',
+          regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                  PRESENT_ABSENT('GROUP_MA','TOUT'),
+                  PRESENT_ABSENT('MAILLE','TOUT'),
+                  AU_MOINS_UN('EVOL','CHAMP_GD','VALE_REF'),
+                  EXCLUS('EVOL','CHAMP_GD'),
+                  ),
+
+          TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ), # [défaut]
+          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")),
+          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'),
+              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)),
+          ),
+          VALE_REF          =SIMP(statut='f',typ='R'),
+         ),
+
+         #  mots clés cachés pour les variables de commande NEUTi :
+         #  -------------------------------------------------------
+         VARC_NEUT1   =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="NEUT1"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="NEUT_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("X1")),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("NEUT1")),
+         ),
+         VARC_NEUT2   =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="NEUT2"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="NEUT_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("X1")),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("NEUT2")),
+         ),
+
+         #  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.,)),
+         ),
+
+         #  mots clés cachés pour variable de commande SECH :
+         #  --------------------------------------------------
+         VARC_SECH    =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="SECH"),
+           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=("SECH",)),
+         ),
+
+         #  mots clés cachés pour variable de commande HYDR :
+         #  --------------------------------------------------
+         VARC_HYDR    =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="HYDR"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="HYDR_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("HYDR",)),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("HYDR",)),
+         ),
+
+         #  mots clés cachés pour variable de commande CORR :
+         #  --------------------------------------------------
+         VARC_CORR    =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="CORR"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="CORR_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("CORR",)),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("CORR",)),
+         ),
+
+         #  mots clés cachés pour variable de commande IRRA :
+         #  --------------------------------------------------
+         VARC_IRRA    =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="IRRA"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="IRRA_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("IRRA",)),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=1,min=1,defaut=("IRRA",)),
+         ),
+
+         #  mots clés cachés pour variable de commande EPSA :
+         #  --------------------------------------------------
+         VARC_EPSA    =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="EPSA"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="EPSI_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPXX","EPYY","EPZZ","EPXY","EPXZ","EPYZ",)),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPSAXX","EPSAYY","EPSAZZ","EPSAXY","EPSAXZ","EPSAYZ",)),
+         ),
+         #  mots clés cachés pour variable de commande metallurgique ACIER :
+         #  -----------------------------------------------------------------
+         VARC_M_ACIER  =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="M_ACIER"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="VARI_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=7,min=7,defaut=("V1","V2","V3","V4","V5","V6","V7")),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=7,min=7,defaut=("PFERRITE","PPERLITE","PBAINITE",
+                                                                          "PMARTENS","TAUSTE","TRANSF","TACIER",)),
+         ),
+         #  mots clés cachés pour variable de commande metallurgique ZIRCALOY :
+         #  --------------------------------------------------------------------
+         VARC_M_ZIRC  =FACT(statut='d',
+           NOM_VARC        =SIMP(statut='c',typ='TXM',defaut="M_ZIRC"),
+           GRANDEUR        =SIMP(statut='c',typ='TXM',defaut="VARI_R"),
+           CMP_GD          =SIMP(statut='c',typ='TXM',max=4,min=4,defaut=("V1","V2","V3","V4")),
+           CMP_VARC        =SIMP(statut='c',typ='TXM',max=4,min=4,defaut=("ALPHPUR","ALPHBETA","TZIRC","TEMPS")),
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  ;
+
+
+#& MODIF COMMANDE  DATE 16/06/2009   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.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+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) ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+         VERIF           =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2,into=("MAILLE","NOEUD") ),
+#
+#====
+# Définition des grandeurs caractéristiques
+#====
+#
+         GRANDEUR_CARA =FACT(statut='f',max=1,
+         fr="Grandeurs caractéristiques pour l'adimensionnement des indicateurs d'erreur HM",
+         ang="Characteristic data for HM error estimators adimensionalisation",
+#
+            LONGUEUR      =SIMP(statut='f',typ='R',val_min=0,
+                                fr ="Longueur caractéristique",
+                                ang="Characteristic length",),
+            PRESSION      =SIMP(statut='f',typ='R',val_min=0,
+                                fr ="Pression caractéristique",
+                                ang="Characteristic pressure",),
+            TEMPERATURE   =SIMP(statut='f',typ='R',val_min=0,
+                                fr ="Température caractéristique",
+                                ang="Characteristic temperature",),),
+#
+         AFFE_SOUS_STRUC =FACT(statut='f',
+           regles=(UN_PARMI('TOUT','SUPER_MAILLE'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           SUPER_MAILLE    =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+           PHENOMENE       =SIMP(statut='f',typ='TXM',defaut="MECANIQUE",into=("MECANIQUE",) ),
+         ),
+         AFFE            =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_MA','GROUP_NO','MAILLE','NOEUD'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           PHENOMENE       =SIMP(statut='o',typ='TXM',
+                                 into=("MECANIQUE","THERMIQUE","ACOUSTIQUE") ),
+                b_mecanique     =BLOC( condition = "PHENOMENE=='MECANIQUE'",
+                                        fr="modélisations mécaniques",
+                    MODELISATION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
+                                  "2D_DIS_T",        # RESP. : FLEJOU J.L.FLEJOU
+                                  "2D_DIS_TR",       # RESP. : FLEJOU J.L.FLEJOU
+                                  "2D_FLUI_ABSO",    # RESP. : DEVESA G.DEVESA
+                                  "2D_FLUI_PESA",    # RESP. : GREFFET N.GREFFET
+                                  "2D_FLUI_STRU",    # RESP. : GREFFET N.GREFFET
+                                  "2D_FLUIDE",       # RESP. : GREFFET N.GREFFET
+                                  "3D",              # RESP. : DESROCHES X.DESROCHES
+                                  "3D_ABSO",         # RESP. : DEVESA G.DEVESA
+                                  "3D_FAISCEAU",     # RESP. : VOLDOIRE F.VOLDOIRE
+                                  "3D_FLUI_ABSO",    # RESP. : DEVESA G.DEVESA
+                                  "3D_FLUIDE",       # RESP. : GREFFET N.GREFFET
+                                  "3D_INCO",         # RESP. : MICHEL S.MICHEL
+                                  "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_XFEM_CONT",    # RESP. : GENIAUT S.GENIAUT
+                                  "3D_JOINT",        # 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_GD",    # RESP. : MICHEL S.MICHEL
+                                  "AXIS_SI",         # RESP. : DESROCHES X.DESROCHES
+                                  "AXIS_GRAD_VARI",  # RESP. : MICHEL S.MICHEL
+                                  "AXIS_JOINT",      # RESP. : LAVERNE J.LAVERNE
+                                  "AXIS_INTERFACE",  # RESP. : LAVERNE J.LAVERNE
+                                  "AXIS_ELDI",       # RESP. : LAVERNE J.LAVERNE
+                                  "BARRE",           # RESP. : FLEJOU J.L.FLEJOU
+                                  "2D_BARRE",        # RESP. : FLEJOU J.L.FLEJOU
+                                  "C_PLAN",          # RESP. : LEFEBVRE J.P.LEFEBVRE
+                                  "C_PLAN_XFEM_CONT",# RESP. : GENIAUT S.GENIAUT
+                                  "C_PLAN_SI",       # RESP. : DESROCHES X.DESROCHES
+                                  "C_PLAN_GRAD_EPSI",# RESP. : MICHEL S.MICHEL
+                                  "CABLE",           # RESP. : FLEJOU J.L.FLEJOU
+                                  "CABLE_POULIE",    # RESP. : None
+                                  "COQUE_3D",        # RESP. : DESROCHES X.DESROCHES
+                                  "COQUE_AXIS",      # RESP. : DESROCHES X.DESROCHES
+                                  "COQUE_C_PLAN",    # RESP. : DESROCHES X.DESROCHES
+                                  "COQUE_D_PLAN",    # RESP. : DESROCHES X.DESROCHES
+                                  "D_PLAN",          # RESP. : LEFEBVRE J.P.LEFEBVRE
+                                  "D_PLAN_XFEM_CONT",# RESP. : GENIAUT S.GENIAUT
+                                  "D_PLAN_GRAD_EPSI",# RESP. : MICHEL S.MICHEL
+                                  "D_PLAN_GRAD_VARI",# RESP. : MICHEL S.MICHEL
+                                  "PLAN_JOINT",      # 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_GD",  # RESP. : MICHEL S.MICHEL
+                                  "D_PLAN_SI",       # RESP. : DESROCHES X.DESROCHES
+                                  "DIS_T",           # RESP. : FLEJOU J.L.FLEJOU
+                                  "DIS_TR",          # RESP. : FLEJOU J.L.FLEJOU
+                                  "DKT",             # RESP. : DESROCHES X.DESROCHES
+                                  "DKTG",            # RESP. : MARKOVIC D.MARKOVIC
+                                  "DST",             # RESP. : DESROCHES X.DESROCHES
+                                  "FLUI_STRU",       # RESP. : GREFFET N.GREFFET
+                                  "GRILLE_EXCENTRE", # RESP. : ROSPARS C.ROSPARS
+                                  "GRILLE_MEMBRANE", # RESP. : ROSPARS C.ROSPARS
+                                  "POU_C_T",         # RESP. : FLEJOU J.L.FLEJOU
+                                  "POU_D_E",         # RESP. : FLEJOU J.L.FLEJOU
+                                  "POU_D_EM",        # RESP. : FLEJOU J.L.FLEJOU
+                                  "POU_D_T",         # RESP. : FLEJOU J.L.FLEJOU
+                                  "POU_D_T_GD",      # RESP. : FLEJOU J.L.FLEJOU
+                                  "POU_D_TG",        # RESP. : FLEJOU J.L.FLEJOU
+                                  "POU_D_TGM",       # RESP. : FLEJOU J.L.FLEJOU
+                                  "Q4G",             # RESP. : DESROCHES X.DESROCHES
+                                  "TUYAU_3M",        # RESP. : PROIX J.M.PROIX
+                                  "TUYAU_6M",        # RESP. : PROIX J.M.PROIX
+                                  "SHB8",            # 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
+                                  "D_PLAN_HMD",      # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THHD",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THH2D",    # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THVD",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THH2MD",   # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THHMD",    # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THMD",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_HHMS",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_HH2MS",    # RESP. : GRANET S.GRANET
+                                  "D_PLAN_HMS",      # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THHS",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THH2S",    # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THVS",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THH2MS",   # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THHMS",    # RESP. : GRANET S.GRANET
+                                  "D_PLAN_THMS",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_HM_P",     # RESP. : GRANET S.GRANET
+                                  "D_PLAN_HHD",      # RESP. : GRANET S.GRANET
+                                  "D_PLAN_HHS",      # RESP. : GRANET S.GRANET
+                                  "D_PLAN_HH2D",     # RESP. : GRANET S.GRANET
+                                  "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
+                                  "AXIS_HH2MD",      # RESP. : GRANET S.GRANET
+                                  "AXIS_HHMD",       # RESP. : GRANET S.GRANET
+                                  "AXIS_HMD",        # RESP. : GRANET S.GRANET
+                                  "AXIS_THHD",       # RESP. : GRANET S.GRANET
+                                  "AXIS_THH2D",      # RESP. : GRANET S.GRANET
+                                  "AXIS_THVD",       # RESP. : GRANET S.GRANET
+                                  "AXIS_THHMD",      # RESP. : GRANET S.GRANET
+                                  "AXIS_THH2MD",     # RESP. : GRANET S.GRANET
+                                  "AXIS_THMD",       # RESP. : GRANET S.GRANET
+                                  "AXIS_HH2MS",      # RESP. : GRANET S.GRANET
+                                  "AXIS_HHMS",       # RESP. : GRANET S.GRANET
+                                  "AXIS_HMS",        # RESP. : GRANET S.GRANET
+                                  "AXIS_THHS",       # RESP. : GRANET S.GRANET
+                                  "AXIS_THH2S",      # RESP. : GRANET S.GRANET
+                                  "AXIS_THVS",       # RESP. : GRANET S.GRANET
+                                  "AXIS_THHMS",      # RESP. : GRANET S.GRANET
+                                  "AXIS_THH2MS",     # RESP. : GRANET S.GRANET
+                                  "AXIS_THMS",       # RESP. : GRANET S.GRANET
+                                  "AXIS_HHD",        # RESP. : GRANET S.GRANET
+                                  "AXIS_HHS",        # RESP. : GRANET S.GRANET
+                                  "AXIS_HH2D",       # RESP. : GRANET S.GRANET
+                                  "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
+                                  "3D_HMD",          # RESP. : GRANET S.GRANET
+                                  "3D_THHD",         # RESP. : GRANET S.GRANET
+                                  "3D_THVD",         # RESP. : GRANET S.GRANET
+                                  "3D_THHMD",        # RESP. : GRANET S.GRANET
+                                  "3D_THMD",         # RESP. : GRANET S.GRANET
+                                  "3D_HHMS",         # RESP. : GRANET S.GRANET
+                                  "3D_HMS",          # RESP. : GRANET S.GRANET
+                                  "3D_THHS",         # RESP. : GRANET S.GRANET
+                                  "3D_THVS",         # RESP. : GRANET S.GRANET
+                                  "3D_THHMS",        # RESP. : GRANET S.GRANET
+                                  "3D_THMS",         # RESP. : GRANET S.GRANET
+                                  "3D_THH2MD",       # RESP. : GRANET S.GRANET
+                                  "3D_THH2MS",       # RESP. : GRANET S.GRANET
+                                  "3D_HH2MD",        # RESP. : GRANET S.GRANET
+                                  "3D_HH2MS",        # RESP. : GRANET S.GRANET
+                                  "3D_THH2S",        # RESP. : GRANET S.GRANET
+                                  "3D_THH2D",        # RESP. : GRANET S.GRANET
+                                  "3D_HHD",          # RESP. : GRANET S.GRANET
+                                  "3D_HHS",          # RESP. : GRANET S.GRANET
+                                  "3D_HH2D",         # RESP. : GRANET S.GRANET
+                                  "3D_HH2S",         # RESP. : GRANET S.GRANET
+                                  "VF1",             # RESP. : GRANET S.GRANET
+                                                                     )  )  ),
+
+                b_thermique     =BLOC( condition = "PHENOMENE=='THERMIQUE'",
+                                        fr="modélisations thermiques",
+                    MODELISATION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
+                                  "3D",              # RESP. : DURAND C.DURAND
+                                  "3D_DIAG",         # RESP. : DURAND C.DURAND
+                                  "AXIS",            # RESP. : DURAND C.DURAND
+                                  "AXIS_DIAG",       # RESP. : DURAND C.DURAND
+                                  "AXIS_FOURIER",    # RESP. : DESROCHES X.DESROCHES
+                                  "COQUE",           # RESP. : DESROCHES X.DESROCHES
+                                  "COQUE_AXIS",      # RESP. : DESROCHES X.DESROCHES
+                                  "COQUE_PLAN",      # RESP. : DESROCHES X.DESROCHES
+                                  "PLAN",            # RESP. : DURAND C.DURAND
+                                  "PLAN_DIAG",       # RESP. : DURAND C.DURAND
+                                                                      ),),),
+
+                b_acoustique    =BLOC( condition = "PHENOMENE=='ACOUSTIQUE'",
+                                        fr="modélisations acoustiques",
+                     MODELISATION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
+                                  "3D",              # RESP. : None
+                                  "PLAN"             # RESP. : None
+                                                                       ), ),),
+
+         ),
+
+         PARTITION         =FACT(statut='d',
+             PARALLELISME    =SIMP(statut='f',typ='TXM',defaut="MAIL_DISPERSE",
+                                   into=("MAIL_CONTIGU","MAIL_DISPERSE","SOUS_DOMAINE","CENTRALISE",)),
+             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),
+             ),
+             b_dist_maille          =BLOC(condition = "PARALLELISME in ('MAIL_DISPERSE','MAIL_CONTIGU')",
+                 CHARGE_PROC0_MA =SIMP(statut='f',typ='I',defaut=100,val_min=0),
+             ),
+         ),
+
+         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 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+AIDE=PROC(nom="AIDE",op=42,
+       UIinfo={"groupes":("Modélisation",)},
+       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",) ),
+         ),
+) ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+ASSE_MAILLAGE=OPER(nom="ASSE_MAILLAGE",op= 105,sd_prod=maillage_sdaster,
+                   fr="Assembler deux maillages pour en former un nouveau",
+                   reentrant='n',
+                   UIinfo={"groupes":("Maillage",)},
+         MAILLAGE_1 =  SIMP(statut='o',typ=maillage_sdaster,),
+         MAILLAGE_2 =  SIMP(statut='o',typ=maillage_sdaster,),
+         OPERATION  =  SIMP(statut='o',typ='TXM',into=("SOUS_STR","SUPERPOSE","COLLAGE"),),
+         b_collage  =  BLOC(condition = "OPERATION == 'COLLAGE'",
+           COLLAGE  =  FACT(statut='o',
+              GROUP_MA_1     =SIMP(statut='o',typ=grma),
+              GROUP_MA_2     =SIMP(statut='o',typ=grma),
+                             ),
+                           ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE BODEL C.BODEL
+def asse_matr_gene_prod(METHODE,**args):
+    if   (METHODE=="INITIAL") : return matr_asse_gene_r
+    elif (args['OPTION']=="RIGI_GENE_C") : return matr_asse_gene_c
+    else : return matr_asse_gene_r
+
+ASSE_MATR_GENE=OPER(nom="ASSE_MATR_GENE",op= 128,sd_prod=asse_matr_gene_prod,
+                    fr="Assemblage des matrices généralisées de macro éléments pour construction de la matrice globale généralisée",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         NUME_DDL_GENE   =SIMP(statut='o',typ=nume_ddl_gene ),
+         METHODE          =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","INITIAL") ),
+         b_option     =BLOC(condition = "METHODE == 'CLASSIQUE'",
+           OPTION          =SIMP(statut='o',typ='TXM',into=("RIGI_GENE","RIGI_GENE_C","MASS_GENE","AMOR_GENE") ),
+           ),
+)  ;
+#& MODIF COMMANDE  DATE 06/10/2008   AUTEUR DEVESA G.DEVESA 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def asse_matrice_prod(MATR_ELEM,**args):
+  if AsType(MATR_ELEM) == matr_elem_depl_r : return matr_asse_depl_r
+  if AsType(MATR_ELEM) == matr_elem_depl_c : return matr_asse_depl_c
+  if AsType(MATR_ELEM) == matr_elem_temp_r : return matr_asse_temp_r
+  if AsType(MATR_ELEM) == matr_elem_pres_c : return matr_asse_pres_c
+  raise AsException("type de concept resultat non prevu")
+
+ASSE_MATRICE=OPER(nom="ASSE_MATRICE",op=12,sd_prod=asse_matrice_prod,
+                  fr="Construction d'une matrice assemblée",reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         MATR_ELEM       =SIMP(statut='o',
+                               typ=(matr_elem_depl_r,matr_elem_depl_c,matr_elem_temp_r,matr_elem_pres_c) ),
+         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster),
+         SYME            =SIMP(statut='f',typ='TXM',into=("OUI",) ),         
+         CHAR_CINE       =SIMP(statut='f',typ=(char_cine_meca,char_cine_ther,char_cine_acou) ),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+
+ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster,
+                  fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         VECT_ELEM       =SIMP(statut='o',typ=vect_elem,max='**'),
+         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster ),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2,) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# 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 BODEL C.BODEL
+ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene,
+                    fr="Projection des chargements sur la base modale d'une sous structure",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         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 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DEVESA G.DEVESA
+CALC_AMOR_MODAL=OPER(nom="CALC_AMOR_MODAL",op= 172,sd_prod=listr8_sdaster,
+                     fr="Création d'une liste d'amortissements modaux calculés selon la règle du RCC-G",
+                     reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         ENER_SOL        =FACT(statut='o',
+           regles=(UN_PARMI('GROUP_NO_RADIER','GROUP_MA_RADIER'),
+                   PRESENT_ABSENT('COEF_GROUP','FONC_GROUP'),
+#  Peut-on remplacer les deux règles suivantes par un ENSEMBLE_('KRX','KRY','KRZ')
+                   PRESENT_PRESENT('KRX','KRY'),
+                   PRESENT_PRESENT('KRX','KRZ'),
+                   PRESENT_ABSENT('COOR_CENTRE','NOEUD_CENTRE'),
+                   PRESENT_ABSENT('GROUP_NO_CENTRE','NOEUD_CENTRE'),
+                   PRESENT_ABSENT('GROUP_NO_CENTRE','COOR_CENTRE'),),
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","RIGI_PARASOL") ),
+           MODE_MECA       =SIMP(statut='o',typ=mode_meca ),
+           GROUP_NO_RADIER =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           GROUP_MA_RADIER =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           FONC_GROUP      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           COEF_GROUP      =SIMP(statut='f',typ='R',max='**'),
+           KX              =SIMP(statut='o',typ='R' ),
+           KY              =SIMP(statut='o',typ='R' ),
+           KZ              =SIMP(statut='o',typ='R' ),
+           KRX             =SIMP(statut='f',typ='R' ),
+           KRY             =SIMP(statut='f',typ='R' ),
+           KRZ             =SIMP(statut='f',typ='R' ),
+           GROUP_NO_CENTRE =SIMP(statut='f',typ=grno),
+           NOEUD_CENTRE    =SIMP(statut='f',typ=no),
+           COOR_CENTRE     =SIMP(statut='f',typ='R',max=3),
+         ),
+         AMOR_INTERNE    =FACT(statut='o',
+           ENER_POT        =SIMP(statut='o',typ=table_sdaster ),
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+           AMOR_REDUIT     =SIMP(statut='o',typ='R',max='**'),
+         ),
+         AMOR_SOL        =FACT(statut='o',
+           AMOR_REDUIT     =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           FONC_AMOR_GEO   =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule),max='**' ),
+           HOMOGENE        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           SEUIL           =SIMP(statut='f',typ='R',defaut= 0.3 ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+
+CALC_CHAM_ELEM=OPER(nom="CALC_CHAM_ELEM",op=38,sd_prod=cham_elem,
+                    fr="Calculer un champ élémentaire en thermique et en accoustique à partir de champs déjà calculés",
+                    reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+
+         regles=(EXCLUS('TOUT','GROUP_MA',),EXCLUS('TOUT','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='**'),
+
+#
+#
+#  introduire un mot cle de type modelisation : mécanique,thermique,...
+#
+
+         OPTION          =SIMP(statut='o',typ='TXM',
+                               into=("FLUX_ELGA_TEMP","FLUX_ELNO_TEMP",
+                                     "PRES_ELNO_DBEL","PRES_ELNO_REEL","PRES_ELNO_IMAG",
+                                     "COOR_ELGA"), ),
+
+         b_thermique  =BLOC(condition="OPTION in ('FLUX_ELNO_TEMP','FLUX_ELGA_TEMP',)",
+           TEMP            =SIMP(statut='o',typ=(cham_no_sdaster,)),
+         ),
+
+         b_acoustique  =BLOC(condition="OPTION in ('PRES_ELNO_DBEL','PRES_ELNO_REEL','PRES_ELNO_IMAG',)",
+           PRES            =SIMP(statut='o',typ=(cham_no_sdaster,)),
+         ),
+
+
+
+         EXCIT           =FACT(statut='f',max='**',
+               regles=(EXCLUS('FONC_MULT','COEF_MULT', ),),
+               CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou)),
+               FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+               COEF_MULT       =SIMP(statut='f',typ='R'), ),
+
+         INST            =SIMP(statut='f',typ='R',defaut= 0.E+0),
+         ACCE            =SIMP(statut='f',typ=cham_no_sdaster),
+         NUME_COUCHE     =SIMP(statut='f',typ='I',defaut= 1),
+         NIVE_COUCHE     =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY") ),
+         MODE_FOURIER    =SIMP(statut='f',typ='I',defaut= 0 ),
+         ANGLE           =SIMP(statut='f',typ='I',defaut= 0),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+
+CALC_CHAR_CINE=OPER(nom="CALC_CHAR_CINE",op= 102,sd_prod=cham_no_sdaster,
+                    fr="Calcul des seconds membres associés à des charges cinématiques (conditions aux limites non dualisées)",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster ),
+         CHAR_CINE       =SIMP(statut='o',typ=(char_cine_meca,char_cine_ther,char_cine_acou ),validators=NoRepeat(),max='**' ),
+         INST            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 DEVESA G.DEVESA
+def calc_char_seisme_prod(MATR_MASS,**args ):
+  if AsType(MATR_MASS) == matr_asse_depl_r : return cham_no_sdaster
+  raise AsException("type de concept resultat non prevu")
+
+CALC_CHAR_SEISME=OPER(nom="CALC_CHAR_SEISME",op=  92,sd_prod=calc_char_seisme_prod,
+                      reentrant='n',fr="Calcul du chargement sismique",
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=(UN_PARMI('MONO_APPUI','MODE_STAT' ),),
+         MATR_MASS       =SIMP(statut='o',typ=matr_asse_depl_r,fr="Matrice de masse" ),
+         DIRECTION       =SIMP(statut='o',typ='R',max=6,fr="Directions du séisme imposé"),
+         MONO_APPUI      =SIMP(statut='f',typ='TXM',into=("OUI",) ),         
+         MODE_STAT       =SIMP(statut='f',typ=(mode_meca,) ),
+         b_mode_stat     =BLOC ( condition = "MODE_STAT != None",
+           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='**'),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 02/11/2009   AUTEUR ASSIRE A.ASSIRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE MICHEL S.MICHEL
+
+from Macro.calc_ecrevisse_ops import calc_ecrevisse_ops
+
+def calc_ecrevisse_prod(self,CHARGE_MECA,CHARGE_THER1,CHARGE_THER2,TABLE,DEBIT,**args):
+
+  self.type_sdprod(CHARGE_MECA,char_meca)   
+  self.type_sdprod(CHARGE_THER1,char_ther)
+  self.type_sdprod(CHARGE_THER2,char_ther)
+  self.type_sdprod(TABLE,table_sdaster)
+  self.type_sdprod(DEBIT,table_sdaster)
+  return None
+
+
+
+CALC_ECREVISSE=MACRO(nom="CALC_ECREVISSE",op=calc_ecrevisse_ops,sd_prod=calc_ecrevisse_prod,reentrant='n',
+                     UIinfo={"groupes":("Outils metier",)},fr="Procedure de couplage avec Ecrevisse",
+
+
+#      CONCEPTS SORTANTS : 2 CHARGEMENTS THERMIQUE + 1 MECANIQUE + 2 TABLES POUR LE POST-TRAITEMENT
+#      ********************************************
+         CHARGE_MECA        =SIMP(statut='o',typ=CO),
+         CHARGE_THER1       =SIMP(statut='o',typ=CO),
+         CHARGE_THER2       =SIMP(statut='o',typ=CO),
+         TABLE              =SIMP(statut='o',typ=CO),
+         DEBIT              =SIMP(statut='o',typ=CO),
+         
+
+#      MODELES MECANIQUES 
+#      ********************************************
+         MODELE_MECA        =SIMP(statut='o',typ=modele_sdaster),
+         MODELE_THER        =SIMP(statut='o',typ=modele_sdaster),
+
+
+#      DONNEES GEOMETRIQUES RELATIVES AUX RESULTATS
+#      ********************************************
+         RESULTAT           =FACT(statut='o',min=1,max=1,
+           MECANIQUE           =SIMP(statut='o',typ=resultat_sdaster),
+           THERMIQUE           =SIMP(statut='o',typ=resultat_sdaster),
+           regles=(EXCLUS('NUME_ORDRE','INST'),),
+           NUME_ORDRE          =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           INST                =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+         ),
+
+#      DONNEES GEOMETRIQUES RELATIVES A LA FISSURE
+#      *******************************************
+
+         FISSURE            =FACT(statut='o',min=1,max='**',
+           PREFIXE_FICHIER     =SIMP(statut='f',typ='TXM',validators=LongStr(1,8), defaut="FISSURE1"),
+           GROUP_MA            =SIMP(statut='o',typ=grma,validators=NoRepeat(),max=2,
+                                     fr="Groupe(s) des noeuds definissant les levres de la fissure"),
+           GROUP_NO_ORIG       =SIMP(statut='o',typ=grno,validators=NoRepeat(),max=2),
+           GROUP_NO_EXTR       =SIMP(statut='o',typ=grno,validators=NoRepeat(),max=2),
+           ZETA                =SIMP(statut='o',typ='R',fr="Coefficient de la perte de charge singuliere a l'entree [zeta]" ),
+           RUGOSITE            =SIMP(statut='o',typ='R',fr="Rugosite absolu (metres) [eps]" ),
+           OUVERT_REMANENTE    =SIMP(statut='o',typ='R',val_min=0.,defaut=10.E-6,fr="Ouverture remanente"),
+           TORTUOSITE          =SIMP(statut='f',typ='R',defaut=1.0, val_min=0., val_max=1.0,
+                                       fr="Coefficient de tortuosite de la fissure" ),
+           SECTION             =SIMP(statut='o',typ='TXM',into=("ELLIPSE","RECTANGLE"),fr="Type de section [is]" ),
+           b_section_ellipse   =BLOC(condition="SECTION=='ELLIPSE'",fr="Fissure a section elliptique",
+             LISTE_COTES_BL      =SIMP(statut='f',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant le petit axe de la section",
+                                       validators=NoRepeat() ),
+             LISTE_VAL_BL        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant le petit axe de la section", ),
+           ),
+           b_section_rectangle =BLOC(condition="SECTION=='RECTANGLE'",fr="Fissure a section rectangulaire",
+             LISTE_COTES_BL      =SIMP(statut='f',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant la largeur de la section",
+                                       validators=NoRepeat() ),
+             LISTE_VAL_BL        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant la largeur de la section", ),
+           ),
+         ),
+
+
+#      DONNEES RELATIVES A L"ECOULEMENT
+#      ********************************
+
+         ECOULEMENT         =FACT(statut='o',min=1,max=1,
+           PRES_ENTREE         =SIMP(statut='o',typ='R',fr="Pression de stagnation a l'entree (Pa) [pe]" ),
+           PRES_SORTIE         =SIMP(statut='o',typ='R',fr="Pression de stagnation a la sortie (Pa) [ps]" ),
+           FLUIDE_ENTREE       =SIMP(statut='o',typ='I',into=(1,2,3,4,5,6),fr="Condition du fluide a l'entree [iflow]" ),
+           b_condition_1       =BLOC(condition="FLUIDE_ENTREE==1",fr="Eau sous-refroidie ou saturee",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+           ),
+           b_condition_2       =BLOC(condition="FLUIDE_ENTREE==2",fr="Fluide diphasique",
+             TITR_MASS           =SIMP(statut='o',typ='R',fr="Titre massique eau vap/eau tot a l'entree [xe]" ),
+           ),
+           b_condition_3       =BLOC(condition="FLUIDE_ENTREE==3",fr="Vapeur saturee ou surchauffee",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+           ),
+           b_condition_4       =BLOC(condition="FLUIDE_ENTREE==4",fr="Air + vapeur surchauffee",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+             PRES_PART           =SIMP(statut='o',typ='R',fr="Pression partielle air en entree (Pa) [pae]" ),
+           ),
+           b_condition_5       =BLOC(condition="FLUIDE_ENTREE==5",fr="Air + vapeur saturee",
+             TITR_MASS           =SIMP(statut='o',typ='R',fr="Titre massique eau vap/eau tot a l'entree [xe]" ),
+             PRES_PART           =SIMP(statut='o',typ='R',fr="Pression partielle air en entree (Pa) [pae]" ),
+           ),
+           b_condition_6       =BLOC(condition="FLUIDE_ENTREE==6",fr="Air seul",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+           ),
+         ),
+
+
+#      CHOIX DES MODELES
+#      *****************
+
+         MODELE_ECRE        =FACT(statut='o',min=1,max=1,
+           IVENAC              =SIMP(statut='f', typ='I', into=(0,1), defaut=0,
+                                     fr="Calcul ECREVISSE avec prise en compte de la vena contracta"),
+           ECOULEMENT          =SIMP(statut='o',typ='TXM',into=("SATURATION","GELE"),
+                                     fr="Type de modele d'ecoulement diphasique [imod]" ),
+           b_ecou_gele         =BLOC(condition="ECOULEMENT=='GELE'",fr="Modele d'ecoulement gele",
+             PRESS_EBULLITION    =SIMP(statut='o',typ='R',fr="Pression d'ebullition [corrp*psat(t)]" ),
+           ),
+           FROTTEMENT          =SIMP(statut='o',typ='I',into=(-3,-2,-1,0,1,2,3),fr="Correlation de frottement [ifrot]" ),
+           b_frottement        =BLOC(condition="FROTTEMENT<0",fr="Modele d'ecoulement gele",
+             REYNOLDS_LIM        =SIMP(statut='o',typ='R',fr="Coefficient de Reynolds limite [relim]" ),
+             FROTTEMENT_LIM      =SIMP(statut='o',typ='R',fr="Coefficient de frottement impose [frtlim]" ),
+           ),
+
+           TRANSFERT_CHAL      =SIMP(statut='o',typ='I',into=(-2,-1,0,1,2),fr="Transfert de chaleur [ichal]" ),
+           b_transchal         =BLOC(condition="TRANSFERT_CHAL<0", fr="Cas diphasique",
+             XMINCH              =SIMP(statut='o',typ='R',fr="Titre massique gazeux min [xminch]"),
+             XMAXCH              =SIMP(statut='o',typ='R',fr="Titre massique gazeux max [xmaxch]"),
+           ),  
+         ),
+
+
+#      DONNEES RELATIVES A LA CONVERGENCE NUMERIQUE
+#      ********************************************
+
+         CONVERGENCE        =FACT(statut='o',min=1,max=1,
+           KGTEST              =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut= 0.5E+0,
+                                     fr="Parametre de l'algorithme iteratif [kgtest]" ),
+           ITER_GLOB_MAXI      =SIMP(statut='f',typ='I',defaut= 400,
+                                     fr="Nombre maximum d'iterations de la methode de Newton [itnmax]" ),
+           CRIT_CONV_DEBI      =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut= 1.E-5,
+                                     fr="Critere de convergence en debit [precdb]" ),
+         ),
+
+#      GENERAL
+#      *******
+
+         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.1",into = ("3.1.1",)),
+         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,3) ),
+
+)  ;
+#& MODIF COMMANDE  DATE 02/11/2009   AUTEUR LEBOUVIER F.LEBOUVIER 
+#            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 ASSIRE A.ASSIRE
+def calc_elem_prod(RESULTAT,**args):
+   if AsType(RESULTAT) != None : return AsType(RESULTAT)
+   raise AsException("type de concept resultat non prevu")
+
+CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f',
+            UIinfo={"groupes":("Post traitements",)},
+            fr="Compléter ou créer un résultat en calculant des champs par éléments (contraintes, déformations,... )",
+     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à"),
+
+#    definition d'un repere local
+
+     REPE_COQUE      =FACT(statut='f',max='**',
+                           fr="définiton du lieu de post-traitement",
+                           regles=EXCLUS('ANGL_REP','VECTEUR'),
+          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='**',),
+
+          NUME_COUCHE  =SIMP(statut='f',typ='I',defaut= 1,
+                             fr="numero de couche dans l'épaisseur de la coque ou du tuyau" ),
+          NIVE_COUCHE  =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
+                             fr="position dans l'épaisseur de la coque, ou de la couche" ),
+
+          ANGLE        =SIMP(statut='f',typ='I',defaut= 0,
+                             fr="angle de dépouillement pour les tuyaux, en degres à partir de la génératrice" ),
+
+          PLAN         =SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL"),
+                               fr="Plan de calcul pour les plaques excentrées" ),
+
+          ANGL_REP     =SIMP(statut='f',typ='R',min=2,max=2,
+                           fr="définition du repere de post-traitement, par défaut ANGL_REP=(0.,0.)"),
+          VECTEUR      =SIMP(statut='f',typ='R',min=3,max=3,
+                           fr="définition du repere de post-traitement, par défaut VECTEUR=(1.,0.,0.)"),
+                            ),
+
+#    options pour des resultats lineaires
+
+     b_lineaire =BLOC( condition = "AsType(RESULTAT) in (evol_elas,dyna_trans,dyna_harmo,mode_meca,\
+                                                         comb_fourier,mult_elas,fourier_elas,mode_flamb)",
+                                                               fr="options mecaniques lineaires",
+          TYPE_OPTION =SIMP(statut='f',typ='TXM',defaut='TOUTES',fr="type d'options mecaniques lineaires",
+                           into=("SIGM_MASSIF","SIGM_STRUCT","EPSI","ENER","CRIT","DERIVEES",
+                                 "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",
+                              #  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","ARCO_ELNO_SIGM",
+                              # 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",
+                                 "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",
+                              #  estimateurs erreur
+                                 "SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM",
+                                 "SIRE_ELNO_DEPL","ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
+                                 "QIRE_ELEM_SIGM","QIRE_ELNO_ELEM","QIZ1_ELEM_SIGM","QIZ2_ELEM_SIGM",
+                                 "SING_ELEM","SING_ELNO_ELEM",
+                              #  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",
+                              #  autres
+                                 "VALE_NCOU_MAXI","PRES_DBEL_DEPL"),),
+
+               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)",
+                    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",),
+                                   fr="choix de l'estimateur d'erreur"),),
+
+               EXCIT           =FACT(statut='f',max='**',
+                                     fr="Charges contenant les températures, les efforts répartis pour les poutres...",
+                                     regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),),
+                    CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca) ),
+                    FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                    FONC_MULT_C     =SIMP(statut='f',typ=fonction_c),
+                    COEF_MULT       =SIMP(statut='f',typ='R'),
+                    COEF_MULT_C     =SIMP(statut='f',typ='C'),
+                    PHAS_DEG        =SIMP(statut='f',typ='R'),
+                    PUIS_PULS       =SIMP(statut='f',typ='I'),
+                    TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),),
+
+
+                            ),
+#             fin bloc b_toutes
+
+          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',
+                            fr="option de calcul des contraintes",
+                           into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL",),),
+
+                    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 ) ",
+                                      fr="charge contenant les temperatures ou autre charge",
+                         EXCIT           =FACT(statut='f',max='**',
+                         CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca) ),),
+                                    ),
+                                  ),
+
+          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',
+                            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 ) ",
+                                            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'),),
+                         CHARGE          =SIMP(statut='f',typ=(char_meca,char_cine_meca) ),
+                         FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                         FONC_MULT_C     =SIMP(statut='f',typ=fonction_c),
+                         COEF_MULT       =SIMP(statut='f',typ='R'),
+                         COEF_MULT_C     =SIMP(statut='f',typ='C'),
+                         PHAS_DEG        =SIMP(statut='f',typ='R'),
+                         PUIS_PULS       =SIMP(statut='f',typ='I'),
+                         TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),),
+                             ),
+
+
+                            ),
+#          fin bloc contraintes struct
+
+          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",),
+                                 ),
+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 ) ",
+                                      fr="charge contenant les temperatures",
+                    EXCIT           =FACT(statut='f',max='**',
+                         CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou,char_cine_meca,) ),),
+                                 ),
+                                       ),
+          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",),
+                                 ),
+               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 \
+                                      (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 ) ",
+                                      fr="charge contenant les temperatures",
+                    EXCIT           =FACT(statut='f',max='**',
+                         CHARGE          =SIMP(statut='f',typ=(char_meca,char_ther,char_acou) ),),
+                              ),
+                                 ),
+
+          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",
+                                 ) ),
+                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",
+                                 ) ),
+               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_indi_erreur        =BLOC( condition = "TYPE_OPTION=='INDI_ERREUR'",
+               OPTION    =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERRE_ELEM_SIGM",
+                           into=("SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM",
+                                 "SIRE_ELNO_DEPL","ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
+                                 "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)",
+                    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",),
+                                   fr="choix de l'estimateur d'erreur"),),
+
+               EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
+                     CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
+                                 ),
+                                 ),
+#    fin bloc lineaire
+
+#    statique ou dynamique non lineaire : evol_noli
+     b_noli          =BLOC( condition = "AsType(RESULTAT) == evol_noli",fr="options mecaniques non lineaires",
+          TYPE_OPTION =SIMP(statut='f',typ='TXM',defaut='TOUTES',fr="type d'options mecaniques non lineaires",
+                           into=("SIGM_MASSIF","SIGM_STRUCT","EPSI","ENER","CRIT",
+                                 "VARI","INDI_ERREUR","TOUTES","AUTRES"),
+                          ),
+          b_toutes =BLOC( condition = "TYPE_OPTION == 'TOUTES'",fr="toutes les options evol elas",
+               OPTION      =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
+                           into=( "SIEF_ELNO_ELGA",
+                                  "SIGM_ELNO_TUYO","SIGM_ELNO_COQU","ARCO_ELNO_SIGM",
+                                  "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","EFGE_ELNO_CART",
+                                  # 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",
+                                 "EPSP_ELNO","EPSP_ELGA",
+                                 "EPFD_ELNO","EPFD_ELGA","EPVC_ELNO","EPVC_ELGA",
+                                 "EPFP_ELNO","EPFP_ELGA",
+                                 "VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU","CRIT_ELNO_RUPT",
+                                 "EXTR_ELGA_VARI","EXTR_ELNO_VARI",
+                                 # 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"),
+                               ),
+               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"),
+
+               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)",
+                    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",),
+                                   fr="choix de l'estimateur d'erreur"),),
+
+
+               b_extr = BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')",
+                             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",
+                               "DIST_DEV","DEV_SUR_CRIT","DIST_ISO","NB_ITER","ARRET","NB_REDE","SIGNE",
+                               "RDEV_1","RDEV_2","RDEV_3","RISO","EPSIVPLA","IND_1","IND_2","IND_3","IND_4",),),
+                            ),
+               EXCIT           =FACT(statut='f',max='**',
+                                      regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),),
+                    CHARGE          =SIMP(statut='o',typ=char_meca ),
+                    FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                    FONC_MULT_C     =SIMP(statut='f',typ=fonction_c),
+                    COEF_MULT       =SIMP(statut='f',typ='R'),
+                    COEF_MULT_C     =SIMP(statut='f',typ='C'),
+                    PHAS_DEG        =SIMP(statut='f',typ='R'),
+                    PUIS_PULS       =SIMP(statut='f',typ='I'),
+                    TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),),
+                         ),
+
+          b_sigm_massif =BLOC( condition = "TYPE_OPTION == 'SIGM_MASSIF'",
+                                      fr="options de contraintes non lin 2D et 3D",
+               OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
+                              #  contraintes
+                           into=( "SIEF_ELNO_ELGA",),),
+                            ),
+
+          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",),),
+                             ),
+
+          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",
+                                 "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) ",
+              EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
+                    CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
+                               ),
+
+          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"),
+                                 ),
+          b_extr         =BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')",
+                   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",
+                               "DIST_DEV","DEV_SUR_CRIT","DIST_ISO","NB_ITER","ARRET","NB_REDE","SIGNE",
+                               "RDEV_1","RDEV_2","RDEV_3","RISO","EPSIVPLA","IND_1","IND_2","IND_3","IND_4"),),
+                            ),
+                           ),
+
+          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",),
+                                 ),
+               EXCIT           =FACT(statut='f',max='**',fr="charge contenant les temperatures",
+                    CHARGE          =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
+                                 ),
+
+          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",
+                                 ) ),
+                                 ),
+
+          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"),),
+                                 ),
+
+          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)",
+                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",),
+                                   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
+
+#           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",),),
+               EXCIT           =FACT(statut='f',max='**',
+                    regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),),
+                    CHARGE          =SIMP(statut='o',typ=char_ther ),
+                    FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                    FONC_MULT_C     =SIMP(statut='f',typ=fonction_c),
+                    COEF_MULT       =SIMP(statut='f',typ='R'),
+                    COEF_MULT_C     =SIMP(statut='f',typ='C'),
+                    PHAS_DEG        =SIMP(statut='f',typ='R'),
+                    PUIS_PULS       =SIMP(statut='f',typ='I'),
+                    TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),
+                                     ),
+                                 ),
+
+#    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",
+                                 ),),
+          EXCIT           =FACT(statut='f',max='**',
+                regles=(EXCLUS('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),),
+                CHARGE          =SIMP(statut='o',typ=char_acou ),
+                FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                FONC_MULT_C     =SIMP(statut='f',typ=fonction_c),
+                COEF_MULT       =SIMP(statut='f',typ='R'),
+                COEF_MULT_C     =SIMP(statut='f',typ='C'),
+                PHAS_DEG        =SIMP(statut='f',typ='R'),
+                PUIS_PULS       =SIMP(statut='f',typ='I'),
+                TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),),
+                                 ),
+
+
+#    Choix du solveur (utilisé actuellement pour estimateur d'erreur ZZ1) :
+     SOLVEUR         =FACT(statut='d', fr="Méthode de résolution des systèmes linéaires",
+     METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("LDLT","MUMPS","MULT_FRONT",) ),
+
+
+       b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+         RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+       ),
+
+       b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+         RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+       ),
+       b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                              fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+         NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+         STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+       ),
+
+       b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+         TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+         PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+         POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
+         RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+         ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+         PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+         RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+         OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+         ),
+     ),
+
+
+
+     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 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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.        
+# ======================================================================
+
+# RESPONSABLE NISTOR I.NISTOR
+
+from Macro.calc_essai_ops import calc_essai_ops
+
+def calc_essai_prod(self,RESU_FLUDELA,RESU_IDENTIFICATION,RESU_TURBULENT, RESU_MODIFSTRU,**args):
+
+    if RESU_FLUDELA != None:
+        for res in RESU_FLUDELA:
+            self.type_sdprod(res['TABLE'],table_sdaster)
+    if RESU_IDENTIFICATION != None:
+        for res in RESU_IDENTIFICATION:
+            self.type_sdprod(res['TABLE'],table_fonction)
+    if RESU_TURBULENT != None:
+        for res in RESU_TURBULENT:
+            self.type_sdprod(res['FONCTION'],fonction_sdaster)
+
+
+    MTYPES = {
+        'MODELE'    : modele_sdaster,
+        'MODE_MECA' : mode_meca,
+        'NUME_DDL'  : nume_ddl_sdaster,
+        'MAILLAGE'  : maillage_sdaster,
+        'MASS_MECA' : matr_asse_depl_r,
+        'RIGI_MECA' : matr_asse_depl_r,
+        'AMOR_MECA' : matr_asse_depl_r,
+        'MACR_ELEM' : macr_elem_stat,
+        'PROJ_MESU' : mode_gene,
+        'BASE_ES'   : mode_meca,
+        'BASE_LMME' : mode_meca,
+        'MODE_STA'  : mode_meca,
+              }
+    if RESU_MODIFSTRU != None:
+        for res in RESU_MODIFSTRU:
+            for mc, typ in MTYPES.items():
+                if res[mc]:
+                    self.type_sdprod(res[mc], typ)
+    return None
+
+
+CALC_ESSAI = MACRO(nom       = 'CALC_ESSAI',
+                   op        = calc_essai_ops,
+                   sd_prod   = calc_essai_prod,
+                   reentrant = 'n',
+                   UIinfo    = {"groupes":("Outils métier",)},
+                   fr        = "Outil de post-traitement interactif pour Meidee ",
+                   UNITE_FIMEN = SIMP( statut='f',typ='I',max='**' ),
+                   INTERACTIF  = SIMP( statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI' ),
+                   RESU_FLUDELA        = FACT( statut='f',max='**',
+                                               TABLE = SIMP(statut='f', typ=CO),
+                                             ),
+                   RESU_TURBULENT      = FACT( statut='f',max=1,
+                                               FONCTION = SIMP(statut='f', typ=CO),
+                                             ),
+                   RESU_IDENTIFICATION = FACT( statut='f',max='**',
+                                               TABLE = SIMP(statut='f', typ=CO),
+                                             ),
+                   RESU_MODIFSTRU = FACT( statut='f', max=1,
+                                          MODELE=SIMP(statut='f',typ=CO,defaut=None),
+                                          MODE_MECA=SIMP(statut='f',typ=CO,defaut=None),
+                                          MAILLAGE=SIMP(statut='f',typ=CO,defaut=None),
+                                          NUME_DDL=SIMP(statut='f',typ=CO,defaut=None),
+                                          MASS_MECA=SIMP(statut='f',typ=CO,defaut=None),
+                                          RIGI_MECA=SIMP(statut='f',typ=CO,defaut=None),
+                                          AMOR_MECA=SIMP(statut='f',typ=CO,defaut=None),
+                                          MACR_ELEM=SIMP(statut='f',typ=CO,defaut=None),
+                                          PROJ_MESU=SIMP(statut='f',typ=CO,defaut=None),
+                                          BASE_ES=SIMP(statut='f',typ=CO,defaut=None),
+                                          BASE_LMME=SIMP(statut='f',typ=CO,defaut=None),
+                                          MODE_STA=SIMP(statut='f',typ=CO,defaut=None),
+                                         ),
+                   UNITE_RESU = SIMP( statut='f',typ='I'),
+
+                   b_inter    = BLOC( condition="INTERACTIF=='NON'",
+
+                             EXPANSION        = FACT( statut='f',max='**',
+                                                      CALCUL           = SIMP(statut='o',typ=mode_meca),
+                                                      NUME_MODE_CALCUL = SIMP(statut='f',typ='I',validators=NoRepeat(),
+                                                                              max='**',defaut=0),
+                                                      MESURE           = SIMP(statut='o',typ=mode_meca),
+                                                      NUME_MODE_MESURE = SIMP(statut='f',typ='I',validators=NoRepeat(),
+                                                                              max='**',defaut=0),
+                                                      RESOLUTION       = SIMP(statut='f',typ='TXM',defaut='SVD',into=('SVD','LU')),
+                                                      b_reso           = BLOC(condition = "RESOLUTION=='SVD'",
+                                                                              EPS = SIMP(statut='f',typ='R', defaut = 0.)
+                                                                       )
+                                                    ),
+                             MEIDEE_FLUDELA   = FACT( statut='f', max='**',
+                                                      MESURE1 = SIMP(statut='o',typ=mode_meca),
+                                                      MESURE2 = SIMP(statut='o',typ=mode_meca),
+                                                      MESURE3 = SIMP(statut='o',typ=mode_meca),
+                                                      BASE    = SIMP(statut='o',typ=mode_meca),
+                                                    ),
+                             MEIDEE_TURBULENT = FACT( statut='f', max='**',
+                                                      INTE_SPEC      = SIMP(statut='o',typ=table_sdaster),
+                                                      NUME_MODE_DECONV = SIMP(statut='f',typ='I',validators=NoRepeat(),
+                                                                              max=1,defaut=0),
+                                                      NUME_MODE_LOCAL  = SIMP(statut='f',typ='I',validators=NoRepeat(),
+                                                                              max='**',defaut=0),
+                                                      BASE = SIMP(statut='o',typ=mode_meca),
+                                                      MESURE = SIMP(statut='o',typ=mode_meca),
+                                                    ),
+                             IDENTIFICATION   = FACT( statut='f',max='**',   
+                                                      ALPHA   = SIMP(statut='f',typ='R', defaut = 0.),
+                                                      EPS     = SIMP(statut='f',typ='R', defaut = 0.),
+                                                      OBSERVABILITE  = SIMP(statut='o',typ=mode_meca),
+                                                      COMMANDABILITE = SIMP(statut='o',typ=mode_meca),
+                                                      INTE_SPEC      = SIMP(statut='o',typ=table_sdaster),
+                                                      RESU_EXPANSION = SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')),
+                                                      BASE           = SIMP(statut='o',typ=mode_meca),
+                                                     ),
+                             MODIFSTRUCT = FACT( statut='f', max=1,
+                                                 MESURE = SIMP(statut='o', typ=mode_meca),
+                                                 MODELE_SUP = SIMP(statut='o', typ=modele_sdaster),
+                                                 MATR_RIGI = SIMP(statut='o', typ=matr_asse_depl_r),
+                                                 RESOLUTION = SIMP(statut='f', typ='TXM',
+                                                               into=('ES', 'LMME'), defaut='ES'),
+                                                 b_resol = BLOC( condition = "RESOLUTION=='LMME'",
+                                                                 MATR_MASS = SIMP(statut='o', typ=matr_asse_depl_r),
+                                                                ),
+                                                 NUME_MODE_MESU   = SIMP(statut='o', typ='I',max='**'),
+                                                 NUME_MODE_CALCUL = SIMP(statut='o', typ='I',max='**'),
+                                                 MODELE_MODIF = SIMP(statut='o', typ=modele_sdaster),
+                                               ),
+
+                             # 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='**'),
+                                                              NOM_CMP  = SIMP(statut='o',typ='TXM', max='**'),
+                                                            ),
+                                   GROUP_NO_EXTERIEUR = FACT( statut='f', max='**',
+                                                              GROUP_NO = SIMP(statut='o',typ='TXM', max='**'),
+                                                              NOM_CMP  = SIMP(statut='o',typ='TXM', max='**'),
+                                                            ),
+                                               ),
+                                          ),
+                        );
+
+#& MODIF COMMANDE  DATE 28/04/2009   AUTEUR ASSIRE A.ASSIRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+from Macro.calc_europlexus_ops import calc_europlexus_ops
+
+import types
+
+def calc_europlexus_prod(self,COURBE=None,**args):
+  if COURBE is not None:
+      self.type_sdprod(args['TABLE_COURBE'],table_sdaster) 
+  return evol_noli
+
+CALC_EUROPLEXUS = MACRO(nom="CALC_EUROPLEXUS",op=calc_europlexus_ops,sd_prod=calc_europlexus_prod,
+        reentrant='n',
+        #UIinfo={"groupes":("Dynamique rapide",)},
+        fr="Chainage Code_Aster-Europlexus",
+
+        LOGICIEL = SIMP(statut='f', typ='TXM', defaut='/home/europlex/EPXD/EUROPLEXUS_GESTION/runepx_d'),
+
+        MODELE     = SIMP(statut='o',typ=modele_sdaster),
+        CARA_ELEM  = SIMP(statut='o',typ=cara_elem),
+
+        FONC_PARASOL = FACT(statut='f',
+           NFKT       = SIMP(statut='f',typ=(fonction_sdaster,)),
+           NFKR       = SIMP(statut='f',typ=(fonction_sdaster,)),
+           GROUP_MA   = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           ),
+
+
+        CHAM_MATER = SIMP(statut='o',typ=cham_mater),
+
+        EXCIT      = FACT(statut='o',max='**',
+           CHARGE         = SIMP(statut='o',typ=(char_meca,)),
+           FONC_MULT      = SIMP(statut='o',typ=(fonction_sdaster,)),
+          ),
+
+        DIME = FACT(statut='o', regles=(AU_MOINS_UN('UNITE_DIME','Q4GS','FORCE',
+                                                    'PT6L','ZONE','POUT','ECRO',
+                                                    'APPU','BLOQ','PRESS','PMAT',
+                                                    'DKT3','DEPL','FNOM','TABLE','FTAB',
+                                                    'MTTI','NEPE','LIAI',), ),                   
+           UNITE_DIME=SIMP(statut='f',typ='I'),
+
+           Q4GS  = SIMP(statut='f',typ='I'),
+           FORCE = SIMP(statut='f',typ='I'),
+           PT6L  = SIMP(statut='f',typ='I'),
+           ZONE  = SIMP(statut='f',typ='I'),
+           POUT  = SIMP(statut='f',typ='I'),
+           ECRO  = SIMP(statut='f',typ='I'),
+           APPU  = SIMP(statut='f',typ='I'),
+           BLOQ  = SIMP(statut='f',typ='I'),
+           PRESS = SIMP(statut='f',typ='I',min=2,max=2,),
+           PMAT  = SIMP(statut='f',typ='I'),
+           DKT3  = SIMP(statut='f',typ='I'),
+           DEPL  = SIMP(statut='f',typ='I'),
+           FNOM  = SIMP(statut='f',typ='I'),
+           TABLE = SIMP(statut='f',typ='I',min=2,max=2,),
+           FTAB  = SIMP(statut='f',typ='I'),
+           MTTI  = SIMP(statut='f',typ='I'),
+           NEPE  = SIMP(statut='f',typ='I'),
+           LIAI  = SIMP(statut='f',typ='I'),
+             ),
+
+        CALCUL = FACT(statut='o',
+           TYPE_DISCRETISATION  = SIMP(statut='o',typ='TXM',defaut='AUTO',into=('AUTO','UTIL')),
+           INST_FIN             = SIMP(statut='o',typ='R'),
+           INST_INIT            = SIMP(statut='o',typ='R'),
+           NMAX                 = SIMP(statut='f',typ='R'),
+
+           b_auto =BLOC( condition = "TYPE_DISCRETISATION=='AUTO'",
+              CSTAB  = SIMP(statut='o',typ='R',max='**',defaut=0.3),
+#              DTMAX  = SIMP(statut='f',typ='R',max='**'),
+                       ),
+
+           b_util =BLOC( condition = "TYPE_DISCRETISATION=='UTIL'",
+              PASFIX   = SIMP(statut='o',typ='R',max='**'),
+                       ),
+           ),
+
+
+        OBSERVATION     =FACT(statut='f',max='**',
+           SUIVI_DDL       = SIMP(statut='o',typ='TXM',defaut="OUI",max=1,into=("OUI","NON")),
+        b_suivi          =BLOC(condition = "SUIVI_DDL == 'OUI' ",
+                               regles=( AU_MOINS_UN('PAS_NBRE','PAS_INST',), 
+                                        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'),),
+           PAS_INST        = SIMP(statut='f',typ='R'),
+           PAS_NBRE        = SIMP(statut='f',typ='I'),
+           GROUP_NO        = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           GROUP_MA        = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           TOUT_GROUP_NO   = SIMP(statut='f',typ='TXM',into=('OUI',),),
+           TOUT_GROUP_MA   = SIMP(statut='f',typ='TXM',into=('OUI',),),
+                             ),
+        ),
+
+
+        ARCHIVAGE        =FACT(statut='f', 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")),
+                             ),                
+        COURBE  =  FACT(statut='f',max='**', regles=(EXCLUS('GROUP_NO','GROUP_MA')),
+           UNITE_ALIT = SIMP(statut='f',typ='I'),
+            NOM_CHAM   = SIMP(statut='f',typ='TXM'),
+            NOM_CMP    = SIMP(statut='f',typ='TXM'),
+#             NOEUD      = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+#             MAILLE     = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+            GROUP_NO   = SIMP(statut='f',typ=grno,validators=NoRepeat(),max=1),
+            GROUP_MA   = SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1),
+
+            b_maille = BLOC(condition = "GROUP_MA != None", regles=(AU_MOINS_UN('NUM_GAUSS')),
+              NUM_GAUSS = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),),
+         ),
+        b_courbe = BLOC(condition = "COURBE != None",
+                        regles=(AU_MOINS_UN('PAS_NBRE_COURBE','PAS_INST_COURBE',),
+                                AU_MOINS_UN('TABLE_COURBE',)),          
+          PAS_INST_COURBE      = SIMP(statut='f',typ='R'),
+          PAS_NBRE_COURBE       = SIMP(statut='f',typ='I'),
+                  TABLE_COURBE      = SIMP(statut='f', typ=CO),
+          ),
+        DOMAINES = FACT(statut='f',max='**',
+             GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             IDENTIFIANT =  SIMP(statut='f',typ='I'),), 
+        INTERFACES = FACT(statut='f',max='**',
+             GROUP_MA_1 = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             GROUP_MA_2 = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             TOLE        =  SIMP(statut='f',typ='R'),
+             IDENT_DOMAINE_1  = SIMP(statut='f',typ='I'), 
+             IDENT_DOMAINE_2  = SIMP(statut='f',typ='I'),),
+
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=( 1, 2 ) ),
+        ) ;
+#& MODIF COMMANDE  DATE 06/07/2009   AUTEUR GALENNE E.GALENNE 
+#            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 ANGLES J.ANGLES
+def calc_fatigue_prod(TYPE_CALCUL,OPTION,**args):
+  if TYPE_CALCUL == "CUMUL_DOMMAGE" : return cham_elem
+  if TYPE_CALCUL == "FATIGUE_MULTI" and OPTION == "DOMA_ELGA": return cham_elem
+  if TYPE_CALCUL == "FATIGUE_MULTI" and OPTION == "DOMA_NOEUD": return cham_no_sdaster
+  if TYPE_CALCUL == "FATIGUE_VIBR" : return cham_elem
+  raise AsException("type de calcul non prevu")
+
+CALC_FATIGUE=OPER(nom="CALC_FATIGUE",op= 151,sd_prod=calc_fatigue_prod,reentrant='n',
+                  fr="Calculer un champ de dommage de fatigue subit par une structure et déterminer le plan critique"
+                      +" dans lequel le cisaillement est maximal.",
+            UIinfo={"groupes":("Post traitements",)},
+
+         TYPE_CALCUL = SIMP(statut='o',typ='TXM',
+                               into=("CUMUL_DOMMAGE","FATIGUE_MULTI","FATIGUE_VIBR") ),
+
+         b_cumul_domma   =BLOC(condition = "TYPE_CALCUL == 'CUMUL_DOMMAGE'",
+                               fr="Calcul d un champ de dommage subi par une structure.",
+           regles=(PRESENT_PRESENT('DOMMAGE','MATER', ),),
+           OPTION          =SIMP(statut='o',typ='TXM',
+                                 into=("DOMA_ELNO_SIGM","DOMA_ELGA_SIGM",
+                                       "DOMA_ELNO_EPSI","DOMA_ELGA_EPSI",
+                                       "DOMA_ELNO_EPME","DOMA_ELGA_EPME") ),
+           
+             b_sigm   =BLOC(condition = "OPTION == 'DOMA_ELNO_SIGM' or OPTION == 'DOMA_ELGA_SIGM'",
+                               fr="Calcul a partir d un champ de contraintes.",
+               HISTOIRE        =FACT(statut='o',
+               RESULTAT        =SIMP(statut='o',typ=(evol_elas,dyna_trans,
+                                                   evol_noli) ),
+               EQUI_GD         =SIMP(statut='f',typ='TXM',defaut="VMIS_SG",
+                                 into=("VMIS_SG",) ),
+                                   ),
+                           ),
+             b_epsi   =BLOC(condition = "OPTION != 'DOMA_ELNO_SIGM' and OPTION != 'DOMA_ELGA_SIGM'",
+                               fr="Calcul a partir d un champ de déformations.",
+               HISTOIRE        =FACT(statut='o',
+               RESULTAT        =SIMP(statut='o',typ=(evol_elas,dyna_trans,
+                                                   evol_noli) ),
+               EQUI_GD         =SIMP(statut='o',typ='TXM',defaut="INVA_2_SG",
+                                 into=("INVA_2_SG",) ),
+                                    ),
+                           ),
+           DOMMAGE         =SIMP(statut='o',typ='TXM',
+                               into=("WOHLER","MANSON_COFFIN","TAHERI_MANSON",
+                                     "TAHERI_MIXTE",) ),
+           MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
+           TAHERI_NAPPE    =SIMP(statut='f',typ=(nappe_sdaster,formule) ),
+           TAHERI_FONC     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         
+         b_domma_moda   =BLOC(condition = "TYPE_CALCUL == 'FATIGUE_VIBR'",
+                               fr="Calcul d un champ de dommage en dynamique vibratoire",
+           regles=(PRESENT_PRESENT('DOMMAGE','MATER', ),),
+           OPTION          =SIMP(statut='o',typ='TXM',
+                                 into=("DOMA_ELNO_SIGM","DOMA_ELGA_SIGM",) ),
+           CORR_SIGM_MOYE = SIMP(statut='o',typ='TXM',into=("GOODMAN","GERBER")),
+           HISTOIRE        =FACT(statut='o',
+             RESULTAT  =SIMP(statut='o',typ=(evol_elas, evol_noli) ),
+             MODE_MECA        =SIMP(statut='o',typ=(mode_meca) ),
+             NUME_MODE        =SIMP(statut='o',typ='I',min=1 ,max='**'),
+             FACT_PARTICI        =SIMP(statut='o',typ='R',min=1, max='**',defaut=1. ),
+             EQUI_GD         =SIMP(statut='f',typ='TXM',defaut="VMIS_SG",
+                                 into=("VMIS_SG",) ),
+           ),
+           DOMMAGE         =SIMP(statut='o',typ='TXM',
+                               into=("WOHLER",) ),
+           MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
+         ),
+
+         b_fatigue_multi   =BLOC(condition = "TYPE_CALCUL == 'FATIGUE_MULTI'",
+                                 fr="Plan critique dans le cas de la fatigue multiaxiale à grand nombre de cycles.",
+           TYPE_CHARGE   =SIMP(statut='o',typ='TXM',into=("PERIODIQUE","NON_PERIODIQUE") ),
+           OPTION        =SIMP(statut='o',typ='TXM',into=("DOMA_ELGA","DOMA_NOEUD") ),
+           RESULTAT      =SIMP(statut='o',typ=(evol_elas, evol_noli) ),
+           CHAM_MATER    =SIMP(statut='o',typ=(cham_mater) ),
+           MAILLAGE      =SIMP(statut='o',typ=maillage_sdaster ),
+           regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),),
+           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='**' ),
+           COEF_PREECROU =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+           b_period       =BLOC(condition = "TYPE_CHARGE == 'PERIODIQUE'",
+               CRITERE       =SIMP(statut='o',typ='TXM',into=("MATAKE_MODI_AC","DANG_VAN_MODI_AC","VMIS_TRESCA") ),
+               b_fati_p  =BLOC(condition = "(CRITERE == 'MATAKE_MODI_AC' or CRITERE == 'DANG_VAN_MODI_AC')",
+                   METHODE       =SIMP(statut='o',typ='TXM',into=("CERCLE_EXACT",) ),
+               ),
+           ),
+           b_non_period   =BLOC(condition = "TYPE_CHARGE == 'NON_PERIODIQUE'",
+               CRITERE       =SIMP(statut='o',typ='TXM',
+                                   into=("MATAKE_MODI_AV","DANG_VAN_MODI_AV","FATESOCI_MODI_AV","VMIS_TRESCA") ),
+               b_fati_np  =BLOC(condition = 
+                               "(CRITERE == 'MATAKE_MODI_AV' or CRITERE == 'DANG_VAN_MODI_AV' or CRITERE == 'FATESOCI_MODI_AV')",
+                   PROJECTION    =SIMP(statut='o',typ='TXM',into=("UN_AXE", "DEUX_AXES") ),
+                   DELTA_OSCI    =SIMP(statut='f',typ='R',defaut= 0.0E+0),  
+               ),
+           ),
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ADOBES A.ADOBES
+CALC_FLUI_STRU=OPER(nom="CALC_FLUI_STRU",op= 144,sd_prod=melasflu_sdaster,
+                    reentrant='n',
+                    fr="Calculer les paramètres modaux d'une structure soumise à un écoulement",
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         VITE_FLUI       =FACT(statut='f',
+                               fr="Définir la plage de vitesse fluide étudiée",
+           VITE_MIN        =SIMP(statut='f',typ='R' ),
+           VITE_MAX        =SIMP(statut='f',typ='R' ),
+           NB_POIN         =SIMP(statut='f',typ='I' ),
+         ),
+         BASE_MODALE     =FACT(statut='o',
+                               
+           regles=(AU_MOINS_UN('AMOR_REDUIT','AMOR_UNIF','AMOR_REDUIT_CONN'),),
+           MODE_MECA       =SIMP(statut='o',typ=mode_meca ),
+           NUME_ORDRE      =SIMP(statut='f',typ='I',max='**'),
+           AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**',val_min=0.E+00),
+           AMOR_UNIF       =SIMP(statut='f',typ='R',val_min=0.E+00 ),
+           AMOR_REDUIT_CONN=SIMP(statut='f',typ='R',max='**',val_min=0.E+00),
+         ),
+         TYPE_FLUI_STRU  =SIMP(statut='o',typ=type_flui_stru ),
+         IMPRESSION      =FACT(statut='f',
+                               fr="Choix des informations à imprimer dans le fichier RESULTAT",
+           PARA_COUPLAGE   =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           DEFORMEE        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+def calc_fonc_interp_prod(FONCTION, NOM_PARA_FONC, **args):
+   if   AsType(FONCTION) == nappe_sdaster:
+      return nappe_sdaster
+   elif AsType(FONCTION) == fonction_sdaster:
+      return fonction_sdaster
+   elif AsType(FONCTION) == fonction_c:
+      return fonction_c
+   elif AsType(FONCTION) == formule_c:
+      return fonction_c
+   elif AsType(FONCTION) == formule:
+      if NOM_PARA_FONC != None:
+         return nappe_sdaster
+      return fonction_sdaster
+   elif AsType(FONCTION) == para_sensi:
+      return para_sensi
+   raise AsException("type de concept resultat non prevu")
+
+CALC_FONC_INTERP=OPER(nom="CALC_FONC_INTERP",op= 134,sd_prod=calc_fonc_interp_prod,
+                      docu="U4.32.01-e",reentrant='n',
+           fr="Définit une fonction (ou une nappe) à partir d'une fonction FORMULE à 1 ou 2 variables",
+           UIinfo={"groupes":("Fonction",)},
+         regles=(UN_PARMI('VALE_PARA','LIST_PARA'),),
+         FONCTION        =SIMP(statut='o',typ=(formule,fonction_sdaster,nappe_sdaster,fonction_c) ),
+         VALE_PARA       =SIMP(statut='f',typ='R',max='**'),
+         LIST_PARA       =SIMP(statut='f',typ=listr8_sdaster ),
+         NOM_RESU        =SIMP(statut='f',typ='TXM'),
+         NOM_PARA        =SIMP(statut='f',typ='TXM'),
+         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG") ),
+         PROL_DROITE     =SIMP(statut='f',typ='TXM',into=("EXCLU","CONSTANT","LINEAIRE") ),
+         PROL_GAUCHE     =SIMP(statut='f',typ='TXM',into=("EXCLU","CONSTANT","LINEAIRE") ),
+         NOM_PARA_FONC   =SIMP(statut='f',typ='TXM'),
+         b_eval_nappe    =BLOC(condition = "NOM_PARA_FONC != None",             
+            regles=(UN_PARMI('VALE_PARA_FONC','LIST_PARA_FONC'),),
+            VALE_PARA_FONC  =SIMP(statut='f',typ='R',max='**'),
+            LIST_PARA_FONC  =SIMP(statut='f',typ=listr8_sdaster ),
+            INTERPOL_FONC   =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG")),
+            PROL_DROITE_FONC=SIMP(statut='f',typ='TXM',into=("EXCLU","CONSTANT","LINEAIRE") ),
+            PROL_GAUCHE_FONC=SIMP(statut='f',typ='TXM',into=("EXCLU","CONSTANT","LINEAIRE") ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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
+from Macro.calc_fonction_ops import calc_fonction_ops
+def calc_fonction_prod(self,DERIVE,EXTRACTION,INTEGRE,INVERSE,COMB,COMB_C,
+                       ENVELOPPE,FRACTILE,SPEC_OSCI,ASSE,FFT,COMPOSE,CORR_ACCE,PUISSANCE,
+                       LISS_ENVELOP,ABS, **args):
+
+   if (INTEGRE     != None): return fonction_sdaster
+   if (DERIVE      != None): return fonction_sdaster
+   if (INVERSE     != None): return fonction_sdaster
+   if (COMB        != None): 
+      type_vale=AsType(COMB[0]['FONCTION'])
+      for mcfact in COMB :
+          if(AsType(mcfact['FONCTION'])!=type_vale):
+             raise AsException("CALC_FONCTION/COMB : pas de types hétérogènes nappe/fonction")
+      return type_vale
+   if (COMB_C      != None):
+      vale=COMB_C[0]['FONCTION']
+      if(AsType(vale) == nappe_sdaster):
+         for mcfact in COMB_C[1:] :
+             if(AsType(mcfact['FONCTION'])!=nappe_sdaster):
+                raise AsException("CALC_FONCTION/COMB_C : pas de types hétérogènes nappe/fonction")
+         return nappe_sdaster
+      else:
+         for mcfact in COMB_C :
+             if(AsType(mcfact['FONCTION'])==nappe_sdaster):
+                raise AsException("CALC_FONCTION/COMB_C : pas de types hétérogènes nappe/fonction")
+         return fonction_c
+   if (ENVELOPPE   != None): return AsType(ENVELOPPE[0]['FONCTION'])
+   if (FRACTILE    != None): return AsType(FRACTILE[0] ['FONCTION'])
+   if (EXTRACTION  != None): return fonction_sdaster
+   if (SPEC_OSCI   != None): return nappe_sdaster
+   if (COMPOSE     != None): return fonction_sdaster
+   if (ASSE        != None): return fonction_sdaster
+   if (FFT         != None):
+      vale=FFT[0]['FONCTION']
+      if (AsType(vale) == fonction_sdaster )  : return fonction_c
+      if (AsType(vale) == fonction_c) : return fonction_sdaster
+   if (CORR_ACCE   != None): return fonction_sdaster
+   if (LISS_ENVELOP!= None): return nappe_sdaster
+   if (PUISSANCE   != None): return AsType(PUISSANCE[0]['FONCTION'])
+   if (ABS         != None): return fonction_sdaster
+   raise AsException("type de concept resultat non prevu")
+
+CALC_FONCTION=MACRO(nom="CALC_FONCTION",op=calc_fonction_ops,sd_prod=calc_fonction_prod
+                    ,fr="Effectue des opérations mathématiques sur des concepts de type fonction",
+                     reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         regles=(UN_PARMI('DERIVE','INTEGRE','SPEC_OSCI','COMB','COMB_C','ENVELOPPE',
+                          'COMPOSE','EXTRACTION','ASSE','FFT','CORR_ACCE', 'PUISSANCE',
+                          'LISS_ENVELOP','INVERSE','ABS','FRACTILE'),),
+         FFT             =FACT(statut='f',fr="Transformée de Fourier ou de son inverse",
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,fonction_c) ),
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="PROL_ZERO",into=("PROL_ZERO","TRONCATURE","COMPLET") ),
+           b_syme          =BLOC ( condition = " AsType(FONCTION)==fonction_c ",
+             SYME           =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI' ),  
+           ),
+         ),
+         DERIVE          =FACT(statut='f',fr="Dérivée d une fonction",
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="DIFF_CENTREE",into=("DIFF_CENTREE",) ),
+           FONCTION        =SIMP(statut='o',typ=fonction_sdaster ),
+         ),
+         INTEGRE         =FACT(statut='f',fr="Intégrale d'une fonction",
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="TRAPEZE",into=("SIMPSON","TRAPEZE") ),
+           FONCTION        =SIMP(statut='o',typ=fonction_sdaster),
+           COEF            =SIMP(statut='f',typ='R',defaut= 0.E+0,fr="Valeur de la constante d intégration" ),
+         ),
+         LISS_ENVELOP    = FACT(statut='f',fr="Lissage d une enveloppe",
+           NAPPE           =SIMP(statut='o',typ=nappe_sdaster ),
+           FREQ_MIN        =SIMP(statut='f',typ='R',defaut =0.2),
+           FREQ_MAX        =SIMP(statut='f',typ='R',defaut =35.5),
+           ELARG           =SIMP(statut='f',typ='R',defaut =0.1 ),
+           TOLE_LISS       =SIMP(statut='f',typ='R',defaut =0.25 ),
+         ),
+         SPEC_OSCI       =FACT(statut='f',fr="Spectre d'oscillateur",
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="NIGAM",into=("NIGAM",) ),
+           FONCTION        =SIMP(statut='o',typ=fonction_sdaster ),
+           AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'),
+           LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster ),
+           FREQ            =SIMP(statut='f',typ='R',max='**'),
+           NORME           =SIMP(statut='o',typ='R',fr="Valeur de la norme du spectre d oscillateur" ),
+           NATURE          =SIMP(statut='f',typ='TXM',defaut="ACCE",into=("DEPL","VITE","ACCE") ),
+           NATURE_FONC     =SIMP(statut='f',typ='TXM',defaut="ACCE",into=("DEPL","VITE","ACCE") ),
+         ),
+         ABS             =FACT(statut='f',fr="Valeur absolue d'une fonction",
+           FONCTION        =SIMP(statut='o',typ=fonction_sdaster,),
+         ),
+         COMB            =FACT(statut='f',max='**',fr="Combinaison linéaire réelle de fonctions",
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster) ),
+           COEF            =SIMP(statut='o',typ='R',fr="Coefficient réel de la combinaison linéaire associée à la fonction" ),
+         ),
+         COMB_C          =FACT(statut='f',max='**',fr="Combinaison linéaire complexe de fonctions",
+           regles=(UN_PARMI('COEF_R','COEF_C'),),
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,fonction_c,nappe_sdaster) ),
+           COEF_R          =SIMP(statut='f',typ='R',fr="Coefficient réel de la combinaison linéaire associée à la fonction" ),
+           COEF_C          =SIMP(statut='f',typ='C',fr="Coefficient complexe de la combinaison linéaire associée à la fonction" ),
+         ),
+         b_comb          =BLOC ( condition = " (COMB != None) or (COMB_C != None)",
+             LIST_PARA      =SIMP(statut='f',typ=listr8_sdaster ),  
+         ),
+         COMPOSE         =FACT(statut='f',fr="Composition de deux fonctions FONC_RESU(FONC_PARA)",
+           FONC_RESU       =SIMP(statut='o',typ=fonction_sdaster),
+           FONC_PARA       =SIMP(statut='o',typ=fonction_sdaster),
+         ),
+         EXTRACTION      =FACT(statut='f',fr="Extraction sur une fonction complexe",
+           FONCTION        =SIMP(statut='o',typ=fonction_c),
+           PARTIE          =SIMP(statut='o',typ='TXM',into=("REEL","IMAG","MODULE","PHASE"),fr="Partie à extraire"),
+         ),
+         ENVELOPPE       =FACT(statut='f',fr="Enveloppe d une famille de fonctions",
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster),max='**' ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="SUP",into=("SUP","INF"),fr="Type de l enveloppe" ),
+         ),
+         FRACTILE        =FACT(statut='f',fr="Fractile d une famille de fonctions ou de nappes",
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster),max='**' ),
+           FRACT           =SIMP(statut='o',typ='R',defaut=1.,val_min=0.,val_max=1.,fr="Valeur du fractile" ),
+         ),
+         ASSE            =FACT(statut='f',fr="Concatenation de fonctions",
+           FONCTION        =SIMP(statut='o',typ=fonction_sdaster,min=2,max=2 ),
+           SURCHARGE       =SIMP(statut='f',typ='TXM',defaut="DROITE",into=("DROITE","GAUCHE")),
+         ),
+         CORR_ACCE       =FACT(statut='f',fr="Correction d un accelerogramme reel",
+            CORR_DEPL       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+            FONCTION        =SIMP(statut='o',typ=fonction_sdaster ),
+         ),
+         PUISSANCE       =FACT(statut='f',fr="Fonction élevée à une puissance",
+            FONCTION      =SIMP(statut='o', typ=(fonction_sdaster,nappe_sdaster) ),
+            EXPOSANT      =SIMP(statut='f', typ='I', defaut=1 ),
+         ),
+         INVERSE         =FACT(statut='f',fr="Inverse d'une fonction",
+            FONCTION      =SIMP(statut='o', typ=fonction_sdaster),
+         ),     
+         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") ),
+         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") ),
+         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 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 GREFFET N.GREFFET
+CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene,
+                   fr="Calculer l'effet de surpression hydrodynamique due au mouvement d'entrainement de la structure"
+                       +" en analyse sismique",
+                   reentrant ='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+
+        regles=(EXCLUS('MODE_MECA','MODELE_GENE'),
+                PRESENT_PRESENT( 'MODELE_GENE','NUME_DDL_GENE'),
+                UN_PARMI('MONO_APPUI', 'NOEUD','GROUP_NO'),
+                UN_PARMI('MONO_APPUI','MODE_STAT')),
+
+         MODELE_FLUIDE   =SIMP(statut='o',typ=modele_sdaster ),
+         MODELE_INTERFACE=SIMP(statut='o',typ=modele_sdaster ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater ),
+         CHARGE          =SIMP(statut='o',typ=char_ther ),
+         MODE_MECA       =SIMP(statut='f',typ=mode_meca ),
+         MODELE_GENE     =SIMP(statut='f',typ=modele_gene ),
+         NUME_DDL_GENE   =SIMP(statut='f',typ=nume_ddl_gene ),
+         DIST_REFE       =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
+         AVEC_MODE_STAT  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         NUME_MODE_MECA  =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+         POTENTIEL       =SIMP(statut='f',typ=evol_ther ),
+         NOEUD_DOUBLE    =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+
+         DIRECTION       =SIMP(statut='o',typ='R',max=3),
+         MONO_APPUI      =SIMP(statut='f',typ='TXM',into=("OUI",),),
+         NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+         GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+         MODE_STAT       =SIMP(statut='f',typ=mode_meca,),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
+
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+           b_mult_front    = BLOC ( condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt          =BLOC( condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_gcpc          =BLOC (condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut=0),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.0E-6,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+                           ),
+
+           ) ;
+#& MODIF COMMANDE  DATE 20/10/2008   AUTEUR GALENNE E.GALENNE 
+#            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 GALENNE E.GALENNE
+CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster,
+            fr="Calcul du taux de restitution d'énergie par la méthode theta en thermo-élasticité"
+                        +" et les facteurs d'intensité de contraintes.",
+                    reentrant='f',
+            UIinfo={"groupes":("Post traitements",)},
+         regles=(EXCLUS('COMP_ELAS','COMP_INCR'),
+                 CONCEPT_SENSIBLE("ENSEMBLE"),
+                 REUSE_SENSIBLE(),
+                 DERIVABLE('RESULTAT'),),
+
+         THETA          =FACT(statut='o',
+           THETA           =SIMP(statut='f',typ=(theta_geom,cham_no_sdaster),),
+           FOND_FISS       =SIMP(statut='f',typ=fond_fiss,max=1),
+           FISSURE         =SIMP(statut='f',typ=fiss_xfem,max=1),
+           DTAN_ORIG       =SIMP(statut='f',typ='R',max='**'),
+           DTAN_EXTR       =SIMP(statut='f',typ='R',max='**'),
+           NB_POINT_FOND   =SIMP(statut='f',typ='I',val_min=2),
+           regles=(EXCLUS('FOND_FISS','FISSURE'),
+                 EXCLUS('FOND_FISS','NB_POINT_FOND'),
+                 EXCLUS('FOND_FISS','DTAN_ORIG'),
+                 EXCLUS('FOND_FISS','DTAN_EXTR'),),
+          b_theta        =BLOC(condition="THETA == None",fr="calcul de theta",
+            regles=(UN_PARMI('R_INF','R_INF_FO'),
+                 PRESENT_PRESENT('R_INF','R_SUP'),
+                PRESENT_PRESENT('R_INF_FO','R_SUP_FO'), ),
+             NUME_FOND        =SIMP(statut='f',typ='I',defaut=1),
+             R_INF           =SIMP(statut='f',typ='R'),
+             R_SUP           =SIMP(statut='f',typ='R'),
+             MODULE          =SIMP(statut='f',typ='R',defaut=1.),
+             DIRE_THETA      =SIMP(statut='f',typ=cham_no_sdaster ),
+             DIRECTION       =SIMP(statut='f',typ='R',max=3,min=3),
+             R_INF_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R_SUP_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),             
+             MODULE_FO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ),
+            ),
+
+         RESULTAT        =SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,mode_meca,mult_elas),),
+
+         b_no_mult          =BLOC(condition="(AsType(RESULTAT) != mult_elas)",
+         regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST',
+                  'TOUT_MODE','NUME_MODE','LIST_MODE','FREQ','LIST_FREQ'),),
+            
+            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),
+            TOUT_MODE       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+            NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+            LIST_MODE       =SIMP(statut='f',typ=listis_sdaster),
+            LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster),
+            FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+       
+           b_acce_reel     =BLOC(condition="(INST != None)or(LIST_INST != None)or(FREQ != None)or(LIST_FREQ != 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'),),
+            ),
+         ),
+
+         b_mult_elas     =BLOC(condition="(AsType(RESULTAT) == mult_elas)",
+            NOM_CAS         =SIMP(statut='f',typ='TXM',validators=NoRepeat() ),
+         ),
+
+        
+         EXCIT           =FACT(statut='f',max='**',
+               CHARGE          =SIMP(statut='f',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",into=("FIXE",) ),
+         ),
+         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","GREEN") ),
+      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_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") ),
+               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",) ),
+               GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+               MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+         ),
+         ETAT_INIT       =FACT(statut='f',
+           SIGM            =SIMP(statut='f',typ=cham_elem),
+           DEPL            =SIMP(statut='f',typ=cham_no_sdaster),
+         ),
+          
+         LISSAGE         =FACT(statut='d',
+           DEGRE           =SIMP(statut='f',typ='I',defaut=5,into=(0,1,2,3,4,5,6,7) ),
+           LISSAGE_THETA   =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",into=("LEGENDRE","LAGRANGE","LAGRANGE_REGU"),),
+           LISSAGE_G       =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",into=("LEGENDRE","LAGRANGE",
+                                 "LAGRANGE_NO_NO","LAGRANGE_REGU"),),
+         ),
+
+         OPTION          =SIMP(statut='o',typ='TXM',max=1,defaut='CALC_G',
+              into=("CALC_G","CALC_G_GLOB","CALC_K_G","K_G_MODA","G_MAX","G_MAX_GLOB","G_BILI",
+                    "G_BILI_GLOB","CALC_K_MAX"),),
+
+         b_g_max    =BLOC(condition="(OPTION=='G_MAX') or (OPTION=='G_MAX_GLOB')",
+           BORNES          =FACT(statut='o',max='**',
+                NUME_ORDRE     =SIMP(statut='o',typ='I'),
+                VALE_MIN       =SIMP(statut='o',typ='R'),
+                VALE_MAX       =SIMP(statut='o',typ='R'),
+                                ),
+         ),
+         b_k_max    =BLOC(condition="(OPTION=='CALC_K_MAX')",
+           SIGNES          =FACT(statut='o',max=1,
+                CHARGE_S       =SIMP(statut='o',typ='I',validators=NoRepeat(),max='**'),
+                CHARGE_NS      =SIMP(statut='o',typ='I',validators=NoRepeat(),max='**'),
+                                ),
+         ),
+
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                           fr="Liste des paramètres de sensibilité.",
+                           ang="List of sensitivity parameters"),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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
+CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_fonction,
+                    fr="Calcul d'une matrice interspectrale à partir d'une fonction du temps",
+                    reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         INST_INIT       =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+         INST_FIN        =SIMP(statut='o',typ='R' ),
+         DUREE_ANALYSE   =SIMP(statut='f',typ='R' ),
+         DUREE_DECALAGE  =SIMP(statut='f',typ='R' ),
+         NB_POIN         =SIMP(statut='o',typ='I' ),
+         FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule),max='**' ),
+         TITRE           =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 GREFFET N.GREFFET
+CALC_MATR_AJOU=OPER(nom="CALC_MATR_AJOU",op= 152,sd_prod=matr_asse_gene_r,
+                    fr="Calcul des matrices de masse, d'amortissement ou de rigidité ajoutés",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=(EXCLUS('MODE_MECA','CHAM_NO','MODELE_GENE'),
+                 PRESENT_ABSENT('NUME_DDL_GENE','CHAM_NO'),
+                 PRESENT_PRESENT('MODELE_GENE','NUME_DDL_GENE'),),
+         MODELE_FLUIDE   =SIMP(statut='o',typ=modele_sdaster ),
+         MODELE_INTERFACE=SIMP(statut='o',typ=modele_sdaster ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater ),
+         CHARGE          =SIMP(statut='o',typ=char_ther ),
+         MODE_MECA       =SIMP(statut='f',typ=mode_meca ),
+         CHAM_NO         =SIMP(statut='f',typ=cham_no_sdaster ),
+         MODELE_GENE     =SIMP(statut='f',typ=modele_gene ),
+         NUME_DDL_GENE   =SIMP(statut='f',typ=nume_ddl_gene ),
+         DIST_REFE       =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
+         AVEC_MODE_STAT  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         NUME_MODE_MECA  =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+         OPTION          =SIMP(statut='o',typ='TXM',into=("MASS_AJOU","AMOR_AJOU","RIGI_AJOU") ),
+         POTENTIEL       =SIMP(statut='f',typ=evol_ther ),
+         NOEUD_DOUBLE    =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
+
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+           b_mult_front    = BLOC ( condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt          =BLOC( condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_gcpc          =BLOC (condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut=0),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.0E-6,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/09/2009   AUTEUR BOYERE E.BOYERE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def calc_matr_elem_prod(OPTION,**args):
+  if OPTION == "RIGI_MECA"        : return matr_elem_depl_r
+  if OPTION == "RIGI_FLUI_STRU"   : return matr_elem_depl_r
+  if OPTION == "MASS_MECA"        : return matr_elem_depl_r
+  if OPTION == "MASS_FLUI_STRU"   : return matr_elem_depl_r
+  if OPTION == "RIGI_GEOM"        : return matr_elem_depl_r
+  if OPTION == "RIGI_ROTA"        : return matr_elem_depl_r
+  if OPTION == "MECA_GYRO"        : return matr_elem_depl_r
+  if OPTION == "AMOR_MECA"        : return matr_elem_depl_r
+  if OPTION == "IMPE_MECA"        : return matr_elem_depl_r
+  if OPTION == "ONDE_FLUI"        : return matr_elem_depl_r
+  if OPTION == "AMOR_MECA_ABSO"   : return matr_elem_depl_r
+  if OPTION == "RIGI_MECA_HYST"   : return matr_elem_depl_c
+  if OPTION == "RIGI_THER"        : return matr_elem_temp_r
+  if OPTION == "MASS_THER"        : return matr_elem_temp_r
+  if OPTION == "MASS_MECA_DIAG"   : return matr_elem_depl_r
+  if OPTION == "RIGI_ACOU"        : return matr_elem_pres_c
+  if OPTION == "MASS_ACOU"        : return matr_elem_pres_c
+  if OPTION == "AMOR_ACOU"        : return matr_elem_pres_c
+  raise AsException("type de concept resultat non prevu")
+
+CALC_MATR_ELEM=OPER(nom="CALC_MATR_ELEM",op=   9,sd_prod=calc_matr_elem_prod
+                    ,fr="Calcul des matrices élémentaires",reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+
+         OPTION          =SIMP(statut='o',typ='TXM',
+                               into=("RIGI_MECA","MASS_MECA","RIGI_GEOM",
+                                     "AMOR_MECA","RIGI_THER","MASS_THER","IMPE_MECA",
+                                     "ONDE_FLUI","AMOR_MECA_ABSO","MASS_FLUI_STRU","RIGI_FLUI_STRU",
+                                     "RIGI_ROTA","MECA_GYRO","MASS_MECA_DIAG","RIGI_ACOU",
+                                     "MASS_ACOU","AMOR_ACOU","RIGI_MECA_HYST") ),
+         MODELE            =SIMP(statut='o',typ=modele_sdaster ),
+
+         # mots clés facultatifs que l'on a du mal à mettre dans les blocs
+         # sans gener MACRO_MATR_ASSE :
+         #------------------------------------------------------------------
+         INST=SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+
+
+         b_rigi_meca = BLOC( condition = "OPTION=='RIGI_MECA'",
+           CHAM_MATER      =SIMP(statut='f',typ=cham_mater ),
+           CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+           MODE_FOURIER    =SIMP(statut='f',typ='I',defaut= 0 ),
+           CHARGE          =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_mass_meca   =BLOC(condition = "(OPTION=='MASS_MECA') or (OPTION=='MASS_MECA_DIAG')",
+           CHAM_MATER      =SIMP(statut='f',typ=cham_mater ),
+           CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+           CHARGE          =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+         ),
+
+         b_rigi_geom       =BLOC(condition = "OPTION=='RIGI_GEOM'",
+           CARA_ELEM         =SIMP(statut='f',typ=cara_elem ),
+           SIEF_ELGA         =SIMP(statut='o',typ=cham_elem ),
+           MODE_FOURIER      =SIMP(statut='f',typ='I',defaut= 0 ),
+         ),
+
+         b_rigi_rota       =BLOC(condition = "OPTION=='RIGI_ROTA'",
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CHARGE            =SIMP(statut='o',typ=char_meca,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_meca_gyro = BLOC( condition = "OPTION=='MECA_GYRO'",
+           CHAM_MATER      =SIMP(statut='f',typ=cham_mater ),
+           CARA_ELEM       =SIMP(statut='o',typ=cara_elem ),
+           CHARGE          =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_amor_meca       =BLOC(condition = "OPTION=='AMOR_MECA'",
+           regles=(AU_MOINS_UN('CARA_ELEM','RIGI_MECA'),
+                   ENSEMBLE('RIGI_MECA','MASS_MECA','CHAM_MATER'), ),
+           CARA_ELEM         =SIMP(statut='f',typ=cara_elem ),
+           CHAM_MATER        =SIMP(statut='f',typ=cham_mater ),
+           RIGI_MECA         =SIMP(statut='f',typ=matr_elem_depl_r ),
+           MASS_MECA         =SIMP(statut='f',typ=matr_elem_depl_r ),
+           CHARGE            =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+         ),
+
+         b_amor_meca_abso  =BLOC(condition = "OPTION=='AMOR_MECA_ABSO'",
+           regles=(AU_MOINS_UN('CARA_ELEM','RIGI_MECA'),
+                   ENSEMBLE('RIGI_MECA','MASS_MECA','CHAM_MATER'), ),
+           CARA_ELEM         =SIMP(statut='f',typ=cara_elem ),
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           RIGI_MECA         =SIMP(statut='f',typ=matr_elem_depl_r ),
+           MASS_MECA         =SIMP(statut='f',typ=matr_elem_depl_r ),
+           CHARGE            =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+         ),
+
+         b_rigi_meca_hyst  =BLOC( condition = "OPTION=='RIGI_MECA_HYST'",
+           CHARGE            =SIMP(statut='f',typ=char_meca ,validators=NoRepeat(),max='**' ),
+           CHAM_MATER        =SIMP(statut='f',typ=cham_mater ),
+           CARA_ELEM         =SIMP(statut='f',typ=cara_elem ),
+           RIGI_MECA         =SIMP(statut='o',typ=matr_elem_depl_r ),
+         ),
+
+         b_rigi_ther       =BLOC(condition = "OPTION=='RIGI_THER'",
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CARA_ELEM         =SIMP(statut='f',typ=cara_elem ),
+           MODE_FOURIER      =SIMP(statut='f',typ='I',defaut= 0 ),
+           CHARGE            =SIMP(statut='f',typ=char_ther,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_mass_ther       =BLOC(condition = "OPTION=='MASS_THER'",
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CARA_ELEM         =SIMP(statut='f',typ=cara_elem ),
+           CHARGE            =SIMP(statut='f',typ=char_ther ,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_rigi_acou       =BLOC(condition = "OPTION=='RIGI_ACOU'",
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CHARGE            =SIMP(statut='f',typ=char_acou ,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_mass_acou       =BLOC(condition = "(OPTION=='MASS_ACOU') or (OPTION=='AMOR_ACOU')",
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CHARGE            =SIMP(statut='f',typ=char_acou ,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_rigi_flui       =BLOC(condition = "OPTION=='RIGI_FLUI_STRU'",
+           CARA_ELEM         =SIMP(statut='o',typ=cara_elem ),
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CHARGE            =SIMP(statut='o',typ=char_meca ,validators=NoRepeat(),max='**' ),
+         ),
+
+         b_mass_flui       =BLOC(condition = "OPTION=='MASS_FLUI_STRU'",
+           CARA_ELEM         =SIMP(statut='o',typ=cara_elem ),
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CHARGE            =SIMP(statut='o',typ=char_meca ,validators=NoRepeat(),max='**'),
+         ),
+
+         b_impe_meca       =BLOC(condition = "(OPTION=='IMPE_MECA') or (OPTION=='ONDE_FLUI')",
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater ),
+           CHARGE            =SIMP(statut='o',typ=char_meca,validators=NoRepeat(),max='**' ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 16/11/2009   AUTEUR DURAND C.DURAND 
+#            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 BARGELLINI R.BARGELLINI
+CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o',
+            UIinfo={"groupes":("Post traitements",)},
+               fr="Calcule l'évolution métallurgique à partir du résultat d'un calcul thermique",
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater ),
+         RESULTAT        =SIMP(statut='o',typ=evol_ther ),
+         ETAT_INIT       =FACT(statut='o',
+            regles=(UN_PARMI('EVOL_THER', 'META_INIT_ELNO'),),
+            EVOL_THER       =SIMP(statut='f',typ=evol_ther ),
+            META_INIT_ELNO  =SIMP(statut='f',typ=carte_sdaster ),
+            b_etat     =BLOC(condition="EVOL_THER != None",
+               regles=(UN_PARMI('NUME_INIT', 'INST_INIT',),),
+               NUME_INIT       =SIMP(statut='f',typ='I'),
+               INST_INIT       =SIMP(statut='f',typ='R'),
+               b_inst     =BLOC(condition="INST_INIT != 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',),),
+               ),
+            ),
+         ),
+         COMP_INCR       =FACT(statut='o',max=1,
+           RELATION        =SIMP(statut='o',typ='TXM',into=("ACIER","ZIRC",) ),
+           ACIER           =SIMP(statut='c',typ='I',defaut=7,into=(7,) ),
+           ZIRC            =SIMP(statut='c',typ='I',defaut=4,into=(4,) ),
+      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='**'),
+         ),
+         OPTION          =SIMP(statut='f',typ='TXM'     
+                             ,into=("META_ELNO_TEMP",) ),
+)  ;
+#& MODIF COMMANDE  DATE 27/04/2009   AUTEUR NISTOR I.NISTOR 
+#            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.        
+# ======================================================================
+
+# RESPONSABLE NISTOR I.NISTOR
+
+from Macro.calc_modal_ops import calc_modal_ops
+
+def calc_modal_prod(self,AMORTISSEMENT,**args):
+  if AMORTISSEMENT=="NON": return mode_meca
+  if AMORTISSEMENT=="OUI": return mode_meca_c
+  raise AsException("type de concept resultat non prevu")
+
+
+CALC_MODAL=MACRO(nom="CALC_MODAL",op=calc_modal_ops,
+            UIinfo={"groupes":("Résolution",)},
+                      sd_prod=calc_modal_prod,
+                    fr="Calcul des modes propres reels ou complexes dans une seule commande",
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         AMORTISSEMENT    =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON" ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
+         INST            =SIMP(statut='f',typ='R',defaut=0.),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         CHARGE          =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),  
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT") ),
+         b_mult_front    =BLOC(condition="METHODE=='MULT_FRONT'",fr="Paramètres associés à la méthode multifrontale",
+           RENUM           =SIMP(statut='f',typ='TXM',into=("MD","MDA","METIS"),defaut="METIS" ),
+         ),
+         b_ldlt          =BLOC(condition="METHODE=='LDLT'",fr="Paramètres associés à la méthode LDLT",
+           RENUM           =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK"  ),
+         ),),
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="SORENSEN",
+                               into=("TRI_DIAG","JACOBI","SORENSEN","QZ") ),
+         b_tri_diag =BLOC(condition = "METHODE == 'TRI_DIAG'",
+           PREC_ORTHO      =SIMP(statut='f',typ='R',defaut= 1.E-12,val_min=0.E+0 ),
+           NMAX_ITER_ORTHO =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+           PREC_LANCZOS    =SIMP(statut='f',typ='R',defaut= 1.E-8,val_min=0.E+0 ),
+           NMAX_ITER_QR    =SIMP(statut='f',typ='I',defaut= 30,val_min=0 ), 
+         ),
+         b_jacobi =BLOC(condition = "METHODE == 'JACOBI'",
+           PREC_BATHE      =SIMP(statut='f',typ='R',defaut= 1.E-10,val_min=0.E+0 ),
+           NMAX_ITER_BATHE =SIMP(statut='f',typ='I',defaut= 40,val_min=0 ),
+           PREC_JACOBI     =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
+           NMAX_ITER_JACOBI=SIMP(statut='f',typ='I',defaut= 12,val_min=0 ),
+         ),
+         b_sorensen =BLOC(condition = "METHODE == 'SORENSEN'",
+           PREC_SOREN      =SIMP(statut='f',typ='R',defaut= 0.E+0,val_min=0.E+0 ),  
+           NMAX_ITER_SOREN =SIMP(statut='f',typ='I',defaut= 20,val_min=0 ),  
+           PARA_ORTHO_SOREN=SIMP(statut='f',typ='R',defaut= 0.717,val_min=0.E+0 ),
+         ),
+         b_qz =BLOC(condition = "METHODE == 'QZ'",
+           TYPE_QZ      =SIMP(statut='f',typ='TXM',defaut="QZ_SIMPLE",into=("QZ_QR","QZ_SIMPLE","QZ_EQUI") ),  
+         ), 
+         MODE_RIGIDE          =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
+                               fr="Calcul des modes de corps rigide, uniquement pour la méthode TRI_DIAG" ),
+         CALC_FREQ       =FACT(statut='d',min=0,
+             OPTION      =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","BANDE","CENTRE","TOUT"),
+                                   fr="Choix de l option et par conséquent du shift du problème 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 donnée",
+               FREQ            =SIMP(statut='o',typ='R',
+                                     fr="Fréquence autour de laquelle on cherche les fréquences 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 donnée",
+               FREQ            =SIMP(statut='o',typ='R',min=2,validators=NoRepeat(),max=2,
+                                     fr="Valeur des deux fréquences délimitant la bande de recherche"),
+             ),           
+             APPROCHE        =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG","COMPLEXE"),
+                                   fr="Choix du pseudo-produit scalaire pour la résolution du problème quadratique" ),           
+             regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
+             DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
+             COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
+             NPREC_SOLVEUR   =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
+             NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+             PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0 ),
+             SEUIL_FREQ      =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
+             STOP_FREQ_VIDE  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+
+        VERI_MODE       =FACT(statut='d',min=0,
+           STOP_ERREUR     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-3,val_min=0.E+0 ),
+           SEUIL           =SIMP(statut='f',typ='R',defaut= 1.E-6,val_min=0.E+0,
+                                 fr="Valeur limite admise pour l ereur a posteriori des modes" ),
+           STURM           =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 28/07/2009   AUTEUR TORKHANI M.TORKHANI 
+#            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.        
+# ======================================================================
+# RESPONSABLE Mohamed TORKHANI
+
+from Macro.calc_mode_rotation_ops import calc_mode_rotation_ops
+
+CALC_MODE_ROTATION=MACRO(nom="CALC_MODE_ROTATION",op=calc_mode_rotation_ops,sd_prod=table_container,
+                  reentrant='n',fr="calculer les fréquences et modes d'un système en fonction des vitesses de rotation",
+                  UIinfo={"groupes":("Résolution",)},
+                         
+                  MATR_A          =SIMP(statut='o',typ=matr_asse_depl_r ),
+                  MATR_B          =SIMP(statut='o',typ=matr_asse_depl_r ),
+                  MATR_AMOR       =SIMP(statut='f',typ=matr_asse_depl_r ),
+                  MATR_GYRO       =SIMP(statut='f',typ=matr_asse_depl_r ),
+                  VITE_ROTA       =SIMP(statut='f',typ='R',max='**'),
+                        
+                  METHODE         =SIMP(statut='f',typ='TXM',defaut="QZ",
+                                        into=("QZ","SORENSEN",) ),
+                                               
+                  CALC_FREQ       =FACT(statut='d',min=0,
+                         OPTION      =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","CENTRE",),
+                                           fr="Choix de l option et par conséquent du shift du problème 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 donnée",
+                              FREQ            =SIMP(statut='o',typ='R',
+                                                     fr="Fréquence autour de laquelle on cherche les fréquences propres"),
+                              AMOR_REDUIT     =SIMP(statut='f',typ='R',),
+                              NMAX_FREQ       =SIMP(statut='f',typ='I',defaut= 10,val_min=0 ),
+                              ),
+                             ),
+                                  
+                  VERI_MODE       =FACT(statut='d',min=0,
+                  STOP_ERREUR     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+                  SEUIL           =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+                  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 02/11/2009   AUTEUR LEBOUVIER F.LEBOUVIER 
+#            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 DESROCHES X.DESROCHES
+def calc_no_prod(RESULTAT,**args):
+   if AsType(RESULTAT) != None : return AsType(RESULTAT)
+   raise AsException("type de concept resultat non prevu")
+
+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",)},
+         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='**'),
+         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='**',
+                               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",
+                                     "EPSP_NOEU"     ,"EPSP_NOEU_ZAC",
+                                     "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"     ,"SIEF_NOEU_ELGA",
+                                     "SIGM_NOEU_CART","SIGM_NOEU_COQU","SIGM_NOEU_DEPL",
+                                     "SIGM_NOEU_SIEF","SIGM_NOEU_ZAC",
+                                     "SIPO_NOEU_DEPL","SIPO_NOEU_SIEF",
+                                     "SIRE_NOEU_DEPL",
+                                     "VARI_NOEU","EXTR_NOEU_VARI","VARI_NOEU_ELGA",
+                                     "ARCO_NOEU_SIGM",) ),
+
+         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(),
+         ),
+         
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         EXCIT           =FACT(statut='f',max='**',
+           CHARGE          =SIMP(statut='f',typ=(char_meca,char_ther,char_acou,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","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 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#            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.
+# ======================================================================
+# RESPONSABLE MICHEL S.MICHEL
+
+from Macro.calc_precont_ops import calc_precont_ops
+
+
+# ===========================================================================
+#           CATALOGUE DE LA MACRO "CALC_PRECONT"
+#           -----------------------------------------
+# USAGE :
+#
+#
+# ===========================================================================
+
+CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli,
+                   fr="Imposer la tension définie par le BPEL dans les cables",
+                   reentrant='f',UIinfo={"groupe":("Modélisation",)},
+         reuse =SIMP(statut='f',typ='evol_noli'),
+         MODELE           =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER       =SIMP(statut='o',typ=cham_mater),
+         CARA_ELEM        =SIMP(statut='o',typ=cara_elem),
+         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',
+            regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','SIGM','VARI',),
+                    EXCLUS('EVOL_NOLI','DEPL',),
+                    EXCLUS('EVOL_NOLI','SIGM',),
+                    EXCLUS('EVOL_NOLI','VARI',),
+                    EXCLUS('NUME_ORDRE','INST'), ),
+            DEPL            =SIMP(statut='f',typ=cham_no_sdaster),
+            SIGM            =SIMP(statut='f',typ=(carte_sdaster,cham_elem)),
+            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'),
+          ),
+          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),
+          ),
+
+         COMP_INCR       =C_COMP_INCR(),
+  )  ;
+#& MODIF COMMANDE  DATE 21/10/2008   AUTEUR CORUS M.CORUS 
+#            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.        
+# ======================================================================
+
+# RESPONSABLE CORUS M.CORUS
+
+from Macro.calc_spec_ops import calc_spec_ops
+
+CALC_SPEC=MACRO(nom="CALC_SPEC",op= calc_spec_ops,sd_prod=table_fonction,
+                     reentrant='n',
+                     fr="Calcule une matrice interspectrale ou des fonctions de transferts",
+                     UIinfo={"groupes":("Fonction",)},
+         TAB_ECHANT      =FACT(statut='f',
+           NOM_TAB         =SIMP(statut='o',typ=table_sdaster),
+           LONGUEUR_ECH    =FACT(statut='f',
+             DUREE           =SIMP(statut='f',typ='R'),
+             POURCENT        =SIMP(statut='f',typ='R'),
+             NB_PTS          =SIMP(statut='f',typ='I'),
+                              ),
+           RECOUVREMENT  =FACT(statut='f',
+             DUREE           =SIMP(statut='f',typ='R'),
+             POURCENT        =SIMP(statut='f',typ='R'),
+             NB_PTS          =SIMP(statut='f',typ='I'),
+                                ),
+                              ),
+         ECHANT          =FACT(statut='f',max='**',
+           NUME_ORDRE_I    =SIMP(statut='o',typ='I' ),
+           NUME_MES        =SIMP(statut='o',typ='I' ),
+           FONCTION        =SIMP(statut='o',typ=fonction_sdaster),
+                              ),
+#-- Cas de la matrice interspectrale --#
+         INTERSPE        =FACT(statut='f',
+           FENETRE         =SIMP(statut='f',typ='TXM',defaut="RECT",into=("RECT","HAMM","HANN","EXPO","PART",)),
+           BLOC_DEFI_FENE  =BLOC(condition = "FENETRE == 'EXPO' or FENETRE == 'PART' ", 
+#             DEFI_FENE       =SIMP(statut='f',typ='R',max='**'),
+                                 ),
+                              ),
+#-- Cas des transferts - estimateurs H1 / H2 / Hv + Coherence --#
+         TRANSFERT       =FACT(statut='f',
+           ESTIM           =SIMP(statut='f',typ='TXM',defaut="H1",into=("H1","H2","CO",)),
+           REFER           =SIMP(statut='o',typ='I',max='**'),
+           FENETRE         =SIMP(statut='f',typ='TXM',defaut="RECT",into=("RECT","HAMM","HANN","EXPO","PART",)),
+           DEFI_FENE       =SIMP(statut='f',typ='R',max='**'),
+
+                              ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+);
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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.        
+# ======================================================================
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE COURTOIS M.COURTOIS
+
+def calc_table_prod(self, TABLE, ACTION, **kargs):
+   """Typage du concept produit.
+   """
+   l_typ = [AsType(TABLE),]
+   for mcf in ACTION:
+      dmc = mcf.cree_dict_valeurs(mcf.mc_liste)
+      if dmc.get('TABLE') != None:
+         l_typ.append(AsType(dmc['TABLE']))
+   # une table_fonction étant une table
+   if table_fonction in l_typ:
+      return table_fonction
+   else:
+      return table_sdaster
+
+
+from Macro.calc_table_ops import calc_table_ops
+
+CALC_TABLE=MACRO(nom="CALC_TABLE",op=calc_table_ops, sd_prod=calc_table_prod,
+                 fr="Opérations sur une table",
+                 reentrant='f',
+   regles=(DERIVABLE('TABLE'),),
+   TABLE  = SIMP(statut='o',typ=table_sdaster),
+   ACTION = FACT(statut='o', max='**',
+                    fr = "Suite des opérations à effectuer sur la table",
+      OPERATION = SIMP(statut='o', typ='TXM',
+                  into=('FILTRE', 'EXTR', 'RENOMME', 'TRI', 'COMB', 'AJOUT', 'OPER',)),
+      
+      b_filtre = BLOC(condition="OPERATION == 'FILTRE'",
+                      fr="Sélectionne les lignes de la table vérifiant un critère",
+         NOM_PARA  = SIMP(statut='o',typ='TXM'),
+         CRIT_COMP = SIMP(statut='f',typ='TXM',defaut="EQ",
+                          into=('EQ','NE','GT','LT','GE','LE','REGEXP',
+                                'VIDE','NON_VIDE','MAXI','ABS_MAXI','MINI','ABS_MINI'),),
+         b_vale = BLOC(condition = "(CRIT_COMP in ('EQ','NE','GT','LT','GE','LE'))",
+            regles=(UN_PARMI('VALE','VALE_I','VALE_K','VALE_C',),),
+            VALE   = SIMP(statut='f',typ='R',max='**'),
+            VALE_I = SIMP(statut='f',typ='I',max='**'),
+            VALE_C = SIMP(statut='f',typ='C',max='**'),
+            VALE_K = SIMP(statut='f',typ='TXM',max='**'),
+         ),
+         b_regexp = BLOC(condition = "CRIT_COMP == 'REGEXP'",
+            VALE_K = SIMP(statut='o',typ='TXM',max='**'),
+         ),
+         b_crit = BLOC(condition = "CRIT_COMP in ('EQ','NE')",
+            CRITERE   = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+            PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+         ),
+      ),
+      
+      b_extr = BLOC(condition="OPERATION ==  'EXTR'",
+                    fr="Extrait une ou plusieurs colonnes de la table",
+         NOM_PARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
+                         fr="Noms des colonnes à extraire"),
+      ),
+   
+      b_renomme = BLOC(condition="OPERATION == 'RENOMME'",
+                       fr="Renomme un ou plusieurs paramètres de la table",
+         NOM_PARA = SIMP(statut='o', typ='TXM', validators=NoRepeat(), min=2, max=2,
+                         fr="Couple (ancien nom du paramètre, nouveau nom du paramètre)",),
+      ),
+   
+      b_tri = BLOC(condition="OPERATION == 'TRI'",
+                   fr="Ordonne les lignes de la table selon les valeurs d'un ou plusieurs paramètres",
+         NOM_PARA = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+         ORDRE    = SIMP(statut='f',typ='TXM',defaut="CROISSANT",
+                         into=("CROISSANT","DECROISSANT") ),
+      ),
+      
+      b_comb = BLOC(condition="OPERATION == 'COMB'",
+                    fr="Combine deux tables ayant éventuellement des paramètres communs",
+         TABLE    = SIMP(statut='o',typ=table_sdaster,
+                         fr="Table dont les colonnes vont venir surcharger la table initiale"),
+         NOM_PARA = SIMP(statut='f',typ='TXM',max='**',
+                         fr="Noms des paramètres dont les valeurs doivent etre identiques dans les deux tables "\
+                            "pour que les colonnes soient combinées"),
+         RESTREINT = SIMP(statut='f', typ='TXM', into=('OUI', 'NON'), defaut='NON',
+                          fr="Restreint la fusion uniquement aux lignes où les NOM_PARA sont communs"),
+      ),
+      
+      b_append = BLOC(condition="OPERATION == 'AJOUT'",
+                    fr="Ajoute une ligne à la table initiale",
+         NOM_PARA = SIMP(statut='o',typ='TXM',max='**',
+                         fr="Noms des paramètres dont les valeurs sont fournies sous VALE"),
+         VALE     = SIMP(statut='o',typ=assd,max='**', fr='Valeurs des paramètres'),
+      ),
+      
+      b_oper = BLOC(condition="OPERATION == 'OPER'",
+                    fr="Applique une formule dans laquelle les variables sont les paramètres de la table",
+         FORMULE  = SIMP(statut='o',typ=formule,
+                         fr="Formule à appliquer aux colonnes de la table"),
+         NOM_PARA = SIMP(statut='o',typ='TXM',
+                         fr="Nom de la nouvelle colonne"),
+      ),
+   ),
+   
+   SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),max=1,
+                      fr="Paramètre de sensibilité",
+                      ang="Sensitivity parameter"),
+   TITRE = SIMP(statut='f',typ='TXM',max='**',
+                fr="Titre de la table produite"),
+   INFO  = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE GALENNE E.GALENNE
+CALC_THETA=OPER(nom="CALC_THETA",op=54,sd_prod=theta_geom,reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+                fr="Définir un champ theta pour le calcul du taux de restitution d'énergie"
+                    +" ou des facteurs d'intensité de contraintes",
+         regles=(UN_PARMI('THETA_2D','THETA_3D','THETA_BANDE'),
+                 PRESENT_ABSENT('THETA_2D','DIRE_THETA'),
+                 EXCLUS('DIRECTION','DIRE_THETA'),),
+         OPTION          =SIMP(statut='f',typ='TXM',defaut="COURONNE",into=("COURONNE","BANDE") ),
+         MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+         THETA_3D        =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','GROUP_NO','NOEUD'),
+                   UN_PARMI('MODULE','MODULE_FO'),
+                   ENSEMBLE('MODULE','R_INF','R_SUP'),
+                   ENSEMBLE('MODULE_FO','R_INF_FO','R_SUP_FO'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           MODULE          =SIMP(statut='f',typ='R'),
+           R_INF           =SIMP(statut='f',typ='R'),
+           R_SUP           =SIMP(statut='f',typ='R'),
+           MODULE_FO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           R_INF_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           R_SUP_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                         ),
+         b_theta_3d     =BLOC(condition="THETA_3D != None",
+           FOND_FISS       =SIMP(statut='o',typ=fond_fiss),),
+         DIRE_THETA      =SIMP(statut='f',typ=cham_no_sdaster ),
+         DIRECTION       =SIMP(statut='f',typ='R',max='**'),
+         THETA_2D        =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_NO','NOEUD'),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           MODULE          =SIMP(statut='o',typ='R'),
+           R_INF           =SIMP(statut='o',typ='R'),
+           R_SUP           =SIMP(statut='o',typ='R'),
+         ),
+         THETA_BANDE     =FACT(statut='f',max='**',
+           MODULE          =SIMP(statut='o',typ='R'),
+           R_INF           =SIMP(statut='o',typ='R'),
+           R_SUP           =SIMP(statut='o',typ='R'),
+         ),
+         GRAD_NOEU_THETA =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         IMPRESSION      =FACT(statut='f',
+           UNITE           =SIMP(statut='f',typ='I',defaut=8),  
+           FORMAT          =SIMP(statut='f',typ='TXM',defaut="EXCEL",into=("EXCEL","AGRAF") ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 07/04/2009   AUTEUR ABBAS M.ABBAS 
+#            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=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","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","GREEN","GREEN_GR",) ),),
+     INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+) ;
+
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def calc_vect_elem_prod(OPTION,**args):
+  if OPTION == "CHAR_MECA" :      return vect_elem_depl_r
+  if OPTION == "CHAR_THER" :      return vect_elem_temp_r
+  if OPTION == "CHAR_ACOU" :      return vect_elem_pres_c
+  if OPTION == "FORC_NODA" :      return vect_elem_depl_r
+  raise AsException("type de concept resultat non prevu")
+
+CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+                    fr="Calcul des seconds membres élémentaires",
+         OPTION          =SIMP(statut='o',typ='TXM',into=("CHAR_MECA","CHAR_THER","CHAR_ACOU",
+                                                           "FORC_NODA") ),
+         b_char_meca     =BLOC(condition = "OPTION=='CHAR_MECA'",
+           regles=(AU_MOINS_UN('CHARGE','MODELE'),),
+           CHARGE          =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+           MODELE          =SIMP(statut='f',typ=modele_sdaster),
+           b_charge     =BLOC(condition = "CHARGE != None", fr="modèle ne contenant pas de sous-structure",
+              CHAM_MATER   =SIMP(statut='f',typ=cham_mater),
+              CARA_ELEM    =SIMP(statut='f',typ=cara_elem),
+              INST         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+              MODE_FOURIER =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),  
+           b_modele     =BLOC(condition = "(MODELE != None)",fr="modèle contenant une sous-structure",
+              SOUS_STRUC      =FACT(statut='o',min=01,
+                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='**',),
+              ),
+           ),
+         ),
+         b_char_ther     =BLOC(condition = "OPTION=='CHAR_THER'",
+           CARA_ELEM        =SIMP(statut='f',typ=cara_elem),
+           CHARGE           =SIMP(statut='o',typ=char_ther,validators=NoRepeat(),max='**'),
+           INST             =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+         ),
+              
+         b_char_acou     =BLOC(condition = "OPTION=='CHAR_ACOU'",
+           CHAM_MATER        =SIMP(statut='o',typ=cham_mater),
+           CHARGE            =SIMP(statut='o',typ=char_acou,validators=NoRepeat(),max='**'),
+         ),
+         
+         b_forc_noda     =BLOC(condition = "OPTION=='FORC_NODA'",
+           SIEF_ELGA         =SIMP(statut='o',typ=cham_elem),
+           CARA_ELEM         =SIMP(statut='f',typ=cara_elem),
+           MODELE            =SIMP(statut='f',typ=modele_sdaster),
+         ),       
+) ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+COMB_FOURIER=OPER(nom="COMB_FOURIER",op= 161,sd_prod=comb_fourier,
+                  reentrant='n',fr="Recombiner les modes de Fourier d'une SD Résultat dans des directions particulières",
+            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"),),
+) ;
+#& MODIF COMMANDE  DATE 08/12/2008   AUTEUR SELLENET N.SELLENET 
+#            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 SELLENET N.SELLENET
+def comb_matr_asse_prod(COMB_R,COMB_C,CALC_AMOR_GENE,**args):
+  if COMB_C != None:
+    type_mat = AsType(COMB_C[0]['MATR_ASSE'])
+    if type_mat in  (matr_asse_depl_c,matr_asse_depl_r) : return matr_asse_depl_c
+    if type_mat in  (matr_asse_gene_c,matr_asse_gene_r) : return matr_asse_gene_c
+    if type_mat in  (matr_asse_temp_c,matr_asse_temp_r) : return matr_asse_temp_c
+    if type_mat in  (matr_asse_pres_c,matr_asse_pres_r) : return matr_asse_pres_c
+  elif COMB_R != None:
+    type_mat = AsType(COMB_R[0]['MATR_ASSE'])
+    if type_mat in  (matr_asse_depl_c,matr_asse_depl_r) : return matr_asse_depl_r
+    if type_mat in  (matr_asse_temp_c,matr_asse_temp_r) : return matr_asse_temp_r
+    if type_mat in  (matr_asse_pres_c,matr_asse_pres_r) : return matr_asse_pres_r
+    if type_mat in  (matr_asse_gene_c,matr_asse_gene_r) : return matr_asse_gene_r
+  elif CALC_AMOR_GENE != None: return matr_asse_gene_r
+  raise AsException("type de concept resultat non prevu")
+
+COMB_MATR_ASSE=OPER(nom="COMB_MATR_ASSE",op=  31,sd_prod=comb_matr_asse_prod,
+                    fr="Effectuer la combinaison linéaire de matrices assemblées",
+                    reentrant='f',
+            UIinfo={"groupes":("Résultats et champs",)},
+         regles=(UN_PARMI('COMB_R','COMB_C','CALC_AMOR_GENE' ),),
+         COMB_R          =FACT(statut='f',max='**',
+           PARTIE          =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ),
+           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,matr_asse_gene_r,matr_asse_gene_c ) ),
+           COEF_R          =SIMP(statut='o',typ='R' ),
+         ),
+         COMB_C          =FACT(statut='f',max='**',
+           regles=(UN_PARMI('COEF_R','COEF_C' ),),
+           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,matr_asse_gene_r,matr_asse_gene_c ) ),
+           COEF_R          =SIMP(statut='f',typ='R' ),
+           COEF_C          =SIMP(statut='f',typ='C' ),
+         ),
+         CALC_AMOR_GENE   =FACT(statut='f',
+           RIGI_GENE    = SIMP(statut='o', typ=matr_asse_gene_r),
+           MASS_GENE    = SIMP(statut='o', typ=matr_asse_gene_r),
+           regles=(UN_PARMI('AMOR_REDUIT','LIST_AMOR' ),),
+           AMOR_REDUIT  = SIMP(statut='f',typ='R',max='**'),
+           LIST_AMOR    = SIMP(statut='f',typ=listr8_sdaster ),
+         ),
+         SANS_CMP        =SIMP(statut='f',typ='TXM',into=("LAGR",) ),
+)  ;
+#& MODIF COMMANDE  DATE 09/11/2009   AUTEUR AUDEBERT S.AUDEBERT 
+#            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 AUDEBERT S.AUDEBERT
+COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_meca,
+                     fr="Réponse sismique par recombinaison modale par une méthode spectrale",
+                     reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+         regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','FREQ','NUME_MODE','LIST_FREQ','LIST_ORDRE'),
+                 UN_PARMI('AMOR_REDUIT','LIST_AMOR','AMOR_GENE' ),
+                 UN_PARMI('MONO_APPUI','MULTI_APPUI' ),),
+         MODE_MECA       =SIMP(statut='o',typ=mode_meca ),
+         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 ),
+         NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+         FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+         LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster ),
+         b_freq          =BLOC(condition = "FREQ != None or LIST_FREQ != None",
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+         ),
+         MODE_CORR       =SIMP(statut='f',typ=mode_meca ),
+         
+         AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'),
+         LIST_AMOR       =SIMP(statut='f',typ=listr8_sdaster ),
+         AMOR_GENE       =SIMP(statut='f',typ=matr_asse_gene_r ),
+         
+         MASS_INER       =SIMP(statut='f',typ=table_sdaster ),
+         CORR_FREQ       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         
+         EXCIT           =FACT(statut='o',max='**',
+           regles=(UN_PARMI('AXE','TRI_AXE','TRI_SPEC' ),),
+           AXE             =SIMP(statut='f',typ='R',max=3,fr="Excitation suivant un seul axe",),
+           TRI_AXE         =SIMP(statut='f',typ='R',max=3,fr="Excitation suivant les trois axes mais avec le meme spectre",),
+           TRI_SPEC        =SIMP(statut='f',typ='TXM',into=("OUI",),
+                                 fr="Excitation suivant les trois axes  avec trois spectres"),
+           b_axe           =BLOC(condition = "AXE != None",fr="Excitation suivant un seul axe",
+             SPEC_OSCI       =SIMP(statut='o',typ=(nappe_sdaster,formule),),
+             ECHELLE         =SIMP(statut='f',typ='R',),
+           ),
+           b_tri_axe       =BLOC(condition = "TRI_AXE != None",fr="Excitation suivant les trois axes mais avec le meme spectre",
+             SPEC_OSCI       =SIMP(statut='o',typ=(nappe_sdaster,formule),),
+             ECHELLE         =SIMP(statut='f',typ='R',),
+           ),
+           b_tri_spec      =BLOC(condition = "TRI_SPEC != None",fr="Excitation suivant les trois axes  avec trois spectres",
+             SPEC_OSCI       =SIMP(statut='o',typ=(nappe_sdaster,formule),min=3,max=3 ),
+             ECHELLE         =SIMP(statut='f',typ='R',min=3,max=3),
+           ),       
+           NATURE          =SIMP(statut='f',typ='TXM',defaut="ACCE",into=("ACCE","VITE","DEPL") ),
+           b_mult_appui    =BLOC(condition = "(MULTI_APPUI != None)",
+                                 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='**'),)                              
+         ),
+         MONO_APPUI      =SIMP(statut='f',typ='TXM',into=("OUI",),
+                                 fr="excitation imposée unique" ),
+         MULTI_APPUI      =SIMP(statut='f',typ='TXM',position='global',into=("DECORRELE","CORRELE"),
+                                 fr="excitation imposée unique" ),
+         b_decorrele     =BLOC(condition = "MULTI_APPUI == 'DECORRELE' ",
+           GROUP_APPUI     =FACT(statut='f',max='**',
+           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='**'),),
+           
+         ),
+         b_correle =BLOC(condition = "MULTI_APPUI == 'CORRELE' ",
+           COMB_MULT_APPUI =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','NOEUD','GROUP_NO' ),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           TYPE_COMBI      =SIMP(statut='f',typ='TXM',into=("QUAD","LINE",) ),),
+         ),
+
+         COMB_MODE       =FACT(statut='o',
+           TYPE            =SIMP(statut='o',typ='TXM',into=("SRSS","CQC","DSC","ABS","DPC") ),
+           DUREE           =SIMP(statut='f',typ='R' ),
+         ),
+         COMB_DIRECTION  =FACT(statut='f',
+           TYPE            =SIMP(statut='f',typ='TXM',into=("QUAD","NEWMARK") ),
+         ),
+         COMB_DEPL_APPUI=FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','LIST_CAS'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           LIST_CAS       =SIMP(statut='f',typ='I',max='**'),
+           TYPE_COMBI      =SIMP(statut='f',typ='TXM',into=("QUAD","LINE","ABS") ),
+         ),
+         DEPL_MULT_APPUI =FACT(statut='f',max='**',
+           regles=(UN_PARMI('NOEUD','GROUP_NO'),
+                   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, ),
+           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='**'),
+           DX              =SIMP(statut='f',typ='R' ),
+           DY              =SIMP(statut='f',typ='R' ),
+           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") ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
+         IMPRESSION      =FACT(statut='f',max='**',
+           regles=(EXCLUS('TOUT','NIVEAU'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NIVEAU          =SIMP(statut='f',typ='TXM',into=("SPEC_OSCI","MASS_EFFE","MAXI_GENE"),validators=NoRepeat(),max=3 ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 12/05/2009   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.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def crea_champ_prod(TYPE_CHAM,**args):
+  if TYPE_CHAM[0:5] == "CART_" :
+     return carte_sdaster
+  elif TYPE_CHAM[0:5] == "NOEU_" :
+     return cham_no_sdaster
+  elif TYPE_CHAM[0:2] == "EL"    :
+     return cham_elem
+  else :
+     raise AsException("type de concept resultat_sdaster non prevu")
+
+
+CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod,
+                fr="Création d'un champ ",reentrant='f',
+            UIinfo={"groupes":("Résultats et champs",)},
+         TYPE_CHAM       =SIMP(statut='o',typ='TXM',into=C_TYPE_CHAM_INTO()),
+      # TYPE_CHAM doit etre de la forme : CART_xx, NOEU_xx, ELEM_xx, ELGA_xx ou ELNO_xx
+      # ou xx est le nom d'une grandeur définie dans le catalogue des grandeurs
+#        SI CREATION D'UN CHAM_NO, POUR IMPOSER LA NUMEROTATION DES DDLS :
+#        ------------------------------------------------------------------
+         regles=(EXCLUS('NUME_DDL','CHAM_NO',)),
+         NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster) ),
+         CHAM_NO         =SIMP(statut='f',typ=(cham_no_sdaster) ),
+
+#        SI CREATION D'UN CHAM_ELEM, POUR aider a l'allocation du champ :
+#        (PAR DEFAUT : TOU_INI_ELNO/_ELGA/_ELEM)
+#        ------------------------------------------------------------------
+         OPTION         =SIMP(statut='f',typ='TXM'),
+
+         OPERATION       =SIMP(statut='o',typ='TXM',into=("AFFE","ASSE","EVAL","EXTR","DISC","NORMALE","R2C","C2R","COMB") ),
+
+#        ------------------------------------------------------------------
+         b_norm          =BLOC(condition = "OPERATION == 'NORMALE'",
+                               regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),),
+             MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+             GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                             ),
+#        ------------------------------------------------------------------
+         b_affe          =BLOC(condition = "OPERATION == 'AFFE'",
+             regles=(UN_PARMI('MAILLAGE','MODELE'),),
+             MAILLAGE        =SIMP(statut='f',typ=(maillage_sdaster) ),
+             MODELE          =SIMP(statut='f',typ=(modele_sdaster) ),
+             b_affe_modele   =BLOC(condition = "MODELE != None",
+                 PROL_ZERO       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), ),
+             AFFE            =FACT(statut='o',max='**',
+                regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD',),
+                        UN_PARMI('VALE','VALE_I','VALE_C','VALE_F', ),),
+                TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                GROUP_MA        =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
+                MAILLE          =SIMP(statut='f',typ=ma   ,validators=NoRepeat(),max='**'),
+                GROUP_NO        =SIMP(statut='f',typ=grno ,validators=NoRepeat(),max='**'),
+                NOEUD           =SIMP(statut='f',typ=no   ,validators=NoRepeat(),max='**'),
+                NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
+                VALE            =SIMP(statut='f',typ='R',max='**' ),
+                VALE_I          =SIMP(statut='f',typ='I',max='**' ),
+                VALE_C          =SIMP(statut='f',typ='C',max='**' ),
+                VALE_F          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
+                                   ),
+                             ),
+#        ------------------------------------------------------------------
+         b_asse          =BLOC(condition = "OPERATION == 'ASSE'",
+             regles=(UN_PARMI('MAILLAGE','MODELE'),),
+             MAILLAGE        =SIMP(statut='f',typ=(maillage_sdaster) ),
+             MODELE          =SIMP(statut='f',typ=(modele_sdaster) ),
+             b_asse_modele   =BLOC(condition = "MODELE != None",
+                 PROL_ZERO       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), ),
+             ASSE            =FACT(statut='o',max='**',
+                regles=(AU_MOINS_UN('TOUT','GROUP_MA','GROUP_NO','MAILLE','NOEUD',),
+                PRESENT_PRESENT('NOM_CMP_RESU','NOM_CMP', ),),
+                TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                CHAM_GD         =SIMP(statut='o',typ=cham_gd_sdaster),
+                NOM_CMP         =SIMP(statut='f',typ='TXM',max='**' ),
+                NOM_CMP_RESU    =SIMP(statut='f',typ='TXM',max='**' ),
+                CUMUL           =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+                COEF_R          =SIMP(statut='f',typ='R',defaut= 1. ),
+                COEF_C          =SIMP(statut='f',typ='C',max=1),
+                                    ),
+                             ),
+#        ------------------------------------------------------------------
+         b_comb          =BLOC(condition = "OPERATION == 'COMB'",
+                               fr="Pour faire une combinaison linéaire de cham_no ayant meme profil",
+             COMB            =FACT(statut='o',max='**',
+                CHAM_GD         =SIMP(statut='o',typ=cham_no_sdaster),
+                COEF_R          =SIMP(statut='o',typ='R'),
+                                   ),
+                             ),
+#        ------------------------------------------------------------------
+         b_eval          =BLOC(condition = "OPERATION == 'EVAL'",
+             CHAM_F          =SIMP(statut='o',typ=cham_gd_sdaster),
+             CHAM_PARA       =SIMP(statut='o',typ=cham_gd_sdaster,max='**'),
+                             ),
+#        ------------------------------------------------------------------
+         b_r2c           =BLOC(condition = "OPERATION == 'R2C'",
+             CHAM_GD          =SIMP(statut='o',typ=cham_gd_sdaster),
+                             ),
+#        ------------------------------------------------------------------
+         b_c2r           =BLOC(condition = "OPERATION == 'C2R'",
+             CHAM_GD          =SIMP(statut='o',typ=cham_gd_sdaster),
+             PARTIE           =SIMP(statut='o',typ='TXM',into=('REEL','IMAG','MODULE','PHASE'),),
+                             ),
+#        ------------------------------------------------------------------
+         b_disc          =BLOC(condition = "OPERATION == 'DISC'",
+             MODELE          =SIMP(statut='f',typ=(modele_sdaster) ),
+             PROL_ZERO       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+             CHAM_GD         =SIMP(statut='o',typ=cham_gd_sdaster),
+                             ),
+#        ------------------------------------------------------------------
+         b_extr          =BLOC(condition = "OPERATION == 'EXTR'",
+             regles=(AU_MOINS_UN('MAILLAGE','FISSURE','RESULTAT','TABLE'),),
+             MAILLAGE        =SIMP(statut='f',typ=(maillage_sdaster) ),
+             FISSURE         =SIMP(statut='f',typ=(fiss_xfem) ),
+             RESULTAT        =SIMP(statut='f',typ=(resultat_sdaster) ),
+             TABLE           =SIMP(statut='f',typ=(table_sdaster),min=1,max=1),
+             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_table    =BLOC(condition = "TABLE != None",
+                      regles=( EXCLUS('MODELE','MAILLAGE'),
+                               EXCLUS('PROL_ZERO','MAILLAGE'),),
+                      MAILLAGE        =SIMP(statut='f',typ=(maillage_sdaster),),
+                      MODELE          =SIMP(statut='f',typ=(modele_sdaster),),
+                      OPTION          =SIMP(statut='f',typ='TXM'),
+                      PROL_ZERO       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+                 ),
+             b_extr_resultat =BLOC(condition = "RESULTAT != None",
+                 regles=(DERIVABLE('RESULTAT'),),
+                 SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),
+                                   fr="Paramètre de sensibilité.",
+                                   ang="Sensitivity parameter"),
+                 NOM_CHAM        =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO()),
+                 TYPE_MAXI       =SIMP(statut='f',typ='TXM',into=("MAXI","MINI","MAXI_ABS","MINI_ABS","NORM_TRAN",) ),
+
+                 # si TYPE_MAXI, on spécifie en général plusieurs numéros d'ordre :
+                 b_type_maxi =BLOC(condition = "TYPE_MAXI != None",
+                      TYPE_RESU       =SIMP(statut='o',typ='TXM',defaut="VALE",into=("VALE","INST",) ),
+
+                      regles=(EXCLUS('TOUT_ORDRE','LIST_INST','LIST_FREQ','NUME_ORDRE','INST',
+                                      'FREQ','NUME_MODE','NOEUD_CMP','NOM_CAS','ANGL'),),
+                      TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                      LIST_INST       =SIMP(statut='f',typ=(listr8_sdaster) ),
+                      LIST_FREQ       =SIMP(statut='f',typ=(listr8_sdaster) ),
+                      NUME_ORDRE      =SIMP(statut='f',typ='I',max='**'),
+                      INST            =SIMP(statut='f',typ='R',max='**'),
+                      FREQ            =SIMP(statut='f',typ='R',max='**'),
+                      NUME_MODE       =SIMP(statut='f',typ='I',max='**'),
+                      NOEUD_CMP       =SIMP(statut='f',typ='TXM',max='**'),
+                      NOM_CAS         =SIMP(statut='f',typ='TXM',max='**'),
+                      ANGL            =SIMP(statut='f',typ='R',max='**'),
+                 ),
+
+                 # si .not. TYPE_MAXI, on ne doit spécifier qu'un seul numéro d'ordre :
+                 b_non_type_maxi =BLOC(condition = "TYPE_MAXI == None",
+                      regles=(EXCLUS('NUME_ORDRE','INST','FREQ','NUME_MODE','NOEUD_CMP','NOM_CAS','ANGL'),),
+                      NUME_ORDRE      =SIMP(statut='f',typ='I'),
+                      INST            =SIMP(statut='f',typ='R'),
+                      FREQ            =SIMP(statut='f',typ='R'),
+                      NUME_MODE       =SIMP(statut='f',typ='I'),
+                      NOEUD_CMP       =SIMP(statut='f',typ='TXM',max=2),
+                      NOM_CAS         =SIMP(statut='f',typ='TXM'),
+                      ANGL            =SIMP(statut='f',typ='R'),
+
+                      INTERPOL        =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","LIN",) ),
+                 ),
+
+                 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',),),
+
+         ),  # fin bloc b_extr
+
+
+               ),
+# FIN DU CATALOGUE : INFO,TITRE ET TYPAGE DU RESULTAT :
+#-----------------------------------------------------
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+)  ;
+#& MODIF COMMANDE  DATE 30/06/2008   AUTEUR PELLET J.PELLET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+CREA_MAILLAGE=OPER(nom="CREA_MAILLAGE",op= 167,sd_prod=maillage_sdaster,
+            reentrant='n',fr="Crée un maillage à partir d'un maillage existant",
+            UIinfo={"groupes":("Maillage",)},
+         regles=(EXCLUS('COQU_VOLU', 'CREA_FISS', 'CREA_GROUP_MA', 'CREA_MAILLE', 'CREA_POI1',
+                        'DETR_GROUP_MA', 'ECLA_PG', 'HEXA20_27', 'LINE_QUAD', 'MODI_MAILLE',
+                        'QUAD_LINE', 'REPERE','RESTREINT'),),
+
+
+
+         # le MAILLAGE est inutile si ECLA_PG
+         MAILLAGE        =SIMP(statut='f',typ=maillage_sdaster ),
+
+         CREA_POI1       =FACT(statut='f',max='**',fr="Création de mailles de type POI1 à partir de noeuds",
+           regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD' ),),
+           NOM_GROUP_MA    =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+         ),
+         CREA_MAILLE     =FACT(statut='f',max='**',fr="Duplication de mailles",
+           regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           PREF_MAILLE     =SIMP(statut='o',typ='TXM' ),
+           PREF_NUME       =SIMP(statut='f',typ='I' ),
+         ),
+         CREA_GROUP_MA   =FACT(statut='f',max='**',fr="Duplication de mailles et création de groupes de mailles",
+           regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
+           NOM             =SIMP(statut='o',typ='TXM'),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           PREF_MAILLE     =SIMP(statut='o',typ='TXM' ),
+           PREF_NUME       =SIMP(statut='f',typ='I' ),
+         ),
+         DETR_GROUP_MA   =FACT(statut='f',fr="Destruction de groupes de mailles",
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           NB_MAILLE       =SIMP(statut='f',typ='I',defaut= 0,
+                                 fr="Nombre minimal de mailles que doit contenir le groupe pour etre détruit",  ),
+         ),
+         RESTREINT   =FACT(statut='f',fr="Restreindre un maillage à des groupes de mailles",max=1,
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+           TOUT_GROUP_MA   =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           TOUT_GROUP_NO   =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
+         ),
+         COQU_VOLU   =FACT(statut='f',
+                           fr="Creation de mailles volumiques à partir de mailles surfaciques",
+           NOM             =SIMP(statut='o',typ='TXM'),
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max ='**'),
+           EPAIS           =SIMP(statut='o',typ='R' ),
+           PREF_MAILLE     =SIMP(statut='f',typ='TXM',defaut="MS" ),
+           PREF_NOEUD      =SIMP(statut='f',typ='TXM',defaut="NS" ),
+           PREF_NUME       =SIMP(statut='f',typ='I'  ,defaut=1 ),
+           PLAN            =SIMP(statut='o',typ='TXM',into=("SUP","MOY","INF")),
+           b_MOY =BLOC(condition = "PLAN == 'MOY'",
+             TRANSLATION   =SIMP(statut='o',typ='TXM',into=("SUP","INF") ),
+           ),
+         ),
+         MODI_MAILLE     =FACT(statut='f',max='**',fr="Modification du type de mailles",
+           regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma  ,validators=NoRepeat(),max='**'),
+           OPTION          =SIMP(statut='o',typ='TXM',into=("TRIA6_7","QUAD8_9","SEG3_4","QUAD_TRIA3"),
+                                 fr="Choix de la transformation" ),
+           b_NOS =BLOC(condition = "OPTION == 'TRIA6_7'  or  OPTION == 'QUAD8_9'  or  OPTION == 'SEG3_4'",
+             PREF_NOEUD      =SIMP(statut='f',typ='TXM',defaut="NS"),
+             PREF_NUME       =SIMP(statut='f',typ='I',defaut= 1 ),
+           ),
+           b_QTR =BLOC(condition = "OPTION == 'QUAD_TRIA3'",
+             PREF_MAILLE     =SIMP(statut='f',typ='TXM',defaut="MS" ),
+             PREF_NUME       =SIMP(statut='f',typ='I',defaut= 1 ),
+           ),
+         ),
+         CREA_FISS = FACT(statut='f',max='**',fr="Creation d'une fissure potentielle avec elts de joint ou elts à disc",
+           NOM             =SIMP(statut='o',typ='TXM'),
+           GROUP_NO_1      =SIMP(statut='o',typ=grno),
+           GROUP_NO_2      =SIMP(statut='o',typ=grno),
+           PREF_MAILLE     =SIMP(statut='o',typ='TXM'),
+           PREF_NUME       =SIMP(statut='f',typ='I',defaut=1 ),
+         ),
+         LINE_QUAD     =FACT(statut='f',fr="Passage linéaire -> quadratique",
+           regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma  ,validators=NoRepeat(),max='**'),
+           PREF_NOEUD      =SIMP(statut='f',typ='TXM',defaut="NS"),
+           PREF_NUME       =SIMP(statut='f',typ='I',defaut= 1 ),
+         ),
+         HEXA20_27     =FACT(statut='f',fr="Passage HEXA20 -> HEXA27",
+           regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma  ,validators=NoRepeat(),max='**'),
+           PREF_NOEUD      =SIMP(statut='f',typ='TXM',defaut="NS"),
+           PREF_NUME       =SIMP(statut='f',typ='I',defaut= 1 ),
+         ),
+         QUAD_LINE     =FACT(statut='f',fr="Passage quadratique -> linéaire",
+           regles=(AU_MOINS_UN('TOUT','MAILLE','GROUP_MA' ),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma  ,validators=NoRepeat(),max='**'),
+         ),
+         REPERE          =FACT(statut='f',max='**',
+                               fr="changement de repère servant à déterminer les caractéristiques d'une section de poutre",
+           TABLE           =SIMP(statut='o',typ=table_sdaster,
+                                 fr="Nom de la table contenant les caractéristiques de la section de poutre" ),
+           NOM_ORIG        =SIMP(statut='f',typ='TXM',into=("CDG","TORSION"),fr="Origine du nouveau repère" ),
+           NOM_ROTA        =SIMP(statut='f',typ='TXM',into=("INERTIE",),fr="Direction du repére"  ),
+           b_cdg =BLOC(condition = "NOM_ORIG == 'CDG'",
+             GROUP_MA        =SIMP(statut='f',typ=grma,
+                                   fr="Nom du groupe de mailles dont le centre de gravité sera l origine du nouveau repère"),
+           ),
+         ),
+         ECLA_PG         =FACT(statut='f',
+                               fr="Eclatement des mailles en petites mailles contenant chacune un seul point de gauss",
+           MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           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='**'),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+#
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 20/10/2008   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.
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+def crea_resu_prod(TYPE_RESU,**args):
+  if TYPE_RESU == "EVOL_ELAS"    : return evol_elas
+  if TYPE_RESU == "EVOL_NOLI"    : return evol_noli
+  if TYPE_RESU == "EVOL_THER"    : return evol_ther
+  if TYPE_RESU == "MULT_ELAS"    : return mult_elas
+  if TYPE_RESU == "MODE_MECA"    : return mode_meca
+  if TYPE_RESU == "FOURIER_ELAS" : return fourier_elas
+  if TYPE_RESU == "FOURIER_THER" : return fourier_ther
+  if TYPE_RESU == "EVOL_VARC"    : return evol_varc
+  if TYPE_RESU == "EVOL_CHAR"    : return evol_char
+  raise AsException("type de concept resultat non prevu")
+
+CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f',
+            UIinfo={"groupes":("Modélisation",)},
+               fr="Créer ou enrichir une structure de donnees resultat à partir de champs aux noeuds",
+
+         OPERATION =SIMP(statut='o',typ='TXM',into=("AFFE","ASSE","ECLA_PG","PERM_CHAM","PROL_RTZ","PREP_VRC1","PREP_VRC2",),
+                         fr="choix de la fonction a activer",),
+
+
+         # Création par affectation de champs :
+         #-------------------------------------
+         b_affe       =BLOC(condition = "OPERATION == 'AFFE'",
+
+           TYPE_RESU    =SIMP(statut='o',position='global',typ='TXM',into=("MODE_MECA","MULT_ELAS","EVOL_ELAS","EVOL_NOLI",
+                                                        "FOURIER_ELAS","EVOL_THER","EVOL_VARC","EVOL_CHAR","FOURIER_THER") ),
+           NOM_CHAM     =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO()),
+
+           b_mode       =BLOC(condition = "TYPE_RESU == 'MODE_MECA'",
+             MATR_A         =SIMP(statut='f',typ=matr_asse_depl_r,),
+             MATR_B         =SIMP(statut='f',typ=matr_asse_depl_r,),
+           ),
+
+           AFFE         =FACT(statut='o',max='**',
+             CHAM_GD       =SIMP(statut='o',typ=(cham_gd_sdaster)),
+             MODELE        =SIMP(statut='f',typ=modele_sdaster),
+             CHAM_MATER    =SIMP(statut='f',typ=cham_mater),
+             CARA_ELEM     =SIMP(statut='f',typ=cara_elem),
+
+             b_mult_elas     =BLOC(condition = "TYPE_RESU == 'MULT_ELAS' ",
+                NOM_CAS         =SIMP(statut='f',typ='TXM' ),
+             ),
+             b_evol          =BLOC(condition = "((TYPE_RESU=='EVOL_ELAS') or (TYPE_RESU=='EVOL_NOLI') or (TYPE_RESU=='EVOL_THER')\
+                                                                          or (TYPE_RESU=='EVOL_VARC') or (TYPE_RESU=='EVOL_CHAR'))",
+                regles=(UN_PARMI('INST','LIST_INST'),),
+                INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+                LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+                NUME_INIT       =SIMP(statut='f',typ='I', val_min=1),
+                NUME_FIN        =SIMP(statut='f',typ='I', val_min=1),
+                PRECISION       =SIMP(statut='f',typ='R',defaut= 0.0 ),
+                CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+             ),
+             b_fourier       =BLOC(condition = "((TYPE_RESU == 'FOURIER_ELAS') or (TYPE_RESU == 'FOURIER_THER')) ",
+                NUME_MODE       =SIMP(statut='f',typ='I'),
+                TYPE_MODE       =SIMP(statut='f',typ='TXM',defaut="SYME",into=("SYME","ANTI","TOUS") ),
+             ),
+             b_mode       =BLOC(condition = "TYPE_RESU == 'MODE_MECA'",
+                NUME_MODE       =SIMP(statut='f',typ='I'),
+                FREQ            =SIMP(statut='f',typ='R'),
+             ),
+           ),
+         ),
+
+
+         # Création par assemblage d'evol_ther :
+         #-----------------------------------------
+         b_asse       =BLOC(condition = "OPERATION == 'ASSE'",
+           TYPE_RESU    =SIMP(statut='o',position='global',typ='TXM',into=("EVOL_THER",) ),
+           ASSE         =FACT(statut='o',max='**',
+             RESULTAT       =SIMP(statut='o',typ=evol_ther),
+             TRANSLATION    =SIMP(statut='f',typ='R',defaut= 0. ),
+           ),
+         ),
+
+
+         b_ecla_pg    =BLOC(condition = "OPERATION == 'ECLA_PG'",
+
+           TYPE_RESU       =SIMP(statut='o',typ='TXM',into=("EVOL_ELAS","EVOL_NOLI","EVOL_THER"), ),
+
+           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='**'),
+             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='**'),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             RESU_INIT       =SIMP(statut='o',typ=resultat_sdaster),
+             MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster),
+             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),
+             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',),),
+           ),
+         ),
+
+
+         b_perm_cham =BLOC(condition = "OPERATION == 'PERM_CHAM'",
+
+           TYPE_RESU       =SIMP(statut='o',typ='TXM',into=("EVOL_NOLI",) ),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',into=("DEPL","SIEF_ELGA","VARI_ELGA",),validators=NoRepeat(),max='**' ),
+           RESU_INIT       =SIMP(statut='o',typ=evol_noli),
+           INST_INIT       =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',),),
+           MAILLAGE_INIT   =SIMP(statut='o',typ=maillage_sdaster,),
+           RESU_FINAL      =SIMP(statut='o',typ=evol_noli,),
+           MAILLAGE_FINAL  =SIMP(statut='o',typ=maillage_sdaster,),
+           PERM_CHAM       =FACT(statut='o',max='**',
+              GROUP_MA_FINAL =SIMP(statut='o',typ=grma),
+              GROUP_MA_INIT  =SIMP(statut='o',typ=grma),
+              TRAN           =SIMP(statut='o',typ='R',min=3,max=3),
+              PRECISION      =SIMP(statut='f',typ='R',defaut=1.0E-3),
+           ),
+         ),
+
+         b_prol_rtz   =BLOC(condition = "OPERATION == 'PROL_RTZ'",
+
+           TYPE_RESU       =SIMP(statut='o',typ='TXM',into=("EVOL_THER",) ),
+
+           PROL_RTZ        =FACT(statut='o',
+              regles=(EXCLUS('INST','LIST_INST'),),
+              MAILLAGE_FINAL  =SIMP(statut='o',typ=maillage_sdaster,),
+              TABLE           =SIMP(statut='o',typ=table_sdaster,fr="Table issue de post_releve_t"),
+              INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+              LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+              b_acce_reel     =BLOC(condition="(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',),),
+              ),
+              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",),),
+              REPERE          =SIMP(statut='o',typ='TXM',into=("CYLINDRIQUE",),),
+              ORIGINE         =SIMP(statut='o',typ='R',min=3,max=3),
+              AXE_Z           =SIMP(statut='o',typ='R',min=3,max=3),
+           ),
+         ),
+
+         b_prep_vrc1      =BLOC(condition = "OPERATION == 'PREP_VRC1'",
+           # calculer la température dans les couches des coques multicouche à partir d'un champ de fonctions
+           # de fonctions du temps et de l'espace (épaisseur)
+
+           TYPE_RESU    =SIMP(statut='o',position='global',typ='TXM',into=( "EVOL_THER",) ),
+
+           PREP_VRC1        =FACT(statut='o',max=1,
+             CHAM_GD       =SIMP(statut='o',typ=(cham_gd_sdaster)), # carte de fonctions du temps et de l'épaisseur
+             MODELE        =SIMP(statut='o',typ=modele_sdaster),    # modèle mécanique contenant les coques multicouche
+             CARA_ELEM     =SIMP(statut='o',typ=cara_elem),         # CARA_ELEM pour connaitre EPAIS et COQU_NCOU
+             INST          =SIMP(statut='o',typ='R',validators=NoRepeat(),max='**'),
+           ),
+         ),
+
+         b_prep_vrc2      =BLOC(condition = "OPERATION == 'PREP_VRC2'",
+           # calculer la température dans les couches des coques multicouche à partir d'un evol_ther "coque"
+           # contenant TEMP/TEMP_INF/TEMP_SUP
+
+           TYPE_RESU    =SIMP(statut='o',position='global',typ='TXM',into=( "EVOL_THER",) ),
+
+           PREP_VRC2        =FACT(statut='o',max=1,
+             EVOL_THER     =SIMP(statut='o',typ=(evol_ther)),       # evol_ther de type "coque" (TEMP/TEMP_INF/TEMP_SUP)
+             MODELE        =SIMP(statut='o',typ=modele_sdaster),    # modèle mécanique contenant les coques multicouche
+             CARA_ELEM     =SIMP(statut='o',typ=cara_elem),         # CARA_ELEM pour connaitre EPAIS et COQU_NCOU
+           ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 28/07/2009   AUTEUR TORKHANI M.TORKHANI 
+#            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.        
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+def crea_table_prod(TYPE_TABLE, **args):
+   """Typage du concept résultat
+   """
+   if TYPE_TABLE == 'TABLE_FONCTION':
+      return table_fonction
+   elif TYPE_TABLE == 'TABLE_CONTENEUR':
+      return table_container
+   else:
+      return table_sdaster
+
+CREA_TABLE=OPER(nom="CREA_TABLE",op=36,sd_prod=crea_table_prod,
+                fr="Création d'une table à partir d'une fonction ou de deux listes",
+                reentrant='f',UIinfo={"groupes":("Table",)},
+
+           regles=(EXCLUS('FONCTION','LISTE'),),
+
+           LISTE=FACT(statut='f',max='**',
+                 fr="Creation d'une table a partir de listes",
+                 regles=(UN_PARMI('LISTE_I','LISTE_R','LISTE_K')), 
+                        PARA     =SIMP(statut='o',typ='TXM'),
+                        TYPE_K   =SIMP(statut='f',typ='TXM',defaut='K8',
+                                    into=('K8','K16','K24')),
+                        NUME_LIGN=SIMP(statut='f',typ='I',max='**'),
+                        LISTE_I  =SIMP(statut='f',typ='I',max='**'),
+                        LISTE_R  =SIMP(statut='f',typ='R',max='**'),
+                        LISTE_K  =SIMP(statut='f',typ='TXM', max='**'),
+           ),
+           FONCTION=FACT(statut='f',
+                    fr="Creation d'une table a partir d'une fonction",
+                        FONCTION=SIMP(statut='o',typ=(fonction_c,fonction_sdaster)),
+                        PARA=SIMP(statut='f',typ='TXM',min=2,max=2),
+           ),
+           b_fonction = BLOC(condition='FONCTION != None',
+               regles=(CONCEPT_SENSIBLE('SEPARE'), REUSE_SENSIBLE(),
+                       DERIVABLE('FONCTION'),),
+               SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                                    fr="Liste des paramètres de sensibilité.",
+                                    ang="List of sensitivity parameters"),
+           ),
+           TYPE_TABLE = SIMP(statut='f', typ='TXM', defaut="TABLE",
+                             into=('TABLE', 'TABLE_FONCTION', 'TABLE_CONTENEUR'),),
+           
+           TITRE=SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+
+
+
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 LEFEBVRE J.P.LEFEBVRE
+
+DEBUG=PROC(nom="DEBUG",op=137,
+            UIinfo={"groupes":("Utilitaires",)},
+               fr="Permettre de changer entre 2 commandes quelques variables globales de debug",
+
+     SDVERI          =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+                           statut='f',typ='TXM',into=('OUI','NON')),
+     JXVERI          =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
+                           statut='f',typ='TXM',into=('OUI','NON')),
+     JEVEUX          =SIMP(fr="force les déchargement sur disque",
+                           statut='f',typ='TXM',into=('OUI','NON')),
+     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 07/09/2009   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.
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+DEBUT=MACRO(nom="DEBUT",op=ops.build_debut ,repetable='n',
+            UIinfo={"groupes":("Gestion du travail",)},
+           fr="Ouverture d'une étude. Allocation des ressources mémoire et disque et fichiers",
+          sd_prod=ops.DEBUT,
+
+         PAR_LOT         =SIMP(fr="mode de traitement des commandes",statut='f',typ='TXM',
+                           into=("OUI","NON"),defaut="OUI"),
+         IMPR_MACRO      =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess",
+                           statut='f',typ='TXM',into=("OUI","NON"),defaut="NON"),
+#         FORMAT_HDF      =SIMP(fr="sauvegarde de la base GLOBALE au format HDF",statut='f',
+#                               typ='TXM',defaut="NON",into=("OUI","NON",) ),
+         BASE            =FACT(fr="définition des paramètres associés aux bases JEVEUX",
+                               statut='f',min=1,max=2,
+           FICHIER         =SIMP(fr="nom de la base",statut='o',typ='TXM',
+                                 into=('GLOBALE','VOLATILE'),),
+           TITRE           =SIMP(statut='f',typ='TXM'),
+           CAS             =SIMP(statut='f',typ='TXM'),
+           NMAX_ENRE       =SIMP(fr="nombre maximum d enregistrements",statut='f',typ='I'),
+           LONG_ENRE       =SIMP(fr="longueur des enregistrements",statut='f',typ='I'),
+           LONG_REPE       =SIMP(fr="longueur du répertoire",statut='f',typ='I'),
+         ),
+
+         IMPRESSION      =FACT(statut='f',min=1,max=3,
+           FICHIER         =SIMP(statut='o',typ='TXM'),
+           UNITE           =SIMP(statut='o',typ='I'),
+         ),
+
+         CATALOGUE       =FACT(statut='f',min=1,max=10,
+           FICHIER         =SIMP(statut='o',typ='TXM'),
+           TITRE           =SIMP(statut='f',typ='TXM'),
+           UNITE           =SIMP(statut='f',typ='I'),
+         ),
+
+         CODE            =FACT(fr="définition d'un nom pour l'ensemble d'une étude",
+                               statut='f',min=1,max=1,
+           NOM             =SIMP(statut='o',typ='TXM'),
+           NIV_PUB_WEB     =SIMP(statut='o',typ='TXM',into=('INTERNET','INTRANET')),
+           VISU_EFICAS     =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI'),
+         ),
+
+         ERREUR          =FACT(fr="comportement en cas d'erreur",statut='f',min=1,max=1,
+           ERREUR_F        =SIMP(statut='f',typ='TXM',into=('ABORT','EXCEPTION'),),
+         ),
+
+         DEBUG           =FACT(fr="option de déboggage reservée aux développeurs",
+                               statut='f',min=1,max=1,
+           JXVERI          =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
+                                 statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
+           SDVERI          =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+                                 statut='f',typ='TXM',into=('OUI','NON')),
+           JEVEUX          =SIMP(fr="force les déchargement sur disque",
+                                 statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
+           ENVIMA          =SIMP(fr="imprime les valeurs définies dans ENVIMA",
+                                 statut='f',typ='TXM',into=('TEST',)),
+         ),
+
+         MESURE_TEMPS     =FACT(fr="Pour choisir les mesures de temps consommé dans les commandes",
+                               statut='d',min=1,max=1,
+           NIVE_DETAIL      =SIMP(fr="niveau de détail des impressions",
+                                 statut='f',typ='I',into=(0,1,2,3),defaut=1),
+                                 # 0 : rien
+                                 # 1 : impression en fin de commande des mesures principales
+                                 # 2 : impression en fin de commande des mesures principales et secondaires
+                                 # 3 : impression des mesures principales et secondaires pour chaque pas de temps
+         ),
+
+         MEMOIRE         =FACT(fr="mode de gestion mémoire utilisé",statut='d',min=1,max=1,
+           GESTION         =SIMP(statut='f',typ='TXM',into=('COMPACTE','RAPIDE'),defaut='RAPIDE'),
+           TYPE_ALLOCATION =SIMP(statut='f',typ='I',into=(1,2,3,4),defaut=1),
+           TAILLE          =SIMP(statut='f',typ='I'),
+           TAILLE_BLOC     =SIMP(statut='f',typ='R',defaut=800.),
+           PARTITION       =SIMP(statut='f',typ='R'),
+           DYNAMIQUE       =SIMP(statut='f',typ='I',defaut=1),
+         ),
+
+         RESERVE_CPU     =FACT(fr="reserve de temps pour terminer une execution",statut='d',max=1,
+           regles=(EXCLUS('VALE','POURCENTAGE'),),
+#          par défaut VALE fixée à 10. dans le FORTRAN si CODE présent
+           VALE            =SIMP(statut='f',typ='I',val_min=0,),
+#          par défaut 10% dans le FORTRAN
+           POURCENTAGE     =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0),
+#          valeur en secondes de la réserve maximum bornée à 900 secondes
+           BORNE           =SIMP(statut='f',typ='I',val_min=0,defaut=900),),
+
+         IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"),
+
+);
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 NISTOR I.NISTOR
+DEFI_BASE_MODALE=OPER(nom="DEFI_BASE_MODALE",op=  99,sd_prod=mode_meca,
+                     reentrant='f',
+                     fr="Définit la base d'une sous-structuration dynamique ou d'une recombinaison modale",
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=(UN_PARMI('CLASSIQUE','RITZ','DIAG_MASS','ORTHO_BASE'),),
+         CLASSIQUE       =FACT(statut='f',
+           INTERF_DYNA     =SIMP(statut='o',typ=interf_dyna_clas ),
+           MODE_MECA       =SIMP(statut='o',typ=mode_meca,max='**' ),
+           NMAX_MODE       =SIMP(statut='f',typ='I',defaut= 10 ),
+         ),
+         RITZ            =FACT(statut='f',max='**',
+           regles=(UN_PARMI('MODE_MECA','BASE_MODALE','MODE_INTF'),),
+           MODE_MECA       =SIMP(statut='f',typ=mode_meca,max='**'  ),
+           NMAX_MODE       =SIMP(statut='f',typ='I'),
+           BASE_MODALE     =SIMP(statut='f',typ=mode_meca ),
+           MODE_INTF       =SIMP(statut='f',typ=(mode_meca,mult_elas), ),
+         ),
+         b_ritz          =BLOC(condition = "RITZ != None",
+           INTERF_DYNA     =SIMP(statut='f',typ=interf_dyna_clas ),
+           NUME_REF        =SIMP(statut='o',typ=nume_ddl_sdaster ),
+           ORTHO           =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
+                               fr="Reorthonormalisation de la base de Ritz" ),
+           LIST_AMOR       =SIMP(statut='f',typ=listr8_sdaster ),
+           b_ortho          =BLOC(condition = "ORTHO == 'OUI' ",
+             MATRICE          =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_gene_r,matr_asse_pres_r ) ),
+               ),
+         ),
+        DIAG_MASS        =FACT(statut='f',max='**',
+           MODE_MECA       =SIMP(statut='o',typ=mode_meca,max='**'  ),
+           MODE_STAT       =SIMP(statut='o',typ=mode_meca ),
+         ),
+        ORTHO_BASE        =FACT(statut='f',max='**',
+           BASE       =SIMP(statut='o',typ=(mode_meca,mult_elas)),
+           MATRICE    =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_gene_r,matr_asse_pres_r ) ),
+         ),
+
+         SOLVEUR         =FACT(statut='d', fr="Méthode de résolution des systèmes linéaires",
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("LDLT","MULT_FRONT","MUMPS") ),
+
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             FILTRAGE_MATRICE =SIMP(statut='f',typ='R',defaut=-1.0,),
+             MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+         ),
+
+
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE MICHEL S.MICHEL
+
+from Macro.defi_cable_bp_ops import defi_cable_bp_ops
+
+# ===========================================================================
+#           CATALOGUE DE LA MACRO "DEFI_CABLE_BP"
+#           -----------------------------------------
+#
+# USAGE :
+# Entrée :
+#  - MODELE
+#  - CABLE
+#  - CHAM_MATER
+#  - CARA_ELEM
+#  - GROUP_MA_BETON
+#  - DEFI_CABLE
+#  - TENSION_INIT
+#  - RECUL_ANCRAGE
+#  - RELAXATION
+#  - CONE
+#      RAYON
+#      LONGUEUR
+#      PRESENT          OUI ou NON deux fois
+#  - TITRE
+#  - INFO               1 / 2
+#
+# ===========================================================================
+
+DEFI_CABLE_BP=MACRO(nom="DEFI_CABLE_BP",op=defi_cable_bp_ops,sd_prod=cabl_precont,
+                   fr="Calculer les profils initiaux de tension le long des cables de précontrainte d'une structure en béton",
+                   reentrant='n',UIinfo={"groupe":("Modélisation",)},
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater ),
+         CARA_ELEM       =SIMP(statut='o',typ=cara_elem ),
+         GROUP_MA_BETON  =SIMP(statut='o',typ=grma,max='**'),
+         DEFI_CABLE      =FACT(statut='o',max='**',
+           regles=(UN_PARMI('MAILLE','GROUP_MA'),
+                   UN_PARMI('NOEUD_ANCRAGE','GROUP_NO_ANCRAGE'),),
+           MAILLE          =SIMP(statut='f',typ=ma,min=2,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma),
+           NOEUD_ANCRAGE   =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max=2),
+           GROUP_NO_ANCRAGE=SIMP(statut='f',typ=grno,validators=NoRepeat(),max=2),
+         ),
+         TYPE_ANCRAGE    =SIMP(statut='o',typ='TXM',min=2,max=2,into=("ACTIF","PASSIF") ),
+         TENSION_INIT    =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         RECUL_ANCRAGE   =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         RELAXATION      =FACT(statut='f',min=0,
+           R_J             =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         ),
+         CONE            =FACT(statut='f',
+           RAYON             =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+           LONGUEUR          =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+           PRESENT           =SIMP(statut='o',typ='TXM',min=2,max=2,into=("OUI","NON") ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE MICHEL S.MICHEL
+
+DEFI_CABLE_OP=OPER(nom="DEFI_CABLE_OP",op= 180,sd_prod=cabl_precont,reentrant='n',
+            fr="Définit les profils initiaux de tension d'une structure en béton le long des cables de précontrainte"
+               +" (utilisée par la macro DEFI_CABLE_BP)",
+            UIinfo={"groupes":("Modélisation",)},
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater ),
+         CARA_ELEM       =SIMP(statut='o',typ=cara_elem ),
+         GROUP_MA_BETON  =SIMP(statut='o',typ=grma,max='**'),
+         DEFI_CABLE      =FACT(statut='o',max='**',
+           regles=(UN_PARMI('MAILLE','GROUP_MA'),
+                   UN_PARMI('NOEUD_ANCRAGE','GROUP_NO_ANCRAGE'),),
+           MAILLE          =SIMP(statut='f',typ=ma,min=2,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma),
+           NOEUD_ANCRAGE   =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max=2),
+           GROUP_NO_ANCRAGE=SIMP(statut='f',typ=grno,validators=NoRepeat(),max=2),
+           GROUP_NO_FUT    =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=2),
+         ),
+         TYPE_ANCRAGE    =SIMP(statut='o',typ='TXM',min=2,max=2,into=("ACTIF","PASSIF") ),
+         TENSION_INIT    =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         RECUL_ANCRAGE   =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         RELAXATION      =FACT(statut='f',min=0,
+           R_J             =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         CONE            =FACT(statut='f',min=0,
+           RAYON             =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+           LONGUEUR          =SIMP(statut='o',typ='R',val_min=0.E+0, defaut=0.E+0 ),  
+           PRESENT           =SIMP(statut='o',typ='TXM',min=2,max=2,into=("OUI","NON") ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 22/09/2009   AUTEUR PROIX J-M.PROIX 
+#            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 PROIX J.M.PROIX
+DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster,
+                   fr="Définir le comportement d'un monocristal, d'un polycristal ou de groupes de fibres",
+                   reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+# on exclut MULTIFBRE de MONOCRISTAL ou POLYCRISTAL car la structure de données n'est pas organisée pareil pour ces cas
+                  regles=(UN_PARMI('MONOCRISTAL','POLYCRISTAL','MULTIFIBRE'),
+                 PRESENT_PRESENT('MULTIFIBRE','GEOM_FIBRE','MATER_SECT'),
+                         ),
+          MONOCRISTAL    =FACT(statut='f', max='**',
+             MATER           =SIMP(statut='o', typ=mater_sdaster, max=1),
+             ECOULEMENT      =SIMP(statut='o', typ='TXM', max=1,
+                   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,
+                                into=('BASAL', 'PRISMATIQUE', 'OCTAEDRIQUE', 'PYRAMIDAL1',
+                                'PYRAMIDAL2', 'CUBIQUE1', 'CUBIQUE2', 'MACLAGE', 'JOINT_GRAIN', 'RL', 'UNIAXIAL','BCC24'),),
+                                ),
+
+
+          POLYCRISTAL    =FACT(statut='f', max='**',
+           regles=(UN_PARMI('ANGL_REP','ANGL_EULER'),),
+             MONOCRISTAL     =SIMP(statut='o', typ=compor_sdaster, max=1),
+             FRAC_VOL  =SIMP(statut='o', typ='R', max=1,fr="fraction volumique de la phase correspondant au monocristal"),
+             ANGL_REP  =SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles nautiques en degrés"),
+             ANGL_EULER=SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles d'Euler   en degrés"),
+                                ),
+
+
+          b_poly      =BLOC( condition = "POLYCRISTAL!='None'",
+          LOCALISATION     =SIMP(statut='f', typ='TXM', max=1, into=('BZ', 'BETA', 'RL',),
+                fr="Donner le nom de la règle de localisation"),
+
+           b_beta      =BLOC( condition = "LOCALISATION=='BETA'",
+             DL            =SIMP(statut='o',typ='R',max=1),
+             DA            =SIMP(statut='o',typ='R',max=1),
+             ),
+             ),
+
+#####################################################################################
+          GEOM_FIBRE = SIMP(statut='f',max=1,typ=gfibre_sdaster,
+                   fr="Donner le nom du concept regroupant tous les groupes de fibres (issu de DEFI_GEOM_FIBRE)"),
+          MATER_SECT = SIMP(statut='f',max=1,typ=mater_sdaster,
+                   fr="Donner le nom du materiau pour les caracteristiques homogeneisees sur la section"),
+          MULTIFIBRE    = FACT(statut='f',max='**',
+          GROUP_FIBRE        =SIMP(statut='o', typ='TXM', max='**'),
+             MATER           =SIMP(statut='o', typ=mater_sdaster, max=1,
+                                   fr="Donner le nom du materiau pour le groupe de fibres"),
+             ALGO_1D         =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)),
+             DEFORMATION      =SIMP(statut='f',typ='TXM',defaut="PETIT",
+                                     into=("PETIT","PETIT_REAC","REAC_GEOM")),
+             RELATION        =SIMP(statut='f', typ='TXM', max=1,defaut="ELAS",into=C_RELATION(),
+                                  fr="Donner le nom de la relation incrementale pour le groupe de fibres",
+                                  ),
+           RELATION_KIT    =SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(),
+                                 into=(
+# MECA KIT_DDI
+                                       "VMIS_ISOT_TRAC",
+                                       "VMIS_ISOT_LINE",
+                                       "VMIS_ISOT_CINE",
+                                       "VMIS_ISOT_PUIS",
+                                       "GRANGER_FP",
+                                       "GRANGER_FP_INDT",
+                                       "GRANGER_FP_V",
+                                       "BETON_UMLV_FP",
+                                       "ROUSS_PR",
+                                       "NADAI_B",
+                                       "BETON_DOUBLE_DP",
+                                       ),),
+# on pourrait ajouter TOUT_GROUP_FIBRE
+
+                                ) );
+
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+DEFI_CONSTANTE=OPER(nom="DEFI_CONSTANTE",op=   2,sd_prod=fonction_sdaster,
+                    fr="Définir la valeur d'une grandeur invariante",
+                    reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         NOM_RESU        =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"),
+         VALE            =SIMP(statut='o',typ='R',),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+DEFI_COQU_MULT=OPER(nom="DEFI_COQU_MULT",op=56,sd_prod=mater_sdaster,reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+                    fr="Déterminer les caractéristiques matériaux homogénéisées d'une coque multicouche à partir"
+                        +" des caractéristiques de chaque couche",
+         COUCHE          =FACT(statut='o',max='**',
+           EPAIS           =SIMP(statut='o',typ='R',val_min=0.E+0 ),
+           MATER           =SIMP(statut='o',typ=(mater_sdaster) ),
+           ORIENTATION     =SIMP(statut='f',typ='R',defaut= 0.E+0,
+                                 val_min=-90.E+0,val_max=90.E+0   ),
+         ),
+         IMPRESSION      =FACT(statut='f',
+           UNITE           =SIMP(statut='f',typ='I',defaut=8),  
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+def DEFIC_prod(self,ACTION,UNITE,**args):
+  if ACTION == "ASSOCIER" or ACTION == "RESERVER":
+    if UNITE != None :
+      return
+    else :
+      return entier
+  elif ACTION == "LIBERER"  :
+    return
+  else :
+    raise AsException("ACTION non prevue : %s" % ACTION)
+
+DEFI_FICHIER=MACRO(nom="DEFI_FICHIER",op=ops.build_DEFI_FICHIER,sd_prod=DEFIC_prod,reentrant='n',
+                  UIinfo={"groupes":("Gestion du travail",)},
+                  fr="Ouvre ou ferme un fichier associé à un numéro d'unité logique",
+
+            ACTION        =SIMP(statut='f',typ='TXM',into=("ASSOCIER","LIBERER","RESERVER"),defaut="ASSOCIER"),
+
+            b_associer    =BLOC(condition = "ACTION == 'ASSOCIER'",
+                                fr="Paramètres pour l'ouverture du fichier",
+                                regles=(AU_MOINS_UN('FICHIER','UNITE'),),
+               UNITE      =SIMP(statut='f',typ='I' ,val_min=1),
+               FICHIER    =SIMP(statut='f',typ='TXM',validators=LongStr(1,255)),
+               TYPE       =SIMP(statut='f',typ='TXM',into=("ASCII","BINARY","LIBRE"),defaut="ASCII"),
+
+               b_type_ascii  =BLOC(condition = "TYPE == 'ASCII'",fr="Paramètres pour le type ASCII",
+                  ACCES      =SIMP(statut='f',typ='TXM',into=("NEW","APPEND","OLD"),defaut="NEW"),
+               ),
+               b_type_autre  =BLOC(condition = "TYPE != 'ASCII'",fr="Paramètres pour les types BINARY et LIBRE",
+                  ACCES      =SIMP(statut='f',typ='TXM',into=("NEW","OLD"),defaut="NEW"),
+               ),
+            ),
+
+            b_reserver    =BLOC(condition = "ACTION == 'RESERVER'",
+                                fr="Paramètres pour la réservation de l'unité du fichier",
+                                regles=(AU_MOINS_UN('FICHIER','UNITE'),),
+               UNITE      =SIMP(statut='f',typ='I' ,val_min=1),
+               FICHIER    =SIMP(statut='f',typ='TXM',validators=LongStr(1,255)),
+               TYPE       =SIMP(statut='f',typ='TXM',into=("ASCII",),defaut="ASCII"),
+               ACCES      =SIMP(statut='f',typ='TXM',into=("APPEND",),defaut="APPEND"),
+            ),
+
+            b_liberer    =BLOC(condition = "ACTION == 'LIBERER'",
+                               fr="Paramètres pour la fermeture du fichier",
+                               regles=(UN_PARMI('FICHIER','UNITE'),),
+                  UNITE         =SIMP(statut='f',typ='I' ,val_min=1),
+                  FICHIER   =SIMP(statut='f',typ='TXM',validators=LongStr(1,255)),
+           ),
+
+           INFO          =SIMP(statut='f',typ='I',into=(1,2) ),           
+           )
+#& MODIF COMMANDE  DATE 24/08/2009   AUTEUR GENIAUT S.GENIAUT 
+#            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 GENIAUT S.GENIAUT
+
+DEFI_FISS_XFEM=OPER(nom="DEFI_FISS_XFEM",op=  41,sd_prod=fiss_xfem,reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+               fr="Définition des caratéristiques d'une fissure ou d'une interface avec X-FEM",
+
+# ------------------------------------------------------------------------------------------------------------------------
+#                       modele sous-jacent
+# ------------------------------------------------------------------------------------------------------------------------
+
+    MODELE                =SIMP(statut='o',typ=modele_sdaster),
+
+# ------------------------------------------------------------------------------------------------------------------------
+#                       fissure/interface
+# ------------------------------------------------------------------------------------------------------------------------
+
+      TYPE_DISCONTINUITE  =SIMP(statut='f',typ='TXM',into=("FISSURE","INTERFACE",) ,defaut="FISSURE",position='global'),
+
+# ------------------------------------------------------------------------------------------------------------------------
+#                       caracteristiques de la fissure/interface
+# ------------------------------------------------------------------------------------------------------------------------
+
+    DEFI_FISS             =FACT(statut='o',max=1,
+
+      regles              =UN_PARMI('GROUP_MA_FISS','FONC_LN','FORM_FISS','CHAM_NO_LSN'),
+
+# impossible de faire des regles dans des blocs condition, dommage
+#       b_fissure           =BLOC(condition = "TYPE_DISCONTINUITE == 'FISSURE' ",fr="Regles pour les fissures",           
+#                 regles    =(ENSEMBLE('FONC_LN','FONC_LT'),
+#                             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'),
+#                             PRESENT_ABSENT('GROUP_MA_FISS','GROUP_MA_FOND')),
+#                                ),
+
+      FONC_LT             =SIMP(statut='f',typ=(fonction_sdaster,formule) ),
+      FONC_LN             =SIMP(statut='f',typ=(fonction_sdaster,formule) ),
+      CHAM_NO_LSN         =SIMP(statut='f',typ=cham_no_sdaster,min=1,max=1),
+      CHAM_NO_LST         =SIMP(statut='f',typ=cham_no_sdaster,min=1,max=1),
+      GROUP_MA_FISS       =SIMP(statut='f',typ=grma,min=1,max=1),
+      GROUP_MA_FOND       =SIMP(statut='f',typ=grma,min=1,max=1),
+      FORM_FISS   =SIMP(statut='f',typ='TXM',into=("ELLIPSE","CYLINDRE","DEMI_PLAN","SEGMENT","DEMI_DROITE","INCLUSION","DROITE") ),
+      b_ellipse           =BLOC(condition = "FORM_FISS == 'ELLIPSE' ",fr="Paramètres de la fissure elliptique",           
+           DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+           DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+           CENTRE         =SIMP(statut='o',typ='R',min=3,max=3),
+           VECT_X         =SIMP(statut='o',typ='R',min=3,max=3),
+           VECT_Y         =SIMP(statut='o',typ='R',min=3,max=3),
+           COTE_FISS      =SIMP(statut='f',typ='TXM',defaut="IN",into=("IN","OUT",) ),    ),
+      b_cylindre          =BLOC(condition = "FORM_FISS == 'CYLINDRE' ",fr="Paramètres de la fissure cylindrique",
+           DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+           DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+           CENTRE         =SIMP(statut='o',typ='R',min=3,max=3),
+           VECT_X         =SIMP(statut='o',typ='R',min=3,max=3),
+           VECT_Y         =SIMP(statut='o',typ='R',min=3,max=3),),
+      b_demiplan          =BLOC(condition = "FORM_FISS == 'DEMI_PLAN' ",fr="Paramètres de la fissure plane à front droit", 
+           PFON           =SIMP(statut='o',typ='R',min=3,max=3),
+           NORMALE        =SIMP(statut='o',typ='R',min=3,max=3),
+           DTAN           =SIMP(statut='o',typ='R',min=3,max=3),),
+      b_segment           =BLOC(condition = "FORM_FISS == 'SEGMENT' ",fr="Paramètres de la fissure 2D segment",
+           PFON_ORIG      =SIMP(statut='o',typ='R',min=3,max=3),
+           PFON_EXTR      =SIMP(statut='o',typ='R',min=3,max=3),),
+      b_demidroite         =BLOC(condition = "FORM_FISS == 'DEMI_DROITE' ",fr="Paramètres de la fissure 2D demi-droite",
+           PFON           =SIMP(statut='o',typ='R',min=3,max=3),
+           DTAN           =SIMP(statut='o',typ='R',min=3,max=3),),
+      b_droite            =BLOC(condition = "FORM_FISS == 'DROITE' ",fr="Paramètres de l'interface 2D (fissure traversante)",
+           POINT          =SIMP(statut='o',typ='R',min=3,max=3),
+           DTAN           =SIMP(statut='o',typ='R',min=3,max=3),),
+      b_inclusion         =BLOC(condition = "FORM_FISS == 'INCLUSION' ",fr="Paramètres de l'interface 2D (inclusion)",
+           DEMI_GRAND_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+           DEMI_PETIT_AXE =SIMP(statut='o',typ='R',val_min=0.E+0),
+           CENTRE         =SIMP(statut='o',typ='R',min=3,max=3),
+           VECT_X         =SIMP(statut='o',typ='R',min=3,max=3),
+           VECT_Y         =SIMP(statut='o',typ='R',min=3,max=3),),
+                            ),
+
+# ------------------------------------------------------------------------------------------------------------------------
+#                       partie du maillage potentiellement enrichie
+# ------------------------------------------------------------------------------------------------------------------------
+
+    GROUP_MA_ENRI         =SIMP(statut='o',typ=grma,max=01),
+
+# ------------------------------------------------------------------------------------------------------------------------
+#                       types d'enrichissement 
+# ------------------------------------------------------------------------------------------------------------------------
+
+    b_enri_inte           =BLOC(condition = "TYPE_DISCONTINUITE == 'INTERFACE' ",     
+
+      CHAM_DISCONTINUITE  =SIMP(statut='f',typ='TXM',into=("DEPL","SIGM"),defaut="DEPL" ),
+
+                          ),
+
+
+    b_enri_fiss           =BLOC(condition = "TYPE_DISCONTINUITE == 'FISSURE' ",           
+
+      CHAM_DISCONTINUITE  =SIMP(statut='f',typ='TXM',into=("DEPL",),defaut="DEPL" ),
+      TYPE_ENRI_FOND      =SIMP(statut='f',typ='TXM',into=("TOPOLOGIQUE","GEOMETRIQUE"),defaut="TOPOLOGIQUE" ),
+
+        b_enri_geom       =BLOC(condition = "TYPE_ENRI_FOND == 'GEOMETRIQUE' ",fr="Paramètres de l enrichissement geometrique",
+           RAYON_ENRI     =SIMP(statut='f',typ='R',val_min=0.E+0),
+
+          b_enri_couches  =BLOC(condition = "(RAYON_ENRI == None) ",fr="Paramètres de l enrichissement à n couches",
+           NB_COUCHES     =SIMP(statut='f',typ='I',defaut=4,val_min=1),
+
+                               ),
+                             ),                        
+                          ),
+
+# ------------------------------------------------------------------------------------------------------------------------
+#                       orientation du fond de fissure
+# ------------------------------------------------------------------------------------------------------------------------
+
+    b_orie_fond           =BLOC(condition = "TYPE_DISCONTINUITE == 'FISSURE' ",           
+
+    ORIE_FOND             =FACT(statut='f',max=1,
+      PFON_INI            =SIMP(statut='o',typ='R',max=3),
+      VECT_ORIE           =SIMP(statut='o',typ='R',max=3),
+      POINT_ORIG          =SIMP(statut='o',typ='R',max=3),
+                               ),
+
+                             ),
+
+# ------------------------------------------------------------------------------------------------------------------------
+#                       info
+# ------------------------------------------------------------------------------------------------------------------------
+
+    INFO                  =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,3,) ),
+
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ADOBES A.ADOBES
+DEFI_FLUI_STRU=OPER(nom="DEFI_FLUI_STRU",op= 143,sd_prod=type_flui_stru,
+                    reentrant='n',fr="Définit les caractéristiques nécessaires à l'étude dynamique d'une structure sous écoulement",
+            UIinfo={"groupes":("Maillage",)},
+         regles=(  UN_PARMI('FAISCEAU_TRANS','GRAPPE','FAISCEAU_AXIAL','COQUE_COAX',),),
+         FAISCEAU_TRANS  =FACT(statut='f',max='**',
+           regles=(  ENSEMBLE('CSTE_CONNORS','NB_CONNORS','RHO_TUBE'),),
+           COUPLAGE        =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
+           CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+           PROF_VITE_FLUI  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PROF_RHO_F_INT  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PROF_RHO_F_EXT  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           NOM_CMP         =SIMP(statut='f',typ='TXM',into=("DX","DY","DZ") ),
+           COEF_MASS_AJOU  =SIMP(statut='f',typ='R' ),
+           TYPE_PAS        =SIMP(statut='f',typ='TXM',into=("CARRE_LIGN","TRIA_LIGN") ),
+           TYPE_RESEAU     =SIMP(statut='f',typ='I' ),
+           UNITE_CD        =SIMP(statut='f',typ='I',defaut=70),
+           UNITE_CK        =SIMP(statut='f',typ='I',defaut=71),            
+           PAS             =SIMP(statut='f',typ='R' ),
+           CSTE_CONNORS    =SIMP(statut='f',typ='R',min=2,max=2,val_min=0.E+00),
+           NB_CONNORS      =SIMP(statut='f',typ='I',val_min=2,),
+           RHO_TUBE        =SIMP(statut='f',typ='R' ),
+         ),
+         GRAPPE          =FACT(statut='f',
+           regles=(ENSEMBLE('GRAPPE_2','NOEUD','CARA_ELEM','MODELE','RHO_FLUI',),
+                   PRESENT_PRESENT('COEF_MASS_AJOU','GRAPPE_2', ),),
+#  peut on créer un bloc a partir de la valeur de couplage  
+           COUPLAGE        =SIMP(statut='o',typ='TXM',into=("OUI","NON") ),
+           GRAPPE_2        =SIMP(statut='f',typ='TXM',
+                                 into=("ASC_CEN","ASC_EXC","DES_CEN","DES_EXC") ),
+           NOEUD           =SIMP(statut='f',typ=no),
+           CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+           MODELE          =SIMP(statut='f',typ=modele_sdaster ),
+           COEF_MASS_AJOU  =SIMP(statut='f',typ='R' ),
+           RHO_FLUI        =SIMP(statut='f',typ='R' ),
+           UNITE_CA        =SIMP(statut='f',typ='I',defaut=70),
+           UNITE_KA        =SIMP(statut='f',typ='I',defaut=71),            
+         ),
+         FAISCEAU_AXIAL  =FACT(statut='f',max='**',
+           regles=(UN_PARMI('GROUP_MA','TRI_GROUP_MA'),
+                   UN_PARMI('CARA_ELEM','RAYON_TUBE'),
+                   ENSEMBLE('RAYON_TUBE','COOR_TUBE'),
+                   PRESENT_ABSENT('RAYON_TUBE','TRI_GROUP_MA'),
+                   ENSEMBLE('CARA_PAROI','VALE_PAROI'),
+                   ENSEMBLE('LONG_TYPG','LARG_TYPG','EPAI_TYPG','RUGO_TYPG','COEF_TRAI_TYPG','COEF_DPOR_TYPG',
+                            'COOR_GRILLE','TYPE_GRILLE', ),),
+#  on doit pouvoir mettre des blocs conditionnels mais pas assez d infos pour le faire                            
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           TRI_GROUP_MA    =SIMP(statut='f',typ='TXM' ),
+           VECT_X          =SIMP(statut='f',typ='R',max=3),
+           PROF_RHO_FLUI   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PROF_VISC_CINE  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+           RAYON_TUBE      =SIMP(statut='f',typ='R' ),
+           COOR_TUBE       =SIMP(statut='f',typ='R',max='**'),
+           PESANTEUR       =SIMP(statut='f',typ='R',min=4,max=4),
+           RUGO_TUBE       =SIMP(statut='f',typ='R' ),
+           CARA_PAROI      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=5,
+                                 into=("YC","ZC","R","HY","HZ") ),
+           VALE_PAROI      =SIMP(statut='f',typ='R',max=5),
+           ANGL_VRIL       =SIMP(statut='f',typ='R' ),
+           LONG_TYPG       =SIMP(statut='f',typ='R',max='**',val_min=0.E+0),
+           LARG_TYPG       =SIMP(statut='f',typ='R',max='**',val_min=0.E+0),
+           EPAI_TYPG       =SIMP(statut='f',typ='R',max='**',val_min=0.E+0),
+           RUGO_TYPG       =SIMP(statut='f',typ='R',max='**',val_min=0.E+0),
+           COEF_TRAI_TYPG  =SIMP(statut='f',typ='R',max='**',val_min=0.E+0),
+           COEF_DPOR_TYPG  =SIMP(statut='f',typ='R',max='**'),
+           COOR_GRILLE     =SIMP(statut='f',typ='R',max='**'),
+           TYPE_GRILLE     =SIMP(statut='f',typ='I',max='**'),
+         ),
+         COQUE_COAX      =FACT(statut='f',
+           MASS_AJOU       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           GROUP_MA_INT    =SIMP(statut='o',typ=grma),
+           GROUP_MA_EXT    =SIMP(statut='o',typ=grma),
+           VECT_X          =SIMP(statut='o',typ='R',max='**'),
+           CARA_ELEM       =SIMP(statut='o',typ=cara_elem ),
+           MATER_INT       =SIMP(statut='o',typ=mater_sdaster ),
+           MATER_EXT       =SIMP(statut='o',typ=mater_sdaster ),
+           RHO_FLUI        =SIMP(statut='o',typ='R' ),
+           VISC_CINE       =SIMP(statut='o',typ='R' ),
+           RUGOSITE        =SIMP(statut='o',typ='R' ),
+           PDC_MOY_1       =SIMP(statut='o',typ='R' ),
+           PDC_DYN_1       =SIMP(statut='o',typ='R' ),
+           PDC_MOY_2       =SIMP(statut='o',typ='R' ),
+           PDC_DYN_2       =SIMP(statut='o',typ='R' ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+DEFI_FONC_ELEC=OPER(nom="DEFI_FONC_ELEC",op=64,sd_prod=fonction_sdaster,reentrant='n',
+            UIinfo={"groupes":("Outils métier",)},
+                    fr="Définir une fonction du temps intervenant dans le calcul des forces de LAPLACE",
+      regles=(UN_PARMI('COUR_PRIN','COUR'),
+              EXCLUS('COUR','COUR_SECO'), ),
+         FREQ            =SIMP(statut='f',typ='R',defaut= 50.),
+         SIGNAL          =SIMP(statut='f',typ='TXM',defaut="COMPLET",into=("COMPLET","CONTINU") ),
+         COUR            =FACT(statut='f',max='**',
+         fr="Définition du courant de court-circuit",
+           regles=(UN_PARMI('PHI_CC_1','INTC_CC_1'),
+                   UN_PARMI('PHI_CC_2','INTC_CC_2'),),
+           INTE_CC_1       =SIMP(statut='o',typ='R'),
+           TAU_CC_1        =SIMP(statut='o',typ='R'),
+           PHI_CC_1        =SIMP(statut='f',typ='R'),
+           INTC_CC_1       =SIMP(statut='f',typ='R'),
+           INTE_CC_2       =SIMP(statut='o',typ='R'),
+           TAU_CC_2        =SIMP(statut='o',typ='R'),
+           PHI_CC_2        =SIMP(statut='f',typ='R'),
+           INTC_CC_2       =SIMP(statut='f',typ='R'),
+           INST_CC_INIT    =SIMP(statut='o',typ='R'),
+           INST_CC_FIN     =SIMP(statut='o',typ='R'),
+         ),
+         COUR_PRIN       =FACT(statut='f',
+         fr="Définition du courant de court-circuit avec réenclenchement",
+           regles=(UN_PARMI('PHI_CC_1','INTC_CC_1'),),
+           INTE_CC_1       =SIMP(statut='o',typ='R'),
+           TAU_CC_1        =SIMP(statut='o',typ='R'),
+           PHI_CC_1        =SIMP(statut='f',typ='R'),
+           INTC_CC_1       =SIMP(statut='f',typ='R'),
+           INTE_RENC_1     =SIMP(statut='f',typ='R'),
+           TAU_RENC_1      =SIMP(statut='f',typ='R'),
+           PHI_RENC_1      =SIMP(statut='f',typ='R'),
+           INST_CC_INIT    =SIMP(statut='o',typ='R'),
+           INST_CC_FIN     =SIMP(statut='o',typ='R'),
+           INST_RENC_INIT  =SIMP(statut='f',typ='R',defaut= 0.0E+0),
+           INST_RENC_FIN   =SIMP(statut='f',typ='R',defaut= 0.0E+0),
+         ),
+         COUR_SECO       =FACT(statut='f',max='**',
+         fr="Définition du courant de court-circuit avec un intervalle de temps différent de celui de COUR_PRIN",
+           regles=(UN_PARMI('PHI_CC_2','INTC_CC_2'),),
+           INTE_CC_2       =SIMP(statut='o',typ='R'),
+           TAU_CC_2        =SIMP(statut='o',typ='R'),
+           PHI_CC_2        =SIMP(statut='f',typ='R'),
+           INTC_CC_2       =SIMP(statut='f',typ='R'),
+           INTE_RENC_2     =SIMP(statut='f',typ='R'),
+           TAU_RENC_2      =SIMP(statut='f',typ='R'),
+           PHI_RENC_2      =SIMP(statut='f',typ='R'),
+           DIST            =SIMP(statut='f',typ='R',defaut=1.0E+0),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ADOBES A.ADOBES
+DEFI_FONC_FLUI=OPER(nom="DEFI_FONC_FLUI",op= 142,sd_prod=fonction_sdaster,
+                    reentrant='n',
+            fr="Définit un profil de vitesse d'écoulement fluide le long d'une poutre",
+            UIinfo={"groupes":("Fonction",)},
+         MAILLAGE        =SIMP(statut='o',typ=(maillage_sdaster) ),
+         NOEUD_INIT      =SIMP(statut='o',typ=no),
+         NOEUD_FIN       =SIMP(statut='o',typ=no),
+         VITE            =FACT(statut='o',
+           VALE            =SIMP(statut='f',typ='R',defaut= 1. ),
+           PROFIL          =SIMP(statut='o',typ='TXM',into=("UNIFORME","LEONARD") ),
+           NB_BAV          =SIMP(statut='f',typ='I',defaut= 0,into=( 0 , 2 , 3 ) ),
+         ),
+         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",
+                               into=("NON","LIN","LOG") ),
+         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 ) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+def defi_fonction_prod(VALE,VALE_PARA,VALE_C,NOEUD_PARA,ABSCISSE,**args):
+  if VALE       != None  : return fonction_sdaster
+  if VALE_C     != None  : return fonction_c
+  if VALE_PARA  != None  : return fonction_sdaster
+  if ABSCISSE   != None  : return fonction_sdaster
+  if NOEUD_PARA != None  : return fonction_sdaster
+  raise AsException("type de concept resultat non prevu")
+
+DEFI_FONCTION=OPER(nom="DEFI_FONCTION",op=3,sd_prod=defi_fonction_prod
+                    ,fr="Définit une fonction réelle ou complexe d'une variable réelle",
+                     reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         regles=(UN_PARMI('VALE','VALE_C','VALE_PARA','NOEUD_PARA','ABSCISSE'),),
+         NOM_PARA        =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ),
+         NOM_RESU        =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"),
+         VALE            =SIMP(statut='f',typ='R',min=2,max='**',
+                               fr ="Fonction réelle définie par une liste de couples (abscisse,ordonnée)"),
+         ABSCISSE        =SIMP(statut='f',typ='R',min=2,max='**',
+                               fr ="Liste d abscisses d une fonction réelle"),
+         VALE_C          =SIMP(statut='f',typ='R',min=2,max='**',
+                               fr ="Fonction complexe définie par une liste de couples"),
+         VALE_PARA       =SIMP(statut='f',typ=listr8_sdaster,
+                               fr ="Fonction réelle définie par deux concepts de type listr8" ),
+         b_vale_para     =BLOC(condition = "VALE_PARA != None",
+           VALE_FONC       =SIMP(statut='o',typ=listr8_sdaster ),
+         ),
+         b_abscisse      =BLOC(condition = "ABSCISSE != None",
+           ORDONNEE        =SIMP(statut='o',typ='R',min=2,max='**',
+                               fr ="Liste d ordonnées d une fonction réelle"),
+         ),
+         NOEUD_PARA      =SIMP(statut='f',typ=no,max='**',
+                               fr ="Fonction réelle définie par une liste de noeuds et un maillage"),
+         b_noeud_para    =BLOC(condition = "NOEUD_PARA != None",
+           MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster ),
+           VALE_Y          =SIMP(statut='o',typ='R',max='**'),
+         ),
+
+         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ),
+         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") ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE GALENNE E.GALENNE
+DEFI_FOND_FISS=OPER(nom="DEFI_FOND_FISS",op=55,sd_prod=fond_fiss,reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+                    fr="Définition de lèvres et d'un fond de fissure en 3D",
+         regles=(UN_PARMI('FOND_FISS','FOND_FERME','FOND_INF'),
+                 EXCLUS('FOND_FERME','DTAN_ORIG'),
+                 EXCLUS('FOND_FERME','DTAN_EXTR'),
+                      EXCLUS('FOND_FERME','VECT_GRNO_ORIG'),
+                      EXCLUS('FOND_FERME','VECT_GRNO_EXTR'),
+                 UN_PARMI('LEVRE_SUP','NORMALE'),
+                      EXCLUS('LEVRE_INF','NORMALE'),
+                 ENSEMBLE('DTAN_ORIG','DTAN_EXTR'),
+                 ENSEMBLE('FOND_SUP','FOND_INF'),
+                 EXCLUS('FOND_INF','FOND_FISS'),
+                 EXCLUS('FOND_INF','FOND_FERME'),
+                      ENSEMBLE('VECT_GRNO_ORIG','VECT_GRNO_EXTR'),
+                      EXCLUS('DTAN_ORIG','VECT_GRNO_ORIG'),
+                      EXCLUS('DTAN_EXTR','VECT_GRNO_EXTR') ,),
+           MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster ),
+           FOND_FISS       =FACT(statut='f',
+             regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),
+                     EXCLUS('NOEUD_ORIG','GROUP_NO_ORIG'),
+                          EXCLUS('NOEUD_EXTR','GROUP_NO_EXTR'),),
+             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='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+#  à mettre à jour le max vaut-il 1  
+             NOEUD_ORIG      =SIMP(statut='f',typ=no,),
+             GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
+             NOEUD_EXTR      =SIMP(statut='f',typ=no,),
+             GROUP_NO_EXTR   =SIMP(statut='f',typ=grno,),
+           ),
+           FOND_FERME      =FACT(statut='f',
+             regles=(UN_PARMI('GROUP_NO','NOEUD','GROUP_MA','MAILLE'),
+                          EXCLUS('NOEUD_ORIG','GROUP_NO_ORIG'),),
+             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='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             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,),
+           ),
+           FOND_INF       =FACT(statut='f',
+             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='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             NOEUD_ORIG      =SIMP(statut='f',typ=no,),
+             GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
+             NOEUD_EXTR      =SIMP(statut='f',typ=no,),
+             GROUP_NO_EXTR   =SIMP(statut='f',typ=grno,),
+           ),
+           FOND_SUP       =FACT(statut='f',
+             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='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             NOEUD_ORIG      =SIMP(statut='f',typ=no,),
+             GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
+             NOEUD_EXTR      =SIMP(statut='f',typ=no,),
+             GROUP_NO_EXTR   =SIMP(statut='f',typ=grno,),
+           ),
+           LEVRE_SUP       =FACT(statut='f',
+             regles=(UN_PARMI('GROUP_MA','MAILLE'),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           ),
+           LEVRE_INF       =FACT(statut='f',
+             regles=(UN_PARMI('GROUP_MA','MAILLE', ),),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           ),
+           NORMALE         =SIMP(statut='f',typ='R',max='**'),
+           PREC_NORM       =SIMP(statut='f',typ='R',defaut=0.1),
+           DTAN_ORIG       =SIMP(statut='f',typ='R',max='**'),
+           DTAN_EXTR       =SIMP(statut='f',typ='R',max='**'),
+           VECT_GRNO_ORIG  =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=2),
+           VECT_GRNO_EXTR  =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=2),
+           INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 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 FLEJOU J.L.FLEJOU
+# 
+DEFI_GEOM_FIBRE=OPER(nom="DEFI_GEOM_FIBRE",op=  119, sd_prod=gfibre_sdaster,
+                    fr="Definition des groupes de fibres pour les elements multifibres",
+                    reentrant='n',
+            UIinfo={"groupes":("Modelisation",)},
+         regles=(AU_MOINS_UN('SECTION','FIBRE'),),
+
+         INFO       =SIMP(statut='f',typ='I', defaut= 1 ,into=(1,2) ),
+#============================================================================
+         SECTION     =FACT(statut='f',max='**',
+              regles=(AU_MOINS_UN('TOUT_SECT','GROUP_MA_SECT','MAILLE_SECT'),
+                      PRESENT_ABSENT('TOUT_SECT','GROUP_MA_SECT','MAILLE_SECT'),),
+
+              GROUP_FIBRE       =SIMP(statut='o',typ='TXM',min=1,max=1),
+              TOUT_SECT         =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+              GROUP_MA_SECT     =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE_SECT       =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+
+              MAILLAGE_SECT     =SIMP(statut='o',typ=maillage_sdaster),
+              COOR_AXE_POUTRE   =SIMP(statut='o',typ='R',min=2,max=2),
+         ),
+
+
+#============================================================================
+         FIBRE     =FACT(statut='f',max='**',
+              GROUP_FIBRE       =SIMP(statut='o',typ='TXM',min=1,max=1),
+              CARA              =SIMP(statut='f',typ='TXM',defaut='SURFACE',into=('SURFACE','DIAMETRE',)),
+              VALE              =SIMP(statut='o',typ='R',max='**'),
+              COOR_AXE_POUTRE   =SIMP(statut='o',typ='R',min=2,max=2),
+          ),
+
+
+) ;
+#& MODIF COMMANDE  DATE 20/04/2009   AUTEUR SFAYOLLE S.FAYOLLE 
+#            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.        
+# ======================================================================
+# RESPONSABLE SFAYOLLE S.FAYOLLE
+DEFI_GLRC=OPER(nom="DEFI_GLRC",op=57,sd_prod=mater_sdaster,reentrant='f',
+            UIinfo={"groupes":("Modelisation",)},
+                    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),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 09/06/2009   AUTEUR REZETTE C.REZETTE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def defi_group_prod(MAILLAGE,**args):
+  if AsType(MAILLAGE) == maillage_sdaster : return maillage_sdaster
+  if AsType(MAILLAGE) == squelette : return squelette
+  raise AsException("type de concept resultat non prevu")
+
+DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod,
+                fr="Définition de nouveaux groupes de noeuds et/ou de mailles dans un concept maillage",
+                reentrant='o',
+            UIinfo={"groupes":("Maillage",)},
+         regles=(AU_MOINS_UN('CREA_GROUP_MA','CREA_GROUP_NO','DETR_GROUP_NO','DETR_GROUP_MA'),),
+         MAILLAGE        =SIMP(statut='o',typ=(maillage_sdaster,squelette) ),
+         DETR_GROUP_MA   =FACT(statut='f',max='**',
+           NOM             =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),),
+         DETR_GROUP_NO   =FACT(statut='f',max='**',
+           NOM             =SIMP(statut='o',typ=grno,validators=NoRepeat(),max='**'),),
+         CREA_GROUP_MA   =FACT(statut='f',max='**',
+
+regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION'),),
+#  quel est le concept attendu deriere NOM
+           NOM             =SIMP(statut='o',typ=grma),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           GROUP_MA        =SIMP(statut='f',typ=grma),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           INTERSEC        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           UNION           =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           DIFFE           =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           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") ),
+           b_group_ma      =BLOC(condition = "GROUP_MA != None",
+             regles=(EXCLUS('POSITION','NUME_INIT'),),
+             NUME_INIT       =SIMP(statut='f',typ='I'),
+             POSITION        =SIMP(statut='f',typ='TXM',into=("INIT","FIN","MILIEU") ),
+             b_nume_init   =BLOC(condition = "NUME_INIT != None",
+               NUME_FIN        =SIMP(statut='f',typ='I' ),
+             ),
+           ),
+           b_face_normale  =BLOC(condition = "OPTION == 'FACE_NORMALE'",
+             regles=(UN_PARMI('ANGL_NAUT','VECT_NORMALE'),),
+             ANGL_NAUT       =SIMP(statut='f',typ='R',max=2),
+             VECT_NORMALE    =SIMP(statut='f',typ='R',max=3),
+             ANGL_PREC       =SIMP(statut='f',typ='R',defaut= 0.5 ),
+             VERI_SIGNE      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_sphere        =BLOC(condition = "OPTION == 'SPHERE'",
+             regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),),
+             POINT           =SIMP(statut='f',typ='R',max=3),
+             NOEUD_CENTRE    =SIMP(statut='f',typ=no),
+             GROUP_NO_CENTRE =SIMP(statut='f',typ=grno),
+             RAYON           =SIMP(statut='o',typ='R' ),
+           ),
+           b_cylindre      =BLOC(condition = "OPTION == 'CYLINDRE'",
+             regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),
+                     UN_PARMI('ANGL_NAUT','VECT_NORMALE'),),
+             POINT           =SIMP(statut='f',typ='R',max=3),
+             NOEUD_CENTRE    =SIMP(statut='f',typ=no),
+             GROUP_NO_CENTRE =SIMP(statut='f',typ=grno),
+             RAYON           =SIMP(statut='o',typ='R' ),
+             ANGL_NAUT       =SIMP(statut='f',typ='R',max=2),
+             VECT_NORMALE    =SIMP(statut='f',typ='R',max=3),
+           ),
+           b_bande         =BLOC(condition = "OPTION == 'BANDE'",
+             regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),
+                     UN_PARMI('ANGL_NAUT','VECT_NORMALE'),),
+             POINT           =SIMP(statut='f',typ='R' ,max=3),
+             NOEUD_CENTRE    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max=1),
+             GROUP_NO_CENTRE =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=1),
+             DIST            =SIMP(statut='o',typ='R' ),
+             ANGL_NAUT       =SIMP(statut='f',typ='R',max=2),
+             VECT_NORMALE    =SIMP(statut='f',typ='R',max=3),
+           ),
+           b_app_lache         =BLOC(condition = "OPTION == 'APPUI_LACHE'",
+             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='**'),
+           ),
+           b_appui            =BLOC(condition = "OPTION == 'APPUI'",
+             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='**'),
+             TYPE_APPUI      =SIMP(statut='o',typ='TXM',max=1, into=('AU_MOINS_UN','TOUT','SOMMET')),
+           ),
+         ),
+         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") ),
+
+           b_option =BLOC(condition = "OPTION == None" ,
+                          regles=(UN_PARMI('TOUT_GROUP_MA','GROUP_MA','GROUP_NO','NOEUD',
+                                                           'INTERSEC','UNION','DIFFE'),),
+              TOUT_GROUP_MA   =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+              GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+              INTERSEC        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              UNION           =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              DIFFE           =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+
+              b_nom_group_ma  =BLOC(condition = "GROUP_MA != None",
+                NOM           = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                CRIT_NOEUD    = SIMP(statut='f',typ='TXM',defaut="TOUS",
+                                  into=("TOUS","SOMMET","MILIEU","CENTRE"),),
+              ),
+              b_group_no      =BLOC(condition = "GROUP_NO != None",
+                                    regles=(EXCLUS('POSITION','NUME_INIT'),),
+                NUME_INIT       =SIMP(statut='f',typ='I'),
+                POSITION        =SIMP(statut='f',typ='TXM',into=("INIT","FIN","MILIEU") ),
+                b_nume_init     =BLOC(condition = "NUME_INIT != None",
+                  NUME_FIN        =SIMP(statut='f',typ='I' ),
+                ),
+              ),
+              b_nom =BLOC(condition = "GROUP_MA == None and TOUT_GROUP_MA == None" ,
+                NOM             =SIMP(statut='o',typ=geom),
+              ),
+           ),
+
+           b_env_sphere    =BLOC(condition = "OPTION == 'ENV_SPHERE'",
+             regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),),
+             NOM             =SIMP(statut='o',typ=geom),
+             POINT           =SIMP(statut='f',typ='R' ,max=3),
+             NOEUD_CENTRE    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max=1),
+             GROUP_NO_CENTRE =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=1),
+             RAYON           =SIMP(statut='o',typ='R' ),
+             PRECISION       =SIMP(statut='o',typ='R' ),
+           ),
+           b_env_cylindre  =BLOC(condition = "OPTION == 'ENV_CYLINDRE'",
+             regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),
+                     UN_PARMI('ANGL_NAUT','VECT_NORMALE'),),
+             NOM             =SIMP(statut='o',typ=geom),
+             POINT           =SIMP(statut='f',typ='R' ,max=3),
+             NOEUD_CENTRE    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max=1),
+             GROUP_NO_CENTRE =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=1),
+             RAYON           =SIMP(statut='o',typ='R' ),
+             ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+             VECT_NORMALE    =SIMP(statut='f',typ='R',max=3),
+             PRECISION       =SIMP(statut='o',typ='R' ),
+           ),
+           b_env_plan      =BLOC(condition = "OPTION == 'PLAN'",
+             regles=(UN_PARMI('POINT','NOEUD_CENTRE','GROUP_NO_CENTRE'),
+                     UN_PARMI('ANGL_NAUT','VECT_NORMALE'),),
+             NOM             =SIMP(statut='o',typ=geom),
+             POINT           =SIMP(statut='f',typ='R' ,max=3),
+             NOEUD_CENTRE    =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max=1),
+             GROUP_NO_CENTRE =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=1),
+             ANGL_NAUT       =SIMP(statut='f',typ='R' ,max=3),
+             VECT_NORMALE    =SIMP(statut='f',typ='R' ,max=3),
+             PRECISION       =SIMP(statut='o',typ='R' ),
+           ),
+           b_segm_droi_ordo=BLOC(condition = "OPTION == 'SEGM_DROI_ORDO'",
+             regles=(AU_MOINS_UN('NOEUD','GROUP_NO'),
+                     UN_PARMI('NOEUD_ORIG','GROUP_NO_ORIG'),
+                     UN_PARMI('NOEUD_EXTR','GROUP_NO_EXTR'),),
+             NOM             =SIMP(statut='o',typ=geom),
+             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+             NOEUD_ORIG      =SIMP(statut='f',typ=no),
+             GROUP_NO_ORIG   =SIMP(statut='f',typ=grno),
+             NOEUD_EXTR      =SIMP(statut='f',typ=no),
+             GROUP_NO_EXTR   =SIMP(statut='f',typ=grno),
+             PRECISION       =SIMP(statut='o',typ='R' ),
+             CRITERE         =SIMP(statut='o',typ='TXM',into=("ABSOLU","RELATIF") ),
+           ),
+           b_noeud_ordo    =BLOC(condition = "OPTION == 'NOEUD_ORDO'",
+             regles=(EXCLUS('NOEUD_ORIG','GROUP_NO_ORIG'),
+                     EXCLUS('NOEUD_EXTR','GROUP_NO_EXTR'),),
+             NOM             =SIMP(statut='o',typ=geom),
+             GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+             NOEUD_ORIG      =SIMP(statut='f',typ=no),
+             GROUP_NO_ORIG   =SIMP(statut='f',typ=grno),
+             NOEUD_EXTR      =SIMP(statut='f',typ=no),
+             GROUP_NO_EXTR   =SIMP(statut='f',typ=grno),
+           ),
+           b_tunnel    =BLOC(condition = "OPTION == 'TUNNEL'",
+             regles=(AU_MOINS_UN ('TOUT','GROUP_MA','MAILLE'),
+                     EXCLUS('NOEUD_ORIG','GROUP_NO_ORIG'),
+                     AU_MOINS_UN ('GROUP_MA_AXE','MAILLE_AXE'),),
+             NOM             =SIMP(statut='o',typ=geom),
+             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_AXE    =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             MAILLE_AXE      =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             NOEUD_ORIG      =SIMP(statut='f',typ=no),
+             GROUP_NO_ORIG   =SIMP(statut='f',typ=grno),
+             RAYON           =SIMP(statut='o',typ='R'),
+             LONGUEUR        =SIMP(statut='f',typ='R'),
+           ),
+         ),
+         ALARME          =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         INFO            =SIMP(statut='f',typ='I',into=( 1 , 2 ) ),
+)  ;
+#& MODIF COMMANDE  DATE 06/05/2008   AUTEUR CORUS M.CORUS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE CORUS M.CORUS
+
+DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op=  98,sd_prod=interf_dyna_clas,
+                      reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+            fr="Définir les interfaces d'une structure et leur affecter un type",
+         NUME_DDL        =SIMP(statut='o',typ=nume_ddl_sdaster ),
+         INTERFACE       =FACT(statut='o',max='**',
+           regles=(ENSEMBLE('NOM','TYPE'),
+#  erreur doc U sur la condition qui suit
+                   UN_PARMI('NOEUD','GROUP_NO'),),
+           NOM             =SIMP(statut='f',typ='TXM' ),
+           TYPE            =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ),
+           NOEUD           =SIMP(statut='f',typ=no,max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,max='**'),
+#           DDL_ACTIF       =SIMP(statut='f',typ='TXM',max='**'),
+           MASQUE          =SIMP(statut='f',typ='TXM',max='**'),
+         ),
+         FREQ            =SIMP(statut='f',typ='R',defaut= 1.),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# 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
+
+DEFI_INTE_SPEC=MACRO(nom="DEFI_INTE_SPEC",op= defi_inte_spec_ops,sd_prod=table_fonction,
+                     reentrant='n',
+                     fr="Définit une matrice interspectrale",
+                     UIinfo={"groupes":("Fonction",)},
+
+         DIMENSION       =SIMP(statut='f',typ='I',defaut= 1 ),
+
+         PAR_FONCTION    =FACT(statut='f',max='**',
+           NUME_ORDRE_I    =SIMP(statut='o',typ='I' ),
+           NUME_ORDRE_J    =SIMP(statut='o',typ='I' ),
+           FONCTION        =SIMP(statut='o',typ=fonction_c ),
+         ),
+         KANAI_TAJIMI    =FACT(statut='f',max='**',
+           regles=(EXCLUS('VALE_R','VALE_C'),),
+           NUME_ORDRE_I    =SIMP(statut='o',typ='I' ),
+           NUME_ORDRE_J    =SIMP(statut='o',typ='I' ),
+           FREQ_MIN        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           FREQ_MAX        =SIMP(statut='f',typ='R',defaut= 100. ),
+           PAS             =SIMP(statut='f',typ='R',defaut= 1. ),
+           AMOR_REDUIT     =SIMP(statut='f',typ='R',defaut= 0.6 ),
+           FREQ_MOY        =SIMP(statut='f',typ='R',defaut= 5. ),
+           VALE_R          =SIMP(statut='f',typ='R' ),
+           VALE_C          =SIMP(statut='f',typ='C' ),
+           INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ),
+           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") ),
+         ),
+         CONSTANT        =FACT(statut='f',max='**',
+           regles=(EXCLUS('VALE_R','VALE_C'),),
+           NUME_ORDRE_I    =SIMP(statut='o',typ='I' ),
+           NUME_ORDRE_J    =SIMP(statut='o',typ='I' ),
+           FREQ_MIN        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           FREQ_MAX        =SIMP(statut='f',typ='R',defaut= 100. ),
+           PAS             =SIMP(statut='f',typ='R',defaut= 1. ),
+           VALE_R          =SIMP(statut='f',typ='R' ),
+           VALE_C          =SIMP(statut='f',typ='C' ),
+           INTERPOL        =SIMP(statut='f',typ='TXM',max=2,defaut="LIN",into=("NON","LIN","LOG") ),
+           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") ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),               
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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":("Fonction",)},
+
+         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,),
+                 PAS             =SIMP(statut='f',typ='I',val_min=1,),
+             ),
+         ),
+
+
+         # extraction d'une liste de nume_ordre dans une sd_resultat :
+         #------------------------------------------------------------
+         b_extr       =BLOC(condition = "OPERATION == 'NUME_ORDRE'",
+             RESULTAT        =SIMP(statut='o',typ=resultat_sdaster),
+             PARAMETRE       =SIMP(statut='o',typ='TXM',),
+             INTERV_R        =SIMP(statut='o',typ='R',min=2,max=2),
+         ),
+
+
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 22/09/2009   AUTEUR SELLENET N.SELLENET 
+#            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.        
+# ======================================================================
+# RESPONSABLE GENIAUT S.GENIAUT
+
+DEFI_LIST_INST=OPER(nom="DEFI_LIST_INST",op=  28,sd_prod=list_inst,reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+               fr="Définition de la gestion de la liste d'instants",
+
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+# mot-cle pour la definition a priori de la liste d'instant
+# ----------------------------------------------------------------------------------------------------------------------------------
+
+    DEFI_LIST             =FACT(statut='o',max=1,
+
+      METHODE  =SIMP(statut='o',typ='TXM',into=("MANUEL","AUTO",),defaut="MANUEL",max=1,position='global' ),
+
+         b_manuel            =BLOC(condition = "METHODE == 'MANUEL' ",fr="Liste d'instants donnée par l'utilisateur",
+           LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
+                                  ),
+                      
+         b_auto              =BLOC(condition = "METHODE == 'AUTO' ",fr="a compléter",
+           LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
+           PAS_MINI    =SIMP(statut='o',typ='R',val_min=0.0,max=1),
+           PAS_MAXI    =SIMP(statut='f',typ='R',max=1),
+           NB_PAS_MAXI =SIMP(statut='f',typ='I',max=1),
+                                  ),
+           
+#          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=("DIVERGENCE",),defaut="DIVERGENCE",max=1 ),
+
+      SUBD_METHODE    =SIMP(statut='f',typ='TXM',into =("AUCUNE","UNIFORME","EXTRAPOLE"),defaut="UNIFORME",max=1,
+                            fr="Méthode de subdivision des pas de temps en cas de diconvergence"),
+
+           b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+             regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+             SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,max=1,
+                fr="Coefficient multiplicateur de la 1ère subdivision"),
+             SUBD_PAS       =SIMP(statut='f',typ='I',defaut=4,val_min=2,max=1,
+                fr="Nombre de subdivision d'un pas de temps"),
+             SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,defaut=3,max=1,
+                fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+             SUBD_PAS_MINI=SIMP(statut='f',typ='R',defaut=0.,val_min=0.0,max=1,
+                fr="Pas de temps en dessous duquel on ne subdivise plus"),
+                           ),
+
+           b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+             regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+             SUBD_OPTION    =SIMP(statut='f',typ='TXM',
+                into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+                defaut="IGNORE_PREMIERES",
+                fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+             SUBD_ITER_IGNO =SIMP(statut='f',typ='I',defaut=3,val_min=3,max=1,
+                fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+             SUBD_ITER_FIN  =SIMP(statut='f',typ='I',defaut=8,val_min=3,max=1,
+                fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+             SUBD_PAS       =SIMP(statut='f',typ='I',defaut=4,val_min=2,max=1,
+                fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+             SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,max=1,
+                fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+             SUBD_PAS_MINI=SIMP(statut='f',typ='R',defaut=0.,val_min=0.0,max=1,
+                fr="Pas de temps en dessous duquel on ne subdivise plus"),
+             SUBD_ITER_PLUS =SIMP(statut='f',typ='I',defaut=50,val_min=20,max=1,
+                fr="% itération autorisée en plus"),
+                            ),
+
+               ),
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+# mot-cle pour le comportement en cas de succes (on a bien converge)
+# ----------------------------------------------------------------------------------------------------------------------------------
+
+  b_adap  =   BLOC(condition="METHODE == 'AUTO'",
+
+    ADAPTATION  =FACT(statut='d',max='**',
+
+#     1) parametres de l'evenement declencheur
+#     ----------------------------------------
+
+      EVENEMENT       =SIMP(statut='f',typ='TXM',into=("SEUIL","TOUT_INST","AUCUN"),defaut="SEUIL",max=1 ),
+
+         b_adap_seuil       =BLOC(condition = "EVENEMENT == 'SEUIL' ",fr="seuil de re-decoupe",           
+
+#          FORMULE_SEUIL          =SIMP(statut='f',typ=formule),
+
+#          b_adap_seuil_nf   =   BLOC(condition="FORMULE_SEUIL == None",
+#              critere : si on fait NB_INCR_SEUIL fois de suite des increments verifiant le critere
+               regles=(PRESENT_PRESENT('NB_INCR_SEUIL','NOM_PARA',),
+                       PRESENT_PRESENT('NB_INCR_SEUIL','CRIT_COMP',),
+                       PRESENT_PRESENT('NB_INCR_SEUIL','CRIT_COMP',),),
+               NB_INCR_SEUIL     =SIMP(statut='f',typ='I',defaut=2),
+               NOM_PARA          =SIMP(statut='f',typ='TXM',into=("NB_ITER_NEWTON",),defaut="NB_ITER_NEWTON"),
+               CRIT_COMP         =SIMP(statut='f',typ='TXM',into=("LT","GT","LE","GE"),defaut="LE"),
+#                   b_vale_R           =BLOC(condition = "NOM_PARA == 'DP' ",fr="valeur reelle",           
+#                VALE              =SIMP(statut='o',typ='R'),
+#                                           ),
+                  b_vale_I           =BLOC(condition = "NOM_PARA == 'NB_ITER_NEWTON' ",fr="valeur entiere",           
+               VALE_I            =SIMP(statut='f',typ='I'),
+                                          ),
+#                                    ),
+                                ),
+                           
+#     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 ),
+         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),
+                               ),
+         b_mdelta           =BLOC(condition = "MODE_CALCUL_TPLUS == 'DELTA_GRANDEUR' ",fr=" ",           
+#      dans le cas DELTA_GRANDEUR : (deltaT+) = (deltaT-)x(VALREF/deltaVAL) : l'acceleration est inversement proportionnelle
+#                                                                             a la variation de la grandeur
+      VALE_REF          =SIMP(statut='o',typ='R',max=1),
+      NOM_CHAM          =SIMP(statut='o',typ='TXM',into=("DEPL","VARI_ELGA","SIEF_ELGA",),max=1),
+      NOM_CMP           =SIMP(statut='o',typ='TXM',max=1),
+                                  ),
+         b_mitnew           =BLOC(condition = "MODE_CALCUL_TPLUS == 'ITER_NEWTON' ",fr=" ",           
+#      dans le cas ITER_NEWTON : (deltaT+) = (deltaT-) x sqrt(VALREF/N) : l'acceleration est inversement proportionnelle
+#                                                                        au nombre d'iter de Newton precedent
+      NB_ITER_NEWTON_REF          =SIMP(statut='o',typ='I',max=1),
+                                  ),
+         b_mformule           =BLOC(condition = "MODE_CALCUL_TPLUS == 'FORMULE' ",fr=" ",           
+#      dans le cas FORMULE
+           regles=UN_PARMI('FORMULE_TPLUS','NOM_SCHEMA'),
+      FORMULE_TPLUS     =SIMP(statut='f',typ=formule),
+      NOM_SCHEMA        =SIMP(statut='f',typ='TXM',into=("OLIVER",)),
+                                   ),
+
+# les schemas pre-definis :
+#  abaqus : 
+#      EVENEMENT       ='SEUIL'
+#      NB_INCR_SEUIL     = 2
+#      NOM_PARA          ='NB_ITER_NEWTON'
+#      CRIT_COMP         ='LE'
+#      VALE_I            = 5
+#      MODE_CALCUL_TPLUS ='FIXE'
+#      PCENT_AUGM        = 50.
+#  Zebulon 1 : 
+#      EVENEMENT       ='TOUT_INST'
+#      MODE_CALCUL_TPLUS ='DELTA_GRANDEUR'
+#      VALE_REF          = valref
+#      NOM_CHAM          ='VARI_ELGA'
+#      NOM_CMP           ='V1'
+#  Zebulon 2 : 
+#      EVENEMENT       ='TOUT_INST'
+#      MODE_CALCUL_TPLUS ='ITER_NEWTON'
+#      NB_ITER_NEWTON_REF= nc
+#  Tough2 : 
+#      EVENEMENT       ='SEUIL'
+#      NB_INCR_SEUIL     = 1
+#      NOM_PARA          ='NB_ITER_NEWTON'
+#      CRIT_COMP         ='LE'
+#      VALE_I            = n
+#      MODE_CALCUL_TPLUS ='FIXE'
+#      PCENT_AUGM        = 100.
+#  Oliver : 
+#      EVENEMENT       ='TOUT_INST'
+#      MODE_CALCUL_TPLUS ='FORMULE'
+#      NOM_SCHEMA        ='OLIVER'
+
+             ),
+      ),
+
+# ----------------------------------------------------------------------------------------------------------------------------------
+
+    INFO                  =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+
+)  ;
+      
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+DEFI_LIST_REEL=OPER(nom="DEFI_LIST_REEL",op=24,sd_prod=listr8_sdaster,
+                    fr="Définir une liste de réels strictement croissante",
+                    reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         regles=(UN_PARMI('VALE','DEBUT',),
+                 EXCLUS('VALE','INTERVALLE'),
+                 ENSEMBLE('DEBUT','INTERVALLE')),
+         VALE            =SIMP(statut='f',typ='R',max='**'),
+         DEBUT           =SIMP(statut='f',typ='R'),
+         INTERVALLE      =FACT(statut='f',max='**',
+           regles=(UN_PARMI('NOMBRE','PAS'),),
+           JUSQU_A         =SIMP(statut='o',typ='R'),
+           NOMBRE          =SIMP(statut='f',typ='I'),
+           PAS             =SIMP(statut='f',typ='R'),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op=  88,sd_prod=maillage_sdaster,
+                   fr="Définition d'un nouveau maillage à partir de macro-éléments",
+                   reentrant='n',
+            UIinfo={"groupes":("Maillage",)},
+         DEFI_SUPER_MAILLE =FACT(statut='o',max='**',
+           MACR_ELEM       =SIMP(statut='o',typ=(macr_elem_stat,macr_elem_dyna),max='**' ),
+           SUPER_MAILLE    =SIMP(statut='f',typ=ma,max='**'),
+           TRAN            =SIMP(statut='f',typ='R',max=3),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+           b_angl_naut     =BLOC(condition = "ANGL_NAUT != None",
+             CENTRE          =SIMP(statut='f',typ='R',max=3),
+           ),
+         ),
+         RECO_GLOBAL     =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','SUPER_MAILLE'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           SUPER_MAILLE    =SIMP(statut='f',typ=ma,max='**'),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+         ),
+         RECO_SUPER_MAILLE =FACT(statut='f',max='**',
+           SUPER_MAILLE    =SIMP(statut='o',typ=ma,max='**'),
+           GROUP_NO        =SIMP(statut='o',typ=grno,max='**'),
+           OPTION          =SIMP(statut='f',typ='TXM',defaut="GEOMETRIQUE",into=("GEOMETRIQUE","NOEUD_A_NOEUD","INVERSE") ),
+           geometrique     =BLOC(condition = "OPTION == 'GEOMETRIQUE'",
+             CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           ),
+         ),
+         DEFI_NOEUD      =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','NOEUD_INIT'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",),
+                                 fr="Renommage de tous les noeuds" ),
+           NOEUD_INIT      =SIMP(statut='f',typ=no,
+                                 fr="Renommage d un seul noeud"),                     
+           b_tout          =BLOC(condition = "TOUT != None",
+             PREFIXE         =SIMP(statut='f',typ='TXM' ),
+             INDEX           =SIMP(statut='o',typ='I',max='**'),
+           ),
+           b_noeud_init    =BLOC(condition = "NOEUD_INIT != None",
+             SUPER_MAILLE    =SIMP(statut='o',typ=ma),
+             NOEUD_FIN       =SIMP(statut='o',typ=no),
+           ),        
+         ),
+         DEFI_GROUP_NO   =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','SUPER_MAILLE'),
+                AU_MOINS_UN('INDEX','GROUP_NO_FIN'),
+                   ENSEMBLE('GROUP_NO_INIT','GROUP_NO_FIN'),),
+#  la regle ancien catalogue AU_MOINS_UN__: ( INDEX , GROUP_NO_FIN ) incoherente avec doc U           
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",),
+                                 fr="Création de plusieurs groupes de noeuds" ),
+           SUPER_MAILLE    =SIMP(statut='f',typ=ma,
+                                 fr="Création de plusieurs groupes de noeuds"),
+           GROUP_NO_INIT   =SIMP(statut='f',typ=grno,
+                                 fr="Création d un seul groupe de noeuds"),
+           PREFIXE         =SIMP(statut='f',typ='TXM' ),
+           INDEX           =SIMP(statut='f',typ='I',max='**'),
+           GROUP_NO_FIN    =SIMP(statut='f',typ=grno),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 22/09/2009   AUTEUR SELLENET N.SELLENET 
+#            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 LEFEBVRE J.P.LEFEBVRE
+DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster,
+                   fr="Définition des paramètres décrivant le comportement d un matériau",
+                   reentrant='f',
+            UIinfo={"groupes":("Modélisation",)},
+       regles=(EXCLUS('ELAS','ELAS_FO','ELAS_FLUI','ELAS_ISTR','ELAS_ISTR_FO','ELAS_ORTH',
+                      'ELAS_ORTH_FO','ELAS_COQUE','ELAS_COQUE_FO',
+                      'ELAS_HYPER','ELAS_2NDG',),
+               EXCLUS('THER','THER_FO','THER_ORTH','THER_NL'),
+               EXCLUS('ECRO_LINE','ECRO_LINE_FO','ECRO_PUIS'),
+               EXCLUS('TAHERI','TAHERI_FO'),
+               EXCLUS('ROUSSELIER','ROUSSELIER_FO'),
+               EXCLUS('VISC_SINH','VISC_SINH_FO'),
+               PRESENT_PRESENT('ROUSSELIER','TRACTION'),
+               PRESENT_PRESENT('ROUSSELIER_FO','TRACTION'),
+               EXCLUS('CIN1_CHAB','CIN1_CHAB_FO'),
+               EXCLUS('CIN2_CHAB','CIN2_CHAB_FO'),
+               EXCLUS('VISCOCHAB','VISCOCHAB_FO'),
+               EXCLUS('LEMAITRE','LEMAITRE_FO','VISC_IRRA_LOG',
+               'LEMA_SEUIL','LEMA_SEUIL_FO','LEMAITRE_IRRA','LMARC_IRRA',),
+               EXCLUS('LMARC','LMARC_FO'),
+               EXCLUS('META_LEMA_ANI','META_LEMA_ANI_FO'),
+               EXCLUS('VMIS_POUTRE','VMIS_POUTRE_FO'),
+               EXCLUS('VENDOCHAB','VENDOCHAB_FO'),
+               PRESENT_PRESENT('BPEL_ACIER','ELAS'),
+               EXCLUS('RCCM','RCCM_FO'),
+               EXCLUS('WEIBULL','WEIBULL_FO'),
+               PRESENT_PRESENT('LAIGLE','ELAS'),
+               PRESENT_PRESENT('LETK','ELAS'),
+               PRESENT_PRESENT('DRUCK_PRAGER','ELAS'),
+               PRESENT_PRESENT('VISC_DRUC_PRAG','ELAS'),
+               PRESENT_PRESENT('ELAS_GONF','ELAS'),
+               PRESENT_PRESENT('HOEK_BROWN','ELAS'),
+               EXCLUS('MAZARS','MAZARS_FO'),
+               PRESENT_PRESENT('JOINT_BA','ELAS'),
+               PRESENT_PRESENT('CABLE','ELAS'),
+               ),
+           MATER      =SIMP(statut='f',typ=mater_sdaster),
+#
+# comportement élastique
+#
+           ELAS            =FACT(statut='f',
+             E               =SIMP(statut='o',typ='R',val_min=0.E+0),
+             NU              =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=0.5E+0),
+             RHO             =SIMP(statut='f',typ='R'),
+             ALPHA           =SIMP(statut='f',typ='R'),
+             AMOR_ALPHA      =SIMP(statut='f',typ='R'),
+             AMOR_BETA       =SIMP(statut='f',typ='R'),
+             AMOR_HYST       =SIMP(statut='f',typ='R'),
+           ),
+           ELAS_FO         =FACT(statut='f',
+             regles=(PRESENT_PRESENT('ALPHA','TEMP_DEF_ALPHA'),),
+             E               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             NU              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RHO             =SIMP(statut='f',typ='R'),
+             TEMP_DEF_ALPHA  =SIMP(statut='f',typ='R'),
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1.),
+             ALPHA           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AMOR_ALPHA      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AMOR_BETA       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AMOR_HYST       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             K_DESSIC        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             B_ENDOGE        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             FONC_DESORP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ELAS_FLUI       =FACT(statut='f',
+             E               =SIMP(statut='o',typ='R'),
+             NU              =SIMP(statut='o',typ='R'),
+             RHO             =SIMP(statut='o',typ='R'),
+             PROF_RHO_F_INT  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PROF_RHO_F_EXT  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COEF_MASS_AJOU  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ELAS_ISTR       =FACT(statut='f',
+             E_L             =SIMP(statut='o',typ='R'),
+             E_N             =SIMP(statut='o',typ='R'),
+             NU_LT           =SIMP(statut='o',typ='R'),
+             NU_LN           =SIMP(statut='o',typ='R'),
+             G_LN            =SIMP(statut='o',typ='R'),
+             RHO             =SIMP(statut='f',typ='R'),
+             ALPHA_L         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             ALPHA_N         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+           ELAS_ISTR_FO    =FACT(statut='f',
+             regles=(
+                      PRESENT_PRESENT('ALPHA_L','TEMP_DEF_ALPHA'),
+                      PRESENT_PRESENT('ALPHA_N','TEMP_DEF_ALPHA'),
+                    ),
+             E_L             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             E_N             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             NU_LT           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             NU_LN           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_LN            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RHO             =SIMP(statut='f',typ='R'),
+             TEMP_DEF_ALPHA  =SIMP(statut='f',typ='R'),
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1.),
+             ALPHA_L         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ALPHA_N         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ELAS_ORTH       =FACT(statut='f',
+             E_L             =SIMP(statut='o',typ='R'),
+             E_T             =SIMP(statut='o',typ='R'),
+             E_N             =SIMP(statut='f',typ='R'),
+             NU_LT           =SIMP(statut='o',typ='R'),
+             NU_LN           =SIMP(statut='f',typ='R'),
+             NU_TN           =SIMP(statut='f',typ='R'),
+             G_LT            =SIMP(statut='o',typ='R'),
+             G_LN            =SIMP(statut='f',typ='R'),
+             G_TN            =SIMP(statut='f',typ='R'),
+             RHO             =SIMP(statut='f',typ='R'),
+             ALPHA_L         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             ALPHA_T         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             ALPHA_N         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             XT              =SIMP(statut='f',typ='R',defaut= 1. ),
+             XC              =SIMP(statut='f',typ='R',defaut= 1. ),
+             YT              =SIMP(statut='f',typ='R',defaut= 1. ),
+             YC              =SIMP(statut='f',typ='R',defaut= 1. ),
+             S_LT            =SIMP(statut='f',typ='R',defaut= 1. ),
+             AMOR_ALPHA      =SIMP(statut='f',typ='R'),
+             AMOR_BETA       =SIMP(statut='f',typ='R'),
+             AMOR_HYST       =SIMP(statut='f',typ='R'),
+           ),
+           ELAS_ORTH_FO    =FACT(statut='f',
+             regles=(
+                      PRESENT_PRESENT('ALPHA_L','TEMP_DEF_ALPHA'),
+                      PRESENT_PRESENT('ALPHA_N','TEMP_DEF_ALPHA'),
+                      PRESENT_PRESENT('ALPHA_T','TEMP_DEF_ALPHA'),
+                    ),
+             E_L             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             E_T             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             E_N             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             NU_LT           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             NU_LN           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             NU_TN           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_LT            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_LN            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_TN            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RHO             =SIMP(statut='f',typ='R'),
+             TEMP_DEF_ALPHA  =SIMP(statut='f',typ='R'),
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1. ),
+             ALPHA_L         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ALPHA_T         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ALPHA_N         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AMOR_ALPHA      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AMOR_BETA       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AMOR_HYST       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ELAS_HYPER      =FACT(statut='f',
+                                 regles=(UN_PARMI('K','NU'),),
+             C10             =SIMP(statut='f',typ='R',defaut=0.0),
+             C01             =SIMP(statut='o',typ='R'),
+             C20             =SIMP(statut='f',typ='R',defaut=0.0),
+             K               =SIMP(statut='f',typ='R'),
+             RHO             =SIMP(statut='f',typ='R',defaut=0.0),
+             NU              =SIMP(statut='f',typ='R',val_min=-1.E+0,val_max=0.5E+0),
+           ),
+           ELAS_COQUE      =FACT(statut='f',
+             regles=(EXCLUS('MEMB_L','M_LLLL',),
+                     PRESENT_PRESENT('MEMB_L','MEMB_LT', 'MEMB_T','MEMB_G_LT','FLEX_L','FLEX_LT',
+                                     'FLEX_T','FLEX_G_LT','CISA_L','CISA_T',),
+                     PRESENT_PRESENT('M_LLLL','M_LLTT','M_LLLT','M_TTTT','M_TTLT','M_LTLT','F_LLLL',
+                                     'F_LLTT','F_LLLT','F_TTTT','F_TTLT','F_LTLT','MF_LLLL',
+                                     'MF_LLTT','MF_LLLT','MF_TTTT','MF_TTLT','MF_LTLT','MC_LLLZ',
+                                     'MC_LLTZ','MC_TTLZ','MC_TTTZ','MC_LTLZ','MC_LTTZ','FC_LLLZ',
+                                     'FC_LLTZ','FC_TTLZ','FC_TTTZ','FC_LTLZ','FC_LTTZ','C_LZLZ',
+                                     'C_LZTZ','C_TZTZ'),),
+             MEMB_L          =SIMP(statut='f',typ='R'),
+             MEMB_LT         =SIMP(statut='f',typ='R'),
+             MEMB_T          =SIMP(statut='f',typ='R'),
+             MEMB_G_LT       =SIMP(statut='f',typ='R'),
+             FLEX_L          =SIMP(statut='f',typ='R'),
+             FLEX_LT         =SIMP(statut='f',typ='R'),
+             FLEX_T          =SIMP(statut='f',typ='R'),
+             FLEX_G_LT       =SIMP(statut='f',typ='R'),
+             CISA_L          =SIMP(statut='f',typ='R'),
+             CISA_T          =SIMP(statut='f',typ='R'),
+             M_LLLL          =SIMP(statut='f',typ='R'),
+             M_LLTT          =SIMP(statut='f',typ='R'),
+             M_LLLT          =SIMP(statut='f',typ='R'),
+             M_TTTT          =SIMP(statut='f',typ='R'),
+             M_TTLT          =SIMP(statut='f',typ='R'),
+             M_LTLT          =SIMP(statut='f',typ='R'),
+             F_LLLL          =SIMP(statut='f',typ='R'),
+             F_LLTT          =SIMP(statut='f',typ='R'),
+             F_LLLT          =SIMP(statut='f',typ='R'),
+             F_TTTT          =SIMP(statut='f',typ='R'),
+             F_TTLT          =SIMP(statut='f',typ='R'),
+             F_LTLT          =SIMP(statut='f',typ='R'),
+             MF_LLLL         =SIMP(statut='f',typ='R'),
+             MF_LLTT         =SIMP(statut='f',typ='R'),
+             MF_LLLT         =SIMP(statut='f',typ='R'),
+             MF_TTTT         =SIMP(statut='f',typ='R'),
+             MF_TTLT         =SIMP(statut='f',typ='R'),
+             MF_LTLT         =SIMP(statut='f',typ='R'),
+             MC_LLLZ         =SIMP(statut='f',typ='R'),
+             MC_LLTZ         =SIMP(statut='f',typ='R'),
+             MC_TTLZ         =SIMP(statut='f',typ='R'),
+             MC_TTTZ         =SIMP(statut='f',typ='R'),
+             MC_LTLZ         =SIMP(statut='f',typ='R'),
+             MC_LTTZ         =SIMP(statut='f',typ='R'),
+             FC_LLLZ         =SIMP(statut='f',typ='R'),
+             FC_LLTZ         =SIMP(statut='f',typ='R'),
+             FC_TTLZ         =SIMP(statut='f',typ='R'),
+             FC_TTTZ         =SIMP(statut='f',typ='R'),
+             FC_LTLZ         =SIMP(statut='f',typ='R'),
+             FC_LTTZ         =SIMP(statut='f',typ='R'),
+             C_LZLZ          =SIMP(statut='f',typ='R'),
+             C_LZTZ          =SIMP(statut='f',typ='R'),
+             C_TZTZ          =SIMP(statut='f',typ='R'),
+             RHO             =SIMP(statut='f',typ='R'),
+             ALPHA           =SIMP(statut='f',typ='R'),
+           ),
+           ELAS_COQUE_FO   =FACT(statut='f',
+             regles=(EXCLUS('MEMB_L','M_LLLL',),
+                     PRESENT_PRESENT('MEMB_L','MEMB_LT','MEMB_T','MEMB_G_LT','FLEX_L','FLEX_LT',
+                                     'FLEX_T','FLEX_G_LT','CISA_L','CISA_T',),
+                     PRESENT_PRESENT('M_LLLL','M_LLTT','M_LLLT','M_TTTT','M_TTLT','M_LTLT','F_LLLL',
+                                     'F_LLTT','F_LLLT','F_TTTT','F_TTLT','F_LTLT','MF_LLLL','MF_LLTT',
+                                     'MF_LLLT','MF_TTTT','MF_TTLT','MF_LTLT','MC_LLLZ','MC_LLTZ',
+                                     'MC_TTLZ','MC_TTTZ','MC_LTLZ','MC_LTTZ','FC_LLLZ','FC_LLTZ',
+                                     'FC_TTLZ','FC_TTTZ','FC_LTLZ','FC_LTTZ','C_LZLZ','C_LZTZ','C_TZTZ'),),
+             MEMB_L          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MEMB_LT         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MEMB_T          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MEMB_G_LT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FLEX_L          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FLEX_LT         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FLEX_T          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FLEX_G_LT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CISA_L          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CISA_T          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_LLLL          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_LLTT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_LLLT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_TTTT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_TTLT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_LTLT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_LLLL          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_LLTT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_LLLT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_TTTT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_TTLT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_LTLT          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MF_LLLL         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MF_LLTT         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MF_LLLT         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MF_TTTT         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MF_TTLT         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MF_LTLT         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MC_LLLZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MC_LLTZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MC_TTLZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MC_TTTZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MC_LTLZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MC_LTTZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FC_LLLZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FC_LLTZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FC_TTLZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FC_TTTZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FC_LTLZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FC_LTTZ         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_LZLZ          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_LZTZ          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_TZTZ          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RHO             =SIMP(statut='f',typ='R'),
+             ALPHA           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ELAS_2NDG        =FACT(statut='f',
+             A1              =SIMP(statut='o',typ='R'),
+             A2              =SIMP(statut='f',typ='R'),
+             A3              =SIMP(statut='f',typ='R'),
+             A4              =SIMP(statut='f',typ='R'),
+             A5              =SIMP(statut='f',typ='R'),
+           ),
+           CABLE           =FACT(statut='f',
+             EC_SUR_E        =SIMP(statut='f',typ='R',defaut= 1.E-4 ),
+           ),
+#
+# comportement mécanique non linéaire
+#
+           TRACTION        =FACT(statut='f',
+             SIGM            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ECRO_LINE       =FACT(statut='f',
+             D_SIGM_EPSI     =SIMP(statut='o',typ='R',),
+             SY              =SIMP(statut='o',typ='R',),
+           ),
+           ECRO_LINE_FO    =FACT(statut='f',
+             D_SIGM_EPSI     =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SY              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ECRO_PUIS       =FACT(statut='f',
+             SY              =SIMP(statut='o',typ='R',),
+             A_PUIS          =SIMP(statut='o',typ='R',val_min=0.0),
+             N_PUIS          =SIMP(statut='o',typ='R',val_min=1.E-6),
+           ),
+           ECRO_PUIS_FO    =FACT(statut='f',
+             SY              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_PUIS          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N_PUIS          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           BETON_ECRO_LINE =FACT(statut='f',
+             D_SIGM_EPSI     =SIMP(statut='o',typ='R'),
+             SYT             =SIMP(statut='o',typ='R'),
+             SYC             =SIMP(statut='f',typ='R'),
+           ),
+           BETON_REGLE_PR =FACT(statut='f',
+             D_SIGM_EPSI     =SIMP(statut='o',typ='R'),
+             SYT             =SIMP(statut='o',typ='R'),
+             SYC             =SIMP(statut='f',typ='R'),
+             EPSC            =SIMP(statut='f',typ='R'),
+             N               =SIMP(statut='f',typ='R'),
+           ),
+           ENDO_ORTH_BETON  =FACT(statut='f',
+             ALPHA            =SIMP(statut='f',typ='R',defaut=0.9),
+             K0               =SIMP(statut='o',typ='R'),
+             K1               =SIMP(statut='o',typ='R'),
+             K2               =SIMP(statut='f',typ='R',defaut=7.E-4),
+             ECROB            =SIMP(statut='o',typ='R'),
+             ECROD            =SIMP(statut='o',typ='R'),
+           ),
+           PRAGER          =FACT(statut='f',
+             C               =SIMP(statut='o',typ='R'),
+           ),
+           PRAGER_FO       =FACT(statut='f',
+             C               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ECRO_FLEJOU     =FACT(statut='f',
+             EP              =SIMP(statut='o',typ='R'),
+             SY              =SIMP(statut='o',typ='R'),
+             SU              =SIMP(statut='o',typ='R'),
+             PUISS           =SIMP(statut='o',typ='R'),
+           ),
+           TAHERI          =FACT(statut='f',
+             R_0             =SIMP(statut='o',typ='R'),
+             ALPHA           =SIMP(statut='o',typ='R'),
+             M               =SIMP(statut='o',typ='R'),
+             A               =SIMP(statut='o',typ='R'),
+             B               =SIMP(statut='o',typ='R'),
+             C1              =SIMP(statut='o',typ='R'),
+             C_INF           =SIMP(statut='o',typ='R'),
+             S               =SIMP(statut='o',typ='R'),
+           ),
+           TAHERI_FO       =FACT(statut='f',
+             R_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ALPHA           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             B               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C1              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_INF           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             S               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ROUSSELIER      =FACT(statut='f',
+             D               =SIMP(statut='o',typ='R'),
+             SIGM_1          =SIMP(statut='o',typ='R'),
+             PORO_INIT       =SIMP(statut='o',typ='R'),
+             PORO_CRIT       =SIMP(statut='f',typ='R',defaut= 1. ),
+             PORO_ACCE       =SIMP(statut='f',typ='R',defaut= 1. ),
+             PORO_LIMI       =SIMP(statut='f',typ='R',defaut= 0.999 ),
+             D_SIGM_EPSI_NORM=SIMP(statut='f',typ='R',defaut= 1. ),
+             AN              =SIMP(statut='f',typ='R',defaut= 0. ),
+             DP_MAXI         =SIMP(statut='f',typ='R',defaut= 0.1),
+             BETA            =SIMP(statut='f',typ='R',defaut=0.85),
+           ),
+           ROUSSELIER_FO   =FACT(statut='f',
+             D               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SIGM_1          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PORO_INIT       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PORO_CRIT       =SIMP(statut='f',typ='R',defaut= 1. ),
+             PORO_ACCE       =SIMP(statut='f',typ='R',defaut= 1. ),
+             PORO_LIMI       =SIMP(statut='f',typ='R',defaut= 0.999 ),
+             D_SIGM_EPSI_NORM=SIMP(statut='f',typ='R',defaut= 1. ),
+             AN              =SIMP(statut='f',typ='R',defaut= 0. ),
+             DP_MAXI         =SIMP(statut='f',typ='R',defaut= 0.1),
+             BETA            =SIMP(statut='f',typ='R',defaut=0.85),
+           ),
+           VISC_SINH      =FACT(statut='f',
+             SIGM_0          =SIMP(statut='o',typ='R'),
+             EPSI_0          =SIMP(statut='o',typ='R'),
+             M               =SIMP(statut='o',typ='R'),
+           ),
+           VISC_SINH_FO      =FACT(statut='f',
+             SIGM_0          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             EPSI_0          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           CIN1_CHAB  =FACT(statut='f',
+             R_0             =SIMP(statut='o',typ='R'),
+             R_I             =SIMP(statut='f',typ='R'),
+             B               =SIMP(statut='f',typ='R',defaut= 0.0E+0),
+             C_I             =SIMP(statut='o',typ='R'),
+             K               =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+             W               =SIMP(statut='f',typ='R',defaut= 0.0E+0),
+             G_0             =SIMP(statut='o',typ='R'),
+             A_I             =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+           ),
+           CIN1_CHAB_FO  =FACT(statut='f',
+             R_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R_I             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             B               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_I             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             K               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             W               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_I             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           CIN2_CHAB  =FACT(statut='f',
+             R_0             =SIMP(statut='o',typ='R'),
+             R_I             =SIMP(statut='f',typ='R'),
+             B               =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             C1_I            =SIMP(statut='o',typ='R'),
+             C2_I            =SIMP(statut='o',typ='R'),
+             K               =SIMP(statut='f',typ='R',defaut= 1.),
+             W               =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             G1_0            =SIMP(statut='o',typ='R'),
+             G2_0            =SIMP(statut='o',typ='R'),
+             A_I             =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+           ),
+           CIN2_CHAB_FO  =FACT(statut='f',
+             R_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R_I             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             B               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C1_I            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C2_I            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             K               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             W               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G1_0            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G2_0            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_I             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           MEMO_ECRO       =FACT(statut='f',
+             MU              =SIMP(statut='o',typ='R'),
+             Q_M             =SIMP(statut='o',typ='R'),
+             Q_0             =SIMP(statut='o',typ='R'),
+             ETA             =SIMP(statut='f',typ='R',defaut= 0.5E+0 ),
+           ),
+           MEMO_ECRO_FO        =FACT(statut='f',
+             MU              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q_M             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ETA             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           VISCOCHAB       =FACT(statut='f',
+             K_0             =SIMP(statut='o',typ='R'),
+             A_K             =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             A_R             =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+             K               =SIMP(statut='o',typ='R'),
+             N               =SIMP(statut='o',typ='R'),
+             ALP             =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             B               =SIMP(statut='f',typ='R'),
+             M_R             =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+             G_R             =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             MU              =SIMP(statut='o',typ='R',defaut= 0.E+0 ),
+             Q_M             =SIMP(statut='o',typ='R'),
+             Q_0             =SIMP(statut='o',typ='R'),
+             QR_0            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             ETA             =SIMP(statut='f',typ='R',defaut= 0.5E+0 ),
+             C1              =SIMP(statut='o',typ='R'),
+             M_1             =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+             D1              =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+             G_X1            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             G1_0            =SIMP(statut='o',typ='R'),
+             C2              =SIMP(statut='o',typ='R'),
+             M_2             =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+             D2              =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+             G_X2            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             G2_0            =SIMP(statut='o',typ='R'),
+             A_I             =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+           ),
+           VISCOCHAB_FO    =FACT(statut='f',
+             K_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_K             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_R             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             K               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ALP             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             B               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_R             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_R             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MU              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q_M             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             QR_0            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ETA             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C1              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_1             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D1              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_X1            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G1_0            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C2              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_2             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D2              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G_X2            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             G2_0            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_I             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           LEMAITRE        =FACT(statut='f',
+             N               =SIMP(statut='o',typ='R'),
+             UN_SUR_K        =SIMP(statut='o',typ='R'),
+             UN_SUR_M        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+           LEMAITRE_IRRA    =FACT(statut='f',
+             N               =SIMP(statut='o',typ='R'),
+             UN_SUR_K        =SIMP(statut='o',typ='R'),
+             UN_SUR_M        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             QSR_K           =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             BETA            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             PHI_ZERO        =SIMP(statut='f',typ='R',defaut= 1.E+20),
+             L               =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             GRAN_A          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             GRAN_B          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             GRAN_S          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+           LMARC_IRRA       =FACT(statut='f',
+             DE_0            =SIMP(statut='o',typ='R'),
+             R_0             =SIMP(statut='o',typ='R'),
+             N               =SIMP(statut='o',typ='R'),
+             K               =SIMP(statut='o',typ='R'),
+             Y_I             =SIMP(statut='o',typ='R'),
+             Y_0             =SIMP(statut='o',typ='R'),
+             B               =SIMP(statut='o',typ='R'),
+             A_0             =SIMP(statut='o',typ='R'),
+             RM              =SIMP(statut='o',typ='R'),
+             M               =SIMP(statut='o',typ='R'),
+             P               =SIMP(statut='o',typ='R'),
+             P1              =SIMP(statut='o',typ='R'),
+             P2              =SIMP(statut='o',typ='R'),
+             M11             =SIMP(statut='o',typ='R'),
+             M22             =SIMP(statut='o',typ='R'),
+             M33             =SIMP(statut='o',typ='R'),
+             M66             =SIMP(statut='o',typ='R'),
+             N11             =SIMP(statut='o',typ='R'),
+             N22             =SIMP(statut='o',typ='R'),
+             N33             =SIMP(statut='o',typ='R'),
+             N66             =SIMP(statut='o',typ='R'),
+             Q11             =SIMP(statut='o',typ='R'),
+             Q22             =SIMP(statut='o',typ='R'),
+             Q33             =SIMP(statut='o',typ='R'),
+             Q66             =SIMP(statut='o',typ='R'),
+             R11             =SIMP(statut='o',typ='R'),
+             R22             =SIMP(statut='o',typ='R'),
+             R33             =SIMP(statut='o',typ='R'),
+             R66             =SIMP(statut='o',typ='R'),
+             GRAN_A          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             GRAN_B          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             GRAN_S          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+          VISC_IRRA_LOG    =FACT(statut='f',
+             A               =SIMP(statut='f',typ='R',defaut= 1.28E-1),
+             B               =SIMP(statut='f',typ='R',defaut= 0.01159),
+             CSTE_TPS        =SIMP(statut='f',typ='R',defaut= 0.3540),
+             ENER_ACT        =SIMP(statut='f',typ='R',defaut= 5000.),
+             FLUX_PHI        =SIMP(statut='o',typ='R',),
+           ),
+          GRAN_IRRA_LOG    =FACT(statut='f',
+             A               =SIMP(statut='f',typ='R',defaut= 1.28E-1),
+             B               =SIMP(statut='f',typ='R',defaut= 0.01159),
+             CSTE_TPS        =SIMP(statut='f',typ='R',defaut= 0.3540),
+             ENER_ACT        =SIMP(statut='f',typ='R',defaut= 5000.),
+             FLUX_PHI        =SIMP(statut='o',typ='R',),
+             GRAN_A          =SIMP(statut='f',typ='R',defaut= 0.E+0),
+             GRAN_B          =SIMP(statut='f',typ='R',defaut= 0.E+0),
+             GRAN_S          =SIMP(statut='f',typ='R',defaut= 0.E+0),
+           ),
+          LEMA_SEUIL   =FACT(statut='f',
+             A               =SIMP(statut='o',typ='R',),
+             S               =SIMP(statut='o',typ='R',),
+           ),
+          LEMA_SEUIL_FO=FACT(statut='f',
+             A               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             S               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+         IRRAD3M=FACT(statut='f',
+               R02      =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+               EPSI_U   =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+               RM       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+               AI0      =SIMP(statut='o',typ='R',val_min=0.0),
+               ZETA_F   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+               ETAI_S   =SIMP(statut='o',typ='R',val_min=0.0),
+               RG0      =SIMP(statut='o',typ='R',val_min=0.0),
+               ALPHA    =SIMP(statut='o',typ='R',val_min=0.0),
+               PHI0     =SIMP(statut='o',typ='R',val_min=0.0),
+               KAPPA    =SIMP(statut='f',typ='R',val_min=0.0,defaut=0.8,val_max=1.0),
+               ZETA_G   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+               TOLER_ET =SIMP(statut='f',typ='R',val_min=0.0,defaut=0.15 ),
+         ),
+           LEMAITRE_FO     =FACT(statut='f',
+             N               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             UN_SUR_K        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             UN_SUR_M        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           LMARC           =FACT(statut='f',
+             DE_0            =SIMP(statut='o',typ='R'),
+             R_0             =SIMP(statut='o',typ='R'),
+             N               =SIMP(statut='o',typ='R'),
+             K               =SIMP(statut='o',typ='R'),
+             Y_I             =SIMP(statut='o',typ='R'),
+             Y_0             =SIMP(statut='o',typ='R'),
+             B               =SIMP(statut='o',typ='R'),
+             A_0             =SIMP(statut='o',typ='R'),
+             RM              =SIMP(statut='o',typ='R'),
+             M               =SIMP(statut='o',typ='R'),
+             P               =SIMP(statut='o',typ='R'),
+             P1              =SIMP(statut='o',typ='R'),
+             P2              =SIMP(statut='o',typ='R'),
+             M11             =SIMP(statut='o',typ='R'),
+             M22             =SIMP(statut='o',typ='R'),
+             M33             =SIMP(statut='o',typ='R'),
+             M66             =SIMP(statut='o',typ='R'),
+             N11             =SIMP(statut='o',typ='R'),
+             N22             =SIMP(statut='o',typ='R'),
+             N33             =SIMP(statut='o',typ='R'),
+             N66             =SIMP(statut='o',typ='R'),
+             Q11             =SIMP(statut='o',typ='R'),
+             Q22             =SIMP(statut='o',typ='R'),
+             Q33             =SIMP(statut='o',typ='R'),
+             Q66             =SIMP(statut='o',typ='R'),
+             R11             =SIMP(statut='o',typ='R'),
+             R22             =SIMP(statut='o',typ='R'),
+             R33             =SIMP(statut='o',typ='R'),
+             R66             =SIMP(statut='o',typ='R'),
+           ),
+           LMARC_FO        =FACT(statut='f',
+             DE_0            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             K               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Y_I             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Y_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             B               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_0             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RM              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             P               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             P1              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             P2              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M11             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M22             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M33             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M66             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N11             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N22             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N33             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N66             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q11             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q22             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q33             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             Q66             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R11             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R22             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R33             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             R66             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+             META_LEMA_ANI     =FACT(statut='f',
+             F1_A            =SIMP(statut='o',typ='R'),
+             F2_A            =SIMP(statut='o',typ='R'),
+             C_A             =SIMP(statut='o',typ='R'),
+             F1_M            =SIMP(statut='o',typ='R'),
+             F2_M            =SIMP(statut='o',typ='R'),
+             C_M             =SIMP(statut='o',typ='R'),
+             F1_N            =SIMP(statut='o',typ='R'),
+             F2_N            =SIMP(statut='o',typ='R'),
+             C_N             =SIMP(statut='o',typ='R'),
+             F1_Q            =SIMP(statut='o',typ='R'),
+             F2_Q            =SIMP(statut='o',typ='R'),
+             C_Q             =SIMP(statut='o',typ='R'),
+             F_MRR_RR        =SIMP(statut='o',typ='R'),
+             C_MRR_RR        =SIMP(statut='o',typ='R'),
+             F_MTT_TT        =SIMP(statut='o',typ='R'),
+             C_MTT_TT        =SIMP(statut='o',typ='R'),
+             F_MZZ_ZZ        =SIMP(statut='o',typ='R'),
+             C_MZZ_ZZ        =SIMP(statut='o',typ='R'),
+             F_MRT_RT        =SIMP(statut='o',typ='R'),
+             C_MRT_RT        =SIMP(statut='o',typ='R'),
+             F_MRZ_RZ        =SIMP(statut='o',typ='R'),
+             C_MRZ_RZ        =SIMP(statut='o',typ='R'),
+             F_MTZ_TZ        =SIMP(statut='o',typ='R'),
+             C_MTZ_TZ        =SIMP(statut='o',typ='R'),
+           ),
+             META_LEMA_ANI_FO  =FACT(statut='f',
+             F1_A            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_A            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_A             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_M            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_M            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_M             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_N            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_N            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_N             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_Q            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_Q            =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_Q             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_MRR_RR        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_MRR_RR        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_MTT_TT        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_MTT_TT        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_MZZ_ZZ        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_MZZ_ZZ        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_MRT_RT        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_MRT_RT        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_MRZ_RZ        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_MRZ_RZ        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_MTZ_TZ        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_MTZ_TZ        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           VMIS_POUTRE     =FACT(statut='f',
+             NP              =SIMP(statut='o',typ='R'),
+             MEY             =SIMP(statut='o',typ='R'),
+             MPY             =SIMP(statut='o',typ='R'),
+             CAY             =SIMP(statut='o',typ='R'),
+             CBY             =SIMP(statut='o',typ='R'),
+             MEZ             =SIMP(statut='o',typ='R'),
+             MPZ             =SIMP(statut='o',typ='R'),
+             CAZ             =SIMP(statut='o',typ='R'),
+             CBZ             =SIMP(statut='o',typ='R'),
+             MPX             =SIMP(statut='o',typ='R'),
+           ),
+           VMIS_POUTRE_FO  =FACT(statut='f',
+             NP              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MEY             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MPY             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CAY             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CBY             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MEZ             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MPZ             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CAZ             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CBZ             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             MPX             =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ARME            =FACT(statut='f',
+             KYE             =SIMP(statut='o',typ='R'),
+             DLE             =SIMP(statut='o',typ='R'),
+             KYP             =SIMP(statut='o',typ='R'),
+             DLP             =SIMP(statut='o',typ='R'),
+             KYG             =SIMP(statut='o',typ='R'),
+           ),
+           ASSE_CORN       =FACT(statut='f',
+             NU_1            =SIMP(statut='o',typ='R'),
+             MU_1            =SIMP(statut='o',typ='R'),
+             DXU_1           =SIMP(statut='o',typ='R'),
+             DRYU_1          =SIMP(statut='o',typ='R'),
+             C_1             =SIMP(statut='o',typ='R'),
+             NU_2            =SIMP(statut='o',typ='R'),
+             MU_2            =SIMP(statut='o',typ='R'),
+             DXU_2           =SIMP(statut='o',typ='R'),
+             DRYU_2          =SIMP(statut='o',typ='R'),
+             C_2             =SIMP(statut='o',typ='R'),
+             KY              =SIMP(statut='o',typ='R'),
+             KZ              =SIMP(statut='o',typ='R'),
+             KRX             =SIMP(statut='o',typ='R'),
+             KRZ             =SIMP(statut='o',typ='R'),
+             R_P0            =SIMP(statut='f',typ='R',defaut= 1.E+4 ),
+           ),
+           DIS_CONTACT     =FACT(statut='f',
+             RIGI_NOR        =SIMP(statut='f',typ='R' ),
+             RIGI_TAN        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             AMOR_NOR        =SIMP(statut='f',typ='R' ),
+             AMOR_TAN        =SIMP(statut='f',typ='R' ),
+             COULOMB         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             DIST_1          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             DIST_2          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             JEU             =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+           DIS_GRICRA    =FACT(statut='f',
+             KN_AX       =SIMP(statut='o',typ='R' ),
+             KT_AX       =SIMP(statut='o',typ='R' ),
+             COUL_AX     =SIMP(statut='o',typ='R' ),
+             F_SER       =SIMP(statut='f',typ='R' ),
+             F_SER_FO    =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ET_AX       =SIMP(statut='f',typ='R',defaut=1.e-7 ),
+             ET_ROT      =SIMP(statut='f',typ='R',defaut=1.e-7 ),
+             ANG1        =SIMP(statut='f',typ='R' ),
+             ANG2        =SIMP(statut='f',typ='R' ),
+             PEN1        =SIMP(statut='f',typ='R' ),
+             PEN2        =SIMP(statut='f',typ='R' ),
+             PEN3        =SIMP(statut='f',typ='R' ),
+             ANG1_FO     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ANG2_FO     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PEN1_FO     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PEN2_FO     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PEN3_FO     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             regles=(EXCLUS('ANG1','ANG1_FO',),
+                     UN_PARMI('ANG1','ANG1_FO',),
+                     EXCLUS('F_SER','F_SER_FO',),
+                     UN_PARMI('F_SER','F_SER_FO',),
+                     PRESENT_PRESENT('ANG1','ANG2','PEN1','PEN2','PEN3',),
+                     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)),
+             COEF_BIAX       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ENER_COMP_RUPT  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             ENER_TRAC_RUPT  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COEF_ELAS_COMP  =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=100.E+0),
+             LONG_CARA       =SIMP(statut='f',typ='R',val_min=0.E+0),
+             ECRO_COMP_P_PIC =SIMP(statut='f',typ='TXM',defaut="LINEAIRE",into=("LINEAIRE","PARABOLE") ),
+             ECRO_TRAC_P_PIC =SIMP(statut='f',typ='TXM',defaut="LINEAIRE",into=("LINEAIRE","EXPONENT") ),
+           ),
+           LABORD_1D=FACT(statut='f',min=0 ,
+             Y01             =SIMP(statut='o',typ='R'),
+             Y02             =SIMP(statut='o',typ='R'),
+             A1              =SIMP(statut='o',typ='R'),
+             A2              =SIMP(statut='o',typ='R'),
+             B1              =SIMP(statut='o',typ='R'),
+             B2              =SIMP(statut='o',typ='R'),
+             BETA1           =SIMP(statut='o',typ='R'),
+             BETA2           =SIMP(statut='o',typ='R'),
+             SIGF            =SIMP(statut='o',typ='R'),
+           ),
+         MAZARS=FACT(statut='f',min=0 ,
+             EPSD0           =SIMP(statut='o',typ='R'),
+             BETA            =SIMP(statut='o',typ='R'),
+             AC              =SIMP(statut='o',typ='R'),
+             BC              =SIMP(statut='o',typ='R'),
+             AT              =SIMP(statut='o',typ='R'),
+             BT              =SIMP(statut='o',typ='R'),
+             CHI             =SIMP(statut='f',typ='R',val_min=0.0E+0,val_max=1.0E+0),
+           ),
+         MAZARS_FO=FACT(statut='f',min=0 ,
+             EPSD0           =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             BETA            =SIMP(statut='o',typ='R'),
+             AC              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             BC              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AT              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             BT              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CHI             =SIMP(statut='f',typ='R'),
+           ),
+         JOINT_BA=FACT(statut='f',min=0 ,max=1,
+             HPEN            =SIMP(statut='o',typ='R',defaut= 1.E+0,val_min=0.E+0),
+             GTT             =SIMP(statut='o',typ='R',val_min=0.E+0),
+             GAMD0           =SIMP(statut='o',typ='R',val_min=1.E-4,val_max=1.E-1),
+             AD1             =SIMP(statut='o',typ='R',val_min=0.E+0),
+             BD1             =SIMP(statut='o',typ='R',defaut= 5.E-1,val_min=1.E-1),
+             GAMD2           =SIMP(statut='o',typ='R',val_min=1.E-4,val_max=1.E+0),
+             AD2             =SIMP(statut='o',typ='R',val_min=0.E+0),
+             BD2             =SIMP(statut='o',typ='R',defaut= 1.E+0,val_min=1.E-1),
+             VIFROT          =SIMP(statut='o',typ='R',val_min=0.E+0),
+             FA              =SIMP(statut='o',typ='R',val_min=0.E+0),
+             FC              =SIMP(statut='o',typ='R',val_min=0.E+0),
+             EPSTR0          =SIMP(statut='o',typ='R',val_min=1.E-4,val_max=1.E+0),
+             ADN             =SIMP(statut='o',typ='R',val_min=0.E+0),
+             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),
+             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)),
+             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)),
+           ),
+           PINTO_MENEGOTTO =FACT(statut='f',
+             SY              =SIMP(statut='o',typ='R'),
+             EPSI_ULTM       =SIMP(statut='o',typ='R'),
+             SIGM_ULTM       =SIMP(statut='o',typ='R'),
+             ELAN            =SIMP(statut='f',typ='R',defaut= 4. ),
+             EPSP_HARD       =SIMP(statut='o',typ='R'),
+             R_PM            =SIMP(statut='f',typ='R',defaut= 20. ),
+             EP_SUR_E        =SIMP(statut='f',typ='R'),
+             A1_PM           =SIMP(statut='f',typ='R',defaut= 18.5 ),
+             A2_PM           =SIMP(statut='f',typ='R',defaut= 0.15 ),
+             A6_PM           =SIMP(statut='f',typ='R',defaut= 620. ),
+             C_PM            =SIMP(statut='f',typ='R',defaut= 0.5 ),
+             A_PM            =SIMP(statut='f',typ='R',defaut= 6.0E-3 ),
+           ),
+           BPEL_BETON      =FACT(statut='f',
+             PERT_FLUA       =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             PERT_RETR       =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+           BPEL_ACIER      =FACT(statut='f',
+            regles=(PRESENT_PRESENT('RELAX_1000','F_PRG',),
+                     PRESENT_PRESENT('MU0_RELAX','F_PRG',),),
+             RELAX_1000      =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             MU0_RELAX       =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             F_PRG           =SIMP(statut='f',typ='R'),
+             FROT_COURB      =SIMP(statut='f',typ='R',defaut=0.E+0),
+             FROT_LINE       =SIMP(statut='f',typ='R',defaut=0.E+0),
+           ),
+           CAM_CLAY      =FACT(statut='f',
+             MU              =SIMP(statut='o',typ='R'),
+             PORO            =SIMP(statut='o',typ='R'),
+             LAMBDA          =SIMP(statut='o',typ='R'),
+             KAPA            =SIMP(statut='o',typ='R'),
+             M               =SIMP(statut='o',typ='R'),
+             PRES_CRIT       =SIMP(statut='o',typ='R'),
+             KCAM            =SIMP(statut='f',typ='R',val_min=0.E+0),
+             PTRAC           =SIMP(statut='f',typ='R',val_max=0.E+0),
+               regles=(PRESENT_PRESENT('PTRAC','KCAM',),),
+           ),
+           BARCELONE      =FACT(statut='f',
+             MU              =SIMP(statut='o',typ='R'),
+             PORO            =SIMP(statut='o',typ='R'),
+             LAMBDA          =SIMP(statut='o',typ='R'),
+             KAPA            =SIMP(statut='o',typ='R'),
+             M               =SIMP(statut='o',typ='R'),
+             PRES_CRIT       =SIMP(statut='o',typ='R'),
+             PA            =SIMP(statut='o',typ='R'),
+             R             =SIMP(statut='o',typ='R'),
+             BETA          =SIMP(statut='o',typ='R'),
+             KC            =SIMP(statut='o',typ='R'),
+             PC0_INIT      =SIMP(statut='o',typ='R'),
+             KAPAS         =SIMP(statut='o',typ='R'),
+             LAMBDAS       =SIMP(statut='o',typ='R'),
+             ALPHAB        =SIMP(statut='f',typ='R'),
+           ),
+           CJS             =FACT(statut='f',
+             BETA_CJS        =SIMP(statut='o',typ='R'),
+             RM              =SIMP(statut='o',typ='R'),
+             N_CJS           =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             KP              =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             RC              =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             A_CJS           =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             B_CJS           =SIMP(statut='f',typ='R',defaut= 1.0E+25 ),
+             C_CJS           =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             GAMMA_CJS       =SIMP(statut='o',typ='R'),
+             MU_CJS          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             PCO             =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             PA              =SIMP(statut='o',typ='R'),
+             Q_INIT          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+             R_INIT          =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+           HUJEUX   =FACT(statut='f',
+             N      =SIMP(statut='o',typ='R' ),
+             BETA   =SIMP(statut='o',typ='R' ),
+             B      =SIMP(statut='o',typ='R' ),
+             D      =SIMP(statut='o',typ='R' ),
+             PHI    =SIMP(statut='o',typ='R' ),
+             ANGDIL =SIMP(statut='o',typ='R' ),
+             PCO    =SIMP(statut='o',typ='R' ),
+             PREF   =SIMP(statut='o',typ='R' ),
+             ACYC   =SIMP(statut='o',typ='R' ),
+             AMON   =SIMP(statut='o',typ='R' ),
+             CCYC   =SIMP(statut='o',typ='R' ),
+             CMON   =SIMP(statut='o',typ='R' ),
+             RD_ELA =SIMP(statut='o',typ='R' ),
+             RI_ELA =SIMP(statut='o',typ='R' ),
+             RHYS   =SIMP(statut='o',typ='R' ),
+             RMOB   =SIMP(statut='o',typ='R' ),
+             XM     =SIMP(statut='o',typ='R' ),
+             RD_CYC =SIMP(statut='o',typ='R' ),
+             RI_CYC =SIMP(statut='o',typ='R' ),
+             DILA   =SIMP(statut='o',typ='R' ),
+             PTRAC  =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+           ECRO_ASYM_LINE  =FACT(statut='f',
+             DC_SIGM_EPSI    =SIMP(statut='o',typ='R'),
+             SY_C            =SIMP(statut='o',typ='R'),
+             DT_SIGM_EPSI    =SIMP(statut='o',typ='R'),
+             SY_T            =SIMP(statut='o',typ='R'),
+           ),
+           GRANGER_FP      =FACT(statut='f',
+             J1              =SIMP(statut='f',typ='R'),
+             J2              =SIMP(statut='f',typ='R'),
+             J3              =SIMP(statut='f',typ='R'),
+             J4              =SIMP(statut='f',typ='R'),
+             J5              =SIMP(statut='f',typ='R'),
+             J6              =SIMP(statut='f',typ='R'),
+             J7              =SIMP(statut='f',typ='R'),
+             J8              =SIMP(statut='f',typ='R'),
+             TAUX_1          =SIMP(statut='f',typ='R'),
+             TAUX_2          =SIMP(statut='f',typ='R'),
+             TAUX_3          =SIMP(statut='f',typ='R'),
+             TAUX_4          =SIMP(statut='f',typ='R'),
+             TAUX_5          =SIMP(statut='f',typ='R'),
+             TAUX_6          =SIMP(statut='f',typ='R'),
+             TAUX_7          =SIMP(statut='f',typ='R'),
+             TAUX_8          =SIMP(statut='f',typ='R'),
+             QSR_K           =SIMP(statut='f',typ='R'),
+           ),
+           GRANGER_FP_INDT =FACT(statut='f',
+             J1              =SIMP(statut='f',typ='R'),
+             J2              =SIMP(statut='f',typ='R'),
+             J3              =SIMP(statut='f',typ='R'),
+             J4              =SIMP(statut='f',typ='R'),
+             J5              =SIMP(statut='f',typ='R'),
+             J6              =SIMP(statut='f',typ='R'),
+             J7              =SIMP(statut='f',typ='R'),
+             J8              =SIMP(statut='f',typ='R'),
+             TAUX_1          =SIMP(statut='f',typ='R'),
+             TAUX_2          =SIMP(statut='f',typ='R'),
+             TAUX_3          =SIMP(statut='f',typ='R'),
+             TAUX_4          =SIMP(statut='f',typ='R'),
+             TAUX_5          =SIMP(statut='f',typ='R'),
+             TAUX_6          =SIMP(statut='f',typ='R'),
+             TAUX_7          =SIMP(statut='f',typ='R'),
+             TAUX_8          =SIMP(statut='f',typ='R'),
+           ),
+           V_GRANGER_FP    =FACT(statut='f',
+             QSR_VEIL        =SIMP(statut='f',typ='R'),
+             FONC_V          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           BETON_UMLV_FP   =FACT(statut='f',min=0 ,
+             K_RS            =SIMP(statut='o',typ='R'),
+             ETA_RS          =SIMP(statut='o',typ='R'),
+             K_IS            =SIMP(statut='o',typ='R'),
+             ETA_IS          =SIMP(statut='o',typ='R'),
+             K_RD            =SIMP(statut='o',typ='R'),
+             ETA_RD          =SIMP(statut='o',typ='R'),
+             ETA_ID          =SIMP(statut='o',typ='R'),
+             ETA_FD          =SIMP(statut='f',typ='R'),
+           ),
+           GLRC_DM         =FACT(statut='f',min=0,max=1,
+             regles=(EXCLUS('GAMMA_C','SYC'),),
+             GAMMA_T         =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
+             GAMMA_C         =SIMP(statut='f',typ='R',val_min=-1.E+0,val_max=1.E+0),
+             GAMMA_F         =SIMP(statut='o',typ='R',val_min=-1.E+0,val_max=1.E+0),
+             SYT             =SIMP(statut='o',typ='R',val_min=0.E+0),
+             SYC             =SIMP(statut='f',typ='R'),
+             SYF             =SIMP(statut='o',typ='R',val_min=0.E+0),
+             EF              =SIMP(statut='f',typ='R',val_min=0.E+0),
+             NUF             =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=0.5+0),
+           ),
+           GATT_MONERIE    =FACT(statut='f',min=0,max=1,
+             D_GRAIN         =SIMP(statut='o',typ='R',val_min=0.E+0),
+             PORO_INIT       =SIMP(statut='o',typ='R',val_min=0.E+0),
+             EPSI_01         =SIMP(statut='o',typ='R',defaut= 2.7252E-10,val_min=0.E+0),
+             EPSI_02         =SIMP(statut='o',typ='R',defaut= 9.1440E-41,val_min=0.E+0),
+           ),
+           CORR_ACIER   =FACT(statut='f',min=0 ,max=1,
+             D_CORR           =SIMP(statut='o',typ='R'),
+             ECRO_K           =SIMP(statut='o',typ='R'),
+             ECRO_M           =SIMP(statut='o',typ='R'),
+             SY              =SIMP(statut='o',typ='R'),
+             ),
+# Discrets non-linéaires : début
+         DIS_ECRO_CINE  =FACT(statut='f',
+            fr="Loi pour les discrets avec écrouissage cinématique.",
+            regles=(PRESENT_PRESENT('LIMY_DX','KCIN_DX',),PRESENT_PRESENT('PUIS_DX','LIMU_DX',),
+                    PRESENT_PRESENT('LIMY_DY','KCIN_DY',),PRESENT_PRESENT('PUIS_DY','LIMU_DY',),
+                    PRESENT_PRESENT('LIMY_DZ','KCIN_DZ',),PRESENT_PRESENT('PUIS_DZ','LIMU_DZ',),
+                    PRESENT_PRESENT('LIMY_RX','KCIN_RX',),PRESENT_PRESENT('PUIS_RX','LIMU_RX',),
+                    PRESENT_PRESENT('LIMY_RY','KCIN_RY',),PRESENT_PRESENT('PUIS_RY','LIMU_RY',),
+                    PRESENT_PRESENT('LIMY_RZ','KCIN_RZ',),PRESENT_PRESENT('PUIS_RZ','LIMU_RZ',),),
+            LIMY_DX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Effort limite élastique suivant l'axe local x de l'élément."),
+            LIMY_DY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Effort limite élastique suivant l'axe local y de l'élément."),
+            LIMY_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Effort limite élastique suivant l'axe local z de l'élément."),
+            LIMY_RX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Moment limite élastique suivant l'axe local x de l'élément."),
+            LIMY_RY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Moment limite élastique suivant l'axe local y de l'élément."),
+            LIMY_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Moment limite élastique suivant l'axe local z de l'élément."),
+            KCIN_DX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Raideur suivant l'axe local x de l'élément."),
+            KCIN_DY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Raideur suivant l'axe local y de l'élément."),
+            KCIN_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Raideur suivant l'axe local z de l'élément."),
+            KCIN_RX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Raideur suivant l'axe local Rx de l'élément."),
+            KCIN_RY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Raideur suivant l'axe local Ry de l'élément."),
+            KCIN_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Raideur suivant l'axe local Rz de l'élément."),
+            LIMU_DX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Effort limite suivant l'axe local x de l'élément."),
+            LIMU_DY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Effort limite suivant l'axe local y de l'élément."),
+            LIMU_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Effort limite suivant l'axe local z de l'élément."),
+            LIMU_RX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Moment limite suivant l'axe local x de l'élément."),
+            LIMU_RY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Moment limite suivant l'axe local y de l'élément."),
+            LIMU_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Moment limite suivant l'axe local z de l'élément."),
+            PUIS_DX =SIMP(statut='f',typ='R',val_min = 1.0,
+               fr="Coefficient de non-linéarité suivant l'axe local x de l'élément."),
+            PUIS_DY =SIMP(statut='f',typ='R',val_min = 1.0,
+               fr="Coefficient de non-linéarité suivant l'axe local y de l'élément."),
+            PUIS_DZ =SIMP(statut='f',typ='R',val_min = 1.0,
+               fr="Coefficient de non-linéarité suivant l'axe local z de l'élément."),
+            PUIS_RX =SIMP(statut='f',typ='R',val_min = 1.0,
+               fr="Coefficient de non-linéarité suivant l'axe local Rx de l'élément."),
+            PUIS_RY =SIMP(statut='f',typ='R',val_min = 1.0,
+               fr="Coefficient de non-linéarité suivant l'axe local Ry de l'élément."),
+            PUIS_RZ =SIMP(statut='f',typ='R',val_min = 1.0,
+               fr="Coefficient de non-linéarité suivant l'axe local Rz de l'élément."),
+         ),
+         DIS_VISC  =FACT(statut='f',
+            fr="Loi pour un discret de type amortisseur visqueux.",
+            regles=(PRESENT_PRESENT('PUIS_DX','COEF_DX',),
+                    PRESENT_PRESENT('PUIS_DY','COEF_DY',),
+                    PRESENT_PRESENT('PUIS_DZ','COEF_DZ',),
+                    PRESENT_PRESENT('PUIS_RX','COEF_RX',),
+                    PRESENT_PRESENT('PUIS_RY','COEF_RY',),
+                    PRESENT_PRESENT('PUIS_RZ','COEF_RZ',),
+                    ),
+            PUIS_DX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Puissance dans la direction locale Dx de l'élément."),
+            PUIS_DY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Puissance dans la direction locale Dy de l'élément."),
+            PUIS_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Puissance dans la direction locale Dz de l'élément."),
+            PUIS_RX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Puissance autour de la direction locale Rx de l'élément."),
+            PUIS_RY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Puissance autour de la direction locale Ry de l'élément."),
+            PUIS_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Puissance autour de la direction locale Rz de l'élément."),
+            COEF_DX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Coefficient C dans la direction locale Dx de l'élément."),
+            COEF_DY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Coefficient C dans la direction locale Dy de l'élément."),
+            COEF_DZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Coefficient C dans la direction locale Dz de l'élément."),
+            COEF_RX =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Coefficient C autour de la direction locale Rx de l'élément."),
+            COEF_RY =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Coefficient C autour de la direction locale Ry de l'élément."),
+            COEF_RZ =SIMP(statut='f',typ='R',val_min = 0.0,
+               fr="Coefficient C autour de la direction locale Rz de l'élément."),
+         ),
+         DIS_BILI_ELAS  =FACT(statut='f',
+            fr="Loi bi-linéaire pour les discrets.",
+            regles=(PRESENT_PRESENT('KDEB_DX','KFIN_DX','FPRE_DX',),
+                    PRESENT_PRESENT('KDEB_DY','KFIN_DY','FPRE_DY',),
+                    PRESENT_PRESENT('KDEB_DZ','KFIN_DZ','FPRE_DZ',),),
+            KDEB_DX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+               fr="Raideur début suivant l'axe local x de l'élément."),
+            KDEB_DY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+               fr="Raideur début suivant l'axe local y de l'élément."),
+            KDEB_DZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+               fr="Raideur début  suivant l'axe local z de l'élément."),
+            KFIN_DX =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+               fr="Raideur fin l'axe local x de l'élément."),
+            KFIN_DY =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+               fr="Raideur fin l'axe local y de l'élément."),
+            KFIN_DZ =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+               fr="Raideur fin l'axe local z de l'élément."),
+            FPRE_DX =SIMP(statut='f',typ='R',
+               fr="Effort de préserrage suivant l'axe local x de l'élément."),
+            FPRE_DY =SIMP(statut='f',typ='R',
+               fr="Effort de préserrage suivant l'axe local y de l'élément."),
+            FPRE_DZ =SIMP(statut='f',typ='R',
+               fr="Effort de préserrage suivant l'axe local z de l'élément."),
+         ),
+# Discrets non-linéaires : fin
+#
+# comportement thermique
+#
+           THER_NL         =FACT(statut='f',
+             regles=(UN_PARMI('BETA','RHO_CP', ),),
+             LAMBDA          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             BETA            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RHO_CP          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           THER_HYDR       =FACT(statut='f',
+             LAMBDA          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             BETA            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             AFFINITE        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CHALHYDR        =SIMP(statut='o',typ='R'),
+             QSR_K           =SIMP(statut='o',typ='R'),
+           ),
+           THER            =FACT(statut='f',
+             LAMBDA          =SIMP(statut='o',typ='R'),
+             RHO_CP          =SIMP(statut='f',typ='R'),
+           ),
+           THER_FO         =FACT(statut='f',
+             LAMBDA          =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             RHO_CP          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           THER_ORTH       =FACT(statut='f',
+             LAMBDA_L        =SIMP(statut='o',typ='R'),
+             LAMBDA_T        =SIMP(statut='o',typ='R'),
+             LAMBDA_N        =SIMP(statut='f',typ='R'),
+             RHO_CP          =SIMP(statut='f',typ='R'),
+           ),
+           THER_COQUE      =FACT(statut='f',
+             COND_LMM        =SIMP(statut='o',typ='R'),
+             COND_TMM        =SIMP(statut='o',typ='R'),
+             COND_LMP        =SIMP(statut='o',typ='R'),
+             COND_TMP        =SIMP(statut='o',typ='R'),
+             COND_LPP        =SIMP(statut='o',typ='R'),
+             COND_TPP        =SIMP(statut='o',typ='R'),
+             COND_LSI        =SIMP(statut='o',typ='R'),
+             COND_TSI        =SIMP(statut='o',typ='R'),
+             COND_NMM        =SIMP(statut='o',typ='R'),
+             COND_NMP        =SIMP(statut='o',typ='R'),
+             COND_NPP        =SIMP(statut='o',typ='R'),
+             COND_NSI        =SIMP(statut='o',typ='R'),
+             CMAS_MM         =SIMP(statut='f',typ='R'),
+             CMAS_MP         =SIMP(statut='f',typ='R'),
+             CMAS_PP         =SIMP(statut='f',typ='R'),
+             CMAS_SI         =SIMP(statut='f',typ='R'),
+           ),
+           THER_COQUE_FO   =FACT(statut='f',
+             COND_LMM        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_TMM        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_LMP        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_TMP        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_LPP        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_TPP        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_LSI        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_TSI        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_NMM        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_NMP        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_NPP        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COND_NSI        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CMAS_MM         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CMAS_MP         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CMAS_PP         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CMAS_SI         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           SECH_GRANGER    =FACT(statut='f',
+             A               =SIMP(statut='o',typ='R'),
+             B               =SIMP(statut='o',typ='R'),
+             QSR_K           =SIMP(statut='o',typ='R'),
+             TEMP_0_C        =SIMP(statut='o',typ='R'),
+           ),
+           SECH_MENSI      =FACT(statut='f',
+             A               =SIMP(statut='o',typ='R'),
+             B               =SIMP(statut='o',typ='R'),
+           ),
+           SECH_BAZANT     =FACT(statut='f',
+             D1              =SIMP(statut='o',typ='R'),
+             ALPHA_BAZANT    =SIMP(statut='o',typ='R'),
+             N               =SIMP(statut='o',typ='R'),
+             FONC_DESORP     =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           SECH_NAPPE      =FACT(statut='f',
+             FONCTION        =SIMP(statut='o',typ=(nappe_sdaster,formule)),
+           ),
+#
+# comportement métallurgique
+#
+           META_ACIER      =FACT(statut='f',
+             TRC             =SIMP(statut='o',typ=(table_sdaster) ),
+             AR3             =SIMP(statut='o',typ='R'),
+             ALPHA           =SIMP(statut='o',typ='R'),
+             MS0             =SIMP(statut='o',typ='R'),
+             AC1             =SIMP(statut='o',typ='R'),
+             AC3             =SIMP(statut='o',typ='R'),
+             TAUX_1          =SIMP(statut='o',typ='R'),
+             TAUX_3          =SIMP(statut='o',typ='R'),
+             LAMBDA0         =SIMP(statut='f',typ='R'),
+             QSR_K           =SIMP(statut='f',typ='R'),
+             D10             =SIMP(statut='f',typ='R'),
+             WSR_K           =SIMP(statut='f',typ='R'),
+           ),
+           META_ZIRC       =FACT(statut='f',
+             TDEQ            =SIMP(statut='o',typ='R'),
+             N               =SIMP(statut='o',typ='R'),
+             K               =SIMP(statut='o',typ='R'),
+             T1C             =SIMP(statut='o',typ='R'),
+             T2C             =SIMP(statut='o',typ='R'),
+             AC              =SIMP(statut='o',typ='R'),
+             M               =SIMP(statut='o',typ='R'),
+             QSR_K           =SIMP(statut='o',typ='R'),
+             T1R             =SIMP(statut='o',typ='R'),
+             T2R             =SIMP(statut='o',typ='R'),
+             AR              =SIMP(statut='o',typ='R'),
+             BR              =SIMP(statut='o',typ='R'),
+           ),
+           DURT_META       =FACT(statut='f',
+             F1_DURT         =SIMP(statut='o',typ='R'),
+             F2_DURT         =SIMP(statut='o',typ='R'),
+             F3_DURT         =SIMP(statut='o',typ='R'),
+             F4_DURT         =SIMP(statut='o',typ='R'),
+             C_DURT          =SIMP(statut='o',typ='R'),
+           ),
+           ELAS_META       =FACT(statut='f',
+             E               =SIMP(statut='o',typ='R'),
+             NU              =SIMP(statut='o',typ='R'),
+             F_ALPHA         =SIMP(statut='o',typ='R'),
+             C_ALPHA         =SIMP(statut='o',typ='R'),
+             PHASE_REFE      =SIMP(statut='o',typ='TXM',into=("CHAUD","FROID")),
+             EPSF_EPSC_TREF  =SIMP(statut='o',typ='R'),
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+             F1_SY           =SIMP(statut='f',typ='R'),
+             F2_SY           =SIMP(statut='f',typ='R'),
+             F3_SY           =SIMP(statut='f',typ='R'),
+             F4_SY           =SIMP(statut='f',typ='R'),
+             C_SY            =SIMP(statut='f',typ='R'),
+             SY_MELANGE      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_S_VP         =SIMP(statut='f',typ='R'),
+             F2_S_VP         =SIMP(statut='f',typ='R'),
+             F3_S_VP         =SIMP(statut='f',typ='R'),
+             F4_S_VP         =SIMP(statut='f',typ='R'),
+             C_S_VP          =SIMP(statut='f',typ='R' ),
+             S_VP_MELANGE    =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           ELAS_META_FO    =FACT(statut='f',
+             regles=(
+                      PRESENT_PRESENT('F_ALPHA','TEMP_DEF_ALPHA'),
+                      PRESENT_PRESENT('C_ALPHA','TEMP_DEF_ALPHA'),
+                    ),
+             E               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             NU              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F_ALPHA         =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_ALPHA         =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PHASE_REFE      =SIMP(statut='o',typ='TXM',into=("CHAUD","FROID")),
+             EPSF_EPSC_TREF  =SIMP(statut='o',typ='R'),
+             TEMP_DEF_ALPHA  =SIMP(statut='f',typ='R'),
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+             F1_SY           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_SY           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_SY           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_SY           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_SY            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SY_MELANGE      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_S_VP         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_S_VP         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_S_VP         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_S_VP         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_S_VP          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             S_VP_MELANGE    =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           META_ECRO_LINE  =FACT(statut='f',
+             F1_D_SIGM_EPSI  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_D_SIGM_EPSI  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_D_SIGM_EPSI  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_D_SIGM_EPSI  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_D_SIGM_EPSI   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           META_TRACTION   =FACT(statut='f',
+             SIGM_F1         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SIGM_F2         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SIGM_F3         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SIGM_F4         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SIGM_C          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           META_VISC_FO    =FACT(statut='f',
+             F1_ETA          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_N            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_C            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F1_M            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_ETA          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_N            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_C            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_M            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_ETA          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_N            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_C            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_M            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_ETA          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_N            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_C            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_M            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_ETA           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_N             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_C             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             C_M             =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           META_PT         =FACT(statut='f',
+             F1_K            =SIMP(statut='f',typ='R'),
+             F2_K            =SIMP(statut='f',typ='R'),
+             F3_K            =SIMP(statut='f',typ='R'),
+             F4_K            =SIMP(statut='f',typ='R'),
+             F1_D_F_META     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F2_D_F_META     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F3_D_F_META     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             F4_D_F_META     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           META_RE         =FACT(statut='f',
+             C_F1_THETA      =SIMP(statut='f',typ='R'),
+             C_F2_THETA      =SIMP(statut='f',typ='R'),
+             C_F3_THETA      =SIMP(statut='f',typ='R'),
+             C_F4_THETA      =SIMP(statut='f',typ='R'),
+             F1_C_THETA      =SIMP(statut='f',typ='R'),
+             F2_C_THETA      =SIMP(statut='f',typ='R'),
+             F3_C_THETA      =SIMP(statut='f',typ='R'),
+             F4_C_THETA      =SIMP(statut='f',typ='R'),
+           ),
+#
+# comportement fluide
+#
+           FLUIDE          =FACT(statut='f',
+             regles=(EXCLUS('CELE_C','CELE_R'),),
+             RHO             =SIMP(statut='o',typ='R'),
+             CELE_C          =SIMP(statut='f',typ='C'),
+             CELE_R          =SIMP(statut='f',typ='R'),
+           ),
+# =================================================================================
+# COMPORTEMENT THERMO_HYDRO_MECANIQUE
+# LES DONNEES NECESSAIRES A LA DEFINITION DU MATERIAU SONT DEPENDANTES
+# DE LA LOI DE COUPLAGE THM DE LA RELATION
+# LE COMPORTEMENT DE COUPLAGE COMP_THM N EST VALABLE QUE POUR LES LOIS
+# DE COUPLAGE : LIQU_SATU,LIQU_GAZ,GAZ,LIQU_GAZ_ATM,LIQU_VAPE_GAZ,LIQU_VAPE
+# ET LIQU_AD_GAZ_VAPE
+# LA CORRESPONDANCE AVEC LES VARIABLES CACHEES EST LA SUIVANTE :
+# 1 -->  LIQU_SATU
+# 2 -->  GAZ
+# 3 -->  LIQU_VAPE
+# 4 -->  LIQU_VAPE_GAZ
+# 5 -->  LIQU_GAZ
+# 6 -->  LIQU_GAZ_ATM
+# 9 -->  LIQU_AD_GAZ_VAPE
+# =================================================================================
+           COMP_THM        = SIMP(statut='f', typ='TXM',
+                                  into = ( "LIQU_SATU"     ,
+                                           "LIQU_GAZ"      ,
+                                           "GAZ"           ,
+                                           "LIQU_GAZ_ATM"  ,
+                                           "LIQU_VAPE_GAZ" ,
+                                           "LIQU_VAPE"     ,
+                                           "LIQU_AD_GAZ_VAPE" ,
+                                          ) ),
+# =================================================================================
+# --- LOI DE COUPLAGE DE TYPE LIQU_SATU -------------------------------------------
+# =================================================================================
+# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : ---------------------------------
+# --- THM_INIT, THM_DIFFU, THM_LIQU -----------------------------------------------
+# =================================================================================
+           b_liqusatu      = BLOC(condition = "COMP_THM == 'LIQU_SATU' ",
+                                 fr="Paramètres nécessaires pour une loi de couplage de type LIQU_SATU",
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_INIT   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRE1          = SIMP(statut='o',typ='R'),
+                                           PORO          = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           TEMP          = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           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 ---------------------------------------------
+# ---------------------------------------------------------------------------------
+                                           COMP_THM         = SIMP(statut='c',typ='R',defaut= 1.0,),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_DIFFU  = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO           = SIMP(statut='o',typ='R'),
+                                           BIOT_COEF     = SIMP(statut='o',typ='R'),
+                                           PESA_X        = SIMP(statut='o',typ='R'),
+                                           PESA_Y        = SIMP(statut='o',typ='R'),
+                                           PESA_Z        = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP            = SIMP(statut='f',typ='R'),
+                                           PERM_IN       = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_END      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                                           regles = (EXCLUS('PERM_IN','PERM_END','PERMIN_X',),
+                                                            PRESENT_PRESENT('PERMIN_X','PERMIN_Y','PERMIN_Z',), ),
+                                           PERMIN_X      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Y      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Z      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_LB_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           LAMB_CT   = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           R_GAZ         = SIMP(statut='f',typ='R'),
+                                           EMMAG           = SIMP(statut='f',typ='R'),
+                                           SATU_PRES       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_SATU_PRES     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_LIQU       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_PERM_LIQU_SATU=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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)),
+                                           FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_PG          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PA         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PL         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FA_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_LIQU   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO           = SIMP(statut='o',typ='R'),
+                                           UN_SUR_K      = SIMP(statut='o',typ='R'),
+                                           VISC          = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP   = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           ALPHA         = SIMP(statut='f',typ='R'),
+                                           CP            = SIMP(statut='f',typ='R'),
+                                         ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+           THM_GAZ         =FACT(statut='f',
+             MASS_MOL        =SIMP(statut='f',typ='R'),
+             CP              =SIMP(statut='f',typ='R'),
+             VISC            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_VISC_TEMP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+           THM_VAPE_GAZ    =FACT(statut='f',
+             MASS_MOL        =SIMP(statut='f',typ='R'),
+             CP              =SIMP(statut='f',typ='R'),
+             VISC            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_VISC_TEMP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+                                 ),
+# =================================================================================
+# --- LOI DE COUPLAGE DE TYPE LIQU_GAZ --------------------------------------------
+# =================================================================================
+# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : ---------------------------------
+# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ --------------------------------------
+# =================================================================================
+           b_liqugaz      = BLOC(condition = "COMP_THM == 'LIQU_GAZ' ",
+                                 fr="Paramètres nécessaires pour une loi de couplage de type LIQU_GAZ",
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_INIT   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRE1             = SIMP(statut='o',typ='R'),
+                                           PRE2             = SIMP(statut='o',typ='R'),
+                                           PORO             = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           TEMP             = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRES_VAPE        = SIMP(statut='f',typ='R'),
+                                           DEGR_SATU        = SIMP(statut='f',typ='R'),
+                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEE CACHEE ---------------------------------------------
+# ---------------------------------------------------------------------------------
+                                           COMP_THM         = SIMP(statut='c',typ='R',defaut= 5.0,),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_DIFFU  = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           R_GAZ            = SIMP(statut='o',typ='R'),
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           BIOT_COEF        = SIMP(statut='o',typ='R'),
+                                           PESA_X           = SIMP(statut='o',typ='R'),
+                                           PESA_Y           = SIMP(statut='o',typ='R'),
+                                           PESA_Z           = SIMP(statut='o',typ='R'),
+                                           SATU_PRES        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_SATU_PRES      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_LIQU        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_PERM_LIQU_SATU = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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)),
+# ---Van Genhuchten et Muallen-----------------------------------------------------------------------------
+
+                                           VG_N    = SIMP(statut='f',typ='R'),
+                                           VG_SR    = SIMP(statut='f',typ='R'),
+                                           VG_PR   = SIMP(statut='f',typ='R'),
+                                           VG_SMAX = SIMP(statut='f',typ='R'),
+                                           VG_SATUR = SIMP(statut='f',typ='R'),
+#
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                           PERM_IN          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_END         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_X      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Y      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Z      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_LB_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           LAMB_CT   = SIMP(statut='f',typ='R'),
+#
+                                  regles = (EXCLUS('PERM_IN','PERM_END','PERMIN_X',),
+                                            PRESENT_PRESENT('PERMIN_X','PERMIN_Y','PERMIN_Z',),
+                                            ENSEMBLE('SATU_PRES','D_SATU_PRES','PERM_LIQU','D_PERM_LIQU_SATU',
+                                                            'PERM_GAZ','D_PERM_SATU_GAZ','D_PERM_PRES_GAZ',),
+                                            ENSEMBLE('VG_N','VG_SR','VG_PR','VG_SMAX','VG_SATUR',),
+                                            UN_PARMI('VG_N','SATU_PRES'),
+                                           ),
+
+# ---------------------------------------------------------------------------------
+# -------------------   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)),
+                                           FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_PG          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PA         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PL         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FA_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ) ,
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_LIQU   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           UN_SUR_K         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           ALPHA            = SIMP(statut='f',typ='R'),
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_GAZ    = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           MASS_MOL        = SIMP(statut='o',typ='R'),
+                                           VISC            = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP     = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP              = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+           THM_VAPE_GAZ    =FACT(statut='f',
+             MASS_MOL        =SIMP(statut='f',typ='R'),
+             CP              =SIMP(statut='f',typ='R'),
+             VISC            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_VISC_TEMP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+                                 ),
+# =================================================================================
+# --- LOI DE COUPLAGE DE TYPE GAZ -------------------------------------------------
+# =================================================================================
+# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : ---------------------------------
+# --- THM_INIT, THM_DIFFU, THM_GAZ ------------------------------------------------
+# =================================================================================
+           b_gaz          = BLOC(condition = "COMP_THM == 'GAZ' ",
+                                 fr="Paramètres nécessaires pour une loi de couplage de type GAZ",
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_INIT   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           TEMP             = SIMP(statut='o',typ='R'),
+                                           PRE1             = SIMP(statut='o',typ='R'),
+                                           PORO             = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           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 ---------------------------------------------
+# ---------------------------------------------------------------------------------
+                                           COMP_THM         = SIMP(statut='c',typ='R',defaut= 2.0,),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_DIFFU  = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           R_GAZ            = SIMP(statut='o',typ='R'),
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           BIOT_COEF        = SIMP(statut='o',typ='R'),
+                                           PESA_X           = SIMP(statut='o',typ='R'),
+                                           PESA_Y           = SIMP(statut='o',typ='R'),
+                                           PESA_Z           = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                           PERM_IN          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_END         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                                           regles = (EXCLUS('PERM_IN','PERM_END','PERMIN_X',),
+                                                            PRESENT_PRESENT('PERMIN_X','PERMIN_Y','PERMIN_Z',), ),
+                                           PERMIN_X      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Y      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Z      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_LB_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           LAMB_CT   = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           EMMAG           = SIMP(statut='f',typ='R'),
+                                           SATU_PRES       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_SATU_PRES     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_LIQU       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_PERM_LIQU_SATU=SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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)),
+                                           FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_PG          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PA         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PL         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FA_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ) ,
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_GAZ    = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           MASS_MOL         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+           THM_LIQU        =FACT(statut='f',
+             RHO             =SIMP(statut='f',typ='R'),
+             UN_SUR_K        =SIMP(statut='f',typ='R'),
+             ALPHA           =SIMP(statut='f',typ='R'),
+             CP              =SIMP(statut='f',typ='R'),
+             VISC            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_VISC_TEMP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             COEF_HENRY      =SIMP(statut='f',typ='R'),
+           ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+           THM_VAPE_GAZ    =FACT(statut='f',
+             MASS_MOL        =SIMP(statut='f',typ='R'),
+             CP              =SIMP(statut='f',typ='R'),
+             VISC            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_VISC_TEMP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+                                 ),
+# =================================================================================
+# --- LOI DE COUPLAGE DE TYPE LIQU_GAZ_ATM ----------------------------------------
+# =================================================================================
+# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : ---------------------------------
+# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ --------------------------------------
+# =================================================================================
+           b_liqugazatm   = BLOC(condition = "COMP_THM == 'LIQU_GAZ_ATM' ",
+                                 fr="Paramètres nécessaires pour une loi de couplage de type LIQU_GAZ_ATM",
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_INIT   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRE1             = SIMP(statut='o',typ='R'),
+                                           PORO             = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           TEMP             = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           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 ---------------------------------------------
+# ---------------------------------------------------------------------------------
+                                           COMP_THM         = SIMP(statut='c',typ='R',defaut= 6.0,),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_DIFFU  = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           BIOT_COEF        = SIMP(statut='o',typ='R'),
+                                           PESA_X           = SIMP(statut='o',typ='R'),
+                                           PESA_Y           = SIMP(statut='o',typ='R'),
+                                           PESA_Z           = SIMP(statut='o',typ='R'),
+                                           SATU_PRES        = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_SATU_PRES      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_LIQU        = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_PERM_LIQU_SATU = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                           PERM_IN          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_END         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                                           regles = (EXCLUS('PERM_IN','PERM_END','PERMIN_X',),
+                                                            PRESENT_PRESENT('PERMIN_X','PERMIN_Y','PERMIN_Z',), ),
+                                           PERMIN_X      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Y      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Z      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_LB_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           LAMB_CT   = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+             EMMAG           = SIMP(statut='f',typ='R'),
+             R_GAZ           =SIMP(statut='f',typ='R'),
+             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)),
+             FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_FV_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_FV_PG          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FICKA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FICKA_PA         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FICKA_PL         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             FICKA_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_FA_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ) ,
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_LIQU   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           UN_SUR_K         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           ALPHA            = SIMP(statut='f',typ='R'),
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+                             THM_GAZ    = FACT(statut='f',
+                                           MASS_MOL         = SIMP(statut='f',typ='R'),
+                                           VISC             = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+           THM_VAPE_GAZ    =FACT(statut='f',
+             MASS_MOL        =SIMP(statut='f',typ='R'),
+             CP              =SIMP(statut='f',typ='R'),
+             VISC            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_VISC_TEMP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+                                 ),
+# =================================================================================
+# --- LOI DE COUPLAGE DE TYPE LIQU_VAPE_GAZ ---------------------------------------
+# =================================================================================
+# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : ---------------------------------
+# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ, THM_VAPE_GAZ ------------------------
+# =================================================================================
+           b_liquvapegaz  = BLOC(condition = "COMP_THM == 'LIQU_VAPE_GAZ' ",
+                                 fr="Paramètres nécessaires pour une loi de couplage de type LIQU_VAPE_GAZ",
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_INIT   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRE1             = SIMP(statut='o',typ='R'),
+                                           PRE2             = SIMP(statut='o',typ='R'),
+                                           PORO             = SIMP(statut='o',typ='R'),
+                                           PRES_VAPE        = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           TEMP             = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           DEGR_SATU        = SIMP(statut='f',typ='R'),
+                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEE CACHEE ---------------------------------------------
+# ---------------------------------------------------------------------------------
+                                           COMP_THM         = SIMP(statut='c',typ='R',defaut= 4.0,),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_DIFFU  = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           R_GAZ            = SIMP(statut='o',typ='R'),
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           BIOT_COEF        = SIMP(statut='o',typ='R'),
+                                           PESA_X           = SIMP(statut='o',typ='R'),
+                                           PESA_Y           = SIMP(statut='o',typ='R'),
+                                           PESA_Z           = SIMP(statut='o',typ='R'),
+                                           SATU_PRES        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_SATU_PRES      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_LIQU        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_PERM_LIQU_SATU = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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)),
+# ---Van Genhuchten et Muallen-----------------------------------------------------------------------------
+
+                                           VG_N     = SIMP(statut='f',typ='R'),
+                                           VG_SR    = SIMP(statut='f',typ='R'),
+                                           VG_PR    = SIMP(statut='f',typ='R'),
+                                           VG_SMAX  = SIMP(statut='f',typ='R'),
+                                           VG_SATUR = SIMP(statut='f',typ='R'),
+#
+                                           FICKV_T          = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                           PERM_IN          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_END         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_X      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Y      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Z      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_LB_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           LAMB_CT   = SIMP(statut='f',typ='R'),
+#
+                                  regles = (EXCLUS('PERM_IN','PERM_END','PERMIN_X',),
+                                            PRESENT_PRESENT('PERMIN_X','PERMIN_Y','PERMIN_Z',),
+                                            ENSEMBLE('SATU_PRES','D_SATU_PRES','PERM_LIQU','D_PERM_LIQU_SATU',
+                                                            'PERM_GAZ','D_PERM_SATU_GAZ','D_PERM_PRES_GAZ',),
+                                            ENSEMBLE('VG_N','VG_SR','VG_PR','VG_SMAX','VG_SATUR',),
+                                            UN_PARMI('VG_N','SATU_PRES'),
+                                           ),
+# ---------------------------------------------------------------------------------
+# -------------------   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)),
+                                           D_FV_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_PG          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           FICKA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PA         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PL         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FA_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ) ,
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_LIQU   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           UN_SUR_K         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           ALPHA            = SIMP(statut='f',typ='R'),
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_GAZ    = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           MASS_MOL         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_VAPE_GAZ = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           MASS_MOL         = SIMP(statut='o',typ='R'),
+                                           CP               = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ),
+                                 ),
+# =================================================================================
+# --- LOI DE COUPLAGE DE TYPE LIQU_AD_GAZ_VAPE -------------------------------------
+# =================================================================================
+# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : ---------------------------------
+# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ, THM_VAPE_GAZ THM_AIR_DISSOUS---------
+# =================================================================================
+           b_liquadvape  = BLOC(condition = "COMP_THM == 'LIQU_AD_GAZ_VAPE' ",
+                                 fr="Paramètres nécessaires pour une loi de couplage de type LIQU_AD_GAZ_VAPE",
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_INIT   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRE1             = SIMP(statut='o',typ='R'),
+                                           PRE2             = SIMP(statut='o',typ='R'),
+                                           PORO             = SIMP(statut='o',typ='R'),
+                                           PRES_VAPE        = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           TEMP             = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           DEGR_SATU        = SIMP(statut='f',typ='R'),
+                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEE CACHEE ---------------------------------------------
+# ---------------------------------------------------------------------------------
+                                           COMP_THM         = SIMP(statut='c',typ='R',defaut= 9.0,),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_DIFFU  = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           R_GAZ            = SIMP(statut='o',typ='R'),
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           BIOT_COEF        = SIMP(statut='o',typ='R'),
+                                           PESA_X           = SIMP(statut='o',typ='R'),
+                                           PESA_Y           = SIMP(statut='o',typ='R'),
+                                           PESA_Z           = SIMP(statut='o',typ='R'),
+                                           SATU_PRES        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_SATU_PRES      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_LIQU        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_PERM_LIQU_SATU = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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)),
+# ---Van Genhuchten et Muallen-----------------------------------------------------------------------------
+                                           VG_N     = SIMP(statut='f',typ='R'),
+                                           VG_SR    = SIMP(statut='f',typ='R'),
+                                           VG_PR    = SIMP(statut='f',typ='R'),
+                                           VG_SMAX  = SIMP(statut='f',typ='R'),
+                                           VG_SATUR = SIMP(statut='f',typ='R'),
+#
+                                           FICKV_T          = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_T          = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                           PERM_IN          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_END         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_X      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Y      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Z      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_LB_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           LAMB_CT   = SIMP(statut='f',typ='R'),
+#
+                                  regles = (EXCLUS('PERM_IN','PERM_END','PERMIN_X',),
+                                            PRESENT_PRESENT('PERMIN_X','PERMIN_Y','PERMIN_Z',),
+                                            ENSEMBLE('SATU_PRES','D_SATU_PRES','PERM_LIQU','D_PERM_LIQU_SATU',
+                                                            'PERM_GAZ','D_PERM_SATU_GAZ','D_PERM_PRES_GAZ',),
+                                            ENSEMBLE('VG_N','VG_SR','VG_PR','VG_SMAX','VG_SATUR',),
+                                            UN_PARMI('VG_N','SATU_PRES'),
+                                           ),
+# ---------------------------------------------------------------------------------
+# -------------------   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)),
+                                           D_FV_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_PG          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+#
+                                           FICKA_PA         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PL         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ) ,
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_LIQU   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           UN_SUR_K         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           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 ---------------------------------------------------------
+# =================================================================================
+                             THM_GAZ    = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           MASS_MOL         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_VAPE_GAZ = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           MASS_MOL         = SIMP(statut='o',typ='R'),
+                                           CP               = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_AIR_DISS = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='o',typ='R'),
+                                           COEF_HENRY       = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ),
+                                 ),
+# =================================================================================
+# --- LOI DE COUPLAGE DE TYPE LIQU_VAPE -------------------------------------------
+# =================================================================================
+# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : ---------------------------------
+# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_VAPE_GAZ ---------------------------------
+# =================================================================================
+           b_liquvape  = BLOC(condition = "COMP_THM == 'LIQU_VAPE' ",
+                                 fr="Paramètres nécessaires pour une loi de couplage de type LIQU_VAPE",
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_INIT   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRE1             = SIMP(statut='o',typ='R'),
+                                           PORO             = SIMP(statut='o',typ='R'),
+                                           PRES_VAPE        = SIMP(statut='o',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           TEMP             = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES INUTILES   ----------------------------------------
+# ---------------------------------------------------------------------------------
+                                           PRE2             = SIMP(statut='f',typ='R'),
+                                           DEGR_SATU        = SIMP(statut='f',typ='R'),
+                                           PRES_ATMO        = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEE CACHEE ---------------------------------------------
+# ---------------------------------------------------------------------------------
+                                           COMP_THM         = SIMP(statut='c',typ='R',defaut= 3.0,),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_DIFFU  = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           R_GAZ            = SIMP(statut='o',typ='R'),
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           BIOT_COEF        = SIMP(statut='o',typ='R'),
+                                           PESA_X           = SIMP(statut='o',typ='R'),
+                                           PESA_Y           = SIMP(statut='o',typ='R'),
+                                           PESA_Z           = SIMP(statut='o',typ='R'),
+                                           SATU_PRES        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_SATU_PRES      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_LIQU        = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_PERM_LIQU_SATU = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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)),
+# ---Van Genhuchten et Muallen-----------------------------------------------------------------------------
+
+                                           VG_N    = SIMP(statut='f',typ='R'),
+                                           VG_SR    = SIMP(statut='f',typ='R'),
+                                           VG_PR   = SIMP(statut='f',typ='R'),
+                                           VG_SMAX = SIMP(statut='f',typ='R'),
+                                           VG_SATUR = SIMP(statut='f',typ='R'),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           CP               = SIMP(statut='f',typ='R'),
+                                           PERM_IN          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERM_END         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_X      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Y      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           PERMIN_Z      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           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_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_LB_S      = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           LAMB_CT   = SIMP(statut='f',typ='R'),
+#
+                                  regles = (EXCLUS('PERM_IN','PERM_END','PERMIN_X',),
+                                            PRESENT_PRESENT('PERMIN_X','PERMIN_Y','PERMIN_Z',),
+                                            ENSEMBLE('SATU_PRES','D_SATU_PRES','PERM_LIQU','D_PERM_LIQU_SATU',
+                                                            'PERM_GAZ','D_PERM_SATU_GAZ','D_PERM_PRES_GAZ',),
+                                            ENSEMBLE('VG_N','VG_SR','VG_PR','VG_SMAX','VG_SATUR',),
+                                            UN_PARMI('VG_N','SATU_PRES'),
+                                           ),
+# ---------------------------------------------------------------------------------
+# -------------------   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)),
+                                           FICKV_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FV_PG          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_T          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PA         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_PL         = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           FICKA_S          = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_FA_T           = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ) ,
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_LIQU   = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           RHO              = SIMP(statut='o',typ='R'),
+                                           UN_SUR_K         = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES NECESSAIRE SI THERMIQUE   -------------------------
+# ---------------------------------------------------------------------------------
+                                           ALPHA            = SIMP(statut='f',typ='R'),
+                                           CP               = SIMP(statut='f',typ='R'),
+                                             ),
+# =================================================================================
+# --- MOT-CLE OBLIGATOIRE ---------------------------------------------------------
+# =================================================================================
+                             THM_VAPE_GAZ = FACT(statut='o',
+# ---------------------------------------------------------------------------------
+# -------------------   DONNEES OBLIGATOIRE   -------------------------------------
+# ---------------------------------------------------------------------------------
+                                           MASS_MOL         = SIMP(statut='o',typ='R'),
+                                           CP               = SIMP(statut='o',typ='R'),
+                                           VISC             = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                           D_VISC_TEMP      = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                             ),
+# =================================================================================
+# --- MOT-CLE INUTILE -------------------------------------------------------------
+# =================================================================================
+           THM_GAZ         =FACT(statut='f',
+             MASS_MOL        =SIMP(statut='f',typ='R'),
+             CP              =SIMP(statut='f',typ='R'),
+             VISC            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_VISC_TEMP     =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+                                 ),
+# courbes et coefficients associés à la fatigue et au dommage
+#
+           FATIGUE         =FACT(statut='f',
+             regles=(PRESENT_ABSENT('WOHLER','A_BASQUIN','BETA_BASQUIN'),
+                     PRESENT_ABSENT('WOHLER','A0','A1','A2','A3','SL'),
+                     PRESENT_ABSENT('A_BASQUIN','A0','A1','A2','A3','SL'),
+                     ENSEMBLE('A_BASQUIN','BETA_BASQUIN'),
+                     ENSEMBLE('A0','A1','A2','A3','SL'),
+                     PRESENT_PRESENT('A0','E_REFE'),
+                     ENSEMBLE('D0','TAU0'),),
+             WOHLER          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_BASQUIN       =SIMP(statut='f',typ='R'),
+             BETA_BASQUIN    =SIMP(statut='f',typ='R'),
+             A0              =SIMP(statut='f',typ='R'),
+             A1              =SIMP(statut='f',typ='R'),
+             A2              =SIMP(statut='f',typ='R'),
+             A3              =SIMP(statut='f',typ='R'),
+             SL              =SIMP(statut='f',typ='R'),
+             MANSON_COFFIN   =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             E_REFE          =SIMP(statut='f',typ='R'),
+             D0              =SIMP(statut='f',typ='R'),
+             TAU0            =SIMP(statut='f',typ='R'),
+           ),
+           DOMMA_LEMAITRE  =FACT(statut='f',
+             S               =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             EPSP_SEUIL      =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             EXP_S           =SIMP(statut='f',typ='R',val_min=0.0E0,defaut=1.0),
+           ),
+           CISA_PLAN_CRIT  =FACT(statut='f',
+             CRITERE       =SIMP(statut='o',typ='TXM',into=("MATAKE_MODI_AC",
+                                                            "DANG_VAN_MODI_AC",
+                                                            "DANG_VAN_MODI_AV",
+                                                            "MATAKE_MODI_AV",
+                                                            "FATESOCI_MODI_AV",
+                                                            ) ),
+
+             b_critere_matake =BLOC(condition="CRITERE=='MATAKE_MODI_AC' or CRITERE=='MATAKE_MODI_AV'",
+                         fr="Cisaillement plan critique critère de matake pour les cas amplitude constante et amplitude variable",
+               MATAKE_A         =SIMP(statut='o',typ='R'),
+               MATAKE_B         =SIMP(statut='o',typ='R'),
+               COEF_FLEX_TORS   =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
+             ),
+
+             b_critere_dang_van =BLOC(condition="(CRITERE=='DANG_VAN_MODI_AC' or CRITERE=='DANG_VAN_MODI_AV')",
+                                 fr="Critère de Dang Van modifié pour les cas amplitude constante et amplitude variable",
+               D_VAN_A            =SIMP(statut='o',typ='R'),
+               D_VAN_B            =SIMP(statut='o',typ='R'),
+               COEF_CISA_TRAC     =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
+             ),
+
+             b_critere_fate_soci =BLOC(condition="CRITERE=='FATESOCI_MODI_AV'",
+                               fr="Critère de Fatemi et Socie, en élasticité ou élastoplasticité, pour le cas amplitude variable",
+               FATSOC_A           =SIMP(statut='o',typ='R'),
+               COEF_CISA_TRAC     =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
+             ),
+           ),
+#
+# autres comportements ...
+#
+           WEIBULL         =FACT(statut='f',
+             M               =SIMP(statut='o',typ='R'),
+             VOLU_REFE       =SIMP(statut='o',typ='R'),
+             SIGM_REFE       =SIMP(statut='o',typ='R'),
+             SEUIL_EPSP_CUMU =SIMP(statut='f',typ='R',defaut= 1.0E-6),
+           ),
+           WEIBULL_FO      =FACT(statut='f',
+             M               =SIMP(statut='o',typ='R'),
+             VOLU_REFE       =SIMP(statut='o',typ='R'),
+             SIGM_CNV        =SIMP(statut='o',typ='R'),
+             SIGM_REFE       =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SEUIL_EPSP_CUMU =SIMP(statut='f',typ='R',defaut= 1.0E-6),
+           ),
+           NON_LOCAL       =FACT(statut='f',
+             regles=(AU_MOINS_UN('LONG_CARA','C_GONF','PENA_LAGR',),),
+             LONG_CARA       =SIMP(statut='f',typ='R'),
+             PENA_LAGR       =SIMP(statut='f',typ='R',defaut= 1.0E3),
+             C_GONF          =SIMP(statut='f',typ='R'),
+             COEF_RIGI_MINI  =SIMP(statut='f',typ='R'),
+           ),
+           RUPT_FRAG       =FACT(statut='f',
+             GC              =SIMP(statut='o',typ='R'),
+             SIGM_C          =SIMP(statut='f',typ='R'),
+             PENA_ADHERENCE  =SIMP(statut='f',typ='R',val_min=1.E-12,val_max=1.E+0),
+             PENA_CONTACT    =SIMP(statut='f',typ='R',defaut=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),
+           ),
+           RUPT_FRAG_FO   =FACT(statut='f',
+             GC              =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SIGM_C          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PENA_ADHERENCE  =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             PENA_CONTACT    =SIMP(statut='f',typ='R',defaut=1.),
+           ),
+           RCCM            =FACT(statut='f',
+             regles=(ENSEMBLE('A_AMORC','B_AMORC','D_AMORC','R_AMORC'),),
+             SY_02           =SIMP(statut='f',typ='R'),
+             SM              =SIMP(statut='f',typ='R'),
+             SU              =SIMP(statut='f',typ='R'),
+             SC              =SIMP(statut='f',typ='R'),
+             SH              =SIMP(statut='f',typ='R'),
+             N_KE            =SIMP(statut='f',typ='R'),
+             M_KE            =SIMP(statut='f',typ='R'),
+             A_AMORC         =SIMP(statut='f',typ='R'),
+             B_AMORC         =SIMP(statut='f',typ='R'),
+             D_AMORC         =SIMP(statut='f',typ='R'),
+             R_AMORC         =SIMP(statut='f',typ='R'),
+           ),
+           RCCM_FO         =FACT(statut='f',
+             regles=(ENSEMBLE('A_AMORC','B_AMORC','D_AMORC','R_AMORC'),),
+             SY_02           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SM              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             SU              =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             S               =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             N_KE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             M_KE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             A_AMORC         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             B_AMORC         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             D_AMORC         =SIMP(statut='f',typ='R'),
+             R_AMORC         =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           ),
+           LAIGLE          =FACT(statut='f',
+             GAMMA_ULT       =SIMP(statut='o',typ='R'),
+             GAMMA_E         =SIMP(statut='o',typ='R'),
+             M_ULT           =SIMP(statut='o',typ='R'),
+             M_E             =SIMP(statut='o',typ='R'),
+             A_E             =SIMP(statut='o',typ='R'),
+             M_PIC           =SIMP(statut='o',typ='R'),
+             A_PIC           =SIMP(statut='o',typ='R'),
+             ETA             =SIMP(statut='o',typ='R'),
+             SIGMA_C         =SIMP(statut='o',typ='R'),
+             GAMMA           =SIMP(statut='o',typ='R'),
+             KSI             =SIMP(statut='o',typ='R'),
+             GAMMA_CJS       =SIMP(statut='o',typ='R'),
+             SIGMA_P1        =SIMP(statut='o',typ='R'),
+             PA              =SIMP(statut='o',typ='R'),
+           ),
+           LETK          =FACT(statut='f',
+             PA         =SIMP(statut='o',typ='R',fr="pression atmospherique"),
+             NELAS      =SIMP(statut='o',typ='R',fr="exposant de la loi de variation des modules K et G"),
+             SIGMA_C    =SIMP(statut='o',typ='R',fr="résistance en compression simple "),
+             H0_EXT     =SIMP(statut='o',typ='R',fr="parametre pilotant la résistance en extension"),
+             GAMMA_CJS  =SIMP(statut='o',typ='R',fr="parametre de forme du critere ds le plan déviatoire entre 0 et 1."),
+             XAMS       =SIMP(statut='o',typ='R',fr="parametre non nul intervenant dans les lois d'écrouissage pre pic"),
+             ETA        =SIMP(statut='o',typ='R',fr="parametre non nul intervenant dans les lois d'écrouissage post pic"),
+             A_0        =SIMP(statut='o',typ='R',fr="a de la limite d'élasticité initiale"),
+             A_E        =SIMP(statut='o',typ='R',fr="a de la limite de clivage ou seuil intermédiaire"),
+             A_PIC      =SIMP(statut='o',typ='R',fr="a du seuil de pic"),
+             S_0        =SIMP(statut='o',typ='R',fr="s de la limite d'élasticité initiale"),
+             M_0        =SIMP(statut='o',typ='R',fr="m de la limite d'élasticité initiale"),
+             M_E        =SIMP(statut='o',typ='R',fr="m de la limite de clivage ou seuil intermédiaire"),
+             M_PIC      =SIMP(statut='o',typ='R',fr="m du seuil de pic"),
+             M_ULT      =SIMP(statut='o',typ='R',fr="m du seuil residuel"),
+             XI_ULT     =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil résiduel"),
+             XI_E       =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil de clivage"),
+             XI_PIC     =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil de pic"),
+             MV_MAX     =SIMP(statut='o',typ='R',fr="m du seuil viscoplastique maximal"),
+             XIV_MAX    =SIMP(statut='o',typ='R',fr="niveau d écrouissage pour atteindre le seuil viscoplastique maximal"),
+             A          =SIMP(statut='o',typ='R',fr="parametre carcaterisant l amplitude de la vitesse de fluage"),
+             N          =SIMP(statut='o',typ='R',fr="parametre intervenant dans la formule pilotant la cinetique de fluage"),
+             SIGMA_P1   =SIMP(statut='o',typ='R',fr="SIG min de l intersection du seuil de pic et intermediaire "),
+             MU0_V      =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance des mecanismes pre pic et viscoplastique"),
+             XI0_V      =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance des mecanismes pre pic et viscoplastique"),
+             MU1        =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance du mecanisme post pic "),
+             XI1        =SIMP(statut='o',typ='R',fr="relatif à l angle de dilatance du mecanisme post pic "),
+           ),
+           DRUCK_PRAGER  =FACT(statut='f',
+             ALPHA           =SIMP(statut='o',typ='R'),
+             SY              =SIMP(statut='o',typ='R'),
+             P_ULTM          =SIMP(statut='o',typ='R'),
+             ECROUISSAGE = SIMP(statut='o',typ='TXM',into=("LINEAIRE","PARABOLIQUE")),
+             b_lineaire =BLOC(condition="ECROUISSAGE=='LINEAIRE'",
+                                    fr="Loi de comportement de type Drucker Prager avec un ecrouissage lineaire",
+                    H               =SIMP(statut='o',typ='R'),
+                    TYPE_DP         =SIMP(statut='c',typ='R',defaut= 1.0,),
+             ),
+             b_parabolique =BLOC(condition="ECROUISSAGE=='PARABOLIQUE'",
+                                    fr="Loi de comportement de type Drucker Prager avec un ecrouissage parabolique",
+                    SY_ULTM         =SIMP(statut='o',typ='R'),
+                    TYPE_DP         =SIMP(statut='c',typ='R',defaut= 2.0,),
+             ),
+             DILAT           =SIMP(statut='f',typ='R',defaut=0.0),
+           ),
+           VISC_DRUC_PRAG          =FACT(statut='f',
+             PREF       =SIMP(statut='o',typ='R',fr="pression de reference"),
+             A          =SIMP(statut='o',typ='R',fr="parametre carcaterisant l amplitude de la vitesse de fluage"),
+             N          =SIMP(statut='o',typ='R',fr="parametre intervenant dans la formule pilotant la cinetique de fluage"),
+             P_PIC      =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil de pic"),
+             P_ULT      =SIMP(statut='o',typ='R',fr="niveau d ecrouissage pour atteindre le seuil utime"),
+             ALPHA_0    =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la cohesion au seuil d elasticite"),
+             ALPHA_PIC  =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la cohesion au seuil de pic"),
+             ALPHA_ULT  =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la cohesion au seuil ultime"),
+             R_0        =SIMP(statut='o',typ='R',fr="parametre d ecrouissage correspondant au seuil d'elasticite"),
+             R_PIC      =SIMP(statut='o',typ='R',fr="parametre d ecrouissage correspondant au seuil de pic"),
+             R_ULT      =SIMP(statut='o',typ='R',fr="parametre d ecrouissage correspondant au seuil ultime"),
+             BETA_0     =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la dilatance au seuil d elasticite"),
+             BETA_PIC   =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la dilatance au seuil de pic"),
+             BETA_ULT   =SIMP(statut='o',typ='R',fr="parametre d ecrouissage relatif à la dilatance au seuil ultime"),          
+           ),
+             HOEK_BROWN          =FACT(statut='f',
+             GAMMA_RUP       =SIMP(statut='o',typ='R'),
+             GAMMA_RES       =SIMP(statut='o',typ='R'),
+             S_END           =SIMP(statut='o',typ='R'),
+             S_RUP           =SIMP(statut='o',typ='R'),
+             M_END           =SIMP(statut='o',typ='R'),
+             M_RUP           =SIMP(statut='o',typ='R'),
+             BETA            =SIMP(statut='o',typ='R'),
+             ALPHAHB         =SIMP(statut='o',typ='R'),
+             PHI_RUP         =SIMP(statut='o',typ='R'),
+             PHI_RES         =SIMP(statut='o',typ='R'),
+             PHI_END         =SIMP(statut='f',typ='R'),
+           ),
+             ELAS_GONF             =FACT(statut='f',
+             BETAM           =SIMP(statut='o',typ='R'),
+             PREF            =SIMP(statut='o',typ='R'),
+           ),
+####  MONOCRISTAL
+
+           ECOU_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',
+             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'),
+             D               =SIMP(statut='o',typ='R'),
+             A               =SIMP(statut='o',typ='R'),
+           ),
+           ECOU_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"),
+             GAMMA0          =SIMP(statut='o',typ='R',fr="Vitesse d ecoulement initiale"),
+             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',
+              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=("ECRO_ISOT",),),
+             R_0             =SIMP(statut='o',typ='R'),
+             Q               =SIMP(statut='o',typ='R'),
+             B               =SIMP(statut='o',typ='R'),
+             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_ISOT2      =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=("ECRO_ISOT",),),
+             R_0             =SIMP(statut='o',typ='R'),
+             Q1              =SIMP(statut='o',typ='R'),
+             B1              =SIMP(statut='o',typ='R'),
+             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'),
+             Q2              =SIMP(statut='o',typ='R'),
+             B2              =SIMP(statut='o',typ='R'),
+           ),
+           ECRO_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',
+             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'),
+           ),
+
+####  MONOCRISTAL
+
+           DRUCK_PRAGER_FO  =FACT(statut='f',
+             ALPHA           =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+             SY              =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+             P_ULTM          =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+             ECROUISSAGE = SIMP(statut='o',typ='TXM',into=("LINEAIRE","PARABOLIQUE")),
+             b_lineaire =BLOC(condition="ECROUISSAGE=='LINEAIRE'",
+                                    fr="Loi de comportement de type Drucker Prager avec un ecrouissage lineaire",
+                    H               =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+                    TYPE_DP         =SIMP(statut='c',typ='R',defaut= 1.0,),
+             ),
+             b_parabolique =BLOC(condition="ECROUISSAGE=='PARABOLIQUE'",
+                                    fr="Loi de comportement de type Drucker Prager avec un ecrouissage parabolique",
+                    SY_ULTM         =SIMP(statut='o',typ=(fonction_sdaster,formule)),
+                    TYPE_DP         =SIMP(statut='c',typ='R',defaut= 2.0,),
+             ),
+            DILAT           =SIMP(statut='f',typ='R',defaut=0.0),
+           ),
+
+
+           INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE BODEL C.BODEL
+DEFI_MODELE_GENE=OPER(nom="DEFI_MODELE_GENE",op= 126,sd_prod=modele_gene,
+                      reentrant='n',
+            fr="Créer la structure globale à partir des sous-structures en sous-structuration dynamique", 
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         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='f',max='**',
+#  dans la doc U stop_erreur est obligatoire         
+           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") ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op=4,sd_prod=nappe_sdaster,
+                fr="Définir une fonction réelle de deux variables réelles",
+                reentrant='n',UIinfo={"groupes":("Fonction",)},
+         regles=(UN_PARMI('FONCTION','DEFI_FONCTION'),
+                 EXCLUS('FONCTION','NOM_PARA_FONC',),
+                 ENSEMBLE('NOM_PARA_FONC','DEFI_FONCTION'),),
+         NOM_PARA        =SIMP(statut='o',typ='TXM',into=C_PARA_FONCTION() ),
+         NOM_RESU        =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"),       
+         PARA            =SIMP(statut='o',typ='R',max='**'),
+         FONCTION        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**' ),
+         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") ),
+           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") ),
+         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) ),
+         VERIF           =SIMP(statut='f',typ='TXM',into=("CROISSANT",) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE KHAM M.KHAM
+DEFI_OBSTACLE=OPER(nom="DEFI_OBSTACLE",op=  73,sd_prod=table_fonction,
+                   fr="Définition d'un obstacle plan perpendiculaire à une structure filaire",
+                   reentrant='n',
+         UIinfo={"groupes":("Modélisation",)},
+         TYPE            =SIMP(statut='o',typ='TXM',defaut="CERCLE",
+                             into=("CERCLE","PLAN_Y","PLAN_Z","DISCRET",
+                             "BI_CERCLE","BI_PLAN_Y","BI_PLAN_Z","BI_CERC_INT",
+                             "CRAYON_900","CRAYON_1300","GUID_A_CARTE_900",
+                             "GUID_B_CARTE_900","GUID_C_CARTE_900",
+                             "GUID_D_CARTE_900","GUID_E_CARTE_900",
+                             "GUID_F_CARTE_900","GUID_A_CARTE_1300",
+                             "GUID_B_CARTE_1300","GUID_C_CARTE_1300",
+                             "GUID_D_CARTE_1300","GUID_E_CARTE_1300",
+                             "GUID_F_CARTE_1300","GUID_A_CARSP_900",
+                             "GUID_B_CARSP_900","GUID_C_CARSP_900",
+                             "GUID_D_CARSP_900","GUID_E_CARSP_900",
+                             "GUID_F_CARSP_900","GUID_A_CARSP_1300",
+                             "GUID_B_CARSP_1300","GUID_C_CARSP_1300",
+                             "GUID_D_CARSP_1300","GUID_E_CARSP_1300",
+                             "GUID_F_CARSP_1300","GUID_A_GCONT_900",
+                             "GUID_B_GCONT_900","GUID_C_GCONT_900",
+                             "GUID_D_GCONT_900","GUID_E_GCONT_900",
+                             "GUID_F_GCONT_900","GUID_A_GCONT_1300",
+                             "GUID_B_GCONT_1300","GUID_C_GCONT_1300",
+                             "GUID_D_GCONT_1300","GUID_E_GCONT_1300",
+                             "GUID_F_GCONT_1300","GUID_A_GCOMB_900",
+                             "GUID_B_GCOMB_900","GUID_C_GCOMB_900",
+                             "GUID_D_GCOMB_900","GUID_E_GCOMB_900",
+                             "GUID_F_GCOMB_900","GUID_A_GCOMB_1300",
+                             "GUID_B_GCOMB_1300","GUID_C_GCOMB_1300",
+                             "GUID_D_GCOMB_1300","GUID_E_GCOMB_1300",
+                             "GUID_F_GCOMB_1300",) ),
+         VALE            =SIMP(statut='f',typ='R',max='**'),
+         VERIF           =SIMP(statut='f',typ='TXM',defaut="FERME"),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+DEFI_PARA_SENSI=OPER(nom="DEFI_PARA_SENSI",op=   2,sd_prod=para_sensi,
+                    fr="Définition d'un paramètre de sensibilité",
+                    ang="Definition of a sensitive parameter",
+                    reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         NOM_RESU        =SIMP(statut='c',typ='TXM',into=("TOUTRESU",),defaut="TOUTRESU",
+                               fr="Nom du concept créé",
+                               ang="Name of the concept"),
+         VALE            =SIMP(statut='o',typ='R',
+                               fr="Valeur du parametre",
+                               ang="Value of the parameter"),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 16/11/2009   AUTEUR ASSIRE A.ASSIRE 
+#            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
+
+from Macro.defi_part_feti_ops import defi_part_feti_ops
+
+DEFI_PART_FETI=MACRO(nom="DEFI_PART_FETI",op=defi_part_feti_ops,sd_prod=sd_feti_sdaster,
+                     reentrant='n',UIinfo={"groupe":("Maillage",)},
+                     fr="Creation partitionnement en sous-domaines pour FETI",
+         regles=(UN_PARMI('MAILLAGE','MODELE'),PRESENT_PRESENT('MODELE','EXCIT'),),
+
+         NB_PART         =SIMP(statut='o',typ='I',val_min=2),
+         MAILLAGE        =SIMP(statut='f',typ=maillage_sdaster),
+         MODELE          =SIMP(statut='f',typ=modele_sdaster),
+         EXCIT           =FACT(statut='f',max='**',
+           CHARGE          =SIMP(statut='f',typ=(char_meca,char_cine_meca)),),
+
+         # Methode de partitionnement
+         METHODE         =SIMP(statut='f',typ='TXM',into=("PMETIS","SCOTCH","KMETIS",), defaut="SCOTCH" ),
+         
+         LOGICIEL      =SIMP(statut='f',typ='TXM'),
+
+         # Corrige les problemes possibles de non-connexite des sous-domaines
+         CORRECTION_CONNEX    =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')),
+
+         # Permet de grouper des mailles dans un meme sous-doamine
+         GROUPAGE        =FACT(statut='f',max='**',
+           GROUP_MA       =SIMP(statut='o',typ=grma,),
+                          ),
+         # Permet d'appliquer des poids sur certaines mailles
+         POIDS_MAILLES   =FACT(statut='f',max='**',
+           GROUP_MA       =SIMP(statut='o',typ=grma,),
+           POIDS          =SIMP(statut='f',typ='I',val_min=2),
+                          ),
+         # Prefixe pour le nom des group_ma definissant les sous-domaines 
+         NOM_GROUP_MA    =SIMP(statut='f',typ='TXM',defaut='SD' ),
+
+         # Traiter les mailles de bords (elles sont enlevees du graphe puis reinjectees)
+         TRAITER_BORDS   =SIMP(statut='f',typ='TXM',defaut='OUI',into=('OUI','NON') ),
+         
+         # Si le mot-clé suivant est renseigné, crée de nouveau group_ma a partir des bords
+         # Note : le calcul FETI sera impossible
+         b_traiter_bords =BLOC(condition="TRAITER_BORDS == 'OUI'", fr="Crée t on des nouveaux group_ma",
+           NOM_GROUP_MA_BORD  =SIMP(statut='f',typ='TXM'),
+             ),
+
+         INFO            =SIMP(statut='f',typ='I',into=(1, 2), defaut=1),
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+
+DEFI_PART_OPS=OPER(nom="DEFI_PART_OPS",op=21,sd_prod=sd_feti_sdaster,
+                    fr="Creation partitionnement en sous-domaines pour FETI",
+                    docu="U4.23.05",reentrant='n',
+                    UIinfo={"groupes":("Résolution",)},
+         MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+         MAILLAGE        =SIMP(statut='f',typ=(maillage_sdaster) ),
+         NOM             =SIMP(statut='f',typ='TXM',defaut='SD'),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2,3,4) ),
+         DEFI          =FACT(statut='f',max='**',
+           GROUP_MA        =SIMP(statut='o',typ=grma),
+           GROUP_MA_BORD   =SIMP(statut='f',typ=grma),
+         ),
+         EXCIT           =FACT(statut='f',max='**',
+           CHARGE          =SIMP(statut='f',typ=(char_meca,char_cine_meca)),
+         ),
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 ASSIRE A.ASSIRE
+
+DEFI_PART_PA_OPS=PROC(nom="DEFI_PART_PA_OPS",op=29,
+                    fr="Creation partitionnement en sous-domaines pour FETI",
+                    docu="U4.00.00",
+                    UIinfo={"groupes":("Résolution",)},
+         MAILLAGE        =SIMP(statut='o',typ=(maillage_sdaster,squelette) ),
+         MODELE          =SIMP(statut='f',typ=(modele_sdaster)),
+         NB_PART         =SIMP(statut='o',typ='I',),
+
+         # Methode de partitionnement
+         METHODE         =SIMP(statut='f',typ='TXM',into=("PMETIS","SCOTCH","KMETIS",), defaut="SCOTCH" ),
+         
+         LOGICIEL      =SIMP(statut='f',typ='TXM'),
+
+         # Corrige les problemes possibles de non-connexite des sous-domaines
+         CORRECTION_CONNEX    =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')),
+
+         # Permet de grouper des mailles dans un meme sous-doamine
+         GROUPAGE        =FACT(statut='f',max='**',
+           GROUP_MA       =SIMP(statut='o',typ=grma,),
+                          ),
+         # Permet d'appliquer des poids sur certaines mailles
+         POIDS_MAILLES   =FACT(statut='f',max='**',
+           GROUP_MA       =SIMP(statut='o',typ=grma,),
+           POIDS          =SIMP(statut='f',typ='I'),
+                          ),
+         # Prefixe pour le nom des group_ma definissant les sous-domaines 
+         NOM_GROUP_MA    =SIMP(statut='f',typ='TXM',defaut='SD' ),
+
+         # Traiter les mailles de bords (elles sont enlevees du graphe puis reinjectees)
+         TRAITER_BORDS   =SIMP(statut='f',typ='TXM',defaut='OUI',into=('OUI','NON') ),
+
+         # Si le mot-clé suivant est renseigné, crée de nouveau group_ma a partir des bords
+         # Note : le calcul FETI sera impossible
+         b_traiter_bords =BLOC(condition="TRAITER_BORDS == 'OUI'", fr="Crée t on des nouveaux group_ma",
+           NOM_GROUP_MA_BORD  =SIMP(statut='f',typ='TXM'),
+             ),
+
+         INFO            =SIMP(statut='f',typ='I',into=(1, 2), defaut=1),
+
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ADOBES A.ADOBES
+DEFI_SPEC_TURB=OPER(nom="DEFI_SPEC_TURB",op= 145,sd_prod=spectre_sdaster,
+                    fr="Définition d'un spectre d'excitation turbulente",
+                    reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+         regles=(UN_PARMI('SPEC_LONG_COR_1','SPEC_LONG_COR_2','SPEC_LONG_COR_3',
+                          'SPEC_LONG_COR_4','SPEC_CORR_CONV_1','SPEC_CORR_CONV_2',
+                          'SPEC_FONC_FORME','SPEC_EXCI_POINT'),),
+         SPEC_LONG_COR_1 =FACT(statut='f',
+           LONG_COR        =SIMP(statut='o',typ='R' ),
+           PROF_VITE_FLUI  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           VISC_CINE       =SIMP(statut='o',typ='R' ),
+         ),
+         SPEC_LONG_COR_2 =FACT(statut='f',
+           regles=(ENSEMBLE('FREQ_COUP','PHI0','BETA' ),),
+           LONG_COR        =SIMP(statut='o',typ='R' ),
+           PROF_VITE_FLUI  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FREQ_COUP       =SIMP(statut='f',typ='R',defaut= 0.1 ),
+           PHI0            =SIMP(statut='f',typ='R',defaut= 1.5E-3 ),
+           BETA            =SIMP(statut='f',typ='R',defaut= 2.7 ),
+         ),
+         SPEC_LONG_COR_3 =FACT(statut='f',
+           regles=(ENSEMBLE('PHI0_1','BETA_1','PHI0_2','BETA_2','FREQ_COUP'),),
+           LONG_COR        =SIMP(statut='o',typ='R' ),
+           PROF_VITE_FLUI  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           FREQ_COUP       =SIMP(statut='f',typ='R',defaut= 0.2 ),
+           PHI0_1          =SIMP(statut='f',typ='R',defaut= 5.E-3 ),
+           BETA_1          =SIMP(statut='f',typ='R',defaut= 0.5 ),
+           PHI0_2          =SIMP(statut='f',typ='R',defaut= 4.E-5 ),
+           BETA_2          =SIMP(statut='f',typ='R',defaut= 3.5 ),
+         ),
+         SPEC_LONG_COR_4 =FACT(statut='f',
+           regles=(ENSEMBLE('BETA','GAMMA'),),
+           LONG_COR        =SIMP(statut='o',typ='R' ),
+           PROF_VITE_FLUI  =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TAUX_VIDE       =SIMP(statut='o',typ='R' ),
+           BETA            =SIMP(statut='f',typ='R',defaut= 2. ),
+           GAMMA           =SIMP(statut='f',typ='R',defaut= 4. ),
+         ),
+         SPEC_CORR_CONV_1=FACT(statut='f',
+           LONG_COR_1      =SIMP(statut='o',typ='R' ),
+           LONG_COR_2      =SIMP(statut='f',typ='R' ),
+           VITE_FLUI       =SIMP(statut='o',typ='R' ),
+           RHO_FLUI        =SIMP(statut='o',typ='R' ),
+           FREQ_COUP       =SIMP(statut='f',typ='R' ),
+           K               =SIMP(statut='f',typ='R',defaut= 5.8E-3 ),
+           D_FLUI          =SIMP(statut='o',typ='R' ),
+           COEF_VITE_FLUI_A=SIMP(statut='f',typ='R' ),
+           COEF_VITE_FLUI_O=SIMP(statut='f',typ='R' ),
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="GENERALE",
+                                 into=("AU_YANG","GENERALE","CORCOS") ),
+         ),
+         SPEC_CORR_CONV_2=FACT(statut='f',
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           VITE_FLUI       =SIMP(statut='o',typ='R' ),
+           FREQ_COUP       =SIMP(statut='f',typ='R' ),
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="GENERALE",
+                                 into=("AU_YANG","GENERALE","CORCOS",) ),
+           COEF_VITE_FLUI_A=SIMP(statut='f',typ='R' ),
+           COEF_VITE_FLUI_O=SIMP(statut='f',typ='R' ),
+         ),
+         SPEC_FONC_FORME =FACT(statut='f',
+           regles=(UN_PARMI('INTE_SPEC','GRAPPE_1'),
+                   ENSEMBLE('INTE_SPEC','FONCTION'),),
+           INTE_SPEC       =SIMP(statut='f',typ=table_fonction),
+           FONCTION        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
+           GRAPPE_1        =SIMP(statut='f',typ='TXM',into=("DEBIT_180","DEBIT_300",) ),
+           NOEUD           =SIMP(statut='o',typ=no),
+           CARA_ELEM       =SIMP(statut='o',typ=cara_elem ),
+           MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         ),
+         SPEC_EXCI_POINT =FACT(statut='f',
+           regles=(UN_PARMI('INTE_SPEC','GRAPPE_2'),),
+           INTE_SPEC       =SIMP(statut='f',typ=table_fonction),
+           GRAPPE_2        =SIMP(statut='f',typ='TXM',
+                                 into=("ASC_CEN","ASC_EXC","DES_CEN","DES_EXC",) ),
+#  Quels sont les statuts des mots cles à l interieur des deux blocs qui suivent
+           b_inte_spec =BLOC(condition = "INTE_SPEC != None",
+             NATURE          =SIMP(statut='o',typ='TXM',max='**',into=("FORCE","MOMENT",) ),
+             ANGL            =SIMP(statut='o',typ='R',max='**'),
+             NOEUD           =SIMP(statut='o',typ=no,max='**'),
+           ),
+           b_grappe_2      =BLOC(condition = "GRAPPE_2 != None",
+             RHO_FLUI        =SIMP(statut='o',typ='R' ),
+             NOEUD           =SIMP(statut='o',typ=no),
+           ),
+           CARA_ELEM       =SIMP(statut='o',typ=cara_elem ),
+           MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE BODEL C.BODEL
+DEFI_SQUELETTE=OPER(nom="DEFI_SQUELETTE",op= 110,sd_prod=squelette,
+                    fr="Définit un maillage pour visualiser les résultats d'une sous-structuration dynamique",
+                    reentrant='n',
+            UIinfo={"groupes":("Maillage",)},
+         regles=(UN_PARMI('CYCLIQUE','MODELE_GENE','MAILLAGE'),
+                 PRESENT_PRESENT('CYCLIQUE','SECTEUR'),
+                 EXCLUS('SOUS_STRUC','SECTEUR'),
+                 PRESENT_PRESENT('NOM_GROUP_MA','MODELE_GENE'),
+                 PRESENT_PRESENT('NOM_GROUP_MA','SOUS_STRUC'),),
+         CYCLIQUE    =FACT(statut='f',max='**',
+           regles=(UN_PARMI('MODE_CYCL','MAILLAGE'),
+                   PRESENT_PRESENT('NB_SECTEUR','MAILLAGE'),),
+           MODE_CYCL       =SIMP(statut='f',typ=mode_cycl ),
+           NB_SECTEUR      =SIMP(statut='f',typ='I',validators=NoRepeat(),max=1 ),
+           MAILLAGE        =SIMP(statut='f',typ=maillage_sdaster ),
+         ),
+         MODELE_GENE     =SIMP(statut='f',typ=modele_gene ),
+         SQUELETTE       =SIMP(statut='f',typ=squelette ),
+         RECO_GLOBAL     =FACT(statut='f',max='**',
+           regles=(EXCLUS('TOUT','GROUP_NO_1'),
+                   PRESENT_PRESENT('GROUP_NO_1','GROUP_NO_2'),
+                   PRESENT_PRESENT('GROUP_NO_1','SOUS_STRUC_1'),
+                   PRESENT_PRESENT('GROUP_NO_2','SOUS_STRUC_2'),
+                   PRESENT_PRESENT('SOUS_STRUC_1','SOUS_STRUC_2'),),
+           TOUT            =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI",) ),
+           GROUP_NO_1      =SIMP(statut='f',typ=grno),
+           SOUS_STRUC_1    =SIMP(statut='f',typ='TXM' ),
+           GROUP_NO_2      =SIMP(statut='f',typ=grno),
+           SOUS_STRUC_2    =SIMP(statut='f',typ='TXM' ),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           DIST_REFE       =SIMP(statut='f',typ='R' ),
+         ),
+         NOM_GROUP_MA    =FACT(statut='f',max='**',
+           NOM             =SIMP(statut='o',typ='TXM' ),
+           SOUS_STRUC      =SIMP(statut='o',typ='TXM' ),
+           GROUP_MA        =SIMP(statut='o',typ=grma),
+         ),
+         EXCLUSIF        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         MAILLAGE        =SIMP(statut='f',typ=maillage_sdaster ),
+         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",) ),
+         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' ),
+           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",) ),
+         ),
+         SECTEUR         =FACT(statut='f',max='**',
+           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",) ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE CANO V.CANO
+DEFI_TRC=OPER(nom="DEFI_TRC",op=94,sd_prod=table_sdaster,reentrant='n',
+            UIinfo={"groupes":("Modélisation",)},
+              fr="Définir d'un diagramme de transformations en refroidissement continu (TRC) de référence d'un acier"
+                +" pour les calculs métallurgiques.",
+         HIST_EXP        =FACT(statut='o',max='**',
+           VALE            =SIMP(statut='o',typ='R',max='**'),
+         ),
+         TEMP_MS         =FACT(statut='o',max='**',
+           SEUIL           =SIMP(statut='o',typ='R'),
+           AKM             =SIMP(statut='o',typ='R'),
+           BKM             =SIMP(statut='o',typ='R'),
+           TPLM            =SIMP(statut='o',typ='R'),
+         ),
+         GRAIN_AUST      =FACT(statut='f',max='**',
+           DREF           =SIMP(statut='f',typ='R'),
+           A              =SIMP(statut='f',typ='R'),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def depl_interne_prod(DEPL_GLOBAL,**args ):
+    if AsType(DEPL_GLOBAL)     == cham_no_sdaster: return cham_no_sdaster
+    if AsType(DEPL_GLOBAL)     == evol_elas      : return evol_elas
+    if AsType(DEPL_GLOBAL)     == dyna_trans     : return dyna_trans
+    if AsType(DEPL_GLOBAL)     == dyna_harmo     : return dyna_harmo
+    if AsType(DEPL_GLOBAL)     == mode_meca      : return mode_meca
+    if AsType(DEPL_GLOBAL)     == mode_meca_c    : return mode_meca_c
+    raise AsException("type de concept resultat non prevu")
+
+DEPL_INTERNE=OPER(nom="DEPL_INTERNE",op=89,sd_prod=depl_interne_prod,reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+                  fr="Calculer le champ de déplacement à l'intérieur d'une sous-structure statique",
+         DEPL_GLOBAL     =SIMP(statut='o',typ=(cham_no_sdaster,mode_meca,mode_meca_c,evol_elas,dyna_trans,dyna_harmo),),
+         SUPER_MAILLE    =SIMP(statut='o',typ=ma,),
+         NOM_CAS         =SIMP(statut='f',typ='TXM',defaut=" "),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+DETRUIRE=MACRO(nom="DETRUIRE",op=-7,
+            UIinfo={"groupes":("Gestion du travail",)},
+              fr="Détruit des concepts utilisateurs dans la base GLOBALE ou des objets JEVEUX",
+             op_init=ops.detruire,
+             regles=(UN_PARMI('CONCEPT','OBJET',),),
+            CONCEPT     =FACT(statut='f',max='**',
+                regles=(DERIVABLE('NOM'),),
+                NOM         =SIMP(statut='o',typ=assd,validators=NoRepeat(),max='**'),
+                SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),
+                                 fr="Paramètre de sensibilité.",
+                                 ang="Sensitivity parameter",max='**'),
+            ),
+            OBJET  =FACT(statut='f',max='**',
+               CLASSE      =SIMP(statut='f',typ='TXM',into=('G','V','L'),defaut='G'),  
+               CHAINE      =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+               POSITION    =SIMP(statut='f',typ='I'  ,max='**'),
+            ),
+            ALARME        =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI',),
+            INFO          =SIMP(statut='f',typ='I',into=(1,2),defaut=2, ),           
+);
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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
+DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_fonction,
+                     fr="Calcul de la réponse spectrale d'une structure linéaire sous une excitation connue par sa DSP",
+                     reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         BASE_MODALE     =FACT(statut='o',
+           regles=(UN_PARMI('NUME_ORDRE','BANDE'),),
+           MODE_MECA       =SIMP(statut='o',typ=mode_meca ),
+           BANDE           =SIMP(statut='f',typ='R',validators=NoRepeat(),max=2),
+           NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           b_bande =BLOC(condition = "BANDE != None",
+             AMOR_UNIF       =SIMP(statut='o',typ='R' ),
+           ),
+           b_nume_ordre =BLOC(condition = "NUME_ORDRE != None",
+             AMOR_REDUIT     =SIMP(statut='o',typ='R',max='**'),
+           ),
+         ),
+         MODE_STAT       =SIMP(statut='f',typ=mode_meca),
+# MODE_STAT devrait etre dans EXCIT car est utile et obligatoire que si NOM_CMP=depl_r, on pourrait
+# ainsi rajouter un bloc du genre  b_mod_stat= BLOC(condition = "(GRANDEUR == None) or (GRANDEUR == 'DEPL_R')",        
+         EXCIT           =FACT(statut='o',
+           INTE_SPEC       =SIMP(statut='o',typ=table_fonction),
+           NUME_VITE_FLUI  =SIMP(statut='f',typ='I' ),
+           OPTION          =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG",) ),
+           MODAL           =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           b_modal_non = BLOC(condition = "(MODAL == None) or (MODAL == 'NON')",           
+             regles=(UN_PARMI('NOEUD_I','NUME_ORDRE_I'),),
+             NUME_ORDRE_I    =SIMP(statut='f',typ='I',max='**'),
+             NOEUD_I         =SIMP(statut='f',typ=no,max='**'),
+             b_nume_ordre_i  =BLOC(condition = "NUME_ORDRE_I != None",
+               regles=(EXCLUS('CHAM_NO','NOEUD'),),
+# on devrait rajouter EXCLUS('GRANDEUR','CHAM_NO') pour eviter ambiguite car CHAM_NO => GRANDEUR='EFFO'
+# cela impliquerait d'enlever la valeur par defaut a GRANDEUR            
+               NUME_ORDRE_J    =SIMP(statut='o',typ='I',max='**'),
+               CHAM_NO         =SIMP(statut='f',typ=cham_no_sdaster),
+               NOEUD           =SIMP(statut='f',typ=no,max='**'),
+               b_noeud         =BLOC(condition = "NOEUD != None",
+                  NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
+                ),  
+               GRANDEUR        =SIMP(statut='f',typ='TXM',defaut="DEPL_R",
+                           into=("DEPL_R","EFFO","SOUR_DEBI_VOLU","SOUR_DEBI_MASS","SOUR_PRESS","SOUR_FORCE")),
+# que se passe-t-il en cas d'incompatibilite entre GRANDEUR et NOM_CMP  
+               DERIVATION      =SIMP(statut='f',typ='I',defaut= 0,into=( 0 , 1 , 2 ) ),
+             ),           
+             b_noeud_i       =BLOC(condition = "NOEUD_I != None",
+               NOEUD_J         =SIMP(statut='o',typ=no,max='**'),
+               NOM_CMP_I       =SIMP(statut='o',typ='TXM',max='**'),
+               NOM_CMP_J       =SIMP(statut='o',typ='TXM',max='**'),
+               NOEUD           =SIMP(statut='o',typ=no,max='**'),
+               NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),
+# ne serait-il pas bien que NOEUD et NOM_CMP soient facultatifs, car l'information peut etre contenue dans
+# NOEUD_I, NOM_CMP_I ...  => modif. du Fortran
+               GRANDEUR        =SIMP(statut='f',typ='TXM',defaut="DEPL_R",
+                           into=("DEPL_R","EFFO","SOUR_DEBI_VOLU","SOUR_DEBI_MASS","SOUR_PRESS","SOUR_FORCE")),
+# que se passe-t-il en cas d'incompatibilite entre GRANDEUR et NOM_CMP_I  
+               DERIVATION      =SIMP(statut='f',typ='I',defaut= 0,into=( 0 , 1 , 2 ) ),
+             ),
+           ),  
+           b_modal_oui = BLOC(condition = "(MODAL == 'OUI')",
+# dans ce cas, y-a-t-il vraiment la possibilite d'une matrice interspectrale avec plusieurs termes
+             NUME_ORDRE_I    =SIMP(statut='o',typ='I',max='**'),
+             NUME_ORDRE_J    =SIMP(statut='o',typ='I',max='**'),
+             GRANDEUR        =SIMP(statut='f',typ='TXM',defaut="DEPL_R",
+                           into=("DEPL_R","EFFO","SOUR_DEBI_VOLU","SOUR_DEBI_MASS","SOUR_PRESS","SOUR_FORCE")),
+             DERIVATION      =SIMP(statut='f',typ='I',defaut= 0,into=( 0 , 1 , 2 ) ),
+# dans le cas MODAL=OUI, GRANDEUR peut-il etre different de EFFO et doit il etre impose a EFFO   On devrait
+# pouvoir supprimer GRANDEUR et DERIVATION ici   
+           ),  
+                    
+         ),
+         REPONSE         =FACT(statut='f',
+           regles=( ENSEMBLE('FREQ_MIN','FREQ_MAX'),),
+           DERIVATION      =SIMP(statut='f',typ='I',defaut= 0,into=( 0 , 1 , 2 ,) ),
+           OPTION          =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG") ),
+           FREQ_MIN        =SIMP(statut='f',typ='R' ),
+           FREQ_MAX        =SIMP(statut='f',typ='R' ),
+           PAS             =SIMP(statut='f',typ='R' ),
+           b_defaut_freq   =BLOC(condition = "FREQ_MIN == NONE",
+              FREQ_EXCIT      =SIMP(statut='f',typ='TXM',defaut="AVEC",into=("AVEC","SANS") ),
+              NB_POIN_MODE    =SIMP(statut='f',typ='I',defaut= 50 ),
+           ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 24/06/2009   AUTEUR ZENTNER I.ZENTNER 
+#            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.        
+# ======================================================================
+# 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,
+                    fr="Calcul du spectre de réponse ou de la reponse temporelle sismique incoherente par decomposition spectrale",
+                    reentrant='n',
+                    UIinfo={"groupes":("Outils métier",)},        
+         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")),
+         ),      
+         MATR_COHE       =FACT(statut='o',
+            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' ),  
+         UNITE_RESU_FORC = SIMP(statut='f',typ='I',defaut=33),
+         UNITE_RESU_IMPE  = SIMP(statut='f',typ='I',defaut=32), 
+         TYPE             = SIMP(statut='f',typ='TXM',into=("BINAIRE","ASCII"), defaut="ASCII"),
+#
+         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)),
+         )  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 ANDRIAM H.ANDRIAMBOLOLONA
+def dyna_line_harm_prod(MATR_RIGI,**args):
+   if (AsType(MATR_RIGI) == matr_asse_depl_r) : return dyna_harmo
+   elif (AsType(MATR_RIGI) == matr_asse_depl_c) : return dyna_harmo
+   elif (AsType(MATR_RIGI) == matr_asse_pres_c) : return acou_harmo
+   elif (AsType(MATR_RIGI) == matr_asse_gene_r) : return harm_gene
+   elif (AsType(MATR_RIGI) == matr_asse_gene_c) : return harm_gene
+   raise AsException("type de concept resultat non prevu")
+
+DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op=  60,sd_prod=dyna_line_harm_prod,
+                    fr="Calcul de la réponse dynamique complexe d'un système à une excitation harmonique",
+                    reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+         regles=(PRESENT_ABSENT('AMOR_REDUIT','MATR_AMOR'),
+                 PRESENT_ABSENT('AMOR_REDUIT','LIST_AMOR'),
+                 PRESENT_ABSENT('MATR_AMOR','LIST_AMOR'),
+                 UN_PARMI('FREQ','LIST_FREQ'),
+                 CONCEPT_SENSIBLE('ENSEMBLE'),),
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater ),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+         MATR_MASS       =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_pres_c,matr_asse_gene_r ) ),
+         MATR_RIGI       =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_pres_c
+                                              ,matr_asse_gene_r,matr_asse_gene_c ) ),
+         MATR_AMOR       =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_pres_c,matr_asse_gene_r ) ),
+         AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'),
+         LIST_AMOR       =SIMP(statut='f',typ=listr8_sdaster ),
+         MATR_IMPE_PHI   =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_gene_r) ),
+         FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+         LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster ),
+         TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI",)),
+         NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=3,into=("DEPL","VITE","ACCE") ),
+         b_reuse =BLOC(condition = "reuse",fr="en mode concept reentrant : RESULTAT obligatoire",
+             RESULTAT      =SIMP(statut='o',typ=(dyna_harmo,harm_gene)),
+         ),
+         EXCIT           =FACT(statut='o',max='**',
+           regles=(UN_PARMI('VECT_ASSE','CHARGE'),
+                   UN_PARMI('FONC_MULT','FONC_MULT_C','COEF_MULT','COEF_MULT_C'),
+                  ),
+           VECT_ASSE       =SIMP(statut='f',position='global',typ=(cham_no_sdaster,vect_asse_gene) ),
+           CHARGE          =SIMP(statut='f',position='global', 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.E+0 ),
+           PUIS_PULS       =SIMP(statut='f',typ='I',defaut= 0 ),
+         ),
+         b_modele_char =BLOC(condition = " CHARGE != None ",
+                       MODELE    =SIMP(statut='o',typ=modele_sdaster ),
+                       ),
+         b_modele_vect =BLOC(condition = " VECT_ASSE != None ",
+                       MODELE    =SIMP(statut='f',typ=modele_sdaster ),
+                       ),
+         EXCIT_RESU      =FACT(statut='f',max='**',
+           RESULTAT        =SIMP(statut='o',typ=(dyna_harmo,harm_gene)),
+           COEF_MULT_C     =SIMP(statut='o',typ='C' ),
+         ),
+         b_matr_gene =BLOC(condition = "AsType(MATR_MASS) in (matr_asse_gene_r,)",
+                           fr="Methode de resolution matrice generalisee",
+          SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="LDLT",into=("LDLT","MUMPS",) ),
+
+           b_ldlt_gene      =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mumps_gene =BLOC( condition = "METHODE=='LDLT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_mumps_gene     =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+           ),
+          ),
+         ),
+
+         b_matr_phys =BLOC(condition = "AsType(MATR_MASS) in (matr_asse_depl_r,matr_asse_pres_c,)",
+                           fr="Methode de resolution matrice sur ddl physique",
+          SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","MUMPS",) ),
+
+           b_mult_front_phys=BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+
+           b_ldlt_phys      =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps_phys =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_mumps_phys     =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),         
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+          ),
+         ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des paramètres de sensibilité.",
+                               ang="List of sensitivity parameters"),
+)  ;
+# 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 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 BOYERE E.BOYERE
+DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op=  48,sd_prod=dyna_trans,
+                    fr="Calcul de la réponse dynamique transitoire à une excitation temporelle quelconque",
+                    reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+#         regles=(UN_PARMI('WILSON','DIFF_CENTRE','ADAPT'),),
+         regles=(UN_PARMI('NEWMARK','WILSON','DIFF_CENTRE','ADAPT'),
+                 CONCEPT_SENSIBLE('ENSEMBLE'),),
+         MODELE          =SIMP(statut='f',typ=modele_sdaster ),
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater ),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+         MATR_MASS       =SIMP(statut='o',typ=matr_asse_depl_r ),
+         MATR_RIGI       =SIMP(statut='o',typ=matr_asse_depl_r ),
+         MATR_AMOR       =SIMP(statut='f',typ=matr_asse_depl_r ),
+         MODE_STAT       =SIMP(statut='f',typ=mode_meca),
+         NEWMARK         =FACT(statut='f',
+           ALPHA           =SIMP(statut='f',typ='R',defaut= 0.25 ),
+           DELTA           =SIMP(statut='f',typ='R',defaut= 0.5 ),
+         ),
+         WILSON          =FACT(statut='f',
+           THETA           =SIMP(statut='f',typ='R',defaut= 1.4 ),
+         ),
+         DIFF_CENTRE     =FACT(statut='f',
+         ),
+         ADAPT           =FACT(statut='f',
+         ),
+         ETAT_INIT       =FACT(statut='f',
+           regles=(AU_MOINS_UN('DYNA_TRANS', 'DEPL_INIT', 'VITE_INIT', 'ACCE_INIT'),
+                   PRESENT_ABSENT('DYNA_TRANS', 'DEPL_INIT', 'VITE_INIT', 'ACCE_INIT'),),
+           DYNA_TRANS      =SIMP(statut='f',typ=dyna_trans ),
+           b_dyna_trans    =BLOC(condition = "DYNA_TRANS != None",
+             regles=(EXCLUS('NUME_INIT','INST_INIT' ),),
+             NUME_INIT       =SIMP(statut='f',typ='I' ),
+             INST_INIT       =SIMP(statut='f',typ='R' ),
+             b_inst_init     =BLOC(condition = "INST_INIT != 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',),),
+             ),
+           ),
+           DEPL_INIT       =SIMP(statut='f',typ=cham_no_sdaster),
+           VITE_INIT       =SIMP(statut='f',typ=cham_no_sdaster),
+           ACCE_INIT       =SIMP(statut='f',typ=cham_no_sdaster),
+         ),
+         EXCIT           =FACT(statut='f',max='**',
+           regles=(UN_PARMI('CHARGE','VECT_ASSE'),
+                   EXCLUS('CHARGE','COEF_MULT'),
+                   EXCLUS('FONC_MULT','COEF_MULT'),
+                   EXCLUS('ACCE','COEF_MULT'),
+                   PRESENT_ABSENT('ACCE','FONC_MULT'),
+                   PRESENT_PRESENT('ACCE','VITE','DEPL'),
+                   # PRESENT_ABSENT('MULT_APPUI','FONC_MULT'),
+                   ),
+           VECT_ASSE       =SIMP(statut='f',typ=cham_no_sdaster),
+           CHARGE          =SIMP(statut='f',typ=char_meca ),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           COEF_MULT       =SIMP(statut='f',typ='R' ),
+           TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",) ),
+           ACCE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           VITE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DEPL            =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_RESU      =FACT(statut='f',max='**',
+           RESULTAT        =SIMP(statut='o',typ=dyna_trans ),
+           COEF_MULT       =SIMP(statut='o',typ='R' ),
+         ),
+         AMOR_MODAL      =FACT(statut='f',
+           MODE_MECA       =SIMP(statut='f',typ=mode_meca ),
+           AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'),
+           NB_MODE         =SIMP(statut='f',typ='I',defaut= 9999 ),
+         ),
+
+         SOLVEUR         =FACT(statut='d',
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+
+           b_gcpc         =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.E-6),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             PARALLELISME    =SIMP(statut='f',typ='TXM',defaut="CENTRALISE",into=("CENTRALISE","CENTRALISE")),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+         ),
+
+         INCREMENT       =FACT(statut='o',max='**',
+           regles=(UN_PARMI('LIST_INST','FONC_INST','PAS'),),
+           LIST_INST       =SIMP(statut='f',typ=listr8_sdaster ),
+           FONC_INST       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           PAS             =SIMP(statut='f',typ='R' ),
+           b_pas           =BLOC(condition = "PAS != None",
+               INST_INIT       =SIMP(statut='f',typ='R' ),
+               INST_FIN        =SIMP(statut='f',typ='R' ),
+           ),
+           b_list_fonc     =BLOC(condition = "LIST_INST != None or FONC_INST != None",
+               regles=(EXCLUS('INST_FIN','NUME_FIN'),),
+               NUME_FIN        =SIMP(statut='f',typ='I' ),
+               INST_FIN        =SIMP(statut='f',typ='R' ),
+           ),
+           VITE_MIN        =SIMP(statut='f',typ='TXM',defaut="NORM",into=("MAXI","NORM") ),
+           COEF_MULT_PAS   =SIMP(statut='f',typ='R',defaut= 1.1 ),
+           COEF_DIVI_PAS   =SIMP(statut='f',typ='R',defaut= 1.33334 ),
+           PAS_LIMI_RELA   =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+           NB_POIN_PERIODE =SIMP(statut='f',typ='I',defaut= 50 ),
+           NMAX_ITER_PAS   =SIMP(statut='f',typ='I',defaut= 16 ),
+           PAS_CALCUL      =SIMP(statut='f',typ='I',defaut= 1 ),
+         ),
+         ARCHIVAGE       =FACT(statut='f',
+           regles=(UN_PARMI('LIST_ARCH','PAS_ARCH', ),),
+           LIST_ARCH       =SIMP(statut='f',typ=listis_sdaster ),
+           PAS_ARCH        =SIMP(statut='f',typ='I' ),
+           CHAM_EXCLU      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=("DEPL","VITE","ACCE") ),
+         ),
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des paramétres de sensibilité.",
+                               ang="List of sensitivity parameters",
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 GREFFET N.GREFFET
+#
+DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f',
+            fr="Calcul de l'évolution dynamique d'une structure dont le matériau ou la géométrie ont un comportement non linéaire",
+            UIinfo={"groupes":("Résolution",)},
+         regles=(AU_MOINS_UN('COMP_INCR','COMP_ELAS',),
+                 CONCEPT_SENSIBLE('ENSEMBLE'),),
+         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",) ),
+         EXCIT           =FACT(statut='o',max='**',
+           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")),
+           CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca)),
+           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='**' ),
+         ),
+         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),
+         ),
+         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","GREEN","GREEN_GR",) ),
+      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=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")),
+         ),
+#-------------------------------------------------------------------
+         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'),
+         ),),
+#-------------------------------------------------------------------
+         INCREMENT       =FACT(statut='f',
+           regles=(EXCLUS('NUME_INST_FIN','INST_FIN'),),
+           LIST_INST       =SIMP(statut='o',typ=(listr8_sdaster,list_inst)),
+           INST_INIT       =SIMP(statut='f',typ='R'),
+           NUME_INST_INIT  =SIMP(statut='f',typ='I'),
+           NUME_INST_FIN   =SIMP(statut='f',typ='I'),
+           INST_FIN        =SIMP(statut='f',typ='R'),
+           ERRE_TEMPS      =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON",
+                                 fr="Adaptation temporelle pour les modélisations HM instationnaires",
+                                 ang="Time adaptation for unstationary HM models"),
+           PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-6 ),
+         ),
+#-------------------------------------------------------------------
+         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          =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),
+         ),
+         SOLVEUR         =FACT(statut='d',
+           METHODE=SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","FETI","PETSC") ),
+           b_mult_front    =BLOC(condition= "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt          =BLOC(condition= "METHODE == 'LDLT'",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON","DECOUPE") ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             FILTRAGE_MATRICE=SIMP(statut='f',typ='R',defaut=-1.0,),
+             MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+           b_gcpc          =BLOC(condition="METHODE == 'GCPC'",fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut=0),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+              NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+              REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+           SYME            =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         ),
+#-------------------------------------------------------------------
+         CONVERGENCE     =FACT(statut='d',
+           regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),),
+           b_refe_rela    =BLOC(condition = "RESI_REFE_RELA != None",
+             regles=(AU_MOINS_UN('SIGM_REFE','EPSI_REFE','FLUX_THER_REFE',
+                                  'FLUX_HYD1_REFE','FLUX_HYD2_REFE','VARI_REFE'),),
+             SIGM_REFE       =SIMP(statut='f',typ='R'),
+             EPSI_REFE       =SIMP(statut='f',typ='R'),
+             FLUX_THER_REFE  =SIMP(statut='f',typ='R'),
+             FLUX_HYD1_REFE  =SIMP(statut='f',typ='R'),
+             FLUX_HYD2_REFE  =SIMP(statut='f',typ='R'),
+             VARI_REFE       =SIMP(statut='f',typ='R'),
+           ),
+           RESI_REFE_RELA  =SIMP(statut='f',typ='R'),
+           RESI_GLOB_MAXI  =SIMP(statut='f',typ='R'),
+           RESI_GLOB_RELA  =SIMP(statut='f',typ='R'),
+           ITER_GLOB_MAXI  =SIMP(statut='f',typ='I',defaut=10),
+           ITER_GLOB_ELAS  =SIMP(statut='f',typ='I',defaut=25),
+           TYPE            =SIMP(statut='f',typ='TXM',defaut="PIC",into=("PIC","PLATEAU")),
+           b_plateau    =BLOC(condition = "TYPE == 'PLATEAU' ",
+
+             PLATEAU_ITER    =SIMP(statut='f',typ='I',defaut=3, val_min =2),
+             PLATEAU_RELA    =SIMP(statut='f',typ='R',defaut=1E-3),
+           ),
+           ARRET           =SIMP(statut='f',typ='TXM',defaut="OUI"),
+
+         ),
+#-------------------------------------------------------------------
+         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",
+                                      "CTCC_GEOM","CTCC_FROT","CTCC_CONT",
+                                      "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 == 'STANDARD' ",
+                            INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                          ),
+         ),
+#-------------------------------------------------------------------
+         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",)),
+         ),
+
+#-------------------------------------------------------------------
+         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"),
+           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) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ADOBES A.ADOBES
+DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=table_fonction,
+                     fr="Calcul de la réponse par recombinaison modale d'une structure linéaire pour une excitation aléatoire",
+                     reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         BASE_ELAS_FLUI  =SIMP(statut='o',typ=melasflu_sdaster ),
+         EXCIT           =FACT(statut='o',
+           INTE_SPEC_GENE  =SIMP(statut='o',typ=table_fonction),
+         ),
+         OPTION          =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG") ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 BOYERE E.BOYERE
+DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op=  74,sd_prod=tran_gene,
+                     fr="Calcul de la réponse dynamique transitoire d'un système amorti ou non en coordonées généralisées"
+                        +" par superposition modale ou par sous structuration",
+                     reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+      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") ),
+         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 ),
+         AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'),
+         LIST_AMOR       =SIMP(statut='f',typ=listr8_sdaster ),
+         MODE_STAT       =SIMP(statut='f',typ=mode_meca ),
+         MODE_CORR       =SIMP(statut='f',typ=(mult_elas,mode_meca),),
+
+         ETAT_INIT       =FACT(statut='f',
+           regles=(EXCLUS('RESU_GENE','DEPL_INIT_GENE'),
+                   EXCLUS('RESU_GENE','VITE_INIT_GENE'),),
+           RESU_GENE       =SIMP(statut='f',typ=tran_gene ),
+           b_resu_gene     =BLOC(condition = "RESU_GENE != None",
+             INST_INIT       =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',),),
+           ),
+           DEPL_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene ),
+           VITE_INIT_GENE  =SIMP(statut='f',typ=vect_asse_gene ),
+         ),
+         INCREMENT       =FACT(statut='o',max='**',
+           INST_INIT       =SIMP(statut='f',typ='R' ),
+           INST_FIN        =SIMP(statut='o',typ='R' ),
+           PAS             =SIMP(statut='f',typ='R' ),
+           VERI_PAS        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           VITE_MIN        =SIMP(statut='f',typ='TXM',defaut="NORM",into=("MAXI","NORM") ),
+           COEF_MULT_PAS   =SIMP(statut='f',typ='R',defaut= 1.1 ),
+           COEF_DIVI_PAS   =SIMP(statut='f',typ='R',defaut= 1.3333334 ),
+           PAS_LIMI_RELA   =SIMP(statut='f',typ='R',defaut= 1.0E-6 ),
+           NB_POIN_PERIODE =SIMP(statut='f',typ='I',defaut= 50 ),
+           NMAX_ITER_PAS   =SIMP(statut='f',typ='I',defaut= 16 ),
+         ),
+         ARCHIVAGE       =FACT(statut='f',
+           regles=(UN_PARMI('LIST_ARCH','PAS_ARCH'),),
+           LIST_ARCH       =SIMP(statut='f',typ=listis_sdaster ),
+           PAS_ARCH        =SIMP(statut='f',typ='I' ),
+         ),
+
+         NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 20 ),
+         RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+         LAMBDA          =SIMP(statut='f',typ='R',defaut= 10. ),
+
+         EXCIT           =FACT(statut='f',max='**',
+           regles=(UN_PARMI('FONC_MULT','COEF_MULT','ACCE'),
+                   UN_PARMI('VECT_GENE','NUME_ORDRE',),
+                   PRESENT_PRESENT('ACCE','VITE','DEPL'),
+                   PRESENT_PRESENT('D_FONC_DT','D_FONC_DT2'),
+                   PRESENT_ABSENT('NUME_ORDRE','VECT_GENE','COEF_MULT'),
+                   EXCLUS('MULT_APPUI','CORR_STAT'),
+                   PRESENT_ABSENT('MULT_APPUI','COEF_MULT'),
+                   PRESENT_ABSENT('MULT_APPUI','FONC_MULT'),),
+           VECT_GENE       =SIMP(statut='f',typ=vect_asse_gene ),
+           NUME_ORDRE      =SIMP(statut='f',typ='I' ),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           COEF_MULT       =SIMP(statut='f',typ='R' ),
+           ACCE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           VITE            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           DEPL            =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           MULT_APPUI      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           DIRECTION       =SIMP(statut='f',typ='R',max='**'),
+           b_loca          =BLOC(condition= "DIRECTION != None",
+             regles=(EXCLUS('NOEUD','GROUP_NO'),),
+             NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+             GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           ),
+           CORR_STAT       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           D_FONC_DT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           D_FONC_DT2      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         CHOC            =FACT(statut='f',max='**',
+           regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD_1','GROUP_NO_1' ),
+                   EXCLUS('NOEUD_2','GROUP_NO_2'),
+                   PRESENT_ABSENT('GROUP_MA','NOEUD_2','GROUP_NO_2'),
+                   PRESENT_ABSENT('MAILLE','NOEUD_2','GROUP_NO_2'),),
+           INTITULE        =SIMP(statut='f',typ='TXM' ),
+           GROUP_MA        =SIMP(statut='f',typ=grma,max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma,max='**'),
+           NOEUD_1         =SIMP(statut='f',typ=no),
+           NOEUD_2         =SIMP(statut='f',typ=no),
+           GROUP_NO_1      =SIMP(statut='f',typ=grno),
+           GROUP_NO_2      =SIMP(statut='f',typ=grno),
+           OBSTACLE        =SIMP(statut='o',typ=table_fonction),
+           ORIG_OBST       =SIMP(statut='f',typ='R',min=3,max=3),
+           NORM_OBST       =SIMP(statut='o',typ='R',min=3,max=3),
+           ANGL_VRIL       =SIMP(statut='f',typ='R' ),
+           JEU             =SIMP(statut='f',typ='R',defaut= 1. ),
+           DIST_1          =SIMP(statut='f',typ='R',val_min=0.E+0 ),
+           DIST_2          =SIMP(statut='f',typ='R',val_min=0.E+0 ),
+           SOUS_STRUC_1    =SIMP(statut='f',typ='TXM' ),
+           SOUS_STRUC_2    =SIMP(statut='f',typ='TXM' ),
+           REPERE          =SIMP(statut='f',typ='TXM',defaut="GLOBAL"),
+           RIGI_NOR        =SIMP(statut='f',typ='R' ),
+           AMOR_NOR        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           RIGI_TAN        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           AMOR_TAN        =SIMP(statut='f',typ='R' ),
+           COULOMB         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+
+           LAME_FLUIDE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           b_lame          =BLOC(condition="LAME_FLUIDE=='OUI'",
+               ALPHA           =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+               BETA            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+               CHI             =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+               DELTA           =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           ),
+         ),
+         VERI_CHOC       =FACT(statut='f',max='**',
+           STOP_CRITERE    =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           SEUIL           =SIMP(statut='f',typ='R',defaut= 0.5 ),
+         ),
+         FLAMBAGE        =FACT(statut='f',max='**',
+           regles=(UN_PARMI('NOEUD_1','GROUP_NO_1'),
+                   EXCLUS('NOEUD_2','GROUP_NO_2'),),
+           NOEUD_1         =SIMP(statut='f',typ=no),
+           NOEUD_2         =SIMP(statut='f',typ=no),
+           GROUP_NO_1      =SIMP(statut='f',typ=grno),
+           GROUP_NO_2      =SIMP(statut='f',typ=grno),
+           OBSTACLE        =SIMP(statut='o',typ=table_fonction),
+           ORIG_OBST       =SIMP(statut='f',typ='R',max='**'),
+           NORM_OBST       =SIMP(statut='o',typ='R',max='**'),
+           ANGL_VRIL       =SIMP(statut='f',typ='R' ),
+           JEU             =SIMP(statut='f',typ='R',defaut= 1. ),
+           DIST_1          =SIMP(statut='f',typ='R' ),
+           DIST_2          =SIMP(statut='f',typ='R' ),
+           REPERE          =SIMP(statut='f',typ='TXM',defaut="GLOBAL"),
+           RIGI_NOR        =SIMP(statut='f',typ='R' ),
+           FNOR_CRIT       =SIMP(statut='f',typ='R' ),
+           FNOR_POST_FL    =SIMP(statut='f',typ='R' ),
+           RIGI_NOR_POST_FL=SIMP(statut='f',typ='R' ),
+         ),
+         ANTI_SISM       =FACT(statut='f',max='**',
+           regles=(UN_PARMI('NOEUD_1','GROUP_NO_1'),
+                   UN_PARMI('NOEUD_2','GROUP_NO_2'),),
+           NOEUD_1         =SIMP(statut='f',typ=no),
+           NOEUD_2         =SIMP(statut='f',typ=no),
+           GROUP_NO_1      =SIMP(statut='f',typ=grno),
+           GROUP_NO_2      =SIMP(statut='f',typ=grno),
+           RIGI_K1         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           RIGI_K2         =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           SEUIL_FX        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           C               =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           PUIS_ALPHA      =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           DX_MAX          =SIMP(statut='f',typ='R',defaut= 1. ),
+         ),
+         RELA_EFFO_DEPL  =FACT(statut='f',max='**',
+           NOEUD           =SIMP(statut='o',typ=no),
+           SOUS_STRUC      =SIMP(statut='f',typ='TXM' ),
+           NOM_CMP         =SIMP(statut='f',typ='TXM' ),
+           RELATION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         RELA_TRANSIS    =FACT(statut='f',max='**',
+           NOEUD           =SIMP(statut='o',typ=no),
+           SOUS_STRUC      =SIMP(statut='f',typ='TXM' ),
+           NOM_CMP         =SIMP(statut='f',typ='TXM' ),
+           RELATION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         RELA_EFFO_VITE  =FACT(statut='f',max='**',
+           NOEUD           =SIMP(statut='o',typ=no),
+           SOUS_STRUC      =SIMP(statut='f',typ='TXM' ),
+           NOM_CMP         =SIMP(statut='f',typ='TXM' ),
+           RELATION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         b_itmi          =BLOC(condition = "METHODE=='ITMI'",
+                regles=(ENSEMBLE('BASE_ELAS_FLUI','NUME_VITE_FLUI'),),
+                BASE_ELAS_FLUI  =SIMP(statut='f',typ=melasflu_sdaster ),
+                NUME_VITE_FLUI  =SIMP(statut='f',typ='I' ),
+                ETAT_STAT       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+                PREC_DUREE      =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
+                CHOC_FLUI       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+                NB_MODE         =SIMP(statut='f',typ='I' ),
+                NB_MODE_FLUI    =SIMP(statut='f',typ='I' ),
+                TS_REG_ETAB     =SIMP(statut='f',typ='R' ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         IMPRESSION      =FACT(statut='f',max='**',
+           regles=(EXCLUS('TOUT','NIVEAU'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NIVEAU          =SIMP(statut='f',typ='TXM',into=("DEPL_LOC","VITE_LOC","FORC_LOC","TAUX_CHOC") ),
+           INST_INIT       =SIMP(statut='f',typ='R' ),
+           INST_FIN        =SIMP(statut='f',typ='R' ),
+         ),
+
+
+         SOLVEUR         =FACT(statut='d', fr="Méthode de résolution des systèmes linéaires",
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="LDLT",into=("LDLT","MUMPS","MULT_FRONT",) ),
+
+
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+         ),
+
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+ )  ;
+#& MODIF COMMANDE  DATE 12/05/2009   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.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+ENGENDRE_TEST=PROC(nom="ENGENDRE_TEST",op=178,
+                   UIinfo={"groupes":("Impression",)},
+                   fr="Engendre des tests pour la non régression du code (pour développeurs)",
+         UNITE           =SIMP(statut='f',typ='I',defaut=8),
+         FORMAT          =SIMP(statut='f',typ='TXM',into=("OBJET",) ),
+         FORMAT_R        =SIMP(statut='f',typ='TXM',defaut="1PE20.13"),
+         PREC_R          =SIMP(statut='f',typ='TXM',defaut="1.E-10"),
+#============================================================================
+         b_aster     =BLOC( condition = "FORMAT==None",
+            CO              =SIMP(statut='o',typ=(cham_gd_sdaster,resultat_sdaster,table_sdaster),
+                                  validators=NoRepeat(),max='**'),
+            TYPE_TEST       =SIMP(statut='f',typ='TXM',defaut="SOMM_ABS",into=("SOMME","SOMM_ABS","MAX","MIN") ),
+         ),
+#============================================================================
+         b_objet     =BLOC( condition = "FORMAT=='OBJET'",
+                            regles=(UN_PARMI('TOUT','CO'),),
+            TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+            CO              =SIMP(statut='f',typ=assd,validators=NoRepeat(),max='**'),
+            TYPE_TEST       =SIMP(statut='f',typ='TXM',defaut="SOMME",into=("SOMME",) ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+
+from Macro.exec_logiciel_ops import exec_logiciel_ops
+def exec_logiciel_prod(self, MAILLAGE, **args):
+   if MAILLAGE != None:
+      mcf = MAILLAGE[0]
+      self.type_sdprod(mcf['MAILLAGE'], maillage_sdaster)
+   return None
+
+EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",op=exec_logiciel_ops, sd_prod=exec_logiciel_prod,
+                      fr="Exécute un logiciel ou une commande système depuis Aster",
+                      UIinfo={"groupes":("Outils métier",)},
+      
+      regles = (AU_MOINS_UN('LOGICIEL', 'MAILLAGE'),),
+      
+      LOGICIEL = SIMP(statut='f', typ='TXM'),
+      ARGUMENT = SIMP(statut='f', max='**', typ='TXM'),
+
+      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,
+                           fr="Unité logique définissant le fichier (fort.N) contenant les données géométriques (datg)"),
+         UNITE      = SIMP(statut='f', typ='I', val_min=10, val_max=90, defaut=19,
+                           fr="Unité logique définissant le fichier (fort.N) produit par le mailleur"),
+         MAILLAGE   = SIMP(statut='o', typ=CO),
+      ),
+
+      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)"),
+      
+      INFO     = SIMP(statut='f', typ='I', defaut=2, into=(1,2),),
+)
+#& MODIF COMMANDE  DATE 05/05/2008   AUTEUR NISTOR I.NISTOR 
+#            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 NISTOR I.NISTOR
+
+def extr_mode_prod(FILTRE_MODE,**args):
+  vale=FILTRE_MODE[0]['MODE']
+  if AsType(vale) == mode_meca   : return mode_meca
+  if AsType(vale) == mode_meca_c : return mode_meca_c
+  if AsType(vale) == mode_gene   : return mode_gene
+  raise AsException("type de concept resultat non prevu")
+
+EXTR_MODE=OPER(nom="EXTR_MODE",op= 168,sd_prod=extr_mode_prod,
+               reentrant='n',fr="Extraire séléctivement des modes des structures de données modales",
+            UIinfo={"groupes":("Résolution",)},
+         FILTRE_MODE     =FACT(statut='o',max='**',
+           regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','NUME_MODE','NUME_MODE_EXCLU','FREQ_MIN','CRIT_EXTR',),),
+           MODE            =SIMP(statut='o',typ=(mode_meca,mode_meca_c,mode_gene ) ),
+           TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
+           NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           NUME_MODE_EXCLU =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           FREQ_MIN        =SIMP(statut='f',typ='R' ),
+           CRIT_EXTR       =SIMP(statut='f',typ='TXM',into=("MASS_EFFE_UN","MASS_GENE") ),
+           b_freq_min      =BLOC(condition = "FREQ_MIN != None",  
+             FREQ_MAX        =SIMP(statut='o',typ='R' ),
+             PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           ),
+           b_crit_extr     =BLOC(condition = "CRIT_EXTR != None",
+             regles=(AU_MOINS_UN('SEUIL','SEUIL_X','SEUIL_Y','SEUIL_Z'),),
+             SEUIL           =SIMP(statut='f',typ='R'),
+             SEUIL_X         =SIMP(statut='f',typ='R'),
+             SEUIL_Y         =SIMP(statut='f',typ='R'),
+             SEUIL_Z         =SIMP(statut='f',typ='R'),
+           ),    
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         IMPRESSION      =FACT(statut='f',
+           CUMUL           =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           CRIT_EXTR       =SIMP(statut='f',typ='TXM',defaut="MASS_EFFE_UN",into=("MASS_EFFE_UN","MASS_GENE") ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 LEFEBVRE J.P.LEFEBVRE
+
+def extr_resu_prod(RESULTAT,**args):
+  if AsType(RESULTAT) == evol_elas    : return evol_elas
+  if AsType(RESULTAT) == evol_noli    : return evol_noli
+  if AsType(RESULTAT) == evol_ther    : return evol_ther
+  if AsType(RESULTAT) == dyna_trans   : return dyna_trans
+  if AsType(RESULTAT) == dyna_harmo   : return dyna_harmo
+  if AsType(RESULTAT) == acou_harmo   : return acou_harmo
+  if AsType(RESULTAT) == mode_meca    : return mode_meca
+  if AsType(RESULTAT) == mode_acou    : return mode_acou
+  if AsType(RESULTAT) == mult_elas    : return mult_elas
+  if AsType(RESULTAT) == fourier_elas : return fourier_elas
+  raise AsException("type de concept resultat non prevu")
+
+EXTR_RESU=OPER(nom="EXTR_RESU",op=176,sd_prod=extr_resu_prod,reentrant='f',
+            UIinfo={"groupes":("Résultats et champs",)},
+            fr="Extraire des champs au sein d'une SD Résultat",
+         regles=(CONCEPT_SENSIBLE('SEPARE'), 
+                 #REUSE_SENSIBLE(),
+                 DERIVABLE('RESULTAT'),),
+         RESULTAT        =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,acou_harmo,mode_meca,
+                                               mode_acou,evol_ther,evol_noli,
+                                               mult_elas,fourier_elas,fourier_ther ) ),
+
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                                   fr="Liste des paramètres de sensibilité.",
+                                   ang="List of sensitivity parameters"),
+
+         ARCHIVAGE       =FACT(statut='f',
+           regles=(  UN_PARMI('NUME_ORDRE', 'INST', 'FREQ', 'NUME_MODE',
+                        'NOEUD_CMP', 'LIST_INST', 'LIST_FREQ', 'LIST_ORDRE',
+                        'NOM_CAS', 'LIST_ARCH', 'PAS_ARCH' ),
+                     EXCLUS( 'CHAM_EXCLU','NOM_CHAM' ),   ),
+           CHAM_EXCLU      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO()),
+           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_ARCH       =SIMP(statut='f',typ=listis_sdaster),
+           PAS_ARCH        =SIMP(statut='f',typ='I'),
+           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='**'),
+           NOM_CAS         =SIMP(statut='f',typ='TXM'),
+                               ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+def extr_table_prod(TYPE_RESU,**args):
+  from Cata import cata
+  typ = TYPE_RESU.lower()
+  if hasattr(cata, typ):
+     return getattr(cata, typ)
+  raise AsException("type de concept resultat non prevu")
+
+EXTR_TABLE=OPER(nom="EXTR_TABLE",op=173,sd_prod=extr_table_prod,reentrant='n',
+            UIinfo={"groupes":("Résultats et champs",)},
+         fr="Extraire d'une table des concepts Code_Aster",
+         TYPE_RESU       =SIMP(statut='o',typ='TXM',),
+
+         TABLE           =SIMP(statut='o',typ=(table_sdaster,table_container)),
+
+         NOM_PARA        =SIMP(statut='o',typ='TXM'),
+
+         FILTRE          =FACT(statut='f',min=1,max='**',
+           NOM_PARA        =SIMP(statut='o',typ='TXM'),
+           CRIT_COMP       =SIMP(statut='f',typ='TXM',defaut="EQ",
+                                 into=("EQ","LT","GT","NE","LE","GE","VIDE",
+                                       "NON_VIDE","MAXI","ABS_MAXI","MINI","ABS_MINI") ),
+           b_vale          =BLOC(condition = "(CRIT_COMP in ('EQ','NE','GT','LT','GE','LE'))",
+              regles=(UN_PARMI('VALE','VALE_I','VALE_K','VALE_C',),),
+              VALE            =SIMP(statut='f',typ='R'),
+              VALE_I          =SIMP(statut='f',typ='I'),
+              VALE_C          =SIMP(statut='f',typ='C'),
+              VALE_K          =SIMP(statut='f',typ='TXM'),),
+
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+         ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 PELLET J.PELLET
+
+def factoriser_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")
+
+FACTORISER=OPER(nom="FACTORISER",op=14,sd_prod=factoriser_prod,
+               fr="Factoriser une matrice assemblée en un produit de deux matrices triangulaires"+
+                  "ou construire une matrice de préconditionnement pour une résolution par gradient conjugué",
+               reentrant='f', UIinfo={"groupes":("Résolution",)},
+         regles=(EXCLUS('BLOC_DEBUT','DDL_DEBUT'),
+                 EXCLUS('BLOC_FIN','DDL_FIN'),),
+         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) ),
+
+         # mots clés pour solveur LDLT et MULT_FRONT et MUMPS:
+         STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         NPREC           =SIMP(statut='f',typ='I',defaut=8),
+
+         # mots clés pour solveur LDLT :
+         BLOC_DEBUT      =SIMP(statut='f',typ='I',val_min=1,),
+         DDL_DEBUT       =SIMP(statut='f',typ='I',val_min=1,),
+         BLOC_FIN        =SIMP(statut='f',typ='I',val_min=1,),
+         DDL_FIN         =SIMP(statut='f',typ='I',val_min=1,),
+
+         # mots clés pour solveur 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")),
+         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")),
+         
+         # mots clés pour solveur GCPC et PETSc :
+         PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+         b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+           NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+           REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+         ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 03/08/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 LEFEBVRE J.P.LEFEBVRE
+FIN=PROC(nom="FIN",op=9999,repetable='n',fr="Fin d'une étude, fin du travail engagé par une des commandes DEBUT ou POURSUITE",
+            UIinfo={"groupes":("Gestion du travail",)},
+#
+# FIN est appelé prématurément en cas d'exception ("SIGUSR1", ArretCPUError,
+# NonConvergenceError..., erreurs <S> ou erreurs <F> récupérées).
+# En cas d'ArretCPUError, on limite au maximum le travail à faire dans FIN.
+# Pour cela, on force certains mots-clés dans Execution/E_JDC.py.
+# 
+         FORMAT_HDF      =SIMP(fr="sauvegarde de la base GLOBALE au format HDF",statut='f',
+                               typ='TXM',defaut="NON",into=("OUI","NON",) ), 
+         RETASSAGE       =SIMP(fr="provoque le retassage de la base GLOBALE",
+                               statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+         INFO_RESU       =SIMP(fr="provoque l'impression des informations sur les structures de données",
+                               statut='f',typ='TXM',defaut="OUI",into=("OUI","NON",) ),
+         UNITE           =SIMP(statut='f',typ='I',defaut=6),  
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ADOBES A.ADOBES
+FONC_FLUI_STRU=OPER(nom="FONC_FLUI_STRU",op= 169,sd_prod=fonction_sdaster,
+                    reentrant='n',fr="Crée une fonction constante paramètrée par l'abscisse curviligne",
+            UIinfo={"groupes":("Fonction",)},
+         TYPE_FLUI_STRU  =SIMP(statut='o',typ=(type_flui_stru) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DURAND C.DURAND
+def formule_prod(self,VALE,VALE_C,**args):
+   if   VALE   != None:
+      return formule
+   elif VALE_C != None:
+      return formule_c
+
+def form_pyth_ops(self,d):
+   NOM_PARA=self.etape['NOM_PARA']
+   VALE    =self.etape['VALE']
+   VALE_C  =self.etape['VALE_C']
+   if type(NOM_PARA) not in (list, tuple):
+      NOM_PARA = [NOM_PARA,]
+   if self.sd == None:
+      return
+   if VALE     != None :
+      texte = ''.join(VALE.splitlines())
+   elif VALE_C != None :
+      texte = ''.join(VALE_C.splitlines())
+   self.sd.setFormule(NOM_PARA, texte.strip())
+
+FORMULE=FORM(nom="FORMULE",op_init=form_pyth_ops,op=-5,
+             sd_prod=formule_prod,UIinfo={"groupes":("Fonction",)},
+             fr="Définit une formule réelle ou complexe à partir de son expression mathématique",
+         regles=(UN_PARMI('VALE','VALE_C',),),
+         VALE     =SIMP(statut='f',typ='TXM'),
+         VALE_C   =SIMP(statut='f',typ='TXM'),
+         NOM_PARA =SIMP(statut='o',typ='TXM',max='**'),
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ZENTNER I.ZENTNER
+GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table_fonction,
+                    fr="Génération de la fonction temporelle à partir d une matrice interspectrale",
+                    reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         INTE_SPEC       =SIMP(statut='o',typ=table_fonction),
+         NUME_VITE_FLUI  =SIMP(statut='f',typ='I' ),
+         INTERPOL        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("NON","OUI") ),
+         b_interpol_oui    =BLOC(condition = "INTERPOL == 'OUI' ",fr="Parametres cas interpolation autorisee",
+           DUREE_TIRAGE    =SIMP(statut='f',typ='R' ),
+           FREQ_INIT       =SIMP(statut='f',typ='R' ),
+           FREQ_FIN        =SIMP(statut='f',typ='R' ),
+             ),
+         NB_POIN         =SIMP(statut='f',typ='I'),
+         NB_TIRAGE       =SIMP(statut='f',typ='I',defaut= 1 ),
+         INIT_ALEA       =SIMP(statut='f',typ='I'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 ZENTNER I.ZENTNER
+def gene_matr_alea_prod(MATR_MOYEN,**args ):
+  if (AsType(MATR_MOYEN) == matr_asse_gene_r )  : return matr_asse_gene_r
+  if (AsType(MATR_MOYEN) == macr_elem_dyna) : return macr_elem_dyna
+  raise AsException("type de concept resultat non prevu")
+
+GENE_MATR_ALEA=OPER(nom="GENE_MATR_ALEA",op=  27,
+#sd_prod=matr_asse_gene_r,
+sd_prod=gene_matr_alea_prod,
+               fr="Générer une réalisation d'une matrice aléatoire réelle sym. déf. positive ou d'un macro élément dynamique",
+               reentrant='n',
+            UIinfo={"groupes":("Matrice",)},
+   MATR_MOYEN   = SIMP(statut='o', typ=(matr_asse_gene_r,macr_elem_dyna)),
+
+#    cas matrice generalisee 
+   b_matr =BLOC( condition = "AsType(MATR_MOYEN) in (matr_asse_gene_r,)",
+           COEF_VAR     = SIMP(statut='f', typ='R', defaut=0.1, val_min=0.E+0 ,
+                                fr="coefficient de variation de la matrice a generer" ),
+           ),
+#    cas macr_elem_dyna 
+   b_macr =BLOC( condition = "AsType(MATR_MOYEN) in (macr_elem_dyna,)",
+           fr="cas macr_elem_dyna (sous-structuratio)",
+           COEF_VAR_RIGI     = SIMP(statut='f', typ='R', defaut=0.1, val_min=0.E+0 ,
+                                fr="coefficient de variation de la matrice de raideur" ),
+           COEF_VAR_MASS     = SIMP(statut='f', typ='R', defaut=0., val_min=0.E+0 ,
+                                fr="coefficient de variation de la matrice de masse" ),
+           COEF_VAR_AMOR     = SIMP(statut='f', typ='R', defaut=0., val_min=0.E+0 ,
+                                fr="coefficient de variation de la matrice d'amortissement" ),),
+
+   INIT_ALEA    =SIMP(statut='f',typ='I'),
+) ;
+   
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 ZENTNER I.ZENTNER
+from Macro.gene_vari_alea_ops import gene_vari_alea_ops,gene_vari_alea_init
+GENE_VARI_ALEA=MACRO(nom="GENE_VARI_ALEA",
+               op_init=gene_vari_alea_init,op=gene_vari_alea_ops,
+               sd_prod=reel,reentrant='n',
+               fr="Générer une réalisation d'une variable aléatoire réelle de loi de probabilité donnée (Gamma ou Exponentielle)",
+               UIinfo={"groupes":("Fonction",)},
+   TYPE       = SIMP(statut='f', typ='TXM', into=("EXP_TRONQUEE", "EXPONENTIELLE", "GAMMA"), defaut="GAMMA"),
+   b_gamma    =BLOC(condition = "TYPE == 'GAMMA' ",fr="Parametres loi gamma",
+           VALE_MOY   = SIMP(statut='f', typ='R', defaut=1.),
+           BORNE_INF  = SIMP(statut='f', typ='R', defaut=0.),
+           COEF_VAR   = SIMP(statut='f', typ='R', defaut=0.1),
+             ),
+   b_expo    =BLOC(condition = "TYPE == 'EXPONENTIELLE' ",fr="Parametres loi exponentielle",
+           VALE_MOY   = SIMP(statut='f', typ='R', defaut=0.),
+           BORNE_INF  = SIMP(statut='f', typ='R', defaut=-1.),
+             ),
+   b_expo_tronq    =BLOC(condition = "TYPE == 'EXP_TRONQUEE' ",fr="Parametres loi exponentielle tronquee",
+           VALE_MOY   = SIMP(statut='f', typ='R', defaut=0.),
+           BORNE_INF  = SIMP(statut='f', typ='R', defaut=-1.),
+           BORNE_SUP  = SIMP(statut='f', typ='R', defaut=1.),
+             ),
+   INIT_ALEA       =SIMP(statut='f',typ='I'),
+)
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+IMPR_CO=PROC(nom="IMPR_CO",op=17,
+            UIinfo={"groupes":("Impression",)},
+             fr="Imprimer tous les objets JEVEUX qui constituent un concept utilisateur existant (pour les développeurs)",
+         regles=(UN_PARMI('CONCEPT','CHAINE','TOUT' ),),
+
+         UNITE           =SIMP(statut='f',typ='I',defaut=8),
+         NIVEAU          =SIMP(statut='f',typ='I',defaut=2,into=(-1,0,1,2) ),
+         ATTRIBUT        =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","OUI") ),
+         CONTENU         =SIMP(statut='f',typ='TXM',defaut="OUI",into=("NON","OUI") ),
+         BASE            =SIMP(statut='f',typ='TXM',defaut="G",into=(" ","G","V","L") ),
+         CONCEPT    =FACT(statut='f',max='**',
+             regles=(DERIVABLE('NOM'),),
+             NOM         =SIMP(statut='o',typ=assd,validators=NoRepeat(),max='**'),
+             SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),
+                                 fr="Paramètre de sensibilité.",
+                                 ang="Sensitivity parameter",max='**'),),        
+         CHAINE          =SIMP(statut='f',typ='TXM'),
+         POSITION        =SIMP(statut='f',typ='I',defaut=1),
+         TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+)  ;
+#& MODIF COMMANDE  DATE 28/07/2009   AUTEUR TORKHANI M.TORKHANI 
+#            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.        
+# ======================================================================
+# RESPONSABLE Mohamed TORKHANI
+
+from Macro.impr_diag_campbell_ops import impr_diag_campbell_ops
+
+IMPR_DIAG_CAMPBELL=MACRO(nom="IMPR_DIAG_CAMPBELL",op=impr_diag_campbell_ops, fr="Tracer du Diagramme de Campbell",
+            UIinfo={"groupes":("Post-traitements",)},
+            MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster),
+            MODES           =SIMP(statut='o',max='**',typ=mode_meca),
+            VITE_ROTA        =SIMP(statut='o',typ='R',max='**'),
+            NFREQ_camp      =SIMP(statut='o',typ='I' ),
+            TYP_PREC        =SIMP(statut='f',typ='I',defaut= 1, into=(1,2) ),
+            TYP_TRI         =SIMP(statut='f',typ='I',defaut= 2, into=(0,1,2) ),
+            UNIT_FLE        =SIMP(statut='o',typ='I' ,val_min=1),
+            UNIT_TOR        =SIMP(statut='o',typ='I' ,val_min=1),
+            UNIT_LON        =SIMP(statut='o',typ='I' ,val_min=1),
+            UNIT_TOT        =SIMP(statut='o',typ='I' ,val_min=1),
+            UNIT_INT        =SIMP(statut='o',typ='I' ,val_min=1),
+            L_S             =SIMP(statut='f',typ='R', defaut= 1., max='**'),
+);
+#& MODIF COMMANDE  DATE 06/05/2008   AUTEUR CNGUYEN C.NGUYEN 
+#            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
+from Macro.impr_fonction_ops import impr_fonction_ops
+
+IMPR_FONCTION=MACRO(nom="IMPR_FONCTION",op=impr_fonction_ops,sd_prod=None,
+                 fr="Imprime le contenu d'objets de type fonction ou liste de réels dans un fichier destiné à un traceur de courbe",
+            UIinfo={"groupes":("Fonction",)},
+         FORMAT          =SIMP(statut='o',typ='TXM',position='global',defaut='TABLEAU',
+                               into=("TABLEAU","AGRAF","XMGRACE",),),
+         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"),
+         ),
+         b_agraf = BLOC(condition = "FORMAT == 'AGRAF'",
+                        fr="Mots-clés propres à AGRAF",
+           UNITE           =SIMP(statut='o',typ='I',defaut=25,
+                                 fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+           UNITE_DIGR      =SIMP(statut='o',typ='I',defaut=26,
+                                 fr="Unité logique définissant le fichier dans lequel on écrit les directives Agraf"),
+         ),
+         # unite pour TABLEAU dans le bloc de mise en forme spécifique
+
+         COURBE          =FACT(statut='o',max='**',fr="Définition de la fonction à tracer",
+           regles=(UN_PARMI('FONCTION','LIST_RESU','FONC_X','ABSCISSE'),),
+           FONCTION        =SIMP(statut='f',typ=(fonction_sdaster, formule, fonction_c, nappe_sdaster),
+                                 fr="Fonction réelle ou complexe", ),
+           LIST_RESU       =SIMP(statut='f',typ=listr8_sdaster,
+                                 fr="Liste des ordonnees d'une fonction réelle définie par deux listes", ),
+           FONC_X          =SIMP(statut='f',typ=(fonction_sdaster,formule),
+                                 fr="Fonction abscisses d'une fonction paramétrique",),
+           ABSCISSE        =SIMP(statut='f',typ='R',max='**',
+                                 fr="Valeurs des abscisses", ),
+           b_fonction      =BLOC(condition = "FONCTION != None",
+             LIST_PARA       =SIMP(statut='f',typ=listr8_sdaster ),
+           ),
+           b_fonction_c  =BLOC(condition = "AsType(FONCTION) in (fonction_c, formule_c)",
+                                 fr="Fonction complexe définie par le mot-clé fonction",
+             PARTIE          =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ),
+           ),
+           b_list_resu     =BLOC(condition = "LIST_RESU != None",
+             LIST_PARA       =SIMP(statut='o',typ=listr8_sdaster ),
+           ),
+           b_fonc_x        =BLOC(condition = "FONC_X != None",
+             FONC_Y          =SIMP(statut='o',typ=(fonction_sdaster,formule),fr="Fonction ordonnées d une fonction paramétrique" ),
+             LIST_PARA       =SIMP(statut='f',typ=listr8_sdaster ),
+           ),
+           b_vale_resu     =BLOC(condition = "ABSCISSE != None",
+             ORDONNEE      =SIMP(statut='o',typ='R',max='**',
+                                 fr="Valeurs des ordonnées"),
+           ),
+
+           # mots-clés utilisant uniquement aux formats autres que TABLEAU
+           # mais ce serait trop pénible de devoir les supprimer quand on change de format
+           # donc on ne les met pas dans un bloc
+           # "pseudo" bloc mise en forme :
+               LEGENDE         =SIMP(statut='f',typ='TXM',
+                                    fr="Légende associée à la fonction" ),
+               STYLE           =SIMP(statut='f',typ='I',val_min=0,
+                                    fr="Style de la ligne représentant la fonction",),
+               COULEUR         =SIMP(statut='f',typ='I',val_min=0,
+                                    fr="Couleur associée à la fonction",),
+               MARQUEUR        =SIMP(statut='f',typ='I',val_min=0,
+                                    fr="Type du marqueur associé à la fonction",),
+               FREQ_MARQUEUR   =SIMP(statut='f',typ='I',defaut=0,
+                                    fr="Fréquence d impression du marqueur associé à la fonction", ),
+           # fin bloc mise en forme
+           
+           TRI             =SIMP(statut='f',typ='TXM',defaut="N",
+                                 fr="Choix du tri effectué sur les abscisses ou sur les ordonnées",
+                                 into=("N","X","Y","XY","YX") ),
+         ),
+         # Mise en page du tableau ou du graphique
+         b_tableau = BLOC(condition = "FORMAT == 'TABLEAU'",
+                          fr="Mots-clés propres au format Tableau",
+           UNITE           =SIMP(statut='o',typ='I',defaut=8,
+                                 fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+           TITRE           =SIMP(statut='f',typ='TXM',
+                                 fr="Titre associé au graphique" ),
+           SOUS_TITRE      =SIMP(statut='f',typ='TXM',
+                                 fr="Sous-titre du graphique" ),
+           SEPARATEUR      =SIMP(statut='f',typ='TXM',defaut=' ',
+                                 fr="Séparateur des colonnes du tableau (ex : ' ', ';'...)"),
+           COMMENTAIRE     =SIMP(statut='f',typ='TXM',defaut='#',
+                                 fr="Caractère indiquant au traceur de fonction que la ligne peut etre ignorée"),
+           COMM_PARA       =SIMP(statut='f',typ='TXM',defaut='',
+                                 fr="Caractère utilisé pour commentariser la ligne des labels de colonnes"),
+           DEBUT_LIGNE     =SIMP(statut='f',typ='TXM',defaut='',
+                                 fr="Caractère de debut de ligne"),
+           FIN_LIGNE       =SIMP(statut='f',typ='TXM',defaut='\n',
+                                 fr="Caractère de fin de ligne"),
+         ),
+         b_graphique = BLOC(condition = "FORMAT != 'TABLEAU'",
+                        fr="Mise en page du graphique",
+           TITRE           =SIMP(statut='f',typ='TXM',
+                                 fr="Titre associé au graphique" ),
+           SOUS_TITRE      =SIMP(statut='f',typ='TXM',
+                                 fr="Sous-titre du graphique" ),
+           BORNE_X         =SIMP(statut='f',typ='R',min=2,max=2,
+                                 fr="Intervalles de variation des abscisses"),
+           BORNE_Y         =SIMP(statut='f',typ='R',min=2,max=2,
+                                 fr="Intervalles de variation des ordonnées"),
+           ECHELLE_X       =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
+                                 fr="Type d'échelle pour les abscisses" ),
+           ECHELLE_Y       =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
+                                 fr="Type d'échelle pour les ordonnées" ),
+           GRILLE_X        =SIMP(statut='f',typ='R',max=1,val_min=0.,
+                                 fr="Pas du quadrillage vertical" ),
+           GRILLE_Y        =SIMP(statut='f',typ='R',max=1,val_min=0.,
+                                 fr="Pas du quadrillage horizontal" ),
+           LEGENDE_X       =SIMP(statut='f',typ='TXM',
+                                 fr="Légende associée à l'axe des abscisses" ),
+           LEGENDE_Y       =SIMP(statut='f',typ='TXM',
+                                 fr="Légende associée à l'axe des ordonnées" ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 BOYERE E.BOYERE
+IMPR_GENE=PROC(nom="IMPR_GENE",op= 157,
+            fr="Imprimer le résultat d'un calcul dynamique en variables généralisées au format RESULTAT",
+            UIinfo={"groupes":("Impression",)},
+         FORMAT          =SIMP(statut='f',typ='TXM',defaut="RESULTAT",into=("RESULTAT",) ),
+         UNITE           =SIMP(statut='f',typ='I',defaut=8),  
+         GENE            =FACT(statut='o',max='**',
+           regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                          'LIST_INST','LIST_FREQ','TOUT_MODE','TOUT_INST','LIST_ORDRE'),
+                   EXCLUS('TOUT_MODE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                          'LIST_INST','LIST_FREQ','TOUT_ORDRE','TOUT_INST','LIST_ORDRE'),
+                   EXCLUS('TOUT_INST','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                          'LIST_INST','LIST_FREQ','TOUT_ORDRE','LIST_ORDRE'),
+                   EXCLUS('TOUT_CMP_GENE','NUME_CMP_GENE'),
+                   EXCLUS('TOUT_CHAM','NOM_CHAM'),
+                   EXCLUS('TOUT_PARA','NOM_PARA'),),
+#  faut-il faire des blocs selon le type de RESU_GENE                   
+           RESU_GENE       =SIMP(statut='o',typ=(vect_asse_gene, tran_gene, mode_gene, harm_gene)),
+           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 ),
+           TOUT_INST       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+           LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster ),
+           TOUT_MODE       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),),
+           b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+              PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+           b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+              PRECISION       =SIMP(statut='o',typ='R',),),
+           TOUT_CMP_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='**'),
+           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='**'),
+           INFO_CMP_GENE   =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
+           INFO_GENE       =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 03/08/2009   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+IMPR_JEVEUX=PROC(nom="IMPR_JEVEUX",op=16,
+            UIinfo={"groupes":("Impression",)},
+                 fr="Imprimer le contenu des objets créés par JEVEUX (pour développeur)",
+         ENTITE          =SIMP(fr="choix de l'observation",statut='o',typ='TXM',
+                               into=("DISQUE","MEMOIRE","REPERTOIRE",    
+                                     "OBJET","ATTRIBUT","SYSTEME","ENREGISTREMENT") ),
+         b_objet      =BLOC(condition = "(ENTITE=='OBJET')",
+            NOMOBJ          =SIMP(fr="nom d'objet",statut='f',typ='TXM' ),  
+            NUMOC           =SIMP(fr="numéro d objet de collection",statut='f',typ='I' ),  
+            NOMOC           =SIMP(fr="nom d'objet de collection",statut='f',typ='TXM' ),  
+         ),
+         b_attribut   =BLOC(condition = "(ENTITE=='ATTRIBUT')",
+            NOMOBJ          =SIMP(fr="nom de collection",statut='f',typ='TXM' ),  
+            NOMATR          =SIMP(fr="nom d attribut de collection",statut='f',typ='TXM',
+                                  into=('$$DESO','$$IADD','$$IADM','$$NOM','$$LONG',
+                                      '$$LONO','$$LUTI','$$NUM') ),
+         ),
+         b_systeme    =BLOC(condition = "(ENTITE=='SYSTEME')",
+            CLASSE          =SIMP(statut='o',typ='TXM',into=('G','V') ),  
+            NOMATR          =SIMP(fr="nom d attribut systeme",statut='f',typ='TXM',   
+                                  into=('$$CARA','$$IADD','$$GENR','$$TYPE','$$MARQ',
+                                      '$$DOCU','$$ORIG','$$RNOM','$$LTYP','$$LONG',
+                                      '$$LONO','$$DATE','$$LUTI','$$HCOD','$$INDX',
+                                      '$$TLEC','$$TECR','$$IADM','$$ACCE','$$USADI') ),
+         ),
+         b_repertoire =BLOC(condition = "(ENTITE=='REPERTOIRE')",
+            CLASSE          =SIMP(statut='f',typ='TXM',into=('G','V',' '),defaut=' '),  
+         ),
+         b_disque     =BLOC(condition = "(ENTITE=='DISQUE')",
+            CLASSE          =SIMP(statut='f',typ='TXM' ,into=('G','V',' '),defaut=' '),  
+         ),
+         b_enregist   =BLOC(condition = "(ENTITE=='ENREGISTREMENT')",
+            CLASSE          =SIMP(statut='f',typ='TXM' ,into=('G','V'),defaut='G'),  
+            NUMERO          =SIMP(statut='o',typ='I',val_min=1),  
+            INFO            =SIMP(statut='f',typ='I',into=(1,2),defaut=1),  
+         ),
+         IMPRESSION      =FACT(statut='f',
+           NOM             =SIMP(statut='f',typ='TXM' ),  
+           UNITE           =SIMP(statut='f',typ='I'),  
+         ),
+         COMMENTAIRE     =SIMP(statut='f',typ='TXM' ),  
+)  ;
+#& MODIF COMMANDE  DATE 06/05/2008   AUTEUR CORUS M.CORUS 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE CORUS M.CORUS
+
+IMPR_MACR_ELEM=PROC(nom="IMPR_MACR_ELEM",op= 160,
+                    UIinfo={"groupes":("Impression",)},
+         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") ),
+
+         b_plexus         =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_miss_3d       =BLOC(condition = "FORMAT == 'MISS_3D'",
+           regles=(EXCLUS('AMOR_REDUIT','LIST_AMOR'),),
+           UNITE           =SIMP(statut='f',typ='I',defaut= 26 ),
+           SOUS_TITRE      =SIMP(statut='f',typ='TXM',max='**'),
+           AMOR_REDUIT     =SIMP(statut='f',typ='R'  ,max='**'),
+           LIST_AMOR       =SIMP(statut='f',typ=listr8_sdaster ),
+           GROUP_MA_INTERF =SIMP(statut='o',typ=grma ,max='**'),
+           GROUP_MA_FLU_STR=SIMP(statut='f',typ=grma,max='**'),
+           GROUP_MA_FLU_SOL=SIMP(statut='f',typ=grma,max='**'),
+           GROUP_MA_SOL_SOL=SIMP(statut='f',typ=grma,max='**'),
+           GROUP_MA_CONTROL=SIMP(statut='f',typ=grma,max='**'),
+           FORMAT_R        =SIMP(statut='f',typ='TXM',defaut="1PE12.5",into=("1PE12.5","1PE16.9") ),
+           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 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 DEVESA G.DEVESA
+IMPR_MISS_3D=PROC(nom="IMPR_MISS_3D",op= 162,
+            UIinfo={"groupes":("Impression",)},
+         fr="Impression des données d'entrée pour une étude sismique avec MISS3D",
+         regles=(UN_PARMI('INST_INIT','FREQ_INIT'),
+                 PRESENT_PRESENT('INST_INIT','INST_FIN'),
+                 PRESENT_PRESENT('FREQ_INIT','FREQ_FIN'),),
+         MACR_ELEM_DYNA  =SIMP(statut='o',typ=macr_elem_dyna ),
+         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) ),
+           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",) ),
+         ),
+         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",) ),
+         ),
+         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",) ),
+         ),
+         DIRE_ONDE       =SIMP(statut='f',typ='R',min=3,max=3),
+         INST_INIT       =SIMP(statut='f',typ='R' ),
+         INST_FIN        =SIMP(statut='f',typ='R' ),
+         FREQ_INIT       =SIMP(statut='f',typ='R' ),
+         FREQ_FIN        =SIMP(statut='f',typ='R' ),
+         PAS             =SIMP(statut='o',typ='R' ),
+         UNITE           =SIMP(statut='f',typ='I',defaut= 26 ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 16/11/2009   AUTEUR DURAND C.DURAND 
+#            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 FOURNIER I.FOURNIER
+#
+from Macro.impr_oar_ops import impr_oar_ops
+IMPR_OAR =MACRO(nom="IMPR_OAR",op= impr_oar_ops, sd_prod=None,
+               fr="Impression au format OAR",
+               UIinfo={"groupes":("Impression",)},
+   TYPE_CALC = SIMP(statut='o', typ='TXM',into=('COMPOSANT', 'MEF', 'TUYAUTERIE')),
+   b_composant =BLOC(condition = "TYPE_CALC == 'COMPOSANT' ",
+      regles = (AU_MOINS_UN('RESU_MECA','RESU_THER')),
+      DIAMETRE = SIMP(statut='o', typ='R'),
+      ORIGINE  = SIMP(statut='o', typ='TXM', defaut='INTERNE', into=('INTERNE', 'EXTERNE')),
+      COEF_U   = SIMP(statut='f', typ='R',   defaut=1.0),
+      ANGLE_C  = SIMP(statut='o', typ='R',   defaut=0.0),
+      REVET    = SIMP(statut='f', typ='TXM', defaut='NON', into=('OUI', 'NON')),
+      RESU_MECA = FACT(statut='f', max='**',
+         NUM_CHAR  = SIMP(statut='o', typ='I'),
+         TYPE      = SIMP(statut='o', typ='TXM', defaut='FX', into=('FX', 'FY', 'FZ', 'MX', 'MY', 'MZ', 'PRE')),
+         TABLE     = SIMP(statut='o', typ=table_sdaster),
+         TABLE_S   = SIMP(statut='f', typ=table_sdaster)),
+      RESU_THER = FACT(statut='f', max='**',
+         NUM_TRAN  = SIMP(statut='o', typ='I'),
+         TABLE_T   = SIMP(statut='o', typ=table_sdaster),
+         TABLE_TEMP= SIMP(statut='o', typ=table_sdaster),
+         TABLE_S   = SIMP(statut='f', typ=table_sdaster),
+         TABLE_ST  = SIMP(statut='f', typ=table_sdaster)),
+         ),
+   b_mef = BLOC(condition = "TYPE_CALC == 'MEF' ",
+      regles = (AU_MOINS_UN('RESU_MECA','RESU_THER')),
+      DIAMETRE = SIMP(statut='o', typ='R'),
+      ORIGINE  = SIMP(statut='o', typ='TXM', defaut='INTERNE', into=('INTERNE', 'EXTERNE')),
+      COEF_U   = SIMP(statut='f', typ='R',   defaut=1.0),
+      RESU_MECA = FACT(statut='f', max='**',
+         AZI       = SIMP(statut='o', typ='R'),
+         TABLE_T   = SIMP(statut='o', typ=table_sdaster),
+         TABLE_F   = SIMP(statut='o', typ=table_sdaster),
+         TABLE_P   = SIMP(statut='o', typ=table_sdaster),
+         TABLE_CA  = SIMP(statut='o', typ=table_sdaster)),
+      RESU_THER=FACT(statut='f', max='**',
+         AZI       = SIMP(statut='o', typ='R'),
+         NUM_CHAR  = SIMP(statut='o', typ='I'),
+         TABLE_T   = SIMP(statut='o', typ=table_sdaster),
+         TABLE_TI  = SIMP(statut='o', typ=table_sdaster)),
+      ),
+   b_tuyauterie = BLOC(condition = "TYPE_CALC == 'TUYAUTERIE' ",
+      RESU_MECA = FACT(statut='o', max='**',
+         NUM_CHAR  = SIMP(statut='o', typ='I'),
+         TABLE     = SIMP(statut='o', typ=table_sdaster),
+         MAILLAGE  = SIMP(statut='o', typ=maillage_sdaster)),
+         ),
+   UNITE = SIMP(statut='f',typ='I',defaut=38),
+   AJOUT = SIMP(statut='f', typ='TXM', defaut='NON', into=('OUI', 'NON')),
+   );
+#& MODIF COMMANDE  DATE 12/10/2009   AUTEUR SELLENET N.SELLENET 
+#            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 SELLENET N.SELLENET
+IMPR_RESU=PROC(nom="IMPR_RESU",op=39,
+            UIinfo={"groupes":("Impression",)},
+               fr="Imprimer un maillage et/ou les résultats d'un calcul (différents formats)",
+         MODELE          =SIMP(statut='f',typ=modele_sdaster),
+
+         FORMAT          =SIMP(statut='f',typ='TXM',position='global',defaut="RESULTAT",
+                                 into=("RESULTAT","IDEAS","ASTER","CASTEM","ENSIGHT","MED","GMSH") ),
+
+         b_format_resultat  =BLOC(condition="FORMAT=='RESULTAT'",fr="unité logique d'impression au format RESULTAT",
+           UNITE           =SIMP(statut='f',typ='I',defaut=8),
+         ),
+
+         b_format_ideas  =BLOC(condition="FORMAT=='IDEAS'",fr="unité logique d'impression et version IDEAS",
+           UNITE           =SIMP(statut='f',typ='I',defaut=30),
+           VERSION         =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
+         ),
+
+         b_format_aster  =BLOC(condition="FORMAT=='ASTER'",fr="unité logique d'impression au format ASTER",
+           UNITE           =SIMP(statut='f',typ='I',defaut=26),
+         ),
+
+         b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="unité logique d'impression et version CASTEM",
+           UNITE           =SIMP(statut='f',typ='I',defaut=37),
+           NIVE_GIBI       =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
+         ),
+
+         b_format_ensight  =BLOC(condition="FORMAT=='ENSIGHT'",fr="unité logique d'impression au format ENSIGHT",
+           UNITE           =SIMP(statut='f',typ='I',defaut=31),
+         ),
+
+         b_format_med  =BLOC(condition="FORMAT=='MED'",fr="unité logique d'impression au format MED",
+           UNITE           =SIMP(statut='f',typ='I',defaut=80),
+         ),
+
+         b_format_gmsh  =BLOC(condition="FORMAT=='GMSH'",fr="unité logique d'impression et version GMSH",
+           UNITE           =SIMP(statut='f',typ='I',defaut=37),
+           VERSION         =SIMP(statut='f',typ='R',defaut=1.2,into=(1.0,1.2)),
+         ),
+
+
+         RESTREINT   =FACT(statut='f', max=1,
+           fr="Pour réduire une ou plusieurs sd_resultat sur un ensemble de mailles",
+           regles=(AU_MOINS_UN('GROUP_MA','MAILLE',),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+           TOUT_GROUP_MA   =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           TOUT_GROUP_NO   =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON'),),
+         ),
+
+         RESU            =FACT(statut='o',max='**',
+
+           regles=(AU_MOINS_UN('CHAM_GD','RESULTAT','MAILLAGE'),
+                   EXCLUS('CHAM_GD','RESULTAT'),),
+           MAILLAGE        =SIMP(statut='f',typ=(maillage_sdaster,squelette)),
+           CHAM_GD         =SIMP(statut='f',typ=cham_gd_sdaster),
+           RESULTAT        =SIMP(statut='f',typ=resultat_sdaster),
+
+           b_info_med  =BLOC(condition="FORMAT=='MED'",
+             INFO_MAILLAGE   =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           ),
+
+           b_sensibilite   =BLOC(condition="RESULTAT != None",
+                                 fr="Définition des paramètres de sensibilité",
+                                 ang="Definition of sensitivity parameters",
+             regles=(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"),),
+
+           b_partie        =BLOC(condition="""(AsType(RESULTAT) in (dyna_harmo, acou_harmo) or
+                          AsType(CHAM_GD) != carte_sdaster) and FORMAT in ('CASTEM', 'GMSH', 'MED')""",
+             PARTIE          =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ),
+           ),
+           b_extrac        =BLOC(condition="RESULTAT != None",
+                                 fr="extraction d un champ de grandeur",
+             regles=(EXCLUS('TOUT_CHAM','NOM_CHAM'),
+                     EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE','NOEUD_CMP',
+                            'LIST_INST','LIST_FREQ','LIST_ORDRE','NOM_CAS','ANGL'),),
+             TOUT_CHAM       =SIMP(statut='f',typ='TXM',into=("OUI","NON") ),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',into=C_NOM_CHAM_INTO()),
+
+             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='**'),
+             LIST_ORDRE      =SIMP(statut='f',typ=listis_sdaster),
+             NOEUD_CMP       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+             NOM_CAS         =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+             ANGL            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+             FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+             LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster),
+             INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+             LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+
+             b_acce_reel     =BLOC(condition="(FREQ != None)or(LIST_FREQ != None)or(INST != None)or(LIST_INST != None)",
+                CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),),
+                b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+                     PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,),),
+                b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                     PRECISION       =SIMP(statut='o',typ='R',),),
+             ),
+           ),
+###
+           b_parametres    =BLOC(condition="""(RESULTAT != None)and(FORMAT == 'RESULTAT')""",
+             regles=(EXCLUS('TOUT_PARA','NOM_PARA'),),
+             INFO_RESU       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+             TOUT_PARA       =SIMP(statut='f',typ='TXM',into=("OUI","NON",) ),
+             NOM_PARA        =SIMP(statut='f',typ='TXM',max='**'),
+             FORM_TABL       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON","EXCEL") ),
+           ),
+###
+           b_cmp=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and\
+           ((FORMAT == 'CASTEM')or(FORMAT == 'RESULTAT')or(FORMAT == 'IDEAS')or(FORMAT == 'ENSIGHT')or(FORMAT == 'MED'))""",
+                                fr="sélection des composantes",
+             regles=(EXCLUS('TOUT_CMP','NOM_CMP'),),
+             TOUT_CMP        =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),
+           ),
+###
+           b_gmsh=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and((FORMAT == 'GMSH'))""",
+                                fr="sélection des composantes et des entités toplogiques",
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+             TYPE_CHAM       =SIMP(statut='f',typ='TXM',defaut="SCALAIRE",
+                                   into=("VECT_2D","VECT_3D","SCALAIRE","TENS_2D","TENS_3D"),),
+             b_scal          =BLOC(condition = "TYPE_CHAM=='SCALAIRE'",
+               NOM_CMP         =SIMP(statut='f',typ='TXM',max='**' ),),
+             b_vect_2d       =BLOC(condition = "TYPE_CHAM=='VECT_2D'",
+               NOM_CMP         =SIMP(statut='o',typ='TXM',min=2,max=2 ),),
+             b_vect_3d       =BLOC(condition = "TYPE_CHAM=='VECT_3D'",
+               NOM_CMP         =SIMP(statut='o',typ='TXM',min=3,max=3 ),),
+             b_tens_2d       =BLOC(condition = "TYPE_CHAM=='TENS_2D'",
+               NOM_CMP         =SIMP(statut='o',typ='TXM',min=4,max=4 ),),
+             b_tens_3d       =BLOC(condition = "TYPE_CHAM=='TENS_3D'",
+               NOM_CMP         =SIMP(statut='o',typ='TXM',min=6,max=6 ),),
+           ),
+###
+           b_topologie=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and\
+           ((FORMAT == 'RESULTAT')or(FORMAT == 'IDEAS')or(FORMAT == 'MED'))""",
+                                fr="sélection des entités topologiques",
+             TOUT            =SIMP(statut='f',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_valeurs=BLOC(condition="(FORMAT == 'RESULTAT')",
+                               fr="sélection sur les valeurs",
+             VALE_MAX        =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             VALE_MIN        =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             BORNE_SUP       =SIMP(statut='f',typ='R'),
+             BORNE_INF       =SIMP(statut='f',typ='R'),
+             IMPR_COOR       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+             FORMAT_R        =SIMP(statut='f',typ='TXM',defaut="1PE12.5"),
+           ),
+
+           SOUS_TITRE      =SIMP(statut='f',typ='TXM',max='**'),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+) ;
+#& MODIF COMMANDE  DATE 05/05/2008   AUTEUR NISTOR I.NISTOR 
+#            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 NISTOR I.NISTOR
+
+IMPR_STURM=PROC(nom="IMPR_STURM",op=32,fr="Calculer et imprimer le nombre de valeurs propres dans un intervalle donné",
+            UIinfo={"groupes":("Résolution",)},
+         MATR_A          =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ),
+         MATR_B          =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ),
+         TYPE_RESU       =SIMP(statut='f',typ='TXM',defaut="DYNAMIQUE",into=("MODE_FLAMB","DYNAMIQUE"),
+                               fr="Type d analyse" ),
+         b_dynamique  =BLOC(condition = "TYPE_RESU == 'DYNAMIQUE'",
+                            fr="Recheche du nombre de fréquences propres",
+             FREQ_MIN        =SIMP(statut='f',typ='R',defaut= 0.E+0 ,fr="Borne inférieure de l intervalle" ),
+             FREQ_MAX        =SIMP(statut='o',typ='R',fr="Borne supérieure de l intervalle" ),
+         ),
+         b_mode_flamb =BLOC(condition = "TYPE_RESU == 'MODE_FLAMB'",
+                            fr="Recherche du nombre de charges critiques",
+             CHAR_CRIT_MIN   =SIMP(statut='o',typ='R',fr="Borne inférieure de l intervalle" ),
+             CHAR_CRIT_MAX   =SIMP(statut='o',typ='R',fr="Borne supérieure de l intervalle" ),
+         ),
+         NPREC_SOLVEUR   =SIMP(statut='f',typ='I',defaut= 8 ),
+         NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5 ),
+         UNITE           =SIMP(statut='f',typ='I',defaut=8),  
+         PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
+         SEUIL_FREQ      =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
+)  ;
+#& MODIF COMMANDE  DATE 06/05/2008   AUTEUR CNGUYEN C.NGUYEN 
+#            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
+from Macro.impr_table_ops import impr_table_ops
+
+IMPR_TABLE=MACRO(nom="IMPR_TABLE",op=impr_table_ops,sd_prod=None,
+            UIinfo={"groupes":("Impression",)},
+                fr="Impression du contenu d'une table dans un fichier",
+           regles=(DERIVABLE("TABLE"),),
+   TABLE          =SIMP(statut='o',typ=table_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"),
+   FORMAT         =SIMP(statut='f',typ='TXM',defaut="TABLEAU",
+                         into=("TABLEAU","ASTER","TABLEAU_CROISE","AGRAF","XMGRACE",),),
+   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"),
+   ),
+   b_unite        =BLOC(condition = "FORMAT != 'XMGRACE'",
+      UNITE          =SIMP(statut='f',typ='I',defaut=8,
+                           fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+   ),
+   FILTRE         =FACT(statut='f',max='**',
+      NOM_PARA       =SIMP(statut='o',typ='TXM'),
+      CRIT_COMP      =SIMP(statut='f',typ='TXM',defaut="EQ",
+                           into=("EQ","LT","GT","NE","LE","GE","VIDE",
+                                 "NON_VIDE","MAXI","ABS_MAXI","MINI","ABS_MINI"),),
+      b_vale         =BLOC(condition = "(CRIT_COMP in ('EQ','NE','GT','LT','GE','LE'))",
+         regles=(UN_PARMI('VALE','VALE_I','VALE_K','VALE_C',),),
+         VALE           =SIMP(statut='f',typ='R',max='**'),
+         VALE_I         =SIMP(statut='f',typ='I',max='**'),
+         VALE_C         =SIMP(statut='f',typ='C',max='**'),
+         VALE_K         =SIMP(statut='f',typ='TXM',max='**'),
+      ),
+      b_crit         =BLOC(condition = "CRIT_COMP in ('EQ','NE')",
+         CRITERE        =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+         PRECISION      =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+      ),
+   ),
+   TRI            =FACT(statut='f',
+      NOM_PARA       =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+      ORDRE          =SIMP(statut='f',typ='TXM',defaut="CROISSANT", # max='**',
+                           into=("CROISSANT","DECROISSANT") ),
+   ),
+   PAGINATION     =SIMP(statut='f',typ='TXM',max='**'),
+   FORMAT_R       =SIMP(statut='f',typ='TXM',defaut="E12.5"),
+   FORMAT_C       =SIMP(statut='f',typ='TXM',defaut="MODULE_PHASE",
+                              into=("MODULE_PHASE","REEL_IMAG") ),
+   NOM_PARA       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+   IMPR_FONCTION  =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+
+   # Mise en page du tableau ou du graphique
+   b_tableau = BLOC(condition = "FORMAT == 'TABLEAU'",
+                    fr="Mots-clés propres au format Tableau",
+      SEPARATEUR      =SIMP(statut='f',typ='TXM',defaut=' ',
+                            fr="Séparateur des colonnes du tableau (ex : ' ', ';'...)"),
+      COMMENTAIRE     =SIMP(statut='f',typ='TXM',defaut='#',
+                            fr="Caractère indiquant au traceur de fonction que la ligne peut etre ignorée"),
+      COMM_PARA       =SIMP(statut='f',typ='TXM',defaut='',
+                            fr="Caractère utilisé pour commentariser la ligne des labels de colonnes"),
+      DEBUT_LIGNE     =SIMP(statut='f',typ='TXM',defaut='',
+                            fr="Caractère de debut de ligne"),
+      FIN_LIGNE       =SIMP(statut='f',typ='TXM',defaut='\n',
+                            fr="Caractère de fin de ligne"),
+    ),
+
+   # mise en forme pour les formats qui passent par Graph
+   b_forme         =BLOC(condition = "FORMAT == 'XMGRACE'",
+                         fr="Données de mise en forme du graphique",
+      # pour la courbe
+      LEGENDE         =SIMP(statut='f',typ='TXM',
+                            fr="Légende associée à la fonction" ),
+      STYLE           =SIMP(statut='f',typ='I',val_min=0,
+                            fr="Style de la ligne représentant la fonction",),
+      COULEUR         =SIMP(statut='f',typ='I',val_min=0,
+                            fr="Couleur associée à la fonction",),
+      MARQUEUR        =SIMP(statut='f',typ='I',val_min=0,
+                            fr="Type du marqueur associé à la fonction",),
+      FREQ_MARQUEUR   =SIMP(statut='f',typ='I',defaut=0,
+                            fr="Fréquence d impression du marqueur associé à la fonction", ),
+      # format du graphique
+      BORNE_X         =SIMP(statut='f',typ='R',min=2,max=2,
+                            fr="Intervalles de variation des abscisses"),
+      BORNE_Y         =SIMP(statut='f',typ='R',min=2,max=2,
+                            fr="Intervalles de variation des ordonnées"),
+      ECHELLE_X       =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
+                            fr="Type d'échelle pour les abscisses" ),
+      ECHELLE_Y       =SIMP(statut='f',typ='TXM',defaut="LIN",into=("LIN","LOG"),
+                            fr="Type d'échelle pour les ordonnées" ),
+      GRILLE_X        =SIMP(statut='f',typ='R',max=1,val_min=0.,
+                            fr="Pas du quadrillage vertical" ),
+      GRILLE_Y        =SIMP(statut='f',typ='R',max=1,val_min=0.,
+                            fr="Pas du quadrillage horizontal" ),
+      LEGENDE_X       =SIMP(statut='f',typ='TXM',
+                            fr="Légende associée à l'axe des abscisses" ),
+      LEGENDE_Y       =SIMP(statut='f',typ='TXM',
+                            fr="Légende associée à l'axe des ordonnées" ),
+   ),
+
+   TITRE          =SIMP(statut='f',typ='TXM',max='**'),
+   INFO           =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 DURAND C.DURAND
+INCLUDE=MACRO(nom="INCLUDE",op=ops.build_include,
+            UIinfo={"groupes":("Gestion du travail",)},
+             fr="Débranchement vers un fichier de commandes secondaires",
+             sd_prod=ops.INCLUDE,op_init=ops.INCLUDE_context,fichier_ini=1,
+         UNITE = SIMP(statut='o',typ='I'),
+         INFO  = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DURAND C.DURAND
+INCLUDE_MATERIAU=MACRO(nom="INCLUDE_MATERIAU",op=-14,
+            UIinfo={"groupes":("Modélisation",)},
+         fr="Récupérer les caractéristiques d'un matériau dans le Catalogue Materiaux d'Aster ",
+         sd_prod=ops.INCLUDE_MATERIAU,op_init=ops.INCLUDE_context,fichier_ini=0,
+         NOM_AFNOR       =SIMP(statut='o',typ='TXM' ),  
+         TYPE_MODELE     =SIMP(statut='o',typ='TXM',into=("REF","PAR") ),
+         VARIANTE        =SIMP(statut='o',typ='TXM',     
+                               into=("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",) ),
+         TYPE_VALE       =SIMP(statut='o',typ='TXM',into=("NOMI","MINI","MAXI") ),
+         NOM_MATER       =SIMP(statut='o',typ='TXM' ),  
+         UNITE           =SIMP(statut='f',typ='I',defaut= 32 ),  
+         EXTRACTION      =FACT(statut='f',max=99,
+           COMPOR          =SIMP(statut='o',typ='TXM' ),  
+           TEMP_EVAL       =SIMP(statut='o',typ='R' ),  
+         ),
+         UNITE_LONGUEUR  =SIMP(statut='f',typ='TXM',into=("M","MM"),defaut="M" ),  
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 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 LEFEBVRE J.P.LEFEBVRE
+INFO_EXEC_ASTER=OPER(nom="INFO_EXEC_ASTER",op=35,sd_prod=table_sdaster,
+                    fr="Récupère différentes informations propres à l'exécution en cours",
+                    reentrant='n',
+                    UIinfo={"groupes":("Gestion du travail",)},
+
+         regles=(),
+         LISTE_INFO     =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=3,
+                              into=("CPU_RESTANT","UNITE_LIBRE","ETAT_UNITE"),),
+         b_etat_unite   =BLOC(condition = "'ETAT_UNITE' in LISTE_INFO", 
+            regles=(UN_PARMI('UNITE','FICHIER'),),
+            UNITE          =SIMP(statut='f',typ='I',val_min=1,val_max=99,max=1,
+                                 fr="Unité logique dont on veut obtenir l'état",),
+            FICHIER        =SIMP(statut='f',typ='TXM',validators=LongStr(1,255),
+                                 fr="Nom du fichier dont on veut obtenir l'état",),
+         ),
+         TITRE          =SIMP(statut='f',typ='TXM',max='**'),
+         INFO           =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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
+from Macro.info_fonction_ops import info_fonction_ops
+def info_fonction_prod(self,ECART_TYPE,RMS,NOCI_SEISME,MAX,NORME, **args):
+   if (RMS         != None): return table_sdaster
+   if (MAX         != None): return table_sdaster
+   if (NOCI_SEISME != None): return table_sdaster
+   if (ECART_TYPE  != None): return table_sdaster
+   if (NORME       != None): return table_sdaster
+   raise AsException("type de concept resultat non prevu")
+
+INFO_FONCTION=MACRO(nom="INFO_FONCTION",op=info_fonction_ops,sd_prod=info_fonction_prod
+                    ,fr="Opérations mathématiques sur des concepts de type fonction, fonction_c ou nappe",
+                     reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         regles=(UN_PARMI('MAX','RMS','NOCI_SEISME','NORME','ECART_TYPE',),),
+         RMS             =FACT(statut='f',fr="Valeur RMS d'une fonction",max='**',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="TRAPEZE",into=("SIMPSON","TRAPEZE") ),
+           FONCTION        =SIMP(statut='o',typ=fonction_sdaster ),
+           INST_INIT       =SIMP(statut='f',typ='R',fr="Instant initial définissant le début du signal" ),
+           INST_FIN        =SIMP(statut='f',typ='R',fr="Instant final définissant la fin du signal" ),
+           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,val_min=0.E+0),),
+           b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+              PRECISION       =SIMP(statut='o',typ='R'),),
+         ),
+         NOCI_SEISME     =FACT(statut='f',
+           regles=(UN_PARMI('FONCTION','SPEC_OSCI',),),
+           FONCTION        =SIMP(statut='f',typ=fonction_sdaster ),
+           SPEC_OSCI       =SIMP(statut='f',typ=nappe_sdaster ),
+           b_option_f      =BLOC(condition="""FONCTION !=None""",
+             OPTION          =SIMP(statut='f',typ='TXM',defaut="TOUT",validators=NoRepeat(),max='**',
+                                   into=("INTE_ARIAS","POUV_DEST","INTE_SPEC","VITE_ABSO_CUMU",
+                                         "DUREE_PHAS_FORT","MAXI","ACCE_SUR_VITE","TOUT",), ),
+             b_amor_red          =BLOC(condition="""OPTION in ("TOUT", "INTE_SPEC") """,
+                AMOR_REDUIT     =SIMP(statut='o',typ='R'),),
+             b_pesanteur         =BLOC(condition="""OPTION in ("TOUT", "INTE_ARIAS", "POUV_DEST", "DUREE_PHAS_FORT") """,
+                PESANTEUR       =SIMP(statut='o',typ='R'),),
+           ),
+           b_option_n      =BLOC(condition="""SPEC_OSCI !=None""",
+             OPTION          =SIMP(statut='f',typ='TXM',defaut="INTE_SPEC",into=("INTE_SPEC",), ),
+             NATURE          =SIMP(statut='o',typ='TXM',into=("DEPL","VITE","ACCE") ),
+             AMOR_REDUIT     =SIMP(statut='o',typ='R'), ),
+           INST_INIT       =SIMP(statut='f',typ='R'),
+           INST_FIN        =SIMP(statut='f',typ='R'),
+           COEF            =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+           FREQ_INIT       =SIMP(statut='f',typ='R',defaut= 4.E-1 ),
+           FREQ_FIN        =SIMP(statut='f',typ='R',defaut= 10.E+0 ),
+           LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster ),
+           FREQ            =SIMP(statut='f',typ='R',max='**'),
+           NORME           =SIMP(statut='f',typ='R',defaut= 1.E+0 ),
+           BORNE_INF       =SIMP(statut='f',typ='R',defaut= 0.05E+0 ),
+           BORNE_SUP       =SIMP(statut='f',typ='R',defaut= 0.95E+0 ),
+           b_acce_reel     =BLOC(condition="(INST_INIT != None)or(INST_FIN != None)or(FREQ_INIT != None)or(FREQ_FIN != 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,val_min=0.E+0),),
+                  b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                      PRECISION       =SIMP(statut='o',typ='R'),),
+           ),
+         ),
+         MAX             =FACT(statut='f',fr="Extrémas locaux d'une fonction",
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster),max='**' ),
+         ),
+         NORME           =FACT(statut='f',fr="Norme L2 d'une fonction",
+            FONCTION      =SIMP(statut='o', typ=nappe_sdaster),
+         ),     
+         ECART_TYPE      =FACT(statut='f',fr="Ecart-type d'une fonction",
+            METHODE       =SIMP(statut='f',typ='TXM',defaut="TRAPEZE",into=("SIMPSON","TRAPEZE") ),
+            FONCTION      =SIMP(statut='o',typ=fonction_sdaster),
+            INST_INIT     =SIMP(statut='f',typ='R',fr="Instant initial définissant le début du signal" ),
+            INST_FIN      =SIMP(statut='f',typ='R',fr="Instant final définissant la fin du signal" ),
+            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,val_min=0.E+0),),
+            b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                PRECISION       =SIMP(statut='o',typ='R'),),
+         ),     
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+INTE_MAIL_2D=OPER(nom="INTE_MAIL_2D",op=50,sd_prod=courbe_sdaster,
+            UIinfo={"groupes":("Post traitements",)},
+                  fr="Définition d'une courbe dans un maillage 2D",reentrant='n',
+
+         MAILLAGE        =SIMP(statut='o',typ=(maillage_sdaster) ),
+
+         regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+                 AU_MOINS_UN('DEFI_SEGMENT','DEFI_ARC','DEFI_CHEMIN'),
+                 PRESENT_ABSENT('DEFI_CHEMIN','DEFI_SEGMENT','DEFI_ARC'),
+                 PRESENT_ABSENT('DEFI_SEGMENT','NOEUD_ORIG','GROUP_NO_ORIG'),
+                 PRESENT_ABSENT('DEFI_ARC','NOEUD_ORIG','GROUP_NO_ORIG'),
+                 EXCLUS('NOEUD_ORIG','GROUP_NO_ORIG'),
+                 EXCLUS('DEFI_CHEMIN','DEFI_SEGMENT'),
+                 EXCLUS('DEFI_CHEMIN','DEFI_ARC'),),
+
+         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='**'),
+
+         DEFI_SEGMENT    =FACT(statut='f',max='**',
+           regles=(UN_PARMI('ORIGINE','NOEUD_ORIG','GROUP_NO_ORIG'),
+                   UN_PARMI('EXTREMITE','NOEUD_EXTR','GROUP_NO_EXTR'),),
+           ORIGINE         =SIMP(statut='f',typ='R',min=2,max=2),  
+           NOEUD_ORIG      =SIMP(statut='f',typ=no,),
+           GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
+           EXTREMITE       =SIMP(statut='f',typ='R',min=2,max=2),  
+           NOEUD_EXTR      =SIMP(statut='f',typ=no,),
+           GROUP_NO_EXTR   =SIMP(statut='f',typ=grno,),
+         ),
+
+         DEFI_ARC        =FACT(statut='f',max='**',
+           regles=(UN_PARMI('CENTRE','NOEUD_CENTRE','GROUP_NO_CENTRE'),
+                   UN_PARMI('RAYON','ORIGINE','NOEUD_ORIG','GROUP_NO_ORIG'),
+                   UN_PARMI('RAYON','EXTREMITE','NOEUD_EXTR','GROUP_NO_EXTR'),               
+                   PRESENT_PRESENT('RAYON','SECTEUR'),),
+           CENTRE          =SIMP(statut='f',typ='R',min=2,max=2),  
+           NOEUD_CENTRE    =SIMP(statut='f',typ=no,),
+           GROUP_NO_CENTRE =SIMP(statut='f',typ=grno,),
+           RAYON           =SIMP(statut='f',typ='R',val_min=0.E+0),  
+           SECTEUR         =SIMP(statut='f',typ='R',min=2,max=2,
+                                 val_min=-180.E+0,val_max=180E+0),  
+           ORIGINE         =SIMP(statut='f',typ='R',min=2,max=2),  
+           NOEUD_ORIG      =SIMP(statut='f',typ=no,),
+           GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
+           EXTREMITE       =SIMP(statut='f',typ='R',min=2,max=2),  
+           NOEUD_EXTR      =SIMP(statut='f',typ=no,),
+           GROUP_NO_EXTR   =SIMP(statut='f',typ=grno,),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),  
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",    
+                                 into=("RELATIF","ABSOLU",) ),
+         ),
+
+         DEFI_CHEMIN     =FACT(statut='f',max='**',
+           regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+         ),
+
+         NOEUD_ORIG      =SIMP(statut='f',typ=no,),
+         GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
+         PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-3),  
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+INTE_MAIL_3D=OPER(nom="INTE_MAIL_3D",op=96,sd_prod=surface_sdaster,
+            UIinfo={"groupes":("Post traitements",)},
+                  fr="Définir un chemin de type segment de droite dans un maillage 3D",reentrant='n',
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster),
+         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='**'),
+         DEFI_SEGMENT    =FACT(statut='o',max='**',
+           regles=(UN_PARMI('ORIGINE','NOEUD_ORIG','GROUP_NO_ORIG'),
+                   UN_PARMI('EXTREMITE','NOEUD_EXTR','GROUP_NO_EXTR'),),
+           ORIGINE         =SIMP(statut='f',typ='R',min=3,max=3),  
+           NOEUD_ORIG      =SIMP(statut='f',typ=no,),
+           GROUP_NO_ORIG   =SIMP(statut='f',typ=grno,),
+           EXTREMITE       =SIMP(statut='f',typ='R',min=3,max=3),  
+           NOEUD_EXTR      =SIMP(statut='f',typ=no,),
+           GROUP_NO_EXTR   =SIMP(statut='f',typ=grno,),
+         ),
+         PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-6),  
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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
+def lire_champ_prod(TYPE_CHAM=None,**args):
+# Remarque : si cette liste évolue, il faut penser à mettre à jour son
+#            homologue dans macr_adap_mail
+  import string
+#  
+  if TYPE_CHAM[0:5] == "NOEU_" : return cham_no_sdaster
+  if TYPE_CHAM[0:2] == "EL"    : return cham_elem
+  raise AsException("type de concept resultat non prevu")
+
+LIRE_CHAMP=OPER(nom="LIRE_CHAMP",op= 192,sd_prod=lire_champ_prod,
+                fr="Lire un champ dans un fichier au format MED et le stocker dans un concept.",
+                reentrant='n',UIinfo={"groupe":("Résultats et champs",)},
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster,),
+         FORMAT          =SIMP(statut='f',typ='TXM',defaut="MED",into=("MED",),),
+         UNITE           =SIMP(statut='f',typ='I',defaut= 81,),  
+         b_format =BLOC(condition = "FORMAT == 'MED'",
+         regles=( UN_PARMI('NOM_CMP_IDEM','NOM_CMP'),
+                  PRESENT_PRESENT('NOM_CMP','NOM_CMP_MED' ),
+                  EXCLUS('NUME_ORDRE','INST'),
+                  EXCLUS('NUME_PT','INST'),),
+            NOM_MED      =SIMP(statut='o',typ='TXM', ),
+            NOM_CMP_IDEM =SIMP(statut='f',typ='TXM',into=("OUI",), ),
+            NOM_CMP      =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',),
+            NOM_CMP_MED  =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',),
+            PROL_ZERO    =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),
+               fr="Affecte des valeurs nulles la ou le champ n'est pas defini (sinon il y a NaN)"),
+            NUME_PT      =SIMP(statut='f',typ='I'  ,validators=NoRepeat(),max='**',),
+            NUME_ORDRE   =SIMP(statut='f',typ='I'  ,validators=NoRepeat(),max='**',
+                           fr="Numero d ordre du champ à lire",ang="Rank of the field to be read" ),
+            INST         =SIMP(statut='f',typ='R',fr="Instant associé",ang="Instant" ),
+#
+            b_precision     =BLOC(condition="(INST != None)",
+                  CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),
+                  fr="Critère de précision sur le choix de l'instant associé",
+                  ang="Accuracy criterium over instant choice" ),
+                  b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+                      PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,
+                      fr="Précision sur le choix de l'instant associé",ang="Accuracy over instant choice" ),),
+                  b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+                      PRECISION       =SIMP(statut='o',typ='R',
+                      fr="Précision sur le choix de l'instant associé",ang="Accuracy over instant choice" ),),),
+#
+            NOM_MAIL_MED =SIMP(statut='f',typ='TXM',),
+                  ),
+#        Remarque : si cette liste évolue, il faut penser à mettre à jour son
+#                   homologue dans macr_adap_mail
+         TYPE_CHAM       =SIMP(statut='o',typ='TXM',into=C_TYPE_CHAM_INTO()),
+         b_modele =BLOC(condition = "TYPE_CHAM!=None and TYPE_CHAM[0:2] == 'EL'",
+            MODELE      =SIMP(statut='o',typ=modele_sdaster, ),
+                  ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# 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
+
+from Macro.lire_fonction_ops import lire_fonction_ops
+
+def lire_fonction_prod(self,TYPE,**args):
+  if   (TYPE == 'FONCTION')  : return fonction_sdaster
+  elif (TYPE == 'FONCTION_C'): return fonction_c
+  elif (TYPE == 'NAPPE'   )  : return nappe_sdaster
+  raise AsException("type de concept resultat non prevu")
+
+LIRE_FONCTION=MACRO(nom="LIRE_FONCTION",op=lire_fonction_ops,sd_prod=lire_fonction_prod,
+                   fr="Lit les valeurs réelles dans un fichier de données représentant une fonction et"
+                     +" crée un concept de type fonction ou nappe",
+                   reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         FORMAT          =SIMP(statut='f',typ='TXM',into=("LIBRE",),defaut="LIBRE"  ),
+         TYPE            =SIMP(statut='f',typ='TXM',into=("FONCTION","FONCTION_C","NAPPE"),defaut="FONCTION"  ),
+         SEPAR           =SIMP(statut='f',typ='TXM',into=("None",",",";","/"),defaut="None" ),
+         INDIC_PARA      =SIMP(statut='f',typ='I',min=2,max=2,defaut=[1,1]),
+         b_fonction      =BLOC(condition = "TYPE=='FONCTION' ",
+           INDIC_RESU      =SIMP(statut='f',typ='I',min=2,max=2,defaut=[1,2]), ),
+         b_fonction_c    =BLOC(condition = "TYPE=='FONCTION_C' ",
+           FORMAT_C        =SIMP(statut='f',typ='TXM',defaut="REEL_IMAG",into=("REEL_IMAG","MODULE_PHASE") ),
+           b_reel_imag     =BLOC(condition = "FORMAT_C=='REEL_IMAG' ",
+             INDIC_REEL      =SIMP(statut='o',typ='I',min=2,max=2,defaut=[1,2]),
+             INDIC_IMAG      =SIMP(statut='o',typ='I',min=2,max=2,defaut=[1,3]), ) ,
+           b_modu_phas     =BLOC(condition = "FORMAT_C=='MODULE_PHASE' ",
+             INDIC_MODU      =SIMP(statut='o',typ='I',min=2,max=2,defaut=[1,2]),
+             INDIC_PHAS      =SIMP(statut='o',typ='I',min=2,max=2,defaut=[1,3]), ), ),
+         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") ),
+           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='**',
+             INDIC_RESU      =SIMP(statut='o',typ='I',min=2,max=2,),),  ),
+         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") ),
+         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") ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 DEVESA G.DEVESA
+LIRE_FORC_MISS=OPER(nom="LIRE_FORC_MISS",op= 179,sd_prod=vect_asse_gene,
+                    fr="Création d un vecteur assemblé à partir de base modale",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},           
+         BASE            =SIMP(statut='o',typ=mode_meca),
+         NUME_DDL_GENE   =SIMP(statut='o',typ=nume_ddl_gene ),
+         FREQ_EXTR       =SIMP(statut='o',typ='R',max=1),
+         NOM_CMP         =SIMP(statut='o',typ='TXM',into=("DX","DY","DZ") ),
+         NOM_CHAM        =SIMP(statut='f',typ='TXM',into=("DEPL","VITE","ACCE"),defaut="DEPL"),
+         UNITE_RESU_FORC =SIMP(statut='f',typ='I',defaut=30),
+)  ;
+
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 DEVESA G.DEVESA
+LIRE_IMPE_MISS=OPER(nom="LIRE_IMPE_MISS",op= 164,sd_prod=matr_asse_gene_c,
+                    fr="Création d une matrice assemblée à partir de base modale",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},           
+         BASE            =SIMP(statut='o',typ=mode_meca ),
+         NUME_DDL_GENE   =SIMP(statut='o',typ=nume_ddl_gene ),
+         FREQ_EXTR       =SIMP(statut='o',typ='R',max=1),
+         UNITE_RESU_IMPE =SIMP(statut='f',typ='I',defaut=30),
+         TYPE            =SIMP(statut='f',typ='TXM',defaut="ASCII",into=("BINAIRE","ASCII") ),         
+)  ;
+
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ZENTNER I.ZENTNER
+
+from Macro.lire_inte_spec_ops import lire_inte_spec_ops
+
+LIRE_INTE_SPEC=MACRO(nom="LIRE_INTE_SPEC",op=lire_inte_spec_ops,sd_prod=table_fonction,
+                    fr="Lecture sur un fichier externe de fonctions complexes pour créer une matrice interspectrale",
+                    reentrant='n',
+            UIinfo={"groupes":("Fonction",)},
+         UNITE           =SIMP(statut='o',typ='I' ),
+         FORMAT_C        =SIMP(statut='f',typ='TXM',defaut="MODULE_PHASE",into=("REEL_IMAG","MODULE_PHASE") ),
+         FORMAT          =SIMP(statut='f',typ='TXM',defaut="ASTER",into=("ASTER","IDEAS") ),
+         NOM_PARA        =SIMP(statut='f',typ='TXM',defaut="FREQ",
+                               into=("DX","DY","DZ","DRX","DRY","DRZ","TEMP",
+                                     "INST","X","Y","Z","EPSI","FREQ","PULS","AMOR","ABSC",) ),
+         NOM_RESU        =SIMP(statut='f',typ='TXM',defaut="DSP" ),
+         INTERPOL        =SIMP(statut='f',typ='TXM',max=2,into=("NON","LIN","LOG") ),
+         PROL_DROITE     =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
+         PROL_GAUCHE     =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+LIRE_MAILLAGE=OPER(nom="LIRE_MAILLAGE",op=   1,sd_prod=maillage_sdaster,
+                   fr="Crée un maillage par lecture d'un fichier au format Aster ou Med",
+                   ang="Readings of a mesh file",
+                   reentrant='n',
+            UIinfo={"groupes":("Maillage",)},
+#
+         UNITE           =SIMP(statut='f',typ='I',defaut= 20 ),
+#
+         FORMAT          =SIMP(statut='f',typ='TXM',defaut="ASTER",into=("ASTER","MED"),
+                            fr="Format du fichier : ASTER ou MED.",
+                            ang="Format of the file : ASTER or MED.",),
+#
+         ABSC_CURV       =FACT(statut='f',min=0,
+               TOUT          =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         ),
+#
+         VERI_MAIL       =FACT(statut='d',
+               VERIF         =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),  
+               APLAT         =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),  
+         ),
+#
+         b_format_med =BLOC( condition = " ( FORMAT == 'MED' ) " ,
+                             fr="Informations complémentaires pour la lecture MED.",
+                             ang="Further information for MED readings.",
+#
+# Pour une lecture dans un fichier MED, on peut préciser le nom sous lequel
+# le maillage y a été enregistré. Par défaut, on va le chercher sous le nom du concept à créer.
+            NOM_MED    = SIMP(statut='f',typ='TXM',
+                              fr="Nom du maillage dans le fichier MED.",
+                              ang="Name of the mesh into the MED file.",),
+            INFO_MED   = SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+#
+            RENOMME = FACT(statut='f', max='**',
+                                 fr="Renommer un nom de groupe MED",
+                 NOM_MED     = SIMP(statut='o', typ=grma,
+                                    fr="Nom du groupe dans le fichier MED"),
+                 NOM         = SIMP(statut='o', typ=grma, validators=LongStr(1,8),
+                                    fr="Nom du groupe dans le maillage ASTER"),
+            ),
+         ),
+#
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+#
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DEVESA G.DEVESA
+def lire_miss_3d_prod(TYPE_RESU,**args):
+  if TYPE_RESU == "TRANS" : return dyna_trans
+  if TYPE_RESU == "HARMO" : return dyna_harmo
+  raise AsException("type de concept resultat non prevu")
+
+LIRE_MISS_3D=OPER(nom="LIRE_MISS_3D",op= 163,sd_prod=lire_miss_3d_prod,
+                  fr="Restituer sur base physique une réponse harmonique ou transitoire issue de MISS3D",
+                  reentrant='n',
+            UIinfo={"groupes":("Maillage",)},
+         MACR_ELEM_DYNA  =SIMP(statut='o',typ=macr_elem_dyna ),
+         UNITE           =SIMP(statut='f',typ='I',defaut= 27 ),
+         NOM             =SIMP(statut='f',typ='TXM' ),
+         TYPE_RESU       =SIMP(statut='f',typ='TXM',defaut="TRANS",into=("TRANS","HARMO") ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 POTAPOV S.POTAPOV
+
+LIRE_PLEXUS=OPER(nom="LIRE_PLEXUS",op= 184,sd_prod=evol_char,
+                 fr="Lire le fichier de résultats au format IDEAS produit par le logiciel EUROPLEXUS",
+                 reentrant='n',
+            UIinfo={"groupes":("Maillage",)},
+         regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),),
+         UNITE           =SIMP(statut='f',typ='I',defaut= 19 ),
+         FORMAT          =SIMP(statut='f',typ='TXM',defaut="IDEAS",into=("IDEAS",)),
+         MAIL_PLEXUS     =SIMP(statut='o',typ=maillage_sdaster ),
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster ),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         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 ),
+         b_prec_crit     =BLOC(condition = "LIST_INST != None or 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',),),),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 LEFEBVRE J.P.LEFEBVRE
+
+def lire_resu_prod(TYPE_RESU,**args):
+  if TYPE_RESU == "EVOL_CHAR" :  return evol_char
+  if TYPE_RESU == "EVOL_THER" :  return evol_ther
+  if TYPE_RESU == "EVOL_ELAS" :  return evol_elas
+  if TYPE_RESU == "EVOL_NOLI" :  return evol_noli
+  if TYPE_RESU == "DYNA_TRANS" : return dyna_trans
+  if TYPE_RESU == "DYNA_HARMO" : return dyna_harmo
+  if TYPE_RESU == "HARM_GENE" :  return harm_gene
+  if TYPE_RESU == "MODE_MECA" :  return mode_meca
+  if TYPE_RESU == "MODE_MECA_C" : return mode_meca_c
+  if TYPE_RESU == "EVOL_VARC" :  return evol_varc
+  raise AsException("type de concept resultat non prevu")
+
+# 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_ELNO_ZAC", "EPSP_NOEU", "EPSP_NOEU_ZAC", "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_ELNO_ZAC", "SIGM_NOEU_CART", "SIGM_NOEU_COQU",
+     "SIGM_NOEU_DEPL", "SIGM_NOEU_SIEF", "SIGM_NOEU_ZAC", "SIGM_NOZ1_ELGA",
+     "SIGM_NOZ2_ELGA", "SIPO_ELNO_DEPL", "SIPO_ELNO_SIEF", "SIPO_NOEU_DEPL",
+     "SIPO_NOEU_SIEF", "SIRE_ELNO_DEPL", "SIRE_NOEU_DEPL", "TEMP", "THETA",
+     "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",
+                           )
+
+LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n',
+            UIinfo={"groupes":("Résultats et champs",)},
+               fr="Lire dans un fichier, soit format IDEAS, soit au format ENSIGHT soit au format MED,"
+                 +" des champs et les stocker dans une SD résultat",
+
+
+# 0) mots clés généraux :
+#----------------------
+         TYPE_RESU       =SIMP(statut='o',typ='TXM',into=("EVOL_THER","EVOL_ELAS","EVOL_NOLI","MODE_MECA",
+                                                          "MODE_MECA_C","DYNA_TRANS","DYNA_HARMO","HARM_GENE",
+                                                          "EVOL_CHAR","EVOL_VARC") ),
+
+         FORMAT          =SIMP(statut='o',typ='TXM',into=("IDEAS","IDEAS_DS58","ENSIGHT","MED") ),
+
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+
+         regles=(UN_PARMI('MAILLAGE','MODELE'),),
+         MAILLAGE        =SIMP(statut='f',typ=maillage_sdaster),
+         MODELE          =SIMP(statut='f',typ=modele_sdaster),
+         COMP_INCR       =C_COMP_INCR(),
+         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'",
+          EXCIT           =FACT(statut='f',max='**',
+            CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca)),
+            FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+            TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",) ),),
+           ),
+
+          b_evol_ther  = BLOC(condition="TYPE_RESU=='EVOL_THER'",
+          EXCIT           =FACT(statut='f',max='**',
+            CHARGE          =SIMP(statut='o',typ=(char_ther,char_cine_ther)),
+            FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),),
+           ),
+
+          b_evol_noli  = BLOC(condition="TYPE_RESU=='EVOL_NOLI'",
+          EXCIT           =FACT(statut='f',max='**',
+           CHARGE          =SIMP(statut='o',typ=(char_meca,char_cine_meca)),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           TYPE_CHARGE     =SIMP(statut='f',typ='TXM',defaut="FIXE_CSTE",
+                                 into=("FIXE_CSTE","FIXE_PILO","SUIV","DIDI")),
+           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='**'),),
+         ),
+
+
+# 1) blocs selon le format choisi :
+#---------------------------------
+
+# 1-1 ideas dataset-58 :
+# ----------------------
+         b_dataset_58 = BLOC(condition="FORMAT=='IDEAS_DS58'",
+           UNITE           =SIMP(statut='f',typ='I',defaut= 19 ),
+         ),
+         b_dataset_58_b = BLOC(condition="(FORMAT=='IDEAS_DS58') and ((TYPE_RESU=='DYNA_TRANS') or\
+                                        (TYPE_RESU=='DYNA_HARMO') or (TYPE_RESU=='HARM_GENE'))",
+           UNITE           =SIMP(statut='f',typ='I',defaut= 19 ),
+           NOM_CHAM=SIMP(statut='o',typ='TXM',into=("DEPL","VITE","ACCE","EPSI_NOEU_DEPL","SIEF_NOEU",) ),
+           REDEFI_ORIENT=FACT(statut='f',max='**',
+                              regles=(PRESENT_PRESENT('CODE_DIR','DIRECTION','NOEUD',),),
+                              CODE_DIR =SIMP(statut='f',typ='I',into=(1,2,3,) ),
+                              DIRECTION=SIMP(statut='f',typ='R',min=3,max=3,),
+                              NOEUD    =SIMP(statut='f',typ=no,validators=NoRepeat(),max='**'),),
+         ),
+
+# 1-2 ideas  :
+# ---------
+         b_ideas         =BLOC(condition="FORMAT=='IDEAS'",
+           UNITE           =SIMP(statut='f',typ='I',defaut= 19 ),
+#           TEST            =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON" ),
+           NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=l_nom_cham_pas_elga()),
+           PROL_ZERO       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",),
+             fr="Affecte des valeurs nulles la ou le champ n'est pas defini"),
+           FORMAT_IDEAS    =FACT(statut='f',max='**',
+             regles=(UN_PARMI('POSI_INST','POSI_FREQ'),),
+             NOM_CHAM        =SIMP(statut='o',typ='TXM',into=l_nom_cham_pas_elga()),
+             NUME_DATASET    =SIMP(statut='f',typ='I',into=(55,57,2414) ),
+             RECORD_3        =SIMP(statut='f',typ='I',max=10),
+             RECORD_6        =SIMP(statut='f',typ='I',max=10),
+             RECORD_9        =SIMP(statut='f',typ='I',max=10),
+             POSI_ORDRE      =SIMP(statut='o',typ='I',min=2,max=2),
+             POSI_NUME_MODE  =SIMP(statut='f',typ='I',min=2,max=2),
+             POSI_MASS_GENE  =SIMP(statut='f',typ='I',min=2,max=2),
+             POSI_AMOR_GENE  =SIMP(statut='f',typ='I',min=2,max=2),
+             POSI_INST       =SIMP(statut='f',typ='I',min=2,max=2),
+             POSI_FREQ       =SIMP(statut='f',typ='I',min=2,max=2),
+             NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),),
+         ),
+             
+         b_mode   =BLOC(condition="((TYPE_RESU=='MODE_MECA')or(TYPE_RESU=='MODE_MECA_C') )and (FORMAT=='IDEAS')",
+             NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster),max=1,
+                fr="Utile en dynamique pour pouvoir imposer la numérotation des cham_no."),     
+         ),
+
+# 1-3 ensight :
+# -------------
+         b_ensight       =BLOC(condition="FORMAT=='ENSIGHT'",
+           NOM_FICHIER     =SIMP(statut='f',typ='TXM'),
+           NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=l_nom_cham_pas_elga()),
+         ),
+
+# 1-4 med :
+# ---------
+         b_med           =BLOC(condition = "FORMAT == 'MED'",fr="Nom du champ dans le fichier MED",
+           UNITE           =SIMP(statut='f',typ='I',defaut= 81, fr="Le fichier est : fort.n.",),
+           FORMAT_MED      =FACT(statut='f',max='**',
+             regles=(ENSEMBLE('NOM_CMP','NOM_CMP_MED'),),
+             NOM_CHAM        =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO(),),
+             NOM_CHAM_MED    =SIMP(statut='o',typ='TXM',               fr="Nom du champ dans le fichier MED.",  ),
+             NOM_CMP         =SIMP(statut='f',typ='TXM',max='**',      fr="Nom des composantes dans ASTER.", ),
+             NOM_CMP_MED     =SIMP(statut='f',typ='TXM',max='**',      fr="Nom des composantes dans MED.", ),
+           ),
+           PROL_ZERO       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON",),
+            fr="Affecte des valeurs nulles la ou le champ n'est pas defini (sinon il y a NaN)"),
+         ),
+
+# 2) blocs selon le type du résultat :
+#---------------------------------
+         b_mode_meca     =BLOC(condition="(TYPE_RESU=='MODE_MECA')or(TYPE_RESU=='MODE_MECA_C')",
+           MATR_A         =SIMP(statut='f',typ=matr_asse_depl_r,),
+           MATR_B         =SIMP(statut='f',typ=matr_asse_depl_r,),
+         ),
+
+
+# 3) autres blocs :
+#---------------------------------
+         b_extrac        =BLOC(condition="1",fr="accès à un champ dans la structure de données résultat",
+           regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST','FREQ','LIST_FREQ'),),
+           TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NUME_ORDRE      =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),
+           LIST_ORDRE      =SIMP(statut='f',typ=listis_sdaster),
+           FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+           LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster),
+
+           b_acce_reel     =BLOC(condition="(INST != None)or(LIST_INST != None)or(FREQ != None)or(LIST_FREQ != 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',),),
+           ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 COURTOIS M.COURTOIS
+
+from Macro.lire_table_ops import lire_table_ops
+
+LIRE_TABLE=MACRO(nom="LIRE_TABLE",op=lire_table_ops,sd_prod=table_sdaster,
+                 fr="Lecture d'un fichier contenant une table",
+            UIinfo={"groupes":("Table",)},
+         UNITE           =SIMP(statut='o',typ='I' ),
+         FORMAT          =SIMP(statut='f',typ='TXM',into=("ASTER",),defaut="ASTER"),
+         NUME_TABLE      =SIMP(statut='f',typ='I',defaut=1),
+         SEPARATEUR      =SIMP(statut='f',typ='TXM',defaut=' '),
+         PARA            =SIMP(statut='f',typ='TXM',max='**'),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         )  ;
+
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 ANDRIAM H.ANDRIAMBOLOLONA
+
+MAC_MODES=OPER(nom="MAC_MODES",op=  141,sd_prod=table_sdaster,
+               fr="Critere orthogonalite de modes propres",
+               reentrant='n',
+               UIinfo={"groupes":("Résolution",)},
+               regles=(PRESENT_PRESENT('IERI','MATR_ASSE'),),
+         BASE_1     =SIMP(statut='o',typ=(mode_meca,mode_meca_c,mode_flamb) ),
+         BASE_2     =SIMP(statut='o',typ=(mode_meca,mode_meca_c,mode_flamb) ),
+         MATR_ASSE  =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_depl_c) ),
+         IERI       =SIMP(statut='f',typ='TXM',into=("OUI",),),
+         TITRE      =SIMP(statut='f',typ='TXM',max='**'),
+         INFO       =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 20/10/2008   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.      
+# ======================================================================
+# 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):
+#
+# 0. Typage des structures produites
+#
+  maillage_np1=args['MAILLAGE_NP1']
+  self.type_sdprod(maillage_np1,maillage_sdaster)
+#
+  if ( args['MAILLAGE_NP1_ANNEXE'] is not None ) :
+    maillage_np1_annexe=args['MAILLAGE_NP1_ANNEXE']
+    self.type_sdprod(maillage_np1_annexe,maillage_sdaster)
+#
+  if MAJ_CHAM == None:return None
+# Remarque : la liste qui suit doit etre conforme à son homologue de LIRE_CHAMP
+  for ch in MAJ_CHAM:
+    t=ch['TYPE_CHAM']
+    if t[0:5] == "NOEU_":self.type_sdprod(ch['CHAM_MAJ'],cham_no_sdaster)
+    if t[0:2] == "EL":   self.type_sdprod(ch['CHAM_MAJ'],cham_elem)
+  return None
+
+
+MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_adap_mail_prod,
+                     fr="Adapter un maillage avec le logiciel HOMARD.",
+                     ang="Mesh adaptation with HOMARD software.",
+                     docu="U7.03.01-b",UIinfo={"groupe":("Maillage",)},
+#
+# 1. Le niveau d'information
+#
+  INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2,3,4)),
+#
+# 2. Version de HOMARD
+#
+  VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_5",
+                        into=("V9_5", "V9_N", "V9_N_PERSO"),
+                        fr="Version de HOMARD",
+                        ang="HOMARD release"),
+#
+# 3. Langue des messages produits par HOMARD
+#
+  LANGUE = SIMP(statut='f',typ='TXM',defaut="FRANCAIS",    
+                into=("FRANCAIS","FRENCH","ANGLAIS","ENGLISH",),
+                fr="Langue des messages produits par HOMARD.",
+                ang="Language for HOMARD messages." ),
+#
+# 4. Les maillages
+# 4.1. Quel que soit le type de traitement, il faut donner  :
+#      A. Le concept du maillage initial (entree)
+#      B. Le concept du maillage final (sortie)
+#
+  MAILLAGE_N   = SIMP(statut='o',typ=maillage_sdaster,
+                      fr="Maillage avant adaptation",
+                      ang="Mesh before adaptation" ),
+#
+  MAILLAGE_NP1 = SIMP(statut='o',typ=CO,
+                      fr="Maillage apres 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",
+                             ang="Additional mesh after adaptation" ),
+#
+# 5. Le pilotage de l'adaptation, avec les variantes suivantes :
+#  . Raffinement et deraffinement, selon un champ d'indicateurs d'erreur
+#  . Raffinement seul, selon un champ d'indicateurs d'erreur
+#  . Deraffinement seul, selon un champ d'indicateurs d'erreur
+#  . Raffinement seul, selon des zones geometriques
+#  . Raffinement uniforme : toutes les mailles sont divisées
+#  . Deraffinement uniforme : toutes les mailles sont regroupées
+#  . Rien : le maillage est le meme a la sortie et a l'entree
+#
+  ADAPTATION = SIMP(statut='o',typ='TXM',
+                    into=("RAFF_DERA","RAFFINEMENT","DERAFFINEMENT","RAFFINEMENT_ZONE", \
+                          "RAFFINEMENT_UNIFORME","DERAFFINEMENT_UNIFORME","RIEN"),    
+                    fr="Pilotage de l'adaptation : selon un indicateur d'erreur ou uniforme.",
+                    ang="Adaptation control : among an error indicator or uniform" ),
+#
+# 6. Pour de l'adaptation libre, il faut un indicateur d'erreur
+#
+  b_indicateur_d_erreur = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
+                                              (ADAPTATION == 'RAFFINEMENT') or \
+                                              (ADAPTATION == 'DERAFFINEMENT') " ,
+                                fr="Pour une adaptation libre, choix de l'indicateur d'erreur ou d'une zone à raffiner",
+                                ang="For free adaptation, selection of error indicator or zone",
+#
+    regles=(UN_PARMI('CHAM_GD','RESULTAT_N')),
+#
+# 6.1. Repérage de la zone à raffiner à l'aide d'un indicateur
+#
+# 6.1.1. Sous forme de champ de grandeur
+#
+    CHAM_GD    = SIMP(statut='f',typ=cham_gd_sdaster,
+                      fr="Champ de grandeur Code_Aster contenant l'indicateur d'erreur",
+                      ang="Code_Aster champ de grandeur with error indicator" ),
+#
+# 6.1.2. Sous forme de concept resultat_sdaster
+#
+    RESULTAT_N = SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther) ,
+                      fr="Concept resultat Code_Aster contenant l'indicateur d'erreur",
+                      ang="Code_Aster result with error indicator" ),
+#
+    b_champ_indicateur = BLOC(condition="(RESULTAT_N != None)",
+      INDICATEUR = SIMP(statut='o',typ='TXM',     
+                        fr="Champ de l'indicateur d'erreur dans le résultat",
+                        ang="Error indicator field in the result structure" ),
+    ),
+#
+# 6.1.3. Est-ce un champ dérivé
+#
+    b_sensibilite = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+                        fr="Est-ce un champ dérivé",
+                        ang="Is the indicator a derivative field",
+#
+      SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),
+                         fr="Paramètre de sensibilité.",
+                         ang="Sensitivity parameter")
+#
+    ),
+#
+# 6.1.4. La composante retenue
+#
+    b_composante = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+                        fr="Choix de la composante pour l'indicateur",
+                        ang="Component selection for error indicator",
+#
+      NOM_CMP_INDICA = SIMP(statut='o',typ='TXM',
+                            fr="Composante retenue pour l'indicateur d'erreur",
+                            ang="Selected component for error indicator" ),
+#
+    ),
+#
+# 6.1.5. Le paramètre temporel pour l'indicateur
+#
+    b_parametre_temporel = BLOC(condition="(RESULTAT_N != None)",
+                                fr="Choix éventuel du paramètre temporel pour l'indicateur",
+                                ang="Time selection for error indicator (option)",
+#
+      regles=(EXCLUS('NUME_ORDRE','INST'),),
+#
+# 6.1.5.1. Soit le numero d'ordre
+#
+      NUME_ORDRE = SIMP(statut='f',typ='I',
+                        fr="Numero d ordre",
+                        ang="Rank" ),  
+#
+# 6.1.5.2. Soit l'instant
+# 6.1.5.2.1. Sa valeur
+#
+      INST       = SIMP(statut='f',typ='R',
+                        fr="Instant associé",
+                        ang="Instant" ),
+#
+# 6.1.5.2.2. La précision du choix de l'instant
+#
+      b_precision = BLOC(condition="(INST != None)",
+                         fr="Choix de la précision du choix de l'instant",
+                         ang="Selection for instant choice",
+        CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),
+                         fr="Critère de précision sur le choix de l'instant associé",
+                         ang="Accuracy criterium over instant choice"),
+        b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+            PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,
+                             fr="Précision relative sur le choix de l'instant associé",
+                             ang="Relative accuracy over instant choice"),),
+        b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+            PRECISION       =SIMP(statut='o',typ='R',
+                             fr="Précision absolue sur le choix de l'instant associé",
+                             ang="Absolute accuracy over instant choice"),),
+      ),
+#
+    ),
+#
+# 6.1.6. Type de valeur de l'indicateur : absolue ou relative
+#
+    b_valeur_indicateur = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+                               fr="Type de valeur pour l'indicateur",
+                               ang="Value type for error indicator",
+#
+      TYPE_VALEUR_INDICA = SIMP(statut='f',typ='TXM',defaut="V_ABSOLUE",into=("V_ABSOLUE","V_RELATIVE"),
+                                fr="Valeur absolue ou relative pour l'indicateur",
+                                ang="Absolute or relative value for error indicator" ),
+#
+    ),
+#
+# 6.1.7. Type d'opération sur l'indicateur : la valeur par maille ou le max du saut entre mailles
+#
+    b_usage_indicateur = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+                              fr="Usage de l'indicateur : direct ou saut",
+                              ang="Use type for error indicator : direct or jump",
+#
+      TYPE_OPER_INDICA = SIMP(statut='f',typ='TXM',defaut="MAILLE",into=("MAILLE","SAUT"),
+                              fr="Usage de l'indicateur : la valeur par maille ou le saut entre mailles voisines",
+                              ang="Use of indicator : value over every mesh or jump between neighbour" ),
+#
+    ),
+#
+  ) ,
+#
+# 7. Les criteres pour de l'adaptation libre avec un indicateur d'erreur :
+#        absolu, relatif, en proportion d'entite
+# 7.1. Pour le raffinement :
+#
+  b_critere_de_raffinement = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
+                                                 (ADAPTATION == 'RAFFINEMENT') " ,
+                                fr="Critère de raffinement.",
+                                ang="Refinement threshold.",
+#
+    regles=(UN_PARMI ( 'CRIT_RAFF_ABS', 'CRIT_RAFF_REL', 'CRIT_RAFF_PE' ),),
+#
+    CRIT_RAFF_ABS = SIMP(statut='f',typ='R',
+                         fr="Critère absolu",
+                         ang="Absolute threshold" ),  
+    CRIT_RAFF_REL = SIMP(statut='f',typ='R',
+                         fr="Critère relatif : fraction réelle entre 0. et 1.",
+                         ang="Relative threshold : ratio between 0. and 1." ),  
+    CRIT_RAFF_PE  = SIMP(statut='f',typ='R',
+                         fr="Pourcentage d'éléments : fraction réelle entre 0. et 1.",
+                         ang="Percentage of elements : ratio between 0. and 1." ),  
+  ) ,
+#
+# 7.2. Pour le deraffinement :
+#
+  b_critere_de_deraffinement = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
+                                                   (ADAPTATION == 'DERAFFINEMENT') " ,
+                                     fr="Critère de déraffinement.",
+                                     ang="Unrefinement threshold.",
+#
+    regles=(UN_PARMI ( 'CRIT_DERA_ABS', 'CRIT_DERA_REL', 'CRIT_DERA_PE' ),),
+#
+    CRIT_DERA_ABS = SIMP(statut='f',typ='R' ,
+                         fr="Critère absolu",
+                         ang="Absolute threshold" ),  
+    CRIT_DERA_REL = SIMP(statut='f',typ='R',
+                         fr="Critère relatif : fraction réelle entre 0. et 1.",
+                         ang="Relative threshold : ratio between 0. and 1." ),  
+    CRIT_DERA_PE  = SIMP(statut='f',typ='R',
+                         fr="Pourcentage d'éléments : fraction réelle entre 0. et 1.",
+                         ang="Percentage of elements : ratio between 0. and 1." ),  
+  ) ,
+#
+# 8. Pour de l'adaptation par zone, définitions des zones
+#
+  b_zone = BLOC( condition = " (ADAPTATION == 'RAFFINEMENT_ZONE') " ,
+                                fr="Pour une adaptation selon une zone à raffiner",
+                                ang="For adaptation among zone",
+    ZONE = FACT(statut='f',max='**',
+                  fr="Définition de zones à raffiner.",
+                  ang="Refined zone definition.",
+#
+      regles=(AU_MOINS_UN('X_MINI','X_CENTRE'),
+              EXCLUS('X_MINI','X_CENTRE',),
+              EXCLUS('Z_MINI','X_CENTRE',),
+              EXCLUS('X_MINI','Z_CENTRE',),
+              EXCLUS('Z_MINI','Z_CENTRE',),
+              PRESENT_PRESENT('X_MINI','X_MAXI','Y_MINI','Y_MAXI'),
+              PRESENT_PRESENT('Z_MINI','Z_MAXI'),
+              PRESENT_PRESENT('X_CENTRE','Y_CENTRE','RAYON'),),
+#
+# 6.2.1. Une boite parallelepipedique
+#
+      X_MINI = SIMP(statut='f',typ='R',
+                    fr="Abscisse minimum de la boite",
+                    ang="Minimum X for the box"),
+      X_MAXI = SIMP(statut='f',typ='R',
+                    fr="Abscisse maximum de la boite",
+                    ang="Maximum X for the box"),
+#
+      Y_MINI = SIMP(statut='f',typ='R',
+                    fr="Orodnnée minimum de la boite",
+                    ang="Minimum Y for the box"),
+      Y_MAXI = SIMP(statut='f',typ='R',
+                    fr="Abscisse maximum de la boite",
+                    ang="Maximum Y for the box"),
+#
+      Z_MINI = SIMP(statut='f',typ='R',
+                    fr="Cote minimum de la boite",
+                    ang="Minimum Z for the box"),
+      Z_MAXI = SIMP(statut='f',typ='R',
+                    fr="Cote maximum de la boite",
+                    ang="Maximum Z for the box"),
+#
+# 6.2.2. Une sphere
+#
+      X_CENTRE = SIMP(statut='f',typ='R',
+                      fr="Abscisse du centre de la sphere",
+                      ang="X for the center of the sphere"),
+      Y_CENTRE = SIMP(statut='f',typ='R',
+                      fr="Ordonnee du centre de la sphere",
+                      ang="Y for the center of the sphere"),
+      Z_CENTRE = SIMP(statut='f',typ='R',
+                      fr="Cote du centre de la sphere",
+                      ang="Z for the center of the sphere"),
+      RAYON = SIMP(statut='f',typ='R',
+                   fr="Rayon de la sphere",
+                   ang="Radius of the sphere"),
+#
+    ) ,
+#
+  ) ,
+#
+# 9. Les niveaux extremes pour le maillage adapte
+# 9.1. Pour le raffinement :
+#
+  b_niveau_maximum = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
+                                         (ADAPTATION == 'RAFFINEMENT') or \
+                                         (ADAPTATION == 'RAFFINEMENT_UNIFORME') or \
+                                         (ADAPTATION == 'RAFFINEMENT_ZONE') " ,
+                           fr="Niveau maximum de profondeur de raffinement",
+                           ang="Maximum level for refinement",
+    NIVE_MAX = SIMP(statut='f',typ='I',
+                    fr="Niveau maximum de profondeur de raffinement",
+                    ang="Maximum level for refinement"),
+  ) ,
+#
+# 9.2. Pour le deraffinement :
+#
+  b_niveau_minimum = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
+                                         (ADAPTATION == 'DERAFFINEMENT') or \
+                                         (ADAPTATION == 'DERAFFINEMENT_UNIFORME') " ,
+                           fr="Niveau minimum de profondeur de déraffinement",
+                           ang="Minimum level for unrefinement",
+    NIVE_MIN = SIMP(statut='f',typ='I',
+                    fr="Niveau minimum de profondeur de déraffinement",
+                    ang="Minimum level for unrefinement"),
+  ) ,
+#
+# 10. Filtrage de l'adaptation par des groupes
+#
+  b_filtrage_par_des_groupes = BLOC( condition = " (ADAPTATION == 'RAFF_DERA') or \
+                                                   (ADAPTATION == 'RAFFINEMENT') or \
+                                                   (ADAPTATION == 'RAFFINEMENT_UNIFORME') or \
+                                                   (ADAPTATION == 'RAFFINEMENT_ZONE') or \
+                                                   (ADAPTATION == 'DERAFFINEMENT') or \
+                                                   (ADAPTATION == 'DERAFFINEMENT_UNIFORME') " ,
+                                fr="Filtrage de l'adaptation par des groupes.",
+                                ang="Filtering of adaptation by groups.",
+#
+    GROUP_MA = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                    fr="Liste des groupes de mailles pour le filtrage de l'adaptation.",
+                    ang="List of groups of meshes for filtering of adaptation." ),  
+#
+    GROUP_NO = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**',
+                    fr="Liste des groupes de noeuds pour le filtrage de l'adaptation.",
+                    ang="List of groups of nodes for filtering of adaptation." ),  
+  ) ,
+#
+# 11. Suivi d'une frontiere
+#
+  MAILLAGE_FRONTIERE = SIMP(statut='f',typ=maillage_sdaster,
+                           fr="Maillage de la frontiere à suivre",
+                           ang="Boundary mesh" ),
+#
+  b_frontiere = BLOC( condition = " MAILLAGE_FRONTIERE != None " ,
+                      fr="Information complémentaire sur la frontière",
+                      ang="Further information about 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" ),
+#
+  ) ,
+#
+# 12. Mise à jour de champs sur le nouveau maillage
+#
+  MAJ_CHAM = FACT(statut='f',max='**',
+                  fr="Mise à jour de champs sur le nouveau maillage.",
+                  ang="Updating of fields over the new mesh.",
+#
+# 12.1. Le nom du champ de grandeur qui contiendra le resultat de la mise a jour
+#
+    CHAM_MAJ = SIMP(statut='o',typ=CO,
+                    fr="Nom du champ de grandeur qui contiendra le champ mis à jour",
+                    ang="Name of the field for the updated field"),
+#
+# 12.2. Le type du champ qui contiendra le resultat de la mise a jour
+#
+    TYPE_CHAM = SIMP(statut='o',typ='TXM',into=C_TYPE_CHAM_INTO(),
+                     fr="Type du champ qui contiendra le champ mis à jour",
+                     ang="Type of the field for the updated field" ),
+#
+# 12.3. Le champ a interpoler
+#
+    regles=(UN_PARMI('CHAM_GD','RESULTAT')),
+#
+# 12.3.1. Sous forme de champ de grandeur
+#
+    CHAM_GD = SIMP(statut='f',typ=cham_gd_sdaster,
+                   fr="Champ de grandeur Code_Aster contenant le champ à mettre à jour",
+                   ang="Champ de grandeur with field to be updated" ),
+#
+# 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",
+                    ang="Result with field to be updated" ),
+#
+    b_nom_du_champ = BLOC(condition="(RESULTAT != None)",
+                          fr="Choix éventuel du nom du champ à interpoler",
+                          ang="Selection for the name of the field (option)",
+#
+      NOM_CHAM = SIMP(statut='o',typ='TXM',
+                      fr="Nom du champ à mettre à jour",
+                      ang="Name of the field to be updated" ),
+#
+    ),
+#
+# 12.4. Est-ce un champ dérivé
+#
+    SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),
+                       fr="Paramètre de sensibilité.",
+                       ang="Sensitivity parameter"),
+#
+# 12.5. Le paramètre temporel pour le champ a interpoler
+#
+    b_parametre_temporel = BLOC(condition="(RESULTAT != None)",
+                                fr="Choix éventuel du paramètre temporel pour le champ à interpoler",
+                                ang="Time selection for the field (option)",
+#
+      regles=(EXCLUS('NUME_ORDRE','INST'),),
+#
+# 12.5.1. Soit le numero d'ordre
+#
+      NUME_ORDRE = SIMP(statut='f',typ='I',
+                        fr="Numero d ordre du champ à mettre à jour",
+                        ang="Rank of the field to be updated" ),
+#
+# 12.5.2. Soit l'instant
+# 12.5.2.1. Sa valeur
+#
+      INST = SIMP(statut='f',typ='R',
+                  fr="Instant associé",
+                  ang="Instant" ),
+#
+# 12.5.2.2. La précision du choix de l'instant
+#
+      b_precision = BLOC(condition="(INST != None)",
+                         fr="Choix de la précision du choix de l'instant",
+                         ang="Selection for instant choice",
+#
+        CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),
+                         fr="Critère de précision sur le choix de l'instant associé",
+                         ang="Accuracy criterium over instant choice"),
+        b_prec_rela=BLOC(condition="(CRITERE=='RELATIF')",
+            PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-6,
+                             fr="Précision relative sur le choix de l'instant associé",
+                             ang="Relative accuracy over instant choice"),),
+        b_prec_abso=BLOC(condition="(CRITERE=='ABSOLU')",
+            PRECISION       =SIMP(statut='o',typ='R',
+                             fr="Précision absolue sur le choix de l'instant associé",
+                             ang="Absolute accuracy over instant choice"),),
+#
+      ),
+#
+    ),
+  ),
+#
+# 13. Les options d'analyse de maillage ; par defaut, on ne fait que les nombres
+# 13.1. Nombre de noeuds et éléments
+#
+  NOMBRE         = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),
+                          fr="Nombre de noeuds et éléments du maillage",
+                          ang="Number of nodes and éléments in the mesh" ),
+#
+# 13.2. Determination de la qualité des éléments du maillage
+#
+  QUALITE        = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
+                          fr="Qualité du maillage",
+                          ang="Mesh quality" ),
+#
+# 13.3. Connexite du maillage
+#
+  CONNEXITE      = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
+                          fr="Connexité du maillage.",
+                          ang="Mesh connexity." ),
+#
+# 13.4. Taille des sous-domaines du maillage
+#
+  TAILLE         = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
+                          fr="Tailles des sous-domaines du maillage.",
+                          ang="Sizes of mesh sub-domains." ),
+#
+# 13.5. Controle de la non-interpenetration des éléments
+#
+  INTERPENETRATION= SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
+                          fr="Controle de la non interpénétration des éléments.",
+                          ang="Overlapping checking." ),
+#
+# 14. Gestion des éléments autres que ceux compatibles avec HOMARD
+#       "REFUSER" : ils sont refuses (defaut)
+#       "IGNORER" : ils sont ignorés
+#
+  ELEMENTS_NON_HOMARD = SIMP(statut='f',typ='TXM',defaut="REFUSER",into=("REFUSER","IGNORER"),
+                             fr="Acceptation d'éléments incompatibles avec HOMARD",
+                             ang="Incompatible elements for HOMARD" ),
+#
+) ;
+#& MODIF COMMANDE  DATE 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#            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 GALENNE E.GALENNE
+from Macro.macr_ascouf_calc_ops import macr_ascouf_calc_ops
+def macr_ascouf_calc_prod(self,MODELE,CHAM_MATER,CARA_ELEM,FOND_FISS,RESU_THER,**args):
+  self.type_sdprod(MODELE,modele_sdaster)
+  if CHAM_MATER != None:self.type_sdprod(CHAM_MATER,cham_mater)
+  if CARA_ELEM  != None:self.type_sdprod(CARA_ELEM,cara_elem)
+  if FOND_FISS  != None:self.type_sdprod(FOND_FISS,fond_fiss)
+  if RESU_THER  != None:self.type_sdprod(RESU_THER,evol_ther)
+  return evol_noli
+
+MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=macr_ascouf_calc_prod,
+                      fr="Réalise l'analyse thermomécanique du coude dont le maillage a été concu par MACR_ASCOUF_MAIL",
+                      reentrant='n',
+            UIinfo={"groupes":("Outils métier",)},
+         regles=(UN_PARMI('COMP_INCR','COMP_ELAS'),),
+
+         TYPE_MAILLAGE   =SIMP(statut='o',typ='TXM',
+                               into=("SAIN",
+                                     "FISS_COUDE",
+                                     "FISS_AXIS_DEB",
+                                     "SOUS_EPAIS_COUDE"
+                                     ) ),
+
+         CL_BOL_P2_GV    =FACT(statut='f',
+           ANGLE           =SIMP(statut='o',typ='R' ),
+           AZIMUT          =SIMP(statut='f',typ='R',defaut= 90. ),
+         ),
+
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster ),
+         MODELE          =SIMP(statut='o',typ=CO,),
+         CHAM_MATER      =SIMP(statut='f',typ=CO,),
+         CARA_ELEM       =SIMP(statut='f',typ=CO,),
+         FOND_FISS       =SIMP(statut='f',typ=CO,),
+         RESU_THER       =SIMP(statut='f',typ=CO,),
+
+         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") ),
+           MATER           =SIMP(statut='o',typ=mater_sdaster ),
+           TEMP_REF        =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
+         ),
+
+         PRES_REP        =FACT(statut='f',
+           PRES            =SIMP(statut='o',typ='R' ),
+           EFFE_FOND_P1    =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           PRES_LEVRE      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         ECHANGE         =FACT(statut='f',
+           COEF_H          =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+           TEMP_EXT        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+
+         TORS_P1         =FACT(statut='f',max=6,
+           regles=(AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
+           FX              =SIMP(statut='f',typ='R' ),
+           FY              =SIMP(statut='f',typ='R' ),
+           FZ              =SIMP(statut='f',typ='R' ),
+           MX              =SIMP(statut='f',typ='R' ),
+           MY              =SIMP(statut='f',typ='R' ),
+           MZ              =SIMP(statut='f',typ='R' ),
+           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")),
+         ),
+
+         SOLVEUR         =C_SOLVEUR(),
+
+         CONVERGENCE     =C_CONVERGENCE(),
+
+         NEWTON          =C_NEWTON(),
+
+         RECH_LINEAIRE   =C_RECH_LINEAIRE(),
+
+         INCREMENT       =C_INCREMENT(),
+
+         THETA_3D        =FACT(statut='f',max='**',
+           R_INF           =SIMP(statut='o',typ='R' ),
+           R_SUP           =SIMP(statut='o',typ='R' ),
+         ),
+
+         IMPR_TABLE      =FACT(statut='f',
+           regles=(UN_PARMI('TOUT_PARA','NOM_PARA', ),
+            PRESENT_PRESENT('TOUT_PARA','ANGLE',    ),
+            PRESENT_PRESENT('TOUT_PARA','R_CINTR',  ),
+                   UN_PARMI('POSI_CURV_LONGI','POSI_ANGUL',),),
+           NOM_PARA        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=4,
+                                 into=("TRESCA_MEMBRANE",
+                                       "TRESCA_MFLE",
+                                       "TRESCA",
+                                       "SI_LONG"
+                                       "SI_RADI"
+                                       "SI_CIRC"
+                                       ) ),
+           TOUT_PARA       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           ANGLE           =SIMP(statut='f',typ='R',max='**' ),
+           R_CINTR         =SIMP(statut='f',typ='R',max='**' ),
+           POSI_CURV_LONGI =SIMP(statut='f',typ='R',max='**' ),
+           POSI_ANGUL      =SIMP(statut='f',typ='R',max='**' ),
+           TRANSFORMEE     =SIMP(statut='f',typ='TXM',defaut="COUDE",into=("COUDE","TUBE") ),
+         ),
+
+         IMPRESSION      =FACT(statut='f',
+           FORMAT          =SIMP(statut='f',typ='TXM',defaut="RESULTAT",
+                                 into=("RESULTAT","ASTER","IDEAS","CASTEM") ),
+
+           b_format_ideas  =BLOC(condition="FORMAT=='IDEAS'",fr="version Ideas",
+             VERSION         =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
+           ),
+
+           b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="version Castem",
+             NIVE_GIBI       =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
+           ),
+
+         ),
+
+         TITRE           =SIMP(statut='f',typ='TXM' ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE GALENNE E.GALENNE
+from Macro.macr_ascouf_mail_ops import macr_ascouf_mail_ops
+MACR_ASCOUF_MAIL=MACRO(nom="MACR_ASCOUF_MAIL",op=macr_ascouf_mail_ops,sd_prod=maillage_sdaster,
+            fr="Engendre le maillage d'un coude sain ou comportant une fissure ou une (ou plusieurs) sous-épaisseur(s)",
+            UIinfo={"groupes":("Outils métier",)},reentrant='n',
+
+         regles=(EXCLUS('SOUS_EPAIS_COUDE','FISS_COUDE','SOUS_EPAIS_MULTI'),),
+
+         EXEC_MAILLAGE   =FACT(statut='o',
+           LOGICIEL        =SIMP(statut='o',typ='TXM',defaut="GIBI2000",into=("GIBI98","GIBI2000") ),
+           UNITE_DATG      =SIMP(statut='f',typ='I',defaut=70),  
+           UNITE_MGIB      =SIMP(statut='f',typ='I',defaut=19),  
+           NIVE_GIBI       =SIMP(statut='f',typ='I',defaut=10,into=(3,4,5,6,7,8,9,10,11)),
+         ),
+
+         TYPE_ELEM       =SIMP(statut='f',typ='TXM',defaut="CU20",into=("CU20","CUB8") ),
+
+         COUDE           =FACT(statut='o',
+           ANGLE           =SIMP(statut='o',typ='R' ),  
+           R_CINTR         =SIMP(statut='o',typ='R' ),  
+           L_TUBE_P1       =SIMP(statut='o',typ='R' ),  
+           L_TUBE_P2       =SIMP(statut='f',typ='R',defaut= 0.E+0 ),  
+           NB_ELEM_EPAIS   =SIMP(statut='f',typ='I',defaut= 3 ),  
+           SYME            =SIMP(statut='f',typ='TXM',defaut="ENTIER",into=("ENTIER","QUART","DEMI") ),
+           TRANSFORMEE     =SIMP(statut='o',typ='TXM',defaut="COUDE",into=("COUDE","TUBE") ),
+           b_transf_coude  =BLOC(condition = "TRANSFORMEE == 'COUDE' ",
+              DEXT            =SIMP(statut='o',typ='R' ),  
+              EPAIS           =SIMP(statut='o',typ='R' ),  
+              SUR_EPAIS       =SIMP(statut='f',typ='R',defaut= 0.E+0 ),  
+              BOL_P2          =SIMP(statut='f',typ='TXM',into=("ASP_MPP","CUVE","GV") ),
+           ),
+           b_transf_tube   =BLOC(condition = "TRANSFORMEE == 'TUBE' ",
+              TRAN_EPAIS      =SIMP(statut='o',typ='TXM',defaut="NON",into=("OUI","NON") ),
+              b_trans_epais_oui    =BLOC(condition = "TRAN_EPAIS == 'OUI' ",
+                      regles=(ENSEMBLE('ANGL_TETA2','EPAIS_TI'),
+                              UN_PARMI('ABSC_CURV_TRAN','POSI_ANGU_TRAN'),),
+                      DEXT_T1         =SIMP(statut='o',typ='R' ),  
+                      EPAIS_T1        =SIMP(statut='o',typ='R' ),  
+                      EPAIS_T2        =SIMP(statut='o',typ='R' ),  
+                      EPAIS_TI        =SIMP(statut='f',typ='R' ),  
+                      ANGL_TETA1      =SIMP(statut='o',typ='R' ),  
+                      ANGL_TETA2      =SIMP(statut='f',typ='R' ),  
+                      ABSC_CURV_TRAN  =SIMP(statut='f',typ='R' ),  
+                      POSI_ANGU_TRAN  =SIMP(statut='f',typ='R' ),  
+              ),
+              b_trans_epais_non    =BLOC(condition = "TRAN_EPAIS == 'NON' ",
+                      DEXT            =SIMP(statut='o',typ='R' ),  
+                      EPAIS           =SIMP(statut='o',typ='R' ),  
+                      SUR_EPAIS       =SIMP(statut='f',typ='R',defaut= 0.E+0 ),  
+                      BOL_P2          =SIMP(statut='f',typ='TXM',into=("ASP_MPP","CUVE","GV") ),
+              ),
+           ),
+         ),
+
+         SOUS_EPAIS_COUDE=FACT(statut='f',
+           regles=(UN_PARMI('POSI_CURV_LONGI','POSI_ANGUL'),
+                   UN_PARMI('POSI_CURV_CIRC','AZIMUT'),),
+           TYPE            =SIMP(statut='o',typ='TXM',into=("AXIS","ELLI") ),
+           AXE_CIRC        =SIMP(statut='f',typ='R' ),  
+           AXE_LONGI       =SIMP(statut='o',typ='R' ),  
+           PROFONDEUR      =SIMP(statut='o',typ='R' ),  
+           POSI_CURV_LONGI =SIMP(statut='f',typ='R' ),  
+           POSI_ANGUL      =SIMP(statut='f',typ='R' ),  
+           POSI_CURV_CIRC  =SIMP(statut='f',typ='R' ),  
+           AZIMUT          =SIMP(statut='f',typ='R' ),  
+           SOUS_EPAIS      =SIMP(statut='o',typ='TXM',into=("INTERNE","EXTERNE") ),
+           NB_ELEM_LONGI   =SIMP(statut='o',typ='I' ),  
+           NB_ELEM_CIRC    =SIMP(statut='o',typ='I' ),  
+           NB_ELEM_RADI    =SIMP(statut='f',typ='I',defaut= 3 ),  
+           EMPREINTE       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         ),
+
+         SOUS_EPAIS_MULTI=FACT(statut='f',max='**',
+           regles=(UN_PARMI('POSI_CURV_LONGI','POSI_ANGUL'),
+                   UN_PARMI('POSI_CURV_CIRC','AZIMUT'),),
+           TYPE            =SIMP(statut='o',typ='TXM',into=("AXIS","ELLI") ),
+           AXE_CIRC        =SIMP(statut='f',typ='R' ),  
+           AXE_LONGI       =SIMP(statut='o',typ='R' ),  
+           PROFONDEUR      =SIMP(statut='o',typ='R' ),  
+           POSI_CURV_LONGI =SIMP(statut='f',typ='R' ),  
+           POSI_ANGUL      =SIMP(statut='f',typ='R' ),  
+           POSI_CURV_CIRC  =SIMP(statut='f',typ='R' ),  
+           AZIMUT          =SIMP(statut='f',typ='R' ),  
+           SOUS_EPAIS      =SIMP(statut='o',typ='TXM',into=("INTERNE","EXTERNE") ),
+           NB_ELEM_LONGI   =SIMP(statut='o',typ='I' ),  
+           NB_ELEM_CIRC    =SIMP(statut='o',typ='I' ),  
+           EMPREINTE       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         ),
+
+         FISS_COUDE      =FACT(statut='f',
+           regles=(UN_PARMI('ABSC_CURV','POSI_ANGUL'),),
+           AXIS            =SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON" ),  
+           b_axis_non    =BLOC(condition = "AXIS == 'NON' ",
+                   LONGUEUR        =SIMP(statut='o',typ='R' ),  
+           ),
+           b_axis_oui    =BLOC(condition = "AXIS == 'OUI' ",
+                   LONGUEUR        =SIMP(statut='f',typ='R' ),  
+           ),
+           PROFONDEUR      =SIMP(statut='o',typ='R' ),  
+           ABSC_CURV       =SIMP(statut='f',typ='R' ),  
+           POSI_ANGUL      =SIMP(statut='f',typ='R' ),  
+           FISSURE         =SIMP(statut='o',typ='TXM',into=("DEB_INT","DEB_EXT") ),
+           AZIMUT          =SIMP(statut='f',typ='R',defaut= 90. ),  
+           ORIEN           =SIMP(statut='o',typ='R',
+                                 into=(45.,-45.,90.,0.E+0) ),
+           NB_TRANCHE      =SIMP(statut='o',typ='I' ),  
+           NB_SECTEUR      =SIMP(statut='o',typ='I' ),  
+           NB_COURONNE     =SIMP(statut='o',typ='I' ),  
+           RAYON_TORE      =SIMP(statut='f',typ='R' ),  
+           COEF_MULT_RC2   =SIMP(statut='f',typ='R',defaut= 1. ),  
+           COEF_MULT_RC3   =SIMP(statut='f',typ='R' ),  
+           ANGL_OUVERTURE  =SIMP(statut='f',typ='R',defaut= 0.5 ),  
+         ),
+
+         IMPRESSION      =FACT(statut='f',max='**',
+           regles=(PRESENT_PRESENT('FICHIER','UNITE'),),
+           FORMAT          =SIMP(statut='f',typ='TXM',defaut="ASTER",   
+                                 into=("ASTER","IDEAS","CASTEM") ),
+           b_format_ideas  =BLOC(condition="FORMAT=='IDEAS'",fr="version Ideas",
+             VERSION         =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
+           ),  
+           b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="version Castem",
+             NIVE_GIBI       =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
+           ),
+           FICHIER         =SIMP(statut='f',typ='TXM' ),  
+           UNITE           =SIMP(statut='f',typ='I' ),  
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#            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 GALENNE E.GALENNE
+from Macro.macr_aspic_calc_ops import macr_aspic_calc_ops
+
+def macr_aspic_calc_prod(self,MODELE,CHAM_MATER,CARA_ELEM,FOND_FISS_1,FOND_FISS_2,RESU_THER,**args):
+  if MODELE      != None:self.type_sdprod(MODELE,modele_sdaster)
+  if CHAM_MATER  != None:self.type_sdprod(CHAM_MATER,cham_mater)
+  if CARA_ELEM   != None:self.type_sdprod(CARA_ELEM,cara_elem)
+  if FOND_FISS_1 != None:self.type_sdprod(FOND_FISS_1,fond_fiss)
+  if FOND_FISS_2 != None:self.type_sdprod(FOND_FISS_2,fond_fiss)
+  if RESU_THER   != None:self.type_sdprod(RESU_THER,evol_ther)
+  return evol_noli
+
+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":("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",
+                                     "FISS_LONG_NONDEB","FISS_AXIS_DEB","FISS_AXIS_NONDEB") ),
+
+         TUBULURE        =FACT(statut='o',
+           TYPE            =SIMP(statut='o',typ='TXM',into=("TYPE_1","TYPE_2") ),
+         ),
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster),
+         MODELE          =SIMP(statut='f',typ=CO,),
+         CHAM_MATER      =SIMP(statut='f',typ=CO,),
+         CARA_ELEM       =SIMP(statut='f',typ=CO,),
+         FOND_FISS_1     =SIMP(statut='f',typ=CO,),
+         FOND_FISS_2     =SIMP(statut='f',typ=CO,),
+         RESU_THER       =SIMP(statut='f',typ=CO,),
+
+         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") ),
+           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")),
+         ),
+
+         EQUILIBRE       =FACT(statut='o',
+           NOEUD           =SIMP(statut='o',typ=no),
+         ),
+
+         PRES_REP        =FACT(statut='o',
+           PRES            =SIMP(statut='o',typ='R'),
+           NOEUD           =SIMP(statut='f',typ=no),
+           EFFE_FOND       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+           PRES_LEVRE      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+         ),
+
+         ECHANGE         =FACT(statut='f',
+           COEF_H_TUBU     =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           COEF_H_CORP     =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           TEMP_EXT        =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+         ),
+
+         TORS_CORP       =FACT(statut='f',max=6,
+           regles=(AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
+           NOEUD           =SIMP(statut='o',typ=no),
+           FX              =SIMP(statut='f',typ='R'),
+           FY              =SIMP(statut='f',typ='R'),
+           FZ              =SIMP(statut='f',typ='R'),
+           MX              =SIMP(statut='f',typ='R'),
+           MY              =SIMP(statut='f',typ='R'),
+           MZ              =SIMP(statut='f',typ='R'),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+         ),
+
+         TORS_TUBU       =FACT(statut='f',max=6,
+           regles=(AU_MOINS_UN('FX','FY','FZ','MX','MY','MZ'),),
+           FX              =SIMP(statut='f',typ='R'),
+           FY              =SIMP(statut='f',typ='R'),
+           FZ              =SIMP(statut='f',typ='R'),
+           MX              =SIMP(statut='f',typ='R'),
+           MY              =SIMP(statut='f',typ='R'),
+           MZ              =SIMP(statut='f',typ='R'),
+           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")),
+         ),
+
+         THETA_3D        =FACT(statut='f',max='**',
+           R_INF           =SIMP(statut='o',typ='R'),
+           R_SUP           =SIMP(statut='o',typ='R'),
+         ),
+
+         OPTION          =SIMP(statut='f',typ='TXM',into=("CALC_G_MAX","CALC_G_MAX_LOCAL") ),
+         BORNES          =FACT(statut='f',max='**',
+           NUME_ORDRE      =SIMP(statut='o',typ='I'),
+           VALE_MIN        =SIMP(statut='o',typ='R'),
+           VALE_MAX        =SIMP(statut='o',typ='R'),
+         ),
+
+         SOLVEUR         =C_SOLVEUR(),
+
+         CONVERGENCE     =C_CONVERGENCE(),
+
+         NEWTON          =C_NEWTON(),
+
+         RECH_LINEAIRE   =C_RECH_LINEAIRE(),
+
+         INCREMENT       =C_INCREMENT(),
+
+         PAS_AZIMUT      =SIMP(statut='f',typ='I',defaut=1),
+
+         IMPRESSION      =FACT(statut='f',
+           FORMAT          =SIMP(statut='f',typ='TXM',defaut="RESULTAT",
+                                 into=("RESULTAT","ASTER","CASTEM","IDEAS")),
+
+           b_format_ideas  =BLOC(condition="FORMAT=='IDEAS'",fr="version Ideas",
+             VERSION         =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
+           ),
+
+           b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="version Castem",
+             NIVE_GIBI       =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
+           ),
+
+           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")),
+
+             TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+             INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+           ),
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+
+         TITRE           =SIMP(statut='f',typ='TXM'),
+)
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE GALENNE E.GALENNE
+
+from Macro.macr_aspic_mail_ops import macr_aspic_mail_ops
+
+MACR_ASPIC_MAIL=MACRO(nom="MACR_ASPIC_MAIL",op= macr_aspic_mail_ops,sd_prod=maillage_sdaster,reentrant='n',
+            fr="Engendre le maillage d'un piquage sain ou avec fissure (longue ou courte)",
+            UIinfo={"groupes":("Outils métier",)},
+
+         EXEC_MAILLAGE   =FACT(statut='o',
+           LOGICIEL        =SIMP(statut='o',typ='TXM',defaut="GIBI2000",into=("GIBI98","GIBI2000")),
+           UNITE_DATG      =SIMP(statut='f',typ='I',defaut=70),  
+           UNITE_MGIB      =SIMP(statut='f',typ='I',defaut=19),  
+           NIVE_GIBI       =SIMP(statut='f',typ='I',defaut=10,into=(3,4,5,6,7,8,9,10,11)),
+         ),
+
+         TYPE_ELEM       =SIMP(statut='f',typ='TXM',defaut="CU20",into=("CU20","CUB8")),
+
+         RAFF_MAIL       =SIMP(statut='f',typ='TXM',defaut="GROS",into=("GROS","FIN")),
+
+         TUBULURE        =FACT(statut='o',
+           E_BASE          =SIMP(statut='o',typ='R'),  
+           DEXT_BASE       =SIMP(statut='o',typ='R'),  
+           L_BASE          =SIMP(statut='o',typ='R'),  
+           L_CHANF         =SIMP(statut='o',typ='R'),  
+           E_TUBU          =SIMP(statut='o',typ='R'),  
+           DEXT_TUBU       =SIMP(statut='o',typ='R'),  
+           Z_MAX           =SIMP(statut='o',typ='R'),  
+           TYPE            =SIMP(statut='o',typ='TXM',into=("TYPE_1","TYPE_2")),
+           L_PENETR        =SIMP(statut='f',typ='R',defaut= 0.0E+0),  
+         ),
+
+         SOUDURE         =FACT(statut='o',
+           H_SOUD          =SIMP(statut='o',typ='R'),  
+           ANGL_SOUD       =SIMP(statut='o',typ='R'),  
+           JEU_SOUD        =SIMP(statut='o',typ='R'),  
+         ),
+
+         CORPS           =FACT(statut='o',
+           E_CORP          =SIMP(statut='o',typ='R'),  
+           DEXT_CORP       =SIMP(statut='o',typ='R'),  
+           X_MAX           =SIMP(statut='o',typ='R'),  
+         ),
+
+         FISS_SOUDURE    =FACT(statut='f',
+           TYPE            =SIMP(statut='o',typ='TXM',into=("LONGUE","COURTE")),
+           AXIS            =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+           PROFONDEUR      =SIMP(statut='o',typ='R'),  
+           LONGUEUR        =SIMP(statut='f',typ='R'),  
+           AZIMUT          =SIMP(statut='o',typ='R'),  
+           RAYON_TORE      =SIMP(statut='f',typ='R'),  
+           POSITION        =SIMP(statut='o',typ='TXM',into=("DROIT","INCLINE")),
+           FISSURE         =SIMP(statut='o',typ='TXM',into=("DEB_INT","DEB_EXT","NON_DEB","TRAVERS")),
+           LIGA_INT        =SIMP(statut='f',typ='R'),  
+           ANGL_OUVERTURE  =SIMP(statut='f',typ='R',defaut= 0.0E+0),  
+           COEF_MULT_RC1   =SIMP(statut='f',typ='R'),  
+           COEF_MULT_RC2   =SIMP(statut='f',typ='R'),  
+           COEF_MULT_RC3   =SIMP(statut='f',typ='R'),  
+           NB_TRANCHE      =SIMP(statut='f',typ='I'),  
+           NB_SECTEUR      =SIMP(statut='f',typ='I'),  
+           NB_COURONNE     =SIMP(statut='f',typ='I'),  
+         ),
+
+         IMPRESSION      =FACT(statut='f',max='**',
+           regles=(PRESENT_PRESENT('FICHIER','UNITE'),),
+           FORMAT          =SIMP(statut='f',typ='TXM',defaut="ASTER",into=("ASTER","IDEAS","CASTEM")),
+
+           b_format_ideas  =BLOC(condition="FORMAT=='IDEAS'",fr="version Ideas",
+             VERSION         =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
+           ),  
+
+           b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="version Castem",
+             NIVE_GIBI       =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
+           ),
+           FICHIER         =SIMP(statut='f',typ='TXM'),  
+           UNITE           =SIMP(statut='f',typ='I'),  
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 30/06/2008   AUTEUR FLEJOU J-L.FLEJOU 
+#            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.
+# ======================================================================
+# RESPONSABLE FLEJOU J.L.FLEJOU
+
+from Macro.macr_cara_poutre_ops import macr_cara_poutre_ops
+
+MACR_CARA_POUTRE=MACRO(nom="MACR_CARA_POUTRE",op=macr_cara_poutre_ops,sd_prod=table_sdaster,
+                       reentrant='n',
+         UIinfo={"groupes":("Modélisation",)},
+         fr="Calculer les caractéristiques d'une section transversale de poutre à partir d'un maillage 2D de la section",
+         regles=( EXCLUS('SYME_X','GROUP_MA_BORD'),
+                  EXCLUS('SYME_Y','GROUP_MA_BORD'),
+                ),
+
+         MAILLAGE       =SIMP(statut='f',typ=maillage_sdaster,
+                           fr="Nom du concept maillage"),
+         b_maillage=BLOC( condition = "MAILLAGE == None",
+            regles=( PRESENT_PRESENT('FORMAT','UNITE') ),
+            FORMAT         =SIMP(statut='f',typ='TXM',defaut="ASTER",into=("ASTER","MED"),
+                              fr="Format du fichier"),
+            UNITE          =SIMP(statut='f',typ='I',defaut= 20,
+                              fr="Unite correspondant au format du fichier maillage"),
+         ),
+
+         ORIG_INER      =SIMP(statut='f',typ='R',max=3,defaut=(0.E+0,0.E+0),
+                           fr="Point par rapport auquel sont calculées les inerties"),
+         INFO           =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+
+         SYME_X         =SIMP(statut='f',typ='TXM',into=("OUI",),
+                           fr="demi maillage par rapport a x=0"),
+         SYME_Y         =SIMP(statut='f',typ='TXM',into=("OUI",),
+                           fr="demi maillage par rapport a y=0"),
+
+         GROUP_MA       =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                           fr="Calcul des caractéristiques équivalentes a plusieurs sections disjointes"),
+
+         GROUP_MA_BORD  =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                           fr="Groupe(s) de mailles linéiques, bord(s) de(s) section(s)"),
+
+            b_gma_bord  =BLOC( condition = "GROUP_MA_BORD != None",
+               fr=" calcul des carac. mecaniques",
+               regles=(UN_PARMI('NOEUD','GROUP_NO')),
+               NOEUD           =SIMP(statut='f',typ=no,  max='**',
+                                 fr="Simplement pour empecher des pivots nuls le cas echeant. Fournir un noeud quelconque"),
+               GROUP_NO        =SIMP(statut='f',typ=grno,max='**',
+                                 fr="Simplement pour empecher des pivots nuls le cas echeant. Fournir un noeud quelconque"),
+               GROUP_MA_INTE   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                                 fr="groupes de mailles linéiques bordant des trous dans la section"),
+            ),
+
+            b_reseau = BLOC( condition ="""(GROUP_MA_BORD != None) and (GROUP_MA != None)""",
+               fr=" calcul des coef de cisaillement équivalents a un reseau de poutres",
+               regles=(ENSEMBLE('LONGUEUR','LIAISON','MATERIAU') ,),
+               LONGUEUR        =SIMP(statut='f',typ='R',
+                                 fr="Longueur du réseau de poutres"),
+               MATERIAU        =SIMP(statut='f',typ=mater_sdaster,
+                                 fr="Materiau elastique lineaire du reseau"),
+               LIAISON         =SIMP(statut='f',typ='TXM',into=("ROTULE","ENCASTREMENT"),
+                                 fr="type de conditions aux limites sur le plancher supérieur" ),
+            ),
+)
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 LEFEBVRE J.P.LEFEBVRE
+
+from Macro.macr_ecla_pg_ops import macr_ecla_pg_ops
+
+def macr_ecla_pg_prod(self,RESULTAT,MAILLAGE,RESU_INIT,**args):
+  self.type_sdprod(RESULTAT,AsType(RESU_INIT))
+  self.type_sdprod(MAILLAGE,maillage_sdaster)
+  return None
+
+
+MACR_ECLA_PG=MACRO(nom="MACR_ECLA_PG",op=macr_ecla_pg_ops,sd_prod=macr_ecla_pg_prod, reentrant='n',
+             UIinfo={"groupes":("Post traitements",)},
+             fr="Permettre la visualisation des champs aux points de Gauss d'une SD_RESULTAT sans lissage ni interpolation",
+
+
+             # 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='**'),
+
+             # paramètres numériques de la commande :
+             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é" ),
+
+             # concepts produits par la commande :
+             RESULTAT        =SIMP(statut='o',typ=CO,fr="SD_RESULTAT résultat de la commande"),
+             MAILLAGE        =SIMP(statut='o',typ=CO,fr="MAILLAGE associé aux cham_no de la SD_RESULTAT"),
+
+             # Sélection éventuelle d'un sous-ensemble des éléments à visualiser :
+             TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+             GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+
+             # Sélection des numéros d'ordre :
+             regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),),
+             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),
+             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 COMMANDE  DATE 02/11/2009   AUTEUR ASSIRE A.ASSIRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE MICHEL S.MICHEL
+
+from Macro.macr_ecre_calc_ops import macr_ecre_calc_ops
+
+def macr_ecre_calc_prod(self,TABLE,DEBIT,**args):
+
+  self.type_sdprod(TABLE,table_sdaster)
+  self.type_sdprod(DEBIT,table_sdaster)
+  return None
+
+MACR_ECRE_CALC=MACRO(nom="MACR_ECRE_CALC",op=macr_ecre_calc_ops,sd_prod=macr_ecre_calc_prod,reentrant='n',
+                     UIinfo={"groupes":("Outils metier",)},fr="Procedure de couplage avec Ecrevisse",
+
+#      CONCEPTS SORTANT : 2 TABLES POUR LE POST-TRAITEMENT 
+#      ********************************************
+         TABLE              =SIMP(statut='o',typ=CO),
+         DEBIT              =SIMP(statut='o',typ=CO),
+
+#      DONNEES GEOMETRIQUES RELATIVES A LA FISSURE
+#      *******************************************
+
+         FISSURE            =FACT(statut='o',min=1,max=1,
+           LONGUEUR            =SIMP(statut='o',typ='R',val_min=0.E+0,fr="Longueur de la fissure [zl]"),
+           RUGOSITE            =SIMP(statut='o',typ='R',fr="Rugosite absolu (metres) [eps]"),
+           ANGLE               =SIMP(statut='o',typ='R',fr="Angle par rapport à l'ascendante verticale (degres)"),
+           ZETA                =SIMP(statut='o',typ='R',fr="Coefficient de la perte de charge singuliere a l'entree [zeta]"),
+           SECTION             =SIMP(statut='o',typ='TXM',into=("ELLIPSE","RECTANGLE"),fr="Type de section [is]"),
+           b_section_ellipse   =BLOC(condition="SECTION=='ELLIPSE'",fr="Fissure a section elliptique",
+             LISTE_COTES_AH      =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant le grand axe de la section",
+                                       validators=NoRepeat()),
+             LISTE_VAL_AH        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant le grand axe de la section",),
+             LISTE_COTES_BL      =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant le petit axe de la section",
+                                       validators=NoRepeat()),
+             LISTE_VAL_BL        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant le petit axe de la section",),
+           ),
+           b_section_rectangle =BLOC(condition="SECTION=='RECTANGLE'",fr="Fissure a section rectangulaire",
+             LISTE_COTES_AH      =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant la hauteur de la section",
+                                       validators=NoRepeat()),
+             LISTE_VAL_AH        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant la hauteur de la section",),
+             LISTE_COTES_BL      =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant la largeur de la section",
+                                       validators=NoRepeat()),
+             LISTE_VAL_BL        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant la largeur de la section",),
+           ),
+         ),
+
+
+#      DONNEES RELATIVES A L"ECOULEMENT
+#      ********************************
+
+         ECOULEMENT         =FACT(statut='f',min=1,max=1,
+           PRES_ENTREE         =SIMP(statut='o',typ='R',fr="Pression de stagnation a l'entree (Pa) [pe]" ),
+           PRES_SORTIE         =SIMP(statut='o',typ='R',fr="Pression de stagnation a la sortie (Pa) [ps]" ),
+           FLUIDE_ENTREE       =SIMP(statut='o',typ='I',into=(1,2,3,4,5,6),fr="Condition du fluide a l'entree [iflow]" ),
+           b_condition_1       =BLOC(condition="FLUIDE_ENTREE==1",fr="Eau sous-refroidie ou saturee",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+           ),
+           b_condition_2       =BLOC(condition="FLUIDE_ENTREE==2",fr="Fluide diphasique",
+             TITR_MASS           =SIMP(statut='o',typ='R',fr="Titre massique eau vap/eau tot a l'entree [xe]" ),
+           ),
+           b_condition_3       =BLOC(condition="FLUIDE_ENTREE==3",fr="Vapeur saturee ou surchauffee",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+           ),
+           b_condition_4       =BLOC(condition="FLUIDE_ENTREE==4",fr="Air + vapeur surchauffee",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+             PRES_PART           =SIMP(statut='o',typ='R',fr="Pression partielle air en entree (Pa) [pae]" ),
+           ),
+           b_condition_5       =BLOC(condition="FLUIDE_ENTREE==5",fr="Air + vapeur saturee",
+             TITR_MASS           =SIMP(statut='o',typ='R',fr="Titre massique eau vap/eau tot a l'entree [xe]" ),
+             PRES_PART           =SIMP(statut='o',typ='R',fr="Pression partielle air en entree (Pa) [pae]" ),  
+           ),
+           b_condition_6       =BLOC(condition="FLUIDE_ENTREE==6",fr="Air seul",
+             TEMP_ENTREE         =SIMP(statut='o',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+           ),
+         ),
+
+
+#      DONNEES RELATIVES AU PROFIL DE TEMPERATURE A TRAVERS LA PAROI
+#      *************************************************************
+
+         TEMPERATURE        =FACT(statut='f',min=1,max=1,
+           GRADIENT            =SIMP(statut='o',typ='TXM',into=("FOURNI","IMPOSE","CALCULE"),
+                                     fr="Modele de calcul du gradient de temperature [imograd]" ),
+           b_gradient_fourni   =BLOC(condition="GRADIENT=='FOURNI'",fr="Distribution de temperature fournie [imograd=-1]",
+             LISTE_COTES_TEMP    =SIMP(statut='o',typ='R',max='**',fr="Liste des cotes pour les temperatures",
+                                       validators=NoRepeat() ),
+             LISTE_VAL_TEMP      =SIMP(statut='o',typ='R',max='**',fr="Liste des valeurs de temperature", ),
+           ),
+           b_gradient_impose   =BLOC(condition="GRADIENT=='IMPOSE'",fr="Distribution imposee de temperature [imograd=0]",
+             TEMP1               =SIMP(statut='o',typ='R',
+                                       fr="Gradient de temperature de la paroi le long de l'ecoulement (degC/m) [tm1]", ),
+             TEMP2               =SIMP(statut='o',typ='R',fr="Temperature de la paroi a l'entree (degC) [tm2]", ),
+           ),
+           b_gradient_calcule  =BLOC(condition="GRADIENT=='CALCULE'",fr="Profil de temperature calcule [imograd=1]",
+             EPAISSEUR_PAROI     =SIMP(statut='o',typ='R',fr="Epaisseur de la paroi (m) [epp]", ),
+             CONVECTION_AMONT    =SIMP(statut='o',typ='R',
+                                       fr="Coefficient de convection a la surface de la paroi cote amont (W/degC/m2) [alphe]", ),
+             CONVECTION_AVAL     =SIMP(statut='o',typ='R',
+                                       fr="Coefficient de convection a la surface de la paroi cote aval (W/degC/m2) [alphs]", ),
+             LAMBDA              =SIMP(statut='o',typ='R',fr="Conduction thermique de la paroi (W/degC/m) [lambd]", ),
+             TEMP_FLUIDE_AVAL    =SIMP(statut='o',typ='R',fr="Temperature du fluide cote aval (degC) [ts]", ),
+           ),
+         ),
+
+
+#      CHOIX DES MODELES
+#      *****************
+
+         MODELE_ECRE        =FACT(statut='f',min=1,max=1,
+           IVENAC              =SIMP(statut='f', typ='I', into=(0,1), defaut=0,
+                                     fr="Calcul ECREVISSE avec prise en compte de la vena contracta"),
+           ECOULEMENT          =SIMP(statut='o',typ='TXM',into=("SATURATION","GELE"),
+                                     fr="Type de modele d'ecoulement diphasique [imod]" ),
+           b_ecou_gele         =BLOC(condition="ECOULEMENT=='GELE'",fr="Modele d'ecoulement gele",
+             PRESS_EBULLITION    =SIMP(statut='o',typ='R',fr="Pression d'ebullition [corrp*psat(t)]"),
+           ),
+           FROTTEMENT          =SIMP(statut='o',typ='I',into=(-3,-2,-1,0,1,2,3),fr="Correlation de frottement [ifrot]"),
+           b_frottement        =BLOC(condition="FROTTEMENT<0",fr="Modele d'ecoulement gele",
+             REYNOLDS_LIM        =SIMP(statut='o',typ='R',fr="Coefficient de Reynolds limite [relim]"),
+             FROTTEMENT_LIM      =SIMP(statut='o',typ='R',fr="Coefficient de frottement impose [frtlim]"),
+           ),
+
+           TRANSFERT_CHAL      =SIMP(statut='o',typ='I',into=(-2,-1,0,1,2),fr="Transfert de chaleur [ichal]"),
+           b_transchal         =BLOC(condition="TRANSFERT_CHAL<0", fr="Cas diphasique",
+             XMINCH              =SIMP(statut='o',typ='R',fr="Titre massique gazeux min [xminch]"),
+             XMAXCH              =SIMP(statut='o',typ='R',fr="Titre massique gazeux max [xmaxch]"),
+           ),  
+         ),
+
+
+#      DONNEES RELATIVES A LA CONVERGENCE NUMERIQUE
+#      ********************************************
+
+         CONVERGENCE        =FACT(statut='f',min=1,max=1,
+           KGTEST              =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut= 0.5E+0,
+                                     fr="Parametre de l'algorithme iteratif [kgtest]" ),
+           ITER_GLOB_MAXI      =SIMP(statut='f',typ='I',defaut= 400,
+                                     fr="Nombre maximum d'iterations de la methode de Newton [itnmax]" ),
+           CRIT_CONV_DEBI      =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut= 1.E-5,
+                                     fr="Critere de convergence en debit [precdb]" ),
+         ),
+
+
+#      GENERAL
+#      *******
+
+         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.1",into = ("3.1.1",)),
+         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,3) ),
+
+)  ;
+#& MODIF COMMANDE  DATE 02/11/2009   AUTEUR ASSIRE A.ASSIRE 
+#            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.        
+# ======================================================================
+# RESPONSABLE MICHEL S.MICHEL
+
+from Macro.macr_ecrevisse_ops import macr_ecrevisse_ops
+
+def macr_ecrevisse_prod(self,TABLE,TEMPER,DEBIT,**args):
+    # On definit ici les concepts produits
+    self.type_sdprod(TABLE,table_sdaster)
+    self.type_sdprod(TEMPER,evol_ther)
+    self.type_sdprod(DEBIT,table_sdaster)
+    # concept retourne
+    return evol_noli
+
+
+
+MACR_ECREVISSE=MACRO(nom="MACR_ECREVISSE",op=macr_ecrevisse_ops,sd_prod=macr_ecrevisse_prod,reentrant='f',
+                       UIinfo={"groupes":("Outils metier",)},fr="Procedure de couplage avec Ecrevisse",
+       reuse =SIMP(statut='f',typ='evol_noli'),
+         
+#      CONCEPT SORTANT
+#      ********************************************
+         TABLE              =SIMP(statut='f',typ=CO),
+         DEBIT              =SIMP(statut='f',typ=CO),
+         TEMPER             =SIMP(statut='f',typ=CO),
+           regles = (EXCLUS('TEMPER','ETAT_INIT'),),
+#      ETAT_INITIAL         
+#      ********************************************
+         ETAT_INIT       =FACT(statut='f',
+             EVOL_NOLI       =SIMP(statut='o',typ=evol_noli),
+             EVOL_THER       =SIMP(statut='o',typ=evol_ther),
+             NUME_ORDRE      =SIMP(statut='o',typ='I'),
+         ),
+
+
+#      MODELES MECANIQUES
+#      ********************************************
+         MODELE_MECA        =SIMP(statut='o',typ=modele_sdaster),
+         MODELE_THER        =SIMP(statut='o',typ=modele_sdaster),
+
+
+#      DONNEES GEOMETRIQUES RELATIVES A LA FISSURE
+#      *******************************************
+         FISSURE            =FACT(statut='o',min=1,max='**',
+           PREFIXE_FICHIER     =SIMP(statut='f',typ='TXM',validators=LongStr(1,8),defaut="FISSURE1"),
+           GROUP_MA            =SIMP(statut='o',typ=grma,validators=NoRepeat(),max=2,
+                                     fr="Groupe(s) des noeuds definissant les levres de la fissure"),
+           GROUP_NO_ORIG       =SIMP(statut='o',typ=grno,validators=NoRepeat(),max=2),
+           GROUP_NO_EXTR       =SIMP(statut='o',typ=grno,validators=NoRepeat(),max=2),
+           ZETA                =SIMP(statut='o',typ='R',fr="Coefficient de la perte de charge singuliere a l'entree [zeta]" ),
+           RUGOSITE            =SIMP(statut='o',typ='R',fr="Rugosite absolu (metres) [eps]" ),
+           OUVERT_REMANENTE    =SIMP(statut='o',typ='R',val_min=0.,defaut=10.E-6,fr="Ouverture remanente"),
+           SECTION             =SIMP(statut='o',typ='TXM',into=("ELLIPSE","RECTANGLE"),fr="Type de section [is]" ),
+           b_section_ellipse   =BLOC(condition="SECTION=='ELLIPSE'",fr="Fissure a section elliptique",
+             LISTE_COTES_BL      =SIMP(statut='f',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant le petit axe de la section",
+                                       validators=NoRepeat() ),
+             LISTE_VAL_BL        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant le petit axe de la section", ),
+           ),
+           b_section_rectangle =BLOC(condition="SECTION=='RECTANGLE'",fr="Fissure a section rectangulaire",
+             LISTE_COTES_BL      =SIMP(statut='f',typ='R',max='**',
+                                       fr="Liste des cotes des points definissant la largeur de la section",validators=NoRepeat()),
+             LISTE_VAL_BL        =SIMP(statut='o',typ='R',max='**',
+                                       fr="Liste des valeurs des points definissant la largeur de la section", ),
+           ),
+         ),
+
+
+#      DONNEES RELATIVES A L"ECOULEMENT
+#      ********************************
+         ECOULEMENT         =FACT(statut='o',min=1,max=1,
+                                  regles=(UN_PARMI('PRES_ENTREE','PRES_ENTREE_FO'),
+                                          UN_PARMI('PRES_SORTIE','PRES_SORTIE_FO'),
+                                          ),
+           PRES_ENTREE         =SIMP(statut='f',typ='R',fr="Pression de stagnation a l'entree (Pa) [pe]" ),
+           PRES_ENTREE_FO      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                     fr="Evolution de la pression de stagnation a l'entree (Pa) [pe]" ),
+           PRES_SORTIE         =SIMP(statut='f',typ='R',fr="Pression de stagnation a la sortie (Pa) [ps]" ),
+           PRES_SORTIE_FO      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                     fr="Evolution de la pression de stagnation a la sortie (Pa) [ps]" ),
+           FLUIDE_ENTREE       =SIMP(statut='o',typ='I',into=(1,2,3,4,5,6),fr="Condition du fluide a l'entree [iflow]" ),
+           b_condition_1       =BLOC(condition="FLUIDE_ENTREE==1",
+                                     regles=(UN_PARMI('TEMP_ENTREE', 'TEMP_ENTREE_FO')),
+                                     fr="Eau sous-refroidie ou saturee",
+             TEMP_ENTREE         =SIMP(statut='f',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+             TEMP_ENTREE_FO      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution de la temperature a l'entree (degres C) [te]" ),
+           ),
+           b_condition_2       =BLOC(condition="FLUIDE_ENTREE==2",
+                                     regles=(UN_PARMI('TITR_MASS', 'TITR_MASS_FO')),
+                                     fr="Fluide diphasique",
+             TITR_MASS           =SIMP(statut='f',typ='R',fr="Titre massique eau vap/eau tot a l'entree [xe]" ),
+             TITR_MASS_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution du titre massique eau vap/eau tot a l'entree [xe]" ),
+           ),
+           b_condition_3       =BLOC(condition="FLUIDE_ENTREE==3",
+                                     regles=(UN_PARMI('TEMP_ENTREE', 'TEMP_ENTREE_FO')),
+                                     fr="Vapeur saturee ou surchauffee",
+             TEMP_ENTREE         =SIMP(statut='f',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+             TEMP_ENTREE_FO      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution de la temperature a l'entree (degres C) [te]" ),
+           ),
+           b_condition_4       =BLOC(condition="FLUIDE_ENTREE==4",
+                                     regles=(UN_PARMI('TEMP_ENTREE', 'TEMP_ENTREE_FO'),
+                                             UN_PARMI('PRES_PART', 'PRES_PART_FO')),
+                                     fr="Air + vapeur surchauffee",
+             TEMP_ENTREE         =SIMP(statut='f',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+             TEMP_ENTREE_FO      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution de la temperature a l'entree (degres C) [te]" ),
+             PRES_PART           =SIMP(statut='f',typ='R',fr="Pression partielle air en entree (Pa) [pae]" ),
+             PRES_PART_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution de la pression partielle air en entree (Pa) [pae]" ),
+           ),
+           b_condition_5       =BLOC(condition="FLUIDE_ENTREE==5",
+                                     regles=(UN_PARMI('TITR_MASS', 'TITR_MASS_FO'),
+                                             UN_PARMI('PRES_PART', 'PRES_PART_FO')),
+                                     fr="Air + vapeur saturee",
+             TITR_MASS           =SIMP(statut='f',typ='R',fr="Titre massique eau vap/eau tot a l'entree [xe]" ),
+             TITR_MASS_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution du titre massique eau vap/eau tot a l'entree [xe]" ),
+             PRES_PART           =SIMP(statut='f',typ='R',fr="Pression partielle air en entree (Pa) [pae]" ),
+             PRES_PART_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution de la pression partielle air en entree (Pa) [pae]" ),
+           ),
+           b_condition_6       =BLOC(condition="FLUIDE_ENTREE==6",
+                                     regles=(UN_PARMI('TEMP_ENTREE', 'TEMP_ENTREE_FO')),
+                                     fr="Air seul",
+             TEMP_ENTREE         =SIMP(statut='f',typ='R',fr="Temperature a l'entree (degres C) [te]" ),
+             TEMP_ENTREE_FO      =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),
+                                       fr="Evolution de la temperature a l'entree (degres C) [te]" ),
+           ),
+         ),
+
+         LIST_INST =SIMP(statut='f',typ=(listr8_sdaster), fr="Liste des instants de calcul imposes" ),
+
+#      CHOIX DES MODELES
+#      *****************
+
+         MODELE_ECRE        =FACT(statut='o',min=1,max=1,
+           IVENAC              =SIMP(statut='f', typ='I', into=(0,1), defaut=0,
+                                     fr="Calcul ECREVISSE avec prise en compte de la vena contracta"),
+           ECOULEMENT          =SIMP(statut='o',typ='TXM',into=("SATURATION","GELE"),
+                                     fr="Type de modele d'ecoulement diphasique [imod]" ),
+           b_ecou_gele         =BLOC(condition="ECOULEMENT=='GELE'",fr="Modele d'ecoulement gele",
+             PRESS_EBULLITION  =SIMP(statut='o',typ='R',fr="Pression d'ebullition [corrp*psat(t)]" ),
+           ),
+           FROTTEMENT          =SIMP(statut='o',typ='I',into=(-3,-2,-1,0,1,2,3),fr="Correlation de frottement [ifrot]" ),
+           b_frottement        =BLOC(condition="FROTTEMENT<0",fr="Modele d'ecoulement gele",
+             REYNOLDS_LIM        =SIMP(statut='o',typ='R',fr="Coefficient de Reynolds limite [relim]" ),
+             FROTTEMENT_LIM      =SIMP(statut='o',typ='R',fr="Coefficient de frottement impose [frtlim]" ),
+           ),
+
+           TRANSFERT_CHAL      =SIMP(statut='o',typ='I',into=(-2,-1,0,1,2),fr="Transfert de chaleur [ichal]" ),
+           b_transchal         =BLOC(condition="TRANSFERT_CHAL<0", fr="Cas diphasique",
+             XMINCH              =SIMP(statut='o',typ='R',fr="Titre massique gazeux min [xminch]"),
+             XMAXCH              =SIMP(statut='o',typ='R',fr="Titre massique gazeux max [xmaxch]"),
+           ),
+         ),
+
+
+#      CRITERE DE CONVERGENCE
+#      **********************
+       
+         CONV_CRITERE       =FACT(statut='o',min=1,max=1,
+           TEMP_REF            =SIMP(statut='o',typ='R',val_min=1.0E-5,fr="Temperature de reference pour le calcul du critere"),
+           PRES_REF            =SIMP(statut='o',typ='R',val_min=1.0E-5,fr="Pression de reference pour le calcul du critere"),
+           CRITERE             =SIMP(statut='o',typ='TXM',defaut="TEMP_PRESS",into=("TEMP_PRESS","EXPLICITE","TEMP","PRESS"),
+                                     fr="La nature du critere pour la convergence"),
+           b_critere_autre     =BLOC(condition="CRITERE=='TEMP_PRESS' or CRITERE=='TEMP' or CRITERE=='PRESS'",
+                                     fr="Critere de convergence temp_press, temp, ou press",
+             SUBD_NIVEAU         =SIMP(statut='f',typ='I',val_min=2,defaut=3,
+                                       fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+             SUBD_PAS_MINI       =SIMP(statut='f',typ='R',val_min=0.0, fr="Pas de temps en dessous duquel on ne subdivise plus"),
+             NUME_ORDRE_MIN      =SIMP(statut='f',typ='I',val_min=-1,defaut=-1,
+                                       fr="Numero d'ordre a partir duquel le critere est pris en compte"),
+             PREC_CRIT           =SIMP(statut='f',typ='R',val_min=1.0E-2,defaut=1.0,
+                                       fr="Valeur du critere pour l'erreur de convergence"),
+           ),
+         ),
+
+
+#      DONNEES RELATIVES A LA CONVERGENCE NUMERIQUE
+#      ********************************************
+
+         CONVERGENCE_ECREVISSE =FACT(statut='f',min=1,max=1,
+           KGTEST                 =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut= 0.5E+0,
+                                        fr="Parametre de l'algorithme iteratif [kgtest]" ),
+           ITER_GLOB_MAXI         =SIMP(statut='f',typ='I',defaut= 400,
+                                        fr="Nombre maximum d'iterations de la methode de Newton [itnmax]" ),
+           CRIT_CONV_DEBI         =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=1.E+0,defaut= 1.E-5,
+                                        fr="Critere de convergence en debit [precdb]" ),
+
+         ),
+
+
+#      GENERAL
+#      *******
+
+         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.1",into = ("3.1.1",) ),
+         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,3) ),
+
+#      DONNEES POUR STAT_NON_LINE ET THER_NON_LINE
+#      *******************************************
+
+         # copie de stat_non_line.capy des options des mots cles qui nous interessent
+         
+         # donnees communes
+         
+         CHAM_MATER         =SIMP(statut='o',typ=cham_mater),
+         CARA_ELEM          =SIMP(statut='f',typ=cara_elem),
+
+         # donnees specifiques a stat_non_line         
+
+         EXCIT_MECA         =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","SUIV","DIDI")),
+         ),
+         COMP_INCR          =C_COMP_INCR(),
+         NEWTON             =FACT(statut='d',
+           REAC_INCR           =SIMP(statut='f',typ='I',defaut= 1 ),
+           PREDICTION          =SIMP(statut='f',typ='TXM',into=("DEPL_CALCULE","TANGENTE","ELASTIQUE","EXTRAPOL") ),
+           MATRICE             =SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE") ),
+           PAS_MINI_ELAS       =SIMP(statut='f',typ='R',defaut=0.0E+0),
+           REAC_ITER           =SIMP(statut='f',typ='I',defaut=0),
+           REAC_ITER_ELAS      =SIMP(statut='f',typ='I',defaut=0),
+           EVOL_NOLI           =SIMP(statut='f',typ=evol_noli),
+         ),
+         CONVERGENCE        =FACT(statut='d',regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),),
+           b_refe_rela         =BLOC(condition = "RESI_REFE_RELA != None",
+                                     regles=(AU_MOINS_UN('SIGM_REFE','EPSI_REFE','FLUX_THER_REFE',
+                                                         'FLUX_HYD1_REFE','FLUX_HYD2_REFE','VARI_REFE'),
+                                            ),
+             SIGM_REFE           =SIMP(statut='f',typ='R'),
+             EPSI_REFE           =SIMP(statut='f',typ='R'),
+             FLUX_THER_REFE      =SIMP(statut='f',typ='R'),
+             FLUX_HYD1_REFE      =SIMP(statut='f',typ='R'),
+             FLUX_HYD2_REFE      =SIMP(statut='f',typ='R'),
+             VARI_REFE           =SIMP(statut='f',typ='R'),
+           ),
+           RESI_REFE_RELA   =SIMP(statut='f',typ='R'),
+           RESI_GLOB_MAXI   =SIMP(statut='f',typ='R'),
+           RESI_GLOB_RELA   =SIMP(statut='f',typ='R'),
+           ITER_GLOB_MAXI   =SIMP(statut='f',typ='I',defaut=10),
+           ITER_GLOB_ELAS   =SIMP(statut='f',typ='I',defaut=25),
+           ARRET            =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+         ),
+         
+         # donnees specifiques a ther_lineaire
+         
+         EXCIT_THER         =FACT(statut='o',max='**',
+           CHARGE              =SIMP(statut='o',typ=(char_ther,char_cine_ther)),
+           FONC_MULT           =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+         ),
+         PARM_THETA         =SIMP(statut='f',typ='R',defaut= 0.57),
+         
+)
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE CORUS M.CORUS
+
+MACR_ELEM_DYNA=OPER(nom="MACR_ELEM_DYNA",op=  81,sd_prod=macr_elem_dyna,
+                    fr="Définition d'un macro élément pour analyse modale ou harmonique par sous structuration dynamique",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=(EXCLUS('MATR_AMOR','AMOR_REDUIT' ),
+                 PRESENT_ABSENT('MATR_IMPE','MATR_RIGI','MATR_MASS'),),
+         BASE_MODALE     =SIMP(statut='o',typ=mode_meca ),
+         MATR_RIGI       =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_depl_c),),
+         MATR_MASS       =SIMP(statut='f',typ=matr_asse_depl_r ),
+         MATR_AMOR       =SIMP(statut='f',typ=matr_asse_depl_r ),
+         AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'), 
+         SANS_GROUP_NO   =SIMP(statut='f',typ=grno ),
+         MATR_IMPE       =SIMP(statut='f',typ=matr_asse_gene_c ),
+         b_matr_impe     =BLOC(condition = "MATR_IMPE != None",
+             FREQ_EXTR       =SIMP(statut='o',typ='R' ),
+             AMOR_SOL        =SIMP(statut='f',typ='R',defaut=0.E+0 ),
+           ),
+         CAS_CHARGE      =FACT(statut='f',max='**',
+           NOM_CAS         =SIMP(statut='o',typ='TXM'),
+           VECT_ASSE_GENE  =SIMP(statut='o',typ=vect_asse_gene ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant='f',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+                    fr="Définition d'un macro-élément pour l'analyse statique par sous-structuration",
+        regles=(AU_MOINS_UN('DEFINITION','RIGI_MECA','MASS_MECA','CAS_CHARGE'),
+                ENSEMBLE('DEFINITION','EXTERIEUR'),),
+         DEFINITION      =FACT(statut='f',
+           regles=(PRESENT_PRESENT('PROJ_MESU','MODE_MESURE'),),
+           MODELE          =SIMP(statut='o',typ=modele_sdaster),
+           CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+           CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+           CHAR_MACR_ELEM  =SIMP(statut='f',typ=char_meca),
+           INST            =SIMP(statut='f',typ='R',defaut=0.0E+0 ),
+           NMAX_CAS        =SIMP(statut='f',typ='I',defaut=10),
+           NMAX_CHAR       =SIMP(statut='f',typ='I',defaut=10),
+           PROJ_MESU       =SIMP(statut='f',typ=(mode_gene,tran_gene,harm_gene),max=1),
+#           MODE_MESURE     =SIMP(statut='f',typ=( mode_meca,base_modale) ),
+           MODE_MESURE     =SIMP(statut='f',typ= mode_meca ), 
+         ),
+         EXTERIEUR       =FACT(statut='f',
+           regles=(AU_MOINS_UN('NOEUD','GROUP_NO'),),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+         ),
+         RIGI_MECA       =FACT(statut='f',
+         ),
+         MASS_MECA       =FACT(statut='f',
+         ),
+         AMOR_MECA       =FACT(statut='f',
+         ),
+         CAS_CHARGE      =FACT(statut='f',max='**',
+           NOM_CAS         =SIMP(statut='o',typ='TXM'),
+           SUIV            =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+           CHARGE          =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+           INST            =SIMP(statut='f',typ='R',defaut=0.E+0),
+         ),
+
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+
+from Macro.macr_fiabilite_ops import macr_fiabilite_ops
+
+#
+#====
+# 1. Le retour : une liste de rééls.
+#====
+#
+def macr_fiabilite_prod ( self , **args ):
+  return listr8_sdaster
+#
+#====
+# 2. L'entete
+#====
+#
+MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops,
+                         docu="U7.03.31",UIinfo={"groupe":("Post traitements",)},
+                         sd_prod=macr_fiabilite_prod,
+                         fr="Calcule les probabiltés de dépassement de seuil (mécanique de fiabilité).",
+                         ang="Fiability mechanics.",
+#
+#====
+# 3. Le niveau d'information
+#====
+#
+   INFO           = SIMP(statut="f",typ="I",defaut=1,into=(1,2)),
+#
+#====
+# 4. Nom et Version du logiciel de fiabilité
+#====
+#
+   LOGICIEL = SIMP(statut="f",typ="TXM",defaut="MEFISTO",
+                   into=("MEFISTO",),
+                   fr="Nom du logiciel de fiabilité.",
+                   ang="Fiability software name."),
+#
+   VERSION = SIMP(statut="f",typ="TXM",defaut="V3_2",
+                  into=("V3_2", "V3_N"),
+                  fr="Version du logiciel de fiabilité.",
+                  ang="Fiability software release."),
+#
+#====
+# 5. Les entrees-sorties du calcul ASTER déterministe
+#====
+#
+# 5.1. ==> Le jeu de commandes déterministe
+#
+   UNITE_ESCL = SIMP(statut="o",typ="I",
+                     fr="Unité logique associée aux commandes du calcul ASTER déterministe.",
+                     ang="Logical unit for the commands of the ASTER deterministic calculation."),
+#
+# 5.2. ==> Le destin des messages produits par ASTER
+#
+   MESS_ASTER = SIMP(statut="f",typ="TXM",defaut="DERNIER",
+                        into=("AUCUN", "DERNIER", "TOUS"),
+                        fr="Quels messages ASTER récupérer.",
+                        ang="Which ASTER messages must be kept."),
+#
+#====
+# 6. Options
+#====
+# 6.1. ==> Générales
+#
+# 6.1.1. ==> La valeur du seuil
+#
+   SEUIL = SIMP(statut="o",typ="R",max=1,
+                fr="Le seuil de défaillance.",
+                ang="Failure threshold."),
+#
+# 6.1.2. ==> Le type du seuil : on a deux cas de figure selon que
+#            la défaillance a lieu au dessus d'un seuil maximum ou
+#            en dessous d'un seuil minimum
+#
+   SEUIL_TYPE = SIMP(statut="o",typ="TXM",max=1,
+                     into=("MINIMUM","MAXIMUM"),
+                     fr="Que faut-il ne pas dépasser : un maximum ou un minimum.",
+                     ang="What is the failure threshold : maximum or minimum."),
+#
+# 6.2. ==> Pour MEFISTO
+#
+### en attente de résolution de AL 2004-006 (1/2)   b_mefisto=BLOC( condition = "LOGICIEL=='MEFISTO'",
+#
+# 6.2.1. ==> Pilotage de la recherche du point de conception
+#
+     RECH_PT_CONCEPT = SIMP(statut="f",typ="TXM",defaut="OUI",
+                            into=("OUI","NON"),
+                            fr="Pour trouver le point de conception.",
+                            ang="To find the design point."),
+#
+     b_rech_pt_concept=BLOC( condition = "RECH_PT_CONCEPT=='OUI'",
+#
+       EPSILON_U = SIMP(statut="f",typ="R",defaut=1.0E-2,
+                        fr="Précision du test d'arret sur les points itératifs dans l'espace standard.",
+                        ang="Precision of stop test for iterative points in standard space."),
+#
+       EPSILON_G = SIMP(statut="f",typ="R",defaut=1.0E-2,
+                        fr="Précision du test d'arret sur la proximité de la surface d'état limite.",
+                        ang="Precision of stop test for limit state surface."),
+#
+       TAU       = SIMP(statut="f",typ="R",defaut=5.0E-1,
+                        fr="Paramètre de la méthode de minimisation.",
+                        ang="Parameter for the minimization method."),
+#
+       OMEGA     = SIMP(statut="f",typ="R",defaut=1.0E-4,
+                        fr="Paramètre de la méthode de minimisation.",
+                        ang="Parameter for the minimization method."),
+#
+       ITER_MAX  = SIMP(statut="f",typ="I",defaut=50,
+                        fr="Nombre maximum d'itérations.",
+                        ang="Maximum number of iterations."),
+     ),
+#
+# 6.2.2. ==> Méthode(s) employée(s) pour la probabilité de défaillance
+#
+     METHODE_FORM = SIMP(statut="f",typ="TXM",defaut="OUI",
+                         into=("OUI","NON"),
+                         fr="Recherche de la probabilité de défaillance avec la méthode FORM.",
+                         ang="Research of failure probability with FORM method."),
+#
+     METHODE_SORM = SIMP(statut="f",typ="TXM",defaut="NON",
+                         into=("OUI","NON"),
+                         fr="Recherche de la probabilité de défaillance avec la méthode SORM.",
+                         ang="Research of failure probability with SORM method."),
+#
+     TIRAGE_IMPORTANCE = SIMP(statut="f",typ="TXM",defaut="NON",
+                              into=("OUI","NON"),
+                              fr="Recherche de la probabilité de défaillance avec le tirage d'importance.",
+                              ang="Research of failure probability with ."),
+#
+     b_tirage_importance=BLOC( condition = "TIRAGE_IMPORTANCE=='OUI'",
+#
+       NB_SIMULATION = SIMP(statut="f",typ="I",defaut=3,
+                            fr="Nombre de simulations pour le tirage d'importance.",
+                            ang="Number of simulation for."),
+#
+     ),
+#
+# 6.2.3. ==> Création d'une surface de réponse polynomiale
+#
+     POLYNOME_TAYLOR   = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),),
+     HGRAD             = SIMP(statut="f",typ="R",defaut=1.0E-2,
+                              fr="Pas incrémental pour le calcul des gradients.",
+                              ang="Step for calculation of gradients."),
+     HHESS             = SIMP(statut="f",typ="R",defaut=1.0E-2,
+                              fr="Pas incrémental pour le calcul des dérivées secondes.",
+                              ang="Step for calculation of second derivatives."),
+#
+# 6.2.4. ==> Recherche d'un plan d'expérience
+#
+     PLAN_EXPERIENCE   = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+                              fr="Construction d'un plan d'expérience.",
+                              ang="Construction of an experiment plan."),
+#
+     b_plan_experience=BLOC( condition = "PLAN_EXPERIENCE=='OUI'",
+#
+       ALPHA         = SIMP(statut="f",typ="R",defaut=2.0E-1,
+                            fr="Plan d'expérience : maille du plan de type composite centré.",
+                            ang="Experiment plane : mesh centered composite."),
+#
+       BETA          = SIMP(statut="f",typ="R",defaut=4.0E-1,
+                            fr="Plan d'expérience : maille du plan de type factoriel.",
+                            ang="Experiment plane : mesh factor."),
+#
+     ),
+#
+# 6.2.5. ==> Les tests
+# 6.2.5.1. ==> Test de la sphere
+#
+     T_SPHERE = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+                     fr="Test de la sphère.",
+                     ang="Sphere test."),
+#
+     b_test_de_la_sphere=BLOC( condition = "T_SPHERE=='OUI'",
+#
+       METHODE_TEST = SIMP(statut="f",typ="TXM",defaut="GAUSSIENNE",
+                           into=("GAUSSIENNE","PARAMETRIQUE","REJECTION"),
+                           fr="Type de méthode.",
+                           ang="Method."),
+#
+       NB_POINT     = SIMP(statut="f",typ="I",max=1,defaut=60,
+                           fr="Nombre de points de la sphere.",
+                           ang="Number of points over the sphere.")
+     ),
+#
+# 6.2.5.2. ==> Test du maximum fort
+#
+     T_MAXIMUM_FORT = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+                           fr="Test du maximum fort.",
+                           ang="Strong maximum test."),
+#
+     b_test_du_maximum_fort=BLOC( condition = "T_MAXIMUM_FORT=='OUI'",
+#
+       COS_LIM = SIMP(statut="f",typ="R",max=1,defaut=1.0,
+                      fr="Cosinus de l'angle d'exclusion.",
+                      ang="Cosine of angle of exclusion."),
+#
+       DPROB   = SIMP(statut="f",typ="R",max=1,defaut=4.3E-1,
+                      fr="Fraction d'iso-densité de probabilité de défaillance.",
+                      ang="Fraction.")
+#
+     ),
+#
+# 6.2.5.3. ==> Test du hessien
+#
+     T_HESSIEN = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),
+                      fr="Test du hessien.",
+                      ang="Hessian test."),
+#
+# 6.2.6. ==> Les correlations entre les variables
+#
+     MATRICE = SIMP(statut="f",typ="R",max="**",
+                    fr="Matrice de corrélation entre les variables.",
+                    ang="Correlation matrix."), 
+#
+### en attente de résolution de AL 2004-006 (2/2)   ),
+#
+#====
+# 7. Definition des paramètres
+#====
+#
+   VARIABLE = FACT(statut="o",min=1,max="**",
+#
+# 7.1. ==> Nom de la variable
+#
+       NOM = SIMP(statut="o",typ="TXM",
+                  fr="Nom de la variable, identique au nom de concept PARA_SENSI.",
+                  ang="Name of the variable, identical to the name of the PARA_SENSI conceipt."),
+#
+# 7.2. ==> Loi de distribution
+#
+       LOI = SIMP(statut="o",typ="TXM",
+                  into=("UNIFORME","NORMALE","LOGNORMALE","NORMALE_TRONQUEE"),
+                  fr="Choix de la loi",
+                  ang="Law."),
+#
+# 7.2.1. ==> Loi normale
+#
+       b_normale=BLOC(condition="LOI=='NORMALE'",
+#
+         VALE_MOY   = SIMP(statut="o",typ="R",max=1,
+                               fr="Valeur moyenne.",
+                               ang="Mean value."),
+#
+         ECART_TYPE = SIMP(statut="o",typ="R",max=1,
+                               fr="Ecart type.",
+                               ang="Standard deviation."),
+#
+       ),
+#
+# 7.2.2. ==> Loi lognormale
+#
+       b_lognormale=BLOC(condition="LOI=='LOGNORMALE'",
+#
+         VALE_MIN       = SIMP(statut="o",typ="R",max=1,
+                                   fr="Valeur minimale.",
+                                   ang="Minimal value."),
+#
+         VALE_MOY       = SIMP(statut="f",typ="R",max=1,
+                                   fr="Valeur moyenne dans l'espace de la loi normale.",
+                                   ang="Mean value in the space of the normal law."),
+#
+         ECART_TYPE     = SIMP(statut="f",typ="R",max=1,
+                                   fr="Ecart type dans l'espace de la loi normale.",
+                                   ang="Standard deviation in the space of the normal law."),
+#
+         VALE_MOY_PHY   = SIMP(statut="f",typ="R",max=1,
+                                   fr="Valeur moyenne dans l'espace physique.",
+                                   ang="Mean value in the physical space."),
+#
+         ECART_TYPE_PHY = SIMP(statut="f",typ="R",max=1,
+                                   fr="Ecart type dans l'espace physique.",
+                                   ang="Standard deviation in the physical space."),
+#
+         regles=(AU_MOINS_UN("VALE_MOY"  ,"VALE_MOY_PHY"),
+                 AU_MOINS_UN("ECART_TYPE","ECART_TYPE_PHY"),
+                 EXCLUS  ("VALE_MOY"  ,"VALE_MOY_PHY"),
+                 EXCLUS  ("VALE_MOY"  ,"ECART_TYPE_PHY"),
+                 EXCLUS  ("ECART_TYPE","VALE_MOY_PHY"),
+                 EXCLUS  ("ECART_TYPE","ECART_TYPE_PHY")),
+#
+       ),
+#
+# 7.2.3. ==> Loi uniforme
+#
+       b_uniforme=BLOC(condition="LOI=='UNIFORME'",
+#
+         VALE_MIN = SIMP(statut="o",typ="R",max=1,
+                             fr="Valeur minimale.",
+                             ang="Minimal value."),
+#
+         VALE_MAX = SIMP(statut="o",typ="R",max=1,
+                             fr="Valeur maximale.",
+                             ang="Maximal value."),
+#
+       ),
+#
+# 7.2.4. ==> Loi normale tronquée
+#
+       b_normale_tronquee=BLOC(condition="LOI=='NORMALE_TRONQUEE'",
+#
+         VALE_MOY   = SIMP(statut="o",typ="R",max=1,
+                               fr="Valeur moyenne de la loi normale complète.",
+                               ang="Mean value for the entire normal law."),
+#
+         ECART_TYPE = SIMP(statut="o",typ="R",max=1,
+                               fr="Ecart type de la loi normale complète.",
+                               ang="Standard deviation for the entire normal law."),
+#
+         VALE_MIN   = SIMP(statut="o",typ="R",max=1,
+                               fr="Valeur minimale.",
+                               ang="Minimal value."),
+#
+         VALE_MAX   = SIMP(statut="o",typ="R",max=1,
+                               fr="Valeur maximale.",
+                               ang="Maximal value."),
+#
+       ),
+#
+# 7.3. ==> Paramètres de calcul
+# 7.3.1. ==> Soit on cherche le point de conception, soit on le connait deja
+#
+       regles=(EXCLUS("POINT_INI","POINT_CONCEPT"),
+               EXCLUS("POINT_REF","POINT_CONCEPT"),),
+#
+# 7.3.2. ==> Quand on cherche le point de conception, on peut préciser le départ de l'algorithme.
+#            Si on ne le fait pas, le programme prendra la valeur moyenne.
+#
+       POINT_INI = SIMP(statut="f",typ="R",max=1,
+                          fr="Point de démarrage de l'algorithme itératif.",
+                          ang="Initial point for iterative process."),
+#
+# 7.3.3. ==> Quand on cherche le point de conception, on peut préciser un point de référence pour normaliser.
+#            Si on ne le fait pas, le programme prendra la valeur moyenne.
+#
+       POINT_REF = SIMP(statut="f",typ="R",max=1,
+                          fr="Point de référence de l'algorithme itératif.",
+                          ang="Reference point for iterative process."),
+#
+# 7.3.4. ==> Quand on cherche uniquement la probabilité de défaillance, il faut donner le point de conception
+#
+       POINT_CONCEPT = SIMP(statut="f",typ="R",max=1,
+                              fr="Point de conception.",
+                              ang="Design point."),
+#
+# 7.4. ==> Mode d'obtention du gradient par rapport à ce paramètre
+#
+       GRADIENT = SIMP(statut="o",typ="TXM",max=1,
+                           into=("OUI","NON"),
+                           fr="ASTER calcule directement le gradient.",
+                       ang="ASTER computes the gradient for this parameter."),
+
+       b_gradient=BLOC(condition="GRADIENT=='NON'",
+         INCREMENT = SIMP(statut="o",typ="R",max=1,
+                             fr="Incrément dans la direction.",
+                         ang="Direction increment."),
+       ),
+
+   ),
+#
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+
+from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
+
+MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
+                     docu="U7.04.41",UIinfo={"groupe":("Impression",)},
+                     fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
+                     ang="Print values for the fiability software",
+#
+# 1. Le niveau d'information
+#
+   INFO           = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+#
+# 2. Impression de la valeur de la cible
+#
+# 2.1. ==> La table contenant la valeur à imprimer
+#
+   TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
+                 fr="Table contenant la valeur cible.",
+                 ang="Table which includes the target value."),
+#
+# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
+#
+   NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM',
+                    fr="Nom du paramètre associé à la valeur cible.",
+                    ang="Name of the parameter connected to the target value."),
+#
+# 3. Impressions des valeurs des éventuels gradients
+#
+   GRADIENTS = FACT(statut='f',min=1,max='**',
+#
+# 3.1. ==> La table contenant la valeur à imprimer
+#
+       TABLE = SIMP(statut='o',typ=table_sdaster,
+                    fr="Table contenant le gradient.",
+                    ang="Table which includes the gradient."),
+#
+# 3.2. ==> Le paramètre sensible
+#
+       PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom),
+                       fr="Paramètre sensible associé au gradient.",
+                       ang="Sensitivity parameter connected to the gradient."),
+#
+# 3.3. ==> Le nom du paramètre associé au gradient dans cette table
+#
+       NOM_PARA = SIMP(statut='o',typ='TXM',
+                       fr="Nom du paramètre associé au gradient.",
+                       ang="Name of the parameter connected to the gradient."),
+#
+         ),
+#
+);
+#& MODIF COMMANDE  DATE 20/10/2008   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.      
+# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+
+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-b",UIinfo={"groupe":("Maillage",)},
+                     fr="Donner des informations sur un maillage.",
+                     ang="To give information about a mesh.",
+#
+# 1. Le niveau d'information
+#
+  INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2,3,4)),
+#
+# 2. Version de HOMARD
+#
+  VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V9_5",
+                        into=("V9_5", "V9_N", "V9_N_PERSO"),
+                        fr="Version de HOMARD",
+                        ang="HOMARD release"),
+#
+# 3. Langue des messages issus de HOMARD
+#
+  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." ),
+#
+# 4. Le nom du maillage a analyser
+#
+  MAILLAGE = SIMP(statut='o',typ=maillage_sdaster,
+                  fr="Maillage à analyser.",
+                  ang="Mesh to be checked." ),
+#
+# 5. Suivi d'une frontiere
+#
+  MAILLAGE_FRONTIERE = SIMP(statut='f',typ=maillage_sdaster,
+                           fr="Maillage de la frontiere à suivre",
+                           ang="Boundary mesh" ),
+#
+  b_frontiere = BLOC( condition = " MAILLAGE_FRONTIERE != None " ,
+                      fr="Information complémentaire sur la frontière",
+                      ang="Further information about boundary",
+#
+    GROUP_MA_FRONT = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                          fr="Groupes de mailles définissant la frontière",
+                          ang="Mesh groups which define the boundary" ),
+#
+                    ) ,
+#
+# 6. Les options ; par defaut, on controle tout
+# 6.1. Nombre de noeuds et elements
+#
+  NOMBRE         = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),
+                        fr="Nombre de noeuds et éléments du maillage",
+                        ang="Number of nodes and elements in the mesh" ),
+#
+# 6.2. Determination de la qualite des elements du maillage
+#
+  QUALITE        = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),
+                        fr="Qualité du maillage",
+                        ang="Mesh quality" ),
+#
+# 6.3. Connexite du maillage
+#
+  CONNEXITE      = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),
+                        fr="Connexité du maillage.",
+                        ang="Mesh connexity." ),
+#
+# 6.4. Taille des sous-domaines du maillage
+#
+  TAILLE         = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),
+                        fr="Tailles des sous-domaines du maillage.",
+                        ang="Sizes of mesh sub-domains." ),
+#
+# 6.5. Controle de la non-interpenetration des elements
+#
+  INTERPENETRATION=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
+                        fr="Controle de la non interpénétration des éléments.",
+                        ang="Overlapping checking." ),
+#
+# 7. Gestion des éléments autres que ceux compatibles avec HOMARD
+#       "REFUSER" : ils sont refuses (defaut)
+#       "IGNORER" : ils sont ignorés
+#
+  ELEMENTS_NON_HOMARD = SIMP(statut='f',typ='TXM',defaut="REFUSER",into=("REFUSER","IGNORER"),
+                             fr="Acceptation d'éléments incompatibles avec HOMARD",
+                             ang="Incompatible elements for HOMARD" ),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 DURAND C.DURAND
+
+from Macro.macr_lign_coupe_ops import macr_lign_coupe_ops
+
+MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table_sdaster,
+                       reentrant='n',
+            UIinfo={"groupes":("Outils métier",)},
+            fr="Extraction des valeurs d'un résultat dans une ou plusieurs tables sur des lignes de coupe définies"
+             +" par deux points et un intervalle",
+            regles=(UN_PARMI("RESULTAT","CHAM_GD"),),
+
+         RESULTAT        =SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther) ),
+         CHAM_GD         =SIMP(statut='f',typ=(cham_gd_sdaster)),
+
+         b_extrac        =BLOC(condition = "RESULTAT != None",fr="extraction des résultats",
+                                 regles=(EXCLUS('NUME_ORDRE','LIST_ORDRE','INST','LIST_INST',), ),
+             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),
+             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',),),
+           ),
+
+# 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' ),
+         ),
+         b_ther        =BLOC(condition = "AsType(RESULTAT) in (evol_ther,)",fr="résultat thermique",
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut='TEMP' ),
+         ),
+         b_cham       =BLOC(condition = "CHAM_GD!=None",
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',),),
+
+         UNITE_MAILLAGE  =SIMP(statut='f',typ='I',defaut=25),
+         MODELE          =SIMP(statut='f',typ=modele_sdaster ),
+
+         VIS_A_VIS       =FACT(statut='f',max='**',
+                             regles=(EXCLUS('GROUP_MA_1','MAILLE_1'),),
+           GROUP_MA_1        =SIMP(statut='f',typ=grma),
+           MAILLE_1          =SIMP(statut='f',typ=ma,max='**'),),
+
+         LIGN_COUPE     =FACT(statut='o',max='**',
+            regles=(EXCLUS("NOM_CMP","INVARIANT","ELEM_PRINCIPAUX","RESULTANTE"),
+                    PRESENT_PRESENT("TRAC_DIR","DIRECTION"),
+                    EXCLUS("TRAC_DIR","TRAC_NOR"),
+                    PRESENT_PRESENT("TRAC_DIR","NOM_CMP"),
+                    PRESENT_PRESENT("TRAC_NOR","NOM_CMP"),),
+
+           INTITULE        =SIMP(statut='f',typ='TXM',),
+           TYPE            =SIMP(statut='o',typ='TXM',max=1,
+                                 into=("GROUP_NO","SEGMENT","ARC","GROUP_MA"),defaut="SEGMENT"),
+           REPERE          =SIMP(statut='f',typ='TXM',defaut="GLOBAL",
+                                into=("GLOBAL","LOCAL","POLAIRE","UTILISATEUR","CYLINDRIQUE"),),
+           OPERATION       =SIMP(statut='f',typ='TXM',into=("EXTRACTION","MOYENNE",),defaut="EXTRACTION",),
+
+           NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),
+           INVARIANT       =SIMP(statut='f',typ='TXM',into=("OUI",),),
+           ELEM_PRINCIPAUX =SIMP(statut='f',typ='TXM',into=("OUI",),),
+           RESULTANTE      =SIMP(statut='f',typ='TXM',max='**'),
+           TRAC_NOR        =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           TRAC_DIR        =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           DIRECTION       =SIMP(statut='f',typ='R',max='**'),
+
+
+           b_local        =BLOC(condition = "REPERE=='LOCAL' ",
+             VECT_Y          =SIMP(statut='o',typ='R',min=2,max=3),),
+
+           b_utili        =BLOC(condition = "REPERE=='UTILISATEUR'",
+             ANGL_NAUT       =SIMP(statut='o',typ='R',min=3,max=3),),
+
+           b_grno          =BLOC(condition = "TYPE=='GROUP_NO'",
+             GROUP_NO        =SIMP(statut='o',typ=grno, max=1),),
+
+           b_grma          =BLOC(condition = "TYPE=='GROUP_MA'",
+             GROUP_MA        =SIMP(statut='o',typ=grma, max=1),
+             MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster),),
+
+           b_segment       =BLOC(condition = "TYPE=='SEGMENT'",
+             NB_POINTS       =SIMP(statut='o',typ='I',max=1),
+             COOR_ORIG       =SIMP(statut='o',typ='R',min=2,max=3),
+             COOR_EXTR       =SIMP(statut='o',typ='R',min=2,max=3),),
+
+           b_arc           =BLOC(condition = "TYPE=='ARC'",
+             NB_POINTS       =SIMP(statut='o',typ='I',max=1),
+             COOR_ORIG       =SIMP(statut='o',typ='R',min=2,max=3),
+             CENTRE          =SIMP(statut='o',typ='R',min=2,max=3),
+             ANGLE           =SIMP(statut='o',typ='R',max=1),
+             DNOR            =SIMP(statut='f',typ='R',min=2,max=3),),
+
+           b_cylind       =BLOC(condition = ("REPERE=='CYLINDRIQUE' and TYPE!='ARC'"),
+             ORIGINE         =SIMP(statut='f',typ='R',min=2,max=3),
+             AXE_Z           =SIMP(statut='f',typ='R',min=3,max=3),),
+
+           DISTANCE_MAX    =SIMP(statut='f',typ='R',defaut=0.,
+                fr="Si la distance entre un noeud de la ligne de coupe et le maillage coupé "
+                +"est > DISTANCE_MAX, ce noeud sera ignoré."),
+
+         ),
+)  ;
+
+
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DESROCHES X.DESROCHES
+
+from Macro.macro_elas_mult_ops import macro_elas_mult_ops
+
+def macro_elas_mult_prod(self,NUME_DDL,CAS_CHARGE,**args ):
+  if isinstance(NUME_DDL,CO) :
+    self.type_sdprod(NUME_DDL,nume_ddl_sdaster)
+  else:
+    self.type_sdprod(NUME_DDL,NUME_DDL.__class__)
+  if CAS_CHARGE[0]['NOM_CAS']      != None : return mult_elas
+  if CAS_CHARGE[0]['MODE_FOURIER'] != None : return fourier_elas
+  raise AsException("type de concept resultat non prevu")
+
+MACRO_ELAS_MULT=MACRO(nom="MACRO_ELAS_MULT",op=macro_elas_mult_ops,sd_prod=macro_elas_mult_prod,reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+         fr="Calculer les réponses statiques linéaires pour différents cas de charges ou modes de Fourier",
+         regles=(UN_PARMI('CHAR_MECA_GLOBAL','CHAR_CINE_GLOBAL','LIAISON_DISCRET', ),),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         NUME_DDL        =SIMP(statut='f',typ=(nume_ddl_sdaster,CO)),
+         CHAR_MECA_GLOBAL=SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+         CHAR_CINE_GLOBAL=SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+         LIAISON_DISCRET =SIMP(statut='f',typ='TXM',into=("OUI",)),
+         CAS_CHARGE      =FACT(statut='o',max='**',
+           regles=(UN_PARMI('NOM_CAS','MODE_FOURIER'),
+                   UN_PARMI('CHAR_MECA','CHAR_CINE','VECT_ASSE'),),
+           NOM_CAS         =SIMP(statut='f',typ='TXM' ),
+           MODE_FOURIER    =SIMP(statut='f',typ='I' ),
+           TYPE_MODE       =SIMP(statut='f',typ='TXM',defaut="SYME",into=("SYME","ANTI","TOUS") ),
+           CHAR_MECA       =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
+           CHAR_CINE       =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","SIRE_ELNO_DEPL",
+                                       "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") ),
+           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='**'),
+           VECT_ASSE       =SIMP(statut='f',typ=cham_no_sdaster),
+         ),
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT") ),
+           b_mult_front    = BLOC ( condition = "METHODE == 'MULT_FRONT' ",
+                                    fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+            ),
+           b_ldlt_mult     =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factorise",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2)),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 BODEL C.BODEL
+
+from Macro.macro_expans_ops import macro_expans_ops
+
+def macro_expans_prod(self, MODELE_MESURE, RESU_NX, RESU_EX, RESU_ET, RESU_RD, **args):
+    RESU_EXP = MODELE_MESURE['MESURE']
+    self.type_sdprod(RESU_NX, mode_meca)
+    for res in (RESU_EX, RESU_ET, RESU_RD):
+        if isinstance(res, CO):
+            if AsType(RESU_EXP) == mode_meca:
+                self.type_sdprod(res, mode_meca)
+            else:
+                self.type_sdprod(res, dyna_harmo)
+        else:
+            self.type_sdprod(res,res.__class__)
+    return None
+
+MACRO_EXPANS=MACRO(nom="MACRO_EXPANS",
+                   op=macro_expans_ops,
+                   sd_prod=macro_expans_prod,
+                   reentrant='n',
+                   UIinfo={"groupes":("Outils métier",)},
+                   fr="Outil d'expansion de resultats exprimentaux sur une base definie sur un modele numerique",
+                        MODELE_CALCUL   = FACT(statut='o',
+                           MODELE          = SIMP(statut='o',typ=(modele_sdaster) ),
+                           BASE            = SIMP(statut='o',typ=(mode_meca,) ), 
+                           NUME_MODE       = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0),
+                           NUME_ORDRE      = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0),
+
+                                             ),
+                        MODELE_MESURE   = FACT(statut='o',
+                           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",) ),
+                           NUME_MODE       = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0),
+                           NUME_ORDRE      = SIMP(statut='f',typ='I',validators=NoRepeat(),max='**',defaut=0),
+
+                                             ),
+                        NUME_DDL       = SIMP(statut='f',typ=(nume_ddl_sdaster)),
+                        RESU_NX        = SIMP(statut='f',typ=(mode_meca,dyna_harmo, CO)),
+                        RESU_EX        = SIMP(statut='f',typ=(mode_meca,dyna_harmo, CO)),
+                        RESU_ET        = SIMP(statut='f',typ=(mode_meca,dyna_harmo, CO)),
+                        RESU_RD        = SIMP(statut='f',typ=(mode_meca,dyna_harmo, CO)),
+                        RESOLUTION     = FACT(statut='f',
+                           METHODE =SIMP(statut='f',typ='TXM',defaut="LU",into=("LU","SVD",) ),
+                           b_svd   =BLOC(condition="METHODE=='SVD'",
+                                         EPS=SIMP(statut='f',typ='R',defaut=0. ),
+                                        ),
+                           REGUL   =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","NORM_MIN","TIK_RELA",) ),
+                           b_regul =BLOC(condition="REGUL!='NON'",
+                                         regles=(PRESENT_ABSENT('COEF_PONDER','COEF_PONDER_F', ),),
+                                         COEF_PONDER   =SIMP(statut='f',typ='R',defaut=0.     ,max='**' ),
+                                         COEF_PONDER_F =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**' ),
+                                        ),
+                                             ),
+                   )
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 GREFFET N.GREFFET
+
+from Macro.macro_matr_ajou_ops import macro_matr_ajou_ops
+
+def macro_matr_ajou_prod(self,MATR_AMOR_AJOU,MATR_MASS_AJOU,MATR_RIGI_AJOU,FORC_AJOU,**args):
+  self.type_sdprod(MATR_AMOR_AJOU,matr_asse_gene_r)
+  self.type_sdprod(MATR_MASS_AJOU,matr_asse_gene_r)
+  self.type_sdprod(MATR_RIGI_AJOU,matr_asse_gene_r)
+  if FORC_AJOU != None:
+    for m in FORC_AJOU:
+      self.type_sdprod(m['VECTEUR'],vect_asse_gene)
+
+  return None
+
+MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro_matr_ajou_prod,
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+            fr="Calculer de facon plus condensée qu'avec CALC_MATR_AJOU des matrices de masse, d'amortissement"
+              +" ou de rigidité ajoutés",
+      regles=(AU_MOINS_UN('MODE_MECA','DEPL_IMPO','MODELE_GENE'),
+              AU_MOINS_UN('MATR_MASS_AJOU','MATR_AMOR_AJOU','MATR_RIGI_AJOU'),
+              EXCLUS('MODE_MECA','DEPL_IMPO','MODELE_GENE'),
+              EXCLUS('MONO_APPUI','MODE_STAT',),
+             ),
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster),
+         GROUP_MA_FLUIDE =SIMP(statut='o',typ=grma),
+         GROUP_MA_INTERF =SIMP(statut='o',typ=grma),
+         MODELISATION    =SIMP(statut='o',typ='TXM',into=("PLAN","AXIS","3D")),
+         FLUIDE          =FACT(statut='o',max='**',
+           RHO             =SIMP(statut='o',typ='R'),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           GROUP_MA        =SIMP(statut='f',typ=grma),
+           MAILLE          =SIMP(statut='f',typ=ma),
+         ),
+         DDL_IMPO        =FACT(statut='o',max='**',
+           regles=(UN_PARMI('NOEUD','GROUP_NO'),
+                   UN_PARMI('PRES_FLUIDE','PRES_SORTIE'),),
+           NOEUD           =SIMP(statut='f',typ=no),
+           GROUP_NO        =SIMP(statut='f',typ=grno),
+           PRES_FLUIDE     =SIMP(statut='f',typ='R'),
+           PRES_SORTIE     =SIMP(statut='f',typ='R'),
+         ),
+         ECOULEMENT      =FACT(statut='f',
+           GROUP_MA_1      =SIMP(statut='o',typ=grma),
+           GROUP_MA_2      =SIMP(statut='o',typ=grma),
+           VNOR_1          =SIMP(statut='o',typ='R'),
+           VNOR_2          =SIMP(statut='f',typ='R'),
+           POTENTIEL       =SIMP(statut='f',typ=evol_ther),
+         ),
+         MODE_MECA       =SIMP(statut='f',typ=mode_meca),
+         DEPL_IMPO       =SIMP(statut='f',typ=cham_no_sdaster),
+         MODELE_GENE     =SIMP(statut='f',typ=modele_gene),
+         NUME_DDL_GENE   =SIMP(statut='f',typ=nume_ddl_gene),
+         DIST_REFE       =SIMP(statut='f',typ='R',defaut= 1.0E-2),
+         MATR_MASS_AJOU  =SIMP(statut='f',typ=CO,),
+         MATR_RIGI_AJOU  =SIMP(statut='f',typ=CO,),
+         MATR_AMOR_AJOU  =SIMP(statut='f',typ=CO,),
+         MONO_APPUI      =SIMP(statut='f',typ='TXM',into=("OUI",),),
+         MODE_STAT       =SIMP(statut='f',typ=mode_meca,),
+         FORC_AJOU       =FACT(statut='f',max='**',
+           DIRECTION     =SIMP(statut='o',typ='R',max=3),
+           NOEUD         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           GROUP_NO      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           VECTEUR       =SIMP(statut='o',typ=CO),
+         ),
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt         =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_gcpc          =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.0E-6,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+         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 17/11/2008   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 PELLET J.PELLET
+
+from Macro.macro_matr_asse_ops import macro_matr_asse_ops
+
+def macro_matr_asse_prod(self,NUME_DDL,MATR_ASSE,**args):
+  if not MATR_ASSE:  raise AsException("Impossible de typer les concepts resultats")
+  if not NUME_DDL :  raise AsException("Impossible de typer les concepts resultats")
+  if isinstance(NUME_DDL,CO) :
+    self.type_sdprod(NUME_DDL,nume_ddl_sdaster)
+  else:
+    self.type_sdprod(NUME_DDL,NUME_DDL.__class__)
+  for m in MATR_ASSE:
+    opti=m['OPTION']
+
+    if opti in ( "RIGI_MECA","RIGI_FLUI_STRU","RIGI_MECA_LAGR" ,
+       "MASS_MECA" , "MASS_FLUI_STRU" ,"RIGI_GEOM" ,"RIGI_ROTA",
+       "AMOR_MECA","IMPE_MECA",
+       "ONDE_FLUI","MASS_MECA_DIAG","MECA_GYRO" ) : t=matr_asse_depl_r
+
+    if opti in ( "RIGI_ACOU","MASS_ACOU","AMOR_ACOU",) : t=matr_asse_pres_c
+
+    if opti in ( "RIGI_THER","MASS_THER","RIGI_THER_CONV" ,
+       "RIGI_THER_CONV_D",) : t=matr_asse_temp_r
+
+    if opti == "RIGI_MECA_HYST"   : t= matr_asse_depl_c
+
+    self.type_sdprod(m['MATRICE'],t)
+  return None
+
+MACRO_MATR_ASSE=MACRO(nom="MACRO_MATR_ASSE",op=macro_matr_asse_ops,
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+                      sd_prod=macro_matr_asse_prod,
+                      fr="Calcul des matrices assemblées (rigidité, masse, amortissement,...) ",
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+         INST            =SIMP(statut='f',typ='R',defaut=0.),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         CHARGE          =SIMP(statut='f',typ=(char_meca,char_ther,char_acou),validators=NoRepeat(),max='**'),
+         CHAR_CINE       =SIMP(statut='f',typ=(char_cine_meca,char_cine_ther,char_cine_acou) ),
+         NUME_DDL        =SIMP(statut='o',typ=(nume_ddl_sdaster,CO)),
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+         b_mult_front    =BLOC(condition="METHODE=='MULT_FRONT'",fr="Paramètres associés à la méthode multifrontale",
+           RENUM           =SIMP(statut='f',typ='TXM',into=("MD","MDA","METIS"),defaut="METIS" ),
+         ),
+         b_ldlt          =BLOC(condition="METHODE=='LDLT'",fr="Paramètres associés à la méthode LDLT",
+           RENUM           =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK"  ),
+         ),
+         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")),
+           OUT_OF_CORE     =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"  ),
+         ),
+         b_petsc         =BLOC(condition = "METHODE == 'PETSC'",fr="Paramètres de la méthode PETSC",
+           RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+         ),
+         ),
+
+         MATR_ASSE       =FACT(statut='o',max='**',
+             MATRICE         =SIMP(statut='o',typ=CO),
+             OPTION          =SIMP(statut='o',typ='TXM',
+                                   into=("RIGI_MECA","MASS_MECA","MASS_MECA_DIAG",
+                                         "AMOR_MECA","RIGI_MECA_HYST","IMPE_MECA",
+                                         "ONDE_FLUI","RIGI_FLUI_STRU","MASS_FLUI_STRU",
+                                         "RIGI_ROTA","RIGI_GEOM","RIGI_MECA_LAGR","MECA_GYRO",
+                                         "RIGI_THER","MASS_THER",
+                                         "RIGI_ACOU","MASS_ACOU","AMOR_ACOU",)
+                                   ),
+
+             b_rigi_meca = BLOC( condition = "OPTION=='RIGI_MECA'",
+               MODE_FOURIER    =SIMP(statut='f',typ='I',defaut= 0),
+             ),
+
+             b_rigi_geom = BLOC( condition = "OPTION=='RIGI_GEOM'",
+               SIEF_ELGA       =SIMP(statut='o',typ=cham_elem),
+               MODE_FOURIER    =SIMP(statut='f',typ='I',defaut= 0),
+             ),
+
+             b_rigi_meca_lagr = BLOC( condition = "OPTION=='RIGI_MECA_LAGR'",
+               THETA           =SIMP(statut='o',typ=theta_geom),
+               PROPAGATION     =SIMP(statut='f',typ='R'),
+             ),
+
+             b_rigi_ther = BLOC( condition = "OPTION=='RIGI_THER'",
+               MODE_FOURIER    =SIMP(statut='f',typ='I',defaut= 0),
+             ),
+
+         ), # fin MATR_ASSE
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 02/06/2008   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.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE DEVESA G.DEVESA
+
+from Macro.macro_miss_3d_ops import macro_miss_3d_ops
+
+MACRO_MISS_3D=MACRO(nom="MACRO_MISS_3D",op=macro_miss_3d_ops,
+            fr="Préparation des données puis exécution du logiciel MISS3D",
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         OPTION          =FACT(statut='o',
+           regles=(UN_PARMI('TOUT','MODULE'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           MODULE          =SIMP(statut='f',typ='TXM',into=("PRE_MISS","MISS_EVOL","MISS_IMPE")),
+         ),
+         PROJET          =SIMP(statut='o',typ='TXM'),  
+         REPERTOIRE      =SIMP(statut='f',typ='TXM'),
+         VERSION         =SIMP(statut='f',typ='TXM',into=("V1_3","V1_4",),defaut="V1_4"),
+         UNITE_IMPR_ASTER=SIMP(statut='f',typ='I',defaut=25),  
+         UNITE_OPTI_MISS =SIMP(statut='f',typ='I',defaut=26),  
+         UNITE_MODELE_SOL=SIMP(statut='f',typ='I',defaut=27),  
+         UNITE_RESU_IMPE =SIMP(statut='f',typ='I',defaut=30),
+         UNITE_RESU_FORC =SIMP(statut='f',typ='I',defaut=0),
+         PARAMETRE       =FACT(statut='f',         
+           regles=(PRESENT_PRESENT('FREQ_MIN','FREQ_MAX','FREQ_PAS'),
+                   PRESENT_PRESENT('CONTR_NB','CONTR_LISTE'),
+                   PRESENT_PRESENT('LFREQ_NB','LFREQ_LISTE'),
+                   PRESENT_PRESENT('OFFSET_MAX','OFFSET_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'),
+           Z0              =SIMP(statut='f',typ='R'), 
+           SURF            =SIMP(statut='f',typ='TXM',into=("OUI","NON",),defaut="NON"),
+           RFIC            =SIMP(statut='f',typ='R'),
+           FICH_RESU_IMPE  =SIMP(statut='f',typ='TXM'),
+           FICH_RESU_FORC  =SIMP(statut='f',typ='TXM'),
+           TYPE            =SIMP(statut='f',typ='TXM',into=("BINAIRE","ASCII",),defaut="ASCII"),
+           DREF            =SIMP(statut='f',typ='R'),
+           ALGO            =SIMP(statut='f',typ='TXM',into=("DEPL","REGU")),
+           OFFSET_MAX      =SIMP(statut='f',typ='R'),
+           OFFSET_NB       =SIMP(statut='f',typ='I'),
+           SPEC_MAX        =SIMP(statut='f',typ='R'),
+           SPEC_NB         =SIMP(statut='f',typ='I'),
+           ISSF            =SIMP(statut='f',typ='TXM',into=("OUI","NON",),defaut="NON"),
+           FICH_POST_TRAI  =SIMP(statut='f',typ='TXM'),
+           CONTR_NB        =SIMP(statut='f',typ='I'),
+           CONTR_LISTE     =SIMP(statut='f',typ='R',max='**'),
+           LFREQ_NB        =SIMP(statut='f',typ='I'),
+           LFREQ_LISTE     =SIMP(statut='f',typ='R',max='**'),
+           DIRE_ONDE       =SIMP(statut='f',typ='R',max='**'),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 05/05/2008   AUTEUR NISTOR I.NISTOR 
+#            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 NISTOR I.NISTOR
+
+from Macro.macro_mode_meca_ops import macro_mode_meca_ops
+
+MACRO_MODE_MECA=MACRO(nom="MACRO_MODE_MECA",op=macro_mode_meca_ops,sd_prod=mode_meca,
+                     reentrant='n',fr="Lancer une succession de calculs de modes propres réels",
+            UIinfo={"groupes":("Résolution",)},
+         MATR_A          =SIMP(statut='o',typ=matr_asse_depl_r ),
+         MATR_B          =SIMP(statut='o',typ=matr_asse_depl_r ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+#  ce mot cle ne devrait il pas etre dans calc_freq  
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="SORENSEN",    
+                               into=("TRI_DIAG","JACOBI","SORENSEN",) ),
+         b_tri_diag =BLOC(condition = "METHODE == 'TRI_DIAG'",
+           PREC_ORTHO      =SIMP(statut='f',typ='R',defaut= 1.E-12,val_min=0.E+0 ),
+           NMAX_ITER_ORTHO =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+           PREC_LANCZOS    =SIMP(statut='f',typ='R',defaut= 1.E-8,val_min=0.E+0 ),
+           NMAX_ITER_QR    =SIMP(statut='f',typ='I',defaut= 30,val_min=0 ), 
+         ),
+         b_jacobi =BLOC(condition = "METHODE == 'JACOBI'",
+           PREC_BATHE      =SIMP(statut='f',typ='R',defaut= 1.E-10,val_min=0.E+0 ),
+           NMAX_ITER_BATHE =SIMP(statut='f',typ='I',defaut= 40,val_min=0 ),
+           PREC_JACOBI     =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
+           NMAX_ITER_JACOBI=SIMP(statut='f',typ='I',defaut= 12,val_min=0 ),
+         ),
+         b_sorensen =BLOC(condition = "METHODE == 'SORENSEN'",
+           PREC_SOREN      =SIMP(statut='f',typ='R',defaut= 0.E+0,val_min=0.E+0 ),  
+           NMAX_ITER_SOREN =SIMP(statut='f',typ='I',defaut= 20,val_min=0 ),  
+           PARA_ORTHO_SOREN=SIMP(statut='f',typ='R',defaut= 0.717,val_min=0.E+0 ),
+         ),
+         OPTION          =SIMP(statut='f',typ='TXM',defaut="SANS",    
+                               into=("MODE_RIGIDE","SANS") ),
+         CALC_FREQ       =FACT(statut='d',min=0,
+           regles=(UN_PARMI('FREQ','FREQ_MAX'),
+                   PRESENT_PRESENT('FREQ_MIN','FREQ_MAX'),
+                   PRESENT_PRESENT('FREQ_MAX','NB_BLOC_FREQ'),
+                   EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
+           FREQ            =SIMP(statut='f',typ='R',min=2,validators=NoRepeat(),max='**', ),  
+           FREQ_MIN        =SIMP(statut='f',typ='R' ),  
+           FREQ_MAX        =SIMP(statut='f',typ='R' ),  
+           NB_BLOC_FREQ    =SIMP(statut='f',typ='I' ),  
+           DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),  
+           COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
+           NPREC_SOLVEUR   =SIMP(statut='f',typ='I',defaut= 8 ),  
+           NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5 ),  
+           PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-2 ),  
+           SEUIL_FREQ      =SIMP(statut='f',typ='R' ,defaut= 1.E-2 ),  
+           STOP_FREQ_VIDE  =SIMP(statut='f',typ='TXM',defaut="NON" ,into=("OUI","NON") ),
+         ),
+         VERI_MODE       =FACT(statut='d',min=0,
+           STOP_ERREUR     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           SEUIL           =SIMP(statut='f',typ='R',defaut= 1.E-6 ),  
+           PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-3 ),  
+           STURM           =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         ),
+         NORM_MODE       =FACT(statut='o',max='**',
+           NORME           =SIMP(statut='f',typ='TXM',defaut="TRAN_ROTA",    
+                                 into=("MASS_GENE","RIGI_GENE","EUCL",           
+                                       "EUCL_TRAN","TRAN","TRAN_ROTA") ),
+           INFO            =SIMP(statut='f',typ='I',defaut= 1 ,into=(1,2) ),
+         ),
+         FILTRE_MODE     =FACT(statut='f',
+           CRIT_EXTR       =SIMP(statut='f',typ='TXM',defaut="MASS_EFFE_UN",    
+                                 into=("MASS_EFFE_UN","MASS_GENE") ),
+           SEUIL           =SIMP(statut='f',typ='R',defaut= 1.E-3 ),  
+         ),
+         IMPRESSION      =FACT(statut='d',
+           TOUT_PARA       =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           CUMUL           =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           CRIT_EXTR       =SIMP(statut='f',typ='TXM',defaut="MASS_EFFE_UN",    
+                                 into=("MASS_EFFE_UN","MASS_GENE",) ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 BOYERE E.BOYERE
+
+from Macro.macro_proj_base_ops import macro_proj_base_ops
+
+def macro_proj_base_prod(self,MATR_ASSE_GENE,VECT_ASSE_GENE,PROFIL,**args ):
+  if MATR_ASSE_GENE != None:
+    for m in MATR_ASSE_GENE:
+      self.type_sdprod(m['MATRICE'],matr_asse_gene_r)
+  if VECT_ASSE_GENE != None:
+    for v in VECT_ASSE_GENE:
+      self.type_sdprod(v['VECTEUR'],vect_asse_gene)
+  return None
+
+MACRO_PROJ_BASE=MACRO(nom="MACRO_PROJ_BASE",op=macro_proj_base_ops,
+         regles=(AU_MOINS_UN('MATR_ASSE_GENE','VECT_ASSE_GENE')),
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+                      sd_prod=macro_proj_base_prod,
+         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 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+
+from Macro.macr_recal_ops import macr_recal_ops
+
+def macr_recal_prod(self,**args ):
+  return listr8_sdaster
+
+MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,
+            UIinfo={"groupes":("Résultats et champs",)},
+                      sd_prod=macr_recal_prod,
+                      fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux"
+                        +" ou sur d'autres résultats de calculs",
+         UNITE_ESCL      =SIMP(statut='o',typ='I'),
+         RESU_EXP        =SIMP(statut='o',typ=assd,max='**'),
+         POIDS           =SIMP(statut='f',typ=assd,max='**'),
+         RESU_CALC       =SIMP(statut='o',typ=assd,max='**'),
+         LIST_PARA       =SIMP(statut='o',typ=assd,max='**'),
+         LIST_DERIV      =SIMP(statut='f',typ=assd,max='**'),
+         ITER_MAXI       =SIMP(statut='f',typ='I',defaut=10),
+         ITER_FONC_MAXI  =SIMP(statut='f',typ='I',defaut=100),
+         RESI_GLOB_RELA  =SIMP(statut='f',typ='R',defaut=1.E-3),
+         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")),
+           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"),
+         ),
+
+         AFFICHAGE       =SIMP(statut='f',typ='TXM',defaut='TOUTE_ITERATION',into=("TOUTE_ITERATION","ITERATION_FINALE")),),
+         SUIVI_ESCLAVE   =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON"),),
+
+         METHODE         =SIMP(statut='f',typ='TXM',defaut='LEVENBERG',into=("LEVENBERG","FMIN","FMINBFGS","FMINNCG","EXTERNE")),
+
+         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_externe =BLOC(condition = "METHODE == 'EXTERNE'" ,
+            GRADIENT        =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )),
+         ),
+
+         b_type_fonctionnelle =BLOC(condition = "METHODE == 'EXTERNE'" ,
+            FONCTIONNELLE   =SIMP(statut='f',typ='TXM',defaut='SCALAIRE',into=("SCALAIRE","VECTORIELLE")),
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut=2,into=( 1, 2 ) ),
+);
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE VOLDOIRE F.VOLDOIRE
+
+from Macro.macr_spectre_ops import macr_spectre_ops
+
+MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster,
+                       reentrant='n', UIinfo={"groupes":("Outils métier",)},
+                       fr="calcul de spectre, post-traitement de séisme",
+         MAILLAGE      =SIMP(statut='o',typ=maillage_sdaster,),
+         PLANCHER      =FACT(statut='o',max='**',
+            regles=(AU_MOINS_UN('NOEUD','GROUP_NO' ),),
+            NOM           =SIMP(statut='o',typ='TXM',),
+            GROUP_NO      =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+            NOEUD         =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'), ),
+         NOM_CHAM      =SIMP(statut='o',typ='TXM' ,into=('ACCE','DEPL')),
+         CALCUL        =SIMP(statut='o',typ='TXM' ,into=('ABSOLU','RELATIF'),position='global'),
+         b_acce  =BLOC( condition = "NOM_CHAM=='ACCE'",
+           regles=(UN_PARMI('LIST_FREQ','FREQ'),),
+           AMOR_SPEC     =SIMP(statut='o',typ='R',max='**'),
+           LIST_INST     =SIMP(statut='f',typ=listr8_sdaster ),
+           LIST_FREQ     =SIMP(statut='f',typ=listr8_sdaster ),
+           FREQ          =SIMP(statut='f',typ='R',max='**'),
+           NORME         =SIMP(statut='o',typ='R'),  
+           RESU          =FACT(statut='o',max='**',
+                regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
+                RESU_GENE     =SIMP(statut='f',typ=tran_gene),
+                RESULTAT      =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
+                b_calc  =BLOC( condition = "CALCUL=='RELATIF'",
+                   ACCE_X        =SIMP(statut='o',typ=fonction_sdaster),
+                   ACCE_Y        =SIMP(statut='o',typ=fonction_sdaster),
+                   ACCE_Z        =SIMP(statut='o',typ=fonction_sdaster),), ),
+           IMPRESSION    =FACT(statut='f',
+                TRI           =SIMP(statut='f',typ='TXM',defaut='AMOR_SPEC',into=("AMOR_SPEC","DIRECTION",),),
+                FORMAT        =SIMP(statut='f',typ='TXM',defaut='TABLEAU',into=("TABLEAU","XMGRACE",),),
+                UNITE         =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
+                                    fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+                b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'",
+                   PILOTE        =SIMP(statut='f',typ='TXM',defaut='',
+                                 into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),),),
+                TOUT          =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON",),),
+                              ),
+         ),
+         b_depl  =BLOC( condition = "NOM_CHAM=='DEPL'",
+           LIST_INST     =SIMP(statut='f',typ=listr8_sdaster),  
+           RESU          =FACT(statut='o',max=3,
+                regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
+                RESU_GENE     =SIMP(statut='f',typ=tran_gene),
+                RESULTAT      =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
+                b_calc  =BLOC( condition = "CALCUL=='ABSOLU'",
+                   DEPL_X        =SIMP(statut='o',typ=fonction_sdaster),
+                   DEPL_Y        =SIMP(statut='o',typ=fonction_sdaster),
+                   DEPL_Z        =SIMP(statut='o',typ=fonction_sdaster),),),
+         ),
+)
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE 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",
+
+         ELEMENT         =FACT(statut='f',),
+
+)  ;
+#& MODIF COMMANDE  DATE 20/10/2009   AUTEUR BOITEAU O.BOITEAU 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas,
+                   fr="Résoudre un problème de mécanique statique linéaire",reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+         regles=(EXCLUS("INST","LIST_INST"),
+                 AU_MOINS_UN('CHAM_MATER','CARA_ELEM',),
+                 CONCEPT_SENSIBLE('ENSEMBLE'),),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater,
+         fr="le CHAM_MATER est nécessaire, sauf si le modèle ne contient que des éléments discrets (modélisations DIS_XXX)",
+         ang="CHAM_MATER is compulsory, except if the model contains only discret elements (modelizations DIS_XXX)"),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem,
+         fr="le CARA_ELEM est nécessaire dès que le modèle contient des éléments de structure : coques, poutres, ...",
+         ang="CARA_ELEM is compulsory as soon as the model contains structural elements : plates, beams, ..."),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         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",into=("FIXE",) ),
+         ),
+         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,
+             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='**',
+                               fr="Liste des paramètres de sensibilité.",
+                               ang="List of sensitivity parameters"),
+
+         SOLVEUR         =FACT(statut='d',
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","FETI","MUMPS","PETSC") ),
+
+           b_feti          =BLOC(condition = "METHODE == 'FETI' ",fr="Paramètres de la méthode FETI 1",
+             PARTITION       =SIMP(statut='o',typ=sd_feti_sdaster),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.E-6,val_min=0.),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             REAC_RESI       =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             TYPE_REORTHO_DD =SIMP(statut='f',typ='TXM',defaut="GSM",into=("SANS","GS","GSM","IGSM") ),
+             NB_REORTHO_DD   =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             NB_REORTHO_INST =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             PRE_COND        =SIMP(statut='f',typ='TXM',defaut="LUMPE",into=("LUMPE","SANS") ),
+             SCALING         =SIMP(statut='f',typ='TXM',defaut="MULT",into=("SANS","MULT") ),
+             VERIF_SDFETI    =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+             TEST_CONTINU    =SIMP(statut='f',typ='R',defaut=1.E-8,val_min=0.),
+             INFO_FETI       =SIMP(statut='f',typ='TXM',defaut='FFFFFFFFFFFFFFFFFFFFFFFF'),
+             STOCKAGE_GI     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON","CAL") ),
+             NB_SD_PROC0     =SIMP(statut='f',typ='I',defaut=0,val_min=0),
+             ACCELERATION_SM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+
+           b_direct_hybride =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' or METHODE=='FETI' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+
+           b_gcpc         =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.E-6),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.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")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 BODEL C.BODEL
+MODE_ITER_CYCL=OPER(nom="MODE_ITER_CYCL",op=  80,sd_prod=mode_cycl,
+                    fr="Calcul des modes propres d'une structure à répétitivité cyclique à partir"
+                        +" d'une base de modes propres réels",
+                    reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         BASE_MODALE     =SIMP(statut='o',typ=mode_meca ),
+         NB_MODE         =SIMP(statut='f',typ='I',defaut= 999 ),
+         NB_SECTEUR      =SIMP(statut='o',typ='I' ),
+         LIAISON         =FACT(statut='o',
+           DROITE          =SIMP(statut='o',typ='TXM' ),
+           GAUCHE          =SIMP(statut='o',typ='TXM' ),
+           AXE             =SIMP(statut='f',typ='TXM' ),
+         ),
+         VERI_CYCL       =FACT(statut='f',
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF",) ),
+           DIST_REFE       =SIMP(statut='f',typ='R' ),
+         ),
+         CALCUL          =FACT(statut='o',
+           regles=(UN_PARMI('TOUT_DIAM','NB_DIAM'),),
+           TOUT_DIAM       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NB_DIAM         =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           OPTION          =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE"
+                                ,into=("PLUS_PETITE","CENTRE","BANDE") ),
+           b_centre      =BLOC(condition = "OPTION == 'CENTRE'",
+             FREQ            =SIMP(statut='o',typ='R',),
+           ),
+           b_bande       =BLOC(condition = "OPTION == 'BANDE'",
+             FREQ            =SIMP(statut='o',typ='R',min=2,validators=NoRepeat(),max=2),
+           ),
+#  NMAX_FREQ n a-t-il pas un sens qu avec OPTION CENTRE                                
+           NMAX_FREQ       =SIMP(statut='f',typ='I',defaut= 10 ),
+           PREC_SEPARE     =SIMP(statut='f',typ='R',defaut= 100. ),
+           PREC_AJUSTE     =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+           NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 50 ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 05/05/2009   AUTEUR BOITEAU O.BOITEAU 
+#            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 O.BOITEAU
+
+def mode_iter_inv_prod(MATR_A,MATR_C,TYPE_RESU,**args ):
+  if TYPE_RESU == "MODE_FLAMB" : return mode_flamb
+  if AsType(MATR_C) == matr_asse_depl_r : return mode_meca_c
+  if AsType(MATR_A) == matr_asse_depl_r : return mode_meca
+  if AsType(MATR_A) == matr_asse_pres_r : return mode_acou
+  if AsType(MATR_A) == matr_asse_gene_r : return mode_gene
+  raise AsException("type de concept resultat non prevu")
+
+MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op=  44,sd_prod=mode_iter_inv_prod
+                    ,fr="Calcul des modes propres par itérations inverses ; valeurs propres et modes réels ou complexes",
+                     reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         regles=(CONCEPT_SENSIBLE('ENSEMBLE'),),
+         MATR_A          =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ) ),
+         MATR_B          =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ) ),
+         MATR_C          =SIMP(statut='f',typ=matr_asse_depl_r ),
+         TYPE_RESU       =SIMP(statut='f',typ='TXM',defaut="DYNAMIQUE",   
+                               into=("MODE_FLAMB","DYNAMIQUE"),fr="Type d analyse" ),
+         b_dynam         =BLOC(condition = "TYPE_RESU == 'DYNAMIQUE'",
+           CALC_FREQ       =FACT(statut='o',fr="Choix des paramètres pour le calcul des valeurs propres",
+           
+             OPTION          =SIMP(statut='f',typ='TXM',defaut="AJUSTE",into=("SEPARE","AJUSTE","PROCHE"),
+                                   fr="Choix de l option pour estimer les valeurs propres"  ),
+             FREQ            =SIMP(statut='o',typ='R',max='**'),
+             AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'),     
+             NMAX_FREQ       =SIMP(statut='f',typ='I',defaut= 0,val_min=0 ),           
+             NMAX_ITER_SEPARE=SIMP(statut='f',typ='I' ,defaut= 30,val_min=0 ),
+             PREC_SEPARE     =SIMP(statut='f',typ='R',defaut= 1.E-4,val_min=0.E+0 ),
+             NMAX_ITER_AJUSTE=SIMP(statut='f',typ='I',defaut= 15,val_min=0 ),
+             PREC_AJUSTE     =SIMP(statut='f',typ='R',defaut= 1.E-4,val_min=0.E+0 ),
+
+             NPREC_SOLVEUR   =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
+             NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+             PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0, ),
+             SEUIL_FREQ      =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0, ),
+           ),
+         ),
+         b_flamb        =BLOC(condition = "TYPE_RESU == 'MODE_FLAMB'",
+           CALC_FREQ       =FACT(statut='o',fr="Choix des paramètres pour le calcul des valeurs propres",
+           
+             OPTION          =SIMP(statut='f',typ='TXM',defaut="AJUSTE",into=("SEPARE","AJUSTE","PROCHE"),
+                                 fr="Choix de l option pour estimer les valeurs propres"  ),
+             CHAR_CRIT       =SIMP(statut='o',typ='R',validators=NoRepeat(),max='**' ),
+             NMAX_FREQ       =SIMP(statut='f',typ='I',defaut= 0,val_min=0 ),           
+             NMAX_ITER_SEPARE=SIMP(statut='f',typ='I' ,defaut= 30,val_min=0 ),
+             PREC_SEPARE     =SIMP(statut='f',typ='R',defaut= 1.E-4,val_min=0.E+0, ),
+             NMAX_ITER_AJUSTE=SIMP(statut='f',typ='I',defaut= 15 ),
+             PREC_AJUSTE     =SIMP(statut='f',typ='R',defaut= 1.E-4,val_min=0.E+0, ),
+           
+             NPREC_SOLVEUR   =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
+             NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+             PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0, ),
+             SEUIL_FREQ      =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0, ),
+           ),
+         ),
+         CALC_MODE       =FACT(statut='d',min=0,fr="Choix des paramètres pour le calcul des vecteurs propres",
+           OPTION          =SIMP(statut='f',typ='TXM',defaut="DIRECT",into=("DIRECT","RAYLEIGH") ),
+           PREC            =SIMP(statut='f',typ='R',defaut= 1.E-5,val_min=0.E+0,fr="Précision de convergence" ),
+           NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 30,val_min=0 ),
+         ),
+         VERI_MODE       =FACT(statut='d',min=0,
+           STOP_ERREUR     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           SEUIL           =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0,
+                                 fr="Valeur limite admise pour l ereur a posteriori des modes"  ),
+         ),
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des param\350tres de sensibilit\351.",
+                               ang="List of sensitivity parameters",
+         ),
+         b_sensibilite   =BLOC(condition = "SENSIBILITE != None",
+             CHAM_MATER      =SIMP(statut='f',typ=cham_mater ),
+             CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+             EXCIT           =FACT(statut='f',max='**',),  # que pour NMDOME
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 05/05/2009   AUTEUR BOITEAU O.BOITEAU 
+#            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 O.BOITEAU
+
+def mode_iter_simult_prod(MATR_A,MATR_C,TYPE_RESU,**args ):
+  if TYPE_RESU == "MODE_FLAMB" : return mode_flamb
+  if AsType(MATR_C) == matr_asse_depl_r : return mode_meca_c
+  if AsType(MATR_A) == matr_asse_depl_r : return mode_meca
+  if AsType(MATR_A) == matr_asse_depl_c : return mode_meca_c
+  if AsType(MATR_A) == matr_asse_pres_r : return mode_acou
+  if AsType(MATR_A) == matr_asse_gene_r : return mode_gene
+  if AsType(MATR_A) == matr_asse_gene_c : return mode_gene
+
+  raise AsException("type de concept resultat non prevu")
+
+MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op=  45,sd_prod=mode_iter_simult_prod,
+                      fr="Calcul des modes propres par itérations simultanées ; valeurs propres et"
+                         +" modes propres réels ou complexes",
+                      reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         regles=(CONCEPT_SENSIBLE('ENSEMBLE'),),
+         MATR_A          =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,
+                               matr_asse_gene_r,matr_asse_gene_c,matr_asse_pres_r ) ),
+         MATR_B          =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ) ),
+         MATR_C          =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_gene_r) ),
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="SORENSEN",
+                               into=("TRI_DIAG","JACOBI","SORENSEN","QZ") ),
+         b_tri_diag =BLOC(condition = "METHODE == 'TRI_DIAG'",
+           PREC_ORTHO      =SIMP(statut='f',typ='R',defaut= 1.E-12,val_min=0.E+0 ),
+           NMAX_ITER_ORTHO =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+           PREC_LANCZOS    =SIMP(statut='f',typ='R',defaut= 1.E-8,val_min=0.E+0 ),
+           NMAX_ITER_QR    =SIMP(statut='f',typ='I',defaut= 30,val_min=0 ), 
+         ),
+         b_jacobi =BLOC(condition = "METHODE == 'JACOBI'",
+           PREC_BATHE      =SIMP(statut='f',typ='R',defaut= 1.E-10,val_min=0.E+0 ),
+           NMAX_ITER_BATHE =SIMP(statut='f',typ='I',defaut= 40,val_min=0 ),
+           PREC_JACOBI     =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
+           NMAX_ITER_JACOBI=SIMP(statut='f',typ='I',defaut= 12,val_min=0 ),
+         ),
+         b_sorensen =BLOC(condition = "METHODE == 'SORENSEN'",
+           PREC_SOREN      =SIMP(statut='f',typ='R',defaut= 0.E+0,val_min=0.E+0 ),  
+           NMAX_ITER_SOREN =SIMP(statut='f',typ='I',defaut= 20,val_min=0 ),  
+           PARA_ORTHO_SOREN=SIMP(statut='f',typ='R',defaut= 0.717,val_min=0.E+0 ),
+         ),
+         b_qz =BLOC(condition = "METHODE == 'QZ'",
+           TYPE_QZ      =SIMP(statut='f',typ='TXM',defaut="QZ_SIMPLE",into=("QZ_QR","QZ_SIMPLE","QZ_EQUI") ),  
+         ),
+         TYPE_RESU       =SIMP(statut='f',typ='TXM',defaut="DYNAMIQUE",
+                               into=("MODE_FLAMB","DYNAMIQUE"),
+                               fr="Type d analyse" ),
+         OPTION          =SIMP(statut='f',typ='TXM',defaut="SANS",into=("MODE_RIGIDE","SANS"),
+                               fr="Calcul des modes de corps rigide, uniquement pour la méthode TRI_DIAG" ),
+
+         b_flamb         =BLOC(condition = "TYPE_RESU == 'MODE_FLAMB'",
+           CALC_FREQ       =FACT(statut='d',min=0,
+             OPTION       =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","BANDE","CENTRE","TOUT"),
+                                   fr="Choix de l option et par conséquent du shift du problème 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 donnée",
+               CHAR_CRIT       =SIMP(statut='o',typ='R',
+                                     fr="Charge critique autour de laquelle on cherche les charges critiques propres"),
+               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 donnée",
+               CHAR_CRIT       =SIMP(statut='o',typ='R',min=2,validators=NoRepeat(),max=2,
+                                     fr="Valeur des deux charges critiques délimitant la bande de recherche"),
+             ),           
+             APPROCHE        =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG"),
+                                   fr="Choix du pseudo-produit scalaire pour la résolution du problème quadratique" ),           
+             regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
+             DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
+             COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
+             NPREC_SOLVEUR   =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
+             NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+             PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0 ),
+             SEUIL_FREQ      =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
+           ),
+         ),
+
+         b_dynam        =BLOC(condition = "TYPE_RESU == 'DYNAMIQUE'",
+           CALC_FREQ       =FACT(statut='d',min=0,
+             OPTION      =SIMP(statut='f',typ='TXM',defaut="PLUS_PETITE",into=("PLUS_PETITE","BANDE","CENTRE","TOUT"),
+                                   fr="Choix de l option et par conséquent du shift du problème 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 donnée",
+               FREQ            =SIMP(statut='o',typ='R',
+                                     fr="Fréquence autour de laquelle on cherche les fréquences 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 donnée",
+               FREQ            =SIMP(statut='o',typ='R',min=2,validators=NoRepeat(),max=2,
+                                     fr="Valeur des deux fréquences délimitant la bande de recherche"),
+             ),           
+             APPROCHE        =SIMP(statut='f',typ='TXM',defaut="REEL",into=("REEL","IMAG","COMPLEXE"),
+                                   fr="Choix du pseudo-produit scalaire pour la résolution du problème quadratique" ),           
+             regles=(EXCLUS('DIM_SOUS_ESPACE','COEF_DIM_ESPACE'),),
+             DIM_SOUS_ESPACE =SIMP(statut='f',typ='I' ),
+             COEF_DIM_ESPACE =SIMP(statut='f',typ='I' ),
+             NPREC_SOLVEUR   =SIMP(statut='f',typ='I',defaut= 8,val_min=0 ),
+             NMAX_ITER_SHIFT =SIMP(statut='f',typ='I',defaut= 5,val_min=0 ),
+             PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-2,val_min=0.E+0 ),
+             SEUIL_FREQ      =SIMP(statut='f',typ='R',defaut= 1.E-2,val_min=0.E+0 ),
+           ),
+         ),
+
+         VERI_MODE       =FACT(statut='d',min=0,
+           STOP_ERREUR     =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           PREC_SHIFT      =SIMP(statut='f',typ='R',defaut= 5.E-3,val_min=0.E+0 ),
+           SEUIL           =SIMP(statut='f',typ='R',defaut= 1.E-6,val_min=0.E+0,
+                                 fr="Valeur limite admise pour l ereur a posteriori des modes" ),
+           STURM           =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         ),
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des param\350tres de sensibilit\351.",
+                               ang="List of sensitivity parameters",
+         ),
+         b_sensibilite   =BLOC(condition = "SENSIBILITE != None",
+             CHAM_MATER      =SIMP(statut='f',typ=cham_mater ),
+             CARA_ELEM       =SIMP(statut='f',typ=cara_elem ),
+             EXCIT           =FACT(statut='f',max='**',),  # que pour NMDOME
+         ),
+         STOP_FREQ_VIDE  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),        
+)  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 NISTOR I.NISTOR
+
+MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_meca,
+                   fr="Calcul de deformees statiques pour un déplacement, une force ou une accélération unitaire imposé",
+                   reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         MATR_RIGI       =SIMP(statut='o',typ=matr_asse_depl_r ),
+         MATR_MASS       =SIMP(statut='f',typ=matr_asse_depl_r ),
+               regles=(UN_PARMI('MODE_STAT','FORCE_NODALE','PSEUDO_MODE'),),
+         MODE_STAT       =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','NOEUD','GROUP_NO'),
+                   UN_PARMI('TOUT_CMP','AVEC_CMP','SANS_CMP'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ,),
+           NOEUD           =SIMP(statut='f',typ=no   ,max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno ,max='**'),
+           TOUT_CMP        =SIMP(statut='f',typ='TXM',into=("OUI",) ,),
+           AVEC_CMP        =SIMP(statut='f',typ='TXM',max='**'),
+           SANS_CMP        =SIMP(statut='f',typ='TXM',max='**'),
+         ),
+         FORCE_NODALE    =FACT(statut='f',max='**',
+           regles=(UN_PARMI('TOUT','NOEUD','GROUP_NO'),
+                   UN_PARMI('TOUT_CMP','AVEC_CMP','SANS_CMP'),),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",), ),
+           NOEUD           =SIMP(statut='f',typ=no   ,max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno ,max='**'),
+           TOUT_CMP        =SIMP(statut='f',typ='TXM',into=("OUI",), ),
+           AVEC_CMP        =SIMP(statut='f',typ='TXM',max='**'),
+           SANS_CMP        =SIMP(statut='f',typ='TXM',max='**'),
+         ),
+         PSEUDO_MODE       =FACT(statut='f',max='**',
+           regles=(UN_PARMI('AXE','DIRECTION','TOUT','NOEUD','GROUP_NO' ),),
+           AXE             =SIMP(statut='f',typ='TXM',into=("X","Y","Z"),max=3),
+           DIRECTION       =SIMP(statut='f',typ='R',min=3,max=3),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           NOEUD           =SIMP(statut='f',typ=no   ,max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno ,max='**'),
+           b_dir           =BLOC(condition = "DIRECTION != None",
+             NOM_DIR         =SIMP(statut='f',typ='TXM' ),),
+           b_cmp          =BLOC(condition="TOUT!= None or NOEUD!=None or GROUP_NO!=None",
+             regles=(UN_PARMI('TOUT_CMP','AVEC_CMP','SANS_CMP'),),
+             TOUT_CMP        =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             AVEC_CMP        =SIMP(statut='f',typ='TXM',max='**'),
+             SANS_CMP        =SIMP(statut='f',typ='TXM',max='**'),
+           ),
+         ),
+
+
+         SOLVEUR         =FACT(statut='d', fr="Méthode de résolution des systèmes linéaires",
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+
+
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+
+           b_gcpc         =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.E-6),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+         ),
+
+
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ,) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 ADOBES A.ADOBES
+MODI_BASE_MODALE=OPER(nom="MODI_BASE_MODALE",op= 149,sd_prod=mode_meca,
+                      reentrant='f',
+            fr="Définir la base modale d'une structure sous écoulement",
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+#  la commande modi_base _modale : reentrant = f ou o                      
+         regles=(EXCLUS('AMOR_UNIF','AMOR_REDUIT', ),),
+         BASE            =SIMP(statut='o',typ=mode_meca ),
+         BASE_ELAS_FLUI  =SIMP(statut='o',typ=melasflu_sdaster ),
+         NUME_VITE_FLUI  =SIMP(statut='o',typ='I' ),
+         NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+         AMOR_REDUIT     =SIMP(statut='f',typ='R',max='**'),
+         AMOR_UNIF       =SIMP(statut='f',typ='R' ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 14/10/2008   AUTEUR REZETTE C.REZETTE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+MODI_MAILLAGE=OPER(nom="MODI_MAILLAGE",op= 154,sd_prod=maillage_sdaster,
+                   fr="Effectuer des modifications sur un maillage existant: réorienter des mailles servant,"
+                      +" à l'application d'une pression, à la modélisation du contact,...",
+                   reentrant='o',
+            UIinfo={"groupes":("Maillage",)},
+      regles=(AU_MOINS_UN('ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D',
+                       'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',
+                       'TRANSLATION','ROTATION','MODI_BASE','ECHELLE','ORIE_SHB','SYMETRIE',
+                       'ORIE_LIGNE',),
+              PRESENT_ABSENT('ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D',
+                       'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',
+                       'ORIE_LIGNE'),
+              PRESENT_ABSENT('DEFORME','ORIE_FISSURE','EQUE_PIQUA','ORIE_PEAU_2D',
+                       'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',
+                       'ORIE_LIGNE'),
+              PRESENT_ABSENT('EQUE_PIQUA','ORIE_FISSURE','DEFORME','ORIE_PEAU_2D',
+                       'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',
+                       'ORIE_LIGNE'),
+              PRESENT_ABSENT('ORIE_PEAU_2D','ORIE_FISSURE','DEFORME','EQUE_PIQUA',
+                       'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',
+                       'ORIE_LIGNE'),
+              PRESENT_ABSENT('ORIE_PEAU_3D','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D',
+                       'PLAQ_TUBE','MODI_MAILLE',),
+              PRESENT_ABSENT('ORIE_NORM_COQUE','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D',
+                       'PLAQ_TUBE','MODI_MAILLE','ORIE_LIGNE'),
+              PRESENT_ABSENT('PLAQ_TUBE','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D',
+                       'ORIE_PEAU_3D','ORIE_NORM_COQUE','MODI_MAILLE','ORIE_LIGNE'),
+              PRESENT_ABSENT('MODI_MAILLE','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D',
+                       'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','ORIE_LIGNE'),
+              EXCLUS('EQUE_PIQUA','PLAQ_TUBE'),
+              EXCLUS('EQUE_PIQUA','TUBE_COUDE'),
+              EXCLUS('ROTATION','MODI_BASE'),
+              EXCLUS('SYMETRIE','ROTATION'),
+              EXCLUS('SYMETRIE','TRANSLATION'),
+              EXCLUS('SYMETRIE','MODI_BASE'),
+              EXCLUS('SYMETRIE','ECHELLE'),
+              ),
+         MAILLAGE        =SIMP(statut='o',typ=maillage_sdaster ),
+
+         ORIE_FISSURE    =FACT(statut='f',
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+         ),
+
+         DEFORME         =FACT(statut='f',
+           OPTION          =SIMP(statut='o',typ='TXM',into=("TRAN","TRAN_APPUI") ),
+           DEPL            =SIMP(statut='o',typ=cham_no_sdaster ),
+        b_deform        =BLOC(condition = "OPTION=='TRAN_APPUI'",
+           GROUP_NO_APPUI = SIMP(statut='o',typ=grno,validators=NoRepeat(),max='**' ),
+           GROUP_NO_STRU  = SIMP(statut='o',typ=grno,validators=NoRepeat(),max='**' ),),
+         ),
+
+         EQUE_PIQUA      =FACT(statut='f',
+           GROUP_NO        =SIMP(statut='o',typ=grno),
+           E_BASE          =SIMP(statut='o',typ='R' ),
+           DEXT_BASE       =SIMP(statut='o',typ='R' ),
+           L_BASE          =SIMP(statut='o',typ='R' ),
+           L_CHANF         =SIMP(statut='o',typ='R' ),
+           TYPE            =SIMP(statut='o',typ='TXM',into=("TYPE_1","TYPE_2")),
+           H_SOUD          =SIMP(statut='o',typ='R' ),
+           ANGL_SOUD       =SIMP(statut='o',typ='R' ),
+           JEU_SOUD        =SIMP(statut='o',typ='R' ),
+           E_CORP          =SIMP(statut='o',typ='R' ),
+           DEXT_CORP       =SIMP(statut='o',typ='R' ),
+           AZIMUT          =SIMP(statut='o',typ='R' ),
+           RAFF_MAIL       =SIMP(statut='o',typ='TXM' ),
+           X_MAX           =SIMP(statut='o',typ='R' ),
+         ),
+         ORIE_PEAU_2D    =FACT(statut='f',max='**',
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_MA_SURF   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+         ),
+         ORIE_PEAU_3D    =FACT(statut='f',max='**',
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_MA_VOLU   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+         ),
+         ORIE_SHB       =FACT(statut='f',max=1,
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+         ),
+         ORIE_NORM_COQUE =FACT(statut='f',max='**',
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+           VECT_NORM       =SIMP(statut='f',typ='R',max=3),
+           b_vect_norm     =BLOC(condition = "VECT_NORM != None",
+             regles=UN_PARMI('NOEUD','GROUP_NO'),
+             NOEUD           =SIMP(statut='f',typ=no),
+             GROUP_NO        =SIMP(statut='f',typ=grno),
+           ),
+         ),
+         ORIE_LIGNE =FACT(statut='f',max='**',
+           GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+           VECT_TANG       =SIMP(statut='f',typ='R',max=3),
+           b_vect_tang     =BLOC(condition = "VECT_TANG != None",
+             regles=UN_PARMI('NOEUD','GROUP_NO'),
+             NOEUD           =SIMP(statut='f',typ=no),
+             GROUP_NO        =SIMP(statut='f',typ=grno),
+           ),
+         ),
+         PLAQ_TUBE       =FACT(statut='f',
+           DEXT            =SIMP(statut='o',typ='R' ),
+           EPAIS           =SIMP(statut='o',typ='R' ),
+           L_TUBE_P1       =SIMP(statut='o',typ='R' ),
+           AZIMUT          =SIMP(statut='f',typ='R',defaut= 90. ),
+           COUTURE         =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON",)  ),
+         ),
+         TUBE_COUDE      =FACT(statut='f',
+           ANGLE           =SIMP(statut='o',typ='R' ),
+           R_CINTR         =SIMP(statut='o',typ='R' ),
+           L_TUBE_P1       =SIMP(statut='o',typ='R' ),
+         ),
+         MODI_MAILLE     =FACT(statut='f',max=1,
+           regles=(AU_MOINS_UN('GROUP_MA_FOND','MAILLE_FOND','GROUP_NO_FOND','NOEUD_FOND'),),
+           OPTION          =SIMP(statut='o',typ='TXM',into=("NOEUD_QUART",) ),
+           GROUP_MA_FOND   =SIMP(statut='f',typ=grma,validators=NoRepeat(),max=1),
+           MAILLE_FOND     =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max=1),
+           GROUP_NO_FOND   =SIMP(statut='f',typ=grno,validators=NoRepeat(),max=1),
+           NOEUD_FOND      =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max=1),
+         ),
+         MODI_BASE       =FACT(statut='f',
+           VECT_X          =SIMP(statut='o',typ='R',min=2,max=3),
+           VECT_Y          =SIMP(statut='f',typ='R',min=2,max=3),
+         ),
+         ECHELLE         =SIMP(statut='f',typ='R',),
+         TRANSLATION     =SIMP(statut='f',typ='R',min=2,max=3),
+         ROTATION        =FACT(statut='f',max='**',
+           POIN_1           =SIMP(statut='o',typ='R',min=2,max=3),
+           ANGL             =SIMP(statut='o',typ='R',defaut= 0.E+0 ),
+           regles=(EXCLUS('DIR','POIN_2'),),
+           POIN_2           =SIMP(statut='f',typ='R',min=2,max=3),
+           DIR              =SIMP(statut='f',typ='R',min=2,max=3),
+         ),
+         SYMETRIE        =FACT(statut='f',max='**',
+                          fr = "Symétrie du maillage par rapport à un plan en 3D ou à une droite en 2D.",
+           POINT           =SIMP(statut='o',typ='R',min=2,max=3,
+                            fr="Point appartenant à la droite ou au plan."),
+           AXE_1           =SIMP(statut='o',typ='R',min=2,max=3,
+                            fr="Vecteur directeur de la droite ou 1er vecteur appartenant au plan."),
+           AXE_2           =SIMP(statut='f',typ='R',min=3,max=3,
+                            fr="2nd vecteur appartenant du plan."),
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 16/06/2009   AUTEUR PELLET J.PELLET 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+
+MODI_MODELE=OPER(nom="MODI_MODELE",op= 103,sd_prod=modele_sdaster,reentrant='o',
+         UIinfo={"groupes":("Modélisation",)},
+         fr="Modifier la partition d'un modèle (parallélisme) ",
+
+         MODELE          =SIMP(statut='o',typ=modele_sdaster,min=1,max=1,),
+
+         PARTITION         =FACT(statut='d',
+             PARALLELISME    =SIMP(statut='f',typ='TXM',defaut="MAIL_DISPERSE",
+                                   into=("MAIL_CONTIGU","MAIL_DISPERSE","SOUS_DOMAINE","CENTRALISE",)),
+             b_dist_maille          =BLOC(condition = "PARALLELISME in ('MAIL_DISPERSE','MAIL_CONTIGU')",
+                 CHARGE_PROC0_MA =SIMP(statut='f',typ='I',defaut=100,val_min=0),
+             ),
+             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),
+             ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 20/04/2009   AUTEUR GENIAUT S.GENIAUT 
+#            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 GENIAUT S.GENIAUT
+
+MODI_MODELE_XFEM=OPER(nom="MODI_MODELE_XFEM",op= 113,sd_prod=modele_sdaster,docu="U4.44.12-e",reentrant='f',
+            UIinfo={"groupes":("Modélisation",)},
+                           fr="Engendrer ou enrichir une structure de donnees en affectant les cham_gd associes",
+                           
+    MODELE_IN       =SIMP(statut='o',typ=modele_sdaster,min=1,max=1,),
+    FISSURE         =SIMP(statut='o',typ=fiss_xfem,min=1,max='**',),
+    CRITERE         =SIMP(statut='f',typ='R',defaut=1.1E-4),
+    INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,)),
+    CONTACT         =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON"),min=1,max=1,),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE KHAM M.KHAM
+MODI_OBSTACLE=OPER(nom="MODI_OBSTACLE",op=182,sd_prod=table_fonction,
+            fr="Calculer les obstacles dans les systèmes guidage-tube après usure",
+            reentrant='f',
+            UIinfo={"groupes":("Modélisation",)},
+      regles=(PRESENT_ABSENT('R_MOBILE','CRAYON'),
+              PRESENT_PRESENT('V_USUR_TUBE','V_USUR_OBST'),),
+         OBSTACLE        =SIMP(statut='f',typ=table_fonction),
+         GUIDE           =SIMP(statut='o',typ=table_sdaster),
+         CRAYON          =SIMP(statut='f',typ=table_sdaster),
+         TABL_USURE      =SIMP(statut='f',typ=table_sdaster),
+         INST            =SIMP(statut='f',typ='R'),  
+         R_MOBILE        =SIMP(statut='f',typ='R'),  
+         PERCEMENT       =SIMP(statut='f',typ='R',defaut=1),  
+         V_USUR_TUBE     =SIMP(statut='f',typ='R',max='**'),
+         V_USUR_OBST     =SIMP(statut='f',typ='R',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 DESROCHES X.DESROCHES
+def modi_repere_prod(RESULTAT,**args):
+  if AsType(RESULTAT) != None : return AsType(RESULTAT)
+
+MODI_REPERE=OPER(nom="MODI_REPERE",op=191,sd_prod=modi_repere_prod,reentrant='n',
+            UIinfo={"groupes":("Résultats et champs",)},
+                    fr="Calcule des résultats dans le repère cylindrique",
+         RESULTAT        =SIMP(statut='o',typ=resultat_sdaster),
+
+         regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                        'NOEUD_CMP','LIST_INST','LIST_FREQ','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),
+
+         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',),),
+
+         MODI_CHAM       =FACT(statut='o',max='**',
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TYPE_CHAM       =SIMP(statut='o',typ='TXM',
+                                 into=("VECT_2D","VECT_3D","TORS_3D","TENS_2D","TENS_3D"),),
+           NOM_CHAM        =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO()),
+           b_vect_2d       =BLOC(condition = "TYPE_CHAM=='VECT_2D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=2,max=2 ),),
+           b_vect_3d       =BLOC(condition = "TYPE_CHAM=='VECT_3D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=3,max=3 ),),
+           b_tors_3d       =BLOC(condition = "TYPE_CHAM=='TORS_3D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=6,max=6 ),),
+           b_tens_2d       =BLOC(condition = "TYPE_CHAM=='TENS_2D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=4,max=4 ),),
+           b_tens_3d       =BLOC(condition = "TYPE_CHAM=='TENS_3D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=6,max=6 ),),
+         ),
+         DEFI_REPERE     =FACT(statut='o',
+         regles=(UN_PARMI('ANGL_NAUT','ORIGINE'),),
+           REPERE          =SIMP(statut='f',typ='TXM',defaut="UTILISATEUR",
+                                 into=("UTILISATEUR","CYLINDRIQUE"),),
+           ANGL_NAUT       =SIMP(statut='f',typ='R',max=3),
+           ORIGINE         =SIMP(statut='f',typ='R',min=2,max=3),
+           AXE_Z           =SIMP(statut='f',typ='R',min=3,max=3),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 NISTOR I.NISTOR
+
+def norm_mode_prod(MODE,**args ):
+  if AsType(MODE) == mode_meca   : return mode_meca
+  if AsType(MODE) == mode_meca_c : return mode_meca_c
+  if AsType(MODE) == mode_flamb  : return mode_flamb
+  raise AsException("type de concept resultat non prevu")
+
+NORM_MODE=OPER(nom="NORM_MODE",op=  37,sd_prod=norm_mode_prod,
+               fr="Normer des modes propres en fonction d'un critère choisi par l'utilisateur",
+               reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+         regles=(UN_PARMI('NORME','NOEUD','AVEC_CMP','SANS_CMP'),
+                 CONCEPT_SENSIBLE('SEPARE'),
+                 DERIVABLE('MODE'),),
+         MODE       =SIMP(statut='o',typ=(mode_meca,mode_flamb) ),
+         NORME      =SIMP(statut='f',typ='TXM',fr="Norme prédéfinie : masse généralisée, euclidienne,...",
+                          into=("MASS_GENE","RIGI_GENE","EUCL","EUCL_TRAN","TRAN","TRAN_ROTA") ),
+         NOEUD      =SIMP(statut='f',typ=no, fr="Composante donnée d un noeud spécifié égale à 1"),
+         b_noeud    =BLOC(condition = "NOEUD != None",
+           NOM_CMP    =SIMP(statut='o',typ='TXM' ),
+         ),
+         AVEC_CMP   =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+         SANS_CMP   =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+         MODE_SIGNE =FACT(statut='f',fr="Imposer un signe sur une des composantes des modes",
+           NOEUD      =SIMP(statut='o',typ=no,fr="Noeud ou sera imposé le signe"),
+           NOM_CMP    =SIMP(statut='o',typ='TXM',fr="Composante du noeud ou sera imposé le signe" ),
+           SIGNE      =SIMP(statut='f',typ='TXM',defaut="POSITIF",into=("NEGATIF","POSITIF"),
+                            fr="Choix du signe" ),
+         ),
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des param\350tres de sensibilit\351.",
+                               ang="List of sensitivity parameters",
+         ),
+#         b_base    =BLOC(condition = "AsType(MODE) == base_modale",
+#              MASSE = SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ), ),
+#              RAIDE = SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_gene_r,matr_asse_pres_r ), ),
+#              AMOR  = SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_gene_r) ),
+#         ),
+         MASSE = SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ), ),
+         RAIDE = SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_gene_r,matr_asse_pres_r ), ),
+         AMOR  = SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_gene_r) ),
+         TITRE      =SIMP(statut='f',typ='TXM',max='**'),
+         INFO       =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+)  ;
+#& MODIF COMMANDE  DATE 08/08/2008   AUTEUR DESOZA T.DESOZA 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+NUME_DDL=OPER(nom="NUME_DDL",op=11,sd_prod=nume_ddl_sdaster,reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+              fr="Etablissement de la numérotation des ddl avec ou sans renumérotation et du stockage de la matrice",
+                  regles=(UN_PARMI('MATR_RIGI','MODELE'),),
+         MATR_RIGI       =SIMP(statut='f',validators=NoRepeat(),max=100,
+                               typ=(matr_elem_depl_r ,matr_elem_depl_c,matr_elem_temp_r ,matr_elem_pres_c) ),
+         MODELE          =SIMP(statut='f',typ=modele_sdaster ),
+         b_modele        =BLOC(condition = "MODELE != None",
+           CHARGE     =SIMP(statut='f',validators=NoRepeat(),max='**',typ=(char_meca,char_ther,char_acou, ),),
+         ),
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","PETSC","MUMPS") ),
+         b_mult_front    =BLOC(condition="METHODE=='MULT_FRONT'",fr="paramètres associés à la méthode multifrontale",
+           RENUM           =SIMP(statut='f',typ='TXM',into=("MD","MDA","METIS"),defaut="METIS" ),
+         ),
+         b_ldlt          =BLOC(condition="METHODE=='LDLT'",fr="paramètres associés à la méthode LDLT",
+           RENUM           =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK"  ),
+         ),
+         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")),
+         ),
+         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"  ),
+         ),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 BODEL C.BODEL
+NUME_DDL_GENE=OPER(nom="NUME_DDL_GENE",op= 127,sd_prod=nume_ddl_gene,
+                   fr="Etablissement de la numérotation des ddl d'un modèle établi en coordonnées généralisées",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=UN_PARMI('MODELE_GENE','BASE'),
+         MODELE_GENE     =SIMP(statut='f',typ=modele_gene ),
+             b_modele_gene     =BLOC(condition = "MODELE_GENE != None",
+               STOCKAGE     =SIMP(statut='f',typ='TXM',defaut="LIGN_CIEL",into=("LIGN_CIEL","PLEIN") ),
+               METHODE            =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("INITIAL","CLASSIQUE") ),
+                                    ),
+         BASE     =SIMP(statut='f',typ=(mode_meca,mode_gene ) ),
+             b_base     =BLOC(condition = "BASE != None",
+               STOCKAGE     =SIMP(statut='f',typ='TXM',defaut="DIAG",into=("DIAG","PLEIN") ),
+               NB_VECT     =SIMP(statut='f',typ='I',defaut= 9999 ),
+                             ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 BODEL C.BODEL
+
+from Macro.observation_ops import observation_ops
+
+
+def observation_prod(self, RESULTAT, **args):
+    if  AsType(RESULTAT) == mode_meca :
+        return mode_meca
+    elif AsType(RESULTAT) == evol_elas :
+        return evol_elas
+    elif AsType(RESULTAT) == dyna_harmo :
+        return dyna_harmo
+    else :
+        return None
+
+OBSERVATION=MACRO(nom="OBSERVATION",op=observation_ops,
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+                      sd_prod=observation_prod,
+                      fr="Calcul de l'observabilite d'un champ aux noeuds ",
+#
+         MODELE_1        =SIMP(statut='o',typ=modele_sdaster),
+         MODELE_2        =SIMP(statut='o',typ=modele_sdaster),
+         RESULTAT        =SIMP(statut='o',typ=mode_meca ),
+         NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1),
+
+#        ------------------------------------------------------------------
+
+         regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE','FREQ','LIST_FREQ','NUME_MODE' ),),
+         TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
+         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='**' ),
+         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),
+         NOEUD_CMP       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+
+#        ------------------------------------------------------------------
+#        OPTIONS DE PROJ_CHAMP (SANS MC FACTEUR PARTICULIER)
+#        ------------------------------------------------------------------
+         PROJECTION     =SIMP(statut='f',max=1,typ='TXM',into=("OUI","NON"),defaut="NON"),
+         CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
+         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."),
+         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="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) ),
+         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='**'),
+             CAS_FIGURE      =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
+             ),
+
+#        ------------------------------------------------------------------
+#        MODI_REPERE
+#        ------------------------------------------------------------------
+         MODI_REPERE     =FACT(statut='f',max='**',
+         regles=(UN_PARMI('REPERE'),
+                 AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+#
+           TYPE_CHAM       =SIMP(statut='f',typ='TXM',
+                                 into=("VECT_2D","VECT_3D","TORS_3D","TENS_2D","TENS_3D"),
+                                       defaut="VECT_3D"),
+           b_vect_2d       =BLOC(condition = "TYPE_CHAM=='VECT_2D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=2,max=2 ),),
+           b_vect_3d       =BLOC(condition = "TYPE_CHAM=='VECT_3D'",
+              NOM_CMP         =SIMP(statut='f',typ='TXM',min=3,max=3,defaut=('DX','DY','DZ') ),),
+           b_tors_3d       =BLOC(condition = "TYPE_CHAM=='TORS_3D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=6,max=6 ),),
+           b_tens_2d       =BLOC(condition = "TYPE_CHAM=='TENS_2D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=4,max=4 ),),
+           b_tens_3d       =BLOC(condition = "TYPE_CHAM=='TENS_3D'",
+              NOM_CMP         =SIMP(statut='o',typ='TXM',min=6,max=6 ),),
+
+           REPERE          =SIMP(statut='o',typ='TXM',
+                                 into=("UTILISATEUR","CYLINDRIQUE","NORMALE"),),
+           b_normale       =BLOC(condition = "REPERE=='NORMALE'",
+             regles=(UN_PARMI('VECT_X','VECT_Y')),
+             VECT_X          =SIMP(statut='f',typ='R',min=3,max=3),
+             VECT_Y          =SIMP(statut='f',typ='R',min=3,max=3), ),
+           b_utilisateur   =BLOC(condition = "REPERE=='UTILISATEUR'",
+             ANGL_NAUT       =SIMP(statut='o',typ='R',max=3)),
+           b_cylindrique   =BLOC(condition = "REPERE=='CYLINDRIQUE'",
+             ORIGINE         =SIMP(statut='o',typ='R',min=2,max=3),
+             AXE_Z           =SIMP(statut='o',typ='R',min=3,max=3)),
+         ),
+
+#        ------------------------------------------------------------------
+#        FILTRE DES DDL
+#        ------------------------------------------------------------------
+         FILTRE     =FACT(statut='f',max='**',
+           regles=(UN_PARMI('DDL_ACTIF'),
+#                           'MASQUE'),
+           AU_MOINS_UN('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),),
+           GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+           NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+           TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+#
+           DDL_ACTIF       =SIMP(statut='f',typ='TXM',max=6),
+# TODO : mettre en place le systeme de masques
+#           MASQUE          =SIMP(statut='f',typ='TXM',max=6),
+         ),
+#        ------------------------------------------------------------------
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+      )  ;
+#& MODIF COMMANDE  DATE 27/07/2009   AUTEUR NISTOR I.NISTOR 
+#            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 GENIAUT S.GENIAUT
+def post_cham_xfem_prod(RESULTAT,**args ):
+ 
+  if AsType(RESULTAT) == evol_noli  : return evol_noli
+  if AsType(RESULTAT) == mode_meca : return mode_meca
+
+  raise AsException("type de concept resultat non prevu")
+
+POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=post_cham_xfem_prod,
+                    reentrant='n',UIinfo={"groupes":("Post traitements",)},
+            fr="Calcul des champs DEPL et SIEF_ELGA sur le maillage fissuré",
+    MAILLAGE_SAIN = SIMP(statut='o',typ=maillage_sdaster),
+    MAILLAGE_FISS = SIMP(statut='o',typ=maillage_sdaster),
+    NOM_CHAM      = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=("DEPL","SIEF_ELGA","VARI_ELGA"),),
+    MODELE        = SIMP(statut='o',typ=modele_sdaster,),
+    RESULTAT      = SIMP(statut='o',typ=resultat_sdaster),
+      b_elga      = BLOC(condition = "NOM_CHAM in ('SIEF_ELGA','VARI_ELGA') or \
+                                      (type(NOM_CHAM)==type(()) and 'SIEF_ELGA' in NOM_CHAM) or \
+                                      (type(NOM_CHAM)==type(()) and 'VARI_ELGA' in NOM_CHAM)",
+      MODELE_VISU = SIMP(statut='o',typ=modele_sdaster,),
+                         ),
+    INFO           =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
+);                     
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ZENTNER I.ZENTNER
+from Macro.post_dyna_alea_ops import post_dyna_alea_ops
+POST_DYNA_ALEA=MACRO(nom="POST_DYNA_ALEA",op= post_dyna_alea_ops,sd_prod=table_sdaster,
+                    fr="Traitements statistiques de résultats de type interspectre et impression sur fichiers",
+                    reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+         regles=(UN_PARMI('FRAGILITE','INTE_SPEC'),),
+         FRAGILITE  =FACT(statut='f',fr="donnees pour courbe de fragilite",max='**', 
+                    TABL_RESU  =SIMP(statut='o',typ=table_sdaster),
+                    regles=(UN_PARMI('VALE','LIST_PARA'),),
+                    VALE       = SIMP(statut='f',typ='R', min=1,validators=NoRepeat(),max='**' ), 
+                    LIST_PARA  = SIMP(statut='f',typ=listr8_sdaster), 
+                    AM_INI     =  SIMP(statut='f',typ='R',defaut= 0.4 ), 
+                    BETA_INI   = SIMP(statut='f',typ='R',defaut= 0.3 ), 
+                    FRACTILE   = SIMP(statut='f',typ='R', min=1,validators=NoRepeat(),max='**'),
+                    b_inte_spec_f  = BLOC(condition="""FRACTILE !=None""",
+                        NB_TIRAGE =SIMP(statut='f',typ='I' ),),                   
+                 ),
+         INTE_SPEC       =SIMP(statut='f',typ=table_fonction),
+         b_inte_spec_f      =BLOC(condition="""INTE_SPEC !=None""",
+            regles=(UN_PARMI('NOEUD_I','NUME_ORDRE_I','OPTION'),),
+            NUME_VITE_FLUI  =SIMP(statut='f',typ='I' ),  
+            TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+            NUME_ORDRE_I    =SIMP(statut='f',typ='I',max='**' ),
+            NOEUD_I         =SIMP(statut='f',typ=no,max='**'),         
+            OPTION          =SIMP(statut='f',typ='TXM',into=("DIAG",) ),
+            b_nume_ordre_i =BLOC(condition = "NUME_ORDRE_I != None",
+               NUME_ORDRE_J    =SIMP(statut='o',typ='I',max='**' ),   
+                                ),  
+            b_noeud_i      =BLOC(condition = "NOEUD_I != None",
+               NOEUD_J         =SIMP(statut='o',typ=no,max='**'),
+               NOM_CMP_I       =SIMP(statut='o',typ='TXM',max='**' ),  
+               NOM_CMP_J       =SIMP(statut='o',typ='TXM',max='**' ),     
+                                ), 
+            MOMENT          =SIMP(statut='f',typ='I',max='**',fr="Moments spectraux en complément des cinq premiers" ), 
+            ),  
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 BOYERE E.BOYERE
+POST_DYNA_MODA_T=OPER(nom="POST_DYNA_MODA_T",op= 130,sd_prod=table_sdaster,
+                      fr="Post-traiter les résultats en coordonnées généralisées produit par DYNA_TRAN_MODAL",
+                      reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+        regles=(UN_PARMI('CHOC','RELA_EFFO_DEPL', ),),
+         RESU_GENE       =SIMP(statut='o',typ=tran_gene ),
+         CHOC            =FACT(statut='f',max='**',
+                               fr="Analyse des non linéarités de choc",
+           INST_INIT       =SIMP(statut='f',typ='R',defaut= -1. ),  
+           INST_FIN        =SIMP(statut='f',typ='R',defaut= 999. ),  
+           NB_BLOC         =SIMP(statut='f',typ='I',defaut= 1 ),  
+           SEUIL_FORCE     =SIMP(statut='f',typ='R',defaut= 0.E+0 ),  
+           DUREE_REPOS     =SIMP(statut='f',typ='R',defaut= 0.E+0 ),  
+           OPTION          =SIMP(statut='f',typ='TXM',defaut="USURE",into=("IMPACT","USURE") ),
+           NB_CLASSE       =SIMP(statut='f',typ='I',defaut= 10 ),  
+         ),
+         RELA_EFFO_DEPL  =FACT(statut='f',
+                               fr="Analyse des relationsnon linéaires effort-déplacement",
+           NOEUD           =SIMP(statut='o',typ=no),
+           NOM_CMP         =SIMP(statut='o',typ='TXM' ),  
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 19/05/2009   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
+# 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 DESROCHES X.DESROCHES
+POST_ELEM=OPER(nom="POST_ELEM",op=107,sd_prod=table_sdaster,reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+               fr="Calcul de quantités globales (masse, inerties, énergie, ...) sur tout ou partie du modèle",
+
+         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',
+                          'AIRE_INTERNE','ENER_ELAS','ENER_TOTALE','ENER_DISS','INTEGRALE'),
+                ),
+
+         MASS_INER      = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                               ORIG_INER    = SIMP(statut='f',typ='R',min=3,max=3 ),
+                              ),
+         b_mass_iner = BLOC(condition = "( MASS_INER != None )",
+                       fr="calcul de la masse, les inerties et le centre de gravité",
+                       regles=(EXCLUS('CHAM_GD','RESULTAT'),
+                               EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                                      'NOEUD_CMP','LIST_ORDRE','LIST_INST','LIST_FREQ','NOM_CAS'),),
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                                        char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       GEOMETRIE      = SIMP(statut='f',typ='TXM',defaut="INITIALE",into=("INITIALE","DEFORMEE")),
+                       CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
+                       RESULTAT       = SIMP(statut='f',typ=(mode_meca,evol_elas,evol_noli,mult_elas,
+                                                             fourier_elas,dyna_trans) ),
+                       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',),
+                       LIST_ORDRE     = SIMP(statut='f',typ=listis_sdaster),
+                       INST           = SIMP(statut='f',typ='R',),
+                       LIST_INST      = SIMP(statut='f',typ=listr8_sdaster),
+                       FREQ           = SIMP(statut='f',typ='R',),
+                       LIST_FREQ      = SIMP(statut='f',typ=listr8_sdaster),
+                       NUME_MODE      = SIMP(statut='f',typ='I',),
+                       NOEUD_CMP      = SIMP(statut='f',typ='TXM',min=2,validators=NoRepeat(),max=2),
+                       NOM_CAS        = SIMP(statut='f',typ='TXM',),
+         ),
+
+         ENER_POT       = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                              ),
+         b_ener_pot = BLOC(condition = "( ENER_POT  != None )",
+                       fr="calcul de l'énergie potentielle de déformation",
+                       regles=(UN_PARMI('CHAM_GD','RESULTAT'),
+                               EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                                      'NOEUD_CMP','LIST_ORDRE','LIST_INST','LIST_FREQ','NOM_CAS'),),
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       ANGLE          = SIMP(statut='f',typ='I',defaut=0),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
+                       RESULTAT       = SIMP(statut='f',typ=(mode_meca,evol_elas,evol_ther,evol_noli,dyna_trans,mult_elas) ),
+                       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),
+                       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='**'),
+                       NOM_CAS        = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+         ),
+
+         ENER_CIN       = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               OPTION       = SIMP(statut='f',typ='TXM',
+                                                   into=("MASS_MECA","MASS_MECA_DIAG"),
+                                                   defaut="MASS_MECA" ),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                              ),
+         b_ener_cin = BLOC(condition = "( ENER_CIN != None )",
+                       fr="calcul de l'énergie cinétique",
+                       regles=(UN_PARMI('CHAM_GD','RESULTAT'),
+                               EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','FREQ','NUME_MODE',
+                                      'NOEUD_CMP','LIST_ORDRE','LIST_INST','LIST_FREQ','NOM_CAS'),),
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       ANGLE          = SIMP(statut='f',typ='I',defaut=0),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
+                       RESULTAT       = SIMP(statut='f',typ=(mode_meca,evol_elas,evol_ther,evol_noli,dyna_trans) ),
+                       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),
+                       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='**'),
+                       NOM_CAS        = SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+         ),
+
+         ENER_DISS      = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                              ),
+         b_ener_diss = BLOC(condition = "( ENER_DISS != None )",
+                       fr="calcul de l'énergie dissipée",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       RESULTAT       = SIMP(statut='o',typ=(evol_noli) ),
+                       regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       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),
+         ),
+
+
+         ENER_ELAS      = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                              ),
+         b_ener_elas = BLOC(condition = "( ENER_ELAS != None )",
+                       fr="calcul de l'énergie de déformation élastique",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       RESULTAT       = SIMP(statut='o',typ=(evol_noli) ),
+                       regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       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),
+         ),
+
+         ENER_TOTALE    = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                              ),
+         b_ener_totale = BLOC(condition = "( ENER_TOTALE != None )",
+                       fr="calcul de l'énergie de déformation totale",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       RESULTAT       = SIMP(statut='o',typ=(evol_noli) ),
+                       regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       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),
+         ),
+
+         INTEGRALE  = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                               NOM_CHAM     = SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+                               NOM_CMP      = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+                               DEJA_INTEGRE = SIMP(statut='f',typ='TXM',into=("OUI","NON",),),
+                              ),
+         b_integrale = BLOC(condition = "( INTEGRALE != None )",
+                       fr="calcul de la moyenne 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),
+                       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),
+         ),
+
+
+         MINMAX  = FACT(statut='f',max=1,
+                       fr="calcul des extrema en espace d'une CMP d'un champ, pour tous les instants spécifiés",
+                       regles=(UN_PARMI('CHAM_GD','RESULTAT'),
+                               PRESENT_PRESENT('CHAM_GD','MODELE'),
+                               PRESENT_PRESENT('RESULTAT','NOM_CHAM'),
+                               AU_MOINS_UN('TOUT','GROUP_MA'),),
+                       TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                       GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                       RESULTAT       = SIMP(statut='f',typ=(evol_noli,evol_ther,evol_elas) ),
+                       NOM_CHAM       = SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+                       CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       NOM_CMP        = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'),
+              b_minmax = BLOC(condition = "( RESULTAT != None )",
+                       regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                              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),
+                              ),
+         ),
+
+         WEIBULL        = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                               OPTION       = SIMP(statut='f',typ='TXM',
+                                                   into=("SIGM_ELGA","SIGM_ELMOY"),
+                                                   defaut="SIGM_ELGA"),
+                               CORR_PLAST   = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                               COEF_MULT    = SIMP(statut='f',typ='R',defaut=1.),
+                              ),
+         b_weibull = BLOC(condition = "( WEIBULL != None )",
+                       fr="calcul du champ élémentaire de la puissance m-ième de la contrainte de Weibull",
+                       regles=(UN_PARMI('CHAM_GD','RESULTAT'),
+                               EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
+                       RESULTAT       = SIMP(statut='f',typ=(evol_noli) ),
+                       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),
+         ),
+
+         RICE_TRACEY    = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                               OPTION       = SIMP(statut='f',typ='TXM',
+                                                   into=("SIGM_ELGA","SIGM_ELMOY"),
+                                                   defaut="SIGM_ELGA"),
+                               LOCAL        = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+                              ),
+         b_rice_tracey = BLOC(condition = "( RICE_TRACEY != None )",
+                       fr="calcul du taux de croissance d'une cavité sphérique par rapport à un domaine",
+                       regles=(UN_PARMI('CHAM_GD','RESULTAT'),
+                               EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       NUME_COUCHE    = SIMP(statut='f',typ='I',defaut=1),
+                       NIVE_COUCHE    = SIMP(statut='f',typ='TXM',defaut="MOY",into=("INF","SUP","MOY"),),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       CHAM_GD        = SIMP(statut='f',typ=(cham_no_sdaster,cham_elem) ),
+                       RESULTAT       = SIMP(statut='f',typ=(evol_noli) ),
+                       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),
+         ),
+
+         INDIC_ENER     = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                              ),
+         b_indic_ener = BLOC(condition = "( INDIC_ENER != None )",
+                       fr="calcul un indicateur global de perte de proportionnalité du chargement",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       RESULTAT       = SIMP(statut='o',typ=(evol_noli) ),
+                       regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       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),
+         ),
+
+         INDIC_SEUIL    = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                              ),
+         b_indic_seuil = BLOC(condition = "( INDIC_SEUIL != None )",
+                       fr="calcul un indicateur global de perte de proportionnalité du chargement",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       RESULTAT       = SIMP(statut='o',typ=(evol_noli) ),
+                       regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       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),
+         ),
+
+         CHAR_LIMITE    = FACT(statut='f',min=0,
+                               CHAR_CSTE = SIMP(statut='f',typ='TXM',into=("OUI","NON"),defaut="NON")
+                              ),
+         b_char_limite = BLOC(condition = "( CHAR_LIMITE != None )",
+                       fr="post-traitement du calcul de la charge limite",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CARA_ELEM      = SIMP(statut='f',typ=cara_elem),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+                       RESULTAT       = SIMP(statut='o',typ=(evol_noli) ),
+                       regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),),
+                       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),
+         ),
+
+         CARA_GEOM      = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+                               TOUT         = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               MAILLE       = SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+                               GROUP_MA     = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                               SYME_X       = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+                               SYME_Y       = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+                               ORIG_INER    = SIMP(statut='f',typ='R',min=2,max=2),
+                              ),
+         b_cara_geom = BLOC(condition = "( CARA_GEOM != None )",
+                       fr="calcul des caractéristiques géométriques d'un section de poutre",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+         ),
+
+         CARA_POUTRE    = FACT(statut='f',max='**',
+                               regles=(AU_MOINS_UN('TOUT','GROUP_MA'),
+                                       ENSEMBLE('LONGUEUR','LIAISON','MATERIAU'),),
+                               TOUT          = SIMP(statut='f',typ='TXM',into=("OUI",) ),
+                               GROUP_MA      = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                               GROUP_MA_INTE = SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+                               CARA_GEOM     = SIMP(statut='o',typ=table_sdaster),
+                               RT            = SIMP(statut='f',typ='R'),
+                               LAPL_PHI      = SIMP(statut='f',typ=evol_ther),
+                               LAPL_PHI_Y    = SIMP(statut='f',typ=evol_ther),
+                               LAPL_PHI_Z    = SIMP(statut='f',typ=evol_ther),
+                               LIAISON       = SIMP(statut='f',typ='TXM',into=("ROTULE","ENCASTREMENT")),
+                               LONGUEUR      = SIMP(statut='f',typ='R'),
+                               MATERIAU      = SIMP(statut='f',typ=mater_sdaster),
+                               OPTION        = SIMP(statut='f',typ='TXM',
+                                                    into=("CARA_TORSION","CARA_CISAILLEMENT","CARA_GAUCHI") ),
+                             ),
+         b_cara_poutre = BLOC(condition = "( CARA_POUTRE != None )",
+                       fr="calcul des caractéristiques mécaniques d'un section de poutre",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+                       CHAM_MATER     = SIMP(statut='f',typ=cham_mater),
+                       CHARGE         = SIMP(statut='f',typ=(char_meca,char_cine_meca,
+                       char_ther,char_acou),validators=NoRepeat(),max='**' ),
+                       MODE_FOURIER   = SIMP(statut='f',typ='I',defaut=0),
+         ),
+
+          AIRE_INTERNE   = FACT(statut='f',max='**',
+                                GROUP_MA_BORD  = SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+                               ),
+         b_aire_interne = BLOC(condition = "( AIRE_INTERNE != None )",
+                       fr="calcul de l'aire d'un trou dans un maillage 2D",
+                       MODELE         = SIMP(statut='f',typ=modele_sdaster),
+         ),
+
+         TRAV_EXT       = FACT(statut='f',),
+         b_trav_ext = BLOC(condition = "( TRAV_EXT != None )",
+                       fr="calcul du travail des efforts extérieurs",
+                       RESULTAT       = SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans) ),
+                       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",) ),
+         ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+
+ )  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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
+POST_FATI_ALEA=OPER(nom="POST_FATI_ALEA",op=170,sd_prod=table_sdaster,reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+                    fr="Calculer le dommage de fatigue subi par une structure soumise à une sollicitation de type aléatoire",
+         regles=(ENSEMBLE('MOMENT_SPEC_0','MOMENT_SPEC_2'),
+                 PRESENT_PRESENT( 'MOMENT_SPEC_4','MOMENT_SPEC_0'),
+                 UN_PARMI('TABL_POST_ALEA','MOMENT_SPEC_0'), ),
+         MOMENT_SPEC_0   =SIMP(statut='f',typ='R'),  
+         MOMENT_SPEC_2   =SIMP(statut='f',typ='R'),  
+         MOMENT_SPEC_4   =SIMP(statut='f',typ='R'),  
+         TABL_POST_ALEA  =SIMP(statut='f',typ=table_sdaster),
+         COMPTAGE        =SIMP(statut='o',typ='TXM',into=("PIC","NIVEAU")),
+         DUREE           =SIMP(statut='f',typ='R',defaut= 1.),  
+         CORR_KE         =SIMP(statut='f',typ='TXM',into=("RCCM",)),
+         DOMMAGE         =SIMP(statut='o',typ='TXM',into=("WOHLER",)),
+         MATER           =SIMP(statut='o',typ=mater_sdaster),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),  
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+# RESPONSABLE ANGLES J.ANGLES
+POST_FATIGUE=OPER(nom="POST_FATIGUE",op=136,sd_prod=table_sdaster,reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+                  fr="Calculer en un point, le dommage de fatigue subi par une structure soumise à une histoire de chargement",
+
+         CHARGEMENT = SIMP(statut='o',typ='TXM',into=("UNIAXIAL","PERIODIQUE","QUELCONQUE")),
+
+         b_uniaxial = BLOC( condition = "CHARGEMENT=='UNIAXIAL'",
+                      regles=(PRESENT_PRESENT('CORR_KE','MATER'),
+                              PRESENT_PRESENT('CORR_SIGM_MOYE','MATER'),
+                              PRESENT_PRESENT('DOMMAGE','MATER'),),
+             HISTOIRE       = FACT(statut='o',
+                                 regles=(UN_PARMI('SIGM','EPSI'),),
+                                 SIGM  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 EPSI  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),),
+             COMPTAGE       = SIMP(statut='o',typ='TXM',into=("RAINFLOW","RCCM","NATUREL")),
+             DELTA_OSCI     = SIMP(statut='f',typ='R',defaut= 0.0E+0),
+             COEF_MULT      = FACT(statut='f',
+                                 KT    = SIMP(statut='o',typ='R'),),
+             CORR_KE        = SIMP(statut='f',typ='TXM',into=("RCCM",)),
+             DOMMAGE        = SIMP(statut='f',typ='TXM',into=("WOHLER","MANSON_COFFIN",
+                                                              "TAHERI_MANSON","TAHERI_MIXTE")),
+             MATER          = SIMP(statut='f',typ=mater_sdaster),
+             CORR_SIGM_MOYE = SIMP(statut='f',typ='TXM',into=("GOODMAN","GERBER")),
+             TAHERI_NAPPE   = SIMP(statut='f',typ=(nappe_sdaster,formule)),
+             TAHERI_FONC    = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+             CUMUL          = SIMP(statut='f',typ='TXM',into=("LINEAIRE",)),
+         ),
+
+         b_periodique = BLOC( condition = "CHARGEMENT=='PERIODIQUE'",
+             HISTOIRE       = FACT(statut='o',
+                                 SIGM_XX  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_YY  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_ZZ  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_XY  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_XZ  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_YZ  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),),
+             CRITERE        = SIMP(statut='o',typ='TXM',into=("CROSSLAND","PAPADOPOULOS")),
+             DOMMAGE        = SIMP(statut='f',typ='TXM',into=("WOHLER",)),
+             MATER          = SIMP(statut='o',typ=mater_sdaster),
+             COEF_CORR      = SIMP(statut='f',typ='R'),
+         ),
+
+         b_quelconque = BLOC( condition = "CHARGEMENT=='QUELCONQUE'",
+             HISTOIRE       = FACT(statut='o',
+                                 SIGM_XX  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_YY  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_ZZ  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_XY  = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_XZ  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 SIGM_YZ  = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 EPSP     = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+                                 TEMP     = SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),),
+             DOMMAGE        = SIMP(statut='f',typ='TXM',into=("LEMAITRE",),),
+             MATER          = SIMP(statut='o',typ=mater_sdaster),
+             CUMUL          = SIMP(statut='f',typ='TXM',into=("LINEAIRE",)),
+         ),
+
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE WADIER Y.WADIER
+
+from Macro.post_gp_ops import post_gp_ops
+def post_gp_prod(self, TABL_RESU, **kargs):
+   """Typage des sd_prod
+   """
+   if TABL_RESU != None:
+      self.type_sdprod(TABL_RESU, table_sdaster)
+   return table_sdaster
+
+POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod,
+              fr="Calcul du critère énergétique Gp suite à un calcul thermo-mécanique",
+              reentrant='n',
+              UIinfo={"groupes":("Post traitements",)},
+              regles=(UN_PARMI('IDENTIFICATION', 'PREDICTION'),
+                      UN_PARMI('THETA_2D','THETA_3D'),
+                      UN_PARMI('PAS_ENTAILLE','LIST_EP_COPEAUX'),
+                      PRESENT_PRESENT('THETA_2D','DIRECTION'),),
+      
+      # Résultat, modèle, comportement, chargement
+      RESULTAT     = SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,mode_meca),),
+      RESU_THER    = SIMP(statut='f',typ=evol_ther,),
+      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","GREEN"),),
+      ),
+      
+      EXCIT        = FACT(statut='f', max='**',
+            CHARGE      = SIMP(statut='o', typ=(char_meca,char_cine_meca)),
+            FONC_MULT   = SIMP(statut='f', typ=(fonction_sdaster,nappe_sdaster,formule)),
+            TYPE_CHARGE = SIMP(statut='f', typ='TXM', defaut="FIXE", into=("FIXE",)),
+      ),
+      SYME_CHAR    = SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","ANTI","SANS")),
+      
+      DIRECTION    = SIMP(statut='f', typ='R', max=3),
+
+      THETA_2D     = FACT(statut='f', max='**',
+                          fr="paramètres de définition des champs theta",
+            GROUP_NO    = SIMP(statut='o', typ=grno, validators=NoRepeat(), max='**'),
+            R_INF       = SIMP(statut='o', typ='R'),
+            R_SUP       = SIMP(statut='o', typ='R'),
+      ),
+
+
+      THETA_3D        =FACT(statut='f',max='**',
+            GROUP_MA        =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'),
+            R_INF           =SIMP(statut='o',typ='R'),
+            R_SUP           =SIMP(statut='o',typ='R'),
+                         ),
+         b_theta_3d     =BLOC(condition="THETA_3D != None",
+            LISSAGE         =FACT(statut='d',
+                DEGRE            =SIMP(statut='f',typ='I',defaut=5,into=(0,1,2,3,4,5,6,7) ),
+                LISSAGE_THETA    =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",
+                                  into=("LEGENDRE","LAGRANGE","LAGRANGE_REGU"),),
+                LISSAGE_G        =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",
+                                  into=("LEGENDRE","LAGRANGE","LAGRANGE_NO_NO","LAGRANGE_REGU"),),
+                             ),
+    
+            FOND_FISS       =SIMP(statut='o',typ=fond_fiss,max=1,),
+            NB_TRANCHES     =SIMP(statut='o',typ='I',max=1,
+                            fr="nombre de tranches: nombre de segments maillant le fond de fissure",),
+                         ),
+
+      # prise en compte de la traction compression
+      TRAC_COMP    = SIMP(statut='f',typ='TXM',into=("OUI",),
+                          fr="prise en compte de la traction-compression (plus lent)",
+                         ),
+
+      # copeaux
+      GROUP_MA        = SIMP(statut='o', typ=grma, validators=NoRepeat(), max='**'),
+      PAS_ENTAILLE    = SIMP(statut='f', typ='R', val_min=0.),
+      LIST_EP_COPEAUX = SIMP(statut='f', typ='R', max='**'),
+      
+      # critère sur Gp
+      CRIT_MAXI_GP = SIMP(statut='f', typ='TXM', defaut="ABSOLU",
+                          into=("RELATIF","ABSOLU")),
+      
+      # correction axisymétrie
+      RAYON_AXIS   = SIMP(statut='f', typ='R', val_min=0., defaut=1.),
+      
+      # identification
+      IDENTIFICATION = FACT(statut='f', max=1,
+            KJ_CRIT     = SIMP(statut='o', typ='R', val_min=0., max='**'),
+            TEMP        = SIMP(statut='o', typ='R', val_min=0., max='**'),
+      ),
+      
+      # prédiction
+      PREDICTION   = FACT(statut='f', max=1,
+            GP_CRIT     = SIMP(statut='o', typ='R', val_min=0., max='**'),
+            TEMP        = SIMP(statut='o', typ='R', val_min=0., max='**'),
+      ),
+      
+      # table résultat
+      TABL_RESU    = SIMP(statut='o', typ=CO,),
+      
+      INFO         = SIMP(statut='f', typ='I', defaut=1, into=(1, 2),),
+)
+#& MODIF COMMANDE  DATE 20/10/2008   AUTEUR GALENNE E.GALENNE 
+#            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 GALENNE E.GALENNE
+from Macro.post_k1_k2_k3_ops import post_k1_k2_k3_ops
+POST_K1_K2_K3=MACRO(nom="POST_K1_K2_K3",op=post_k1_k2_k3_ops,sd_prod=table_sdaster,
+                   fr="Calcul des facteurs d'intensité de contraintes en 2D et en 3D par extrapolation des sauts de déplacements"
+                     +" sur les lèvres de la fissure",
+                   reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+
+           regles=(UN_PARMI('RESULTAT','TABL_DEPL_SUP'),
+                  EXCLUS('FISSURE','FOND_FISS'),
+                  PRESENT_PRESENT('FISSURE','RESULTAT'),
+                  PRESENT_PRESENT('FOND_FISS','VECT_K1'),
+                  PRESENT_PRESENT('TABL_DEPL_SUP','VECT_K1'),
+                   #PRESENT_PRESENT('RESULTAT','FOND_FISS'),
+                   ),
+
+         MODELISATION  =SIMP(statut='o',typ='TXM',
+                             into=("3D","AXIS","D_PLAN","C_PLAN"),
+                             fr="Modélisation cohérente avec celle utilisée pour le calcul des déplacements"),
+         FOND_FISS     =SIMP(statut='f',typ=fond_fiss),
+         FISSURE     =SIMP(statut='f',typ=fiss_xfem),
+         b_fond_fiss   =BLOC (condition="(FOND_FISS!= None)",
+                         MAILLAGE      = SIMP(statut='o',typ=maillage_sdaster),
+                         TYPE_MAILLAGE = SIMP(statut='f',typ='TXM',into=("LIBRE","REGLE"),defaut="REGLE"),
+                         NB_NOEUD_COUPE= SIMP(statut='f',typ='I'),
+                         NOEUD         = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                         GROUP_NO      = SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+                         SANS_NOEUD    = SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+                         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_fissure   =BLOC (condition="(FISSURE!= None)",
+                         MAILLAGE       = SIMP(statut='o',typ=maillage_sdaster),
+                         NB_NOEUD_COUPE = SIMP(statut='f',typ='I' ,defaut=5 ),
+                         NB_POINT_FOND  = SIMP(statut='f',typ='I' ,),
+                         NUME_FOND      = SIMP(statut='f',typ='I',defaut=1),
+                         DTAN_ORIG      = SIMP(statut='f',typ='R',max='**'),
+                         DTAN_EXTR      = SIMP(statut='f',typ='R',max='**'),
+                         ),
+         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),
+                             fr="Déplacement des noeuds de la lèvre supérieure et inférieure"),
+         TABL_DEPL_SUP =SIMP(statut='f',typ=table_sdaster,
+                             fr="Table issue de post_releve_t sur les noeuds de la lèvre supérieure"),
+         TABL_DEPL_INF =SIMP(statut='f',typ=table_sdaster,
+                             fr="Table issue de post_releve_t sur les noeuds de la lèvre inférieure"),
+         ABSC_CURV_MAXI=SIMP(statut='o',typ='R',
+                             fr="Distance maximum à partir du fond de fissure à utiliser pour le calcul"),  
+         PREC_VIS_A_VIS= SIMP(statut='f',typ='R',defaut=0.1),
+         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),
+             b_acce_reel     =BLOC(condition="(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',),),
+             ),
+         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"),  
+         TITRE         =SIMP(statut='f',typ='TXM',max='**'),  
+)  ;
+#& MODIF COMMANDE  DATE 03/06/2008   AUTEUR DURAND C.DURAND 
+#            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 C.MESSELIER-GOUZE
+#
+POST_K_BETA=OPER(nom="POST_K_BETA",op=198,sd_prod=table_sdaster,
+                   fr="Calcul des facteurs d'intensité de contraintes par la méthode K_BETA",
+                   reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+         MAILLAGE      = SIMP(statut='o',typ=maillage_sdaster),
+         MATER_REV     = SIMP(statut='o',typ=mater_sdaster),
+         EPAIS_REV     = SIMP(statut='o',typ='R'),
+         FISSURE       = FACT(statut='o',
+            DECALAGE       = SIMP(statut='f',typ='R',defaut=-2.e-04),
+            PROFONDEUR     = SIMP(statut='o',typ='R'),
+            LONGUEUR       = SIMP(statut='o',typ='R'),
+            ORIENTATION    = SIMP(statut='o',typ='TXM',
+                                 into=("CIRC","LONGI"),),
+         ),
+         K1D           = FACT(statut='o',max='**',
+            TABL_MECA_REV  = SIMP(statut='o',typ=(table_sdaster)),
+            TABL_MECA_MDB  = SIMP(statut='o',typ=(table_sdaster)),
+            TABL_THER      = SIMP(statut='o',typ=(table_sdaster)),
+            INTITULE       = SIMP(statut='o',typ='TXM' ), 
+         ),
+         TITRE         = SIMP(statut='f',typ='TXM',max='**'),  
+);
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 GALENNE E.GALENNE
+
+from Macro.post_k_trans_ops import post_k_trans_ops
+
+POST_K_TRANS=MACRO(nom="POST_K_TRANS",op=post_k_trans_ops,sd_prod=table_sdaster,
+            fr="Calcul des facteurs d intensite des contrainte par recombinaison modale",reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+        RESU_TRANS      =SIMP(statut='o',typ=tran_gene), 
+        K_MODAL         =FACT(statut='o',
+           TABL_K_MODA     =SIMP(statut='f',typ=table_sdaster,),
+           RESU_MODA       =SIMP(statut='f',typ=mode_meca,),
+           FOND_FISS       =SIMP(statut='f',typ=fond_fiss,),
+           FISSURE         =SIMP(statut='f',typ=fiss_xfem,),
+           THETA           =SIMP(statut='f',typ=(theta_geom,cham_no_sdaster)),
+           R_INF           =SIMP(statut='f',typ='R'),
+           R_SUP           =SIMP(statut='f',typ='R'),
+           MODULE          =SIMP(statut='f',typ='R'),
+           DIRE_THETA      =SIMP(statut='f',typ=cham_no_sdaster ),
+           DIRECTION       =SIMP(statut='f',typ='R',max='**'),
+           R_INF_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           R_SUP_FO        =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),             
+           MODULE_FO       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+           DEGRE           =SIMP(statut='f',typ='I',into=(0,1,2,3,4,5,6,7) ),
+           LISSAGE_THETA   =SIMP(statut='f',typ='TXM',into=("LEGENDRE","LAGRANGE","LAGRANGE_REGU"),),
+           LISSAGE_G       =SIMP(statut='f',typ='TXM',into=("LEGENDRE","LAGRANGE","LAGRANGE_NO_NO","LAGRANGE_REGU"),),
+
+
+           regles=(UN_PARMI('TABL_K_MODA','RESU_MODA'),
+                   UN_PARMI('FISSURE','FOND_FISS'),
+                   EXCLUS('MODULE','MODULE_FO'),
+                   PRESENT_PRESENT('R_INF','R_SUP'),
+                   PRESENT_PRESENT('R_INF_FO','R_SUP_FO'), ),
+         ),
+        regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),),
+        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),
+        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'),),
+        INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+        TITRE           =SIMP(statut='f',typ='TXM'),
+)
+
+#& MODIF COMMANDE  DATE 12/05/2009   AUTEUR MAZET S.MAZET 
+#            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 GENIAUT S.GENIAUT
+POST_MAIL_XFEM=OPER(nom="POST_MAIL_XFEM",op= 187,sd_prod=maillage_sdaster,
+                    reentrant='n',UIinfo={"groupes":("Maillage",)},
+            fr="Crée un maillage se conformant à la fissure pour le post-traitement des éléments XFEM",
+    MODELE        = SIMP(statut='o',typ=modele_sdaster),
+    MAILLAGE_SAIN = SIMP(statut='o',typ=maillage_sdaster),
+    PREF_NOEUD_X   =SIMP(statut='f',typ='TXM',defaut="NX",validators=LongStr(1,2),),
+    PREF_NOEUD_M   =SIMP(statut='f',typ='TXM',defaut="NM",validators=LongStr(1,2),),
+    PREF_NOEUD_P   =SIMP(statut='f',typ='TXM',defaut="NP",validators=LongStr(1,2),),
+    PREF_MAILLE_X  =SIMP(statut='f',typ='TXM',defaut="MX",validators=LongStr(1,2),),
+    PREF_GROUP_CO  =SIMP(statut='f',typ=geom ,defaut="NFISSU",),
+    TITRE         = SIMP(statut='f',typ='TXM',max='**'),
+    INFO           =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
+
+);                     
+#& MODIF COMMANDE  DATE 06/07/2009   AUTEUR GALENNE E.GALENNE 
+#            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 PARTIC               
+#
+# 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 GALENNE E.GALENNE
+POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster,
+               fr="Vérification des critères de niveau 0 et certains critères de niveau A du RCC-M-B3200 (Edition 1991)",
+               reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+         TYPE_RESU       =SIMP(statut='f',typ='TXM',defaut="VALE_MAX",into=("VALE_MAX","DETAILS") ),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         TYPE_RESU_MECA  =SIMP(statut='o',typ='TXM',into=("EVOLUTION","UNITAIRE","TUYAUTERIE") ),
+
+# ======================================================================
+     b_evolution  =BLOC(condition="(TYPE_RESU_MECA == 'EVOLUTION')",
+
+         OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
+                               into=("PM_PB","SN","FATIGUE_ZH210","AMORCAGE") ),
+         MATER           =SIMP(statut='o',typ=mater_sdaster ),
+         SY_MAX          =SIMP(statut='f',typ='R',
+                               fr="limite élastique utilisée pour le calcul du rochet thermique" ),
+         TYPE_KE         =SIMP(statut='f',typ='TXM',defaut="KE_MECA",into=("KE_MECA","KE_MIXTE"),
+                               fr="Ke meca seul ou partition mecanique + thermique" ),
+                               
+         TRANSITOIRE     =FACT(statut='o',max='**',fr="transitoire à dépouiller",
+           regles=(EXCLUS('TOUT_ORDRE','INST','LIST_INST'),
+                   UN_PARMI('TABL_RESU_MECA','TABL_SIGM_THETA'),),
+           NB_OCCUR        =SIMP(statut='f',typ='I',defaut= 1,
+                                 fr="nombre d occurences réelles de ce transitoire" ),
+           TABL_RESU_MECA  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="relevé des contraintes sur le chemin"),
+           TABL_SIGM_THER  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="résultat sous chargement thermique seul" ),
+           TABL_RESU_PRES  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes sous chargement de pression" ),
+           TABL_SIGM_THETA =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes a la distance d de la singularité pour chacun des angles THETA" ),
+           TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+           LIST_INST       =SIMP(statut='f',typ=listr8_sdaster ),
+           b_inst          =BLOC(condition = "(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',),),),
+           ),
+         ),
+
+# ======================================================================
+     b_unitaire  =BLOC(condition="(TYPE_RESU_MECA == 'UNITAIRE')",
+
+         OPTION          =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
+                               into=("PM_PB","SN","FATIGUE") ),
+         MATER           =SIMP(statut='o',typ=mater_sdaster ),
+         SY_MAX          =SIMP(statut='f',typ='R',
+                               fr="limite élastique utilisée pourle calcul du rochet thermique" ),
+         TYPE_KE         =SIMP(statut='f',typ='TXM',defaut="KE_MECA",into=("KE_MECA","KE_MIXTE"),
+                               fr="Ke meca seul ou partition mecanique + thermique" ),
+         CHAR_MECA   =FACT(statut='o',max='**',fr="Chargements mécaniques",
+                           regles=(UN_PARMI('MX','MX_TUBU'),),
+           NUME_CHAR     =SIMP(statut='o',typ='I',fr="numéro du chargement" ),
+           NOM_CHAR      =SIMP(statut='f',typ='TXM',fr="nom du chargement" ),
+           MX            =SIMP(statut='f',typ='R',fr="moment suivant x", ),
+           MX_TUBU       =SIMP(statut='f',typ='R',fr="moment suivant x, tubulure", ),
+           b_1_tenseur     =BLOC( condition = "MX != None",
+             FX            =SIMP(statut='f',typ='R',fr="effort suivant x", ),
+             FY            =SIMP(statut='f',typ='R',fr="effort suivant y", ),
+             FZ            =SIMP(statut='f',typ='R',fr="effort suivant z", ),
+             MY            =SIMP(statut='o',typ='R',fr="moment suivant y", ),
+             MZ            =SIMP(statut='o',typ='R',fr="moment suivant z", ),
+           ),
+           b_2_tenseurs    =BLOC( condition = "MX_TUBU != None",
+             FX_TUBU       =SIMP(statut='f',typ='R',fr="effort suivant x, tubulure", ),
+             FY_TUBU       =SIMP(statut='f',typ='R',fr="effort suivant y, tubulure", ),
+             FZ_TUBU       =SIMP(statut='f',typ='R',fr="effort suivant z, tubulure", ),
+             MY_TUBU       =SIMP(statut='o',typ='R',fr="moment suivant y, tubulure", ),
+             MZ_TUBU       =SIMP(statut='o',typ='R',fr="moment suivant z, tubulure", ),
+             FX_CORP       =SIMP(statut='f',typ='R',fr="effort suivant x, corps du piquage", ),
+             FY_CORP       =SIMP(statut='f',typ='R',fr="effort suivant y, corps du piquage", ),
+             FZ_CORP       =SIMP(statut='f',typ='R',fr="effort suivant z, corps du piquage", ),
+             MX_CORP       =SIMP(statut='o',typ='R',fr="moment suivant x, corps du piquage", ),
+             MY_CORP       =SIMP(statut='o',typ='R',fr="moment suivant y, corps du piquage", ),
+             MZ_CORP       =SIMP(statut='o',typ='R',fr="moment suivant z, corps du piquage", ),
+           ),
+
+                         ),
+         RESU_MECA_UNIT =FACT(statut='o',fr="resultats mécaniques unitaires",
+                              regles=(UN_PARMI('TABL_MX','TABL_MX_TUBU'),),
+           TABL_MX       =SIMP(statut='f',typ=table_sdaster,
+                               fr="table relevé des contraintes pour chargement unitaire MX"),
+           TABL_MX_TUBU  =SIMP(statut='f',typ=table_sdaster,
+                               fr="table relevé des contraintes pour chargement unitaire MX_TUBU"),
+           b_1_tenseur     =BLOC( condition = "TABL_MX != None",
+             TABL_FX       =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FX"),
+             TABL_FY       =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FY"),
+             TABL_FZ       =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FZ"),
+             TABL_MY       =SIMP(statut='o',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire MY"),
+             TABL_MZ       =SIMP(statut='o',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire MZ"),
+           ),
+           b_2_tenseurs    =BLOC( condition = "TABL_MX_TUBU != None",
+             TABL_FX_TUBU  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FX_TUBU"),
+             TABL_FY_TUBU  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FY_TUBU"),
+             TABL_FZ_TUBU  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FZ_TUBU"),
+             TABL_MY_TUBU  =SIMP(statut='o',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire MY_TUBU"),
+             TABL_MZ_TUBU  =SIMP(statut='o',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire MZ_TUBU"),
+             TABL_FX_CORP  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FX_CORP"),
+             TABL_FY_CORP  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FY_CORP"),
+             TABL_FZ_CORP  =SIMP(statut='f',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire FZ_CORP"),
+             TABL_MX_CORP  =SIMP(statut='o',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire MX_CORP"),
+             TABL_MY_CORP  =SIMP(statut='o',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire MY_CORP"),
+             TABL_MZ_CORP  =SIMP(statut='o',typ=table_sdaster,
+                                 fr="table relevé des contraintes pour chargement unitaire MZ_CORP"),
+           ),
+           TABL_PRES     =SIMP(statut='o',typ=table_sdaster,
+                               fr="table relevé des contraintes pour chargement unitaire de pression"),
+                         ),
+
+          RESU_THER   =FACT(statut='f',max='**',fr="resultats thermiques",
+           NUME_RESU_THER =SIMP(statut='o',typ='I',fr="numéro de la table de résultat thermique" ),
+           TABL_RESU_THER =SIMP(statut='o',typ=table_sdaster,
+                              fr="table relevé des contraintes sous chargement thermique seul" ),
+                           ),
+         SEISME         =FACT(statut='f',max='**',fr="Situation séisme",ang="situation_ang",
+              NB_OCCUR         =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
+              NB_CYCL_SEISME   =SIMP(statut='o',typ='I',fr="nombre de cycles associé au séisme" ),
+              NUME_SITU        =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+              NOM_SITU         =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
+              NUME_GROUPE      =SIMP(statut='o',typ='I',fr="numéros du groupe de la situation" ),
+              CHAR_ETAT        =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
+                               ),
+         SITUATION         =FACT(statut='o',max='**',fr="Situation",ang="situation_ang",
+              NB_OCCUR         =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
+              NUME_SITU        =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+              NOM_SITU         =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
+              COMBINABLE       =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ),
+              NUME_GROUPE      =SIMP(statut='f',typ='I',
+                                     fr="numéros des groupes de la situation" ),
+              NUME_PASSAGE     =SIMP(statut='f',typ='I',min=2,max=2,
+                                     fr="numéro des situations de passage" ),
+              NUME_RESU_THER   =SIMP(statut='f',typ='I',max=1,fr="numeros de transitoires thermiques" ),
+              CHAR_ETAT_A      =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
+              CHAR_ETAT_B      =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat B" ),
+              PRES_A           =SIMP(statut='o',typ='R',fr="pression etat A"),
+              PRES_B           =SIMP(statut='o',typ='R',fr="pression etat B"),
+              TEMP_REF_A       =SIMP(statut='f',typ='R',fr="temperature référence etat A"),
+              TEMP_REF_B       =SIMP(statut='f',typ='R',fr="temperature référence etat B"),
+                               ),
+                      ),
+# ======================================================================
+     b_tuyauterie  =BLOC(condition="(TYPE_RESU_MECA == 'TUYAUTERIE')",
+
+         OPTION          =SIMP(statut='o',typ='TXM',into=("FATIGUE",) ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater ),
+         TYPE_KE         =SIMP(statut='f',typ='TXM',defaut="KE_MECA",into=("KE_MECA","KE_MIXTE"),
+                               fr="Ke meca seul ou partition mecanique + thermique" ),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CARA_ELEM       =SIMP(statut='o',typ=cara_elem),
+         ZONE_ANALYSE =FACT(statut='o',fr="liste des mailles ou des noeuds analysés",
+            regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),AU_MOINS_UN('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='**'),
+            ),
+         RESU_MECA   =FACT(statut='o',max='**',fr="Chargements mécaniques",
+           regles=(UN_PARMI('CHAM_GD','RESULTAT'),),
+           NUME_CHAR     =SIMP(statut='o',typ='I',fr="numéro du chargement" ),
+           NOM_CHAR      =SIMP(statut='f',typ='TXM',fr="nom du chargement" ),
+           CHAM_GD         =SIMP(statut='f',typ=cham_gd_sdaster),
+           RESULTAT        =SIMP(statut='f',typ=resultat_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"),),
+             TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             NUME_ORDRE      =SIMP(statut='f',typ='I',),
+             INST            =SIMP(statut='f',typ='R',),
+             NOEUD_CMP       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+             b_acce_reel     =BLOC(condition="(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',),),
+             ),
+           ),
+                          ),
+         INDI_SIGM =FACT(statut='o',max='**',fr="indices de contraintes",
+            regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+            C1              =SIMP(statut='f',typ='R',defaut=1.0,fr="indice de contraintes C1 du RCCM"),
+            K1              =SIMP(statut='f',typ='R',defaut=1.0,fr="indice de contraintes K1 du RCCM"),
+            C2              =SIMP(statut='f',typ='R',defaut=1.0,fr="indice de contraintes C2 du RCCM"),
+            K2              =SIMP(statut='f',typ='R',defaut=1.0,fr="indice de contraintes K2 du RCCM"),
+            C3              =SIMP(statut='f',typ='R',defaut=0.5,fr="indice de contraintes C3 du RCCM"),
+            K3              =SIMP(statut='f',typ='R',defaut=1.0,fr="indice de contraintes K3 du RCCM"),
+            TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",),),
+            GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',
+                             fr="groupe(s) de mailles ou sont affectés les indices de contraintes"),
+            MAILLE          =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',
+                             fr="liste des mailles ou sont affectés les indices de contraintes"),
+            b_grma     =BLOC(condition="(GROUP_MA != None)or(MAILLE != None)",
+               GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+               NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            ),
+            TYPE_ELEM_STANDARD =SIMP(statut='f',typ='TXM',into=("DRO","COU","TRN","TEE"),
+                              fr="type d'élément de tuyauterie ou sont affectés les indices de contraintes"),
+                         ),
+          RESU_THER   =FACT(statut='f',max='**',fr="resultats thermiques",
+            regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),AU_MOINS_UN('TOUT','GROUP_MA','MAILLE'),),
+            NUME_RESU_THER =SIMP(statut='o',typ='I',fr="numéro de la table de résultat thermique" ),
+            TABL_RESU_THER =SIMP(statut='o',typ=table_sdaster,
+                              fr="table relevé des températures sur la section"),
+            TABL_MOYE_THER =SIMP(statut='o',typ=table_sdaster,
+                              fr="table relevé des moyennes sur la section"),
+            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='**'),
+            b_grma     =BLOC(condition="(GROUP_MA != None)or(MAILLE != None)",
+               GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+               NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+            ),
+                           ),
+         SEISME         =FACT(statut='f',max='**',fr="Situation séisme",ang="situation_ang",
+              NB_OCCUR         =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
+              NB_CYCL_SEISME   =SIMP(statut='o',typ='I',fr="nombre de cycles associé au séisme" ),
+              NUME_SITU        =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+              NOM_SITU         =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
+              NUME_GROUPE      =SIMP(statut='o',typ='I',fr="numéros du groupe de la situation" ),
+              CHAR_ETAT        =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
+              TEMP_REF         =SIMP(statut='f',typ='R',fr="temperature référence"),
+                               ),
+         SITUATION         =FACT(statut='o',max='**',fr="Situation",ang="situation_ang",
+              NB_OCCUR         =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ),
+              NUME_SITU        =SIMP(statut='o',typ='I',fr="numéro de la situation" ),
+              NOM_SITU         =SIMP(statut='f',typ='TXM',fr="nom de la situation" ),
+              COMBINABLE       =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ),
+              NUME_GROUPE      =SIMP(statut='f',typ='I',
+                                     fr="numéros des groupes de la situation" ),
+              NUME_PASSAGE     =SIMP(statut='f',typ='I',min=2,max=2,
+                                     fr="numéro des situations de passage" ),
+              NUME_RESU_THER   =SIMP(statut='f',typ='I',max='**',fr="numeros de transitoires thermiques" ),
+              CHAR_ETAT_A      =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat A" ),
+              CHAR_ETAT_B      =SIMP(statut='o',typ='I',max='**',fr="numeros de chargements etat B" ),
+              PRES_A           =SIMP(statut='o',typ='R',fr="pression etat A"),
+              PRES_B           =SIMP(statut='o',typ='R',fr="pression etat B"),
+              TEMP_REF_A       =SIMP(statut='f',typ='R',fr="temperature référence etat A"),
+              TEMP_REF_B       =SIMP(statut='f',typ='R',fr="temperature référence etat B"),
+                               ),
+               ),
+)  ;
+#& MODIF COMMANDE  DATE 12/05/2009   AUTEUR DESROCHES X.DESROCHES 
+# ======================================================================
+#            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 DESROCHES X.DESROCHES
+POST_RELEVE_T=OPER(nom="POST_RELEVE_T",op=51,sd_prod=table_sdaster,reentrant='f',
+            fr="Extraire des valeurs de composantes de champs de grandeurs pour y effectuer des calculs (moyenne,invariants,..)"
+               +" ou pour les exprimer dans d'autres repères",
+            docu="U4.81.21",UIinfo={"groupes":("Post traitements",)},
+
+         ACTION          =FACT(statut='o',max='**',
+                               regles=(UN_PARMI('RESULTAT','CHAM_GD'),), 
+
+           OPERATION       =SIMP(statut='o',typ='TXM',into=("EXTRACTION","MOYENNE","MOYENNE_ARITH","EXTREMA"),
+           validators=NoRepeat(),max=2),
+           INTITULE        =SIMP(statut='o',typ='TXM'),  
+
+           CHAM_GD         =SIMP(statut='f',typ=(cham_no_sdaster,
+                                                 cham_elem,),),
+           RESULTAT        =SIMP(statut='f',typ=resultat_sdaster),
+#
+#  1. Sensibilité
+#  1.1. Cas d'un résultat réel
+#       Cas d'un résultat harmonique dont on veut partie réelle ou imaginaire
+#
+           b_sensibilite   =BLOC(condition=" (RESULTAT != None) and \
+                                      (   AsType(RESULTAT) in (evol_elas,evol_ther,evol_noli,dyna_trans, \
+                                                               mode_meca,mode_flamb,mode_acou, \
+                                                               mult_elas,fourier_elas,fourier_ther) or \
+                                        ( AsType(RESULTAT) in (dyna_harmo,acou_harmo) and FORMAT_C != 'MODULE' ) )",
+                                 fr="Définition des paramètres de sensibilité",
+                                 ang="Definition of sensitivity parameters",
+             regles=(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"),
+
+           ),
+#
+#  1.2. Cas d'un résultat harmonique dont on veut le module
+#
+           b_sensibilite_harmo =BLOC(condition=" (RESULTAT != None) and \
+                                      ( AsType(RESULTAT) in (dyna_harmo,acou_harmo) and FORMAT_C == 'MODULE' )",
+                                     fr="Définition des paramètres de sensibilité",
+                                     ang="Definition of sensitivity parameters",
+             regles=(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"),
+               b_sensibilite_harmo =BLOC(condition=" SENSIBILITE != None",
+                                         fr="Option pour la sensibilite",
+                                         ang="Option for sensitivity",
+               SENSIBILITE_OPTION =SIMP(statut='o',typ='TXM',into=("MODULE_SENSIBILITE","SENSIBILITE_MODULE",),
+                                        fr="Option : module de la dérivée ou dérivée du module",
+                                        ang="Option : modulus of derivative or derivative of modulus"),
+               ),
+           ),
+
+           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' ),  
+             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),
+             NUME_MODE       =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),  
+             LIST_MODE       =SIMP(statut='f',typ=listis_sdaster),
+             NOEUD_CMP       =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+             NOM_CAS         =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),  
+             FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),  
+             LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster),
+             INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),  
+             LIST_INST       =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',),),
+           ),
+
+           b_extrema   =BLOC(condition="OPERATION == 'EXTREMA'",
+                             fr="recherche de MIN MAX",
+                             regles=(EXCLUS('TOUT_CMP','NOM_CMP'),),
+              TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+              GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+              TOUT_CMP        =SIMP(statut='f',typ='TXM',into=("OUI",)),
+              NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),  
+           ),
+
+           b_MOYENNE_ARITH   =BLOC(condition="OPERATION == 'MOYENNE_ARITH'",
+                             fr="moyenne sur des groupes",
+                             regles=(EXCLUS('TOUT_CMP','NOM_CMP'),),
+              TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+              GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+              TOUT_CMP        =SIMP(statut='f',typ='TXM',into=("OUI",)),
+              NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),  
+           ),
+
+           b_autre   =BLOC(condition="OPERATION != 'EXTREMA' and OPERATION != 'MOYENNE_ARITH'",
+                           fr="extraction et moyenne",
+                           regles=(AU_MOINS_UN('CHEMIN','GROUP_NO','NOEUD'),
+                                   EXCLUS('CHEMIN','GROUP_NO'),
+                                   EXCLUS('CHEMIN','NOEUD'),
+                                   PRESENT_ABSENT('CHEMIN','GROUP_MA','MAILLE'),
+                                   UN_PARMI('TOUT_CMP','NOM_CMP','INVARIANT','ELEM_PRINCIPAUX','RESULTANTE'),
+                                   PRESENT_PRESENT('TRAC_DIR','DIRECTION'),          
+                                   ENSEMBLE('MOMENT','POINT'),
+                                   PRESENT_PRESENT('MOMENT','RESULTANTE'),
+                                   PRESENT_ABSENT('TOUT_CMP','TRAC_DIR','TRAC_NOR'),
+                                   EXCLUS('TRAC_DIR','TRAC_NOR'),
+                                   PRESENT_PRESENT('ORIGINE','AXE_Z'),),
+                   
+              CHEMIN          =SIMP(statut='f',typ=(courbe_sdaster,surface_sdaster) ),
+              TOUT            =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+              GROUP_MA        =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+              MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+              GROUP_NO        =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+              NOEUD           =SIMP(statut='f',typ=no  ,validators=NoRepeat(),max='**'),
+
+              TOUT_CMP        =SIMP(statut='f',typ='TXM',into=("OUI",)),
+              NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),  
+              INVARIANT       =SIMP(statut='f',typ='TXM',into=("OUI",)),
+              ELEM_PRINCIPAUX =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+              RESULTANTE      =SIMP(statut='f',typ='TXM',max='**'),  
+
+              MOMENT          =SIMP(statut='f',typ='TXM',max='**'),  
+              POINT           =SIMP(statut='f',typ='R',max='**'),  
+
+              REPERE          =SIMP(statut='f',typ='TXM',defaut="GLOBAL",
+                                 into=("GLOBAL","LOCAL","POLAIRE","UTILISATEUR","CYLINDRIQUE"),),
+              ANGL_NAUT       =SIMP(statut='f',typ='R',min=3,max=3),  
+              ORIGINE         =SIMP(statut='f',typ='R',min=3,max=3),  
+              AXE_Z           =SIMP(statut='f',typ='R',min=3,max=3),  
+
+              TRAC_NOR        =SIMP(statut='f',typ='TXM',into=("OUI",)),
+              TRAC_DIR        =SIMP(statut='f',typ='TXM',into=("OUI",)),
+              DIRECTION       =SIMP(statut='f',typ='R',max='**'),  
+ 
+              VECT_Y          =SIMP(statut='f',typ='R',max='**'),  
+              MOYE_NOEUD      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+           ),
+
+           FORMAT_C        =SIMP(statut='f',typ='TXM',defaut="MODULE",into=("MODULE","REEL","IMAG")),
+
+         ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),  
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ZENTNER I.ZENTNER
+POST_USURE=OPER(nom="POST_USURE",op=153,sd_prod=table_sdaster,reentrant='f',
+            UIinfo={"groupes":("Post traitements",)},
+                fr="Calcul des volumes d'usure et des profondeurs d'usure d'après la puissance d'usure",
+         regles=(UN_PARMI('TUBE_NEUF','RESU_GENE','PUIS_USURE'),
+                 PRESENT_PRESENT('RESU_GENE','NOEUD','LOI_USURE'),
+                 PRESENT_PRESENT('PUIS_USURE','LOI_USURE'),),
+         TUBE_NEUF       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         ETAT_INIT       =FACT(statut='f',
+           TABL_USURE      =SIMP(statut='f',typ=table_sdaster),
+           INST_INIT       =SIMP(statut='f',typ='R'),  
+                         ),
+         RESU_GENE       =SIMP(statut='f',typ=tran_gene),
+         NOEUD           =SIMP(statut='f',typ=no,),
+         INST_INIT       =SIMP(statut='f',typ='R',defaut=-1.0E+0),  
+         INST_FIN        =SIMP(statut='f',typ='R'),  
+         NB_BLOC         =SIMP(statut='f',typ='I',defaut= 1 ),  
+         PUIS_USURE      =SIMP(statut='f',typ='R'),  
+         LOI_USURE       =SIMP(statut='f',typ='TXM',into=("ARCHARD","KWU_EPRI","EDF_MZ")),
+         b_archard       =BLOC(condition = "LOI_USURE == 'ARCHARD'",
+           regles=(UN_PARMI('MOBILE','MATER_USURE','SECTEUR'), 
+                   EXCLUS('MATER_USURE','OBSTACLE'),
+                   EXCLUS('MOBILE','USURE_OBST'),),
+           MOBILE          =FACT(statut='f',
+             COEF_USURE      =SIMP(statut='o',typ='R'), 
+           ),   
+           OBSTACLE        =FACT(statut='f',
+             COEF_USURE      =SIMP(statut='o',typ='R'), 
+           ),
+           SECTEUR         =FACT(statut='f',max='**',
+             CONTACT         =SIMP(statut='f',typ='TXM',into=("TUBE_BAV","TUBE_ALESAGE","TUBE_4_ENCO",  
+                                                              "GRAPPE_ALESAGE","TUBE_3_ENCO","TUBE_TUBE", 
+                                                              "GRAPPE_1_ENCO","GRAPPE_2_ENCO")),
+             COEF_USUR_MOBILE=SIMP(statut='f',typ='R'),  
+             COEF_USUR_OBST  =SIMP(statut='f',typ='R'),  
+             ANGL_INIT       =SIMP(statut='f',typ='R'),  
+             ANGL_FIN        =SIMP(statut='f',typ='R'),  
+           ),
+           MATER_USURE     =SIMP(statut='f',typ='TXM'),  
+           USURE_OBST      =SIMP(statut='f',typ='TXM',into=("OUI",)),
+         ),
+         b_kwu_epri        =BLOC(condition = "LOI_USURE == 'KWU_EPRI'",
+           regles=(UN_PARMI('MOBILE','MATER_USURE'), 
+                   EXCLUS('MATER_USURE','OBSTACLE'),
+                   EXCLUS('MOBILE','USURE_OBST'),),
+           MOBILE          =FACT(statut='f',
+             COEF_FNOR       =SIMP(statut='f',typ='R'),  
+             COEF_VTAN       =SIMP(statut='f',typ='R'),  
+             COEF_USURE      =SIMP(statut='f',typ='R'),  
+             COEF_K          =SIMP(statut='f',typ='R',defaut=5.0E+0),  
+             COEF_C          =SIMP(statut='f',typ='R',defaut=10.0E+0),  
+           ),   
+           OBSTACLE        =FACT(statut='f',
+             COEF_FNOR       =SIMP(statut='f',typ='R' ),  
+             COEF_VTAN       =SIMP(statut='f',typ='R' ),  
+             COEF_USURE      =SIMP(statut='o',typ='R'), 
+             COEF_K          =SIMP(statut='f',typ='R',defaut=5.0E+0),  
+             COEF_C          =SIMP(statut='f',typ='R',defaut=10.0E+0),  
+           ),   
+           MATER_USURE     =SIMP(statut='f',typ='TXM'),  
+           USURE_OBST      =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           FNOR_MAXI       =SIMP(statut='f',typ='R' ),  
+           VTAN_MAXI       =SIMP(statut='f',typ='R' ),  
+         ),
+         b_edf_mz          =BLOC(condition = "LOI_USURE == 'EDF_MZ'",
+           regles=(UN_PARMI('MOBILE','MATER_USURE'), 
+                   EXCLUS('MATER_USURE','OBSTACLE'),
+                   EXCLUS('MOBILE','USURE_OBST'),),
+           MOBILE          =FACT(statut='f',
+             COEF_USURE      =SIMP(statut='f',typ='R',defaut=1.0E-13),  
+             COEF_B          =SIMP(statut='f',typ='R',defaut=1.2E+0),  
+             COEF_N          =SIMP(statut='f',typ='R',defaut=2.44E-8),  
+             COEF_S          =SIMP(statut='f',typ='R',defaut=1.14E-16),  
+           ),   
+           OBSTACLE        =FACT(statut='f',
+             COEF_USURE      =SIMP(statut='o',typ='R',defaut=1.0E-13), 
+             COEF_B          =SIMP(statut='f',typ='R',defaut=1.2E+0),  
+             COEF_N          =SIMP(statut='f',typ='R',defaut=2.44E-8),  
+             COEF_S          =SIMP(statut='f',typ='R',defaut=1.14E-16),  
+           ),   
+           MATER_USURE     =SIMP(statut='f',typ='TXM'),  
+           USURE_OBST      =SIMP(statut='f',typ='TXM',into=("OUI",)),
+         ),
+         b_tube_neuf       =BLOC(condition = "TUBE_NEUF == 'OUI'",
+            TABL_USURE      =SIMP(statut='o',typ=table_sdaster),
+            INST            =SIMP(statut='f',typ='R'),
+         ),
+         CONTACT         =SIMP(statut='f',typ='TXM',into=("TUBE_BAV","TUBE_ALESAGE","TUBE_4_ENCO",    
+                                                          "GRAPPE_ALESAGE","TUBE_3_ENCO","TUBE_TUBE",        
+                                                          "GRAPPE_1_ENCO","GRAPPE_2_ENCO")),
+         RAYON_MOBILE    =SIMP(statut='f',typ='R'),  
+         RAYON_OBST      =SIMP(statut='f',typ='R'),  
+         LARGEUR_OBST    =SIMP(statut='f',typ='R'),  
+         ANGL_INCLI      =SIMP(statut='f',typ='R'),  
+         ANGL_ISTHME     =SIMP(statut='f',typ='R'),  
+         ANGL_IMPACT     =SIMP(statut='f',typ='R'),  
+         INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),  
+         LIST_INST       =SIMP(statut='f',typ=listr8_sdaster),
+         COEF_INST       =SIMP(statut='f',typ='R',defaut=1.0E+0),  
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 07/09/2009   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.
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+
+POURSUITE=MACRO(nom="POURSUITE",op=ops.build_poursuite,repetable='n',
+                fr="Poursuite d'une étude à partir de la sauvegarde au format JEVEUX ou HDF de sa base globale",
+                sd_prod = ops.POURSUITE,
+            UIinfo={"groupes":("Gestion du travail",)},
+                op_init = ops.POURSUITE_context,fichier_ini = 1,
+         FORMAT_HDF      =SIMP(fr="sauvegarde de la base GLOBALE au format HDF",statut='f',
+                               typ='TXM',defaut="NON",into=("OUI","NON",) ),
+         PAR_LOT         =SIMP(fr="mode de traitement des commandes",statut='f',typ='TXM',
+                           into=("OUI","NON"),defaut="OUI"),
+         IMPR_MACRO      =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess",
+                           statut='f',typ='TXM',into=("OUI","NON"),defaut="NON"),
+
+         BASE            =FACT(fr="définition des paramètres associés aux bases JEVEUX",
+                               statut='f',min=1,max=2,
+           FICHIER         =SIMP(fr="nom de la base",statut='o',typ='TXM'),
+           TITRE           =SIMP(statut='f',typ='TXM'),
+           CAS             =SIMP(statut='f',typ='TXM'),
+           NMAX_ENRE       =SIMP(fr="nombre maximum d enregistrements",statut='f',typ='I'),
+           LONG_ENRE       =SIMP(fr="longueur des enregistrements",statut='f',typ='I'),
+           LONG_REPE       =SIMP(fr="longueur du répertoire",statut='f',typ='I'),
+         ),
+
+         IMPRESSION      =FACT(statut='f',min=1,max=3,
+           FICHIER         =SIMP(statut='o',typ='TXM'),
+           UNITE           =SIMP(statut='o',typ='I'),
+         ),
+
+         CATALOGUE       =FACT(statut='f',min=1,max=10,
+           FICHIER         =SIMP(statut='o',typ='TXM'),
+           TITRE           =SIMP(statut='f',typ='TXM'),
+           UNITE           =SIMP(statut='f',typ='I'),
+         ),
+
+         ERREUR          =FACT(fr="comportement en cas d'erreur",statut='f',min=1,max=1,
+           ERREUR_F        =SIMP(statut='f',typ='TXM',into=('ABORT','EXCEPTION'),defaut='ABORT'),
+         ),
+
+         DEBUG           =FACT(fr="option de déboggage reservée aux développeurs",
+                               statut='f',min=1,max=1,
+           JXVERI          =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
+                                 statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
+           SDVERI          =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+                                 statut='f',typ='TXM',into=('OUI','NON')),
+           JEVEUX          =SIMP(fr="force les déchargement sur disque",
+                                 statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
+           ENVIMA          =SIMP(fr="imprime les valeurs définies dans ENVIMA",
+                                 statut='f',typ='TXM',into=('TEST',)),
+         ),
+
+         MESURE_TEMPS     =FACT(fr="Pour choisir les mesures de temps consommé dans les commandes",
+                               statut='f',min=1,max=1,
+           NIVE_DETAIL      =SIMP(fr="niveau de détail des impressions",
+                                 statut='f',typ='I',into=(0,1,2,3),defaut=1),
+                                 # 0 : rien
+                                 # 1 : impression en fin de commande des mesures principales
+                                 # 2 : impression en fin de commande des mesures principales et secondaires
+                                 # 3 : impression des mesures principales et secondaires pour chaque pas de temps
+         ),
+
+         MEMOIRE         =FACT(fr="mode de gestion mémoire utilisé",statut='d',min=1,max=1,
+           GESTION         =SIMP(statut='f',typ='TXM',into=('COMPACTE','RAPIDE'),defaut='RAPIDE'),
+           TYPE_ALLOCATION =SIMP(statut='f',typ='I',into=(1,2,3,4),defaut=1),
+           TAILLE          =SIMP(statut='f',typ='I'),
+           TAILLE_BLOC     =SIMP(statut='f',typ='R',defaut=800.),
+           PARTITION       =SIMP(statut='f',typ='R' ),
+           DYNAMIQUE       =SIMP(statut='f',typ='I',defaut=1),
+         ),
+
+         RESERVE_CPU     =FACT(fr="reserve de temps pour terminer une execution",statut='d',max=1,
+           regles=(EXCLUS('VALE','POURCENTAGE'),),
+           VALE            =SIMP(statut='f',typ='I',val_min=0),
+#                            valeur par défaut fixée à 10. dans le FORTRAN si CODE présent
+           POURCENTAGE     =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0),
+#                           valeur par défaut fixée à 10% dans le FORTRAN
+           BORNE           =SIMP(statut='f',typ='I',val_min=0,defaut=900) ),
+#          valeur en pourcentage du temps maximum bornée à 900 secondes
+
+         CODE            =FACT("définition d'un nom pour l'ensemble d'une étude",
+                               statut='f',min=1,max=1,
+           NOM             =SIMP(statut='o',typ='TXM'),
+         ),
+
+
+         IGNORE_ALARM = SIMP(statut='f', typ='TXM', max='**', fr="Alarmes que l'utilisateur souhaite délibérément ignorer"),
+
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+PRE_GIBI=PROC(nom="PRE_GIBI",op=49,
+            UIinfo={"groupes":("Gestion du travail",)},
+              fr="Conversion d'un fichier de maillage GIBI au format Aster",
+         UNITE_GIBI      =SIMP(statut='f',typ='I',defaut=19),  
+         UNITE_MAILLAGE  =SIMP(statut='f',typ='I',defaut=20),  
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+PRE_GMSH=PROC(nom="PRE_GMSH",op=47,
+            UIinfo={"groupes":("Gestion du travail",)},
+               fr="Conversion d'un fichier de maillage GMSH au format Aster",
+         UNITE_GMSH      =SIMP(statut='f',typ='I',defaut=19),  
+         UNITE_MAILLAGE  =SIMP(statut='f',typ='I',defaut=20),  
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE MIKCHEVITCH A.MIKCHEVITCH
+PRE_IDEAS=PROC(nom="PRE_IDEAS",op=47,
+            UIinfo={"groupes":("Gestion du travail",)},
+               fr="Conversion d'un fichier universel IDEAS-SUPERTAB au format Aster",
+         UNITE_IDEAS     =SIMP(statut='f',typ='I',defaut=19),  
+         UNITE_MAILLAGE  =SIMP(statut='f',typ='I',defaut=20),  
+         CREA_GROUP_COUL =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+
+PROD_MATR_CHAM=OPER(nom="PROD_MATR_CHAM",op= 156,sd_prod=cham_no_sdaster,
+                    fr="Effectuer le produit d'une matrice par un vecteur",
+                    reentrant='n',
+            UIinfo={"groupes":("Résultats et champs",)},
+         MATR_ASSE       =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,matr_asse_pres_c ) ),
+         CHAM_NO         =SIMP(statut='o',typ=cham_no_sdaster),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+)  ;
+#& MODIF COMMANDE  DATE 12/05/2009   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.
+# ======================================================================
+# RESPONSABLE PELLET J.PELLET
+def proj_champ_prod(RESULTAT=None,CHAM_NO_REFE=None,**args ):
+    if AsType(RESULTAT) != None : return AsType(RESULTAT)
+    if CHAM_NO_REFE     != None : return cham_no_sdaster
+    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 les champs aux noeuds d'une SD résultat de type evol_xxx sur un autre maillage",
+
+
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="ELEM",
+                               into=("NUAGE_DEG_0","NUAGE_DEG_1","ELEM",) ),
+
+
+         # Méthode NUAGE_xxx :
+         #--------------------
+         b_nuage         =BLOC(condition="(METHODE=='NUAGE_DEG_1') or (METHODE=='NUAGE_DEG_0')",
+                               fr="Lissage d'un nuage de points",
+           CHAM_NO         =SIMP(statut='o',typ=cham_no_sdaster),
+           CHAM_NO_REFE    =SIMP(statut='o',typ=cham_no_sdaster),
+         ),
+
+
+
+         # Méthode ELEM :
+         #--------------------
+         b_elem          =BLOC(condition="METHODE=='ELEM'",
+                              fr="Utilisation des fonctions de forme du maillage initial",
+           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'),),
+           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",),
+           MODELE_1        =SIMP(statut='o',typ=modele_sdaster),
+           MODELE_2        =SIMP(statut='o',typ=modele_sdaster),
+
+           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."),
+
+
+           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',),),
+           ),
+
+
+           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."),
+
+         ),
+
+
+
+         # Mots clés utilisables avec les 2 méthodes :
+         #---------------------------------------------
+         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='**'),
+           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."),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 BOYERE E.BOYERE
+def matr_asse_gene_prod(MATR_ASSE,MATR_ASSE_GENE,**args):
+  if AsType(MATR_ASSE) == matr_asse_depl_r  : return matr_asse_gene_r
+  if AsType(MATR_ASSE_GENE) == matr_asse_gene_r  : return matr_asse_gene_r
+  if AsType(MATR_ASSE) == matr_asse_depl_c  : return matr_asse_gene_c
+  if AsType(MATR_ASSE_GENE) == matr_asse_gene_c  : return matr_asse_gene_c
+  raise AsException("type de concept resultat non prevu")
+
+PROJ_MATR_BASE=OPER(nom="PROJ_MATR_BASE",op=  71,sd_prod=matr_asse_gene_prod,
+                    fr="Projection d'une matrice assemblée sur une base (modale ou de RITZ)",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=(UN_PARMI('MATR_ASSE','MATR_ASSE_GENE'),),            
+         BASE            =SIMP(statut='o',typ=(mode_meca,mode_gene ) ),
+         NUME_DDL_GENE   =SIMP(statut='o',typ=nume_ddl_gene ),
+         MATR_ASSE       =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_depl_c) ),
+         MATR_ASSE_GENE  =SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c) ),
+)  ;
+
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 ANDRIAM H.ANDRIAMBOLOLONA
+def proj_mesu_modal_prod(MODELE_MESURE,**args):
+     vale=MODELE_MESURE['MESURE']
+     if  AsType(vale) == dyna_trans   : return tran_gene
+     if  AsType(vale) == dyna_harmo   : return harm_gene
+     if  AsType(vale) == mode_meca    : return mode_gene
+     if  AsType(vale) == mode_meca_c  : return mode_gene
+#     if  AsType(vale) == base_modale  : return mode_gene
+     raise AsException("type de concept resultat non prevu")
+
+PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193,
+                     sd_prod=proj_mesu_modal_prod,
+                     reentrant='n',
+            UIinfo={"groupes":("Résultats et champs",)},
+                     fr="Calcul des coordonnees généralisees de mesure experimentale relatives a une base de projection",
+
+         MODELE_CALCUL   =FACT(statut='o',
+           MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+#           BASE            =SIMP(statut='o',typ=(mode_meca,base_modale,) ),          
+           BASE            =SIMP(statut='o',typ= mode_meca, ),
+                         ),
+         MODELE_MESURE   =FACT(statut='o',
+           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",) ),
+                         ),
+         CORR_MANU       =FACT(statut='f',max='**',
+           regles=(PRESENT_PRESENT('NOEU_CALCUL','NOEU_MESURE'),),
+           NOEU_CALCUL     =SIMP(statut='f',typ=no),
+           NOEU_MESURE     =SIMP(statut='f',typ=no),
+                         ),
+         NOM_PARA        =SIMP(statut='f',typ='TXM',max='**'),
+         RESOLUTION      =FACT(statut='f',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="LU",into=("LU","SVD",) ),
+           b_svd =BLOC(condition="METHODE=='SVD'",
+                       EPS=SIMP(statut='f',typ='R',defaut=0. ),
+                      ),
+           REGUL           =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","NORM_MIN","TIK_RELA",) ),
+           b_regul =BLOC(condition="REGUL!='NON'",
+                         regles=(PRESENT_ABSENT('COEF_PONDER','COEF_PONDER_F', ),),
+                         COEF_PONDER   =SIMP(statut='f',typ='R',defaut=0.     ,max='**' ),  
+                         COEF_PONDER_F =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**' ),
+                        ),
+             ),
+
+          ); 
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE ADOBES A.ADOBES
+PROJ_SPEC_BASE=OPER(nom="PROJ_SPEC_BASE",op= 146,sd_prod=table_fonction,reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+            fr="Projecter un ou plusieurs spectres de turbulence sur une (ou plusieurs) base(s) modale(s) ",
+      regles=(UN_PARMI('BASE_ELAS_FLUI','MODE_MECA','CHAM_NO'),),
+         SPEC_TURB       =SIMP(statut='o',typ=spectre_sdaster,validators=NoRepeat(),max='**' ),
+         TOUT_CMP        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+         BASE_ELAS_FLUI  =SIMP(statut='f',typ=melasflu_sdaster ),
+         MODE_MECA       =SIMP(statut='f',typ=mode_meca ),
+         CHAM_NO         =SIMP(statut='f',typ=cham_no_sdaster),
+         FREQ_INIT       =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         FREQ_FIN        =SIMP(statut='o',typ='R',val_min=0.E+0 ),  
+         NB_POIN         =SIMP(statut='o',typ='I' ),  
+         OPTION          =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG")),
+         GROUP_MA        =SIMP(statut='f',typ=grma),
+#  Quel est le type attendu derriere  MODELE_INTERFACE         
+         MODELE_INTERFACE=SIMP(statut='f',typ=modele_sdaster),
+         VECT_X          =SIMP(statut='f',typ='R',min=3,max=3 ),  
+         VECT_Y          =SIMP(statut='f',typ='R',min=3,max=3 ),  
+         ORIG_AXE        =SIMP(statut='f',typ='R',min=3,max=3 ),  
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 BOYERE E.BOYERE
+
+PROJ_VECT_BASE=OPER(nom="PROJ_VECT_BASE",op=  72,sd_prod=vect_asse_gene,
+                    fr="Projection d'un vecteur assemblé sur une base (modale ou de RITZ)",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=(UN_PARMI('VECT_ASSE','VECT_ASSE_GENE'),),              
+         BASE            =SIMP(statut='o',typ=(mode_meca,mode_gene) ),
+         NUME_DDL_GENE   =SIMP(statut='o',typ=nume_ddl_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 ),
+)  ;
+#& MODIF COMMANDE  DATE 24/08/2009   AUTEUR GENIAUT S.GENIAUT 
+#            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.        
+# ======================================================================
+# RESPONSABLE GALENNE E.GALENNE
+
+
+from Macro.propa_fiss_ops import propa_fiss_ops
+
+def propa_fiss_prod(self,**args):
+  if  args.has_key('MA_TOT2')  : 
+      MA_TOT2 = args['MA_TOT2']
+      self.type_sdprod(MA_TOT2,maillage_sdaster)
+  if args.has_key('MA_XFEM2')  :
+      MA_XFEM2 = args['MA_XFEM2']
+      self.type_sdprod(MA_XFEM2,maillage_sdaster)
+  if args.has_key('FISSURE') :
+      FISSURE = args['FISSURE']
+      for numfis in FISSURE :
+          self.type_sdprod(numfis['FISS_PROPAGEE'],fiss_xfem)
+  return None
+
+PROPA_FISS=MACRO(nom="PROPA_FISS",op=propa_fiss_ops,sd_prod=propa_fiss_prod,
+            fr="Propagation de fissure avec X-FEM",reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+
+        METHODE_PROPA = SIMP(statut='o',typ='TXM',
+                               into=("SIMPLEXE","UPWIND","MAILLAGE","INITIALISATION") ),
+            
+        b_hamilton = BLOC(condition="(METHODE_PROPA=='SIMPLEXE') or (METHODE_PROPA=='UPWIND') ",
+              MODELE        = SIMP(statut='o',typ=modele_sdaster),
+              TEST_MAIL     = SIMP(statut='f',typ='TXM',into=("NON","CONSTANT","LINEAIRE",),defaut="NON"),
+              DA_MAX        = SIMP(statut='o',typ='R',max=1),
+              RAYON         = SIMP(statut='o',typ='R',),
+              b_propagation = BLOC(condition = "TEST_MAIL == 'NON' ",
+                                   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),
+                                                    ),
+                                   LOI_PROPA = FACT(statut='o',max=1,
+                                                    LOI     = SIMP(statut='o',typ='TXM',into=("PARIS",),defaut="PARIS"),
+                                                    b_paris = BLOC(condition = "LOI=='PARIS'",
+                                                                   C = SIMP(statut='o',typ='R',),
+                                                                   N = SIMP(statut='o',typ='R',),
+                                                                   M = SIMP(statut='o',typ='R',),
+                                                                  ),
+                                                    MATER = SIMP(statut='o',typ=mater_sdaster,),
+                                                   ),
+                                   COMP_LINE = FACT(statut='f',max=1, 
+                                                    COEF_MULT_MINI = SIMP(statut='o',typ='R',),
+                                                    COEF_MULT_MAXI = SIMP(statut='o',typ='R',),
+                                                   ),
+                                   ),
+              b_test_const  = BLOC(condition = "TEST_MAIL == 'CONSTANT' ",
+                                   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),
+                                  ),
+
+                         ),
+
+        b_maillage    =BLOC(condition="(METHODE_PROPA=='MAILLAGE')",
+               MA_STRUC       = SIMP(statut='o',typ=maillage_sdaster), 
+               MA_XFEM1       = SIMP(statut='o',typ=maillage_sdaster), 
+               FISSURE1       = SIMP(statut='o',typ=fiss_xfem),
+               DTAN_ORIG      = SIMP(statut='f',typ='R',max=3),
+               DTAN_EXTR      = SIMP(statut='f',typ='R',max=3),
+               METHODE_POSTK  = SIMP(statut='f',typ='I',into=(1,2,3),max=1),
+               ITERATION      = SIMP(statut='o',typ='I',max=1),
+               HYPOTHESE      = SIMP(statut='f',typ='TXM',into=("PLAN","NON_PLAN"),defaut="NON_PLAN"),
+               MA_XFEM2       = SIMP(statut='f',typ=CO), 
+               MA_TOT2        = SIMP(statut='o',typ=CO), 
+               TABLE          = SIMP(statut='o',typ=table_sdaster,max=1),
+                                ),      
+                                    
+        b_init    =BLOC(condition="(METHODE_PROPA=='INITIALISATION')",
+               MA_STRUC    = SIMP(statut='o',typ=maillage_sdaster), 
+               FORM_FISS   = SIMP(statut='o',typ='TXM', into=("DEMI_DROITE","DEMI_PLAN"), ),
+               PFON        = SIMP(statut='f',typ='R',max=3),
+               DTAN        = SIMP(statut='o',typ='R',min=3,max=3),
+               POINT_ORIG        = SIMP(statut='f',typ='R',min=3,max=3),
+               POINT_EXTR        = SIMP(statut='f',typ='R',min=3,max=3),
+               NB_POINT_FOND   = SIMP(statut='f',typ='I',),
+               regles=(PRESENT_PRESENT('POINT_ORIG','POINT_EXTR',),
+                       UN_PARMI('PFON','POINT_ORIG'),),
+               MA_TOT2     = SIMP(statut='o',typ=CO), 
+               MA_XFEM2       = SIMP(statut='f',typ=CO), 
+                                ),          
+
+        b_loi_et_comp_line=BLOC(condition="(METHODE_PROPA=='MAILLAGE') or (METHODE_PROPA=='INITIALISATION') ",
+                              LOI_PROPA = FACT(statut='f',max=1,
+                                          LOI = SIMP(statut='o',typ='TXM',into=("PARIS",),defaut="PARIS"),
+                                          b_paris  =BLOC( condition = "LOI=='PARIS'",
+                                                       C        = SIMP(statut='f',typ='R',),
+                                                       M        = SIMP(statut='o',typ='R',),
+                                                       DA_MAX   = SIMP(statut='f',typ='R',max=1),
+                                                       regles=(UN_PARMI('C','DA_MAX'),),
+                                                          ),
+                                               ),
+                              ),
+
+        INFO = SIMP(statut='f',typ='I',defaut=1,into=(0,1,2)),
+)
+
+#& MODIF COMMANDE  DATE 24/08/2009   AUTEUR GENIAUT S.GENIAUT 
+#            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 GENIAUT S.GENIAUT
+
+PROPA_XFEM=OPER(nom="PROPA_XFEM",op=10,sd_prod=fiss_xfem,reentrant='n',
+                UIinfo={"groupes":("Modélisation",)},
+                fr="Propagation de fissure avec X-FEM",
+    
+    MODELE        =SIMP(statut='o',typ=modele_sdaster),
+
+    GRILLE_AUX    =SIMP(statut='f',typ=modele_sdaster),
+
+    TEST_MAIL     =SIMP(statut='f',typ='TXM',into=("NON","CONSTANT","LINEAIRE",),defaut="NON"),
+
+    DA_MAX        =SIMP(statut='o',typ='R'),
+
+    FISS_PROP     =SIMP(statut='o',typ=fiss_xfem),
+
+    LISTE_FISS    =SIMP(statut='o',typ=fiss_xfem,min=1,max='**'),
+        
+    b_propa =BLOC( condition = "TEST_MAIL == 'NON' ",
+                   NB_POINT_FOND =SIMP(statut='f',typ='I',min=1,max='**'),
+                   TABLE         =SIMP(statut='o',typ=table_sdaster,min=1,max='**'),
+                   LOI_PROPA     =FACT(statut='o',max=1,
+                   LOI            =SIMP(statut='o',typ='TXM',into=("PARIS",),defaut="PARIS"),
+                   b_paris        =BLOC( condition = "LOI=='PARIS'",
+                     C            =SIMP(statut='o',typ='R',),
+                     N            =SIMP(statut='o',typ='R',),
+                     M            =SIMP(statut='o',typ='R',),
+                     E            =SIMP(statut='o',typ='R',),
+                     NU           =SIMP(statut='o',typ='R',),),
+                       ),
+
+                   COMP_LINE      =FACT(statut='f',max=1, 
+                     COEF_MULT_MINI        =SIMP(statut='o',typ='R',),
+                     COEF_MULT_MAXI        =SIMP(statut='o',typ='R',),
+                       ),
+         ),
+
+    b_test_mail_const =BLOC( condition = "TEST_MAIL == 'CONSTANT' ",
+                             FISS_INITIALE =SIMP(statut='o',typ=fiss_xfem,max=1),
+                             DISTANCE      =SIMP(statut='o',typ='R',max=1),
+                             TOLERANCE     =SIMP(statut='o',typ='R',max=1),
+                           ),
+            
+    RAYON          =SIMP(statut='o',typ='R',),
+          
+    METHODE =SIMP(statut='f',typ='TXM',into=("SIMPLEXE","UPWIND",),defaut="UPWIND"),
+
+    INFO           =SIMP(statut='f',typ='I',defaut= 0,into=(0,1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 20/07/2009   AUTEUR GENIAUT S.GENIAUT 
+#            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.        
+# ======================================================================
+# RESPONSABLE GENIAUT S.GENIAUT
+from Macro.raff_xfem_ops import raff_xfem_ops
+RAFF_XFEM=MACRO(nom="RAFF_XFEM",op=raff_xfem_ops,sd_prod=cham_no_sdaster,
+                   fr="Calcul de la distance au fond de fissure le plus proche",
+                   reentrant='n',
+            UIinfo={"groupes":("Rupture",)},
+
+    FISSURE       =SIMP(statut='o',typ=fiss_xfem,min=1,max='**',),
+    INFO          =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE PARROT A.PARROT
+RECA_WEIBULL=OPER(nom="RECA_WEIBULL",op= 197,sd_prod=table_sdaster,
+                     fr="Recaler les paramètres du modèle de WEIBULL sur des données expérimentales",reentrant='n',
+            UIinfo={"groupes":("Post traitements",)},
+         LIST_PARA       =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=2,into=("SIGM_REFE","M",) ),
+         RESU            =FACT(statut='o',max='**',
+           regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST',),
+                   AU_MOINS_UN('TOUT','GROUP_MA','MAILLE', ),),
+           EVOL_NOLI       =SIMP(statut='o',typ=(evol_noli) ),
+           MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+           CHAM_MATER      =SIMP(statut='o',typ=(cham_mater) ),
+           TEMPE           =SIMP(statut='f',typ='R' ),
+           LIST_INST_RUPT  =SIMP(statut='o',typ='R',validators=NoRepeat(),max='**' ),
+           TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NUME_ORDRE      =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) ),
+           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='**'),
+           COEF_MULT       =SIMP(statut='f',typ='R',defaut= 1.E0 ),
+                         ),
+         OPTION          =SIMP(statut='f',typ='TXM',defaut="SIGM_ELGA",into=("SIGM_ELGA","SIGM_ELMOY",) ),
+         CORR_PLAST      =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="MAXI_VRAI",into=("MAXI_VRAI","REGR_LINE",) ),
+         INCO_GLOB_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+         ITER_GLOB_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ,) ),
+                       )  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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
+def recu_fonction_prod(RESULTAT=None,TABLE=None,RESU_GENE=None,
+                       BASE_ELAS_FLUI=None,CHAM_GD=None,NAPPE=None,
+                       NOM_PARA_TABL=None,**args):
+   if AsType(RESULTAT)  == dyna_harmo or \
+      AsType(RESU_GENE) == harm_gene or \
+      (TABLE != None and NOM_PARA_TABL == "FONCTION_C"):
+      return fonction_c
+   else:
+      return fonction_sdaster
+
+RECU_FONCTION=OPER(nom="RECU_FONCTION",op=90,sd_prod=recu_fonction_prod,
+                   fr="Extraire sous forme d'une fonction, l'évolution d'une grandeur en fonction d'une autre",
+                   reentrant='f',
+            UIinfo={"groupes":("Fonction",)},
+         regles=(UN_PARMI('CHAM_GD','RESULTAT','RESU_GENE','TABLE','BASE_ELAS_FLUI','NAPPE'),),
+
+         CHAM_GD         =SIMP(statut='f',typ=(cham_no_sdaster,cham_elem,),),
+         RESULTAT        =SIMP(statut='f',typ=resultat_sdaster),
+         RESU_GENE       =SIMP(statut='f',typ=(tran_gene, mode_gene, harm_gene)),
+         TABLE           =SIMP(statut='f',typ=(table_sdaster,table_fonction)),
+         BASE_ELAS_FLUI  =SIMP(statut='f',typ=melasflu_sdaster),
+         NAPPE           =SIMP(statut='f',typ=nappe_sdaster),
+
+# ======= SENSIBILITE =================================================
+         b_sensibilite   =BLOC(condition="RESULTAT != None",
+                                 fr="Définition des paramètres de sensibilité",
+                                 ang="Definition of sensitivity parameters",
+           regles=(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"),),
+# ======= ACCES A LA SD RESULTAT =================================================
+         b_acces = BLOC ( condition = "(RESULTAT != None) or (RESU_GENE != None)",
+                          fr="acces a une SD résultat",
+# on ne peut pas mettre de regles, le défaut TOUT_ORDRE est pris en compte dans le fortran
+           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 ),
+           TOUT_INST       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           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='**'),
+           b_prec = BLOC ( condition = "(INST != None) or (LIST_INST != None) or (FREQ != None) or (LIST_FREQ != 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',),),
+             INTERP_NUME     =SIMP(statut='f',typ='TXM',into=("NON","LIN") ),
+           ),
+         ),
+# ======= BASE_ELAS_FLUI =================================================
+         b_base_elas_flui = BLOC ( condition = "BASE_ELAS_FLUI != None",
+                                   fr="Récupération de la fonction à partir d un concept melasflu",
+           regles=(UN_PARMI('TOUT_ORDRE','NUME_ORDRE'),),
+           TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+           NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+           NUME_MODE       =SIMP(statut='o',typ='I' ),
+           PARA_X          =SIMP(statut='o',typ='TXM',into=("VITE_FLU",) ),
+           PARA_Y          =SIMP(statut='o',typ='TXM',into=("FREQ","AMOR") ),
+         ),
+
+# ======= TABLE =================================================
+         b_table = BLOC ( condition = "TABLE != None",
+                          fr="Récupération de la fonction à partir d un concept table",
+                          regles=(UN_PARMI('PARA_X','NOM_PARA_TABL'),
+                                  PRESENT_PRESENT('PARA_X','PARA_Y'),),
+           PARA_X        = SIMP(statut='f',typ='TXM',
+                                 fr="1ère colonne de la table qui définit la fonction à récupérer", ),
+           PARA_Y        = SIMP(statut='f',typ='TXM',
+                                 fr="2ème colonne de la table qui définit la fonction à récupérer", ),
+           #b_tabl_fonc = BLOC(condition = "AsType(TABLE) == table_fonction",
+           NOM_PARA_TABL = SIMP(statut='f',typ='TXM',into=("FONCTION","FONCTION_C"),
+                                fr="Nom du paramètre de la table contenant la fonction" ),
+           #),
+
+           FILTRE        = FACT(statut='f',max='**',
+              NOM_PARA        =SIMP(statut='o',typ='TXM' ),
+              CRIT_COMP       =SIMP(statut='f',typ='TXM',defaut="EQ",
+                                    into=("EQ","LT","GT","NE","LE","GE","VIDE",
+                                          "NON_VIDE","MAXI","ABS_MAXI","MINI","ABS_MINI") ),
+              b_vale          =BLOC(condition = "(CRIT_COMP in ('EQ','NE','GT','LT','GE','LE'))",
+                 regles=(UN_PARMI('VALE','VALE_I','VALE_K','VALE_C',),),
+                 VALE            =SIMP(statut='f',typ='R' ),
+                 VALE_I          =SIMP(statut='f',typ='I' ),
+                 VALE_C          =SIMP(statut='f',typ='C' ),
+                 VALE_K          =SIMP(statut='f',typ='TXM' ),),
+
+              CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+              PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           ),
+         ),
+
+# ======= RESULTAT =================================================
+         b_resu = BLOC ( condition = "RESULTAT != None", fr="Opérandes en cas de RESULTAT",
+                         regles=(UN_PARMI('NOM_CHAM','NOM_PARA_RESU'),),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+           NOM_PARA_RESU   =SIMP(statut='f',typ='TXM' ),
+           b_cham = BLOC ( condition = "NOM_CHAM != None",
+                           regles=(AU_MOINS_UN('MAILLE','GROUP_MA','GROUP_NO','NOEUD'),
+                                   PRESENT_ABSENT('POINT','NOEUD','GROUP_NO'),
+                                   PRESENT_ABSENT('SOUS_POINT','NOEUD','GROUP_NO'),
+                                   EXCLUS('GROUP_MA','MAILLE'),
+                                   EXCLUS('GROUP_NO','NOEUD'),),
+             NOM_CMP         =SIMP(statut='o',typ='TXM' ),
+             MAILLE          =SIMP(statut='f',typ=ma),
+             GROUP_MA        =SIMP(statut='f',typ=grma),
+             NOEUD           =SIMP(statut='f',typ=no),
+             GROUP_NO        =SIMP(statut='f',typ=grno),
+             POINT           =SIMP(statut='f',typ='I' ),
+             SOUS_POINT      =SIMP(statut='f',typ='I' ),
+           ),
+         ),
+
+# ======= RESU_GENE =================================================
+         b_tran_gene = BLOC ( condition = "AsType(RESU_GENE) == tran_gene",
+                              fr="Récupération d'une fonction à partir d un concept TRAN_GENE",
+                              regles=(UN_PARMI('NOM_CHAM','NOEUD_CHOC','GROUP_NO_CHOC'),),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',into=("DEPL","VITE","ACCE","PTEM") ),
+             NOEUD_CHOC      =SIMP(statut='f',typ=no),
+             GROUP_NO_CHOC   =SIMP(statut='f',typ=grno),
+           b_cham = BLOC ( condition = "(NOM_CHAM=='DEPL') or (NOM_CHAM=='VITE') or (NOM_CHAM=='ACCE')",
+                           regles=(UN_PARMI('GROUP_NO','NOEUD'),
+                                   EXCLUS('MULT_APPUI','CORR_STAT'),),
+             NOM_CMP         =SIMP(statut='o',typ='TXM' ),
+             NOEUD           =SIMP(statut='f',typ=no),
+             GROUP_NO        =SIMP(statut='f',typ=grno),
+             MULT_APPUI      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             CORR_STAT       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             ACCE_MONO_APPUI =SIMP(statut='f',typ=(fonction_sdaster,formule)),
+           ),
+           b_choc = BLOC ( condition = "(NOEUD_CHOC != None) or (GROUP_NO_CHOC != None)",
+                           regles=(PRESENT_PRESENT('SOUS_STRUC','INTITULE'),),
+             PARA_X          =SIMP(statut='o',typ='TXM',
+                              into=("INST","FN","FT1","FT2","VN","VT1","VT2","DXLOC","DYLOC","DZLOC") ),
+             PARA_Y          =SIMP(statut='o',typ='TXM',
+                              into=("INST","FN","FT1","FT2","VN","VT1","VT2","DXLOC","DYLOC","DZLOC") ),
+             LIST_PARA       =SIMP(statut='f',typ=listr8_sdaster ),
+             INTITULE        =SIMP(statut='f',typ='TXM' ),
+             SOUS_STRUC      =SIMP(statut='f',typ='TXM' ),
+           ),
+         ),
+         b_harm_gene = BLOC ( condition = "AsType(RESU_GENE)==harm_gene",
+                              fr="Récupération d'une fonction à partir d un concept HARM_GENE",
+                              regles=(UN_PARMI('NOM_CHAM','NOM_PARA_RESU'),),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+             NOM_PARA_RESU   =SIMP(statut='f',typ='TXM' ),
+           b_cham = BLOC ( condition = "NOM_CHAM != None",
+                           regles=(UN_PARMI('NUME_CMP_GENE','NOM_CMP'),),
+             NUME_CMP_GENE   =SIMP(statut='f',typ='I' ),
+             NOM_CMP         =SIMP(statut='f',typ='TXM' ),
+             b_cmp = BLOC ( condition = "NOM_CMP != None",
+                            regles=(UN_PARMI('NOEUD','GROUP_NO'),),
+               NOEUD         =SIMP(statut='f',typ=no),
+               GROUP_NO      =SIMP(statut='f',typ=grno),
+             ),
+           ),
+         ),
+         b_mode_gene = BLOC ( condition = "AsType(RESU_GENE)==mode_gene",
+                              fr="Récupération d'une fonction à partir d un concept MODE_GENE",
+                              regles=(UN_PARMI('NOM_CHAM','NOM_PARA_RESU'),),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+             NOM_PARA_RESU   =SIMP(statut='f',typ='TXM' ),
+           b_cham = BLOC ( condition = "NOM_CHAM != None",
+                           regles=(UN_PARMI('NUME_CMP_GENE','NOM_CMP'),),
+             NUME_CMP_GENE   =SIMP(statut='f',typ='I' ),
+             NOM_CMP         =SIMP(statut='f',typ='TXM' ),
+             b_cmp = BLOC ( condition = "NOM_CMP != None",
+                            regles=(UN_PARMI('NOEUD','GROUP_NO'),
+                                    UN_PARMI('SQUELETTE','SOUS_STRUC'),),
+               NOEUD         =SIMP(statut='f',typ=no),
+               GROUP_NO      =SIMP(statut='f',typ=grno),
+               SQUELETTE     =SIMP(statut='f',typ=squelette ),
+               SOUS_STRUC    =SIMP(statut='f',typ='TXM' ),  
+             ),
+           ),
+         ),
+
+# ======= CHAM_GD =================================================
+         b_cham_gd = BLOC ( condition = "(CHAM_GD != None)", fr="Opérandes en cas de CHAM_GD",
+                            regles=(AU_MOINS_UN('MAILLE','GROUP_MA','GROUP_NO','NOEUD'),
+                                    PRESENT_ABSENT('POINT','NOEUD','GROUP_NO'),
+                                    PRESENT_ABSENT('SOUS_POINT','NOEUD','GROUP_NO'),
+                                    EXCLUS('GROUP_MA','MAILLE'),
+                                    EXCLUS('GROUP_NO','NOEUD'),),
+           NOM_CMP         =SIMP(statut='o',typ='TXM' ),
+           MAILLE          =SIMP(statut='f',typ=ma),
+           GROUP_MA        =SIMP(statut='f',typ=grma),
+           NOEUD           =SIMP(statut='f',typ=no),
+           GROUP_NO        =SIMP(statut='f',typ=grno),
+           POINT           =SIMP(statut='f',typ='I' ),
+           SOUS_POINT      =SIMP(statut='f',typ='I' ),
+         ),
+
+# ======= NAPPE =================================================
+         b_nappe = BLOC ( condition = "(NAPPE != None)", fr="Opérandes en cas de NAPPE",
+         VALE_PARA_FONC  =SIMP(statut='o',typ='R' ),
+         PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+         CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+         ),
+
+# ======= SURCHARGE DES ATTRIBUTS =================================================
+         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") ),
+         PROL_DROITE     =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
+         PROL_GAUCHE     =SIMP(statut='f',typ='TXM',into=("CONSTANT","LINEAIRE","EXCLU") ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
+)  ;
+#& MODIF COMMANDE  DATE 30/09/2008   AUTEUR REZETTE C.REZETTE 
+#            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 BOYERE E.BOYERE
+RECU_GENE=OPER(nom="RECU_GENE",op=  76,sd_prod=vect_asse_gene,reentrant='n',
+            UIinfo={"groupes":("Résultats et champs",)},
+               fr="Extraire d'un champ de grandeur (déplacements, vitesses ou accélérations) à partir de résultats"
+                  +" en coordonnées généralisées",
+         RESU_GENE       =SIMP(statut='o',typ=tran_gene ),
+         INST            =SIMP(statut='o',typ='R' ),
+         NOM_CHAM        =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE","ACCE") ),
+         INTERPOL        =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","LIN") ),
+         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 COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+RECU_TABLE=OPER(nom="RECU_TABLE",op= 174,sd_prod=table_sdaster,
+         fr="Récupérer dans une table les valeurs d'un paramètre d'une SD Résultat ou d'extraire une table contenue"
+            +" dans une autre SD pour celles qui le permettent",
+         UIinfo={"groupes":("Résultats et champs",)},reentrant='n',
+         CO              =SIMP(statut='o',typ=assd),
+         regles=(UN_PARMI('NOM_TABLE','NOM_PARA')),
+         NOM_TABLE       =SIMP(statut='f',typ='TXM' ),
+         NOM_PARA        =SIMP(statut='f',typ='TXM',max='**'),  
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),  
+)  ;
+#& MODIF COMMANDE  DATE 11/08/2009   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            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 PELLET J.PELLET
+
+RESOUDRE=OPER(nom="RESOUDRE",op=15,sd_prod=cham_no_sdaster,reentrant='f',
+               fr="Résolution par méthode directe un système d'équations linéaires préalablement factorisé par FACT_LDLT"+
+                  "ou Résolution d'un système linéaire par la méthode du gradient conjugué préconditionné",
+               UIinfo={"groupes":("Résolution",)},
+         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_NO         =SIMP(statut='o',typ=cham_no_sdaster),
+         CHAM_CINE       =SIMP(statut='f',typ=cham_no_sdaster),
+
+         # mot-clé commun aux solveurs MUMPS, GCPC et PETSc:
+         RESI_RELA       =SIMP(statut='f',typ='R',defaut=1.E-6),
+         
+         # mot-clé pour les posttraitements de la phase de solve de MUMPS
+         POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),
+         
+         # mot-clé commun aux solveurs GCPC et PETSc:
+         NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+         MATR_PREC       =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ),
+
+         # mots-clés pour solveur PETSc:
+         ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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.        
+# ======================================================================
+ 
+# RESPONSABLE DEVESA G.DEVESA
+def rest_cond_tran_prod(RESULTAT,**args ):
+ 
+  if AsType(RESULTAT) == evol_noli  : return dyna_trans
+  if AsType(RESULTAT) == dyna_trans : return dyna_trans
+
+  raise AsException("type de concept resultat non prevu")
+
+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',
+            UIinfo={"groupes":("Matrices/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) ),
+         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),
+         TOUT_INST       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),  
+         LIST_INST       =SIMP(statut='f',typ=listr8_sdaster ),
+         TOUT_ORDRE      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         NUME_ORDRE      =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
+         CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("ABSOLU","RELATIF") ),
+         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',),),
+         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",) ),),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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.        
+# ======================================================================
+
+# RESPONSABLE BOYERE E.BOYERE
+
+def rest_gene_phys_prod(RESU_GENE,**args ):
+  if AsType(RESU_GENE) == tran_gene : return dyna_trans
+  if AsType(RESU_GENE) == mode_gene : return mode_meca
+  if AsType(RESU_GENE) == harm_gene : return dyna_harmo
+  
+  raise AsException("type de concept resultat non prevu")
+
+REST_GENE_PHYS=OPER(nom="REST_GENE_PHYS",op=  75,sd_prod=rest_gene_phys_prod,
+                    fr="Restituer dans la base physique des résultats en coordonnées généralisées",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+        regles=(
+                EXCLUS('INST','LIST_INST','TOUT_INST',
+                       'TOUT_ORDRE','NUME_ORDRE','NUME_MODE',),
+                EXCLUS('FREQ','LIST_FREQ'),
+                EXCLUS('MULT_APPUI','CORR_STAT'),
+                EXCLUS('MULT_APPUI','NOEUD','GROUP_NO'),
+                EXCLUS('CORR_STAT','NOEUD','GROUP_NO'),             
+                EXCLUS('NOEUD','GROUP_NO'),
+                EXCLUS('MAILLE','GROUP_MA'),
+                PRESENT_PRESENT('ACCE_MONO_APPUI','DIRECTION'),),
+         RESU_GENE       =SIMP(statut='f',typ=(tran_gene,mode_gene,harm_gene) ), 
+         MODE_MECA       =SIMP(statut='f',typ=mode_meca ),
+         NUME_DDL        =SIMP(statut='f',typ=nume_ddl_sdaster ),
+         TOUT_INST       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         INST            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), 
+         LIST_INST       =SIMP(statut='f',typ=listr8_sdaster ),
+         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='**' ), 
+         FREQ            =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ),  
+         LIST_FREQ       =SIMP(statut='f',typ=listr8_sdaster ),
+         CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("ABSOLU","RELATIF") ),
+         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',),),
+         INTERPOL        =SIMP(statut='f',typ='TXM',defaut="NON",into=("NON","LIN") ),
+         MULT_APPUI      =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         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",) ),),
+         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='**'),
+         MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+         ACCE_MONO_APPUI =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+         DIRECTION       =SIMP(statut='f',typ='R',min=3,max=3 ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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.        
+# ======================================================================
+
+# RESPONSABLE CORUS M.CORUS
+def rest_sous_struc_prod(RESU_GENE,RESULTAT,**args ):
+  if AsType(RESU_GENE) == tran_gene : return dyna_trans
+  if AsType(RESU_GENE) == mode_gene : return mode_meca
+  if AsType(RESU_GENE) == mode_cycl : return mode_meca
+  if AsType(RESU_GENE) == harm_gene : return dyna_harmo
+  if AsType(RESULTAT)  == evol_noli      : return evol_noli
+  if AsType(RESULTAT)  == dyna_trans     : return dyna_trans
+  if AsType(RESULTAT)  == mode_meca      : return mode_meca
+  raise AsException("type de concept resultat non prevu")
+
+REST_SOUS_STRUC=OPER(nom="REST_SOUS_STRUC",op=  77,sd_prod=rest_sous_struc_prod,
+          fr="Restituer dans la base physique des résultats obtenus par sous-structuration",
+                    reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+        regles=(UN_PARMI('RESU_GENE','RESULTAT'),
+# ajout d'une regle de Ionel et Nicolas:
+#                UN_PARMI('NOM_CHAM','TOUT_CHAM'),
+#
+              EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','TOUT_INST','NUME_MODE',
+                     'FREQ', 'LIST_FREQ'),
+#  Doc U à revoir
+              EXCLUS('NOEUD','GROUP_NO'),
+              EXCLUS('MAILLE','GROUP_MA'),
+              PRESENT_PRESENT('RESULTAT','SQUELETTE'),
+
+                ),
+         RESULTAT        =SIMP(statut='f',typ=(evol_noli,dyna_trans,
+                                            mode_meca) ),
+         RESU_GENE       =SIMP(statut='f',typ=(tran_gene,mode_gene,mode_cycl,harm_gene) ),
+         NUME_DDL        =SIMP(statut='f',typ=nume_ddl_sdaster ),
+         MODE_MECA       =SIMP(statut='f',typ=mode_meca ),
+         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='**' ),  
+         TOUT_INST       =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+         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 ),
+         CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("ABSOLU","RELATIF") ),
+         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',),),
+         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",) ),),
+         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='**'),
+         MAILLE          =SIMP(statut='f',typ=ma  ,validators=NoRepeat(),max='**'),
+         CYCLIQUE    =FACT(statut='f',max='**',
+           NB_SECTEUR      =SIMP(statut='f',typ='I',validators=NoRepeat(),max=1 ),
+           NUME_DIAMETRE    =SIMP(statut='f',typ='I',validators=NoRepeat(),max=1 ),
+           RESULTAT2       =SIMP(statut='f',typ=(evol_elas,evol_noli,dyna_trans,evol_char,
+                                               mode_meca) ),
+         ),
+
+         SQUELETTE       =SIMP(statut='f',typ=squelette ),
+         SOUS_STRUC      =SIMP(statut='f',typ='TXM' ),  
+         SECTEUR         =SIMP(statut='f',typ='I',defaut= 1 ),  
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 11/05/2009   AUTEUR NISTOR I.NISTOR 
+#            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 ADOBES A.ADOBES
+REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_fonction,
+                    reentrant='n',
+            fr="Calculer la réponse d'une structure dans la base physique",
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=(AU_MOINS_UN('BASE_ELAS_FLUI','MODE_MECA'),),        
+         BASE_ELAS_FLUI  =SIMP(statut='f',typ=melasflu_sdaster ),
+         MODE_MECA       =SIMP(statut='f',typ=mode_meca,),
+         BANDE           =SIMP(statut='f',typ='R',min=2,validators=NoRepeat(),max=2    ),  
+         NUME_ORDRE      =SIMP(statut='f',typ='I'      ,validators=NoRepeat(),max='**' ),
+         TOUT_ORDRE       =SIMP(statut='f',typ='TXM',defaut="NON",  into=("OUI","NON")  ),
+         INTE_SPEC_GENE  =SIMP(statut='o',typ=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") ),
+         MODE_STAT       =SIMP(statut='f',typ=mode_meca ),
+         EXCIT           =FACT(statut='f',
+           NOEUD           =SIMP(statut='o',typ=no   ,max='**'),
+           NOM_CMP         =SIMP(statut='o',typ='TXM',max='**'),  
+         ),
+         MOUVEMENT       =SIMP(statut='f',typ='TXM',defaut="ABSOLU",into=("RELATIF","ABSOLU","DIFFERENTIEL") ),
+         OPTION          =SIMP(statut='f',typ='TXM',defaut="DIAG_DIAG",    
+                               into=("DIAG_TOUT","DIAG_DIAG","TOUT_TOUT","TOUT_DIAG") ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),  
+)  ;
+#& MODIF COMMANDE  DATE 06/10/2008   AUTEUR DEVESA G.DEVESA 
+#            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.        
+# ======================================================================
+# RESPONSABLE DEVESA G.DEVESA
+def rest_spec_temp_prod(RESU_GENE,RESULTAT,**args):
+  if AsType(RESULTAT) == dyna_harmo    : return dyna_trans
+  if AsType(RESU_GENE) == harm_gene    : return tran_gene
+  if AsType(RESULTAT) == dyna_trans    : return dyna_harmo
+  if AsType(RESU_GENE) == tran_gene    : return harm_gene
+  raise AsException("type de concept resultat non prevu")
+
+
+REST_SPEC_TEMP=OPER(nom="REST_SPEC_TEMP",op=181,sd_prod=rest_spec_temp_prod,
+              fr="Transformée de Fourier d'un résultat",
+              reentrant='n',
+            UIinfo={"groupes":("Matrices/vecteurs",)},
+         regles=UN_PARMI('RESU_GENE','RESULTAT'),
+         RESU_GENE       =SIMP(statut='f',typ=(harm_gene,tran_gene,) ),
+         RESULTAT        =SIMP(statut='f',typ=(dyna_harmo,dyna_trans,) ),
+         METHODE         =SIMP(statut='f',typ='TXM',defaut="PROL_ZERO",into=("PROL_ZERO","TRONCATURE") ),
+         SYMETRIE        =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         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 07/07/2009   AUTEUR REZETTE C.REZETTE 
+#            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 PROIX J.M.PROIX
+# -*- coding: iso-8859-1 -*-
+
+from Macro.simu_point_mat_ops import simu_point_mat_ops
+
+SIMU_POINT_MAT=MACRO(nom="SIMU_POINT_MAT", op=simu_point_mat_ops,sd_prod=table_sdaster,
+                   UIinfo={"groupes":("Résolution",)},
+                   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_POUTRE_GR","CABLE","ELAS_HYPER")),
+           DEFORMATION     =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GREEN","GREEN_GR",) ),
+         ),
+   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.
+   ANGLE      =SIMP(statut='f',typ='R',max=1, defaut=0.),
+# --MASSIF : orientation du materiau (monocristal, orthotropie)
+   MASSIF          =FACT(statut='f',max='**',
+     regles=(UN_PARMI('ANGL_REP','ANGL_EULER'),),
+     ANGL_REP        =SIMP(statut='f',typ='R',max=3),
+     ANGL_EULER      =SIMP(statut='f',typ='R',min=3,max=3),
+   ),
+   INCREMENT       =C_INCREMENT(),
+   NEWTON          =C_NEWTON(),
+   RECH_LINEAIRE   =C_RECH_LINEAIRE(),                                      
+   CONVERGENCE     =C_CONVERGENCE(),
+   SUIVI_DDL      = FACT(statut='f',max=4,                                                                   
+       NUME_SUIVI      =SIMP(statut='o',typ='I' ,min=1,max=4),                                               
+       NOM_CHAM        =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,                               
+                             into=("DEPL","SIEF_ELGA","VARI_ELGA",)),                                        
+       NOM_CMP         =SIMP(statut='o',typ='TXM',max=1 ),                                                   
+   ),                                                                                                        
+   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.E-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","LANL_ELGA")),
+            ),       
+   MODELISATION  =SIMP(statut='f',typ='TXM',defaut="3D",validators=NoRepeat(),max=1,
+                       into=("3D","C_PLAN","D_PLAN",)),                                                       
+   b_3D = BLOC(condition="MODELISATION ==  '3D'",
+                       fr="Trajets de chargement en 3D",                    
+          SIGM_IMPOSE=FACT(statut='f',
+                 SIXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 SIYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 SIZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 SIXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 SIXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 SIYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                            ),
+          EPSI_IMPOSE=FACT(statut='f',
+                 EPXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 EPYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 EPZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 EPXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 EPXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                 EPYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                            ),
+            ),
+            
+   b_2D = BLOC(condition="MODELISATION !=  '3D'",
+                    fr="Trajets de chargement en 2D",
+                    
+         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) ),
+                SIXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                           ),
+         EPSI_IMPOSE=FACT(statut='f',
+                EPXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                EPYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                EPXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+                           ),
+             ),
+
+   b_3Dini = BLOC(condition="MODELISATION ==  '3D'",
+                      fr="Etat initial en 3D",                    
+          SIGM_INIT=FACT(statut='f',
+                 SIXX = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                 SIYY = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                 SIZZ = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                 SIXY = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                 SIXZ = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                 SIYZ = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                            ),
+          EPSI_INIT=FACT(statut='f',
+                 EPXX = SIMP(statut='o',typ='R',max=1),
+                 EPYY = SIMP(statut='o',typ='R',max=1),
+                 EPZZ = SIMP(statut='o',typ='R',max=1),
+                 EPXY = SIMP(statut='o',typ='R',max=1),
+                 EPXZ = SIMP(statut='o',typ='R',max=1),
+                 EPYZ = SIMP(statut='o',typ='R',max=1),
+                            ),
+          VARI_INIT=FACT(statut='f',
+                 VALE = SIMP(statut='o',typ='R',max='**'),
+                            ),
+            ),
+            
+   b_2Dini = BLOC(condition="MODELISATION !=  '3D'",
+                    fr="Etat initial en 2D",
+                    
+         SIGM_INIT=FACT(statut='f',
+                SIXX = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                SIYY = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                SIXY = SIMP(statut='f',typ='R',max=1,defaut=0.0E+0),
+                           ),
+         EPSI_INIT=FACT(statut='f',
+                EPXX = SIMP(statut='o',typ='R',max=1),
+                EPYY = SIMP(statut='o',typ='R',max=1),
+                EPXY = SIMP(statut='o',typ='R',max=1),
+                           ),
+          VARI_INIT=FACT(statut='f',
+                 VALE    = SIMP(statut='o',typ='R',max='**'),
+                            ),
+             ),
+   INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)
+
+#& MODIF COMMANDE  DATE 22/09/2009   AUTEUR SELLENET N.SELLENET 
+#            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
+
+from Macro.stanley_ops import stanley_ops
+
+STANLEY=MACRO(nom="STANLEY",op=stanley_ops,sd_prod=None,
+                       reentrant='n',
+              UIinfo={"groupes":("Outils métier",)},
+                       fr="Outil de post-traitement interactif Stanley ",
+         RESULTAT        =SIMP(statut='f',typ=(evol_elas,evol_noli,evol_ther,mode_meca,dyna_harmo,dyna_trans) ),
+         MODELE          =SIMP(statut='f',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='f',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         DISPLAY         =SIMP(statut='f',typ='TXM'),
+         UNITE_VALIDATION=SIMP(statut='f',typ='I',val_min=10,val_max=90,
+                               fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit les md5"),
+
+)  ;
+#& MODIF COMMANDE  DATE 08/09/2009   AUTEUR SFAYOLLE S.FAYOLLE 
+#            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 ABBAS M.ABBAS
+#
+STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli,
+                   fr="Calcul de l'évolution mécanique ou thermo-hydro-mécanique couplée, en quasi-statique,"
+                      +" d'une structure en non linéaire",
+                   reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+         regles=(AU_MOINS_UN('COMP_INCR','COMP_ELAS'),
+                 CONCEPT_SENSIBLE('ENSEMBLE'),
+#                 AU_MOINS_UN('NEWTON','IMPL_EX'),
+#                 EXCLUS('NEWTON','IMPL_EX'),
+                ),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         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","FIXE_PILO","SUIV","DIDI")),
+         ),
+         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)),
+              ),
+         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=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","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","GREEN","GREEN_GR",) ),
+      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='**'),
+         ),
+         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',),
+                     EXCLUS('EVOL_NOLI','DEPL',),
+                     EXCLUS('EVOL_NOLI','SIGM',),
+                     EXCLUS('EVOL_NOLI','VARI',),
+                     EXCLUS('NUME_ORDRE','INST'), ),
+             DEPL            =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','SIGM','VARI',),
+                     EXCLUS('EVOL_NOLI','DEPL',),
+                     EXCLUS('EVOL_NOLI','SIGM',),
+                     EXCLUS('EVOL_NOLI','VARI',),
+                     EXCLUS('NUME_ORDRE','INST'), ),
+             DEPL            =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'),
+         ),),
+
+         INCREMENT       =C_INCREMENT(),
+
+         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),
+           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='**'),
+                         ),
+
+         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",
+                                      "PILO_PARA",
+                                      "MATR_ASSE",
+                                      "ITER_DEBO",
+                                      "CTCD_ITER","CTCD_GEOM","CTCD_NOEU",
+                                      "CTCC_GEOM","CTCC_FROT","CTCC_CONT",
+                                      "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 == 'STANDARD' ",
+                            INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+                          ),
+         ),
+
+
+
+         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"),
+           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',into=(1,2) ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+
+#         NEWTON  = C_NEWTON(),
+#         IMPL_EX = C_IMPL_EX(),
+
+#         **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(),
+                        ),
+ )
+
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY  
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY  
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR     
+# (AT YOUR OPTION) ANY LATER VERSION.                                                  
+#                                                                       
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT   
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF            
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU      
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                              
+#                                                                       
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE     
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,         
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.        
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+
+from Macro.test_fichier_ops import test_fichier_ops
+
+TEST_FICHIER=MACRO(nom="TEST_FICHIER", op=test_fichier_ops,
+                   UIinfo={"groupes":("Impression",)},
+                   fr="Tester la non régression de fichiers produits par des commandes aster",
+   FICHIER          =SIMP(statut='o',typ='TXM',validators=LongStr(1,255)),
+   EXPR_IGNORE      =SIMP(statut='f',typ='TXM',max='**',
+                          fr="Liste d'expressions régulières permettant d'ignorer certaines lignes"),
+
+   TYPE_TEST       =SIMP(statut='f',typ='TXM',defaut='SOMM',into=("SOMM_ABS","SOMM","MAXI","MINI","MAXI_ABS","MINI_ABS")),
+   NB_VALE         =SIMP(statut='o',typ='I',),
+   VALE            =SIMP(statut='f',typ='R',max='**'),
+   VALE_K          =SIMP(statut='f',typ='TXM'),
+
+   CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
+   PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-3),
+
+   REFERENCE       =SIMP(statut='f',typ='TXM',
+                         into=("ANALYTIQUE","SOURCE_EXTERNE","NON_REGRESSION","AUTRE_ASTER") ),
+
+   b_version       =BLOC(condition = "REFERENCE == 'NON_REGRESSION'",
+      VERSION         =SIMP(statut='f',typ='TXM' ),
+   ),
+
+   INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)
+#& MODIF COMMANDE  DATE 22/09/2009   AUTEUR SELLENET N.SELLENET 
+# -*- coding: iso-8859-1 -*-
+#            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 SELLENET N.SELLENET
+from Macro.test_fonction_ops import test_fonction_ops
+
+TEST_FONCTION=MACRO(nom="TEST_FONCTION",op=test_fonction_ops,sd_prod=None,
+            fr="Extraction d'une valeur numérique ou d'un attribut de fonction pour comparaison à une valeur de référence",
+            UIinfo={"groupes":("Impression",)},
+         TEST_NOOK       =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         VALEUR          =FACT(statut='f',max='**',
+                               fr="Tester la valeur d une fonction ou d une nappe",
+           regles=(UN_PARMI('VALE_REFE','VALE_REFE_C',),
+                   UN_PARMI('VALE_PARA','INTERVALLE'),
+                   DERIVABLE('FONCTION'),),
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,fonction_c,nappe_sdaster,formule) ),
+           SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),
+                                 fr="Paramètre de sensibilité.",
+                                 ang="Sensitivity parameter"),
+           NOM_PARA        =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2),
+           VALE_PARA       =SIMP(statut='f',typ='R'  ,validators=NoRepeat(),max=2),
+           INTERVALLE      =SIMP(statut='f',typ='R'  ,validators=NoRepeat(),min=2,max=2),
+           VALE_REFE       =SIMP(statut='f',typ='R',max='**' ),
+           VALE_REFE_C     =SIMP(statut='f',typ='C',max='**' ),
+           VALE_ABS        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           CRITERE         =SIMP(statut='f',typ='TXM',fr="Critère de comparaison avec la solution de référence",
+                                 defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           PRECISION       =SIMP(statut='f',typ='R',fr="Ecart maximal autorisé avec la solution de référence",
+                                 defaut= 1.E-3 ),
+           REFERENCE       =SIMP(statut='f',typ='TXM',
+                                 into=("ANALYTIQUE","SOURCE_EXTERNE","NON_REGRESSION","AUTRE_ASTER") ),
+           b_version = BLOC (condition = "REFERENCE == 'NON_REGRESSION'",
+             VERSION         =SIMP(statut='f',typ='TXM' ),
+           ),
+         ),
+         ATTRIBUT        =FACT(statut='f',max='**',
+                               fr="Tester la valeur d un attribut d une fonction ou d''une nappe",
+           FONCTION        =SIMP(statut='o',typ=(fonction_sdaster,fonction_c,nappe_sdaster,formule) ),
+           PARA            =SIMP(statut='f',typ='R' ),
+           CRIT_PARA       =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           PREC_PARA       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           ATTR            =SIMP(statut='o',typ='TXM',
+                                 into=("NOM_PARA","NOM_RESU","PROL_DROITE","PROL_GAUCHE","INTERPOL",
+                                       "PROL_GAUCHE_FONC","PROL_DROITE_FONC","INTERPOL_FONC","NOM_PARA_FONC") ),
+           ATTR_REFE       =SIMP(statut='o',typ='TXM' ),
+           REFERENCE       =SIMP(statut='f',typ='TXM',
+                                 into=("ANALYTIQUE","SOURCE_EXTERNE","NON_REGRESSION","AUTRE_ASTER") ),
+           b_version       =BLOC(condition = "REFERENCE == 'NON_REGRESSION'",
+             VERSION         =SIMP(statut='f',typ='TXM' ),
+           ),
+         ),
+         TABL_INTSP      =FACT(statut='f',max='**',
+                               fr="Tester la valeur d une fonction contenue dans une table interspectrale",
+           regles=(UN_PARMI('NUME_ORDRE_I','NOEUD_I'),),
+           INTE_SPEC       =SIMP(statut='o',typ=table_fonction),
+           NOEUD_I         =SIMP(statut='f',typ=no),
+           NUME_ORDRE_I    =SIMP(statut='f',typ='I' ),
+           b_nume_ordre_i = BLOC (condition = "NUME_ORDRE_I != None",
+             NUME_ORDRE_J    =SIMP(statut='o',typ='I' ),
+           ),
+           b_noeud_i = BLOC (condition = "NOEUD_I != None",
+             NOEUD_J         =SIMP(statut='o',typ=no),
+             NOM_CMP_I       =SIMP(statut='o',typ='TXM' ),
+             NOM_CMP_J       =SIMP(statut='o',typ='TXM' ),
+           ),
+           NUME_VITE_FLUI  =SIMP(statut='f',typ='I' ),
+           VALE_PARA       =SIMP(statut='o',typ='R' ),
+           VALE_REFE_C     =SIMP(statut='o',typ='C',max='**' ),
+           CRITERE         =SIMP(statut='f',typ='TXM',fr="Critère de comparaison avec la solution de référence",
+                                 defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           PRECISION       =SIMP(statut='f',typ='R',fr="Ecart maximal autorisé avec la solution de référence",
+                                 defaut= 1.E-3 ),
+           REFERENCE       =SIMP(statut='f',typ='TXM',
+                                 into=("ANALYTIQUE","SOURCE_EXTERNE","NON_REGRESSION","AUTRE_ASTER") ),
+           b_version       =BLOC(condition = "REFERENCE == 'NON_REGRESSION'",
+             VERSION         =SIMP(statut='f',typ='TXM' ),
+           ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+#
+#
+# ======================================================================
+# RESPONSABLE LEFEBVRE J.P.LEFEBVRE
+TEST_RESU=PROC(nom="TEST_RESU",op=23,
+            UIinfo={"groupes":("Impression",)},
+         fr="Extraction d'une valeur d'une structure de donnée et comparaison à une valeur de référence",
+         regles=(AU_MOINS_UN('CHAM_NO','CHAM_ELEM','RESU','GENE','OBJET')),
+
+         CHAM_NO         =FACT(statut='f',max='**',
+           regles=(UN_PARMI('NOEUD','GROUP_NO','TYPE_TEST'),
+                   EXCLUS('NOEUD','GROUP_NO'),
+                   PRESENT_PRESENT('NOEUD','NOM_CMP'),
+                   PRESENT_PRESENT( 'GROUP_NO','NOM_CMP'),
+                   UN_PARMI('VALE','VALE_I','VALE_C'),),
+           CHAM_GD         =SIMP(statut='o',typ=cham_no_sdaster),
+           NOEUD           =SIMP(statut='f',typ=no   ),
+           GROUP_NO        =SIMP(statut='f',typ=grno ),
+           NOM_CMP         =SIMP(statut='f',typ='TXM'),
+           TYPE_TEST       =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN")),
+           VALE            =SIMP(statut='f',typ='R',max='**'),
+           VALE_I          =SIMP(statut='f',typ='I',max='**'),
+           VALE_C          =SIMP(statut='f',typ='C',max='**'),
+           VALE_ABS        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-3),
+           REFERENCE       =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE","SOURCE_EXTERNE",
+                                                            "NON_REGRESSION","AUTRE_ASTER")),
+           VERSION         =SIMP(statut='f',typ='TXM'),
+         ),
+
+         CHAM_ELEM       =FACT(statut='f',max='**',
+           regles=(UN_PARMI('MAILLE','TYPE_TEST',),
+                   EXCLUS('NOEUD','GROUP_NO','POINT'),
+                   PRESENT_PRESENT('NOEUD','NOM_CMP'),
+                   PRESENT_PRESENT('GROUP_NO','NOM_CMP'),
+                   PRESENT_PRESENT('POINT','NOM_CMP'),
+                   UN_PARMI('VALE','VALE_I','VALE_C'), ),
+           CHAM_GD         =SIMP(statut='o',typ=cham_elem),
+           MAILLE          =SIMP(statut='f',typ=ma),
+           POINT           =SIMP(statut='f',typ='I' ),
+           SOUS_POINT      =SIMP(statut='f',typ='I'),
+           NOEUD           =SIMP(statut='f',typ=no),
+           GROUP_NO        =SIMP(statut='f',typ=grno),
+           NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),
+           TYPE_TEST       =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN") ),
+           VALE            =SIMP(statut='f',typ='R',max='**' ),
+           VALE_I          =SIMP(statut='f',typ='I',max='**' ),
+           VALE_C          =SIMP(statut='f',typ='C',max='**' ),
+           VALE_ABS        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+           REFERENCE       =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE","SOURCE_EXTERNE",
+                                                            "NON_REGRESSION","AUTRE_ASTER") ),
+           VERSION         =SIMP(statut='f',typ='TXM' ),
+         ),
+
+         RESU            =FACT(statut='f',max='**',
+           regles=(UN_PARMI('NUME_ORDRE','INST','FREQ','NUME_MODE','NOEUD_CMP','NOM_CAS','ANGL'),
+                   UN_PARMI('NOM_CHAM','PARA'),
+                   PRESENT_ABSENT('PARA','NOEUD','GROUP_NO','POINT','NOM_CMP','TYPE_TEST'),
+                   PRESENT_PRESENT('NOM_CMP','NOM_CHAM'),
+                   EXCLUS('NOEUD','GROUP_NO','POINT','TYPE_TEST'),
+                   PRESENT_PRESENT('NOEUD','NOM_CMP'),
+                   PRESENT_PRESENT('GROUP_NO','NOM_CMP'),
+                   PRESENT_PRESENT('POINT','NOM_CMP'),
+                   UN_PARMI('VALE','VALE_I','VALE_C'),
+                   DERIVABLE('RESULTAT'),),
+           RESULTAT        =SIMP(statut='o',typ=resultat_sdaster),
+           SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),
+                                 fr="Paramètre de sensibilité.",
+                                 ang="Sensitivity parameter"),
+           NUME_ORDRE      =SIMP(statut='f',typ='I'),
+           INST            =SIMP(statut='f',typ='R'),
+           FREQ            =SIMP(statut='f',typ='R'),
+           NUME_MODE       =SIMP(statut='f',typ='I'),
+           NOEUD_CMP       =SIMP(statut='f',typ='TXM',min=2,max=2),
+           NOM_CAS         =SIMP(statut='f',typ='TXM'),
+           ANGL            =SIMP(statut='f',typ='R'),
+           PARA            =SIMP(statut='f',typ='TXM'),
+           NOM_CHAM        =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+           NOM_CMP         =SIMP(statut='f',typ='TXM',max='**'),
+           MAILLE          =SIMP(statut='f',typ=ma   ,max='**'),
+           NOEUD           =SIMP(statut='f',typ=no   ,max='**'),
+           GROUP_NO        =SIMP(statut='f',typ=grno ,max='**'),
+           POINT           =SIMP(statut='f',typ='I'),
+           SOUS_POINT      =SIMP(statut='f',typ='I'),
+           TYPE_TEST       =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN")),
+           VALE            =SIMP(statut='f',typ='R',max='**'),
+           VALE_I          =SIMP(statut='f',typ='I',max='**'),
+           VALE_C          =SIMP(statut='f',typ='C',max='**'),
+           VALE_ABS        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           CRITERE         =SIMP(statut='f',typ='TXM',into=("RELATIF","ABSOLU"),max=2),
+           PRECISION       =SIMP(statut='f',typ='R',max=2),
+           REFERENCE       =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE","SOURCE_EXTERNE",
+                                                            "NON_REGRESSION","AUTRE_ASTER",) ),
+           VERSION         =SIMP(statut='f',typ='TXM' ),
+         ),
+
+         GENE            =FACT(statut='f',max='**',
+           regles=(UN_PARMI('VALE','VALE_I','VALE_C') ,),
+           RESU_GENE       =SIMP(statut='o',typ=(vect_asse_gene, tran_gene, mode_gene, harm_gene)),
+           b_vect_asse     =BLOC(condition = "AsType(RESU_GENE) == vect_asse_gene",
+             NUME_CMP_GENE   =SIMP(statut='o',typ='I'),
+           ),
+           b_mode          =BLOC(condition = "(AsType(RESU_GENE) == harm_gene) or (AsType(RESU_GENE) == mode_gene)",
+                            regles=(UN_PARMI('NUME_ORDRE','FREQ','NUME_MODE'),
+                                    UN_PARMI('NOM_CHAM','PARA'),
+                                    PRESENT_PRESENT('NOM_CHAM','NUME_CMP_GENE'),),
+             NOM_CHAM        =SIMP(statut='f',typ='TXM',into=C_NOM_CHAM_INTO()),
+             NUME_CMP_GENE   =SIMP(statut='f',typ='I'),
+             PARA            =SIMP(statut='f',typ='TXM'),
+             NUME_ORDRE      =SIMP(statut='f',typ='I'),
+             NUME_MODE       =SIMP(statut='f',typ='I'),
+             FREQ            =SIMP(statut='f',typ='R'),
+           ),
+           b_tran          =BLOC(condition = "AsType(RESU_GENE) == tran_gene",
+                            regles=(UN_PARMI('NUME_ORDRE','INST') ,),
+             NOM_CHAM        =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO()),
+             NUME_CMP_GENE   =SIMP(statut='o',typ='I'),
+             NUME_ORDRE      =SIMP(statut='f',typ='I'),
+             INST            =SIMP(statut='f',typ='R'),
+           ),
+           VALE            =SIMP(statut='f',typ='R',max='**'),
+           VALE_I          =SIMP(statut='f',typ='I',max='**'),
+           VALE_C          =SIMP(statut='f',typ='C',max='**'),
+           VALE_ABS        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           CRITERE         =SIMP(statut='f',typ='TXM',into=("RELATIF","ABSOLU"),max=2),
+           PRECISION       =SIMP(statut='f',typ='R',max=2),
+           REFERENCE       =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE","SOURCE_EXTERNE",
+                                                            "NON_REGRESSION","AUTRE_ASTER",) ),
+           VERSION         =SIMP(statut='f',typ='TXM' ),
+         ),
+
+         OBJET           =FACT(statut='f',max='**',
+           regles=(UN_PARMI('S_I','S_R',),
+                   UN_PARMI('VALE','VALE_I','VALE_C','S_R','S_I'),),
+           NOM             =SIMP(statut='o',typ='TXM'),
+           S_R             =SIMP(statut='f',typ='R'),
+           S_I             =SIMP(statut='f',typ='I'),
+           VALE            =SIMP(statut='f',typ='R'),
+           VALE_I          =SIMP(statut='f',typ='I'),
+           VALE_C          =SIMP(statut='f',typ='C'),
+           VALE_ABS        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
+           PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
+           REFERENCE       =SIMP(statut='f',typ='TXM',into=("ANALYTIQUE","SOURCE_EXTERNE",
+                                                            "NON_REGRESSION","AUTRE_ASTER",) ),
+           VERSION         =SIMP(statut='f',typ='TXM' ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 21/04/2008   AUTEUR LEFEBVRE J-P.LEFEBVRE 
+#            CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR   
+# (AT YOUR OPTION) ANY LATER VERSION.                                 
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT 
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF          
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU    
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.                            
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE   
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,       
+#    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.      
+# ======================================================================
+# RESPONSABLE COURTOIS M.COURTOIS
+TEST_TABLE=PROC(nom="TEST_TABLE",op= 177,
+            UIinfo={"groupes":("Impression",)},
+         fr="Tester une cellule ou une colonne d'une table",
+         regles=(UN_PARMI('VALE','VALE_I','VALE_C', ),
+                 DERIVABLE('TABLE'),),
+#  concept table_sdaster à tester
+         TABLE           =SIMP(statut='o',typ=table_sdaster),
+
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),
+                                 fr="Paramètre de sensibilité.",
+                                 ang="Sensitivity parameter"),
+         FILTRE          =FACT(statut='f',max='**',
+           NOM_PARA        =SIMP(statut='o',typ='TXM' ),
+           CRIT_COMP       =SIMP(statut='f',typ='TXM',defaut="EQ",
+                                 into=("EQ","LT","GT","NE","LE","GE","VIDE",
+                                       "NON_VIDE","MAXI","ABS_MAXI","MINI","ABS_MINI") ),
+           b_vale          =BLOC(condition = "(CRIT_COMP in ('EQ','NE','GT','LT','GE','LE'))",
+              regles=(UN_PARMI('VALE','VALE_I','VALE_K','VALE_C',),),
+              VALE            =SIMP(statut='f',typ='R',),
+              VALE_I          =SIMP(statut='f',typ='I',),
+              VALE_C          =SIMP(statut='f',typ='C',),
+              VALE_K          =SIMP(statut='f',typ='TXM' ),),
+
+           CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+           PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+         ),
+         TYPE_TEST       =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN") ),
+         NOM_PARA        =SIMP(statut='o',typ='TXM' ),
+         VALE            =SIMP(statut='f',typ='R',max='**' ),
+         VALE_I          =SIMP(statut='f',typ='I',max='**' ),
+         VALE_C          =SIMP(statut='f',typ='C',max='**' ),
+         VALE_ABS        =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         CRITERE         =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+         PRECISION       =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+         REFERENCE       =SIMP(statut='f',typ='TXM',
+                               into=("ANALYTIQUE","SOURCE_EXTERNE","NON_REGRESSION","AUTRE_ASTER") ),
+         b_version       =BLOC(condition = "REFERENCE == 'NON_REGRESSION'",
+             VERSION         =SIMP(statut='f',typ='TXM' ),
+         INFO            =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+         ),
+)  ;
+#& MODIF COMMANDE  DATE 05/09/2008   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.        
+# ======================================================================
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE COURTOIS M.COURTOIS
+
+
+from Macro.test_temps_ops import test_temps_ops
+
+TEST_TEMPS=MACRO(nom="TEST_TEMPS",op=test_temps_ops, sd_prod=None,
+                 fr="Permet de vérifier le temps passé dans les commandes",
+                 reentrant='n',
+
+   RESU = FACT(statut='o',max='**',
+      COMMANDE   = SIMP(statut='o', typ='TXM',
+            fr="Nom de la commande testee"),
+      NUME_ORDRE = SIMP(statut='f', typ='I', defaut=1, val_min=1,
+            fr="Numero de l'occurrence de la commande testee"),
+      MACHINE    = SIMP(statut='o', typ='TXM', max='**',
+            fr="Liste des machines dont on a la référence"),
+      VALE       = SIMP(statut='o', typ='R', max='**',
+            fr="Temps CPU sur les machines listees en secondes"),
+      CRITERE    = SIMP(statut='f', typ='TXM', defaut='RELATIF', into=('ABSOLU', 'RELATIF')),
+      PRECISION  = SIMP(statut='f', typ='R', defaut=0.01, max='**',
+            fr="Ecart admissible pour chaque machine"),
+      TYPE_TEST  = SIMP(statut='o', typ='TXM', into=('USER', 'SYSTEM', 'USER+SYS', 'ELAPSED'),
+            defaut='USER+SYS',
+            fr="Valeur testee parmi 'USER', 'SYSTEM', 'USER+SYS', 'ELAPSED'"),
+   ),
+
+   INFO  = SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)
+
+#& MODIF COMMANDE  DATE 16/11/2009   AUTEUR DURAND C.DURAND 
+#            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 DURAND C.DURAND
+THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+                   fr="Résoudre un problème thermique linéaire stationnaire ou transitoire",
+         regles=(CONCEPT_SENSIBLE('ENSEMBLE'),),
+         MODELE          =SIMP(statut='o',typ=modele_sdaster),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater),
+         CARA_ELEM       =SIMP(statut='f',typ=cara_elem),
+         EXCIT           =FACT(statut='o',max='**',
+           CHARGE          =SIMP(statut='o',typ=(char_ther,char_cine_ther)),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+         ),
+         INCREMENT       =FACT(statut='f',
+           regles=(EXCLUS('NUME_INST_INIT','INST_INIT'),
+                   EXCLUS('NUME_INST_FIN','INST_FIN'),),
+           LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
+           NUME_INST_INIT  =SIMP(statut='f',typ='I'),
+           INST_INIT       =SIMP(statut='f',typ='R'),
+           NUME_INST_FIN   =SIMP(statut='f',typ='I'),
+           INST_FIN        =SIMP(statut='f',typ='R'),
+           PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-6 ),
+         ),
+         ETAT_INIT       =FACT(statut='f',
+           regles=(EXCLUS('STATIONNAIRE','EVOL_THER','CHAM_NO','VALE'),),
+           STATIONNAIRE    =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           EVOL_THER       =SIMP(statut='f',typ=evol_ther),
+           CHAM_NO         =SIMP(statut='f',typ=cham_no_sdaster),
+           VALE            =SIMP(statut='f',typ='R'),
+           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',),),
+           INST_ETAT_INIT  =SIMP(statut='f',typ='R'),
+         ),
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des paramètres de sensibilité.",
+                               ang="List of sensitivity parameters",
+         ),
+           SENS_INIT       =FACT(statut='f',
+             regles=(EXCLUS('STATIONNAIRE','EVOL_THER', ),),
+             STATIONNAIRE    =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+             EVOL_THER       =SIMP(statut='f',typ=evol_ther),
+             NUME_INIT       =SIMP(statut='f',typ='I'),
+           ),
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_gcpc          =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+         ),
+         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",)),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2)),
+)  ;
+#& MODIF COMMANDE  DATE 16/11/2009   AUTEUR DURAND C.DURAND 
+#            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 DURAND C.DURAND
+THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f',
+            UIinfo={"groupes":("Résolution",)},
+                   fr="Résoudre un problème thermique non linéaire (conditions limites ou comportement matériau)"
+                      +" stationnaire ou transitoire" ,
+         regles=(CONCEPT_SENSIBLE('ENSEMBLE'),),
+         MODELE          =SIMP(statut='o',typ=(modele_sdaster) ),
+         CHAM_MATER      =SIMP(statut='o',typ=(cham_mater) ),
+         CARA_ELEM       =SIMP(statut='c',typ=(cara_elem) ),
+         COMP_THER_NL    =FACT(statut='d',max='**',
+           RELATION        =SIMP(statut='f',typ='TXM',defaut="THER_NL",
+                                 into=("THER_NL",
+                                       "THER_HYDR",
+                                       "SECH_GRANGER",
+                                       "SECH_MENSI",
+                                       "SECH_BAZANT",
+                                       "SECH_NAPPE"
+                                       ) ),
+         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='**'),
+         ),
+         EVOL_THER_SECH  =SIMP(statut='f',typ=evol_ther),
+         EXCIT           =FACT(statut='o',max='**',
+           CHARGE          =SIMP(statut='o',typ=char_ther),
+           FONC_MULT       =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+         ),
+         INCREMENT       =FACT(statut='f',
+           regles=(EXCLUS('NUME_INST_INIT','INST_INIT'),
+                   EXCLUS('NUME_INST_FIN','INST_FIN'),),
+           LIST_INST       =SIMP(statut='o',typ=listr8_sdaster),
+           NUME_INST_INIT  =SIMP(statut='f',typ='I'),
+           INST_INIT       =SIMP(statut='f',typ='R'),
+           NUME_INST_FIN   =SIMP(statut='f',typ='I'),
+           INST_FIN        =SIMP(statut='f',typ='R'),
+           PRECISION       =SIMP(statut='f',typ='R',defaut=1.0E-6 ),
+         ),
+         ETAT_INIT       =FACT(statut='f',
+           regles=(EXCLUS('STATIONNAIRE','EVOL_THER','CHAM_NO','VALE'),),
+           STATIONNAIRE    =SIMP(statut='f',typ='TXM',into=("OUI",)),
+           EVOL_THER       =SIMP(statut='f',typ=evol_ther),
+           CHAM_NO         =SIMP(statut='f',typ=cham_no_sdaster),
+           VALE            =SIMP(statut='f',typ='R'),
+           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',),),
+           INST_ETAT_INIT  =SIMP(statut='f',typ='R'),
+         ),
+         NEWTON          =FACT(statut='d',
+           REAC_ITER       =SIMP(statut='f',typ='I',defaut= 0 ,val_min=0),
+           RESI_LINE_RELA  =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
+           ITER_LINE_MAXI  =SIMP(statut='f',typ='I',defaut= 0 ),
+         ),
+         CONVERGENCE     =FACT(statut='d',
+           RESI_GLOB_MAXI  =SIMP(statut='f',typ='R'),
+           RESI_GLOB_RELA  =SIMP(statut='f',typ='R'),
+           ITER_GLOB_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
+         ),
+         SENSIBILITE     =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+                               fr="Liste des paramètres de sensibilité.",
+                               ang="List of sensitivity parameters",
+         ),
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","PETSC") ),
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Parametres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Parametres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_gcpc          =BLOC(condition = "METHODE == 'GCPC' ", fr="Parametres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I'  ,defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R'  ,defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I'  ,defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),           
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             FILTRAGE_MATRICE=SIMP(statut='f',typ='R',defaut=-1.0,),
+             MIXER_PRECISION =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+           SYME            =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+         ),
+         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',),),),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**'),
+         OPTION          =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2,
+                               into=("FLUX_ELGA_TEMP","FLUX_ELNO_TEMP") ),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+
+)  ;
+#& MODIF COMMANDE  DATE 13/10/2009   AUTEUR COURTOIS M.COURTOIS 
+#            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 DURAND C.DURAND
+THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther,
+                     fr="Résoudre un problème thermique non linéaire (conditions limites ou comportement matériau)"
+                        +" stationnaire avec chargement mobile",
+                     reentrant='n',
+            UIinfo={"groupes":("Résolution",)},
+         MODELE          =SIMP(statut='o',typ=modele_sdaster ),
+         CHAM_MATER      =SIMP(statut='o',typ=cham_mater ),
+         CARA_ELEM       =SIMP(statut='c',typ=cara_elem ),
+         EXCIT           =FACT(statut='o',max='**',
+           CHARGE          =SIMP(statut='o',typ=char_ther ),
+           FONC_MULT       =SIMP(statut='c',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+         ),
+         ETAT_INIT       =FACT(statut='f',
+           EVOL_THER       =SIMP(statut='f',typ=evol_ther ),
+           NUME_ORDRE      =SIMP(statut='f',typ='I',defaut= 0 ),
+         ),
+         CONVERGENCE     =FACT(statut='d',
+           CRIT_TEMP_RELA  =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+           CRIT_ENTH_RELA  =SIMP(statut='f',typ='R',defaut= 1.E-2 ),
+           ITER_GLOB_MAXI  =SIMP(statut='f',typ='I',defaut= 10 ),
+           ARRET           =SIMP(statut='c',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+         ),
+         SOLVEUR         =FACT(statut='d',
+           METHODE         =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS") ),
+           b_mult_front    =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
+           ),
+           b_ldlt          =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
+           ),
+           b_ldlt_mult_mumps =BLOC( condition = "METHODE=='LDLT' or METHODE=='MULT_FRONT' or METHODE=='MUMPS' ",
+                                   fr="Paramètres relatifs à la non inversibilité de la matrice à factoriser",
+             NPREC           =SIMP(statut='f',typ='I',defaut= 8 ),
+             STOP_SINGULIER  =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
+           ),
+           b_gcpc          =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
+             NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= 0 ),
+           ),
+           b_mumps        =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+             TYPE_RESOL      =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+             PRETRAITEMENTS  =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+             POSTTRAITEMENTS =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO","FORCE")),             
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+             ELIM_LAGR2      =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+             PCENT_PIVOT     =SIMP(statut='f',typ='I',defaut=10,),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut=-1.0,),
+             OUT_OF_CORE     =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+             ),
+           b_petsc          =BLOC(condition = "METHODE == 'PETSC' ",fr="Paramètres de la méthode PETSC",
+             ALGORITHME      =SIMP(statut='f',typ='TXM',into=("BCGS","BICG","CG","CR","GMRES","TFQMR",),defaut="CG" ),
+             PRE_COND        =SIMP(statut='f',typ='TXM',into=("LDLT_INC","JACOBI","SOR"),defaut="LDLT_INC" ),
+             b_petsc_ilu     =BLOC(condition = "PRE_COND == 'LDLT_INC' ",
+               NIVE_REMPLISSAGE = SIMP(statut='f',typ='I',defaut= 0 ),
+               REMPLISSAGE      = SIMP(statut='f',typ='R',defaut= 1.0),
+             ),
+             RENUM           =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
+             RESI_RELA       =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
+             NMAX_ITER       =SIMP(statut='f',typ='I',defaut= -1 ),
+           ),
+           SYME            =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+         ),
+         TITRE           =SIMP(statut='f',typ='TXM',max='**' ),
+         INFO            =SIMP(statut='f',typ='I',into=(1,2) ),
+)  ;
+
+
+

diff --git a/Aster/Cata/cataSTA10/ops.py b/Aster/Cata/cataSTA10/ops.py
new file mode 100644 (file)
index 0000000..e0098c8
--- /dev/null
+++ b/Aster/Cata/cataSTA10/ops.py
@@ -0,0 +1,500 @@
+#@ MODIF ops Cata  DATE 16/11/2009   AUTEUR COURTOIS M.COURTOIS 
+# -*- coding: iso-8859-1 -*-
+#            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.      
+# ======================================================================
+
+
+# Modules Python
+import types
+import string,linecache,os,traceback,re
+import pickle
+import re
+
+# Modules Eficas
+import Accas
+from Accas import ASSD
+from Noyau.ascheckers     import CheckLog
+
+try:
+   import aster
+   aster_exists = True
+   # Si le module aster est présent, on le connecte
+   # au JDC
+   import Build.B_CODE
+   Build.B_CODE.CODE.codex=aster
+   
+   from Utilitai.Utmess   import UTMESS
+   from Build.B_SENSIBILITE_MEMO_NOM_SENSI import MEMORISATION_SENSIBILITE
+   from Execution.E_Global import MessageLog
+except:
+   aster_exists = False
+
+
+def commun_DEBUT_POURSUITE(jdc, PAR_LOT, IMPR_MACRO, CODE, DEBUG, IGNORE_ALARM):
+   """Fonction sdprod partie commune à DEBUT et POURSUITE.
+   (on stocke un entier au lieu du logique)
+   """
+   jdc.par_lot    = PAR_LOT
+   jdc.impr_macro = int(IMPR_MACRO == 'OUI')
+   jdc.jxveri     = int(CODE != None or (DEBUG != None and DEBUG['JXVERI'] == 'OUI'))
+   jdc.sdveri     = int(DEBUG != None and DEBUG['SDVERI'] == 'OUI')
+   jdc.fico       = None
+   jdc.sd_checker = CheckLog()
+   if CODE != None:
+      jdc.fico = CODE['NOM']
+   if aster_exists:
+      # en POURSUITE, ne pas écraser la mémorisation existante.
+      if not hasattr(jdc, 'memo_sensi'):
+         jdc.memo_sensi = MEMORISATION_SENSIBILITE()
+      jdc.memo_sensi.reparent(jdc)
+
+      # ne faire qu'une fois
+      if not hasattr(jdc, 'msg_init'):
+         # messages d'alarmes désactivés
+         if IGNORE_ALARM:
+            if not type(IGNORE_ALARM) in (list, tuple):
+               IGNORE_ALARM = [IGNORE_ALARM]
+            for idmess in IGNORE_ALARM:
+               MessageLog.disable_alarm(idmess)
+               
+      # en POURSUITE, conserver le catalogue de comportement picklé
+      if not hasattr(jdc, 'catalc'):
+         from Comportement import catalc
+         jdc.catalc = catalc
+
+      jdc.msg_init = True
+
+
+def DEBUT(self, PAR_LOT, IMPR_MACRO, CODE, DEBUG, IGNORE_ALARM, **args):
+   """
+       Fonction sdprod de la macro DEBUT
+   """
+   # La commande DEBUT ne peut exister qu'au niveau jdc
+   if self.jdc is not self.parent :
+      raise Accas.AsException("La commande DEBUT ne peut exister qu'au niveau jdc")
+
+   commun_DEBUT_POURSUITE(self.jdc, PAR_LOT, IMPR_MACRO, CODE, DEBUG, IGNORE_ALARM)
+
+
+def build_debut(self,**args):
+   """
+   Fonction ops pour la macro DEBUT
+   """
+   self.jdc.UserError=self.codex.error
+
+   if self.jdc.par_lot == 'NON' :
+      self.jdc._Build()
+   # On execute la fonction debut pour initialiser les bases
+   # Cette execution est indispensable avant toute autre action sur ASTER
+   # op doit etre un entier car la fonction debut appelle GCECDU qui demande
+   # le numero de l'operateur associé (getoper)
+   self.definition.op=0
+   self.set_icmd(1)
+   lot,ier=self.codex.debut(self,1)
+   # On remet op a None juste apres pour eviter que la commande DEBUT
+   # ne soit executée dans la phase d'execution
+   self.definition.op=None
+   return ier
+
+def POURSUITE(self, PAR_LOT, IMPR_MACRO, CODE, DEBUG, IGNORE_ALARM, **args):
+   """
+       Fonction sdprod de la macro POURSUITE
+   """
+   # La commande POURSUITE ne peut exister qu'au niveau jdc
+   if self.jdc is not self.parent :
+      raise Accas.AsException("La commande POURSUITE ne peut exister qu'au niveau jdc")
+
+   commun_DEBUT_POURSUITE(self.jdc, PAR_LOT, IMPR_MACRO, CODE, DEBUG, IGNORE_ALARM)
+   
+   if (self.codex and os.path.isfile("glob.1") or os.path.isfile("bhdf.1")):
+     # Le module d'execution est accessible et glob.1 est present
+     # Pour eviter de rappeler plusieurs fois la sequence d'initialisation
+     # on memorise avec l'attribut fichier_init que l'initialisation
+     # est réalisée
+     if hasattr(self,'fichier_init'):return
+     self.fichier_init='glob.1'
+     self.jdc.initexec()
+     # le sous programme fortran appelé par self.codex.poursu demande le numero
+     # de l'operateur (GCECDU->getoper), on lui donne la valeur 0
+     self.definition.op=0
+     lot,ier,lonuti,concepts=self.codex.poursu(self,1)
+     # Par la suite pour ne pas executer la commande pendant la phase
+     # d'execution on le remet à None
+     self.definition.op=None
+     # On demande la numerotation de la commande POURSUITE avec l'incrément
+     # lonuti pour qu'elle soit numérotée à la suite des commandes existantes.
+####CD     self.set_icmd(lonuti)    Non : on repart à zéro
+     pos=0
+     d={}
+     while pos+80 < len(concepts)+1:
+       nomres=concepts[pos:pos+8]
+       concep=concepts[pos+8:pos+24]
+       nomcmd=concepts[pos+24:pos+40]
+       statut=concepts[pos+40:pos+48]
+       print nomres,concep,nomcmd,statut
+       if nomres[0] not in (' ','.','&') and statut != '&DETRUIT':
+          exec nomres+'='+string.lower(concep)+'()' in self.parent.g_context,d
+       elif statut == '&DETRUIT' : self.jdc.nsd = self.jdc.nsd+1
+       pos=pos+80
+     # ces ASSD seront écrasées par le pick.1,
+     # on vérifiera la cohérence de type entre glob.1 et pick.1
+     for k,v in d.items():
+       self.parent.NommerSdprod(v,k)
+     self.g_context=d
+
+     # Il peut exister un contexte python sauvegardé sous forme  pickled
+     # On récupère ces objets après la restauration des concepts pour que
+     # la récupération des objets pickled soit prioritaire.
+     # On vérifie que les concepts relus dans glob.1 sont bien tous
+     # presents sous le meme nom et du meme type dans pick.1
+     # Le contexte est ensuite updaté (surcharge) et donc enrichi des
+     # variables qui ne sont pas des concepts.
+     # On supprime du pickle_context les concepts valant None, ca peut 
+     # etre le cas des concepts non executés, placés après FIN.
+     pickle_context=get_pickled_context()
+     if pickle_context==None :
+        UTMESS('F','SUPERVIS_86')
+        return
+     self.jdc.restore_pickled_attrs(pickle_context)
+     from Cata.cata  import ASSD,entier
+     from Noyau.N_CO import CO
+     for elem in pickle_context.keys():
+         if isinstance(pickle_context[elem], ASSD):
+            pickle_class=pickle_context[elem].__class__
+            # on rattache chaque assd au nouveau jdc courant (en poursuite)
+            pickle_context[elem].jdc=self.jdc
+            pickle_context[elem].parent=self.jdc
+            # le marquer comme 'executed'
+            pickle_context[elem].executed = 1
+            # pour que sds_dict soit cohérent avec g_context
+            self.jdc.sds_dict[elem] = pickle_context[elem]
+            if elem != pickle_context[elem].nom:
+               name = re.sub('_([0-9]+)$', '[\\1]', pickle_context[elem].nom)
+               UTMESS('A', 'SUPERVIS_93', valk=(elem, name))
+               del pickle_context[elem]
+               continue
+            # rétablir le parent pour les attributs de la SD
+            pickle_context[elem].reparent_sd()
+            if elem in self.g_context.keys():
+               poursu_class=self.g_context[elem].__class__
+               if poursu_class!=pickle_class :
+                  UTMESS('F','SUPERVIS_87',valk=[elem])
+                  return
+            elif isinstance(pickle_context[elem],ASSD) and pickle_class not in (CO,entier) : 
+            # on n'a pas trouvé le concept dans la base et sa classe est ASSD : ce n'est pas normal
+            # sauf dans le cas de CO : il n'a alors pas été typé et c'est normal qu'il soit absent de la base
+            # meme situation pour le type 'entier' produit uniquement par DEFI_FICHIER
+               UTMESS('F','SUPERVIS_88',valk=[elem,str(pickle_class)])
+               return
+         if pickle_context[elem]==None : del pickle_context[elem]
+     self.g_context.update(pickle_context)
+     return
+
+   else:
+     # Si le module d'execution n est pas accessible ou glob.1 absent on 
+     # demande un fichier (EFICAS)
+     # Il faut éviter de réinterpréter le fichier à chaque appel de
+     # POURSUITE
+     if hasattr(self,'fichier_init'):
+        return
+     self.make_poursuite()
+
+def get_pickled_context():
+    """
+       Cette fonction permet de réimporter dans le contexte courant du jdc (jdc.g_context)
+       les objets python qui auraient été sauvegardés, sous forme pickled, lors d'une 
+       précédente étude. Un fichier pick.1 doit etre présent dans le répertoire de travail
+    """
+    fpick = 'pick.1'
+    if not os.path.isfile(fpick):
+       return None
+   
+    # Le fichier pick.1 est présent. On essaie de récupérer les objets python sauvegardés
+    context={}
+    try:
+       file=open(fpick,'r')
+       # Le contexte sauvegardé a été picklé en une seule fois. Il est seulement
+       # possible de le récupérer en bloc. Si cette opération echoue, on ne récupère
+       # aucun objet.
+       context=pickle.load(file)
+       file.close()
+    except:
+       # En cas d'erreur on ignore le contenu du fichier
+       traceback.print_exc()
+       return None
+
+    return context
+
+def POURSUITE_context(self,d):
+   """
+       Fonction op_init de la macro POURSUITE
+   """
+   # self représente la macro POURSUITE ...
+   d.update(self.g_context)
+   # Une commande POURSUITE n'est possible qu'au niveau le plus haut
+   # On ajoute directement les concepts dans le contexte du jdc
+   # XXX est ce que les concepts ne sont pas ajoutés plusieurs fois ??
+   for v in self.g_context.values():
+      if isinstance(v,ASSD) :
+         self.jdc.sds.append(v)
+
+def build_poursuite(self,**args):
+   """
+   Fonction ops pour la macro POURSUITE
+   """
+   # Pour POURSUITE on ne modifie pas la valeur initialisee dans ops.POURSUITE
+   # Il n y a pas besoin d executer self.codex.poursu (c'est deja fait dans
+   # la fonction sdprod de la commande (ops.POURSUITE))
+   self.set_icmd(1)
+   self.jdc.UserError=self.codex.error
+   return 0
+
+def INCLUDE(self,UNITE,**args):
+   """ 
+       Fonction sd_prod pour la macro INCLUDE
+   """
+   if not UNITE : return
+   if hasattr(self,'unite'):return
+   self.unite=UNITE
+
+   if self.jdc and self.jdc.par_lot == 'NON':
+      # On est en mode commande par commande, on appelle la methode speciale
+      self.Execute_alone()
+
+   self.make_include(unite=UNITE)
+
+def INCLUDE_context(self,d):
+   """ 
+       Fonction op_init pour macro INCLUDE
+   """
+   for k,v in self.g_context.items():
+      d[k]=v
+
+def build_include(self,**args):
+   """
+   Fonction ops de la macro INCLUDE appelée lors de la phase de Build
+   """
+   # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
+   # le numero de la commande n est pas utile en phase de construction
+   # La macro INCLUDE ne sera pas numérotée (incrément=None)
+   ier=0
+   self.set_icmd(None)
+   icmd=0
+   # On n'execute pas l'ops d'include en phase BUILD car il ne sert a rien.
+   #ier=self.codex.opsexe(self,icmd,-1,1)
+   return ier
+
+def detruire(self,d):
+   """
+       Cette fonction est la fonction op_init de la PROC DETRUIRE
+   """
+   list_co = set()
+   sd = []
+   # par nom de concept (typ=assd)
+   if self["CONCEPT"] != None:
+      for mc in self["CONCEPT"]:
+         mcs = mc["NOM"]
+         if type(mcs) not in (list, tuple):
+            mcs = [mcs]
+         list_co.update(mcs)
+   # par chaine de caractères (typ='TXM')
+   if self["OBJET"] != None:
+      for mc in self["OBJET"]:
+         mcs = mc["CHAINE"]
+         if type(mcs) not in (list, tuple):
+            mcs = [mcs]
+         # longueur <= 8, on cherche les concepts existants
+         for nom in mcs:
+            assert type(nom) in (str, unicode), 'On attend une chaine de caractères : %s' % nom
+            if len(nom.strip()) <= 8:
+               if self.jdc.sds_dict.get(nom) != None:
+                  list_co.add(self.jdc.sds_dict[nom])
+               elif d.get(nom) != None:
+                  list_co.add(d[nom])
+            #else uniquement destruction des objets jeveux
+   
+   for co in list_co:
+      assert isinstance(co, ASSD), 'On attend un concept : %s (type=%s)' % (co, type(co))
+      nom = co.nom
+      # traitement particulier pour les listes de concepts, on va mettre à None
+      # le terme de l'indice demandé dans la liste :
+      # nomconcept_i est supprimé, nomconcept[i]=None
+      i = nom.rfind('_')
+      if i > 0 and not nom.endswith('_'):
+         concept_racine = nom[:i]
+         if d.has_key(concept_racine) and type(d[concept_racine]) is list:
+            try:
+               num = int(nom[i+1:])
+               d[concept_racine][num] = None
+            except (ValueError, IndexError):
+               # cas : RESU_aaa ou (RESU_8 avec RESU[8] non initialisé)
+               pass
+      # pour tous les concepts :
+      if d.has_key(nom):
+         del d[nom]
+      if self.jdc.sds_dict.has_key(nom):
+         del self.jdc.sds_dict[nom]
+      # On signale au parent que le concept s n'existe plus apres l'étape self 
+      self.parent.delete_concept_after_etape(self, co)
+
+
+def subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR):
+   """
+       Cette fonction retourne un texte obtenu à partir du texte passé en argument (text)
+       en substituant le nom du materiau par NOM_MATER 
+       et en réalisant les extractions spéciifées dans EXTRACTION
+   """
+   lines=string.split(text,'\n')
+
+##### traitement de UNIT : facteur multiplicatif puissance de 10
+   regmcsu=re.compile(r" *(.*) *= *([^ ,]*) *## +([^ ]*) *([^ ]*)")
+   ll_u=[]
+   for l in lines:
+       m=regmcsu.match(l)
+       if m:
+          if m.group(3) == "UNIT":
+             if   UNITE_LONGUEUR=='M'  : coef = '0'
+             elif UNITE_LONGUEUR=='MM' : coef = m.group(4)
+             ll_u.append(m.group(1)+" = "+m.group(2)+coef)
+          else : ll_u.append(l)
+       else : ll_u.append(l)
+
+##### traitement de EXTRACTION
+   if EXTRACTION:
+     regmcf=re.compile(r" *(.*) *= *_F\( *## +(.*) +(.*)")
+     regmcs=re.compile(r" *(.*) *= *([^ ,]*) *, *## +([^ ]*) *([^ ]*)")
+     regfin=re.compile(r" *\) *")
+     ll=[]
+     temps={};lmcf=[]
+     for e in EXTRACTION:
+       mcf=e['COMPOR']
+       lmcf.append(mcf)
+       temps[mcf]=e['TEMP_EVAL']
+     FLAG=0
+     for l in ll_u:
+       m=regmcf.match(l)
+       if m: # On a trouve un mot cle facteur "commentarise"
+         if m.group(2) == "SUBST": # il est de plus substituable
+           if temps.has_key(m.group(3)): # Il est a substituer
+             ll.append(" "+m.group(3)+"=_F(")
+             mcf=m.group(3)
+             TEMP=temps[mcf]
+             FLAG=1 # Indique que l'on est en cours de substitution
+           else: # Il n est pas a substituer car il n est pas dans la liste demandee
+             ll.append(l)
+         else: # Mot cle facteur commentarise non substituable
+           ll.append(l)
+       else:  # La ligne ne contient pas un mot cle facteur commentarise
+         if FLAG == 0: # On n est pas en cours de substitution
+           ll.append(l)
+         else: # On est en cours de substitution. On cherche les mots cles simples commentarises
+           m=regmcs.match(l)
+           if m: # On a trouve un mot cle simple commentarise
+             if m.group(3) == "EVAL":
+               ll.append("  "+m.group(1)+' = '+m.group(4)+"("+str(TEMP)+'),')
+             elif m.group(3) == "SUPPR":
+               pass
+             else:
+               ll.append(l)
+           else: # On cherche la fin du mot cle facteur en cours de substitution
+             m=regfin.match(l)
+             if m: # On l a trouve. On le supprime de la liste
+               FLAG=0
+               del temps[mcf]
+             ll.append(l)
+   else:
+     ll=ll_u
+
+   lines=ll
+   ll=[]
+   for l in lines:
+     l=re.sub(" *MAT *= *",NOM_MATER+" = ",l,1)
+     ll.append(l)
+   text=string.join(ll,'\n')
+   return text
+
+def post_INCLUDE(self):
+  """
+      Cette fonction est executée apres toutes les commandes d'un INCLUDE (RETOUR)
+      Elle sert principalement pour les INCLUDE_MATERIAU : remise a blanc du prefixe Fortran
+  """
+  self.codex.opsexe(self,0,-1,2)
+
+def INCLUDE_MATERIAU(self,NOM_AFNOR,TYPE_MODELE,VARIANTE,TYPE_VALE,NOM_MATER,
+                    EXTRACTION,UNITE_LONGUEUR,INFO,**args):
+  """ 
+      Fonction sd_prod pour la macro INCLUDE_MATERIAU
+  """
+  mat=string.join((NOM_AFNOR,'_',TYPE_MODELE,'_',VARIANTE,'.',TYPE_VALE),'')
+  if not hasattr(self,'mat') or self.mat != mat or self.nom_mater != NOM_MATER :
+    # On récupère le répertoire des matériaux dans les arguments 
+    # supplémentaires du JDC
+    rep_mat=self.jdc.args.get("rep_mat","NOrep_mat")
+    f=os.path.join(rep_mat,mat)
+    self.mat=mat
+    self.nom_mater=NOM_MATER
+    if not os.path.isfile(f):
+       del self.mat
+       self.make_contexte(f,"#Texte sans effet pour reinitialiser le contexte a vide\n")
+       raise "Erreur sur le fichier materiau: "+f
+    # Les materiaux sont uniquement disponibles en syntaxe Python
+    # On lit le fichier et on supprime les éventuels \r
+    text=string.replace(open(f).read(),'\r\n','\n')
+    # On effectue les substitutions necessaires
+    self.text= subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR)
+    if INFO == 2:
+      print "INCLUDE_MATERIAU: ", self.mat,' ',NOM_MATER,'\n'
+      print self.text
+    # on execute le texte fourni dans le contexte forme par
+    # le contexte de l etape pere (global au sens Python)
+    # et le contexte de l etape (local au sens Python)
+    # Il faut auparavant l'enregistrer aupres du module linecache (utile pour nommage.py)
+    linecache.cache[f]=0,0,string.split(self.text,'\n'),f
+
+    self.postexec=post_INCLUDE
+
+    if self.jdc.par_lot == 'NON':
+      # On est en mode commande par commande, on appelle la methode speciale
+      self.Execute_alone()
+
+    self.make_contexte(f,self.text)
+    for k,v in self.g_context.items() :
+        if isinstance(v,ASSD) and k!=v.nom : del self.g_context[k]
+
+def build_procedure(self,**args):
+    """
+    Fonction ops de la macro PROCEDURE appelée lors de la phase de Build
+    """
+    ier=0
+    # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
+    # le numero de la commande n est pas utile en phase de construction
+    # On ne numérote pas une macro PROCEDURE (incrément=None)
+    self.set_icmd(None)
+    icmd=0
+    #ier=self.codex.opsexe(self,icmd,-1,3)
+    return ier
+
+def build_DEFI_FICHIER(self,**args):
+    """
+    Fonction ops de la macro DEFI_FICHIER
+    """
+    ier=0
+    self.set_icmd(1)
+    icmd=0
+    ier=self.codex.opsexe(self,icmd,-1,26)
+    return ier

diff --git a/Aster/Cata/cataSTA9/Macro/calc_ecrevisse_ops.py b/Aster/Cata/cataSTA9/Macro/calc_ecrevisse_ops.py
new file mode 100644 (file)
index 0000000..b14842d
--- /dev/null
+++ b/Aster/Cata/cataSTA9/Macro/calc_ecrevisse_ops.py
@@ -0,0 +1,799 @@
+#@ MODIF calc_ecrevisse_ops Macro  DATE 05/10/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+
+# Debut de la macro, on impose en parametre les donnees placer dans T_EC, l'appel a ecrevisse
+
+def calc_ecrevisse_ops(self,
+    CHARGE_MECA,
+    CHARGE_THER1,
+    CHARGE_THER2,
+    TABLE,
+    DEBIT,
+    MODELE_MECA,
+    MODELE_THER,
+    RESULTAT,
+    FISSURE,
+    ECOULEMENT,
+    MODELE_ECRE,
+    CONVERGENCE,
+    LOGICIEL,
+    VERSION,
+    ENTETE,
+    IMPRESSION,
+    INFO,
+    COURBES,
+    **args):
+
+    """
+        Procedure de couplage Aster-Ecrevisse
+        Recuperation du profil de la fissure , appel de MACR_ECRE_CALC, 
+        creation des tableaux de resultats et des chargements pour AsterGeneration par Aster
+    """
+
+    import os, string, types, shutil
+    import aster
+    from Accas import _F
+    from Noyau.N_utils import AsType
+    from Utilitai.Utmess import UTMESS
+    from Utilitai.Table import Table, merge
+    from math import atan, pi, sqrt
+
+    ier=0
+
+    # Concepts sortant
+    self.DeclareOut('__TAB',TABLE)
+    self.DeclareOut('__ECR_F1',CHARGE_THER1)
+    self.DeclareOut('__ECR_F2',CHARGE_THER2)
+    self.DeclareOut('__ECR_P',CHARGE_MECA)
+    self.DeclareOut('__DEB',DEBIT)
+
+
+    # La macro compte pour 1 dans la numerotation des commandes
+    self.set_icmd(1)
+
+    # Parametres Developpeur
+    tmp_ecrevisse = "tmp_ecrevisse"
+    fichier_data = "data.dat"
+    defaut = '00'
+    # Niveaux de debug
+    debug1 = (INFO>1)
+    debug2 = (INFO>2)
+    #
+    InfoAster = 1
+    #
+    oldVersion = False  # Permet de retourner un chargement thermique defini selon l'ancien mode (flux thermique)
+
+    # IMPORTATION DE COMMANDES ASTER
+    DEFI_GROUP       = self.get_cmd("DEFI_GROUP")
+    POST_RELEVE_T    = self.get_cmd("POST_RELEVE_T")
+    MACR_ECRE_CALC   = self.get_cmd("MACR_ECRE_CALC")
+    IMPR_TABLE       = self.get_cmd("IMPR_TABLE")
+    DETRUIRE         = self.get_cmd("DETRUIRE")
+    IMPR_CO          = self.get_cmd("IMPR_CO")
+    DEFI_FONCTION    = self.get_cmd("DEFI_FONCTION")
+    CREA_TABLE       = self.get_cmd("CREA_TABLE")
+    CO               = self.get_cmd("CO")
+    AFFE_CHAR_THER_F = self.get_cmd("AFFE_CHAR_THER_F")
+    AFFE_CHAR_MECA_F = self.get_cmd("AFFE_CHAR_MECA_F")
+    DEFI_FICHIER     = self.get_cmd("DEFI_FICHIER")
+
+    # RECUPERATION DES MOTS-CLES FACTEURS
+    dRESULTAT=RESULTAT[0].cree_dict_valeurs(RESULTAT[0].mc_liste)
+    for i in dRESULTAT.keys():
+        if dRESULTAT[i]==None : del dRESULTAT[i]
+
+    dECOULEMENT=ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
+    for i in dECOULEMENT.keys():
+        if dECOULEMENT[i]==None : del dECOULEMENT[i]
+
+    dMODELE_ECRE=MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
+    for i in dMODELE_ECRE.keys():
+        if dMODELE_ECRE[i]==None : dMODELE_ECRE[i]=None #del dMODELE_ECRE[i]
+
+    dCONVERGENCE=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+    for i in dCONVERGENCE.keys():
+        if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
+
+    # Instants
+    _l_inst = dRESULTAT['MECANIQUE'].LIST_VARI_ACCES()
+    if dRESULTAT.has_key('INST'):
+        Inst_Ecrevisse = dRESULTAT['INST']
+    else:
+        pass
+
+    # ancienne version
+    # liste des mots cles facteurs de FLUX_REP pour le flux F1 de chaque fissure (sur GROUP_MA[0])
+    l_FLUX_REP_F1 = []
+    # liste des mots cles facteurs de PRES_REP pour le flux F2 de  chaque fissure (sur GROUP_MA[1])
+    l_FLUX_REP_F2 = []
+    
+    # nouvelle version
+    # liste des mots cles facteurs de ECHANGE pour le flux F1 de chaque fissure (sur GROUP_MA[0])
+    l_ECHANGE_F1 = []
+    # liste des mots cles facteurs de ECHANGE pour le flux F2 de chaque fissure (sur GROUP_MA[1])
+    l_ECHANGE_F2 = []
+    
+    # Toutes versions
+    # liste des mots cles facteurs de PRES_REP pour chaque fissure
+    l_PRES_REP = []
+
+
+    # Liste des noms des groupes de noeuds du maillage
+    _lgno = map(lambda x: x[0], MODELE_MECA['MAILLAGE'].LIST_GROUP_NO() )
+
+    for k, fissure in enumerate(FISSURE):
+        dFISSURE=fissure.cree_dict_valeurs(fissure.mc_liste)
+        for i in dFISSURE.keys():
+            if dFISSURE[i]==None : del dFISSURE[i]
+
+        # On cree les group_no correspondant aux group_ma des levres de la fissure dans le cas ou ils n'existent pas deja
+        if not dFISSURE['GROUP_MA'][0] in _lgno:
+            DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                       MAILLAGE=MODELE_MECA['MAILLAGE'],
+                       CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][0]),),);
+
+        if not dFISSURE['GROUP_MA'][1] in _lgno:
+            DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                       MAILLAGE=MODELE_MECA['MAILLAGE'],
+                       CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),),);
+
+        # Test sur le nombre de caracteres du nom des group_ma
+        if len(dFISSURE['GROUP_MA'][0]) >7:
+            sys.exit(1)
+
+        if len(dFISSURE['GROUP_MA'])>1 and len(dFISSURE['GROUP_MA'][1]) >7:
+            sys.exit(1)
+
+        # Creation des group_no ordonnes des levres des fissures
+        _nom_gno_1 = '_' + dFISSURE['GROUP_MA'][0]
+        if not _nom_gno_1 in _lgno:
+            DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                       MAILLAGE=MODELE_MECA['MAILLAGE'],
+                       CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
+                                        NOM=_nom_gno_1,
+                                        GROUP_NO=dFISSURE['GROUP_MA'][0],
+                                        GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][0],
+                                        GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][0],
+                                        PRECISION=0.001,
+                                        CRITERE='ABSOLU',),
+                       INFO=InfoAster,);
+
+
+        if len(dFISSURE['GROUP_MA'])>1:
+            _nom_gno_2 = '_' + dFISSURE['GROUP_MA'][1]
+            if not _nom_gno_2 in _lgno:
+                DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+                           MAILLAGE=MODELE_MECA['MAILLAGE'],
+                           CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
+                                            NOM=_nom_gno_2,
+                                            GROUP_NO=dFISSURE['GROUP_MA'][1],
+                                            GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][1],
+                                            GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][1],
+                                            PRECISION=0.001,
+                                            CRITERE='ABSOLU',),
+                           INFO=InfoAster,);
+
+        _T_DY=POST_RELEVE_T(ACTION=_F(INTITULE='DEPL_FIS',
+                                      GROUP_NO=_nom_gno_1,
+                                      RESULTAT=dRESULTAT['MECANIQUE'],
+                                      NOM_CHAM='DEPL',
+                                      NOM_CMP=('DX','DY',),
+                                      INST = Inst_Ecrevisse,
+                                      OPERATION='EXTRACTION',),
+                                      );
+
+        if len(dFISSURE['GROUP_MA'])>1:
+            # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
+            # represente par une seule levre et l'autre est fixe
+            _T_DY_B=POST_RELEVE_T(ACTION=_F(INTITULE='DX_FIS',
+                                            GROUP_NO=_nom_gno_2,
+                                            RESULTAT=dRESULTAT['MECANIQUE'],
+                                            NOM_CHAM='DEPL',
+                                            NOM_CMP=('DX','DY',),
+                                            INST = Inst_Ecrevisse,
+                                            OPERATION='EXTRACTION',),);
+
+        _T_TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
+                                        GROUP_NO=_nom_gno_1,
+                                        RESULTAT=dRESULTAT['THERMIQUE'],
+                                        NOM_CHAM='TEMP',
+                                        TOUT_CMP='OUI',
+                                        INST = Inst_Ecrevisse,
+                                        OPERATION='EXTRACTION',),);
+
+        if len(dFISSURE['GROUP_MA'])>1:
+            _T_TEMPB=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
+                                             GROUP_NO=_nom_gno_2,
+                                             RESULTAT=dRESULTAT['THERMIQUE'],
+                                             NOM_CHAM='TEMP',
+                                             TOUT_CMP='OUI',
+                                             INST = Inst_Ecrevisse,
+                                             OPERATION='EXTRACTION',),);
+
+        if ( debug2 ) :
+            print '_T_DY ==================================================='
+            print  _T_DY.EXTR_TABLE()
+            print '_T_TEMP ================================================='
+            print  _T_TEMP.EXTR_TABLE()
+
+
+        # Extraction des tables Temperatures + deplacement levres fissure
+        _tbl_temp = _T_TEMP.EXTR_TABLE()
+        _tbl_dy   = _T_DY.EXTR_TABLE()
+        DETRUIRE(CONCEPT=_F(NOM=(_T_DY,_T_TEMP,)),INFO=1,ALARME='NON')
+        
+        # Determination de la direction de la fissure : limitee aux cas horizontal ou vertical a cause
+        # de la creation des chargement pour aster
+        
+        _xih = _tbl_dy.values()['COOR_X'][0] 
+        _yih = _tbl_dy.values()['COOR_Y'][0] 
+        _xeh = _tbl_dy.values()['COOR_X'][-1] 
+        _yeh = _tbl_dy.values()['COOR_Y'][-1]    
+
+        if abs(_xeh -_xih)<1.E-6 : # fissure verticale
+
+           if (_yeh-_yih)<0 : # fluide du haut vers le bas
+              alpha = 180.  
+           else :
+              alpha =0.   # fluide du bas vers le haut
+           DIR_FISS='Y'
+           NORM_FISS='X'
+        elif abs(_yih - _yeh)<1.E-6 : # fissure horizontale
+           alpha = 90.
+           DIR_FISS ='X'
+           NORM_FISS = 'Y'
+        else:
+           UTMESS('F','ECREVISSE0_23')
+        
+#        Determination de l'ouverture de la fissure
+
+        _l_dy1 = _tbl_dy.values()['ABSC_CURV']
+        _l_dy2 = [ x + y for (x,y) in zip(_tbl_dy.values()['D%s' % NORM_FISS], _tbl_dy.values()['COOR_%s' % NORM_FISS]) ]
+
+        # Listes des cotes et ouvertures (deuxieme groupe)
+        if len(dFISSURE['GROUP_MA'])>1:
+            # signifie que l'on prend en compte la deuxieme levre de la fissure,
+            _tbl_dy_b  = _T_DY_B.EXTR_TABLE()
+            _tbl_temp_b = _T_TEMPB.EXTR_TABLE()
+            DETRUIRE(CONCEPT=_F(NOM=(_T_DY_B,_T_TEMPB,)),INFO=1,ALARME='NON')
+            
+            _l_dy1_b = _tbl_dy_b.values()['ABSC_CURV']
+            _l_dy2_b = [ x + y for (x,y) in zip(_tbl_dy_b.values()['D%s' % NORM_FISS], _tbl_dy_b.values()['COOR_%s' % NORM_FISS]) ]
+
+        # Listes des cotes et temperatures (premier groupe)
+        _l_t1  = _tbl_temp.values()['ABSC_CURV']
+        _l_t2  = _tbl_temp.values()['TEMP']
+        
+        # Listes des cotes et temperatures (deuxieme groupe)
+        if len(dFISSURE['GROUP_MA'])>1:
+            # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
+            # represente par une seule levre et l'autre est fixe
+
+            _l_t1_b  = _tbl_temp_b.values()['ABSC_CURV']
+            _l_t2_b  = _tbl_temp_b.values()['TEMP']
+
+
+        if ( debug2 ):
+            print "Informations de debug:\n"
+            print 'Inst_Ecrevisse=', Inst_Ecrevisse
+            print '_l_t1=', len(_l_t1),_l_t1
+            print '_l_t2=', len(_l_t2),_l_t2
+            print '_l_dy1=', len(_l_dy1),_l_dy1
+            print '_l_dy2=', len(_l_dy2),_l_dy2
+
+            if len(dFISSURE['GROUP_MA'])>1:
+                print '_l_t1_b=', len(_l_t1_b),_l_t1_b
+                print '_l_t2_b=', len(_l_t2_b),_l_t2_b
+                print '_l_dy1_b=', len(_l_dy1_b),_l_dy1_b
+                print '_l_dy2_b=', len(_l_dy2_b),_l_dy2_b
+
+
+        # Affichage d'informations que l'on peut voir sur le fichier .mess ou .resu
+
+        if (debug1):
+           UTMESS('I', 'ECREVISSE0_1', valk=["Premiere levre"],
+                valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
+
+           if len(dFISSURE['GROUP_MA'])>1:
+               UTMESS('I', 'ECREVISSE0_1',valk=["Deuxieme levre"],
+                    valr=[Inst_Ecrevisse,min(_l_t1_b), max(_l_t1_b), min(_l_t2_b), max(_l_t2_b), min(_l_dy1_b), max(_l_dy1_b), min(_l_dy2_b), max(_l_dy2_b)])
+
+
+        # ----------------------------------------------------------------------------------
+        # Partie concernant la prise en compte des deux levres
+        if len(dFISSURE['GROUP_MA'])>1:
+
+            # Calcul de l'ouverture entre les deux levres
+            _l_dy2 = map(lambda x,y: abs(y-x), _l_dy2, _l_dy2_b)
+
+            # Pour la temperature, on fait la moyenne des temperatures des deux levres (points a ameliorer peut etre par un autre modele)
+            _l_t2  = map(lambda x,y: 0.5*(x+y), _l_t2_b,_l_t2)
+
+        # ----------------------------------------------------------------------------------
+        
+        if dFISSURE['OUVERT_REMANENTE']:
+            # une fissure refermee a une ouverture egale a l'ouverture remanente
+            _l_dy2 = map(lambda x: max(dFISSURE['OUVERT_REMANENTE'],x), _l_dy2)
+        
+        UTMESS('I', 'ECREVISSE0_2',
+                valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
+
+
+        if ( debug2 ):
+            print "Informations de debug:\n"
+            print 'Inst_Ecrevisse=', Inst_Ecrevisse
+            print '_l_t1=', len(_l_t1),_l_t1
+            print '_l_t2=', len(_l_t2),_l_t2
+            print '_l_dy1=', len(_l_dy1),_l_dy1
+            print '_l_dy2=', len(_l_dy2),_l_dy2
+
+        # Test de non divergence, les messages sont assez explicites
+
+        # Si toutes les listes sont bien definies
+        if len(_l_dy1)*len(_l_dy2)*len(_l_t1)*len(_l_t2) == 0:
+            UTMESS('F','ECREVISSE0_3', valr=[Inst_Ecrevisse])
+            __TAB = None
+            break
+
+        # Si les ouvertures ne sont pas trop faibles
+        elif min(_l_dy2) < 1e-20:
+            UTMESS('F','ECREVISSE0_4', valr=[Inst_Ecrevisse, min(_l_dy2)])
+            __TAB = None
+            break
+
+        elif max(_l_t2) > 700:
+            UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2 )])
+            __TAB = None
+            break
+
+        elif max(_l_t2_b) > 700:
+            UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2_b )])
+            __TAB = None
+            break
+
+        elif min(_l_t2) < 0:
+            UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2 )])
+            __TAB = None
+            break
+
+        elif min(_l_t2_b) < 0:
+            UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2_b )])
+            __TAB = None
+            break
+
+        elif abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) )< 5:
+            UTMESS('F','ECREVISSE0_7', valr=[Inst_Ecrevisse, abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) ) ] )
+            __TAB = None
+            break
+
+        # On lance Ecrevisse
+        else:
+            UTMESS('I','ECREVISSE0_8', valr=[Inst_Ecrevisse])
+
+            # On efface le rep
+            try:
+                for fic in os.listdir(os.path.join(os.getcwd(),tmp_ecrevisse)):
+                    try:
+                        os.remove( os.path.join(os.getcwd(),tmp_ecrevisse) + '/' + fic )
+                    except:
+                        pass
+            except:
+                pass
+
+            if dFISSURE.has_key('LISTE_COTES_BL'):
+                __LISTE_COTES_BL = dFISSURE['LISTE_COTES_BL']
+            else:
+                __LISTE_COTES_BL = (0., max(_l_dy1))
+
+            # Mot-cle ECOULEMENT
+            txt={}
+            txt = { 'PRES_ENTREE' : dECOULEMENT['PRES_ENTREE'],
+                    'PRES_SORTIE' : dECOULEMENT['PRES_SORTIE'],
+                    'FLUIDE_ENTREE'   : dECOULEMENT['FLUIDE_ENTREE'],
+                    }
+            if int(dECOULEMENT['FLUIDE_ENTREE']) in [1, 3, 4, 6]:
+                txt['TEMP_ENTREE'] = dECOULEMENT['TEMP_ENTREE']
+            if int(dECOULEMENT['FLUIDE_ENTREE']) in [2, 5]:
+                txt['TITR_MASS'] = dECOULEMENT['TITR_MASS']
+            if int(dECOULEMENT['FLUIDE_ENTREE']) in [4, 5]:
+                txt['PRES_PART'] = dECOULEMENT['PRES_PART']
+
+
+            # Traitement des cas ou les mots cles reynold, xminch, etc... ne doivent pas apparaitre
+            # Mot-cle MODELE_ECRE
+            txt2 = {}
+            txt2['ECOULEMENT'] = dMODELE_ECRE['ECOULEMENT']
+            if dMODELE_ECRE['ECOULEMENT'] == 'GELE' :
+                txt2['PRESS_EBULLITION'] = dMODELE_ECRE['PRESS_EBULLITION']
+
+            txt2['FROTTEMENT'] = dMODELE_ECRE['FROTTEMENT']
+
+            if int(dMODELE_ECRE['FROTTEMENT']) in [-4,-3,-2,-1] :
+                txt2['REYNOLDS_LIM'] = dMODELE_ECRE['REYNOLDS_LIM']
+                txt2['FROTTEMENT_LIM'] = dMODELE_ECRE['FROTTEMENT_LIM']
+
+            txt2['TRANSFERT_CHAL'] = dMODELE_ECRE['TRANSFERT_CHAL']
+            if int(dMODELE_ECRE['TRANSFERT_CHAL']) in [-2,-1] :
+                txt2['XMINCH'] = dMODELE_ECRE['XMINCH']
+                txt2['XMAXCH'] = dMODELE_ECRE['XMAXCH']
+
+            try :
+                if dMODELE_ECRE['IVENAC'] in [0, 1]:
+                    txt2['IVENAC'] = dMODELE_ECRE['IVENAC']
+                else :
+                    txt2['IVENAC'] = 0
+            except :
+                txt2['IVENAC'] = 0
+
+            motscle2= {'ECOULEMENT': txt, 'MODELE_ECRE' : txt2 }
+
+            DETRUIRE(OBJET=_F(CHAINE = '_TAB2' ),INFO=1,ALARME='NON')
+            DETRUIRE(OBJET=_F(CHAINE = '_DEB2' ),INFO=1,ALARME='NON')
+            __TAB_i = CO('_TAB2')
+            __DEB_i = CO('_DEB2')
+
+            MACR_ECRE_CALC(TABLE = __TAB_i,
+                           DEBIT = __DEB_i,
+                           ENTETE=ENTETE,
+                           COURBES=COURBES,
+                           IMPRESSION=IMPRESSION,
+                           INFO=INFO,
+                           LOGICIEL=LOGICIEL,
+                           VERSION=VERSION,
+                           FISSURE=_F(LONGUEUR           = max(_l_dy1)/dFISSURE['TORTUOSITE'],
+                                   ANGLE              = alpha,
+                                   RUGOSITE           = dFISSURE['RUGOSITE'],
+                                   ZETA               = dFISSURE['ZETA'],
+                                   SECTION            = dFISSURE['SECTION'],
+                                   LISTE_COTES_AH     = _l_dy1,
+                                   LISTE_VAL_AH       = _l_dy2,
+                                   LISTE_COTES_BL     = __LISTE_COTES_BL,
+                                   LISTE_VAL_BL       = dFISSURE['LISTE_VAL_BL'],
+                                   ),
+                           TEMPERATURE=_F(GRADIENT       = 'FOURNI',
+                                       LISTE_COTES_TEMP = _l_t1,
+                                       LISTE_VAL_TEMP   = _l_t2,
+                                       ),
+                           CONVERGENCE=_F(KGTEST         = dCONVERGENCE['KGTEST'],
+                                       ITER_GLOB_MAXI = dCONVERGENCE['ITER_GLOB_MAXI'],
+                                       CRIT_CONV_DEBI = dCONVERGENCE['CRIT_CONV_DEBI'],
+                                       ),
+                           **motscle2
+                           );
+            
+            # Creation de la table resultat sur toutes les fissures:
+
+            # Nom de la fissure
+            nom_fiss = dFISSURE['GROUP_MA'][0] + "-" + dFISSURE['GROUP_MA'][1]
+            # Creation de la table
+            __TABFISS_i = __TAB_i.EXTR_TABLE()
+            __DEBFISS_i = __DEB_i.EXTR_TABLE()
+            # Taille de la table
+            nb_lignes_table = len(__TABFISS_i["COTES"])
+            # Ajout d'une colonne supplementaire
+            __TABFISS_i["FISSURE"] = [nom_fiss] * nb_lignes_table
+            __DEBFISS_i["FISSURE"] = [nom_fiss]
+            if k==0:
+                __TABFISS_tot = __TABFISS_i
+                __DEBFISS_tot = __DEBFISS_i
+            else:
+                __TABFISS_tot = merge(__TABFISS_tot, __TABFISS_i)
+                __DEBFISS_tot = merge(__DEBFISS_tot, __DEBFISS_i)
+            
+            
+            DETRUIRE(OBJET=_F(CHAINE = '__TAB_i' ),INFO=1,ALARME='NON')
+            DETRUIRE(OBJET=_F(CHAINE = '__DEB_i' ),INFO=1,ALARME='NON')
+
+            if ( debug2 ):
+               os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+
+            pref_fic = dFISSURE['PREFIXE_FICHIER']
+
+            # Ecriture du fichier debits en fonction du temps:
+            try:
+                # on lit le fichier debit produit par ecrevisse
+                f_ast = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+                _txt = f_ast.read()
+                f_ast.close()
+                nomfic = str(pref_fic) + '_debits'
+                # on concatene
+                fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic, 'a')
+                fw.write( str(Inst_Ecrevisse) + ' ' + _txt )
+                fw.close()
+                # On recopie le fichier debits pour reprise ulterieure
+                nomfic2 = 'debits_dernier'
+                fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic2, 'w')
+                fw.write( _txt )
+                fw.close()
+            except Exception, e:
+                print e
+
+
+            if COURBES != "AUCUNE":
+              # Pour masquer certaines alarmes
+              from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
+              MasquerAlarme('TABLE0_6')
+ 
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_flux')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','FLUX',),
+                         TITRE='Flux de chaleur a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Flux (W/m2)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_temperature')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','TEMP',),
+                         TITRE='Temperature a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Temperature (degres C)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_coeffconv')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','COEF_CONV',),
+                         TITRE='Coefficient de convection a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Coefficient de convection (W/m2/K)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+              
+              nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_pression')
+              if not os.path.isfile(nomfic): acces='NEW'
+              else: acces='APPEND'
+
+              DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+              IMPR_TABLE(FORMAT='XMGRACE',
+                         TABLE=__TAB_i,
+                         UNITE=55,
+                         PILOTE=COURBES,
+                         NOM_PARA=('COTES','PRESSION',),
+                         TITRE='Pression a l\'instant %s' % Inst_Ecrevisse,
+                         LEGENDE_X='Abscisse curviligne (m)',
+                         LEGENDE_Y='Pression (Pa)',
+                        );
+              DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+              
+              # Pour la gestion des alarmes
+              RetablirAlarme('TABLE0_6')
+
+
+            # On recopie dans REPE_OUT les fichiers resultats d'Ecrevisse
+            tmp_ecrevisse_absolu = os.path.join(os.getcwd(),tmp_ecrevisse)
+            repe_out_absolu = os.path.join(os.getcwd(),'REPE_OUT')
+            for file in os.listdir(tmp_ecrevisse_absolu):
+                if not file in ['ecrevisse', 'ecrevisse.sh']:
+                    old_file = os.path.join(tmp_ecrevisse_absolu, file)
+                    new_file = os.path.join(repe_out_absolu, str(pref_fic) + '_' + file + '_' + str(Inst_Ecrevisse))
+                    shutil.copy(old_file, new_file)
+
+            if ( debug2 ):
+                os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+
+
+            # Creation des chargements Aster
+            # ******************************
+
+            # Recuperation des valeurs dans la table (voir si il y a plus simple)
+            _lst_c = __TABFISS_i.COTES.values()
+            _lst_f = __TABFISS_i.FLUX.values()
+            _lst_p = __TABFISS_i.PRESSION.values()
+            _lst_t = __TABFISS_i.TEMP.values()
+            _lst_cc = __TABFISS_i.COEF_CONV.values()
+
+            _lis_dtot = __TABFISS_i.DEBTOT.values()
+            _lis_dair = __TABFISS_i.DEBAIR.values()
+            _lis_dvap = __TABFISS_i.DEBVAP.values()
+            _lis_dliq = __TABFISS_i.DEBLIQ.values()
+            _lis_ecou = __TABFISS_i.ECOULEMENT.values()
+            
+            if ( debug2 ):
+                print '_lst_c2=',_lst_c
+                print '_lst_f2=',_lst_f
+                print '_lst_p2=',_lst_p
+                print '_lst_t2=',_lst_t
+                print '_lst_cc2=',_lst_cc
+
+            try:
+                a=len(_lst_c)
+            except:
+                _lst_c = []
+                _lst_f = []
+                _lst_p = []
+                _lst_t = []
+                _lst_cc = []
+            try:
+                if _lst_c[1]==0:
+                    _lst_c = []
+                    _lst_f = []
+                    _lst_p = []
+                    _lst_t = []
+                    _lst_cc = []
+            except:
+                pass
+
+
+            # ------------------------------------------------------
+            # Extraction des conditions limites du calcul Ecrevisse
+            #
+            if len(_lst_c)>=2:
+                if ( debug2 ):
+                  print '_lst_c=',_lst_c
+                  print '_lst_f=',_lst_f
+                  print '_lst_p=',_lst_p
+                  print '_lst_t=',_lst_t
+                  print '_lst_cc=',_lst_cc
+
+                _lst_f=list(_lst_f)
+                _lst_p=list(_lst_p)
+                _lst_t=list(_lst_t)
+                _lst_cc=list(_lst_cc)
+
+                # decalage par rapport a l'abscisse curviligne (a regler)
+                _x0 = 0.001
+
+                # ANCIENNE VERSION (TRANSMISSION DES FLUX THERMIQUES
+                if(oldVersion) :
+                    # Creation des deux listes (x1, y1, x2, y2, ...)
+                    _tmp1=[]
+                    _tmp2=[]
+                    _tmp3=[]
+
+                    for i in range(len(_lst_c)):
+                        _tmp1.append( _x0 + _lst_c[i] )
+                        _tmp1.append( _lst_f[i] )
+                        _tmp3.append( _x0 + _lst_c[i] )
+                        _tmp3.append( -1*_lst_f[i] )
+
+                        _tmp2.append( _x0 + _lst_c[i] )
+                        _tmp2.append( _lst_p[i] )
+
+                    # Flux en provenance d'Ecrevisse
+
+                    _L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp1,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    _L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp3,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT' );
+
+                    l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+                                                            FLUX_X=_L_F1,))
+
+                    l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+                                                            FLUX_X=_L_F2,))
+
+                    # Pressions en provenance d'Ecrevisse
+                    _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp2,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
+                                                            PRES=_L_P,))
+
+                # NOUVELLE VERSION
+                else :
+
+                    # Creation des deux listes (x1, y1, x2, y2, ...)
+                    _tmp1=[]
+                    _tmp2=[]
+                    _tmp3=[]
+
+                    for i in range(len(_lst_c)):
+                        # On cree trois listes :
+                        #  _tmp1=temperature en chaque point du maillage,
+                        #  _tmp3=coefficient d echange en chaque point du maillage
+                        #  _tmp2=pression en chaque point du maillage
+                        _tmp1.append( _x0 + _lst_c[i] )
+                        _tmp1.append( _lst_t[i] )
+                        _tmp3.append( _x0 + _lst_c[i] )
+                        _tmp3.append( _lst_cc[i] )
+
+                        _tmp2.append( _x0 + _lst_c[i] )
+                        _tmp2.append( _lst_p[i] )
+
+                    _L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp1,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    _L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp3,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    l_ECHANGE_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+                                                            TEMP_EXT=_L_F1,
+                                                            COEF_H=_L_F2))
+
+                    l_ECHANGE_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+                                                            TEMP_EXT=_L_F1,
+                                                            COEF_H=_L_F2))
+
+                    # Pressions en provenance d'Ecrevisse
+                    _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+                                        VALE=_tmp2,
+                                        PROL_GAUCHE='CONSTANT',
+                                        PROL_DROITE='CONSTANT');
+
+                    l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
+                                                            PRES=_L_P,))
+
+            #
+            # Fin extraction des conditions limites du calcul Ecrevisse
+            # ----------------------------------------------------------
+
+        # Fin de la boucle sur les fissures
+
+
+
+    # Assemblage des concepts sortants
+    if(oldVersion) :
+        __ECR_F1=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  FLUX_REP=l_FLUX_REP_F1);
+
+        __ECR_F2=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  FLUX_REP=l_FLUX_REP_F2);
+    else:
+        __ECR_F1=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  ECHANGE=l_ECHANGE_F1);
+
+        __ECR_F2=AFFE_CHAR_THER_F(MODELE=MODELE_THER,
+                                  ECHANGE=l_ECHANGE_F2);
+
+    __ECR_P=AFFE_CHAR_MECA_F(MODELE=MODELE_MECA,
+                             PRES_REP=l_PRES_REP);
+
+    # Table resultat
+    try:
+       dprod = __TABFISS_tot.dict_CREA_TABLE()
+       __TAB = CREA_TABLE(**dprod)
+       debprod = __DEBFISS_tot.dict_CREA_TABLE()
+       __DEB = CREA_TABLE(**debprod)
+    except:
+       UTMESS('F','ECREVISSE0_9', valr=[Inst_Ecrevisse])

diff --git a/Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py b/Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py
index ba32578ab19c4e4a99fba5024a2bcd9132a8784a..68b6c630aa95af6e51db6d64cad743d6747114d8 100644 (file)
--- a/Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py
+++ b/Aster/Cata/cataSTA9/Macro/calc_europlexus_ops.py
@@ -1,4 +1,4 @@
-#@ MODIF calc_europlexus_ops Macro  DATE 28/04/2009   AUTEUR ASSIRE A.ASSIRE 
+#@ MODIF calc_europlexus_ops Macro  DATE 18/11/2009   AUTEUR MACOCCO K.MACOCCO 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -2315,7 +2315,8 @@ class EUROPLEXUS:
   def lancer_calcul(self,fichier_med='auto'):
 
      fichier_epx = self.nom_fichiers['COMMANDE']
-     EXEC_LOGICIEL(LOGICIEL='cd %s ; %s %s ; iret=$? ; cd %s ; exit $iret' % (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)
 
 

diff --git a/Aster/Cata/cataSTA9/Macro/exec_logiciel_ops.py b/Aster/Cata/cataSTA9/Macro/exec_logiciel_ops.py
index 964c2600ec96f4ee830f358d82920369794d0c8b..30218ea7651aaad774144960dac91011a00d9a58 100644 (file)
--- a/Aster/Cata/cataSTA9/Macro/exec_logiciel_ops.py
+++ b/Aster/Cata/cataSTA9/Macro/exec_logiciel_ops.py
@@ -1,4 +1,4 @@
-#@ MODIF exec_logiciel_ops Macro  DATE 21/10/2008   AUTEUR COURTOIS M.COURTOIS 
+#@ MODIF exec_logiciel_ops Macro  DATE 18/11/2009   AUTEUR MACOCCO K.MACOCCO 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -117,7 +117,8 @@ def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, INFO
       iret, output, error = ExecCommand(scmd, alt_comment=comment, verbose=False, 
                                         capturestderr=True, separated_stderr=True)
       erreur = iret > CODE_RETOUR_MAXI
-      
+      if CODE_RETOUR_MAXI == -1: erreur = False
+
       # output
       if INFO > 0 or erreur:
          UTMESS('I', 'EXECLOGICIEL0_11', vali=(iret, CODE_RETOUR_MAXI))

diff --git a/Aster/Cata/cataSTA9/Macro/macr_ecre_calc_ops.py b/Aster/Cata/cataSTA9/Macro/macr_ecre_calc_ops.py
new file mode 100644 (file)
index 0000000..afef7e7
--- /dev/null
+++ b/Aster/Cata/cataSTA9/Macro/macr_ecre_calc_ops.py
@@ -0,0 +1,638 @@
+#@ MODIF macr_ecre_calc_ops Macro  DATE 05/10/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+
+
+def macr_ecre_calc_ops(
+  self,
+  TABLE,
+  DEBIT,
+  FISSURE,
+  ECOULEMENT,
+  TEMPERATURE,
+  MODELE_ECRE,
+  CONVERGENCE,
+  LOGICIEL,
+  VERSION,
+  ENTETE,
+  COURBES,
+  IMPRESSION,
+  INFO,
+  **args):
+
+  """
+     Procedure de couplage Aster-Ecrevisse
+     Generation par Aster du fichier de donnees d'Ecrevisse et lancement d'Ecrevisse
+  """
+
+  import os, string, types, shutil
+  import aster
+  from Accas import _F
+  from Noyau.N_utils import AsType
+  from Utilitai.Utmess import UTMESS
+  from Utilitai.System import ExecCommand
+
+  ier=0
+
+  # Concept sortant
+  self.DeclareOut('__TAB',TABLE)
+  self.DeclareOut('__DEB',DEBIT)
+
+  # La macro compte pour 1 dans la numerotation des commandes
+  self.set_icmd(1)
+
+  # Parametres
+  # Niveaux de debug
+  debug1 = (INFO>1)
+  debug2 = (INFO>2)
+    
+
+  # Parametres Developpeur
+  tmp_ecrevisse = "tmp_ecrevisse"
+  fichier_data = "data.dat"
+  defaut = '00'
+
+  # IMPORTATION DE COMMANDES ASTER
+  EXEC_LOGICIEL  = self.get_cmd("EXEC_LOGICIEL")
+  CREA_TABLE     = self.get_cmd("CREA_TABLE")
+#  IMPR_TABLE     = self.get_cmd("IMPR_TABLE")
+  IMPR_FONCTION  = self.get_cmd("IMPR_FONCTION")
+
+  # RECUPERATION DES MOTS-CLES FACTEURS
+  dFISSURE=FISSURE[0].cree_dict_valeurs(FISSURE[0].mc_liste)
+  for i in dFISSURE.keys():
+    if dFISSURE[i]==None : del dFISSURE[i]
+
+  dECOULEMENT=ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
+  for i in dECOULEMENT.keys():
+    if dECOULEMENT[i]==None : del dECOULEMENT[i]
+
+  dTEMPERATURE=TEMPERATURE[0].cree_dict_valeurs(TEMPERATURE[0].mc_liste)
+  for i in dTEMPERATURE.keys():
+    if dTEMPERATURE[i]==None : del dTEMPERATURE[i]
+
+  dMODELE_ECRE=MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
+  for i in dMODELE_ECRE.keys():
+    if dMODELE_ECRE[i]==None : del dMODELE_ECRE[i]
+
+  dCONVERGENCE=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+  for i in dCONVERGENCE.keys():
+    if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
+
+  if debug2:
+    print 'dFISSURE = ', dFISSURE
+    print 'dECOULEMENT = ', dECOULEMENT
+    print 'dTEMPERATURE = ', dTEMPERATURE
+    print 'dMODELE_ECRE = ', dMODELE_ECRE
+    print 'dCONVERGENCE = ', dCONVERGENCE
+    print 'ENTETE = ', ENTETE
+    print 'IMPRESSION = ', IMPRESSION
+    print 'INFO = ', INFO
+
+# ---------------------------------------------------------------------
+
+  # CONSTRUCTION DU JEU DE PARAMETRES
+
+  d = {}
+  d[ 0 ] = ENTETE,
+
+  # FISSURE
+  d[ 1 ]  = defaut,
+  d[ 2 ]  = str(len(dFISSURE['LISTE_COTES_AH'])),
+  d[ 3 ]  = dFISSURE['LISTE_COTES_AH'],
+  d[ 4 ]  = dFISSURE['LISTE_VAL_AH'],
+  d[ 5 ]  = str(len(dFISSURE['LISTE_COTES_BL'])),
+  d[ 6 ]  = dFISSURE['LISTE_COTES_BL'],
+  d[ 7 ]  = dFISSURE['LISTE_VAL_BL'],
+  d[ 8 ]  = dFISSURE['LONGUEUR'],
+  d[ 9 ]  = dFISSURE['ANGLE'],
+  d[ 10 ] = dFISSURE['RUGOSITE'],
+  d[ 11 ] = dFISSURE['ZETA'],
+  if dFISSURE['SECTION'] == 'ELLIPSE':
+    d[ 1 ]  = 1,
+  if dFISSURE['SECTION'] == 'RECTANGLE':
+    d[ 1 ]  = 2,
+
+  # ECOULEMENT
+  d[ 20 ] = dECOULEMENT['PRES_ENTREE'],
+  d[ 21 ] = dECOULEMENT['PRES_SORTIE'],
+  d[ 22 ] = dECOULEMENT['FLUIDE_ENTREE'],
+  d[ 23 ] = defaut,
+  d[ 24 ] = defaut,
+  d[ 25 ] = defaut,
+  if dECOULEMENT['FLUIDE_ENTREE'] in [1, 3, 4, 6]:
+    d[ 23 ] = dECOULEMENT['TEMP_ENTREE'],
+  if dECOULEMENT['FLUIDE_ENTREE'] in [2, 5]:
+    d[ 24 ] = dECOULEMENT['TITR_MASS'],
+  if dECOULEMENT['FLUIDE_ENTREE'] in [4, 5]:
+    d[ 25 ] = dECOULEMENT['PRES_PART'],
+
+  # TEMPERATURE
+  d[ 30 ] = defaut,
+  d[ 31 ] = defaut,
+  d[ 32 ] = defaut,
+  d[ 33 ] = defaut,
+  d[ 34 ] = defaut,
+  d[ 35 ] = defaut,
+  d[ 36 ] = defaut,
+  d[ 37 ] = defaut,
+  d[ 38 ] = defaut,
+  d[ 39 ] = defaut,
+  d[ 40 ] = defaut,
+  if dTEMPERATURE['GRADIENT'] == 'FOURNI':
+    d[ 30 ] = -1
+    d[ 31 ] = len(dTEMPERATURE['LISTE_COTES_TEMP'])
+    d[ 32 ] = dTEMPERATURE['LISTE_COTES_TEMP']
+    d[ 33 ] = dTEMPERATURE['LISTE_VAL_TEMP']
+  if dTEMPERATURE['GRADIENT'] == 'IMPOSE':
+    d[ 30 ] = 0
+    d[ 34 ] = dTEMPERATURE['TEMP1']
+    d[ 35 ] = dTEMPERATURE['TEMP2']
+  if dTEMPERATURE['GRADIENT'] == 'CALCULE':
+    d[ 30 ] = 1
+    d[ 36 ] = dTEMPERATURE['EPAISSEUR_PAROI']
+    d[ 37 ] = dTEMPERATURE['CONVECTION_AMONT']
+    d[ 38 ] = dTEMPERATURE['CONVECTION_AVAL']
+    d[ 39 ] = dTEMPERATURE['LAMBDA']
+    d[ 40 ] = dTEMPERATURE['TEMP_FLUIDE_AVAL']
+
+  # MODELE_ECRE
+  d[ 60 ] = defaut,
+  d[ 61 ] = defaut,
+  if dMODELE_ECRE['ECOULEMENT'] == 'SATURATION':
+    d[ 60 ] = 1,
+  if dMODELE_ECRE['ECOULEMENT'] == 'GELE':
+    d[ 60 ] = 2,
+    d[ 61 ] = dMODELE_ECRE['PRESS_EBULLITION'],
+
+  d[ 70 ] = dMODELE_ECRE['FROTTEMENT'],
+  d[ 71 ] = defaut,
+  d[ 72 ] = defaut,
+  d[ 73 ] = defaut,
+  d[ 74 ] = defaut,
+  d[ 75 ] = defaut,
+  if dMODELE_ECRE['FROTTEMENT'] < 0:
+    d[ 71 ] = dMODELE_ECRE['REYNOLDS_LIM'],
+    d[ 72 ] = dMODELE_ECRE['FROTTEMENT_LIM'],
+
+  d[ 73 ] = dMODELE_ECRE['TRANSFERT_CHAL'],
+
+  if dMODELE_ECRE['TRANSFERT_CHAL'] == 0: pass # Pour memoire 3 cas >0, =0, <0
+  if dMODELE_ECRE['TRANSFERT_CHAL']  > 0: pass # Pour memoire 3 cas >0, =0, <0
+  if dMODELE_ECRE['TRANSFERT_CHAL']  < 0:
+    d[74] = dMODELE_ECRE['XMINCH'],
+    d[75] = dMODELE_ECRE['XMAXCH'],
+
+  d[79] = dMODELE_ECRE['IVENAC'],
+
+  if IMPRESSION == 'OUI':
+    d[ 84 ] = 1,
+  if IMPRESSION == 'NON':
+    d[ 84 ] = 0,
+
+  # CONVERGENCE
+  d[ 88 ] = dCONVERGENCE['KGTEST'],
+  d[ 89 ] = dCONVERGENCE['ITER_GLOB_MAXI'],
+  d[ 90 ] = dCONVERGENCE['CRIT_CONV_DEBI'],
+
+  if debug2: print d
+
+# ---------------------------------------------------------------------
+
+  # GENERATION DU FICHIER DATA.DAT
+  txt = fichier_data_ecrevisse()
+
+  for num_param in d.keys():
+    if type(d[num_param]) in [int, float]:
+      txt0 = str(d[num_param])
+    elif type(d[num_param]) in [tuple, list]:
+      txt0 = str(d[num_param]).replace('(', '')
+      txt0 = txt0.replace(')', '')
+      txt0 = txt0.replace(',', '')
+      txt0 = txt0.replace("'", '')
+      txt0 = txt0.replace("[", '')
+      txt0 = txt0.replace("]", '')
+    else:
+      try:    txt0 = str(d[num_param])
+      except: UTMESS('F','ECREVISSE0_11')
+
+    # On remplace la variable dans le fichier par sa valeur
+    txt = txt.replace( '$V['+str(num_param)+']', txt0 )
+
+  if debug1: print txt
+
+
+# ---------------------------------------------------------------------
+
+  # CREATION DE L'ENVIRONNEMENT D'ETUDE POUR ECREVISSE
+
+  # Repertoire temporaire d'execution d'Ecrevisse
+  tmp_ecrevisse = os.path.join(os.getcwd(),tmp_ecrevisse)
+
+  if not os.path.isdir(tmp_ecrevisse):
+    try :
+      os.mkdir(tmp_ecrevisse)
+    except os.error,erreur :
+      print "Code d'erreur de mkdir : " + str(erreur[0]) + " : " + str(erreur[1])
+      UTMESS('F','ECREVISSE0_12',valk=[tmp_ecrevisse])
+
+  # On recopie eventuellement l'ancien fichier debits
+  src = os.path.join('.', 'REPE_OUT', 'debits_dernier')
+  dst = os.path.join(tmp_ecrevisse, 'debits')
+  if os.path.isfile(src):
+     try:
+        shutil.copyfile(src, dst)
+     except Exception, e:
+        print "ERREUR : copyfile %s -> %s" % (src, dst)
+
+  # Executable Ecrevisse
+  if LOGICIEL:
+    if not os.path.isfile(str(LOGICIEL)):
+      UTMESS('F','ECREVISSE0_13')
+    else:
+      chemin_executable = str(LOGICIEL)
+  else:
+    chemin_executable = os.path.join(aster.repout(), 'ecrevisse')
+
+  # Soit on fait un lien symbolique (incompatible avec certaines plate-formes) soit on recopie l'executable
+  if not os.path.isfile(os.path.join(tmp_ecrevisse, 'ecrevisse')):
+    try:
+      os.symlink( chemin_executable, os.path.join(tmp_ecrevisse, 'ecrevisse') )
+    except:
+      UTMESS('A','ECREVISSE0_14')
+      cmd = 'cp ' + chemin_executable + ' ' + os.path.join(tmp_ecrevisse, 'ecrevisse')
+      res = os.system(cmd)
+      os.chmod( os.path.join(tmp_ecrevisse, 'ecrevisse') ,0755)
+      if (res!=0): UTMESS('F','ECREVISSE0_15')
+
+  # Ecriture du fichier de donnees pour Ecrevisse
+  fw = open(os.path.join(tmp_ecrevisse, fichier_data),'w')
+  fw.write(txt)
+  fw.close()
+
+  # Sauvegarde dans REPE_OUT du data.dat
+  os.system('cp ' + tmp_ecrevisse + '/data.dat REPE_OUT/')
+
+
+# ---------------------------------------------------------------------
+
+  # EXECUTION D'ECREVISSE
+
+  # Choix du shell
+  cmd = '#!sh'
+  for shell in ['/bin/sh', '/bin/bash', '/usr/bin/sh']:
+    if os.path.isfile(shell):
+      cmd = '#!' + shell
+      break
+
+#   #Ligne suivante a ajouter avec la version LINUX compilee avec GFORTRAN
+#   cmd = cmd + '\nexport LD_LIBRARY_PATH=/logiciels/aster/Linux/GF4/public/gcc-4.1.1/lib:$LD_LIBRARY_PATH'
+
+  # Creation du contenu du script de lancement ecrevisse.sh
+  cmd = cmd + '\ncd ' + tmp_ecrevisse + '\n' + os.path.join(tmp_ecrevisse, 'ecrevisse') + '\nset iret=$?\ncd ..\nexit $iret'
+  fw = open(os.path.join(tmp_ecrevisse, 'ecrevisse.sh'),'w')
+  fw.write(cmd)
+  fw.close()
+  os.chmod(os.path.join(tmp_ecrevisse, 'ecrevisse.sh') ,0755)
+
+  # Lancement d'Ecrevisse
+  UTMESS('I','ECREVISSE0_16')
+  res = ExecCommand(os.path.join(tmp_ecrevisse, 'ecrevisse.sh'),follow_output=True,verbose=True)
+  UTMESS('I','ECREVISSE0_17')
+
+
+  if debug1: os.system('ls -al ' + tmp_ecrevisse)
+
+
+# ---------------------------------------------------------------------
+
+  # RECUPERATION DU RESULTAT DEPUIS ECREVISSE
+
+
+  try:
+    f_ast = open(os.path.join(tmp_ecrevisse, 'pour_aster'),'r')
+    _txt = f_ast.read()
+    f_ast.close()
+    # transforme le texte en liste
+    _lst = _txt.split()
+    # transforme la liste de textes en liste de float
+    _lst = map( float, _lst )
+
+    # 5 colonnes (a partir de ECREVISSE 3.1.e)
+    #    cote z (m), flux thermique (W/m2), pression totale absolue (Pa), temperature fluide (degres C), coefficient de convection (W/m2/K)
+    _ecr_c  = _lst[1:len(_lst):5]
+    _ecr_f  = _lst[2:len(_lst):5]
+    _ecr_p  = _lst[3:len(_lst):5]
+    _ecr_t  = _lst[4:len(_lst):5]
+    _ecr_cc = _lst[5:len(_lst):5]
+
+
+  except:
+      UTMESS('F','ECREVISSE0_18')
+      _ecr_c = [-1]
+      _ecr_f = [-1]
+      _ecr_p = [-1]
+      _ecr_t = [-1]
+      _ecr_cc = [-1]
+
+  else:
+      # Generation de la table resultat
+      if debug1: print "Chargement donne par Ecrevisse"
+      if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
+      if debug1:
+        print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
+        print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
+        print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
+        print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
+        print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
+
+
+      # Formule permettant de redefinir les chargements par mailles
+      lx_ast = dFISSURE['LISTE_COTES_AH']
+
+      # epsilon pour le decalage
+      eps = 1.e-8
+
+      lx = []
+      ly = []
+      ly2 = []
+      ly3 = []
+      ly4 = []
+
+      lx.append( lx_ast[0] )
+      ly.append( _ecr_f[0] )
+      ly2.append( _ecr_p[0] )
+      ly3.append( _ecr_t[0] )
+      ly4.append( _ecr_cc[0] )
+
+      for i in range(len(lx_ast)-2):
+        x = lx_ast[i+1]
+        lx.append( x - eps )
+        lx.append( x + eps )
+        ly.append( _ecr_f[i] )
+        ly.append( _ecr_f[i+1] )
+        ly2.append( _ecr_p[i] )
+        ly2.append( _ecr_p[i+1] )
+        ly3.append( _ecr_t[i] )
+        ly3.append( _ecr_t[i+1] )
+        ly4.append( _ecr_cc[i] )
+        ly4.append( _ecr_cc[i+1] )
+      #
+      lx.append( lx_ast[-1] )
+      ly.append( _ecr_f[-1] )
+      ly2.append( _ecr_p[-1] )
+      ly3.append( _ecr_t[-1] )
+      ly4.append( _ecr_cc[-1] )
+
+      _ecr_c = lx
+      _ecr_f = ly
+      _ecr_p = ly2
+      _ecr_t = ly3
+      _ecr_cc = ly4
+
+
+  # Generation de la table resultat
+  if debug1: print "Chargement par mailles pour Aster"
+  if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
+  if debug1:
+    print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
+    print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
+    print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
+    print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
+    print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
+
+  # Creation de la SD table (resultat de CALC_ECREVISSE)
+  __TAB=CREA_TABLE(LISTE=(_F(LISTE_R=_ecr_c,
+                           PARA='COTES'),
+                        _F(LISTE_R=_ecr_f,
+                           PARA='FLUX'),
+                        _F(LISTE_R=_ecr_p,
+                           PARA='PRESSION'),
+                        _F(LISTE_R=_ecr_t,
+                           PARA='TEMP'),
+                        _F(LISTE_R=_ecr_cc,
+                           PARA='COEF_CONV'),
+                         ));
+
+
+#  if debug: IMPR_TABLE(TABLE=__TAB, FORMAT='TABLEAU',);
+
+# ---------------------------------------------------------------------
+
+  # RECUPERATION DU DEBIT DEPUIS ECREVISSE
+
+  try:
+    f_deb = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+    _tex = f_deb.read()
+    f_deb.close()
+    # transforme le texte en liste
+    _lis = _tex.split()
+    # transforme la liste de textes en liste de float
+    _lis = map( float, _lis )
+
+    # 5 colonnes (a partir de ECREVISSE 3.1.e)
+    # debit total (kg/s), debit d'air (kg/s), debit de vapeur (kg/s), debit de liquide (kg/s), type d'ecoulement
+    _dtot  = _lis[0:len(_lis):5]
+    _dair  = _lis[1:len(_lis):5]
+    _dvap  = _lis[2:len(_lis):5]
+    _dliq  = _lis[3:len(_lis):5]
+    _ecou  = _lis[4:len(_lis):5]
+
+
+  except:
+      UTMESS('A','ECREVISSE0_18')
+      _dtot = [-1]
+      _dair = [-1]
+      _dvap = [-1]
+      _dliq = [-1]
+      _ecou = [-1]
+
+
+      # Formule permettant de redefinir les chargements par mailles
+      ly_deb = LIST_INST
+
+
+      # epsilon pour le decalage
+      eps = 1.e-8
+
+      ly = []
+      ly1 = []
+      ly2 = []
+      ly3 = []
+      ly4 = []
+
+      ly.append( _dtot[0] )
+      ly1.append( _dair[0] )
+      ly2.append( _dvap[0] )
+      ly3.append( _dliq[0] )
+      ly4.append( _ecou[0] )
+
+      for i in range(len(ly_deb)-2):
+        ly.append( _dtot[i] )
+        ly.append( _dtot[i+1] )
+        ly1.append( _dair[i] )
+        ly1.append( _dair[i+1] )
+        ly2.append( _dvap[i] )
+        ly2.append( _dvap[i+1] )
+        ly3.append( _dliq[i] )
+        ly3.append( _dliq[i+1] )
+        ly4.append( _ecou[i] )
+        ly4.append( _ecou[i+1] )
+      #
+      ly.append( _dtot[-1] )
+      ly1.append( _dair[-1] )
+      ly2.append( _dvap[-1] )
+      ly3.append( _dliq[-1] )
+      ly4.append( _ecou[-1] )
+
+      _dtot = ly
+      _dair = ly1
+      _dvap = ly2
+      _dliq = ly3
+      _ecou = ly4
+
+  # Creation de la SD table (resultat de CALC_ECREVISSE)
+  __DEB=CREA_TABLE(LISTE=(_F(LISTE_R=_dtot,
+                           PARA='DEBTOT'),
+                        _F(LISTE_R=_dair,
+                           PARA='DEBAIR'),
+                        _F(LISTE_R=_dvap,
+                           PARA='DEBVAP'),
+                        _F(LISTE_R=_dliq,
+                           PARA='DEBLIQ'),
+                        _F(LISTE_I=_ecou,
+                           PARA='ECOULEMENT'),
+                         ));
+
+
+#  if debug: IMPR_TABLE(TABLE=__DEB, FORMAT='TABLEAU',);
+
+# ---------------------------------------------------------------------
+
+  # RECUPERATION DES RESULTATS OPTIONNELS DEPUIS ECREVISSE
+
+# A finir
+
+#  lst_fic = os.listdir(tmp_ecrevisse)
+
+# ---------------------------------------------------------------------
+
+  # FIN MACR_ECRE_CALC
+
+  return ier
+
+# ---------------------------------------------------------------------
+
+def fichier_data_ecrevisse():
+
+  """
+     Modele du fichier data.dat a la syntaxe Ecrevisse 3.0
+     Cette chaine de caractere est l'exacte replique d'un fichier de donnees
+     Ecrevisse 3.0 dans lequel toutes les donnees numeriques ont ete
+     remplacees par $V[x].
+  """
+
+  txt = """$V[0]
+
+
+      DONNEES GEOMETRIQUES RELATIVES A LA FISSURE
+      *******************************************
+
+$V[1]        is: type de section  (is=1 ellipse is=2 rectangle)
+$V[2]        nb points decrivant ah: grand axe  (m)
+$V[3]
+$V[4]
+$V[5]        nb points decrivant bl: petit axe (m)
+$V[6]
+$V[7]
+$V[8]        zl: longueur totale de la fissure (m)
+$V[9]        theta: angle par rapport a la verticale ascendante (en degres)
+$V[10]       eps: rugosite absolu (m)
+$V[11]       zeta: coefficient de la perte de charge singuliere a l'entree
+
+      DONNEES RELATIVES A L"ECOULEMENT
+      ********************************
+
+$V[20]       pe: pression de stagnation a l'entree (Pa)
+$V[21]       ps: pression de stagnation a la sortie (Pa)
+$V[22]       iflow : condition du fluide a l'entree
+               iflow=1  : eau sous-refroidie ou saturee
+               iflow=2  : fluide diphasique
+               iflow=3  : vapeur saturee ou surchauffee
+               iflow=4  : air + vapeur surchauffee
+               iflow=5  : air + vapeur saturee
+               iflow=6  : air seul
+$V[23]       te: temperature a l'entree (deg C) (utilise si iflow=1,3,4,6)
+$V[24]       xe: titre m. eau vap/eau tot a l'entree (utilise si iflow=2 ou 5)
+$V[25]       pae : pression partielle air en entree (Pa) (utilise si iflow>3)
+
+      DONNEES RELATIVES AU PROFIL DE TEMPERATURE A TRAVERS LA PAROI
+      *************************************************************
+
+$V[30]       imograd : modele de calcul du gradient de temperature
+               imograd=-1/ distribution imposee de temperature (max 100pts)
+               imograd=0 : profil impose de la temperature
+               imograd=1 : calcul du profil
+$V[31]       cas imograd = -1 : ntmat, nb de points donnes ensuite (max=100)
+$V[32]
+$V[33]
+$V[34]       tm1: grad. temp. paroi le lg de l'ecoul.(utilise si imograd=0) (degC/m)
+$V[35]       tm2: temperature de la paroi a l'entree (utilise si imograd=0) (degC)
+$V[36]       epp: epaisseur de la paroi (utilise si imograd=1) (m)
+$V[37]       alphe: coeff. convection face amont (utilise si imograd=1) (W/degC/m2)
+$V[38]       alphs: coeff. convection face aval  (utilise si imograd=1) (W/degC/m2)
+$V[39]       lambd: conduct. thermique de la paroi (utilise si imograd=1) (W/degC/m)
+$V[40]       ts: temperature du fluide cote aval (utilise si imograd=1) (degC)
+
+      CHOIX DES MODELES
+      *****************
+
+Modeles d'ecoulement diphasique
+-------------------------------
+$V[60]       imod : type de modele d'ecoulement diphasique
+               imod=1 : modele d'ecoulement a saturation a l'entree
+               imod=2 : modele d'ecoulement 'gele' a l'entree
+$V[61]       corrp: press. d'ebullition = corrp*psat(t)
+
+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
+
+Modelisation de la vena contracta
+---------------------------------
+$V[79]       ivenac : avec = 1, sans = 0
+
+Procedure d'impression
+----------------------
+$V[84]       iprint : impression profils ecran ( oui:1 non:0 )
+
+      DONNEES RELATIVES A LA CONVERGENCE NUMERIQUE
+      ********************************************
+
+$V[88]       kgtest (0 < kgtest < 1) tel que g=kgtest*gmax+(1-kgtest)*gmin
+$V[89]       itnmax : nombre maximum iterations methode newton
+$V[90]       precdb : critere de convergence en debit
+"""
+
+  return txt

diff --git a/Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py b/Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py
new file mode 100644 (file)
index 0000000..2cbd64a
--- /dev/null
+++ b/Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py
@@ -0,0 +1,711 @@
+#@ MODIF macr_ecrevisse_ops Macro  DATE 05/10/2009   AUTEUR ASSIRE A.ASSIRE 
+# -*- 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.        
+# ======================================================================
+
+def macr_ecrevisse_ops(self,reuse,
+   CONV_CRITERE,
+   TABLE,
+   TEMPER,
+   DEBIT,
+   MODELE_MECA,
+   MODELE_THER,
+   FISSURE,
+   ECOULEMENT,
+   LIST_INST,
+   MODELE_ECRE,
+   CONVERGENCE_ECREVISSE,
+   COURBES,
+   LOGICIEL,
+   VERSION,
+   ENTETE,
+   IMPRESSION,
+   CHAM_MATER,
+   CARA_ELEM,
+   EXCIT_MECA,
+   EXCIT_THER,
+   COMP_INCR,
+   NEWTON,
+   CONVERGENCE,
+   ETAT_INIT,
+   INFO,
+   **args):
+   """
+        Procedure de couplage Aster-Ecrevisse
+        Execution pour tous les pas de temps des calculs thermiques, mécaniques puis hydraulique
+        DecoupageGeneration par Aster du fichier de donnees d'Ecrevisse et lancement d'Ecrevisse
+   """
+
+
+   from Utilitai.Utmess import UTMESS
+   from Utilitai.Table import Table, merge
+   from Accas import _F
+   import os, aster, copy
+
+   ier=0
+   # Niveaux de debug
+   debug1 = (INFO>1)
+   debug2 = (INFO>2)
+  
+   #
+   InfoAster = 1
+   #
+   # La macro compte pour 1 dans la numerotation des commandes
+   self.set_icmd(1)
+
+   # IMPORTATION DE COMMANDES ASTER
+   DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
+   THER_LINEAIRE  = self.get_cmd("THER_LINEAIRE")
+   PROJ_CHAMP     = self.get_cmd("PROJ_CHAMP")
+   DETRUIRE       = self.get_cmd("DETRUIRE")
+   AFFE_MATERIAU  = self.get_cmd("AFFE_MATERIAU")
+   STAT_NON_LINE  = self.get_cmd("STAT_NON_LINE")
+   POST_RELEVE_T  = self.get_cmd("POST_RELEVE_T")
+   CALC_ECREVISSE = self.get_cmd("CALC_ECREVISSE")
+   CO             = self.get_cmd("CO")
+   CREA_TABLE     = self.get_cmd("CREA_TABLE")
+   CREA_RESU      = self.get_cmd("CREA_RESU")
+   CREA_CHAMP     = self.get_cmd("CREA_CHAMP")
+
+   # Concepts sortants
+   # TABLE creees par concatenation des tables sorties par CALC_ECREVISSE a chaque iteration
+   self.DeclareOut('TABL_RES',TABLE)
+   self.DeclareOut('DEB_RES',DEBIT)
+   # Concepts sortant: les resultats de STAT_NON_LINE et de THER_LINEAIRE valides vis-a-vis du calcul ecrevisse
+   self.DeclareOut('RTHERM',TEMPER)
+   self.DeclareOut('MECANIC', self.sd)
+   
+   IsPoursuite = False
+   IsInit = True
+   # Traitement de l'etat initial en cas de poursuite
+   if ETAT_INIT:
+       dEtatInit=ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste)
+       for i in dEtatInit.keys():
+           if dEtatInit[i]==None : del dEtatInit[i]
+       __EVINIT = dEtatInit['EVOL_NOLI']
+       __THINIT = dEtatInit['EVOL_THER']
+       _nume_ordre = dEtatInit['NUME_ORDRE']
+       IsPoursuite= True
+   else :
+       dEtatInit=None
+ 
+   # Valeur par defaut du mot cle LOGICIEL
+   if not LOGICIEL: LOGICIEL = os.path.join(aster.repout(), 'ecrevisse')
+
+   # RECUPERATION DES MOTS-CLES FACTEURS
+
+   l_dFISSURE=[]
+   for fissure in FISSURE:
+      dFISSURE=fissure.cree_dict_valeurs(fissure.mc_liste)
+      for i in dFISSURE.keys():
+         if dFISSURE[i]==None : del dFISSURE[i]
+      l_dFISSURE.append(dFISSURE)
+
+   dECOULEMENT=ECOULEMENT[0].cree_dict_valeurs(ECOULEMENT[0].mc_liste)
+   for i in dECOULEMENT.keys():
+      if dECOULEMENT[i]==None : del dECOULEMENT[i]
+
+   dMODELE_ECRE=MODELE_ECRE[0].cree_dict_valeurs(MODELE_ECRE[0].mc_liste)
+   for i in dMODELE_ECRE.keys():
+      if dMODELE_ECRE[i]==None : dMODELE_ECRE[i]=None #del dMODELE_ECRE[i]
+
+   dCONVERGENCE_ECREVISSE=CONVERGENCE_ECREVISSE[0].cree_dict_valeurs(CONVERGENCE_ECREVISSE[0].mc_liste)
+   for i in dCONVERGENCE_ECREVISSE.keys():
+      if dCONVERGENCE_ECREVISSE[i]==None : del dCONVERGENCE_ECREVISSE[i]
+
+   dCOMP_INCR=COMP_INCR[0].cree_dict_valeurs(COMP_INCR[0].mc_liste)
+   for i in dCOMP_INCR.keys():
+      if dCOMP_INCR[i]==None : del dCOMP_INCR[i]
+
+   dNEWTON=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
+   for i in dNEWTON.keys():
+      if dNEWTON[i]==None : del dNEWTON[i]
+
+   dCONVERGENCE=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
+   for i in dCONVERGENCE.keys():
+      if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
+
+   # Recuperation des infos pour la convergence de la macro
+   dMacr_Conv = CONV_CRITERE[0].cree_dict_valeurs(CONV_CRITERE[0].mc_liste)
+   for i in dMacr_Conv.keys():
+      if dMacr_Conv[i]==None : del dMacr_Conv[i]
+
+   motclefsCALC_ECREVISSE = {}
+   motclefsCALC_ECREVISSE['COURBES'] = COURBES,
+
+   # -----------------------------------------------------------------------------------------------------
+   # Debut de la macro
+
+   # Si LIST_INST est un DEFI_LIST_REEL :
+   _liste_inst = LIST_INST.Valeurs()
+   if ( debug1 ):
+      print 'liste des instants liste_inst = ', _liste_inst
+
+   # Drapeaux pour les 1ers calculs et les 1eres definitions
+   IsDefineMaterMeca  = False
+   EcrevisseExe       = False  # si l'execution d'Ecrevisse n'a pas plantee ou a ete realisee
+
+   # Table python devant contenir toutes les tables Ecrevisse
+   T_TABL_RES = None
+   T_DEB_RES  = None
+   # Precision demandee pour converger sur le critere de la macro
+   # Nombre de decoupages succesifs d'un pas de temps
+   # Pas de temps en dessous duquel on ne decoupe plus
+   if dMacr_Conv.has_key('SUBD_NIVEAU'):
+       MacrNbDecoupage   = dMacr_Conv['SUBD_NIVEAU']
+   if dMacr_Conv.has_key('SUBD_PAS_MINI'):
+       MacrPasMini       = dMacr_Conv['SUBD_PAS_MINI']
+   MacrTempRef       = dMacr_Conv['TEMP_REF']
+   MacrPresRef       = dMacr_Conv['PRES_REF']
+   MacrCritere       = dMacr_Conv['CRITERE']
+   if dMacr_Conv.has_key('PREC_CRIT'):
+      MacrPrecisCritere = dMacr_Conv['PREC_CRIT']
+   else:
+      MacrPrecisCritere = None
+   if dMacr_Conv.has_key('NUME_ORDRE_MIN'):
+      MacrNumeOrdre     = dMacr_Conv['NUME_ORDRE_MIN']
+
+   #
+   # il faut 2 pas au minimum dans la liste
+   if (len(_liste_inst) < 2 ):
+      UTMESS('F','ECREVISSE0_20', vali=[2])
+
+   if (not IsPoursuite) :
+     _nume_ordre = 0
+   else :
+     # Dans le cas d'une poursuite :
+     # n reconstruit une nouvelle liste d'instant composee de l'ancienne liste jusqu'a l'instant recherche, 
+     # puis de la nouvelle a partir de cet instant
+     # ainsi le _nume_ordre de la nouvelle liste correspond au nume_ordre de l'ancienne
+     __dico1 = __THINIT.LIST_VARI_ACCES()
+     _list_precedente = __dico1['INST']
+     _inst_init  = _list_precedente[_nume_ordre-1]
+     try:
+        # si l'instant est dans la liste, on recupere l'index
+        _idx = _liste_inst.index(_inst_init)
+     except:
+        # on cherche le plus proche
+        idx = 0
+        found = False
+        for t in _liste_inst:
+           if t > _inst_init:
+              found = True
+              idx += 1
+              break
+           idx += 1
+     new_list = _list_precedente[0:_nume_ordre]  # liste precedent jusqu'a l'instant a recalculer (inclu, ca permet de gerer le cas ou l'instant a recalculer n'est pas dans la nouvelle liste : il sera ajoute)
+     new_list.extend( _liste_inst[_idx+1:] )  # on lui ajoute la nouvelle liste a partir du l'instant a recalculer 
+     _liste_inst = copy.copy(new_list)
+     
+   ########################################################################################  
+   # Debut boucle sur la liste d'instant
+   ########################################################################################
+   FinBoucle = False
+   while ( not FinBoucle ):
+      _inst      = _liste_inst[_nume_ordre]
+      if (debug1):
+         print 'instant debut boucle', _inst
+
+      # On boucle jusqu'a convergence
+      NbIter = 0
+      while True:
+
+
+         if ( (not IsPoursuite) or EcrevisseExe) : 
+         # Le temps que l'on traite
+           _inst_p_un = _liste_inst[_nume_ordre+1]
+           IsInitEcre= False
+           # Construction de la liste des pas
+           LES_PAS = DEFI_LIST_REEL( VALE=_liste_inst, )
+           if ( debug1 ):
+              print '=====> ===== ===== ===== <===='
+              print 'Iteration numero : ', NbIter
+              print 'Instant          : ', _inst
+              print 'Instant+1        : ', _inst_p_un
+              print 'nume_ordre       : ', _nume_ordre+1
+              print 'Donnee Ecrevisse : ', EcrevisseExe
+
+           # ---------------------
+           #        THERMIQUE
+           # ---------------------
+           # Recuperation des chargements thermiques
+           _dEXCIT_THER = []
+           if EXCIT_THER:
+             for excit_i in EXCIT_THER:
+               dEXCIT_THER_i = excit_i.cree_dict_valeurs(excit_i.mc_liste)
+               for j in dEXCIT_THER_i.keys():
+                  if dEXCIT_THER_i[j]==None : del dEXCIT_THER_i[j]
+               _dEXCIT_THER.append(dEXCIT_THER_i)
+
+         #
+         # Definition des chargements thermiques venant d Ecrevisse
+           if ( EcrevisseExe ):
+              _dEXCIT_THER.append( _F(CHARGE=FLU1ECR0) )
+              _dEXCIT_THER.append( _F(CHARGE=FLU2ECR0) )
+ 
+           # Definition de l'etat initial 
+           motclefs = {}
+           if (_nume_ordre == 0) :
+              # On verifie que temp_ref est bien renseigne dans AFFE_MATERIAU            
+              try:
+                 tref = CHAM_MATER['AFFE_VARC']['VALE_REF']
+              except:
+                 UTMESS('F','ECREVISSE0_22',)
+            
+              motclefs['ETAT_INIT']=[_F(VALE=tref, NUME_ORDRE=_nume_ordre)]
+              if ( debug2 ):
+                 print 'thermique initialise avec tref'
+           else:
+              if (IsInit) :
+                 motclefs['reuse']=__THINIT  
+                 motclefs['ETAT_INIT']=[_F(EVOL_THER=__THINIT,  NUME_ORDRE=_nume_ordre)]
+                 if (debug2):
+                    print 'thermique initialise avec etat_initial'
+              else :
+                 motclefs['reuse']=RTHERM
+                 motclefs['ETAT_INIT']=[_F(EVOL_THER=RTHERM,  NUME_ORDRE=_nume_ordre)]
+                 if (debug2):
+                    print 'thermique initialise avec instant precedent'
+           if ( debug1 ):
+              print '====> THER_LINEAIRE <===='
+           if ( debug2 ):
+              print '   Les charges thermiques'
+              print EXCIT_THER
+         #
+           if IsPoursuite :
+              __THINIT = THER_LINEAIRE(
+                MODELE     = MODELE_THER,
+                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'),
+                INFO       = InfoAster,
+                **motclefs )
+            
+              RTHERMPJ=PROJ_CHAMP(RESULTAT=__THINIT, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
+                     VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
+                     INFO=2,
+                      )
+              RTHERM=__THINIT
+           else : 
+              RTHERM=THER_LINEAIRE(
+               MODELE     = MODELE_THER,
+               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'),
+               INFO       = InfoAster,
+               **motclefs
+               )
+
+           # Projection du champ thermique, à tous les instants sinon pas de deformations thermiques
+              RTHERMPJ=PROJ_CHAMP(RESULTAT=RTHERM, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
+                VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
+                INFO=2,
+                 )
+
+         # Definition du materiau pour la mecanique : a faire une seule fois
+           if ( not IsDefineMaterMeca ):
+              motclefmater = {}
+              motclefmater['AFFE'] = []
+              motclefmater['AFFE_VARC'] = []
+
+              for j in CHAM_MATER['AFFE_VARC'] :
+                 dvarc = j.cree_dict_valeurs(j.mc_liste)
+                 for mc, val in dvarc.items():
+                    if val == None:
+                       del dvarc[mc]
+                 motclefmater['AFFE_VARC'].append(dvarc)
+
+              for j in CHAM_MATER['AFFE'] :
+                 daffe = j.cree_dict_valeurs(j.mc_liste)
+                 for mc, val in daffe.items():
+                    if val == None:
+                       del daffe[mc]
+                 motclefmater['AFFE'].append(daffe)
+
+
+              dvarc['EVOL'] = RTHERMPJ
+              motclefmater['MAILLAGE'] = CHAM_MATER['MAILLAGE']
+              __MATMEC=AFFE_MATERIAU(
+                 **motclefmater
+              )
+              IsDefineMaterMeca = True
+
+           # ---------------------
+           #        MECANIQUE
+           # ---------------------
+           _dEXCIT_MECA = []
+           # Recuperation des chargements mecaniques
+           if EXCIT_MECA:
+              for excit_i in EXCIT_MECA:
+                 dEXCIT_MECA_i = excit_i.cree_dict_valeurs(excit_i.mc_liste)
+                 for j in dEXCIT_MECA_i.keys():
+                    if dEXCIT_MECA_i[j]==None : del dEXCIT_MECA_i[j]
+                 _dEXCIT_MECA.append(dEXCIT_MECA_i)
+         
+         
+           # Definition des chargements venant d'Ecrevisse
+           if ( EcrevisseExe ):
+              _dEXCIT_MECA.append( _F(CHARGE=MECAECR0) )
+
+           motclefs = {}
+
+           if (not IsPoursuite) :
+             if (_nume_ordre != 0):
+                motclefs['reuse'] = MECANIC
+                motclefs['ETAT_INIT']=[_F(EVOL_NOLI=MECANIC, NUME_ORDRE=_nume_ordre)]
+                if (debug2):
+                   print 'etat meca initial = pas precedent'
+             else:
+                if (debug2):
+                   print 'etat meca initial : vierge'   
+           else:   
+              motclefs['reuse']=__EVINIT
+              motclefs['ETAT_INIT']=[_F(EVOL_NOLI=__EVINIT, NUME_ORDRE=_nume_ordre)]
+              if (debug2):
+                 print 'etat meca initial dReuseM', motclefs
+            
+            
+           if ( debug1 ):
+              print '====> STAT_NON_LINE <===='
+           if ( debug2 ):
+              print '   Les charges mecaniques'
+              print _dEXCIT_MECA
+            
+            
+           MECANIC=STAT_NON_LINE(
+              MODELE      = MODELE_MECA,
+              CHAM_MATER  = __MATMEC,
+              CARA_ELEM   = CARA_ELEM,
+              EXCIT       = _dEXCIT_MECA,
+              COMP_INCR   = _F(**dCOMP_INCR),
+              INCREMENT   = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,),
+              NEWTON      = _F(**dNEWTON),
+              CONVERGENCE = _F(**dCONVERGENCE),
+              SOLVEUR     = _F(SYME='OUI'),
+              ARCHIVAGE   = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
+              INFO        = InfoAster,
+              **motclefs
+           )
+           # Destruction des concepts
+           #  Thermique projete
+           #  Liste des pas
+           DETRUIRE( CONCEPT=(_F(NOM=RTHERMPJ),_F(NOM=LES_PAS),),INFO=1,ALARME='NON',)
+         
+         else :
+           #      CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE 
+           #     LES CHARGEMENT A UTILISER POUR LES PROBLEMES THERMIQUES ET MECANIQUES
+           _inst_p_un=_inst
+           IsInitEcre = True
+           
+         # -----------------------------------------------------------------------
+         #        ECREVISSE : ATTENTION SI REPRISE CALCUL, ON RECALCULE LE DERNIER INSTANT
+         # -------------------------------------------------------------------------
+         # Si Ecrevisse a deja ete fait une fois.
+         #   ==> Efface les concepts qui sont en sortie
+         if ( EcrevisseExe ):
+            DETRUIRE(
+               CONCEPT=(
+                  _F(NOM=MECAECR1),
+                  _F(NOM=FLU1ECR1),
+                  _F(NOM=FLU2ECR1),
+                  _F(NOM=TABLECR1),
+                  _F(NOM=DEBIECR1),
+               ),INFO=1,ALARME='NON',
+            )
+
+         # On remplace FONC_XXX par la valeur XXX correspondante a l'instant _inst_p_un
+         dECOULEMENT_ecrevisse = copy.copy(dECOULEMENT)
+         for fonc_name in ["PRES_ENTREE_FO", "PRES_SORTIE_FO", "PRES_PART_FO", "TITR_MASS_FO", "TEMP_ENTREE_FO"]:
+            if dECOULEMENT.has_key(fonc_name):
+               fonc = dECOULEMENT_ecrevisse.pop(fonc_name)
+               vale_name = fonc_name.replace('_FO', '')
+               dECOULEMENT_ecrevisse[vale_name] = fonc(_inst_p_un)
+
+
+         # Initialisation des concepts en sortie
+         MECAECR1=CO('MECAECR1')
+         FLU1ECR1=CO('FLU1ECR1')
+         FLU2ECR1=CO('FLU2ECR1')
+         TABLECR1=CO('TABLECR1')
+         DEBIECR1=CO('DEBIECR1')
+
+         if ( debug1 ):
+            print '====> ECREVISSE entree dans CALC_ECREVISSE <===='
+         
+         if (not IsPoursuite) : 
+                  
+           CALC_ECREVISSE(
+              CHARGE_MECA      = MECAECR1,
+              CHARGE_THER1     = FLU1ECR1,
+              CHARGE_THER2     = FLU2ECR1,
+              TABLE            = TABLECR1,
+              DEBIT            = DEBIECR1,
+              MODELE_MECA      = MODELE_MECA,
+              MODELE_THER      = MODELE_THER,
+              ENTETE           = ENTETE,
+              IMPRESSION       = IMPRESSION,
+              INFO             = INFO,
+              RESULTAT=_F(THERMIQUE  = RTHERM,
+                        MECANIQUE  = MECANIC,
+                        INST       = _inst_p_un, ),
+              # chemin d acces a Ecrevisse
+              LOGICIEL         = LOGICIEL,
+              VERSION          = VERSION,
+              # donnees necessaire pour ecrevisse
+              # assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
+              # activation eventuelle de TITR_VA et P_AIR
+
+              FISSURE=l_dFISSURE, # TODO a verifier
+              ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
+              MODELE_ECRE=_F( **dMODELE_ECRE),
+
+              CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
+              **motclefsCALC_ECREVISSE
+              );
+         else :
+           CALC_ECREVISSE(
+              CHARGE_MECA      = MECAECR1,
+              CHARGE_THER1     = FLU1ECR1,
+              CHARGE_THER2     = FLU2ECR1,
+              TABLE            = TABLECR1,
+              DEBIT            = DEBIECR1,
+              MODELE_MECA      = MODELE_MECA,
+              MODELE_THER      = MODELE_THER,
+              ENTETE           = ENTETE,
+              IMPRESSION       = IMPRESSION,
+              INFO             = INFO,
+              RESULTAT=_F(THERMIQUE  = __THINIT,
+                          MECANIQUE  = __EVINIT,
+                          INST       = _inst_p_un, ),
+              # chemin d acces a Ecrevisse
+              LOGICIEL         = LOGICIEL,
+              VERSION          = VERSION,
+              # donnees necessaire pour ecrevisse
+              # assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
+              # activation eventuelle de TITR_VA et P_AIR
+
+              FISSURE=l_dFISSURE, # TODO a verifier
+              ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
+              MODELE_ECRE=_F( **dMODELE_ECRE),
+
+              CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
+              **motclefsCALC_ECREVISSE
+              );
+                
+         if ( debug1 ):
+            print '====> ECREVISSE sortie de CALC_ECREVISSE <===='
+
+
+         # Recuperation des infos de la table resultat Ecrevisse
+         T_TABL_TMP1 = TABLECR1.EXTR_TABLE()
+         T_DEB_TMP1  = DEBIECR1.EXTR_TABLE()
+#         # Ajout de deux colonnes supplementaires
+#         _nb_ligne = len(T_DEB_TMP1["DEBTOT"])
+#         T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*_nb_ligne
+#         T_DEB_TMP1["INST"]       = [_inst_p_un]*_nb_ligne
+         
+         # Le calcul Ecrevisse c'est bien passe ?
+         EcrevisseExe = ( T_TABL_TMP1.values()['COTES'][0] != -1 )
+         #
+         if ( not EcrevisseExe ):
+            # Destruction des concepts de sortie, et on arrete tout
+            DETRUIRE(
+               CONCEPT=( _F(NOM=MECAECR1),
+                         _F(NOM=FLU1ECR1),
+                         _F(NOM=FLU2ECR1),
+                         _F(NOM=TABLECR1),
+                         _F(NOM=DEBIECR1),
+               ),
+               INFO=1,ALARME='NON',
+            )
+            if ( not IsInit ):
+               DETRUIRE(
+                  CONCEPT=( _F(NOM=MECAECR0),
+                            _F(NOM=FLU1ECR0),
+                            _F(NOM=FLU2ECR0),
+                            _F(NOM=TABLECR0),
+                            _F(NOM=DEBIECR0),
+                  ),
+                  INFO=1,ALARME='NON',
+               )
+            FinBoucle = True
+            break
+         #
+         # A t'on atteint la convergence
+         #  TABLECR0 table Ecrevisse a _inst
+         #  TABLECR1 table Ecrevisse a _inst_p_un
+         # --------------------
+         
+         if ( not IsInit ):
+            # On recupere la liste des temperatures a t et t+1
+            lst_T_0 = T_TABL_TMP0.values()['TEMP']
+            lst_T_1 = T_TABL_TMP1.values()['TEMP']
+            # Le maximum des ecarts
+            lst_T_diff_01 = []
+            for v1, v2 in zip(lst_T_0,lst_T_1):
+               lst_T_diff_01.append(abs(v1-v2))
+            max_T_diff_01 = max(lst_T_diff_01)
+
+            # On recupere la liste des pressions a t et t+1
+            lst_P_0 = T_TABL_TMP0.values()['PRESSION']
+            lst_P_1 = T_TABL_TMP1.values()['PRESSION']
+            # Le maximum des ecarts
+            lst_P_diff_01 = []
+            for v1, v2 in zip(lst_P_0,lst_P_1):
+               lst_P_diff_01.append(abs(v1-v2))
+            max_P_diff_01 = max(lst_P_diff_01)
+            #
+            # "TEMP_PRESS","EXPLICITE","TEMP","PRESS"
+            ErreurT = (max_T_diff_01/MacrTempRef)
+            ErreurP = (max_P_diff_01/MacrPresRef)
+            ErreurG = (ErreurT**2+ErreurP**2)**0.5
+            if   ( MacrCritere == 'TEMP' ):
+               Erreur = ErreurT
+            elif ( MacrCritere == 'PRESS' ):
+               Erreur = ErreurP
+            else:
+               Erreur = ErreurG
+            #
+            print 'CONVERGENCE_MACR_ECREVISSE. Instant de calcul : %.3f .' % (_inst_p_un)
+            print '  Erreur en Temperature : %f . Ecart en Temperature : %.3f' % (ErreurT,max_T_diff_01)
+            print '  Erreur en Pression    : %f . Ecart en Pression    : %.3f' % (ErreurP,max_P_diff_01)
+            print '  Erreur Temp-Press     : %f' % (ErreurG)
+            if ( MacrCritere != 'EXPLICITE' ):
+               Convergence = ( Erreur <= MacrPrecisCritere )
+               print 'CONVERGENCE_MACR_ECREVISSE . Nature du Critere %s . Valeur du critere %s . Convergence %s ' % (MacrCritere,MacrPrecisCritere,Convergence,)
+
+         else:
+            Convergence = True
+            print 'CONVERGENCE_MACR_ECREVISSE. 1er Instant de calcul : %f . Pas de calcul de critere.' % (_inst_p_un)
+         # --------------------
+
+         #
+
+         if ( MacrCritere == 'EXPLICITE' ):
+            Convergence = True
+         else:
+            if ( (_nume_ordre != 0) and (_nume_ordre+1 <= MacrNumeOrdre) ):
+               UTMESS('A','ECREVISSE0_33', vali=[_nume_ordre+1,MacrNumeOrdre],valr=[_inst_p_un])
+               Convergence = True
+
+         if ( Convergence ):
+            nb_lignes_t1 = len(T_TABL_TMP1["COTES"])
+            # Ajout de deux colonnes supplementaires
+            # POUR LA TABLE ECREVISSE
+            T_TABL_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_lignes_t1
+            T_TABL_TMP1["INST"]       = [_inst_p_un]*nb_lignes_t1
+
+            # POUR LA TABLE DES DEBITS  
+            nb_ligne_t2 = len(T_DEB_TMP1["DEBTOT"])
+            T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_ligne_t2
+            T_DEB_TMP1["INST"]       = [_inst_p_un]*nb_ligne_t2
+
+            #
+            # Ajout des infos dans la table finale
+            if ( IsInit ):
+               T_TABL_RES = T_TABL_TMP1
+               T_DEB_RES  = T_DEB_TMP1
+            else:
+               T_TABL_RES = merge(T_TABL_RES, T_TABL_TMP1)
+               T_DEB_RES = merge(T_DEB_RES, T_DEB_TMP1)
+               T_TABL_RES.titr = 'TABLE_SDASTER CHARGEMENT ECREVISSE'
+               T_DEB_RES.titr = 'TABLE_SDASTER DEBIT ECREVISSE'
+            #
+            # RAZ des compteurs de division
+            NbIter = 0
+            # On memorise les concepts valides
+            MECAECR0 = MECAECR1
+            FLU1ECR0 = FLU1ECR1
+            FLU2ECR0 = FLU2ECR1
+            TABLECR0 = TABLECR1
+            DEBIECR0 = DEBIECR1
+            #
+            T_TABL_TMP0 = T_TABL_TMP1
+            if (not IsInitEcre) :
+              IsInit = False
+            if ( debug1 ):
+               print 'Convergence atteinte, on passe au pas de temps suivant'
+            break
+            
+         else:
+            NbIter += 1
+            # A t'on le droit de decouper, par rapport au nombre de division
+            if ( NbIter > MacrNbDecoupage ):
+               FinBoucle = True
+               UTMESS('A','ECREVISSE0_30', valr=[_inst,_inst_p_un],vali=[MacrNbDecoupage])
+               break
+            #
+            # on divise le pas de temps par 2
+            tmp = (_inst + _inst_p_un )*0.5
+            # A t'on le droit de continuer, par rapport au pas de temps minimum
+            if ( (tmp - _inst) <= MacrPasMini ):
+               FinBoucle = True
+               UTMESS('A','ECREVISSE0_31', valr=[_inst,_inst_p_un,tmp,MacrPasMini])
+               break
+            #
+            if ( debug1 ):
+               UTMESS('A','ECREVISSE0_32', valr=[_inst,_inst_p_un,tmp],vali=[NbIter])
+            # on insere le nouveau temps dans la liste des instants avant "_inst_p_un"
+            _liste_inst.insert(_nume_ordre+1,tmp)
+
+
+      # Convergence atteinte, on passe au pas de temps suivant, s'il en reste
+      if IsInitEcre :
+         continue
+      elif (_nume_ordre + 2 < len(_liste_inst)):
+         _nume_ordre += 1
+      else:
+         # On a fait tous les pas de temps
+         FinBoucle = True
+   #######################################################################################
+   #     Fin boucle sur les pas de temps
+   #######################################################################################
+
+   # Creation du concept de la table en sortie
+   if ( T_TABL_RES != None ):
+      dprod = T_TABL_RES.dict_CREA_TABLE()
+      TABL_RES = CREA_TABLE(**dprod)
+   if ( T_DEB_RES != None ):
+      debprod = T_DEB_RES.dict_CREA_TABLE()
+      DEB_RES = CREA_TABLE(**debprod)
+
+   # Destruction des concepts temporaires
+   DETRUIRE(
+            CONCEPT=( _F(NOM=MECAECR1),
+                      _F(NOM=FLU1ECR1),
+                      _F(NOM=FLU2ECR1),
+                      _F(NOM=TABLECR1),
+                      _F(NOM=DEBIECR1),
+            ),
+            INFO=1,ALARME='NON',
+   )
+   
+   if (_nume_ordre != 0 ):
+       DETRUIRE(
+                CONCEPT=( _F(NOM=MECAECR0),
+                          _F(NOM=FLU1ECR0),
+                          _F(NOM=FLU2ECR0),
+                          _F(NOM=TABLECR0),
+                          _F(NOM=DEBIECR0),
+                ),
+                INFO=1,ALARME='NON',
+       )
+
+   return ier

diff --git a/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py
index fd7078e5f54da7f3e08f87823f8fffa193a83b7c..a503e9da1701101d6dc46e29b405c86347564c92 100644 (file)
--- a/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py
+++ b/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py
@@ -1,4 +1,4 @@
-#@ MODIF macr_lign_coupe_ops Macro  DATE 07/10/2008   AUTEUR PELLET J.PELLET 
+#@ MODIF macr_lign_coupe_ops Macro  DATE 18/11/2009   AUTEUR MACOCCO K.MACOCCO 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -788,6 +788,10 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE,
 
   if n_modele in self.get_global_contexte().keys() : MODELE_1=self.get_global_contexte()[n_modele]
   else                                             : MODELE_1=self.jdc.current_context[n_modele]
+
+
+  if NOM_CHAM[5:9]=='ELGA' : UTMESS('F','POST0_18',valk=[NOM_CHAM,])
+
   __recou=PROJ_CHAMP(METHODE='ELEM',
                      RESULTAT=RESULTAT,
                      MODELE_1=MODELE_1,

diff --git a/Aster/Cata/cataSTA9/Macro/post_gp_ops.py b/Aster/Cata/cataSTA9/Macro/post_gp_ops.py
index a66baa1fb5372a697274a6a6e57f629484669fa9..bb6e7fa0cfe3fc71ead855748ed49b5f1f3bbfab 100644 (file)
--- a/Aster/Cata/cataSTA9/Macro/post_gp_ops.py
+++ b/Aster/Cata/cataSTA9/Macro/post_gp_ops.py
@@ -1,4 +1,4 @@
-#@ MODIF post_gp_ops Macro  DATE 15/04/2008   AUTEUR MACOCCO K.MACOCCO 
+#@ MODIF post_gp_ops Macro  DATE 18/11/2009   AUTEUR MACOCCO K.MACOCCO 
 # -*- coding: iso-8859-1 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
@@ -538,11 +538,6 @@ def post_gp_ops(self, **args):
          'YOUNG' : CallRCVALE(TEMP, 'E', MATER),
          'NU'    : CallRCVALE(TEMP, 'NU', MATER),
       }
-      if is_2D:
-         dict_constantes['R'] = self['RAYON_AXIS']
-      else:
-         dict_constantes['R'] = ep_tranche
-         
       
       # 3.3. ----- calcul de Kj(G)
       l_tabi = []
@@ -554,8 +549,7 @@ def post_gp_ops(self, **args):
          if is_2D:
             # fusion avec TEMP, E et nu
             tab = merge(tab, t_relev, 'NUME_ORDRE')
-            tab.fromfunction(new_para, fKj, ('G', 'YOUNG', 'NU'),
-                           { 'R' : self['RAYON_AXIS'] })
+            tab.fromfunction(new_para, fKj, ('G', 'YOUNG', 'NU'))
             # renomme G en G_i
             tab.Renomme('G', 'G_%d' % (k + 1))
          else:
@@ -797,11 +791,10 @@ def CallRCVALE(TEMP, para, MATER):
    return valres
 
 # -----------------------------------------------------------------------------
-def fKj(G, YOUNG, NU, R=1):
+def fKj(G, YOUNG, NU):
    """Calcul de Kj à partir de G (formule d'Irwin)
-      R n'intervient pas en 3D
    """
-   Kj=(abs(G / R * YOUNG / (1.0 - NU**2)))**0.5
+   Kj=(abs(G * YOUNG / (1.0 - NU**2)))**0.5
    return Kj
 
 # -----------------------------------------------------------------------------

diff --git a/Aster/Cata/cataSTA9/SD/utilsd.py b/Aster/Cata/cataSTA9/SD/utilsd.py
index 01726a8d825c051065cb146308c452e504a591bf..ab3e6a4bb14f8cdd0037eafb37b369ee7ce6b6a9 100644 (file)
--- a/Aster/Cata/cataSTA9/SD/utilsd.py
+++ b/Aster/Cata/cataSTA9/SD/utilsd.py
@@ -23,6 +23,7 @@
    Utilitaire sur le catalogue des structures de données.
 """
 
+__revision__ = "$Id: $"
 
 import sys
 import os

diff --git a/Aster/Cata/cataSTA9c_clefs_docu b/Aster/Cata/cataSTA9c_clefs_docu
new file mode 100644 (file)
index 0000000..8efdfe0
--- /dev/null
+++ b/Aster/Cata/cataSTA9c_clefs_docu
@@ -0,0 +1,217 @@
+AFFE_CARA_ELEM:U4.42.01-i.pdf
+AFFE_CHAR_ACOU:U4.44.04-g
+AFFE_CHAR_CINE_F:U4.44.03-h
+AFFE_CHAR_CINE:U4.44.03-h
+AFFE_CHAR_MECA:U4.44.01-i
+AFFE_CHAR_MECA_F:U4.44.01-i
+AFFE_CHAR_MECA_C:U4.44.05-f
+AFFE_CHAR_THER_F:U4.44.02-h
+AFFE_CHAR_THER:U4.44.02-h
+AFFE_CHAR_THER_F:U4.44.02-i
+AFFE_CHAR_THER:U4.44.02-i
+AFFE_MATERIAU:U4.43.03-i
+AFFE_MODELE:U4.41.01-i
+AIDE:U4.02.01-i
+ASSE_MAILLAGE:U4.23.03-h
+ASSE_MATRICE:U4.61.22-i
+ASSE_MATR_GENE:U4.65.04-g
+ASSE_VECTEUR:U4.61.23-i
+ASSE_VECT_GENE:U4.65.05-g
+CALC_AMOR_MODAL:U4.52.13-g
+CALC_CHAM_ELEM:U4.81.03-i
+CALC_CHAR_CINE:U4.61.03-h
+CALC_CHAR_SEISME:U4.63.01-h
+CALC_ELEM:U4.81.01-i
+CALC_FATIGUE:U4.83.02-f
+CALC_FLUI_STRU:U4.66.02-g
+CALC_FONCTION:U4.32.04-i
+CALC_FONC_INTERP:U4.32.01-g
+CALC_FORC_AJOU:U4.66.03-c
+CALC_G:U4.82.03-h
+CALC_G_THETA_T:U4.82.03-g
+CALC_INTE_SPEC:U4.36.03-h
+CALC_MATR_AJOU:U4.66.01-f
+CALC_MATR_ELEM:U4.61.01-i
+CALC_META:U4.85.01-d
+CALC_NO:U4.81.02-h
+CALC_PRECONT:U4.42.05-b
+CALC_TABLE:U4.33.03-a
+CALC_THETA:U4.82.02-g
+CALC_VECT_ELEM:U4.61.02-i
+COMB_CHAM_ELEM:U4.72.03-g
+COMB_CHAM_NO:U4.72.02-h
+COMB_FOURIER:U4.83.31-f
+COMB_MATR_ASSE:U4.72.01-i
+COMB_SISM_MODAL:U4.84.01-g
+COMP_INCR:U4.51.11-b
+CREA_CHAMP:U4.72.04-d
+CREA_MAILLAGE:U4.23.02-f
+CREA_RESU:U4.44.12-g
+CREA_TABLE:U4.33.02-b
+DEBUT:U4.11.01-i
+DEFI_ CONSTANTE:U4.31.01-i
+DEFI_BASE_MODALE:U4.64.02-h1
+DEFI_CABLE_BP:U4.42.04-d
+DEFI_COMPOR:U4.43.06-b
+DEFI_CONSTANTE:U4.31.01-h
+DEFI_COQU_MULT:U4.42.03-h
+DEFI_FICHIER:U4.12.03-b
+DEFI_FISS_XFEM:U4.82.08-b
+DEFI_FLUI_STRU:U4.25.01-g
+DEFI_FONCTION:U4.31.02-i
+DEFI_FONC_ELEC:U4.mk.10-h
+DEFI_FONC_FLUI:U4.35.01-f
+DEFI_FOND_FISS:U4.82.01-h
+DEFI_GROUP:U4.22.01-h
+DEFI_INTERF_DYNA:U4.64.01-h
+DEFI_INTE_SPEC:U4.36.02-h
+DEFI_LIST_ENTI:U4.34.02-i
+DEFI_LIST_REEL:U4.34.01-i
+DEFI_MAILLAGE:U4.23.01-h
+DEFI_MATERIAU:U4.43.01-i
+DEFI_MODELE_GENE:U4.65.02-g
+DEFI_NAPPE:U4.31.03-i
+DEFI_OBSTACLE:U4.44.21-h
+DEFI_PARA_SENSI:U4.31.06-c
+DEFI_PART_FETI:U4.23.05-a1
+DEFI_SPEC_TURB:U4.44.31-f
+DEFI_SQUELETTE:U4.24.01-i
+DEFI_THER_JOULE:U4.mk.20-f
+DEFI_TRC:U4.43.04-h
+DEPL_INTERNE:U4.62.02-h
+DETRUIRE:U4.14.01-g
+DIST_LIGN_3D:U4.mk.30-f
+DYNA_ALEA_MODAL:U4.53.22-h
+DYNA_LINE_HARM:U4.53.11-h
+DYNA_LINE_TRAN:U4.53.02-i
+DYNA_NON_LINE:U4.53.01-h
+DYNA_SPEC_MODAL:U4.53.23-f
+DYNA_TRAN_EXPLI:U4.53.03-b
+DYNA_TRAN_MODAL:U4.53.21-h
+ENGENDRE_TEST:U4.92.11-e
+EXEC_LOGICIEL:U7.00.01-d
+EXTR_MODE:U4.52.12-f
+EXTR_RESU:U4.71.04-e
+EXTR_TABLE:U4.71.05-b
+FACT_GRAD:U4.55.03-h
+FACT_LDLT:U4.55.01-i
+FIN:U4.11.02-i
+FONC_FLUI_STRU:U4.35.02-f
+FORMULE:U4.31.05-g
+GENE_FONC_ALEA:U4.36.05-h
+GENE_MATR_ALEA:U4.36.06-c
+GENE_VARI_ALEA:U4.36.07-c
+IMPR_CO:U4.91.11-i
+IMPR_FONCTION:U4.33.01-g
+IMPR_GENE:U4.91.02-f
+IMPR_JEVEUX:U4.91.21-i
+IMPR_MACR_ELEM:U7.04.33-g
+IMPR_MATRICE:U7.04.32-f
+IMPR_MISS3D:U7.04.11-f
+IMPR_MISS_3D:U7.04.11-e
+IMPR_OAR:U7.04.51-b
+IMPR_RESU:U4.91.01-i
+IMPR_STURM:U4.52.01-i
+IMPR_TABLE:U4.91.03-f
+INCLUDE:U4.13.01-h
+INCLUDE_MATERIAU:U4.43.02-d
+INFO_EXEC_ASTER:U4.13.04-b
+INFO_FONCTION:U4.32.05-a
+INTE_MAIL_2D:U4.81.11-h
+INTE_MAIL_3D:U4.81.12-h
+LIRE_CHAMP:U7.02.02-d
+LIRE_FONCTION:U4.32.02-h
+LIRE_FORC_MISS:U7.02.33-a
+LIRE_IMPE_MISS:U7.02.32-a
+LIRE_INTE_SPEC:U4.36.01-h
+LIRE_MAILLAGE:Patronvestepatchwork.pdf
+LIRE_MISS_3D:U7.02.31-f
+LIRE_PLEXUS:U7.02.11-d
+LIRE_RESU:U7.02.01-f
+LIRE_TABLE:U7.02.03-c
+MACRO_ELAS_MULT:U4.51.02-e
+MACRO_ELIAS_MULT:U4.51.02-f
+MACRO_MATR_AJOU:U4.66.11-e
+MACRO_MATR_ASSE:U4.61.21-f
+MACRO_MISS_3D:U7.03.11-e
+MACRO_MODE_MECA:U4.52.02-f
+MACRO_PROJ_BASE:U4.63.11-f
+MACR_ADAP_MAIL:U7.03.01-d
+MACR_ASCOUF_CALC:U4.cf.20-d
+MACR_ASCOUF_MAIL:U4.cf.10-d
+MACR_ASPIC_CALC:U4.pc.20-d
+MACR_ASPIC_MAIL:U4.pc.10-d
+MACR_CABRI_CALC:U4.cb.20-b
+MACR_CABRI_MAIL:U4.cb.10-b
+MACR_CARA_POUTRE:U4.42.02-f
+MACR_ECLA_PG:U4.44.14-b
+MACR_ELEM_DYNA:U4.65.01-g
+MACR_ELEM_STAT:U4.62.01-h
+MACR_FIABILITE:U7.03.31-b
+MACR_FIAB_IMPR:U7.04.41-b
+MACR_INFO_MAIL:U7.03.02-d
+MACR_LIGN_COUPE:U4.81.13-c
+MACR_RECAL:U4.73.02-c
+MACR_SPECTRE:U4.32.11-a
+MAC_MODES:U4.52.15-a
+MAJ_CATA:U4.15.01-g
+MECA_STATIQUE:U4.51.01-i
+MEMO_NOM_SENSI:U4.31.07-c
+MODE_ITER_CYCL:U4.52.05-h
+MODE_ITER_INV:U4.52.04-i
+MODE_ITER_SIMULT:U4.52.03-h
+MODE_STATIQUE:U4.52.14-h
+MODI_BASE_MODALE:U4.66.21-f
+MODI_MAILLAGE:U4.23.04-f
+MODI_MODELE_XFEM:U4.41.11-b
+MODI_OBSTACLE:U4.44.22-d
+MODI_REPERE:U4.74.01-c
+NORM_MODE:U4.52.11-h
+NUME_DDL:U4.61.11-i
+NUME_DDL_GENE:U4.65.03-g
+POST_CHAM_XFEM:U4.82.22-a
+POST_DYNA_ALEA:U4.84.04-g
+POST_DYNA_MODA_T:U4.84.02-g
+POST_ELEM:U4.81.22-g
+POST_FATIGUE:U4.83.01-f
+POST_FATI_ALEA:U4.84.03-f
+POST_GP:U4.82.31-a
+POST_K1_K2_K3:U4.82.05-d
+POST_K_BETA:U4.82.07-c
+POST_K_TRANS:U4.82.30-a
+POST_MAIL_XFEM:U4.82.21-a
+POST_RCCM:U4.83.11-f
+POST_RELEVE_T:U4.81.21-g1
+POST_USURE:U4.84.05-g
+POST_ZAC:U4.83.21-e
+POURSUITE:U4.11.03-i
+PRE_GIBI:U7.01.11-i
+PRE_GMSH:U7.01.31-c
+PRE_IDEAS:U7.01.01-i
+PROD_MATR_CHAM:U4.72.06-e
+PROJ_CHAMP:U4.72.05-g
+PROJ_MATR_BASE:U4.63.12-h
+PROJ_MESU_MODAL:U4.73.01-d
+PROJ_SPEC_BASE:U4.63.14-f
+PROJ_VECT_BASE:U4.63.13-h
+PROPA_XFEM:U4.82.11-a
+RECA_WEIBULL:U4.82.06-d
+RECU_FONCTION:U4.32.03-h
+RECU_GENE:U4.71.03-h
+RECU_TABLE:U4.71.02-d
+RESO_GRAD:U4.55.04-h
+RESO_LDLT:U4.55.02-i
+REST_BASE_PHYS:U4.63.21-h
+REST_SPEC_PHYS:U4.63.22-f
+SENSIBILITE:U4.50.02-c
+SIMU_POINT_MAT:U4.51.12-a
+SOLVEUR:U4.50.01-f
+STANLEY:U4.81.31-c
+STAT_NON_LINE:U4.51.03-h
+TEST_FICHIER:U4.92.04-b
+TEST_FONCTION:U4.92.02-h
+TEST_RESU:U4.92.01-i
+TEST_TABLE:U4.92.03-e
+THER_LINEAIRE:U4.54.01-i
+THER_NON_LINE:U4.54.02-g
+THER_NON_LINE_MO:U4.54.03-e