From: eficas <> Date: Thu, 29 Jan 2004 18:16:49 +0000 (+0000) Subject: CCAR: Mise a jour des catalogues et Macro avec la version 7.2.11 d'Aster X-Git-Tag: CC_param_poursuite~286 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=8edbd4d41edcd51ccc929c2a091b9c1b98c925b4;p=modules%2Feficas.git CCAR: Mise a jour des catalogues et Macro avec la version 7.2.11 d'Aster --- diff --git a/Aster/Cata/Macro/calc_precont_ops.py b/Aster/Cata/Macro/calc_precont_ops.py index bb42a62c..793ceea3 100644 --- a/Aster/Cata/Macro/calc_precont_ops.py +++ b/Aster/Cata/Macro/calc_precont_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_precont_ops Macro DATE 15/09/2003 AUTEUR ASSIRE A.ASSIRE +#@ MODIF calc_precont_ops Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -107,7 +107,7 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, # Teste si INST_INIT est bien plus petit que INST_FIN if __TMAX <= __TMIN: ier=ier+1 - self.cr.fatal("""ERREUR : INST_FIN PLUS PETIT QUE INST_INIT""") + self.cr.fatal(""" ERREUR : INST_FIN PLUS PETIT QUE INST_INIT""") return ier # Cree la liste d'instant __L2 allant de __TMIN a __TMAX et contenant diff --git a/Aster/Cata/Macro/defi_cable_bp_ops.py b/Aster/Cata/Macro/defi_cable_bp_ops.py index 8441a63c..14fbcd2a 100644 --- a/Aster/Cata/Macro/defi_cable_bp_ops.py +++ b/Aster/Cata/Macro/defi_cable_bp_ops.py @@ -1,4 +1,4 @@ -#@ MODIF defi_cable_bp_ops Macro DATE 21/03/2003 AUTEUR ASSIRE A.ASSIRE +#@ MODIF defi_cable_bp_ops Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -102,7 +102,7 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, print ' # ---------------------------------------------------------------------------' print ' ' ier=ier+1 - self.cr.fatal("""Erreur defi_cable_bp""") + self.cr.fatal(""" Erreur dans la macro""") return ier @@ -163,7 +163,7 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, print ' # ---------------------------------------------------------------------------' print ' ' ier=ier+1 - self.cr.fatal("""Erreur defi_cable_bp""") + self.cr.fatal(""" Erreur dans la macro""") return ier if i.has_key('GROUP_NO_ANCRAGE') == 1: __PC1 = i['GROUP_NO_ANCRAGE'][0] @@ -199,7 +199,7 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, print ' # ---------------------------------------------------------------------------' print ' ' ier=ier+1 - self.cr.fatal("""Erreur defi_cable_bp""") + self.cr.fatal(""" Erreur dans la macro""") return ier if i.has_key('GROUP_NO_ANCRAGE') == 1: __PC1 = i['GROUP_NO_ANCRAGE'][1] diff --git a/Aster/Cata/Macro/fiabilite_fichier.py b/Aster/Cata/Macro/fiabilite_fichier.py new file mode 100644 index 00000000..66fff09c --- /dev/null +++ b/Aster/Cata/Macro/fiabilite_fichier.py @@ -0,0 +1,332 @@ +#@ MODIF fiabilite_fichier Macro DATE 16/01/2004 AUTEUR GNICOLAS G.NICOLAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS +# +class fiabilite_fichier : +# + """ Classe des fichiers de données des logiciels fiabilistes + Cette classe a été mise au point pour le couplage entre + Code_ASTER et MEFISTO, mais pourrait servir ailleurs. + """ +# +# +#==== +# 1. Le constructeur +#==== +# +# + def __init__ ( self, jdc, Rep_Calc_LOGICIEL_global, nomfic, info = 1 ) : +# +# jdc : le jeu de commandes en cours de traitement +# + self.jdc = jdc +# +# Rep_Calc_LOGICIEL_global : le répertoire d'exécution du logiciel de fiabilité +# + self.Rep_Calc_LOGICIEL_global = Rep_Calc_LOGICIEL_global +# +# nomfic : nom local du fichier à créer +# + self.nomfic = nomfic +# +# messages_erreur : messages d'erreur +# + self.messages_erreur = { 0 : "Tout va bien", + 1 : "==> Ce fichier est inconnu.", + 2 : "==> Ce type d'ouverture est inconnu.", + 10 : "==> Problème à l'ouverture.", + 11 : "==> Problème à la fermeture.", + 20 : "==> Problème à l'impression." } +# +# info : niveau d'information au sens ASTER +# + self.info = info +# +# ligne_sep : ligne de séparation +# + self.ligne_sep = "=========================================================" + self.ligne_commentaire = "#" + self.ligne_sep + "\n" +# + if info >= 2 : + print "Création du fichier : "+self.nomfic +# +#==== +# 2. Ouverture du fichier +#==== +# + def Ouvre_Fichier ( self, type_ouvr ) : +# +# 2.0. ==> Préalables +# + """ + Ouvre le fichier en lecture ou écriture. + 0 : tout s'est bien passé + 1 : on veut ouvrir en lecture un fichier qui n'existe pas + 2 : le mode d'ouverture est inconnu + 10 : impossible d'ouvrir + """ +# + import os +# +# 2.1. ==> Le nom global du fichier +# + self.nomfic_global = os.path.join(self.Rep_Calc_LOGICIEL_global,self.nomfic) +# +# 2.2. ==> Controles +# + erreur = 0 +# + if ( type_ouvr == "w" or type_ouvr == "r" ) : +# + if ( type_ouvr == "r" ) : + if not os.path.isfile(self.nomfic_global) : + erreur = 1 + + else : +# + self.jdc.cr.warn("Type d'ouverture : "+type_ouvr) + erreur = 2 +# +# 2.3. ==> Ouverture vraie +# + if not erreur : +# + erreur_partiel = [0] + try : + self.fic = open( self.nomfic_global, type_ouvr ) + except os.error,erreur_partiel : + self.jdc.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) + erreur = 10 +# +# 2.4. ==> C'est fini +# + if erreur : + self.jdc.cr.warn("Fichier : "+self.nomfic) + self.jdc.cr.warn(self.messages_erreur[erreur]) +# + return erreur +# +#==== +# 3. Fermeture du fichier +#==== +# + def Ferme_Fichier ( self ) : +# +# 3.0. ==> Préalables +# + """ + Ferme le fichier. + 0 : tout s'est bien passé + 20 : impossible d'imprimer + """ +# + import os +# +# 3.1. ==> Controles +# + erreur = 0 +# + if not os.path.isfile(self.nomfic_global) : + erreur = 1 +# +# 3.2. ==> Fermeture vraie +# + if not erreur : +# + erreur_partiel = [0] + try : + self.fic.close( ) + except os.error,erreur_partiel : + self.jdc.cr.warn("Code d'erreur de close : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) + erreur = 11 +# +# 3.3. ==> C'est fini +# + if erreur : + self.jdc.cr.warn("Fichier : "+self.nomfic) + self.jdc.cr.warn(self.messages_erreur[erreur]) +# + return erreur +# +#==== +# 4. Impression du contenu du fichier +#==== +# + def Imprime_Fichier ( self ) : +# +# 4.0. ==> Préalables +# + """ + Imprime le fichier. + 0 : tout s'est bien passé + 20 : impossible d'imprimer + """ +# +# 4.1. ==> Lecture +# + erreur = self.Ouvre_Fichier ( "r" ) + if not erreur : + les_lignes = self.fic.readlines() + erreur = self.Ferme_Fichier ( ) +# +# 4.2. ==> Impression +# + if not erreur : +# + print "\n"+self.ligne_sep + print "Contenu du fichier " + self.nomfic," :" + for ligne in les_lignes : + print ligne[:-1] + print self.ligne_sep+"\n" +# +# 4.4. ==> C'est fini +# + if erreur : + erreur = 20 + self.jdc.cr.warn("Fichier : "+self.nomfic) + self.jdc.cr.warn(self.messages_erreur[erreur]) +# + return erreur +# +#==== +# 5. Ecriture de lignes de commentaires +#==== +# + def Ecrit_Commentaires ( self, comm ) : +# + """ + Liste = commentaires à écrire + Soit c'est une chaine qu'on écrit sur une ligne ; + Soit c'est une liste, qu'on écrit à raison de une par ligne. + Remarque : cela suppose que le fichier est ouvert en écriture + """ +# + if type(comm) == type([ ]) : + Liste = comm + else : + Liste = [comm] +# + for ligne in Liste : + self.fic.write("# "+str(ligne)+"\n") +# +#==== +# 6. Ecriture de lignes de titres +#==== +# + def Ecrit_Titre ( self, comm ) : +# + """ + Liste = commentaires à écrire, encadrés par des séparateurs + Soit c'est une chaine qu'on écrit sur une ligne ; + Soit c'est une liste, qu'on écrit à raison de une par ligne. + Remarque : cela suppose que le fichier est ouvert en écriture + """ +# + self.fic.write(self.ligne_commentaire) + self.Ecrit_Commentaires(comm) + self.fic.write(self.ligne_commentaire) +# +#==== +# 7. Ecriture d'une ligne de valeurs +#==== +# + def Ecrit_Valeurs ( self, val ) : +# + """ + Liste = liste des valeurs à écrire, représenatn une ligne + Remarque : cela suppose que le fichier est ouvert en écriture + """ +# + if type(val) == type([ ]) : + ligne = " " + for aux in val : + ligne = ligne + " " + str(aux) + else : + ligne = str(val) +# + self.fic.write(ligne+"\n") +# +# +#======================================================================================= +#======================================================================================= +# +# +if __name__ == "__main__" : +# + import os + import sys + import tempfile +# +# 1. ==> Préalable +# + Rep_Calc_LOGICIEL_global = tempfile.mktemp() + os.mkdir(Rep_Calc_LOGICIEL_global) +# + jdc = None +# +# 2. ==> Création de la classe +# + nomfic = "dataGrad" + fic = fiabilite_fichier ( jdc, Rep_Calc_LOGICIEL_global , nomfic ) +# +# 3. ==> Ouverture du fichier +# + erreur = fic.Ouvre_Fichier ( "w" ) +# +# 4. ==> Remplissage du fichier +# + if not erreur : + aux = ["Titre 1", "Titre 2"] + fic.Ecrit_Titre (aux) + aux = ["Ligne 1", "Ligne 2"] + fic.Ecrit_Commentaires (aux) + aux = "Ligne en forme de chaine" + fic.Ecrit_Commentaires (aux) + aux = 1789.1792 + fic.Ecrit_Commentaires (aux) + aux = [1, 0.0] + fic.Ecrit_Valeurs (aux) + aux = 1958. + fic.Ecrit_Valeurs (aux) +# +# 5. ==> Fermeture du fichier +# + if not erreur : + erreur = fic.Ferme_Fichier ( ) +# +# 4. ==> Impression du fichier +# + if not erreur : + erreur = fic.Imprime_Fichier ( ) +# +# 4. ==> La fin +# + Liste = os.listdir(Rep_Calc_LOGICIEL_global) +# + for nomfic in Liste : + fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) + os.chmod (fic_total,0755) + os.remove (fic_total) + os.rmdir (Rep_Calc_LOGICIEL_global) +# + if erreur : + mess = "Erreur " + str(erreur) + else : + mess = "Fin normale." + sys.exit(mess) diff --git a/Aster/Cata/Macro/fiabilite_mefisto.py b/Aster/Cata/Macro/fiabilite_mefisto.py new file mode 100644 index 00000000..6f18b48d --- /dev/null +++ b/Aster/Cata/Macro/fiabilite_mefisto.py @@ -0,0 +1,445 @@ +#@ MODIF fiabilite_mefisto Macro DATE 16/01/2004 AUTEUR GNICOLAS G.NICOLAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS +# +def fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global, + INFO, VERSION, + SEUIL, SEUIL_TYPE, + VARIABLE, + valeurs_lois, + **args ) : +# +# valeurs_lois est un dictionnaire indexé sur les variables. +# Chaque case, valeurs_lois[m], est un dictionnaire contenant : +# d["v_moy_physique"] = valeur moyenne physique +# d["v_moy_loi"] = valeur moyenne de la loi +# d["v_min_loi"] = valeur minimale de la loi +# d["v_max_loi"] = valeur maximale de la loi +# d["sigma_loi"] = ecart type de la loi +# +# args est le dictionnaire des arguments optionnels +# args.keys() est la liste des mots-clés +# args.keys()[0] est la premiere valeur de cette liste +# args.keys()[1:] est la liste des valeurs suivantes dans cette liste +# args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante. +# + """ Ecriture des données spécifiques à MEFISTO. """ +# + from Macro import fiabilite_fichier + import os + import string +# +#____________________________________________________________________ +# +# 1. Préalables +#____________________________________________________________________ +# +# + messages_erreur = { 0 : "Tout va bien", + 1 : "Fichier inconnu.", + 2 : "Problème d'ouverture de fichier.", + 10 : "Problème d'ouverture de fichier.", + 11 : "Problème de fermeture de fichier.", + 20 : "Problème d'impression de fichier.", + 50 : "Donnée inacceptable.", + 100 : "Erreur." } +# + trad_oui_non = { "OUI" : 1, + "NON" : 0 } +# + erreur = 0 +# + while not erreur : +# +#____________________________________________________________________ +# +# 2. Les fichiers pour le logiciel de fiabilité +# Ils sont créés dans le répertoire d'exécution du logiciel de fiabilité, avec leurs noms officiels +#____________________________________________________________________ +# +# + fic_dataMenu = "dataMenu" + fic_dataStoch = "dataStoch" + fic_dataNum = "dataNum" + fic_dataGrad = "dataGrad" +# +#____________________________________________________________________ +# +# 3. Construction du fichier 'dataMenu' +#____________________________________________________________________ +# +# 3.1 ==> Ouverture du fichier +# + f_menu = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataMenu, INFO ) + erreur = f_menu.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 3.2 ==> Ecriture des données nécessaires +# + f_menu.Ecrit_Titre ("MENU DU PROGRAMME MEFISTO") + f_menu.Ecrit_Titre ("1 <=> OUI et 0 <=> NON (entiers)") +# + f_menu.Ecrit_Titre ("Recherche du point de conception") + aux = trad_oui_non[args["RECH_PT_CONCEPT"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("First Order Reliability Analyses") + aux = trad_oui_non[args["METHODE_FORM"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Second Order Reliability Analyses") + aux = trad_oui_non[args["METHODE_SORM"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Importance Sampling Analyses") + aux = trad_oui_non[args["TIRAGE_IMPORTANCE"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Optimality Test (1) : Hessian Test") + aux = trad_oui_non[args["T_HESSIEN"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Optimality Test (2) : Sphere Test") + aux = trad_oui_non[args["T_SPHERE"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Optimality Test (3) : Strong Max Test") + aux = trad_oui_non[args["T_MAXIMUM_FORT"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Experiment Plan") + aux = trad_oui_non[args["PLAN_EXPERIENCE"]] + f_menu.Ecrit_Valeurs (aux) +# + f_menu.Ecrit_Titre ("Polynomial Taylor Approximation (order 2)") + aux = trad_oui_non[args["POLYNOME_TAYLOR"]] + f_menu.Ecrit_Valeurs (aux) +# +# 3.3 ==> Fermeture du fichier +# + erreur = f_menu.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_menu.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 4. Construction du fichier "dataStoch" +#____________________________________________________________________ +# +# 4.1 ==> Ouverture du fichier +# + f_stoch = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataStoch, INFO ) + erreur = f_stoch.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 4.2 ==> Nombre d'occurence de VARIABLE +# + nb_occu_variable = len(VARIABLE) +# +# 4.3 ==> Ecriture des données nécessaires +# + f_stoch.Ecrit_Titre ("Code name") + aux=string.replace(VERSION,"_",".") + aux=string.replace(aux,"N","n") + aux=string.replace(aux,"V","v") + f_stoch.Ecrit_Valeurs ( "aster_" + aux ) +# + aux = [ "Gradients evaluated by the code" ] + aux.append("1 : Au moins 1 ; 0 : aucun") + f_stoch.Ecrit_Titre (aux) + gradient = 0 + for m in VARIABLE : + if m["GRADIENT"] == "OUI" : gradient = 1 + f_stoch.Ecrit_Valeurs (gradient) +# + f_stoch.Ecrit_Titre ("Variates number") + f_stoch.Ecrit_Valeurs ( nb_occu_variable ) +# + aux = [ "Stochastic Variates" ] + aux.append("1: Uniforme (min, max)") + aux.append("2: Normal (mean, std dev)") + aux.append("3: LogNormal (mean, std dev, min)") + aux.append("4: Normal Truncated (mean, std dev, min, max)") + f_stoch.Ecrit_Titre (aux) +# + for m in VARIABLE : +# + d = valeurs_lois[m] + if m["LOI"] == "UNIFORME" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 1 , d["v_min_loi"] , d["v_max_loi"] ] ) + elif m["LOI"] == "NORMALE" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 2 , d["v_moy_loi"] , d["sigma_loi"] ] ) + elif m["LOI"] == "LOGNORMALE" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 3 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] ] ) + elif m["LOI"] == "NORMALE_TRONQUEE" : + f_stoch.Ecrit_Valeurs ( [ m["NOM"], 4 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] , d["v_max_loi"] ] ) + else : + erreur = 50 +# + if erreur : + break +# + f_stoch.Ecrit_Titre ("Initial Points") + for m in VARIABLE : + if m["POINT_INI"] is None : + aux = valeurs_lois[m]["v_moy_physique"] + else : + aux = m["POINT_INI"] + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Reference Points") + for m in VARIABLE : + if m["POINT_REF"] is None : + aux = valeurs_lois[m]["v_moy_physique"] + else : + aux = m["POINT_REF"] + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Design Points") + for m in VARIABLE : + if args["RECH_PT_CONCEPT"] == "OUI" : + aux = 1792. + elif m["POINT_CONCEPT"] is None : + aux = valeurs_lois[m]["v_moy_physique"] + else : + aux = m["POINT_CONCEPT"] + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Correlation matrix fictive") + for m in range(nb_occu_variable) : + aux = [ ] + for n in range(nb_occu_variable) : + aux.append(args["MATRICE"][n + m*nb_occu_variable]) + f_stoch.Ecrit_Valeurs ( aux ) +# + f_stoch.Ecrit_Titre ("Parameter threshold value") + if SEUIL_TYPE == "MAXIMUM" : + aux = SEUIL + else : + aux = -SEUIL + f_stoch.Ecrit_Valeurs ( aux ) +# +# 4.4 ==> Fermeture du fichier +# + erreur = f_stoch.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_stoch.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 5. Construction du fichier 'dataNum' +#____________________________________________________________________ +# +# 5.1 ==> Ouverture du fichier +# + f_num = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataNum, INFO ) + erreur = f_num.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 5.2 ==> Ecriture des données nécessaires +# + f_num.Ecrit_Titre ("Parameters : EpsU, EpsG, Tau, Omega, iterMax") + if args["RECH_PT_CONCEPT"] == "OUI" : + f_num.Ecrit_Valeurs (args["EPSILON_U"]) + f_num.Ecrit_Valeurs (args["EPSILON_G"]) + f_num.Ecrit_Valeurs (args["TAU"]) + f_num.Ecrit_Valeurs (args["OMEGA"]) + f_num.Ecrit_Valeurs (args["ITER_MAX"]) + else : + aux = 0.1848 + for k in range(5) : + f_num.Ecrit_Valeurs (aux) +# + f_num.Ecrit_Titre ("Parameters : hgrad, hhess") + f_num.Ecrit_Valeurs (args["HGRAD"]) + f_num.Ecrit_Valeurs (args["HHESS"]) +# + aux = [ "Parameter Optimality Test(sphere)" ] + aux.append("1: Parametric Method (Point Number in each direction)") + aux.append("2: Gaussian Method (Total Point Number)") + aux.append("3: Rejection Method (Total Point Number)") + f_num.Ecrit_Titre (aux) +# + if args["T_SPHERE"] == "OUI" : +# + if args["METHODE_TEST"] == "PARAMETRIQUE" : + aux1 = 1 + elif args["METHODE_TEST"] == "GAUSSIENNE" : + aux1 = 2 + elif args["METHODE_TEST"] == "REJECTION" : + aux1 = 3 + else : + self.cr.warn("METHODE DE TEST : "+args["METHODE_TEST"]) + erreur = 50 + break +# + aux2 = args["NB_POINT"] +# + else : +# +# remarque : il faut mettre une valeur plausible en aux1, sinon plantage violent ... + aux1 = 1 + aux2 = 1789 +# + f_num.Ecrit_Valeurs ( [ aux1 , aux2 ] ) +# + aux = [ "Parameters : alpha, beta" ] + aux.append("alpha: common net") + aux.append("beta: extreme net") + f_num.Ecrit_Titre (aux) + if args["PLAN_EXPERIENCE"] == "OUI" : + aux1 = args["ALPHA"] + aux2 = args["BETA"] + else : + aux1 = 1789.0 + aux2 = 1789.0 + f_num.Ecrit_Valeurs ( aux1 ) + f_num.Ecrit_Valeurs ( aux2 ) +# + f_num.Ecrit_Titre ("Parameters Strong Max Test : cosLim, dProb") + if args["T_MAXIMUM_FORT"] == "OUI" : + aux1 = args["COS_LIM"] + aux2 = args["DPROB"] + else : + aux1 = 0.1789 + aux2 = 0.1789 + f_num.Ecrit_Valeurs ( aux1 ) + f_num.Ecrit_Valeurs ( aux2 ) +# + f_num.Ecrit_Titre ("Parameter Importance Samplings : Simulation Number") + if args["TIRAGE_IMPORTANCE"] == "OUI" : + aux = args["NB_SIMULATION"] + else : + aux = 1945 + f_num.Ecrit_Valeurs ( aux ) +# +# 5.3 ==> Fermeture du fichier +# + erreur = f_num.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_num.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 6. Construction du fichier 'dataGrad' +#____________________________________________________________________ +# +# 6.1 ==> Création du fichier +# + f_grad = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataGrad, INFO ) + erreur = f_grad.Ouvre_Fichier ( "w" ) + if erreur : + break +# +# 6.2 ==> Ecriture des données nécessaires +# + f_grad.Ecrit_Titre ("Commentaires") +# + for m in VARIABLE : + f_grad.Ecrit_Commentaires (m["NOM"]) + if m["GRADIENT"] == "OUI" : + gradient = 1 + increment = 0.0 + else : + gradient = 0 + increment = m["INCREMENT"] + aux = [gradient,increment] + f_grad.Ecrit_Valeurs (aux) +# +# 6.3 ==> Fermeture du fichier +# + erreur = f_grad.Ferme_Fichier ( ) + if erreur : + break +# + if INFO >= 2 : + erreur = f_grad.Imprime_Fichier ( ) + if erreur : + break +# +#____________________________________________________________________ +# +# 7. C'est fini ! +#____________________________________________________________________ +# + break +# + if erreur : + if not messages_erreur.has_key(erreur) : + erreur = 100 + self.cr.warn(messages_erreur[erreur]) + erreur = 11 +# + return erreur +# +########################## Fin de la fonction################################## +# +########################## Auto-test################################## +# +if __name__ == "__main__" : +# + import os + import sys + import tempfile +# + Rep_Calc_LOGICIEL_global = tempfile.mktemp() + os.mkdir(Rep_Calc_LOGICIEL_global) +# + INFO = 2 + VERSION = "V3_2" + SEUIL = 1789. + SEUIL_TYPE = "MAXIMUM" + VARIABLE = [] + args = {} + valeurs = {} +# + erreur = fiabilite_mefisto ( None, Rep_Calc_LOGICIEL_global, + INFO, VERSION, + SEUIL, SEUIL_TYPE, + VARIABLE, + valeurs, + **args ) +### print "Erreur = ", erreur + Liste = os.listdir(Rep_Calc_LOGICIEL_global) +# + for nomfic in Liste : + fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) + os.chmod (fic_total,0755) + os.remove (fic_total) + os.rmdir (Rep_Calc_LOGICIEL_global) +# + sys.exit("blabla") diff --git a/Aster/Cata/Macro/macr_adap_mail_ops.py b/Aster/Cata/Macro/macr_adap_mail_ops.py index cccf5c78..e0cb084d 100644 --- a/Aster/Cata/Macro/macr_adap_mail_ops.py +++ b/Aster/Cata/Macro/macr_adap_mail_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_adap_mail_ops Macro DATE 13/10/2003 AUTEUR DURAND C.DURAND +#@ MODIF macr_adap_mail_ops Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -305,8 +305,9 @@ def macr_adap_mail_ops ( self, os.mkdir(Rep_Calc_HOMARD_global) except os.error,codret_partiel : self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) - self.cr.fatal("Impossible de créer le répertoire de travail pour HOMARD : "+Rep_Calc_HOMARD_global) + self.cr.fatal(" Impossible de créer le répertoire de travail pour HOMARD : "+Rep_Calc_HOMARD_global) codret = codret + 1 + return codret # # 4.2. ==> Ecriture des commandes de creation des donnees MED # @@ -339,8 +340,9 @@ def macr_adap_mail_ops ( self, os.symlink(Fichier_ASTER_vers_HOMARD,Fichier_HOMARD_Entree) except os.error,codret_partiel : self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) - self.cr.fatal("Probleme au lien entre " + Fichier_ASTER_vers_HOMARD + " et " + Fichier_HOMARD_Entree) + self.cr.fatal(" Probleme au lien entre " + Fichier_ASTER_vers_HOMARD + " et " + Fichier_HOMARD_Entree) codret = codret + 1 + return codret # # 4.2.1.2. ==> De HOMARD vers ASTER # @@ -354,8 +356,9 @@ def macr_adap_mail_ops ( self, os.symlink(Fichier_HOMARD_vers_ASTER,Fichier_HOMARD_Sortie) except os.error,codret_partiel : self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) - self.cr.fatal("Probleme au lien entre " + Fichier_HOMARD_vers_ASTER + " et " + Fichier_HOMARD_Sortie) + self.cr.fatal(" Probleme au lien entre " + Fichier_HOMARD_vers_ASTER + " et " + Fichier_HOMARD_Sortie) codret = codret + 1 + return codret # # 4.2.2. La définition du fichier de ASTER vers HOMARD # @@ -468,8 +471,9 @@ def macr_adap_mail_ops ( self, # if ( niveau == 2 ) : if ( ADAPTATION['NIVE_MIN'] > ADAPTATION['NIVE_MAX'] ) : - self.cr.fatal("Le niveau minimum doit etre inferieur au niveau maximum.") + self.cr.fatal(" Le niveau minimum doit etre inferieur au niveau maximum.") codret = codret + 1 + return codret # # 4.3.1.5. ==> Mise à jour de la solution # diff --git a/Aster/Cata/Macro/macr_aspic_mail_ops.py b/Aster/Cata/Macro/macr_aspic_mail_ops.py new file mode 100644 index 00000000..4e232f75 --- /dev/null +++ b/Aster/Cata/Macro/macr_aspic_mail_ops.py @@ -0,0 +1,611 @@ +#@ MODIF macr_aspic_mail_ops Macro DATE 19/01/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. +# ====================================================================== + +# Ecriture du fichier GIBI principal (dgib) - ASPID0 +def write_file_dgib_ASPID0(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, THETA, TYPELE, + ITYPSO, DPENE, NIVMAG, loc_datg) : + +# Ouverture du fichier d'entrée de commandes + fdgib=open(nomFichierDATG,'w') + POIVIR = ' ; \n' + texte='****************************************************************\n' + texte=texte+'opti echo 0 ; \n' + texte=texte+'epT1 = '+str(EPT1) +POIVIR + texte=texte+'DeT1 = '+str(DET1) +POIVIR + texte=texte+'d1 = '+str(D1) +POIVIR + texte=texte+'d2 = '+str(D2) +POIVIR + texte=texte+'epT2 = '+str(EPT2) +POIVIR + texte=texte+'DeT2 = '+str(DET2) +POIVIR + texte=texte+'Zmax = '+str(ZMAX) +POIVIR + texte=texte+'type_s = '+str(ITYPSO) +POIVIR + texte=texte+'d_pene = '+str(DPENE) +POIVIR + texte=texte+'h = '+str(H) +POIVIR + texte=texte+'angl_s = '+str(ALPHA) +POIVIR + texte=texte+'jeu = '+str(JEU) +POIVIR + texte=texte+'epC = '+str(EPC) +POIVIR + texte=texte+'DeC = '+str(DEC) +POIVIR + texte=texte+'Xmax = '+str(XMAX) +POIVIR + texte=texte+'typmai = MOT '+TYPMAI +POIVIR + texte=texte+'theta = '+str(THETA) +POIVIR + texte=texte+'typele = MOT '+TYPELE +POIVIR + texte=texte+'typ_eque = MOT '+'SAINE' +POIVIR + texte=texte+'nivmag = '+str(NIVMAG) +POIVIR + texte=texte+'* \n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'aspic.datg'+"';\n" + print texte + fdgib.write(texte) + fdgib.close() + +# Ecriture du fichier GIBI principal (dgib) - ASPID1 +def write_file_dgib_ASPID1(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,THETA, + A,C,EPS, RC0, NS,NC,NT,POSI, NDT,FETIRF,FETIRP, + TFISS,ZETA,ITYPSO,DPENE, NIVMAG, loc_datg) : + +# Ouverture du fichier d'entrée de commandes + fdgib=open(nomFichierDATG,'w') + POIVIR = ' ; \n' + texte='****************************************************************\n' + texte=texte+'opti echo 0 ; \n' + texte=texte+'epT1 = '+str(EPT1) +POIVIR + texte=texte+'DeT1 = '+str(DET1) +POIVIR + texte=texte+'d1 = '+str(D1) +POIVIR + texte=texte+'d2 = '+str(D2) +POIVIR + texte=texte+'epT2 = '+str(EPT2) +POIVIR + texte=texte+'DeT2 = '+str(DET2) +POIVIR + texte=texte+'Zmax = '+str(ZMAX) +POIVIR + texte=texte+'type_s = '+str(ITYPSO) +POIVIR + texte=texte+'d_pene = '+str(DPENE) +POIVIR + texte=texte+'h = '+str(H) +POIVIR + texte=texte+'angl_s = '+str(ALPHA) +POIVIR + texte=texte+'jeu = '+str(JEU) +POIVIR + texte=texte+'epC = '+str(EPC) +POIVIR + texte=texte+'DeC = '+str(DEC) +POIVIR + texte=texte+'Xmax = '+str(XMAX) +POIVIR + texte=texte+'typmai = MOT '+TYPMAI +POIVIR + texte=texte+'theta = '+str(THETA) +POIVIR + texte=texte+'a = '+str(A) +POIVIR + texte=texte+'c = '+str(C) +POIVIR + texte=texte+'zeta = '+str(ZETA) +POIVIR + texte=texte+'eps = '+str(EPS) +POIVIR + texte=texte+'rc0 = '+str(RC0) +POIVIR + texte=texte+'ns = '+str(NS) +POIVIR + texte=texte+'nc = '+str(NC) +POIVIR + texte=texte+'nt = '+str(NT) +POIVIR + texte=texte+'dir_fiss = MOT '+POSI +POIVIR + texte=texte+'pos_fiss = MOT '+TFISS +POIVIR + texte=texte+'ndt = '+str(NDT) +POIVIR + texte=texte+'f_etir_f = '+str(FETIRF) +POIVIR + texte=texte+'f_etir_p = '+str(FETIRP) +POIVIR + texte=texte+'typ_eque = MOT '+'FISS_LON' +POIVIR + texte=texte+'nivmag = '+str(NIVMAG) +POIVIR + texte=texte+'* \n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'aspic_v2.datg'+"';\n" + print texte + fdgib.write(texte) + fdgib.close() + +# Ecriture du fichier GIBI principal (dgib) - ASPID2 +def write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, + H, ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, + THETA, A, C, EPS, RC0, RC1, RC2, RC3, + ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS, + ZETA,ITYPSO,DPENE, NIVMAG, loc_datg) : + +# Ouverture du fichier d'entrée de commandes + fdgib=open(nomFichierDATG,'w') + POIVIR = ' ; \n' + texte='****************************************************************\n' + texte=texte+'opti echo 0 ; \n' + texte=texte+'epT1 = '+str(EPT1) +POIVIR + texte=texte+'DeT1 = '+str(DET1) +POIVIR + texte=texte+'d1 = '+str(D1) +POIVIR + texte=texte+'d2 = '+str(D2) +POIVIR + texte=texte+'epT2 = '+str(EPT2) +POIVIR + texte=texte+'DeT2 = '+str(DET2) +POIVIR + texte=texte+'Zmax = '+str(ZMAX) +POIVIR + texte=texte+'type_s = '+str(ITYPSO) +POIVIR + texte=texte+'d_pene = '+str(DPENE) +POIVIR + texte=texte+'h = '+str(H) +POIVIR + texte=texte+'angl_s = '+str(ALPHA) +POIVIR + texte=texte+'jeu = '+str(JEU) +POIVIR + texte=texte+'epC = '+str(EPC) +POIVIR + texte=texte+'DeC = '+str(DEC) +POIVIR + texte=texte+'Xmax = '+str(XMAX) +POIVIR + texte=texte+'typmai = MOT '+TYPMAI +POIVIR + texte=texte+'theta = '+str(THETA) +POIVIR + texte=texte+'a = '+str(A) +POIVIR + texte=texte+'c = '+str(C) +POIVIR + texte=texte+'zeta = '+str(ZETA) +POIVIR + texte=texte+'eps = '+str(EPS) +POIVIR + texte=texte+'rc0 = '+str(RC0) +POIVIR + texte=texte+'rc1 = '+str(RC1) +POIVIR + texte=texte+'rc2 = '+str(RC2) +POIVIR + texte=texte+'rc3 = '+str(RC3) +POIVIR + texte=texte+'alpha = '+str(ALP) +POIVIR + texte=texte+'beta = '+str(BETA) +POIVIR + texte=texte+'ns = '+str(NS) +POIVIR + texte=texte+'nc = '+str(NC) +POIVIR + texte=texte+'nt = '+str(NT) +POIVIR + texte=texte+'dir_fiss = MOT '+POSI +POIVIR + texte=texte+'pos_fiss = MOT '+TFISS +POIVIR + texte=texte+'ndt = '+str(NDT) +POIVIR + texte=texte+'nsdt = '+str(NSDT) +POIVIR + texte=texte+'typ_eque = MOT '+'FISS_COU' +POIVIR + texte=texte+'nivmag = '+str(NIVMAG) +POIVIR + texte=texte+'* \n' + texte=texte+'list epc ;\n' + texte=texte+'opti donn ' + texte=texte+"'"+loc_datg+'aspic.datg'+"';\n" + print texte + fdgib.write(texte) + fdgib.close() + +def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, + SOUDURE,CORPS,FISS_SOUDURE,IMPRESSION,INFO, + **args): + """ + Ecriture de la macro MACR_ASPIC_MAIL + """ + from Accas import _F + import types + import aster + from math import sqrt,cos,sin,pi + ier=0 + +# On importe les definitions des commandes a utiliser dans la macro + EXEC_LOGICIEL =self.get_cmd('EXEC_LOGICIEL') + PRE_GIBI =self.get_cmd('PRE_GIBI') + LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE') + DEFI_GROUP =self.get_cmd('DEFI_GROUP') + MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE') + 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') + +# La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + TYPELE = TYPE_ELEM + NIVMAG = EXEC_MAILLAGE['NIVE_GIBI'] +# +# --- raffinement maillage --- +# + TYPMAI = RAFF_MAIL + GROS = (TYPMAI=='GROS') + if GROS : NBAZIT = 40 + else : NBAZIT = 48 +# +# --- caracteristiques de la tubulure --- +# + EPT1 = TUBULURE['E_BASE' ] + DET1 = TUBULURE['DEXT_BASE'] + D1 = TUBULURE['L_BASE' ] + D2 = TUBULURE['L_CHANF' ] + EPT2 = TUBULURE['E_TUBU' ] + DET2 = TUBULURE['DEXT_TUBU'] + ZMAX = TUBULURE['Z_MAX' ] + TYPSOU= TUBULURE['TYPE' ] + DPENE = TUBULURE['L_PENETR' ] + if TYPSOU=='TYPE_2' and DPENE>0.0 : + self.cr.fatal(" les piquages penetrants sont autorises uniquement avec les soudures de type 1") + ier = ier+1 + return ier + if TYPSOU=='TYPE_2' : + ITYPSO = 2 + else : + ITYPSO = 1 +# +# --- caracteristiques de la soudure --- +# + H = SOUDURE['H_SOUD' ] + ALPHA = SOUDURE['ANGL_SOUD'] + JEU = SOUDURE['JEU_SOUD' ] +# +# --- caracteristiques du corps --- +# + EPC = CORPS ['E_CORP' ] + DEC = CORPS ['DEXT_CORP'] + XMAX = CORPS ['X_MAX' ] + EPSI = 1.E-03 + RMB = ( DET1 - EPT1 ) / 2.0 + VAL1 = 1.5 * sqrt( RMB**3 / EPT1 ) + VAL3 = 3.0 * sqrt( RMB * EPT1 ) + RMT = ( DET2 - EPT2 ) / 2.0 + VAL2 = 1.5 * sqrt( RMT**3 / EPT2 ) + VAL4 = 3.0 * sqrt( RMT * EPT2 ) + LZMAX = max ( VAL1 , VAL2, VAL3, VAL4 ) + ZMAXC = LZMAX + ( DEC/2.0 ) + D1 + D2 + LOK = ( abs(ZMAX-ZMAXC) <= EPSI * abs(ZMAXC) ) + if not LOK : + print ' erreur donnees' + print ' Z_MAX FOURNIE : ', ZMAX + print ' Z_MAX CALCULEE : ', ZMAXC + self.cr.fatal(" erreur donnees ") + ier = ier+1 + return ier + RMC = ( DEC - EPC ) / 2.0 + VAL1 = 1.5 * sqrt( RMC**3 / EPC ) + VAL2 = 3.0 * sqrt( RMC * EPC ) + LXMAX = max( VAL1 , VAL2 ) + XMAXC = LXMAX + ( DET1 / 2.0 ) + LOK = ( abs(XMAX-XMAXC) <= EPSI * abs(XMAXC) ) + if not LOK : + print ' erreur donnees' + print ' Z_MAX FOURNIE : ', ZMAX + print ' Z_MAX CALCULEE : ', ZMAXC + self.cr.fatal(" erreur donnees ") + ier = ier+1 + return ier + print ' MACR_ASPIC_MAIL / X_MAX CALCULEE : ',XMAX + print ' MACR_ASPIC_MAIL / Z_MAX CALCULEE : ',XMAXC +# +# --- caracteristiques de la fissure --- +# + SAIN = 0 + FISLON = 0 + FISCOU = 0 + THETA = 0.0 + TFISS = None + if FISS_SOUDURE==None : + SAIN = 1 + else : + if FISS_SOUDURE['TYPE']=='LONGUE' : FISLON = 1 + elif FISS_SOUDURE['TYPE']=='COURTE' : FISCOU = 1 + THETA = FISS_SOUDURE['AZIMUT' ] + EPS = FISS_SOUDURE['ANGL_OUVERTURE'] + AXIS = FISS_SOUDURE['AXIS' ] + POSI = FISS_SOUDURE['POSITION' ] + TFISS = FISS_SOUDURE['FISSURE' ] + A = FISS_SOUDURE['PROFONDEUR' ] + if FISS_SOUDURE['LONGUEUR' ]!=None : + C = FISS_SOUDURE['LONGUEUR' ] + N1 = 1 + else : N1 = 0 + if (TFISS=='DEB_INT') and (POSI=='INCLINE') and (DPENE>0.0) and (JEU>0.0) : + print ' erreur donnees' + print ' dans le cas de fissures' + print ' inclinees debouchant en peau interne avec' + print ' piquage penetrant le jeu doit etre nul' + self.cr.fatal(" erreur donnees ") + ier = ier+1 + return ier + ZETA = 0.5 + if TFISS not in ('DEB_INT','DEB_EXT') : + if FISS_SOUDURE['LIGA_INT']==None : + print ' erreur donnees' + print ' dans le cas de fissures internes' + print ' (NON_DEB) le ligament inferieur est obligatoire' + self.cr.fatal(" erreur donnees ") + ier = ier+1 + return ier + LIGA = FISS_SOUDURE['LIGA_INT'] + if POSI=='DROIT' : + if ITYPSO==1 : ZETA = (A+LIGA)/(EPC+H) + else : ZETA = (A+LIGA)/(EPT1+H) + else : + if ITYPSO==1 : ZETA = (A+LIGA)*cos(ALPHA*pi/180.0)/EPC + else : ZETA = (A+LIGA)*cos(ALPHA*pi/180.0)/EPT1 + if ZETA < 0.1 : + self.cr.fatal(" dans le cas de fissures internes (NON_DEB) le ligament est trop petit ") + ier = ier+1 + return ier + if ZETA > 0.9 : + self.cr.fatal(" dans le cas de fissures internes (NON_DEB) le ligament est trop grand ") + ier = ier+1 + return ier + if LIGA < 0.1*EPC : + self.cr.fatal(" dans le cas de fissures internes (NON_DEB) le ligament est trop petit ") + ier = ier+1 + return ier + if (LIGA + 2.0*A) > 0.9*EPC : + self.cr.fatal(" dans le cas de fissures internes (NON_DEB) le ligament est trop grand ") + ier = ier+1 + return ier + if N1==0 : + if FISCOU : + self.cr.fatal(" dans le cas de fissures courte il faut preciser la longueur ") + ier = ier+1 + return ier + if AXIS=='NON' : + self.cr.fatal(" dans le cas de la fissure longue il faut preciser la longueur ou axis=oui ") + ier = ier+1 + return ier + C = 0.0 + else : + if AXIS=='OUI' : print ' fissure axisymetrique : le mot clef ne doit pas etre renseigne' + C = 0.5 * C + LEQU=2.*(pi*(DEC-EPC)-DET1+2.*EPT1) +# +# LPIQ est une valeur qui depend theoriquement de la fissure. la valeur +# ci-dessous est approchee car elle ne sert qu'a calculer les facteurs d'etirement +# + LPIQ=pi*(DET1) + if AXIS=='OUI' : C=100.0*LPIQ + RAPL=LEQU/LPIQ + if FISCOU : + RAP=A/C + CAS1=RAP<0.3499 + CAS3=RAP>0.4999 + CAS2= not (CAS1 or CAS3) + if CAS1 : ALP=0.8 + if CAS2 : ALP=0.4 + if CAS3 : ALP=0.0 + BETA=1.0 + if GROS and not CAS1 : + NDT=1 + NSDT=2 + else : + NDT=2 + NSDT=4 +# + if FISLON : + if GROS : + NDT=2 + FETIRF=30.*RAPL + FETIRP=60.*RAPL + else : + NDT=3 + FETIRF=15.*RAPL + FETIRP=30.*RAPL +# + RC0 = FISS_SOUDURE['RAYON_TORE'] + if (FISCOU and RC0==None) : + if GROS : RC0=0.12 + else : RC0=0.10 + if CAS1 : RC0=0.08 + RC0=RC0*A + if (FISLON and RC0==None) : RC0=A/(NDT+1) +# + RC1 = FISS_SOUDURE['COEF_MULT_RC1'] + if (FISCOU and RC1==None) : + if GROS : RC1=1.2 + else : RC1=1.0 +# + RC2 = FISS_SOUDURE['COEF_MULT_RC2'] + if (FISCOU and RC2==None) : + if GROS : RC2=1.4 + else : RC2=1.2 +# + RC3 = FISS_SOUDURE['COEF_MULT_RC3'] + if (FISCOU and RC3==None) : + if GROS : + if CAS1 : RC3=2.5 + else : RC3=1.0 # valeur non utilisee + else : + if CAS3 : RC3=2.2 + else : RC3=2.0 +# + NT = FISS_SOUDURE['NB_TRANCHE'] + if (FISCOU and NT==None) : + if GROS : NT = 8 + else : NT = 16 + if CAS1 : NT = NT*2 + if (FISLON and NT==None) : NT=0 +# + NS = FISS_SOUDURE['NB_SECTEUR'] + if (FISCOU and NS==None) : + if GROS : NS = 2 + else : NS = 4 + if (FISLON and NS==None) : + if GROS : NS = 2 + else : NS = 4 +# + NC = FISS_SOUDURE['NB_COURONNE'] + if (FISCOU and NC==None) : + if GROS : NC = 3 + else : NC = 4 + if (FISLON and NC==None) : + if GROS : NC = 3 + else : NC = 4 +# + loc_gibi=aster.repout() + logiel = EXEC_MAILLAGE['LOGICIEL' ] + UNITD = EXEC_MAILLAGE['UNITE_DATG'] + UNITS = EXEC_MAILLAGE['UNITE_MGIB'] + if logiel=='GIBI98' : logiel = loc_gibi+'gibi98' + elif logiel=='GIBI2000': logiel = loc_gibi+'gibi2000' + else : + self.cr.fatal(" seuls gibi98 et gibi2000 sont appelableS") + ier = ier+1 + return ier +# +# --- ecriture sur le fichier .datg de la procedure --- +# +# Nom du fichier de commandes pour GIBI + nomFichierDATG = 'fort.'+str(UNITD) +# Nom du fichier de maillage GIBI + nomFichierGIBI = 'fort.'+str(UNITS) + loc_datg = aster.repdex() + if SAIN : write_file_dgib_ASPID0(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, THETA, TYPELE, + ITYPSO, DPENE, NIVMAG,loc_datg) + if FISLON : write_file_dgib_ASPID1(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, H, + ALPHA, JEU, EPC, DEC, XMAX, TYPMAI,THETA, + A,C,EPS, RC0,NS,NC,NT,POSI, NDT,FETIRF,FETIRP, + TFISS,ZETA,ITYPSO,DPENE, NIVMAG,loc_datg) + if FISCOU : write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, ZMAX, + H, ALPHA, JEU, EPC, DEC, XMAX, TYPMAI, + THETA, A, C, EPS, RC0, RC1, RC2, RC3, + ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS, + ZETA,ITYPSO,DPENE, NIVMAG,loc_datg) +# + EXEC_LOGICIEL( LOGICIEL = logiel , + ARGUMENT = ( _F(NOM_PARA=nomFichierDATG), + _F(NOM_PARA=nomFichierGIBI), ), ) +# + PRE_GIBI() +# + __MAPROV=LIRE_MAILLAGE(INFO=INFO) +# + motscles={} + motscles['CREA_GROUP_MA']=[] + l_CREA_GROUP_NO=[] + if SAIN : + l_CREA_GROUP_NO.append('S_LAT1') + l_CREA_GROUP_NO.append('S_LAT2') + else : + l_CREA_GROUP_NO.append('S_LAT1_C') + l_CREA_GROUP_NO.append('S_LAT2_C') + l_CREA_GROUP_NO.append('S_LAT1_T') + l_CREA_GROUP_NO.append('S_LAT2_T') + if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') : + l_CREA_GROUP_NO.append('PFONDINF') + l_CREA_GROUP_NO.append('PFONDSUP') + else : + l_CREA_GROUP_NO.append('PFONDFIS') + if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='COURTE') : + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS', + NOM = 'MAIL_ORI', + POSITION = 'INIT' )) + if (TFISS[:4]=='DEB_') and (AXIS=='OUI') : + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FONDFISS', + NOM = 'MAIL_ORI', + POSITION = 'INIT' )) + if (TFISS=='NON_DEB') and (FISS_SOUDURE['TYPE']=='LONGUE') : + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FOND_SUP', + NOM = 'MA_ORI_S', + POSITION = 'INIT' )) + motscles['CREA_GROUP_MA'].append(_F(GROUP_MA = 'FOND_INF', + NOM = 'MA_ORI_I', + POSITION = 'INIT' )) + l_CREA_GROUP_NO.append('S_FOND1') + l_CREA_GROUP_NO.append('S_FOND2') + l_CREA_GROUP_NO.append('EQUERRE') + motscles['CREA_GROUP_NO']=_F(GROUP_MA=l_CREA_GROUP_NO) +# + __MAPROV=DEFI_GROUP(reuse =__MAPROV, + MAILLAGE=__MAPROV, + **motscles ) +# + __MAPROV=MODI_MAILLAGE(reuse =__MAPROV, + MAILLAGE=__MAPROV, + EQUE_PIQUA=_F( GROUP_NO = 'EQUERRE' , + E_BASE = EPT1 , + DEXT_BASE = DET1 , + L_BASE = D1 , + L_CHANF = D2 , + TYPE = TYPSOU, + H_SOUD = H , + ANGL_SOUD = ALPHA , + JEU_SOUD = JEU , + E_CORP = EPC , + DEXT_CORP = DEC , + AZIMUT = THETA , + RAFF_MAIL = TYPMAI, + X_MAX = XMAX , ) + ) +# + __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'),) + else : + motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU',),) + __MAPROV=MODI_MAILLAGE(reuse =__MAPROV, + MAILLAGE=__MAPROV, + MODELE =__MODELE, + **motscles + ) +# + if SAIN : + __MAPROV=DEFI_GROUP(reuse = __MAPROV, + MAILLAGE = __MAPROV, + CREA_GROUP_NO = _F(GROUP_MA=('NIDXT','NEDXT','NIIXT','NEIXT')) ) +# + for i in range(1,NBAZIT+1): + prec = EPC / 5.0 + __MAPROV=DEFI_GROUP(reuse = __MAPROV, + MAILLAGE = __MAPROV, + CREA_GROUP_NO = ( _F( NOM = 'NID'+str(i) , + GROUP_NO = 'NIDXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'NED'+str(i) , + GROUP_NO = 'NEDXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'NII'+str(i) , + GROUP_NO = 'NIIXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'NEI'+str(i) , + GROUP_NO = 'NEIXT' , + NUME_INIT = i , + NUME_FIN = i ,), + _F( NOM = 'LDN'+str(i) , + GROUP_MA = 'LD' +str(i) ,), + _F( NOM = 'LD' +str(i) , + GROUP_NO = 'LDN'+str(i) , + OPTION = 'SEGM_DROI_ORDO', + PRECISION = prec , + CRITERE = 'ABSOLU' , + GROUP_NO_ORIG = 'NID'+str(i), + GROUP_NO_EXTR = 'NED'+str(i),), + _F( NOM = 'LIN'+str(i) , + GROUP_MA = 'LI' +str(i) ,), + _F( NOM = 'LI' +str(i) , + GROUP_NO = 'LIN'+str(i) , + OPTION = 'SEGM_DROI_ORDO', + PRECISION = prec , + CRITERE = 'ABSOLU' , + GROUP_NO_ORIG = 'NII'+str(i), + GROUP_NO_EXTR = 'NEI'+str(i),),)) +# +# +# --- commande CREA_MAILLAGE --- +# + self.DeclareOut('nomres',self.sd) + nomres=CREA_MAILLAGE( MAILLAGE=__MAPROV, + CREA_POI1 = ( _F( NOM_GROUP_MA = 'P1_CORP ' , + GROUP_NO = 'P1_CORP ' , ), + _F( NOM_GROUP_MA = 'P2_CORP ' , + GROUP_NO = 'P2_CORP ' , ), + _F( NOM_GROUP_MA = 'P_TUBU ' , + GROUP_NO = 'P_TUBU ' , ),) + ) +# + if IMPRESSION!=None: + if IMPRESSION.__class__.__name__ !='MCList' : IMPRESSION =[IMPRESSION,] + for impr in IMPRESSION : +# + if impr['FICHIER']!=None: + DEFI_FICHIER(FICHIER = impr['FICHIER'], + UNITE = impr['UNITE' ] ) +# + motscles={} + if impr['FORMAT']=='IDEAS' : motscles['VERSION'] =impr['VERSION'] + if impr['FORMAT']=='CASTEM' : motscles['NIVE_GIBI']=impr['NIVE_GIBI'] + if impr['FICHIER']!=None : motscles['FICHIER'] =impr['FICHIER'] + impr_resu = _F( MAILLAGE = nomres, + FORMAT = impr['FORMAT'], + **motscles) + IMPR_RESU( RESU = impr_resu ) +# + return ier + diff --git a/Aster/Cata/Macro/macr_cabri_calc_ops.py b/Aster/Cata/Macro/macr_cabri_calc_ops.py index 29274170..3f9c0dce 100644 --- a/Aster/Cata/Macro/macr_cabri_calc_ops.py +++ b/Aster/Cata/Macro/macr_cabri_calc_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_cabri_calc_ops Macro DATE 09/09/2003 AUTEUR DURAND C.DURAND +#@ MODIF macr_cabri_calc_ops Macro DATE 18/11/2003 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -389,8 +389,8 @@ def macr_cabri_calc_ops(self,MAILLAGE,MODELE_MECA,MODELE_THER,CHAR_THER, # Contact zone de joint cl_me8=AFFE_CHAR_MECA(MODELE=modmeca, - CONTACT=_F(GROUP_MA_1='SCBJ', - GROUP_MA_2='SCJB',), + CONTACT=_F(GROUP_MA_MAIT='SCBJ', + GROUP_MA_ESCL='SCJB',), INFO=2,); # Deformation thermique cl_me9=AFFE_CHAR_MECA( MODELE=modmeca, diff --git a/Aster/Cata/Macro/macr_cabri_mail_ops.py b/Aster/Cata/Macro/macr_cabri_mail_ops.py index 742d2c12..57317384 100644 --- a/Aster/Cata/Macro/macr_cabri_mail_ops.py +++ b/Aster/Cata/Macro/macr_cabri_mail_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_cabri_mail_ops Macro DATE 20/05/2003 AUTEUR MABBAS M.ABBAS +#@ MODIF macr_cabri_mail_ops Macro DATE 24/11/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -17,8 +17,7 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# Variable pour préparer la restit (test->0, restit->1) -RESTIT = 1 +import os def macr_cabri_mail_ops(self,EXEC_MAILLAGE,RAFF_MAILLAGE,VERI_MAIL,GEOM_BRID, IMPRESSION,**args): @@ -44,9 +43,9 @@ def macr_cabri_mail_ops(self,EXEC_MAILLAGE,RAFF_MAILLAGE,VERI_MAIL,GEOM_BRID, # le contexte de la macro self.DeclareOut('nomres',self.sd) - import aster # Chemin de Gibi + import aster loc_gibi=aster.repout() gibi2000=loc_gibi+'gibi' @@ -204,8 +203,7 @@ def macr_cabri_mail_ops(self,EXEC_MAILLAGE,RAFF_MAILLAGE,VERI_MAIL,GEOM_BRID, # Importation des modules Python #============================================================================================= -import os -from Macro.macr_cabri_mail_dat import * +from Macro.macr_cabri_mail_dat import dico_var_geo,dico_var_msh,dico_bride_std #============================================================================================= # Fonctions principales @@ -288,7 +286,6 @@ def write_file_dgib_STD(unite_mgib,unite_datg,msh_bride,geo_bride): # Ecriture du fichier GIBI principal (dgib) - Bride QUELCONQUE def write_file_dgib_QQE(unite_mgib,unite_datg,msh_bride,geo_bride): - import aster # Nom du fichier maillage produit par GIBI nomFichierMGIB = name_file_mgib(unite_mgib) @@ -373,13 +370,9 @@ def name_file_datg(unite_datg): # Récupère un fichier texte DATG: texte GIBI pour procédures def text_datg_pro(): - if RESTIT == 1: - import aster - loc_datg = aster.repdex() - datg_bridePro = loc_datg+"macr_cabri_mail_proc.datg" - else: - datg_bridePro = 'fort.'+str(39) - + import aster + loc_datg = aster.repdex() + datg_bridePro = loc_datg+"macr_cabri_mail_proc.datg" fproc=open(datg_bridePro,'r') procText = fproc.read() fproc.close() @@ -388,13 +381,9 @@ def text_datg_pro(): # Récupère un fichier texte DATG: texte GIBI pour bride quelconque def text_datg_qqe(): - if RESTIT == 1: - import aster - loc_datg = aster.repdex() - datg_brideQqe = loc_datg+"macr_cabri_mail_qqe.datg" - else: - datg_brideQqe = 'fort.'+str(38) - + import aster + loc_datg = aster.repdex() + datg_brideQqe = loc_datg+"macr_cabri_mail_qqe.datg" fproc=open(datg_brideQqe,'r') procText = fproc.read() fproc.close() @@ -403,13 +392,9 @@ def text_datg_qqe(): # Récupère un fichier texte DATG: texte GIBI pour bride standard def text_datg_std(): - if RESTIT == 1: - import aster - loc_datg = aster.repdex() - datg_brideStd = loc_datg+"macr_cabri_mail_std.datg" - else: - datg_brideStd = 'fort.'+str(37) - + import aster + loc_datg = aster.repdex() + datg_brideStd = loc_datg+"macr_cabri_mail_std.datg" fproc=open(datg_brideStd,'r') procText = fproc.read() fproc.close() diff --git a/Aster/Cata/Macro/macr_cara_poutre_ops.py b/Aster/Cata/Macro/macr_cara_poutre_ops.py index 9bc59c66..53d70c97 100644 --- a/Aster/Cata/Macro/macr_cara_poutre_ops.py +++ b/Aster/Cata/Macro/macr_cara_poutre_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_cara_poutre_ops Macro DATE 28/01/2003 AUTEUR JMBHH01 J.M.PROIX +#@ MODIF macr_cara_poutre_ops Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -44,6 +44,11 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, NUME_DDL =self.get_cmd('NUME_DDL') ASSE_VECTEUR =self.get_cmd('ASSE_VECTEUR') POST_ELEM =self.get_cmd('POST_ELEM') + CALC_ELEM =self.get_cmd('CALC_ELEM') + INTE_MAIL_2D =self.get_cmd('INTE_MAIL_2D') + POST_RELEVE_T =self.get_cmd('POST_RELEVE_T') + IMPR_TABLE =self.get_cmd('IMPR_TABLE') + IMPR_CO =self.get_cmd('IMPR_CO') # La macro compte pour 1 dans la numerotation des commandes #self.icmd=1 self.set_icmd(1) @@ -56,7 +61,7 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, # if GROUP_MA_BORD and GROUP_MA: # if not LIAISON: # ier=ier+1 -# self.cr.fatal("Avec GROUP_MA, il faut obligatoirement preciser LIAISON, LONGUEUR ET MATERIAU") +# self.cr.fatal(" Avec GROUP_MA, il faut obligatoirement preciser LIAISON, LONGUEUR ET MATERIAU") # return ier # __nomlma=LIRE_MAILLAGE(UNITE=UNITE_MAILLAGE,) @@ -94,12 +99,12 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, # --- = OU DU CENTRE DE TORSION/CISAILLEMENT = # --- = DES COEFFICIENTS DE CISAILLEMENT = # --- = ET DE L INERTIE DE GAUCHISSEMENT = +# --- = DU RAYON DE TORSION SUR TOUT LE MAILLAGE # --- = ON CREE UN MODELE PLAN 2D THERMIQUE REPRESENTANT LA SECTION = # --- = DE LA POUTRE CAR ON A A RESOUDRE DES E.D.P. AVEC DES LAPLACIENS= # ================================================================== if GROUP_MA_BORD and not GROUP_MA: - # --- TRANSFORMATION DES GROUP_MA EN GROUP_NO SUR-LESQUELS # --- ON POURRA APPLIQUER DES CONDITIONS DE TEMPERATURE IMPOSEE : # --------------------------------------------------------- @@ -113,6 +118,7 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, __nomlma=DEFI_GROUP(reuse=__nomlma, MAILLAGE=__nomlma, **motscles) + # --- CREATION D UN MAILLAGE IDENTIQUE AU PREMIER A CECI PRES @@ -286,6 +292,61 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, SOLVEUR=_F(STOP_SINGULIER='NON',), ) +# --- CALCUL DU RAYON DE TORSION : +# -------------------------- + +# CALCUL DU RAYON DE TORSION EXTERNE : rtext + + __tempe1=CALC_ELEM(reuse=__tempe1, + RESULTAT=__tempe1, + MODELE=__nomoth, + CHAM_MATER=__chmath, + TOUT_ORDRE='OUI', + OPTION='FLUX_ELNO_TEMP', + ) + + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=GROUP_MA_BORD), + INFO=2,) + + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + + __m1=abs(__flun['TRAC_NOR',3]) + __m2=abs(__flun['TRAC_NOR',4]) + __rtext=max(__m1,__m2) + + # CALCUL DU RAYON DE TORSION : rt + # rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) + + if args.has_key('GROUP_MA_INTE'): + if args['GROUP_MA_INTE'] != None : + if type(args['GROUP_MA_INTE'])==types.StringType : + l_group_ma_inte=[args['GROUP_MA_INTE'],] + else: + l_group_ma_inte=args['GROUP_MA_INTE'] + for i in range(0,len(l_group_ma_inte)): + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_inte[i]), + INFO=2,) + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + __m1=(abs(__flun['TRAC_NOR',3])+abs(__flun['TRAC_NOR',4]))/2. + if __m1 > __rtext : + __rtext=__m1 + + __rt=__rtext + # --- CALCUL DE LA CONSTANTE DE TORSION : # --------------------------------- @@ -295,18 +356,21 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, if lgmaint != None : motscles['CARA_POUTRE']=_F(CARA_GEOM=nomres, LAPL_PHI=__tempe1, + RT=__rt, TOUT='OUI', OPTION='CARA_TORSION', GROUP_MA_INTE=args['GROUP_MA_INTE'],) else: motscles['CARA_POUTRE']=_F(CARA_GEOM=nomres, - LAPL_PHI=__tempe1, - TOUT='OUI', - OPTION='CARA_TORSION', ) + LAPL_PHI=__tempe1, + RT=__rt, + TOUT='OUI', + OPTION='CARA_TORSION', ) nomres=POST_ELEM(reuse=nomres, MODELE=__nomoth, CHAM_MATER=__chmath, **motscles ) + # --- CALCUL DES COEFFICIENTS DE CISAILLEMENT ET DES COORDONNEES DU # --- CENTRE DE CISAILLEMENT/TORSION : @@ -320,6 +384,7 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, LAPL_PHI_Z=__tempe3, TOUT='OUI', OPTION='CARA_CISAILLEMENT',), ) + # # ------------------------------------------------------------ @@ -484,10 +549,12 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, TOUT='OUI', OPTION='CARA_GAUCHI'), ) + # # ================================================================== # --- = CALCUL DE LA CONSTANTE DE TORSION SUR CHAQUE GROUPE = -# --- = ET DU CENTRE DE TORSION/CISAILLEMENT = +# --- = ET DU RAYON DE TORSION SUR CHAQUE GROUPE = +# --- = DU CENTRE DE TORSION/CISAILLEMENT = # --- = DES COEFFICIENTS DE CISAILLEMENT = # ================================================================== # @@ -512,11 +579,11 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, if len(l_group_ma)!=len(l_group_ma_bord): ier=ier+1 - self.cr.fatal("GROUP_MA et GROUP_MA_BORD incoherents") + self.cr.fatal(" GROUP_MA et GROUP_MA_BORD incoherents") return ier if args.has_key('NOEUD') and (len(l_group_ma)!=len(l_noeud)): ier=ier+1 - self.cr.fatal("GROUP_MA et NOEUD incoherents") + self.cr.fatal(" GROUP_MA et NOEUD incoherents") return ier for i in range(0,len(l_group_ma_bord)): @@ -658,15 +725,71 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, CHAM_MATER=__chmath, EXCIT=_F(CHARGE=__chart3, ), SOLVEUR=_F(STOP_SINGULIER='NON',) ) + +# --- CALCUL DU RAYON DE TORSION : +# -------------------------- + +# CALCUL DU RAYON DE TORSION EXTERNE : rtext + __tempe1=CALC_ELEM(reuse=__tempe1, + RESULTAT=__tempe1, + MODELE=__nomoth, + CHAM_MATER=__chmath, + TOUT_ORDRE='OUI', + OPTION='FLUX_ELNO_TEMP', + ) + + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_bord[i]), + INFO=2,) + + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + + __m1=abs(__flun['TRAC_NOR',3]) + __m2=abs(__flun['TRAC_NOR',4]) + __rtext=max(__m1,__m2) + +# CALCUL DU RAYON DE TORSION : rt +# rt = max ( rtext , 2*AIRE(TROU)/L(TROU) ) + + if args.has_key('GROUP_MA_INTE'): + if args['GROUP_MA_INTE'] != None : + if type(args['GROUP_MA_INTE'])==types.StringType : + l_group_ma_inte=[args['GROUP_MA_INTE'],] + else: + l_group_ma_inte=args['GROUP_MA_INTE'] + for j in range(0,len(l_group_ma_inte)): + __chem=INTE_MAIL_2D(MAILLAGE=__nomapi, + DEFI_CHEMIN=_F(GROUP_MA=l_group_ma_inte[j]), + INFO=2,) + __flun=POST_RELEVE_T(ACTION=_F(INTITULE='FLUX_NORM', + CHEMIN=__chem, + RESULTAT=__tempe1, + NOM_CHAM='FLUX_ELNO_TEMP', + TRAC_NOR='OUI', + NOM_CMP=('FLUX','FLUY'), + OPERATION='MOYENNE')) + __m1=(abs(__flun['TRAC_NOR',3])+abs(__flun['TRAC_NOR',4]))/2. + if __m1 > __rtext : + __rtext=__m1 + + __rt=__rtext + # --- CALCUL DE LA CONSTANTE DE TORSION : # --------------------------------- - + nomres=POST_ELEM(reuse=nomres, MODELE=__nomoth, CHAM_MATER=__chmath, CARA_POUTRE=_F(CARA_GEOM=nomres, LAPL_PHI=__tempe1, + RT=__rt, GROUP_MA=l_group_ma[i], OPTION='CARA_TORSION' ), ) @@ -685,6 +808,6 @@ def macr_cara_poutre_ops(self,UNITE_MAILLAGE,SYME_X,SYME_Y,GROUP_MA_BORD, MATERIAU=args['MATERIAU'], LIAISON =args['LIAISON'], OPTION='CARA_CISAILLEMENT' ), ) + IMPR_TABLE(TABLE=nomres) return ier - diff --git a/Aster/Cata/Macro/macr_fiab_impr_ops.py b/Aster/Cata/Macro/macr_fiab_impr_ops.py new file mode 100644 index 00000000..6e20c815 --- /dev/null +++ b/Aster/Cata/Macro/macr_fiab_impr_ops.py @@ -0,0 +1,106 @@ +#@ MODIF macr_fiab_impr_ops Macro DATE 16/01/2004 AUTEUR GNICOLAS G.NICOLAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS +# +def macr_fiab_impr_ops(self, INFO, + TABLE_CIBLE, NOM_PARA_CIBLE, GRADIENTS, **args): +# +# +# 1. args est le dictionnaire des arguments +# args.keys() est la liste des mots-clés +# args.keys()[0] est la premiere valeur de cette liste +# args.keys()[1:] est la liste des valeurs suivantes dans cette liste +# args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante. +# + """ Macro-commande réalisant l'impression des valeurs pour le logiciel de fiabilite. """ +# +# On charge les modules nécessaires + from Accas import _F +# +#____________________________________________________________________ +# +# 1. Préalables +#____________________________________________________________________ +# + erreur = 0 +# +# 1.1 ==> La macro compte pour 1 dans l'exécution des commandes +# + self.set_icmd(1) +# +# 1.2 ==> On importe les définitions des commandes Aster utilisées +# dans la macro +# + DEFI_FICHIER = self.get_cmd("DEFI_FICHIER") + IMPR_TABLE = self.get_cmd("IMPR_TABLE") +# +# 1.3. ==> Des constantes +# Atention : le numéro d'unité utilisé ici et celui +# utlisé dans le python d'échange lance_aster_5 +# doivent correspondre. +# + Unite_Fichier_ASTER_vers_FIABILITE = 91 + Nom_Symbolique_Fichier_ASTER_vers_FIABILITE = "ASTER_vers_FIABILITE" + FORMAT_R="1PE17.10" +#____________________________________________________________________ +# +# 2. Définition d'un fichier d'échange +#____________________________________________________________________ +# + DEFI_FICHIER ( ACTION= "ASSOCIER", + FICHIER = Nom_Symbolique_Fichier_ASTER_vers_FIABILITE, + UNITE = Unite_Fichier_ASTER_vers_FIABILITE, + TYPE = "ASCII", + INFO = INFO ) +#____________________________________________________________________ +# +# 4. Ecriture de la valeur cible +#____________________________________________________________________ +# + IMPR_TABLE ( TABLE = TABLE_CIBLE, + NOM_PARA = NOM_PARA_CIBLE, + FICHIER = Nom_Symbolique_Fichier_ASTER_vers_FIABILITE, + FORMAT_R = FORMAT_R, + INFO = INFO ) +#____________________________________________________________________ +# +# 5. Ecritures des gradients +#____________________________________________________________________ +# + for val in GRADIENTS : +# + IMPR_TABLE ( TABLE = val["TABLE"], + NOM_PARA = ("PAR_SENS", val["NOM_PARA"]), + FICHIER = Nom_Symbolique_Fichier_ASTER_vers_FIABILITE, + FORMAT_R = FORMAT_R, + INFO = INFO ) +#____________________________________________________________________ +# +# 6. Libération du fichier d'échange +#____________________________________________________________________ +# + DEFI_FICHIER ( ACTION= "LIBERER", + UNITE = Unite_Fichier_ASTER_vers_FIABILITE, + INFO = INFO ) +# +#-------------------------------------------------------------------- +# 7. C'est fini ! +#-------------------------------------------------------------------- +# + return erreur diff --git a/Aster/Cata/Macro/macr_fiabilite_ops.py b/Aster/Cata/Macro/macr_fiabilite_ops.py new file mode 100644 index 00000000..b4590868 --- /dev/null +++ b/Aster/Cata/Macro/macr_fiabilite_ops.py @@ -0,0 +1,321 @@ +#@ MODIF macr_fiabilite_ops Macro DATE 16/01/2004 AUTEUR GNICOLAS G.NICOLAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS +# +def macr_fiabilite_ops(self, INFO, + LOGICIEL, VERSION, + UNITE_ESCL, MESS_ASTER, + SEUIL, SEUIL_TYPE, + VARIABLE, + **args ) : +# +# args est le dictionnaire des arguments optionnels +# args.keys() est la liste des mots-clés +# args.keys()[0] est la premiere valeur de cette liste +# args.keys()[1:] est la liste des valeurs suivantes dans cette liste +# args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante. +### print args +### print args.keys() +### if len (args.keys())>0 : print args.keys()[0] +# + """ Macro-commande réalisant le pilotage du logiciel de fiabilite. """ +# +# On charge les modules nécessaires + from Accas import _F + from Macro import fiabilite_mefisto + import aster + import os + import string + import sys + import Numeric +# +#____________________________________________________________________ +# +# 1. Préalables +#____________________________________________________________________ +# +# 1.1 ==> La macro compte pour 1 dans l'exécution des commandes +# + self.set_icmd(1) +# +# 1.2 ==> On importe les définitions des commandes Aster utilisées +# dans la macro +# + EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL") + DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL") +# +# 1.3 ==> Le nom du programme de fiabilite à lancer +# + repertoire_outils = aster.repout() + fiabilite = repertoire_outils + "fiabilite" +# +# 1.4 ==> Initialisations +# + erreur = 0 + erreur_partiel = [0] + Rep_Calc_ASTER = os.getcwd() + Nom_Exec_ASTER = sys.executable +# + messages_erreur = { 0 : "Tout va bien", + 1 : "Impossible de créer le répertoire de travail pour le logiciel de fiabilité.", + 2 : "Probleme d'ouverture du fichier.", + 10 : "Erreur dans le choix du logiciel de fiabilité.", + 11 : "Erreur dans la création des données pour le logiciel de fiabilité.", + 100 : "Erreur." } +# + while not erreur : +# +#____________________________________________________________________ +# +# 2. Répertoires et fichiers +#____________________________________________________________________ +# +# 2.1. ==> Création du répertoire pour l'exécution du logiciel de fiabilité +# + Nom_Rep_local = "tmp_fiabilite" + Rep_Calc_LOGICIEL_local = os.path.join(".",Nom_Rep_local) + Rep_Calc_LOGICIEL_global = os.path.join(Rep_Calc_ASTER,Nom_Rep_local) +# + try : + os.mkdir(Rep_Calc_LOGICIEL_global) + except os.error,erreur_partiel : + self.cr.warn("Code d'erreur de mkdir : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) + self.cr.fatal("Impossible de créer le répertoire de travail pour le logiciel de fiabilité : "+Rep_Calc_LOGICIEL_global) + erreur = erreur + 1 + break +# +# 2.2. ==> On crée un fichier annexe pour transmettre des données à la procédure +# de lancement des calculs ASTER par le LOGICIEL. +# Ce fichier est créé dans le répertoire d'exécution du logiciel de fiabilité. +# On fait ainsi car les arguments passés ont du mal à transiter via l'exécutable. +# On stocke : +# 1. Le niveau d'information +# 2. L'unité logique associée au jeu de commandes déterministes +# 3. La gestion des sorties ASTER +# 4. Le nom de l'exécutable ASTER +# 5. Le type de seuil du problème (maximum ou minimum) +# + fic_Info_ASTER = os.path.join(Rep_Calc_LOGICIEL_global,"InfoExecASTER") + try : + f_execAster = open(fic_Info_ASTER, "w") + except os.error,erreur_partiel : + self.cr.warn("Fichier : "+fic_Info_ASTER) + self.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) + erreur = 2 + break +# + f_execAster.write(str(INFO)+"\n") + f_execAster.write(str(UNITE_ESCL)+"\n") + f_execAster.write(str(MESS_ASTER)+"\n") + f_execAster.write(str(Nom_Exec_ASTER)+"\n") + f_execAster.write(str(SEUIL_TYPE)) + f_execAster.close() + fichier = open (fic_Info_ASTER,"r") +# + if INFO >= 2 : + print "\nContenu du fichier " + fic_Info_ASTER," :" + les_lignes = fichier.readlines() + fichier.close() + print les_lignes, "\n" +# +#____________________________________________________________________ +# +# 3. Les variables par defaut +#____________________________________________________________________ +# +# 3.1. ==> Dictionnaire des valeurs physiques et liées à la loi +# + valeurs_lois = { } +# + for m in VARIABLE : +# + v_moy_physique = None + v_moy_loi = None + v_min_loi = None + v_max_loi = None + sigma_loi = None +# +# 3.1.1. ==> loi uniforme : transfert des min et max +# on définit une moyennne comme étant la médiane des extremes. +# + if m["LOI"] == "UNIFORME" : + v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] ) + v_min_loi = m["VALE_MIN"] + v_max_loi = m["VALE_MAX"] +# +# 3.1.2. ==> loi normale : transfert des moyennne et écart-type. +# + elif m["LOI"] == "NORMALE" : + v_moy_loi = m["VALE_MOY"] + v_moy_physique = v_moy_loi + sigma_loi = m["ECART_TYPE"] +# +# 3.1.3. ==> loi lognormale : identité du min, conversion pour le reste +# + elif m["LOI"] == "LOGNORMALE" : + v_min_loi = m["VALE_MIN"] + if m["VALE_MOY_PHY"] is None : + v_moy_loi = m["VALE_MOY"] + sigma_loi = m["ECART_TYPE"] + aux = Numeric.exp(0.5*sigma_loi*sigma_loi+v_moy_loi) + v_moy_physique = v_min_loi + aux + else : + v_moy_physique = m["VALE_MOY_PHY"] + aux = m["ECART_TYPE_PHY"]/(m["VALE_MOY_PHY"]-m["VALE_MIN"]) + aux1 = 1. + aux*aux + aux2 = Numeric.sqrt(aux1) + v_moy_loi = Numeric.log((m["VALE_MOY_PHY"]-m["VALE_MIN"])/aux2) + aux2 = Numeric.log(aux1) + sigma_loi = Numeric.sqrt(aux2) +# +# 3.1.4. ==> loi normale tronquée : transfert des moyenne, mini/maxi et écart-type +# on définit une moyennne comme étant la médiane des extremes. +# + else : + v_moy_loi = m["VALE_MOY"] + v_min_loi = m["VALE_MIN"] + v_max_loi = m["VALE_MAX"] + sigma_loi = m["ECART_TYPE"] + v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] ) +# + d = { } + d["v_moy_physique"] = v_moy_physique + d["v_moy_loi"] = v_moy_loi + d["v_min_loi"] = v_min_loi + d["v_max_loi"] = v_max_loi + d["sigma_loi"] = sigma_loi + valeurs_lois[m] = d +# +#____________________________________________________________________ +# +# 4. Création des fichiers pour le logiciel de fiabilite +#____________________________________________________________________ +# + if ( LOGICIEL == "MEFISTO" ) : +# +# 4.1. ==> MEFISTO +# + erreur = fiabilite_mefisto.fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global, + INFO, VERSION, + SEUIL, SEUIL_TYPE, + VARIABLE, + valeurs_lois, + **args ) +# +# 4.2. ==> Erreur si autre logiciel +# + else : +# + self.cr.warn("Logiciel de fiabilité : "+LOGICIEL) + erreur = 10 +# +# 4.3. ==> Arret en cas d'erreur +# + if erreur : + break +# +#____________________________________________________________________ +# +# 5. Ecriture de la commande d"exécution du logiciel de fiabilité +# +# Remarque : dans la donnée de la version du logiciel de fiabilité, il faut remplacer +# le _ de la donnée par un ., qui +# est interdit dans la syntaxe du langage de commandes ASTER +# Remarque : il faut remplacer le N majuscule de la donnee par +# un n minuscule, qui est interdit dans la syntaxe du langage +# de commandes ASTER +#____________________________________________________________________ +# +# + VERSION=string.replace(VERSION,"_",".") + VERSION=string.replace(VERSION,"N","n") +# + EXEC_LOGICIEL ( ARGUMENT = (_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é + ), + LOGICIEL = fiabilite + ) +# +#-------------------------------------------------------------------- +# 6. C'est fini ! +#-------------------------------------------------------------------- +# + break +# +# 6.1. ==> Arret en cas d'erreur +# + if erreur : + if not messages_erreur.has_key(erreur) : + erreur = 100 + self.cr.fatal(messages_erreur[erreur]) +# +# 6.2. ==> Si tout va bien, on crée une liste de réels pour le retour +# A terme, il serait intéressant d'y mettre les résultats +# de l'analyse fiabiliste. Pour le moment, on se contente de +# mettre une valeur nulle qui permet de faire un test dans +# les commandes appelantes. +# + aux = [float(erreur)] +# + self.DeclareOut("nomres",self.sd) + nomres = DEFI_LIST_REEL( VALE = aux , INFO = 1 ) +# + return +# +########################## Fin de la fonction################################## +# +########################## Auto-test################################## +# +if __name__ == "__main__" : +# + import os + import sys + import tempfile +# + Rep_Calc_LOGICIEL_global = tempfile.mktemp() + os.mkdir(Rep_Calc_LOGICIEL_global) +# + classe = None + INFO = 2 + LOGICIEL = "MEFISTO" + VERSION = "V3_2" + UNITE_ESCL = 38 + MESS_ASTER = "DERNIER" + SEUIL = 1789. + SEUIL_TYPE = "MAXIMUM" + VARIABLE = [] + args = {} +# + lr8 = macr_fiabilite_ops(classe, INFO, + LOGICIEL, VERSION, + UNITE_ESCL, MESS_ASTER, + SEUIL, SEUIL_TYPE, + VARIABLE, + **args ) +### print "lr8 = ", lr8 + Liste = os.listdir(Rep_Calc_LOGICIEL_global) +# + for nomfic in Liste : + fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) + os.chmod (fic_total,0755) + os.remove (fic_total) + os.rmdir (Rep_Calc_LOGICIEL_global) +# + sys.exit("blabla") diff --git a/Aster/Cata/Macro/macr_recal_ops.py b/Aster/Cata/Macro/macr_recal_ops.py index f48536b5..c9671031 100644 --- a/Aster/Cata/Macro/macr_recal_ops.py +++ b/Aster/Cata/Macro/macr_recal_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_recal_ops Macro DATE 31/01/2003 AUTEUR PABHHHH N.TARDIEU +#@ MODIF macr_recal_ops Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -17,7 +17,7 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, LIST_PARA, RESU_CALC, +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, **args ): """Macro commande réalisant le recalage de modèles Aster""", @@ -28,7 +28,7 @@ def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, LIST_PARA, RESU_CALC, import Numeric except ImportError: ier=ier+1 - self.cr.fatal("Le module Numeric de Python n'a pu etre chargé") + self.cr.fatal(" Le module Numeric de Python n'a pu etre chargé") return ier # On essaie d'importer Gnuplot -> PAS DE GRAPHIQUE try: @@ -40,25 +40,33 @@ def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, LIST_PARA, RESU_CALC, import copy import types import Macro - import Cata from Cata import cata - from Macro.recal import gestion,transforme_list_Num,EXTRACT,calcul_F - from Macro.reca_message import * - from Macro.reca_algo import * - from Macro.reca_interp import * + from Cata.cata import DEFI_LIST_REEL + from Macro.recal import gestion,transforme_list_Num,EXTRACT,calcul_F,graphique + from Macro import reca_message + from Macro import reca_algo + from Macro import reca_interp # La macro compte pour 1 dans l'execution des commandes #self.icmd=1 self.set_icmd(1) self.DeclareOut('nomres',self.sd) + #_______________________________________________ + # + # 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,GRAPHIQUE,UNITE_RESU) + texte_erreur = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU) if (texte_erreur != ""): ier=ier+1 + texte_erreur=' '+texte_erreur self.cr.fatal(texte_erreur) return ier @@ -79,26 +87,26 @@ def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, LIST_PARA, RESU_CALC, #_____________________________________________ iter = 0 restant,temps_iter=0.,0. - restant,temps_iter,err=temps_CPU(self,restant,temps_iter) + 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) 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 = Message(para,RESU_EXP,copy.copy(val_init),UNITE_RESU) + 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 - Simul = Sim_exp(RESU_EXP) - Dim = Dimension(copy.copy(val_init),para) + 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 = lambda_init(Numeric.matrixmultiply(Numeric.transpose(A),A)) - gradient_init =calcul_gradient(A,erreur) #utile pour le test de convergence, on prend les valeurs dimensionnées - residu = test_convergence(gradient_init,erreur,A,Numeric.zeros(len(gradient_init),Numeric.Float)) + 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=temps_CPU(self,restant,temps_iter) + restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter) if (err==1): ier=ier+1 return ier @@ -110,17 +118,17 @@ def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, LIST_PARA, RESU_CALC, epsilon = 10.*RESI_GLOB_RELA while((residu > RESI_GLOB_RELA) & (iter On ne peut avoir a la fois NOM_CAS et MODE_FOURIER""") return ier if (numeddl in self.sdprods) or (numeddl==None): diff --git a/Aster/Cata/Macro/macro_matr_ajou_ops.py b/Aster/Cata/Macro/macro_matr_ajou_ops.py new file mode 100644 index 00000000..77c01004 --- /dev/null +++ b/Aster/Cata/Macro/macro_matr_ajou_ops.py @@ -0,0 +1,261 @@ +#@ MODIF macro_matr_ajou_ops Macro DATE 19/01/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. +# ====================================================================== +def macro_matr_ajou_ops(self,MAILLAGE,GROUP_MA_FLUIDE,GROUP_MA_INTERF,MODELISATION,MODE_MECA,DEPL_IMPO, + NUME_DDL_GENE,MODELE_GENE,MATR_MASS_AJOU,MATR_AMOR_AJOU,MATR_RIGI_AJOU, + NOEUD_DOUBLE,FLUIDE,DDL_IMPO,DIST_REFE,SOLVEUR,INFO,AVEC_MODE_STAT, + MODE_STAT,MONO_APPUI, + FORC_AJOU,ECOULEMENT,**args): + """ + Ecriture de la macro MACRO_MATR_AJOU + """ + from Accas import _F + import types + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + DEFI_MATERIAU =self.get_cmd('DEFI_MATERIAU') + AFFE_MATERIAU =self.get_cmd('AFFE_MATERIAU') + AFFE_MODELE =self.get_cmd('AFFE_MODELE') + AFFE_CHAR_THER =self.get_cmd('AFFE_CHAR_THER') + CALC_MATR_AJOU =self.get_cmd('CALC_MATR_AJOU') + THER_LINEAIRE =self.get_cmd('THER_LINEAIRE') + CALC_FORC_AJOU =self.get_cmd('CALC_FORC_AJOU') + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + if FLUIDE.__class__.__name__!='MCList' : + print ' tout le domaine fluide specifie dans GROUP_MA_INTERF et GROUP_MA_FLUIDE' + print ' sera affecte par la masse volumique RHO = ',FLUIDE['RHO'] + if FLUIDE['GROUP_MA']!=None : + print ' cas fluide simple : le group_ma dans lequel vous affectez la masse' + print 'volumique RHO doit etre la reunion de GROUP_MA_INTERF et GROUP_MA_FLUIDE.' + else : + for flu in FLUIDE : + if flu['GROUP_MA']==None : + self.cr.fatal(" cas fluides multiples : precisez le GROUP_MA dans lequel vous affectez la masse volumique RHO.") + ier=ier+1 + return ier + + if FLUIDE.__class__.__name__ !='MCList' : FLUIDE =[FLUIDE,] + IOCFLU=len(FLUIDE) + + if DDL_IMPO.__class__.__name__!='MCList' : DDL_IMPO=[DDL_IMPO,] + +# --------------------------------------------------------------- +# definition du materiau fluide par caracteristique +# thermique equivalente + +# CAS FLUIDE SIMPLE + if IOCFLU==1 : + __NOMMAT=DEFI_MATERIAU( THER = _F( LAMBDA = 1.0, + RHO_CP = FLUIDE[0]['RHO'])) + __NOMCMA=AFFE_MATERIAU( MAILLAGE = MAILLAGE, + AFFE = _F( GROUP_MA = (GROUP_MA_FLUIDE,GROUP_MA_INTERF), + MATER = __NOMMAT), ) + +# --------------------------------------------------------------- +# cas fluides multiples + else : + affmat=[] + for flu in FLUIDE: + __NOMMAT=DEFI_MATERIAU( THER = _F( LAMBDA = 1.0, + RHO_CP = flu['RHO'])) + mfact=_F(GROUP_MA=flu['GROUP_MA'],MATER=__NOMMAT) + affmat.append(mfact) + + __NOMCMA=AFFE_MATERIAU( MAILLAGE = MAILLAGE, + AFFE = affmat ) + +# --------------------------------------------------------------- +# commande AFFE_MODELE modele fluide + __NOMFLU=AFFE_MODELE( MAILLAGE = MAILLAGE, + AFFE = _F( GROUP_MA = (GROUP_MA_FLUIDE,GROUP_MA_INTERF), + MODELISATION = MODELISATION, + PHENOMENE = 'THERMIQUE' ), ) + +# --------------------------------------------------------------- +# commande AFFE_MODELE modele interface + __NOMINT=AFFE_MODELE( MAILLAGE = MAILLAGE, + AFFE = _F( GROUP_MA = GROUP_MA_INTERF, + MODELISATION = MODELISATION, + PHENOMENE = 'THERMIQUE' ), ) + +# --------------------------------------------------------------- +# commande AFFE_CHAR_THER condition de pression imposee +# en un point ou un groupe du fluide + affimp=[] + nflui=0 + for DDL in DDL_IMPO : + if DDL['PRES_FLUIDE']!=None : + nflui=nflui+1 + if DDL['NOEUD'] !=None : mfact=_F(NOEUD =DDL['NOEUD'], TEMP=DDL['PRES_FLUIDE']) + if DDL['GROUP_NO']!=None : mfact=_F(GROUP_NO=DDL['GROUP_NO'],TEMP=DDL['PRES_FLUIDE']) + affimp.append(mfact) + if nflui==0: + self.cr.fatal(" PRES_FLUIDE obligatoire une fois") + ier=ier+1 + return ier + + __CHARGE=AFFE_CHAR_THER( MODELE = __NOMFLU, + TEMP_IMPO = affimp ) + +# --------------------------------------------------------------- +# calcul des masses, rigidites et amortissements ajoutes en theorie +# potentielle +# commande CALC_MATR_AJOU, calcul de la masse ajoutee + + if MATR_MASS_AJOU!=None : + self.DeclareOut('MASSAJ',MATR_MASS_AJOU) + solveur=SOLVEUR.cree_dict_valeurs(SOLVEUR.mc_liste) + mostcles={} + if NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE + if INFO !=None : mostcles['INFO'] =INFO + if MODE_MECA !=None : mostcles['MODE_MECA'] =MODE_MECA + elif DEPL_IMPO !=None : mostcles['CHAM_NO'] =DEPL_IMPO + elif MODELE_GENE !=None : + mostcles['MODELE_GENE'] =MODELE_GENE + mostcles['AVEC_MODE_STAT']=AVEC_MODE_STAT + mostcles['DIST_REFE'] =DIST_REFE + if NOEUD_DOUBLE !=None : mostcles['NOEUD_DOUBLE'] =NOEUD_DOUBLE + + MASSAJ = CALC_MATR_AJOU(MODELE_FLUIDE = __NOMFLU, + MODELE_INTERFACE = __NOMINT, + CHARGE = __CHARGE, + CHAM_MATER = __NOMCMA, + OPTION = 'MASS_AJOU', + SOLVEUR = solveur, + **mostcles) + +# --------------------------------------------------------------- +# calcul de l amortissement ajoute + if (MATR_AMOR_AJOU!=None ) or (MATR_RIGI_AJOU!=None ): + +# --------------------------------------------------------------- +# on definit un nouveau modele fluide pour calculer +# le potentiel stationnaire - AFFE_MODELE + grma=[GROUP_MA_FLUIDE,] + if ECOULEMENT!=None : + grma.append(ECOULEMENT['GROUP_MA_1']) + grma.append(ECOULEMENT['GROUP_MA_2']) + __NOFLUI=AFFE_MODELE( MAILLAGE = MAILLAGE, + AFFE = _F( GROUP_MA = grma, + MODELISATION = MODELISATION, + PHENOMENE = 'THERMIQUE' ), ) + affimp=[] + for DDL in DDL_IMPO : + if DDL['PRES_SORTIE']!=None : + if DDL['NOEUD'] !=None : mfact=_F(NOEUD =DDL['NOEUD'], TEMP=DDL['PRES_SORTIE']) + if DDL['GROUP_NO']!=None : mfact=_F(GROUP_NO=DDL['GROUP_NO'],TEMP=DDL['PRES_SORTIE']) + affimp.append(mfact) + + affecl=[] + for ECL in ECOULEMENT : + mfact=_F(GROUP_MA=ECL['GROUP_MA_1'],FLUN=ECL['VNOR_1']) + affecl.append(mfact) + mfact=_F(GROUP_MA=ECL['GROUP_MA_2'],FLUN=ECL['VNOR_2']) + affecl.append(mfact) + __CHARG2=AFFE_CHAR_THER( MODELE = __NOFLUI, + TEMP_IMPO = affimp , + FLUX_REP = affecl ) + + __POTEN = THER_LINEAIRE( MODELE = __NOFLUI, + CHAM_MATER = __NOMCMA , + EXCIT = _F( CHARGE = __CHARG2 ) ) + +# --------------------------------------------------------------- +# calcul amortissement proprement dit + if MATR_AMOR_AJOU!=None : + self.DeclareOut('AMORAJ',MATR_AMOR_AJOU) + solveur=SOLVEUR.cree_dict_valeurs(SOLVEUR.mc_liste) + mostcles={} + if NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE + if INFO !=None : mostcles['INFO'] =INFO + if MODE_MECA !=None : mostcles['MODE_MECA'] =MODE_MECA + elif DEPL_IMPO !=None : mostcles['CHAM_NO'] =DEPL_IMPO + else : + self.cr.fatal(" amortissement ajoute sur modele generalise non encore implante") + ier=ier+1 + return ier + + AMORAJ = CALC_MATR_AJOU(MODELE_FLUIDE = __NOMFLU, + MODELE_INTERFACE = __NOMINT, + CHARGE = __CHARGE, + CHAM_MATER = __NOMCMA, + OPTION = 'AMOR_AJOU', + SOLVEUR = solveur, + POTENTIEL = __POTEN, + **mostcles) + +# --------------------------------------------------------------- +# calcul de la rigidite ajoutee + if MATR_RIGI_AJOU!=None : + self.DeclareOut('RIGIAJ',MATR_RIGI_AJOU) + solveur=SOLVEUR.cree_dict_valeurs(SOLVEUR.mc_liste) + mostcles={} + if NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE + if INFO !=None : mostcles['INFO'] =INFO + if MODE_MECA !=None : mostcles['MODE_MECA'] =MODE_MECA + elif DEPL_IMPO !=None : mostcles['CHAM_NO'] =DEPL_IMPO + else : + self.cr.fatal(" rigidite ajoutee sur modele generalise non encore implante") + ier=ier+1 + return ier + + RIGIAJ = CALC_MATR_AJOU(MODELE_FLUIDE = __NOMFLU, + MODELE_INTERFACE = __NOMINT, + CHARGE = __CHARGE, + CHAM_MATER = __NOMCMA, + OPTION = 'RIGI_AJOU', + SOLVEUR = solveur, + POTENTIEL = __POTEN, + **mostcles) + +# --------------------------------------------------------------- +# boucle sur le nombre de vecteurs a projeter, commande CALC_FORC_AJOU + if FORC_AJOU!=None : + if FORC_AJOU.__class__.__name__!='MCList' : FORC_AJOU=[FORC_AJOU,] + for FORCAJ in FORC_AJOU: + self.DeclareOut('VECTAJ',FORCAJ['VECTEUR']) + solveur=SOLVEUR.cree_dict_valeurs(SOLVEUR.mc_liste) + mostcles={} + if NUME_DDL_GENE!=None : mostcles['NUME_DDL_GENE'] =NUME_DDL_GENE + if MODE_MECA !=None : mostcles['MODE_MECA'] =MODE_MECA + elif MODELE_GENE !=None : + mostcles['MODELE_GENE'] =MODELE_GENE + mostcles['AVEC_MODE_STAT']=AVEC_MODE_STAT + mostcles['DIST_REFE'] =DIST_REFE + if NOEUD_DOUBLE !=None : mostcles['NOEUD_DOUBLE'] =NOEUD_DOUBLE + if MODE_STAT !=None : + mostcles['MODE_STAT'] =MODE_STAT + if FORCAJ['NOEUD'] !=None : mostcles['NOEUD'] =FORCAJ['NOEUD'] + if FORCAJ['GROUP_NO'] !=None : mostcles['GROUP_NO'] =FORCAJ['GROUP_NO'] + else : + mostcles['MONO_APPUI'] =MONO_APPUI + + VECTAJ = CALC_FORC_AJOU(DIRECTION = FORCAJ['DIRECTION'], + MODELE_FLUIDE = __NOMFLU, + MODELE_INTERFACE = __NOMINT, + CHARGE = __CHARGE, + CHAM_MATER = __NOMCMA, + SOLVEUR = solveur, + **mostcles) + + + return ier diff --git a/Aster/Cata/Macro/macro_matr_asse_ops.py b/Aster/Cata/Macro/macro_matr_asse_ops.py index ee530505..6c455830 100644 --- a/Aster/Cata/Macro/macro_matr_asse_ops.py +++ b/Aster/Cata/Macro/macro_matr_asse_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_matr_asse_ops Macro DATE 20/01/2003 AUTEUR DURAND C.DURAND +#@ MODIF macro_matr_asse_ops Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -44,7 +44,7 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, renum='RCMK' if renum not in ('SANS','RCMK'): ier=ier+1 - self.cr.fatal("Avec methode LDLT, RENUM doit etre SANS ou RCMK.") + self.cr.fatal(" Avec methode LDLT, RENUM doit etre SANS ou RCMK.") return ier elif methode=='MULT_FRONT': if SOLVEUR['RENUM']: @@ -53,7 +53,7 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, renum='MDA' if renum not in ('MDA','MD','METIS'): ier=ier+1 - self.cr.fatal("Avec methode MULT_FRONT, RENUM doit etre MDA, MD ou RCMK.") + self.cr.fatal(" Avec methode MULT_FRONT, RENUM doit etre MDA, MD ou RCMK.") return ier elif methode=='GCPC': if SOLVEUR['RENUM']: @@ -62,7 +62,7 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, renum='SANS' if renum not in ('SANS','RCMK'): ier=ier+1 - self.cr.fatal("Avec methode GCPC, RENUM doit etre SANS ou RCMK.") + self.cr.fatal(" Avec methode GCPC, RENUM doit etre SANS ou RCMK.") return ier else: methode='MULT_FRONT' @@ -97,29 +97,29 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, if iocc == 1 and lnume == 1 and option not in ('RIGI_MECA','RIGI_MECA_LAGR', 'RIGI_THER','RIGI_ACOU') : ier=ier+1 - self.cr.fatal("UNE DES OPTIONS DOIT ETRE RIGI_MECA OU RIGI_THER OU RIGI_ACOU OU RIGI_MECA_LAGR") + self.cr.fatal(" UNE DES OPTIONS DOIT ETRE RIGI_MECA OU RIGI_THER OU RIGI_ACOU OU RIGI_MECA_LAGR") return ier if m['SIEF_ELGA']!=None and option!='RIGI_GEOM': ier=ier+1 - self.cr.fatal("SIEF_ELGA N EST ADMIS QU AVEC L OPTION RIGI_GEOM") + self.cr.fatal(" SIEF_ELGA N EST ADMIS QU AVEC L OPTION RIGI_GEOM") return ier if m['MODE_FOURIER']!=None and option not in ('RIGI_MECA','RIGI_FLUI_STRU','RIGI_THER'): ier=ier+1 - self.cr.fatal("MODE_FOURIER N EST ADMIS QU AVEC UNE DES OPTIONS RIGI_MECA RIGI_FLUI_STRU RIGI_THER") + self.cr.fatal(" MODE_FOURIER N EST ADMIS QU AVEC UNE DES OPTIONS RIGI_MECA RIGI_FLUI_STRU RIGI_THER") return ier if (m['THETA']!=None or m['PROPAGATION']!=None) and option!='RIGI_MECA_LAGR': ier=ier+1 - self.cr.fatal("PROPAGATION ET,OU THETA NE SONT ADMIS QU AVEC L OPTION RIGI_MECA_LAGR") + self.cr.fatal(" PROPAGATION ET,OU THETA NE SONT ADMIS QU AVEC L OPTION RIGI_MECA_LAGR") return ier motscles={'OPTION':option} if option == 'AMOR_MECA': if (not lrigel or not lmasel): ier=ier+1 - self.cr.fatal("""POUR CALCULER AMOR_MECA, IL FAUT AVOIR CALCULE + self.cr.fatal(""" POUR CALCULER AMOR_MECA, IL FAUT AVOIR CALCULE RIGI_MECA ET MASS_MECA AUPARAVANT (DANS LE MEME APPEL)""") return ier if CHAM_MATER != None: @@ -155,27 +155,3 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, self.DeclareOut('mm',m['MATRICE']) mm=ASSE_MATRICE(MATR_ELEM=__a,NUME_DDL=num) return ier - - -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") - self.type_sdprod(NUME_DDL,nume_ddl) - 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 - diff --git a/Aster/Cata/Macro/macro_miss_3d_ops.py b/Aster/Cata/Macro/macro_miss_3d_ops.py index 55b83d9e..86ec4963 100644 --- a/Aster/Cata/Macro/macro_miss_3d_ops.py +++ b/Aster/Cata/Macro/macro_miss_3d_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_miss_3d_ops Macro DATE 29/09/2003 AUTEUR ACBHHCD G.DEVESA +#@ MODIF macro_miss_3d_ops Macro DATE 04/11/2003 AUTEUR ACBHHCD G.DEVESA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -29,13 +29,13 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, ier=0 # On importe les definitions des commandes a utiliser dans la macro # Le nom de la variable doit etre obligatoirement le nom de la commande - FERMER =self.get_cmd('FERMER') + DEFI_FICHIER =self.get_cmd('DEFI_FICHIER') EXEC_LOGICIEL =self.get_cmd('EXEC_LOGICIEL') # La macro compte pour 1 dans la numerotation des commandes #self.icmd=1 self.set_icmd(1) - FERMER(UNITE=UNITE_IMPR_ASTER) + DEFI_FICHIER(ACTION='LIBERER',UNITE=UNITE_IMPR_ASTER) import aster loc_fic=aster.repout() diff --git a/Aster/Cata/Macro/macro_proj_base_ops.py b/Aster/Cata/Macro/macro_proj_base_ops.py index 999a2cf3..19f91127 100644 --- a/Aster/Cata/Macro/macro_proj_base_ops.py +++ b/Aster/Cata/Macro/macro_proj_base_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_proj_base_ops Macro DATE 11/03/2003 AUTEUR DURAND C.DURAND +#@ MODIF macro_proj_base_ops Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -38,7 +38,7 @@ def macro_proj_base_ops(self,BASE,NB_VECT,MATR_ASSE_GENE,VECT_ASSE_GENE,PROFIL,* elif m['MATR_ASSE_GENE']: motscles['MATR_ASSE_GENE']=m['MATR_ASSE_GENE'] else: ier=ier+1 - self.cr.fatal("MATR_ASSE et MATR_ASSE_GENE absents") + self.cr.fatal(" MATR_ASSE et MATR_ASSE_GENE absents") return ier self.DeclareOut('mm',m['MATRICE']) mm=PROJ_MATR_BASE(BASE=BASE,NUME_DDL_GENE=_num,**motscles) @@ -51,7 +51,7 @@ def macro_proj_base_ops(self,BASE,NB_VECT,MATR_ASSE_GENE,VECT_ASSE_GENE,PROFIL,* elif v['VECT_ASSE_GENE']: motscles['VECT_ASSE_GENE']=v['VECT_ASSE_GENE'] else: ier=ier+1 - self.cr.fatal("MATR_ASSE et MATR_ASSE_GENE absents") + self.cr.fatal(" MATR_ASSE et MATR_ASSE_GENE absents") return ier motscles['TYPE_VECT']=v['TYPE_VECT'] self.DeclareOut('vv',v['VECTEUR']) diff --git a/Aster/Cata/Macro/reca_algo.py b/Aster/Cata/Macro/reca_algo.py index cfa75007..f0f767fb 100644 --- a/Aster/Cata/Macro/reca_algo.py +++ b/Aster/Cata/Macro/reca_algo.py @@ -1,4 +1,4 @@ -#@ MODIF reca_algo Macro DATE 04/07/2003 AUTEUR DURAND C.DURAND +#@ MODIF reca_algo Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -129,7 +129,7 @@ def temps_CPU(self,restant_old,temps_iter_old): temps_iter=(temps_iter_old + (restant_old-restant))/2. if ((temps_iter>0.96*restant)or(restant<0.)): err=1 - self.cr.fatal("Arret de MACR_RECAL par manque de temps CPU") + self.cr.fatal(" Arret de MACR_RECAL par manque de temps CPU") return restant,temps_iter,err @@ -200,7 +200,7 @@ 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=',')) - self.cr.fatal("Erreur dans l'algorithme de bornes de MACR_RECAL") + self.cr.fatal(" Erreur dans l'algorithme de bornes de MACR_RECAL") return newval=copy.copy(val+dval) return newval,s,l,Act diff --git a/Aster/Cata/Macro/reca_interp.py b/Aster/Cata/Macro/reca_interp.py index 48aac07e..61233e11 100644 --- a/Aster/Cata/Macro/reca_interp.py +++ b/Aster/Cata/Macro/reca_interp.py @@ -1,4 +1,4 @@ -#@ MODIF reca_interp Macro DATE 13/01/2003 AUTEUR PABHHHH N.TARDIEU +#@ MODIF reca_interp Macro DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -20,7 +20,7 @@ import os import Numeric import Macro -from Macro.recal import * +from Macro.recal import calcul_F #=========================================================================================== # INTERPOLATION, CALCUL DE SENSIBILITE, ETC.... @@ -28,8 +28,9 @@ from Macro.recal import * #-------------------------------------- class Sim_exp : - def __init__ (self,result_exp) : + def __init__ (self,result_exp,poids) : self.resu_exp = result_exp + self.poids = poids # Distance verticale d'un point M à une ligne brisée composée de n points @@ -53,7 +54,7 @@ class Sim_exp : # La Fonction Interpole ,interpole une et une seule F_calc sur F_exp et renvoie l'erreur seulement - def Interpole (self, F_calc,experience) : #ici on passe en argument "une" experience + def Interpole (self, F_calc,experience,poids) : #ici on passe en argument "une" experience n = 0 resu_num = F_calc n_exp = len(experience) # nombre de points sur la courbe expérimentale num.i @@ -67,14 +68,14 @@ class Sim_exp : n = n + 1 # on totalise le nombre de points valables err = Numeric.ones(n, Numeric.Float) for i in xrange(n) : - err[i] = stockage[i] + 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 L_erreur=[] for i in range(len(reponses)): - err = self.Interpole(L_F[i],self.resu_exp[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 dim=[] @@ -97,7 +98,7 @@ class Sim_exp : def multi_interpole_sensib(self,L_F,reponses): L_erreur=[] for i in range(len(reponses)): - err = self.Interpole(L_F[i],self.resu_exp[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 return L_erreur @@ -121,7 +122,7 @@ class Sim_exp : fic.write('\n Problème de division par zéro dans la normalisation de la fonctionnelle.') fic.write('\n Une des valeurs de la fonctionnelle initiale est nulle ou inférieure à la précision machine :'+ str(L_J_init)) fic.close() - self.cr.fatal("Problème de division par zéro dans la normalisation de la fonctionnelle.\nUne des valeurs de la fonctionnelle initiale est nulle ou inférieure à la précision machine :"+ str(L_J_init)) + self.cr.fatal(" Problème de division par zéro dans la normalisation de la fonctionnelle.\nUne des valeurs de la fonctionnelle initiale est nulle ou inférieure à la précision machine :"+ str(L_J_init)) return J = Numeric.sum(L_J) @@ -155,7 +156,7 @@ class Sim_exp : 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() - self.cr.fatal("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") + self.cr.fatal(" 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 construit la matrice de sensiblité sous forme d'un tab num dim =[] diff --git a/Aster/Cata/Macro/recal.py b/Aster/Cata/Macro/recal.py index 5129d34b..d092d302 100644 --- a/Aster/Cata/Macro/recal.py +++ b/Aster/Cata/Macro/recal.py @@ -1,4 +1,4 @@ -#@ MODIF recal Macro DATE 10/07/2003 AUTEUR DURAND C.DURAND +#@ MODIF recal Macro DATE 13/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -24,7 +24,7 @@ import Numeric import types import Gnuplot import Cata -from Cata.cata import * +from Cata.cata import INCLUDE,DETRUIRE from Accas import _F import os @@ -101,10 +101,7 @@ def calcul_F(self,UL,para,val,reponses): index_fin = string.index(fichier,'FIN(') #on restreind fichier en enlevant 'FIN();' fichier = fichier[:index_fin] - except : - #on va dans l'except si on a modifié le fichier au moins une fois - index_retour = string.index(fichier,'RETOUR') - fichier=fichier[:index_retour] + except : pass #-------------------------------------------------------------------------------- #on cherche à délimiter le bloc des parametres dans le fichier #Tout d'abord on cherche les indices d'apparition des paras dans le fichier @@ -158,8 +155,6 @@ def calcul_F(self,UL,para,val,reponses): for i in range(len(reponses)): Fichier_Resu.append('F = EXTRACT('+str(reponses[i][0])+','+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n') Fichier_Resu.append('Lrep.append(F)'+'\n') - #on ajoute à RETOUR - Fichier_Resu.append('RETOUR();\n') #ouverture du fichier fort.3 et mise a jour de celui ci x=open('fort.'+str(UL),'w') @@ -289,6 +284,14 @@ 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 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 @@ -348,7 +351,7 @@ def verif_UNITE(GRAPHIQUE,UNITE_RESU): -def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,GRAPHIQUE,UNITE_RESU): +def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU): #Cette methode va utiliser les methodes de cette classe declarée ci_dessus #test est un boolean: test=0 -> pas d'erreur # test=1 -> erreur détectée @@ -377,6 +380,8 @@ def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,GRAPHIQUE,UNITE_RESU): #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 diff --git a/Aster/Cata/cata_STA7.py b/Aster/Cata/cata_STA7.py index 1fa56710..6f325de9 100755 --- a/Aster/Cata/cata_STA7.py +++ b/Aster/Cata/cata_STA7.py @@ -1,4 +1,4 @@ -#& MODIF ENTETE DATE 26/09/2003 AUTEUR DURAND C.DURAND +#& MODIF ENTETE DATE 02/12/2003 AUTEUR PBADEL P.BADEL # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -20,6 +20,7 @@ import Accas from Accas import * from Accas import _F import string +import Numeric import ops @@ -30,7 +31,7 @@ except: # __version__="$Name: $" -__Id__="$Id: cata_STA7.py,v 1.3.2.1 2003/10/15 15:11:51 eficas Exp $" +__Id__="$Id: cata_aster_v6.py,v 1.12 2001/01/16 15:55:05 iliade Exp $" # JdC = JDC_CATA(code='ASTER', execmodul=None, @@ -95,6 +96,19 @@ class listr8 (ASSD): return list(aster.getvectjev(vale)) +# post-traitement : +#-------------------------------- +class post_comp_cham_el : + def __init__(self,valeurs,maille=None,point=None,sous_point=None) : + self.valeurs=valeurs + self.maille=maille + self.point=point + self.sous_point=sous_point + +class post_comp_cham_no : + def __init__(self,valeurs,noeud=None) : + self.valeurs=valeurs + self.noeud=noeud # maillage : #-------------------------------- @@ -148,7 +162,43 @@ class carte_vnor_c (carte):pass # cham_gd/cham_elem : #-------------------------------- -class cham_elem(cham_gd):pass +class cham_elem(cham_gd): + + def EXTR_COMP(self,comp,lgma,topo=0) : + """ retourne les valeurs de la composante comp du champ sur la liste + de groupes de mailles lgma avec eventuellement l'info de la + topologie si topo>0. Si lgma est une liste vide, c'est equivalent + a un TOUT='OUI' dans les commandes aster + Attributs retourne + - self.valeurs : Numeric.array contenant les valeurs + Si on a demande la topo : + - self.maille : numero de mailles + - self.point : numero du point dans la maille + - self.sous_point : numero du sous point dans la maille """ + + + ncham=self.get_name() + ncham=ncham+(8-len(ncham))*' ' + nchams=ncham[0:7]+'S' + ncmp=comp+(8-len(comp))*' ' + + aster.prepcompcham(ncham,nchams,ncmp,"EL ",topo,lgma) + + valeurs=Numeric.array(aster.getvectjev(nchams+(19-len(ncham))*' '+'.V')) + + if (topo>0) : + maille=(aster.getvectjev(nchams+(19-len(ncham))*' '+'.M')) + point=(aster.getvectjev(nchams+(19-len(ncham))*' '+'.P')) + sous_point=(aster.getvectjev(nchams+(19-len(ncham))*' '+'.SP')) + else : + maille=None + point=None + sous_point=None + + aster.prepcompcham("__DETR__",nchams,ncmp,"EL ",topo,lgma) + + return post_comp_cham_el(valeurs,maille,point,sous_point) + class cham_elem_crit_r(cham_elem):pass class cham_elem_dbel_r(cham_elem):pass class cham_elem_depl_c(cham_elem):pass @@ -183,7 +233,37 @@ class cham_elem_vnor_c(cham_elem):pass # cham_gd/cham_no : #-------------------------------- -class cham_no(cham_gd):pass +class cham_no(cham_gd): + + def EXTR_COMP(self,comp,lgno,topo=0) : + """ retourne les valeurs de la composante comp du champ sur la liste + de groupes de noeuds lgno avec eventuellement l'info de la + topologie si topo>0. Si lgno est une liste vide, c'est equivalent + a un TOUT='OUI' dans les commandes aster + Attributs retourne + - self.valeurs : Numeric.array contenant les valeurs + Si on a demande la topo (i.e. self.topo = 1) : + - self.noeud : numero de noeud """ + + + ncham=self.get_name() + ncham=ncham+(8-len(ncham))*' ' + nchams=ncham[0:7]+'S' + ncmp=comp+(8-len(comp))*' ' + + aster.prepcompcham(ncham,nchams,ncmp,"NO ",topo,lgno) + + valeurs=Numeric.array(aster.getvectjev(nchams+(19-len(ncham))*' '+'.V')) + + if (topo>0) : + noeud=(aster.getvectjev(nchams+(19-len(ncham))*' '+'.N')) + else : + noeud=None + + aster.prepcompcham("__DETR__",nchams,ncmp,"NO ",topo,lgno) + + return post_comp_cham_no(valeurs,noeud) + class cham_no_dbel_r (cham_no):pass class cham_no_depl_c (cham_no):pass class cham_no_depl_f (cham_no):pass @@ -380,7 +460,7 @@ class vect_elem_pres_r(vect_elem):pass class vect_elem_temp_r(vect_elem):pass -#& MODIF COMMUN DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMUN DATE 08/12/2003 AUTEUR GRANET S.GRANET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -454,6 +534,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "NORTON_HOFF", "LEMAITRE", "ZIRC_CYRA2", + "VISC_IRRA_LOG", "ZIRC_EPRI", "ASSE_COMBU", "VENDOCHAB", @@ -469,6 +550,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "CJS", "CAM_CLAY", "LAIGLE", + "DRUCKER_PRAGER", "OHNO", "GRANGER_FP", "GRANGER_FP_V", @@ -487,6 +569,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "SURF_ETAT_SATU", "CAM_CLAY_THM", "KIT_DDI", + "GLRC", "SANS", ) ), ELAS =SIMP(statut='c',typ='I',defaut=1,into=(1,)), @@ -545,6 +628,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# LEMAITRE =SIMP(statut='c',typ='I',defaut=2,into=(2,)), ZIRC_CYRA2 =SIMP(statut='c',typ='I',defaut=2,into=(2,)), ZIRC_EPRI =SIMP(statut='c',typ='I',defaut=2,into=(2,)), + VISC_IRRA_LOG =SIMP(statut='c',typ='I',defaut=2,into=(2,)), ASSE_COMBU =SIMP(statut='c',typ='I',defaut=5,into=(5,)), NADAI_B =SIMP(statut='c',typ='I',defaut=34,into=(34,)), VENDOCHAB =SIMP(statut='c',typ='I',defaut=10,into=(10,)), @@ -559,6 +643,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# CJS =SIMP(statut='c',typ='I',defaut=16,into=(16,)), CAM_CLAY =SIMP(statut='c',typ='I',defaut=2,into=(2,)), LAIGLE =SIMP(statut='c',typ='I',defaut=4,into=(4,)), + DRUCKER_PRAGER =SIMP(statut='c',typ='I',defaut=3,into=(3,)), OHNO =SIMP(statut='c',typ='I',defaut=32,into=(32,)), GRANGER_FP =SIMP(statut='c',typ='I',defaut=55,into=(55,)), GRANGER_FP_V =SIMP(statut='c',typ='I',defaut=55,into=(55,)), @@ -571,7 +656,8 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# KIT_THM =SIMP(statut='c',typ='I',defaut=0,into=(0,)), 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=20,into=(20,)), + BETON_UMLV_FP =SIMP(statut='c',typ='I',defaut=21,into=(21,)), + GLRC =SIMP(statut='c',typ='I',defaut=7,into=(7,)), RELATION_KIT =SIMP(statut='f',typ='TXM',max='**',validators=NoRepeat(), into=( @@ -580,6 +666,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "CJS", "CAM_CLAY", "LAIGLE", + "DRUCKER_PRAGER", "ELAS_THM", "SURF_ETAT_NSAT", "SURF_ETAT_SATU", @@ -592,6 +679,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "LIQU_SATU_GAT", "LIQU_GAZ_ATM", "LIQU_VAPE_GAZ", + "LIQU_AD_GAZ_VAPE", "LIQU_VAPE", "LIQU_NSAT_GAT", "LIQU_GAZ", @@ -629,6 +717,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# LIQU_SATU_GAT =SIMP(statut='c',typ='I',defaut=2,into=(2,)), LIQU_GAZ_ATM =SIMP(statut='c',typ='I',defaut=3,into=(3,)), LIQU_VAPE_GAZ =SIMP(statut='c',typ='I',defaut=4,into=(4,)), + LIQU_AD_GAZ_VAPE=SIMP(statut='c',typ='I',defaut=4,into=(4,)), LIQU_VAPE =SIMP(statut='c',typ='I',defaut=4,into=(4,)), LIQU_NSAT_GAT =SIMP(statut='c',typ='I',defaut=3,into=(3,)), LIQU_GAZ =SIMP(statut='c',typ='I',defaut=3,into=(3,)), @@ -826,7 +915,7 @@ def C_NOM_CHAM_INTO() : return ("ACCE", #COMMUN# "VITE_VENT", ) -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 04/11/2003 AUTEUR ACBHHCD G.DEVESA # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -1058,7 +1147,14 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, NOEUD_CENTRE =SIMP(statut='f',typ=no), COOR_CENTRE =SIMP(statut='f',typ='R',max='**'), ), - + + RIGI_MISS_3D =FACT(statut='f',max='**', + GROUP_MA_POI1 =SIMP(statut='o',typ=ma,max=1), + GROUP_MA_SEG2 =SIMP(statut='f',typ=ma,max=1), + FREQ_EXTR =SIMP(statut='o',typ='R',max=1), + UNITE_RESU_IMPE =SIMP(statut='f',typ='I',defaut=30), + ), + ASSE_GRIL =FACT(statut='f',max='**', regles=(UN_PARMI('MAILLE','GROUP_MA'),), MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), @@ -1299,7 +1395,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 29/09/2003 AUTEUR CIBHHPD D.NUNEZ +#& MODIF COMMANDE DATE 18/11/2003 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -1332,7 +1428,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca 'LIAISON_SOLIDE','LIAISON_ELEM','ONDE_FLUI','PRES_CALCULEE', 'EPSA_CALCULEE','LIAISON_CHAMNO','VECT_ASSE','LIAISON_COQUE', 'LIAISON_MAIL','FORCE_TUYAU','SECH_CALCULEE','HYDR_CALCULEE', - 'EFFE_FOND','EVOL_CHAR','ARLEQUIN','DDL_POUTRE'), + 'EFFE_FOND','EVOL_CHAR','ARLEQUIN','DDL_POUTRE','GRAPPE_FLUIDE'), EXCLUS('PRES_CALCULEE','EVOL_CHAR'),), VERI_DDL =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), VERI_NORM =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ), @@ -1599,7 +1695,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca VECT_ASSE =SIMP(statut='f',typ=cham_no_depl_r ), CONTACT =FACT(statut='f',fr="Imposer du contact avec ou sans frottement",max='**', - regles=(UN_PARMI('GROUP_MA_2','MAILLE_2'),), + regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),), APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", into=("NON","NODAL","NODAL_SYME","MAIT_ESCL","MAIT_ESCL_SYME")), RECHERCHE =SIMP(statut='f',typ='TXM',defaut="NOEUD_VOISIN",into=("NOEUD_BOUCLE","NOEUD_VOISIN")), @@ -1608,10 +1704,11 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca METHODE =SIMP(statut='f',typ='TXM',defaut="CONTRAINTE", into=("CONTRAINTE","LAGRANGIEN","PENALISATION","CONTINUE") ), PROJECTION =SIMP(statut='f',typ='TXM',defaut="LINEAIRE",into=("LINEAIRE","QUADRATIQUE") ), - GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE_1 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_MA_2 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE_2 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_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='**'), + TOLE_PROJ =SIMP(statut='f',typ='R',defaut=0.25), b_active =BLOC(condition = "METHODE == 'CONTRAINTE' ", fr="Paramètres de la méthode des contraintes actives (contact uniquement)", regles=(EXCLUS('DIST_2','COEF_IMPO'), @@ -1885,6 +1982,67 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca ), + GRAPPE_FLUIDE =FACT(statut='f',max='**', + regles=(EXCLUS('GROUP_NO_EXTR','NOEUD_EXTR'), + EXCLUS('GROUP_NO_ORIG','NOEUD_ORIG'), + PRESENT_PRESENT('CARA_HYDR','VALE_HYDR'), + PRESENT_PRESENT('CARA_GRAPPE','VALE_GRAPPE'), + PRESENT_PRESENT('CARA_COMMANDE','VALE_COMMANDE'), + PRESENT_PRESENT('CARA_MANCHETTE','VALE_MANCHETTE'), + PRESENT_PRESENT('CARA_GUIDE','VALE_GUIDE'), + PRESENT_PRESENT('CARA_ASSEMBLAGE','VALE_ASSEMBLAGE'), + PRESENT_PRESENT('CARA_PDC','VALE_PDC'),), + GROUP_MA =SIMP(statut='f',typ=grma,max=1), + GROUP_NO_EXTR =SIMP(statut='f',typ=grno,max=1), + NOEUD_EXTR =SIMP(statut='f',typ=no,max=1), + GROUP_NO_ORIG =SIMP(statut='f',typ=grno,max=1), + NOEUD_ORIG =SIMP(statut='f',typ=no,max=1), + Z0 =SIMP(statut='f',typ='R' ), + CARA_HYDR =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', + fr="définition des données hydrauliques", + into=("Q","ROC","ROD","ROP","ROM","ROML","ROG","NUC","NUM", + "NUML","NUG","P2","P3","P4","CGG","G") ), + VALE_HYDR =SIMP(statut='f',typ='R',max='**', + fr="valeurs des données hydrauliques",), + CARA_GRAPPE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', + fr="définition des données géométriques de la grappe", + into=("M","DTIGE","DTMOY","ROTIGE","LTIGE","LLT","LCT", + "VARAI","RORAI","DCRAY","ROCRAY","LCRAY","LCHUT", + "CFCM","CFCI","CFCG","HRUGC","HRUGTC","NCA") ), + VALE_GRAPPE =SIMP(statut='f',typ='R',max='**', + fr="valeurs des données géométriques de la grappe",), + CARA_COMMANDE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', + fr="définition des données géométriques du mécanisme de commande", + into=("LI","LML","LG","LIG","DIML","DEML","DCSP", + "DG","HRUGML","HRUGCSP","HRUGG") ), + VALE_COMMANDE =SIMP(statut='f',typ='R',max='**', + fr="valeurs des données géométriques du mécanisme de commande",), + CARA_MANCHETTE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', + fr="définition des données géométriques de la manchette et son adaptateur", + into=("LM","LA","LIM","DIMT","DEMT","DCMT","VMT", + "ROMT","DA","HRUGM","HRUGA") ), + VALE_MANCHETTE =SIMP(statut='f',typ='R',max='**', + fr="valeurs des données géométriques de la manchette et son adaptateur",), + CARA_GUIDE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', + fr="définition des données géométriques des tubes guides", + into=("NRET","L0","L1","L2","L3","L4","DTG","DR", + "DOR","D0","D00","HRUGTG") ), + VALE_GUIDE =SIMP(statut='f',typ='R',max='**', + fr="valeurs des données géométriques des tubes guides",), + CARA_ASSEMBLAGE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', + fr="définition des données géométriques des assemblages", + into=("SASS","DCC","DTI","NGM","NGMDP","KM","KS","KI", + "KES","KEI","KF") ), + VALE_ASSEMBLAGE =SIMP(statut='f',typ='R',max='**', + fr="valeurs des données géométriques des assemblages",), + CARA_PDC =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**', + fr="définition des coefficients de perte de charge singulière", + into=("CD0","CD1","CD2","CDELARG","CDRET","CDM","CDA","CDML", + "CDI","CDG") ), + VALE_PDC =SIMP(statut='f',typ='R',max='**', + fr="valeurs des coefficients de perte de charge singulière",), + ), + LIAISON_COQUE =FACT(statut='f',max='**', GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), MAILLE_1 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), @@ -2071,7 +2229,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 29/09/2003 AUTEUR CIBHHPD D.NUNEZ +#& MODIF COMMANDE DATE 18/11/2003 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -2222,7 +2380,7 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, ), CONTACT =FACT(statut='f',fr="Imposer du contact avec ou sans frottement",max='**', - regles=(UN_PARMI('GROUP_MA_2','MAILLE_2'),), + regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),), APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL", into=("NON","NODAL","NODAL_SYME","MAIT_ESCL","MAIT_ESCL_SYME")), RECHERCHE =SIMP(statut='f',typ='TXM',defaut="NOEUD_VOISIN",into=("NOEUD_BOUCLE","NOEUD_VOISIN")), @@ -2231,10 +2389,11 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, METHODE =SIMP(statut='f',typ='TXM',defaut="CONTRAINTE", into=("CONTRAINTE","LAGRANGIEN","PENALISATION","CONTINUE") ), PROJECTION =SIMP(statut='f',typ='TXM',defaut="LINEAIRE",into=("LINEAIRE","QUADRATIQUE") ), - GROUP_MA_1 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE_1 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), - GROUP_MA_2 =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - MAILLE_2 =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), + GROUP_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='**'), + TOLE_PROJ =SIMP(statut='f',typ='R',defaut=0.25), b_active =BLOC(condition = "METHODE == 'CONTRAINTE' ", fr="Paramètres de la méthode des contraintes actives (contact uniquement)", regles=(EXCLUS('DIST_2','COEF_IMPO'), @@ -3020,7 +3179,7 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, ), ) ; -#& MODIF COMMANDE DATE 29/09/2003 AUTEUR JMBHH01 J.M.PROIX +#& MODIF COMMANDE DATE 08/12/2003 AUTEUR GRANET S.GRANET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -3079,6 +3238,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele,docu="U4.41.01-g", "3D_HM", "3D_INCO", "3D_JOINT_CT", + "3D_NS", "3D_SI", "3D_THH", "3D_THHM", @@ -3094,6 +3254,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele,docu="U4.41.01-g", "AXIS_HHM", "AXIS_HM", "AXIS_INCO", + "AXIS_NS", "AXIS_SI", "AXIS_THH", "AXIS_THHM", @@ -3103,6 +3264,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele,docu="U4.41.01-g", "BARRE", "2D_BARRE", "C_PLAN", + "C_PLAN_NS", "C_PLAN_SI", "C_PLAN_GRAD_EPSI", "C_PLAN_GRAD_VARI", @@ -3115,6 +3277,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele,docu="U4.41.01-g", "D_PLAN", "D_PLAN_GRAD_EPSI", "D_PLAN_GRAD_VARI", + "D_PLAN_NS", "PLAN_FISSURE", "D_PLAN_ABSO", "D_PLAN_HHM", @@ -3130,21 +3293,28 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele,docu="U4.41.01-g", "3D_THVD", "3D_THHMD", "3D_THMD", + "AXIS_HH2MD", "AXIS_HHMD", "AXIS_HMD", "AXIS_THHD", + "AXIS_THH2D", "AXIS_THVD", "AXIS_THHMD", + "AXIS_THH2MD", "AXIS_THMD", "D_PLAN_HHMD", + "D_PLAN_HH2MD", "D_PLAN_HMD", "D_PLAN_THHD", + "D_PLAN_THH2D", "D_PLAN_THVD", + "D_PLAN_THH2MD", "D_PLAN_THHMD", - "D_PLAN_THMD", + "D_PLAN_THMD", "DIS_T", "DIS_TR", "DKT", + "DKTG", "DST", "FLUI_STRU", "GRILLE", @@ -3219,7 +3389,7 @@ AIDE=PROC(nom="AIDE",op=42,docu="U4.02.01-g", ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 05/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -3241,8 +3411,16 @@ AIDE=PROC(nom="AIDE",op=42,docu="U4.02.01-g", ASSE_MAILLAGE=OPER(nom="ASSE_MAILLAGE",op= 105,sd_prod=maillage, fr="Assembler deux maillages sous un seul nom", docu="U4.23.03-f",reentrant='n', - UIinfo={"groupes":("Maillage",)}, - MAILLAGE =SIMP(statut='o',typ=maillage,min=2,validators=NoRepeat(),max=2 ), + UIinfo={"groupes":("Maillage",)}, + MAILLAGE_1 = SIMP(statut='o',typ=maillage,), + MAILLAGE_2 = SIMP(statut='o',typ=maillage,), + OPERATION = SIMP(statut='o',typ='TXM',into=("SOUS_STR","SUPERPOSE","COLLAGE"),), + b_collage = BLOC(condition = "OPERATION == 'COLLAGE'", + COLLAGE = FACT(statut='o', + GROUP_MA_1 =SIMP(statut='o',typ=grma), + GROUP_MA_2 =SIMP(statut='o',typ=grma), + ), + ), ) ; #& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND @@ -4217,7 +4395,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 24/11/2003 AUTEUR F1BHHAJ J.ANGLES # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -4272,17 +4450,24 @@ CALC_FATIGUE=OPER(nom="CALC_FATIGUE",op= 151,sd_prod=calc_fatigue_prod,reentrant b_fatigue_multi =BLOC(condition = "TYPE_CALCUL == 'FATIGUE_MULTI'", fr="Plan critique dans le cas de la fatigue multiaxiale à grand nombre de cycles.", + TYPE_CHARGE =SIMP(statut='o',typ='TXM',into=("PERIODIQUE","NON_PERIODIQUE") ), OPTION =SIMP(statut='o',typ='TXM',into=("DOMA_ELGA","DOMA_NOEUD") ), RESULTAT =SIMP(statut='o',typ=(evol_elas, evol_noli) ), CHAM_MATER =SIMP(statut='o',typ=(cham_mater) ), - CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE","DANG_VAN") ), - METHODE =SIMP(statut='o',typ='TXM',into=("CERCLE_EXACT",) ), 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_fati_mult_ma =BLOC(condition = "(GROUP_MA != None or MAILLE != None or GROUP_NO != None or NOEUD != None) and \ - OPTION == 'DOMA_NOEUD'", + b_period =BLOC(condition = "TYPE_CHARGE == 'PERIODIQUE'", + CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE","DANG_VAN_MODI") ), + 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",) ), + 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)", MODELE =SIMP(statut='o',typ=modele ), MAILLAGE =SIMP(statut='o',typ=maillage ), ), @@ -4776,7 +4961,7 @@ CALC_G_LOCAL_T=OPER(nom="CALC_G_LOCAL_T",op=77,sd_prod=tabl_calc_g_loca, INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 16/12/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -4802,7 +4987,7 @@ CALC_G_THETA_T=OPER(nom="CALC_G_THETA_T",op=53,sd_prod=tabl_calc_g_th, EXCLUS('COMP_ELAS','COMP_INCR'),), MODELE =SIMP(statut='o',typ=modele), CHAM_MATER =SIMP(statut='o',typ=cham_mater), - THETA =SIMP(statut='o',typ=theta_geom), + THETA =SIMP(statut='o',typ=(theta_geom,cham_no_depl_r),), DEPL =SIMP(statut='f',typ=cham_no_depl_r), RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_noli),), @@ -5191,7 +5376,7 @@ CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,docu="U4.85.01-b",reentr ,into=("META_ELNO_TEMP",) ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 08/12/2003 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -5287,6 +5472,10 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,docu="U4.81.02-f",reentr TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), + GROUP_MA_RESU =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + MAILLE_RESU =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), + GROUP_NO_RESU =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), + NOEUD_RESU =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'), ) ; #& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND @@ -6929,7 +7118,7 @@ DEFI_FONC_FLUI=OPER(nom="DEFI_FONC_FLUI",op= 142,sd_prod=fonction, TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 18/11/2003 AUTEUR LEBOUVIE F.LEBOUVIER # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -6962,9 +7151,9 @@ DEFI_FONCTION=OPER(nom="DEFI_FONCTION",op=3,sd_prod=defi_fonction_prod regles=(UN_PARMI('VALE','VALE_C','VALE_PARA','NOEUD_PARA'),), NOM_PARA =SIMP(statut='o',typ='TXM', into=("DX","DY","DZ","DRX","DRY","DRZ","TEMP", - "INST","X","Y","Z","EPSI","META","FREQ","PULS", + "INST","X","Y","Z","EPSI","META","FREQ","PULS","DSP", "AMOR","ABSC","SIGM","HYDR","SECH","PORO","SAT", - "PGAZ","PCAP","VITE","ENDO") ), + "PGAZ","PCAP","VITE","ENDO","NORM") ), NOM_RESU =SIMP(statut='f',typ='TXM',defaut="TOUTRESU"), VALE =SIMP(statut='f',typ='R',min=2,max='**', fr ="Fonction réelle définie par une liste de couples (abscisse,ordonnée)"), @@ -7067,7 +7256,7 @@ DEFI_FOND_FISS=OPER(nom="DEFI_FOND_FISS",op=55,sd_prod=fond_fiss,docu="U4.82.01- INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 16/12/2003 AUTEUR VABHHTS J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -7099,7 +7288,7 @@ DEFI_GROUP=OPER(nom="DEFI_GROUP",op= 104,sd_prod=defi_group_prod, MAILLAGE =SIMP(statut='o',typ=(maillage,squelette) ), CREA_GROUP_MA =FACT(statut='f',max='**', - + regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION'),), # quel est le concept attendu deriere NOM NOM =SIMP(statut='o',typ=grma), @@ -7161,11 +7350,9 @@ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION') CREA_GROUP_NO =FACT(statut='f',max='**', regles = ( AU_MOINS_UN ('TOUT_GROUP_MA','GROUP_MA','NOEUD', 'INTERSEC','UNION','DIFFE','GROUP_NO','OPTION'), - PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'), EXCLUS ('TOUT_GROUP_MA','GROUP_MA','NOEUD','INTERSEC','UNION','DIFFE'),), TOUT_GROUP_MA =SIMP(statut='f',typ='TXM',into=("OUI",) ), GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), - TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), INTERSEC =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'), @@ -7241,6 +7428,9 @@ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION') b_tunnel =BLOC(condition = "OPTION == 'TUNNEL'", regles=(EXCLUS('NOEUD_ORIG','GROUP_NO_ORIG'), AU_MOINS_UN ('GROUP_MA_AXE','MAILLE_AXE'),), + + TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), # en complément de GROUP_MA et MAILLE + GROUP_MA_AXE =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), MAILLE_AXE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), NOEUD_ORIG =SIMP(statut='f',typ=no), @@ -7506,7 +7696,7 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage, ), ) ; -#& MODIF COMMANDE DATE 26/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 12/01/2004 AUTEUR GRANET S.GRANET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -7541,7 +7731,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, EXCLUS('CIN2_CHAB','CIN2_CHAB_FO'), EXCLUS('VISCOCHAB','VISCOCHAB_FO'), EXCLUS('POLY_CFC','POLY_CFC_FO'), - EXCLUS('LEMAITRE','LEMAITRE_FO','ZIRC_CYRA2','ZIRC_EPRI'), + EXCLUS('LEMAITRE','LEMAITRE_FO','ZIRC_CYRA2','ZIRC_EPRI','VISC_IRRA_LOG'), EXCLUS('OHNO','OHNO_FO'), EXCLUS('LMARC','LMARC_FO'), EXCLUS('VMIS_POUTRE','VMIS_POUTRE_FO'), @@ -7551,8 +7741,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, EXCLUS('WEIBULL','WEIBULL_FO'), PRESENT_PRESENT('CAM_CLAY','ELAS'), PRESENT_PRESENT('LAIGLE','ELAS'), + PRESENT_PRESENT('DRUCKER_PRAGER','ELAS'), EXCLUS('MAZARS','MAZARS_FO'), PRESENT_PRESENT('BAZANT_FD','ELAS_FO'), + EXCLUS('GLRC','GLRC_FO'), ), # # comportement élastique @@ -7580,10 +7772,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, K_DESSIC =SIMP(statut='f',typ='R',defaut= 0.E+0 ), B_ENDOGE =SIMP(statut='f',typ='R',defaut= 0.E+0 ), FONC_DESORP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP","INST",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="INST",into=("TEMP","INST",) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="HYDR",into=("HYDR",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="SECH",into=("SECH",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","INST","HYDR","SECH",) ), ), ELAS_FLUI =FACT(statut='f', E =SIMP(statut='o',typ='R'), @@ -7592,7 +7781,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PROF_RHO_F_INT =SIMP(statut='o',typ=(fonction,formule)), PROF_RHO_F_EXT =SIMP(statut='o',typ=(fonction,formule)), COEF_MASS_AJOU =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="ABSC",into=("ABSC",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("ABSC",) ), ), ELAS_ISTR =FACT(statut='f', E_L =SIMP(statut='o',typ='R'), @@ -7619,7 +7808,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PRECISION =SIMP(statut='f',typ='R',defaut= 1.), ALPHA_L =SIMP(statut='f',typ=(fonction,formule)), ALPHA_N =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP","INST")), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","INST")), ), ELAS_ORTH =FACT(statut='f', E_L =SIMP(statut='o',typ='R'), @@ -7662,7 +7851,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, ALPHA_L =SIMP(statut='f',typ=(fonction,formule)), ALPHA_T =SIMP(statut='f',typ=(fonction,formule)), ALPHA_N =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP","INST",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","INST",) ), ), ELAS_THM =FACT(statut='f', RHO_S =SIMP(statut='o',typ='R'), @@ -7840,7 +8029,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, C_TZTZ =SIMP(statut='f',typ=(fonction,formule)), RHO =SIMP(statut='f',typ='R'), ALPHA =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP","INST") ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","INST") ), ), APPUI_ELAS =FACT(statut='f', E_N =SIMP(statut='o',typ='R'), @@ -7859,10 +8048,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # TRACTION =FACT(statut='f', SIGM =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="EPSI",into=("EPSI",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="HYDR",into=("HYDR",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="SECH",into=("SECH",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("EPSI","TEMP","HYDR","SECH",) ), ), ECRO_LINE =FACT(statut='f', D_SIGM_EPSI =SIMP(statut='o',typ='R'), @@ -7871,7 +8057,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, ECRO_LINE_FO =FACT(statut='f', D_SIGM_EPSI =SIMP(statut='o',typ=(fonction,formule)), SY =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), BETON_ECRO_LINE =FACT(statut='f', D_SIGM_EPSI =SIMP(statut='o',typ='R'), @@ -7883,7 +8069,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, ), PRAGER_FO =FACT(statut='f', C =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), ECRO_FLEJOU =FACT(statut='f', EP =SIMP(statut='o',typ='R'), @@ -7910,7 +8096,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, C1 =SIMP(statut='o',typ=(fonction,formule)), C_INF =SIMP(statut='o',typ=(fonction,formule)), S =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), ROUSSELIER =FACT(statut='f', D =SIMP(statut='o',typ='R'), @@ -7931,7 +8117,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PORO_LIMI =SIMP(statut='f',typ='R',defaut= 0.999 ), D_SIGM_EPSI_NORM=SIMP(statut='f',typ='R',defaut= 1. ), AN =SIMP(statut='f',typ='R',defaut= 0. ), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), ROUSS_VISC =FACT(statut='f', SIGM_0 =SIMP(statut='o',typ='R'), @@ -7968,7 +8154,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, W =SIMP(statut='o',typ=(fonction,formule)), G_0 =SIMP(statut='o',typ=(fonction,formule)), A_I =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",)), ), CIN2_CHAB =FACT(statut='f', R_0 =SIMP(statut='o',typ='R'), @@ -7993,7 +8179,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, G1_0 =SIMP(statut='o',typ=(fonction,formule)), G2_0 =SIMP(statut='o',typ=(fonction,formule)), A_I =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), VISCOCHAB =FACT(statut='f', K_0 =SIMP(statut='o',typ='R'), @@ -8048,7 +8234,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, G_X2 =SIMP(statut='o',typ=(fonction,formule)), G2_0 =SIMP(statut='o',typ=(fonction,formule)), A_I =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), POLY_CFC =FACT(statut='f', TEXTURE =SIMP(statut='o',typ=(tabl_texture) ), @@ -8081,7 +8267,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, C1 =SIMP(statut='o',typ=(fonction,formule)), D1 =SIMP(statut='o',typ=(fonction,formule)), C2 =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), LEMAITRE =FACT(statut='f', N =SIMP(statut='o',typ='R'), @@ -8092,8 +8278,15 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, EPSI_FAB =SIMP(statut='o',typ=(fonction,formule)), TEMP_RECUIT =SIMP(statut='o',typ=(fonction,formule)), FLUX_PHI =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="INST",into=("INST",) ), - ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("INST",) ), + ), + VISC_IRRA_LOG =FACT(statut='f', + A =SIMP(statut='f',typ='R',defaut= 1.28E-1), + B =SIMP(statut='f',typ='R',defaut= 0.01159), + CSTE_TPS =SIMP(statut='f',typ='R',defaut= 0.3540), + ENER_ACT =SIMP(statut='f',typ='R',defaut= 5000.), + FLUX_PHI =SIMP(statut='o',typ='R',), + ), ZIRC_EPRI =FACT(statut='f', FLUX_PHI =SIMP(statut='o',typ='R'), R_P =SIMP(statut='o',typ='R'), @@ -8103,7 +8296,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, N =SIMP(statut='o',typ=(fonction,formule)), UN_SUR_K =SIMP(statut='o',typ=(fonction,formule)), UN_SUR_M =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), GRAN_IRRA =FACT(statut='f', A =SIMP(statut='f',typ='R',defaut= 0.E+0), @@ -8157,7 +8350,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, M3 =SIMP(statut='o',typ=(fonction,formule)), M4 =SIMP(statut='o',typ=(fonction,formule)), M5 =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), LMARC =FACT(statut='f', DE_0 =SIMP(statut='o',typ='R'), @@ -8220,7 +8413,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, R22 =SIMP(statut='o',typ=(fonction,formule)), R33 =SIMP(statut='o',typ=(fonction,formule)), R66 =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), VMIS_POUTRE =FACT(statut='f', NP =SIMP(statut='o',typ='R'), @@ -8245,7 +8438,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CAZ =SIMP(statut='o',typ=(fonction,formule)), CBZ =SIMP(statut='o',typ=(fonction,formule)), MPX =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), ARME =FACT(statut='f', KYE =SIMP(statut='o',typ='R'), @@ -8297,9 +8490,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, MOMENT_3 =SIMP(statut='f',typ=(fonction,formule)), MOMENT_4 =SIMP(statut='f',typ=(fonction,formule)), C_PRAGER_MZ =SIMP(statut='f',typ='R',defaut= 0.E+0 ), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="DRZ",into=("DRZ",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="INST",into=("INST",) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("DRZ","INST","TEMP",) ), ), NADAI_B =FACT(statut='f', F_C =SIMP(statut='o',typ='R'), @@ -8320,10 +8511,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, LONG_CARA =SIMP(statut='f',typ='R'), ECRO_COMP_P_PIC =SIMP(statut='f',typ='TXM',defaut="LINEAIRE",into=("LINEAIRE","PARABOLE") ), ECRO_TRAC_P_PIC =SIMP(statut='f',typ='TXM',defaut="LINEAIRE",into=("LINEAIRE","EXPONENT") ), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP","INST",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="INST",into=("TEMP","INST",) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="HYDR",into=("HYDR",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="SECH",into=("SECH",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","INST","HYDR","SECH",) ), ), LABORD_1D=FACT(statut='f',min=0 , Y01 =SIMP(statut='o',typ='R'), @@ -8351,7 +8539,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, BC =SIMP(statut='o',typ=(fonction,formule)), AT =SIMP(statut='o',typ=(fonction,formule)), BT =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), VENDOCHAB =FACT(statut='f', S_VP =SIMP(statut='o',typ='R'), @@ -8374,8 +8562,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, R_D =SIMP(statut='o',typ=(fonction,formule)), A_D =SIMP(statut='o',typ=(fonction,formule)), K_D =SIMP(statut='o',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="X",into=("X",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","X",) ), ), PINTO_MENEGOTTO =FACT(statut='f', SY =SIMP(statut='o',typ='R'), @@ -8456,7 +8643,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, V_GRANGER_FP =FACT(statut='f', QSR_VEIL =SIMP(statut='f',typ='R'), FONC_V =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="INST",into=("INST",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("INST",) ), ), BAZANT_FD =FACT(statut='f', LAM_VISC =SIMP(statut='o',typ='R'), @@ -8470,6 +8657,31 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, ETA_RD =SIMP(statut='o',typ='R'), ETA_ID =SIMP(statut='o',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), + 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,formule)), + MEY1 =SIMP(statut='o',typ=(fonction,formule)), + MEX2 =SIMP(statut='o',typ=(fonction,formule)), + MEY2 =SIMP(statut='o',typ=(fonction,formule)), + CX1 =SIMP(statut='o',typ=(fonction,formule)), + CY1 =SIMP(statut='o',typ=(fonction,formule)), + CXY1 =SIMP(statut='o',typ=(fonction,formule)), + CX2 =SIMP(statut='o',typ=(fonction,formule)), + CY2 =SIMP(statut='o',typ=(fonction,formule)), + CXY2 =SIMP(statut='o',typ=(fonction,formule)), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("NORM",) ), + ), # # comportement thermique # @@ -8478,7 +8690,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, LAMBDA =SIMP(statut='o',typ=(fonction,formule)), BETA =SIMP(statut='f',typ=(fonction,formule)), RHO_CP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), THER_HYDR =FACT(statut='f', LAMBDA =SIMP(statut='o',typ=(fonction,formule)), @@ -8486,8 +8698,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, AFFINITE =SIMP(statut='o',typ=(fonction,formule)), CHALHYDR =SIMP(statut='o',typ='R'), QSR_K =SIMP(statut='o',typ='R'), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("HYDR",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="HYDR",into=("HYDR",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("HYDR","TEMP",) ), ), THER =FACT(statut='f', LAMBDA =SIMP(statut='o',typ='R'), @@ -8496,7 +8707,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, THER_FO =FACT(statut='f', LAMBDA =SIMP(statut='o',typ=(fonction,formule)), RHO_CP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="INST",into=("INST",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("INST",) ), ), THER_ORTH =FACT(statut='f', LAMBDA_L =SIMP(statut='o',typ='R'), @@ -8557,8 +8768,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, ), SECH_NAPPE =FACT(statut='f', FONCTION =SIMP(statut='o',typ=(nappe,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="TSEC",into=("TSEC",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","TSEC",) ), ), # # comportement métallurgique @@ -8616,7 +8826,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, F4_S_VP =SIMP(statut='f',typ='R'), C_S_VP =SIMP(statut='f',typ='R' ), S_VP_MELANGE =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="META",into=("META",)), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("META",)), ), ELAS_META_FO =FACT(statut='f', regles=( @@ -8643,8 +8853,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, F4_S_VP =SIMP(statut='f',typ=(fonction,formule)), C_S_VP =SIMP(statut='f',typ=(fonction,formule)), S_VP_MELANGE =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="META",into=("META",)), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","META",)), ), META_ECRO_LINE =FACT(statut='f', F1_D_SIGM_EPSI =SIMP(statut='f',typ=(fonction,formule)), @@ -8652,7 +8861,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, F3_D_SIGM_EPSI =SIMP(statut='f',typ=(fonction,formule)), F4_D_SIGM_EPSI =SIMP(statut='f',typ=(fonction,formule)), C_D_SIGM_EPSI =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",)), ), META_TRACTION =FACT(statut='f', SIGM_F1 =SIMP(statut='f',typ=(fonction,formule)), @@ -8660,8 +8869,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, SIGM_F3 =SIMP(statut='f',typ=(fonction,formule)), SIGM_F4 =SIMP(statut='f',typ=(fonction,formule)), SIGM_C =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="EPSI",into=("EPSI",)), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("EPSI","TEMP",)), ), META_VISC_FO =FACT(statut='f', F1_ETA =SIMP(statut='f',typ=(fonction,formule)), @@ -8684,7 +8892,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, C_N =SIMP(statut='f',typ=(fonction,formule)), C_C =SIMP(statut='f',typ=(fonction,formule)), C_M =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), META_PT =FACT(statut='f', F1_K =SIMP(statut='f',typ='R'), @@ -8695,8 +8903,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, F2_D_F_META =SIMP(statut='f',typ=(fonction,formule)), F3_D_F_META =SIMP(statut='f',typ=(fonction,formule)), F4_D_F_META =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="META",into=("META",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP","META",) ), ), META_RE =FACT(statut='f', C_F1_THETA =SIMP(statut='f',typ='R'), @@ -8735,6 +8942,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # DE LA LOI DE COUPLAGE THM DE LA RELATION # LE COMPORTEMENT DE COUPLAGE COMP_THM N EST VALABLE QUE POUR LES LOIS # DE COUPLAGE : LIQU_SATU,LIQU_GAZ,GAZ,LIQU_GAZ_ATM,LIQU_VAPE_GAZ,LIQU_VAPE +# ET LIQU_AD_GAZ_VAPE # POUR LES LOIS DE COUPLAGE LIQU_SATU_GAT ET LIQU_NSAT_GAT # ON NE MODIFIE RIEN # LA CORRESPONDANCE AVEC LES VARIABLES CACHEES EST LA SUIVANTE : @@ -8746,6 +8954,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # 6 --> LIQU_GAZ_ATM # 7 --> LIQU_SATU_GAT # 8 --> LIQU_NSAT_GAT +# 9 --> LIQU_AD_GAZ_VAPE # ================================================================================= COMP_THM = SIMP(statut='f', typ='TXM', into = ( "LIQU_SATU" , @@ -8756,6 +8965,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, "LIQU_VAPE" , "LIQU_SATU_GAT" , "LIQU_NSAT_GAT" , + "LIQU_AD_GAZ_VAPE" , ) ), # ================================================================================= # --- LOI DE COUPLAGE DE TYPE LIQU_SATU ------------------------------------------- @@ -8809,12 +9019,18 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_IN = SIMP(statut='f',typ=(fonction,formule)), PERM_END = SIMP(statut='f',typ=(fonction,formule)), regles = (EXCLUS('PERM_IN','PERM_END'),), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_S = SIMP(statut='f',typ=(fonction,formule)), + D_LB_S = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- R_GAZ = SIMP(statut='f',typ='R'), + EMMAG = SIMP(statut='f',typ='R'), SATU_PRES =SIMP(statut='f',typ=(fonction,formule)), D_SATU_PRES =SIMP(statut='f',typ=(fonction,formule)), PERM_LIQU =SIMP(statut='f',typ=(fonction,formule)), @@ -8822,22 +9038,25 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_GAZ =SIMP(statut='f',typ=(fonction,formule)), D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction,formule)), D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction,formule)), - FICK =SIMP(statut='f',typ=(fonction,formule)), - D_FICK_TEMP =SIMP(statut='f',typ=(fonction,formule)), - D_FICK_GAZ_PRES =SIMP(statut='f',typ=(fonction,formule)), SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), D_SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR =SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO =SIMP(statut='f',typ=(fonction,formule)), + FICKV_T = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKA_T = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="SAT", into=("SAT" ,) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 =SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 =SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), ), # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -8855,16 +9074,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # --------------------------------------------------------------------------------- ALPHA = SIMP(statut='f',typ='R'), CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), -# --------------------------------------------------------------------------------- -# ------------------- DONNEES INUTILES ---------------------------------------- -# --------------------------------------------------------------------------------- - COEF_HENRY =SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE INUTILE ------------------------------------------------------------- @@ -8874,9 +9087,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - LAMBDA =SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE INUTILE ------------------------------------------------------------- @@ -8886,7 +9097,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), ), # ================================================================================= @@ -8949,27 +9160,36 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_IN = SIMP(statut='f',typ=(fonction,formule)), PERM_END = SIMP(statut='f',typ=(fonction,formule)), regles = (EXCLUS('PERM_IN','PERM_END'),), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_S = SIMP(statut='f',typ=(fonction,formule)), + D_LB_S = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- - FICK = SIMP(statut='f',typ=(fonction,formule)), - D_FICK_TEMP = SIMP(statut='f',typ=(fonction,formule)), - D_FICK_GAZ_PRES = SIMP(statut='f',typ=(fonction,formule)), + EMMAG = SIMP(statut='f',typ='R'), SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), D_SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR = SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO = SIMP(statut='f',typ=(fonction,formule)), + FICKV_T = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKA_T = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 = SIMP(statut='c',typ='TXM',defaut="SAT" ,into=("SAT" ,) ), - VERI_P3 = SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 = SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 = SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 = SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), ) , # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -8987,16 +9207,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # --------------------------------------------------------------------------------- ALPHA = SIMP(statut='f',typ='R'), CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), -# --------------------------------------------------------------------------------- -# ------------------- DONNEES INUTILES ---------------------------------------- -# --------------------------------------------------------------------------------- - COEF_HENRY = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9012,12 +9226,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- # --------------------------------------------------------------------------------- CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE INUTILE ------------------------------------------------------------- @@ -9027,7 +9239,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), ), # ================================================================================= @@ -9080,11 +9292,17 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_IN = SIMP(statut='f',typ=(fonction,formule)), PERM_END = SIMP(statut='f',typ=(fonction,formule)), regles = (EXCLUS('PERM_IN','PERM_END'),), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_S = SIMP(statut='f',typ=(fonction,formule)), + D_LB_S = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- + EMMAG = SIMP(statut='f',typ='R'), SATU_PRES =SIMP(statut='f',typ=(fonction,formule)), D_SATU_PRES =SIMP(statut='f',typ=(fonction,formule)), PERM_LIQU =SIMP(statut='f',typ=(fonction,formule)), @@ -9092,22 +9310,25 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_GAZ =SIMP(statut='f',typ=(fonction,formule)), D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction,formule)), D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction,formule)), - FICK =SIMP(statut='f',typ=(fonction,formule)), - D_FICK_TEMP =SIMP(statut='f',typ=(fonction,formule)), - D_FICK_GAZ_PRES =SIMP(statut='f',typ=(fonction,formule)), SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), D_SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR =SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO =SIMP(statut='f',typ=(fonction,formule)), + FICKV_T = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKA_T = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="SAT",into=("SAT",) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 =SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 =SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), ) , # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9123,12 +9344,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- # --------------------------------------------------------------------------------- CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE INUTILE ------------------------------------------------------------- @@ -9140,10 +9359,8 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - LAMBDA =SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP =SIMP(statut='f',typ=(fonction,formule)), COEF_HENRY =SIMP(statut='f',typ='R'), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE INUTILE ------------------------------------------------------------- @@ -9153,7 +9370,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), ), # ================================================================================= @@ -9212,31 +9429,40 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_IN = SIMP(statut='f',typ=(fonction,formule)), PERM_END = SIMP(statut='f',typ=(fonction,formule)), regles = (EXCLUS('PERM_IN','PERM_END'),), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_S = SIMP(statut='f',typ=(fonction,formule)), + D_LB_S = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- + EMMAG = SIMP(statut='f',typ='R'), R_GAZ =SIMP(statut='f',typ='R'), PERM_GAZ =SIMP(statut='f',typ=(fonction,formule)), D_PERM_SATU_GAZ =SIMP(statut='f',typ=(fonction,formule)), D_PERM_PRES_GAZ =SIMP(statut='f',typ=(fonction,formule)), - FICK =SIMP(statut='f',typ=(fonction,formule)), - D_FICK_TEMP =SIMP(statut='f',typ=(fonction,formule)), - D_FICK_GAZ_PRES =SIMP(statut='f',typ=(fonction,formule)), SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), D_SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR =SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO =SIMP(statut='f',typ=(fonction,formule)), + FICKV_T = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKA_T = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="SAT", into=("SAT", ) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 =SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 =SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), ) , # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9254,16 +9480,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # --------------------------------------------------------------------------------- ALPHA = SIMP(statut='f',typ='R'), CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), -# --------------------------------------------------------------------------------- -# ------------------- DONNEES INUTILES ---------------------------------------- -# --------------------------------------------------------------------------------- - COEF_HENRY = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9279,12 +9499,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- # --------------------------------------------------------------------------------- CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES --------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE INUTILE ------------------------------------------------------------- @@ -9294,7 +9512,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), ), # ================================================================================= @@ -9350,9 +9568,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_GAZ = SIMP(statut='o',typ=(fonction,formule)), D_PERM_SATU_GAZ = SIMP(statut='o',typ=(fonction,formule)), D_PERM_PRES_GAZ = SIMP(statut='o',typ=(fonction,formule)), - FICK = SIMP(statut='o',typ=(fonction,formule)), - D_FICK_TEMP = SIMP(statut='o',typ=(fonction,formule)), - D_FICK_GAZ_PRES = SIMP(statut='o',typ=(fonction,formule)), + FICKV_T = SIMP(statut='o',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- # --------------------------------------------------------------------------------- @@ -9360,24 +9576,38 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_IN = SIMP(statut='f',typ=(fonction,formule)), PERM_END = SIMP(statut='f',typ=(fonction,formule)), regles = (EXCLUS('PERM_IN','PERM_END'),), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_S = SIMP(statut='f',typ=(fonction,formule)), + D_LB_S = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- -# ------------------- DONNEES INUTILES ---------------------------------------- +# ------------------- DONNEES FACULTATIVE ---------------------------------- # --------------------------------------------------------------------------------- + EMMAG = SIMP(statut='f',typ='R'), SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), D_SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR = SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES INUTILES ---------------------------------------- +# --------------------------------------------------------------------------------- + FICKA_T = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 = SIMP(statut='c',typ='TXM',defaut="SAT" ,into=("SAT" ,) ), - VERI_P3 = SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 = SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 = SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 = SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT" ,"PORO","PGAZ","PCAP","ENDO",) ), ) , # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9395,16 +9625,164 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # --------------------------------------------------------------------------------- ALPHA = SIMP(statut='f',typ='R'), CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES CACHEES ------------------------------------------- +# --------------------------------------------------------------------------------- + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), + ), +# ================================================================================= +# --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- +# ================================================================================= + THM_GAZ = FACT(statut='o', +# --------------------------------------------------------------------------------- +# ------------------- DONNEES OBLIGATOIRE ------------------------------------- +# --------------------------------------------------------------------------------- + MASS_MOL = SIMP(statut='o',typ='R'), + VISC = SIMP(statut='o',typ=(fonction,formule)), + D_VISC_TEMP = SIMP(statut='o',typ=(fonction,formule)), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- +# --------------------------------------------------------------------------------- + CP = SIMP(statut='f',typ='R'), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES CACHEES ------------------------------------------- +# --------------------------------------------------------------------------------- + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), + ), +# ================================================================================= +# --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- +# ================================================================================= + THM_VAPE_GAZ = FACT(statut='o', +# --------------------------------------------------------------------------------- +# ------------------- DONNEES OBLIGATOIRE ------------------------------------- +# --------------------------------------------------------------------------------- + MASS_MOL = SIMP(statut='o',typ='R'), + CP = SIMP(statut='o',typ='R'), + VISC = SIMP(statut='o',typ=(fonction,formule)), + D_VISC_TEMP = SIMP(statut='o',typ=(fonction,formule)), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES CACHEES ------------------------------------------- +# --------------------------------------------------------------------------------- + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), + ), + ), +# ================================================================================= +# --- LOI DE COUPLAGE DE TYPE LIQU_AD_GAZ_VAPE ------------------------------------- +# ================================================================================= +# --- PRESENCE OBLIGATOIRE DES MOT-CLES SUIVANT : --------------------------------- +# --- THM_INIT, THM_DIFFU, THM_LIQU, THM_GAZ, THM_VAPE_GAZ THM_AIR_DISSOUS--------- +# ================================================================================= + b_liquadvape = BLOC(condition = "COMP_THM == 'LIQU_AD_GAZ_VAPE' ", + fr="Paramètres nécessaires pour une loi de couplage de type LIQU_AD_GAZ_VAPE", +# ================================================================================= +# --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- +# ================================================================================= + THM_INIT = FACT(statut='o', +# --------------------------------------------------------------------------------- +# ------------------- DONNEES OBLIGATOIRE ------------------------------------- +# --------------------------------------------------------------------------------- + PRE1 = SIMP(statut='o',typ='R'), + PRE2 = SIMP(statut='o',typ='R'), + PORO = SIMP(statut='o',typ='R'), + PRES_VAPE = SIMP(statut='o',typ='R'), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- +# --------------------------------------------------------------------------------- + TEMP = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- - COEF_HENRY = SIMP(statut='f',typ='R'), + DEGR_SATU = SIMP(statut='f',typ='R'), + PRES_ATMO = SIMP(statut='f',typ='R'), +# --------------------------------------------------------------------------------- +# ------------------- DONNEE CACHEE --------------------------------------------- +# --------------------------------------------------------------------------------- + COMP_THM = SIMP(statut='c',typ='R',defaut= 9.0,), + ), +# ================================================================================= +# --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- +# ================================================================================= + THM_DIFFU = FACT(statut='o', +# --------------------------------------------------------------------------------- +# ------------------- DONNEES OBLIGATOIRE ------------------------------------- +# --------------------------------------------------------------------------------- + R_GAZ = SIMP(statut='o',typ='R'), + RHO = SIMP(statut='o',typ='R'), + BIOT_COEF = SIMP(statut='o',typ='R'), + PESA_X = SIMP(statut='o',typ='R'), + PESA_Y = SIMP(statut='o',typ='R'), + PESA_Z = SIMP(statut='o',typ='R'), + SATU_PRES = SIMP(statut='o',typ=(fonction,formule)), + D_SATU_PRES = SIMP(statut='o',typ=(fonction,formule)), + PERM_LIQU = SIMP(statut='o',typ=(fonction,formule)), + D_PERM_LIQU_SATU = SIMP(statut='o',typ=(fonction,formule)), + PERM_GAZ = SIMP(statut='o',typ=(fonction,formule)), + D_PERM_SATU_GAZ = SIMP(statut='o',typ=(fonction,formule)), + D_PERM_PRES_GAZ = SIMP(statut='o',typ=(fonction,formule)), + FICKV_T = SIMP(statut='o',typ=(fonction,formule)), + FICKA_T = SIMP(statut='o',typ=(fonction,formule)), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- +# --------------------------------------------------------------------------------- + CP = SIMP(statut='f',typ='R'), + PERM_IN = SIMP(statut='f',typ=(fonction,formule)), + PERM_END = SIMP(statut='f',typ=(fonction,formule)), + regles = (EXCLUS('PERM_IN','PERM_END'),), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_S = SIMP(statut='f',typ=(fonction,formule)), + D_LB_S = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES FACULTATIVES ------------------------------------ +# --------------------------------------------------------------------------------- + EMMAG = SIMP(statut='f',typ='R'), + SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), + D_SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), + PERM_G_INTR = SIMP(statut='f',typ=(fonction,formule)), + CHAL_VAPO = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), +# + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES CACHEES ------------------------------------------- +# --------------------------------------------------------------------------------- + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), + ) , +# ================================================================================= +# --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- +# ================================================================================= + THM_LIQU = FACT(statut='o', +# --------------------------------------------------------------------------------- +# ------------------- DONNEES OBLIGATOIRE ------------------------------------- +# --------------------------------------------------------------------------------- + RHO = SIMP(statut='o',typ='R'), + UN_SUR_K = SIMP(statut='o',typ='R'), + VISC = SIMP(statut='o',typ=(fonction,formule)), + D_VISC_TEMP = SIMP(statut='o',typ=(fonction,formule)), +# --------------------------------------------------------------------------------- +# ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- +# --------------------------------------------------------------------------------- + ALPHA = SIMP(statut='f',typ='R'), + CP = SIMP(statut='f',typ='R'), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9420,12 +9798,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # ------------------- DONNEES NECESSAIRE SI THERMIQUE ------------------------- # --------------------------------------------------------------------------------- CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9441,7 +9817,17 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), + ), +# ================================================================================= +# --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- +# ================================================================================= + THM_AIR_DISS = FACT(statut='o', +# --------------------------------------------------------------------------------- +# ------------------- DONNEES OBLIGATOIRE ------------------------------------- +# --------------------------------------------------------------------------------- + CP = SIMP(statut='o',typ='R'), + COEF_HENRY = SIMP(statut='o',typ=(fonction,formule)), ), ), # ================================================================================= @@ -9504,27 +9890,36 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, PERM_IN = SIMP(statut='f',typ=(fonction,formule)), PERM_END = SIMP(statut='f',typ=(fonction,formule)), regles = (EXCLUS('PERM_IN','PERM_END'),), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), + LAMB_PHI = SIMP(statut='f',typ=(fonction,formule)), + D_LB_PHI = SIMP(statut='f',typ=(fonction,formule)), + LAMB_T = SIMP(statut='f',typ=(fonction,formule)), + D_LB_T = SIMP(statut='f',typ=(fonction,formule)), + LAMB_S = SIMP(statut='f',typ=(fonction,formule)), + D_LB_S = SIMP(statut='f',typ=(fonction,formule)), + LAMB_CT = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES INUTILES ---------------------------------------- # --------------------------------------------------------------------------------- - FICK = SIMP(statut='f',typ=(fonction,formule)), - D_FICK_TEMP = SIMP(statut='f',typ=(fonction,formule)), - D_FICK_GAZ_PRES = SIMP(statut='f',typ=(fonction,formule)), + EMMAG = SIMP(statut='f',typ='R'), SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), D_SIGMA_T = SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR = SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO = SIMP(statut='f',typ=(fonction,formule)), + FICKV_T = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKA_T = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 = SIMP(statut='c',typ='TXM',defaut="SAT" ,into=("SAT" ,) ), - VERI_P3 = SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 = SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 = SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 = SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), ) , # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9542,16 +9937,10 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # --------------------------------------------------------------------------------- ALPHA = SIMP(statut='f',typ='R'), CP = SIMP(statut='f',typ='R'), - LAMBDA = SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP = SIMP(statut='f',typ=(fonction,formule)), -# --------------------------------------------------------------------------------- -# ------------------- DONNEES INUTILES ---------------------------------------- -# --------------------------------------------------------------------------------- - COEF_HENRY = SIMP(statut='f',typ='R'), # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES --------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE OBLIGATOIRE --------------------------------------------------------- @@ -9567,7 +9956,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, # --------------------------------------------------------------------------------- # ------------------- DONNEES CACHEES ------------------------------------------- # --------------------------------------------------------------------------------- - VERI_P1 = SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), # ================================================================================= # --- MOT-CLE INUTILE ------------------------------------------------------------- @@ -9577,9 +9966,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - LAMBDA =SIMP(statut='f',typ=(fonction,formule)), - D_LAMBDA_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), ), # ================================================================================= @@ -9595,7 +9982,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, LAMBDA =SIMP(statut='f',typ=(fonction,formule)), D_LAMBDA_TEMP =SIMP(statut='f',typ=(fonction,formule)), COEF_HENRY =SIMP(statut='f',typ='R'), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), THM_GAZ =FACT(statut='f', MASS_MOL =SIMP(statut='f',typ='R'), @@ -9604,15 +9991,19 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), LAMBDA =SIMP(statut='f',typ=(fonction,formule)), D_LAMBDA_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), THM_VAPE_GAZ =FACT(statut='f', MASS_MOL =SIMP(statut='f',typ='R'), CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), + THM_AIR_DISS = FACT(statut='f', + CP = SIMP(statut='f',typ='R'), + COEF_HENRY = SIMP(statut='f',typ=(fonction,formule)), + ), THM_INIT =FACT(statut='f', TEMP =SIMP(statut='o',typ='R'), PRE1 =SIMP(statut='o',typ='R'), @@ -9653,12 +10044,18 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, D_SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR =SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="SAT",into=("SAT",) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 =SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 =SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + FICKV_T = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV = SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKV_S = SIMP(statut='f',typ=(fonction,formule)), + D_FV_T = SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG = SIMP(statut='f',typ=(fonction,formule)), + FICKA_T = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA = SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL = SIMP(statut='f',typ=(fonction,formule)), + FICKA_S = SIMP(statut='f',typ=(fonction,formule)), + D_FA_T = SIMP(statut='f',typ=(fonction,formule)), + VERI_P = SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), ), ), b_liqunsatgat = BLOC(condition = "COMP_THM == 'LIQU_NSAT_GAT' ", @@ -9673,7 +10070,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, LAMBDA =SIMP(statut='f',typ=(fonction,formule)), D_LAMBDA_TEMP =SIMP(statut='f',typ=(fonction,formule)), COEF_HENRY =SIMP(statut='f',typ='R'), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), THM_GAZ =FACT(statut='f', MASS_MOL =SIMP(statut='f',typ='R'), @@ -9682,14 +10079,18 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), LAMBDA =SIMP(statut='f',typ=(fonction,formule)), D_LAMBDA_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), + THM_AIR_DISS = FACT(statut='f', + CP = SIMP(statut='f',typ='R'), + COEF_HENRY = SIMP(statut='f',typ=(fonction,formule)), + ), THM_VAPE_GAZ =FACT(statut='f', MASS_MOL =SIMP(statut='f',typ='R'), CP =SIMP(statut='f',typ='R'), VISC =SIMP(statut='f',typ=(fonction,formule)), D_VISC_TEMP =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP",)), ), THM_INIT =FACT(statut='f', TEMP =SIMP(statut='o',typ='R'), @@ -9731,12 +10132,18 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, D_SIGMA_T =SIMP(statut='f',typ=(fonction,formule)), PERM_G_INTR =SIMP(statut='f',typ=(fonction,formule)), CHAL_VAPO =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="SAT",into=("SAT",) ), - VERI_P3 =SIMP(statut='c',typ='TXM',defaut="PORO",into=("PORO",) ), - VERI_P4 =SIMP(statut='c',typ='TXM',defaut="PGAZ",into=("PGAZ",) ), - VERI_P5 =SIMP(statut='c',typ='TXM',defaut="PCAP",into=("PCAP",) ), - VERI_P6 =SIMP(statut='c',typ='TXM',defaut="ENDO",into=("ENDO",) ), + FICKV_T =SIMP(statut='f',typ=(fonction,formule)), + FICKV_PV =SIMP(statut='f',typ=(fonction,formule)), + FICKV_PG =SIMP(statut='f',typ=(fonction,formule)), + FICKV_S =SIMP(statut='f',typ=(fonction,formule)), + D_FV_T =SIMP(statut='f',typ=(fonction,formule)), + D_FV_PG =SIMP(statut='f',typ=(fonction,formule)), + FICKA_T =SIMP(statut='f',typ=(fonction,formule)), + FICKA_PA =SIMP(statut='f',typ=(fonction,formule)), + FICKA_PL =SIMP(statut='f',typ=(fonction,formule)), + FICKA_S =SIMP(statut='f',typ=(fonction,formule)), + D_FA_T =SIMP(statut='f',typ=(fonction,formule)), + VERI_P =SIMP(statut='c',typ='TXM',defaut=("TEMP","SAT","PORO","PGAZ","PCAP","ENDO",) ), ), ), # @@ -9762,16 +10169,15 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, E_REFE =SIMP(statut='f',typ='R'), D0 =SIMP(statut='f',typ='R'), TAU0 =SIMP(statut='f',typ='R'), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="SIGM",into=("SIGM",) ), - VERI_P2 =SIMP(statut='c',typ='TXM',defaut="EPSI",into=("EPSI",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("SIGM","EPSI",) ), ), DOMMA_LEMAITRE =FACT(statut='f', S =SIMP(statut='o',typ=(fonction,formule)), EPSP_SEUIL =SIMP(statut='o',typ='R'), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), CISA_PLAN_CRIT =FACT(statut='f', - CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE","DANG_VAN") ), + CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE","DANG_VAN_MODI","DOMM_MAXI") ), b_critere_matake =BLOC(condition="CRITERE=='MATAKE'", fr="cisaillement plan critique critère de matake", @@ -9780,12 +10186,19 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, COEF_FLEX_TORS =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0), ), - b_critere_dang_van =BLOC(condition="CRITERE=='DANG_VAN'", - fr="cisaillement plan critique critère de Dang Van", + b_critere_dang_van =BLOC(condition="CRITERE=='DANG_VAN_MODI'", + fr="cisaillement plan critique critère de Dang Van modifié", D_VAN_A =SIMP(statut='o',typ='R'), D_VAN_B =SIMP(statut='o',typ='R'), COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0), ), + + b_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), + ), ), # # autres comportements ... @@ -9802,7 +10215,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, SIGM_CNV =SIMP(statut='o',typ='R'), SIGM_REFE =SIMP(statut='o',typ=(fonction,formule)), SEUIL_EPSP_CUMU =SIMP(statut='f',typ='R',defaut= 1.0E-6), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), NON_LOCAL =FACT(statut='f', LONG_CARA =SIMP(statut='o',typ='R'), @@ -9829,7 +10242,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, S =SIMP(statut='f',typ=(fonction,formule)), N_KE =SIMP(statut='f',typ=(fonction,formule)), M_KE =SIMP(statut='f',typ=(fonction,formule)), - VERI_P1 =SIMP(statut='c',typ='TXM',defaut="TEMP",into=("TEMP",) ), + VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ), ), LAIGLE =FACT(statut='f', GAMMA_ULT =SIMP(statut='o',typ='R'), @@ -9847,6 +10260,22 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater, SIGMA_P1 =SIMP(statut='o',typ='R'), PA =SIMP(statut='o',typ='R'), ), + DRUCKER_PRAGER =FACT(statut='f', + ALPHA =SIMP(statut='o',typ='R'), + SY =SIMP(statut='o',typ='R'), + P_ULTM =SIMP(statut='o',typ='R'), + ECROUISSAGE = SIMP(statut='o',typ='TXM',into=("LINEAIRE","PARABOLIQUE")), + b_lineaire =BLOC(condition="ECROUISSAGE=='LINEAIRE'", + fr="Loi de comportement de type Drucker Prager avec un ecrouissage lineaire", + H =SIMP(statut='o',typ='R'), + TYPE_DP =SIMP(statut='c',typ='R',defaut= 1.0,), + ), + b_parabolique =BLOC(condition="ECROUISSAGE=='PARABOLIQUE'", + fr="Loi de comportement de type Drucker Prager avec un ecrouissage parabolique", + SY_ULTM =SIMP(statut='o',typ='R'), + TYPE_DP =SIMP(statut='c',typ='R',defaut= 2.0,), + ), + ), INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ), ) ; @@ -10782,7 +11211,7 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 14/10/2003 AUTEUR ACBHHCD G.DEVESA +#& MODIF COMMANDE DATE 21/01/2004 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -10853,6 +11282,29 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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','VITE','SIGM','VARI','VARI_NON_LOCAL',), + EXCLUS('EVOL_NOLI','DEPL',), + EXCLUS('EVOL_NOLI','VITE'), + 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_depl_r), + VITE =SIMP(statut='f',typ=cham_no_depl_r), + SIGM =SIMP(statut='f',typ=(cham_elem_sief_r,carte_sief_r)), + VARI =SIMP(statut='f',typ=cham_elem_vari_r), + VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_vanl_r), + 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','VITE','SIGM','VARI','VARI_NON_LOCAL',), EXCLUS('EVOL_NOLI','DEPL',), @@ -10873,7 +11325,7 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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'), @@ -10981,8 +11433,6 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")), ), #------------------------------------------------------------------- - OPTION =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',defaut="ELNO", - into=("SIEF_ELNO_ELGA","VARI_ELNO_ELGA","EFGE_ELNO_CART","ELNO","SANS") ), ARCHIVAGE =FACT(statut='f', regles=(EXCLUS('PAS_ARCH','LIST_INST','INST'), EXCLUS('ARCH_ETAT_INIT','NUME_INIT'), ), @@ -11085,7 +11535,7 @@ DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=tabl_intsp, TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 14/10/2003 AUTEUR ACBHHCD G.DEVESA +#& MODIF COMMANDE DATE 21/01/2004 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG @@ -11279,8 +11729,6 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 69,sd_prod=evol_noli,reentrant='f into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")), ), #------------------------------------------------------------------- - OPTION =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**',defaut="ELNO", - into=("SIEF_ELNO_ELGA","VARI_ELNO_ELGA","EFGE_ELNO_CART","ELNO","SANS") ), ARCHIVAGE =FACT(statut='f', regles=(EXCLUS('PAS_ARCH','LIST_INST','INST'), EXCLUS('ARCH_ETAT_INIT','NUME_INIT'), ), @@ -11332,7 +11780,6 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," 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), @@ -11822,40 +12269,7 @@ FACT_GRAD=OPER(nom="FACT_GRAD",op=85,sd_prod=fact_grad_prod,docu="U4.55.03-f", INFO =SIMP(statut='f',typ='I',into=(1,2) ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 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. -# ====================================================================== -FACT_INTE_SPEC=OPER(nom="FACT_INTE_SPEC",op= 117,sd_prod=interspfact, - fr="Factorisation d une matrice interspectrale hermitienne", - docu="U4.36.04-f",reentrant='n', - UIinfo={"groupes":("Fonction",)}, - regles=(ENSEMBLE('FREQ_FIN','NB_POIN'),), -# regle non indiquée dans la doc U - INTE_SPEC =SIMP(statut='o',typ=tabl_intsp ), - NUME_VITE_FLUI =SIMP(statut='f',typ='I' ), - FREQ_INIT =SIMP(statut='f',typ='R',defaut= 0.E+0 ), - FREQ_FIN =SIMP(statut='f',typ='R' ), - NB_POIN =SIMP(statut='f',typ='I',defaut= 0 ), - SUR_ECHAN =SIMP(statut='f',typ='R',defaut= 1. ), - TITRE =SIMP(statut='f',typ='TXM',max='**'), -) ; - -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 21/01/2004 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -12017,7 +12431,7 @@ FORMULE = FORM( nom='FORMULE',op=ops.build_formule,sd_prod=formule, COMPLEXE = SIMP(typ = 'shell',), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 05/11/2003 AUTEUR CAMBIER S.CAMBIER # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -12035,18 +12449,27 @@ FORMULE = FORM( nom='FORMULE',op=ops.build_formule,sd_prod=formule, # 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 GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table, - fr="Génération de la fonction temporelle à partir d une matrice interspectrale factorisée", + fr="Génération de la fonction temporelle à partir d une matrice interspectrale", docu="U4.36.05-f",reentrant='n', UIinfo={"groupes":("Fonction",)}, - INTE_SPEC_FACT =SIMP(statut='o',typ=interspfact ), - INIT_ALEA =SIMP(statut='f',typ='I',defaut= 12312745 ), + INTE_SPEC =SIMP(statut='o',typ=tabl_intsp ), + NUME_VITE_FLUI =SIMP(statut='f',typ='I' ), + INTERPOL =SIMP(statut='f',typ='TXM',defaut="OUI",into=("NON","OUI") ), + b_interpol_oui =BLOC(condition = "INTERPOL == 'OUI' ",fr="Parametres cas interpolation autorisee", + DUREE_TIRAGE =SIMP(statut='f',typ='R' ), + FREQ_INIT =SIMP(statut='f',typ='R' ), + FREQ_FIN =SIMP(statut='f',typ='R' ), + ), + NB_POIN =SIMP(statut='f',typ='I'), NB_TIRAGE =SIMP(statut='f',typ='I',defaut= 1 ), - NB_POIN =SIMP(statut='f',typ='I' ), + INIT_ALEA =SIMP(statut='f',typ='I'), INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ), + TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 05/11/2003 AUTEUR CAMBIER S.CAMBIER # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -12064,17 +12487,18 @@ GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table, # 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 GENE_MATR_ALEA=OPER(nom="GENE_MATR_ALEA",op= 27,sd_prod=matr_asse_gene_r, fr="Generateur de matrice aleatoire", docu="U4.36.06-a",reentrant='n', UIinfo={"groupes":("Fonction",)}, MATR_MOYEN = SIMP(statut='o', typ=matr_asse_gene_r), - DELTA = SIMP(statut='f', typ='R', defaut=0.1), - INIT = SIMP(statut='f', typ='TXM', into=("OUI","NON"),defaut="NON"), + COEF_VAR = SIMP(statut='f', typ='R', defaut=0.1), + INIT_ALEA =SIMP(statut='f',typ='I'), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 05/11/2003 AUTEUR CAMBIER S.CAMBIER # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -12092,16 +12516,28 @@ GENE_MATR_ALEA=OPER(nom="GENE_MATR_ALEA",op= 27,sd_prod=matr_asse_gene_r, # 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 GENE_VARI_ALEA=OPER(nom="GENE_VARI_ALEA",op= 28,sd_prod=table, fr="Generateur de variable aleatoire", docu="U4.36.07-a",reentrant='n', UIinfo={"groupes":("Fonction",)}, - TYPE = SIMP(statut='f', typ='TXM', into=("EXP_TRONQUEE", "EXPONENTIELLE", "GAMMA"), defaut="EXP_TRONQUEE"), - VALE_MOY = SIMP(statut='f', typ='R', defaut=0.), - DELTA = SIMP(statut='f', typ='R', defaut=0.1), - A = SIMP(statut='f', typ='R', defaut=-1.), - B = SIMP(statut='f', typ='R', defaut=1.), - INIT = SIMP(statut='f', typ='TXM', into=("OUI","NON"),defaut="NON"), + 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), + ), + INIT_ALEA =SIMP(statut='f',typ='I'), ) ; @@ -12210,7 +12646,7 @@ IMPR_CO=PROC(nom="IMPR_CO",op=17,docu="U4.91.11-g", POSITION =SIMP(statut='f',typ='I',defaut=1), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 16/12/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -12248,6 +12684,11 @@ IMPR_COURBE=PROC(nom="IMPR_COURBE",op= 141,fr="Impression, sur fichiers", LEGENDE_Y =SIMP(statut='f',typ='TXM',fr="Légende associée à l axe des ordonnées" ), FREQ_GRILLE_X =SIMP(statut='f',typ='I',defaut= 0,fr="Fréquence de tracage du quadrillage vertical" ), FREQ_GRILLE_Y =SIMP(statut='f',typ='I',defaut= 0,fr="Fréquence de tracage du quadrillage horizontal" ), + TRI =SIMP(statut='f',typ='TXM',defaut="N", + fr="Choix du tri effectué sur les abcisses ou sur les ordonnées", + into=("N","X","Y","XY","YX") ), + FREQ_MARQUEUR =SIMP(statut='f',typ='I',defaut= 0, + fr="Fréquence d impression du marqueur associé à la courbe", ), ), b_excel = BLOC(condition = "(FORMAT=='EXCEL')",fr="Mots-clés propres au format Excel", BORNE_X =SIMP(statut='f',typ='R',min=2,max=2,fr="Intervalles de variation des abcisses"), @@ -12328,13 +12769,6 @@ IMPR_COURBE=PROC(nom="IMPR_COURBE",op= 141,fr="Impression, sur fichiers", "PLUS","X","CERCLE","CERCLE_P","CARRE_P", "LOSANGE_P","CERCLE_P_X","LOSANGE_P_X", "CERCLE_X","CARRE_X","LOSANGE_X") ), - b_agraf =BLOC(condition = "(FORMAT=='AGRAF')",fr="Mots-clés propres à AGRAF", - TRI =SIMP(statut='f',typ='TXM',defaut="N", - fr="Choix du tri effectué sur les abcisses ou sur les ordonnées", - into=("N","X","Y","XY","YX") ), - FREQ_MARQUEUR =SIMP(statut='f',typ='I',defaut= 0, - fr="Fréquence d impression du marqueur associé à la courbe", ), - ), ), ) ; @@ -12896,7 +13330,7 @@ IMPR_MISS_3D=PROC(nom="IMPR_MISS_3D",op= 162, TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 06/01/2004 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -12931,7 +13365,7 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39,docu="U4.91.01-g", ), b_format_gmsh =BLOC(condition="FORMAT=='GMSH'",fr="version post traitement de GMSH", - VERSION =SIMP(statut='f',typ='R',defaut=1.0,into=(1.0,1.2)), + VERSION =SIMP(statut='f',typ='R',defaut=1.2,into=(1.0,1.2)), ), regles=(AU_MOINS_UN('CHAM_GD','RESULTAT','MAILLAGE'), @@ -12983,7 +13417,7 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39,docu="U4.91.01-g", ), b_cmp=BLOC(condition="""((CHAM_GD != None)or(RESULTAT != None))and\ - ((FORMAT == 'RESULTAT')or(FORMAT == 'IDEAS')or(FORMAT == 'ENSIGHT')or(FORMAT == 'MED'))""", + ((FORMAT == 'CASTEM')or(FORMAT == 'RESULTAT')or(FORMAT == 'IDEAS')or(FORMAT == 'ENSIGHT')or(FORMAT == 'MED'))""", fr="sélection des composantes", regles=(EXCLUS('TOUT_CMP','NOM_CMP'),), TOUT_CMP =SIMP(statut='f',typ='TXM',into=("OUI",) ), @@ -14969,7 +15403,7 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=-17,sd_prod=macr_aspic_calc_prod, ) ; # debut entete -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 19/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -14988,7 +15422,10 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=-17,sd_prod=macr_aspic_calc_prod, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== # RESPONSABLE F1BHHAJ J.ANGLES -MACR_ASPIC_MAIL=MACRO(nom="MACR_ASPIC_MAIL",op= -16,sd_prod=maillage,reentrant='n', + +from Macro.macr_aspic_mail_ops import macr_aspic_mail_ops + +MACR_ASPIC_MAIL=MACRO(nom="MACR_ASPIC_MAIL",op= macr_aspic_mail_ops,sd_prod=maillage,reentrant='n', fr=" ",docu="U4.pc.10-b", UIinfo={"groupes":("Outils métier",)}, @@ -15408,7 +15845,7 @@ MACR_ELEM_DYNA=OPER(nom="MACR_ELEM_DYNA",op= 81,sd_prod=macr_elem_dyna, "DIAG_MASS") ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 21/01/2004 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -15448,7 +15885,6 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,docu="U4.6 RIGI_MECA =FACT(statut='f', ), MASS_MECA =FACT(statut='f', - BIDO1 =SIMP(statut='f',typ='I',defaut=0), ), CAS_CHARGE =FACT(statut='f',max='**', NOM_CAS =SIMP(statut='o',typ='TXM'), @@ -15458,6 +15894,451 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,docu="U4.6 ), ) ; +#& MODIF COMMANDE DATE 16/01/2004 AUTEUR GNICOLAS G.NICOLAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS + +from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops + +MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops, + fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.", + ang="Print values for the fiability software", + docu="U7.04.41-a", +# +# 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, + 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, + fr="Table contenant le gradient.", + ang="Table which includes the gradient."), +# +# 3.2. ==> 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 16/01/2004 AUTEUR GNICOLAS G.NICOLAS +# CONFIGURATION MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# ====================================================================== +# RESPONSABLE GNICOLAS G.NICOLAS + +from Macro.macr_fiabilite_ops import macr_fiabilite_ops + +# +#==== +# 1. Le retour : une liste de rééls. +#==== +# +def macr_fiabilite_prod ( self , **args ): + return listr8 +# +#==== +# 2. L'entete +#==== +# +MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops, + sd_prod=macr_fiabilite_prod, + fr="Faire de la mécanique fiabiliste.", + ang="Fiability mechanics.", + docu="U7.03.31-a", +# +#==== +# 3. Le niveau d'information +#==== +# + INFO = SIMP(statut="f",typ="I",defaut=1,into=(1,2)), +# +#==== +# 4. Nom et Version du logiciel de fiabilité +#==== +# + LOGICIEL = SIMP(statut="f",typ="TXM",defaut="MEFISTO", + into=("MEFISTO",), + fr="Nom du logiciel de fiabilité.", + ang="Fiability software name."), +# + VERSION = SIMP(statut="f",typ="TXM",defaut="V3_2", + into=("V3_2", "V3_N"), + fr="Version du logiciel de fiabilité.", + ang="Fiability software release."), +# +#==== +# 5. Les entrees-sorties du calcul ASTER déterministe +#==== +# +# 5.1. ==> Le jeu de commandes déterministe +# + UNITE_ESCL = SIMP(statut="o",typ="I", + fr="Unité logique associée aux commandes du calcul ASTER déterministe.", + ang="Logical unit for the commands of the ASTER deterministic calculation."), +# +# 5.2. ==> Le destin des messages produits par ASTER +# + MESS_ASTER = SIMP(statut="f",typ="TXM",defaut="DERNIER", + into=("AUCUN", "DERNIER", "TOUS"), + fr="Quels messages ASTER récupérer.", + ang="Which ASTER messages must be kept."), +# +#==== +# 6. Options +#==== +# 6.1. ==> Générales +# +# 6.1.1. ==> La valeur du seuil +# + SEUIL = SIMP(statut="o",typ="R",max=1, + fr="Le seuil de défaillance.", + ang="Failure threshold."), +# +# 6.1.2. ==> Le type du seuil : on a deux cas de figure selon que +# la défaillance a lieu au dessus d'un seuil maximum ou +# en dessous d'un seuil minimum +# + SEUIL_TYPE = SIMP(statut="o",typ="TXM",max=1, + into=("MINIMUM","MAXIMUM"), + fr="Que faut-il ne pas dépasser : un maximum ou un minimum.", + ang="What is the failure threshold : maximum or minimum."), +# +# 6.2. ==> Pour MEFISTO +# +### en attente de résolution de AL 2004-006 (1/2) b_mefisto=BLOC( condition = "LOGICIEL=='MEFISTO'", +# +# 6.2.1. ==> Pilotage de la recherche du point de conception +# + RECH_PT_CONCEPT = SIMP(statut="f",typ="TXM",defaut="OUI", + into=("OUI","NON"), + fr="Pour trouver le point de conception.", + ang="To find the design point."), +# + b_rech_pt_concept=BLOC( condition = "RECH_PT_CONCEPT=='OUI'", +# + EPSILON_U = SIMP(statut="f",typ="R",defaut=1.0E-2, + fr="Précision du test d'arret sur les points itératifs dans l'espace standard.", + ang="Precision of stop test for iterative points in standard space."), +# + EPSILON_G = SIMP(statut="f",typ="R",defaut=1.0E-2, + fr="Précision du test d'arret sur la proximité de la surface d'état limite.", + ang="Precision of stop test for limit state surface."), +# + TAU = SIMP(statut="f",typ="R",defaut=5.0E-1, + fr="Paramètre de la méthode de minimisation.", + ang="Parameter for the minimization method."), +# + OMEGA = SIMP(statut="f",typ="R",defaut=1.0E-4, + fr="Paramètre de la méthode de minimisation.", + ang="Parameter for the minimization method."), +# + ITER_MAX = SIMP(statut="f",typ="I",defaut=50, + fr="Nombre maximum d'itérations.", + ang="Maximum number of iterations."), + ), +# +# 6.2.2. ==> Méthode(s) employée(s) pour la probabilité de défaillance +# + METHODE_FORM = SIMP(statut="f",typ="TXM",defaut="OUI", + into=("OUI","NON"), + fr="Recherche de la probabilité de défaillance avec la méthode FORM.", + ang="Research of failure probability with FORM method."), +# + METHODE_SORM = SIMP(statut="f",typ="TXM",defaut="NON", + into=("OUI","NON"), + fr="Recherche de la probabilité de défaillance avec la méthode SORM.", + ang="Research of failure probability with SORM method."), +# + TIRAGE_IMPORTANCE = SIMP(statut="f",typ="TXM",defaut="NON", + into=("OUI","NON"), + fr="Recherche de la probabilité de défaillance avec le tirage d'importance.", + ang="Research of failure probability with ."), +# + b_tirage_importance=BLOC( condition = "TIRAGE_IMPORTANCE=='OUI'", +# + NB_SIMULATION = SIMP(statut="f",typ="I",defaut=3, + fr="Nombre de simulations pour le tirage d'importance.", + ang="Number of simulation for."), +# + ), +# +# 6.2.3. ==> Création d'une surface de réponse polynomiale +# + POLYNOME_TAYLOR = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"),), + HGRAD = SIMP(statut="f",typ="R",defaut=1.0E-2, + fr="Pas incrémental pour le calcul des gradients.", + ang="Step for calculation of gradients."), + HHESS = SIMP(statut="f",typ="R",defaut=1.0E-2, + fr="Pas incrémental pour le calcul des dérivées secondes.", + ang="Step for calculation of second derivatives."), +# +# 6.2.4. ==> Recherche d'un plan d'expérience +# + PLAN_EXPERIENCE = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"), + fr="Construction d'un plan d'expérience.", + ang="Construction of an experiment plan."), +# + b_plan_experience=BLOC( condition = "PLAN_EXPERIENCE=='OUI'", +# + ALPHA = SIMP(statut="f",typ="R",defaut=2.0E-1, + fr="Plan d'expérience : maille du plan de type composite centré.", + ang="Experiment plane : mesh centered composite."), +# + BETA = SIMP(statut="f",typ="R",defaut=4.0E-1, + fr="Plan d'expérience : maille du plan de type factoriel.", + ang="Experiment plane : mesh factor."), +# + ), +# +# 6.2.5. ==> Les tests +# 6.2.5.1. ==> Test de la sphere +# + T_SPHERE = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"), + fr="Test de la sphère.", + ang="Sphere test."), +# + b_test_de_la_sphere=BLOC( condition = "T_SPHERE=='OUI'", +# + METHODE_TEST = SIMP(statut="f",typ="TXM",defaut="GAUSSIENNE", + into=("GAUSSIENNE","PARAMETRIQUE","REJECTION"), + fr="Type de méthode.", + ang="Method."), +# + NB_POINT = SIMP(statut="f",typ="I",max=1,defaut=60, + fr="Nombre de points de la sphere.", + ang="Number of points over the sphere.") + ), +# +# 6.2.5.2. ==> Test du maximum fort +# + T_MAXIMUM_FORT = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"), + fr="Test du maximum fort.", + ang="Strong maximum test."), +# + b_test_du_maximum_fort=BLOC( condition = "T_MAXIMUM_FORT=='OUI'", +# + COS_LIM = SIMP(statut="f",typ="R",max=1,defaut=1.0, + fr="Cosinus de l'angle d'exclusion.", + ang="Cosine of angle of exclusion."), +# + DPROB = SIMP(statut="f",typ="R",max=1,defaut=4.3E-1, + fr="Fraction d'iso-densité de probabilité de défaillance.", + ang="Fraction.") +# + ), +# +# 6.2.5.3. ==> Test du hessien +# + T_HESSIEN = SIMP(statut="f",typ="TXM",defaut="NON",into=("OUI","NON"), + fr="Test du hessien.", + ang="Hessian test."), +# +# 6.2.6. ==> Les correlations entre les variables +# + MATRICE = SIMP(statut="o",typ="R",max="**", + fr="Matrice de corrélation entre les variables.", + ang="Correlation matrix."), +# +### en attente de résolution de AL 2004-006 (2/2) ), +# +#==== +# 7. Definition des paramètres +#==== +# + VARIABLE = FACT(statut="o",min=1,max="**", +# +# 7.1. ==> Nom de la variable +# + NOM = SIMP(statut="o",typ="TXM", + fr="Nom de la variable, identique au nom de concept PARA_SENSI.", + ang="Name of the variable, identical to the name of the PARA_SENSI conceipt."), +# +# 7.2. ==> Loi de distribution +# + LOI = SIMP(statut="o",typ="TXM", + into=("UNIFORME","NORMALE","LOGNORMALE","NORMALE_TRONQUEE"), + fr="Choix de la loi", + ang="Law."), +# +# 7.2.1. ==> Loi normale +# + b_normale=BLOC(condition="LOI=='NORMALE'", +# + VALE_MOY = SIMP(statut="o",typ="R",max=1, + fr="Valeur moyenne.", + ang="Mean value."), +# + ECART_TYPE = SIMP(statut="o",typ="R",max=1, + fr="Ecart type.", + ang="Standard deviation."), +# + ), +# +# 7.2.2. ==> Loi lognormale +# + b_lognormale=BLOC(condition="LOI=='LOGNORMALE'", +# + VALE_MIN = SIMP(statut="o",typ="R",max=1, + fr="Valeur minimale.", + ang="Minimal value."), +# + VALE_MOY = SIMP(statut="f",typ="R",max=1, + fr="Valeur moyenne dans l'espace de la loi normale.", + ang="Mean value in the space of the normal law."), +# + ECART_TYPE = SIMP(statut="f",typ="R",max=1, + fr="Ecart type dans l'espace de la loi normale.", + ang="Standard deviation in the space of the normal law."), +# + VALE_MOY_PHY = SIMP(statut="f",typ="R",max=1, + fr="Valeur moyenne dans l'espace physique.", + ang="Mean value in the physical space."), +# + ECART_TYPE_PHY = SIMP(statut="f",typ="R",max=1, + fr="Ecart type dans l'espace physique.", + ang="Standard deviation in the physical space."), +# + regles=(AU_MOINS_UN("VALE_MOY" ,"VALE_MOY_PHY"), + AU_MOINS_UN("ECART_TYPE","ECART_TYPE_PHY"), + EXCLUS ("VALE_MOY" ,"VALE_MOY_PHY"), + EXCLUS ("VALE_MOY" ,"ECART_TYPE_PHY"), + EXCLUS ("ECART_TYPE","VALE_MOY_PHY"), + EXCLUS ("ECART_TYPE","ECART_TYPE_PHY")), +# + ), +# +# 7.2.3. ==> Loi uniforme +# + b_uniforme=BLOC(condition="LOI=='UNIFORME'", +# + VALE_MIN = SIMP(statut="o",typ="R",max=1, + fr="Valeur minimale.", + ang="Minimal value."), +# + VALE_MAX = SIMP(statut="o",typ="R",max=1, + fr="Valeur maximale.", + ang="Maximal value."), +# + ), +# +# 7.2.4. ==> Loi normale tronquée +# + b_normale_tronquee=BLOC(condition="LOI=='NORMALE_TRONQUEE'", +# + VALE_MOY = SIMP(statut="o",typ="R",max=1, + fr="Valeur moyenne de la loi normale complète.", + ang="Mean value for the entire normal law."), +# + ECART_TYPE = SIMP(statut="o",typ="R",max=1, + fr="Ecart type de la loi normale complète.", + ang="Standard deviation for the entire normal law."), +# + VALE_MIN = SIMP(statut="o",typ="R",max=1, + fr="Valeur minimale.", + ang="Minimal value."), +# + VALE_MAX = SIMP(statut="o",typ="R.",max=1, + fr="Valeur maximale.", + ang="Maximal value."), +# + ), +# +# 7.3. ==> Paramètres de calcul +# 7.3.1. ==> Soit on cherche le point de conception, soit on le connait deja +# + regles=(EXCLUS("POINT_INI","POINT_CONCEPT"), + EXCLUS("POINT_REF","POINT_CONCEPT"),), +# +# 7.3.2. ==> Quand on cherche le point de conception, on peut préciser le départ de l'algorithme. +# Si on ne le fait pas, le programme prendra la valeur moyenne. +# + POINT_INI = SIMP(statut="f",typ="R",max=1, + fr="Point de démarrage de l'algorithme itératif.", + ang="Initial point for iterative process."), +# +# 7.3.3. ==> Quand on cherche le point de conception, on peut préciser un point de référence pour normaliser. +# Si on ne le fait pas, le programme prendra la valeur moyenne. +# + POINT_REF = SIMP(statut="f",typ="R",max=1, + fr="Point de référence de l'algorithme itératif.", + ang="Reference point for iterative process."), +# +# 7.3.4. ==> Quand on cherche uniquement la probabilité de défaillance, il faut donner le point de conception +# + POINT_CONCEPT = SIMP(statut="f",typ="R",max=1, + fr="Point de conception.", + ang="Design point."), +# +# 7.4. ==> Mode d'obtention du gradient par rapport à ce paramètre +# + GRADIENT = SIMP(statut="o",typ="TXM",max=1, + into=("OUI","NON"), + fr="ASTER calcule directement le gradient.", + ang="ASTER computes the gradient for this parameter."), + + b_gradient=BLOC(condition="GRADIENT=='NON'", + INCREMENT = SIMP(statut="o",typ="R",max=1, + fr="Incrément dans la direction.", + ang="Direction increment."), + ), + + ), +# +); + #& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -15715,7 +16596,7 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=macr_ ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 18/11/2003 AUTEUR NICOLAS O.NICOLAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG @@ -15745,6 +16626,7 @@ MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,docu="U4.73.02-a", fr="Réalise le recalage de modèles Aster", 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), @@ -15837,7 +16719,7 @@ MACRO_ELAS_MULT=MACRO(nom="MACRO_ELAS_MULT",op=macro_elas_mult_ops,sd_prod=macro TITRE =SIMP(statut='f',typ='TXM',max='**'), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 13/01/2004 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -15855,17 +16737,20 @@ 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_depl_r) - self.type_sdprod(MATR_MASS_AJOU,matr_asse_depl_r) - self.type_sdprod(MATR_RIGI_AJOU,matr_asse_depl_r) + 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=-13,docu="U4.66.11-c",sd_prod=macro_matr_ajou_prod, +MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,docu="U4.66.11-c",sd_prod=macro_matr_ajou_prod, UIinfo={"groupes":("Matrices/vecteurs",)}, regles=(AU_MOINS_UN('MODE_MECA','DEPL_IMPO','MODELE_GENE'), AU_MOINS_UN('MATR_MASS_AJOU','MATR_AMOR_AJOU','MATR_RIGI_AJOU'), @@ -15890,7 +16775,7 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=-13,docu="U4.66.11-c",sd_prod=mac PRES_FLUIDE =SIMP(statut='f',typ='R'), PRES_SORTIE =SIMP(statut='f',typ='R'), ), - ECOULEMENT =FACT(statut='f',max='**', + 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'), @@ -15937,7 +16822,7 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=-13,docu="U4.66.11-c",sd_prod=mac 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 09/09/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -16513,7 +17398,7 @@ MODE_ITER_INV=OPER(nom="MODE_ITER_INV",op= 44,sd_prod=mode_iter_inv_prod TITRE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 18/11/2003 AUTEUR NICOLAS O.NICOLAS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -16546,7 +17431,7 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op= 45,sd_prod=mode_iter_simult_pr UIinfo={"groupes":("Résolution",)}, 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',position='global',typ=matr_asse_depl_r ), + MATR_C =SIMP(statut='f',position='global',typ=(matr_asse_depl_r,matr_asse_gene_r) ), METHODE =SIMP(statut='f',position='global',typ='TXM',defaut="SORENSEN", into=("TRI_DIAG","JACOBI","SORENSEN") ), b_tri_diag =BLOC(condition = "METHODE == 'TRI_DIAG'", @@ -16583,6 +17468,7 @@ MODE_ITER_SIMULT=OPER(nom="MODE_ITER_SIMULT",op= 45,sd_prod=mode_iter_simult_pr 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", @@ -17238,7 +18124,7 @@ POST_DYNA_MODA_T=OPER(nom="POST_DYNA_MODA_T",op= 130,sd_prod=tabl_post_dyna, TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 04/11/2003 AUTEUR LEBOUVIE F.LEBOUVIER # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -17605,6 +18491,7 @@ POST_ELEM=OPER(nom="POST_ELEM",op=107,sd_prod=post_elem_prod,docu="U4.81.22-e",r 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='f',typ=tabl_cara_geom), + 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), @@ -17783,7 +18670,7 @@ POST_GOUJ2E=OPER(nom="POST_GOUJ2E",op=187,sd_prod=tabl_post_gouj2e,reentrant='n' TABLE =SIMP(statut='o',typ=tabl_post_rele), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 18/11/2003 AUTEUR CIBHHLV L.VIVAN # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -17821,7 +18708,8 @@ POST_K1_K2_K3=OPER(nom="POST_K1_K2_K3",op=188,sd_prod=tabl_post_k, 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='**') + 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, fr="Matériau homogène et isotrope cohérent avec celui utilisé pour le calcul des déplacements"), @@ -18569,30 +19457,6 @@ PRE_IDEAS=PROC(nom="PRE_IDEAS",op=47,docu="U7.01.01-g", CREA_GROUP_COUL =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 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. -# ====================================================================== -PROCEDURE=MACRO(nom="PROCEDURE",op=ops.build_procedure, docu="U4.13.03-f", - UIinfo={"groupes":("Gestion du travail",)}, - fr="Nommer le fichier de commandes secondaires", - NOM =SIMP(statut='f',typ='TXM',defaut=" "), -) ; - #& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18929,7 +19793,7 @@ RECA_WEIBULL=OPER(nom="RECA_WEIBULL",op= 197,sd_prod=tabl_reca_weib, INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ,) ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 06/01/2004 AUTEUR MCOURTOI M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -18980,7 +19844,6 @@ RECU_FONCTION=OPER(nom="RECU_FONCTION",op= 90,sd_prod=recu_fonction_prod, # concept table à créer TABLE =SIMP(statut='f',typ=table), BASE_ELAS_FLUI =SIMP(statut='f',typ=melasflu), - REPERE =SIMP(statut='f',typ='TXM',into=("POLAIRE","GLOBAL") ), OBSTACLE =SIMP(statut='f',typ=obstacle), b_tran_gene = BLOC ( condition = "RESU_GENE != None", @@ -19141,6 +20004,10 @@ RECU_FONCTION=OPER(nom="RECU_FONCTION",op= 90,sd_prod=recu_fonction_prod, NOEUD_CHOC =SIMP(statut='f',typ=no), GROUP_NO_CHOC =SIMP(statut='f',typ=grno), ), + b_obstacle = BLOC ( condition = "OBSTACLE != None", + fr="Choix du repère", + REPERE =SIMP(statut='f',typ='TXM',into=("POLAIRE","GLOBAL") ), + ), ### NOM_PARA =SIMP(statut='f',typ='TXM', into=("DX","DY","DZ","DRX","DRY","DRZ","TEMP", @@ -19407,30 +20274,7 @@ REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=tabl_intsp, TITRE =SIMP(statut='f',typ='TXM',max='**' ), ) ; -#& MODIF COMMANDE DATE 26/09/2003 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. -# ====================================================================== -RETOUR=MACRO(nom="RETOUR",op=ops.build_retour,docu="U4.13.02-f", - UIinfo={"groupes":("Gestion du travail",)}, - fr="Retour au fichier de commandes appelant", -) ; - -#& MODIF COMMANDE DATE 16/09/2003 AUTEUR JMBHH01 J.M.PROIX +#& MODIF COMMANDE DATE 28/10/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -19483,25 +20327,46 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'), MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'), ), - 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_depl_r), - SIGM =SIMP(statut='f',typ=(cham_elem_sief_r,carte_sief_r)), - VARI =SIMP(statut='f',typ=cham_elem_vari_r), - VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_vanl_r), - 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_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_depl_r), + SIGM =SIMP(statut='f',typ=(cham_elem_sief_r,carte_sief_r)), + VARI =SIMP(statut='f',typ=cham_elem_vari_r), + VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_vanl_r), + 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_depl_r), + SIGM =SIMP(statut='f',typ=(cham_elem_sief_r,carte_sief_r)), + VARI =SIMP(statut='f',typ=cham_elem_vari_r), + VARI_NON_LOCAL =SIMP(statut='f',typ=cham_no_vanl_r), + 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'),), @@ -19757,7 +20622,7 @@ TEST_FONCTION=PROC(nom="TEST_FONCTION",op= 135,fr="Extraction d une valeur num ), ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 21/01/2004 AUTEUR CIBHHLV L.VIVAN # RESPONSABLE VABHHTS J.PELLET # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19871,11 +20736,9 @@ TEST_RESU=PROC(nom="TEST_RESU",op=23,docu="U4.92.01-g", ), OBJET =FACT(statut='f',max='**', - regles=(UN_PARMI('INDICE','S_I','S_R','RESUME',), - UN_PARMI('VALE','VALE_I','VALE_C','RESUME','S_R','S_I'),), + 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'), - INDICE =SIMP(statut='f',typ='I'), - NUM_OBJ =SIMP(statut='f',typ='I'), S_R =SIMP(statut='f',typ='R'), S_I =SIMP(statut='f',typ='I'), RESUME =SIMP(statut='f',typ='I'), @@ -20148,27 +21011,27 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,docu="U4.54.02- ) ; -#& MODIF COMMANDE DATE 09/09/2003 AUTEUR DURAND C.DURAND +#& MODIF COMMANDE DATE 17/11/2003 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. +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. # -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. # -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== THER_NON_LINE_MO=OPER(nom="THER_NON_LINE_MO",op= 171,sd_prod=evol_ther, fr="Thermique non lineaire en repere mobile", - docu="U4.54.03-c",reentrant='f', + docu="U4.54.03-c",reentrant='n', UIinfo={"groupes":("Résolution",)}, MODELE =SIMP(statut='o',typ=modele ), CHAM_MATER =SIMP(statut='o',typ=cham_mater ), diff --git a/Aster/Cata/cata_reduit.py b/Aster/Cata/cata_reduit.py index 368e9497..e65ca90f 100755 --- a/Aster/Cata/cata_reduit.py +++ b/Aster/Cata/cata_reduit.py @@ -30,7 +30,7 @@ except: # __version__="$Name: $" -__Id__="$Id: cata_reduit.py,v 1.2 2003/10/16 14:31:22 eficas Exp $" +__Id__="$Id: cata_reduit.py,v 1.3 2003/10/23 12:12:14 eficas Exp $" # JdC = JDC_CATA(code='ASTER', execmodul=None, @@ -509,6 +509,32 @@ PLS_BASE_NOREPEAT=OPER(nom="PLS_BASE_NOREPEAT",op=19,sd_prod=cara_pout, VAR7=SIMP(statut='o',typ='I',min=1,max=6,validators=[NoRepeat(),PairVal()]), ) ; +def toto(**args): + return maillage + +BLOCBLOC=OPER(nom="BLOCBLOC",op=1,sd_prod=toto, + TITI =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + TUTU =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + TATA =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + TOTO =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + b_unit1 =BLOC(condition = "TITI =='AAA'", + TOTO1 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit1 =BLOC(condition = "TOTO1 == 'AAA'", UNITE1 =SIMP(statut='f',typ='I',defaut=25),), + ), + b_unit2 =BLOC(condition = "TUTU =='AAA'", + TOTO2 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit2 =BLOC(condition = "TOTO2 == 'BBB'", UNITE2 =SIMP(statut='f',typ='I',defaut=25),), + ), + b_unit3 =BLOC(condition = "TATA =='BBB'", + TOTO3 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit3 =BLOC(condition = "TOTO3 == 'BBB'", UNITE3 =SIMP(statut='f',typ='I',defaut=25),), + ), + b_unit4 =BLOC(condition = "TOTO =='BBB'", + TOTO4 =SIMP(statut='f',typ='TXM',defaut='AAA',into=('AAA','BBB'),), + c_unit4 =BLOC(condition = "TOTO4 == 'AAA'", UNITE4 =SIMP(statut='f',typ='I',defaut=25),), + ), + ) + #& MODIF COMMANDE DATE 21/03/2003 AUTEUR ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -574,3 +600,31 @@ FIN=PROC(nom="FIN",op=9999,repetable='n',fr="Fin d'une FICHIER =SIMP(statut='f',typ='TXM',defaut="MESSAGE"), ) ; +FORMULE = FORM( nom='FORMULE',op=ops.build_formule,sd_prod=formule, + docu="U4.31.05-e", + fr="Définition d une fonction",reentrant = 'n', + regles=(UN_PARMI('REEL','COMPLEXE'),), + +##### fonctions entieres interdites suite au probleme AL2003-072 +##### regles=(UN_PARMI('REEL','ENTIER','COMPLEXE'),), +##### ENTIER = SIMP(typ = 'shell',), + + REEL = SIMP(typ = 'shell',), + COMPLEXE = SIMP(typ = 'shell',), +) ; + +DETRUIRE=PROC(nom="DETRUIRE",op=-7,docu="U4.14.01-e", + UIinfo={"groupes":("Gestion du travail",)}, + fr="Destruction d un concept utilisateur dans la base GLOBALE", + op_init=ops.detruire, + regles=(UN_PARMI('CONCEPT','OBJET',),), + CONCEPT =FACT(statut='f', + NOM =SIMP(statut='o',typ=assd,validators=NoRepeat(),max='**'), + ), + OBJET =FACT(statut='f', + CHAINE =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**'), + POSITION =SIMP(statut='o',typ='I' ,validators=NoRepeat(),max='**'), + ), + INFO =SIMP(statut='f',typ='I',into=(1,2),defaut=2, ), +); + diff --git a/Aster/Cata/ops.py b/Aster/Cata/ops.py index 841a3e56..6010f7be 100644 --- a/Aster/Cata/ops.py +++ b/Aster/Cata/ops.py @@ -1,4 +1,4 @@ -#@ MODIF ops Cata DATE 06/09/2003 AUTEUR D6BHHJP J.P.LEFEBVRE +#@ MODIF ops Cata DATE 12/11/2003 AUTEUR DURAND C.DURAND # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG @@ -69,7 +69,7 @@ def build_debut(self,**args): self.definition.op=None return ier -def POURSUITE(self,PAR_LOT,CODE,HDF,**args): +def POURSUITE(self,PAR_LOT,CODE,HDF=None,**args): """ Fonction sdprod de la macro POURSUITE """ @@ -197,12 +197,6 @@ def detruire(self,d): if d.has_key(e):del d[e] if self.jdc.sds_dict.has_key(e):del self.jdc.sds_dict[e] else: -#CCAR: ajout de ce test pour ne pas détruire une formule. Faut-il le reintegrer -# dans le catalogue d'Aster ? Est-il spécial EFICAS ? - if isinstance(mcs,formule): - cr=self.parent.report() - cr.fatal("la destruction d'une FORMULE est impossible" ) -#CCAR: fin ajout if isinstance(mcs,ASSD): sd.append(mcs) mcs=mcs.nom