From: Christian Caremoli <> Date: Wed, 15 Nov 2006 17:59:35 +0000 (+0000) Subject: CCAR: 1- mise a niveau avec Aster 8.3.21 (catalogue dans cataSTA8) X-Git-Tag: CC_param_poursuite X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=7140611cbaa8899b6d4c944210c8cb104a881343;p=tools%2Feficas.git CCAR: 1- mise a niveau avec Aster 8.3.21 (catalogue dans cataSTA8) 2- correction d'un bug sur la prise en compte des parametres dans les poursuites : http://clpwdev.der.edf.fr:8080/REX/issue9791 3- adaptation d'EFICAS à la suppression du prefixe pour les INCLUDE_MATERIAU 4- quelques corrections diverses --- diff --git a/Aster/Cata/cataSTA7/__init__.py b/Aster/Cata/cataSTA7/__init__.py index 654fb130..0a644069 100644 --- a/Aster/Cata/cataSTA7/__init__.py +++ b/Aster/Cata/cataSTA7/__init__.py @@ -1,6 +1,4 @@ import os,sys -import prefs -import sys -rep_macro = os.path.join(prefs.REPINI,'Cata/cataSTA7') +rep_macro = os.path.dirname(__file__) sys.path.insert(0,rep_macro) from cata import * diff --git a/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py b/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py index 68ddb810..afe030a7 100644 --- a/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py +++ b/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_precont_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +#@ MODIF calc_precont_ops Macro DATE 10/10/2006 AUTEUR REZETTE C.REZETTE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -25,7 +25,7 @@ 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,SOLV_NON_LOCAL, - LAGR_NON_LOCAL,PARM_THETA,INFO,TITRE,**args): + LAGR_NON_LOCAL,INFO,TITRE,**args): """ @@ -291,12 +291,20 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, 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) ) + 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) ) + dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I,) ) # 1.5 Modele contenant uniquement les cables de precontrainte @@ -354,11 +362,11 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, _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, - PARM_THETA = PARM_THETA, INFO =INFO, TITRE = TITRE, ) @@ -421,7 +429,6 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, SOLV_NON_LOCAL = dSolv_nonloc, LAGR_NON_LOCAL = dLagr_nonloc, ARCHIVAGE = _F(INST = __TINT), - PARM_THETA = PARM_THETA, INFO =INFO, TITRE = TITRE, EXCIT = dExcit1, @@ -457,7 +464,6 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, LAGR_NON_LOCAL = dLagr_nonloc, ARCHIVAGE = _F(NUME_INIT = __no, DETR_NUME_SUIV = 'OUI' ), - PARM_THETA = PARM_THETA, INFO =INFO, TITRE = TITRE, EXCIT =dExcit2, diff --git a/Aster/Cata/cataSTA8/Macro/calc_table_ops.py b/Aster/Cata/cataSTA8/Macro/calc_table_ops.py index cd62da23..74201a01 100644 --- a/Aster/Cata/cataSTA8/Macro/calc_table_ops.py +++ b/Aster/Cata/cataSTA8/Macro/calc_table_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_table_ops Macro DATE 10/04/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF calc_table_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -29,19 +29,23 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): import aster macro = 'CALC_TABLE' - from Accas import _F - from Cata.cata import table_jeveux - from Utilitai.Utmess import UTMESS - from Utilitai import transpose - from Utilitai.Table import Table, merge - from Utilitai.Sensibilite import NomCompose + 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 + from Utilitai.Sensibilite import NomCompose 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 + # 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 @@ -112,7 +116,7 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): if occ['OPERATION'] == 'COMB': tab2 = occ['TABLE'].EXTR_TABLE() opts = [tab, tab2] - if occ['NOM_PARA']<>None: + if occ.get('NOM_PARA') != None: lpar = occ['NOM_PARA'] if not type(lpar) in EnumTypes: lpar = [lpar] @@ -157,6 +161,7 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): tit = [tit] dprod['TITRE'] = tuple(['%-80s' % lig for lig in tit]) # type de la table de sortie à passer à CREA_TABLE - tabout = CREA_TABLE(**dprod) + tabout = CREA_TABLE(TYPE_TABLE=typ_tabout, + **dprod) return ier diff --git a/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py b/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py index 3c41eccf..ed50681b 100644 --- a/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py +++ b/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py @@ -1,4 +1,4 @@ -#@ MODIF creation_donnees_homard Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF creation_donnees_homard Macro DATE 30/10/2006 AUTEUR DURAND C.DURAND # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18,11 +18,11 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE MCOURTOI M.COURTOIS -__all__ = [ ] """ Cette classe crée le fichier de configuration permettant de lancer HOMARD depuis Code_Aster. """ -__revision__ = "V1.0" +__revision__ = "V1.1" +__all__ = [ ] import os import os.path @@ -109,9 +109,9 @@ class creation_donnees_homard: # print "\nArguments a l'entree de", __name__, ":", entier # try: - la_chaine = '%02d' % entier + la_chaine = '%02d' % entier except TypeError: - la_chaine = None + la_chaine = None # return la_chaine # ------------------------------------------------------------------------------ @@ -173,6 +173,8 @@ class creation_donnees_homard: 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 # @@ -269,12 +271,12 @@ class creation_donnees_homard: 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"] : + 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"] : + 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"] : + 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 @@ -370,8 +372,8 @@ class creation_donnees_homard: 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("Les fichiers de bilan") - self.ecrire_ligne_configuration_2("PPBasFic", "info") + 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 # @@ -409,35 +411,37 @@ class creation_donnees_homard: 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.3. Les niveaux extremes +# 5.4. Les niveaux extremes # for aux in self.niveau : self.ecrire_ligne_configuration_2(aux[0], aux[1]) # -# 6. 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"]) -# -# 7. Les éventuels champs à mettre à jour +# 6. Les éventuels champs à mettre à jour # if self.dico_configuration.has_key("Champs") : self.ecrire_ligne_configuration_0("Champs à mettre à jour") @@ -454,7 +458,7 @@ class creation_donnees_homard: elif maj_champ.has_key("INST") : self.ecrire_ligne_configuration_3("CCChaIns", iaux, maj_champ["INST"]) # -# 8. L'éventuel maillage de frontière +# 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") @@ -466,13 +470,16 @@ class creation_donnees_homard: for group_ma in self.mots_cles["GROUP_MA"] : self.ecrire_ligne_configuration_2("CCGroFro", group_ma) # -# 9. L'usage des éléments incompatibles avec HOMARD +# 8. L'éventuel maillage annexe # - 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) + 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"]) # -# 10. Options particulières +# 9. Options particulières # self.ecrire_ligne_configuration_0("Autres options") if self.mots_cles.has_key("LANGUE") : @@ -482,6 +489,12 @@ class creation_donnees_homard: 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() diff --git a/Aster/Cata/cataSTA8/Macro/defi_inte_spec_ops.py b/Aster/Cata/cataSTA8/Macro/defi_inte_spec_ops.py new file mode 100644 index 00000000..63a04aec --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/defi_inte_spec_ops.py @@ -0,0 +1,153 @@ +#@ MODIF defi_inte_spec_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI 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 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 : + txt = "nombre de fonctions erroné pour une matrice hermitienne" + UTMESS('F',commande, txt) + + 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'] 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', macro, "FORMAT SALOME, L'ARGUMENT 1 DOIT ETRE " \ + "LE NOM DU FICHIER MED PRODUIT PAR LE SCRIPT PYTHON.") + else: + d_para['fichMED'] = l_args[0] + + else: + UTMESS('F', macro, "ON NE SAIT PAS TRAITER LE FORMAT '%s'" % 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 = ExecCommand(scmd, + alt_comment=comment) + # écrire l'output dans le .mess si demandé + if INFO == 2: + aster.affiche('MESSAGE', output) + + if CODE_RETOUR_MAXI >= 0 and iret > CODE_RETOUR_MAXI: + UTMESS('F', macro, 'CODE RETOUR INCORRECT (MAXI %d) : %d' \ + % (CODE_RETOUR_MAXI, iret)) + + #---------------------------------------------- + # 3b. Exécution d'un fichier Python + elif mode_lancement == EXECFILE: + if d_para['prog'] != '': + UTMESS('A', macro, "LE MOT-CLE LOGICIEL N'EST PAS UTILISE AVEC CE FORMAT") + context={} + try: + execfile(d_para['fichIN'], context) + except: + traceback.print_exc() + txt = open(d_para['fichIN'], 'r').read() + UTMESS('F', macro, """ERREURS LORS DE L'EXECUTION DU FICHIER CI-DESSOUS : +<<<<<<<<<<<<<<< DEBUT DU FICHIER >>>>>>>>>>>>>>> +%s +<<<<<<<<<<<<<<< FIN DU FICHIER >>>>>>>>>>>>>>> +""" % txt) + + if not os.path.exists(d_para['fichMED']): + UTMESS('F', macro, "LE FICHIER %s N'EXISTE PAS" % 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', macro, "Mode de lancement inconnu : %s" % 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/cataSTA8/Macro/impr_oar_ops.py b/Aster/Cata/cataSTA8/Macro/impr_oar_ops.py new file mode 100644 index 00000000..ce3bf2b5 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/impr_oar_ops.py @@ -0,0 +1,769 @@ +#@ MODIF impr_oar_ops Macro DATE 07/11/2006 AUTEUR DURAND C.DURAND +# -*- 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 aster +from Utilitai.Utmess import UTMESS +from Utilitai.Table import Table +from Utilitai.partition import MAIL_PY + +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\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 + "\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', 'IMPR_OAR', 'LES COUPES MECANIQUES ET THERMIQUE DOIVENT PARTAGER LES MEMES ABSCISSES') + + try : + self.interpoleInstants() # Interpolation des instants de la table des température sur celle de la table mécanique + except interpolationError, err: + UTMESS('F', 'IMPR_OAR', 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', 'IMPR_OAR', 'LES COUPES DU REVETEMENT ET DE LA STRUCTURE DOIVENT PARTAGER UNE ABSCISSE COMMUNE') + + # 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', 'IMPR_OAR', 'LES COUPES DU REVETEMENT ET DE LA STRUCTURE DOIVENT PARTAGER UNE ABSCISSE COMMUNE') + + # 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', 'IMPR_OAR', "ERREUR D'ACCES AUX DONNEES") + + # 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', 'IMPR_OAR', 'FONCTION NON IMPLANTEE') + elif TYPE_CALC=='TUYAUTERIE' : + obj = tuyauterie(**args) + else : + UTMESS('F', 'IMPR_OAR', 'Mot clé facteur inconnu') + + # 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', 'IMPR_OAR', "Erreur à l'ouverture du fichier") + else : + obj.getNode().save(fileObj) + fileObj.close() diff --git a/Aster/Cata/cataSTA8/Macro/impr_table_ops.py b/Aster/Cata/cataSTA8/Macro/impr_table_ops.py index 4b90940d..fec1bdbb 100644 --- a/Aster/Cata/cataSTA8/Macro/impr_table_ops.py +++ b/Aster/Cata/cataSTA8/Macro/impr_table_ops.py @@ -1,4 +1,4 @@ -#@ MODIF impr_table_ops Macro DATE 07/03/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF impr_table_ops Macro DATE 06/11/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -145,8 +145,9 @@ def impr_table_ops(self, FORMAT, TABLE, INFO, **args): if not p in tab.para: UTMESS('A', 'IMPR_TABLE', 'Paramètre absent de la table : %s' % p) - # sélection des paramètres - timp=tab[nom_para] + # sélection des paramètres et suppression des colonnes vides + timp = tab[nom_para] + timp = timp.SansColonneVide() # passage des mots-clés de mise en forme à la méthode Impr kargs=args.copy() @@ -193,7 +194,7 @@ def impr_table_ops(self, FORMAT, TABLE, INFO, **args): if args['IMPR_FONCTION'] and args['IMPR_FONCTION']=='OUI': # cherche parmi les cellules celles qui contiennent un nom de fonction dfon={} - for row in timp: + for row in timp['FONCTION', 'FONCTION_C']: for par,cell in row.items(): if type(cell) in StringTypes: if aster.getvectjev(cell.strip().ljust(19)+'.PROL')<>None: @@ -213,7 +214,6 @@ def impr_table_ops(self, FORMAT, TABLE, INFO, **args): # 99. Traiter le cas des UL réservées UL.EtatInit() - return ier # ------------------------------------------------------------------------------ diff --git a/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py b/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py index 0554e0cd..0fe9c89e 100644 --- a/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py +++ b/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py @@ -1,4 +1,4 @@ -#@ MODIF info_fonction_ops Macro DATE 02/05/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF info_fonction_ops Macro DATE 24/10/2006 AUTEUR DURAND C.DURAND # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -27,9 +27,13 @@ def info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,INFO,**args): 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') @@ -41,22 +45,69 @@ def info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,INFO,**args): ### if (MAX != None): - __ff=MAX['FONCTION'].convert() - __ex=__ff.extreme() - n_mini=len(__ex['min']) - n_maxi=len(__ex['max']) - listeMCF=[_F(LISTE_K=[MAX['FONCTION'].nom]*(n_mini+n_maxi),PARA='FONCTION'), - _F(LISTE_K=['MINI',]*n_mini+['MAXI',]*n_maxi,PARA='TYPE'),] - 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'])] - C_out=CREA_TABLE(LISTE=listeMCF) + 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 : + UTMESS('F','INFO_FONCTION',''' calcul du MAX, la liste de fonctions\ + n'est pas homogène en type (fonctions et nappes) ''') + if len(lpara)>1 : + UTMESS('F','INFO_FONCTION',''' calcul du MAX, la liste de fonctions\ + n'est pas homogène en label NOM_PARA :'''+' '.join(lpara)) + if len(lresu)>1 : + UTMESS('F','INFO_FONCTION',''' calcul du MAX, la liste de fonctions\ + n'est pas homogène en label NOM_RESU : '''+' '.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): diff --git a/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py b/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py index a2bd9567..e4f1188d 100644 --- a/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py +++ b/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py @@ -1,4 +1,4 @@ -#@ MODIF lire_inte_spec_ops Macro DATE 03/01/2006 AUTEUR REZETTE C.REZETTE +#@ MODIF lire_inte_spec_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -106,10 +106,11 @@ def lire_inte_spec_ops(self,UNITE,FORMAT,NOM_PARA,NOM_RESU,INTERPOL, 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' ,LISTE_K=l_fonc ,NUME_LIGN=range(2,len(list_fonc)+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,) + TITRE=TITRE, + TYPE_TABLE='TABLE_FONCTION') # remet UNITE dans son état initial UL.EtatInit() diff --git a/Aster/Cata/cataSTA8/Macro/lire_table_ops.py b/Aster/Cata/cataSTA8/Macro/lire_table_ops.py index 5d4edeff..af24a012 100644 --- a/Aster/Cata/cataSTA8/Macro/lire_table_ops.py +++ b/Aster/Cata/cataSTA8/Macro/lire_table_ops.py @@ -1,4 +1,4 @@ -#@ MODIF lire_table_ops Macro DATE 03/01/2006 AUTEUR REZETTE C.REZETTE +#@ MODIF lire_table_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18,160 +18,135 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import string +import os +import re # ------------------------------------------------------------------------------ -def lecture_table(texte,nume,separ): - """Méthode de construction du dictionnaire PARAMETRE / LISTE DE VALEURS - format ASTER - 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 - VALE_PARA et VALE_RESU est l indice permettant de pointer sur la - fonction voulue, au sens de ce découpage. - """ - - from Utilitai.transpose import transpose - if string.strip(separ)=='' : separ=None - tab_lue={} - nume_lign=[] - idt_deb='#DEBUT_TABLE\n' - idt_fin='#FIN_TABLE\n' - idt_tit='#TITRE' - if nume>texte.count(idt_deb) : - message= " NUME_TABLE :le nombre de blocs de tables dans " - message=message+"le fichier est "+str(texte.count(idt_deb)) - return 1,message,None,None,None - for i in range(nume): - texte=texte[texte.index(idt_deb)+1:] - texte=texte[:texte.index(idt_fin)] - - titre_tab=[string.rstrip(elem[7:-1]) for elem in texte if elem.find(idt_tit)!=-1] - texte_tab=[elem.split(separ) for elem in texte if elem.find(idt_tit)==-1] - - if ( separ!=None) : - tab_trav=[] - for line in texte_tab : - ligne=[] - for elem in line : - if ( elem != '' and elem !='\n') : - ligne.append(string.strip(elem)) - tab_trav.append(ligne) - texte_tab=tab_trav - - list_para=texte_tab[0] - list_type=texte_tab[1] - texte_tab.pop(0) - texte_tab.pop(0) - nb_para=len(texte_tab[0]) - - for line in texte_tab : - if len(line)!=nb_para : - message= " incoherence dans le nombre de colonnes " - message=message+"de la table a lire" - return 1,message,None,None,None - texte_tab=transpose(texte_tab) - for i in range(nb_para): - tab_trav=[] - list_val=[] - col_type=list_type[i] - if col_type=='R': - try : - texte_tab[i]=map(float,texte_tab[i]) - nume_lign.append([0]) - except ValueError: -# Presence de - dans la ligne - for indice in range(len(texte_tab[i])): - if texte_tab[i][indice]!='-': - tab_trav.append(indice+1) - list_val.append(float(texte_tab[i][indice])) - - nume_lign.append(tab_trav) - texte_tab[i]=list_val - elif col_type=='I' : - try : - texte_tab[i]=map(int,texte_tab[i]) - nume_lign.append([0]) -# Presence de - dans la ligne - except ValueError: - for indice in range(len(texte_tab[i])): - if texte_tab[i][indice]!='-': - tab_trav.append(indice+1) - list_val.append(float(texte_tab[i][indice])) - nume_lign.append(tab_trav) - texte_tab[i]=list_val - - else : - try : nume_lign.append([0]) - except ValueError: pass - - tab_lue[list_para[i]]=(list_type[i],texte_tab[i],nume_lign[i]) - - return 0,None,titre_tab,list_para,tab_lue - +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 lire_table_ops(self,UNITE,FORMAT,NUME_TABLE,SEPARATEUR, - PARA,TITRE,**args): - """Méthode corps de la macro LIRE_TABLE - """ - import os - from Accas import _F - 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') +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 + + 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: + message = """NUME_TABLE=%d incorrect : il n'y a que %d blocs de tables""" \ + """ dans le fichier""" % (nume, nbbloc) + return 1, message, None + 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()): + message = """Nombre de champs incorrect ligne %d. +Il y a %d paramètres""" % (i + 1, nb_para) + if hasattr(mat, 'groups'): + message += """, on a lu %d champs.""" % len(mat.groups()) + return 1, message, None + 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 0, '', tab - ### 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) - - file=open(nomfich,'r') - texte=file.readlines() - file.close() - - ### mise en forme de la liste de valeurs suivant le format choisi : - if FORMAT=='ASTER': - ier,message,titr_tab,list_para,tab_lue=lecture_table(texte,NUME_TABLE,SEPARATEUR) - if ier!=0 : - UTMESS('F', nompro, message) - else : pass - - ### création de la table ASTER : - self.DeclareOut('ut_tab',self.sd) - mcfact=[] - num_col=0 - for tab_para in list_para: - mcsimp={} - mcsimp['PARA']=tab_para - - if tab_lue[tab_para][2] != [0] : - mcsimp['NUME_LIGN']=tab_lue[tab_para][2] - - if tab_lue[tab_para][0] not in ('I','R') : - mcsimp['TYPE_K'] =tab_lue[tab_para][0] - mcsimp['LISTE_K']=tab_lue[tab_para][1] - elif tab_lue[tab_para][0]=='I' : - mcsimp['LISTE_I']=tab_lue[tab_para][1] - elif tab_lue[tab_para][0]=='R' : - mcsimp['LISTE_R']=tab_lue[tab_para][1] - - mcfact.append( _F(**mcsimp) ) - num_col = num_col + 1 - motscles={} - motscles['LISTE']=mcfact - - ut_tab=CREA_TABLE(TITRE=titr_tab,**motscles) - - # remet UNITE dans son état initial - UL.EtatInit() - return ier +# ------------------------------------------------------------------------------ +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': + ier, message, tab_lue = lecture_table(texte, NUME_TABLE, SEPARATEUR) + if ier != 0 : + UTMESS('F', nompro, message) + 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/cataSTA8/Macro/macr_adap_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_adap_mail_ops.py index 8040fea8..32a58b2e 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_adap_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_adap_mail_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_adap_mail_ops Macro DATE 02/06/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF macr_adap_mail_ops Macro DATE 30/10/2006 AUTEUR DURAND C.DURAND # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19,6 +19,11 @@ # ====================================================================== # RESPONSABLE GNICOLAS G.NICOLAS # +""" +Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL +""" +__revision__ = "V1.1" +# def macr_adap_mail_ops ( self, INFO, VERSION_HOMARD, MAILLAGE_FRONTIERE, **args): @@ -51,7 +56,7 @@ def macr_adap_mail_ops ( self, # # 3. Les caractéristiques d'un maillage sont conservées dans un dictionnaire. Il y a autant de # dictionnaires que de maillages manipulés. L'ensemble de ces dictionnaires est conservé -# dans la liste Liste_Maillages. +# 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 associé @@ -60,7 +65,7 @@ def macr_adap_mail_ops ( self, # # 4. Les caractéristiques d'un champ sont conservées dans un dictionnaire. Il y a autant de # dictionnaires que de champs manipulés. L'ensemble de ces dictionnaires est conservé -# dans la liste Liste_Champs. +# 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 résutat associé @@ -73,6 +78,7 @@ def macr_adap_mail_ops ( self, # dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ # dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage # dico["NOM_MED"] = o ; string ; Nom MED du champ +# dico["SENSIBILITE"] = f ; string ; Nom du paramètre sensible associé # from Accas import _F from Macro import creation_donnees_homard @@ -80,7 +86,7 @@ def macr_adap_mail_ops ( self, import aster import string import os -#gn import shutil + import shutil # global Liste_Passages # @@ -120,9 +126,9 @@ def macr_adap_mail_ops ( self, codret_partiel = [0] Rep_Calc_ASTER = os.getcwd() # - Liste_Maillages = [] - Liste_Champs = [] - Liste_Zones = [] + liste_maillages = [] + liste_champs = [] + liste_zones = [] dico_indi = {} # LISTE_ADAPTATION_LIBRE = ("RAFF_DERA" , "RAFFINEMENT" , "DERAFFINEMENT") @@ -154,11 +160,12 @@ def macr_adap_mail_ops ( self, else : dico["Action"] = "Rien" #gn print "dico = ",dico - Liste_Maillages.append(dico) + liste_maillages.append(dico) # # 2.1.2. ==> L'éventuel indicateur d'erreur # -#gn print "\n.. Debut de 2.1.2" +#gn print "\n.. Debut de 2.1.2" +#gn print "args = ", args if args["ADAPTATION"] in LISTE_ADAPTATION_LIBRE : dico = {} dico["Type_Champ"] = "INDICATEUR" @@ -175,18 +182,24 @@ def macr_adap_mail_ops ( self, 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 = " " - nopase = " " +#gn print "dico = ", dico # -### print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase + 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 ) -### print "dico[\"NOM_MED\"] = ", dico["NOM_MED"] +#gn print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"] dico["COMPOSANTE"] = args["NOM_CMP_INDICA"] - Liste_Champs.append(dico) + liste_champs.append(dico) dico_indi = dico ### print dico # @@ -207,11 +220,11 @@ def macr_adap_mail_ops ( self, # dico = {} dico["Type_Champ"] = "CHAMP_MAJ" - Liste_aux = [ "CHAM_MAJ", "TYPE_CHAM" ] + liste_aux = [ "CHAM_MAJ", "TYPE_CHAM" ] if ( maj_cham["RESULTAT"] != None ) : lresu = 1 - Liste_aux.append("RESULTAT") - Liste_aux.append("NOM_CHAM") + 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 ) : @@ -221,19 +234,27 @@ def macr_adap_mail_ops ( self, 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") + liste_aux.append("CHAM_GD") noresu = maj_cham["CHAM_GD"].nom nomsym = " " - for cle in Liste_aux : + for cle in liste_aux : dico[cle] = maj_cham[cle] - nopase = " " -### print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase +#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) + liste_champs.append(dico) # # 2.1.4. ==> Les zones de raffinement # @@ -250,13 +271,13 @@ def macr_adap_mail_ops ( self, ### 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'] : + 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) + liste_zones.append(dico) # -### print Liste_Zones +### print liste_zones # # 2.2. ==> Données de pilotage de l'information # @@ -268,7 +289,7 @@ def macr_adap_mail_ops ( self, dico["Type_Maillage"] = "MAILLAGE_N" dico["Nom_ASTER"] = args["MAILLAGE"] dico["Action"] = "A_ecrire" - Liste_Maillages.append(dico) + liste_maillages.append(dico) # # 2.3. ==> Suivi de frontière # @@ -280,7 +301,7 @@ def macr_adap_mail_ops ( self, dico["Type_Maillage"] = "MAILLAGE_FRONTIERE" dico["Nom_ASTER"] = MAILLAGE_FRONTIERE dico["Action"] = "A_ecrire" - Liste_Maillages.append(dico) + liste_maillages.append(dico) # # 2.4. ==> Le numéro de version de HOMARD # Remarque : dans la donnée de la version de HOMARD, il faut remplacer @@ -316,8 +337,8 @@ def macr_adap_mail_ops ( self, # Nom_Concept_Maillage_NP1_ANNEXE = None l_aux = [] - for dico in Liste_Maillages : -#gn print "\ndico avant = ",dico + 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) @@ -327,8 +348,8 @@ def macr_adap_mail_ops ( self, 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 +#gn print "\ndico apres = ",dico + liste_maillages = l_aux # # 3.2. ==> Recherche du numéro d'itération et du répertoire de travail # @@ -434,21 +455,21 @@ def macr_adap_mail_ops ( self, ## # 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 + 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 + 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 définition du fichier de ASTER vers HOMARD # DEFI_FICHIER ( ACTION= "ASSOCIER", - UNITE = Unite_Fichier_ASTER_vers_HOMARD, + UNITE = unite_fichier_aster_vers_homard, TYPE = "LIBRE", INFO = INFO ) # @@ -460,7 +481,7 @@ def macr_adap_mail_ops ( self, # les conventions MED imposent la présence du maillage dans le fichier. # Donc on va toujours écrire. # - for dico in Liste_Maillages : + for dico in liste_maillages : if ( dico["Action"] == "A_ecrire" ) : motscsi = {} motscsi["MAILLAGE"] = dico["Nom_ASTER"] @@ -469,7 +490,7 @@ def macr_adap_mail_ops ( self, **motscsi ) # IMPR_RESU ( INFO = INFO, - FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD, + FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard, **motscfa ) # # 4.4. Le(s) champ(s) @@ -491,33 +512,34 @@ def macr_adap_mail_ops ( self, # dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ # dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage # dico["NOM_MED"] = o ; string ; Nom MED du champ +# dico["SENSIBILITE"] = f ; string ; Nom du paramètre sensible associé # # 4.4.1. Recherche d'un doublon éventuel sur le champ d'indicateur d'erreur # -### print "dico_indi = ",dico_indi +#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" ] + liste_aux = [ "RESULTAT", "NOM_CHAM" ] else : - Liste_aux = [ "CHAM_GD" ] + liste_aux = [ "CHAM_GD" ] else : indic_est_deja_imprime = 1 - Liste_aux = [ ] -### print ".. Au debut de la boucle, Liste_aux = ",Liste_aux -### print ".. Au debut de la boucle, indic_est_deja_imprime = ",indic_est_deja_imprime + 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 : + liste_champs_imprime = [] + for dico in liste_champs : ### print "\n.... dico = ",dico # Pour un champ à mettre à jour, on a toujours impression if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : - Liste_Champs_imprime.append(dico) + liste_champs_imprime.append(dico) # Si le champ d'indicateur n'a toujours pas été repéré comme champ à mettre à jour : if not indic_est_deja_imprime : # Est-ce le meme champ ? on_a_le_champ = 1 - for cle in Liste_aux : + for cle in liste_aux : if ( dico.has_key(cle) ) : ### print "...... dico_indi[cle] = ",dico_indi[cle] ### print "...... dico[cle] = ",dico[cle] @@ -527,6 +549,18 @@ def macr_adap_mail_ops ( self, 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 désigné, c'est qu'il n'y a qu'un # seul instant ... donc c'est le meme ! En revanche, on ne sait pas comparer une donnée # en numéro d'ordre et une donnée en instant. On croise les doigts.) @@ -544,12 +578,12 @@ def macr_adap_mail_ops ( self, # Si le champ d'indicateur n'a pas été repéré comme champ à mettre à jour, il faut # l'inclure dans les champs à imprimer if not indic_est_deja_imprime : - Liste_Champs_imprime.append(dico_indi) + liste_champs_imprime.append(dico_indi) # # 4.4.2. Impressions après le filtrage précédent #gn print "\n.... Debut de 4.2.4.2." # - for dico in Liste_Champs_imprime : + 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) : @@ -557,14 +591,16 @@ def macr_adap_mail_ops ( self, 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 ) -### print ".. motscfa = ",motscfa +#gn print ".. motscfa = ",motscfa # IMPR_RESU ( INFO = INFO, - FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD, + FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard, **motscfa ) # #==================================================================== @@ -584,25 +620,26 @@ def macr_adap_mail_ops ( self, dico_configuration["version_perso"] = version_perso # dico_configuration["niter"] = niter - dico_configuration["Fichier_ASTER_vers_HOMARD"] = Fichier_ASTER_vers_HOMARD + dico_configuration["Fichier_ASTER_vers_HOMARD"] = fichier_aster_vers_homard if ( mode_homard == "ADAP" ) : - dico_configuration["Fichier_HOMARD_vers_ASTER"] = Fichier_HOMARD_vers_ASTER + dico_configuration["Fichier_HOMARD_vers_ASTER"] = fichier_homard_vers_aster # # 5.2. ==> Les noms med des maillages # - for dico in Liste_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'éventuel indicateur d'erreur # - for dico in Liste_Champs : + for dico in liste_champs : dico_aux = {} if ( dico["Type_Champ"] == "INDICATEUR" ) : - Liste_aux = [ "NOM_MED", "COMPOSANTE" ] + liste_aux = [ "NOM_MED", "COMPOSANTE" ] if dico.has_key("NUME_ORDRE") : - Liste_aux.append("NUME_ORDRE") - for cle in Liste_aux : + liste_aux.append("NUME_ORDRE") + for cle in liste_aux : if ( dico[cle] != None ) : dico_aux[cle] = dico[cle] dico_configuration["Indicateur"] = dico_aux @@ -612,7 +649,7 @@ def macr_adap_mail_ops ( self, # 5.4. ==> Les zones de raffinement # prem = 1 - for dico in Liste_Zones : + for dico in liste_zones : if prem : l_aux = [dico] prem = 0 @@ -626,16 +663,16 @@ def macr_adap_mail_ops ( self, # 5.5. ==> La mise à jour de champs # prem = 1 - for dico in Liste_Champs : + for dico in liste_champs : dico_aux = {} if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : - Liste_aux = [ "NOM_MED", "COMPOSANTE" ] + liste_aux = [ "NOM_MED", "COMPOSANTE" ] if dico.has_key("NUME_ORDRE") : - Liste_aux.append("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 : + liste_aux.append(cle) + for cle in liste_aux : if dico.has_key(cle) : if ( dico[cle] != None ) : dico_aux[cle] = dico[cle] @@ -667,10 +704,10 @@ def macr_adap_mail_ops ( self, #gn print "Répertoire ",Rep_Calc_HOMARD_global #gn os.system("ls -la "+Rep_Calc_HOMARD_global) if ( INFO > 1 ) : - L_aux = ["HOMARD.Donnees" , "HOMARD.Configuration"] + l_aux = ["HOMARD.Donnees" , "HOMARD.Configuration"] else : - L_aux = [ ] - for nomfic in L_aux : + l_aux = [ ] + for nomfic in l_aux : fic = os.path.join(Rep_Calc_HOMARD_global, nomfic) if os.path.isfile (fic) : print "\n\n==============================================================" @@ -691,21 +728,27 @@ def macr_adap_mail_ops ( self, #==================================================================== # # -#gn print "\.. Debut de 7." -### Fichier_ASTER_vers_HOMARD_2 = os.path.join("/home/gnicolas" , "fort." + str(Unite_Fichier_ASTER_vers_HOMARD)) -### shutil.copyfile(Fichier_ASTER_vers_HOMARD,Fichier_ASTER_vers_HOMARD_2) +#gn print "\.. Debut de 6." +#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) # - EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_HOMARD_global), # nom du repertoire - _F(NOM_PARA=VERSION_HOMARD), # version de homard - _F(NOM_PARA=str(INFO)), # niveau d information - _F(NOM_PARA=Nom_Fichier_Donnees), # fichier de données HOMARD + EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_HOMARD_global, # nom du repertoire + VERSION_HOMARD, # version de homard + str(INFO), # niveau d information + Nom_Fichier_Donnees, # fichier de données HOMARD + str(version_perso), # version personnelle de homard ? ), LOGICIEL = homard ) +# os.system("sleep 3600") # -### if ( mode_homard == "ADAP" ) : -### Fichier_HOMARD_vers_ASTER_2 = os.path.join("/home/gnicolas" , "fort." + str(Unite_Fichier_HOMARD_vers_ASTER)) -### shutil.copyfile(Fichier_HOMARD_vers_ASTER,Fichier_HOMARD_vers_ASTER_2) + #gn if ( mode_homard == "ADAP" ) : +#gn fichier_homard_vers_aster_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)) +#gn shutil.copyfile(fichier_homard_vers_aster, fichier_homard_vers_aster_2) +#gn fichier_homard_vers_aster_2_1 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".1") +#gn os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_1+""+fichier_homard_vers_aster_2_2+" Ecriture de la commande de lecture des resultats med @@ -724,20 +767,24 @@ def macr_adap_mail_ops ( self, # 7.1. ==> Le maillage # #gn print "args = ",args - for dico in Liste_Maillages : + for dico in liste_maillages : #gn print dico if ( dico["Action"] == "A_lire" ) : self.DeclareOut("maillage_a_lire", dico["Nom_ASTER"]) - maillage_a_lire = LIRE_MAILLAGE ( UNITE = Unite_Fichier_HOMARD_vers_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 = INFO, INFO = INFO ) +#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 os.system("sleep 100") # - for dico in Liste_Champs : + for dico in liste_champs : if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : #gn print dico self.DeclareOut("champ_maj", dico["CHAM_MAJ"]) @@ -748,8 +795,12 @@ def macr_adap_mail_ops ( self, motscsi[cle] = dico[cle] if dico.has_key("NUME_ORDRE") : motscsi["NUME_PT"] = dico["NUME_ORDRE"] - champ_maj = LIRE_CHAMP ( UNITE = Unite_Fichier_HOMARD_vers_ASTER, FORMAT = "MED", - MAILLAGE = maillage_np1, +#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 = INFO, **motscsi ) # @@ -757,14 +808,14 @@ def macr_adap_mail_ops ( self, # 8. Menage des fichiers MED et HOMARD devenus inutiles #==================================================================== # - Liste_aux = [ Fichier_ASTER_vers_HOMARD ] + liste_aux = [ fichier_aster_vers_homard ] if ( mode_homard == "ADAP" ) : - Liste_aux.append(Fichier_HOMARD_vers_ASTER) + liste_aux.append(fichier_homard_vers_aster) fic = os.path.join(Rep_Calc_HOMARD_global, fic_homard_niter) - Liste_aux.append(fic) -#gn print "Liste_aux = ",Liste_aux + liste_aux.append(fic) +#gn print "liste_aux = ",liste_aux # - for fic in Liste_aux : + for fic in liste_aux : if ( INFO > 1 ) : print "Destruction du fichier ", fic if os.path.isfile(fic) : diff --git a/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py b/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py index fcb37351..ac8e6edf 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_ascouf_calc_ops Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF macr_ascouf_calc_ops Macro DATE 31/10/2006 AUTEUR REZETTE C.REZETTE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -649,10 +649,8 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA motscles['LISSAGE']=_F(LISSAGE_THETA='LAGRANGE', LISSAGE_G='LAGRANGE', DEGRE=4,) - _nogloc=CALC_G (MODELE =modele, - RESULTAT =nomres, + _nogloc=CALC_G (RESULTAT =nomres, TOUT_ORDRE ='OUI', - CHAM_MATER =affmat, THETA=_F( FOND_FISS =fonfis, R_INF = thet['R_INF'], R_SUP = thet['R_SUP'],),**motscles); diff --git a/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py index 3495d88d..7a4bedb3 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_ascouf_mail_ops Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF macr_ascouf_mail_ops Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -412,7 +412,7 @@ def ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP,GEOM,SYME): # texte_final=string.join(echo_mess) aster.affiche('MESSAGE',texte_final) - return ier + return ier,AZIMC # ------------------------------------------------------------------------------ def ASCTCI(MCL_SOUS_EPAIS,RM): @@ -1516,13 +1516,15 @@ def write_file_dgib_ASCFDO(nomFichierDATG,RM,RC,ALPHA,NBTRAN,EP1,EP2,EPI,TETA1, # 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,loc_datg) : + SYME,NBEP,NLX,NLY,NIVMAG,SUREP,AZIMC,loc_datg) : - ssep= MCL_SOUS_EPAIS[0] + 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 @@ -1554,7 +1556,8 @@ def write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2, 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+' ltran = '+repr(LTRAN) +POIVIR + texte=texte+' surep = '+str(SUREP) +POIVIR if GEOM == 'COUDE': texte=texte+" zcoude = 'oui' "+POIVIR else: @@ -1574,6 +1577,7 @@ def write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2, 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 @@ -1741,7 +1745,7 @@ def write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg) texte=texte+'nbelz = table '+POIVIR texte=texte+'axisym = table '+POIVIR texte=texte+'sousep = table '+POIVIR - texte=texte+'* \n' + 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) @@ -1781,7 +1785,7 @@ def write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg) # NZONEY = NOMBRE DE ZONES LONGITUDINALES # # ------------------------------------------------------------------------------ -def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP, +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): @@ -1879,6 +1883,10 @@ def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP, 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') @@ -1886,7 +1894,6 @@ def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP, fpgib.close() - ################################################################################ ################################################################################ ################################################################################ @@ -1902,7 +1909,7 @@ def write_file_pgib_ASCSP2(MCL_SOUS_EPAIS,NLX,NLY): 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'+POIVIR + 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 @@ -2037,7 +2044,6 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE') DEFI_GROUP =self.get_cmd('DEFI_GROUP') MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE') - AFFE_MODELE =self.get_cmd('AFFE_MODELE') CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE') DEFI_FICHIER =self.get_cmd('DEFI_FICHIER') IMPR_RESU =self.get_cmd('IMPR_RESU') @@ -2455,7 +2461,7 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, AXEAP,AXECP,SFP = ASCFIS(ALPHA, RM, RC, EP1, SUREP, GEOM, FPROF, DGAXEC, AZIM, POSIT, SF, DSF, BETA, ORIEN) elif MCL_SOUS_EPAIS!=None : - ier= ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP1,GEOM,SYME) + 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) @@ -2475,6 +2481,7 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, UNITP = EXEC_MAILLAGE['UNITE_MGIB'] if logiel=='GIBI98' : logiel = loc_gibi+'gibi98' elif logiel=='GIBI2000': logiel = loc_gibi+'gibi2000' + else : UTMESS('F', "MACR_ASCOUF_MAIL", "seuls gibi98 et gibi2000 sont appelables") # @@ -2496,12 +2503,12 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, # 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,loc_datg) + 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, + 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) @@ -2512,15 +2519,16 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, # GIBI + DEFI_FICHIER(ACTION='LIBERER',UNITE=19) + DEFI_FICHIER(ACTION='LIBERER',UNITE=20) EXEC_LOGICIEL( LOGICIEL = logiel , - ARGUMENT = ( _F(NOM_PARA=nomFichierDATG), - _F(NOM_PARA=nomFichierGIBI), ), ) + ARGUMENT = (nomFichierDATG, + nomFichierGIBI), ) # PRE_GIBI PRE_GIBI() - if SYME == 'QUART' : self.DeclareOut('nomres',self.sd) # LIRE_MAILLAGE - nomres=LIRE_MAILLAGE(INFO=INFO) + __nomres=LIRE_MAILLAGE(INFO=INFO) # DEFI_GROUP 1 @@ -2681,8 +2689,8 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, CRITERE = CRITER,),) - nomres=DEFI_GROUP(reuse =nomres, - MAILLAGE=nomres, + __nomres=DEFI_GROUP(reuse =__nomres, + MAILLAGE=__nomres, **motscles ) # # DEFI_GROUP 2 @@ -2711,17 +2719,10 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, motscles['CREA_GROUP_NO'].append(_F(NOM = 'G_AXE_2', INTERSEC = tuple(l_peau+l_intersec),),) - nomres=DEFI_GROUP(reuse =nomres, - MAILLAGE=nomres, + __nomres=DEFI_GROUP(reuse =__nomres, + MAILLAGE=__nomres, **motscles ) -# AFFE_MODELE - __MODELE=AFFE_MODELE( MAILLAGE=nomres, - AFFE=_F( GROUP_MA = 'COUDE' , - PHENOMENE = 'MECANIQUE' , - MODELISATION = '3D' , ) - ) - # MODI_MAILLAGE 1 motscles={} if GEOM == 'COUDE': @@ -2741,8 +2742,8 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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, + __nomres=MODI_MAILLAGE( reuse =__nomres, + MAILLAGE=__nomres, **motscles ) # MODI_MAILLAGE 2 @@ -2751,25 +2752,21 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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, - MODELE =__MODELE, + __nomres=MODI_MAILLAGE(reuse =__nomres, + MAILLAGE=__nomres, **motscles) # CREA_MAILLAGE - if SYME != 'QUART': - 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, + 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) - else: - nomre2=nomres # IMPRESSSION diff --git a/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py b/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py index eda90f99..ac1b2f66 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_aspic_calc_ops Macro DATE 09/05/2006 AUTEUR REZETTE C.REZETTE +#@ MODIF macr_aspic_calc_ops Macro DATE 31/10/2006 AUTEUR REZETTE C.REZETTE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -670,9 +670,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C 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 ( MODELE = modele, - CHAM_MATER = affmat, - THETA = _F(THETA=__theta), + __gtheta = CALC_G ( THETA = _F(THETA=__theta), OPTION = 'CALC_G_GLOB', RESULTAT = nomres, TOUT_ORDRE = 'OUI', @@ -688,9 +686,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C mcfact.append(_F( NUME_ORDRE = born['NUME_ORDRE'] , VALE_MIN = born['VALE_MIN' ] , VALE_MAX = born['VALE_MAX' ] ) ) - __gbil = CALC_G( MODELE = modele, - CHAM_MATER = affmat, - THETA = _F(THETA=__theta), + __gbil = CALC_G( THETA = _F(THETA=__theta), RESULTAT = nomres, TOUT_ORDRE = 'OUI', COMP_ELAS = _F(TOUT = 'OUI', @@ -709,9 +705,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C if FERME: motscles['LISSAGE']=_F(LISSAGE_THETA= 'LAGRANGE', LISSAGE_G= 'LAGRANGE',) - __glocal = CALC_G( MODELE = modele, - CHAM_MATER = affmat, - THETA=_F( FOND_FISS = fond3d[j], + __glocal = CALC_G( THETA=_F( FOND_FISS = fond3d[j], R_INF = tht3d['R_INF'], R_SUP = tht3d['R_SUP'],), RESULTAT = nomres, @@ -733,9 +727,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C VALE_MIN = born['VALE_MIN' ] , VALE_MAX = born['VALE_MAX' ] ) ) motscles['BORNES']=mcfact - __glbil = CALC_G( MODELE = modele, - CHAM_MATER = affmat, - THETA=_F( FOND_FISS = fond3d[j], + __glbil = CALC_G( THETA=_F( FOND_FISS = fond3d[j], R_INF = tht3d['R_INF'], R_SUP = tht3d['R_SUP'],), RESULTAT = nomres, diff --git a/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py index 783db3ab..d1b14cb6 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_aspic_mail_ops Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF macr_aspic_mail_ops Macro DATE 25/09/2006 AUTEUR GALENNE E.GALENNE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -216,15 +216,27 @@ def write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, YN0 = 0.0 ZN0 = ZA0 + A*CALPHA XN = XN0 * CTHETA - YN = XN0 * STHETA + 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') : @@ -418,9 +430,9 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE') DEFI_GROUP =self.get_cmd('DEFI_GROUP') MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE') - AFFE_MODELE =self.get_cmd('AFFE_MODELE') 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) @@ -665,10 +677,12 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, 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 = ( _F(NOM_PARA=nomFichierDATG), - _F(NOM_PARA=nomFichierGIBI), ), ) + ARGUMENT = (nomFichierDATG, + nomFichierGIBI), ) # PRE_GIBI() # @@ -743,12 +757,7 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, X_MAX = XMAX , ) ) # - __MODELE=AFFE_MODELE( MAILLAGE=__MAPROV, - AFFE=_F( GROUP_MA = ('EQUERRE','PEAUINT','EXCORP1','EXCORP2','EXTUBU'), - PHENOMENE = 'MECANIQUE' , - MODELISATION = '3D' , ) - ) -# + motscles={} if TFISS=='DEB_INT' : motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU','LEVRTUBU','LEVRCORP'),) @@ -756,7 +765,6 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU',),) __MAPROV=MODI_MAILLAGE(reuse =__MAPROV, MAILLAGE=__MAPROV, - MODELE =__MODELE, **motscles ) # diff --git a/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py b/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py index da2fa29f..95ac8187 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_cabri_calc_ops Macro DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA +#@ MODIF macr_cabri_calc_ops Macro DATE 10/07/2006 AUTEUR LEBOUVIE F.LEBOUVIER # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -107,7 +107,7 @@ def macr_cabri_calc_ops(self,MAILLAGE,MODELE_MECA,MODELE_THER,CHAR_THER, MAILLAGE=mail, ORIE_PEAU_3D=(_F(GROUP_MA=('M_INT','M_TUB',),), _F(GROUP_MA=('M_L_AA','M_JOI','M_L_SA',),),), - MODELE=modmeca,); + ); diff --git a/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py index 92154545..af724996 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_cabri_mail_ops Macro DATE 07/02/2005 AUTEUR MABBAS M.ABBAS +#@ MODIF macr_cabri_mail_ops Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -129,9 +129,7 @@ def macr_cabri_mail_ops(self,EXEC_MAILLAGE,RAFF_MAILLAGE,VERI_MAIL,GEOM_BRID, # Lancement de GIBI EXEC_LOGICIEL( LOGICIEL=gibi2000, - ARGUMENT=(_F(NOM_PARA=fichier_datg), - _F(NOM_PARA=fichier_mgib), - ) + ARGUMENT=(fichier_datg, fichier_mgib), ) # Lecture du maillage GIBI dans ASTER PRE_GIBI( diff --git a/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py b/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py index 62a10eba..41df0154 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_fiabilite_ops Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF macr_fiabilite_ops Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -249,9 +249,9 @@ def macr_fiabilite_ops(self, INFO, VERSION=string.replace(VERSION,"_",".") VERSION=string.replace(VERSION,"N","n") # - EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_LOGICIEL_global), # nom du repertoire - _F(NOM_PARA=LOGICIEL), # nom du logiciel de fiabilité - _F(NOM_PARA=VERSION), # version du logiciel de fiabilité + EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_LOGICIEL_global, # nom du repertoire + LOGICIEL, # nom du logiciel de fiabilité + VERSION, # version du logiciel de fiabilité ), LOGICIEL = fiabilite ) diff --git a/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py index a2912b6e..639b6685 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_lign_coupe_ops Macro DATE 09/05/2006 AUTEUR GALENNE E.GALENNE +#@ MODIF macr_lign_coupe_ops Macro DATE 27/06/2006 AUTEUR THOMASSO D.THOMASSON # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -218,9 +218,11 @@ def macr_lign_coupe_ops(self,RESULTAT,UNITE_MAILLAGE,LIGN_COUPE,NOM_CHAM, if MAILLE != None : motscles['VIS_A_VIS'].append(_F(MAILLE_1 = MAILLE,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] __recou=PROJ_CHAMP(METHODE='ELEM', RESULTAT=RESULTAT, - MODELE_1=self.jdc.current_context[n_modele], + MODELE_1=MODELE_1, MODELE_2=__mocou, TYPE_CHAM='NOEU', NOM_CHAM=NOM_CHAM, **motscles); diff --git a/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py b/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py index 40e793af..58ee1fd9 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_recal_ops Macro DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE +#@ MODIF macr_recal_ops Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -17,150 +17,1008 @@ # 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, types, copy, math +from glob import glob +import Numeric +debug = False -def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC, - ITER_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI, - GRAPHIQUE, INFO, **args ): - """Macro commande réalisant le recalage de modèles Aster""", +INFO = 1 +NOMPRO = 'MACR_RECAL' + +fichier_export = None +mode_python = False +type_fonctionnelle = 'float' + +# -------------------------------------------------------------------------------------------------- +def UTMESS(code,sprg,texte): + fmt='\n <%s> <%s> %s\n\n' + if INFO>0 or code=='F': print fmt % (code,sprg,texte) + if code=='F': + sys.exit() + + +# -------------------------------------------------------------------------------------------------- +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 renvoit les parametres obtenus""" + + import Cata, aster, Macro + from Cata.cata import DEFI_LIST_REEL + from Accas import _F + from Utilitai.Utmess import UTMESS + 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 CALCUL_ASTER.METHODE != 'EXTERNE': + txt = "Nombre d'evaluation de la fonction : " + str(CALCUL_ASTER.evaluation_fonction) + UTMESS('I','MACR_RECAL',txt) + Mess.ecrire("\n"+txt) + + 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 ): + + METHODE='EXTERNE' + + # Mot-cle GRAPHIQUE + if GRAPHIQUE: + GRAPHIQUE0 = {'INTERACTIF': 'NON', '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 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 string, copy, types, Numeric + import aster import Macro from Cata import cata - from Cata.cata import DEFI_LIST_REEL - from Macro.recal import gestion,transforme_list_Num,calcul_F + from Cata.cata import DEFI_LIST_REEL, CREA_TABLE, TEST_TABLE + from Macro import reca_message from Macro import reca_algo from Macro import reca_interp - from Macro import reca_graphique - - try: - from Utilitai.Utmess import UTMESS - except ImportError: - def UTMESS(code,sprg,texte): - fmt='\n <%s> <%s> %s\n\n' - print fmt % (code,sprg,texte) + from Macro import reca_utilitaires + from Macro import reca_calcul_aster + from Macro.reca_controles import gestion + from Utilitai.Utmess import UTMESS - # Test du mot-clé GRAPHIQUE - 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 - UTMESS('A','MACR_RECAL',"Le logiciel Gnuplot ou le module python Gnuplot.py n'est pas disponible. On desactive l'affichage des courbes.") + # 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 type(v)==types.InstanceType: + if v.__class__.__name__ in ('OPER','MACRO'): + self.current_context[k]= v + self.current_context['_F']=cata.__dict__['_F'] + + 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 + + +# -------------------------------------------------------------------------------------------------- +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 ): + + + # 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: + sys.path.append(os.path.join(aster.repout, '..', 'ASTK', 'ASTK_SERV', 'lib')) + try: + from as_profil import ASTER_PROFIL + except: + UTMESS('F','MACR_RECAL',"Impossible d'importer le module as_profil ! Vérifier la variable d'environnement ASTER_ROOT ou mettez a jour ASTK.") + + 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','MACR_RECAL',"Le logiciel Gnuplot ou le module python Gnuplot.py n'est pas disponible. On desactive l'affichage des courbes par Gnuplot.") + + + #_____________________________________________ + # + # VERIFICATION PREALABLE SUR MEM_ASTER + #_____________________________________________ + + # Lecture du fichier .export + list_export = glob('*.export') + if len(list_export) == 0: + UTMESS('F','MACR_RECAL',"Probleme : il n'y a pas de fichier .export dans le repertoire de travail!") + elif len(list_export) >1: + UTMESS('F','MACR_RECAL',"Probleme : il y a plus d'un fichier .export dans le repertoire de travail!") + + prof = ASTER_PROFIL(list_export[0]) + + mem_aster = prof['mem_aster'][0] + memjeveux = prof.args.get('memjeveux') + + if mem_aster in ('', '100'): + if INFO>=1: UTMESS('A','MACR_RECAL',"Attention : il faut specifier une valeur pour 'mem_aster' (menu Option de ASTK) " \ + "pour limiter la memoire allouee au calcul maitre.") + mem_aster = '0' + if not memjeveux: + UTMESS('F','MACR_RECAL',"Probleme : aucune valeur pour le parametre 'memjeveux'. Verifier le .export") + + try: + if mem_aster == '0': + memjeveux_esclave = float(memjeveux) + else: + memjeveux_esclave = float(memjeveux) / float(mem_aster) * 100. - float(memjeveux) + except: + UTMESS('F','MACR_RECAL',"Probleme : verifier les valeurs des parametres 'mem_aster' et 'memjeveux'") + + if INFO>=1: UTMESS('I','MACR_RECAL',"Information : les calculs esclaves utiliseront : %.1f Mega Mots." % 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','MACR_RECAL',"Pour l'algorithme " + METHODE + " on ne peut tracer qu'a la derniere iteration") + # Les bornes ne sont pas gerees + UTMESS('I','MACR_RECAL',"Pour l'algorithme " + METHODE + " on ne tient pas compte des bornes sur les parametres.") + #_______________________________________________ # # GESTION DE L'OPTION FACULTATIVE POUR LES POIDS #_______________________________________________ if( POIDS == None): POIDS=Numeric.ones(len(RESU_EXP)) - + + #_____________________________________________ # # GESTION DES ERREURS DE SYNTAXE #_____________________________________________ - texte_erreur = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU) + texte_erreur = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU,METHODE) if (texte_erreur != ""): UTMESS('F', "MACR_RECAL", texte_erreur) - #_____________________________________________ - # - # DECLARATION DE TOUTES LES COMMANDES ASTER - #_____________________________________________ - for k,v in cata.__dict__.items() : - if type(v)==types.InstanceType: - if v.__class__.__name__ in ('OPER','MACRO'): - self.current_context[k]= v - self.current_context['_F']=cata.__dict__['_F'] #_____________________________________________ # # INITIALISATIONS #_____________________________________________ - iter = 0 - restant,temps_iter=0.,0. - restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter) - para,val,borne_inf,borne_sup = transforme_list_Num(LIST_PARA,RESU_EXP) + + 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) - L_init = calcul_F(self,UNITE_ESCL,para,val,RESU_CALC) - #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) - #instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim + + # 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) - 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(self,UNITE_ESCL,L_init,val,para,RESU_CALC,PARA_DIFF_FINI,UNITE_RESU) - 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([]),UNITE_RESU) - # On teste un manque de temps CPU - restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter) - if (err==1): - ier=ier+1 - return ier - - #_____________________________________________ + + 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() + txt = "Lancement de l'optimisation avec la methode : " + METHODE + if INFO>=1: UTMESS('I','MACR_RECAL',txt) + Mess.ecrire(txt) + + + + #------------------------------------------------------------------------------- + # Methode EXTERNE (en fait juste une evaluation de la fonction puis on sort) # - # BOUCLE PRINCIPALE DE L'ALGORITHME - #_____________________________________________ - epsilon = 10.*RESI_GLOB_RELA - while((residu > RESI_GLOB_RELA) & (iter RESI_GLOB_RELA) & (iter=1: UTMESS('I','MACR_RECAL',txt) + + if (GRAPHIQUE): + if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION': + GRAPHE_UL_OUT=GRAPHIQUE['UNITE'] + interactif=(GRAPHIQUE['INTERACTIF']=='OUI') + reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,interactif) + + # 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) + + + #------------------------------------------------------------------------------- - # On teste un manque de temps CPU - restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter) - if (err==1): - ier=ier+1 - return ier #_____________________________________________ # - # FIN DES ITERATIONS - # CONVERGENCE OU ECHEC + # FIN DES ITERATIONS POUR TOUS LES ALGOS #_____________________________________________ - Mess.affiche_etat_final_convergence(iter,ITER_MAXI,RESI_GLOB_RELA,residu,Act,UNITE_RESU) - reca_algo.calcul_etat_final(para,A,iter,ITER_MAXI,RESI_GLOB_RELA,residu,Mess,UNITE_RESU) + + 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 + fichier = args['prefix_graph'] + if trace: + if INFO>=1: UTMESS('I','MACR_RECAL',"Trace des graphiques") + GRAPHE_UL_OUT=GRAPHIQUE['UNITE'] + interactif=(GRAPHIQUE['INTERACTIF']=='OUI') + reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,interactif,fichier) + + if( METHODE == 'EXTERNE'): + if mode_python: return fonctionnelle, gradient + +# print residu, RESI_GLOB_RELA + + # 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 #_____________________________________________ - lival=[] - for i in range(len(val)): - lival.append(val[i]) - nomres=DEFI_LIST_REEL(VALE=lival) + + + nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess) return + + + + + + + + + + + + + +#------------------------------------------------------------------------------- +if __name__ == '__main__': + + mode_python = True + + from optparse import OptionParser, OptionGroup + + 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', 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','MACR_RECAL',"Impossible de determiner l'emplacement d'Aster ! Fixer le chemin avec la variable d'environnement ASTER_ROOT.") + + # 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','MACR_RECAL',"Impossible de determiner le fichier .export a utiliser. Specifier le sur la ligne de commande.") + 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','MACR_RECAL',"Probleme : le fichier .comm n'est pas defini dans le .export.") + if not os.path.isfile(nom_comm): + UTMESS('F','MACR_RECAL',"Probleme : le fichier .comm suivant n'est pas defini : " + nom_comm) + + + + # ------------------------------------------------------------------- + # Lecture des valeurs d'entree + if INFO==2: UTMESS('I',NOMPRO,"Lecture du fichier : " + 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',NOMPRO,"Probleme : impossible de lire le fichier d'entree :\n" + input_file) + if INFO>=2: UTMESS('I',NOMPRO,"Parametres d'entree : " + 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: + txt = "Probleme : Le fichier de commande :\n" + nom_comm + "\n ne semble pas comporter la commande MACR_RECAL" + UTMESS('F',NOMPRO,txt) + + + # ------------------------------------------------------------------- + # 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','MACR_RECAL',"Probleme : impossible d'importer le module Utilitai! Prevenir la maintenance.") + + + # ------------------------------------------------------------------- + # 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',NOMPRO,txt) + 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',NOMPRO,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',NOMPRO,"Lecture du fichier : " + 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',NOMPRO,"Probleme : il faut mettre les parametres sous la forme d'une ligne python " + str(_PARAM_) + " = [param1, param2, ...]") + if not ok3: UTMESS('F',NOMPRO,"Probleme : la commande MACR_RECAL n'a pas ete trouvee dans le .comm") + if not ok4: UTMESS('F',NOMPRO,"Probleme : dans la commande MACR_RECAL, il faut choisir METHODE='EXTERNE'") + + txt = txt.replace('_RESU_', _RESU_) + + # Ecriture du nouveau fichier comm temporaire + if INFO==2: UTMESS('I',NOMPRO,"Ecriture du fichier : " + 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',NOMPRO,"Ecriture du fichier : " + new_fichier_export) + prof.WriteExportTo(new_fichier_export) + except: + UTMESS('F',NOMPRO,"Probleme : Impossible d'ecrire le fichier export : " + new_fichier_export) + 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', nompro, "Variable d'environnement ASTER_ROOT absente, " \ + "on essaiera avec 'as_run' dans le $PATH.") + + + # 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','MACR_RECAL',"Probleme : impossible d'importer le module Utilitai! Prevenir la maintenance.") + + + # Lancement d'Aster avec le deuxieme export + cmd = '%s %s' % (as_run, new_fichier_export) + if INFO>=2: UTMESS('I','MACR_RECAL',"Lancement de la commande : " + cmd) + iret, txt_output = ExecCommand(cmd, follow_output=opts.follow_output,verbose=opts.follow_output) + if INFO>=2: UTMESS('I','MACR_RECAL',"Fin du lancement de la commande : " + cmd) + + try: os.remove(new_fichier_comm) + except: pass + try: os.remove(new_fichier_export) + except: pass + + diff --git a/Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py b/Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py new file mode 100644 index 00000000..874cebc4 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py @@ -0,0 +1,356 @@ +#@ MODIF macr_spectre_ops Macro DATE 07/11/2006 AUTEUR DURAND C.DURAND +# -*- 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 aster +import string +from Utilitai.Utmess import UTMESS +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 : motscles['RESU_GENE'] = resu['RESU_GENE'] + if resu['RESULTAT' ]!=None : + motscles['RESULTAT'] = resu['RESULTAT'] + if CALCUL=='ABSOLU' : + UTMESS('F', macro, 'Pas de calcul relatif avec dyna_trans ou evol_noli') + + __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/cataSTA8/Macro/macro_elas_mult_ops.py b/Aster/Cata/cataSTA8/Macro/macro_elas_mult_ops.py index bdd9e7df..b9dac9fe 100644 --- a/Aster/Cata/cataSTA8/Macro/macro_elas_mult_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macro_elas_mult_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_elas_mult_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +#@ MODIF macro_elas_mult_ops Macro DATE 07/11/2006 AUTEUR CIBHHLV L.VIVAN # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -242,8 +242,8 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, CALC_ELEM(reuse=nomres, RESULTAT=nomres, MODELE=MODELE, - NIVE_COUCHE=m['NIVE_COUCHE'], - NUME_COUCHE=m['NUME_COUCHE'], + REPE_COQUE=_F(NIVE_COUCHE=m['NIVE_COUCHE'], + NUME_COUCHE=m['NUME_COUCHE'],), OPTION=tuple(liste_el), **motscles) if nbno: diff --git a/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py b/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py index 60374b6c..ddf508f1 100644 --- a/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_matr_asse_ops Macro DATE 30/01/2006 AUTEUR DURAND C.DURAND +#@ MODIF macro_matr_asse_ops Macro DATE 12/06/2006 AUTEUR CIBHHLV L.VIVAN # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -21,7 +21,7 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, - SOLVEUR,NUME_DDL,CHARGE,INST,**args): + SOLVEUR,NUME_DDL,CHARGE,CHAR_CINE,INST,**args): """ Ecriture de la macro MACRO_MATR_ASSE """ @@ -104,6 +104,10 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, motscles={'OPTION':option} + if option == 'RIGI_MECA_HYST': + if (not lrigel): + UTMESS('F', "MACRO_MATR_ASSE", "POUR CALCULER RIGI_MECA_HYST, IL FAUT AVOIR CALCULE RIGI_MECA AUPARAVANT (DANS LE MEME APPEL)") + motscles['RIGI_MECA'] =rigel if option == 'AMOR_MECA': if (not lrigel or not lmasel): UTMESS('F', "MACRO_MATR_ASSE", "POUR CALCULER AMOR_MECA, IL FAUT AVOIR CALCULE RIGI_MECA ET MASS_MECA AUPARAVANT (DANS LE MEME APPEL)") @@ -145,5 +149,10 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, num=numeddl self.DeclareOut('mm',m['MATRICE']) - mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num) + 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/cataSTA8/Macro/macro_miss_3d_ops.py b/Aster/Cata/cataSTA8/Macro/macro_miss_3d_ops.py index 54af120b..97b6bd15 100644 --- a/Aster/Cata/cataSTA8/Macro/macro_miss_3d_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macro_miss_3d_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_miss_3d_ops Macro DATE 20/03/2006 AUTEUR ACBHHCD G.DEVESA +#@ MODIF macro_miss_3d_ops Macro DATE 31/10/2006 AUTEUR ACBHHCD G.DEVESA # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -44,9 +44,24 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, import aster loc_fic=aster.repout() - miss3d=loc_fic+'miss3d' - #miss3d='/home/acbhhcd/MISS3D/V6.4/miss3d.csh' + 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' + + 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': @@ -65,7 +80,7 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, prfor = 'fort.'+str(UNITE_RESU_FORC) l_para = ['FREQ_MIN','FREQ_MAX','FREQ_PAS','Z0','RFIC','SURF', - 'FICH_RESU_IMPE','FICH_RESU_FORC','DREF','ALGO', + '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'] @@ -78,47 +93,48 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, dpara = {} for cle in l_para: - if cle in ('SURF', 'ISSF'): + 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] = ' '.join([str(s) for s in PARAMETRE[cle]]) + dpara[cle] = repr(' '.join([str(s) for s in PARAMETRE[cle]])) else: dpara[cle] = str(PARAMETRE[cle]) EXEC_LOGICIEL( LOGICIEL=miss3d, - ARGUMENT=(_F(NOM_PARA=MODUL2), - _F(NOM_PARA=ETUDE), - _F(NOM_PARA=BASE), - _F(NOM_PARA=paste), - _F(NOM_PARA=popti), - _F(NOM_PARA=pdsol), - _F(NOM_PARA=primp), - _F(NOM_PARA=VERSION), - _F(NOM_PARA=dpara['FREQ_MIN']), - _F(NOM_PARA=dpara['FREQ_MAX']), - _F(NOM_PARA=dpara['FREQ_PAS']), - _F(NOM_PARA=dpara['Z0']), - _F(NOM_PARA=dpara['SURF']), - _F(NOM_PARA=dpara['RFIC']), - _F(NOM_PARA=dpara['FICH_RESU_IMPE']), - _F(NOM_PARA=dpara['FICH_RESU_FORC']), - _F(NOM_PARA=dpara['DREF']), - _F(NOM_PARA=dpara['ALGO']), - _F(NOM_PARA=dpara['OFFSET_MAX']), - _F(NOM_PARA=dpara['OFFSET_NB']), - _F(NOM_PARA=dpara['SPEC_MAX']), - _F(NOM_PARA=dpara['SPEC_NB']), - _F(NOM_PARA=dpara['ISSF']), - _F(NOM_PARA=dpara['FICH_POST_TRAI']), - _F(NOM_PARA=dpara['CONTR_NB']), - _F(NOM_PARA=dpara['CONTR_LISTE']), - _F(NOM_PARA=dpara['LFREQ_NB']), - _F(NOM_PARA=dpara['LFREQ_LISTE']), - _F(NOM_PARA=prfor), + 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, ), ) diff --git a/Aster/Cata/cataSTA8/Macro/post_dyna_alea_ops.py b/Aster/Cata/cataSTA8/Macro/post_dyna_alea_ops.py new file mode 100644 index 00000000..db6f62ab --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/post_dyna_alea_ops.py @@ -0,0 +1,254 @@ +#@ MODIF post_dyna_alea_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI 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 post_dyna_alea_ops(self,INTE_SPEC,NUME_VITE_FLUI,TOUT_ORDRE,NUME_ORDRE_I, + NOEUD_I,OPTION,MOMENT,TITRE,INFO,**args): + import aster + from types import ListType, TupleType + EnumTypes = (ListType, TupleType) + from Accas import _F + from Utilitai.Utmess import UTMESS + from Utilitai.t_fonction import t_fonction + from Utilitai.Table import Table + import Numeric + import math + from math import pi,sqrt + + 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') + + intespec=INTE_SPEC.EXTR_TABLE() + +# ------------------------------------------------------------------ +# 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' in intespec.para : + if TOUT_ORDRE!=None : + jnuor=intespec['NUME_VITE_FLUI'].values()['NUME_VITE_FLUI'] + jvite=dict([(i,0) for i in jnuor]).keys() + 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) : + txt = "il faut autant d indices en I et J" + UTMESS('F',commande, txt) + listpara=['NUME_ORDRE_I','NUME_ORDRE_J'] + listtype=['I','I'] + dicotabl={'NUME_ORDRE_I' : l_ind_i ,\ + 'NUME_ORDRE_J' : l_ind_j , } + 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) : + txt = "il faut autant d indices en I et J" + UTMESS('F',commande, txt) + if len(l_cmp_i)!=len(l_cmp_j) : + txt = "il faut autant de composantes en I et J" + UTMESS('F',commande, txt) + if len(l_ind_i)!=len(l_cmp_i) : + txt = "il faut autant de composantes que de noeuds" + UTMESS('F',commande, txt) + listpara=['NOEUD_I','NOEUD_J','NOM_CMP_I','NOM_CMP_J'] + listtype=['K8','K8','K8','K8',] + dicotabl={'NOEUD_I' : l_ind_i,\ + 'NOEUD_J' : l_ind_j,\ + 'NOM_CMP_I': l_cmp_i,\ + 'NOM_CMP_J': l_cmp_j } +# ------------------------------------------------------------------ +# Cas de tous les indices centraux + + elif OPTION!=None : + if 'NUME_ORDRE_I' in intespec.para : + inuor=intespec['NUME_ORDRE_I'].values()['NUME_ORDRE_I'] + imode=dict([(i,0) for i in inuor]).keys() + l_ind_i=imode + l_ind_j=imode + listpara=['NUME_ORDRE_I','NUME_ORDRE_J'] + listtype=['I','I'] + dicotabl={'NUME_ORDRE_I' : l_ind_i ,\ + 'NUME_ORDRE_J' : l_ind_j , } + else : + if 'NUME_VITE_FLUI' in intespec.para : + intespec=intespec.NUME_VITE_FLUI==jvite[0] + l_ind_i=intespec['NOEUD_I'].values()['NOEUD_I'] + l_ind_j=intespec['NOEUD_J'].values()['NOEUD_J'] + if len(l_ind_i)!=len(l_ind_j) : + txt = "il faut autant d indices en I et J" + UTMESS('F',commande, txt) + l_cmp_i=intespec['NOM_CMP_I'].values()['NOM_CMP_I'] + l_cmp_j=intespec['NOM_CMP_J'].values()['NOM_CMP_J'] + if (len(l_ind_i)!=len(l_cmp_i) or len(l_ind_j)!=len(l_cmp_j)) : + txt = "il faut autant de composantes que de noeuds" + UTMESS('F',commande, txt) + 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]) + listpara=['NOEUD_I','NOEUD_J','NOM_CMP_I','NOM_CMP_J'] + listtype=['K8','K8','K8','K8',] + dicotabl={'NOEUD_I' : l_ind_i*len(jvite) ,\ + 'NOEUD_J' : l_ind_j*len(jvite) ,\ + 'NOM_CMP_I': l_cmp_i*len(jvite) ,\ + 'NOM_CMP_J': l_cmp_j*len(jvite) } + + if jvite[0]!=None : + listpara.append('NUME_VITE_FLUI') + listtype.append('I') + dicotabl['NUME_VITE_FLUI']=[] +# ------------------------------------------------------------------ +# Liste des moments spectraux + + l_moments=[0,1,2,3,4] + if MOMENT!=None : + l_moments=l_moments+list(MOMENT) + l_moments=dict([(i,0) for i in l_moments]).keys() + +# ------------------------------------------------------------------ +# Boucle sur les tables + + l_ind=zip(l_ind_i,l_ind_j) + 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 : + mcfact=[] + if vite!=None : + dicotabl['NUME_VITE_FLUI'].append(vite) + mcfact.append(_F(NOM_PARA='NUME_VITE_FLUI',VALE_I=vite)) + if 'NOEUD_I' in listpara : + mcfact.append(_F(NOM_PARA='NOEUD_I',VALE_K=ind[0])) + mcfact.append(_F(NOM_PARA='NOEUD_I',VALE_K=ind[1])) + if INFO==2 : + aster.affiche('MESSAGE','INDICES :'+ind[0]+' - '+ind[1]+'\n') + else : + 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 : + trapz = Numeric.zeros(len(fvaly),Numeric.Float) + trapz[0] = 0. + valy = fvaly*(2*pi*fvalx)**i_mom + trapz[1:] = (valy[1:]+valy[:-1])/2*(fvalx[1:]-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) + if dicotabl.has_key(chmo) : dicotabl[chmo].append(val_mom[i_mom]) + else : + dicotabl[chmo]=[val_mom[i_mom],] + listpara.append(chmo) + listtype.append('R') + +#--- fonctions statistiques + + pstat = {'ECART' :0.,\ + 'NB_PASS_ZERO_P_S':0.,\ + 'NB_EXTREMA_P_S' :0.,\ + 'FACT_IRRE' :0.,\ + 'FREQ_APPAR' :0.,} + 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 + pstat['ECART'] = sqrt(val_mom[0]*2.) + else : + pstat['ECART'] = sqrt(val_mom[0]) + if abs(val_mom[2])>=1e-20 : + pstat['NB_EXTREMA_P_S'] = 1./pi*sqrt(val_mom[4]/val_mom[2]) + if abs(val_mom[0])>=1e-20 : + pstat['NB_PASS_ZERO_P_S'] = 1./pi*sqrt(val_mom[2]/val_mom[0]) + pstat['FREQ_APPAR'] = 0.5*pstat['NB_PASS_ZERO_P_S'] + if abs(val_mom[4])>=1e-20 : + pstat['FACT_IRRE'] = sqrt( val_mom[2]*val_mom[2]/val_mom[0]/val_mom[4]) + + for key in pstat.keys(): + if dicotabl.has_key(key) : dicotabl[key].append(pstat[key]) + else : + dicotabl[key]=[pstat[key],] + listpara.append(key) + listtype.append('R') + +#--- construction de la table produite + + mcfact=[] + for i in range(len(listpara)) : + if listtype[i]=='R': + mcfact.append(_F(PARA=listpara[i] ,LISTE_R=dicotabl[listpara[i]] )) + if listtype[i]=='K8': + mcfact.append(_F(PARA=listpara[i] ,LISTE_K=dicotabl[listpara[i]] )) + if listtype[i]=='I': + mcfact.append(_F(PARA=listpara[i] ,LISTE_I=dicotabl[listpara[i]] )) + tabout = CREA_TABLE(LISTE=mcfact,TITRE = 'POST_DYNA_ALEA concept : '+self.sd.nom) + + return ier diff --git a/Aster/Cata/cataSTA8/Macro/post_gp_ops.py b/Aster/Cata/cataSTA8/Macro/post_gp_ops.py new file mode 100644 index 00000000..c72135c1 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/post_gp_ops.py @@ -0,0 +1,371 @@ +#@ MODIF post_gp_ops Macro DATE 31/10/2006 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 types import ListType, TupleType +EnumTypes = (ListType, TupleType) +from sets import Set + +# ----------------------------------------------------------------------------- +def post_gp_ops(self, **args): + """ + Corps de la macro POST_GP + """ + macro = 'POST_GP' + ier=0 + from Accas import _F + from Utilitai.Utmess import UTMESS + from Utilitai.Table import Table, merge + from Utilitai.t_fonction import t_fonction + 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') + + # ----- 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 boule 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,] + + # 1. ----- calcul de G-theta + nbcour = len(self['THETA_2D']) + 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), + EXCIT=self['EXCIT'].List_F(), + RESULTAT=self['RESULTAT'], + TOUT_ORDRE='OUI', + SYME_CHAR=self['SYME_CHAR'], + COMP_ELAS=self['COMP_ELAS'].List_F(),) + + 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 = [grma.strip() for grma in self['GROUP_MA']] + nbcop = len(l_copo) + l_charg = [charg['CHARGE'] for charg in self['EXCIT']] + + __ener = POST_ELEM(MODELE=self['MODELE'], + RESULTAT=self['RESULTAT'], + CHARGE=l_charg, + TOUT_ORDRE='OUI', + ENER_ELAS=_F(GROUP_MA=l_copo), + TITRE='Energie élastique',) + + 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 + t_enel.fromfunction('DELTAL', fDL, 'ICOP', { 'pascop' : self['PAS_ENTAILLE'] }) + + # 2.2. ----- Calcul de Gp fonction de Ener.Totale et de deltaL + t_enel.fromfunction('GP', fGp_Etot, ('TOTALE', 'ICOP'), + { 'pascop' : self['PAS_ENTAILLE'], + 'syme' : self['SYME_CHAR'] != 'SANS', + 'R' : self['RAYON_AXIS'] }) + + # 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'] + l_numord = list(Set(ttmp.NUME_ORDRE.values())) + l_numord.sort() + for j in l_numord: + tj = ttmp.NUME_ORDRE == j + if self['CRIT_MAXI_GP'] == 'ABSOLU': + t = tj.GP.MAXI() + else: + t = MaxRelatif(tj, 'GP') + if j == 1: + tb_Gpmax = t + else: + tb_Gpmax = tb_Gpmax | t + tb_Gpmax.Renomme('GP', 'GPMAX') + tb_Gpmax.Renomme('ICOP', 'ICOPMAX') + tb_Gpmax.Renomme('DELTAL', 'DELTALMAX') + tb_Gpmax.titr = 'Gpmax à chaque instant' + if info >= 2: + print tb_Gpmax + + # 2.5. ----- extraction de la température en fond d'entaille + if self['RESU_THER']: + grno_fond = self['THETA_2D'][0]['GROUP_NO'] + __relev = POST_RELEVE_T(ACTION=_F(RESULTAT=self['RESU_THER'], + OPERATION='EXTRACTION', + INTITULE='Temperature', + NOM_CHAM='TEMP', + TOUT_ORDRE='OUI', + NOM_CMP='TEMP', + GROUP_NO=grno_fond,),) + t_relev = __relev.EXTR_TABLE()['NUME_ORDRE', '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' : i, 'TEMP' : TEMP} for i 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 }) + #tb_Gpmax = merge(tb_Gpmax, t_relev, 'NUME_ORDRE') + flag_mat = False + + # 3.2. ----- paramètres + dict_constantes = { + 'YOUNG' : CallRCVALE(TEMP, 'E', MATER), + 'NU' : CallRCVALE(TEMP, 'NU', MATER), + 'R' : self['RAYON_AXIS'], + } + + # 3.3. ----- calcul de Kj(G) + l_tabi = [] + for k, tab in enumerate(l_tab): + # fusion avec TEMP, E et nu. + tab = merge(tab, t_relev, 'NUME_ORDRE') + + # calcul de Kj(G) = K_i + new_para = 'K_%d' % (k + 1) + tab.fromfunction(new_para, fKj, ('G', 'YOUNG', 'NU'), + { 'R' : self['RAYON_AXIS'] }) + + # renomme G en G_i + tab.Renomme('G', 'G_%d' % (k + 1)) + l_tabi.append(tab) + + # 3.4 ----- Table des Gi, Ki sur les differentes couronnes + Kmoyen + tabK_G = l_tabi[0]['NUME_ORDRE'] + for tab in l_tabi: + tabK_G = merge(tabK_G, tab, 'NUME_ORDRE') + tabK_G.titr = 'G et K sur les differentes couronnes + moyennes' + tabK_G.fromfunction('GMOY', moyenne, ['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 + tabres = merge(tabK_G, tb_Gpmax, 'NUME_ORDRE') + tabres['OCCURRENCE'] = [iocc + 1] * len(l_numord) + 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', + } + # Gpmax fonction du temps + d_para.update({ 'NOM_RESU' : 'GPMAX' }) + fGp = t_fonction(tabres.INST.values(), tabres.GPMAX.values(), d_para) + + # 3.6.1. --- identification + if identification: + KJ_CRIT = l_crit[iocc] + # définition des fonctions pour faire les interpolations + d_para.update({ 'NOM_RESU' : 'DELTALMAX' }) + fdL = t_fonction(tabres.INST.values(), tabres.DELTALMAX.values(), d_para) + + d_para.update({ 'NOM_PARA' : 'KMOY', + 'NOM_RESU' : 'INST', }) + valkmoy = tabres.KMOY.values() + finv = t_fonction(valkmoy, tabres.INST.values(), d_para) + + if not (min(valkmoy) <= KJ_CRIT <= max(valkmoy)): + UTMESS('A', macro, 'Interpolation hors du domaine (prolongement ' \ + 'constant utilisé).') + # valeurs à mettre dans la table + ti = finv(KJ_CRIT) + 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) + + # 3.6.2. --- prédiction + else: + pass + + # 4. ----- Construction de la table résultat si demandée + # 4.1. --- identification + if identification: + tab_ident = Table(rows=lv_ident, + para=('KJ_CRIT', 'INST', 'GPMAX', 'KGPMAX', 'DELTALMAX'), + typ= ('R', 'R', 'R', 'R', 'R'), + 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) + + tab_pred = tabl_glob['NUME_ORDRE', 'INST', 'TEMP', 'DELTALMAX', 'GPMAX'] + 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, R): + """Calcul de Kj à partir de G (formule d'Irwin) + """ + return (G / R * YOUNG / (1.0 - NU**2))**0.5 + +# ----------------------------------------------------------------------------- +def fDL(ICOP, pascop): + """DeltaL = numéro copeau * pas d'entaille + """ + return ICOP * pascop + +# ----------------------------------------------------------------------------- +def fGp_Etot(TOTALE, ICOP, pascop, R, syme=False): + """Gp(Etotale, K), deltal pris dans le context global. + ICOP : numéro du copeau, + pascop : pas d'entaille. + syme : True s'il y a symétrie. + """ + fact_axis = 1. + if syme: + fact_axis = 2. + return fact_axis * TOTALE / (fDL(ICOP, pascop) * R) + +# ----------------------------------------------------------------------------- +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) + diff --git a/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py b/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py index 5f3f5533..a9797446 100644 --- a/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py +++ b/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py @@ -1,4 +1,4 @@ -#@ MODIF post_k1_k2_k3_ops Macro DATE 22/05/2006 AUTEUR REZETTE C.REZETTE +#@ MODIF post_k1_k2_k3_ops Macro DATE 06/11/2006 AUTEUR GALENNE E.GALENNE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -39,7 +39,13 @@ def cross_product(a,b): cross[1] = a[2]*b[0]-a[0]*b[2] cross[2] = a[0]*b[1]-a[1]*b[0] return cross - + +def moy(t): + m = 0 + for value in t : + m += value + return (m/len(t)) + def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,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, @@ -77,9 +83,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, # 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') 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') # ------------------------------------------------------------------ @@ -177,63 +183,67 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, if LNOFO==None : RECOL = True LNOFO = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND_INF .NOEU ') - if LNOFO==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DU FOND DE FISSURE') + if LNOFO==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DU FOND DE FISSURE \n') LNOFO = map(string.rstrip,LNOFO) Nbfond = len(LNOFO) + if MODELISATION=='3D' : # ----------Mots cles TOUT, NOEUD, SANS_NOEUD ------------- - Typ = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND .TYPE ') - if (Typ[0]=='SEG2 ') or (Typ[0]=='SEG3 ' and TOUT=='OUI') : - pas = 1 - elif (Typ[0]=='SEG3 ') : - pas = 2 - else : - UTMESS('F', macro, 'TYPE DE MAILLES DU FOND DE FISSURE NON DEFINI') + Typ = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND .TYPE ') + if (Typ[0]=='SEG2 ') or (Typ[0]=='SEG3 ' and TOUT=='OUI') : + pas = 1 + elif (Typ[0]=='SEG3 ') : + pas = 2 + else : + UTMESS('F', macro, 'TYPE DE MAILLES DU FOND DE FISSURE NON DEFINI') #### - NO_SANS = [] - NO_AVEC = [] - if GROUP_NO!=None : - collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO') - cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE') - 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', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE") - 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=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO') - cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE') - 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', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE") - 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 + NO_SANS = [] + NO_AVEC = [] + if GROUP_NO!=None : + collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO') + cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE') + 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', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE") + 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=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO') + cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE') + 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', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE") + 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', macro, 'LE NOEUD %s N APPARTIENT PAS AU FOND DE FISSURE'%NO_AVEC[i]) + 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', macro, 'LE NOEUD %s N APPARTIENT PAS AU FOND DE FISSURE'%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 : - for i in range(0,Nbfond,pas) : - if not (LNOFO[i] in NO_SANS) : - Lnf1.append(LNOFO[i]) - Nbf1 = Nbf1 +1 - + Lnf1 = LNOFO + Nbf1 = 1 + ##### Cas maillage libre########### # creation des directions normales et macr_lign_coup if TYPE_MAILLAGE =='LIBRE': @@ -253,48 +263,84 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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(nbval,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=aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMMAI') + for i in range(len(cmail)) : + if cmail[i] == ListmaS[0] : break + colcnx=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.CONNEX') + cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE') + 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,] - DTANOR = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_ORIGINE') - if DTANOR != None : - VN[0] = array(DTANOR) - else : + if MODELISATION=='3D' : + DTANOR = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_ORIGINE') Pfon2 = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]]) - 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[i] = array(cross_product(VT,v1)) - for i in range(1,Nbfond-1): + 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]]) - Pfon3 = array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]]) + VLextr = Pfon2 - Plev 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]]) - absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1] - absfon.append(absf) - DTANEX = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_EXTREMITE') - 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)]) + DTANEX = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_EXTREMITE') + 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 @@ -308,7 +354,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, MODEL = self.jdc.sds_dict[MOD[0]] for i in range(Nbf1): Porig = array(d_coorf[Lnf1[i]] ) - Pextr = Porig - ABSC_CURV_MAXI*dicVN[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, MAILLE = ListmaS, LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],), @@ -324,14 +372,21 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, else: # ---------- Dictionnaires des levres ------------- NnormS = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.SUPNORM .NOEU ') - if NnormS==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DES LEVRES') + if NnormS==None : + message= 'PROBLEME A LA RECUPERATION DES NOEUDS DE LA LEVRE SUP : VERIFIER ' + message=message+'QUE LE MOT CLE LEVRE_SUP EST BIEN RENSEIGNE DANS DEFI_FOND_FISS\n' + UTMESS('F', macro, message) NnormS = map(string.rstrip,NnormS) - if LNOFO[0]==LNOFO[-1] : Nbfond=Nbfond-1 # Cas fond de fissure ferme + 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 = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.INFNORM .NOEU ') + if NnormI==None : + message= 'PROBLEME A LA RECUPERATION DES NOEUDS DE LA LEVRE INF : VERIFIER ' + message=message+'QUE LE MOT CLE LEVRE_INF EST BIEN RENSEIGNE DANS DEFI_FOND_FISS\n' + UTMESS('F', macro, message) 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] @@ -366,7 +421,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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(nbval,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) @@ -450,10 +505,14 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, if SYME_CHAR=='SANS' : Lnoinf[Nbnofo] = Tmpinf Lnofon.append(Lnf1[i]) Nbnofo = Nbnofo+1 - + if Nbnofo == 0 : + message= 'CALCUL POSSIBLE POUR AUCUN NOEUD DU FOND :' + message=message+' VERIFIER LES DONNEES' + UTMESS('F',macro, message) + else : Nbnofo = 1 - + # ----------Recuperation de la temperature au fond ------------- if Tempe3D : resuth = map(string.rstrip,resuth) @@ -536,8 +595,10 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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] @@ -855,7 +916,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, else : v = aster.__version__ titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K1_K2_K3 LE &DATE A &HEURE \n'%v - if FOND_FISS : + 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)) mcfact.append(_F(PARA='METHODE',LISTE_I=(1,2,3))) @@ -878,12 +939,12 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, __tabi=CREA_TABLE(LISTE=mcfact,) npara = ['K1_MAX','METHODE'] if inst!=None : npara.append('INST') - if FOND_FISS : npara.append('NOEUD_FOND') + 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 pour conserver le meme ordre que operateur initial en fortran - if len(l_inst)!=1 and FOND_FISS : + if len(l_inst)!=1 and FOND_FISS and MODELISATION=='3D': tabout=CALC_TABLE(reuse=tabout,TABLE=tabout, ACTION=_F(OPERATION = 'TRI',NOM_PARA=('INST','ABSC_CURV','METHODE'),ORDRE='CROISSANT')) diff --git a/Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py b/Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py new file mode 100644 index 00000000..6295395b --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py @@ -0,0 +1,245 @@ +#@ MODIF post_k_trans_ops Macro DATE 31/10/2006 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 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())['ABS_CURV'].values()['ABS_CURV'][0:nbno] + + if nmodtr != n_mode : + n_mode = min(nmodtr,n_mode) + message = 'NOMBRE DE MODES DIFFERENT ENTRE LA BASE MODALE' + message = message +'ET %s : ON PREND LE MINIMUM DES DEUX (%i)\n'%(nomresu,n_mode) + UTMESS('A', macro, message) + +# +# 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 : + message = 'LE NUMERO D ORDRE %i N APPARTIENT PAS AU RESULTAT %s'%(ord,nomresu) + UTMESS('A', macro, message) + 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)=2 : + message = 'PLUSIEURS INSTANTS TROUVES DANS LA TABLE POUR L INSTANT %f\n'%ins + UTMESS('A', macro, message) + 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', macro, 'AUCUN INSTANT OU NUMERO D ORDRE TROUVE') + + +# +# 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 = 'ABS_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/cataSTA8/Macro/reca_algo.py b/Aster/Cata/cataSTA8/Macro/reca_algo.py index 429de101..6ef8f7ca 100644 --- a/Aster/Cata/cataSTA8/Macro/reca_algo.py +++ b/Aster/Cata/cataSTA8/Macro/reca_algo.py @@ -1,5 +1,6 @@ -#@ MODIF reca_algo Macro DATE 31/01/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF reca_algo Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- +# RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -18,16 +19,25 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== - - -import Numeric +import Numeric, MLab from Numeric import take, size import copy,os import LinearAlgebra -from Cata.cata import INFO_EXEC_ASTER -from Cata.cata import DETRUIRE -from Accas import _F -from Utilitai.Utmess import UTMESS + +try: + from Cata.cata import INFO_EXEC_ASTER + from Cata.cata import DETRUIRE + from Accas import _F +except: pass + +try: + from Utilitai.Utmess import UTMESS +except ImportError: + def UTMESS(code,sprg,texte): + fmt='\n <%s> <%s> %s\n\n' + print fmt % (code,sprg,texte) + if code=='F': sys.exit() + def calcul_gradient(A,erreur): @@ -35,11 +45,18 @@ def calcul_gradient(A,erreur): return grad -#------------------------------------------- -#classe gérant l'adimensionnement et le dimensionnemnt +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + class Dimension: - #le constructeur calcul la matrice D et son inverse + """ + 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) @@ -48,6 +65,8 @@ class Dimension: 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]): @@ -55,6 +74,7 @@ class Dimension: return A +# ------------------------------------------------------------------------------ def redim_sensi(self,A): for i in range(A.shape[0]): @@ -63,16 +83,29 @@ class Dimension: 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) @@ -84,7 +117,13 @@ def cond(matrix): condi=0.0 return condi,e[size-1],e[0] -#----------------------------------------- + + + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + def norm(matrix): e=LinearAlgebra.Heigenvalues(matrix) size=len(e) @@ -92,10 +131,14 @@ def norm(matrix): norm=e[size-1] return norm -#----------------------------------------- + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + def lambda_init(matrix): -# Routine qui calcule la valeur initial du parametre -# de regularisation l. + """ + 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): @@ -106,47 +149,21 @@ def lambda_init(matrix): l=abs(10000.*emin-emax)/10001. return l -#----------------------------------------- - - -def temps_CPU(self,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 - UTMESS('F', "MACR_RECAL", 'Arret de MACR_RECAL par manque de temps CPU') - return restant,temps_iter,err - - - - -def Levenberg_bornes(self,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 + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + +#def Levenberg_bornes(self,val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out): +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 @@ -211,12 +228,15 @@ def Levenberg_bornes(self,val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out 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', "MACR_RECAL", "Erreur dans l'algorithme de bornes de MACR_RECAL") + UTMESS('F','MACR_RECAL',"Erreur dans l'algorithme de bornes de MACR_RECAL") 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) @@ -241,27 +261,39 @@ def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J): return l +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + def test_convergence(gradient_init,erreur,A,s): + """ + Renvoie le residu + """ gradient = calcul_gradient(A,erreur)+s - epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init) + try: + epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init) + except: + UTMESS('F', "MACR_RECAL", "Erreur dans le test de convergence de MACR_RECAL") + return epsilon = epsilon**0.5 return epsilon -# fonction appellé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 -def calcul_etat_final(para,A,iter,max_iter,prec,residu,Messg,ul_out): +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + +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) 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)) - Messg.affiche_calcul_etat_final(para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible,ul_out) - - - - - + Messg.affiche_calcul_etat_final(para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible) diff --git a/Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py b/Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py new file mode 100644 index 00000000..f58e4f9c --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py @@ -0,0 +1,901 @@ +#@ MODIF reca_calcul_aster Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE +# -*- coding: iso-8859-1 -*- +# RESPONSABLE ASSIRE A.ASSIRE +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 +debug = False + +__commandes_aster__ = False + + +import copy, Numeric, types, os, sys, pprint, math +from glob import glob + +try: + import aster +except: pass + +try: + from Utilitai.Utmess import UTMESS +except ImportError: + def UTMESS(code,sprg,texte): + fmt='\n <%s> <%s> %s\n\n' + print fmt % (code,sprg,texte) + if code=='F': sys.exit() + +from Utilitai.System import ExecCommand + +# 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','MACR_RECAL',"Probleme : impossible d'importer le module de lecture des tables!") + 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','MACR_RECAL',"Lancement de la commande : " + 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','MACR_RECAL',"Fin du lancement de la commande : " + cmd) + + diag = self.Recuperation_Diagnostic(txt_output) + + return + + + # ------------------------------------------------------------------------------ + + def Recuperation_Diagnostic(self, output): + + txt = '--- DIAGNOSTIC JOB :' + diag = None + for ligne in output.splitlines(): + if ligne.find(txt) > -1: + diag = ligne.split(txt)[-1].strip() + break + + if self.INFO>=1: UTMESS('I','MACR_RECAL',"Diagnostic du calcul esclave : " + diag) + + if diag in ['OK', 'NOOK_TEST_RESU', '_ALARM', '_COPY_ERROR']: return True + else: + UTMESS('F','MACR_RECAL',"Le fichier esclave ne s'est pas terminé correctement.") + + + # ------------------------------------------------------------------------------ + + 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', nompro, "Le nombre d'evaluation de la fonctionnelle depasse le critere ITER_FONC_MAXI.") + 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', nompro, "Impossible de relire le fichier esclave : \n " + str(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', nompro, "Variable d'environnement ASTER_ROOT absente, " \ + "on essaiera avec 'as_run' dans le $PATH.") + + 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', nompro, message) + + # 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','MACR_RECAL',"Probleme : impossible d'importer le module de lecture des tables!") + + txt = [] + for i in para: + txt.append( "\t\t\t%s : %s" % (i, val[para.index(i)]) ) + if INFO>=1: UTMESS('I','MACR_RECAL',"Calcul de F avec les parametres:\n%s" % '\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) + + #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() + + # 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: + message = "Impossible de recuperer les resultats de calcul esclave!" + UTMESS('F', nompro, message) + + 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 + message = """Impossible de recuperer les resultats de calcul esclave (lecture des tables)! +Le calcul esclave n'a pas du se terminer correctement (ajouter un repertoire en Resultat avec +le type repe et voir l'output du fichier esclave dans ce repertoire. +Message: +""" + message += str(err) + UTMESS('F', nompro, message) + + try: + ier, message, table_lue = lecture_table(texte, 1, ' ') + list_para = table_lue.para + tab_lue = table_lue.values() + except Exception, err: + ier=1 + message = "Impossible de recuperer les resultats de calcul esclave (lecture des tables)!\nMessage:\n" + str(err) + + if ier!=0 : + UTMESS('F', nompro, message) + + 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: + message = "Impossible de recuperer les resultats de calcul esclave (recuperation des tables)!\nMessage:\n" + str(err) + UTMESS('F', nompro, message) + + + # ------------------------------------------------------ + # 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: + message = """Impossible de recuperer les resultats de calcul esclave (lecture des tables)! +Le calcul esclave n'a pas du se terminer correctement (ajouter un repertoire en Resultat avec +le type repe et voir l'output du fichier esclave dans ce repertoire. +Message: +""" + message += str(err) + UTMESS('F', nompro, message) + + try: + ier, message, table_lue = lecture_table(texte, 1, ' ') + list_para = table_lue.para + tab_lue = table_lue.values() + except Exception, err: + ier=1 + message = "Impossible de recuperer les resultats de calcul esclave (lecture des tables)!\nMessage:\n" + str(err) + + + if ier!=0 : + UTMESS('F', nompro, message) + + 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: + message = "Impossible de recuperer les resultats de calcul esclave (recuperation des tables)!\nMessage:\n" + str(err) + UTMESS('F', nompro, message) + + + # 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) + +# print 50*'+' +# print self.A_nodim +# print 50*'+' +# print 50*'+' +# print 'self.L=', self.L +# print 50*'+' +# print 'self.reponses=', self.reponses +# print 50*'+' +# print 'self.resu_exp=', self.Simul.resu_exp +# print 50*'+' +# print 'self.L_J=', self.L_J +# print 50*'+' +# print 'self.erreur=', self.erreur +# print 50*'+' + +# A_nodim = copy.copy(self.A_nodim) + 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. + +# print 50*'+' +# print self.A_nodim +# print 50*'+' +# print self.A +# print 50*'+' +# print "Numeric.sum(self.A_nodim,0)=", Numeric.sum(self.A_nodim,0) +# print "Numeric.sum(self.A,0)=", Numeric.sum(self.A,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 ) + +# print self.norme_A_nodim +# print self.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: + txt = "Informations de convergence :" + txt += '\n=======================================================\n' + if self.evaluation_fonction >1: txt += "\n Nombre d'evaluation de la fonction = " + str(self.evaluation_fonction) + txt += "\n=> Fonctionnelle = "+str(J) + + if self.vector_output: + if self.INFO>=1: + txt += "\n=> Norme de l'erreur = " + str(norme) + txt += '\n=======================================================\n' + UTMESS('I','MACR_RECAL',txt) + return erreur + else: + if self.INFO>=1: + txt += "\n=> Erreur = " + str(norme) + txt += '\n=======================================================\n' + UTMESS('I','MACR_RECAL',txt) + return norme + +# if self.error_output: +# print "erreur:", erreur +# return erreur +# else: +# print "norme:", 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 + 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','MACR_RECAL',"Probleme : Impossible de creer le repertoire temporaire : " + 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','MACR_RECAL',"Probleme : Impossible de creer le repertoire temporaire : " + 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','MACR_RECAL',"Probleme : il n'y a pas de fichier .export dans le repertoire de travail!") + elif len(list_export) >1: UTMESS('F','MACR_RECAL',"Probleme : il y a plus d'un fichier .export dans le repertoire de travail!") + + # 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'])) + + # sinon on garde la ligne + setattr(prof, lab, l_fr) + + # Ecriture du nouveau fichier export + prof.WriteExportTo(self.new_export) + +# os.system('cp ' + self.new_export + ' /tmp') + + # --FIN CLASSE ---------------------------------------------------------------------------- + + + diff --git a/Aster/Cata/cataSTA8/Macro/reca_controles.py b/Aster/Cata/cataSTA8/Macro/reca_controles.py new file mode 100644 index 00000000..43f8dc3a --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/reca_controles.py @@ -0,0 +1,228 @@ +#@ MODIF reca_controles Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE +# -*- coding: iso-8859-1 -*- +# RESPONSABLE ASSIRE A.ASSIRE +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 + +try: + from Utilitai.Utmess import UTMESS +except ImportError: + def UTMESS(code,sprg,texte): + fmt='\n <%s> <%s> %s\n\n' + print fmt % (code,sprg,texte) + if code=='F': sys.exit() + + +# 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="" + + 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 + 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 += "\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_infPARAMETRES[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="" + #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 commndes ASTER + if METHODE != 'EXTERNE': # pour celui-ci le fort.UL n'est pas l'esclave... voir comment faire + texte = texte + verif_fichier(UL,PARAMETRES,REPONSES) + + #verification des valeurs des PARAMETRES entrées par l'utilisteur + 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 + diff --git a/Aster/Cata/cataSTA8/Macro/reca_interp.py b/Aster/Cata/cataSTA8/Macro/reca_interp.py index 0d04cc21..d441a5e7 100644 --- a/Aster/Cata/cataSTA8/Macro/reca_interp.py +++ b/Aster/Cata/cataSTA8/Macro/reca_interp.py @@ -1,5 +1,6 @@ -#@ MODIF reca_interp Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND +#@ MODIF reca_interp Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- +# RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -18,11 +19,20 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import os +import os, sys, pprint import Numeric -import Macro -from Macro.recal import calcul_F -from Utilitai.Utmess import UTMESS + +try: import Macro +except: pass + +try: + from Utilitai.Utmess import UTMESS +except ImportError: + def UTMESS(code,sprg,texte): + fmt='\n <%s> <%s> %s\n\n' + print fmt % (code,sprg,texte) + if code=='F': sys.exit() + #=========================================================================================== @@ -36,29 +46,66 @@ class Sim_exp : self.resu_exp = result_exp self.poids = poids -# Distance verticale d'un point M à une ligne brisée composée de n points - +# ------------------------------------------------------------------------------ + + 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] ) : + txt = "Problème lors de l'interpolation du calcul dérivé sur les données expérimentale!" + txt += "\nValeur à interpoler : " + str(x0) + txt += "\nDomaine couvert par l'experience : [" + str(points[0][0]) + ":" + str(points[n-1][0]) + "]" + UTMESS('F','MACR_RECAL', txt) + + 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) : - # 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 - - -# La Fonction Interpole ,interpole une et une seule F_calc sur F_exp et renvoie l'erreur seulement - def Interpole (self, F_calc,experience,poids) : #ici on passe en argument "une" experience + """ + 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 @@ -69,19 +116,31 @@ class Sim_exp : 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 - #cette fonction appelle la fonction interpole et retourne les sous fonctionnelle J et l'erreur - def multi_interpole(self,L_F, reponses): #on interpole toutes les reponses une à une en appelent la methode interpole + +# ------------------------------------------------------------------------------ + + 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]) + err = self._Interpole(L_F[i],self.resu_exp[i],self.poids[i]) L_erreur.append(err) - #on transforme L_erreur en tab num + +# print "L_erreur=", L_erreur + + # On transforme L_erreur en tab num dim=[] J=[] for i in range(len(L_erreur)): @@ -97,16 +156,25 @@ class Sim_exp : del(L_erreur) #on vide la liste puisqu'on n'en a plus besoin return L_J,erreur - #cette fonction retourne seulement l'erreur ,je l'appelle dans la methode sensibilité - #on interpole toutes les reponses une à une en appelent la methode interpole - def multi_interpole_sensib(self,L_F,reponses): + +# ------------------------------------------------------------------------------ + + 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]) + err = self._Interpole(L_F[i], self.resu_exp[i], self.poids[i]) L_erreur.append(err) - #on transforme L_erreur en tab num + # 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)): @@ -115,54 +183,131 @@ class Sim_exp : 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): - #cette fonction calcul une valeur normée de 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: message= 'Problème de division par zéro dans la normalisation de la fonctionnelle.\n' message=message+'Une des valeurs de la fonctionnelle initiale est nulle ou inférieure à la précision machine : %.2f \n'%L_J_init - fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') - fic.write(message) - fic.close() + if unite_resu: + fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') + fic.write(message) + fic.close() UTMESS('F', "MACR_RECAL", message) - + return + J = Numeric.sum(L_J) J = J/len(L_J) - return J - - def sensibilite(self,objet,UL,F,val,para,reponses,pas,unite_resu): - F_interp=self.multi_interpole_sensib(F, reponses) #F_interp est une liste contenant des tab num des reponses interpolés - L_A=[] #creation de la liste des matrices de sensibilités + 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) ) - #calcul de la sensibilité - fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') - fic.write('\nCalcul de la sensibilité par rapport à :') - fic.close() - for k in range(len(val)): #pour une colone de A - h = val[k]*pas - val[k] = val[k] + h - F_perturbe = calcul_F(objet,UL,para,val,reponses) - fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') - fic.write(' '+para[k]) - fic.close() - F_perturbe_interp =self.multi_interpole_sensib(F_perturbe, reponses) - val[k] = val[k] - h - 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: - message= 'Probleme de division par zéro dans le calcul de la matrice de sensiblité\n ' - message=message+'Le parametre '+para[k]+'est nul ou plus petit que la précision machine \n' - fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') - fic.write(message) - fic.close() - UTMESS('F', "MACR_RECAL", message) - #on construit la matrice de sensiblité sous forme d'un tab num + + 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','MACR_RECAL','On utilise les differences finies pour calculer la sensibilite de : %s ' % 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','MACR_RECAL',"Probleme de division par zéro dans le calcul de la matrice de sensiblité.\n Le parametre "+para[k]+"est nul ou plus petit que la précision machine") + 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','MACR_RECAL','On utilise le calcul de SENSIBILITE pour : %s ' % 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])) @@ -174,8 +319,7 @@ class Sim_exp : 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 - + 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/cataSTA8/Macro/reca_message.py b/Aster/Cata/cataSTA8/Macro/reca_message.py index 0691b785..ec5d87fa 100644 --- a/Aster/Cata/cataSTA8/Macro/reca_message.py +++ b/Aster/Cata/cataSTA8/Macro/reca_message.py @@ -1,5 +1,6 @@ -#@ MODIF reca_message Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF reca_message Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- +# RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -18,7 +19,15 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import os,Numeric +import os, Numeric + +try: + from Utilitai.Utmess import UTMESS +except: + def UTMESS(code,sprg,texte): + fmt='\n <%s> <%s> %s\n\n' + print fmt % (code,sprg,texte) + if code=='F': sys.exit() #=========================================================================================== @@ -28,88 +37,137 @@ import os,Numeric 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.res_exp = resu_exp - res=open(os.getcwd()+'/fort.'+str(ul_out),'a') - res.write(' MACR_RECAL V1.1 \n\n\n') + self.resu_exp = resu_exp + self.val_init = val_init + self.resu_exp = resu_exp + self.ul_out = ul_out + +# ------------------------------------------------------------------------------ + + def initialise(self): + res=open(os.getcwd()+'/fort.'+str(self.ul_out),'w') res.close() - + + txt = ' MACR_RECAL\n\n' + self.ecrire(txt) + +# ------------------------------------------------------------------------------ - def affiche_result_iter(self,iter,J,val,residu,Act,ul_out): - res=open(os.getcwd()+'/fort.'+str(ul_out),'a') - res.write('\n=======================================================\n') - res.write('Iteration '+str(iter)+' :\n') - res.write('\n=> Fonctionnelle = '+str(J)) - res.write('\n=> Résidu = '+str(residu)) - res.write('\n=> Paramètres = ') + def ecrire(self,txt): + res=open(os.getcwd()+'/fort.'+str(self.ul_out),'a') + res.write(txt+'\n') + res.flush() + res.close() + + +# ------------------------------------------------------------------------------ + + def affiche_valeurs(self,val): + + txt = '\n=> Paramètres = ' for i in range(len(val)): - res.write('\n '+ self.nom_para[i]+' = '+str(val[i]) ) + 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): - res.write('\n\n Le paramètre ') + txt += '\n\n Le paramètre ' else: - res.write('\n\n Les paramètres ') + txt += '\n\n Les paramètres ' for i in Act: - res.write(self.nom_para[i]+' ') + txt += self.nom_para[i]+' ' if (len(Act)==1): - res.write('\n est en butée sur un bord de leur domaine admissible.') + txt += '\n est en butée sur un bord de leur domaine admissible.' else: - res.write('\n sont en butée sur un bord de leur domaine admissible.') - res.write('\n=======================================================\n\n') - res.close() - - def affiche_etat_final_convergence(self,iter,max_iter,prec,residu,Act,ul_out): - res=open(os.getcwd()+'/fort.'+str(ul_out),'a') - if ((iter < max_iter) or (residu < prec)): - res.write('\n=======================================================\n') - res.write(' CONVERGENCE ATTEINTE ') + 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): - res.write("\n\n ATTENTION : L'OPTIMUM EST ATTEINT AVEC ") - res.write("\n DES PARAMETRES EN BUTEE SUR LE BORD ") - res.write("\n DU DOMAINE ADMISSIBLE ") - res.write('\n=======================================================\n') - res.close() + 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: - res.write("\n=======================================================\n") - res.write(' CONVERGENCE NON ATTEINTE ') - res.write("\n Le nombre maximal d'itération ("+str(max_iter)+") a été dépassé") - res.write('\n=======================================================\n') - res.close() - - def affiche_calcul_etat_final(self,para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible,ul_out): - res=open(os.getcwd()+'/fort.'+str(ul_out),'a') - res.write('\n\nValeurs propres du Hessien:\n') - res.write(str( valeurs_propres)) - res.write('\n\nVecteurs propres associés:\n') - res.write(str( vecteurs_propres)) - res.write('\n\n --------') - res.write('\n\nOn peut en déduire que :') + 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): - res.write('\n\nLes combinaisons suivantes de paramètres sont prépondérantes pour votre calcul :\n') + 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)) - res.write('\n '+str(k)+') ') + txt += '\n '+str(k)+') ' for j in numero: - res.write('%+3.1E ' %colonne[j]+'* '+para[j]+' ') - res.write('\n associée à la valeur propre %3.1E \n' %valeurs_propres[i]) + 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): - res.write('\n\nLes combinaisons suivantes de paramètres sont insensibles pour votre calcul :\n') + 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)) - res.write('\n '+str(k)+') ') + txt += '\n '+str(k)+') ' for j in numero: - res.write('%+3.1E ' %colonne[j]+'* '+para[j]+' ') - res.write('\n associée à la valeur propre %3.1E \n' %valeurs_propres[i]) - res.close() + 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/cataSTA8/Macro/reca_utilitaires.py b/Aster/Cata/cataSTA8/Macro/reca_utilitaires.py new file mode 100644 index 00000000..c2c3cd27 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/reca_utilitaires.py @@ -0,0 +1,225 @@ +#@ MODIF reca_utilitaires Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE +# -*- coding: iso-8859-1 -*- +# RESPONSABLE ASSIRE A.ASSIRE +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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: + from Cata.cata import INFO_EXEC_ASTER, DEFI_FICHIER, IMPR_FONCTION, DETRUIRE + from Accas import _F +except: pass + +try: import Gnuplot +except: pass + +try: + from Utilitai.Utmess import UTMESS +except ImportError: + def UTMESS(code,sprg,texte): + fmt='\n <%s> <%s> %s\n\n' + print fmt % (code,sprg,texte) + if code=='F': sys.exit() + + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + +#_____________________________________________ +# +# 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( CONCEPT =self.g_context['_F'](NOM = 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 + UTMESS('F','MACR_RECAL',"Arret de MACR_RECAL par manque de temps CPU.") + + return restant,temps_iter,err + + + + +#_____________________________________________ +# +# IMPRESSIONS GRAPHIQUES +#_____________________________________________ + + +def graphique(FORMAT, L_F, res_exp, reponses, iter, UL_out, interactif, 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 } ) + 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' + + IMPR_FONCTION(FORMAT='XMGRACE', + UNITE=int(UL_out), + TITRE='Courbe de : ' + reponses[i][0], + SOUS_TITRE=txt_iter, + LEGENDE_X=reponses[i][1], + LEGENDE_Y=reponses[i][2], + **motscle2 + ); + + elif FORMAT=='GNUPLOT': + if INFO>=2: UTMESS('I','MACR_RECAL',"Trace des courbes dans le fichier " + fichier ) + + if 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 2.') + 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 2.') + 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 interactif: + graphe[i]('pause 5') + else: + if fichier: + if INFO>=2: UTMESS('I','MACR_RECAL',"Trace des courbes dans le fichier " + 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','MACR_RECAL',"Probleme lors de l'affichage des courbes. On ignore et on continue. Erreur :\n" + str(err) ) + diff --git a/Aster/Cata/cataSTA8/Macro/recal.py b/Aster/Cata/cataSTA8/Macro/recal.py index 2e43b088..684df91c 100644 --- a/Aster/Cata/cataSTA8/Macro/recal.py +++ b/Aster/Cata/cataSTA8/Macro/recal.py @@ -1,4 +1,4 @@ -#@ MODIF recal Macro DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE +#@ MODIF recal Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -22,24 +22,8 @@ import string, copy, Numeric, types -# import Gnuplot import Cata -from Cata.cata import INCLUDE, DETRUIRE, FIN, EXEC_LOGICIEL, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE -from Utilitai.Utmess import UTMESS -from Accas import _F - -import os, aster, cPickle, sys - -# try: -# import Gnuplot -# except: pass - -try: - from Utilitai.Utmess import UTMESS -except ImportError: - def UTMESS(code,sprg,texte): - fmt='\n <%s> <%s> %s\n\n' - print fmt % (code,sprg,texte) +from Cata.cata import INCLUDE, DETRUIRE #_____________________________________________ @@ -232,6 +216,21 @@ def compare__dim_rep__dim_RESU_EXP(REPONSES,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 @@ -326,6 +325,8 @@ def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU): #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 diff --git a/Aster/Cata/cataSTA8/Macro/simu_point_mat_ops.py b/Aster/Cata/cataSTA8/Macro/simu_point_mat_ops.py new file mode 100644 index 00000000..54873925 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/simu_point_mat_ops.py @@ -0,0 +1,327 @@ +#@ MODIF simu_point_mat_ops Macro DATE 10/10/2006 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 simu_point_mat_ops(self, COMP_INCR, MATER, INCREMENT, NEWTON,CONVERGENCE, + SUIVI_DDL,SIGM_IMPOSE,EPSI_IMPOSE, 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) + + # 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') + STAT_NON_LINE = self.get_cmd('STAT_NON_LINE') + 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') + + 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={} + + CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'] + CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'] + + 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(6): + SIG[CMP_SIG[i]]=__fonczero + + if EPSI_IMPOSE: + EPS=EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste) +# for i in EPS.keys(): +# if EPS[i]==None : EPS[i]=__fonczero + else: + for i in range(6): + EPS[CMP_EPS[i]]=None + + for index in range(6): + 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 + + 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 + FIN + """ + UL = UniteAster() + umail = UL.Libre(action='ASSOCIER', nom='simu.mail' ) + + fi_mail = open('simu.mail','w') + fi_mail.write(texte_ma) + fi_mail.close() + + __MA = LIRE_MAILLAGE(UNITE=umail) + UL.EtatInit() + + +# -- Materiau et modele + + __CHMAT = AFFE_MATERIAU( + MAILLAGE = __MA, + AFFE = _F( + MAILLE = 'VOLUME', + MATER = MATER + ) + ) + + + __MO = AFFE_MODELE( + MAILLAGE = __MA, + AFFE = _F( + MAILLE = ('VOLUME','F1','F2','F3','F4'), + PHENOMENE = 'MECANIQUE', + MODELISATION = '3D' + ) + ) + + +# -- 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), + ) + ) + +# -- Chargement en deformation + + __E = [None]*6 + + __E[0] = AFFE_CHAR_MECA( + MODELE = __MO, + DDL_IMPO = _F(NOEUD='P1', DX=1) + ) + + __E[1] = AFFE_CHAR_MECA( + MODELE = __MO, + DDL_IMPO = _F(NOEUD='P2', DY=1) + ) + + __E[2] = AFFE_CHAR_MECA( + MODELE = __MO, + DDL_IMPO = _F(NOEUD='P3', DZ=1) + ) + + __E[3] = AFFE_CHAR_MECA( + MODELE = __MO, + DDL_IMPO = _F(NOEUD='P1', DY=1) + ) + + __E[4] = AFFE_CHAR_MECA( + MODELE = __MO, + DDL_IMPO = _F(NOEUD='P1', DZ=1) + ) + + __E[5] = AFFE_CHAR_MECA( + MODELE = __MO, + DDL_IMPO = _F(NOEUD='P2', DZ=1) + ) + + +# -- Chargement en contrainte + + __S = [None]*6 + + 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), + ) + ) + + +# -- Construction de la charge + + l_char = [ _F(CHARGE=__C_RIGIDE) ] + + for i in xrange(6) : + ike=CMP_EPS[i] + if EPS[ike]: + l_char.append( _F(CHARGE=__E[i],FONC_MULT=EPS[ike]) ) + + for i in xrange(6) : + iks=CMP_SIG[i] + l_char.append( _F(CHARGE=__S[i],FONC_MULT=SIG[iks]) ) + +# -- Deroulement du calcul + motscles={} + motscles['COMP_INCR'] = COMP_INCR.List_F() + motscles['CONVERGENCE'] = CONVERGENCE.List_F() + motscles['NEWTON'] = NEWTON.List_F() + motscles['INCREMENT'] = INCREMENT.List_F() + + if SUIVI_DDL : + motscles['SUIVI_DDL'] = SUIVI_DDL.List_F() + + + __EVOL = STAT_NON_LINE( + MODELE = __MO, + CHAM_MATER = __CHMAT, + EXCIT = l_char, + ARCHIVAGE = _F(ARCH_ETAT_INIT = 'OUI'),**motscles) + + + __EVOL = CALC_ELEM(reuse = __EVOL, + RESULTAT = __EVOL, + OPTION = ('SIEF_ELNO_ELGA','EPSI_ELNO_DEPL','VARI_ELNO_ELGA') + ) + + +# -- Recuperation des courbes + + __REP_VARI = POST_RELEVE_T( + ACTION = ( + _F( + INTITULE = 'VARI_INT', + RESULTAT = __EVOL, + 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' + ), + ) + ) + self.DeclareOut('REPONSE',self.sd) + REPONSE=CALC_TABLE( TABLE=__REP_EPSI, + ACTION=_F(OPERATION='COMB',TABLE=__REP_SIGM,NOM_PARA=('INST'), ) ) + + REPONSE=CALC_TABLE(reuse=REPONSE, TABLE=REPONSE, + ACTION=_F(OPERATION='COMB',TABLE=__REP_VARI,NOM_PARA=('INST'), ) ) + + + return ier + + + + diff --git a/Aster/Cata/cataSTA8/Macro/stanley_ops.py b/Aster/Cata/cataSTA8/Macro/stanley_ops.py index 51af193a..761b45fb 100644 --- a/Aster/Cata/cataSTA8/Macro/stanley_ops.py +++ b/Aster/Cata/cataSTA8/Macro/stanley_ops.py @@ -1,4 +1,4 @@ -#@ MODIF stanley_ops Macro DATE 15/05/2006 AUTEUR ASSIRE A.ASSIRE +#@ MODIF stanley_ops Macro DATE 12/09/2006 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -33,6 +33,9 @@ def stanley_ops(self,RESULTAT,MODELE,CHAM_MATER,CARA_ELEM,DISPLAY,**args): 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 @@ -81,4 +84,6 @@ def stanley_ops(self,RESULTAT,MODELE,CHAM_MATER,CARA_ELEM,DISPLAY,**args): STANLEY(DISPLAY='adresse_ip:0.0');""") + aster.onFatalError(prev_onFatalError) + return ier diff --git a/Aster/Cata/cataSTA8/__init__.py b/Aster/Cata/cataSTA8/__init__.py index ee8be403..ea9a6f6b 100644 --- a/Aster/Cata/cataSTA8/__init__.py +++ b/Aster/Cata/cataSTA8/__init__.py @@ -1,8 +1,8 @@ import os,sys -import prefs -import sys -rep_macro = os.path.join(prefs.REPINI,'Cata/cataSTA8') +sys.modules["Cata"]=sys.modules[__name__] +rep_macro = os.path.dirname(__file__) sys.path.insert(0,rep_macro) + from cata import * from math import ceil from Extensions import param2 diff --git a/Aster/Cata/cataSTA8/cata.py b/Aster/Cata/cataSTA8/cata.py index e2497c03..a39504e4 100755 --- a/Aster/Cata/cataSTA8/cata.py +++ b/Aster/Cata/cataSTA8/cata.py @@ -1,4 +1,4 @@ -#& MODIF ENTETE DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF ENTETE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -34,7 +34,7 @@ except: pass __version__="$Name: $" -__Id__="$Id: cata.py,v 1.1.6.2 2006/06/20 12:14:36 pnoyret Exp $" +__Id__="$Id: cata_aster_v6.py,v 1.12 2001/01/16 15:55:05 iliade Exp $" EnumTypes = (ListType, TupleType) @@ -109,7 +109,6 @@ class listis_sdaster (ASSD):pass class melasflu_sdaster(ASSD):pass class nume_ddl_sdaster(ASSD):pass class nume_ddl_gene (ASSD):pass -class obstacle_sdaster(ASSD):pass class sd_feti_sdaster (ASSD):pass class spectre_sdaster (ASSD):pass class surface_sdaster (ASSD):pass @@ -152,12 +151,15 @@ class mater_sdaster(ASSD): raise Accas.AsException("Erreur dans mater.RCVALE en PAR_LOT='OUI'") from Utilitai.Utmess import UTMESS # vérification des arguments - if not nompar in EnumTypes: - nompar = tuple(nompar) - if not valpar in EnumTypes: - valpar = tuple(valpar) - if not nomres in EnumTypes: - nomres = tuple(nomres) + if not type(nompar) in EnumTypes: + nompar = [nompar,] + if not type(valpar) in EnumTypes: + valpar = [valpar,] + if not type(nomres) in EnumTypes: + nomres = [nomres,] + nompar = tuple(nompar) + valpar = tuple(valpar) + nomres = tuple(nomres) if len(nompar) != len(valpar): UTMESS('F', 'RCVALE', """Arguments incohérents : Nom des paramètres : %s @@ -206,7 +208,6 @@ class macr_elem_dyna (ASSD): else: raise Accas.AsException("Le type de la matrice est incorrect") ncham=nommacr+(8-len(nommacr))*' '+ext - print ncham desc=Numeric.array(aster.getvectjev(ncham+'_DESC')) # On teste si le DESC du vecteur existe @@ -453,6 +454,7 @@ class comb_fourier (resultat_sdaster):pass class dyna_harmo (resultat_sdaster):pass class dyna_trans (resultat_sdaster):pass class fourier_elas (resultat_sdaster):pass +class fourier_ther (resultat_sdaster):pass class harm_gene (resultat_sdaster):pass class mode_acou (resultat_sdaster):pass class mode_cycl (resultat_sdaster):pass @@ -559,21 +561,23 @@ class fonction_sdaster(fonction_class): if lbl == None: UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale) lbl = list(lbl) - dim=len(lbl)/2 - lx=lbl[0:dim] - ly=lbl[dim:2*dim] - return [lx,ly] - elif hasattr(self,'etape') and self.etape.nom=='DEFI_FONCTION' : - if self.etape['VALE']!=None: - lbl=list(self.etape['VALE']) - dim=len(lbl) - lx=[lbl[i] for i in range(0,dim,2)] - ly=[lbl[i] for i in range(1,dim,2)] - return [lx,ly] - elif self.etape['VALE_PARA']!=None: - return [self.etape['VALE_PARA'].Valeurs(),self.etape['VALE_FONC'].Valeurs()] - else : - raise Accas.AsException("Erreur dans fonction.Valeurs en PAR_LOT='OUI'") + dim = len(lbl)/2 + lx = lbl[0:dim] + ly = lbl[dim:2*dim] + elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION' : + if self.etape['VALE'] != None: + lbl = list(self.etape['VALE']) + dim = len(lbl) + lx = [lbl[i] for i in range(0,dim,2)] + ly = [lbl[i] for i in range(1,dim,2)] + elif self.etape['VALE_PARA']!=None: + lx = self.etape['VALE_PARA'].Valeurs() + ly = self.etape['VALE_FONC'].Valeurs() + else: + raise Accas.AsException("Erreur (fonction.Valeurs) : ne fonctionne en " \ + "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \ + "dans le jdc courant.") + return [lx, ly] def Absc(self): """Retourne la liste des abscisses""" return self.Valeurs()[0] @@ -626,28 +630,29 @@ class fonction_c(fonction_class): Retourne trois listes de valeurs : abscisses, parties reelles et imaginaires. """ if not self.par_lot(): - vale = '%-19s.VALE' % self.get_name() - lbl = aster.getvectjev(vale) - if lbl == None: - UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale) - lbl = list(lbl) - dim=len(lbl)/3 - lx=lbl[0:dim] - lr=[] - li=[] - for i in range(dim): - lr.append(lbl[dim+2*i]) - li.append(lbl[dim+2*i+1]) - return [lx,lr,li] - if self.etape.nom=='DEFI_FONCTION' : - lbl=list(self.etape['VALE_C']) - dim=len(lbl) - lx=[lbl[i] for i in range(0,dim,3)] - lr=[lbl[i] for i in range(1,dim,3)] - li=[lbl[i] for i in range(2,dim,3)] - return [lx,lr,li] - else : - raise Accas.AsException("Erreur dans fonction_c.Valeurs en PAR_LOT='OUI'") + vale = '%-19s.VALE' % self.get_name() + lbl = aster.getvectjev(vale) + if lbl == None: + UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale) + lbl = list(lbl) + dim=len(lbl)/3 + lx=lbl[0:dim] + lr=[] + li=[] + for i in range(dim): + lr.append(lbl[dim+2*i]) + li.append(lbl[dim+2*i+1]) + elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION': + lbl=list(self.etape['VALE_C']) + dim=len(lbl) + lx=[lbl[i] for i in range(0,dim,3)] + lr=[lbl[i] for i in range(1,dim,3)] + li=[lbl[i] for i in range(2,dim,3)] + else: + raise Accas.AsException("Erreur (fonction_c.Valeurs) : ne fonctionne en " \ + "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \ + "dans le jdc courant.") + return [lx, lr, li] def Absc(self): """Retourne la liste des abscisses""" return self.Valeurs()[0] @@ -1046,6 +1051,11 @@ class table_sdaster(ASSD): return Table(lisdic, lpar, ltyp, titr) # ----------------------------------------------------------------------------- +class table_fonction(table_sdaster): + """Table contenant en plus une colonne FONCTION et/ou FONCTION_C dont les + valeurs des cellules sont des noms de fonction_sdaster ou fonction_c. + """ + class table_jeveux(table_sdaster): """Classe permettant d'accéder à une table jeveux qui n'a pas d'ASSD associée, c'est le cas des concepts résultats (table, evol_xxxx) dérivés.""" @@ -1145,7 +1155,7 @@ class vect_elem_pres_c(vect_elem):pass class vect_elem_pres_r(vect_elem):pass class vect_elem_temp_r(vect_elem):pass -#& MODIF COMMUN DATE 09/05/2006 AUTEUR JMBHH01 J.M.PROIX +#& MODIF COMMUN DATE 07/11/2006 AUTEUR MARKOVIC D.MARKOVIC # CONFIGURATION MANAGEMENT OF EDF VERSION # RESPONSABLE JMBHH01 J.M.PROIX # ====================================================================== @@ -1172,6 +1182,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VISC_ISOT_TRAC", "VMIS_ISOT_LINE", "VISC_ISOT_LINE", + "VMIS_ISOT_PUIS", "VMIS_ECMI_TRAC", "VMIS_ECMI_LINE", "LABORD_1D", @@ -1215,7 +1226,6 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VMIS_CIN2_CHAB", "VISC_CIN1_CHAB", "VISC_CIN2_CHAB", - "POLY_CFC", "LMARC", "LMARC_IRRA", "ROUSSELIER", @@ -1268,7 +1278,8 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VMIS_ASYM_LINE", "ELAS_THER", "KIT_DDI", - "GLRC", + "GLRC_DAMAGE", + "GLRC_DM", "SANS", "CORR_ACIER", "MONOCRISTAL", @@ -1284,6 +1295,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# VISC_ISOT_TRAC =SIMP(statut='c',typ='I',defaut=3,into=(3,)), VMIS_ISOT_LINE =SIMP(statut='c',typ='I',defaut=2,into=(2,)), VISC_ISOT_LINE =SIMP(statut='c',typ='I',defaut=3,into=(3,)), + VMIS_ISOT_PUIS =SIMP(statut='c',typ='I',defaut=2,into=(2,)), VMIS_ECMI_TRAC =SIMP(statut='c',typ='I',defaut=8,into=(8,)), VMIS_ECMI_LINE =SIMP(statut='c',typ='I',defaut=8,into=(8,)), LABORD_1D =SIMP(statut='c',typ='I',defaut=5,into=(5,)), @@ -1291,7 +1303,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# ENDO_ISOT_BETON =SIMP(statut='c',typ='I',defaut=2,into=(2,)), ENDO_ORTH_BETON =SIMP(statut='c',typ='I',defaut=7,into=(7,)), BETON_REGLE_PR =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - MAZARS =SIMP(statut='c',typ='I',defaut=3,into=(3,)), + MAZARS =SIMP(statut='c',typ='I',defaut=4,into=(4,)), JOINT_BA =SIMP(statut='c',typ='I',defaut=6,into=(6,)), RUPT_FRAG =SIMP(statut='c',typ='I',defaut=1,into=(1,)), CZM_EXP_REG =SIMP(statut='c',typ='I',defaut=4,into=(4,)), @@ -1326,7 +1338,6 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# VMIS_CIN2_CHAB =SIMP(statut='c',typ='I',defaut=14,into=(14,)), VISC_CIN1_CHAB =SIMP(statut='c',typ='I',defaut=8,into=(8,)), VISC_CIN2_CHAB =SIMP(statut='c',typ='I',defaut=14,into=(14,)), - POLY_CFC =SIMP(statut='c',typ='I',defaut=1688,into=(1688,)), LMARC =SIMP(statut='c',typ='I',defaut=20,into=(20,)), LMARC_IRRA =SIMP(statut='c',typ='I',defaut=20,into=(20,)), VISC_TAHERI =SIMP(statut='c',typ='I',defaut=9,into=(9,)), @@ -1378,7 +1389,8 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# KIT_THHM =SIMP(statut='c',typ='I',defaut=0,into=(0,)), VMIS_ASYM_LINE =SIMP(statut='c',typ='I',defaut=4,into=(4,)), BETON_UMLV_FP =SIMP(statut='c',typ='I',defaut=21,into=(21,)), - GLRC =SIMP(statut='c',typ='I',defaut=7,into=(7,)), + GLRC_DAMAGE =SIMP(statut='c',typ='I',defaut=21,into=(21,)), + GLRC_DM =SIMP(statut='c',typ='I',defaut=4,into=(4,)), GATT_MONERIE =SIMP(statut='c',typ='I',defaut=2,into=(2,)), b_monox = BLOC(condition = "RELATION == 'MONOCRISTAL' ", @@ -1429,6 +1441,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VMIS_ISOT_TRAC", "VMIS_ISOT_LINE", "VMIS_ISOT_CINE", + "VMIS_ISOT_PUIS", "GRANGER_FP", "GRANGER_FP_INDT", "GRANGER_FP_V", @@ -1454,7 +1467,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# ZIRC =SIMP(statut='c',typ='I',defaut=3,into=(3,)), DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT", - into=("PETIT","PETIT_REAC","SIMO_MIEHE","GREEN_GR","GREEN","COROTATIONNEL")), + into=("PETIT","PETIT_REAC","SIMO_MIEHE","GREEN_GR","GREEN","COROTATIONNEL","REAC_GEOM")), ALGO_C_PLAN =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)), ALGO_1D =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)), regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), @@ -1466,8 +1479,9 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# 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")), + PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ), ) ; -#& MODIF COMMUN DATE 04/04/2006 AUTEUR CIBHHLV L.VIVAN +#& MODIF COMMUN DATE 07/11/2006 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -1492,6 +1506,8 @@ 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", @@ -1525,8 +1541,12 @@ def C_NOM_CHAM_INTO() : return ("ACCE", #COMMUN# "ENEL_ELNO_ELGA", "ENEL_NOEU_ELGA", "EPEQ_ELNO_TUYO", - "EPGR_ELGA", - "EPGR_ELNO", + "EPVC_ELGA", + "EPVC_ELNO", + "EPFD_ELGA", + "EPFD_ELNO", + "EPFP_ELGA", + "EPFP_ELNO", "EPME_ELGA_DEPL", "EPME_ELNO_DEPL", "EPMG_ELGA_DEPL", @@ -1655,6 +1675,58 @@ def C_NOM_CHAM_INTO() : return ("ACCE", #COMMUN# "VITE_ABSOLU", "VITE_VENT", ) +#& 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 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 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","VITE","ENDO","NORM","EPAIS", + "NEUT1","NEUT2",) #& MODIF COMMUN DATE 04/04/2006 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -1801,59 +1873,7 @@ def C_NOM_GRANDEUR() : return ( #COMMUN# "WEIBULL", "XCONTAC", ) -#& 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 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","VITE","ENDO","NORM","EPAIS", - "NEUT1","NEUT2",) -#& 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 09/05/2006 AUTEUR JMBHH01 J.M.PROIX +#& MODIF COMMANDE DATE 19/09/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -1980,6 +2000,7 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), EPAIS =SIMP(statut='o',typ='R' ), 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='c',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 ), @@ -2013,99 +2034,127 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, # affection des caractéristiques de RIGIDITE/AMORTISSEMENT b_K_T_D_N =BLOC(condition = "(CARA=='K_T_D_N')or(CARA=='A_T_D_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=3 ,max=3 ),), + VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),), b_K_T_D_L =BLOC(condition = "(CARA=='K_T_D_L')or(CARA=='A_T_D_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=3 ,max=3 ),), + VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),), b_K_TR_D_N =BLOC(condition = "(CARA=='K_TR_D_N')or(CARA=='A_TR_D_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=6 ,max=6 ),), + VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),), b_K_TR_D_L =BLOC(condition = "(CARA=='K_TR_D_L')or(CARA=='A_TR_D_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=6 ,max=6 ),), + VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),), b_K_T_N =BLOC(condition = "(CARA=='K_T_N')or(CARA=='A_T_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=6 ,max=6 ),), + VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),), b_K_T_L =BLOC(condition = "(CARA=='K_T_L')or(CARA=='A_T_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=21,max=21),), + VALE =SIMP(statut='f',typ='R',min=21,max=21), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),), b_K_TR_N =BLOC(condition = "(CARA=='K_TR_N')or(CARA=='A_TR_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=21,max=21),), + VALE =SIMP(statut='f',typ='R',min=21,max=21), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),), b_K_TR_L =BLOC(condition = "(CARA=='K_TR_L')or(CARA=='A_TR_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=78,max=78),), + 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'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=1 ,max=1 ),), + 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'excentricité", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=10,max=10),), + VALE =SIMP(statut='f',typ='R',min=10,max=10), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),), b_M_T_N =BLOC(condition = "CARA=='M_T_N'", fr="NOEUD: 6 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=6 ,max=6 ),), + VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),), b_M_T_L =BLOC(condition = "CARA=='M_T_L'", fr="SEGMENT: 21 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=21,max=21),), + VALE =SIMP(statut='f',typ='R',min=21,max=21), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),), b_M_TR_N =BLOC(condition = "CARA=='M_TR_N'", fr="NOEUD: 21 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=21,max=21),), + VALE =SIMP(statut='f',typ='R',min=21,max=21), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),), b_M_TR_L =BLOC(condition = "CARA=='M_TR_L'", fr="SEGMENT: 78 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=78,max=78),), + VALE =SIMP(statut='f',typ='R',min=78,max=78), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=78 ,max=78 ),), ), #============================================================================ @@ -2123,99 +2172,127 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, # affection des caractéristiques de RIGIDITE/AMORTISSEMENT b_K_T_D_N =BLOC(condition = "(CARA=='K_T_D_N')or(CARA=='A_T_D_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=2 ,max=2 ),), + VALE =SIMP(statut='f',typ='R',min=2 ,max=2 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=2 ,max=2 ),), b_K_T_D_L =BLOC(condition = "(CARA=='K_T_D_L')or(CARA=='A_T_D_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=2 ,max=2 ),), + VALE =SIMP(statut='f',typ='R',min=2 ,max=2 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=2 ,max=2 ),), b_K_TR_D_N =BLOC(condition = "(CARA=='K_TR_D_N')or(CARA=='A_TR_D_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=3 ,max=3 ),), + VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),), b_K_TR_D_L =BLOC(condition = "(CARA=='K_TR_D_L')or(CARA=='A_TR_D_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=3 ,max=3 ),), + VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),), b_K_T_N =BLOC(condition = "(CARA=='K_T_N')or(CARA=='A_T_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=3 ,max=3 ),), + VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),), b_K_T_L =BLOC(condition = "(CARA=='K_T_L')or(CARA=='A_T_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=10,max=10),), + VALE =SIMP(statut='f',typ='R',min=10,max=10), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),), b_K_TR_N =BLOC(condition = "(CARA=='K_TR_N')or(CARA=='A_TR_N')", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=6 ,max=6),), + VALE =SIMP(statut='f',typ='R',min=6 ,max=6), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),), b_K_TR_L =BLOC(condition = "(CARA=='K_TR_L')or(CARA=='A_TR_L')", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=21,max=21),), + 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'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=1 ,max=1 ),), + 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'excentricité(ex,ey) ", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=4 ,max=4 ),), + VALE =SIMP(statut='f',typ='R',min=4 ,max=4 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=4 ,max=4 ),), b_M_T_N =BLOC(condition = "CARA=='M_T_N'", fr="NOEUD: 3 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=3 ,max=3 ),), + VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),), b_M_T_L =BLOC(condition = "CARA=='M_T_L'", fr="SEGMENT: 10 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=10,max=10),), + VALE =SIMP(statut='f',typ='R',min=10,max=10), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),), b_M_TR_N =BLOC(condition = "CARA=='M_TR_N'", fr="NOEUD: 6 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),), + regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=6 ,max=6 ),), + VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),), b_M_TR_L =BLOC(condition = "CARA=='M_TR_L'", fr="SEGMENT: 21 valeurs de masse (triangulaire supérieure par colonne)", - regles=(UN_PARMI('MAILLE','GROUP_MA'),), + regles=(UN_PARMI('MAILLE','GROUP_MA'), + AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('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='o',typ='R',min=21,max=21),), + VALE =SIMP(statut='f',typ='R',min=21,max=21), + VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),), ), #============================================================================ @@ -2267,17 +2344,20 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, #============================================================================ MASSIF =FACT(statut='f',max='**', regles=(UN_PARMI('MAILLE','GROUP_MA'), - UN_PARMI('ANGL_REP','ANGL_AXE'), + 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'),), @@ -2633,7 +2713,7 @@ AFFE_CHAR_CINE_F=OPER(nom="AFFE_CHAR_CINE_F",op= 108,sd_prod=affe_char_cine_f_pr ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 03/05/2006 AUTEUR MABBAS M.ABBAS +#& MODIF COMMANDE DATE 28/08/2006 AUTEUR CIBHHPD L.SALMONA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -2661,10 +2741,9 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 'PRES_REP','FORCE_POUTRE','FORCE_COQUE','LIAISON_OBLIQUE', 'FORCE_ELEC','INTE_ELEC','PESANTEUR','ROTATION','IMPE_FACE', 'VITE_FACE','TEMP_CALCULEE','RELA_CINE_BP','EPSI_INIT','CONTACT', - 'LIAISON_GROUP','LIAISON_UNIF','FLUX_THM_REP', - 'LIAISON_SOLIDE','LIAISON_ELEM','ONDE_FLUI', - 'EPSA_CALCULEE','LIAISON_CHAMNO','VECT_ASSE','LIAISON_COQUE', - 'LIAISON_MAIL','LIAISON_CYCL','FORCE_TUYAU','SECH_CALCULEE', + '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','GRAPPE_FLUIDE', 'LIAISON_UNILATER'), ), @@ -2672,10 +2751,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, MODELE =SIMP(statut='o',typ=(modele_sdaster) ), TEMP_CALCULEE =SIMP(statut='f',fr="Champ de température issu d'un autre calcul", typ=(evol_ther,cham_no_sdaster,carte_sdaster) ), - SECH_CALCULEE =SIMP(statut='f',fr="Champ de séchage issu d'un autre calcul", - typ=(evol_ther,cham_no_sdaster,carte_sdaster ) ), - EPSA_CALCULEE =SIMP(statut='f',fr="Champ de déformation anélastique issu d'un autre calcul", - typ=evol_noli ), EVOL_CHAR =SIMP(statut='f',fr="Champ de pression issu d'un autre calcul", typ=evol_char ), @@ -3025,7 +3100,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, fr="Définit les zones soumises à des conditions de contact unilatéral avec ou sans frottement", regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),), APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", - into=("NON","NODAL","MAIT_ESCL","MAIT_ESCL_SYME")), + into=("RIGIDE","NODAL","MAIT_ESCL","MAIT_ESCL_SYME")), RECHERCHE =SIMP(statut='f',typ='TXM',defaut="NOEUD_BOUCLE", into=("NOEUD_BOUCLE","NOEUD_VOISIN")), LISSAGE =SIMP(statut='f',typ='TXM',defaut="NON", @@ -3041,7 +3116,8 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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='**'), + MAILLE_ESCL =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + b_cara =BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'", CARA_ELEM =SIMP(statut='o',typ=(cara_elem) ), ), @@ -3059,10 +3135,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, b_active =BLOC(condition = "METHODE == 'CONTRAINTE' ", fr="Paramètres de la méthode des contraintes actives (contact uniquement)", - regles=(EXCLUS('DIST_ESCL','COEF_IMPO'), - EXCLUS('DIST_MAIT','COEF_IMPO'),), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","PRES","TEMP","PRE1","PRE2")), GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ", @@ -3089,8 +3161,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - COEF_IMPO =SIMP(statut='f',typ='R'), - COEF_MULT_ESCL =SIMP(statut='f',typ='R'), VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3), VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3), DIST_MAIT =SIMP(statut='f',typ='R'), @@ -3099,7 +3169,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, ), b_lagrangien =BLOC(condition = "METHODE == 'LAGRANGIEN' ", fr="Paramètres de la méthode Lagrangienne (contact avec ou sans frottement)", - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)), FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ), TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), TOLE_PROJ_INT =SIMP(statut='f',typ='R' ,defaut=0.001), @@ -3138,7 +3207,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, b_penalisation =BLOC(condition = "METHODE == 'PENALISATION' ", fr="Paramètres de la méthode pénalisée (contact avec ou sans frottement)", - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)), E_N =SIMP(statut='f',typ='R'), FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ), TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), @@ -3178,7 +3246,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, b_continue =BLOC(condition = "METHODE == 'CONTINUE' ", fr="Paramètres de la méthode continue (contact avec ou sans frottement)", # regles=(UN_PARMI('GLISSIERE','FROTTEMENT'),), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE")), GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ", @@ -3186,6 +3253,9 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, ), FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ), COMPLIANCE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), + FOND_FISSURE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), + RACCORD_LINE_QUAD=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ), + INTEGRATION =SIMP(statut='f',typ='TXM',defaut="NOEUD",into=("GAUSS","NOEUD","SIMPSON","SIMPSON1","SIMPSON2", "NCOTES","NCOTES1","NCOTES2")), COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), @@ -3199,6 +3269,17 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3), TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), CONTACT_INIT =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='**'),), + 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='**'),), + b_compliance =BLOC(condition = "COMPLIANCE == 'OUI' ",fr="Parametres de la compliance", ASPERITE =SIMP(statut='o',typ='R',), E_N =SIMP(statut='o',typ='R',), @@ -3215,10 +3296,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, b_gcp =BLOC(condition = "METHODE == 'GCP' ", fr="Paramètres de la méthode du gradient conjugué projeté (contact uniquement)", - regles=(EXCLUS('DIST_ESCL','COEF_IMPO'), - EXCLUS('DIST_MAIT','COEF_IMPO'),), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","PRES","TEMP","PRE1","PRE2")), 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=3, fr="Fréquence de réinitialisation de la conjugaison"), @@ -3249,8 +3326,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - COEF_IMPO =SIMP(statut='f',typ='R'), - COEF_MULT_ESCL =SIMP(statut='f',typ='R'), VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3), VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3), DIST_MAIT =SIMP(statut='f',typ='R'), @@ -3738,7 +3813,7 @@ AFFE_CHAR_MECA_C=OPER(nom="AFFE_CHAR_MECA_C",op= 7,sd_prod=char_meca, ), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 03/05/2006 AUTEUR MABBAS M.ABBAS +#& MODIF COMMANDE DATE 17/10/2006 AUTEUR CIBHHPD L.SALMONA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -3860,11 +3935,12 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, 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'),), + 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='o',typ='R',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) ), ), @@ -3950,7 +4026,7 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, +" sont données par l'intermédiaire de concept fonction",max='**', regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),), APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", - into=("NON","NODAL","MAIT_ESCL","MAIT_ESCL_SYME")), + into=("NODAL","MAIT_ESCL","MAIT_ESCL_SYME")), RECHERCHE =SIMP(statut='f',typ='TXM',defaut="NOEUD_BOUCLE",into=("NOEUD_BOUCLE","NOEUD_VOISIN")), LISSAGE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), DIST_POUTRE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), @@ -3980,10 +4056,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, b_active =BLOC(condition = "METHODE == 'CONTRAINTE' ", fr="Paramètres de la méthode des contraintes actives (contact uniquement)", - regles=(EXCLUS('DIST_ESCL','COEF_IMPO'), - EXCLUS('DIST_MAIT','COEF_IMPO'),), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","PRES","TEMP","PRE1","PRE2")), GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ", @@ -4011,8 +4083,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - COEF_IMPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - COEF_MULT_ESCL =SIMP(statut='f',typ='R'), VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3), VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3), DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -4020,7 +4090,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, ), b_lagrangien =BLOC(condition = "METHODE == 'LAGRANGIEN' ", fr="Paramètres de la méthode Lagrangienne (contact avec ou sans frottement)", - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)), FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ), TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), TOLE_PROJ_INT =SIMP(statut='f',typ='R' ,defaut=0.001), @@ -4055,7 +4124,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, ),), b_penalisation =BLOC(condition = "METHODE == 'PENALISATION' ", fr="Paramètres de la méthode pénalisée (contact avec ou sans frottement)", - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)), E_N =SIMP(statut='f',typ='R'), FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ), TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50), @@ -4092,7 +4160,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, b_continue =BLOC(condition = "METHODE == 'CONTINUE' ", fr="Paramètres de la méthode continue (contact avec ou sans frottement)", # regles=(UN_PARMI('GLISSIERE','FROTTEMENT'),), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)), GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")), b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ", @@ -4127,10 +4194,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, b_gcp =BLOC(condition = "METHODE == 'GCP' ", fr="Paramètres de la méthode du gradient conjugué projeté (contact uniquement)", - regles=(EXCLUS('DIST_ESCL','COEF_IMPO'), - EXCLUS('DIST_MAIT','COEF_IMPO'),), - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL", - into=("DEPL","PRES","TEMP","PRE1","PRE2")), 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=3, fr="Fréquence de réinitialisation de la conjugaison"), @@ -4161,8 +4224,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")), - COEF_IMPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - COEF_MULT_ESCL =SIMP(statut='f',typ='R'), VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3), VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3), DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), @@ -4868,7 +4929,7 @@ AFFE_CHAR_THER_F=OPER(nom="AFFE_CHAR_THER_F",op=33,sd_prod=char_ther, INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 25/04/2006 AUTEUR CIBHHPD L.SALMONA +#& MODIF COMMANDE DATE 28/08/2006 AUTEUR CIBHHPD L.SALMONA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -4894,8 +4955,8 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, MAILLAGE =SIMP(statut='o',typ=maillage_sdaster), MODELE =SIMP(statut='f',typ=modele_sdaster), - # affectation du nom du matériau : - # ------------------------------- + # 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",) ), @@ -4903,41 +4964,53 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), MATER =SIMP(statut='o',typ=mater_sdaster,max=30), TEMP_REF =SIMP(statut='f',typ='R',defaut= 0.E+0 ), - SECH_REF =SIMP(statut='f',typ='R',val_min=0.E+0), + ), + + # affectation du nom du matériau (par noeuds): + # ---------------------------------------------- + AFFE_NOEUD =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='**'), + MATER =SIMP(statut='o',typ=mater_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=("CORR","IRRA","HYDR","NEUT1","NEUT2")), + LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("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'), - UN_PARMI('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='**'), - - CHAMP_GD =SIMP(statut='f',typ=cham_gd_sdaster,), - B_CHAMP_GD =BLOC(condition="CHAMP_GD!=None", - NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","NEUT1","NEUT2")), - ), - EVOL =SIMP(statut='f',typ=evol_sdaster,), - B_EVOL =BLOC(condition="EVOL!=None", - NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","NEUT1","NEUT2")), - B_NOM_CORR =BLOC(condition="NOM_VARC=='CORR'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'CORR',),), - B_NOM_IRRA =BLOC(condition="NOM_VARC=='IRRA'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'IRRA',),), - B_NOM_HYDR =BLOC(condition="NOM_VARC=='HYDR'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'HYDR_ELNO_ELGA',),), - B_NOM_NEUT1 =BLOC(condition="NOM_VARC=='NEUT1'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),), - B_NOM_NEUT2 =BLOC(condition="NOM_VARC=='NEUT2'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),), - 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") ), - ), - VALE_REF =SIMP(statut='f',typ='R'), + regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'), + PRESENT_ABSENT('GROUP_MA','TOUT'), + PRESENT_ABSENT('MAILLE','TOUT'), + UN_PARMI('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='**'), + + CHAMP_GD =SIMP(statut='f',typ=cham_gd_sdaster,), + B_CHAMP_GD =BLOC(condition="CHAMP_GD!=None", + NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC","EPSA","NEUT1","NEUT2")), + ), + EVOL =SIMP(statut='f',typ=evol_sdaster,), + B_EVOL =BLOC(condition="EVOL!=None", + NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC","EPSA","NEUT1","NEUT2")), + B_NOM_CORR =BLOC(condition="NOM_VARC=='CORR'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'CORR',),), + B_NOM_IRRA =BLOC(condition="NOM_VARC=='IRRA'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'IRRA',),), + B_NOM_HYDR =BLOC(condition="NOM_VARC=='HYDR'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'HYDR_ELNO_ELGA',),), + B_NOM_SECH =BLOC(condition="NOM_VARC=='SECH'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'TEMP',),), + B_NOM_EPSA =BLOC(condition="NOM_VARC=='EPSA'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'EPSA_ELNO',),), + B_NOM_M_ACIER =BLOC(condition="NOM_VARC=='M_ACIER'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'META_ELNO_TEMP',),), + B_NOM_M_ZIRC =BLOC(condition="NOM_VARC=='M_ZIRC'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'META_ELNO_TEMP',),), + B_NOM_NEUT1 =BLOC(condition="NOM_VARC=='NEUT1'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),), + B_NOM_NEUT2 =BLOC(condition="NOM_VARC=='NEUT2'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),), + 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") ), + ), + VALE_REF =SIMP(statut='f',typ='R'), ), # mots clés cachés pour les variables de commande NEUTi : @@ -5009,13 +5082,149 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, 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=("EPXX","EPYY","EPZZ","EPXY","EPXZ","EPYZ",)), + CMP_VARC =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPSAXX","EPSAYY","EPSAZZ","EPSAXY","EPSAXZ","EPSAYZ",)), VALE_DEF =SIMP(statut='c',typ='R',max=6,min=6,defaut=( 0., 0., 0., 0., 0., 0., )), ), + # 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",)), + VALE_DEF =SIMP(statut='c',typ='R',max=7,min=7,defaut=( 0., 0., 0., 0., 0., 0., 0. )), + ), + # 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=3,min=3,defaut=("V1","V2","V3")), + CMP_VARC =SIMP(statut='c',typ='TXM',max=3,min=3,defaut=("ALPHPUR","ALPHBETA","TZIRC",)), + VALE_DEF =SIMP(statut='c',typ='R',max=3,min=3,defaut=( 0., 0., 0. )), + ), ) ; -#& MODIF COMMANDE DATE 09/05/2006 AUTEUR JMBHH01 J.M.PROIX +#& MODIF COMMANDE DATE 22/06/2005 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. +# ====================================================================== +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 19/06/2006 AUTEUR VABHHTS 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. +# ====================================================================== +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'), + UNITE =SIMP(statut='f',typ='I',defaut=15), + ), + 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'),defaut='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',)), + ), + MEMOIRE =FACT(fr="mode de gestion mémoire utilisé",statut='f',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'), + ), + RESERVE_CPU =FACT(fr="reserve de temps pour terminer une execution",statut='f',max=1, + regles=(EXCLUS('VALE','POURCENTAGE'),), + VALE =SIMP(statut='f',typ='I',val_min=0), + POURCENTAGE =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0), +# valeur en pourcentage du temps maximum bornée à 180 secondes + BORNE =SIMP(statut='f',typ='I',val_min=0,defaut=180) + ), + ); +#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -5042,9 +5251,9 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_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") ), AFFE_SOUS_STRUC =FACT(statut='f', - regles=(UN_PARMI('TOUT','MAILLE'),), + regles=(UN_PARMI('TOUT','SUPER_MAILLE'),), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), + 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='**', @@ -5057,7 +5266,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, PHENOMENE =SIMP(statut='o',typ='TXM', into=("MECANIQUE","THERMIQUE","ACOUSTIQUE") ), b_mecanique =BLOC( condition = "PHENOMENE=='MECANIQUE'", - fr="modelisations mécaniques", + fr="modélisations mécaniques", MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=( "2D_DIS_T", "2D_DIS_TR", @@ -5071,7 +5280,6 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "3D_FLUI_ABSO", "3D_FLUIDE", "3D_INCO", - "3D_JOINT_CT", "3D_SI", "3D_GRAD_EPSI", "3D_GRAD_VARI", @@ -5152,6 +5360,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "D_PLAN_THH2MS", "D_PLAN_THHMS", "D_PLAN_THMS", + "D_PLAN_HM_P", "AXIS_THH", "AXIS_THHM", "AXIS_THM", @@ -5199,11 +5408,10 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "3D_HH2MS", "3D_THH2S", "3D_THH2D", - ) ) ), b_thermique =BLOC( condition = "PHENOMENE=='THERMIQUE'", - fr="modelisations thermiques", + fr="modélisations thermiques", MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=( "3D", "3D_DIAG", @@ -5218,7 +5426,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, ),),), b_acoustique =BLOC( condition = "PHENOMENE=='ACOUSTIQUE'", - fr="modelisations acoustiques", + fr="modélisations acoustiques", MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=( "3D", "PLAN" @@ -5244,39 +5452,6 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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 22/06/2005 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 VABHHTS J.PELLET ASSE_MAILLAGE=OPER(nom="ASSE_MAILLAGE",op= 105,sd_prod=maillage_sdaster, fr="Assembler deux maillages pour en former un nouveau", @@ -5604,7 +5779,7 @@ CALC_CHAR_SEISME=OPER(nom="CALC_CHAR_SEISME",op= 92,sd_prod=calc_char_seisme_pr ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 07/11/2006 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -5636,7 +5811,7 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,mode_meca, mode_stat,mode_stat_depl,mode_stat_acce,mode_stat_forc, - evol_noli,mult_elas,fourier_elas, + evol_noli,mult_elas,fourier_elas,fourier_ther, evol_ther,base_modale, acou_harmo,mode_acou,mode_flamb) , fr="Résultat d'une commande globale"), @@ -5665,7 +5840,33 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**', fr="le calcul ne sera effectué que sur ces mailles là"), -# options pour des resultats lineaire +# 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,\ mode_stat,mode_stat_depl,mode_stat_acce,mode_stat_forc,\ @@ -5673,17 +5874,18 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', 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_ERRE","AUTRES","TOUTES"), + "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", + "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", @@ -5702,15 +5904,8 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', # autres "VNOR_ELEM_DEPL","VALE_NCOU_MAXI","PRES_DBEL_DEPL"),), - 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 en degres à partir de la génératrice"), 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", ), - PLAN = SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL"), - fr="Plan de calcul pour les plaques excentrées" ), 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 \ @@ -5781,53 +5976,15 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),), ), - b_niv_couche = BLOC( condition = "OPTION in ('SIGM_ELNO_DEPL',) or \ - (type(OPTION)==type(()) and 'SIGM_ELNO_DEPL' in OPTION) ", - - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ), - 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" ), - ), - b_sigtuyo = BLOC( condition = "OPTION == 'SIGM_ELNO_TUYO' or \ - (type(OPTION)==type(()) and 'SIGM_ELNO_TUYO' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1 , - fr="numero de couche dans l'épaisseur du tuyau" ), - ANGLE =SIMP(statut='f',typ='I',defaut= 0,fr="angle en degres à partir de la génératrice" ), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="position dans l'épaisseur de la couche" ), - ), - b_plan_excentrement =BLOC( condition = "OPTION=='EFGE_ELNO_DEPL' or \ - (type(OPTION)==type(()) and 'EFGE_ELNO_DEPL' in OPTION)", - fr="Plan de calcul des efforts pour les plaques avec excentrement", - PLAN = SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL"), - fr="Plan de calcul des efforts pour les plaques avec excentrement",), - - ), ), # 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",), + "DEGE_ELNO_DEPL","EPSI_ELNO_TUYO","EPVC_ELNO","EPVC_ELGA",), ), - b_niv_couche = BLOC( condition = "OPTION =='EPSI_ELNO_DEPL' or \ - (type(OPTION)==type(()) and 'EPSI_ELNO_DEPL' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ), - 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" ), - ) , - b_epstuyo = BLOC( condition = "OPTION == 'EPSI_ELNO_TUYO' or \ - (type(OPTION)==type(()) and 'EPSI_ELNO_TUYO' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1 , - fr="numero de couche dans l'épaisseur du tuyau" ), - ANGLE =SIMP(statut='f',typ='I',defaut= 0,fr="angle en degres à partir de la génératrice" ), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="position dans l'épaisseur de la couche" ), - ), 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 \ @@ -5862,15 +6019,6 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ "ENDO_ELGA","ENDO_ELNO_ELGA", "ENDO_ELNO_SIGA","ENDO_ELNO_SINO","CRIT_ELNO_RUPT","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO", ) ), - b_niv_couche = BLOC( condition = "OPTION in ('CRIT_ELNO_RUPT','EQUI_ELNO_SIGM') or \ - (type(OPTION)==type(()) and 'EQUI_ELNO_SIGM' in OPTION) or \ - (type(OPTION)==type(()) and 'SIEQ_ELNO_TUYO' in OPTION) or \ - (type(OPTION)==type(()) and 'CRIT_ELNO_RUPT' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ), - 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" ), - ), EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),), ), @@ -5890,7 +6038,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ NOM_CMP =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),), ), - b_indi_erre =BLOC( condition = "TYPE_OPTION=='INDI_ERRE'", + 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", @@ -5907,7 +6055,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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.,val_max=1., - fr="precision demandee pour calculer la de taille des elements" ),), + fr="precision demandee pour calculer la carte de taille des elements" ),), EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),), @@ -5920,19 +6068,20 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ b_noli =BLOC( condition = "AsType(RESULTAT) == evol_noli",fr="options evol noli", TYPE_OPTION =SIMP(statut='f',typ='TXM',defaut='TOUTES', into=("SIGM_MASSIF","SIGM_STRUCT","EPSI","ENER","CRIT", - "VARI","INDI_ERRE","TOUTES","AUTRES"), + "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", + "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", - "EPGR_ELNO","EPGR_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 @@ -5950,13 +6099,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ into=("VMIS","TOTAL","VMIS_CINE","TOTAL_CINE"), fr="Type de norme pour les options RADI_ et DCHA_"), - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,fr="numéro de couche pour coques et tuyaux" ), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="choix du point d'intégration dans la couche" ), - ANGLE =SIMP(statut='f',typ='I',defaut= 0 ,fr="angle de dépouillement pour les tuyaux"), 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"), - PLAN = SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL") ), 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 \ @@ -6001,48 +6145,20 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ # contraintes into=( "SIEF_ELNO_ELGA","EFGE_ELNO_CART","SIGM_ELNO_TUYO","SIGM_ELNO_COQU", "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF",),), - b_sigcoqu = BLOC( condition = "OPTION in ('SIGM_ELNO_COQU',) or \ - (type(OPTION)==type(()) and 'SIGM_ELNO_COQU' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numéro de couche dans l'épaisseur de la coque" ), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="choix du point d'intégration dans la couche" ), - ), - b_sigtuyo = BLOC( condition = "OPTION in ('SIGM_ELNO_TUYO',) or \ - (type(OPTION)==type(()) and 'SIGM_ELNO_TUYO' in OPTION)", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numéro de couche dans l'épaisseur du tuyau" ), - ANGLE =SIMP(statut='f',typ='I',defaut= 0, - fr="angle de dépouillement pour les tuyaux, en degres" ), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="choix du point d'intégration dans la couche"), - ), ), 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","EPGR_ELNO","EPGR_ELGA", - "DEGE_ELNO_DEPL",), + "EPSP_ELNO","EPSP_ELGA","DEGE_ELNO_DEPL","EPVC_ELNO","EPVC_ELGA", + "EPFD_ELNO","EPFD_ELGA","EPFP_ELNO","EPFP_ELGA"), ), - b_niv_couche = BLOC( condition = "OPTION =='EPSI_ELNO_DEPL' or \ - (type(OPTION)==type(()) and 'EPSI_ELNO_DEPL' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ), - 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" ), - ) , 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 \ + b_epstuyo =BLOC( condition = "OPTION == 'EPSI_ELNO_TUYO' or \ (type(OPTION)==type(()) and 'EPSI_ELNO_TUYO' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1 , - fr="numero de couche dans l'épaisseur du tuyau" ), - ANGLE =SIMP(statut='f',typ='I',defaut= 0,fr="angle en degres à partir de la génératrice" ), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="position dans l'épaisseur de la couche" ), EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures", CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),), ), @@ -6053,24 +6169,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ into=("VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU", "EXTR_ELGA_VARI","EXTR_ELNO_VARI"), ), - b_varcoqu = BLOC( condition = "OPTION in ('VARI_ELNO_COQU',) or \ - (type(OPTION)==type(()) and 'VARI_ELNO_COQU' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numéro de couche dans l'épaisseur de la coque"), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="choix du point d'intégration dans la couche" ), - ), - b_vartuyo = BLOC( condition = "OPTION in ('VARI_ELNO_TUYO',) or \ - (type(OPTION)==type(()) and 'VARI_ELNO_TUYO' in OPTION) ", - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1, - fr="numéro de couche dans l'épaisseur de tuyau" ), - ANGLE =SIMP(statut='f',typ='I',defaut= 0, - fr="angle de dépouillement pour les tuyaux, en degres"), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="choix du point d'intégration dans la couche" ), - ), - 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", + 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"),), @@ -6093,9 +6193,6 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ "ENDO_ELGA","ENDO_ELNO_ELGA", "PMPB_ELNO_SIEF","PMPB_ELGA_SIEF","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO", ) ), - NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,fr="numéro de couche dans l'épaisseur de la coque"), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="choix du point d'intégration dans la couche" ), ), b_autres =BLOC( condition = "TYPE_OPTION=='AUTRES'", @@ -6108,7 +6205,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ ), - b_indi_erre =BLOC( condition = "TYPE_OPTION=='INDI_ERRE'", + 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", @@ -6138,8 +6235,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ ), # fin bloc evol_noli -# thermique : evol_ther - b_ther =BLOC( condition = "AsType(RESULTAT) == evol_ther",fr="options thermiques", +# 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", @@ -6155,9 +6252,6 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ PUIS_PULS =SIMP(statut='f',typ='I'), TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),), ), - NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"), - fr="choix du point de calcul dans l'épaisseur des coques" ), - ), # acoustique @@ -6184,7 +6278,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 16/10/2006 AUTEUR JMBHH01 J.M.PROIX # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -6249,13 +6343,19 @@ CALC_FATIGUE=OPER(nom="CALC_FATIGUE",op= 151,sd_prod=calc_fatigue_prod,reentrant 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","DANG_VAN_MODI_AC") ), - METHODE =SIMP(statut='o',typ='TXM',into=("CERCLE_EXACT",) ), + 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=("DOMM_MAXI","DANG_VAN_MODI_AV","FATEMI_SOCIE") ), - PROJECTION =SIMP(statut='o',typ='TXM',into=("UN_AXE", "DEUX_AXES") ), - DELTA_OSCI =SIMP(statut='f',typ='R',defaut= 0.0E+0), + 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), + ), ), b_fati_grmano =BLOC(condition = "(GROUP_MA != None or MAILLE != None or GROUP_NO != None or NOEUD != None)", MAILLAGE =SIMP(statut='o',typ=maillage_sdaster ), @@ -6366,7 +6466,7 @@ CALC_FONC_INTERP=OPER(nom="CALC_FONC_INTERP",op= 134,sd_prod=calc_fonc_interp_pr TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ), ) ; -#& MODIF COMMANDE DATE 19/09/2005 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 07/11/2006 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -6462,7 +6562,7 @@ CALC_FONCTION=MACRO(nom="CALC_FONCTION",op=calc_fonction_ops,sd_prod=calc_foncti 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',defaut= 9.81E+0,fr="Valeur de la norme du spectre d oscillateur" ), + 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") ), ), @@ -6593,7 +6693,7 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene, ), ) ; -#& MODIF COMMANDE DATE 29/05/2006 AUTEUR GALENNE E.GALENNE +#& MODIF COMMANDE DATE 31/10/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG @@ -6611,129 +6711,164 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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=(UN_PARMI('RESULTAT','DEPL'), - PRESENT_PRESENT('VITE','ACCE'), - EXCLUS('COMP_ELAS','COMP_INCR'), - CONCEPT_SENSIBLE("ENSEMBLE"), - REUSE_SENSIBLE(), - DERIVABLE('RESULTAT'),), - MODELE =SIMP(statut='f',typ=modele_sdaster), - CHAM_MATER =SIMP(statut='f',typ=cham_mater), - 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), - regles=(EXCLUS('FOND_FISS','FISSURE'),), - b_theta =BLOC(condition="THETA == None",fr="calcul de theta", - regles=(UN_PARMI('R_INF','R_INF_FO'), - EXCLUS('MODULE','MODULE_FO'), - PRESENT_PRESENT('R_INF','R_SUP'), - PRESENT_PRESENT('R_INF_FO','R_SUP_FO'), ), - 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)), - ), - ), +from Macro.post_k_trans_ops import post_k_trans_ops - DEPL =SIMP(statut='f',typ=cham_no_sdaster), - VITE =SIMP(statut='f',typ=cham_no_sdaster), - ACCE =SIMP(statut='f',typ=cham_no_sdaster), - RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_noli,dyna_trans,mode_meca),), +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), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ), + + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), + TITRE =SIMP(statut='f',typ='TXM'), +) - b_extrac =BLOC(condition="RESULTAT != None",fr="extraction d un champ", - 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)", - PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - ), - ), - 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") ), - - COMP_ELAS =FACT(statut='f', - RELATION =SIMP(statut='f',typ='TXM',defaut="ELAS", - into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC") ), - ELAS =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), - ELAS_VMIS_LINE =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), - ELAS_VMIS_TRAC =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), - 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 =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), - VMIS_ISOT_TRAC =SIMP(statut='f',typ='I',defaut=2,into=(2,) ), - VMIS_ISOT_LINE =SIMP(statut='f',typ='I',defaut=2,into=(2,) ), - 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"),), - LISSAGE_G =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",into=("LEGENDRE","LAGRANGE","LAGRANGE_NO_NO"),), - ), +#& MODIF COMMANDE DATE 10/10/2006 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. +# ====================================================================== +# -*- coding: iso-8859-1 -*- - 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","G_LAGR","G_LAGR_GLOB"),), +from Macro.simu_point_mat_ops import simu_point_mat_ops - 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'), - ), +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(), + MATER =SIMP(statut='o',typ=mater_sdaster,max=30), + INCREMENT =FACT(statut='o', + LIST_INST =SIMP(statut='o',typ=listr8_sdaster), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + ), + NEWTON =FACT(statut='d', + PREDICTION =SIMP(statut='f',typ='TXM',into=("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=1), + REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0), ), - PROPAGATION =SIMP(statut='f',typ='R'), - THETA_LAGR =SIMP(statut='f',typ=theta_geom), - DIRE_THETA_LAGR =SIMP(statut='f',typ=cham_no_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"), - - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), -); -#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE + CONVERGENCE =FACT(statut='d', + regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),), + SIGM_REFE =SIMP(statut='f',typ='R'), + EPSI_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=50), + ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25), + ARRET =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), + ), + 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 ), + ), + 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) ), + ), + + + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), +) +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -6751,7 +6886,7 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_sdaster, +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",)}, @@ -6762,7 +6897,7 @@ CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_sdaster, 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) ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1 , 2) ), ) ; #& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -7069,7 +7204,7 @@ CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o', OPTION =SIMP(statut='f',typ='TXM' ,into=("META_ELNO_TEMP",) ), ) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 24/10/2006 AUTEUR SMICHEL S.MICHEL-PONNELLE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -7098,7 +7233,7 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='o', RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,acou_harmo,mode_meca, mode_acou,mode_stat,mode_stat_depl,mode_stat_acce, mode_stat_forc,evol_ther,evol_noli,base_modale, - mult_elas,fourier_elas,mode_flamb ) ), + mult_elas,fourier_elas,fourier_ther,mode_flamb ) ), SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', fr="Liste des paramètres de sensibilité.", ang="List of sensitivity parameters"), @@ -7136,6 +7271,7 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='o', "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", @@ -7173,280 +7309,23 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='o', GROUP_NO_RESU =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), NOEUD_RESU =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), ) ; -#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 21/02/2006 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 ASSIRE A.ASSIRE - -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 =FACT(statut='o', - LIST_INST =SIMP(statut='o',typ=listr8_sdaster), - INST_INIT =SIMP(statut='f',typ='R'), - INST_FIN =SIMP(statut='f',typ='R'), - PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ), - SUBD_PAS =SIMP(statut='f',typ='I',defaut=1), - SUBD_PAS_MINI =SIMP(statut='f',typ='R'), - COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0), - ), - - 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), - EVOL_NOLI =SIMP(statut='f',typ=evol_noli), - ), - RECH_LINEAIRE =FACT(statut='f', - RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ), - ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 3), - ), - 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), - ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25), - ARRET =SIMP(statut='f',typ='TXM',defaut="OUI"), - ), - ETAT_INIT =FACT(statut='f', - regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','SIGM','VARI','VARI_NON_LOCAL',), - EXCLUS('EVOL_NOLI','DEPL',), - EXCLUS('EVOL_NOLI','SIGM',), - EXCLUS('EVOL_NOLI','VARI',), - EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), - 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), - VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), - EVOL_NOLI =SIMP(statut='f',typ=evol_noli), - NUME_ORDRE =SIMP(statut='f',typ='I'), - INST =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") ), - NUME_DIDI =SIMP(statut='f',typ='I'), - INST_ETAT_INIT =SIMP(statut='f',typ='R'), - ), - SOLVEUR =FACT(statut='d', - METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), - 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","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 ), - ), - SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), - ), - SOLV_NON_LOCAL =FACT(statut='f', - METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), - 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") ), - ), - 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 ), - RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), - NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), - ), - EPS =SIMP(statut='f',typ='R',defaut= 0.E+0 ), - ), - LAGR_NON_LOCAL =FACT(statut='f', - ITER_DUAL_MAXI =SIMP(statut='f',typ='I',defaut= 50), - RESI_DUAL_ABSO =SIMP(statut='o',typ='R'), - RESI_PRIM_ABSO =SIMP(statut='o',typ='R'), - R =SIMP(statut='f',typ='R',defaut= 1000.), - ITER_PRIM_MAXI =SIMP(statut='f',typ='I',defaut= 10), - ), - PARM_THETA =SIMP(statut='f',typ='R' - ,defaut= 1. ), - 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 10/05/2006 AUTEUR MCOURTOI 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 MCOURTOI M.COURTOIS - -def calc_table_prod(self, TABLE, **kargs): - """Typage du concept produit. - """ - typ_table = AsType(TABLE) - if issubclass(typ_table, table_sdaster): - return typ_table - raise AsException("type de concept resultat non prevu") - -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', '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'), - VALE_I = SIMP(statut='f',typ='I'), - VALE_C = SIMP(statut='f',typ='C'), - VALE_K = SIMP(statut='f',typ='TXM'), - ), - b_regexp = BLOC(condition = "CRIT_COMP == 'REGEXP'", - VALE_K = SIMP(statut='f',typ='TXM'), - ), - 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"), - ), - - 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/02/2006 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. +# 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. # ====================================================================== CALC_THETA=OPER(nom="CALC_THETA",op=54,sd_prod=theta_geom,reentrant='n', UIinfo={"groupes":("Post traitements",)}, @@ -7571,7 +7450,7 @@ CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentr INST =SIMP(statut='f',typ='R',defaut= 0.E+0 ), ), ) ; -#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 12/09/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -7590,33 +7469,15 @@ CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentr # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE G8BHHXD X.DESROCHES - -COMB_CHAM_ELEM=OPER(nom="COMB_CHAM_ELEM",op= 139,sd_prod=cham_elem,reentrant='f', - fr="Effectuer la combinaison linéaire de champs par éléments", - UIinfo={"groupes":("Résultats et champs",)}, - regles=(UN_PARMI('COMB_R','COMB_C','COMB_FOURIER'), - PRESENT_PRESENT('COMB_FOURIER','ANGL'),), - COMB_R =FACT(statut='f',max='**', - PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ), - COEF_R =SIMP(statut='o',typ='R'), - CHAM_ELEM =SIMP(statut='o',typ=cham_elem), - ), - COMB_C =FACT(statut='f',max='**', - regles=(UN_PARMI('COEF_R','COEF_C', ),), - COEF_R =SIMP(statut='f',typ='R'), - COEF_C =SIMP(statut='f',typ='C'), - CHAM_ELEM =SIMP(statut='o',typ=cham_elem), - ), - COMB_FOURIER =FACT(statut='f',max='**', - COEF_R =SIMP(statut='f',typ='R',defaut= 1.), - NUME_MODE =SIMP(statut='o',typ='I'), - TYPE_MODE =SIMP(statut='o',typ='TXM',into=("SYME","ANTI") ), - CHAM_ELEM =SIMP(statut='o',typ=cham_elem), - ), - ANGL =SIMP(statut='f',typ='R' ), -) ; - -#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE +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 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -7634,107 +7495,28 @@ COMB_CHAM_ELEM=OPER(nom="COMB_CHAM_ELEM",op= 139,sd_prod=cham_elem,reentrant='f' # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE G8BHHXD X.DESROCHES -def comb_cham_no_prod(COMB_R,**args): - typ=cham_no_sdaster - if COMB_R != None: - type_mat = AsType(COMB_R[0]['CHAM_NO']) - if type_mat == matr_asse_gene_r : typ= matr_asse_gene_r - return typ - -COMB_CHAM_NO=OPER(nom="COMB_CHAM_NO",op= 30,sd_prod=comb_cham_no_prod - ,fr="Effectuer la combinaison linéaire de champs aux noeuds", - reentrant='f', +# RESPONSABLE VABHHTS J.PELLET +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','COMB_FOURIER'),), - COMB_R =FACT(statut='f',max='**', - PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG",) ), - CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), - COEF_R =SIMP(statut='o',typ='R' ), - ), - COMB_C =FACT(statut='f',max='**', - regles=(UN_PARMI('COEF_R','COEF_C' ),), - CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), - COEF_R =SIMP(statut='f',typ='R' ), - COEF_C =SIMP(statut='f',typ='C' ), - ), - COMB_FOURIER =FACT(statut='f',max='**', - CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), - COEF_R =SIMP(statut='f',typ='R',defaut= 1. ), - NUME_MODE =SIMP(statut='o',typ='I' ), - TYPE_MODE =SIMP(statut='o',typ='TXM',into=("SYME","ANTI") ), - ), - b_angl = BLOC ( condition = "COMB_FOURIER != None", - ANGL =SIMP(statut='o',typ='R' ), - ), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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 G8BHHXD 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 ), - ANGL =SIMP(statut='o',typ='R',max='**'), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=5, - into=("DEPL","REAC_NODA","SIEF_ELGA_DEPL","EPSI_ELNO_DEPL","SIGM_ELNO_DEPL") ), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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 VABHHTS J.PELLET -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' ),), + 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 @@ -7871,7 +7653,7 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_stat, ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 12/09/2006 AUTEUR REZETTE C.REZETTE # RESPONSABLE VABHHTS J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -7918,7 +7700,7 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, # ------------------------------------------------------------------ OPTION =SIMP(statut='f',typ='TXM'), - OPERATION =SIMP(statut='o',typ='TXM',into=("AFFE","ASSE","EVAL","EXTR","DISC","NORMALE") ), + OPERATION =SIMP(statut='o',typ='TXM',into=("AFFE","ASSE","EVAL","EXTR","DISC","NORMALE","R2C","C2R") ), # ------------------------------------------------------------------ b_norm =BLOC(condition = "OPERATION == 'NORMALE'", @@ -7969,6 +7751,7 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, 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), ), ), # ------------------------------------------------------------------ @@ -7976,6 +7759,15 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, 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'),), + ), # ------------------------------------------------------------------ b_disc =BLOC(condition = "OPERATION == 'DISC'", MODELE =SIMP(statut='f',typ=(modele_sdaster) ), @@ -8048,7 +7840,8 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, ), # fin bloc b_extr - ), + + ), # FIN DU CATALOGUE : INFO,TITRE ET TYPAGE DU RESULTAT : #----------------------------------------------------- INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ), @@ -8210,7 +8003,7 @@ CREA_MAILLAGE=OPER(nom="CREA_MAILLAGE",op= 167,sd_prod=maillage_sdaster, # INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 24/01/2006 AUTEUR D6BHHJP J.P.LEFEBVRE +#& MODIF COMMANDE DATE 12/09/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -8234,6 +8027,7 @@ def crea_resu_prod(TYPE_RESU,**args): if TYPE_RESU == "EVOL_THER" : return evol_ther if TYPE_RESU == "MULT_ELAS" : return mult_elas 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") @@ -8248,7 +8042,7 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', b_affe =BLOC(condition = "OPERATION == 'AFFE'", TYPE_RESU =SIMP(statut='o',position='global',typ='TXM',into=("MULT_ELAS","EVOL_ELAS","EVOL_NOLI","FOURIER_ELAS", - "EVOL_THER","EVOL_VARC","EVOL_CHAR",) ), + "EVOL_THER","EVOL_VARC","EVOL_CHAR","FOURIER_THER") ), NOM_CHAM =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO()), AFFE =FACT(statut='o',max='**', @@ -8270,7 +8064,7 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), ), - b_fourier =BLOC(condition = "TYPE_RESU == 'FOURIER_ELAS' ", + 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") ), ), @@ -8343,140 +8137,6 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', ), ) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS -# 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. -# ====================================================================== -CREA_TABLE=OPER(nom="CREA_TABLE",op= 36,sd_prod=table_sdaster, - 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"), - ), - TITRE=SIMP(statut='f',typ='TXM',max='**'), -) ; - - - -#& MODIF COMMANDE DATE 16/01/2006 AUTEUR D6BHHJP 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. -# ====================================================================== -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'), - UNITE =SIMP(statut='f',typ='I',defaut=15), - ), - 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'), - 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',)), - ), - MEMOIRE =FACT(fr="mode de gestion mémoire utilisé",statut='f',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'), - ), - RESERVE_CPU =FACT(fr="reserve de temps pour terminer une execution",statut='f',max=1, - regles=(EXCLUS('VALE','POURCENTAGE'),), - VALE =SIMP(statut='f',typ='I',val_min=0), - POURCENTAGE =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0), -# valeur en pourcentage du temps maximum bornée à 180 secondes - BORNE =SIMP(statut='f',typ='I',val_min=0,defaut=180) - ), - ); #& MODIF COMMANDE DATE 03/10/2005 AUTEUR NICOLAS O.NICOLAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -8613,130 +8273,20 @@ DEFI_CABLE_BP=MACRO(nom="DEFI_CABLE_BP",op=defi_cable_bp_ops,sd_prod=cabl_precon #& MODIF COMMANDE DATE 22/06/2005 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. -# ====================================================================== - -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/06/2005 AUTEUR REZETTE C.REZETTE -# RESPONSABLE JMBHH01 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. -# ====================================================================== -DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster, - fr="Définir le comportement d'un monocristal ou d'un polycristal", - reentrant='n', - UIinfo={"groupes":("Modélisation",)}, - regles=(EXCLUS('MONOCRISTAL','POLYCRISTAL'),), - - 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'),), - ), - - - POLYCRISTAL =FACT(statut='f', max='**', - 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='o',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), - ), - ), - - ); - -#& MODIF COMMANDE DATE 22/06/2005 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. +# 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. # ====================================================================== DEFI_CONSTANTE=OPER(nom="DEFI_CONSTANTE",op= 2,sd_prod=fonction_sdaster, fr="Définir la valeur d'une grandeur invariante", @@ -8781,133 +8331,6 @@ DEFI_COQU_MULT=OPER(nom="DEFI_COQU_MULT",op=56,sd_prod=mater_sdaster,reentrant=' #& MODIF COMMANDE DATE 22/06/2005 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 D6BHHJP 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 25/04/2006 AUTEUR CIBHHPD L.SALMONA -# 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. -# ====================================================================== - -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 avec X-FEM", - - MODELE =SIMP(statut='o',typ=modele_sdaster), - DEFI_FISS =FACT(statut='o',max=01, - regles =(UN_PARMI('GROUP_MA_FISS','FONC_LT'), - ENSEMBLE('FONC_LT','FONC_LN'), - ENSEMBLE('GROUP_MA_FISS','GROUP_MA_FOND')), - FONC_LT =SIMP(statut='f',typ=(fonction_sdaster,formule) ), - FONC_LN =SIMP(statut='f',typ=(fonction_sdaster,formule) ), - GROUP_MA_FISS =SIMP(statut='f',typ=grma,max=01), - GROUP_MA_FOND =SIMP(statut='f',typ=grma), - ), - GROUP_MA_ENRI =SIMP(statut='o',typ=grma,max=01), - RAYON_ENRI =SIMP(statut='f',typ='R',defaut=0.E+0), - ORIE_FOND =FACT(statut='f',max=01, - PFON_INI =SIMP(statut='o',typ='R',max=03), - VECT_ORIE =SIMP(statut='o',typ='R',max=03), - PT_ORIGIN =SIMP(statut='o',typ='R',max=03), - ), - CONTACT =FACT(statut='f',max=01, - NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",) ), - FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ), - INTEGRATION =SIMP(statut='f',typ='TXM',defaut="FPG4",into=("GAUSS","FPG4","FPG6","FPG7",) ), - COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), - MODL_AXIS =SIMP(statut='f',typ='TXM',into=("NON",)), - ITER_CONT_MAXI =SIMP(statut='f',typ='I',defaut=30), - 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), - b_frottement =BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramères 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), - SEUIL_INIT =SIMP(statut='f',typ='R',defaut=0.E+0),), - ), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,3,) ), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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 @@ -9476,7 +8899,7 @@ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION') ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), INFO =SIMP(statut='f',typ='I',into=( 1 , 2 ) ), ) ; -#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -9494,9 +8917,12 @@ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION') # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -DEFI_INTE_SPEC=OPER(nom="DEFI_INTE_SPEC",op= 115,sd_prod=table_sdaster, - reentrant='n',fr="Définit une matrice interspectrale", - UIinfo={"groupes":("Fonction",)}, +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 ), @@ -9536,7 +8962,7 @@ DEFI_INTE_SPEC=OPER(nom="DEFI_INTE_SPEC",op= 115,sd_prod=table_sdaster, TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 26/06/2006 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -9567,7 +8993,7 @@ DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas, 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='**'), +# DDL_ACTIF =SIMP(statut='f',typ='TXM',max='**'), MASQUE =SIMP(statut='f',typ='TXM',max='**'), ), FREQ =SIMP(statut='f',typ='R',defaut= 1.), @@ -9646,7 +9072,7 @@ DEFI_LIST_REEL=OPER(nom="DEFI_LIST_REEL",op=24,sd_prod=listr8_sdaster, INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -9669,9 +9095,9 @@ 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_MAILLE =FACT(statut='o',max='**', + DEFI_SUPER_MAILLE =FACT(statut='o',max='**', MACR_ELEM_STAT =SIMP(statut='o',typ=macr_elem_stat,max='**' ), - MAILLE =SIMP(statut='f',typ=ma,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", @@ -9679,14 +9105,14 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, ), ), RECO_GLOBAL =FACT(statut='f',max='**', - regles=(UN_PARMI('TOUT','MAILLE'),), + regles=(UN_PARMI('TOUT','SUPER_MAILLE'),), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - MAILLE =SIMP(statut='f',typ=ma,max='**'), + 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_MAILLE =FACT(statut='f',max='**', - MAILLE =SIMP(statut='o',typ=ma,max='**'), + 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'", @@ -9705,18 +9131,18 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, INDEX =SIMP(statut='o',typ='I',max='**'), ), b_noeud_init =BLOC(condition = "NOEUD_INIT != None", - MAILLE =SIMP(statut='o',typ=ma), + 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','MAILLE'), + 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" ), - MAILLE =SIMP(statut='f',typ=ma, + 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"), @@ -9725,7 +9151,7 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, GROUP_NO_FIN =SIMP(statut='f',typ=grno), ), ) ; -#& MODIF COMMANDE DATE 29/05/2006 AUTEUR MJBHHPE J.L.FLEJOU +#& MODIF COMMANDE DATE 07/11/2006 AUTEUR MARKOVIC D.MARKOVIC # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -9751,7 +9177,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 'ELAS_ORTH_FO','ELAS_COQUE','ELAS_COQUE_FO', 'ELAS_HYPER',), EXCLUS('THER','THER_FO','THER_ORTH','THER_NL'), - EXCLUS('ECRO_LINE','ECRO_LINE_FO'), + EXCLUS('ECRO_LINE','ECRO_LINE_FO','ECRO_PUIS'), EXCLUS('TAHERI','TAHERI_FO'), EXCLUS('ROUSSELIER','ROUSSELIER_FO'), PRESENT_PRESENT('ROUSSELIER','TRACTION'), @@ -9759,7 +9185,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, EXCLUS('CIN1_CHAB','CIN1_CHAB_FO'), EXCLUS('CIN2_CHAB','CIN2_CHAB_FO'), EXCLUS('VISCOCHAB','VISCOCHAB_FO'), - EXCLUS('POLY_CFC','POLY_CFC_FO'), EXCLUS('LEMAITRE','LEMAITRE_FO','ZIRC_CYRA2','ZIRC_EPRI','VISC_IRRA_LOG', 'LEMA_SEUIL','LEMA_SEUIL_FO','LEMAITRE_IRRA','LMARC_IRRA',), EXCLUS('LMARC','LMARC_FO'), @@ -9775,9 +9200,9 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, PRESENT_PRESENT('HOEK_BROWN','ELAS'), EXCLUS('MAZARS','MAZARS_FO'), PRESENT_PRESENT('BAZANT_FD','ELAS_FO'), - EXCLUS('GLRC','GLRC_FO'), PRESENT_PRESENT('JOINT_BA','ELAS'), PRESENT_PRESENT('CABLE','ELAS'), + EXCLUS('GLRC_DAMAGE','GLRC_DM'), ), # # comportement élastique @@ -10036,6 +9461,17 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, SY =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), + 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)), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), + ), BETON_ECRO_LINE =FACT(statut='f', D_SIGM_EPSI =SIMP(statut='o',typ='R'), SYT =SIMP(statut='o',typ='R'), @@ -10217,39 +9653,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, A_I =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), - POLY_CFC =FACT(statut='f', - TEXTURE =SIMP(statut='o',typ=(table_sdaster) ), - DL =SIMP(statut='f',typ='R'), - DA =SIMP(statut='f',typ='R'), - N =SIMP(statut='o',typ='R'), - K =SIMP(statut='o',typ='R'), - TAU_0 =SIMP(statut='o',typ='R'), - Q1 =SIMP(statut='o',typ='R'), - B1 =SIMP(statut='o',typ='R'), - HL =SIMP(statut='o',typ='R'), - Q2 =SIMP(statut='o',typ='R'), - B2 =SIMP(statut='o',typ='R'), - C1 =SIMP(statut='o',typ='R'), - D1 =SIMP(statut='o',typ='R'), - C2 =SIMP(statut='o',typ='R'), - ), - POLY_CFC_FO =FACT(statut='f', - TEXTURE =SIMP(statut='o',typ=(table_sdaster) ), - DL =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - DA =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)), - TAU_0 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - Q1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - B1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - HL =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - Q2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - B2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - C1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - D1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - C2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), - ), LEMAITRE =FACT(statut='f', N =SIMP(statut='o',typ='R'), UN_SUR_K =SIMP(statut='o',typ='R'), @@ -10734,30 +10137,46 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, ETA_ID =SIMP(statut='o',typ='R'), ETA_FD =SIMP(statut='f',typ='R'), ), - GLRC =FACT(statut='f',min=0,max=1, - MEX1 =SIMP(statut='o',typ='R',val_min=0.E+0), - MEY1 =SIMP(statut='o',typ='R',val_min=0.E+0), - MEX2 =SIMP(statut='o',typ='R',val_max=0.E+0), - MEY2 =SIMP(statut='o',typ='R',val_max=0.E+0), + GLRC_DAMAGE =FACT(statut='f',min=0,max=1, + FMEX1 =SIMP(statut='o',typ=(fonction_sdaster)), + FMEY1 =SIMP(statut='o',typ=(fonction_sdaster)), + FMEX2 =SIMP(statut='o',typ=(fonction_sdaster)), + FMEY2 =SIMP(statut='o',typ=(fonction_sdaster)), + DFMEX1 =SIMP(statut='o',typ=(fonction_sdaster)), + DFMEY1 =SIMP(statut='o',typ=(fonction_sdaster)), + DFMEX2 =SIMP(statut='o',typ=(fonction_sdaster)), + DFMEY2 =SIMP(statut='o',typ=(fonction_sdaster)), + DDFMEX1 =SIMP(statut='o',typ=(fonction_sdaster)), + DDFMEY1 =SIMP(statut='o',typ=(fonction_sdaster)), + DDFMEX2 =SIMP(statut='o',typ=(fonction_sdaster)), + DDFMEY2 =SIMP(statut='o',typ=(fonction_sdaster)), + CX1 =SIMP(statut='o',typ='R',val_min=0.E+0), CY1 =SIMP(statut='o',typ='R',val_min=0.E+0), CXY1 =SIMP(statut='o',typ='R',val_min=0.E+0), CX2 =SIMP(statut='o',typ='R',val_min=0.E+0), CY2 =SIMP(statut='o',typ='R',val_min=0.E+0), CXY2 =SIMP(statut='o',typ='R',val_min=0.E+0), - ), - GLRC_FO =FACT(statut='f',min=0,max=1, - MEX1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - MEY1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - MEX2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - MEY2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - CX1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - CY1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - CXY1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - CX2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - CY2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - CXY2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)), - VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("NORM",) ), + MF1 =SIMP(statut='o',typ='R',val_min=0.E+0), + MF2 =SIMP(statut='o',typ='R',val_max=0.E+0), + QP1 =SIMP(statut='o',typ='R',val_min=0.E+0), + QP2 =SIMP(statut='o',typ='R',val_min=0.E+0), + GAMMA =SIMP(statut='o',typ='R',val_min=0.E+0), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("X ",) ), + ), + GLRC_DM =FACT(statut='f',min=0,max=1, + GAMMA_T =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), + GAMMA_F =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0), + SYT =SIMP(statut='o',typ='R',val_min=0.E+0), + 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), + ), + GLRC_ACIER =FACT(statut='f',min=0,max=1, + AX =SIMP(statut='o',typ='R',val_min=0.E+0), + AY =SIMP(statut='o',typ='R',val_min=0.E+0), + E =SIMP(statut='o',typ='R',val_min=0.E+0), + ENROB =SIMP(statut='o',typ='R',val_min=0.E+0), ), GATT_MONERIE =FACT(statut='f',min=0,max=1, D_GRAIN =SIMP(statut='o',typ='R',val_min=0.E+0), @@ -12105,15 +11524,15 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), CISA_PLAN_CRIT =FACT(statut='f', - CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE", + CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE_MODI_AC", "DANG_VAN_MODI_AC", "DANG_VAN_MODI_AV", - "DOMM_MAXI", - "FATEMI_SOCIE", + "MATAKE_MODI_AV", + "FATESOCI_MODI_AV", ) ), - b_critere_matake =BLOC(condition="CRITERE=='MATAKE'", - fr="Cisaillement plan critique critère de matake", + 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), @@ -12126,14 +11545,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0), ), - b_crit_domm_maxi =BLOC(condition="CRITERE=='DOMM_MAXI'", - fr="Critère pour chargement non périodique : domm_maxi", - DOMM_A =SIMP(statut='o',typ='R'), - DOMM_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=='FATEMI_SOCIE'", + 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), @@ -12260,23 +11672,39 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, DELTAV =SIMP(statut='o',typ='R',fr="Volume d activation"), DELTAG0 =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"), ), - ECOU_PLAS1 =FACT(statut='f', - TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_PLAS",),), - C =SIMP(statut='o',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='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='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'), ), @@ -12407,7 +11835,7 @@ DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op= 4,sd_prod=nappe_sdaster, VERIF =SIMP(statut='f',typ='TXM',into=("CROISSANT",) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -12425,10 +11853,10 @@ DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op= 4,sd_prod=nappe_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -DEFI_OBSTACLE=OPER(nom="DEFI_OBSTACLE",op= 73,sd_prod=obstacle_sdaster - ,fr="Définition d'un obstacle plan perpendiculaire à une structure filaire", - reentrant='n', - UIinfo={"groupes":("Modélisation",)}, +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", @@ -12492,166 +11920,7 @@ DEFI_PARA_SENSI=OPER(nom="DEFI_PARA_SENSI",op= 2,sd_prod=para_sensi, ang="Value of the parameter"), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 30/08/2005 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'),), - MAILLAGE =SIMP(statut='f',typ=maillage_sdaster), - MODELE =SIMP(statut='f',typ=modele_sdaster), - NB_PART =SIMP(statut='o',typ='I',val_min=2), - 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 22/02/2005 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 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 30/08/2005 AUTEUR ASSIRE A.ASSIRE -# 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=OPER(nom="DEFI_PART_PA_OPS",op=29,sd_prod=sd_feti_sdaster, - fr="Creation partitionnement en sous-domaines pour FETI", - docu="U4.00.00",reentrant='n', - 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 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -12732,7 +12001,7 @@ DEFI_SPEC_TURB=OPER(nom="DEFI_SPEC_TURB",op= 145,sd_prod=spectre_sdaster, SPEC_FONC_FORME =FACT(statut='f', regles=(UN_PARMI('INTE_SPEC','GRAPPE_1'), ENSEMBLE('INTE_SPEC','FONCTION'),), - INTE_SPEC =SIMP(statut='f',typ=table_sdaster), + 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), @@ -12741,7 +12010,7 @@ DEFI_SPEC_TURB=OPER(nom="DEFI_SPEC_TURB",op= 145,sd_prod=spectre_sdaster, ), SPEC_EXCI_POINT =FACT(statut='f', regles=(UN_PARMI('INTE_SPEC','GRAPPE_2'),), - INTE_SPEC =SIMP(statut='f',typ=table_sdaster), + 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 @@ -12835,37 +12104,76 @@ DEFI_SQUELETTE=OPER(nom="DEFI_SQUELETTE",op= 110,sd_prod=squelette, ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 07/11/2006 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. +# 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. # ====================================================================== -DEFI_TEXTURE=OPER(nom="DEFI_TEXTURE",op= 181,sd_prod=table_sdaster,reentrant='n', - fr="Définir pour un materiau CFC, les orientations cristillographiques et leur système de glissement ", - UIinfo={"groupes":("Modélisation",)}, - SYST_GLISSEMENT =FACT(statut='o',min=3,max=3, - N =SIMP(statut='o',typ='R',min=12,max=12 ), - L =SIMP(statut='o',typ='R',max='**' ), + +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='f',typ='R',defaut=9.81), + 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",),), + ), ), - PLAN =FACT(statut='o',min=1,max=40, - ANGL_NAUT =SIMP(statut='o',typ='R',max='**' ), - PROPORTION =SIMP(statut='o',typ='R' ), + 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),),), ), - TITRE =SIMP(statut='f',typ='TXM',max='**' ), -) ; +) #& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -12902,47 +12210,118 @@ DEFI_TRC=OPER(nom="DEFI_TRC",op=94,sd_prod=table_sdaster,reentrant='n', A =SIMP(statut='f',typ='R'), ), ) ; -#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 22/06/2005 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. -# ====================================================================== -DEPL_INTERNE=OPER(nom="DEPL_INTERNE",op=89,sd_prod=cham_no_sdaster,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), - MAILLE =SIMP(statut='o',typ=ma,), - NOM_CAS =SIMP(statut='f',typ='TXM',defaut=" "), -) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS -# CONFIGURATION MANAGEMENT OF EDF VERSION +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# COPYRIGHT (C) 1991 - 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, + + +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='**', + into=("SIEF_ELGA","VARI_ELGA","SIEF_ELGA_DEPL","FLUX_ELGA_TEMP",) ), + + # 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), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ), + ) +#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA +# 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. +# ====================================================================== +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) == base_modale : return base_modale + 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,base_modale,evol_elas,dyna_trans,dyna_harmo),), + SUPER_MAILLE =SIMP(statut='o',typ=ma,), + NOM_CAS =SIMP(statut='f',typ='TXM',defaut=" "), +) ; +#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI 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. # ====================================================================== DETRUIRE=MACRO(nom="DETRUIRE",op=-7, @@ -12965,7 +12344,95 @@ DETRUIRE=MACRO(nom="DETRUIRE",op=-7, 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 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 31/10/2006 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. +# ====================================================================== + +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=(AU_MOINS_UN('IDENTIFICATION', 'PREDICTION'),), + + # 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='o', typ='R', max=3), + THETA_2D = FACT(statut='o', 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'), + ), + + # copeaux + GROUP_MA = SIMP(statut='o', typ=grma, validators=NoRepeat(), max='**'), + PAS_ENTAILLE = SIMP(statut='o', typ='R', val_min=0.), + + # 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 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -12983,8 +12450,8 @@ DETRUIRE=MACRO(nom="DETRUIRE",op=-7, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_sdaster - ,fr="Calcul de la réponse spectrale d'une structure linéaire sous une excitation connue par sa DSP", +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', @@ -13003,7 +12470,7 @@ DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_sdaster # 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_sdaster), + 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") ), @@ -13141,7 +12608,7 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op= 60,sd_prod=dyna_line_harm_prod, # Rajouter test icompatibilite vect_asse et sensibilite # Peut-on aussi rajouter ici le test d incompatibilite charge complexe - derivation # presents dans le Fortran -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 12/06/2006 AUTEUR BOITEAU O.BOITEAU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -13254,12 +12721,13 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, 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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6), - ), + 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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,), + ), ), INCREMENT =FACT(statut='o',max='**', @@ -13297,7 +12765,7 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, TITRE =SIMP(statut='f',typ='TXM',max='**'), INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -13439,9 +12907,43 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', NUME_INST_FIN =SIMP(statut='f',typ='I'), INST_FIN =SIMP(statut='f',typ='R'), PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ), - SUBD_PAS =SIMP(statut='f',typ='I',defaut=1), - SUBD_PAS_MINI =SIMP(statut='f',typ='R'), - COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),), NOM_CHAM =SIMP(statut='f',typ='TXM',), NOM_CMP =SIMP(statut='f',typ='TXM',), @@ -13468,7 +12970,6 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0), PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0), ), - PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ), 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", @@ -13482,11 +12983,13 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,), - ), + 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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), + ), 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), @@ -13504,7 +13007,7 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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), + RHO_EXCL =SIMP(statut='f',typ='R',defaut=0.9E-2,val_min=0.), ), PILOTAGE =FACT(statut='f', regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), @@ -13539,16 +13042,20 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', ), #------------------------------------------------------------------- SUIVI_DDL = FACT(statut='f',max=4, - regles=(UN_PARMI('NOEUD','MAILLE'), + regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'), PRESENT_PRESENT('MAILLE','POINT'),), NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4), 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",)), NOM_CMP =SIMP(statut='o',typ='TXM',max=1 ), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max=1), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max=1), - POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max=1), + 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='**'), + POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), + 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",) ), ), AFFICHAGE = FACT(statut='f',max=16, @@ -13644,10 +13151,12 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," 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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,), + 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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), ), 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" ), @@ -13668,7 +13177,7 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -13686,330 +13195,257 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=table_sdaster, +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_sdaster), + 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 16/05/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 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 -DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f',UIinfo={"groupe":("Résolution",)}, - fr="Calcul de l'évolution dynamique d'une structure dont la géométrie ou le matériau ont un comportement" - +" non linéaire, par une méthode explicite sur les accélérations ", - regles=(AU_MOINS_UN('COMP_INCR','COMP_ELAS',),UN_PARMI('DIFF_CENT','TCHAMWA'),), - MODELE =SIMP(statut='o',typ=modele_sdaster), - CHAM_MATER =SIMP(statut='o',typ=cham_mater), - MODE_STAT =SIMP(statut='f',typ=(mode_stat_depl,mode_stat_acce,mode_stat_forc,)), - CARA_ELEM =SIMP(statut='f',typ=cara_elem), - MASS_DIAG =SIMP(statut='f',typ='TXM',defaut="NON",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","FIXE_PILO","SUIV","DIDI")), - CHARGE =SIMP(statut='o',typ=char_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=3), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), - GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), - ), - AMOR_MODAL =FACT(statut='f', - MODE_MECA =SIMP(statut='o',typ=mode_meca), - AMOR_REDUIT =SIMP(statut='f',typ='R',max='**' ), - NB_MODE =SIMP(statut='f',typ='I',defaut= 9999 ), - REAC_VITE =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), +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_stat_depl,mode_stat_acce,mode_stat_forc) ), + MODE_CORR =SIMP(statut='f',typ=(mult_elas,mode_stat_acce) ,), + + 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' ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + ), + DEPL_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene ), + VITE_INIT_GENE =SIMP(statut='f',typ=vect_asse_gene ), ), - 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), + 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 ), ), - EXCIT_GENE =FACT(statut='f', - FONC_MULT =SIMP(statut='f',typ=fonction_sdaster,max='**' ), - VECT_GENE =SIMP(statut='f',typ=vect_asse_gene,max='**' ), + 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' ), ), - 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_POUTRE_GR","CABLE","ELAS_HYPER")), - ELAS =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_VMIS_TRAC =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_VMIS_LINE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_HYPER =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_POUTRE_GR =SIMP(statut='c',typ='I',defaut=3,into=(3,)), - CABLE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - 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")), + + 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'), + 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) ), ), -#------------------------------------------------------------------- - ETAT_INIT =FACT(statut='f', - regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','VITE','ACCE','SIGM','VARI','VARI_NON_LOCAL',), - EXCLUS('EVOL_NOLI','DEPL',), - EXCLUS('EVOL_NOLI','VITE'), - EXCLUS('EVOL_NOLI','ACCE'), - EXCLUS('EVOL_NOLI','SIGM',), - EXCLUS('EVOL_NOLI','VARI',), - EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), - 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), - VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), - EVOL_NOLI =SIMP(statut='f',typ=evol_noli), - NUME_ORDRE =SIMP(statut='f',typ='I'), - INST =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") ), - NUME_DIDI =SIMP(statut='f',typ='I'), - INST_ETAT_INIT =SIMP(statut='f',typ='R'), + 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',defaut= 0.E+0 ), + 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 ), + ), ), -#------------------------------------------------------------------- - INCREMENT =FACT(statut='o', - regles=(EXCLUS('NUME_INST_INIT','INST_INIT'), - EXCLUS('NUME_INST_FIN','INST_FIN'),), - LIST_INST =SIMP(statut='o',typ=listr8_sdaster), - EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE", - into=("CHRONOLOGIQUE","RETROGRADE","SANS",) ), - 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-3 ), - SUBD_PAS =SIMP(statut='f',typ='I',defaut=1), - SUBD_PAS_MINI =SIMP(statut='f',typ='R'), - COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0), - OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),), - NOM_CHAM =SIMP(statut='f',typ='TXM',), - NOM_CMP =SIMP(statut='f',typ='TXM',), - VALE =SIMP(statut='f',typ='R'), + 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 ), ), -#------------------------------------------------------------------- - DIFF_CENT =FACT(statut='f', + 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' ), ), - TCHAMWA =FACT(statut='f', - PHI =SIMP(statut='f',typ='R',defaut= 1.05), + 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. ), ), - STOP_CFL =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), - NEWTON =FACT(statut='c', - REAC_INCR =SIMP(statut='f',typ='I',defaut= 1 ), - 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), - REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0), - PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0), + 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) ), ), - PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ), - SOLVEUR =FACT(statut='d', - METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), - 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","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 ), - ), - SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), + 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) ), ), -#------------------------------------------------------------------- - RECH_LINEAIRE =FACT(statut='c', - RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ), - ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 3), - 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), + 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) ), ), - PILOTAGE =FACT(statut='c', - regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), - TYPE =SIMP(statut='o',typ='TXM',into=("DDL_IMPO","LONG_ARC","PRED_ELAS","PRED_ELAS_INCR","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 =FACT(statut='d', - regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),), - 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'), - 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"), - 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_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' ), + NB_MODE_DIAG =SIMP(statut='f',typ='I' ), + TS_REG_ETAB =SIMP(statut='f',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", - "LAGR_ECAR","LAGR_INCR","LAGR_ITER", - "MATR_ASSE", - "ITER_DEBO", - "CTCD_ITER","CTCD_INFO","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-3), - 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","VARI_NON_LOCAL","LANL_ELGA")), - ), - OBSERVATION =FACT(statut='f',max='**', - regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'), - PRESENT_PRESENT('MAILLE','POINT'),), - NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - -into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU") ), - NOM_CMP =SIMP(statut='o',typ='TXM',max='**' ), - LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - PAS_OBSE =SIMP(statut='f',typ='I'), - 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='**'), - POINT =SIMP(statut='f',typ='I' ,max='**'), + 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' ), ), -#------------------------------------------------------------------- - SOLV_NON_LOCAL =FACT(statut='f', - METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), - 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") ), - ), - 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 ), - RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), - NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), - ), - ), - LAGR_NON_LOCAL =FACT(statut='f', - ITER_DUAL_MAXI =SIMP(statut='f',typ='I',defaut= 50), - RESI_DUAL_ABSO =SIMP(statut='o',typ='R'), - RESI_PRIM_ABSO =SIMP(statut='o',typ='R'), - R =SIMP(statut='f',typ='R',defaut= 1000.), - ITER_PRIM_MAXI =SIMP(statut='f',typ='I',defaut= 10), - ), -#------------------------------------------------------------------- - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), + ) ; +#& MODIF COMMANDE DATE 22/06/2005 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 VABHHTS 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)", + regles=(UN_PARMI('TOUT','CO'),), + UNITE =SIMP(statut='f',typ='I',defaut=8), + 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","RESUME") ), + FORMAT_R =SIMP(statut='f',typ='TXM',defaut="1PE12.5"), + PREC_R =SIMP(statut='f',typ='TXM',defaut="1.E-5"), ) ; -#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -14027,309 +13463,93 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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', + +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 14/10/2005 AUTEUR CIBHHLV L.VIVAN +# 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. +# ====================================================================== +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",)}, - 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_stat_depl,mode_stat_acce,mode_stat_forc) ), - MODE_CORR =SIMP(statut='f',typ=(mult_elas,mode_stat_acce) ,), - - 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' ), + 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 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), ), - 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 ), + 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'), + ), ), - 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'), - PRESENT_PRESENT('ACCE','VITE','DEPL'), - PRESENT_PRESENT('D_FONC_DT','D_FONC_DT2'), - PRESENT_ABSENT('NUME_MODE','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_MODE =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), - MAILLE =SIMP(statut='f',typ=ma), - 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=obstacle_sdaster ), - 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',defaut= 0.E+0 ), - 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=obstacle_sdaster ), - 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' ), - NB_MODE_DIAG =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' ), - ), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - ) ; -#& MODIF COMMANDE DATE 22/06/2005 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 VABHHTS 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)", - regles=(UN_PARMI('TOUT','CO'),), - UNITE =SIMP(statut='f',typ='I',defaut=8), - 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","RESUME") ), - FORMAT_R =SIMP(statut='f',typ='TXM',defaut="1PE12.5"), - PREC_R =SIMP(statut='f',typ='TXM',defaut="1.E-5"), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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. -# ====================================================================== -EXEC_LOGICIEL=PROC(nom="EXEC_LOGICIEL",op= 183, - fr="Exécute un logiciel ou une commande système depuis Aster", - UIinfo={"groupes":("Impression",)}, - LOGICIEL =SIMP(statut='f',typ='TXM' ), - ARGUMENT =FACT(statut='f',max='**', - NOM_PARA =SIMP(statut='f',typ='TXM' ), - ), -) ; -#& MODIF COMMANDE DATE 14/10/2005 AUTEUR CIBHHLV L.VIVAN -# 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. -# ====================================================================== -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") ), + 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 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR VABHHTS J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -14356,10 +13576,9 @@ def extr_resu_prod(RESULTAT,**args): 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) == mode_stat : return mode_stat - if AsType(mode_stat) == mode_stat_depl : return mode_stat_depl - if AsType(mode_stat) == mode_stat_acce : return mode_stat_acce - if AsType(mode_stat) == mode_stat_forc : return mode_stat_forc + if AsType(RESULTAT) == mode_stat_depl : return mode_stat_depl + if AsType(RESULTAT) == mode_stat_acce : return mode_stat_acce + if AsType(RESULTAT) == mode_stat_forc : return mode_stat_forc if AsType(RESULTAT) == mult_elas : return mult_elas if AsType(RESULTAT) == fourier_elas : return fourier_elas raise AsException("type de concept resultat non prevu") @@ -14371,7 +13590,7 @@ EXTR_RESU=OPER(nom="EXTR_RESU",op=176,sd_prod=extr_resu_prod,reentrant='f', DERIVABLE('RESULTAT'),), RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,acou_harmo,mode_meca, mode_acou,mode_stat_depl,mode_stat_acce,mode_stat_forc,evol_ther,evol_noli, - mult_elas,fourier_elas ) ), + 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é.", @@ -14404,7 +13623,42 @@ EXTR_RESU=OPER(nom="EXTR_RESU",op=176,sd_prod=extr_resu_prod,reentrant='f', #& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# 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. +# ====================================================================== +def fact_grad_prod(MATR_ASSE,**args): + if AsType(MATR_ASSE) == matr_asse_depl_r : return matr_asse_depl_r + if AsType(MATR_ASSE) == matr_asse_temp_r : return matr_asse_temp_r + if AsType(MATR_ASSE) == matr_asse_pres_r : return matr_asse_pres_r + raise AsException("type de concept resultat non prevu") + +FACT_GRAD=OPER(nom="FACT_GRAD",op=85,sd_prod=fact_grad_prod, + UIinfo={"groupes":("Résolution",)}, + fr="Construire une matrice de préconditionnement pour une résolution par gradient conjugué", + reentrant='n', + MATR_ASSE =SIMP(statut='o', + typ=(matr_asse_depl_r,matr_asse_temp_r, + matr_asse_pres_r) ), + PRE_COND =SIMP(statut='f',typ='TXM',defaut="LDLT_INC",into=("LDLT_INC",) ), + NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), +) ; +#& MODIF COMMANDE DATE 22/06/2005 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 @@ -14419,72 +13673,58 @@ EXTR_RESU=OPER(nom="EXTR_RESU",op=176,sd_prod=extr_resu_prod,reentrant='f', # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -def extr_table_prod(TYPE_RESU,**args): - if TYPE_RESU == "MATR_ASSE_GENE_R" : return matr_asse_gene_r - 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 la matrice de masse généralisée assemblée", - TYPE_RESU =SIMP(statut='o',typ='TXM',into=("MATR_ASSE_GENE_R",) ), - - TABLE =SIMP(statut='o',typ=table_sdaster), - - 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'),), +# RESPONSABLE GNICOLAS G.NICOLAS - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), - ), +from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops - TITRE =SIMP(statut='f',typ='TXM',max='**' ), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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. +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", # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# 1. Le niveau d'information # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 fact_grad_prod(MATR_ASSE,**args): - if AsType(MATR_ASSE) == matr_asse_depl_r : return matr_asse_depl_r - if AsType(MATR_ASSE) == matr_asse_temp_r : return matr_asse_temp_r - if AsType(MATR_ASSE) == matr_asse_pres_r : return matr_asse_pres_r - raise AsException("type de concept resultat non prevu") - -FACT_GRAD=OPER(nom="FACT_GRAD",op=85,sd_prod=fact_grad_prod, - UIinfo={"groupes":("Résolution",)}, - fr="Construire une matrice de préconditionnement pour une résolution par gradient conjugué", - reentrant='n', - MATR_ASSE =SIMP(statut='o', - typ=(matr_asse_depl_r,matr_asse_temp_r, - matr_asse_pres_r) ), - PRE_COND =SIMP(statut='f',typ='TXM',defaut="LDLT_INC",into=("LDLT_INC",) ), - NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ), - INFO =SIMP(statut='f',typ='I',into=(1,2) ), -) ; + 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 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -14625,7 +13865,7 @@ FORMULE=FORM(nom="FORMULE",op_init=form_pyth_ops,op=-5, VALE =SIMP(statut='f',typ='TXM'), NOM_PARA =SIMP(statut='o',typ='TXM',max='**'), ); -#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -14644,11 +13884,11 @@ FORMULE=FORM(nom="FORMULE",op_init=form_pyth_ops,op=-5, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE CAMBIER S.CAMBIER -GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table_sdaster, +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_sdaster), + 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", @@ -14662,99 +13902,6 @@ GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table_sdaster, INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 11/07/2005 AUTEUR CAMBIER S.CAMBIER -# 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 CAMBIER S.CAMBIER -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 28/02/2006 AUTEUR VABHHTS J.PELLET -# 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 CAMBIER S.CAMBIER -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.), - COEF_VAR = SIMP(statut='f', typ='R', defaut=0.1,val_min=0.), - ), - INIT_ALEA =SIMP(statut='f',typ='I'), -) #& MODIF COMMANDE DATE 23/08/2004 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -14863,157 +14010,23 @@ IMPR_CO=PROC(nom="IMPR_CO",op=17, POSITION =SIMP(statut='f',typ='I',defaut=1), TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), ) ; -#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 21/02/2006 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 MCOURTOI 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) == fonction_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"), - ), - - # le bloc n'est pas activé (vide) car position n'est pas pris en compte - b_forme =BLOC(condition = "FORMAT != 'TABLEAU'", - fr="Données de mise en forme de la fonction (cf. doc)", - ), - 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 b_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"), - 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 21/02/2006 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. +# 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. # ====================================================================== 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", @@ -15287,53 +14300,7 @@ IMPR_MISS_3D=PROC(nom="IMPR_MISS_3D",op= 162, INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 16/06/2004 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 D6BHHAM A.M.DONORE -# -IMPR_OAR =PROC(nom="IMPR_OAR",op= 40, - fr="Impression au format OAR", - UIinfo={"groupes":("Impression",)}, - CARA_ELEM =SIMP(statut='f',typ=cara_elem ), - MAILLAGE =SIMP(statut='o',typ=maillage_sdaster ), - MODELE =SIMP(statut='o',typ=modele_sdaster ), - MAILLE =SIMP(statut='o',typ=ma ,validators=NoRepeat(),max=2 ), - NOEUD =SIMP(statut='o',typ=no ,validators=NoRepeat() ), - - CHARGE =FACT(statut='o',max='**', - - NUM_CHAR =SIMP(statut='o',typ='I'), - TEMP_NOEUD =SIMP(statut='f',typ='R',defaut=20.), - TYPE =SIMP(statut='f',typ='TXM',defaut="DILA", - into=("POIDS","DILA","SEISME","DEPL","EFFO","STRATIF","CONDITIONNEL","COMBINAISON") ), - NATURE =SIMP(statut='f',typ='TXM',defaut="PRIMAIRE", - into=("PRIMAIRE","SECONDAIRE","TOTAL") ), - SIGNE =SIMP(statut='f',typ='TXM',defaut="S", - into=("S","NS") ), - RESULTAT =SIMP(statut='o',typ=resultat_sdaster),# CO() sd a creer !!! - ), - - - UNITE =SIMP(statut='f',typ='I',defaut=38), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), -) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 06/11/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -15386,7 +14353,7 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39, ), b_format_gmsh =BLOC(condition="FORMAT=='GMSH'",fr="unité logique d'impression et version GMSH", - UNITE =SIMP(statut='f',typ='I',defaut=19), + UNITE =SIMP(statut='f',typ='I',defaut=37), VERSION =SIMP(statut='f',typ='R',defaut=1.2,into=(1.0,1.2)), ), @@ -15695,212 +14662,89 @@ INCLUDE_MATERIAU=MACRO(nom="INCLUDE_MATERIAU",op=-14, 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 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 22/06/2005 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. +# 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 D6BHHJP 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",)}, +# RESPONSABLE G8BHHXD 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', - 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",), + 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,), ), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), + + 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 24/05/2005 AUTEUR MCOURTOI 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. -# ====================================================================== -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") ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3,val_min=0.E+0 ), - ), - 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 =BLOC(condition="""OPTION=="TOUT" or OPTION=="INTE_SPEC" """, - AMOR_REDUIT =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 ), - PESANTEUR =SIMP(statut='f',typ='R',defaut= 9.81E+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)", - PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3,val_min=0.E+0), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - ), - ), - MAX =FACT(statut='f',fr="Extrémas locaux d'une fonction", - FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster) ), - ), - 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") ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3,val_min=0.E+0 ), - ), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), -) -#& MODIF COMMANDE DATE 22/06/2005 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 G8BHHXD 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 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -16067,65 +14911,7 @@ LIRE_FONCTION=MACRO(nom="LIRE_FONCTION",op=lire_fonction_ops,sd_prod=lire_foncti INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 21/02/2006 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. -# ====================================================================== -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=base_modale ), - 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 08/11/2005 AUTEUR ACBHHCD G.DEVESA -# 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. -# ====================================================================== -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=base_modale ), - 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), -) ; - -#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -16146,7 +14932,7 @@ LIRE_IMPE_MISS=OPER(nom="LIRE_IMPE_MISS",op= 164,sd_prod=matr_asse_gene_c, 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_sdaster, +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",)}, @@ -16466,87 +15252,25 @@ LIRE_RESU=OPER(nom="LIRE_RESU",op=150,sd_prod=lire_resu_prod,reentrant='n', ), ), ) ; -#& MODIF COMMANDE DATE 03/04/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 30/10/2006 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. +# 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. # ====================================================================== - -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 13/02/2006 AUTEUR DURAND C.DURAND -# 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. -# ====================================================================== -# ====================================================================== - -MAC_MODES=OPER(nom="MAC_MODES",op= 141,sd_prod=table_sdaster, - fr="Normalisation de modes propres", - reentrant='n', - UIinfo={"groupes":("Résolution",)}, - BASE_1 =SIMP(statut='o',typ=(mode_meca,mode_flamb,base_modale) ), - BASE_2 =SIMP(statut='o',typ=(mode_meca,mode_flamb,base_modale) ), - MATR_ASSE =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_depl_c) ), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), -) ; -#& MODIF COMMANDE DATE 02/06/2006 AUTEUR MCOURTOI 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 GNICOLAS G.NICOLAS +# RESPONSABLE GNICOLAS G.NICOLAS from Macro.macr_adap_mail_ops import macr_adap_mail_ops @@ -16582,8 +15306,8 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # # 2. Version de HOMARD # - VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_2", - into=("V8_2", "V8_N", "V8_N_PERSO"), + VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_5", + into=("V8_5", "V8_N", "V8_N_PERSO"), fr="Version de HOMARD", ang="HOMARD release"), # @@ -16659,7 +15383,19 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ang="Error indicator field in the result structure" ), ), # -# 6.1.3. La composante retenue +# 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", @@ -16671,7 +15407,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # ), # -# 6.1.4. Le paramètre temporel pour l'indicateur +# 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", @@ -16679,20 +15415,20 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # regles=(EXCLUS('NUME_ORDRE','INST'),), # -# 6.1.4.1. Soit le numero d'ordre +# 6.1.5.1. Soit le numero d'ordre # NUME_ORDRE = SIMP(statut='f',typ='I', fr="Numero d ordre", ang="Rank" ), # -# 6.1.4.2. Soit l'instant -# 6.1.4.2.1. Sa valeur +# 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.4.2.2. La précision du choix de l'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", @@ -16706,6 +15442,18 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ), # ), +# +# 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" ), +# + ), # ) , # @@ -16752,7 +15500,6 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ) , # # 8. Pour de l'adaptation par zone, définitions des zones -# Remarque : on impose le 3D # b_zone = BLOC( condition = " (ADAPTATION == 'RAFFINEMENT_ZONE') " , fr="Pour une adaptation selon une zone à raffiner", @@ -16763,8 +15510,12 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # regles=(AU_MOINS_UN('X_MINI','X_CENTRE'), EXCLUS('X_MINI','X_CENTRE',), - PRESENT_PRESENT('X_MINI','X_MAXI','Y_MINI','Y_MAXI','Z_MINI','Z_MAXI'), - PRESENT_PRESENT('X_CENTRE','Y_CENTRE','Z_CENTRE','RAYON'),), + 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 # @@ -16894,7 +15645,13 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # ), # -# 11.4. Le paramètre temporel pour le champ a interpoler +# 11.4. Est-ce un champ dérivé +# + SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom), + fr="Paramètre de sensibilité.", + ang="Sensitivity parameter"), +# +# 11.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", @@ -16902,20 +15659,20 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # regles=(EXCLUS('NUME_ORDRE','INST'),), # -# 11.4.1. Soit le numero d'ordre +# 11.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" ), # -# 11.4.2. Soit l'instant -# 11.4.2.1. Sa valeur +# 11.5.2. Soit l'instant +# 11.5.2.1. Sa valeur # INST = SIMP(statut='f',typ='R', fr="Instant associé", ang="Instant" ), # -# 11.4.2.2. La précision du choix de l'instant +# 11.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", @@ -16974,7 +15731,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ang="Incompatible elements for HOMARD" ), # ) ; -#& MODIF COMMANDE DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA +#& MODIF COMMANDE DATE 25/09/2006 AUTEUR MJBHHPE J.L.FLEJOU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -17136,9 +15893,43 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma NUME_INST_FIN =SIMP(statut='f',typ='I'), INST_FIN =SIMP(statut='f',typ='R'), PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ), - SUBD_PAS =SIMP(statut='f',typ='I',defaut=1), - SUBD_PAS_MINI =SIMP(statut='f',typ='R'), - COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS ), THETA_3D =FACT(statut='f',max='**', @@ -17333,7 +16124,7 @@ MACR_ASCOUF_MAIL=MACRO(nom="MACR_ASCOUF_MAIL",op=macr_ascouf_mail_ops,sd_prod=ma INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA +#& MODIF COMMANDE DATE 25/09/2006 AUTEUR MJBHHPE J.L.FLEJOU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -17521,9 +16312,43 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_ NUME_INST_FIN =SIMP(statut='f',typ='I'), INST_FIN =SIMP(statut='f',typ='R'), PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ), - SUBD_PAS =SIMP(statut='f',typ='I',defaut=1), - SUBD_PAS_MINI =SIMP(statut='f',typ='R'), - COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS ), PAS_AZIMUT =SIMP(statut='f',typ='I',defaut=1), @@ -17653,10 +16478,93 @@ MACR_ASPIC_MAIL=MACRO(nom="MACR_ASPIC_MAIL",op= macr_aspic_mail_ops,sd_prod=mail INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), ) ; -#& MODIF COMMANDE DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG +# 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. +# ====================================================================== +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' ),), + BASE_MODALE =SIMP(statut='o',typ=base_modale ), + MATR_RIGI =SIMP(statut='f',typ=matr_asse_depl_r ), + 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='**'), + OPTION =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","RITZ", + "DIAG_MASS") ), +) ; +#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA +# 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. +# ====================================================================== +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) ), + ), + 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', + ), + 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 07/11/2006 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 @@ -17671,144 +16579,223 @@ MACR_ASPIC_MAIL=MACRO(nom="MACR_ASPIC_MAIL",op= macr_aspic_mail_ops,sd_prod=mail # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +# RESPONSABLE thomasso D.THOMASSON +# +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 25/04/2006 AUTEUR CIBHHPD L.SALMONA +# 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. +# ====================================================================== -from Macro.macr_cabri_calc_ops import macr_cabri_calc_ops - -def macr_cabri_calc_prod(self,MODELE_THER,MODELE_MECA,CHAM_MATER, - CHAR_THER,CHAR_MECA,RESU_THER,**args): - if MODELE_THER != None: - self.type_sdprod(MODELE_THER,modele_sdaster) - if MODELE_MECA != None: - self.type_sdprod(MODELE_MECA,modele_sdaster) - if RESU_THER != None: - self.type_sdprod(RESU_THER,evol_ther) - if CHAM_MATER != None: - self.type_sdprod(CHAM_MATER,cham_mater) - if CHAR_THER != None: - for m in CHAR_THER: - self.type_sdprod(m['CHARGE'],char_ther) - if CHAR_MECA != None: - for m in CHAR_MECA: - self.type_sdprod(m['CHARGE'],char_meca) - return evol_noli +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 avec X-FEM", + MODELE =SIMP(statut='o',typ=modele_sdaster), + DEFI_FISS =FACT(statut='o',max=01, + regles =(UN_PARMI('GROUP_MA_FISS','FONC_LT'), + ENSEMBLE('FONC_LT','FONC_LN'), + ENSEMBLE('GROUP_MA_FISS','GROUP_MA_FOND')), + FONC_LT =SIMP(statut='f',typ=(fonction_sdaster,formule) ), + FONC_LN =SIMP(statut='f',typ=(fonction_sdaster,formule) ), + GROUP_MA_FISS =SIMP(statut='f',typ=grma,max=01), + GROUP_MA_FOND =SIMP(statut='f',typ=grma), + ), + GROUP_MA_ENRI =SIMP(statut='o',typ=grma,max=01), + RAYON_ENRI =SIMP(statut='f',typ='R',defaut=0.E+0), + ORIE_FOND =FACT(statut='f',max=01, + PFON_INI =SIMP(statut='o',typ='R',max=03), + VECT_ORIE =SIMP(statut='o',typ='R',max=03), + PT_ORIGIN =SIMP(statut='o',typ='R',max=03), + ), + CONTACT =FACT(statut='f',max=01, + NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",) ), + FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ), + INTEGRATION =SIMP(statut='f',typ='TXM',defaut="FPG4",into=("GAUSS","FPG4","FPG6","FPG7",) ), + COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0), + MODL_AXIS =SIMP(statut='f',typ='TXM',into=("NON",)), + ITER_CONT_MAXI =SIMP(statut='f',typ='I',defaut=30), + 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), + b_frottement =BLOC(condition = "FROTTEMENT == 'COULOMB' ",fr="Paramères 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), + SEUIL_INIT =SIMP(statut='f',typ='R',defaut=0.E+0),), + ), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,3,) ), +) ; +#& MODIF COMMANDE DATE 30/10/2006 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 GNICOLAS G.NICOLAS -MACR_CABRI_CALC=MACRO(nom="MACR_CABRI_CALC", - op=macr_cabri_calc_ops, - sd_prod=macr_cabri_calc_prod, - fr="Calcul thermo-mécanique d'une jonction boulonnée de tuyauterie", - reentrant='n', - UIinfo={"groupes":("Outils métier",)}, - MAILLAGE = SIMP(statut='o',typ=maillage_sdaster,), - AFFE_MATERIAU = FACT(statut='o',max='**', - regles=(UN_PARMI('TOUT','GROUP_MA',),), - TOUT = SIMP(statut='f',typ='TXM',into=("OUI",) ), - GROUP_MA = SIMP(statut='f',typ='TXM',into=( - "BRIDE", - "GOUJON", - "ROND", - "ECROU", - "JOINT",) ), - MATER = SIMP(statut='o',typ=mater_sdaster), - TEMP_REF = SIMP(statut='d',typ='R',defaut= 25. ), - ), - CHAM_MATER = SIMP(statut = 'f',typ=CO,), - MODELE_THER= SIMP(statut = 'f',typ=CO,), - - DEFI_CHAR_THER = FACT(statut ='d', - TEMP_INIT = SIMP(statut='d',typ='R',defaut= 25.,), - COEF_H_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), - TEMP_EXT_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), - COEF_H_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), - TEMP_EXT_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), - LIST_INST = SIMP(statut='f',typ=listr8_sdaster), - ), - - CHAR_THER = FACT(statut = 'f',max=4, - CHARGE = SIMP(statut='o',typ=CO), - TYPE = SIMP(statut='o',typ='TXM', - into=("BRIDE_FLUIDE","BRIDE_AIR","ECROU_GOUJON", - "BRIDE_JOINT"),) - ), - - RESU_THER = SIMP(statut = 'f',typ=CO,), - - - MODELE_MECA= SIMP(statut = 'f',typ=CO,), - - DEFI_CHAR_MECA = FACT(statut='o', - PRETENS = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), - PRES_REP = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), - EFFE_FOND = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), - ), - - CHAR_MECA = FACT(statut = 'f',max=11, - CHARGE = SIMP(statut='o',typ=CO), - TYPE = SIMP(statut='o',typ='TXM', - into=("BLOC_BAS_GOUJ","BLOC_BAS_JOINT", - "BLOC_LAT_ALES","BLOC_LAT_NALES", - "PLAN_TUBE", - "PRES_FLU","EFFET_FOND", - "CONT_JOINT", - "DEFO_THER", - "SERR_ECROU_1","SERR_ECROU_2",),) - ), - - RELATION = SIMP(statut='f',typ='TXM', - into=('VMIS_ISOT_TRAC','ELAS','ELAS_VMIS_TRAC',),), - - SOLVEUR = FACT(statut='d', - METHODE = SIMP(statut='d',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT",) ), - b_mult_front = BLOC(condition = "METHODE == 'MULT_FRONT' ", - fr="Paramètres de la méthode multi frontale", - RENUM = SIMP(statut='d',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ), - NPREC = SIMP(statut='d',typ='I',defaut=8), - STOP_SINGULIER = SIMP(statut='d',typ='TXM',defaut="OUI",into=("OUI","NON") ), - ), - ), - INCREMENT = FACT(statut='f', - regles=(EXCLUS('NUME_INST_INIT','INST_INIT'), - EXCLUS('NUME_INST_FIN','INST_FIN'),), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE", - into=("CHRONOLOGIQUE",) ), - 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-3 ), - SUBD_PAS =SIMP(statut='f',typ='I',defaut=1), - SUBD_PAS_MINI =SIMP(statut='f',typ='R'), - COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0), - OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),), - NOM_CHAM =SIMP(statut='f',typ='TXM',), - NOM_CMP =SIMP(statut='f',typ='TXM',), - VALE =SIMP(statut='f',typ='R'), - ), - NEWTON =FACT(statut='d', - REAC_INCR =SIMP(statut='f',typ='I',defaut= 1 ), - PREDICTION =SIMP(statut='f',typ='TXM',into=("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), - EVOL_NOLI =SIMP(statut='f',typ=evol_noli), - ), - RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", - into=("IMPLICITE",)), - CONVERGENCE =FACT(statut='d', - regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),), - SIGM_REFE =SIMP(statut='f',typ='R'), - EPSI_REFE =SIMP(statut='f',typ='R'), - FLUX_THER_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), - ), - ); +from Macro.macr_adap_mail_ops import macr_adap_mail_ops -#& MODIF COMMANDE DATE 07/02/2005 AUTEUR MABBAS M.ABBAS +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)), +# +# 2. Version de HOMARD +# + VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_5", + into=("V8_5", "V8_N", "V8_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 = 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 10/10/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -17826,144 +16813,173 @@ MACR_CABRI_CALC=MACRO(nom="MACR_CABRI_CALC", # 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_cabri_mail_ops import macr_cabri_mail_ops +from Macro.calc_precont_ops import calc_precont_ops -MACR_CABRI_MAIL=MACRO(nom="MACR_CABRI_MAIL", - op=macr_cabri_mail_ops, - sd_prod=maillage_sdaster, - fr="maillage d'une jonction boulonnée de tuyauterie", - reentrant='n', - UIinfo={"groupes":("Outils métier",)}, - EXEC_MAILLAGE = FACT(statut='o', - LOGICIEL = SIMP(statut = 'o',typ='TXM',into=("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), - ), - ), - RAFF_MAILLAGE = FACT(statut = 'd', - NB_RADIAL = SIMP(statut = 'f',typ='I',defaut=2,), - NB_CIRCONF = SIMP(statut = 'f',typ='I',defaut=3,), - NB_VERTICAL = SIMP(statut = 'f',typ='I',defaut=6,), - NB_ALESAGE = SIMP(statut = 'f',typ='I',defaut=5,), - ), - 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 ), - ), - GEOM_BRID = FACT(statut = 'o', - NORME = SIMP(statut = 'o',typ='TXM',into=("OUI","NON"),), - b_bride_iso = BLOC(condition = "NORME == 'OUI'", - TYPE = SIMP(statut='o',typ='TXM', - into=('A','AA','B','B1','C','D','D1','E','F', - 'FF','G','GG','H','H1','I','J','J1', - 'K','L','L1','M','N','O','P','S','T','W'), - ), - ), - b_bride_niso = BLOC(condition = "NORME == 'NON'", - TUBU_D_EXT = SIMP(statut='o',typ='R',), - TUBU_H = SIMP(statut='o',typ='R',), - BRID_D_EXT = SIMP(statut='o',typ='R',), - BRID_D_INT = SIMP(statut='o',typ='R',), - BRID_H = SIMP(statut='o',typ='R',), - BRID_D_CONGE = SIMP(statut='o',typ='R',), - BRID_R_CONGE = SIMP(statut='o',typ='R',), - BRID_D_EPAUL = SIMP(statut='o',typ='R',), - BRID_H_EPAUL = SIMP(statut='o',typ='R',), - BRID_D_ALESAG = SIMP(statut='o',typ='R',), - BRID_P_ALESAG = SIMP(statut='o',typ='R',), - BRID_H_ALESAG = SIMP(statut='o',typ='R',), - GOUJ_N_GOUJON = SIMP(statut='o',typ='I',), - GOUJ_D_GOUJON = SIMP(statut='o',typ='R',), - GOUJ_E_FILET = SIMP(statut='o',typ='R',), - GOUJ_D_RONDEL = SIMP(statut='o',typ='R',), - GOUJ_E_RONDEL = SIMP(statut='o',typ='R',), - GOUJ_D_ECROU = SIMP(statut='o',typ='R',), - GOUJ_E_ECROU = SIMP(statut='o',typ='R',), - ETAN_E_JOINT = SIMP(statut='o',typ='R',), - ), - ), - IMPRESSION = FACT(statut='d', - UNITE = SIMP(statut='f',typ='I'), - FORMAT = SIMP(statut='f',typ='TXM',defaut="ASTER", - into=("ASTER","CASTEM","IDEAS"), - ), - b_impr_castem = BLOC(condition = "FORMAT == 'CASTEM'", - NIVE_GIBI = SIMP(statut='f',typ='I',defaut=10,into=(3,10),), - ), - b_impr_ideas = BLOC(condition = "FORMAT == 'IDEAS'", - VERSION = SIMP(statut='f',typ='I',defaut=5,into=(4,5),), - ), - ), - ); -#& MODIF COMMANDE DATE 03/01/2006 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 JMBHH01 J.M.PROIX +# =========================================================================== +# CATALOGUE DE LA MACRO "CALC_PRECONT" +# ----------------------------------------- +# USAGE : +# +# +# =========================================================================== -from Macro.macr_cara_poutre_ops import macr_cara_poutre_ops +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 =FACT(statut='o', + LIST_INST =SIMP(statut='o',typ=listr8_sdaster), + INST_INIT =SIMP(statut='f',typ='R'), + INST_FIN =SIMP(statut='f',typ='R'), + PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + ), -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'),), - - UNITE_MAILLAGE =SIMP(statut='f',typ='I',defaut= 20 ), - 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", + 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), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + ), + RECH_LINEAIRE =FACT(statut='f', + RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ), + ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 3), + ), + 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), + ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25), + ARRET =SIMP(statut='f',typ='TXM',defaut="OUI"), + ), + ETAT_INIT =FACT(statut='f', + regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','SIGM','VARI','VARI_NON_LOCAL',), + EXCLUS('EVOL_NOLI','DEPL',), + EXCLUS('EVOL_NOLI','SIGM',), + EXCLUS('EVOL_NOLI','VARI',), + EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), + 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), + VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + NUME_ORDRE =SIMP(statut='f',typ='I'), + INST =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") ), + NUME_DIDI =SIMP(statut='f',typ='I'), + INST_ETAT_INIT =SIMP(statut='f',typ='R'), + ), + SOLVEUR =FACT(statut='d', + METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), + 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","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 ), + ), + SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), + ), + SOLV_NON_LOCAL =FACT(statut='f', + METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), + 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") ), + ), + 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 ), + RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), + NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), + ), + EPS =SIMP(statut='f',typ='R',defaut= 0.E+0 ), + ), + LAGR_NON_LOCAL =FACT(statut='f', + ITER_DUAL_MAXI =SIMP(statut='f',typ='I',defaut= 50), + RESI_DUAL_ABSO =SIMP(statut='o',typ='R'), + RESI_PRIM_ABSO =SIMP(statut='o',typ='R'), + R =SIMP(statut='f',typ='R',defaut= 1000.), + ITER_PRIM_MAXI =SIMP(statut='f',typ='I',defaut= 10), + ), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), + TITRE =SIMP(statut='f',typ='TXM',max='**' ), - NOEUD =SIMP(statut='f',typ=no,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" ), - ), - ) + EXCIT =FACT(statut='o',max='**', + CHARGE =SIMP(statut='o',typ=char_meca), + ), + + COMP_INCR =C_COMP_INCR(), + ) ; #& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# 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 @@ -17979,50 +16995,38 @@ MACR_CARA_POUTRE=MACRO(nom="MACR_CARA_POUTRE",op=macr_cara_poutre_ops,sd_prod=ta # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== - -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='**', - into=("SIEF_ELGA","VARI_ELGA","SIEF_ELGA_DEPL","FLUX_ELGA_TEMP",) ), - - # 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), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ), - ) -#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE +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 04/04/2006 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -18040,71 +17044,77 @@ MACR_ECLA_PG=MACRO(nom="MACR_ECLA_PG",op=macr_ecla_pg_ops,sd_prod=macr_ecla_pg_p # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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' ),), - BASE_MODALE =SIMP(statut='o',typ=base_modale ), - MATR_RIGI =SIMP(statut='f',typ=matr_asse_depl_r ), - 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='**'), - OPTION =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","RITZ", - "DIAG_MASS") ), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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. -# ====================================================================== -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', - 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), - ), - 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', +# RESPONSABLE G8BHHXD 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), ), - 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), + 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 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# 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 @@ -18119,440 +17129,2428 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant= # 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 +# RESPONSABLE D6BHHJP 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) -from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops +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", -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 04/10/2005 AUTEUR REZETTE C.REZETTE + 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 21/02/2006 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. +# 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_fiabilite_ops import macr_fiabilite_ops +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_stat_depl,mode_stat_acce,mode_stat_forc,),), + 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") ), + 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 iversibilité de la matrice à factorise", + 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 ), + ), + ), + 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 12/06/2006 AUTEUR CIBHHLV L.VIVAN +# 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. # -#==== -# 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 +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - SEUIL = SIMP(statut="o",typ="R",max=1, - fr="Le seuil de défaillance.", - ang="Failure threshold."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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","MASS_ID_MDEP_R","MASS_ID_MDNS_R", + "ONDE_FLUI","MASS_MECA_DIAG" ) : 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","MASS_ID_MTEM_R","MASS_ID_MTNS_R",) : 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=("LDLT","MULT_FRONT","GCPC","MUMPS")), + RENUM =SIMP(statut='f',typ='TXM',into=("SANS","RCMK","MD","MDA","METIS")), + ), + + 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", + "RIGI_THER","MASS_THER", + "RIGI_ACOU","MASS_ACOU","AMOR_ACOU", + "MASS_ID_MTEM_R","MASS_ID_MTNS_R","MASS_ID_MDEP_R","MASS_ID_MDNS_R",) + ), + + 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 19/09/2006 AUTEUR ACBHHCD 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. # -# 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 +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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_2","V1_3",),defaut="V1_2"), + 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='**'), + ), +) ; +#& MODIF COMMANDE DATE 03/01/2006 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. # - b_rech_pt_concept=BLOC( condition = "RECH_PT_CONCEPT=='OUI'", +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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='**',val_min=0.E+0 ), + 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='**', + MASS_INER =SIMP(statut='o',typ=table_sdaster), + 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 21/02/2006 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. # - 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."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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_stat,base_modale,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 22/06/2005 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. # - 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."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - ITER_MAX = SIMP(statut="f",typ="I",defaut=50, - fr="Nombre maximum d'itérations.", - ang="Maximum number of iterations."), - ), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +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 12/06/2006 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. # -# 6.2.2. ==> Méthode(s) employée(s) pour la probabilité de défaillance +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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 +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# 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 +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") ), + + 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), + 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_ldlt_mult =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' or METHODE == 'FETI' ", + 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") ), + ), + + 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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,), + ), + ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), +) ; +#& MODIF COMMANDE DATE 10/06/2004 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. # - 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."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - b_plan_experience=BLOC( condition = "PLAN_EXPERIENCE=='OUI'", +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# 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 +MEMO_NOM_SENSI=PROC(nom="MEMO_NOM_SENSI",op=129, + UIinfo={"groupes":("Fonction",)}, + fr="Mémorisation des noms des concepts dérivés.", + ang="Memorisation of the names of the sensitive concepts.", + + regles=(AU_MOINS_UN('NOM','NOM_ZERO','NOM_UN'),), + + NOM=FACT(statut='f',max='**', + regles=(PRESENT_PRESENT('MOT_CLE','VALEUR','MOT_FACT' ),), + + NOM_SD=SIMP(statut='o',typ='TXM', + fr="Nom de la structure de base", + ang="Name of the basic structure"), + + PARA_SENSI=SIMP(statut='o',typ=(para_sensi,theta_geom), + fr="Nom du paramètre sensible", + ang="Name of the sensitive parameter"), + + NOM_COMPOSE=SIMP(statut='f',typ='TXM',defaut=" ", + fr="Nom de la structure composée", + ang="Name of the built structure"), + + MOT_FACT=SIMP(statut='f',typ='TXM',max='**', + fr="Liste des mots clés facteurs concernés par la dérivation", + ang="Factor keyword list involved in derivation"), + + MOT_CLE=SIMP(statut='f',typ='TXM',max='**', + fr="Liste des mots clés concernés par la dérivation", + ang="Keyword list involved in derivation"), + + VALEUR=SIMP(statut='f',typ='TXM',max='**', + fr="Liste des objets concernés par la dérivation", + ang="Object list involved in derivation"), + + ), + + NOM_ZERO=SIMP(statut='f',typ=fonction_sdaster, + fr="Nom de la fonction nulle", + ang="Name of the zero fonction"), + + NOM_UN =SIMP(statut='f',typ=fonction_sdaster, + fr="Nom de la fonction unité", + ang="Name of the one fonction"), + +) ; +#& MODIF COMMANDE DATE 22/06/2005 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. # - 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."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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_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=base_modale ), + 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', + 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 10/05/2006 AUTEUR MCOURTOI 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. # -# 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.") - ), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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 10/05/2006 AUTEUR MCOURTOI 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. # -# 6.2.5.2. ==> Test du maximum fort +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - T_MAXIMUM_FORT = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"), - fr="Test du maximum fort.", - ang="Strong maximum test."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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 + 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_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") ), + 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 ), + ), + 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"), + 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"), + 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 22/06/2005 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. # - b_test_du_maximum_fort=BLOC( condition = "T_MAXIMUM_FORT=='OUI'", +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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.") -# - ), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 mode_stat_prod(MODE_STAT,FORCE_NODALE,PSEUDO_MODE,**args): + if (MODE_STAT != None) : return mode_stat_depl + if (PSEUDO_MODE !=None) : return mode_stat_acce + if (FORCE_NODALE != None) : return mode_stat_forc + raise AsException("type de concept resultat non prevu") +MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_stat_prod, + fr="Calcul de modes 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='**'), + ), + ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ,) ), +) ; +#& MODIF COMMANDE DATE 22/06/2005 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. # -# 6.2.5.3. ==> Test du hessien +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - T_HESSIEN = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"), - fr="Test du hessien.", - ang="Hessian test."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +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 10/07/2006 AUTEUR LEBOUVIE 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. # -# 6.2.6. ==> Les correlations entre les variables +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - MATRICE = SIMP(statut="f",typ="R",max="**", - fr="Matrice de corrélation entre les variables.", - ang="Correlation matrix."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE G8BHHXD X.DESROCHES +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_SHB8','SYMETRIE', + ), + PRESENT_ABSENT('ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D', + 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), + PRESENT_ABSENT('DEFORME','ORIE_FISSURE','EQUE_PIQUA','ORIE_PEAU_2D', + 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), + PRESENT_ABSENT('EQUE_PIQUA','ORIE_FISSURE','DEFORME','ORIE_PEAU_2D', + 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), + PRESENT_ABSENT('ORIE_PEAU_2D','ORIE_FISSURE','DEFORME','EQUE_PIQUA', + 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), + 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',), + PRESENT_ABSENT('PLAQ_TUBE','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D', + 'ORIE_PEAU_3D','ORIE_NORM_COQUE','MODI_MAILLE',), + PRESENT_ABSENT('MODI_MAILLE','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D', + 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE',), + 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='**'), + ), + ORIE_PEAU_3D =FACT(statut='f',max='**', + GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), + ), + ORIE_SHB8 =FACT(statut='f',max=1, + GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), + ), + ORIE_NORM_COQUE =FACT(statut='f',max='**', + regles=(EXCLUS('NOEUD','GROUP_NO'), + PRESENT_PRESENT('NOEUD','VECT_NORM'), + PRESENT_PRESENT('GROUP_NO','VECT_NORM'),), + GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), + VECT_NORM =SIMP(statut='f',typ='R',max=3), + 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 10/10/2006 AUTEUR MCOURTOI 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. # -### en attente de résolution de AL 2004-006 (2/2) ), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # -#==== -# 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."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +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 12/09/2005 AUTEUR CIBHHLV L.VIVAN +# 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. # -# 7.2. ==> Loi de distribution +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - LOI = SIMP(statut="o",typ="TXM", - into=("UNIFORME","NORMALE","LOGNORMALE","NORMALE_TRONQUEE"), - fr="Choix de la loi", - ang="Law."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# 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 modi_repere_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) == mode_meca : return mode_meca + if AsType(RESULTAT) == mode_flamb : return mode_flamb + if AsType(RESULTAT) == mult_elas : return mult_elas + if AsType(RESULTAT) == base_modale : return base_modale + raise AsException("type de concept resultat non prevu") + +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=(evol_elas,dyna_trans,dyna_harmo,mode_meca, + evol_noli,mult_elas, + evol_ther,base_modale,mode_flamb) ), + 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), + + PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),), + + 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 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA +# 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. # -# 7.2.1. ==> Loi normale +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - b_normale=BLOC(condition="LOI=='NORMALE'", +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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 + if AsType(MODE) == base_modale : return base_modale + 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,base_modale) ), + 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='**'), + MASS_INER =SIMP(statut='f',typ=table_sdaster), + 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) ), + ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), +) ; +#& MODIF COMMANDE DATE 12/06/2006 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. # - VALE_MOY = SIMP(statut="o",typ="R",max=1, - fr="Valeur moyenne.", - ang="Mean value."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - ECART_TYPE = SIMP(statut="o",typ="R",max=1, - fr="Ecart type.", - ang="Standard deviation."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# 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 +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","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'",fr="paramètres associés à la méthode gradient conjugué", + RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ), + ), + INFO =SIMP(statut='f',typ='I',into=(1,2)), +) ; +#& MODIF COMMANDE DATE 22/06/2005 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. # -# 7.2.2. ==> Loi lognormale +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +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_stat,base_modale,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 10/10/2006 AUTEUR MCOURTOI 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. # - b_lognormale=BLOC(condition="LOI=='LOGNORMALE'", +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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'", +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC 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 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('NOEUD_I','NUME_ORDRE_I','OPTION'),), + INTE_SPEC =SIMP(statut='o',typ=table_fonction), + 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 03/01/2006 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. # - 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."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - 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."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +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 12/09/2006 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. # - VALE_MIN = SIMP(statut="o",typ="R",max=1, - fr="Valeur minimale.", - ang="Minimal value."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - VALE_MAX = SIMP(statut="o",typ="R.",max=1, - fr="Valeur maximale.", - ang="Maximal value."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE G8BHHXD 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', + 'WEIBULL', 'RICE_TRACEY', 'CARA_GEOM','CHAR_LIMITE', + 'CARA_POUTRE', 'INDIC_ENER', 'INDIC_SEUIL', + 'AIRE_INTERNE','ENER_ELAS','ENER_TOTALE','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_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) ), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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) ), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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) ), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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_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'),), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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'),), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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='o',typ='TXM',into=C_NOM_CHAM_INTO()), + NOM_CMP = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'), + ), + b_integrale = BLOC(condition = "( INTEGRALE != None )", + fr="calcul de la moyenne d'une composante", + regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),), + MODELE = SIMP(statut='f',typ=modele_sdaster), + RESULTAT = SIMP(statut='o',typ=(evol_noli,evol_ther,evol_elas) ), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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) ), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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) ), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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'),), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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'),), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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'),), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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_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_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) ), + PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + 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 03/01/2006 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. # -# 7.3. ==> Paramètres de calcul -# 7.3.1. ==> Soit on cherche le point de conception, soit on le connait deja +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +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 03/01/2006 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. # - regles=(EXCLUS("POINT_INI","POINT_CONCEPT"), - EXCLUS("POINT_REF","POINT_CONCEPT"),), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # -# 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. +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +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 03/01/2006 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. # - 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."), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # -# 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. +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# +# +# ====================================================================== # - 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."), +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 09/05/2006 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. # -# 7.3.4. ==> Quand on cherche uniquement la probabilité de défaillance, il faut donner le point de conception +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # - POINT_CONCEPT = SIMP(statut="f",typ="R",max=1, - fr="Point de conception.", - ang="Design point."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# 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'), + 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), + 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' ,defaut=5 ), + 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",) ) + ), + 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="Table 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='f',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)", + PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + ), + 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='o',typ='R',max=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/10/2006 AUTEUR CIBHHLV L.VIVAN +# 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. # -# 7.4. ==> Mode d'obtention du gradient par rapport à ce paramètre +# THIS PROGRAM IS 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 # - 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."), +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# 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 +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_gradient=BLOC(condition="GRADIENT=='NON'", - INCREMENT = SIMP(statut="o",typ="R",max=1, - fr="Incrément dans la direction.", - ang="Direction increment."), - ), +# ====================================================================== + b_evolution =BLOC(condition="(TYPE_RESU_MECA == 'EVOLUTION')", + + OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', + into=("PM_PB","SN","FATIGUE_ZH210") ), + MATER =SIMP(statut='o',typ=mater_sdaster ), + SY_MAX =SIMP(statut='f',typ='R', + fr="limite élastique utilisée pourle calcul du rochet thermique" ), + + TRANSITOIRE =FACT(statut='o',max='**',fr="transitoire à dépouiller", + regles=(EXCLUS('TOUT_ORDRE','INST','LIST_INST'),), + NB_OCCUR =SIMP(statut='f',typ='I',defaut= 1, + fr="nombre d occurences réelles de ce transitoire" ), + TABL_RESU_MECA =SIMP(statut='o',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" ), + 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)" , + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("ABSOLU","RELATIF") ), + ), + ), + ), + +# ====================================================================== + 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" ), + TYPE_CHAR =SIMP(statut='f',typ='TXM',fr="nature du chargement",into=( "SEISME","AUTRE"),defaut="AUTRE",), + 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" ), + ), + SITUATION =FACT(statut='o',max='**',fr="Situation",ang="situation_ang", + NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ), + NB_CYCL_SEISME =SIMP(statut='f',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" ), + COMBINABLE =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ), + NUME_GROUPE =SIMP(statut='o',typ='I',fr="numéro du groupe de la situation" ), + NUME_PASSAGE =SIMP(statut='f',typ='I',max=2,fr="numéro des deux groupes en relation" ), + 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"), + ), + ), +# ====================================================================== + b_tuyauterie =BLOC(condition="(TYPE_RESU_MECA == 'TUYAUTERIE')", - ), -# -); -#& MODIF COMMANDE DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS -# CONFIGURATION MANAGEMENT OF EDF VERSION + 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" ), + TYPE_CHAR =SIMP(statut='f',typ='TXM',fr="nature du chargement",into=( "SEISME","AUTRE"),defaut="AUTRE",), + 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)", + PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU"), ), + ), + ), + ), + 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='**'), + ), + ), + SITUATION =FACT(statut='o',max='**',fr="Situation",ang="situation_ang", + NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ), + NB_CYCL_SEISME =SIMP(statut='f',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" ), + COMBINABLE =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ), + NUME_GROUPE =SIMP(statut='o',typ='I',fr="numéro du groupe de la situation" ), + NUME_PASSAGE =SIMP(statut='f',typ='I',max=2,fr="numéro des deux groupes en relation" ), + 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/09/2006 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 @@ -18568,191 +19566,116 @@ MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops, # 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 +# RESPONSABLE G8BHHXD 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", + UIinfo={"groupes":("Post traitements",)}, -from Macro.macr_adap_mail_ops import macr_adap_mail_ops + ACTION =FACT(statut='o',max='**', + regles=(UN_PARMI('RESULTAT','CHAM_GD'),), -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)), -# -# 2. Version de HOMARD -# - VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_2", - into=("V8_2", "V8_N", "V8_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 = 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="OUI",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 09/05/2006 AUTEUR GALENNE E.GALENNE -# 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. -# ====================================================================== + OPERATION =SIMP(statut='o',typ='TXM',into=("EXTRACTION","MOYENNE","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=(evol_elas,evol_ther,evol_noli,dyna_trans, + mode_meca,mode_flamb,mode_acou,base_modale,mode_stat, + mult_elas,fourier_elas,fourier_ther,dyna_harmo,acou_harmo)), + + 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"), + ), + + 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), + PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + ), -from Macro.macr_lign_coupe_ops import macr_lign_coupe_ops + 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='**'), + ), -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", - RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,evol_ther) ), -# 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' ), - ), - UNITE_MAILLAGE =SIMP(statut='f',typ='I',defaut=25), - MODELE =SIMP(statut='f',typ=modele_sdaster ), - GROUP_MA =SIMP(statut='f',typ=grma), - MAILLE =SIMP(statut='f',typ=ma,max='**'), - regles=(EXCLUS('GROUP_MA','MAILLE'),), - LIGN_COUPE =FACT(statut='o',max='**', - regles=(UN_PARMI('NB_POINTS','GROUP_NO'),), - INTITULE =SIMP(statut='f',typ='TXM',), - GROUP_NO =SIMP(statut='f',typ=grno), - NB_POINTS =SIMP(statut='f',typ='I'), - b_nbpts = BLOC(condition = "NB_POINTS != None", - COOR_ORIG =SIMP(statut='o',typ='R',min=2,max=3), - COOR_EXTR =SIMP(statut='o',typ='R',min=2,max=3), - VECT_Y =SIMP(statut='f',typ='R',min=2,max=3),), - ), -) ; + b_autre =BLOC(condition="OPERATION != 'EXTREMA'", + 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='**'), -#& MODIF COMMANDE DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== - -from Macro.macr_recal_ops import macr_recal_ops + 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), -def macr_recal_prod(self,**args ): - return listr8_sdaster + 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")), + ), -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='**'), - ITER_MAXI =SIMP(statut='f',typ='I',defaut=10), - 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='d', - UNITE =SIMP(statut='f',typ='I',defaut=90), - FORMAT =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT")), - INTERACTIF =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")),), - INFO =SIMP(statut='f',typ='I',defaut=1,into=( 1, 2 ) ), + 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 04/04/2006 AUTEUR CIBHHLV L.VIVAN +#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -18770,74 +19693,108 @@ MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE G8BHHXD 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") ), +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'), ), - 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") ), + 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",)), ), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2)), - TITRE =SIMP(statut='f',typ='TXM',max='**'), + 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 21/02/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -18855,95 +19812,34 @@ MACRO_ELAS_MULT=MACRO(nom="MACRO_ELAS_MULT",op=macro_elas_mult_ops,sd_prod=macro # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== - -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), +POST_ZAC=OPER(nom="POST_ZAC",op= 175,sd_prod=mult_elas,reentrant='n', + UIinfo={"groupes":("Post traitements",)}, + fr="Déterminer l'état adapté ou accommodé par la méthode de Zarka-Casier d'une structure sous" + +" chargement cyclique élastique affine ou non", + MODELE =SIMP(statut='o',typ=modele_sdaster), + CHAM_MATER =SIMP(statut='o',typ=cham_mater), + EXCIT =FACT(statut='o',max='**', + CHARGE =SIMP(statut='o',typ=char_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",)), ), - 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_stat_depl,mode_stat_acce,mode_stat_forc,),), - 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), + EVOL_ELAS =SIMP(statut='o',typ=evol_elas), + b_evol_elas =BLOC(condition="EVOL_ELAS != None", + regles=(UN_PARMI('NUME_ORDRE','LIST_INST','INST'),), + NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), ), - SOLVEUR =FACT(statut='d', - METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), - 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 iversibilité de la matrice à factorise", - 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 ), - ), + TEMP_ZAC =SIMP(statut='f',typ='R',defaut=0.0E+0), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + b_evol_noli =BLOC(condition="EVOL_NOLI != None", + INST_MAX =SIMP(statut='o',typ='R'), ), - 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 16/05/2006 AUTEUR REZETTE C.REZETTE + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), + +) ; +#& MODIF COMMANDE DATE 19/06/2006 AUTEUR VABHHTS J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -18961,86 +19857,111 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== - -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","MASS_ID_MDEP_R","MASS_ID_MDNS_R", - "ONDE_FLUI","MASS_MECA_DIAG" ) : 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","MASS_ID_MTEM_R","MASS_ID_MTNS_R",) : 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='**'), - NUME_DDL =SIMP(statut='o',typ=(nume_ddl_sdaster,CO)), - SOLVEUR =FACT(statut='d', - METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT", - into=("LDLT","MULT_FRONT","GCPC","MUMPS")), - RENUM =SIMP(statut='f',typ='TXM',into=("SANS","RCMK","MD","MDA","METIS")), +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'),defaut='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',)), + ), + MEMOIRE =FACT(fr="mode de gestion mémoire utilisé",statut='f',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' ), + ), + RESERVE_CPU =FACT(fr="reserve de temps pour terminer une execution",statut='f',max=1, + regles=(EXCLUS('VALE','POURCENTAGE'),), + VALE =SIMP(statut='f',typ='I',val_min=0), + POURCENTAGE =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0), +# valeur en pourcentage du temps maximum bornée à 180 secondes + BORNE =SIMP(statut='f',typ='I',val_min=0,defaut=180) + ), + CODE =FACT("définition d un nom pour l'esemble d'une étude", + statut='f',min=1,max=1, + NOM =SIMP(statut='o',typ='TXM'), + UNITE =SIMP(statut='f',typ='I',defaut=15), + ), +) ; +#& MODIF COMMANDE DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS +# 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. +# ====================================================================== - 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", - "RIGI_THER","MASS_THER", - "RIGI_ACOU","MASS_ACOU","AMOR_ACOU", - "MASS_ID_MTEM_R","MASS_ID_MTNS_R","MASS_ID_MDEP_R","MASS_ID_MDNS_R",) - ), - - 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), - ), +# RESPONSABLE MCOURTOI M.COURTOIS - b_rigi_meca_lagr = BLOC( condition = "OPTION=='RIGI_MECA_LAGR'", - THETA =SIMP(statut='o',typ=theta_geom), - PROPAGATION =SIMP(statut='f',typ='R'), - ), +from Macro.test_fichier_ops import test_fichier_ops - b_rigi_ther = BLOC( condition = "OPTION=='RIGI_THER'", - MODE_FOURIER =SIMP(statut='f',typ='I',defaut= 0), - ), +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)), + NB_CHIFFRE =SIMP(statut='o',typ='I',), # defaut=6 pas de defaut, il faut + EPSILON =SIMP(statut='o',typ='R',), # defaut=1.E-12 se poser la question ! + EXPR_IGNORE =SIMP(statut='f',typ='TXM',max='**', + fr="Liste d'expressions régulières permettant d'ignorer certaines lignes"), + VALE_K =SIMP(statut='o',typ='TXM' ), + REFERENCE =SIMP(statut='f',typ='TXM', + into=("ANALYTIQUE","SOURCE_EXTERNE","NON_REGRESSION","AUTRE_ASTER") ), - ), # fin MATR_ASSE + b_version =BLOC(condition = "REFERENCE == 'NON_REGRESSION'", + VERSION =SIMP(statut='f',typ='TXM' ), + ), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), -) ; -#& MODIF COMMANDE DATE 20/03/2006 AUTEUR ACBHHCD G.DEVESA + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), +) +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19058,54 +19979,13 @@ MACRO_MATR_ASSE=MACRO(nom="MACRO_MATR_ASSE",op=macro_matr_asse_ops, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== - -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_2","V1_3",),defaut="V1_2"), - 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'), - 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='**'), - ), +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 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19124,79 +20004,13 @@ MACRO_MISS_3D=MACRO(nom="MACRO_MISS_3D",op=macro_miss_3d_ops, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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='**',val_min=0.E+0 ), - 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='**', - MASS_INER =SIMP(statut='o',typ=table_sdaster), - 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",) ), - ), +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/02/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19214,42 +20028,48 @@ MACRO_MODE_MECA=MACRO(nom="MACRO_MODE_MECA",op=macro_mode_meca_ops,sd_prod=mode_ # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +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 15/05/2006 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. +# ====================================================================== -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 +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,mode_stat,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='c',typ='I',val_min=10,val_max=90, + fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit les md5"), -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_stat,base_modale,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 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19267,14 +20087,16 @@ MACRO_PROJ_BASE=MACRO(nom="MACRO_PROJ_BASE",op=macro_proj_base_ops, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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',), +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 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 12/09/2006 AUTEUR VABHHTS J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19293,149 +20115,104 @@ MAJ_CATA=PROC(nom="MAJ_CATA",op=20, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE VABHHTS 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") ), - - 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), - 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_ldlt_mult =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' or METHODE == 'FETI' ", - 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") ), - ), - - 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 ), - ), +def proj_champ_prod(RESULTAT=None,CHAM_NO_REFE=None,**args ): + if AsType(RESULTAT) == evol_ther : return evol_ther + if AsType(RESULTAT) == evol_elas : return evol_elas + if AsType(RESULTAT) == evol_noli : return evol_noli + if AsType(RESULTAT) == evol_char : return evol_char + if AsType(RESULTAT) == dyna_trans : return dyna_trans + if AsType(RESULTAT) == dyna_harmo : return dyna_harmo + if AsType(RESULTAT) == mode_meca : return mode_meca + if AsType(RESULTAT) == mode_stat_depl : return mode_stat_depl + if AsType(RESULTAT) == base_modale : return base_modale + if CHAM_NO_REFE != None : return cham_no_sdaster + raise AsException("type de concept resultat non prevu") - 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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6), - ), - ), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), -) ; -#& MODIF COMMANDE DATE 10/06/2004 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. +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", # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# 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 -MEMO_NOM_SENSI=PROC(nom="MEMO_NOM_SENSI",op=129, - UIinfo={"groupes":("Fonction",)}, - fr="Mémorisation des noms des concepts dérivés.", - ang="Memorisation of the names of the sensitive concepts.", + METHODE =SIMP(statut='f',typ='TXM',defaut="ELEM", + into=("NUAGE_DEG_0","NUAGE_DEG_1","ELEM",) ), + 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), + ), + 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=(evol_ther,evol_elas,evol_noli,dyna_trans,evol_char,dyna_harmo, + mode_meca,mode_stat_depl,base_modale) ), + 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), - regles=(AU_MOINS_UN('NOM','NOM_ZERO','NOM_UN'),), + 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='**'), - NOM=FACT(statut='f',max='**', - regles=(PRESENT_PRESENT('MOT_CLE','VALEUR','MOT_FACT' ),), +# POUR IMPOSER LA NUMEROTATION DES DDLS : +# ------------------------------------------------------------------ + NUME_DDL =SIMP(statut='f',typ=(nume_ddl_sdaster) ), - NOM_SD=SIMP(statut='o',typ='TXM', - fr="Nom de la structure de base", - ang="Name of the basic structure"), - PARA_SENSI=SIMP(statut='o',typ=(para_sensi,theta_geom), - fr="Nom du paramètre sensible", - ang="Name of the sensitive parameter"), + 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_COMPOSE=SIMP(statut='f',typ='TXM',defaut=" ", - fr="Nom de la structure composée", - ang="Name of the built structure"), - MOT_FACT=SIMP(statut='f',typ='TXM',max='**', - fr="Liste des mots clés facteurs concernés par la dérivation", - ang="Factor keyword list involved in derivation"), + 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."), + 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."), - MOT_CLE=SIMP(statut='f',typ='TXM',max='**', - fr="Liste des mots clés concernés par la dérivation", - ang="Keyword list involved in derivation"), + ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), - VALEUR=SIMP(statut='f',typ='TXM',max='**', - fr="Liste des objets concernés par la dérivation", - ang="Object list involved in derivation"), + 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."), - NOM_ZERO=SIMP(statut='f',typ=fonction_sdaster, - fr="Nom de la fonction nulle", - ang="Name of the zero fonction"), + ), - NOM_UN =SIMP(statut='f',typ=fonction_sdaster, - fr="Nom de la fonction unité", - ang="Name of the one fonction"), + 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_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3, + fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+ + " aux noeuds du MODELE_2 avant la projection."), + ), + TITRE =SIMP(statut='f',typ='TXM',max='**' ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), ) ; #& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19455,44 +20232,25 @@ MEMO_NOM_SENSI=PROC(nom="MEMO_NOM_SENSI",op=129, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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=base_modale ), - 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', - 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) ), +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,base_modale,mode_gene,mode_stat ) ), + 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 10/05/2006 AUTEUR MCOURTOI M.COURTOIS + +#& MODIF COMMANDE DATE 19/06/2006 AUTEUR VABHHTS J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19510,84 +20268,91 @@ MODE_ITER_CYCL=OPER(nom="MODE_ITER_CYCL",op= 80,sd_prod=mode_cycl, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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") +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_c + if AsType(vale) == base_modale : 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", +PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193, + sd_prod=proj_mesu_modal_prod, 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 ), + UIinfo={"groupes":("Résultats et champs",)}, + fr="Calcul des coordonnees généralisees de mesure experimentale relatives a une base de projection", - 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 10/05/2006 AUTEUR MCOURTOI M.COURTOIS + MODELE_CALCUL =FACT(statut='o', + MODELE =SIMP(statut='o',typ=(modele_sdaster) ), + BASE =SIMP(statut='o',typ=(mode_meca,base_modale,) ), + ), + 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,) ), + 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 10/10/2006 AUTEUR MCOURTOI 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. +# ====================================================================== +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'), + ENSEMBLE('FREQ_INIT','FREQ_FIN','NB_POIN'),), + 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='f',typ='R',val_min=0.E+0 ), + FREQ_FIN =SIMP(statut='f',typ='R',val_min=0.E+0 ), + NB_POIN =SIMP(statut='f',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 21/02/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19605,131 +20370,19 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op= 44,sd_prod=mode_iter_inv_prod # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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 - 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_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") ), - 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 ), - ), - 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"), - 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"), - 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='**'), +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,base_modale,mode_gene,mode_stat ) ), + 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 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19747,89 +20400,264 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op= 45,sd_prod=mode_iter_simult_pr # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -def mode_stat_prod(MODE_STAT,FORCE_NODALE,PSEUDO_MODE,**args): - if (MODE_STAT != None) : return mode_stat_depl - if (PSEUDO_MODE !=None) : return mode_stat_acce - if (FORCE_NODALE != None) : return mode_stat_forc - raise AsException("type de concept resultat non prevu") -MODE_STATIQUE=OPER(nom="MODE_STATIQUE",op= 93,sd_prod=mode_stat_prod, - fr="Calcul de modes 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='**'), +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 07/11/2006 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 MCOURTOI 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=(evol_elas,dyna_trans,evol_noli,evol_ther,dyna_harmo ) ), + 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)", + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + 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' ), + ), + ), ), - 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='**'), + +# ======= 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' ), ), - 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='**'), - ), + +# ======= 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 22/06/2005 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. -# ====================================================================== -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='**'), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ), ) ; #& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19849,165 +20677,47 @@ MODI_BASE_MODALE=OPER(nom="MODI_BASE_MODALE",op= 149,sd_prod=mode_meca, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE G8BHHXD X.DESROCHES -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_SHB8','SYMETRIE', - ), - PRESENT_ABSENT('ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D', - 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), - PRESENT_ABSENT('DEFORME','ORIE_FISSURE','EQUE_PIQUA','ORIE_PEAU_2D', - 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), - PRESENT_ABSENT('EQUE_PIQUA','ORIE_FISSURE','DEFORME','ORIE_PEAU_2D', - 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), - PRESENT_ABSENT('ORIE_PEAU_2D','ORIE_FISSURE','DEFORME','EQUE_PIQUA', - 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE','MODI_MAILLE',), - 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',), - PRESENT_ABSENT('PLAQ_TUBE','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D', - 'ORIE_PEAU_3D','ORIE_NORM_COQUE','MODI_MAILLE',), - PRESENT_ABSENT('MODI_MAILLE','ORIE_FISSURE','DEFORME','EQUE_PIQUA','ORIE_PEAU_2D', - 'ORIE_PEAU_3D','ORIE_NORM_COQUE','PLAQ_TUBE',), - 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='**'), - ), - ORIE_PEAU_3D =FACT(statut='f',max='**', - GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), - ), - ORIE_SHB8 =FACT(statut='f',max=1, - GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), - ), - ORIE_NORM_COQUE =FACT(statut='f',max='**', - regles=(EXCLUS('NOEUD','GROUP_NO'), - PRESENT_PRESENT('NOEUD','VECT_NORM'), - PRESENT_PRESENT('GROUP_NO','VECT_NORM'),), - GROUP_MA =SIMP(statut='o',typ=grma,validators=NoRepeat(),max='**'), - VECT_NORM =SIMP(statut='f',typ='R',max=3), - NOEUD =SIMP(statut='f',typ=no), - GROUP_NO =SIMP(statut='f',typ=grno), - ), - b_modele =BLOC(condition = "(ORIE_PEAU_2D != None) or (ORIE_PEAU_3D != None) or(ORIE_NORM_COQUE != None)", - MODELE =SIMP(statut='o',typ=modele_sdaster ), - ), - 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) ), +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=("ABSOLU","RELATIF") ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), ) ; -#& MODIF COMMANDE DATE 06/07/2005 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. +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE +# CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== - -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=01,max=01,), - FISSURE =SIMP(statut='o',typ=fiss_xfem,min=01,max=01,), - CRITERE =SIMP(statut='f',typ='R',defaut=1.1E-4), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,)), - +# 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 VABHHTS J.PELLET +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 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -20025,23 +20735,21 @@ MODI_MODELE_XFEM=OPER(nom="MODI_MODELE_XFEM",op= 113,sd_prod=modele_sdaster,docu # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -MODI_OBSTACLE=OPER(nom="MODI_OBSTACLE",op=182,sd_prod=obstacle_sdaster, - 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'),), - V_USUR_TUBE =SIMP(statut='f',typ='R',max='**'), - V_USUR_OBST =SIMP(statut='f',typ='R',max='**'), - TABL_USURE =SIMP(statut='f',typ=table_sdaster), - INST =SIMP(statut='f',typ='R'), - OBSTACLE =SIMP(statut='f',typ=obstacle_sdaster), - GUIDE =SIMP(statut='o',typ=obstacle_sdaster), - CRAYON =SIMP(statut='f',typ=obstacle_sdaster), - R_MOBILE =SIMP(statut='f',typ='R'), - PERCEMENT =SIMP(statut='f',typ='R',defaut=1), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), + +RESO_GRAD=OPER(nom="RESO_GRAD",op= 84,sd_prod=cham_no_sdaster, + fr="Résolution d'un système linéaire par la méthode du gradient conjugué préconditionné", + reentrant='f', + UIinfo={"groupes":("Résolution",)}, + MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ), + CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), + CHAM_CINE =SIMP(statut='f',typ=cham_no_sdaster), + MATR_FACT =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ), + NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), + REPRISE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), + RESI_RELA =SIMP(statut='f',typ='R',defaut= 1E-6 ), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 12/09/2005 AUTEUR CIBHHLV L.VIVAN +#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -20059,72 +20767,21 @@ MODI_OBSTACLE=OPER(nom="MODI_OBSTACLE",op=182,sd_prod=obstacle_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE JMBHH01 J.M.PROIX -def modi_repere_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) == mode_meca : return mode_meca - if AsType(RESULTAT) == mode_flamb : return mode_flamb - if AsType(RESULTAT) == mult_elas : return mult_elas - if AsType(RESULTAT) == base_modale : return base_modale - raise AsException("type de concept resultat non prevu") - -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=(evol_elas,dyna_trans,dyna_harmo,mode_meca, - evol_noli,mult_elas, - evol_ther,base_modale,mode_flamb) ), - 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), - - PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",),), +# RESPONSABLE VABHHTS J.PELLET - 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), - ), +RESO_LDLT=OPER(nom="RESO_LDLT",op=15,sd_prod=cham_no_sdaster,reentrant='f', + fr="Résoudre par méthode directe un système d'équations linéaires préalablement factorisé par FACT_LDLT", + UIinfo={"groupes":("Résolution",)}, + MATR_FACT =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), + # RESI_RELA : précision utilisée si SOLVEUR=MUMPS + RESI_RELA =SIMP(statut='f',typ='R',defaut=1.e-6), TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 31/10/2006 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -20142,43 +20799,127 @@ MODI_REPERE=OPER(nom="MODI_REPERE",op=191,sd_prod=modi_repere_prod,reentrant='n' # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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 +# RESPONSABLE BOYERE E.BOYERE +def rest_base_phys_prod(RESU_GENE,RESU_PHYS,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(RESU_PHYS) == evol_noli : return dyna_trans + if AsType(RESULTAT) == evol_elas : return evol_elas + if AsType(RESULTAT) == evol_noli : return evol_noli + if AsType(RESULTAT) == evol_char : return evol_char + if AsType(RESULTAT) == dyna_trans : return dyna_trans + if AsType(RESULTAT) == mode_meca : return mode_meca + if AsType(RESULTAT) == mode_stat_depl : return mode_stat_depl + if AsType(RESULTAT) == base_modale : return base_modale 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='**'), - MASS_INER =SIMP(statut='f',typ=table_sdaster), - 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" ), +REST_BASE_PHYS=OPER(nom="REST_BASE_PHYS",op= 75,sd_prod=rest_base_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=(UN_PARMI('RESU_GENE','RESU_PHYS','RESULTAT'), + EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','TOUT_INST'), + EXCLUS('TOUT_INST','NUME_ORDRE','INST','LIST_INST','TOUT_ORDRE'), +# Doc U à revoir + EXCLUS('MULT_APPUI','CORR_STAT'), + EXCLUS('MULT_APPUI','NOEUD','GROUP_NO'), + EXCLUS('CORR_STAT','NOEUD','GROUP_NO'), + EXCLUS('NOEUD','GROUP_NO'), + PRESENT_PRESENT('RESU_PHYS','BASE_MODALE'), + PRESENT_PRESENT('RESULTAT','SQUELETTE'), + PRESENT_PRESENT('ACCE_MONO_APPUI','DIRECTION'),), + RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_noli,dyna_trans,evol_char, + mode_meca,mode_stat_depl,base_modale) ), + + RESU_GENE =SIMP(statut='f',typ=(tran_gene,mode_gene,mode_cycl,harm_gene) ), + RESU_PHYS =SIMP(statut='f',typ=evol_noli ), + BASE_MODALE =SIMP(statut='f',typ=(base_modale,mode_meca) ), + 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") ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), + 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",) ), + 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",) ), + TOUT_CHAM =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='**'), + + ACCE_MONO_APPUI =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), + DIRECTION =SIMP(statut='f',typ='R',min=3,max=3 ), + + 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,mode_stat_depl,base_modale) ), ), - 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", + + 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 10/10/2006 AUTEUR MCOURTOI 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. +# ====================================================================== +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='**' ), + 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_stat_depl,mode_stat_acce,mode_stat_forc), ), + EXCIT =FACT(statut='f', + NOEUD =SIMP(statut='o',typ=no ,max='**'), + NOM_CMP =SIMP(statut='o',typ='TXM',max='**'), ), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), + 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 01/04/2005 AUTEUR VABHHTS J.PELLET +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -20196,93 +20937,371 @@ NORM_MODE=OPER(nom="NORM_MODE",op= 37,sd_prod=norm_mode_prod, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE VABHHTS 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, ),), +# RESPONSABLE MABBAS 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'),), + 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")), ), - 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 associés à la méthode multifrontale", - RENUM =SIMP(statut='f',typ='TXM',into=("MD","MDA","METIS"),defaut="METIS" ), + SOUS_STRUC =FACT(statut='f',min=01,max='**', + regles=(UN_PARMI('TOUT','MAILLE'),), + CAS_CHARGE =SIMP(statut='o',typ='TXM' ), + TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), + MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',), + ), + 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")), + ELAS =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_VMIS_TRAC =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_VMIS_LINE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_HYPER =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_POUTRE_GR =SIMP(statut='c',typ='I',defaut=3,into=(3,)), + CABLE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + 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_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_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','VARI_NON_LOCAL',), + EXCLUS('EVOL_NOLI','DEPL',), + EXCLUS('EVOL_NOLI','SIGM',), + EXCLUS('EVOL_NOLI','VARI',), + EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), + 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), + VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + NUME_ORDRE =SIMP(statut='f',typ='I'), + INST =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") ), + 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','VARI_NON_LOCAL',), + EXCLUS('EVOL_NOLI','DEPL',), + EXCLUS('EVOL_NOLI','SIGM',), + EXCLUS('EVOL_NOLI','VARI',), + EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), + 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), + VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + NUME_ORDRE =SIMP(statut='f',typ='I'), + INST =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") ), + NUME_DIDI =SIMP(statut='f',typ='I'), + INST_ETAT_INIT =SIMP(statut='f',typ='R'), + ),), + INCREMENT =FACT(statut='o', + regles=(EXCLUS('NUME_INST_INIT','INST_INIT'), + EXCLUS('NUME_INST_FIN','INST_FIN'),), + LIST_INST =SIMP(statut='o',typ=listr8_sdaster), + EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE", + into=("CHRONOLOGIQUE","RETROGRADE","SANS",) ), + 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-3 ), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),), + NOM_CHAM =SIMP(statut='f',typ='TXM',), + NOM_CMP =SIMP(statut='f',typ='TXM',), + VALE =SIMP(statut='f',typ='R'), + ), + 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), + ), + RECH_LINEAIRE =FACT(statut='f', + RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ), + ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 3), + 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.), + ), + 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","PRED_ELAS_INCR","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 =FACT(statut='d', + regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),), + 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'), + 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")), + ), + SOLVEUR =FACT(statut='d', + METHODE=SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","FETI") ), + 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","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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), + ), + 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), + 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") ), + ), + SYME =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-3), + 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", + "VARI_NON_LOCAL","LANL_ELGA")), + ), + OBSERVATION =FACT(statut='f',max='**', + regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'), + PRESENT_PRESENT('MAILLE','POINT'),), + 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")), + NOM_CMP =SIMP(statut='o',typ='TXM',max='**' ), + LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + PAS_OBSE =SIMP(statut='f',typ='I'), + 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='**'), + POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), + ), + + SUIVI_DDL = FACT(statut='f',max=4, + regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'), + PRESENT_PRESENT('MAILLE','POINT'),), + NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4), + 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",)), + NOM_CMP =SIMP(statut='o',typ='TXM',max=1 ), + 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='**'), + POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), + 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_mumps =BLOC(condition="METHODE=='MUMPS'",fr="paramètres associés à la méthode MUMPS", - RENUM =SIMP(statut='f',typ='TXM',into=("SANS",),defaut="SANS" ), + + 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", + "LAGR_ECAR","LAGR_INCR","LAGR_ITER", + "MATR_ASSE", + "ITER_DEBO", + "CTCD_ITER","CTCD_INFO","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")), + ), ), - 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" ), + + + + 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"), ), - INFO =SIMP(statut='f',typ='I',into=(1,2)), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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. -# ====================================================================== -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_stat,base_modale,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 22/06/2005 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. -# ====================================================================== -POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=resultat_sdaster, - reentrant='n',UIinfo={"groupes":("Post traitements",)}, - fr="Calcul des champs DEPL et SIEF_ELGA sur le maillage fissuré", - MAILLAGE = SIMP(statut='o',typ=maillage_sdaster), - MODELE = SIMP(statut='o',typ=modele_sdaster,), - RESULTAT = SIMP(statut='o',typ=resultat_sdaster), - NOM_CHAM = SIMP(statut='o',typ='TXM',into=("DEPL","SIEF_ELGA"),) -); -#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE + SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', + fr="Liste des paramètres de sensibilité", + ang="List of sensitivity parameters"), + SOLV_NON_LOCAL =FACT(statut='f', + 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 =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") ), + ), + 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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), + ), + 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 ), + RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), + NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), + ), + EPS =SIMP(statut='f',typ='R',defaut= 0.E+0 ), + ), + LAGR_NON_LOCAL =FACT(statut='f', + ITER_DUAL_MAXI =SIMP(statut='f',typ='I',defaut= 50), + RESI_DUAL_ABSO =SIMP(statut='o',typ='R'), + RESI_PRIM_ABSO =SIMP(statut='o',typ='R'), + R =SIMP(statut='f',typ='R',defaut= 1000.), + ITER_PRIM_MAXI =SIMP(statut='f',typ='I',defaut= 10), + ), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), + TITRE =SIMP(statut='f',typ='TXM',max='**' ), + ) + +#& MODIF COMMANDE DATE 17/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -20300,545 +21319,521 @@ POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=resultat_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -POST_DYNA_ALEA=OPER(nom="POST_DYNA_ALEA",op= 132,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('NOEUD_I','NUME_ORDRE_I','OPTION'),), - INTE_SPEC =SIMP(statut='o',typ=table_sdaster), - 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='**' ), - ), - DEPASSEMENT =FACT(statut='f',max='**', - fr="Loi de dépassement d un seuil pendant une durée donnée", - regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),), - VALE_MIN =SIMP(statut='f',typ='R' ), - VALE_MAX =SIMP(statut='f',typ='R' ), - PAS =SIMP(statut='f',typ='R' ), - DUREE =SIMP(statut='f',typ='R',defaut= 1. ), - ), - RAYLEIGH =FACT(statut='f',max='**', - fr="Densité de probabilité de pic positif, loi adaptée à des signaux à bande étroite", - regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),), - VALE_MIN =SIMP(statut='f',typ='R' ), - VALE_MAX =SIMP(statut='f',typ='R' ), - PAS =SIMP(statut='f',typ='R' ), - ), - GAUSS =FACT(statut='f',max='**', - fr="Densité de probabilité de pic positif, loi normale adaptée à des signaux large bande", - regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),), - VALE_MIN =SIMP(statut='f',typ='R' ), - VALE_MAX =SIMP(statut='f',typ='R' ), - PAS =SIMP(statut='f',typ='R' ), - ), - VANMARCKE =FACT(statut='f',max='**', - fr="Probabilité de non dépassement de seuil pendant une durée donnée (analyse sismique)", - regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),), - VALE_MIN =SIMP(statut='f',typ='R' ), - VALE_MAX =SIMP(statut='f',typ='R' ), - PAS =SIMP(statut='f',typ='R' ), - DUREE =SIMP(statut='f',typ='R',defaut= 10. ), +# RESPONSABLE MCOURTOI M.COURTOIS +TEST_FONCTION=PROC(nom="TEST_FONCTION",op= 135, + 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',), + 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='o',typ='R' ,validators=NoRepeat(),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' ), + ), ), - 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 03/01/2006 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. -# ====================================================================== -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 ), + 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' ), + ), ), - 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' ), + 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' ), + ), ), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), - TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE +# RESPONSABLE VABHHTS 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. +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE G8BHHXD 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', - 'WEIBULL', 'RICE_TRACEY', 'CARA_GEOM','CHAR_LIMITE', - 'CARA_POUTRE', 'INDIC_ENER', 'INDIC_SEUIL', - 'AIRE_INTERNE','ENER_ELAS','ENER_TOTALE','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_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) ), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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',), - ), +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')), - 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_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) ), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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='**'), + 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'), ), - 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_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) ), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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='**'), + 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' ), ), - 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_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'),), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + 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' ), ), - 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_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'),), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + 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' ), ), - 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='o',typ='TXM',into=C_NOM_CHAM_INTO()), - NOM_CMP = SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'), - ), - b_integrale = BLOC(condition = "( INTEGRALE != None )", - fr="calcul de la moyenne d'une composante", - regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST'),), - MODELE = SIMP(statut='f',typ=modele_sdaster), - RESULTAT = SIMP(statut='o',typ=(evol_noli,evol_ther,evol_elas) ), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + OBJET =FACT(statut='f',max='**', + regles=(UN_PARMI('S_I','S_R','RESUME',), + UN_PARMI('VALE','VALE_I','VALE_C','RESUME','S_R','S_I'),), + NOM =SIMP(statut='o',typ='TXM'), + S_R =SIMP(statut='f',typ='R'), + S_I =SIMP(statut='f',typ='I'), + RESUME =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 10/10/2006 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 VABHHTS J.PELLET +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), - 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_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) ), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + 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.2E-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 12/06/2006 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. +# ====================================================================== +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', + LIST_INST =SIMP(statut='o',typ=listr8_sdaster ), + NUME_INIT =SIMP(statut='f',typ='I'), + NUME_FIN =SIMP(statut='f',typ='I'), + ), + TEMP_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_INIT =SIMP(statut='f',typ='I'), + ), + 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") ), + 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") ), + ), + 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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,), + ), + ), + PARM_THETA =SIMP(statut='f',typ='R',defaut= 0.57), + ARCHIVAGE =FACT(statut='f', + regles=(UN_PARMI('LIST_ARCH','PAS_ARCH','LIST_INST','INST'),), + LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF", + into=("RELATIF","ABSOLU")), + PAS_ARCH =SIMP(statut='f',typ='I'), + CHAM_EXCLU =SIMP(statut='f',typ='TXM',into=("VARI",)), ), - - 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_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) ), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + TITRE =SIMP(statut='f',typ='TXM',max='**'), + INFO =SIMP(statut='f',typ='I',into=(1,2)), +) ; +#& MODIF COMMANDE DATE 19/06/2006 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. +# ====================================================================== +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='**'), ), - - 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_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'),), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + 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)), ), - - 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_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'),), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + INCREMENT =FACT(statut='f', + LIST_INST =SIMP(statut='o',typ=listr8_sdaster), + NUME_INIT =SIMP(statut='f',typ='I'), + NUME_FIN =SIMP(statut='f',typ='I'), ), - - 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_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'),), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - 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), + TEMP_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_INIT =SIMP(statut='f',typ='I'), ), - - 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_ther,char_acou),validators=NoRepeat(),max='**' ), - MODE_FOURIER = SIMP(statut='f',typ='I',defaut=0), + NEWTON =FACT(statut='d', + REAC_ITER =SIMP(statut='f',typ='I',defaut= 0 ), + RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), + ITER_LINE_MAXI =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_ther,char_acou),validators=NoRepeat(),max='**' ), - MODE_FOURIER = 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 ), ), - - 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), + SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', + fr="Liste des paramètres de sensibilité.", + ang="List of sensitivity parameters", ), - - 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) ), - PRECISION = SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE = SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - TOUT_ORDRE = SIMP(statut='f',typ='TXM',into=("OUI",) ), + 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="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 =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' ", + fr="Parametres relatifs a la non inversibilité de la matrice a factorise", + 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")), + SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")), + RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")), + PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,), + RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,), + ), + 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=(UN_PARMI('LIST_ARCH','PAS_ARCH','LIST_INST','INST', ),), + LIST_ARCH =SIMP(statut='f',typ=(listis_sdaster) ), + LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ), + PAS_ARCH =SIMP(statut='f',typ='I'), + CHAM_EXCLU =SIMP(statut='f',typ='TXM',into=("VARI",)), ), + 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) ), - TITRE =SIMP(statut='f',typ='TXM',max='**' ), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), - - ) ; -#& MODIF COMMANDE DATE 03/01/2006 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. -# ====================================================================== -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 03/01/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -20856,182 +21851,60 @@ POST_FATI_ALEA=OPER(nom="POST_FATI_ALEA",op=170,sd_prod=table_sdaster,reentrant= # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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'), +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) ), ), - - 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",)), + TEMP_INIT =FACT(statut='f', + EVOL_THER =SIMP(statut='f',typ=evol_ther ), + NUME_INIT =SIMP(statut='f',typ='I',defaut= 0 ), ), - - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), - TITRE =SIMP(statut='f',typ='TXM',max='**'), -) ; -#& MODIF COMMANDE DATE 09/05/2006 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'), - 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), - 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' ,defaut=5 ), - 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",) ) - ), - 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="Table 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='f',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)", - PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - ), - 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='o',typ='R',max=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/01/2006 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. -# -# -# ====================================================================== -# -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"),), + 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") ), ), - 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' ), + SOLVEUR =FACT(statut='d', + METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), + 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") ), + ), + 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 ), + ), + SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), ), - TITRE = SIMP(statut='f',typ='TXM',max='**'), -); + TITRE =SIMP(statut='f',typ='TXM',max='**' ), + INFO =SIMP(statut='f',typ='I',into=(1,2) ), +) ; + + + #& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG +# 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 @@ -21046,1585 +21919,1570 @@ POST_K_BETA=OPER(nom="POST_K_BETA",op=198,sd_prod=table_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -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), - TITRE = SIMP(statut='f',typ='TXM',max='**'), -); -#& MODIF COMMANDE DATE 13/03/2006 AUTEUR CIBHHLV L.VIVAN -# 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 JMBHH01 J.M.PROIX -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')", +def extr_table_prod(TYPE_RESU,**args): + if TYPE_RESU == "MATR_ASSE_GENE_R" : return matr_asse_gene_r + raise AsException("type de concept resultat non prevu") - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("PM_PB","SN","FATIGUE_ZH210") ), - MATER =SIMP(statut='o',typ=mater_sdaster ), +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 la matrice de masse généralisée assemblée", + TYPE_RESU =SIMP(statut='o',typ='TXM',into=("MATR_ASSE_GENE_R",) ), - TRANSITOIRE =FACT(statut='o',max='**',fr="transitoire à dépouiller", - regles=(EXCLUS('TOUT_ORDRE','INST','LIST_INST'),), - NB_OCCUR =SIMP(statut='f',typ='I',defaut= 1, - fr="nombre d occurences réelles de ce transitoire" ), - TABL_RESU_MECA =SIMP(statut='o',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" ), - 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)" , - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-6 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("ABSOLU","RELATIF") ), - ), - ), - ), + TABLE =SIMP(statut='o',typ=table_sdaster), -# ====================================================================== - b_unitaire =BLOC(condition="(TYPE_RESU_MECA == 'UNITAIRE')", + NOM_PARA =SIMP(statut='o',typ='TXM'), - OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - into=("PM_PB","SN","FATIGUE") ), - MATER =SIMP(statut='o',typ=mater_sdaster ), - 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" ), - TYPE_CHAR =SIMP(statut='f',typ='TXM',fr="nature du chargement",into=( "SEISME","AUTRE"),defaut="AUTRE",), - 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", ), - ), + 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'),), - ), - 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"), - ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), + ), - 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" ), - ), - SITUATION =FACT(statut='o',max='**',fr="Situation",ang="situation_ang", - NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ), - NB_CYCL_SEISME =SIMP(statut='f',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" ), - COMBINABLE =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ), - NUME_GROUPE =SIMP(statut='o',typ='I',fr="numéro du groupe de la situation" ), - NUME_PASSAGE =SIMP(statut='f',typ='I',max=2,fr="numéro des deux groupes en relation" ), - 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"), - ), - ), + TITRE =SIMP(statut='f',typ='TXM',max='**' ), +) ; +#& MODIF COMMANDE DATE 28/02/2006 AUTEUR VABHHTS J.PELLET +# CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== - 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" ), - TYPE_CHAR =SIMP(statut='f',typ='TXM',fr="nature du chargement",into=( "SEISME","AUTRE"),defaut="AUTRE",), - 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)", - PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU"), ), +# 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 CAMBIER S.CAMBIER +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.), + COEF_VAR = SIMP(statut='f', typ='R', defaut=0.1,val_min=0.), ), + INIT_ALEA =SIMP(statut='f',typ='I'), +) +#& MODIF COMMANDE DATE 11/07/2005 AUTEUR CAMBIER S.CAMBIER +# 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 CAMBIER S.CAMBIER +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" ), ), - ), - 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='**'), - ), - ), - SITUATION =FACT(statut='o',max='**',fr="Situation",ang="situation_ang", - NB_OCCUR =SIMP(statut='o',typ='I',fr="nombre d'occurences de la situation" ), - NB_CYCL_SEISME =SIMP(statut='f',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" ), - COMBINABLE =SIMP(statut='f',typ='TXM',defaut= "OUI",into=("OUI","NON"),fr="non = sous-cycle" ), - NUME_GROUPE =SIMP(statut='o',typ='I',fr="numéro du groupe de la situation" ), - NUME_PASSAGE =SIMP(statut='f',typ='I',max=2,fr="numéro des deux groupes en relation" ), - 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 16/05/2006 AUTEUR REZETTE C.REZETTE +# 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 03/04/2006 AUTEUR MCOURTOI M.COURTOIS +# 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. # ====================================================================== + +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 09/05/2006 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 G8BHHXD 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", - UIinfo={"groupes":("Post traitements",)}, +# 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. +# ====================================================================== - ACTION =FACT(statut='o',max='**', - regles=(UN_PARMI('RESULTAT','CHAM_GD'),), +from Macro.macr_lign_coupe_ops import macr_lign_coupe_ops - OPERATION =SIMP(statut='o',typ='TXM',into=("EXTRACTION","MOYENNE","EXTREMA"),validators=NoRepeat(),max=2), - INTITULE =SIMP(statut='o',typ='TXM'), +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", + RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,evol_ther) ), +# 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' ), + ), + UNITE_MAILLAGE =SIMP(statut='f',typ='I',defaut=25), + MODELE =SIMP(statut='f',typ=modele_sdaster ), + GROUP_MA =SIMP(statut='f',typ=grma), + MAILLE =SIMP(statut='f',typ=ma,max='**'), + regles=(EXCLUS('GROUP_MA','MAILLE'),), + LIGN_COUPE =FACT(statut='o',max='**', + regles=(UN_PARMI('NB_POINTS','GROUP_NO'),), + INTITULE =SIMP(statut='f',typ='TXM',), + GROUP_NO =SIMP(statut='f',typ=grno), + NB_POINTS =SIMP(statut='f',typ='I'), + b_nbpts = BLOC(condition = "NB_POINTS != None", + COOR_ORIG =SIMP(statut='o',typ='R',min=2,max=3), + COOR_EXTR =SIMP(statut='o',typ='R',min=2,max=3), + VECT_Y =SIMP(statut='f',typ='R',min=2,max=3),), + ), +) ; - CHAM_GD =SIMP(statut='f',typ=(cham_no_sdaster, - cham_elem,),), - RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_ther,evol_noli,dyna_trans, - mode_meca,mode_flamb,mode_acou,base_modale,mode_stat, - mult_elas,fourier_elas,dyna_harmo,acou_harmo)), - 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"), - ), +#& MODIF COMMANDE DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== + +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='d', + GRAPHIQUE =FACT(statut='f', + UNITE =SIMP(statut='f',typ='I',defaut=90), + FORMAT =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT")), + INTERACTIF =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")), + 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"),), - 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), - PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - ), + METHODE =SIMP(statut='f',typ='TXM',defaut='LEVENBERG',into=("LEVENBERG","FMIN","FMINBFGS","FMINNCG","EXTERNE")), - 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_gradient =BLOC(condition = "METHODE == 'FMINBFGS' or METHODE == 'FMINNCG'" , + GRADIENT =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )), + ), - b_autre =BLOC(condition="OPERATION != 'EXTREMA'", - 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='**'), + b_gradient_externe =BLOC(condition = "METHODE == 'EXTERNE'" , + GRADIENT =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )), + ), - 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='**'), + b_type_fonctionnelle =BLOC(condition = "METHODE == 'EXTERNE'" , + FONCTIONNELLE =SIMP(statut='f',typ='TXM',defaut='SCALAIRE',into=("SCALAIRE","VECTORIELLE")), + ), - MOMENT =SIMP(statut='f',typ='TXM',max='**'), - POINT =SIMP(statut='f',typ='R',max='**'), + INFO =SIMP(statut='f',typ='I',defaut=2,into=( 1, 2 ) ), +); +#& MODIF COMMANDE DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS +# 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 D6BHHJP 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",)}, - 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), + 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 03/01/2006 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 JMBHH01 J.M.PROIX - 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")), - ), +from Macro.macr_cara_poutre_ops import macr_cara_poutre_ops - FORMAT_C =SIMP(statut='f',typ='TXM',defaut="MODULE",into=("MODULE","REEL","IMAG")), +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'),), + + UNITE_MAILLAGE =SIMP(statut='f',typ='I',defaut= 20 ), + 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", + + NOEUD =SIMP(statut='f',typ=no,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 07/02/2005 AUTEUR MABBAS M.ABBAS +# 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. +# ====================================================================== + +from Macro.macr_cabri_mail_ops import macr_cabri_mail_ops + +MACR_CABRI_MAIL=MACRO(nom="MACR_CABRI_MAIL", + op=macr_cabri_mail_ops, + sd_prod=maillage_sdaster, + fr="maillage d'une jonction boulonnée de tuyauterie", + reentrant='n', + UIinfo={"groupes":("Outils métier",)}, + EXEC_MAILLAGE = FACT(statut='o', + LOGICIEL = SIMP(statut = 'o',typ='TXM',into=("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), + ), + ), + RAFF_MAILLAGE = FACT(statut = 'd', + NB_RADIAL = SIMP(statut = 'f',typ='I',defaut=2,), + NB_CIRCONF = SIMP(statut = 'f',typ='I',defaut=3,), + NB_VERTICAL = SIMP(statut = 'f',typ='I',defaut=6,), + NB_ALESAGE = SIMP(statut = 'f',typ='I',defaut=5,), + ), + 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 ), + ), + GEOM_BRID = FACT(statut = 'o', + NORME = SIMP(statut = 'o',typ='TXM',into=("OUI","NON"),), + b_bride_iso = BLOC(condition = "NORME == 'OUI'", + TYPE = SIMP(statut='o',typ='TXM', + into=('A','AA','B','B1','C','D','D1','E','F', + 'FF','G','GG','H','H1','I','J','J1', + 'K','L','L1','M','N','O','P','S','T','W'), + ), + ), + b_bride_niso = BLOC(condition = "NORME == 'NON'", + TUBU_D_EXT = SIMP(statut='o',typ='R',), + TUBU_H = SIMP(statut='o',typ='R',), + BRID_D_EXT = SIMP(statut='o',typ='R',), + BRID_D_INT = SIMP(statut='o',typ='R',), + BRID_H = SIMP(statut='o',typ='R',), + BRID_D_CONGE = SIMP(statut='o',typ='R',), + BRID_R_CONGE = SIMP(statut='o',typ='R',), + BRID_D_EPAUL = SIMP(statut='o',typ='R',), + BRID_H_EPAUL = SIMP(statut='o',typ='R',), + BRID_D_ALESAG = SIMP(statut='o',typ='R',), + BRID_P_ALESAG = SIMP(statut='o',typ='R',), + BRID_H_ALESAG = SIMP(statut='o',typ='R',), + GOUJ_N_GOUJON = SIMP(statut='o',typ='I',), + GOUJ_D_GOUJON = SIMP(statut='o',typ='R',), + GOUJ_E_FILET = SIMP(statut='o',typ='R',), + GOUJ_D_RONDEL = SIMP(statut='o',typ='R',), + GOUJ_E_RONDEL = SIMP(statut='o',typ='R',), + GOUJ_D_ECROU = SIMP(statut='o',typ='R',), + GOUJ_E_ECROU = SIMP(statut='o',typ='R',), + ETAN_E_JOINT = SIMP(statut='o',typ='R',), + ), + ), + IMPRESSION = FACT(statut='d', + UNITE = SIMP(statut='f',typ='I'), + FORMAT = SIMP(statut='f',typ='TXM',defaut="ASTER", + into=("ASTER","CASTEM","IDEAS"), + ), + b_impr_castem = BLOC(condition = "FORMAT == 'CASTEM'", + NIVE_GIBI = SIMP(statut='f',typ='I',defaut=10,into=(3,10),), + ), + b_impr_ideas = BLOC(condition = "FORMAT == 'IDEAS'", + VERSION = SIMP(statut='f',typ='I',defaut=5,into=(4,5),), + ), + ), + ); - ), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), - TITRE =SIMP(statut='f',typ='TXM',max='**'), -) ; -#& MODIF COMMANDE DATE 03/01/2006 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. -# ====================================================================== -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 22/06/2005 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 10/10/2006 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. +# 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. # ====================================================================== -POST_ZAC=OPER(nom="POST_ZAC",op= 175,sd_prod=mult_elas,reentrant='n', - UIinfo={"groupes":("Post traitements",)}, - fr="Déterminer l'état adapté ou accommodé par la méthode de Zarka-Casier d'une structure sous" - +" chargement cyclique élastique affine ou non", +#& RESPONSABLE +DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f',UIinfo={"groupe":("Résolution",)}, + fr="Calcul de l'évolution dynamique d'une structure dont la géométrie ou le matériau ont un comportement" + +" non linéaire, par une méthode explicite sur les accélérations ", + regles=(AU_MOINS_UN('COMP_INCR','COMP_ELAS',),UN_PARMI('DIFF_CENT','TCHAMWA'),), MODELE =SIMP(statut='o',typ=modele_sdaster), CHAM_MATER =SIMP(statut='o',typ=cham_mater), + MODE_STAT =SIMP(statut='f',typ=(mode_stat_depl,mode_stat_acce,mode_stat_forc,)), + CARA_ELEM =SIMP(statut='f',typ=cara_elem), + MASS_DIAG =SIMP(statut='f',typ='TXM',defaut="NON",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","FIXE_PILO","SUIV","DIDI")), CHARGE =SIMP(statut='o',typ=char_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",)), - ), - EVOL_ELAS =SIMP(statut='o',typ=evol_elas), - b_evol_elas =BLOC(condition="EVOL_ELAS != None", - regles=(UN_PARMI('NUME_ORDRE','LIST_INST','INST'),), - NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), - ), - TEMP_ZAC =SIMP(statut='f',typ='R',defaut=0.0E+0), - EVOL_NOLI =SIMP(statut='f',typ=evol_noli), - b_evol_noli =BLOC(condition="EVOL_NOLI != None", - INST_MAX =SIMP(statut='o',typ='R'), + 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=3), + NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), + GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")), - -) ; -#& MODIF COMMANDE DATE 16/01/2006 AUTEUR D6BHHJP 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. -# ====================================================================== -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'), + AMOR_MODAL =FACT(statut='f', + MODE_MECA =SIMP(statut='o',typ=mode_meca), + AMOR_REDUIT =SIMP(statut='f',typ='R',max='**' ), + NB_MODE =SIMP(statut='f',typ='I',defaut= 9999 ), + REAC_VITE =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), ), - IMPRESSION =FACT(statut='f',min=1,max=3, - FICHIER =SIMP(statut='o',typ='TXM'), - UNITE =SIMP(statut='o',typ='I'), + 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), ), - 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'), + 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='**' ), ), - 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'), + 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_POUTRE_GR","CABLE","ELAS_HYPER")), + ELAS =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_VMIS_TRAC =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_VMIS_LINE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_HYPER =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + ELAS_POUTRE_GR =SIMP(statut='c',typ='I',defaut=3,into=(3,)), + CABLE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), + 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")), ), - 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'), - 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',)), +#------------------------------------------------------------------- + ETAT_INIT =FACT(statut='f', + regles=(AU_MOINS_UN('EVOL_NOLI','DEPL','VITE','ACCE','SIGM','VARI','VARI_NON_LOCAL',), + EXCLUS('EVOL_NOLI','DEPL',), + EXCLUS('EVOL_NOLI','VITE'), + EXCLUS('EVOL_NOLI','ACCE'), + EXCLUS('EVOL_NOLI','SIGM',), + EXCLUS('EVOL_NOLI','VARI',), + EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), + 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), + VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + NUME_ORDRE =SIMP(statut='f',typ='I'), + INST =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") ), + NUME_DIDI =SIMP(statut='f',typ='I'), + INST_ETAT_INIT =SIMP(statut='f',typ='R'), ), - MEMOIRE =FACT(fr="mode de gestion mémoire utilisé",statut='f',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' ), +#------------------------------------------------------------------- + INCREMENT =FACT(statut='o', + regles=(EXCLUS('NUME_INST_INIT','INST_INIT'), + EXCLUS('NUME_INST_FIN','INST_FIN'),), + LIST_INST =SIMP(statut='o',typ=listr8_sdaster), + EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE", + into=("CHRONOLOGIQUE","RETROGRADE","SANS",) ), + 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-3 ), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),), + NOM_CHAM =SIMP(statut='f',typ='TXM',), + NOM_CMP =SIMP(statut='f',typ='TXM',), + VALE =SIMP(statut='f',typ='R'), ), - RESERVE_CPU =FACT(fr="reserve de temps pour terminer une execution",statut='f',max=1, - regles=(EXCLUS('VALE','POURCENTAGE'),), - VALE =SIMP(statut='f',typ='I',val_min=0), - POURCENTAGE =SIMP(statut='f',typ='R',val_min=0.,val_max=1.0), -# valeur en pourcentage du temps maximum bornée à 180 secondes - BORNE =SIMP(statut='f',typ='I',val_min=0,defaut=180) +#------------------------------------------------------------------- + DIFF_CENT =FACT(statut='f', ), - CODE =FACT("définition d un nom pour l'esemble d'une étude", - statut='f',min=1,max=1, - NOM =SIMP(statut='o',typ='TXM'), - UNITE =SIMP(statut='f',typ='I',defaut=15), + TCHAMWA =FACT(statut='f', + PHI =SIMP(statut='f',typ='R',defaut= 1.05), ), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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. -# ====================================================================== -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 22/06/2005 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. -# ====================================================================== - -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 22/06/2005 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. -# ====================================================================== -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/02/2006 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. -# ====================================================================== - -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 10/05/2006 AUTEUR MCOURTOI 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 VABHHTS J.PELLET -def proj_champ_prod(RESULTAT=None,CHAM_NO_REFE=None,**args ): - if AsType(RESULTAT) == evol_ther : return evol_ther - if AsType(RESULTAT) == evol_elas : return evol_elas - if AsType(RESULTAT) == evol_noli : return evol_noli - if AsType(RESULTAT) == evol_char : return evol_char - if AsType(RESULTAT) == dyna_trans : return dyna_trans - if AsType(RESULTAT) == mode_meca : return mode_meca - if AsType(RESULTAT) == mode_stat_depl : return mode_stat_depl - if AsType(RESULTAT) == base_modale : return base_modale - 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",) ), - 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), + STOP_CFL =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")), + NEWTON =FACT(statut='c', + REAC_INCR =SIMP(statut='f',typ='I',defaut= 1 ), + 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), + REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=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") ), + 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","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 ), + ), + SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), ), - 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=(evol_ther,evol_elas,evol_noli,dyna_trans,evol_char, - mode_meca,mode_stat_depl,base_modale) ), - 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), - - TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ), - NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), - -# POUR IMPOSER LA NUMEROTATION DES DDLS : -# ------------------------------------------------------------------ - NUME_DDL =SIMP(statut='f',typ=(nume_ddl_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), - 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='**'), - - 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."), - +#------------------------------------------------------------------- + RECH_LINEAIRE =FACT(statut='c', + RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ), + ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 3), + 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), ), - - 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",) ), + PILOTAGE =FACT(statut='c', + regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),), + TYPE =SIMP(statut='o',typ='TXM',into=("DDL_IMPO","LONG_ARC","PRED_ELAS","PRED_ELAS_INCR","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 =FACT(statut='d', + regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),), + 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'), + 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"), + 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")), ), +#------------------------------------------------------------------- + AFFICHAGE = FACT(statut='f',max=16, - TITRE =SIMP(statut='f',typ='TXM',max='**' ), - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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. -# ====================================================================== -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,base_modale,mode_gene,mode_stat ) ), - 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 22/06/2005 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. -# ====================================================================== -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_c - 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", + UNITE = SIMP(statut='f',typ='I',val_min=1), - MODELE_CALCUL =FACT(statut='o', - MODELE =SIMP(statut='o',typ=(modele_sdaster) ), - BASE =SIMP(statut='o',typ=(mode_meca,base_modale,) ), - ), - 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,) ), - 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), - ), - 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='**' ), - ), - ), + 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", + "LAGR_ECAR","LAGR_INCR","LAGR_ITER", + "MATR_ASSE", + "ITER_DEBO", + "CTCD_ITER","CTCD_INFO","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-3), + 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","VARI_NON_LOCAL","LANL_ELGA")), + ), + OBSERVATION =FACT(statut='f',max='**', + regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'), + PRESENT_PRESENT('MAILLE','POINT'),), + NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**', - ); -#& MODIF COMMANDE DATE 21/02/2006 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. -# ====================================================================== -PROJ_SPEC_BASE=OPER(nom="PROJ_SPEC_BASE",op= 146,sd_prod=table_sdaster,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'), - ENSEMBLE('FREQ_INIT','FREQ_FIN','NB_POIN'),), - SPEC_TURB =SIMP(statut='o',typ=spectre_sdaster,validators=NoRepeat(),max='**' ), - 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='f',typ='R',val_min=0.E+0 ), - FREQ_FIN =SIMP(statut='f',typ='R',val_min=0.E+0 ), - NB_POIN =SIMP(statut='f',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='**' ), +into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU") ), + NOM_CMP =SIMP(statut='o',typ='TXM',max='**' ), + LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), + PAS_OBSE =SIMP(statut='f',typ='I'), + 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='**'), + POINT =SIMP(statut='f',typ='I' ,max='**'), + ), +#------------------------------------------------------------------- + SOLV_NON_LOCAL =FACT(statut='f', + METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ), + 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") ), + ), + 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 ), + RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), + NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), + ), + ), + LAGR_NON_LOCAL =FACT(statut='f', + ITER_DUAL_MAXI =SIMP(statut='f',typ='I',defaut= 50), + RESI_DUAL_ABSO =SIMP(statut='o',typ='R'), + RESI_PRIM_ABSO =SIMP(statut='o',typ='R'), + R =SIMP(statut='f',typ='R',defaut= 1000.), + ITER_PRIM_MAXI =SIMP(statut='f',typ='I',defaut= 10), + ), +#------------------------------------------------------------------- + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE +#& MODIF COMMANDE DATE 25/09/2006 AUTEUR MJBHHPE J.L.FLEJOU # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 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. # ====================================================================== -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,base_modale,mode_gene,mode_stat ) ), - 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 09/05/2006 AUTEUR MASSIN P.MASSIN +from Macro.macr_cabri_calc_ops import macr_cabri_calc_ops + +def macr_cabri_calc_prod(self,MODELE_THER,MODELE_MECA,CHAM_MATER, + CHAR_THER,CHAR_MECA,RESU_THER,**args): + if MODELE_THER != None: + self.type_sdprod(MODELE_THER,modele_sdaster) + if MODELE_MECA != None: + self.type_sdprod(MODELE_MECA,modele_sdaster) + if RESU_THER != None: + self.type_sdprod(RESU_THER,evol_ther) + if CHAM_MATER != None: + self.type_sdprod(CHAM_MATER,cham_mater) + if CHAR_THER != None: + for m in CHAR_THER: + self.type_sdprod(m['CHARGE'],char_ther) + if CHAR_MECA != None: + for m in CHAR_MECA: + self.type_sdprod(m['CHARGE'],char_meca) + return evol_noli + + +MACR_CABRI_CALC=MACRO(nom="MACR_CABRI_CALC", + op=macr_cabri_calc_ops, + sd_prod=macr_cabri_calc_prod, + fr="Calcul thermo-mécanique d'une jonction boulonnée de tuyauterie", + reentrant='n', + UIinfo={"groupes":("Outils métier",)}, + MAILLAGE = SIMP(statut='o',typ=maillage_sdaster,), + AFFE_MATERIAU = FACT(statut='o',max='**', + regles=(UN_PARMI('TOUT','GROUP_MA',),), + TOUT = SIMP(statut='f',typ='TXM',into=("OUI",) ), + GROUP_MA = SIMP(statut='f',typ='TXM',into=( + "BRIDE", + "GOUJON", + "ROND", + "ECROU", + "JOINT",) ), + MATER = SIMP(statut='o',typ=mater_sdaster), + TEMP_REF = SIMP(statut='d',typ='R',defaut= 25. ), + ), + CHAM_MATER = SIMP(statut = 'f',typ=CO,), + MODELE_THER= SIMP(statut = 'f',typ=CO,), + + DEFI_CHAR_THER = FACT(statut ='d', + TEMP_INIT = SIMP(statut='d',typ='R',defaut= 25.,), + COEF_H_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), + TEMP_EXT_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), + COEF_H_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), + TEMP_EXT_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), + LIST_INST = SIMP(statut='f',typ=listr8_sdaster), + ), + + CHAR_THER = FACT(statut = 'f',max=4, + CHARGE = SIMP(statut='o',typ=CO), + TYPE = SIMP(statut='o',typ='TXM', + into=("BRIDE_FLUIDE","BRIDE_AIR","ECROU_GOUJON", + "BRIDE_JOINT"),) + ), + + RESU_THER = SIMP(statut = 'f',typ=CO,), + + + MODELE_MECA= SIMP(statut = 'f',typ=CO,), + + DEFI_CHAR_MECA = FACT(statut='o', + PRETENS = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), + PRES_REP = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), + EFFE_FOND = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),), + ), + + CHAR_MECA = FACT(statut = 'f',max=11, + CHARGE = SIMP(statut='o',typ=CO), + TYPE = SIMP(statut='o',typ='TXM', + into=("BLOC_BAS_GOUJ","BLOC_BAS_JOINT", + "BLOC_LAT_ALES","BLOC_LAT_NALES", + "PLAN_TUBE", + "PRES_FLU","EFFET_FOND", + "CONT_JOINT", + "DEFO_THER", + "SERR_ECROU_1","SERR_ECROU_2",),) + ), + + RELATION = SIMP(statut='f',typ='TXM', + into=('VMIS_ISOT_TRAC','ELAS','ELAS_VMIS_TRAC',),), + + SOLVEUR = FACT(statut='d', + METHODE = SIMP(statut='d',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT",) ), + b_mult_front = BLOC(condition = "METHODE == 'MULT_FRONT' ", + fr="Paramètres de la méthode multi frontale", + RENUM = SIMP(statut='d',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ), + NPREC = SIMP(statut='d',typ='I',defaut=8), + STOP_SINGULIER = SIMP(statut='d',typ='TXM',defaut="OUI",into=("OUI","NON") ), + ), + ), + INCREMENT = FACT(statut='f', + regles=(EXCLUS('NUME_INST_INIT','INST_INIT'), + EXCLUS('NUME_INST_FIN','INST_FIN'),), + LIST_INST =SIMP(statut='f',typ=listr8_sdaster), + EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE", + into=("CHRONOLOGIQUE",) ), + 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-3 ), + # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + SUBD_METHODE =SIMP( statut='f',typ='TXM', + into =("AUCUNE","UNIFORME","EXTRAPOLE"), + defaut="AUCUNE", + fr="Méthode de subdivision des pas de temps en cas de non-convergence" + ), + 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, + fr="Coefficient multiplicateur de la 1ère subdivision"), + SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + ), + 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='c',typ='I',defaut=3,val_min=0, + fr="Les n premières itérations sont ignorées pour l'extrapolation"), + SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3, + fr="Seules les n dernières itérations sont prises pour l'extrapolation"), + SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2, + fr="Nombre de subdivision d'un pas de temps en cas divergence"), + SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2, + 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"), + SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20, + fr="% itération autorisée en plus"), + ), + # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS + OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),), + NOM_CHAM =SIMP(statut='f',typ='TXM',), + NOM_CMP =SIMP(statut='f',typ='TXM',), + VALE =SIMP(statut='f',typ='R'), + ), + NEWTON =FACT(statut='d', + REAC_INCR =SIMP(statut='f',typ='I',defaut= 1 ), + PREDICTION =SIMP(statut='f',typ='TXM',into=("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), + EVOL_NOLI =SIMP(statut='f',typ=evol_noli), + ), + RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE", + into=("IMPLICITE",)), + CONVERGENCE =FACT(statut='d', + regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),), + SIGM_REFE =SIMP(statut='f',typ='R'), + EPSI_REFE =SIMP(statut='f',typ='R'), + FLUX_THER_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), + ), + ); + +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG +# 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. -# ====================================================================== - -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), - - TABLE =SIMP(statut='o',typ=table_sdaster), - - LOI_PROPA =FACT(statut='o',max=01, - LOI =SIMP(statut='o',typ='TXM',into=("PARIS",),defaut="PARIS"), - b_paris =BLOC( condition = "LOI=='PARIS'", - C =SIMP(statut='o',typ='R',), - M =SIMP(statut='o',typ='R',),), - ), - GROUP_MA_ENRI =SIMP(statut='o',typ=grma,max=01), - - INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), -) ; -#& MODIF COMMANDE DATE 03/01/2006 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. -# ====================================================================== -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 16/05/2006 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 MCOURTOI M.COURTOIS -def recu_fonction_prod(RESULTAT=None,TABLE=None,OBSTACLE=None, - RESU_GENE=None,BASE_ELAS_FLUI=None,CHAM_GD=None, - TYPE_RESU=None,**args): - if AsType(RESULTAT) == dyna_harmo : return fonction_c - if AsType(RESU_GENE) == harm_gene : return fonction_c -# On ne sait pas interpreter les deux conditions suivantes - if TABLE != None : - if TYPE_RESU != None : - if TYPE_RESU == "FONCTION_C" : return fonction_c - if TYPE_RESU == "FONCTION" : return fonction_sdaster - else: - return fonction_sdaster - if RESU_GENE != None : return fonction_sdaster - if BASE_ELAS_FLUI != None : return fonction_sdaster - if RESULTAT != None : return fonction_sdaster - if CHAM_GD != None : return fonction_sdaster - if OBSTACLE != None : return fonction_sdaster - raise AsException("type de concept resultat non prevu") - -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','OBSTACLE'),), - - CHAM_GD =SIMP(statut='f',typ=(cham_no_sdaster, - cham_elem,),), - RESULTAT =SIMP(statut='f',typ=(evol_elas,dyna_trans,evol_noli,evol_ther,dyna_harmo ) ), - RESU_GENE =SIMP(statut='f',typ=(tran_gene, mode_gene, harm_gene)), - TABLE =SIMP(statut='f',typ=table_sdaster), - BASE_ELAS_FLUI =SIMP(statut='f',typ=melasflu_sdaster), - OBSTACLE =SIMP(statut='f',typ=obstacle_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)", - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - 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", ), - NOM_PARA_TABL =SIMP(statut='f',typ='TXM',into=("FONCTION",), - fr="Nom du paramètre de la table à qui est associé la fonction" ), - b_nom_para_tabl = BLOC (condition = "NOM_PARA_TABL != None", - TYPE_RESU =SIMP(statut='f',typ='TXM',defaut="FONCTION",into=("FONCTION","FONCTION_C") ), - ), - - 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' ), - ), - ), - ), +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== -# ======= 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' ), - ), +def crea_table_prod(TYPE_TABLE, **args): + """Typage du concept résultat + """ + if TYPE_TABLE == 'TABLE_FONCTION': + return table_fonction + else: + return table_sdaster -# ======= OBSTACLE ================================================= - b_obstacle = BLOC ( condition = "OBSTACLE != None", - fr="Choix du repère", - REPERE =SIMP(statut='f',typ='TXM',into=("POLAIRE","GLOBAL") ), - ), +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",)}, -# ======= 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") ), + regles=(EXCLUS('FONCTION','LISTE'),), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ), + 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'),), + + TITRE=SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE + + + +#& MODIF COMMANDE DATE 04/10/2005 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. +# 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."), # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. + b_test_de_la_sphere=BLOC( condition = "T_SPHERE=='OUI'", # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== -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=("ABSOLU","RELATIF") ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), -) ; -#& MODIF COMMANDE DATE 22/06/2005 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. + METHODE_TEST = SIMP(statut="f",typ="TXM",defaut="GAUSSIENNE", + into=("GAUSSIENNE","PARAMETRIQUE","REJECTION"), + fr="Type de méthode.", + ang="Method."), # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. + 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.") + ), # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# 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 -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 21/02/2006 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. +# 6.2.5.2. ==> Test du maximum fort # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. + T_MAXIMUM_FORT = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"), + fr="Test du maximum fort.", + ang="Strong maximum test."), # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# ====================================================================== + 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."), -RESO_GRAD=OPER(nom="RESO_GRAD",op= 84,sd_prod=cham_no_sdaster, - fr="Résolution d'un système linéaire par la méthode du gradient conjugué préconditionné", - reentrant='f', - UIinfo={"groupes":("Résolution",)}, - MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ), - CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster), - CHAM_CINE =SIMP(statut='f',typ=cham_no_sdaster), - MATR_FACT =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_temp_r,matr_asse_pres_r ) ), - NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), - REPRISE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), - RESI_RELA =SIMP(statut='f',typ='R',defaut= 1E-6 ), - INFO =SIMP(statut='f',typ='I',into=(1,2) ), -) ; -#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE + 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 05/09/2006 AUTEUR JOUMANA J.EL-GHARIB +# RESPONSABLE JMBHH01 J.M.PROIX # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 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 VABHHTS J.PELLET +DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster, + fr="Définir le comportement d'un monocristal ou d'un polycristal", + reentrant='n', + UIinfo={"groupes":("Modélisation",)}, + regles=(EXCLUS('MONOCRISTAL','POLYCRISTAL'),), -RESO_LDLT=OPER(nom="RESO_LDLT",op=15,sd_prod=cham_no_sdaster,reentrant='f', - fr="Résoudre par méthode directe un système d'équations linéaires préalablement factorisé par FACT_LDLT", - UIinfo={"groupes":("Résolution",)}, - MATR_FACT =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), - # RESI_RELA : précision utilisée si SOLVEUR=MUMPS - RESI_RELA =SIMP(statut='f',typ='R',defaut=1.e-6), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',into=(1,2) ), -) ; -#& MODIF COMMANDE DATE 20/03/2006 AUTEUR ACBHHCD G.DEVESA + 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), + ), + ), + + ); + +#& MODIF COMMANDE DATE 30/08/2005 AUTEUR ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 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 BOYERE E.BOYERE -def rest_base_phys_prod(RESU_GENE,RESU_PHYS,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(RESU_PHYS) == evol_noli : return dyna_trans - if AsType(RESULTAT) == evol_elas : return evol_elas - if AsType(RESULTAT) == evol_noli : return evol_noli - if AsType(RESULTAT) == evol_char : return evol_char - if AsType(RESULTAT) == dyna_trans : return dyna_trans - if AsType(RESULTAT) == mode_meca : return mode_meca - if AsType(RESULTAT) == mode_stat_depl : return mode_stat_depl - if AsType(RESULTAT) == base_modale : return base_modale - raise AsException("type de concept resultat non prevu") +# RESPONSABLE ASSIRE A.ASSIRE -REST_BASE_PHYS=OPER(nom="REST_BASE_PHYS",op= 75,sd_prod=rest_base_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=(UN_PARMI('RESU_GENE','RESU_PHYS','RESULTAT'), - EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','TOUT_INST'), - EXCLUS('TOUT_INST','NUME_ORDRE','INST','LIST_INST','TOUT_ORDRE'), -# Doc U à revoir - EXCLUS('MULT_APPUI','CORR_STAT'), - EXCLUS('MULT_APPUI','NOEUD','GROUP_NO'), - EXCLUS('CORR_STAT','NOEUD','GROUP_NO'), - EXCLUS('NOEUD','GROUP_NO'), - PRESENT_PRESENT('RESU_PHYS','BASE_MODALE'), - PRESENT_PRESENT('RESULTAT','SQUELETTE'), - PRESENT_PRESENT('ACCE_MONO_APPUI','DIRECTION'),), - RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_noli,dyna_trans,evol_char, - mode_meca,mode_stat_depl,base_modale) ), +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'),), + MAILLAGE =SIMP(statut='f',typ=maillage_sdaster), + MODELE =SIMP(statut='f',typ=modele_sdaster), + NB_PART =SIMP(statut='o',typ='I',val_min=2), + 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" ), - RESU_GENE =SIMP(statut='f',typ=(tran_gene,mode_gene,mode_cycl,harm_gene) ), - RESU_PHYS =SIMP(statut='f',typ=evol_noli ), - BASE_MODALE =SIMP(statut='f',typ=(base_modale,mode_meca) ), - 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") ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ), - 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",) ), - 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",) ), - TOUT_CHAM =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='**'), - - ACCE_MONO_APPUI =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)), - DIRECTION =SIMP(statut='f',typ='R',min=3,max=3 ), + LOGICIEL =SIMP(statut='f',typ='TXM'), - 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,mode_stat_depl,base_modale) ), - ), + # Corrige les problemes possibles de non-connexite des sous-domaines + CORRECTION_CONNEX =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')), - 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 03/01/2006 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. -# ====================================================================== -REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_sdaster, - 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='**' ), - INTE_SPEC_GENE =SIMP(statut='o',typ=table_sdaster), - 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_stat_depl,mode_stat_acce,mode_stat_forc), ), - 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 15/05/2006 AUTEUR ASSIRE A.ASSIRE + # 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 22/02/2005 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG @@ -22642,367 +23500,327 @@ REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_sdaster, # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +# RESPONSABLE 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,mode_stat,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='c',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 16/05/2006 AUTEUR REZETTE C.REZETTE +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 22/06/2005 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. +# 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 MABBAS 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'),), - 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','MAILLE'),), - CAS_CHARGE =SIMP(statut='o',typ='TXM' ), - TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), - MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**',), - ), - 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")), - ELAS =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_VMIS_TRAC =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_VMIS_LINE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_HYPER =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - ELAS_POUTRE_GR =SIMP(statut='c',typ='I',defaut=3,into=(3,)), - CABLE =SIMP(statut='c',typ='I',defaut=1,into=(1,)), - 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','VARI_NON_LOCAL',), - EXCLUS('EVOL_NOLI','DEPL',), - EXCLUS('EVOL_NOLI','SIGM',), - EXCLUS('EVOL_NOLI','VARI',), - EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), - 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), - VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), - EVOL_NOLI =SIMP(statut='f',typ=evol_noli), - NUME_ORDRE =SIMP(statut='f',typ='I'), - INST =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") ), - 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','VARI_NON_LOCAL',), - EXCLUS('EVOL_NOLI','DEPL',), - EXCLUS('EVOL_NOLI','SIGM',), - EXCLUS('EVOL_NOLI','VARI',), - EXCLUS('EVOL_NOLI','VARI_NON_LOCAL',), - 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), - VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_sdaster), - EVOL_NOLI =SIMP(statut='f',typ=evol_noli), - NUME_ORDRE =SIMP(statut='f',typ='I'), - INST =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") ), - NUME_DIDI =SIMP(statut='f',typ='I'), - INST_ETAT_INIT =SIMP(statut='f',typ='R'), - ),), - INCREMENT =FACT(statut='o', - regles=(EXCLUS('NUME_INST_INIT','INST_INIT'), - EXCLUS('NUME_INST_FIN','INST_FIN'),), - LIST_INST =SIMP(statut='o',typ=listr8_sdaster), - EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE", - into=("CHRONOLOGIQUE","RETROGRADE","SANS",) ), - 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-3 ), - SUBD_PAS =SIMP(statut='f',typ='I',defaut=1), - SUBD_PAS_MINI =SIMP(statut='f',typ='R'), - COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0), - OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),), - NOM_CHAM =SIMP(statut='f',typ='TXM',), - NOM_CMP =SIMP(statut='f',typ='TXM',), - VALE =SIMP(statut='f',typ='R'), - ), - 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), - ), - RECH_LINEAIRE =FACT(statut='f', - RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-1 ), - ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 3), - 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), +# RESPONSABLE MCOURTOI 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"), ), - 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","PRED_ELAS_INCR","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 =FACT(statut='d', - regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),), - 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'), - 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")), + 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"), ), - PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ), - SOLVEUR =FACT(statut='d', - METHODE=SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","FETI") ), - 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") ), + # 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_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_fonction_c =BLOC(condition = "AsType(FONCTION) == fonction_c", + fr="Fonction complexe définie par le mot-clé fonction", + PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ), ), - 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","DECOUPE") ), + b_list_resu =BLOC(condition = "LIST_RESU != None", + LIST_PARA =SIMP(statut='o',typ=listr8_sdaster ), ), - b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué", - PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),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_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_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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.,), + b_vale_resu =BLOC(condition = "ABSCISSE != None", + ORDONNEE =SIMP(statut='o',typ='R',max='**', + fr="Valeurs des ordonnées"), ), - 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), - 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") ), + + # le bloc n'est pas activé (vide) car position n'est pas pris en compte + b_forme =BLOC(condition = "FORMAT != 'TABLEAU'", + fr="Données de mise en forme de la fonction (cf. doc)", ), - SYME =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-3), - 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", - "VARI_NON_LOCAL","LANL_ELGA")), + 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 b_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") ), ), - OBSERVATION =FACT(statut='f',max='**', - regles=(UN_PARMI('NOEUD','GROUP_NO','MAILLE'), - PRESENT_PRESENT('MAILLE','POINT'),), - 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")), - NOM_CMP =SIMP(statut='o',typ='TXM',max='**' ), - LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**' ), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), - PAS_OBSE =SIMP(statut='f',typ='I'), - 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='**'), - POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'), + # 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"), + 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"), ), - - SUIVI_DDL = FACT(statut='f',max=4, - regles=(UN_PARMI('NOEUD','MAILLE'), - PRESENT_PRESENT('MAILLE','POINT'),), - NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4), - 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",)), - NOM_CMP =SIMP(statut='o',typ='TXM',max=1 ), - NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max=1), - MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max=1), - POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max=1), + 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 13/06/2006 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. +# ====================================================================== - 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", - "LAGR_ECAR","LAGR_INCR","LAGR_ITER", - "MATR_ASSE", - "ITER_DEBO", - "CTCD_ITER","CTCD_INFO","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")), - ), - ), +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=01,max=01,), + FISSURE =SIMP(statut='o',typ=fiss_xfem,min=01,max=01,), + CRITERE =SIMP(statut='f',typ='R',defaut=1.67E-8), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,)), +) ; +#& MODIF COMMANDE DATE 22/06/2005 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. +# ====================================================================== +POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=resultat_sdaster, + reentrant='n',UIinfo={"groupes":("Post traitements",)}, + fr="Calcul des champs DEPL et SIEF_ELGA sur le maillage fissuré", + MAILLAGE = SIMP(statut='o',typ=maillage_sdaster), + MODELE = SIMP(statut='o',typ=modele_sdaster,), + RESULTAT = SIMP(statut='o',typ=resultat_sdaster), + NOM_CHAM = SIMP(statut='o',typ='TXM',into=("DEPL","SIEF_ELGA"),) +); +#& MODIF COMMANDE DATE 22/06/2005 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. +# ====================================================================== +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), + TITRE = SIMP(statut='f',typ='TXM',max='**'), +); +#& MODIF COMMANDE DATE 24/10/2006 AUTEUR DURAND C.DURAND +# 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. +# ====================================================================== +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") - 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"), +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") ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3,val_min=0.E+0 ), ), - SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**', - fr="Liste des paramètres de sensibilité", - ang="List of sensitivity parameters"), - SOLV_NON_LOCAL =FACT(statut='f', - 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 =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") ), - ), - 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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,), - ), - 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 ), - RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ), - NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ), - ), - EPS =SIMP(statut='f',typ='R',defaut= 0.E+0 ), - ), - LAGR_NON_LOCAL =FACT(statut='f', - ITER_DUAL_MAXI =SIMP(statut='f',typ='I',defaut= 50), - RESI_DUAL_ABSO =SIMP(statut='o',typ='R'), - RESI_PRIM_ABSO =SIMP(statut='o',typ='R'), - R =SIMP(statut='f',typ='R',defaut= 1000.), - ITER_PRIM_MAXI =SIMP(statut='f',typ='I',defaut= 10), + 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 =BLOC(condition="""OPTION=="TOUT" or OPTION=="INTE_SPEC" """, + AMOR_REDUIT =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 ), + PESANTEUR =SIMP(statut='f',typ='R',defaut= 9.81E+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)", + PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3,val_min=0.E+0), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), ), - INFO =SIMP(statut='f',typ='I',into=(1,2) ), - TITRE =SIMP(statut='f',typ='TXM',max='**' ), - ) - -#& MODIF COMMANDE DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS + ), + 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") ), + PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3,val_min=0.E+0 ), + ), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), +) +#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# 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 @@ -23017,622 +23835,432 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, # 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 MCOURTOI M.COURTOIS -from Macro.test_fichier_ops import test_fichier_ops +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 -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)), - NB_CHIFFRE =SIMP(statut='o',typ='I',), # defaut=6 pas de defaut, il faut - EPSILON =SIMP(statut='o',typ='R',), # defaut=1.E-12 se poser la question ! - EXPR_IGNORE =SIMP(statut='f',typ='TXM',max='**', - fr="Liste d'expressions régulières permettant d'ignorer certaines lignes"), - VALE_K =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' ), - ), +from Macro.calc_table_ops import calc_table_ops - INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), -) -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI 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 MCOURTOI M.COURTOIS -TEST_FONCTION=PROC(nom="TEST_FONCTION",op= 135, - 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',), - 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='o',typ='R' ,validators=NoRepeat(),max=2), - VALE_REFE =SIMP(statut='f',typ='R' ), - VALE_REFE_C =SIMP(statut='f',typ='C' ), - 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' ), - ), +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', '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'), + VALE_I = SIMP(statut='f',typ='I'), + VALE_C = SIMP(statut='f',typ='C'), + VALE_K = 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' ), - ), + b_regexp = BLOC(condition = "CRIT_COMP == 'REGEXP'", + VALE_K = 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_sdaster), - 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' ), - 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' ), - ), + 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 ), ), -) ; -#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE -# RESPONSABLE VABHHTS J.PELLET + ), + + 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"), + ), + + 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 30/08/2005 AUTEUR ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. -# -# +# COPYRIGHT (C) 1991 - 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. # ====================================================================== -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')), +# RESPONSABLE ASSIRE A.ASSIRE - 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'), - 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'), - ), +DEFI_PART_PA_OPS=OPER(nom="DEFI_PART_PA_OPS",op=29,sd_prod=sd_feti_sdaster, + fr="Creation partitionnement en sous-domaines pour FETI", + docu="U4.00.00",reentrant='n', + 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',), - 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' ), - 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' ), - ), + # Methode de partitionnement + METHODE =SIMP(statut='f',typ='TXM',into=("PMETIS","SCOTCH","KMETIS",), defaut="SCOTCH" ), + + LOGICIEL =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'), - 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',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' ), - ), + # Corrige les problemes possibles de non-connexite des sous-domaines + CORRECTION_CONNEX =SIMP(statut='f',typ='TXM',defaut='NON',into=('OUI','NON')), - 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'), - 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',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' ), - ), + # 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' ), - OBJET =FACT(statut='f',max='**', - regles=(UN_PARMI('S_I','S_R','RESUME',), - UN_PARMI('VALE','VALE_I','VALE_C','RESUME','S_R','S_I'),), - NOM =SIMP(statut='o',typ='TXM'), - S_R =SIMP(statut='f',typ='R'), - S_I =SIMP(statut='f',typ='I'), - RESUME =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' ), - ), + # 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 13/02/2006 AUTEUR DURAND C.DURAND +# 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. +# ====================================================================== +# ====================================================================== + +MAC_MODES=OPER(nom="MAC_MODES",op= 141,sd_prod=table_sdaster, + fr="Normalisation de modes propres", + reentrant='n', + UIinfo={"groupes":("Résolution",)}, + BASE_1 =SIMP(statut='o',typ=(mode_meca,mode_flamb,base_modale) ), + BASE_2 =SIMP(statut='o',typ=(mode_meca,mode_flamb,base_modale) ), + MATR_ASSE =SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_depl_c) ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), ) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#& MODIF COMMANDE DATE 19/09/2006 AUTEUR ACBHHCD 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. +# 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 VABHHTS J.PELLET -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' ),), +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=base_modale ), + 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") ), +) ; - 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' ), - 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.2E-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 21/02/2006 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. +# ====================================================================== +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=base_modale ), + 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 10/05/2006 AUTEUR MCOURTOI M.COURTOIS + +#& MODIF COMMANDE DATE 31/10/2006 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. +# 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. # ====================================================================== -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', - LIST_INST =SIMP(statut='o',typ=listr8_sdaster ), - NUME_INIT =SIMP(statut='f',typ='I'), - NUME_FIN =SIMP(statut='f',typ='I'), - ), - TEMP_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_INIT =SIMP(statut='f',typ='I'), - ), - 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") ), - 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") ), - ), - 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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,), - ), - ), - PARM_THETA =SIMP(statut='f',typ='R',defaut= 0.57), - ARCHIVAGE =FACT(statut='f', - regles=(UN_PARMI('LIST_ARCH','PAS_ARCH','LIST_INST','INST'),), - LIST_ARCH =SIMP(statut='f',typ=listis_sdaster), - LIST_INST =SIMP(statut='f',typ=listr8_sdaster), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF", - into=("RELATIF","ABSOLU")), - PAS_ARCH =SIMP(statut='f',typ='I'), - CHAM_EXCLU =SIMP(statut='f',typ='TXM',into=("VARI",)), +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'), + EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST', + 'TOUT_MODE','NUME_MODE','LIST_MODE','FREQ','LIST_FREQ',),), + + 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), + regles=(EXCLUS('FOND_FISS','FISSURE'),), + b_theta =BLOC(condition="THETA == None",fr="calcul de theta", + regles=(UN_PARMI('R_INF','R_INF_FO'), + EXCLUS('MODULE','MODULE_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'), + 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)), + ), + ), + + RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,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), + 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)", + PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6), + CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ), ), - TITRE =SIMP(statut='f',typ='TXM',max='**'), - INFO =SIMP(statut='f',typ='I',into=(1,2)), -) ; -#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI 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. -# ====================================================================== -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='**'), + + 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",) ), ), - 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)), + 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 =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), + ELAS_VMIS_LINE =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), + ELAS_VMIS_TRAC =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), + 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 =SIMP(statut='f',typ='I',defaut=1,into=(1,) ), + VMIS_ISOT_TRAC =SIMP(statut='f',typ='I',defaut=2,into=(2,) ), + VMIS_ISOT_LINE =SIMP(statut='f',typ='I',defaut=2,into=(2,) ), + 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='**'), ), - INCREMENT =FACT(statut='f', - LIST_INST =SIMP(statut='o',typ=listr8_sdaster), - NUME_INIT =SIMP(statut='f',typ='I'), - NUME_FIN =SIMP(statut='f',typ='I'), + ETAT_INIT =FACT(statut='f', + SIGM =SIMP(statut='f',typ=cham_elem), + DEPL =SIMP(statut='f',typ=cham_no_sdaster), ), - TEMP_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_INIT =SIMP(statut='f',typ='I'), + + 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"),), ), - NEWTON =FACT(statut='d', - REAC_ITER =SIMP(statut='f',typ='I',defaut= 0 ), - RESI_LINE_RELA =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), - ITER_LINE_MAXI =SIMP(statut='f',typ='I',defaut= 0 ), + + 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","G_LAGR","G_LAGR_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'), + ), ), - 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 ), + 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='**'), + ), ), + + PROPAGATION =SIMP(statut='f',typ='R'), + THETA_LAGR =SIMP(statut='f',typ=theta_geom), + DIRE_THETA_LAGR =SIMP(statut='f',typ=cham_no_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", - ), - 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="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 =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' ", - fr="Parametres relatifs a la non inversibilité de la matrice a factorise", - 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')), - PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,), - RESI_RELA =SIMP(statut='f',typ='R',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=(UN_PARMI('LIST_ARCH','PAS_ARCH','LIST_INST','INST', ),), - LIST_ARCH =SIMP(statut='f',typ=(listis_sdaster) ), - LIST_INST =SIMP(statut='f',typ=(listr8_sdaster) ), - INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'), - PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ), - CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ), - PAS_ARCH =SIMP(statut='f',typ='I'), - CHAM_EXCLU =SIMP(statut='f',typ='TXM',into=("VARI",)), - ), - 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) ), + fr="Liste des paramètres de sensibilité.", + ang="List of sensitivity parameters"), -) ; -#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE + TITRE =SIMP(statut='f',typ='TXM',max='**'), + INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), +); +#& MODIF COMMANDE DATE 22/08/2006 AUTEUR MASSIN P.MASSIN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== -# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# COPYRIGHT (C) 1991 - 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. # ====================================================================== -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) ), - ), - TEMP_INIT =FACT(statut='f', - EVOL_THER =SIMP(statut='f',typ=evol_ther ), - NUME_INIT =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") ), - 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") ), - ), - 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 ), - ), - 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) ), -) ; +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), + + TABLE =SIMP(statut='o',typ=table_sdaster), + + LOI_PROPA =FACT(statut='o',max=01, + LOI =SIMP(statut='o',typ='TXM',into=("PARIS",),defaut="PARIS"), + b_paris =BLOC( condition = "LOI=='PARIS'", + C =SIMP(statut='o',typ='R',), + M =SIMP(statut='o',typ='R',),), + ), + + RAYON =SIMP(statut='o',typ='R',), + + METHODE =SIMP(statut='f',typ='TXM',into=("SIMPLEXE","UPWIND",),defaut="COEFF_POSITIF"), +# RUNGE_KUTTA =SIMP(statut='f',typ='I',into=("1","2",),defaut=1), + INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ), +) ; diff --git a/Aster/Cata/cataSTA8/ops.py b/Aster/Cata/cataSTA8/ops.py index 088e9561..6e6ab0f7 100644 --- a/Aster/Cata/cataSTA8/ops.py +++ b/Aster/Cata/cataSTA8/ops.py @@ -1,4 +1,4 @@ -#@ MODIF ops Cata DATE 08/11/2005 AUTEUR D6BHHJP J.P.LEFEBVRE +#@ MODIF ops Cata DATE 24/10/2006 AUTEUR DURAND C.DURAND # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -121,6 +121,7 @@ def POURSUITE(self,PAR_LOT,IMPR_MACRO,CODE,DEBUG,**args): 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 for k,v in d.items(): self.parent.NommerSdprod(v,k) @@ -144,6 +145,10 @@ def POURSUITE(self,PAR_LOT,IMPR_MACRO,CODE,DEBUG,**args): for elem in pickle_context.keys(): if type(pickle_context[elem])==types.InstanceType : pickle_class=pickle_context[elem].__class__ + # on rattache chaque assd au nouveau jdc courant (en poursuite) + if isinstance(pickle_context[elem],ASSD) : + pickle_context[elem].jdc=self.jdc + pickle_context[elem].parent=self.jdc if elem in self.g_context.keys(): poursu_class=self.g_context[elem].__class__ if poursu_class!=pickle_class : @@ -403,7 +408,6 @@ def INCLUDE_MATERIAU(self,NOM_AFNOR,TYPE_MODELE,VARIANTE,TYPE_VALE,NOM_MATER, # 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.prefix=NOM_MATER self.text= subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR) if INFO == 2: print "INCLUDE_MATERIAU: ", self.mat,' ',NOM_MATER,'\n' diff --git a/Aster/editeur.ini b/Aster/editeur.ini index 09c41684..1ebdff57 100644 --- a/Aster/editeur.ini +++ b/Aster/editeur.ini @@ -43,6 +43,7 @@ catalogues = ( # ('ASTER','v5.9',os.path.join(rep_cata,'cataSTA5'),'asterv5'), # ('ASTER','v6.8',os.path.join(rep_cata,'cataSTA6'),'python6'), # ('ASTER','v7.7',os.path.join(rep_cata,'cataSTA7'),'python'), - ('ASTER','v8.3',os.path.join(rep_cata,'cataSTA8'),'python','defaut'), + ('ASTER','v8.4',os.path.join(rep_cata,'cataSTA8'),'python'), + ('ASTER','v8',os.path.join(rep_cata,'cataSTA8'),'python','defaut'), ) diff --git a/Editeur/compomacro.py b/Editeur/compomacro.py index 543391d6..e08513a5 100644 --- a/Editeur/compomacro.py +++ b/Editeur/compomacro.py @@ -37,7 +37,7 @@ from widgets import showinfo,showerror # __version__="$Name: $" -__Id__="$Id: compomacro.py,v 1.24 2005/11/03 09:03:48 eficas Exp $" +__Id__="$Id: compomacro.py,v 1.25 2005/12/07 10:20:34 eficas Exp $" # class MACROPanel(panels.OngletPanel): @@ -206,9 +206,17 @@ class INCLUDETreeItemBase(MACROTreeItem): #print "makeEdit",self.object,self.object.nom #print "makeEdit",self.object.jdc_aux,self.object.jdc_aux.nom #print "makeEdit",self.object.jdc_aux.context_ini + if self.object.text_converted == 0: + # Le texte du fichier inclus n'a pas pu etre converti par le module convert + msg="Le fichier de commande n'a pas pu etre converti pour etre editable par Eficas\n\n" + msg=msg+self.object.text_error + Fenetre(self,titre="Include non editable",texte=msg,wrap='none') + return + if not hasattr(self.object,"jdc_aux") or self.object.jdc_aux is None: #L'include n'est pas initialise self.object.build_include(None,"") + # On cree un nouvel onglet dans le bureau appli.bureau.ShowJDC(self.object.jdc_aux,self.object.jdc_aux.nom, label_onglet=None, @@ -216,8 +224,10 @@ class INCLUDETreeItemBase(MACROTreeItem): def makeView(self,appli,node): if not hasattr(self.object,"jdc_aux") or self.object.jdc_aux is None: - showerror("Include vide","L'include doit etre correctement initialisé pour etre visualisé") + showerror("Include vide", + "L'include doit etre correctement initialisé pour etre visualisé") return + nom=self.object.nom if hasattr(self.object,'fichier_ini'): if self.object.fichier_ini is None: @@ -242,11 +252,19 @@ class INCLUDETreeItem(INCLUDETreeItemBase): class POURSUITETreeItem(INCLUDETreeItemBase): def makeEdit(self,appli,node): + if self.object.text_converted == 0: + # Le texte du fichier inclus n'a pas pu etre converti par le module convert + msg="Le fichier de commande n'a pas pu etre converti pour etre editable par Eficas\n\n" + msg=msg+self.object.text_error + Fenetre(self,titre="Poursuite non editable",texte=msg,wrap='none') + return + if not hasattr(self.object,"jdc_aux") or self.object.jdc_aux is None: #La poursuite n'est pas initialisee text="""DEBUT() FIN()""" self.object.build_poursuite(None,text) + # On cree un nouvel onglet dans le bureau appli.bureau.ShowJDC(self.object.jdc_aux,self.object.jdc_aux.nom, label_onglet=None, diff --git a/Editeur/macrodisplay.py b/Editeur/macrodisplay.py index 7d769e9f..464d59a8 100644 --- a/Editeur/macrodisplay.py +++ b/Editeur/macrodisplay.py @@ -49,7 +49,7 @@ class MacroDisplay: self.nom_jdc=nom_jdc self.appli=appli self.barre=Tkinter.Frame(self.fenetre,relief="ridge",bd=2) - self.barre.pack(expand=1,fill=Tkinter.X) + self.barre.pack(expand=0,fill=Tkinter.X) if self.macroitem.object.fichier_text is not None: b=Tkinter.Button(self.barre,image=images.get_image("Zoom24"),command=self.visufile) b.pack(side='left') diff --git a/Editeur/widgets.py b/Editeur/widgets.py index 9fba89dc..0784ce93 100644 --- a/Editeur/widgets.py +++ b/Editeur/widgets.py @@ -55,11 +55,11 @@ def askyesno(title=None, message=None, **options): class Fenetre : """ Cette classe permet de créer une fenêtre Toplevel dans laquelle on peut afficher un texte et qui permet de le sauver""" - def __init__(self,appli,titre="",texte=""): + def __init__(self,appli,titre="",texte="",wrap=WORD,width=100,height=30): self.appli=appli self.fenetre = Toplevel() self.fenetre.withdraw() - self.fenetre.configure(width = 800,height=500) + #self.fenetre.configure(width = 800,height=500) self.fenetre.protocol("WM_DELETE_WINDOW", self.quit) self.fenetre.title("Visualisation du "+titre) self.texte = string.replace(texte,'\r\n','\n') @@ -68,10 +68,11 @@ class Fenetre : # définition des frames self.frame_texte = Frame(self.fenetre) self.frame_boutons = Frame(self.fenetre) - self.frame_texte.place(relx=0,rely=0,relwidth=1,relheight=0.9) - self.frame_boutons.place(relheight=0.1,relx=0,rely=0.9,relwidth=1.) + #self.frame_texte.place(relx=0,rely=0,relwidth=1,relheight=0.9) + #self.frame_boutons.place(relheight=0.1,relx=0,rely=0.9,relwidth=1.) # définition de la zone texte et du scrollbar - self.zone_texte = Text(self.frame_texte,font=fonte) + self.zone_texte = Text(self.frame_texte,font=fonte,wrap=wrap, + height=height,width=width) self.zone_texte.bind("", self.page_up) self.zone_texte.bind("", self.page_down) self.zone_texte.bind("", self.unit_up) @@ -83,10 +84,18 @@ class Fenetre : self.zone_texte.pack(side='top',fill='both',expand=1,padx=5,pady=10) self.zone_texte.configure(yscrollcommand=self.scroll_v.set) # définition des boutons - self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit,default='active') - self.but_save = Button(self.frame_boutons,text = "sauver",command = self.save) - self.but_quit.place(relx=0.4,rely=0.5,anchor='center') - self.but_save.place(relx=0.6,rely=0.5,anchor='center') + self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit, + default='active') + self.but_save = Button(self.frame_boutons,text = "Sauver",command = self.save) + #self.but_quit.place(relx=0.4,rely=0.5,anchor='center') + #self.but_save.place(relx=0.6,rely=0.5,anchor='center') + self.but_quit.pack(side='left',padx=25, pady=5) + self.but_save.pack(side='right',padx=25, pady=5) + self.frame_texte.pack(side='top',fill='both',expand=1) + self.frame_boutons.pack(side='bottom') + self.zone_texte.focus_set() + self.fenetre.bind('',self.quit) #dismiss window + # affichage du texte self.affiche_texte(self.texte) self.zone_texte.config(state=DISABLED) @@ -95,20 +104,25 @@ class Fenetre : def page_up(self,event): event.widget.yview_scroll(-1, "page") + return "break" #Pour eviter la propagation de l'evenement a la fenetre principale def page_down(self,event): event.widget.yview_scroll(1, "page") + return "break" #Pour eviter la propagation de l'evenement a la fenetre principale def unit_up(self,event): event.widget.yview_scroll(-1, "unit") + return "break" #Pour eviter la propagation de l'evenement a la fenetre principale def unit_down(self,event): event.widget.yview_scroll(1, "unit") + return "break" #Pour eviter la propagation de l'evenement a la fenetre principale def wait(self): self.fenetre.grab_set() self.zone_texte.focus_set() self.fenetre.wait_window(self.fenetre) - def quit(self): + def quit(self,event=None): self.fenetre.destroy() + return "break" #Pour eviter la propagation de l'evenement a la fenetre principale def efface_scroll(self): """ Efface le scroll lorsqu'il n'est pas nécessaire : ne marche pas""" diff --git a/Extensions/jdc_include.py b/Extensions/jdc_include.py index 8a74ee42..580be8eb 100644 --- a/Extensions/jdc_include.py +++ b/Extensions/jdc_include.py @@ -27,6 +27,7 @@ que le jeu de commandes inclus est valide et compatible avec le contexte avant et apres l'insertion """ +import string from Accas import JDC,ASSD,AsException,JDC_CATA from Ihm import CONNECTOR @@ -53,6 +54,9 @@ class JDC_POURSUITE(JDC): if recorded_units is not None:self.recorded_units=recorded_units if old_recorded_units is not None:self.old_recorded_units=old_recorded_units + def o_register(self,sd): + return self.jdc_pere.o_register(sd) + def NommerSdprod(self,sd,sdnom,restrict='non'): """ Nomme la SD apres avoir verifie que le nommage est possible : nom @@ -64,6 +68,28 @@ class JDC_POURSUITE(JDC): #print "NommerSdprod",sd,sdnom,restrict if self.prefix_include: if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom + + if sdnom != '' and sdnom[0] == '_': + # Si le nom du concept commence par le caractere _ on lui attribue + # un identificateur automatique comme dans JEVEUX (voir gcncon) + # + # nom commencant par __ : il s'agit de concepts qui seront detruits + # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes + # ATTENTION : il faut traiter différemment les concepts dont le nom + # commence par _ mais qui sont des concepts nommés automatiquement par + # une éventuelle sous macro. + if sdnom[1] in string.digits: + # Ce concept provient probablement d'une sous macro (cas improbable) + #pas de renommage + pass + elif sdnom[1] == '_': + #cas d'un concept à ne pas conserver apres execution de la commande + sdnom=sd.id[2:] + pass + else: + sdnom=sd.id[2:] + pass + o=self.sds_dict.get(sdnom,None) if isinstance(o,ASSD): raise AsException("Nom de concept deja defini : %s" % sdnom) diff --git a/Ihm/I_MACRO_ETAPE.py b/Ihm/I_MACRO_ETAPE.py index 258f44ca..0ab72b58 100644 --- a/Ihm/I_MACRO_ETAPE.py +++ b/Ihm/I_MACRO_ETAPE.py @@ -26,9 +26,13 @@ import traceback,types,string # Modules Eficas import I_ETAPE +import I_ENTITE +import I_OBJECT import Noyau from Noyau.N_ASSD import ASSD +from Noyau import N__F import convert +from Extensions import param2 # import rajoutés suite à l'ajout de Build_sd --> à résorber import Noyau, Validation.V_MACRO_ETAPE @@ -41,6 +45,10 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): def __init__(self): self.typret=None + #indique si le jeu de commande inclus a pu etre analysé par convert + #pour etre editable (0=NON, 1=OUI) + self.text_converted=1 + self.text_error="" self.recorded_units={} def get_sdprods(self,nom_sd): @@ -99,13 +107,22 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # Il faut convertir le texte inclus en fonction du format # sauf les INCLUDE_MATERIAU + self.text_converted=0 + self.text_error="" if self.nom != "INCLUDE_MATERIAU": format=self.jdc.appli.format_fichier.get() if convert.plugins.has_key(format): # Le convertisseur existe on l'utilise p=convert.plugins[format]() p.text=text - text=p.convert('exec',self) + text=p.convert('exec',self.jdc.appli) + #Si le fichier ne peut pas etre converti, le cr n'est pas vide + #et le texte est retourné tel que + if not p.cr.estvide(): + self.text_converted=0 + self.text_error=str(p.cr) + else: + self.text_converted=1 j=self.JdC_aux( procedure=text, nom=fichier, appli=self.jdc.appli, @@ -132,6 +149,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # Erreurs dans l'INCLUDE. On garde la memoire du fichier # mais on n'insere pas les concepts # On retablit l'etape courante step + #print j.cr CONTEXT.unset_current_step() CONTEXT.set_current_step(step) raise Exception("Impossible de relire le fichier\n"+str(j.cr)) @@ -140,6 +158,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # L'INCLUDE n'est pas valide. # on produit un rapport d'erreurs cr=j.report() + #print cr # On retablit l'etape courante step CONTEXT.unset_current_step() CONTEXT.set_current_step(step) @@ -157,6 +176,9 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): CONTEXT.set_current_step(step) raise + # Si on est arrivé ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...) + # est valide et insérable dans le JDC + # On remplit le dictionnaire des concepts produits inclus # en retirant les concepts présents dans le contexte initial # On ajoute egalement le concept produit dans le sds_dict du parent @@ -168,6 +190,20 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): self.g_context[k]=v self.parent.sds_dict[k]=v + #Ce traitement n'est réalisé que dans les cas suivants: + # - si convert n'a pas pu convertir le jeu de commandes + # - et ce n'est pas un INCLUDE_MATERIAU + #On collecte les variables Python qui ne sont pas dans le contexte initial + #et dans le contexte validé et on en fait un pseudo-parametre (Variable) + if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU": + for k,v in j.g_context.items(): + if k in context_ini:continue + if k in j_context:continue + if isinstance(v,ASSD):continue + if isinstance(v,I_ENTITE.ENTITE):continue + if isinstance(v,I_OBJECT.OBJECT):continue + if callable(v):continue + self.g_context[k]=param2.Variable(k,v) # On recupere le contexte courant self.current_context=j.current_context @@ -788,7 +824,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): """ Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU en interprétant un texte source Python - Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU + Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU """ #print "make_contexte",fichier # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU @@ -807,14 +843,22 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): import Extensions.jdc_include self.JdC_aux=Extensions.jdc_include.JdC_include except: - traceback.print_exc() raise try: self.make_contexte_include(self.fichier_ini ,self.fichier_text) + if not self.g_context.has_key(self.nom_mater): + #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones + self.g_context[self.nom_mater]=None + if self.parent: self.parent.g_context[self.nom_mater]=None except: l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1]) self.fichier_err = string.join(l) self.g_context={} + #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones + if self.parent: + self.parent.g_context[self.nom_mater]=None + self.g_context[self.nom_mater]=None + #------------- self.etapes=[] self.jdc_aux=None self.contexte_fichier_init={} diff --git a/Noyau/N_ETAPE.py b/Noyau/N_ETAPE.py index dde08f5b..2e96ccfc 100644 --- a/Noyau/N_ETAPE.py +++ b/Noyau/N_ETAPE.py @@ -1,4 +1,4 @@ -#@ MODIF N_ETAPE Noyau DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF N_ETAPE Noyau DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -37,6 +37,7 @@ import N_MCCOMPO from N_Exception import AsException import N_utils from N_utils import AsType +from N_ASSD import ASSD class ETAPE(N_MCCOMPO.MCCOMPO): """ @@ -190,6 +191,14 @@ class ETAPE(N_MCCOMPO.MCCOMPO): self.sd= sd_prod(etape=self) # Si l'operateur est obligatoirement reentrant et reuse n'a pas ete specifie, c'est une erreur. # On ne fait rien ici. L'erreur sera traiter par la suite. + # précaution + if self.sd is not None and not isinstance(self.sd, ASSD): + raise AsException(""" +Impossible de typer le résultat ! +Causes possibles : + Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte, + soit il y a une "," à la fin d'une commande précédente. + Développeur : La fonction "sd_prod" retourne un type invalide.""") return self.sd def get_type_produit(self): diff --git a/Noyau/N_MACRO_ETAPE.py b/Noyau/N_MACRO_ETAPE.py index 43ff1d7d..7b3f3454 100644 --- a/Noyau/N_MACRO_ETAPE.py +++ b/Noyau/N_MACRO_ETAPE.py @@ -1,4 +1,4 @@ -#@ MODIF N_MACRO_ETAPE Noyau DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS +#@ MODIF N_MACRO_ETAPE Noyau DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -37,6 +37,7 @@ from N_Exception import AsException import N_utils from N_utils import AsType from N_CO import CO +from N_ASSD import ASSD class MACRO_ETAPE(N_ETAPE.ETAPE): """ @@ -209,6 +210,14 @@ class MACRO_ETAPE(N_ETAPE.ETAPE): self.typret=sd_prod # Si la commande est obligatoirement reentrante et reuse n'a pas ete specifie, c'est une erreur. # On ne fait rien ici. L'erreur sera traitee par la suite. + # précaution + if self.sd is not None and not isinstance(self.sd, ASSD): + raise AsException(""" +Impossible de typer le résultat ! +Causes possibles : + Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte, + soit il y a une "," à la fin d'une commande précédente. + Développeur : La fonction "sd_prod" retourne un type invalide.""") return self.sd def get_type_produit(self,force=0): diff --git a/Noyau/N_MCLIST.py b/Noyau/N_MCLIST.py index 6c7ab567..cbf60d43 100644 --- a/Noyau/N_MCLIST.py +++ b/Noyau/N_MCLIST.py @@ -1,4 +1,4 @@ -#@ MODIF N_MCLIST Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND +#@ MODIF N_MCLIST Noyau DATE 25/09/2006 AUTEUR MCOURTOI M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -205,3 +205,17 @@ class MCList(UserList.UserList): return self.data[0].get_mocle(key) else: return self.data[key] + + def List_F(self): + """ + Retourne une liste de dictionnaires (eventuellement singleton) qui peut etre + passe directement derriere un mot-cle facteur (pour les macros). + """ + dresu = [] + for mcf in self: + dico = mcf.cree_dict_valeurs(mcf.mc_liste) + for i in dico.keys(): + if dico[i] == None: + del dico[i] + dresu.append(dico) + return dresu diff --git a/Noyau/N_SENSIBILITE.py b/Noyau/N_SENSIBILITE.py index 29ffc1de..3501df17 100644 --- a/Noyau/N_SENSIBILITE.py +++ b/Noyau/N_SENSIBILITE.py @@ -161,6 +161,9 @@ class DERIVABLE(REGLE): concept = [concept,] l_ps = obj["SENSIBILITE"] for co in concept: + if co is None: + text="Pas de sensibilité sur objet None" + return text,0 if not l_ps: # pas de sensibilité if hasattr(co,"sensi") and not co.sensi.get('nominal'): diff --git a/Tests/config.py b/Tests/config.py index b6711092..b6edf378 100644 --- a/Tests/config.py +++ b/Tests/config.py @@ -1,8 +1,5 @@ - import sys -sys.path.insert(0,"../Aster") import prefs #ASTERDIR="/local/chris/ASTER/instals/STA8.2/astest" -ASTERDIR="/local/chris/ASTER/instals/NEW8/astest" -sys.path.insert(0,prefs.CODE_PATH) +ASTERDIR="/local/chris/ASTER/instals/astests/V8.3.21" diff --git a/Tests/editeur.ini b/Tests/editeur.ini new file mode 100644 index 00000000..4f495120 --- /dev/null +++ b/Tests/editeur.ini @@ -0,0 +1,53 @@ +# 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 + +import prefs + +rep_cata = os.path.abspath(os.path.join(prefs.REPINI,'../Aster/Cata')) +rep_Pmw = os.path.join(prefs.REPINI,'../Pmw') + +# Accès à la documentation Aster +path_doc = os.path.join(rep_cata,'..','Doc') +exec_acrobat = "acroread" +# Utilisateur/Développeur +isdeveloppeur = "NON" +path_cata_dev = "/tmp/cata" +# Répertoire temporaire +rep_travail = "/tmp" +# Répertoire initial +initialdir=os.curdir + +# Choix des catalogues +rep_mat=os.path.join(rep_cata,'..','materiau') +rep_mat="/local/cchris/ASTER/instals/materiaux/NEW8/materiau" + +catalogues = ( + ('ASTER','petit',os.path.join(rep_cata,'petitcata'),'python'), + ('ASTER','v5.9',os.path.join(rep_cata,'cataSTA5'),'asterv5'), + ('ASTER','v6.8',os.path.join(rep_cata,'cataSTA6'),'python6'), + ('ASTER','v6',os.path.join(rep_cata,'cataSTA6'),'python6'), + ('ASTER','v7.7',os.path.join(rep_cata,'cataSTA7'),'python'), + ('ASTER','v7',os.path.join(rep_cata,'cataSTA7'),'python'), + ('ASTER','v8.4',os.path.join(rep_cata,'cataSTA8'),'python'), + ('ASTER','v8',os.path.join(rep_cata,'cataSTA8'),'python','defaut'), + ) + diff --git a/Tests/eficas_aster.py b/Tests/eficas_aster.py new file mode 100755 index 00000000..1d298b58 --- /dev/null +++ b/Tests/eficas_aster.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# 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. +# +# +# ====================================================================== + +""" + Ce module sert à lancer EFICAS configuré pour Code_Aster +""" +# Modules Python + +# Modules Eficas +import prefs +from Editeur import eficas_go + +eficas_go.lance_eficas() diff --git a/Tests/prefs.py b/Tests/prefs.py index e69de29b..28a5c8ed 100644 --- a/Tests/prefs.py +++ b/Tests/prefs.py @@ -0,0 +1,104 @@ +# -*- coding: utf-8 -*- +# 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 + +# REPINI sert à localiser le fichier editeur.ini +# Obligatoire +REPINI=os.path.dirname(os.path.abspath(__file__)) + +# INSTALLDIR sert à localiser l'installation d'Eficas +# Obligatoire +INSTALLDIR=os.path.join(REPINI,'..') + +# CODE_PATH sert à localiser Noyau et Validation éventuellement +# non contenus dans la distribution EFICAS +# Par défaut on utilise les modules de INSTALLDIR +# Peut valoir None (defaut) +CODE_PATH = None +#CODE_PATH = os.path.join(REPINI,'../../Superv') + +# la variable code donne le nom du code a selectionner +code="ASTER" + +# ICONDIR sert à localiser le répertoire contenant les icones +# Par défaut on utilise le répertoire icons dans Editeur +ICONDIR=os.path.join(INSTALLDIR,'Editeur','icons') + +# lang indique la langue utilisée pour les chaines d'aide : fr ou ang +lang='fr' + +# Codage des strings qui accepte les accents (en remplacement de 'ascii') +encoding='iso-8859-1' + +labels= ('Fichier','Edition','Jeu de commandes', +# 'Catalogue','Browsers', + 'Options', + 'Aide', + ) + +appli_composants=['readercata','bureau', +# 'browser', + 'options', + ] + +menu_defs={ 'bureau': [ + ('Fichier',[ + ('Nouveau','newJDC','','Ctrl+N'), + ('Nouvel INCLUDE','newJDC_include'), + ('Ouvrir','openJDC','','Ctrl+O'), + ('Enregistrer','saveJDC','','Ctrl+S'), + ('Enregistrer sous','saveasJDC','','Ctrl+E'), + None, + ('Fermer','closeJDC','','Ctrl+W'), + ('Quitter','exitEFICAS','','Ctrl+Q'), + ] + ), + ('Edition',[ + ('Copier','copy','','Ctrl+C'), + ('Couper','cut','','Ctrl+X'), + ('Coller','paste','','Ctrl+V'), + ] + ), + ('Jeu de commandes',[ + ('Rapport de validation','visuCRJDC','','Ctrl+R'), + ('Fichier source','visu_txt_brut_JDC','','Ctrl+B'), + #('Paramètres Eficas','affichage_fichier_ini'), + ] + ), + ('Aide',[ + ('Aide EFICAS','aideEFICAS','','Ctrl+A'), + ] + ), + ] + } + +if os.name == 'nt': + userprefs = os.sep.join( [ os.environ['HOMEDRIVE'], os.environ['HOMEPATH'], 'Eficas_install', 'prefs.py' ]) +else : + userprefs=os.path.expanduser("~/Eficas_install/prefs.py") +if os.path.isfile(userprefs): + try: + execfile(userprefs) + except: + pass + +sys.path[:0]=[INSTALLDIR] diff --git a/Tests/properties.py b/Tests/properties.py new file mode 100644 index 00000000..c174e28e --- /dev/null +++ b/Tests/properties.py @@ -0,0 +1,25 @@ +#@ MODIF properties Accas DATE 26/10/2005 AUTEUR gcbhhhh M.ADMINISTRATEUR +# CONFIGURATION MANAGEMENT OF EDF VERSION +# RESPONSABLE D6BHHHH J-P.LEFEBVRE +# ====================================================================== +# 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. +# ====================================================================== +# IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR +# DE LA VERSION DU CODE_ASTER ASSOCIE +#---------------------------------------------------------------------- +version = "8.2.24" +date = "O1/06/2006" +exploit = False diff --git a/Tests/style.py b/Tests/style.py new file mode 100644 index 00000000..0d387727 --- /dev/null +++ b/Tests/style.py @@ -0,0 +1,63 @@ +# -*- coding: utf-8 -*- +""" +Pour modifier le style d'EFICAS il faut ajouter un fichier style.py qui contiendra les +informations sur le style voulu dans son repertoire Eficas_install. + +La methode la plus simple consiste à modifier directement les attributs de l'objet style dans le +fichier style.py d'Eficas_install. Exemple:: + + style.background='yellow' + +pour modifier la couleur du background. + +Il existe une autre méthode qui peut être utilisée quand on veut modifier plusieurs propriétés à la fois. + +Le fichier style.py doit définir une nouvelle classe qui dérive de la classe de base STYLE avec des attributs +de classe qui définiront le nouveau style (par exemple, si on veut modifier le background):: + + class STYLE(STYLE): + background='yellow' + +Il faut ensuite instancier cette classe, dans ce meme fichier, en donnant le nom style à l'objet cree:: + + style=STYLE() + +Tous les attributs de classe possibles sont visibles dans le module Editeur/basestyle.py:: + + background='gray90' + foreground='black' + entry_background='white' + list_background='white' + list_select_background='#00008b' + list_select_foreground='grey' + tooltip_background="yellow" + + standard = ("Helvetica",12) + standard_italique = ("Helvetica",12,'italic') + standard_gras = ("Helvetica",12,'bold') + standard_gras_souligne = ("Helvetica",12,'bold','underline') + + canvas = ('Helvetica',10) + canvas_italique = ('Helvetica',10,'italic') + canvas_gras = ("Helvetica",10,'bold') + canvas_gras_italique = ("Helvetica",12,'bold','italic') + + standard12 = ("Helvetica",14) + standard12_gras = ("Helvetica",14,'bold') + standard12_gras_italique = ( "Helvetica",14,'bold','italic') + + +Le fichier style.py contenu dans le répertoire Aster permet de spécifier des propriétés globales pour une installation. +Les modifications de style contenues dans ce fichier et dans le fichier style.py d'Eficas_install +sont prises en compte dans cet ordre. +""" + + +style.background='gray90' +style.foreground='black' +style.standard = ("Helvetica",10) +style.standard_italique = ("Helvetica",10,'italic') +style.standard_gras = ("Helvetica",10,'bold') +style.canvas_italique = ('Helvetica',10,'italic') +style.canvas_gras = ("Helvetica",10,'bold') +style.statusfont = ("Helvetica",14) diff --git a/Tests/testastest/basetest.py b/Tests/testastest/basetest.py new file mode 100644 index 00000000..a8f2a068 --- /dev/null +++ b/Tests/testastest/basetest.py @@ -0,0 +1,67 @@ +import os,glob,sys +import unittest +import difflib + +from Editeur import appli + +from config import ASTERDIR + +def cdiff(text1,text2): + return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1))) + +def make_tests(files): + class TestCase(unittest.TestCase): + app=None + + def setUp(self): + if self.app == None: + self.app=appli.STANDALONE(version='v8') + pass + + def tearDown(self): + CONTEXT.unset_current_step() + + i=0 + for f in glob.glob(os.path.join(ASTERDIR,files)): + ff=open(f) + text=ff.read() + ff.close() + if text.find("VISU_EFICAS='NON'") != -1:continue + for o in ('3','2','1','0','m'): + f=f[:-1]+o + if os.path.isfile(f):break + i=i+1 + name=os.path.splitext(os.path.basename(f))[0] + + exec """def test_%s(self,file="%s"): + "fichier:%s" + self.commtest(file) +""" % (name,f,f) + del i,f,ff,text,o,name + + def commtest(self,file): + """ Test generique""" + name=os.path.splitext(os.path.basename(file))[0] + errfile=os.path.join(os.path.dirname(__file__),name+".err") + err="" + if os.path.isfile(errfile): + f=open(errfile) + err=f.read() + f.close() + try: + j=self.app.openJDC(file=file) + if err == "": + assert j.isvalid(),j.report() + else: + txt=str(j.report()) + assert txt == err,cdiff(err,txt) + j.supprime() + assert sys.getrefcount(j) == 2,sys.getrefcount(j) + except ValueError,e: + txt=str(e) + if err == "": + raise + else: + assert txt == err,cdiff(err,txt) + + return TestCase diff --git a/Tests/testastest/erreu01a.err b/Tests/testastest/erreu01a.err new file mode 100644 index 00000000..7bdc2e9b --- /dev/null +++ b/Tests/testastest/erreu01a.err @@ -0,0 +1,4 @@ +Compilation impossible : File "erreu01a.comm", line 44 + UELAS=MECA_STATIQUE(MODELE=MOD, + ^ + SyntaxError: invalid syntax diff --git a/Tests/testastest/testaster1.py b/Tests/testastest/testaster1.py new file mode 100644 index 00000000..7aa1d9ed --- /dev/null +++ b/Tests/testastest/testaster1.py @@ -0,0 +1,5 @@ +import basetest + +files="[a-l]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster10.py b/Tests/testastest/testaster10.py new file mode 100644 index 00000000..febe8cab --- /dev/null +++ b/Tests/testastest/testaster10.py @@ -0,0 +1,5 @@ +import basetest + +files="z*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster2.py b/Tests/testastest/testaster2.py new file mode 100644 index 00000000..72c6892f --- /dev/null +++ b/Tests/testastest/testaster2.py @@ -0,0 +1,6 @@ +import basetest + +files="[m-r]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass + diff --git a/Tests/testastest/testaster3.py b/Tests/testastest/testaster3.py new file mode 100644 index 00000000..230a79c1 --- /dev/null +++ b/Tests/testastest/testaster3.py @@ -0,0 +1,5 @@ +import basetest + +files="s[a-d]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster4.py b/Tests/testastest/testaster4.py new file mode 100644 index 00000000..c3217c72 --- /dev/null +++ b/Tests/testastest/testaster4.py @@ -0,0 +1,5 @@ +import basetest + +files="s[e-r]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster5.py b/Tests/testastest/testaster5.py new file mode 100644 index 00000000..26851b9b --- /dev/null +++ b/Tests/testastest/testaster5.py @@ -0,0 +1,5 @@ +import basetest + +files="ssl[a-l]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster6.py b/Tests/testastest/testaster6.py new file mode 100644 index 00000000..c779a122 --- /dev/null +++ b/Tests/testastest/testaster6.py @@ -0,0 +1,5 @@ +import basetest + +files="ssl[m-z]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster7.py b/Tests/testastest/testaster7.py new file mode 100644 index 00000000..99f426c1 --- /dev/null +++ b/Tests/testastest/testaster7.py @@ -0,0 +1,6 @@ +import basetest + +files="ss[m-z]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass + diff --git a/Tests/testastest/testaster8.py b/Tests/testastest/testaster8.py new file mode 100644 index 00000000..04f45616 --- /dev/null +++ b/Tests/testastest/testaster8.py @@ -0,0 +1,5 @@ +import basetest + +files="s[t-z]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster9.py b/Tests/testastest/testaster9.py new file mode 100644 index 00000000..4c561729 --- /dev/null +++ b/Tests/testastest/testaster9.py @@ -0,0 +1,5 @@ +import basetest + +files="[t-y]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testcomm/hplp101b.comm b/Tests/testcomm/hplp101b.comm new file mode 100755 index 00000000..ef2790a1 --- /dev/null +++ b/Tests/testcomm/hplp101b.comm @@ -0,0 +1,189 @@ +# MODIF DATE 09/05/2006 AUTEUR REZETTE C.REZETTE +# TITRE FISSURE AU CENTRE D'UNE PLAQUE MINCE RECTANGULAIRE FAISANT +# 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. +# ====================================================================== +# OBSTACLE A UN FLUC DE CHALEUR UNIFORME EN MILIEU ISOTROPE +# +# TESTE LES DERIVEES DE G DANS LE CAS D'UN CHARGEMENT EN FORCE DE VOLUME + +DEBUT( CODE=_F( NOM = 'HPLP101B',NIV_PUB_WEB='INTERNET')) + +YOUNG = DEFI_PARA_SENSI(VALE=1.) +FORC = DEFI_PARA_SENSI(VALE=1.) + +MA=LIRE_MAILLAGE( ) + +MA=DEFI_GROUP( reuse=MA, MAILLAGE=MA, + CREA_GROUP_NO=_F( + GROUP_MA = ( 'LP9P10', 'LP9P10B', + 'LP8P9', 'LP8P9B', + )) + ) + +MO=AFFE_MODELE( MAILLAGE=MA, + AFFE=_F( TOUT = 'OUI', + PHENOMENE = 'MECANIQUE', + MODELISATION = 'C_PLAN') + ) +ZERO = DEFI_CONSTANTE(VALE=0.) +NU = DEFI_CONSTANTE(VALE=0.3) +ALPHA = DEFI_CONSTANTE(VALE=0.) + +MAT=DEFI_MATERIAU(ELAS_FO=_F( E = YOUNG, NU = NU, + TEMP_DEF_ALPHA =20., + ALPHA = ALPHA, RHO=7800.,)) + +CHMAT=AFFE_MATERIAU( MAILLAGE=MA, + AFFE=_F( TOUT = 'OUI', + MATER = MAT) + ) + +CH=AFFE_CHAR_MECA_F( MODELE=MO, + FORCE_INTERNE=_F(TOUT='OUI',FY=FORC,), + DDL_IMPO=( + _F( GROUP_NO = 'LP8P9', + DX = ZERO), + _F( GROUP_NO = 'LP8P9B', + DX = ZERO), + _F( GROUP_NO = 'P11', + DY = ZERO)) + ) + +DEP=MECA_STATIQUE( MODELE=MO, CHAM_MATER=CHMAT, + SENSIBILITE = (FORC), + EXCIT=_F( CHARGE = CH), + ) + +DEP=CALC_ELEM(reuse=DEP,RESULTAT=DEP, + SENSIBILITE = (FORC), + OPTION=('EPSI_ELGA_DEPL','SIEF_ELGA_DEPL',),) + +FOND=DEFI_FOND_FISS( MAILLAGE=MA, + FOND_FISS=_F( GROUP_NO = ('P0',)), + NORMALE=(0., 1., 0.,) + ) + +THETA0=CALC_THETA( MODELE=MO, + THETA_2D=_F( GROUP_NO = ('P0',), + MODULE = 1., + R_INF = 3.75E-5, + R_SUP = 7.50E-5), + DIRECTION=(1., 0., 0.,) + ) + +G0=CALC_G( RESULTAT=DEP, + THETA=_F(THETA=THETA0), + SYME_CHAR='SANS', + COMP_ELAS=_F( RELATION = 'ELAS', + DEFORMATION = 'PETIT') + ) + +DG0=CALC_G( RESULTAT=DEP, + SENSIBILITE = (FORC), + THETA=_F(THETA=THETA0), + SYME_CHAR='SANS', + COMP_ELAS=_F( RELATION = 'ELAS', + DEFORMATION = 'PETIT') + ) + +TEST_TABLE( TABLE=DG0, + NOM_PARA='DG/DF', + SENSIBILITE = (FORC), + VALE=1.06E-2, + REFERENCE='ANALYTIQUE', + PRECISION=0.0005 ) +FIN() + +THETA01=CALC_THETA( MODELE=MO, + THETA_2D=_F( GROUP_NO = ('P0',), + MODULE = 1., + R_INF = 7.50E-5, + R_SUP = 1.125E-4), + DIRECTION=(1., 0., 0.,) + ) + +G1=CALC_G( RESULTAT=DEP, + THETA=_F(THETA=THETA01), + COMP_ELAS=_F( RELATION = 'ELAS', + DEFORMATION = 'PETIT'), + SYME_CHAR='SANS' + ) + +DG1=CALC_G( RESULTAT=DEP, + SENSIBILITE = (FORC), + THETA=_F(THETA=THETA01), + SYME_CHAR='SANS', + COMP_ELAS=_F( RELATION = 'ELAS', + DEFORMATION = 'PETIT') + ) + +TEST_TABLE( TABLE=DG1, + NOM_PARA='G', + SENSIBILITE = (FORC), + REFERENCE='ANALYTIQUE', + VALE=1.06E-2, + PRECISION=0.0005 ) + +# +# DERIVEE PAR RAPPORT A E +# + +DEP2=MECA_STATIQUE( MODELE=MO, CHAM_MATER=CHMAT, + SENSIBILITE = (YOUNG), + EXCIT=_F( CHARGE = CH), + ) + +DEP2=CALC_ELEM(reuse=DEP2,RESULTAT=DEP2, + SENSIBILITE = (YOUNG), + OPTION=('EPSI_ELGA_DEPL','SIEF_ELGA_DEPL',),) + + +DG2=CALC_G( RESULTAT=DEP2, + SENSIBILITE = (YOUNG), + THETA=_F(THETA=THETA0), + SYME_CHAR='SANS', + COMP_ELAS=_F( RELATION = 'ELAS', + DEFORMATION = 'PETIT') + ) + +TEST_TABLE( TABLE=DG2, + NOM_PARA='G', + SENSIBILITE = (YOUNG), + REFERENCE='ANALYTIQUE', + VALE=-5.3E-3, + PRECISION=0.0005 ) + + +DG3=CALC_G( RESULTAT=DEP2, + SENSIBILITE = (YOUNG), + THETA=_F(THETA=THETA01), + SYME_CHAR='SANS', + COMP_ELAS=_F( RELATION = 'ELAS', + DEFORMATION = 'PETIT') + ) + +TEST_TABLE( TABLE=DG3, + NOM_PARA='G', + VALE=-5.3E-3, + SENSIBILITE = (YOUNG), + REFERENCE='ANALYTIQUE', + PRECISION=0.0005 ) + + +FIN() + diff --git a/Tests/testcomm/hsnv100h.comm b/Tests/testcomm/hsnv100h.comm new file mode 100755 index 00000000..976dc604 --- /dev/null +++ b/Tests/testcomm/hsnv100h.comm @@ -0,0 +1,46 @@ +# MODIF DATE 23/10/2006 AUTEUR VABHHTS J.PELLET +# TITRE THERMO-PLASTICITE EN TRACTION SIMPLE (MODELISATION:C_PLAN) +# 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. +# ====================================================================== +# + +DEBUT(CODE=_F( NOM = 'HSNV100H',NIV_PUB_WEB='INTRANET'),IMPR_MACRO='OUI',DEBUG=_F(SDVERI='OUI')) + +#...................................................................... +# CAS TEST THERMOPLASTICITE ELEMENTAIRE +#...................................................................... +# DEFINITION DES CARACTERISTIQUES DU MATERIAU +# + +MAIL=LIRE_MAILLAGE( ) + +INCLUDE_MATERIAU(TYPE_MODELE='REF', + TYPE_VALE='NOMI', + NOM_AFNOR='Z2CND1712', + VARIANTE='A', + NOM_MATER='MONMAT', + UNITE_LONGUEUR='MM' + ) + +CHMAT=AFFE_MATERIAU( MAILLAGE=MAIL,AFFE=( + _F( TOUT='OUI',TEMP_REF=25, MATER = MONMAT), + ),) + +# + +FIN() diff --git a/Tests/testcomm/param1.err b/Tests/testcomm/param1.err deleted file mode 100644 index 758a38b6..00000000 --- a/Tests/testcomm/param1.err +++ /dev/null @@ -1 +0,0 @@ -erreur sur defi_materiau diff --git a/Tests/testcomm/param2.com0 b/Tests/testcomm/param2.com0 new file mode 100644 index 00000000..2d32a387 --- /dev/null +++ b/Tests/testcomm/param2.com0 @@ -0,0 +1,4 @@ +POURSUITE(); +l1=DEFI_LIST_ENTI(DEBUT=mon_param,); +FIN(); + diff --git a/Tests/testcomm/param2.comm b/Tests/testcomm/param2.comm new file mode 100644 index 00000000..19c8eeb2 --- /dev/null +++ b/Tests/testcomm/param2.comm @@ -0,0 +1,4 @@ +DEBUT(); +mon_param = 2; +m=LIRE_MAILLAGE() +FIN(); diff --git a/Tests/testcomm/param3.11 b/Tests/testcomm/param3.11 new file mode 100644 index 00000000..236ca5ca --- /dev/null +++ b/Tests/testcomm/param3.11 @@ -0,0 +1,2 @@ +x=45 +y=77 diff --git a/Tests/testcomm/param3.12 b/Tests/testcomm/param3.12 new file mode 100644 index 00000000..2c2a2157 --- /dev/null +++ b/Tests/testcomm/param3.12 @@ -0,0 +1 @@ +d=5;f=7 diff --git a/Tests/testcomm/param3.com0 b/Tests/testcomm/param3.com0 new file mode 100644 index 00000000..d5a0bbf5 --- /dev/null +++ b/Tests/testcomm/param3.com0 @@ -0,0 +1,11 @@ +POURSUITE(); +l1=DEFI_LIST_ENTI(DEBUT=2*mon_param+1,); +l2=DEFI_LIST_ENTI(DEBUT=a[1]); +INCLUDE_MATERIAU( NOM_AFNOR='18MND5', TYPE_MODELE='REF', + VARIANTE='A', TYPE_VALE='NOMI', + NOM_MATER='MAT3', INFO=1 ) +INCLUDE(UNITE=11) +INCLUDE(UNITE=12) + +FIN(); + diff --git a/Tests/testcomm/param3.comm b/Tests/testcomm/param3.comm new file mode 100644 index 00000000..b7a38ea2 --- /dev/null +++ b/Tests/testcomm/param3.comm @@ -0,0 +1,5 @@ +DEBUT(); +mon_param = 2; +m=LIRE_MAILLAGE() +a=[1,2,3,4];b=2 +FIN(); diff --git a/Tests/testcomm/parseur.comm b/Tests/testcomm/parseur.comm index 6f42e785..92aaf898 100644 --- a/Tests/testcomm/parseur.comm +++ b/Tests/testcomm/parseur.comm @@ -69,6 +69,6 @@ FL_INT05 = FORMULE(NOM_PARA='TEMP',VALE=''' zz=8.9; #ne marche pas avec le parseur actuel -zz=8.9;aa=10 #position +#zz=8.9;aa=10 #position FIN() diff --git a/Tests/testcomm/testaster1.py b/Tests/testcomm/testaster1.py deleted file mode 100644 index 00b63ddb..00000000 --- a/Tests/testcomm/testaster1.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.3') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"[a-l]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - - exec """def test%s(self,file="%s"): - "fichier:%s" - self.commtest(file) -""" % (i,f,f) - del i,f,ff,text,o - - def commtest(self,file): - """ Test generique""" - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) diff --git a/Tests/testcomm/testaster10.py b/Tests/testcomm/testaster10.py deleted file mode 100644 index 8e7a4053..00000000 --- a/Tests/testcomm/testaster10.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.2') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"z*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - exec """def test%s(self,file="%s"): - self.commtest(file) -""" % (i,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - print file - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster2.py b/Tests/testcomm/testaster2.py deleted file mode 100644 index b9bcb3a5..00000000 --- a/Tests/testcomm/testaster2.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.3') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"[m-r]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - exec """def test%s(self,file="%s"): - "fichier:%s" - self.commtest(file) -""" % (i,f,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster3.py b/Tests/testcomm/testaster3.py deleted file mode 100644 index fc412fc4..00000000 --- a/Tests/testcomm/testaster3.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.3') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"s[a-d]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - exec """def test%s(self,file="%s"): - "fichier:%s" - self.commtest(file) -""" % (i,f,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster4.py b/Tests/testcomm/testaster4.py deleted file mode 100644 index 9994411b..00000000 --- a/Tests/testcomm/testaster4.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.3') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"s[e-r]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - exec """def test%s(self,file="%s"): - "fichier:%s" - self.commtest(file) -""" % (i,f,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster5.py b/Tests/testcomm/testaster5.py deleted file mode 100644 index 0b65fb3e..00000000 --- a/Tests/testcomm/testaster5.py +++ /dev/null @@ -1,44 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.3') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"ssl[a-l]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") == -1: break - i=i+1 - exec """def test%s(self,file="%s"): - "fichier:%s" - self.commtest(file) -""" % (i,f,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster6.py b/Tests/testcomm/testaster6.py deleted file mode 100644 index cfa59a34..00000000 --- a/Tests/testcomm/testaster6.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.3') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"ssl[m-z]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - exec """def test%s(self,file="%s"): - "fichier:%s" - self.commtest(file) -""" % (i,f,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster7.py b/Tests/testcomm/testaster7.py deleted file mode 100644 index df4fab18..00000000 --- a/Tests/testcomm/testaster7.py +++ /dev/null @@ -1,44 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.2') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"ss[m-z]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") == -1: break - i=i+1 - exec """def test%s(self,file="%s"): - self.commtest(file) -""" % (i,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - print file - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster8.py b/Tests/testcomm/testaster8.py deleted file mode 100644 index 8111717b..00000000 --- a/Tests/testcomm/testaster8.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.2') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"s[t-z]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - exec """def test%s(self,file="%s"): - self.commtest(file) -""" % (i,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - print file - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testaster9.py b/Tests/testcomm/testaster9.py deleted file mode 100644 index 890a42a1..00000000 --- a/Tests/testcomm/testaster9.py +++ /dev/null @@ -1,40 +0,0 @@ -import os,glob,sys -import unittest - -from Editeur import appli - -from config import ASTERDIR - -class TestCase(unittest.TestCase): - app=None - def setUp(self): - if self.app == None: - self.app=appli.STANDALONE(version='v8.2') - pass - - def tearDown(self): - CONTEXT.unset_current_step() - - i=0 - for f in glob.glob(os.path.join(ASTERDIR,"[t-y]*.comm")): - ff=open(f) - text=ff.read() - ff.close() - if text.find("VISU_EFICAS='NON'") != -1:continue - for o in ('3','2','1','0','m'): - f=f[:-1]+o - if os.path.isfile(f):break - i=i+1 - exec """def test%s(self,file="%s"): - self.commtest(file) -""" % (i,f) - del i,f,o,ff,text - - def commtest(self,file): - """ Test generique""" - print file - j=self.app.openJDC(file=file) - assert j.isvalid(),j.report() - j.supprime() - assert sys.getrefcount(j) == 2,sys.getrefcount(j) - diff --git a/Tests/testcomm/testcomm.py b/Tests/testcomm/testcomm.py index 4d540b15..f0c97101 100644 --- a/Tests/testcomm/testcomm.py +++ b/Tests/testcomm/testcomm.py @@ -26,14 +26,15 @@ class TestCase(unittest.TestCase): app=None def setUp(self): if self.app == None: - self.app=appli.STANDALONE(version='v8.3') + self.app=appli.STANDALONE(version='v8') pass def tearDown(self): CONTEXT.unset_current_step() i=0 - for f in glob.glob(os.path.join(prefs.INSTALLDIR,"Tests/testcomm/*.comm")): + files="Tests/testcomm/*.comm" + for f in glob.glob(os.path.join(prefs.INSTALLDIR,files)): for o in ('3','2','1','0','m'): f=f[:-1]+o if os.path.isfile(f):break diff --git a/Tests/testelem/testaz76.py b/Tests/testelem/testaz76.py index 2dd8a129..44401008 100644 --- a/Tests/testelem/testaz76.py +++ b/Tests/testelem/testaz76.py @@ -35,7 +35,7 @@ class TestCase(unittest.TestCase): def test000(self): """ Test de construction du fichier de commandes az.comm de zero""" - app=appli.STANDALONE(version='v7.6') + app=appli.STANDALONE(version='v7') j=app.newJDC() # commande DEBUT co=j.addentite("DEBUT",0) @@ -322,7 +322,7 @@ class TestCase(unittest.TestCase): def test001(self): """ Test de construction d'un fichier de commandes avec DEFI_LIST_REEL, fonction et parametre de zero""" - app=appli.STANDALONE(version='v7.6') + app=appli.STANDALONE(version='v7') j=app.newJDC() # commande DEBUT co=j.addentite("DEBUT",0) diff --git a/Tests/testelem/testitem1.py b/Tests/testelem/testitem1.py index 3b46a8f8..5c73b925 100644 --- a/Tests/testelem/testitem1.py +++ b/Tests/testelem/testitem1.py @@ -24,7 +24,7 @@ def add_mcsimp(obj,nom,valeur): def cdiff(text1,text2): return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1))) -version= 'v8.3' +version= 'v8' class TestCase(unittest.TestCase): """ Tests sur des items """ diff --git a/Tests/testelem/testjdc1.py b/Tests/testelem/testjdc1.py index e77bbf61..ea403fb0 100644 --- a/Tests/testelem/testjdc1.py +++ b/Tests/testelem/testjdc1.py @@ -25,7 +25,7 @@ def add_mcsimp(obj,nom,valeur): def cdiff(text1,text2): return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1))) -version='v8.3' +version='v8' class TestCase(unittest.TestCase): def setUp(self): diff --git a/Tests/testelem/testjdc3.py b/Tests/testelem/testjdc3.py index 2048b576..842be867 100644 --- a/Tests/testelem/testjdc3.py +++ b/Tests/testelem/testjdc3.py @@ -25,7 +25,7 @@ def add_mcsimp(obj,nom,valeur): def cdiff(text1,text2): return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1))) -version='v8.3' +version='v8' class TestCase(unittest.TestCase): def setUp(self): diff --git a/Tests/testelem/testjdc4.py b/Tests/testelem/testjdc4.py index 9f43130f..eaa59483 100644 --- a/Tests/testelem/testjdc4.py +++ b/Tests/testelem/testjdc4.py @@ -25,7 +25,7 @@ def add_mcsimp(obj,nom,valeur): def cdiff(text1,text2): return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1))) -version='v8.3' +version='v8' class TestCase(unittest.TestCase): def setUp(self): diff --git a/Tests/testelem/testzzz6az.py b/Tests/testelem/testzzz6az.py index d2b519ca..a29eebcd 100644 --- a/Tests/testelem/testzzz6az.py +++ b/Tests/testelem/testzzz6az.py @@ -35,7 +35,7 @@ class TestCase(unittest.TestCase): def test000(self): """ Test de construction du fichier de commandes az.comm de zero""" - app=appli.STANDALONE(version='v6') + app=appli.STANDALONE(version='v6.8') j=app.newJDC() # commande DEBUT co=j.addentite("DEBUT",0) @@ -322,7 +322,7 @@ class TestCase(unittest.TestCase): def test001(self): """ Test de construction d'un fichier de commandes avec DEFI_LIST_REEL, fonction et parametre de zero""" - app=appli.STANDALONE(version='v6') + app=appli.STANDALONE(version='v6.8') j=app.newJDC() # commande DEBUT co=j.addentite("DEBUT",0) diff --git a/Tests/testihm/common.py b/Tests/testihm/common.py index fbd438a2..ebad6afc 100644 --- a/Tests/testihm/common.py +++ b/Tests/testihm/common.py @@ -1,5 +1,6 @@ # -*- coding: utf-8 -*- +from tkMessageBox import showinfo root=None jdcdisplay=None @@ -179,6 +180,8 @@ def set_complexe(valeur,panel): def add_valeur_into(valeur,panel): label=panel.Liste_choix.dico_labels[valeur] + panel.Liste_choix.afficheMot(valeur) + root.update() label.event_generate("<1>") panel.bouton_add.invoke() root.update() diff --git a/Tests/testihm/testihm1.py b/Tests/testihm/testihm1.py index 5b79c45e..52e49e83 100644 --- a/Tests/testihm/testihm1.py +++ b/Tests/testihm/testihm1.py @@ -16,7 +16,7 @@ from Editeur import eficas from Editeur import images from common import * -version='v8.3' +version='v8' class TestCase(unittest.TestCase): def setUp(self): diff --git a/Tests/testihm/testihm2.py b/Tests/testihm/testihm2.py index 06c14ec8..b701fbb0 100644 --- a/Tests/testihm/testihm2.py +++ b/Tests/testihm/testihm2.py @@ -23,7 +23,7 @@ class TestCase(unittest.TestCase): images.update_cache() # Analyse des arguments de la ligne de commande options=session.parse([]) - options.cata="v8.3" + options.cata="v8" pass def tearDown(self): diff --git a/Tests/testihm/testihm4.py b/Tests/testihm/testihm4.py index ae7a0920..3d384921 100644 --- a/Tests/testihm/testihm4.py +++ b/Tests/testihm/testihm4.py @@ -23,7 +23,7 @@ class TestCase(unittest.TestCase): images.update_cache() # Analyse des arguments de la ligne de commande options=session.parse([]) - options.cata="v8.3" + options.cata="v8" pass def tearDown(self): diff --git a/generator/generator_python.py b/generator/generator_python.py index 0bdaa78a..6a22dcc3 100644 --- a/generator/generator_python.py +++ b/generator/generator_python.py @@ -241,7 +241,8 @@ class PythonGenerator: return repr(obj) def generFormula(self,obj): - return repr(obj) + #return repr(obj) + return str(obj) def generPARAMETRE(self,obj): """