Sprout from BR_dev_V1_14 2008-10-10 13:48:46 UTC Pascale Noyret <pascale.noyret@edf.fr> 'Merge avec Salome Meca'
Delete:
Aster/Cata/cataSTA9/Intranet/__init__.py
Aster/Cata/cataSTA9/Intranet/calc_eolienne.py
Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_cata.py
Aster/Cata/cataSTA9/Intranet/macr_cabri_calc_ops.py
Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_cata.py
Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_dat.py
Aster/Cata/cataSTA9/Intranet/macr_cabri_mail_ops.py
Aster/Cata/cataSTA9/Intranet/macro_bascule_schema_ops.py
Editeur/Patrons/OPENTURNS/Anne.comm
Openturns/Open_Cata_IDM_V5.py
Openturns/Open_Cata_IDM_V6.py
Openturns/Open_Cata_IDM_V7.py
Openturns/editeur.ini
Openturns/eficas_openturns.py
Openturns/prefs.py
Openturns/properties.py
Openturns/qtEficas_openturns.py
Openturns/sdistOTqt.py
Openturns/style.py
+++ /dev/null
-#@ MODIF __init__ Intranet DATE 18/09/2007 AUTEUR DURAND C.DURAND
-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
+++ /dev/null
-#@ MODIF calc_eolienne Intranet DATE 18/09/2007 AUTEUR DURAND C.DURAND
-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-#
-# LISTE DES FONCTIONS, MACROS et CATALOGUES
-#
-# MACROS
-#
-# calc_char_houle
-# macr_calc_eolienne
-#
-# FONCTIONS
-#
-# mail_eolienne
-# eolien_regression
-# lect_resu_stream
-# donn_boucle_pas_temps
-# extr_char_houle
-#
-# CATALOGUES
-#
-# CALC_CHAR_HOULE
-# MACR_CALC_EOLIENNE
-#
-#____________________________________________________________________
-#
-# On charge les modules necessaires
-import os
-import Numeric
-import re
-import math
-#
-# permet de definir dans le meme fichier les catalogues et les macros
-from Cata.cata import *
-#
-#____________________________________________________________________
-#____________________________________________________________________
-#
-#____________________________________________________________________
-#___________________ DEBUT MACRO calc_char_houle ____________________
-#
-#
-def calc_char_houle_ops(self, INFO, STREAM, IMPRESSION, **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.
-
- """ Calcule le chargement du a la houle. """
-
-# On charge les modules nécessaires
- from Accas import _F
- import aster
-
-#____________________________________________________________________
-#
-# 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")
- IMPR_TABLE= self.get_cmd("IMPR_TABLE")
- DEFI_FICHIER= self.get_cmd("DEFI_FICHIER")
-
-# 1.3 ==> Le nom des programmes à lancer
-
-# repertoire_outils = "/home/eolien/ASTER_EOLIEN/"
- repertoire_outils = aster.repout()
- calc_houle = repertoire_outils + "calc_houle"
-
-# 1.4 ==> Initialisations
-
- erreur = 0
- erreur_partiel = [0]
- Rep_Calc_ASTER = os.getcwd()
-
- messages_erreur = { 0 : "<CALC_CHAR_HOULE> Tout va bien.",
- 1 : "<CALC_CHAR_HOULE> Impossible de créer le répertoire de travail pour le logiciel de calcul de houle.",
- 100 : "<CALC_CHAR_HOULE> Erreur." }
-
- while not erreur :
-
-#____________________________________________________________________
-#
-# 2. Répertoires et fichiers
-#____________________________________________________________________
-#
-
-# 2.1. ==> Création du répertoire pour l'exécution du logiciel STREAM_FM
-
- Nom_Rep_local_houle = "tmp_stream"
- Rep_Calc_LOGICIEL_local_houle = os.path.join(".",Nom_Rep_local_houle)
- Rep_Calc_LOGICIEL_global_houle = os.path.join(Rep_Calc_ASTER,Nom_Rep_local_houle)
-
- try :
- os.mkdir(Rep_Calc_LOGICIEL_global_houle)
- 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 calcul de houle : "+Rep_Calc_LOGICIEL_global_houle)
- erreur = 1
- break
-
-# 2.2. ==> On cree un fichier annexe pour transmettre des infos à la procédure de lancement
-# de STREAM_FM
-
- fic_Info_ASTER = os.path.join(Rep_Calc_LOGICIEL_global_houle,"InfoExecASTER")
- f_execAster = open(fic_Info_ASTER, "w")
- f_execAster.write(str(INFO)+"\n")
- f_execAster.close()
-
-#____________________________________________________________________
-#
-# 3. Décodage des arguments de la macro-commande
-# et création des fichiers pour STREAM_FM
-#____________________________________________________________________
-
-# 3.1. ==> Les fichiers pour le logiciel STREAM_FM
-# Ils sont créés dans le répertoire d'exécution du logiciel, avec leurs noms officiels
-
- fic_data_HT = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_HT.par")
- fic_data_FM = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_FM.par")
-
-# 3.2 ==> Construction du fichier 'data_HT'
-
-# 3.2.1 ==> Ouverture du fichier data_HT dans un répertoire temporaire
-
- f_menu = open(fic_data_HT, "w")
-
-# 3.2.2 ==> Lecture et écriture des données nécessaires
-
- prof = STREAM['PROFONDEUR']
- h_houle = STREAM['H_HOULE']
- peri_houle = STREAM['PERI_HOULE']
- courant_euler = STREAM['COUR_EULERIEN']
- ordre_fonc = STREAM['ORDR_FONC_COURAN']
-
- f_menu.write(str(prof)+" <= Profondeur d'eau (m)\n")
- f_menu.write(str(h_houle)+" <= Hauteur de houle (crete-a-creux) (m)\n")
- f_menu.write(str(peri_houle)+" <= Periode de houle (s)\n")
- f_menu.write(str(courant_euler)+" <= Vitesse du courant eulerien (m/s)\n")
- f_menu.write(str(ordre_fonc)+" <= ordre de la fonction de courant (m/s)\n")
-
-# 3.2.3 ==> Fermeture du fichier data_HT
-
- f_menu.close()
-
- if INFO >= 2 :
- print "===========================\n"
- print "Contenu du fichier data_HT :"
- fichier = open (fic_data_HT,"r")
- les_lignes = fichier.readlines()
- fichier.close()
- for ligne in les_lignes :
- print ligne[:-1]
- print "===========================\n"
-
-# 3.3 ==> Construction du fichier "data_FM"
-
-# 3.3.1 ==> Ouverture du fichier
-
- f_FM = open(fic_data_FM, "w")
-
-# 3.3.2 ==> Lecture et écriture des données nécessaires
-
- diam = STREAM['DEXT_HAUT_BASE']
- coef_trainee = STREAM['COEF_TRAINEE']
- coef_inertie = STREAM['COEF_INERTIE']
- nb_nive_z = STREAM['NB_POINTS_VERT']
- nb_dt_par_t = STREAM['NB_INTER_PERI']
-
- f_FM.write(str(diam)+" <= Diametre du cylindre (m)\n")
- f_FM.write(str(coef_trainee)+" <= Coefficient de trainee Cd\n")
- f_FM.write(str(coef_inertie)+" <= Coefficient d'inertie Cm\n")
- f_FM.write(str(nb_nive_z)+" <= Nbe de points sur la verticale\n")
- f_FM.write(str(nb_dt_par_t)+" <= Nbe de pas de temps sur une periode de houle\n")
-
-# 3.3.3 ==> Fermeture du fichier data_FM
-
- f_FM.close()
-
- if INFO >= 2 :
- print "===========================\n"
- print "Contenu du fichier data_FM :"
- fichier = open (fic_data_FM,"r")
- les_lignes = fichier.readlines()
- fichier.close()
- for ligne in les_lignes :
- print ligne[:-1]
- print "===========================\n"
-
-# 3.4 ==> Nom du fichier qui contiendra le résultat
-
- if (IMPRESSION['UNITE'] != None) :
- Unit_Fich_Resu = 'fort.'+str(IMPRESSION['UNITE'])
-
-#____________________________________________________________________
-#
-# 4. Ecriture de la commande d"exécution du logiciel STREAM
-#
-# Remarque : dans la donnée de la version du logiciel STREAM, 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="aster"
- LOGICIEL = "STREAM"
-
- EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_LOGICIEL_global_houle, # nom du repertoire du calcul de houle
- LOGICIEL, # nom du logiciel de calcul de houle
- VERSION, # version du logiciel de calcul de houle
- ),
- LOGICIEL = calc_houle
- )
-
-#____________________________________________________________________
-#
-# 5. Lecture du fichier de résultats STREAM_FM
-#____________________________________________________________________
-#
-# 5.1 ==> Ouverture, lecture et fermeture du fichier "AMA_FM.res"
-
- if (IMPRESSION['UNITE'] != None) :
- fic_resuStream = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_FM.res")
- f_resu = open(fic_resuStream, "r")
- lignes = f_resu.readlines()
- f_resu.close()
-
- Fic_Tabl_Resu = os.path.join(Rep_Calc_ASTER,Unit_Fich_Resu)
- f_resu = open(Fic_Tabl_Resu, "w")
- f_resu.writelines(lignes)
- f_resu.close()
-#
-#____________________________________________________________________
-#
-# 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])
-
- return
-
-#____________________________________________________________________
-#____________________ FIN MACRO calc_char_houle _____________________
-#
-#____________________________________________________________________
-#___________________ DEBUT FONCTION mail_eolienne ___________________
-#
-#
-# ===> Creation des fichiers de commandes GIBI
-#____________________________________________________________________
-#
-
-def mail_eolienne(H_TOTALE, H_BASE, H_IMMERGEE, H_MOYEU, H_JONCTION, DECAL_PALES,
- DEXT_NACELLE, EPAIS_NACELLE, DEXT_HAUT_BASE, DEXT_BAS_BASE,
- EPAIS_HAUT_BASE, EPAIS_BAS_BASE, DEXT_HAUT_FUT, DEXT_BAS_FUT,
- EPAIS_HAUT_FUT, EPAIS_BAS_FUT, NB_ELEM_BASE, NB_ELEM_FUT,
- NBEL_EPAIS_BASE, NBEL_EPAIS_FUT, NBEL_DCIR_BASE, NBEL_DCIR_FUT,
- ANGLE_VENT_AXE_X,
- MODELISATION, TYPE_ELEM, NIVE_GIBI, fichier_datg) :
-
-#
-# 1 ==> Reccuperation du repertoire dans lequel s'execute le calcul ASTER
-#
- Rep_Calc_ASTER = os.getcwd()
-
-#
-# 2 ==> Decoupage des mailles de la base en fonction du niveau d'eau
-#
- lb = H_BASE / NB_ELEM_BASE
- nbi = int(H_IMMERGEE/lb)
- hbe = H_BASE - H_IMMERGEE
-
- # CAS 1
- if ( ((H_IMMERGEE/lb)-nbi) < 0.5 ) :
- lbi = H_IMMERGEE/nbi
- if (hbe > 0.0) :
- nbe = NB_ELEM_BASE - nbi
- lbe = hbe/nbe
- else :
- nbe = 0
- # CAS 2
- if ( ((H_IMMERGEE/lb)-nbi) >= 0.5 ) :
- lbi = H_IMMERGEE/(nbi+1)
- nbe = NB_ELEM_BASE - (nbi+1)
- lbe = hbe/nbe
- nbi = nbi + 1
-
-#
-# 3 ==> Ecriture des donnees necessaires dans le fichier auxiliaire
-#
- if MODELISATION == 'POUTRE' :
-
- # 3.1 ==> Ouverture du fichier auxiliaire
-
- fichier_auxi = os.path.join(Rep_Calc_ASTER,"fichaux")
- fdaux = open (fichier_auxi,'w')
-
- # 3.2 ==> Ecriture des donnees dans le fichier auxiliaire
-
- j = 0
-
- for i in range(nbi) :
- j = j+1
- fdaux.write("base"+str(j)+" = baset . "+str(j)+";\n")
- if hbe > 0.0 :
- for i in range(nbe) :
- j = j+1
- fdaux.write("base"+str(j)+" = baset . "+str(j)+";\n")
-
- for i in range(NB_ELEM_FUT) :
- fdaux.write("fut"+str(i+1)+" = futt . "+str(i+1)+";\n")
-
- fdaux.write("SAUV FORM eolienne;\n")
- fdaux.write("FIN;\n")
-
- # 3.3 ==> Fermeture du fichier auxiliaire
-
- fdaux.close()
-
-#
-# 4 ==> Ecriture des donnees necessaires dans le fichier de donnees GIBI
-#
-
-# 4.1 ==> Ouverture du fichier de données GIBI
-
- fdgib = open (fichier_datg,'w')
-
-
-# 4.2 ==> Ecriture des donnees dans le fichier de donnees GIBI
-
- fdgib.write("*********************************\n")
- fdgib.write("** Maillage d'une eolienne en mer\n")
- fdgib.write("*********************************\n")
- fdgib.write("***********************\n")
- fdgib.write("***********************\n")
- fdgib.write("** donnees geometriques\n")
- fdgib.write("***********************\n")
-
- fdgib.write("opti nive "+str(NIVE_GIBI)+";\n")
-
- if MODELISATION == 'POUTRE' :
- fdgib.write("modbase = 'poutre';\n")
- fdgib.write("modfut = 'poutre';\n")
- if MODELISATION == 'COQUE' :
- fdgib.write("modbase = 'coque';\n")
- fdgib.write("modfut = 'coque';\n")
- if MODELISATION == '3D' :
- fdgib.write("modbase = '3D';\n")
- fdgib.write("modfut = '3D';\n")
- if TYPE_ELEM == 'CUB8' : fdgib.write("quad = 'non';\n")
- if TYPE_ELEM == 'CU20' : fdgib.write("quad = 'oui';\n")
-
- fdgib.write("**** hauteur totale du monopode (hors nacelle)\n")
- fdgib.write("h_totale = "+str(H_TOTALE)+";\n")
- fdgib.write("**** hauteur de la base du monopode\n")
- fdgib.write("hb = "+str(H_BASE)+";\n")
- fdgib.write("**** hauteur immergee (deduite du calcul par STREAM)\n")
- fdgib.write("hbi = "+str(H_IMMERGEE)+";\n")
- fdgib.write("**** nombre de mailles immergees de la base\n")
- fdgib.write("nbi = "+str(nbi)+";\n")
- fdgib.write("**** hauteur emergee\n")
- fdgib.write("hbe = "+str(hbe)+";\n")
- fdgib.write("**** nombre de mailles emergees de la base\n")
- fdgib.write("nbe = "+str(nbe)+";\n")
- fdgib.write("**** decoupage vertical\n")
- fdgib.write("nb_base = "+str(NB_ELEM_BASE)+";\n")
- fdgib.write("nb_fut = "+str(NB_ELEM_FUT)+";\n")
- fdgib.write("**** diametre et epaisseur bas du fut\n")
- fdgib.write("dex_bfut = "+str(DEXT_BAS_FUT)+";\n")
- fdgib.write("ep_bfut = "+str(EPAIS_BAS_FUT)+";\n")
- fdgib.write("**** diametre et epaisseur haut du fut\n")
- fdgib.write("dex_hfut = "+str(DEXT_HAUT_FUT)+";\n")
- fdgib.write("ep_hfut = "+str(EPAIS_HAUT_FUT)+";\n")
- fdgib.write("**** diametre et epaisseur bas de la base\n")
- fdgib.write("dex_bbas = "+str(DEXT_BAS_BASE)+";\n")
- fdgib.write("ep_bbas = "+str(EPAIS_BAS_BASE)+";\n")
- fdgib.write("**** diametre et epaisseur haut de la base\n")
- fdgib.write("dex_hbas = "+str(DEXT_HAUT_BASE)+";\n")
- fdgib.write("ep_hbas = "+str(EPAIS_HAUT_BASE)+";\n")
-
- if MODELISATION == '3D' or MODELISATION == 'COQUE' :
- fdgib.write("**** nombre d'elements sur un demi-cercle\n")
- fdgib.write("nbcirfut = "+str(NBEL_DCIR_FUT)+";\n")
- fdgib.write("nbcirbas = "+str(NBEL_DCIR_BASE)+";\n")
- fdgib.write("**** hauteur de la jonction base/fut\n")
- fdgib.write("hbj = "+str(H_JONCTION)+";\n")
- if MODELISATION == '3D' :
- fdgib.write("**** nombre d'elements dans l'epaisseur\n")
- fdgib.write("nbep_fut = "+str(NBEL_EPAIS_FUT)+";\n")
- fdgib.write("nbep_bas = "+str(NBEL_EPAIS_BASE)+";\n")
-
- fdgib.write("**** angle entre la pression du vent et l'axe X (degres)\n")
- fdgib.write("alpha = "+str(ANGLE_VENT_AXE_X)+";\n")
- fdgib.write("**** decalage pales\n")
- fdgib.write("dec0 = "+str(DECAL_PALES)+";\n")
- fdgib.write("**** hauteur moyeu\n")
- fdgib.write("hp0 = "+str(H_MOYEU)+";\n")
-
- fdgib.write("opti echo 0;\n")
-# loc_datg = "/home/eolien/DATG/"
- loc_datg = aster.repdex()
- fdgib.write("* \n")
- fdgib.write(open(os.path.join(loc_datg, 'calc_eolienne.datg'), 'r').read())
-
-# 4.3 ==> Fermeture du fichier de donnees GIBI
-
- fdgib.close()
-
-# 5 ==> FIN
-
- return
-
-#____________________________________________________________________
-#____________________ FIN FONCTION mail_eolienne ____________________
-#
-#____________________________________________________________________
-#
-#____________________________________________________________________
-#_________________ DEBUT FONCTION eolien_regression _________________
-#
-#
-# ===> Regression selon les moindres carres
-#____________________________________________________________________
-#
-#
-def eolien_regression (liste, INFO,) :
-#
-#
-#____________________________________________________________________
-#
-# MOINDRES CARRES
-#____________________________________________________________________
-#
-# Calcul des coefficients teta0, teta1, teta2 et teta3 de
-# l'application qui passe au mieux (au sens des moindres carres)
-# par les couples (profondeur,force lineique).
-
-
-# 1 ==> Initialisation
-
-
-# 2 ==> Nombre de points calcules par STREAM selon l'axe vertical
-
- dim = liste.shape[0]
-
-# Controle : dim == Nb_valeur a voir
-
-# 3 ==> Definition des polynomes
-
- global P0, P1, P2, P3
-
- def P0():
- return 1
-
- def P1(alpha1, x):
- return (x-alpha1)
-
- def P2(alpha1, alpha2, beta2, x):
- return (x-alpha2)*(x-alpha1) - beta2
-
- def P3(alpha1, alpha2, alpha3, beta2, beta3, x):
- return (x-alpha3)*((x-alpha2)*(x-alpha1) - beta2) - beta3*(x-alpha1)
-
-# 4 ==> Definition de la fonction polynomiale de degre 3
-
- def FF3(alpha1, alpha2, alpha3, beta2, beta3, teta0, teta1, teta2, teta3, x):
- return teta0*P0() + teta1*P1(alpha1,x) + teta2*P2(alpha1,alpha2,beta2,x) + teta3*P3(alpha1,alpha2,alpha3,beta2,beta3,x)
-
-# 5 ==> Calcul des coefficients alpha1, alpha2, alpha3, beta2 et beta3
-
- numerateur_alpha1 = 0
- denominateur_alpha1 = 0
- alpha1 = 0
- for i in range(dim) :
- numerateur_alpha1 = numerateur_alpha1 + liste[[i,0]]*P0()**2
- denominateur_alpha1 = denominateur_alpha1 + P0()**2
-
- alpha1 = numerateur_alpha1/denominateur_alpha1
-
- numerateur_alpha2 = 0
- denominateur_alpha2 = 0
- alpha2 = 0
- numerateur_beta2 = 0
- denominateur_beta2 = 0
- beta2 = 0
- for i in range(dim) :
- numerateur_alpha2 = numerateur_alpha2 + liste[[i,0]]*P1(alpha1,liste[[i,0]])**2
- denominateur_alpha2 = denominateur_alpha2 + P1(alpha1,liste[[i,0]])**2
- numerateur_beta2 = numerateur_beta2 + P1(alpha1,liste[[i,0]])**2
- denominateur_beta2 = denominateur_beta2 + P0()**2
-
- alpha2 = numerateur_alpha2/denominateur_alpha2
- beta2 = numerateur_beta2/denominateur_beta2
-
- numerateur_alpha3 = 0
- denominateur_alpha3 = 0
- alpha3 = 0
- numerateur_beta3 = 0
- denominateur_beta3 = 0
- beta3 = 0
- for i in range(dim) :
- numerateur_alpha3 = numerateur_alpha3 + liste[[i,0]]*P2(alpha1,alpha2,beta2,liste[[i,0]])**2
- denominateur_alpha3 = denominateur_alpha3 + P2(alpha1,alpha2,beta2,liste[[i,0]])**2
- numerateur_beta3 = numerateur_beta3 + P2(alpha1,alpha2,beta2,liste[[i,0]])**2
- denominateur_beta3 = denominateur_beta3 + P1(alpha1,liste[[i,0]])**2
-
- alpha3 = numerateur_alpha3/denominateur_alpha3
- beta3 = numerateur_beta3/denominateur_beta3
-
-# 6 ==> Calcul des estimateurs cherches : teta0, teta1, teta2, teta3
-
- numerateur_teta0 = 0
- denominateur_teta0 = 0
- teta0 = 0
- for i in range(dim) :
- numerateur_teta0 = numerateur_teta0 + liste[[i,1]]*P0()
- denominateur_teta0 = denominateur_teta0 + P0()**2
-
- teta0 = numerateur_teta0/denominateur_teta0
-
- numerateur_teta1 = 0
- denominateur_teta1 = 0
- teta1 = 0
- for i in range(dim) :
- numerateur_teta1 = numerateur_teta1 + liste[[i,1]]*P1(alpha1,liste[[i,0]])
- denominateur_teta1 = denominateur_teta1 + P1(alpha1,liste[[i,0]])**2
-
- teta1 = numerateur_teta1/denominateur_teta1
-
- numerateur_teta2 = 0
- denominateur_teta2 = 0
- teta2 = 0
- for i in range(dim) :
- numerateur_teta2 = numerateur_teta2 + liste[[i,1]]*P2(alpha1,alpha2,beta2,liste[[i,0]])
- denominateur_teta2 = denominateur_teta2 + P2(alpha1,alpha2,beta2,liste[[i,0]])**2
-
- teta2 = numerateur_teta2/denominateur_teta2
-
- numerateur_teta3 = 0
- denominateur_teta3 = 0
- teta3 = 0
- for i in range(dim) :
- numerateur_teta3 = numerateur_teta3 + liste[[i,1]]*P3(alpha1,alpha2,alpha3,beta2,beta3,liste[[i,0]])
- denominateur_teta3 = denominateur_teta3 + P3(alpha1,alpha2,alpha3,beta2,beta3,liste[[i,0]])**2
-
- teta3 = numerateur_teta3/denominateur_teta3
-
-# 7 ==> Impression de certains resultats si INFO == 2
-
- if (INFO == 2) :
- print " "
- print "<EOLIEN_REGRESSION> RESULTATS "
- print " "
- print "<EOLIEN_REGRESSION> teta0 = ", teta0
- print "<EOLIEN_REGRESSION> teta1 = ", teta1
- print "<EOLIEN_REGRESSION> teta2 = ", teta2
- print "<EOLIEN_REGRESSION> teta3 = ", teta3
- print " "
-
- print "<EOLIEN_REGRESSION> ===> VERIFICATION INTERPOLATION\n"
- print " No point - profondeur - valeur STREAM - valeur par moindres carres \n"
- for i in range(dim) :
- print ' %3d %12.4f %12.4f %12.4f' % (i+1,liste[[i,0]],liste[[i,1]],FF3(alpha1, alpha2, alpha3, beta2, beta3, teta0, teta1, teta2, teta3,liste[[i,0]]))
-
- return (teta0,teta1,teta2,teta3,alpha1,alpha2,alpha3,beta2,beta3)
-
-#____________________________________________________________________
-#_________________ FIN FONCTION eolien_regression ___________________
-#
-#____________________________________________________________________
-#
-#____________________________________________________________________
-#_________________ DEBUT FONCTION lect_resu_stream __________________
-#
-#
-# ===> Lecture du fichier de resultats STREAM_FM
-#____________________________________________________________________
-#
-
-def lect_resu_stream(INFO) :
-
-# 1 ==> Ouverture, lecture et fermeture du fichier "AMA_FM.res"
-
- Rep_Calc_ASTER = os.getcwd()
- Nom_Rep_local_houle = "tmp_stream"
- Rep_Calc_LOGICIEL_local_houle = os.path.join(".",Nom_Rep_local_houle)
- Rep_Calc_LOGICIEL_global_houle = os.path.join(Rep_Calc_ASTER,Nom_Rep_local_houle)
-
- fic_resuStream = os.path.join(Rep_Calc_LOGICIEL_global_houle,"AMA_FM.res")
- f_resu = open(fic_resuStream, "r")
- lignes = f_resu.readlines()
- f_resu.close()
-
-# 2 ==> Lecture du nombre de points (valeurs de forces lineiques).
-# Lecture du nombre par lequel la periode a ete decoupee
-# ATENTION ==> le nombre de pas de temps est egal a ce nombre plus un.
-
- compt_temps = 0
- compt_valeur = 0
- dict_temps = {}
-
- for i in range(len(lignes)) :
- ligne = lignes[i].split()
- print"<LECT_RESU_STREAM> ligne = ",ligne
- if ligne[0] == "/PERIODE" and ligne[2] == "HOULE.................T........:" :
- periode_houle = float(ligne[len(ligne)-2])
-
- if INFO == 2 :
- print "<I> <MACR_CALC_EOLIENNE> Periode de houle = ",periode_houle
-
- if ligne[0] == "/NB" and ligne[2] == "POINTS" :
- Nb_valeur = int(ligne[len(ligne)-1])
-
- if INFO == 2 :
- print "<I> <MACR_CALC_EOLIENNE> Nb_valeur = ",Nb_valeur
-
- if ligne[0] == "/NB" and ligne[4] == "TEMPS" :
- Nb_pas_temps = int(ligne[len(ligne)-1])
-
- if INFO == 2 :
- print "<I> <MACR_CALC_EOLIENNE> Nb_pas_temps = ",Nb_pas_temps
- break
-
- return(periode_houle,Nb_valeur,Nb_pas_temps,lignes)
-
-#____________________________________________________________________
-#__________________ FIN FONCTION lect_resu_stream ___________________
-#
-#____________________________________________________________________
-#
-#____________________________________________________________________
-#_______________ DEBUT FONCTION donn_boucle_pas_temps _______________
-#
-#
-# ===> Preparation donnees necessaires a la boucle sur les pas de temps
-# et verification du nombre de pas de temps
-#____________________________________________________________________
-#
-
-def donn_boucle_pas_temps(lignes,Nb_pas_temps) :
-
-# 1 ==> Construction du dictionnaire contenant :
-# pas_de_temps : numeros de ligne du fichier resu_STREAM_FM
-
- compt_temps = 0
- dict_temps = {}
-
- for i in range(len(lignes)) :
- ligne = lignes[i].split()
- if len(ligne) != 0 :
- if ligne[0] == "#TITRE" and ligne[1] == "TEMPS" :
- compt_temps = compt_temps + 1
- dict_temps["TEMPS_"+str(compt_temps)] = i+1
-
-# 2 ==> Controle de l'egalite : compt_temps == Nb_pas_temps+1
-# et arret en cas d'erreur.
-
- if compt_temps != (Nb_pas_temps+1) :
- print"\n <F> <DONN_BOUCLE_PAS_TEMPS> IL Y A UN PROBLEME DANS DE NOMBRE DE PAS DE TEMPS.\n"
-
- return(dict_temps)
-#
-#____________________________________________________________________
-#________________ FIN FONCTION donn_boucle_pas_temps ________________
-#
-#____________________________________________________________________
-#
-#____________________________________________________________________
-#__________________ DEBUT FONCTION extr_char_houle __________________
-#
-#
-# ===> Extraction des couples (profondeur,force lineique)
-# du fichier resu_STREAM_FM au pas de temps courant et
-# remplissage de la liste de travail.
-#____________________________________________________________________
-#
-#####################
-# VALEUR TEST
-#
-test = 'NON'
-# Nb_pas_temps = 0
-#####################
-
-def extr_char_houle(k,dict_temps,Nb_valeur,lignes) :
-
- liste = Numeric.zeros((Nb_valeur,2), Numeric.Float)
-
- nume_ligne_temps = dict_temps["TEMPS_"+str(k)]
- range_depart = int(nume_ligne_temps) + 2
- range_arrive = int(nume_ligne_temps) + Nb_valeur + 3
- for l in range(range_depart, range_arrive) :
- ligne = lignes[l].split()
- if (len(ligne) != 0) :
- Flag_Val=re.match(r'^[-]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?$',ligne[0])
- if (Flag_Val != None) :
- liste[[(l-range_depart),0]] = float(ligne[0])
- liste[[(l-range_depart),1]] = float(ligne[1])
-
- return(range_depart,range_arrive,liste)
-
-#____________________________________________________________________
-#___________________ FIN FONCTION extr_char_houle ___________________
-#
-# _____________________________
-# _______________
-# _____________________________
-#
-#____________________________________________________________________
-#__________________ DEBUT MACRO macr_calc_eolienne __________________
-#
-#
-# ===> MACRO COMMANDE MACR_CALC_EOLIENNE
-#
-#____________________________________________________________________
-#
-# SCRIPT PYTHON
-#
-def macr_calc_eolienne_ops(self, INFO, MONOPODE, EXEC_MAILLAGE, AFFE_MATERIAU, CHARGEMENT,
- IMPRESSION, MODELISATION, NOM_MAIL_REF, TYPE_ELEM, FATIGUE, **args) :
-
- """ Calcule la structure de l'eolienne en mer. """
-
-# On charge les modules nécessaires
- from Accas import _F
- import aster
-# import os
-
-#____________________________________________________________________
-#
-# 1. Préalables
-#____________________________________________________________________
-#
-# 1.1 ==> La macro compte pour 1 dans l'exécution des commandes
-
- self.set_icmd(1)
- erreur = 0
-
-# 1.2 ==> On importe les définitions des commandes Aster utilisées
-# dans la macro
-
- affemateriau = AFFE_MATERIAU
-# impression = IMPRESSION
- PRE_GIBI = self.get_cmd("PRE_GIBI")
- EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL")
- LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE")
- DEFI_GROUP = self.get_cmd("DEFI_GROUP")
- CREA_MAILLAGE = self.get_cmd("CREA_MAILLAGE")
- MODI_MAILLAGE = self.get_cmd("MODI_MAILLAGE")
- AFFE_CARA_ELEM = self.get_cmd("AFFE_CARA_ELEM")
- AFFE_MODELE = self.get_cmd("AFFE_MODELE")
- AFFE_MATERIAU = self.get_cmd("AFFE_MATERIAU")
- FORMULE = self.get_cmd("FORMULE")
- AFFE_CHAR_MECA_F= self.get_cmd("AFFE_CHAR_MECA_F")
- AFFE_CHAR_MECA= self.get_cmd("AFFE_CHAR_MECA")
- DEFI_LIST_REEL= self.get_cmd("DEFI_LIST_REEL")
- STAT_NON_LINE= self.get_cmd("STAT_NON_LINE")
- MECA_STATIQUE= self.get_cmd("MECA_STATIQUE")
- CREA_CHAMP= self.get_cmd("CREA_CHAMP")
- PROJ_CHAMP= self.get_cmd("PROJ_CHAMP")
- CREA_RESU= self.get_cmd("CREA_RESU")
- CALC_ELEM= self.get_cmd("CALC_ELEM")
-#
-# IMPR_CO= self.get_cmd("IMPR_CO")
-#
- IMPR_RESU= self.get_cmd("IMPR_RESU")
- CALC_NO= self.get_cmd("CALC_NO")
- CALC_FATIGUE= self.get_cmd("CALC_FATIGUE")
- DETRUIRE= self.get_cmd("DETRUIRE")
- DEFI_FICHIER= self.get_cmd("DEFI_FICHIER")
-
-# 1.3 ==> Lecture des donnees
-
- H_TOTALE = MONOPODE['H_TOTALE']
- H_BASE = MONOPODE['H_BASE']
- H_MOYEU = MONOPODE['H_MOYEU']
- DECAL_PALES = MONOPODE['DECAL_PALES']
- DEXT_HAUT_BASE = MONOPODE['DEXT_HAUT_BASE']
- DEXT_BAS_BASE = MONOPODE['DEXT_BAS_BASE']
- EPAIS_HAUT_BASE = MONOPODE['EPAIS_HAUT_BASE']
- EPAIS_BAS_BASE = MONOPODE['EPAIS_BAS_BASE']
- DEXT_HAUT_FUT = MONOPODE['DEXT_HAUT_FUT']
- DEXT_BAS_FUT = MONOPODE['DEXT_BAS_FUT']
- EPAIS_HAUT_FUT = MONOPODE['EPAIS_HAUT_FUT']
- EPAIS_BAS_FUT = MONOPODE['EPAIS_BAS_FUT']
- NB_ELEM_BASE = MONOPODE['NB_ELEM_BASE']
- NB_ELEM_FUT = MONOPODE['NB_ELEM_FUT']
- if (MODELISATION == '3D' or MODELISATION == 'COQUE') :
- H_JONCTION = MONOPODE['H_JONCTION']
- DEXT_NACELLE = MONOPODE['DEXT_NACELLE']
- EPAIS_NACELLE = MONOPODE['EPAIS_NACELLE']
- NBEL_EPAIS_BASE = MONOPODE['NBEL_EPAIS_BASE']
- NBEL_EPAIS_FUT = MONOPODE['NBEL_EPAIS_FUT']
- else :
- H_JONCTION = None
- DEXT_NACELLE = None
- EPAIS_NACELLE = None
- NBEL_EPAIS_BASE = None
- NBEL_EPAIS_FUT = None
-
- if (MODELISATION == '3D') :
- NBEL_DCIR_BASE = MONOPODE['NBEL_DCIR_BASE']
- NBEL_DCIR_FUT = MONOPODE['NBEL_DCIR_FUT']
- else :
- NBEL_DCIR_BASE = None
- NBEL_DCIR_FUT = None
-
- ANGLE_VENT_AXE_X = CHARGEMENT['ANGLE_VENT_AXE_X']
-
- LOGICIEL = EXEC_MAILLAGE['LOGICIEL']
- UNITE_DATG = EXEC_MAILLAGE['UNITE_DATG']
- UNITE_MGIB = EXEC_MAILLAGE['UNITE_MGIB']
- NIVE_GIBI = EXEC_MAILLAGE['NIVE_GIBI']
-
-# 1.4 ==> Creation du repertoire pour l'execution du logiciel GIBI
-
- erreur_partiel = [0]
- Rep_Calc_ASTER = os.getcwd()
-
- Nom_Rep_local_mail = "tmp_dgib"
- Rep_Calc_LOGICIEL_local_mail = os.path.join(".",Nom_Rep_local_mail)
- Rep_Calc_LOGICIEL_global_mail = os.path.join(Rep_Calc_ASTER,Nom_Rep_local_mail)
-
- try :
- os.mkdir(Rep_Calc_LOGICIEL_global_mail)
- 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 creer le repertoire de travail pour le logiciel de maillage : "+Rep_Calc_LOGICIEL_global_mail)
-
- aux_datg = 'fort.'+str(UNITE_DATG)
- fichier_datg = os.path.join(Rep_Calc_LOGICIEL_global_mail,aux_datg)
-
- aux_mgib = 'fort.'+str(UNITE_MGIB)
- fichier_mgib = os.path.join(Rep_Calc_ASTER,aux_mgib)
-
- repertoire_outils = aster.repout()
- if (LOGICIEL == 'GIBI2000') : logi_mail = repertoire_outils+'gibi2000'
- if (LOGICIEL == 'GIBI98') : logi_mail = repertoire_outils+'gibi98'
-
-# 1.5 ==> Construction du maillage et du modele de reference
-
- if (MODELISATION == '3D') and (FATIGUE != None) :
-
- H_IMMERGEE = MONOPODE['H_BASE']
-
- mail_eolienne(H_TOTALE, H_BASE, H_IMMERGEE, H_MOYEU, H_JONCTION, DECAL_PALES,
- DEXT_NACELLE, EPAIS_NACELLE, DEXT_HAUT_BASE, DEXT_BAS_BASE,
- EPAIS_HAUT_BASE, EPAIS_BAS_BASE, DEXT_HAUT_FUT, DEXT_BAS_FUT,
- EPAIS_HAUT_FUT, EPAIS_BAS_FUT, NB_ELEM_BASE, NB_ELEM_FUT,
- NBEL_EPAIS_BASE, NBEL_EPAIS_FUT, NBEL_DCIR_BASE, NBEL_DCIR_FUT,
- ANGLE_VENT_AXE_X,
- MODELISATION, TYPE_ELEM, NIVE_GIBI, fichier_datg)
-
- EXEC_LOGICIEL(
- LOGICIEL=logi_mail,
- ARGUMENT=(fichier_datg, # fichier de donnees GIBI
- fichier_mgib, # fichier resultats format GIBI
- )
- )
-
- PRE_GIBI()
-
- if NOM_MAIL_REF!=None : self.DeclareOut('mail_ref',NOM_MAIL_REF)
- mail_ref = LIRE_MAILLAGE()
-
-# debut test
-# IMPR_CO(CO=mail_ref,)
-# fin test
-
- MOREF = AFFE_MODELE( MAILLAGE=mail_ref,
- AFFE=(_F(GROUP_MA = ('MONOPODE'),
- PHENOMENE = 'MECANIQUE',
- MODELISATION = '3D',),),);
-
-# 1.6 ==> Lecture du fichier de resultats STREAM_FM
-
- (periode_houle,Nb_valeur,Nb_pas_temps,lignes) = lect_resu_stream(INFO)
-
-# 1.7 ==> declaration de tableaux pour les concepts Aster
-
- if (MODELISATION == 'COQUE') :
- MA2 = [None] * (Nb_pas_temps+1) # pour la modelisation COQUE
-
- MA = [None] * (Nb_pas_temps+1) # pour les modelisations POUTRE et 3D
- __MO = [None] * (Nb_pas_temps+1)
- CARA = [None] * (Nb_pas_temps+1)
- __affmat = [None] * (Nb_pas_temps+1)
-
-# 1.8 ==> Construction du dictionnaire contenant :
-# pas_de_temps : numeros de ligne du fichier resu_STREAM_FM
-
- dict_temps = donn_boucle_pas_temps(lignes,Nb_pas_temps)
-
-#____________________________________________________________________
-#
-#####################
-# VALEUR TEST
-#
- test = 'NON'
-# Nb_pas_temps = 0
-#####################
-#____________________________________________________________________
-#
-# 2. ==> BOUCLE SUR LES PAS DE TEMPS
-# Dans cette boucle, a chaque pas de temps nous produisons :
-# 1. un maillage en fonction de la hauteur d'eau ;
-# 2. un chargement correspondant a la hauteur d'eau et a la modelisation ;
-# 3. un calcul elastique lineaire avec MECA_STATIQUE ;
-# 4. un fichier resultat qui est stocke dans un repertoire .repe ;
-# 5. dans le cas ou un calcul en fatigue est demande nous projetons
-# le champ de contrainte calcule aux noeuds sur un maillage de reference.
-#
-
- for j in range(Nb_pas_temps+1) :
-
- k = j + 1
-
-# 2.1 ==> Extraction des couples (profondeur,force lineique)
-# du fichier resu_STREAM_FM au pas de temps courant et
-# remplissage de la liste de travail.
-
- (range_depart,range_arrive,liste) = extr_char_houle(k,dict_temps,Nb_valeur,lignes)
-
-# 2.2 ==> Extraction de la hauteur d'eau
-
- H_IMMERGEE = liste[[(range_arrive-range_depart-2),0]]
- if INFO == 2 :
- print "<I> <MACR_CALC_EOLIENNE> ==> Numero d'ordre = ", j
- print "<I> <MACR_CALC_EOLIENNE> ==> hauteur_eau = ", H_IMMERGEE
-
-#####################
-# VALEUR TEST
-#
-# hauteur_eau = 30.
-#####################
- print "\n<CALC_EOLIENNE> liste = \n", liste
- print" "
-
-# 2.3 ==> Calcul des coefficients de la regression de maniere a
-# construire un chargement continu.
-
- (teta0,teta1,teta2,teta3,alpha1,alpha2,alpha3,beta2,beta3) = eolien_regression (liste, INFO)
-
- print " "
- print "<I> <MACR_CALC_EOLIENNE> RESULTATS "
- print " "
- print "<I> <MACR_CALC_EOLIENNE> teta0 = ", teta0
- print "<I> <MACR_CALC_EOLIENNE> teta1 = ", teta1
- print "<I> <MACR_CALC_EOLIENNE> teta2 = ", teta2
- print "<I> <MACR_CALC_EOLIENNE> teta3 = ", teta3
- print " "
-
-# 2.4 ==> Creation du maillage pour la hauteur d'eau (H_IMMERGEE) courante
-
- mail_eolienne(H_TOTALE, H_BASE, H_IMMERGEE, H_MOYEU, H_JONCTION, DECAL_PALES,
- DEXT_NACELLE, EPAIS_NACELLE, DEXT_HAUT_BASE, DEXT_BAS_BASE,
- EPAIS_HAUT_BASE, EPAIS_BAS_BASE, DEXT_HAUT_FUT, DEXT_BAS_FUT,
- EPAIS_HAUT_FUT, EPAIS_BAS_FUT, NB_ELEM_BASE, NB_ELEM_FUT,
- NBEL_EPAIS_BASE, NBEL_EPAIS_FUT, NBEL_DCIR_BASE, NBEL_DCIR_FUT,
- ANGLE_VENT_AXE_X,
- MODELISATION, TYPE_ELEM, NIVE_GIBI, fichier_datg)
-
-# 2.5 ==> Lancement de GIBI
- EXEC_LOGICIEL(
- LOGICIEL = logi_mail,
- ARGUMENT = (fichier_datg, # fichier de donnees GIBI
- fichier_mgib, # fichier resultats format GIBI
- )
- )
-
-# 2.6 ==> Lecture du maillage et definition des groupes
-
- PRE_GIBI()
-
- MA[j] = LIRE_MAILLAGE()
-
- MA[j]=DEFI_GROUP( reuse = MA[j],
- MAILLAGE = MA[j],
- CREA_GROUP_NO = _F( TOUT_GROUP_MA='OUI',),);
-
-# debut test
-# IMPR_CO(CO=MA[j],)
-# fin test
-
-# 2.7 ==> Modelisation POUTRE
-
- if MODELISATION == 'POUTRE' :
-
- __MO[j]=AFFE_MODELE(MAILLAGE=MA[j],
- AFFE=_F(GROUP_MA='EOLIENNE',PHENOMENE='MECANIQUE',MODELISATION='POU_D_T',),);
-
- motscle={}
- motscle['POUTRE']=[]
- for i in range(NB_ELEM_FUT) :
- nom = 'FUT'+str(i+1)
- incr = (DEXT_BAS_FUT - DEXT_HAUT_FUT)/(2.0*NB_ELEM_FUT)
- r1 = (DEXT_BAS_FUT/2.0) - (i*incr)
- r2 = r1 - incr
- motscle['POUTRE'].append(_F(GROUP_MA=nom,SECTION='CERCLE',CARA=('R1','R2','EP1','EP2',),VALE=(r1,r2,EPAIS_BAS_FUT,EPAIS_HAUT_FUT,),VARI_SECT='HOMOTHETIQUE',), )
-
- for i in range(NB_ELEM_BASE) :
- nom = 'BASE'+str(i+1)
- incr = (DEXT_BAS_BASE - DEXT_HAUT_BASE)/(2.0*NB_ELEM_BASE)
- r1 = (DEXT_BAS_BASE/2.0) - (i*incr)
- r2 = r1 - incr
- motscle['POUTRE'].append(_F(GROUP_MA=nom,SECTION='CERCLE',CARA=('R1','R2','EP1','EP2',),VALE=(r1,r2,EPAIS_BAS_BASE,EPAIS_HAUT_BASE,),VARI_SECT='HOMOTHETIQUE',), )
-
- CARA[j]=AFFE_CARA_ELEM( MODELE = __MO[j],
- **motscle );
-
-# 2.8 ==> Modelisation COQUE
-
- if MODELISATION == 'COQUE' :
-
- MA2[j] = CREA_MAILLAGE( MAILLAGE=MA[j],
- MODI_MAILLE=( _F( OPTION = 'QUAD8_9',
- GROUP_MA = ('PARTEM','PARTIM',),),
- _F( OPTION = 'TRIA6_7',
- GROUP_MA = ('JONCTION',),),),
- );
-
- __MO[j] = AFFE_MODELE( MAILLAGE=MA2[j],
- AFFE=( _F( GROUP_MA = ('PARTEM','PARTIM','JONCTION','CHAUTE'),
- PHENOMENE = 'MECANIQUE',
- MODELISATION = 'COQUE_3D',),
- _F( GROUP_MA = 'NACELLE',
- PHENOMENE = 'MECANIQUE',
- MODELISATION = 'POU_D_E',),),
- );
-
-
- MA2[j] = MODI_MAILLAGE( reuse = MA2[j],
- MAILLAGE = MA2[j],
- ORIE_NORM_COQUE = _F(
- GROUP_MA = ('PARTEM','PARTIM','JONCTION'),),);
-
- CARA[j] = AFFE_CARA_ELEM( MODELE=__MO[j],
- POUTRE=( _F(GROUP_MA = 'NACELLE',
- SECTION = 'CERCLE',
- CARA = ('R','EP',),
- VALE = (dex_nacelle/2.,ep_nacelle,), ),
- ),
- COQUE=( _F( GROUP_MA = ('PARTEM','PARTIM','CHAUTE'),
- EPAIS = ep_b_fut,
- ANGL_REP = (0.0,90.0,), ),
-
- _F( GROUP_MA = ('JONCTION'),
- EPAIS = h_jonction, ),
- ),
- );
-
-# 2.9 ==> Modelisation 3D
-
- if MODELISATION == '3D' :
-
- __MO[j] = AFFE_MODELE( MAILLAGE=MA[j],
- AFFE=(_F( GROUP_MA = ('BASE','FUT','JONCTION','CHAUTE','SI1','SE1'),
- PHENOMENE = 'MECANIQUE',
- MODELISATION = '3D',),
- _F( GROUP_MA ='NACELLE',
- PHENOMENE ='MECANIQUE',
- MODELISATION ='POU_D_E',),),
- );
-
- MA[j] = MODI_MAILLAGE( reuse = MA[j],
- MAILLAGE = MA[j],
- ORIE_PEAU_3D = _F(
- GROUP_MA = ('SE1','SI1','CHAUTE'),),
- );
-
- CARA[j] = AFFE_CARA_ELEM( MODELE =__MO[j],
- POUTRE =(
- _F( GROUP_MA = 'NACELLE',
- SECTION = 'CERCLE',
- CARA = ('R','EP',),
- VALE = (DEXT_NACELLE/2.0,EPAIS_NACELLE,), ),
- ),
- );
-
-# 2.10 ==> Affectation du materiau
-
- motscles={}
- motscles['AFFE_MATERIAU']=[]
- for mat in affemateriau :
- if mat['TOUT'] == None :
- # Creation de mots-cles pour les AFFE_CHAR_MECA
- motscles['AFFE_MATERIAU'].append(_F( GROUP_MA = mat['GROUP_MA'],
- MATER = mat['MATER'],
- TEMP_REF = mat['TEMP_REF'],) )
- else :
- # Creation de mots-cles pour les AFFE_CHAR_MECA
- motscles['AFFE_MATERIAU'].append(_F( TOUT = 'OUI',
- MATER = mat['MATER'],
- TEMP_REF = mat['TEMP_REF'],) )
- if MODELISATION == 'COQUE' :
- __affmat[j] = AFFE_MATERIAU( MAILLAGE = MA2[j],
- MODELE = __MO[j],
- AFFE = motscles['AFFE_MATERIAU'],
- )
- else :
- __affmat[j] = AFFE_MATERIAU( MAILLAGE = MA[j],
- MODELE = __MO[j],
- AFFE = motscles['AFFE_MATERIAU'],
- )
-
-# 2.11 ==> Chargement et conditions aux limites
-
- RAUMER = 1027.42 # masse volumique de l'eau de mer (kg/m3)
- l_elem_stream = 0.3 # longueur des elements de STREAM_FM (m)
-
- if test == 'OUI':
- # FC3 poutre
- if MODELISATION == 'POUTRE' :
- FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE=' -(exp((Z+231.21)/20.187))/0.3')
- else :
- # FC3 coque et 3D
- FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE='''- (
- (3.E-5-(1.E4*Z))+((-6.E-8*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+2.E-5*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))
- -0.0021*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+0.0224*(atan(Y/(X+1.E-8)))+0.9328)*
- (0.5*'''+str(RAUMER)+'''*1.6**2)))''')
- else :
- if MODELISATION == 'POUTRE' :
- FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE=''' -('''
- +str(teta0)+'''+('''
- +str(teta1)+''')*(Z-('''+str(alpha1)+'''))+('''
- +str(teta2)+''')*((Z-('''+str(alpha2)+'''))*(Z-('''+str(alpha1)+'''))-('''+str(beta2)+'''))+('''
- +str(teta3)+''')*( (Z-('''+str(alpha3)+'''))*((Z-('''+str(alpha2)+'''))*(Z-('''+str(alpha1)+'''))-('''
- +str(beta2)+'''))-('''+str(beta3)+''')*(Z-('''+str(alpha1)+'''))))/'''+str(l_elem_stream))
- else :
- r_bas = (DEXT_HAUT_BASE + DEXT_BAS_FUT)/4.0 # rayon moyen de la base
- deux_pi_r_bas = 2.0*math.pi*r_bas # rayon moyen de la base multiplie par 2*pi
- int_dp_etoil = -4.83893 # valeur de l integrale de la fonction de repartition de pression
-
- FC3 = FORMULE(NOM_PARA=('X','Y','Z'),VALE=''' -(
- (('''+str(H_BASE)+'''-Z)*1.0E+4)+(
- ((('''+str(teta0)+'''+'''
- +str(teta1)+'''*(Z-'''+str(alpha1)+''')+'''
- +str(teta2)+'''*((Z-'''+str(alpha2)+''')*(Z-'''+str(alpha1)+''')-'''+str(beta2)+''')+'''
- +str(teta3)+'''*( (Z-'''+str(alpha3)+''')*((Z-'''+str(alpha2)+''')*(Z-'''+str(alpha1)+''')-'''
- +str(beta2)+''')-'''+str(beta3)+'''*(Z-'''+str(alpha1)+''')))/'''+str(l_elem_stream)+''')-'''
- +str(deux_pi_r_bas)+'''*(('''+str(H_BASE)+'''-Z)*1.0E+4))*
- ((-6.E-8*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+2.E-5*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))
- -0.0021*(atan(Y/(X+1.E-8)))*(atan(Y/(X+1.E-8)))+0.0224*(atan(Y/(X+1.E-8)))+0.9328))/('''+str(r_bas)+'''*'''+str(int_dp_etoil)+''')))''')
-
- if CHARGEMENT['VENT'] == 'OUI' :
- FV0 = CHARGEMENT['FORCE_VENT_FUT']
- else :
- FV0 = FORMULE(NOM_PARA=('X','Y','Z'),VALE='0.0*Z')
-
- if MODELISATION == 'POUTRE' :
- CH=AFFE_CHAR_MECA_F(MODELE=__MO[j],
- FORCE_POUTRE=(_F(GROUP_MA='PARTIM',FX=FC3,),
- _F(GROUP_MA='PARTEM',FX=FV0,),),)
- if MODELISATION == 'COQUE' :
- CH=AFFE_CHAR_MECA_F(MODELE=__MO[j],
- FORCE_COQUE=(_F(GROUP_MA='SI1',PRES=FC3,),
- _F(GROUP_MA='SE1',PRES=FV0,),),);
-
- if MODELISATION == '3D' :
- CH=AFFE_CHAR_MECA_F(MODELE=__MO[j],
- PRES_REP=(_F(GROUP_MA='SI1',PRES=FC3,),
- _F(GROUP_MA='SE1',PRES=FV0,),),);
-
- # force due au poids du rotor decale de d1 (N)
- F2 = CHARGEMENT['FORCE_POIDS_ROTOR']
-
- # force due au poids de la nacelle (N)
- F3 = CHARGEMENT['FORCE_POIDS_NACELLE']
-
- # force totale en z sur le sommet
- FCZ = F2+F3
-
- # force du à l'effort du vent sur les pales
- FRU = CHARGEMENT['FORCE_VENT_PALES']
- # moment resistant
- MRU = CHARGEMENT['MOMENT_RESISTANT']
-
- # force et moment dus au vent sur le rotor suivant le repère global
- ALPHAR = CHARGEMENT['ANGLE_VENT_AXE_X']*(math.pi)/180.0
-
- F1X = FRU*math.cos(ALPHAR)
- F1Y = FRU*math.sin(ALPHAR)
- M1X = MRU*math.cos(ALPHAR)
- M1Y = MRU*math.sin(ALPHAR)
-
- MCY = M1Y-(MONOPODE['DECAL_PALES']*F2)+(MONOPODE['H_MOYEU']*FRU)
-
- if MODELISATION == 'POUTRE' :
- LIMIT=AFFE_CHAR_MECA( MODELE = __MO[j],
- DDL_IMPO = _F( GROUP_NO='B_BASE',
- DX=0.0,DY=0.0,DZ=0.0,
- DRX=0.0,DRY=0.0,DRZ=0.0,),
- FORCE_NODALE = _F( GROUP_NO='H_FUT',
- FX=F1X,
- FY=F1Y,
- FZ=FCZ,
- MX=M1X,
- MY=MCY,
- MZ=0.0,),)
-
- if MODELISATION == 'COQUE' :
- LIMIT=AFFE_CHAR_MECA(MODELE=__MO[j],
- DDL_IMPO=_F(GROUP_NO='CBASI',
- DX=0.0,DY=0.0,DZ=0.0,
- DRX=0.0,DRY=0.0,DRZ=0.0,),
-
- LIAISON_ELEM=_F(OPTION='COQ_POU',
- CARA_ELEM = CARA[j],
- AXE_POUTRE=(0.,0.,1.,),
- GROUP_MA_1='CHAUTE',
- GROUP_NO_2='H_FUT',),
-
- FORCE_NODALE=(_F(GROUP_NO='CHP',
- FX=F1X,FY=F1Y,FZ=F2,
- MX=M1X,MY=M1Y,MZ=0.0,),
-
- _F(GROUP_NO='CHP0',FZ=F3,),
- ),)
-
- if MODELISATION == '3D' :
- LIMIT=AFFE_CHAR_MECA(MODELE=__MO[j],
- DDL_IMPO=_F(GROUP_NO='CBASI',
- DX=0.0,DY=0.0,DZ=0.0,),
-
- LIAISON_ELEM=_F(OPTION='3D_POU',
- CARA_ELEM = CARA[j],
- AXE_POUTRE=(0.,0.,1.,),
- GROUP_MA_1='CHAUTE',
- GROUP_NO_2='H_FUT',),
-
- FORCE_NODALE=(_F(GROUP_NO='CHP',
- FX=F1X,FY=F1Y,FZ=F2,
- MX=M1X,MY=M1Y,MZ=0.0,),
-
- _F(GROUP_NO='CHP0',FZ=F3,),
- ),)
-
- POIDS=AFFE_CHAR_MECA( MODELE=__MO[j],
- PESANTEUR=(9.81,0.0,0.0,-1.0,),)
-
-# 2.12 ==> Realisation du calcul
-
- if MODELISATION == 'POUTRE' :
-
- TEMPS=DEFI_LIST_REEL(DEBUT=0.0,
- INTERVALLE=_F(JUSQU_A=1.0,
- PAS=1.0,),)
-
- RESU=STAT_NON_LINE(MODELE=__MO[j],
- CHAM_MATER=__affmat[j],
- CARA_ELEM=CARA[j],
- EXCIT=(_F(CHARGE=POIDS,),
- _F(CHARGE=CH,),
- _F(CHARGE=LIMIT,),),
- COMP_INCR=_F(RELATION='ELAS',
- GROUP_MA='EOLIENNE',),
- INCREMENT=_F(LIST_INST=TEMPS,
- NUME_INST_FIN=1,),)
-
- RESU=CALC_ELEM( reuse =RESU,
- RESULTAT=RESU,
- OPTION=('SIEF_ELNO_ELGA','SIGM_ELNO_SIEF','SIPO_ELNO_SIEF',),)
-
- if MODELISATION == 'COQUE' :
- RESU=MECA_STATIQUE( MODELE=__MO[j],
- CHAM_MATER=__affmat[j],
- CARA_ELEM=CARA[j],
- EXCIT=(_F(CHARGE=POIDS,),
- _F(CHARGE=CH,),
- _F(CHARGE=LIMIT,),),
- NIVE_COUCHE='MOY',
- );
- RESU=CALC_ELEM( reuse =RESU,
- RESULTAT=RESU,
- OPTION=('SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',),)
-
- RESU = CALC_NO( reuse =RESU,
- RESULTAT=RESU,
- OPTION=('SIGM_NOEU_DEPL','EQUI_NOEU_SIGM',),);
-
- if MODELISATION == '3D' :
- RESU=MECA_STATIQUE( MODELE=__MO[j],
- CHAM_MATER=__affmat[j],
- CARA_ELEM=CARA[j],
- EXCIT=(_F(CHARGE=POIDS,),
- _F(CHARGE=CH,),
- _F(CHARGE=LIMIT,),),
- );
- RESU=CALC_ELEM( reuse =RESU,
- RESULTAT=RESU,
- REPE_COQUE=_F(NIVE_COUCHE='MOY',),
- OPTION=('SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',));
-
- RESU = CALC_NO( reuse =RESU,
- RESULTAT=RESU,
- OPTION=('SIGM_NOEU_DEPL','EQUI_NOEU_SIGM',),);
-
-# 2.13 ==> Preparation du modele de reference si modelisation 3D calcul de la fatigue
-
- delta = periode_houle/Nb_pas_temps
- inst = -periode_houle/2.0 + j*delta
- if (MODELISATION == '3D') and (FATIGUE != None) :
-
- if (k == 1) :
- CHAMREF = AFFE_MATERIAU( MAILLAGE = mail_ref,
- MODELE = MOREF,
- AFFE = motscles['AFFE_MATERIAU'],)
-
- RESPRO = PROJ_CHAMP( METHODE = 'ELEM',
- NOM_CHAM = 'SIGM_NOEU_DEPL',
- RESULTAT = RESU,
- MODELE_1 = __MO[j],
- MODELE_2 = MOREF,
- VIS_A_VIS=(
- _F( GROUP_MA_2='MONOPODE',
- GROUP_MA_1='MONOPODE' ),
- ),
- )
-
- SIG_PRO = CREA_CHAMP( TYPE_CHAM = 'NOEU_SIEF_R',
- OPERATION = 'EXTR',
- RESULTAT = RESPRO ,
- NOM_CHAM = 'SIGM_NOEU_DEPL',
- NUME_ORDRE = 1,
- )
-
- if (k==1) :
- RESREF = CREA_RESU(
- OPERATION = 'AFFE',
- TYPE_RESU = 'EVOL_ELAS',
- NOM_CHAM = 'SIGM_NOEU_DEPL',
- AFFE = _F( CHAM_GD = SIG_PRO,
- INST = (inst), ),
- )
- else :
- RESREF = CREA_RESU( reuse = RESREF,
- OPERATION = 'AFFE',
- TYPE_RESU = 'EVOL_ELAS',
- NOM_CHAM = 'SIGM_NOEU_DEPL',
- AFFE = _F( CHAM_GD = SIG_PRO,
- INST = (inst), ),
- )
-
-# 2.14 ==> Impression des resultats
-
- if MODELISATION == 'POUTRE' :
- fich1='poutre_t='+str(inst)+'.resu'
- fich2='poutre_t='+str(inst)+'.cast'
- fich3='poutre_t='+str(inst)+'.ensi'
- fich4='poutre_t='+str(inst)+'.unv'
- if MODELISATION == 'COQUE' :
- fich1='coque_t='+str(inst)+'.resu'
- fich2='coque_t='+str(inst)+'.cast'
- fich3='coque_t='+str(inst)+'.ensi'
- fich4='coque_t='+str(inst)+'.unv'
- if MODELISATION == '3D' :
- fich1='3D_t='+str(inst)+'.resu'
- fich2='3D_t='+str(inst)+'.cast'
- fich3='3D_t='+str(inst)+'.ensi'
- fich4='3D_t='+str(inst)+'.unv'
-
- fich1b = './REPE_OUT/'+fich1
- fich2b = './REPE_OUT/'+fich2
- fich3b = './REPE_OUT/'+fich3
- fich4b = './REPE_OUT/'+fich4
-
- if IMPRESSION != None :
- motscles={}
- motscles['IMPRESSION']=[]
- # Creation de mots-cles pour les IMPR_RESU
- for impr in IMPRESSION :
- if impr['FORMAT']=='RESULTAT':
- UNIT_1B=DEFI_FICHIER(FICHIER=fich1b)
- unitr = UNIT_1B
- if impr['FORMAT']=='CASTEM':
- UNIT_2B=DEFI_FICHIER(FICHIER=fich2b)
- unitr = UNIT_2B
- if impr['FORMAT']=='ENSIGHT':
- UNIT_3B=DEFI_FICHIER(FICHIER=fich3b)
- unitr = UNIT_3B
- if impr['FORMAT']=='IDEAS':
- UNIT_4B=DEFI_FICHIER(FICHIER=fich4b)
- unitr = UNIT_4B
- if MODELISATION == '3D':
- motscles['IMPRESSION'].append(_F(MAILLAGE=MA[j],RESULTAT=RESU,
- NOM_CHAM=('DEPL','SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',),) )
- if MODELISATION == 'COQUE':
- motscles['IMPRESSION'].append(_F(MAILLAGE=MA2[j],RESULTAT=RESU,
- NOM_CHAM=('DEPL','SIGM_ELNO_DEPL','EQUI_ELNO_SIGM',),) )
- if MODELISATION == 'POUTRE':
- motscles['IMPRESSION'].append(_F(MAILLAGE=MA[j],RESULTAT=RESU,
- NOM_CHAM=('DEPL','SIGM_ELNO_SIEF','SIPO_ELNO_SIEF',),) )
-
- IMPR_RESU(FORMAT=impr['FORMAT'],UNITE=unitr,
- RESU=motscles['IMPRESSION'],)
-
- for impr in IMPRESSION :
- if impr['FORMAT']=='RESULTAT':
- DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich1b)
- DETRUIRE(CONCEPT=_F( NOM = UNIT_1B))
- if impr['FORMAT']=='CASTEM':
- DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich2b)
- DETRUIRE(CONCEPT=_F( NOM = UNIT_2B))
- if impr['FORMAT']=='ENSIGHT':
- DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich3b)
- DETRUIRE(CONCEPT=_F( NOM = UNIT_3B))
- if impr['FORMAT']=='IDEAS':
- DEFI_FICHIER(ACTION='LIBERER',FICHIER=fich4b)
- DETRUIRE(CONCEPT=_F( NOM = UNIT_4B))
-
- if (MODELISATION == '3D') and (FATIGUE != None) :
- DETRUIRE(CONCEPT=_F( NOM = SIG_PRO))
- DETRUIRE(CONCEPT=_F( NOM = RESPRO))
- if MODELISATION == 'POUTRE' :
- DETRUIRE(CONCEPT=_F( NOM = TEMPS))
-
- DETRUIRE(CONCEPT=_F( NOM = FC3))
- DETRUIRE(CONCEPT=_F( NOM = CH))
- DETRUIRE(CONCEPT=_F( NOM = LIMIT))
- DETRUIRE(CONCEPT=_F( NOM = POIDS))
- DETRUIRE(CONCEPT=_F( NOM = RESU))
-#
-#____________________________________________________________________
-#
-# 3. Calcul de fatigue.
-# On calcule la fatigue si la modelisation est 3D et si le mot clef
-# fatigue est present.
-#____________________________________________________________________
-#
-# 3.1 ==> Calcul de la fatigue
-#
- if (MODELISATION == '3D') and (FATIGUE != None) :
-
- self.DeclareOut('CHFATI',self.sd)
- CHFATI = CALC_FATIGUE (
- TYPE_CALCUL = 'FATIGUE_MULTI',
- TYPE_CHARGE = 'PERIODIQUE',
- OPTION = 'DOMA_NOEUD',
- RESULTAT = RESREF,
- CHAM_MATER = CHAMREF,
- GROUP_MA = ('BASE','FUT'),
- MAILLAGE = mail_ref,
- CRITERE=FATIGUE['CRITERE'],
- METHODE='CERCLE_EXACT',
- INFO = 2, )
-
-#____________________________________________________________________
-#
-# 3.2 ==> Impression des resultats de fatigue
-#
- if IMPRESSION != None :
- motscles={}
- motscles['IMPRESSION']=[]
-
- motscles['IMPRESSION'].append(_F(MAILLAGE=mail_ref,CHAM_GD=CHFATI,) )
-
- IMPR_RESU( FORMAT=impr['FORMAT'],
- MODELE = MOREF,
- RESU=motscles['IMPRESSION'],)
-
-#____________________________________________________________________
-#
-# 4. C'est fini !
-#____________________________________________________________________
-#
- if erreur :
- if not messages_erreur.has_key(erreur) :
- erreur = 100
- self.cr.fatal(messages_erreur[erreur])
-
- return
-#
-#____________________________________________________________________
-#____________________________________________________________________
-#
-# CATALOGUES DES MACRO-COMMANDES
-#____________________________________________________________________
-#____________________________________________________________________
-#
-# ________________________________________
-#
-#____________________________________________________________________
-#____________________________________________________________________
-#
-# CATALOGUE DE LA MACRO COMMANDE CALC_CHAR_HOULE
-#____________________________________________________________________
-#____________________________________________________________________
-#
-
-CALC_CHAR_HOULE=MACRO( nom="CALC_CHAR_HOULE",op=calc_char_houle_ops,
- fr="Calcul le chargement du a la houle.",
- ang=".",reentrant='n',
- docu="Ux.xx.xx-a",
-
- STREAM =FACT(statut='o',max=1,
- PROFONDEUR =SIMP(statut='o',typ='R'),
- H_HOULE =SIMP(statut='o',typ='R'),
- PERI_HOULE =SIMP(statut='o',typ='R'),
- COUR_EULERIEN =SIMP(statut='o',typ='R'),
- COEF_TRAINEE =SIMP(statut='o',typ='R'),
- COEF_INERTIE =SIMP(statut='o',typ='R'),
- ORDR_FONC_COURAN =SIMP(statut='o',typ='I'),
- NB_POINTS_VERT =SIMP(statut='o',typ='I'),
- NB_INTER_PERI =SIMP(statut='o',typ='I'),
- DEXT_HAUT_BASE =SIMP(statut='o',typ='R'),
- ),
-
- IMPRESSION =FACT(statut='f',
- UNITE =SIMP(statut='o',typ='I'),
- ),
-
- INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-
-);
-
-#
-#____________________________________________________________________
-#____________________________________________________________________
-#
-# CATALOGUE DE LA MACRO COMMANDE MACR_CALC_EOLIENNE
-#____________________________________________________________________
-#____________________________________________________________________
-#
-
-def macr_calc_eolienne_prod(self,NOM_MAIL_REF,**args):
- if NOM_MAIL_REF != None : self.type_sdprod(NOM_MAIL_REF,maillage_sdaster)
- return cham_no_sdaster
-
-
-MACR_CALC_EOLIENNE=MACRO(nom="MACR_CALC_EOLIENNE",op=macr_calc_eolienne_ops,
- sd_prod=macr_calc_eolienne_prod,
- fr="Calcul d une eolienne en mer.",
- ang=".",reentrant='n',
- docu="U2.09.04-a",
-
- EXEC_MAILLAGE =FACT(statut='o',
- LOGICIEL =SIMP(statut='o',typ='TXM',defaut="GIBI2000",into=("GIBI98","GIBI2000") ),
- UNITE_DATG =SIMP(statut='f',typ='I',defaut=70),
- UNITE_MGIB =SIMP(statut='f',typ='I',defaut=19),
- NIVE_GIBI =SIMP(statut='f',typ='I',defaut=10,into=(3,4,5,6,7,8,9,10,11)),
- ),
-
- MODELISATION =SIMP(statut='o',typ='TXM', into=("POUTRE","COQUE","3D") ),
- NOM_MAIL_REF =SIMP(statut='f',typ=(CO,maillage_sdaster)),
-
- TYPE_ELEM =SIMP(statut='f',typ='TXM',defaut="CUB8",into=("CUB8","CU20") ),
-
- b_model_3D =BLOC(condition = "MODELISATION == '3D'",
-
- MONOPODE =FACT(statut='o',max=1,
-
- H_TOTALE =SIMP(statut='o',typ='R' ),
- H_BASE =SIMP(statut='o',typ='R' ),
- H_MOYEU =SIMP(statut='o',typ='R' ),
- H_JONCTION =SIMP(statut='o',typ='R' ),
- DECAL_PALES =SIMP(statut='o',typ='R' ),
- DEXT_NACELLE =SIMP(statut='o',typ='R' ),
- EPAIS_NACELLE =SIMP(statut='o',typ='R' ),
- DEXT_HAUT_BASE =SIMP(statut='o',typ='R' ),
- DEXT_BAS_BASE =SIMP(statut='f',typ='R' ),
- EPAIS_HAUT_BASE =SIMP(statut='o',typ='R' ),
- EPAIS_BAS_BASE =SIMP(statut='f',typ='R' ),
- DEXT_HAUT_FUT =SIMP(statut='o',typ='R' ),
- DEXT_BAS_FUT =SIMP(statut='f',typ='R' ),
- EPAIS_HAUT_FUT =SIMP(statut='o',typ='R' ),
- EPAIS_BAS_FUT =SIMP(statut='f',typ='R' ),
- NB_ELEM_BASE =SIMP(statut='f',typ='I',defaut=30),
- NB_ELEM_FUT =SIMP(statut='f',typ='I',defaut=70),
- NBEL_EPAIS_BASE =SIMP(statut='f',typ='I',defaut=3),
- NBEL_EPAIS_FUT =SIMP(statut='f',typ='I',defaut=3),
- NBEL_DCIR_BASE =SIMP(statut='f',typ='I',defaut=15),
- NBEL_DCIR_FUT =SIMP(statut='f',typ='I',defaut=15),
- ),
- ),
-
- b_model_coque =BLOC(condition = "MODELISATION == 'COQUE' ",
-
- MONOPODE =FACT(statut='o',max=1,
-
- H_TOTALE =SIMP(statut='o',typ='R' ),
- H_BASE =SIMP(statut='o',typ='R' ),
- H_MOYEU =SIMP(statut='o',typ='R' ),
- H_JONCTION =SIMP(statut='o',typ='R' ),
- DECAL_PALES =SIMP(statut='o',typ='R' ),
- DEXT_NACELLE =SIMP(statut='o',typ='R' ),
- EPAIS_NACELLE =SIMP(statut='o',typ='R' ),
- DEXT_HAUT_BASE =SIMP(statut='o',typ='R' ),
- DEXT_BAS_BASE =SIMP(statut='f',typ='R' ),
- EPAIS_HAUT_BASE =SIMP(statut='o',typ='R' ),
- EPAIS_BAS_BASE =SIMP(statut='f',typ='R' ),
- DEXT_HAUT_FUT =SIMP(statut='o',typ='R' ),
- DEXT_BAS_FUT =SIMP(statut='f',typ='R' ),
- EPAIS_HAUT_FUT =SIMP(statut='o',typ='R' ),
- EPAIS_BAS_FUT =SIMP(statut='f',typ='R' ),
- NB_ELEM_BASE =SIMP(statut='f',typ='I',defaut=30),
- NB_ELEM_FUT =SIMP(statut='f',typ='I',defaut=70),
- NBEL_DCIR_BASE =SIMP(statut='f',typ='I',defaut=15),
- NBEL_DCIR_FUT =SIMP(statut='f',typ='I',defaut=15),
- ),
- ),
-
- b_model_poutre =BLOC(condition = "MODELISATION == 'POUTRE' ",
-
- MONOPODE =FACT(statut='o',max=1,
-
- H_TOTALE =SIMP(statut='o',typ='R' ),
- H_BASE =SIMP(statut='o',typ='R' ),
- H_MOYEU =SIMP(statut='o',typ='R' ),
- DECAL_PALES =SIMP(statut='o',typ='R' ),
- DEXT_HAUT_BASE =SIMP(statut='o',typ='R' ),
- DEXT_BAS_BASE =SIMP(statut='f',typ='R' ),
- EPAIS_HAUT_BASE =SIMP(statut='o',typ='R' ),
- EPAIS_BAS_BASE =SIMP(statut='f',typ='R' ),
- DEXT_HAUT_FUT =SIMP(statut='o',typ='R' ),
- DEXT_BAS_FUT =SIMP(statut='f',typ='R' ),
- EPAIS_HAUT_FUT =SIMP(statut='o',typ='R' ),
- EPAIS_BAS_FUT =SIMP(statut='f',typ='R' ),
- NB_ELEM_BASE =SIMP(statut='f',typ='I',defaut=30),
- NB_ELEM_FUT =SIMP(statut='f',typ='I',defaut=70),
- ),
- ),
-
- AFFE_MATERIAU =FACT(statut='o',max=3,
- regles=(UN_PARMI('TOUT','GROUP_MA'),),
- TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
- GROUP_MA =SIMP(statut='f',typ='TXM',into=("BASE","FUT") ),
- MATER =SIMP(statut='o',typ=mater_sdaster ),
- TEMP_REF =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
- ),
-
- CHARGEMENT =FACT(statut='o',
- FORCE_POIDS_ROTOR =SIMP(statut='o',typ='R' ),
- FORCE_POIDS_NACELLE =SIMP(statut='o',typ='R' ),
- FORCE_VENT_PALES =SIMP(statut='o',typ='R' ),
- ANGLE_VENT_AXE_X =SIMP(statut='o',typ='R' ),
- MOMENT_RESISTANT =SIMP(statut='o',typ='R' ),
- FORCE_VENT_FUT =SIMP(statut='o',typ=(fonction_sdaster,formule) ),
- VENT =SIMP(statut='o',typ='TXM',into=("OUI","NON") ),
- HOULE =SIMP(statut='o',typ='TXM',into=("OUI","NON") ),
- ),
-
- FATIGUE =FACT(statut='f',
- CRITERE =SIMP(statut='f',typ='TXM',defaut="DANG_VAN_MODI_AC",into=("MATAKE","DANG_VAN_MODI_AC") ),
- ),
-
- SOLVEUR =FACT(statut='d',
- METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ),
- b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
- RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
- ),
- b_ldlt =BLOC(condition = "METHODE == 'LDLT' ",fr="Paramètres de la méthode LDLT",
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("RCMK","SANS") ),
- ),
- b_ldlt_mult =BLOC(condition = "METHODE == 'LDLT' or METHODE == 'MULT_FRONT' ",
- fr="Paramètres relatifs à la non inversibilité de la matrice à factorise",
- NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
- STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
- ),
- b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
- PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
- NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut= 0 ),
- RENUM =SIMP(statut='f',typ='TXM',defaut="RCMK",into=("SANS","RCMK") ),
- RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
- NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
- ),
- SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
- ),
-
- IMPRESSION =FACT(statut='f',
- FORMAT =SIMP(statut='f',typ='TXM',defaut="RESULTAT",
- into=("RESULTAT","CASTEM","IDEAS","ENSIGHT")),
-
- b_format_ideas =BLOC(condition="FORMAT=='IDEAS'",fr="version Ideas",
- VERSION =SIMP(statut='f',typ='I',defaut=5,into=(4,5)),
- ),
-
- b_format_castem =BLOC(condition="FORMAT=='CASTEM'",fr="version Castem",
- NIVE_GIBI =SIMP(statut='f',typ='I',defaut=10,into=(3,10)),
- ),
-
- TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
- NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
- INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
- ),
-
- INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-
-);
+++ /dev/null
-#@ MODIF macr_cabri_calc_cata Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
-# -*- coding: iso-8859-1 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-
-from Intranet.macr_cabri_calc_ops import macr_cabri_calc_ops
-from Cata.cata import *
-
-def macr_cabri_calc_prod(self,MODELE_THER,MODELE_MECA,CHAM_MATER,
- CHAR_THER,CHAR_MECA,RESU_THER,**args):
- if MODELE_THER != None:
- self.type_sdprod(MODELE_THER,modele_sdaster)
- if MODELE_MECA != None:
- self.type_sdprod(MODELE_MECA,modele_sdaster)
- if RESU_THER != None:
- self.type_sdprod(RESU_THER,evol_ther)
- if CHAM_MATER != None:
- self.type_sdprod(CHAM_MATER,cham_mater)
- if CHAR_THER != None:
- for m in CHAR_THER:
- self.type_sdprod(m['CHARGE'],char_ther)
- if CHAR_MECA != None:
- for m in CHAR_MECA:
- self.type_sdprod(m['CHARGE'],char_meca)
- return evol_noli
-
-
-MACR_CABRI_CALC=MACRO(nom="MACR_CABRI_CALC",
- op=macr_cabri_calc_ops,
- sd_prod=macr_cabri_calc_prod,
- fr="Calcul thermo-mécanique d'une jonction boulonnée de tuyauterie",
- reentrant='n',
- UIinfo={"groupes":("Outils métier",)},
- MAILLAGE = SIMP(statut='o',typ=maillage_sdaster,),
- AFFE_MATERIAU = FACT(statut='o',max='**',
- regles=(UN_PARMI('TOUT','GROUP_MA',),),
- TOUT = SIMP(statut='f',typ='TXM',into=("OUI",) ),
- GROUP_MA = SIMP(statut='f',typ='TXM',into=(
- "BRIDE",
- "GOUJON",
- "ROND",
- "ECROU",
- "JOINT",) ),
- MATER = SIMP(statut='o',typ=mater_sdaster),
- TEMP_REF = SIMP(statut='d',typ='R',defaut= 25. ),
- ),
- CHAM_MATER = SIMP(statut = 'f',typ=CO,),
- MODELE_THER= SIMP(statut = 'f',typ=CO,),
-
- DEFI_CHAR_THER = FACT(statut ='d',
- TEMP_INIT = SIMP(statut='d',typ='R',defaut= 25.,),
- COEF_H_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
- TEMP_EXT_FLUI = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
- COEF_H_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
- TEMP_EXT_AIR = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
- LIST_INST = SIMP(statut='f',typ=listr8_sdaster),
- ),
-
- CHAR_THER = FACT(statut = 'f',max=4,
- CHARGE = SIMP(statut='o',typ=CO),
- TYPE = SIMP(statut='o',typ='TXM',
- into=("BRIDE_FLUIDE","BRIDE_AIR","ECROU_GOUJON",
- "BRIDE_JOINT"),)
- ),
-
- RESU_THER = SIMP(statut = 'f',typ=CO,),
-
-
- MODELE_MECA= SIMP(statut = 'f',typ=CO,),
-
- DEFI_CHAR_MECA = FACT(statut='o',
- PRETENS = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
- PRES_REP = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
- EFFE_FOND = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster),),
- ),
-
- CHAR_MECA = FACT(statut = 'f',max=11,
- CHARGE = SIMP(statut='o',typ=CO),
- TYPE = SIMP(statut='o',typ='TXM',
- into=("BLOC_BAS_GOUJ","BLOC_BAS_JOINT",
- "BLOC_LAT_ALES","BLOC_LAT_NALES",
- "PLAN_TUBE",
- "PRES_FLU","EFFET_FOND",
- "CONT_JOINT",
- "DEFO_THER",
- "SERR_ECROU_1","SERR_ECROU_2",),)
- ),
-
- RELATION = SIMP(statut='f',typ='TXM',
- into=('VMIS_ISOT_TRAC','ELAS','ELAS_VMIS_TRAC',),),
-
- SOLVEUR = FACT(statut='d',
- METHODE = SIMP(statut='d',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT",) ),
- b_mult_front = BLOC(condition = "METHODE == 'MULT_FRONT' ",
- fr="Paramètres de la méthode multi frontale",
- RENUM = SIMP(statut='d',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
- NPREC = SIMP(statut='d',typ='I',defaut=8),
- STOP_SINGULIER = SIMP(statut='d',typ='TXM',defaut="OUI",into=("OUI","NON") ),
- ),
- ),
- INCREMENT = FACT(statut='f',
- regles=(EXCLUS('NUME_INST_INIT','INST_INIT'),
- EXCLUS('NUME_INST_FIN','INST_FIN'),),
- LIST_INST =SIMP(statut='f',typ=listr8_sdaster),
- EVOLUTION =SIMP(statut='f',typ='TXM',defaut="CHRONOLOGIQUE",
- into=("CHRONOLOGIQUE",) ),
- NUME_INST_INIT =SIMP(statut='f',typ='I'),
- INST_INIT =SIMP(statut='f',typ='R'),
- NUME_INST_FIN =SIMP(statut='f',typ='I'),
- INST_FIN =SIMP(statut='f',typ='R'),
- PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
- SUBD_METHODE =SIMP( statut='f',typ='TXM',
- into =("AUCUNE","UNIFORME","EXTRAPOLE"),
- defaut="AUCUNE",
- fr="Méthode de subdivision des pas de temps en cas de non-convergence"
- ),
- b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
- regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
- SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
- fr="Coefficient multiplicateur de la 1ère subdivision"),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
- fr="Nombre de subdivision d'un pas de temps"),
- SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
- fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
- SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
- fr="Pas de temps en dessous duquel on ne subdivise plus"),
- ),
- b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
- regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
- SUBD_OPTION =SIMP(statut='f',typ='TXM',
- into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
- defaut="IGNORE_PREMIERES",
- fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
- SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
- fr="Les n premières itérations sont ignorées pour l'extrapolation"),
- SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
- fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
- SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
- fr="Nombre de subdivision d'un pas de temps en cas divergence"),
- SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
- fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
- SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
- fr="Pas de temps en dessous duquel on ne subdivise plus"),
- SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
- fr="% itération autorisée en plus"),
- ),
- # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
- OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),),
- NOM_CHAM =SIMP(statut='f',typ='TXM',),
- NOM_CMP =SIMP(statut='f',typ='TXM',),
- VALE =SIMP(statut='f',typ='R'),
- ),
- NEWTON =FACT(statut='d',
- REAC_INCR =SIMP(statut='f',typ='I',defaut= 1 ),
- PREDICTION =SIMP(statut='f',typ='TXM',into=("TANGENTE","ELASTIQUE","EXTRAPOL") ),
- MATRICE =SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE") ),
- PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0),
- REAC_ITER =SIMP(statut='f',typ='I',defaut=0),
- EVOL_NOLI =SIMP(statut='f',typ=evol_noli),
- ),
- RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
- into=("IMPLICITE",)),
- CONVERGENCE =FACT(statut='d',
- regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),),
- SIGM_REFE =SIMP(statut='f',typ='R'),
- EPSI_REFE =SIMP(statut='f',typ='R'),
- FLUX_THER_REFE =SIMP(statut='f',typ='R'),
- RESI_REFE_RELA =SIMP(statut='f',typ='R'),
- RESI_GLOB_MAXI =SIMP(statut='f',typ='R'),
- RESI_GLOB_RELA =SIMP(statut='f',typ='R'),
- ITER_GLOB_MAXI =SIMP(statut='f',typ='I',defaut=10),
- ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25),
- ),
- );
+++ /dev/null
-#@ MODIF macr_cabri_calc_ops Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
-# -*- coding: iso-8859-1 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-
-
-def macr_cabri_calc_ops(self,MAILLAGE,MODELE_MECA,MODELE_THER,CHAR_THER,
- CHAR_MECA,RESU_THER,RESO_INTE,
- AFFE_MATERIAU,DEFI_CHAR_THER,DEFI_CHAR_MECA,RELATION,SOLVEUR,CONVERGENCE,NEWTON,
- INCREMENT,CHAM_MATER,**args):
- """
- Ecriture de la macro MACR_CABRI_CALC
- """
-
- #################################################################
- ########## PREPARATION MACRO
- #################################################################
-
- from Accas import _F
-
- ier =0
-
- # On met certains mots-clefs dans des variables locales pour les proteger
- affemateriau = AFFE_MATERIAU
- mail = MAILLAGE
- resointe = RESO_INTE
-
- # On importe les definitions des commandes a utiliser dans la macro
- # Le nom de la variable doit etre obligatoirement le nom de la commande
- DEFI_GROUP = self.get_cmd('DEFI_GROUP')
- AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
- AFFE_MODELE = self.get_cmd('AFFE_MODELE')
- MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE')
- AFFE_CHAR_THER_F = self.get_cmd('AFFE_CHAR_THER_F')
- AFFE_CHAR_THER = self.get_cmd('AFFE_CHAR_THER')
- AFFE_CHAR_MECA_F = self.get_cmd('AFFE_CHAR_MECA_F')
- AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA')
- DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
- DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
- THER_LINEAIRE = self.get_cmd('THER_LINEAIRE')
- STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
-
- # La macro compte pour 1 dans la numerotation des commandes
- self.set_icmd(1)
-
- # Le concept sortant (de type evol_noli) est nomme 'resumeca' dans
- # le contexte de la macro
- self.DeclareOut('resumeca',self.sd)
- self.DeclareOut('mail',MAILLAGE)
-
- #################################################################
- ########## PREPARATION DES MODELES
- #################################################################
-
- # Definition des groupes
- mail=DEFI_GROUP(reuse =mail,MAILLAGE=mail,
- CREA_GROUP_NO=(
- _F(GROUP_MA='M_GOU',NOM='N_M_GOU',),
- _F(GROUP_MA='M_JOI',NOM='N_M_JOI',),
- _F(GROUP_MA='SCBJ',NOM='N_SCBJ',),
- _F(GROUP_MA='SCJB',NOM='N_SCJB',),
- _F(GROUP_MA='M_L_AA',NOM='N_M_L_AA',),
- _F(GROUP_MA='SCEG',NOM='N_SCEG',),
- _F(GROUP_MA='SCGE',NOM='N_SCGE',),),)
-
- # Creation du modele thermique
- if MODELE_THER != None:
- self.DeclareOut('modther',MODELE_THER)
-
- modther=AFFE_MODELE(MAILLAGE=mail,
- AFFE=_F(GROUP_MA=('VTOT','M_GOU','M_TUB','M_JOI','SCBJ','SCJB',
- 'M_L_AA','M_INT','M_L_SA','M_EXT','SCEG','SCGE',),
- PHENOMENE='THERMIQUE',
- MODELISATION='3D_DIAG',),
- );
-
- # Creation du modele mecanique
- if MODELE_MECA != None:
- self.DeclareOut('modmeca',MODELE_MECA)
-
- modmeca = AFFE_MODELE(MAILLAGE=mail,
- AFFE=_F(GROUP_MA=('VTOT','M_GOU','M_TUB','M_JOI','SCBJ','SCJB',
- 'M_L_AA','M_L_SA','SCEG','SCGE','M_INT','M_EXT',),
- PHENOMENE='MECANIQUE',
- MODELISATION='3D',),
- );
-
- # Orientation des mailles
- mail=MODI_MAILLAGE(reuse =mail,
- MAILLAGE=mail,
- ORIE_PEAU_3D=(_F(GROUP_MA=('M_INT','M_TUB',),),
- _F(GROUP_MA=('M_L_AA','M_JOI','M_L_SA',),),),
- );
-
-
-
- # Affectation des materiaux (thermique)
- motscles={}
- motscles['AFFE']=[]
- for mat in affemateriau:
- if mat['TOUT'] == None:
- # Creation de mots-cles pour les AFFE_CHAR_MECA
- motscles['AFFE'].append(_F(GROUP_MA=mat['GROUP_MA'],
- MATER = mat['MATER']))
- else:
- # Creation de mots-cles pour les AFFE_CHAR_MECA
- motscles['AFFE'].append(_F(TOUT='OUI',
- MATER = mat['MATER']))
-
- __cham = AFFE_MATERIAU(MAILLAGE=mail,
- MODELE=modther,
- AFFE=motscles['AFFE'],
- )
-
- #################################################################
- ########## CONDITIONS AUX LIMITES THERMIQUES
- #################################################################
- # Recuperation des parametres thermiques
-
- if DEFI_CHAR_THER != None:
- temp_ini = DEFI_CHAR_THER['TEMP_INIT']
- if DEFI_CHAR_THER['COEF_H_FLUI']!=None:
- coef_int = DEFI_CHAR_THER['COEF_H_FLUI']
- else:
- coef_int = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,0.016,
- 7200.0,0.016,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- if DEFI_CHAR_THER['TEMP_EXT_FLUI']!=None:
- temp_int = DEFI_CHAR_THER['TEMP_EXT_FLUI']
- else:
- temp_int = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,temp_ini,1.0,temp_ini,11.0,60.0,
- 600.0,60.0,610.0,280.0,1800.0,280.0,7200.0,280.0,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- if DEFI_CHAR_THER['COEF_H_AIR']!=None:
- coef_ext = DEFI_CHAR_THER['COEF_H_AIR']
- else:
- coef_ext = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,1e-05,7200.0,1e-05,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
-
- if DEFI_CHAR_THER['TEMP_EXT_AIR']!=None:
- temp_ext = DEFI_CHAR_THER['TEMP_EXT_AIR']
- else:
- temp_ext = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,20.0,7200.0,20.0,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- if DEFI_CHAR_THER['LIST_INST']!=None:
- transi1 = DEFI_CHAR_THER['LIST_INST']
- else:
- transi1 = DEFI_LIST_REEL(DEBUT=0.0,
- INTERVALLE=(_F(JUSQU_A=1.0,
- NOMBRE=1,),
- _F(JUSQU_A=11.0,
- NOMBRE=10,),
- _F(JUSQU_A=600.0,
- NOMBRE=10,),
- _F(JUSQU_A=610.0,
- NOMBRE=30,),
- _F(JUSQU_A=1800.0,
- NOMBRE=30,),
- _F(JUSQU_A=7200.0,
- NOMBRE=10,),),);
- else:
- temp_ini = DEFI_CHAR_THER['TEMP_INIT']
- coef_int = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,0.016,
- 7200.0,0.016,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- temp_int = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,temp_ini,1.0,temp_ini,11.0,60.0,
- 600.0,60.0,610.0,280.0,1800.0,280.0,7200.0,280.0,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- coef_ext = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,1e-05,7200.0,1e-05,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- temp_ext = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,20.0,7200.0,20.0,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- transi1 = DEFI_LIST_REEL(DEBUT=0.0,
- INTERVALLE=(_F(JUSQU_A=1.0,
- NOMBRE=1,),
- _F(JUSQU_A=11.0,
- NOMBRE=10,),
- _F(JUSQU_A=600.0,
- NOMBRE=10,),
- _F(JUSQU_A=610.0,
- NOMBRE=30,),
- _F(JUSQU_A=1800.0,
- NOMBRE=30,),
- _F(JUSQU_A=7200.0,
- NOMBRE=10,),),);
- # Que sauver ?
- if CHAR_THER != None:
- for m in CHAR_THER:
- if m['TYPE']=="BRIDE_FLUIDE":
- self.DeclareOut('cl_th1',m['CHARGE'])
- if m['TYPE']=="BRIDE_AIR":
- self.DeclareOut('cl_th2',m['CHARGE'])
- if m['TYPE']=="ECROU_GOUJON":
- self.DeclareOut('cl_th3',m['CHARGE'])
- if m['TYPE']=="BRIDE_JOINT":
- self.DeclareOut('cl_th4',m['CHARGE'])
-
- # Echanges thermiques internes entre le fluide et la bride
- cl_th1=AFFE_CHAR_THER_F(MODELE=modther,
- ECHANGE=_F(GROUP_MA = 'M_INT',
- COEF_H = coef_int,
- TEMP_EXT = temp_int,),);
-
- # Echanges thermiques externes entre bride et air ambiant
- cl_th2=AFFE_CHAR_THER_F(MODELE=modther,
- ECHANGE=_F(GROUP_MA='M_EXT',
- COEF_H=coef_ext,
- TEMP_EXT=temp_ext,),);
-
- # Echanges thermiques entre ecrou et goujon
- cl_th3=AFFE_CHAR_THER(MODELE=modther,
- LIAISON_GROUP=_F(GROUP_NO_1='N_SCEG',
- GROUP_NO_2='N_SCGE',
- DDL_1='TEMP',
- COEF_MULT_1=1.0,
- DDL_2='TEMP',
- COEF_MULT_2=-1.0,
- COEF_IMPO=0.0,),);
-
- # Echanges thermiques entre bride et joint
- cl_th4=AFFE_CHAR_THER(MODELE=modther,
- LIAISON_GROUP=_F(GROUP_NO_1='N_SCBJ',
- GROUP_NO_2='N_SCJB',
- DDL_1='TEMP',
- COEF_MULT_1=1.0,
- DDL_2='TEMP',
- COEF_MULT_2=-1.0,
- COEF_IMPO=0.0,),);
-
-
-
- #################################################################
- ########## CALCUL THERMIQUE
- #################################################################
- if RESU_THER != None:
- self.DeclareOut('resuther',RESU_THER)
-
- resuther=THER_LINEAIRE(MODELE=modther,
- CHAM_MATER=__cham,
- EXCIT=(_F(CHARGE=cl_th1,),
- _F(CHARGE=cl_th2,),
- _F(CHARGE=cl_th3,),
- _F(CHARGE=cl_th4,),),
- INCREMENT=_F(LIST_INST=transi1,),
- ETAT_INIT=_F(VALE=temp_ini,),
- TITRE='CABRI THERMIQUE &DATE &HEURE',);
-
- # Affectation des materiaux (mécanique)
- if CHAM_MATER != None:
- self.DeclareOut('_chamt',CHAM_MATER)
- motscles={}
- motscles['AFFE']=[]
- motscles['AFFE_VARC']=[]
- for mat in affemateriau:
- if mat['TOUT'] == None:
- # Creation de mots-cles pour les AFFE_CHAR_MECA
- motscles['AFFE'].append(_F(GROUP_MA=mat['GROUP_MA'],
- MATER = mat['MATER'],) )
- motscles['AFFE_VARC'].append(_F(NOM_VARC='TEMP',GROUP_MA=mat['GROUP_MA'],
- EVOL=resuther,NOM_CHAM='TEMP',
- VALE_REF = mat['TEMP_REF'],))
- else:
- # Creation de mots-cles pour les AFFE_CHAR_MECA
- motscles['AFFE'].append(_F(TOUT='OUI',
- MATER = mat['MATER']) )
- motscles['AFFE_VARC'].append(_F(NOM_VARC='TEMP',TOUT='OUI',
- EVOL=resuther,NOM_CHAM='TEMP',
- VALE_REF = mat['TEMP_REF'],))
-
- _chamt = AFFE_MATERIAU(MAILLAGE=mail,
- MODELE=modther,
- AFFE=motscles['AFFE'],
- AFFE_VARC=motscles['AFFE_VARC'],
- )
-
- #################################################################
- ########## CONDITIONS AUX LIMITES MECANIQUES
- #################################################################
- # Recuperation des parametres mecaniques
- if DEFI_CHAR_MECA != None:
- if DEFI_CHAR_MECA['PRETENS']!=None:
- f_pret = DEFI_CHAR_MECA['PRETENS']
- else:
- f_pret=DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,0.0,1.0,-0.02,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- if DEFI_CHAR_MECA['PRES_REP']!=None:
- pre_int = DEFI_CHAR_MECA['PRES_REP']
- else:
- pre_int = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,0.0,1.0,0.0,11.0,16.0,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- if DEFI_CHAR_MECA['EFFE_FOND']!=None:
- eff_fond = DEFI_CHAR_MECA['EFFE_FOND']
- else:
- eff_fond=DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,-0.0,1.0,-0.0,11.0,-20.607059,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- else:
- f_pret=DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,0.0,1.0,-0.02,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
-
- pre_int = DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,0.0,1.0,0.0,11.0,16.0,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
-
- eff_fond=DEFI_FONCTION(NOM_PARA='INST',
- VALE=(0.0,-0.0,1.0,-0.0,11.0,-20.607059,),
- PROL_DROITE='CONSTANT',
- PROL_GAUCHE='CONSTANT',);
- # Que sauver ?
- if CHAR_MECA != None:
- for m in CHAR_MECA:
- if m['TYPE']=="BLOC_BAS_GOUJ":
- self.DeclareOut('cl_me1',m['CHARGE'])
- if m['TYPE']=="BLOC_BAS_JOINT":
- self.DeclareOut('cl_me2',m['CHARGE'])
- if m['TYPE']=="BLOC_LAT_ALES":
- self.DeclareOut('cl_me3',m['CHARGE'])
- if m['TYPE']=="BLOC_LAT_NALES":
- self.DeclareOut('cl_me4',m['CHARGE'])
- if m['TYPE']=="PLAN_TUBE":
- self.DeclareOut('cl_me5',m['CHARGE'])
- if m['TYPE']=="PRES_FLU":
- self.DeclareOut('cl_me6',m['CHARGE'])
- if m['TYPE']=="EFFET_FOND":
- self.DeclareOut('cl_me7',m['CHARGE'])
- if m['TYPE']=="CONT_JOINT":
- self.DeclareOut('cl_me8',m['CHARGE'])
- if m['TYPE']=="SERR_ECROU_1":
- self.DeclareOut('cl_me10',m['CHARGE'])
- if m['TYPE']=="SERR_ECROU_2":
- self.DeclareOut('cl_me11',m['CHARGE'])
-
-
- # Blocage bas du goujon
- cl_me1=AFFE_CHAR_MECA(MODELE=modmeca,
- DDL_IMPO=_F(GROUP_NO='N_M_GOU',
- DZ=0.0,),
- INFO=2,);
- # Blocage bas du joint
- cl_me2=AFFE_CHAR_MECA(MODELE=modmeca,
- DDL_IMPO=_F(GROUP_NO='N_M_JOI',
- DZ=0.0,),
- INFO=2,);
-
- # Blocage lateral, face laterale avec alesage
- cl_me3=AFFE_CHAR_MECA(MODELE=modmeca,
- DDL_IMPO=_F(GROUP_NO='N_M_L_AA',
- DY=0.0,),
- INFO=2,);
-
- # Face laterale sans alesage
- cl_me4=AFFE_CHAR_MECA(MODELE=modmeca,
- FACE_IMPO=_F(GROUP_MA='M_L_SA',
- DNOR=0.0,),
- INFO=2,);
-
- # Condition de planeite de la face de coupe du tube
- cl_me5=AFFE_CHAR_MECA(MODELE=modmeca,
- LIAISON_UNIF=_F(GROUP_MA='M_TUB',
- DDL='DZ',),
- INFO=2,);
- # Pression due au fluide
- cl_me6=AFFE_CHAR_MECA_F(MODELE=modmeca,
- PRES_REP=_F(GROUP_MA='M_INT',
- PRES=pre_int,),
- INFO=2,);
-
- # Effet de fond
- cl_me7=AFFE_CHAR_MECA_F(MODELE=modmeca,
- PRES_REP=_F(GROUP_MA='M_TUB',
- PRES=eff_fond,),
- INFO=2,);
-
- # Contact zone de joint
- cl_me8=AFFE_CHAR_MECA(MODELE=modmeca,
- CONTACT=_F(GROUP_MA_MAIT='SCBJ',
- GROUP_MA_ESCL='SCJB',),
- INFO=2,);
-
- # Serrage ecrou/goujon (pre-tensionnement)
- cl_me10=AFFE_CHAR_MECA_F(MODELE=modmeca,
- LIAISON_GROUP=_F(GROUP_NO_1='N_SCEG',
- GROUP_NO_2='N_SCGE',
- DDL_1='DZ',
- COEF_MULT_1=1.0,
- DDL_2='DZ',
- COEF_MULT_2=-1.0,
- COEF_IMPO=f_pret,),
- INFO=2,);
-
- cl_me11=AFFE_CHAR_MECA(MODELE=modmeca,
- LIAISON_GROUP=_F(GROUP_NO_1='N_SCEG',
- GROUP_NO_2='N_SCGE',
- DDL_1='DX',
- COEF_MULT_1=1.0,
- DDL_2='DX',
- COEF_MULT_2=-1.0,
- COEF_IMPO=0.0,),
- INFO=2,);
-
-
- #################################################################
- ########## CALCUL MECANIQUE
- #################################################################
- # Options de convergence
- solveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
-
- # Elimination des valeurs "None"
- for i in solveur.keys():
- if solveur[i]==None : del solveur[i]
-
-
- transi2 = DEFI_LIST_REEL(DEBUT=0.0,
- INTERVALLE=(_F(JUSQU_A=1.0,
- NOMBRE=2,),
- _F(JUSQU_A=11.0,
- NOMBRE=20,),
- _F(JUSQU_A=600.0,
- NOMBRE=20,),
- _F(JUSQU_A=610.0,
- NOMBRE=20,),
- _F(JUSQU_A=1800.0,
- NOMBRE=20,),
- _F(JUSQU_A=7200.0,
- NOMBRE=20,),),);
-
- # Options d'incrementation
- if INCREMENT != None:
- if INCREMENT['LIST_INST'] != None:
- listinst = INCREMENT['LIST_INST']
- else:
- listinst = transi2
-
- increment=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
-
- # Elimination des valeurs "None"
- for i in increment.keys():
- if increment[i]==None : del increment[i]
-
- increment['LIST_INST'] = listinst
-
- else:
- listinst = transi2
- increment =_F(
- LIST_INST = listinst,
- ),
-
- # Options de Newton
- newton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
- # Elimination des valeurs "None"
- for i in newton.keys():
- if newton[i]==None : del newton[i]
-
- # Options de convergence
- convergence=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
- # Elimination des valeurs "None"
- for i in convergence.keys():
- if convergence[i]==None : del convergence[i]
-
- # Options de comportement
- # Type incremental (=1) ou elastique (=0)
- comp_incr = 0
- if RELATION:
- relation=RELATION
- if relation == 'VMIS_ISOT_TRAC':
- comp_incr = 1
- else:
- comp_incr = 0
- else:
- relation = 'ELAS'
- comp_incr = 0
-
-
- # Parametres du calcul
- if comp_incr == 1:
- resumeca=STAT_NON_LINE(MODELE=modmeca,
- CHAM_MATER=_chamt,
- EXCIT=(_F(CHARGE=cl_me1,),
- _F(CHARGE=cl_me2,),
- _F(CHARGE=cl_me3,),
- _F(CHARGE=cl_me4,),
- _F(CHARGE=cl_me5,),
- _F(CHARGE=cl_me6,),
- _F(CHARGE=cl_me7,),
- _F(CHARGE=cl_me8,),
- _F(CHARGE=cl_me10,),
- _F(CHARGE=cl_me11,),
- ),
- SOLVEUR = solveur,
- COMP_INCR =_F(RELATION=relation,RESO_INTE=resointe),
- NEWTON = newton,
- INCREMENT = increment,
- CONVERGENCE = convergence,
- TITRE='CABRI THERMOM\xe9CANIQUE &DATE &HEURE',);
- else:
- resumeca=STAT_NON_LINE(MODELE=modmeca,
- CHAM_MATER=_chamt,
- EXCIT=(_F(CHARGE=cl_me1,),
- _F(CHARGE=cl_me2,),
- _F(CHARGE=cl_me3,),
- _F(CHARGE=cl_me4,),
- _F(CHARGE=cl_me5,),
- _F(CHARGE=cl_me6,),
- _F(CHARGE=cl_me7,),
- _F(CHARGE=cl_me8,),
- _F(CHARGE=cl_me10,),
- _F(CHARGE=cl_me11,),
- ),
- SOLVEUR = solveur,
- COMP_ELAS =_F(RELATION=relation,RESO_INTE=resointe),
- NEWTON = newton,
- INCREMENT = increment,
- CONVERGENCE = convergence,
- TITRE='CABRI THERMOM\xe9CANIQUE &DATE &HEURE',);
-
- return ier
+++ /dev/null
-#@ MODIF macr_cabri_mail_cata Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
-# -*- coding: iso-8859-1 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-
-from Intranet.macr_cabri_mail_ops import macr_cabri_mail_ops
-from Cata.cata import *
-
-MACR_CABRI_MAIL=MACRO(nom="MACR_CABRI_MAIL",
- op=macr_cabri_mail_ops,
- sd_prod=maillage_sdaster,
- fr="maillage d'une jonction boulonnée de tuyauterie",
- reentrant='n',
- UIinfo={"groupes":("Outils métier",)},
- EXEC_MAILLAGE = FACT(statut='o',
- LOGICIEL = SIMP(statut = 'o',typ='TXM',into=("GIBI2000",),),
- UNITE_DATG = SIMP(statut = 'f',typ='I',defaut=70,),
- UNITE_MGIB = SIMP(statut = 'f',typ='I',defaut=19,),
- NIVE_GIBI = SIMP(statut = 'f',typ='I',defaut=10,
- into = (3,4,5,6,7,8,9,10,11),
- ),
- ),
- RAFF_MAILLAGE = FACT(statut = 'd',
- NB_RADIAL = SIMP(statut = 'f',typ='I',defaut=2,),
- NB_CIRCONF = SIMP(statut = 'f',typ='I',defaut=3,),
- NB_VERTICAL = SIMP(statut = 'f',typ='I',defaut=6,),
- NB_ALESAGE = SIMP(statut = 'f',typ='I',defaut=5,),
- ),
- VERI_MAIL = FACT(statut='d',
- VERIF = SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
- APLAT = SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
- ),
- GEOM_BRID = FACT(statut = 'o',
- NORME = SIMP(statut = 'o',typ='TXM',into=("OUI","NON"),),
- b_bride_iso = BLOC(condition = "NORME == 'OUI'",
- TYPE = SIMP(statut='o',typ='TXM',
- into=('A','AA','B','B1','C','D','D1','E','F',
- 'FF','G','GG','H','H1','I','J','J1',
- 'K','L','L1','M','N','O','P','S','T','W'),
- ),
- ),
- b_bride_niso = BLOC(condition = "NORME == 'NON'",
- TUBU_D_EXT = SIMP(statut='o',typ='R',),
- TUBU_H = SIMP(statut='o',typ='R',),
- BRID_D_EXT = SIMP(statut='o',typ='R',),
- BRID_D_INT = SIMP(statut='o',typ='R',),
- BRID_H = SIMP(statut='o',typ='R',),
- BRID_D_CONGE = SIMP(statut='o',typ='R',),
- BRID_R_CONGE = SIMP(statut='o',typ='R',),
- BRID_D_EPAUL = SIMP(statut='o',typ='R',),
- BRID_H_EPAUL = SIMP(statut='o',typ='R',),
- BRID_D_ALESAG = SIMP(statut='o',typ='R',),
- BRID_P_ALESAG = SIMP(statut='o',typ='R',),
- BRID_H_ALESAG = SIMP(statut='o',typ='R',),
- GOUJ_N_GOUJON = SIMP(statut='o',typ='I',),
- GOUJ_D_GOUJON = SIMP(statut='o',typ='R',),
- GOUJ_E_FILET = SIMP(statut='o',typ='R',),
- GOUJ_D_RONDEL = SIMP(statut='o',typ='R',),
- GOUJ_E_RONDEL = SIMP(statut='o',typ='R',),
- GOUJ_D_ECROU = SIMP(statut='o',typ='R',),
- GOUJ_E_ECROU = SIMP(statut='o',typ='R',),
- ETAN_E_JOINT = SIMP(statut='o',typ='R',),
- ),
- ),
- IMPRESSION = FACT(statut='d',
- UNITE = SIMP(statut='f',typ='I'),
- FORMAT = SIMP(statut='f',typ='TXM',defaut="ASTER",
- into=("ASTER","CASTEM","IDEAS"),
- ),
- b_impr_castem = BLOC(condition = "FORMAT == 'CASTEM'",
- NIVE_GIBI = SIMP(statut='f',typ='I',defaut=10,into=(3,10),),
- ),
- b_impr_ideas = BLOC(condition = "FORMAT == 'IDEAS'",
- VERSION = SIMP(statut='f',typ='I',defaut=5,into=(4,5),),
- ),
- ),
- );
+++ /dev/null
-#@ MODIF macr_cabri_mail_dat Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
-# -*- coding: iso-8859-1 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-
-# Données pour les brides standards
-
-
-
-# Pour ajouter une bride x:
-# Définir un dico_bride_x comme ci-dessous puis ajoutez-le à dico_bride_std
-
-# dictionnaire pour la description des variables
-dico_var_geo = {'nbgouj':'Nombre de goujons de la jonction boulonnée (GOUJ_N_GOUJON)',
- 'dint':'Diamètre intérieur de la bride (BRID_D_INT)',
- 'dex1':'Diamétre extérieur de la conduite (TUBU_D_EXT)',
- 'dex2':'Position (diamètre) du congé de la bride (BRID_D_CONGE)',
- 'dex3':'Diamètre de l''épaulement de la bride au niveau de l''interface d''étanchéité (BRID_D_EPAUL)',
- 'dtrou':'Position des alésages de la bride permettant l''introduction des goujons (BRID_P_ALESAG)',
- 'dext':'Diamètre extérieur de la bride (BRID_D_EXT)',
- 'dt':'Diamètre des alésages de la bride permettant l''introduction des goujons (BRID_D_ALESAG)',
- 'drd':'Diamètre de la rondelle (GOUJ_D_RONDEL)',
- 'dg':'Diamètre des goujons de la jonction boulonnée (GOUJ_D_GOUJON)',
- 'dec':'Diamètre de l''écrou (GOUJ_D_ECROU)',
- 'rcong':'Rayon du congé de la bride (BRID_R_CONGE)',
- 'he':'Epaisseur de la rondelle (GOUJ_E_RONDEL)',
- 'e':'Epaisseur de l''écrou (GOUJ_E_ECROU)',
- 'hc1':'Hauteur de la bride (BRID_H)',
- 'hcg1':'Hauteur de conduite (TUBU_H)',
- 'hb':'Hauteur de l''épaulement de la bride au niveau de l''interface d''étanchéité (BRID_H_EPAUL)',
- 'htrou':'Hauteur des alésages de la bride permettant l''introduction des goujons (BRID_H_ALESAG)',
- 'pf':'Profondeur (épaisseur) des filets des goujons (GOUJ_E_FILET)',
- 'j':'Epaisseur du joint au niveau de l''interface d''étanchéité (ETAN_E_JOINT)'}
-
-dico_var_msh = {'nrad':'Nombre d''éléments radiaux (NBR_RAD)',
- 'ncir':'Nombre d''éléments circonférentiels (NBR_CIR)',
- 'nver':'Nombre d''éléments verticaux (NBR_VER)',
- 'nsect':'Nombre d''éléments de l''alésage (NBR_ALE)',
- 'temps':'Temps d''analyse'}
-
-# dictionnaires des brides standards
-dico_bride_A = {'nbgouj': 4,
- 'dint': 15.76,
- 'dex1': 21.3,
- 'dex2': 38.,
- 'dex3': 48.,
- 'dtrou': 67.,
- 'dext': 95.,
- 'dt': 14.,
- 'drd': 25.,
- 'dg': 12.,
- 'dec': 18.,
- 'rcong': 3.,
- 'he': 12.,
- 'e': 2.5,
- 'hc1': 46.5,
- 'hcg1': 20,
- 'hb': 1.5,
- 'htrou': 20.,
- 'pf': 1.5,
- 'j': 2}
-
-dico_bride_AA = {'nbgouj': 32,
- 'dint': 336.5,
- 'dex1': 355.6,
- 'dex2': 395.,
- 'dex3': 415.,
- 'dtrou': 460.,
- 'dext': 515.,
- 'dt': 22.,
- 'drd': 36.,
- 'dg': 20.,
- 'dec': 30.,
- 'rcong': 5.,
- 'he': 20.,
- 'e': 3.,
- 'hc1': 115.,
- 'hcg1': 115./2.,
- 'hb': 3.,
- 'htrou': 47.,
- 'pf': 2.2,
- 'j': 2}
-
-dico_bride_B = {'nbgouj': 4,
- 'dint': 26.64,
- 'dex1': 33.4,
- 'dex2': 53.,
- 'dex3': 63.,
- 'dtrou': 88.,
- 'dext': 123.,
- 'dt': 16.,
- 'drd': 27.,
- 'dg': 14.,
- 'dec': 21.,
- 'rcong': 4.,
- 'he': 14.,
- 'e': 2.5,
- 'hc1': 59.,
- 'hcg1': 59./2.,
- 'hb': 1.5,
- 'htrou': 27.5,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_B1 = {'nbgouj': 4,
- 'dint': 24.3,
- 'dex1': 33.4,
- 'dex2': 53.,
- 'dex3': 63.,
- 'dtrou': 88.,
- 'dext': 123.,
- 'dt': 16.,
- 'drd': 27.,
- 'dg': 14.,
- 'dec': 21.,
- 'rcong': 4.,
- 'he': 14.,
- 'e': 2.5,
- 'hc1': 59.,
- 'hcg1': 59./2.,
- 'hb': 1.5,
- 'htrou': 27.5,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_C = {'nbgouj': 8,
- 'dint': 52.48,
- 'dex1': 60.3,
- 'dex2': 84.,
- 'dex3': 100.,
- 'dtrou': 127.,
- 'dext': 165.,
- 'dt': 18.,
- 'drd': 30,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 4.,
- 'he': 16.,
- 'e': 3,
- 'hc1': 70.,
- 'hcg1': 70./2.,
- 'hb': 1.5,
- 'htrou': 21.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_D = {'nbgouj': 8,
- 'dint': 42.9,
- 'dex1': 60.3,
- 'dex2': 84.,
- 'dex3': 100.,
- 'dtrou': 127.,
- 'dext': 165.,
- 'dt': 18.,
- 'drd': 30,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 87.6,
- 'hcg1': 87.6/2.,
- 'hb': 1.5,
- 'htrou': 38.5,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_D1 = {'nbgouj': 8,
- 'dint': 49.22,
- 'dex1': 60.3,
- 'dex2': 84.,
- 'dex3': 100.,
- 'dtrou': 127.,
- 'dext': 165.,
- 'dt': 18.,
- 'drd': 30,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 87.6,
- 'hcg1': 87.6/2.,
- 'hb': 1.5,
- 'htrou': 38.5,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_E = {'nbgouj': 8,
- 'dint': 83.1,
- 'dex1': 88.9,
- 'dex2': 117.5,
- 'dex3': 135.,
- 'dtrou': 165.,
- 'dext': 209.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 80.,
- 'hcg1': 80./2.,
- 'hb': 2.,
- 'htrou': 27.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_F = {'nbgouj': 8,
- 'dint': 73.66,
- 'dex1': 88.9,
- 'dex2': 117.5,
- 'dex3': 135.,
- 'dtrou': 165.,
- 'dext': 209.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 89.,
- 'hcg1': 89./2.,
- 'hb': 2.,
- 'htrou': 36.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_FF = {'nbgouj': 32,
- 'dint': 396.99,
- 'dex1': 406.4,
- 'dex2': 440.,
- 'dex3': 455.,
- 'dtrou': 485.,
- 'dext': 535.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 99.,
- 'hcg1': 99./2.,
- 'hb': 3.,
- 'htrou': 40.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_G = {'nbgouj': 12,
- 'dint': 66.7,
- 'dex1': 88.9,
- 'dex2': 117.5,
- 'dex3': 135.,
- 'dtrou': 165.,
- 'dext': 209.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 98.,
- 'hcg1': 98./2.,
- 'hb': 2.,
- 'htrou': 45.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_GG = {'nbgouj': 36,
- 'dint': 381.,
- 'dex1': 406.4,
- 'dex2': 445.,
- 'dex3': 460.,
- 'dtrou': 495.,
- 'dext': 545.,
- 'dt': 22.,
- 'drd': 36,
- 'dg': 20.,
- 'dec': 30.,
- 'rcong': 5.,
- 'he': 20.,
- 'e': 3.,
- 'hc1': 129.,
- 'hcg1': 129./2.,
- 'hb': 3.,
- 'htrou': 63.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_H = {'nbgouj': 12,
- 'dint': 108.2,
- 'dex1': 114.3,
- 'dex2': 146.,
- 'dex3': 157.,
- 'dtrou': 190.,
- 'dext': 225.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 89.,
- 'hcg1': 89./2.,
- 'hb': 2.,
- 'htrou': 33.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_H1 = {'nbgouj': 12,
- 'dint': 102.6,
- 'dex1': 114.3,
- 'dex2': 146.,
- 'dex3': 157.,
- 'dtrou': 190.,
- 'dext': 225.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 89.,
- 'hcg1': 89./2.,
- 'hb': 2.,
- 'htrou': 33.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_I = {'nbgouj': 18,
- 'dint': 92.1,
- 'dex1': 114.3,
- 'dex2': 146.,
- 'dex3': 160.,
- 'dtrou': 200.,
- 'dext': 255.,
- 'dt': 20.,
- 'drd': 32.,
- 'dg': 18.,
- 'dec': 27.,
- 'rcong': 5.,
- 'he': 18.,
- 'e': 3.,
- 'hc1': 99.,
- 'hcg1': 99./2.,
- 'hb': 2.,
- 'htrou': 43.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_J = {'nbgouj': 18,
- 'dint': 87.34,
- 'dex1': 114.3,
- 'dex2': 146.,
- 'dex3': 160.,
- 'dtrou': 200.,
- 'dext': 255.,
- 'dt': 20.,
- 'drd': 32.,
- 'dg': 18.,
- 'dec': 27.,
- 'rcong': 5.,
- 'he': 18.,
- 'e': 3.,
- 'hc1': 111.,
- 'hcg1': 111./2.,
- 'hb': 2.,
- 'htrou': 55.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_J1 = {'nbgouj': 18,
- 'dint': 87.3,
- 'dex1': 114.3,
- 'dex2': 146.,
- 'dex3': 160.,
- 'dtrou': 200.,
- 'dext': 255.,
- 'dt': 22.,
- 'drd': 36.,
- 'dg': 20.,
- 'dec': 30.,
- 'rcong': 5.,
- 'he': 20.,
- 'e': 3.,
- 'hc1': 111.,
- 'hcg1': 111./2.,
- 'hb': 2.,
- 'htrou': 55.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_K = {'nbgouj': 8,
- 'dint': 161.5,
- 'dex1': 168.3,
- 'dex2': 192.,
- 'dex3': 210.,
- 'dtrou': 235.,
- 'dext': 280.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 84.,
- 'hcg1': 84./2.,
- 'hb': 2.,
- 'htrou': 28.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_L = {'nbgouj': 16,
- 'dint': 154.8,
- 'dex1': 168.3,
- 'dex2': 206.,
- 'dex3': 220.,
- 'dtrou': 255.,
- 'dext': 317.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 96.,
- 'hcg1': 96./2.,
- 'hb': 2.,
- 'htrou': 40.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_L1 = {'nbgouj': 16,
- 'dint': 154.8,
- 'dex1': 168.3,
- 'dex2': 206.,
- 'dex3': 220.,
- 'dtrou': 255.,
- 'dext': 317.,
- 'dt': 20.,
- 'drd': 32.,
- 'dg': 18.,
- 'dec': 27.,
- 'rcong': 5.,
- 'he': 18.,
- 'e': 3.,
- 'hc1': 96.,
- 'hcg1': 96./2.,
- 'hb': 2.,
- 'htrou': 40.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_M = {'nbgouj': 16,
- 'dint': 139.7,
- 'dex1': 168.3,
- 'dex2': 206.,
- 'dex3': 220.,
- 'dtrou': 250.,
- 'dext': 290.,
- 'dt': 24.,
- 'drd': 40.,
- 'dg': 22.,
- 'dec': 32.,
- 'rcong': 5.,
- 'he': 22.,
- 'e': 3.,
- 'hc1': 135.,
- 'hcg1': 135./2.,
- 'hb': 3.,
- 'htrou': 62.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_N = {'nbgouj': 12,
- 'dint': 131.9,
- 'dex1': 168.3,
- 'dex2': 220.,
- 'dex3': 240.,
- 'dtrou': 290.,
- 'dext': 365.,
- 'dt': 30.,
- 'drd': 48.,
- 'dg': 27.,
- 'dec': 41.,
- 'rcong': 5.,
- 'he': 27.,
- 'e': 4.,
- 'hc1': 148.,
- 'hcg1': 148./2.,
- 'hb': 3.,
- 'htrou': 75.,
- 'pf': 2.6,
- 'j': 2}
-dico_bride_O = {'nbgouj': 12,
- 'dint': 211.58,
- 'dex1': 219.1,
- 'dex2': 248.,
- 'dex3': 260.,
- 'dtrou': 292.,
- 'dext': 335.,
- 'dt': 20.,
- 'drd': 32.,
- 'dg': 18.,
- 'dec': 27.,
- 'rcong': 5.,
- 'he': 18.,
- 'e': 3.,
- 'hc1': 87.,
- 'hcg1': 87./2.,
- 'hb': 3.,
- 'htrou': 30.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_P = {'nbgouj': 16,
- 'dint': 202.74,
- 'dex1': 219.1,
- 'dex2': 248.,
- 'dex3': 260.,
- 'dtrou': 292.,
- 'dext': 335.,
- 'dt': 20.,
- 'drd': 32,
- 'dg': 18.,
- 'dec': 27.,
- 'rcong': 5.,
- 'he': 18.,
- 'e': 3.,
- 'hc1': 99.,
- 'hcg1': 99./2.,
- 'hb': 3.,
- 'htrou': 42.,
- 'pf': 2.2,
- 'j': 2}
-dico_bride_S = {'nbgouj': 16,
- 'dint': 264.62,
- 'dex1': 273.,
- 'dex2': 305.,
- 'dex3': 315.,
- 'dtrou': 350.,
- 'dext': 390.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 89.,
- 'hcg1': 89./2.,
- 'hb': 3.,
- 'htrou': 32.,
- 'pf': 1.7,
- 'j': 2}
-dico_bride_T = {'nbgouj': 16,
- 'dint': 254.56,
- 'dex1': 273.,
- 'dex2': 320.,
- 'dex3': 340.,
- 'dtrou': 385.,
- 'dext': 444.,
- 'dt': 27.,
- 'drd': 45.,
- 'dg': 24.,
- 'dec': 36.,
- 'rcong': 5.,
- 'he': 24.,
- 'e': 4.,
- 'hc1': 128.,
- 'hcg1': 128./2.,
- 'hb': 3.,
- 'htrou': 55.,
- 'pf': 2.6,
- 'j': 2}
-dico_bride_W = {'nbgouj': 28,
- 'dint': 314.76,
- 'dex1': 323.9,
- 'dex2': 360.,
- 'dex3': 385.,
- 'dtrou': 415.,
- 'dext': 460.,
- 'dt': 18.,
- 'drd': 30.,
- 'dg': 16.,
- 'dec': 24.,
- 'rcong': 5.,
- 'he': 16.,
- 'e': 3.,
- 'hc1': 96.,
- 'hcg1': 96./2.,
- 'hb': 3.,
- 'htrou': 37.,
- 'pf': 1.7,
- 'j': 2}
-
-
-# dictionnaire pour faire le lien entre l'option de bride et les valeurs normalisées
-dico_bride_std = {'AA':dico_bride_AA,
- 'A':dico_bride_A,
- 'B':dico_bride_B,
- 'B1':dico_bride_B1,
- 'C':dico_bride_C,
- 'D':dico_bride_D,
- 'D1':dico_bride_D1,
- 'E':dico_bride_E,
- 'F':dico_bride_F,
- 'FF':dico_bride_FF,
- 'G':dico_bride_G,
- 'GG':dico_bride_GG,
- 'H':dico_bride_H,
- 'H1':dico_bride_H1,
- 'I':dico_bride_I,
- 'J':dico_bride_J,
- 'J1':dico_bride_J1,
- 'K':dico_bride_K,
- 'L':dico_bride_L,
- 'L1':dico_bride_L1,
- 'M':dico_bride_M,
- 'N':dico_bride_N,
- 'O':dico_bride_O,
- 'P':dico_bride_P,
- 'S':dico_bride_S,
- 'T':dico_bride_T,
- 'W':dico_bride_W}
+++ /dev/null
-#@ MODIF macr_cabri_mail_ops Intranet DATE 28/01/2008 AUTEUR PELLET J.PELLET
-# -*- coding: iso-8859-1 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2008 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-
-import os
-
-def macr_cabri_mail_ops(self,EXEC_MAILLAGE,RAFF_MAILLAGE,VERI_MAIL,GEOM_BRID,
- IMPRESSION,**args):
- """
- Ecriture de la macro MACR_CABRI_MAIL
- """
- import types
- from Accas import _F
-
- 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
- EXEC_LOGICIEL = self.get_cmd('EXEC_LOGICIEL')
- LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
- PRE_GIBI = self.get_cmd('PRE_GIBI')
- IMPR_RESU = self.get_cmd('IMPR_RESU')
-
- # La macro compte pour 1 dans la numerotation des commandes
- self.set_icmd(1)
-
- # Le concept sortant (de type mail) est nommé 'nomres' dans
- # le contexte de la macro
-
- self.DeclareOut('nomres',self.sd)
-
- # Chemin de Gibi
- import aster
- loc_gibi=aster.repout()
- gibi2000=loc_gibi+'gibi'
-
- # Unité pour le fichier maillage produit (format GIBI)
- unite_mgib = EXEC_MAILLAGE['UNITE_MGIB']
- # Unité pour le fichier de commandes GIBI
- unite_datg = EXEC_MAILLAGE['UNITE_DATG']
- # Niveau gibi
- niveau_gibi = EXEC_MAILLAGE['NIVE_GIBI']
-
- # Verif mail
- ver_apla = VERI_MAIL['APLAT']
- ver_veri = VERI_MAIL['VERIF']
-
- # Impression
- if IMPRESSION['UNITE']!=None:
- imp_unit = IMPRESSION['UNITE']
- imp_unitF = 1
- else:
- imp_unitF = 0
- if IMPRESSION['FORMAT']!=None:
- imp_form = IMPRESSION['FORMAT']
- imp_formF = 1
- else:
- imp_formF = 0
-# if IMPRESSION['FICHIER']!=None:
-# imp_fich = IMPRESSION['FICHIER']
-# imp_fichF = 1
-# else:
-# imp_fichF = 0
-
- # Maillage
- nrad = RAFF_MAILLAGE['NB_RADIAL']
- ncir = RAFF_MAILLAGE['NB_CIRCONF']
- nver = RAFF_MAILLAGE['NB_VERTICAL']
- nsect = RAFF_MAILLAGE['NB_ALESAGE']
- temps = 5.
-
- maillage = {'nrad': nrad,
- 'ncir': ncir,
- 'nver': nver,
- 'nsect': nsect,
- 'temps' : temps,}
-
- # Création du fichier datg
-
- if GEOM_BRID['NORME'] == 'OUI':
- # Bride standard
- type_bride = GEOM_BRID['TYPE']
- ### Ecriture du fichier GIBI principal (dgib) - Bride STANDARD
- write_file_dgib_STD(unite_mgib,unite_datg,maillage,type_bride)
- else:
- # Bride quelconque
- geo_bride_qqe = {'nbgouj': GEOM_BRID['GOUJ_N_GOUJON'],
- 'dint': GEOM_BRID['BRID_D_INT'],
- 'dex1': GEOM_BRID['TUBU_D_EXT'],
- 'dex2': GEOM_BRID['BRID_D_CONGE'],
- 'dex3': GEOM_BRID['BRID_D_EPAUL'],
- 'dtrou': GEOM_BRID['BRID_P_ALESAG'],
- 'dext': GEOM_BRID['BRID_D_EXT'],
- 'dt': GEOM_BRID['BRID_D_ALESAG'],
- 'drd': GEOM_BRID['GOUJ_D_RONDEL'],
- 'dg': GEOM_BRID['GOUJ_D_GOUJON'],
- 'dec': GEOM_BRID['GOUJ_D_ECROU'],
- 'rcong': GEOM_BRID['BRID_R_CONGE'],
- 'he': GEOM_BRID['GOUJ_E_ECROU'],
- 'e': GEOM_BRID['GOUJ_E_RONDEL'],
- 'hc1': GEOM_BRID['BRID_H'],
- 'hcg1': GEOM_BRID['TUBU_H'],
- 'hb': GEOM_BRID['BRID_H_EPAUL'],
- 'htrou': GEOM_BRID['BRID_H_ALESAG'],
- 'pf': GEOM_BRID['GOUJ_E_FILET'],
- 'j': GEOM_BRID['ETAN_E_JOINT']}
- ### Ecriture du fichier GIBI principal (dgib) - Bride QUELCONQUE
- write_file_dgib_QQE(unite_mgib,unite_datg,maillage,geo_bride_qqe)
-
- fichier_datg = 'fort.'+str(unite_datg)
- fichier_mgib = 'fort.'+str(unite_mgib)
-
- # Lancement de GIBI
- EXEC_LOGICIEL(
- LOGICIEL=gibi2000,
- ARGUMENT=(fichier_datg, fichier_mgib),
- )
- # Lecture du maillage GIBI dans ASTER
- PRE_GIBI(
- UNITE_GIBI = unite_mgib,
- )
-
- nomres = LIRE_MAILLAGE(VERI_MAIL=_F(APLAT = ver_apla,
- VERIF = ver_veri ),)
-
-# if (imp_fichF == 1):
-# print imp_fich
- if (imp_formF == 1):
- print imp_form
- if (imp_unitF == 1):
- print imp_unit
- # Impression du fichier maillage
- if (imp_formF == 1):
- if (imp_form == 'CASTEM'):
- imp_ngib = IMPRESSION['NIVE_GIBI']
- IMPR_RESU( RESU = _F(MAILLAGE=nomres, ),
- FORMAT = 'CASTEM', NIVE_GIBI = imp_ngib )
- if (imp_form == 'IDEAS'):
- imp_nver = IMPRESSION['VERSION']
- IMPR_RESU(RESU = _F(MAILLAGE=nomres,),
- FORMAT = 'IDEAS', VERSION = imp_nver )
-
- return ier
-
-
-##############################################################################################
-# Liste des fonctions
-##############################################################################################
-
-#############
-## EXTERNES (appelables depuis l'extérieur)
-#############
-
-### Ecriture du fichier GIBI principal (dgib) - Bride STANDARD
-# null = write_file_dgib_STD(unite_mgib,unite_datg,msh_bride,geo_bride)
-
-### Ecriture du fichier GIBI principal (dgib) - Bride QUELCONQUE
-# null = write_file_dgib_QQE(unite_mgib,unite_datg,msh_bride,geo_bride)
-
-### Imprime tout le catalogue des brides standards disponibles dans un fichier texte
-# null = print_bride_std(nom_fichier)
-
-### Catalogue complet des brides standards disponibles
-# txt = bride_std()
-
-#############
-## INTERNES (réservées au travail interne)
-#############
-
-### Génération du nom du fichier pour le fichier maillage résultant (format GIBI)
-# NomFichier(txt) = name_file_mgib(unite_mgib):
-
-### Génération du nom du fichier pour le fichier générant le maillage (commandes GIBI)
-# NomFichier(txt) = name_file_datg(unite_datg):
-
-### Récupère un fichier texte DATG
-# Txt = text_datg(fichier_datg):
-
-### Génération du texte pour les variables
-# Txt = para_text(dico_var,var):
-
-
-
-#=============================================================================================
-# Importation des modules Python
-#=============================================================================================
-
-from Intranet.macr_cabri_mail_dat import dico_var_geo,dico_var_msh,dico_bride_std
-
-#=============================================================================================
-# Fonctions principales
-#=============================================================================================
-# Ecriture du fichier GIBI principal (dgib) - Bride STANDARD
-def write_file_dgib_STD(unite_mgib,unite_datg,msh_bride,geo_bride):
-
- # Nom du fichier maillage produit par GIBI
- nomFichierMGIB = name_file_mgib(unite_mgib)
-
- # Nom du fichier de commandes pour GIBI
- nomFichierDATG = name_file_datg(unite_datg)
-
- # Ouverture du fichier d'entrée de commandes
- fdgib=open(nomFichierDATG,'w')
-
- # En-tete
- text = "**************************************************************\n"
- text = text + "* Fichier GIBI pour le maillage d'une bride \n"
- text = text + "**************************************************************\n"
- text = text + "\n"
- text = text + "* Ce fichier a été généré automatiquement par la macro ASTER MACR_CABRI_MAIL \n"
- text = text + "* Ne pas modifier\n"
- text = text + "\n"
- text = text + "**************************************************************\n"
- text = text + "* Type bride: Bride standard \n"
- text = text + "**************************************************************\n"
- text = text + "titre '"+"Bride standard"+"';\n"
- text = text + "** Type bride standard: "+geo_bride+"\n"
-
- text = text + "\n"
- text = text + "nomfich = CHAINE \n"
- if len(nomFichierMGIB)>72:
- raise Exception, 'Nom de fichier trop long (limité à 72 caractères ' \
- 'pour GIBI) :\n',nomFichierMGIB
- elif len(nomFichierMGIB)<=69:
- text = text + "'"+nomFichierMGIB+"';\n"
- else:
- text = text + "'"+nomFichierMGIB[:69]+"'\n" \
- + "'"+nomFichierMGIB[69:]+"';\n"
- text = text + "opti dime 3 elem cub8 SAUV FORM nomfich;\n"
- text = text + "dens 1;\n"
- text = text + "\n"
- fdgib.write(text)
-
- # Procédures internes supplémentaires
- text = "**************************************************************\n"
- text = text + "* Procédures supplémentaires \n"
- text = text + "**************************************************************\n"
- text = text + text_datg_pro()
- fdgib.write(text)
-
- # Début de procédure de création du maillage
- text = "**************************************************************\n"
- text = text + "**************************************************************\n"
- text = text + "********* Début de procédure de création du maillage *********\n"
- text = text + "**************************************************************\n"
- text = text + "**************************************************************\n"
- text = text + "\n debproc constru;\n"
- fdgib.write(text)
-
- # Paramètres géométriques
- car_bride = dico_bride_std[geo_bride]
- text = "**************************************************************\n"
- text = text + "* Paramètres géométriques \n"
- text = text + "**************************************************************\n"
- text = text + para_text(dico_var_geo,car_bride)
- fdgib.write(text)
-
- # Paramètres du maillage
- text = "**************************************************************\n"
- text = text + "* Paramètres physiques \n"
- text = text + "**************************************************************\n"
- text = text + para_text(dico_var_msh,msh_bride)
- fdgib.write(text)
-
- # Algorithme du maillage
- text = "**************************************************************\n"
- text = text + "* Algorithme de maillage \n"
- text = text + "**************************************************************\n"
- text = text + text_datg_std()
- fdgib.write(text)
-
- # Fermeture du fichier maillage
- fdgib.close()
-
-
-# Ecriture du fichier GIBI principal (dgib) - Bride QUELCONQUE
-def write_file_dgib_QQE(unite_mgib,unite_datg,msh_bride,geo_bride):
-
- # Nom du fichier maillage produit par GIBI
- nomFichierMGIB = name_file_mgib(unite_mgib)
-
- # Nom du fichier de commandes pour GIBI
- nomFichierDATG = name_file_datg(unite_datg)
-
- # Ouverture du fichier d'entree de commandes
- fdgib=open(nomFichierDATG,'w')
-
- # En-tete
- text = "**************************************************************\n"
- text = text + "* Fichier GIBI pour le maillage d'une bride \n"
- text = text + "**************************************************************\n"
- text = text + "\n"
- text = text + "* Ce fichier a été généré automatiquement par la macro ASTER MACR_CABRI_MAIL \n"
- text = text + "* Ne pas modifier\n"
- text = text + "\n"
- text = text + "**************************************************************\n"
- text = text + "* Type bride: Bride quelconque\n"
- text = text + "**************************************************************\n"
- text = text + "titre '"+"Bride Quelconque"+"';\n"
- text = text + "\n"
- text = text + "nomfich = CHAINE \n"
- if len(nomFichierMGIB)>72:
- raise Exception, 'Nom de fichier trop long (limité à 72 caractères ' \
- 'pour GIBI) :\n',nomFichierMGIB
- elif len(nomFichierMGIB)<=69:
- text = text + "'"+nomFichierMGIB+"';\n"
- else:
- text = text + "'"+nomFichierMGIB[:69]+"'\n" \
- + "'"+nomFichierMGIB[69:]+"';\n"
- text = text + "opti dime 3 elem cub8 SAUV FORM nomfich;\n"
- text = text + "dens 1;\n"
- text = text + "\n"
- fdgib.write(text)
-
- # Procédures internes supplémentaires
- text = "**************************************************************\n"
- text = text + "* Procédures supplémentaires \n"
- text = text + "**************************************************************\n"
- text = text + text_datg_pro()
- fdgib.write(text)
-
- # Début de procédure de création du maillage
- text = "**************************************************************\n"
- text = text + "**************************************************************\n"
- text = text + "********* Début de procédure de création du maillage *********\n"
- text = text + "**************************************************************\n"
- text = text + "**************************************************************\n"
- text = text + "\n debproc constru;\n"
- fdgib.write(text)
-
- # Paramètres géométriques
- text = "**************************************************************\n"
- text = text + "* Paramètres géométriques \n"
- text = text + "**************************************************************\n"
- text = text + para_text(dico_var_geo,geo_bride)
- fdgib.write(text)
-
- # Paramètres du maillage
- text = "**************************************************************\n"
- text = text + "* Paramètres physiques \n"
- text = text + "**************************************************************\n"
- text = text + para_text(dico_var_msh,msh_bride)
- fdgib.write(text)
-
- # Algorithme du maillage
- text = "**************************************************************\n"
- text = text + "* Algorithme de maillage \n"
- text = text + "**************************************************************\n"
- text = text + text_datg_qqe()
- fdgib.write(text)
-
- # Fermeture du fichier maillage
- fdgib.close()
-
-# Génération du nom du fichier pour le fichier maillage résultant (format GIBI)
-def name_file_mgib(unite_mgib):
- cur_dir = os.getcwd()
- nomFichier = cur_dir+'/fort.'+str(unite_mgib)
- return nomFichier
-
-
-# Génération du nom du fichier pour le fichier générant le maillage (commandes GIBI)
-def name_file_datg(unite_datg):
- cur_dir = os.getcwd()
- nomFichier = cur_dir+'/fort.'+str(unite_datg)
- return nomFichier
-
-# Récupère un fichier texte DATG: texte GIBI pour procédures
-def text_datg_pro():
- 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()
-
- return procText
-
-# Récupère un fichier texte DATG: texte GIBI pour bride quelconque
-def text_datg_qqe():
- 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()
-
- return procText
-
-# Récupère un fichier texte DATG: texte GIBI pour bride standard
-def text_datg_std():
- 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()
-
- return procText
-
-# Génération du texte pour les variables
-def para_text(dico_var,var):
- text = '\n'
- for nom_var in var.keys():
- text = text+"* "+dico_var[nom_var]+"\n"
- text = text+nom_var+" = "+`var[nom_var]`+";\n"
- return text
-
-#=============================================================================================
-# Accès au catalogue des brides standards
-# (les brides standards sont décrites dans le fichier Data_Brides.py)
-#=============================================================================================
-
-
-
-# Imprime tout le catalogue des brides standards disponibles dans un fichier texte
-def print_bride_std(nom_fichier):
- text = bride_std()
- # Ouverture du fichier
- finfo=open(nom_fichier,'w')
- # Ecriture des infos
- finfo.write(text)
- # Fermeture du fichier
- finfo.close()
-
-# Catalogue complet des brides standards disponibles
-def bride_std():
- # Ligne d'info
- text = "Liste des brides standards avec leurs dimensions\n"
- # Première ligne
- text = text+"\t"
- for nom_variable in dico_var_geo.keys():
- text = text + nom_variable+"\t\t"
- text = text + "\n"
- # Lignes suivantes
- for nom_bride in dico_bride_std.keys():
- bride = dico_bride_std[nom_bride]
- text = text + nom_bride + '\t'
- for nom_var in dico_var_geo.keys():
- chaine = "%f" % (bride[nom_var])
- text = text+chaine+"\t"
- text = text + "\n"
- return text
+++ /dev/null
-#@ MODIF macro_bascule_schema_ops Intranet DATE 17/12/2007 AUTEUR GREFFET N.GREFFET
-# -*- coding: iso-8859-1 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2007 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-
-def macro_bascule_schema_ops (self,MODE,MATE,CARA,
- INCR_I,INCR_E,
- SCH_TEMPS_I,SCH_TEMPS_E,SCH_TEMPS_EQ,
- C_INCR_I,C_INCR_E,
- EXC_T,NEWT,INIT,TP_BAS,SCH_INI,EQUILIBRAGE,**args):
- ier=0
- import copy
- import aster
- import string
- import types
- from Accas import _F
- from Noyau.N_utils import AsType
- from Utilitai.Utmess import UTMESS
- # On importe les definitions des commandes a utiliser dans la macro
- DYNA_NON_LINE =self.get_cmd('DYNA_NON_LINE')
- CREA_CHAMP =self.get_cmd('CREA_CHAMP')
- DEFI_LIST_REEL =self.get_cmd('DEFI_LIST_REEL')
- # La macro compte pour 1 dans la numerotation des commandes
- self.set_icmd(1)
- # Le concept sortant (de type evol_noli) est nommé
- # 'nomres' dans le contexte de la macro
- self.DeclareOut('nomres',self.sd)
- #
- #
- dexct=[]
- for j in EXC_T :
- dexct.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dexct[-1].keys():
- if dexct[-1][i]==None : del dexct[-1][i]
- #
- dComp_incri=[]
- for j in C_INCR_I :
- dComp_incri.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dComp_incri[-1].keys():
- if dComp_incri[-1][i]==None : del dComp_incri[-1][i]
- #
- dComp_incre=[]
- for j in C_INCR_E :
- dComp_incre.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dComp_incre[-1].keys():
- if dComp_incre[-1][i]==None : del dComp_incre[-1][i]
- #
- dincri=[]
- for j in INCR_I :
- dincri.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dincri[-1].keys():
- if dincri[-1][i]==None : del dincri[-1][i]
- #
- dincre=[]
- for j in INCR_E :
- dincre.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dincre[-1].keys():
- if dincre[-1][i]==None : del dincre[-1][i]
- #
- dschi=[]
- for j in SCH_TEMPS_I :
- dschi.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dschi[-1].keys():
- if dschi[-1][i]==None : del dschi[-1][i]
- #
- dsche=[]
- for j in SCH_TEMPS_I :
- dsche.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dsche[-1].keys():
- if dsche[-1][i]==None : del dsche[-1][i]
- #
- dscheq=[]
- for j in SCH_TEMPS_I :
- dscheq.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dscheq[-1].keys():
- if dscheq[-1][i]==None : del dscheq[-1][i]
- #
- dnew=[]
- for j in NEWT :
- dnew.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dnew[-1].keys():
- if dnew[-1][i]==None : del dnew[-1][i]
- #
- dini=[]
- for j in INIT :
- dini.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dini[-1].keys():
- if dini[-1][i]==None : del dini[-1][i]
- #
- dequi=[]
- for j in EQUILIBRAGE :
- dequi.append(j.cree_dict_valeurs(j.mc_liste))
- for i in dequi[-1].keys():
- if dequi[-1][i]==None : del dequi[-1][i]
- #
- __L0 = TP_BAS['VALE']
- dincri1=copy.copy(dincri)
- dincri1[-1]['INST_FIN']= __L0[0]
- #
- __dtimp=dequi[-1]['DT_IMP']
- __dtexp=dequi[-1]['DT_EXP']
- #
- __dim=(-1)*len(dComp_incri)
- __lis=range(0,__dim,-1)
- __non_lin='NON'
- for i in __lis :
- if (dComp_incri[i]['RELATION']!='DIS_CHOC' and dComp_incri[i]['RELATION']!='ELAS'):
- __non_lin='OUI'
- break
- #
- #
- if SCH_INI=='IMPLICITE':
- dincri1=copy.copy(dincri)
- dincri1[-1]['INST_FIN']= __L0[0]
- nomres=DYNA_NON_LINE(MODELE =MODE,
- CHAM_MATER =MATE,
- CARA_ELEM =CARA,
- EXCIT =dexct,
- COMP_INCR =dComp_incri,
- INCREMENT =dincri1,
- SCHEMA_TEMPS=dschi,
- NEWTON=dnew,
- ETAT_INIT=dini, )
- __prc = 'IMPLICITE'
- #
- if SCH_INI=='EXPLICITE':
- dincre1=copy.copy(dincre)
- dincre1[-1]['INST_FIN']= __L0[0]
- nomres=DYNA_NON_LINE(MODELE =MODE,
- CHAM_MATER =MATE,
- MASS_DIAG='OUI',
- CARA_ELEM =CARA,
- EXCIT =dexct,
- COMP_INCR =dComp_incre,
- INCREMENT =dincre1,
- SCHEMA_TEMPS=dsche,
- NEWTON=dnew,
- ETAT_INIT=dini, )
-
- __prc = 'EXPLICITE'
-
- #
- __nb=len(__L0)
- j = 1
- while 1:
- #
- if __prc=='IMPLICITE' :
- __Ue=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=__L0[j-1],)
- #
- __Ve=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=__L0[j-1],)
- #
- __Ae=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=__L0[j-1],)
- #
- __Ce=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='ELGA_SIEF_R', NOM_CHAM='SIEF_ELGA', INST=__L0[j-1],)
- #
- __Vae=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='ELGA_VARI_R', NOM_CHAM='VARI_ELGA', INST=__L0[j-1],)
- dincre1=copy.copy(dincre)
- dincre1[-1]['INST_FIN'] = __L0[j]
- dincre1[-1]['INST_INIT']= __L0[j-1]
- nomres=DYNA_NON_LINE(reuse=nomres,
- MODELE=MODE,
- MASS_DIAG='OUI',
- CHAM_MATER=MATE,
- CARA_ELEM=CARA,
- EXCIT=dexct,
- ETAT_INIT=_F(DEPL=__Ue, VITE=__Ve, ACCE=__Ae,
- SIGM=__Ce, VARI=__Vae,),
- COMP_INCR=dComp_incre,
- INCREMENT=dincre1,
- SCHEMA_TEMPS=dsche,
- NEWTON=dnew,)
- #
- __prc='EXPLICITE'
- j = j + 1
- bool = (j!=(__nb))
- if (not bool): break
- #
- if __prc=='EXPLICITE' :
- # calcul sur la zone de recouvrement
- print('calcul d''une solution explicite stabilisée')
- __U1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=__L0[j-1],)
- #
- __V1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=__L0[j-1],)
- #
- __A1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=__L0[j-1],)
- #
- __C1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='ELGA_SIEF_R', NOM_CHAM='SIEF_ELGA', INST=__L0[j-1],)
- #
- __Va1=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='ELGA_VARI_R', NOM_CHAM='VARI_ELGA', INST=__L0[j-1],)
- #
- __lrec=DEFI_LIST_REEL(DEBUT=__L0[j-1],
- INTERVALLE=_F(JUSQU_A=(__L0[j-1])+(10*(__dtexp)),
- PAS=__dtexp),)
- __u_rec=DYNA_NON_LINE(MODELE=MODE,
- CHAM_MATER=MATE,
- MASS_DIAG='OUI',
- CARA_ELEM=CARA,
- EXCIT=dexct,
- ETAT_INIT=_F(DEPL=__U1, VITE=__V1, ACCE=__A1,
- SIGM=__C1, VARI=__Va1,),
- COMP_INCR=dComp_incre,
- INCREMENT=_F(LIST_INST=__lrec,
- INST_INIT=__L0[j-1],
- INST_FIN=(__L0[j-1])+(10*(__dtexp))),
- SCHEMA_TEMPS=dscheq,
- NEWTON=dnew,)
- #
- __Ui =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=__u_rec,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- __Vi =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=__u_rec,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- __Ai =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=__u_rec,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- # equilibrage du premier pas implicite
- print('equilibrage du pas explicite stabilisée')
- dincri1=copy.copy(dincri)
- dincri1[-1]['INST_FIN'] = ((__L0[j-1])+(10*(__dtexp)))
- dincri1[-1]['INST_INIT']= (__L0[j-1])
- nomres=DYNA_NON_LINE(reuse=nomres,
- MODELE=MODE,
- CHAM_MATER=MATE,
- CARA_ELEM=CARA,
- EXCIT=dexct,
- ETAT_INIT=_F(DEPL=__Ui, VITE=__Vi, ACCE=__Ai,
- SIGM=__C1, VARI=__Va1,),
- COMP_INCR=dComp_incri,
- INCREMENT=dincri1,
- SCHEMA_TEMPS=dschi,
- NEWTON=dnew,)
- #
- __Ui =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='DEPL', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- __Vi =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='VITE', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- __Ai =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='NOEU_DEPL_R', NOM_CHAM='ACCE', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- __Ci =CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='ELGA_SIEF_R', NOM_CHAM='SIEF_ELGA', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- __Vai=CREA_CHAMP(OPERATION='EXTR', PRECISION=1.E-7, RESULTAT=nomres,
- TYPE_CHAM='ELGA_VARI_R', NOM_CHAM='VARI_ELGA', INST=(__L0[j-1])+(10*(__dtexp)),)
- #
- print('calcul implicite après équilibrage')
- dincri1=copy.copy(dincri)
- dincri1[-1]['INST_FIN'] = __L0[j]
- dincri1[-1]['INST_INIT']= ((__L0[j-1])+(10*(__dtexp)))
- nomres=DYNA_NON_LINE(reuse=nomres,
- MODELE=MODE,
- CHAM_MATER=MATE,
- CARA_ELEM=CARA,
- EXCIT=dexct,
- ETAT_INIT=_F(DEPL=__Ui, VITE=__Vi, ACCE=__Ai,
- SIGM=__Ci, VARI=__Vai,
- ),
- COMP_INCR=dComp_incri,
- INCREMENT=dincri1,
- SCHEMA_TEMPS=dschi,
- NEWTON=dnew,)
- #
- __prc='IMPLICITE'
- j = j + 1
- bool = (j!=(__nb))
- if (not bool): break
- #
- return ier
+++ /dev/null
-
-L_E=DISTRIBUTION(Kind='Normal',
- Mu=12,
- Sigma=0.5,);
-
-L_L=DISTRIBUTION(Kind='LogNormal',
- Settings='MuSigmaOverMu',
- Gamma=0.0,);
-
-STUDY(Analysis='Reliability',
- Algorithm='SORM',
- Method='Cobyla',
- Threshold=5.0,
- ComparisonOperator='Less',
- SeedToBeSet='no',
- Variables=(_F(Name='E',
- Type='in',
- MarginalDistribution=L_E,),
- _F(Name='L',
- Type='in',
- MarginalDistribution=L_L,),
- _F(Name='O',
- Type='out',),),
- Solver='aaa',
- WrapperPath='aster.so',
- FunctionName='aster',
- WrapCouplingMode='fork',
- Command='/usr/bin/runaster',
- InDataTransfer='files',
- OutDataTransfer='files',
- Files=(_F(Id='fich1',
- Type='in',
- Path='../fich_entree',
- Subst='E,L',),
- _F(Id='fich2',
- Type='out',
- Path='fich_sortie',
- Subst='O',),),);
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-# --------------------------------------------------
-# debut entete
-# --------------------------------------------------
-
-import Accas
-from Accas import *
-
-class loi ( ASSD ) : pass
-
-
-#CONTEXT.debug = 1
-JdC = JDC_CATA ( code = 'OPENTURNS',
- execmodul = None,
- regles = ( AU_MOINS_UN ( 'STUDY' ), ),
- ) # Fin JDC_CATA
-
-# --------------------------------------------------
-# fin entete
-# --------------------------------------------------
-
-# 3. Version d OPENTURNS ?
-
-#===========================================================
-
-
-#================================
-# 1. Definition des LOIS
-#================================
-
-# Nota : les variables de type OPER doivent etre en majuscules !
-DISTRIBUTION = OPER ( nom = "DISTRIBUTION",
- sd_prod = loi,
- op = 68,
- fr = "Definitions des lois marginales utilisees par les variables d'entree",
-
-
-#====
-# 2. Type de la loi de distribution
-#====
-
- Kind = SIMP ( statut = "o", typ = "TXM",
- into = ( "Beta",
- "Exponential",
- "Gamma",
- "Geometric",
- "Gumbel",
- "Histogram",
- "Logistic",
- "LogNormal",
- "MultiNomial",
- "Normal",
- "TruncatedNormal",
- "Poisson",
- "Student",
- "Triangular",
- "Uniform",
- "UserDefined",
- "Weibull",
- ),
- fr = "Choix du type de la loi marginale",
- ang = "1D marginal distribution." ),
-
-#====
-# 3. Definition des parametres selon le type de la loi
-#====
-
-# 3.1. ==> Loi beta
-
- BETA = BLOC ( condition = " Kind in ( 'Beta', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "RT", "MuSigma" ),
- defaut = "RT",
- fr = "Parametrage de la loi beta",
- ang = "Beta distribution parameter set"
- ),
-
- RT_Parameters = BLOC ( condition = " Settings in ( 'RT', ) ",
-
- R = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre R de la loi",
- ang = "R parameter"
- ),
-
- # T > R
- T = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre T de la loi | T > R",
- ang = "T parameter | T > R"
- ),
-
- ), # Fin BLOC RT_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre A de la loi",
- ang = "A parameter"
- ),
-
- # B > A
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre B de la loi | B > A",
- ang = "B parameter | B > A"
- ),
-
- ), # Fin BLOC BETA
-
-# 3.2. ==> Loi exponentielle
-
- EXPONENTIAL = BLOC ( condition = " Kind in ( 'Exponential', ) ",
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC EXPONENTIAL
-
-# 3.3. ==> Loi gamma
-
- GAMMA = BLOC ( condition = " Kind in ( 'Gamma', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "KLambda", "MuSigma" ),
- defaut = "KLambda",
- fr = "Parametrage de la loi gamma",
- ang = "Gamma distribution parameter set"
- ),
-
- KLambda_Parameters = BLOC ( condition = " Settings in ( 'KLambda', ) ",
-
- K = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre K de la loi | K > 0",
- ang = "K parameter | K > 0"
- ),
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda de la loi | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- ), # Fin BLOC KLambda_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- defaut = 0.0,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- defaut = 1.0,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
-
- ), # Fin BLOC GAMMA
-
-# 3.5. ==> Loi geometrique
-
- GEOMETRIC = BLOC ( condition = " Kind in ( 'Geometric', ) ",
-
- P = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- val_max = 1.,
- fr = "Parametre P | 0 < P < 1",
- ang = "P parameter | 0 < P < 1"
- ),
-
- ), # Fin BLOC GEOMETRIC
-
-# 3.6. ==> Loi gumbel
-
- GUMBEL = BLOC ( condition = " Kind in ( 'Gumbel', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "AlphaBeta", "MuSigma" ),
- defaut = "AlphaBeta",
- fr = "Parametrage de la loi gumbel",
- ang = "Gumbel distribution parameter set"
- ),
-
- AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Alpha de la loi | Alpha > 0",
- ang = "Alpha parameter | Alpha > 0"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Beta de la loi",
- ang = "Beta parameter"
- ),
-
- ), # Fin BLOC AlphaBeta_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- ), # Fin BLOC GUMBEL
-
-# 3.7. ==> Loi histogramme
-
- HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
-
- Sup = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la distribution",
- ang = "Upper bound"
- ),
-
- # Il faut definir une collection de couples ( x,p )
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC HISTOGRAM
-
-# 3.8. ==> Loi lognormale
-
- LOGNORMAL = BLOC ( condition = " Kind in ( 'LogNormal', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ),
- defaut = "MuSigmaLog",
- fr = "Parametrage de la loi lognormale",
- ang = "Lognormal distribution parameter set"
- ),
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', 'MuSigmaOverMu' ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi | Mu > Gamma",
- ang = "Mu parameter | Mu > Gamma"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
-
- MuLog = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu log de la loi",
- ang = "Mu log parameter"
- ),
-
- SigmaLog = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma log de la loi | SigmaLog > 0",
- ang = "Sigma log parameter | SigmaLog > 0"
- ),
-
- ), # Fin BLOC MuSigmaLog_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC LOGNORMAL
-
-# 3.9. ==> Loi logistique
-
- LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Alpha de la loi",
- ang = "Alpha parameter"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Beta de la loi | Beta > = 0",
- ang = "Beta parameter | Beta > = 0"
- ),
-
- ), # Fin BLOC LOGISTIC
-
-# 3.10. ==> Loi multinomiale
-
- MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ",
-
- N = SIMP ( statut = "o",
- typ = "E",
- max = 1,
- fr = "Dimension de la loi",
- ang = "DISTRIBUTION dimension"
- ),
-
- # Il faut un vecteur P de taille N
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC MULTINOMIAL
-
-# 3.11. ==> Loi normale
-
- NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC NORMAL
-
-# 3.12. ==> Loi Poisson
-
- POISSON = BLOC ( condition = " Kind in ( 'Poisson', ) ",
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda de la loi | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- ), # Fin BLOC POISSON
-
-# 3.13. ==> Loi student
-
- STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Nu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 2.,
- fr = "Parametre Nu de la loi | V > = 2",
- ang = "Nu parameter | V > = 2"
- ),
-
- ), # Fin BLOC STUDENT
-
-# 3.14. ==> Loi triangulaire
-
- TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = M < = B",
- ang = "Lower bound | A < = M < = B"
- ),
-
- M = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Mode de la loi | A < = M < = B",
- ang = "Mode | A < = M < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = M < = B",
- ang = "Upper bound | A < = M < = B"
- ),
-
- ), # Fin BLOC TRIANGULAR
-
-# 3.15. ==> Loi normale tronquee
-
- TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
-
- MuN = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- SigmaN = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre SigmaN de la loi | SigmaN > 0",
- ang = "SigmaN parameter | SigmaN> 0"
- ),
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = B",
- ang = "Lower bound | A < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = B",
- ang = "Upper bound | A < = B"
- ),
-
- ), # Fin BLOC TRUNCATEDNORMAL
-
-# 3.16. ==> uniforme
-
- UNIFORM = BLOC ( condition = " Kind in ( 'Uniform', ) ",
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = B",
- ang = "Lower bound | A < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = B",
- ang = "Upper bound | A < = B"
- ),
-
- ), # Fin BLOC UNIFORM
-
-# 3.17. ==> Loi definie par l'utilisateur
-
- USERDEFINED = BLOC ( condition = " Kind in ( 'UserDefined', ) ",
-
- # Il faut definir une collection de couples ( x,p )
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC USERDEFINED
-
-# 3.18. ==> Weibull
-
- WEIBULL = BLOC ( condition = " Kind in ( 'Weibull', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "AlphaBeta", "MuSigma" ),
- defaut = "AlphaBeta",
- fr = "Parametrage de la loi weibull",
- ang = "Weibull distribution parameter set"
- ),
-
- AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Alpha de la loi | Alpha > 0",
- ang = "Alpha parameter | Alpha > 0"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Beta de la loi | Beta > 0",
- ang = "Beta parameter | Beta > 0"
- ),
-
- ), # Fin BLOC AlphaBeta_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC WEIBULL
-
-); # Fin OPER DISTRIBUTION
-
-#================================
-# 2. Definition du cas d'etude
-#================================
-# Nota : les variables de type PROC doivent etre en majuscules !
-STUDY = PROC ( nom = "STUDY",
- op = None,
- docu = "",
- fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.",
- ang = "Writes the configuration file for OPENTURNS.",
-
-
-#=====
-# 1. Le Type d'Analyse
-#=====
-
- Analysis = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "Reliability", "Simulation", "QuadraticCumul" ),
- fr = "Type d'Analyse",
- ang = "Analysis",
- ),
-
-#=====
-# 2. Pour la probabilite
-# algorithme et mode choisis
-#=====
-
- Reliability = BLOC ( condition = " Analysis in ( 'Reliability', ) ",
-
-# 2.1. ==> L'algorithme
-
- Algorithm = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "FORM", "SORM" ),
- fr = "Algorithme de fiabilite",
- ang = "Reliability algorithm"
- ),
-
-# 2.2. ==> La methode
-# 2.2.1. ==> La methode
-
- Method = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "Cobyla", "AbdoRackwitz" ),
- fr = "Methode d'optimisation.",
- ang = "Optimisation method."
- ),
-
-# 2.2.1. ==> Tirage d'importance
-
- ImportanceSampling = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "yes", "no" ),
- defaut = "no",
- fr = "Tirage d'importance autour du point de conception",
- ang = "Importance sampling around design point"
- ),
-
-###
-### Il faut definir ces 3 elements pour ImportanceSampling sans collisioner ceux de Simulation
-###
- ImportanceSamplingSettings = BLOC ( condition = "ImportanceSampling in ( 'yes', )",
-# 3.1.2. ==> Nombre d...
-
- ImportanceSampling_BlockSize = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- defaut = 1,
- fr = "Nombre maximum ...",
- ang = "Maximum number of ..."
- ),
-
-# 3.2.3. ==> ... maximum ...
-
- ImportanceSampling_MaximumCoefficientOfVariation = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " maximum ...",
- ang = "Absolute maximum ...."
- ),
-
-# 3.2.4. ==> Maximum d'iterations
-
- ImportanceSampling_MaximumOuterSampling = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = "Maximum d iterations externes.",
- ang = "Maximum outer Sampling value."
- ),
-
- ), # Fin BLOC ImportanceSamplingSettings
-
-
-# 2.2.2. ==> Regles
-
- regles = ( EXCLUS ( "MaximumAbsoluteError", "RelativeAbsoluteError" ), ),
-
-# 2.2.3. ==> Nombre d'iterations
-
- MaximumIterationsNumber = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = "Nombre maximum d iterations.",
- ang = "Maximum number of iterations."
- ),
-
-# 2.2.4. ==> Erreur maximum absolue
-
- MaximumAbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Distance maximum absolue entre 2 iterations successifs.",
- ang = "Absolute maximum distance between 2 successive iterates."
- ),
-
-# 2.2.5. ==> Erreur maximum relative
-
- RelativeAbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Distance maximum relative entre 2 iterations successifs.",
- ang = "Relative maximum distance between 2 successive iterates."
- ),
-
-# 2.2.6. ==> Ecart de contrainte absolu
-
- MaximumConstraintError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Valeur maximum absolue de la fonction \
- moins la valeur du niveau.",
- ang = "Maximum absolute value of the constraint function \
- minus the level value."
- ),
-
-# 2.2.7. ==> Ecart de residu absolu
-
- MaximumResidualError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Maximum orthogonality error.",
- ang = "Maximum orthogonality error."
- ),
-
- ), # Fin BLOC Reliability
-
-#=====
-# 3. Pour la probabilite
-# seuil par simulation :
-# algorithme choisi
-#=====
-
- Simulation = BLOC ( condition = " Analysis in ( 'Simulation', ) ",
-
-# 3.1. ==> L'algorithme
-
- Algorithm = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "MonteCarlo", "LHS", "DirectionalSampling" ),
- fr = "Algorithme de simulation",
- ang = "Simulation algorithm"
- ),
-
-# 3.1.2. ==> Nombre d...
-
- BlockSize = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- defaut = 1,
- fr = "Nombre maximum ...",
- ang = "Maximum number of ..."
- ),
-
-# 3.2.3. ==> ... maximum ...
-
- MaximumCoefficientOfVariation = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " maximum ...",
- ang = "Absolute maximum ...."
- ),
-
-# 3.2.4. ==> Maximum d'iterations
-
- MaximumOuterSamplingType = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- defaut = "UserDefined",
- into = ( "Wilks", "UserDefined" ),
- fr = "Mode definition du maximum d iterations",
- ang = "Definition for the maximum iterations number"
- ),
-
- MaximumOuterSamplingType_Wilks = BLOC ( condition = " MaximumOuterSamplingType in ( 'Wilks', ) ",
-
- Wilks_Alpha = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- val_max = 1.0,
- defaut = 0.95,
- fr = "Ordre du quantile.",
- ang = "Order of the quantile."
- ),
-
- Wilks_Beta = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- val_max = 1.0,
- defaut = 0.90,
- fr = "Confiance ...",
- ang = "Confidence ..."
- ),
-
- Wilks_I = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 0,
- defaut = 0,
- fr = " ...",
- ang = "Rank ..."
- ),
-
- ), # Fin BLOC Wilks
-
- MaximumOuterSamplingType_UserDefined = BLOC ( condition = " MaximumOuterSamplingType in ( 'UserDefined', ) ",
-
- MaximumOuterSampling = SIMP ( statut = "o",
- typ = "I",
- max = 1,
- val_min = 1,
- defaut = 250,
- fr = "Maximum d iterations externes.",
- ang = "Maximum outer Sampling value."
- ),
-
- ), # Fin BLOC UserDefined
-
-# 3.2.6. ==> Root strategy
-
- DirectionalSampling = BLOC ( condition = " Algorithm in ( 'DirectionalSampling', ) ",
-
- RootStrategy = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "SafeAndSlow",
- into = ( "RiskyAndFast", "MediumSafe", "SafeAndSlow" ),
- fr = "La strategie de recherche des racines",
- ang = "Root strategy."
- ),
-
- SamplingStrategy = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "SafeAndSlow",
- into = ( "OrthogonalDirection", "RandomDirection" ),
- fr = "La strategie d'echantillonage",
- ang = "Sampling strategy."
- ),
-
- Solver = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- defaut = "Brent",
- into = ( "Bisection", "Brent", "Secant" ),
- fr = "Solver.",
- ang = "Solver."
- ),
-
- SolverSettings = BLOC ( condition = " Solver in ( 'Bisection', 'Brent', 'Secant' ) ",
-
- regles = ( ENSEMBLE ( 'AbsoluteError', 'RelativeError', 'maximumFunctionEvaluation' ), ),
-
- AbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " Absolute error ...",
- ang = "Absolute error ..."
- ),
-
- RelativeError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " Relative error ...",
- ang = "Relative error ..."
- ),
-
- MaximumFunctionEvaluation = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = " maximum Function Evaluation ...",
- ang = "maximum Function Evaluation ..."
- ),
-
- ), # Fin BLOC SolverSettings
-
- ), # Fin BLOC DirectionalSampling
-
-# 3.2.7. ==> Impression des intervalles de confiance
-
- ConfidenceIntervalProbability = SIMP ( statut = "f",
- typ = 'R',
- max = '**',
- val_min = 0.,
- val_max = 1.,
- fr = "Liste des intervalles de confiance voulus",
- ang = "Confidence intervals"
- ),
-
- ), # Fin BLOC Simulation
-
-# QuadraticCumul = BLOC ( condition = " Analysis in ( 'QuadraticCumul', ) ",
-
-# ), # Fin BLOC QuadraticCumul
-
-#=====
-# 4. Pour la probabilite evenement
-#=====
-
- Event = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
-
- Threshold = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Le seuil de defaillance.",
- ang = "Failure threshold."
- ),
-
- ComparisonOperator = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ),
- fr = "Que faut-il ne pas depasser : un maximum ou un minimum.",
- ang = "What is the failure threshold : maximum or minimum."
- ),
-
- ), # Fin BLOC Event
-
-
- RandomGenerator = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
-
- SeedToBeSet = SIMP ( statut = "o",
- typ = 'TXM',
- into = ( 'yes', 'no' ),
- defaut = 'no',
- max = 1,
- fr = "La racine du generateur aleatoire doit-elle etre positionnee ?",
- ang = "Does the random generator seed need to be set ?"
- ),
-
- SeedSettings = BLOC ( condition = " SeedToBeSet in ( 'yes', ) ",
-
- RandomGeneratorSeed = SIMP ( statut = "o",
- typ = "I",
- max = 1,
- fr = "Racine du generateur aleatoire",
- ang = "Random generator seed"
- ),
-
- ), # Fin BLOC SeedSettings
-
- ), # Fin BLOC RandomGenerator
-
-
-#====
-# 5. Definition des parametres
-#====
-
- Variables = FACT ( statut = "o",
- min = 1,
- max = "**",
-
-# 5.1. ==> Nom de la variable
-
- Name = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Nom de la variable, identique au nom dans le solver.",
- ang = "Name of the variable, identical to the name in solver."
- ),
-
- Type = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "in", "out", ),
- defaut = "in",
- fr = "variable d'entree ou de sortie du solver",
- ang = "Input or Output variable",
- ),
-
- Unit = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Unite",
- ang = "Unit",
- ),
-
- Comment = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Commentaire",
- ang = "Comment",
- ),
-
- Regexp = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Expression reguliere",
- ang = "Regular expression",
- ),
-
- Format = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Format d'ecriture",
- ang = "Format",
- ),
-
-# 5.2. ==> Variable d'entree
-# 5.2.1. ==> Loi de distribution
-
- InputVariable = BLOC ( condition = " Type in ( 'in', ) ",
-
- MarginalDistribution = SIMP ( statut = "o",
- typ = ( loi, ),
- max = 1,
- fr = "Choix de la loi marginale",
- ang = "1D marginal distribution."
- ),
-
-# 5.2.2. ==> Parametres de calcul
-
-# 5.2.2.1. ==> Quand on cherche le point de conception, on peut preferer le depart de l'algorithme.
-# Si on ne le fait pas, le programme prendra la valeur mediane.
-
- PhysicalStartingPoint = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- fr = "Point de demarrage de l'algorithme iteratif",
- ang = "Initial point for iterative process."
- ),
-
-# 5.2.2.2. ==> Mode d'obtention du gradient par rapport au parametre
-
- Gradient = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- into = ( "OUI", "NON" ),
- defaut = "NON",
- fr = "ASTER calcule directement le gradient.",
- ang = "ASTER computes the gradient for this parameter."
- ),
-
- GradientProvided = BLOC ( condition = " GRADIENT in ( 'NON', ) ",
-
- Increment = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- fr = "Increment dans la direction.",
- ang = "Direction increment."
- ),
- ), # Fin BLOC GradientProvided
-
- ), # Fin BLOC InputVariable
-
- ), # Fin FACT Variables
-
-#====
-# 6. La fonction
-#====
-
-
- PhysicalSolver = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- #into = ( "Code_Aster", "Code_Saturne", "User_defined" ),
- fr = "Nom du solveur de calcul",
- ang = "Solver name"
- ),
-
- WrapperPath = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "chemin d acces au wrapper",
- ang = "wrapper library path"
- ),
-
- FunctionName = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Nom de la fonction dans le wrapper",
- ang = "Function's name in wrapper"
- ),
-
- GradientName = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du gradient dans le wrapper",
- ang = "gradient's name in wrapper"
- ),
-
- HessianName = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du hessian dans le wrapper",
- ang = "hessian's name in wrapper"
- ),
-
- WrapCouplingMode = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "static-link", "dynamic-link", "fork", ),
- fr = "mode de couplage du solver",
- ang = "Solver coupling mode"
- ),
-
- DTDDirectory = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "repertoire de la DTD",
- ang = "DTD directory"
- ),
-
- Fork = BLOC ( condition = " WrapCouplingMode in ( 'fork', ) ",
-
- Command = SIMP ( statut = "o",
- max = 1,
- typ = "TXM",
- fr = "Chemin du solver",
- ang = "solver path"
- ),
- ), # Fin BLOC Fork
-
- State = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- into = ( "shared", "specific" ),
- fr = "partage de l etat interne entre les fonctions",
- ang = "internal state sharing"
- ),
-
- InDataTransfer = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
- fr = "mode de transfert des donnees d entree",
- ang = "input transfering mode"
- ),
-
- OutDataTransfer = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
- fr = "mode de transfert des donnees de sortie",
- ang = "output transfering mode"
- ),
-
-
-
-#====
-# 7. Informations sur les fichiers d'echange
-#====
-
- Files = FACT ( statut = "f",
- min = 1,
- max = "**",
-
- Id = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Identificateur du fichier",
- ang = "File id"
- ),
-
- Type = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "in", "out", ),
- fr = "Fichier d entree ou de sortie du solveur ?",
- ang = "Input or Output file ?"
- ),
-
- Name = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du fichier",
- ang = "file name"
- ),
-
- Path = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "chemin du fichier",
- ang = "path file "
- ),
-
- Subst = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "liste de variables",
- ang = "list"
- ),
-
- ), # Fin FACT Files
-
-); # Fin PROC STUDY
-
-RESULT = PROC ( nom = "RESULT",
- op = None,
- docu = "",
- fr = "Liste des resultats a produire",
- ang = "List of results to write out",
-
- GeneralizedReliabilityIndex = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "yes", "no" ),
- defaut = "no",
- max = 1,
- fr = "Index de fiabilite generalise",
- ang = "Generalized reliability index"
- ),
-
-); # Fin PROC Result
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-# --------------------------------------------------
-# debut entete
-# --------------------------------------------------
-
-import Accas
-from Accas import *
-
-class loi ( ASSD ) : pass
-
-
-#CONTEXT.debug = 1
-JdC = JDC_CATA ( code = 'OPENTURNS',
- execmodul = None,
- regles = ( AU_MOINS_UN ( 'STUDY' ), ),
- ) # Fin JDC_CATA
-
-# --------------------------------------------------
-# fin entete
-# --------------------------------------------------
-
-# 3. Version d OPENTURNS ?
-
-#===========================================================
-
-
-#================================
-# 1. Definition des LOIS
-#================================
-
-# Nota : les variables de type OPER doivent etre en majuscules !
-DISTRIBUTION = OPER ( nom = "DISTRIBUTION",
- sd_prod = loi,
- op = 68,
- fr = "Definitions des lois marginales utilisees par les variables d'entree",
-
-
-#====
-# 2. Type de la loi de distribution
-#====
-
- Kind = SIMP ( statut = "o", typ = "TXM",
- into = ( "Beta",
- "Exponential",
- "Gamma",
- "Geometric",
- "Gumbel",
- "Histogram",
- "Logistic",
- "LogNormal",
- "MultiNomial",
- "Normal",
- "TruncatedNormal",
- "Poisson",
- "Student",
- "Triangular",
- "Uniform",
- "UserDefined",
- "Weibull",
- ),
- fr = "Choix du type de la loi marginale",
- ang = "1D marginal distribution." ),
-
-#====
-# 3. Definition des parametres selon le type de la loi
-#====
-
-# 3.1. ==> Loi beta
-
- BETA = BLOC ( condition = " Kind in ( 'Beta', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "RT", "MuSigma" ),
- defaut = "RT",
- fr = "Parametrage de la loi beta",
- ang = "Beta distribution parameter set"
- ),
-
- RT_Parameters = BLOC ( condition = " Settings in ( 'RT', ) ",
-
- R = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre R de la loi",
- ang = "R parameter"
- ),
-
- # T > R
- T = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre T de la loi | T > R",
- ang = "T parameter | T > R"
- ),
-
- ), # Fin BLOC RT_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre A de la loi",
- ang = "A parameter"
- ),
-
- # B > A
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre B de la loi | B > A",
- ang = "B parameter | B > A"
- ),
-
- ), # Fin BLOC BETA
-
-# 3.2. ==> Loi exponentielle
-
- EXPONENTIAL = BLOC ( condition = " Kind in ( 'Exponential', ) ",
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC EXPONENTIAL
-
-# 3.3. ==> Loi gamma
-
- GAMMA = BLOC ( condition = " Kind in ( 'Gamma', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "KLambda", "MuSigma" ),
- defaut = "KLambda",
- fr = "Parametrage de la loi gamma",
- ang = "Gamma distribution parameter set"
- ),
-
- KLambda_Parameters = BLOC ( condition = " Settings in ( 'KLambda', ) ",
-
- K = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre K de la loi | K > 0",
- ang = "K parameter | K > 0"
- ),
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda de la loi | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- ), # Fin BLOC KLambda_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- defaut = 0.0,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- defaut = 1.0,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
-
- ), # Fin BLOC GAMMA
-
-# 3.5. ==> Loi geometrique
-
- GEOMETRIC = BLOC ( condition = " Kind in ( 'Geometric', ) ",
-
- P = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- val_max = 1.,
- fr = "Parametre P | 0 < P < 1",
- ang = "P parameter | 0 < P < 1"
- ),
-
- ), # Fin BLOC GEOMETRIC
-
-# 3.6. ==> Loi gumbel
-
- GUMBEL = BLOC ( condition = " Kind in ( 'Gumbel', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "AlphaBeta", "MuSigma" ),
- defaut = "AlphaBeta",
- fr = "Parametrage de la loi gumbel",
- ang = "Gumbel distribution parameter set"
- ),
-
- AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Alpha de la loi | Alpha > 0",
- ang = "Alpha parameter | Alpha > 0"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Beta de la loi",
- ang = "Beta parameter"
- ),
-
- ), # Fin BLOC AlphaBeta_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- ), # Fin BLOC GUMBEL
-
-# 3.7. ==> Loi histogramme
-
- HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
-
- Sup = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la distribution",
- ang = "Upper bound"
- ),
-
- # Il faut definir une collection de couples ( x,p )
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC HISTOGRAM
-
-# 3.8. ==> Loi lognormale
-
- LOGNORMAL = BLOC ( condition = " Kind in ( 'LogNormal', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ),
- defaut = "MuSigmaLog",
- fr = "Parametrage de la loi lognormale",
- ang = "Lognormal distribution parameter set"
- ),
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', 'MuSigmaOverMu' ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi | Mu > Gamma",
- ang = "Mu parameter | Mu > Gamma"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
-
- MuLog = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu log de la loi",
- ang = "Mu log parameter"
- ),
-
- SigmaLog = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma log de la loi | SigmaLog > 0",
- ang = "Sigma log parameter | SigmaLog > 0"
- ),
-
- ), # Fin BLOC MuSigmaLog_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC LOGNORMAL
-
-# 3.9. ==> Loi logistique
-
- LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Alpha de la loi",
- ang = "Alpha parameter"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Beta de la loi | Beta > = 0",
- ang = "Beta parameter | Beta > = 0"
- ),
-
- ), # Fin BLOC LOGISTIC
-
-# 3.10. ==> Loi multinomiale
-
- MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ",
-
- N = SIMP ( statut = "o",
- typ = "E",
- max = 1,
- fr = "Dimension de la loi",
- ang = "DISTRIBUTION dimension"
- ),
-
- # Il faut un vecteur P de taille N
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC MULTINOMIAL
-
-# 3.11. ==> Loi normale
-
- NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC NORMAL
-
-# 3.12. ==> Loi Poisson
-
- POISSON = BLOC ( condition = " Kind in ( 'Poisson', ) ",
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda de la loi | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- ), # Fin BLOC POISSON
-
-# 3.13. ==> Loi student
-
- STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Nu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 2.,
- fr = "Parametre Nu de la loi | V > = 2",
- ang = "Nu parameter | V > = 2"
- ),
-
- ), # Fin BLOC STUDENT
-
-# 3.14. ==> Loi triangulaire
-
- TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = M < = B",
- ang = "Lower bound | A < = M < = B"
- ),
-
- M = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Mode de la loi | A < = M < = B",
- ang = "Mode | A < = M < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = M < = B",
- ang = "Upper bound | A < = M < = B"
- ),
-
- ), # Fin BLOC TRIANGULAR
-
-# 3.15. ==> Loi normale tronquee
-
- TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
-
- MuN = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- SigmaN = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre SigmaN de la loi | SigmaN > 0",
- ang = "SigmaN parameter | SigmaN> 0"
- ),
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = B",
- ang = "Lower bound | A < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = B",
- ang = "Upper bound | A < = B"
- ),
-
- ), # Fin BLOC TRUNCATEDNORMAL
-
-# 3.16. ==> uniforme
-
- UNIFORM = BLOC ( condition = " Kind in ( 'Uniform', ) ",
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = B",
- ang = "Lower bound | A < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = B",
- ang = "Upper bound | A < = B"
- ),
-
- ), # Fin BLOC UNIFORM
-
-# 3.17. ==> Loi definie par l'utilisateur
-
- USERDEFINED = BLOC ( condition = " Kind in ( 'UserDefined', ) ",
-
- # Il faut definir une collection de couples ( x,p )
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC USERDEFINED
-
-# 3.18. ==> Weibull
-
- WEIBULL = BLOC ( condition = " Kind in ( 'Weibull', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "AlphaBeta", "MuSigma" ),
- defaut = "AlphaBeta",
- fr = "Parametrage de la loi weibull",
- ang = "Weibull distribution parameter set"
- ),
-
- AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Alpha de la loi | Alpha > 0",
- ang = "Alpha parameter | Alpha > 0"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Beta de la loi | Beta > 0",
- ang = "Beta parameter | Beta > 0"
- ),
-
- ), # Fin BLOC AlphaBeta_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC WEIBULL
-
-); # Fin OPER DISTRIBUTION
-
-#================================
-# 2. Definition du cas d'etude
-#================================
-# Nota : les variables de type PROC doivent etre en majuscules !
-STUDY = PROC ( nom = "STUDY",
- op = None,
- docu = "",
- fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.",
- ang = "Writes the configuration file for OPENTURNS.",
-
-
-#=====
-# 1. Le Type d'Analyse
-#=====
-
- Analysis = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "Reliability", "Simulation", "QuadraticCumul" ),
- fr = "Type d'Analyse",
- ang = "Analysis",
- ),
-
-#=====
-# 2. Pour la probabilite
-# algorithme et mode choisis
-#=====
-
- Reliability = BLOC ( condition = " Analysis in ( 'Reliability', ) ",
-
-# 2.1. ==> L'algorithme
-
- Algorithm = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "FORM", "SORM" ),
- fr = "Algorithme de fiabilite",
- ang = "Reliability algorithm"
- ),
-
-# 2.2. ==> La methode
-# 2.2.1. ==> La methode
-
- Method = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "Cobyla", "AbdoRackwitz" ),
- fr = "Methode d'optimisation.",
- ang = "Optimisation method."
- ),
-
-# 2.2.2. ==> Regles
-
- regles = ( EXCLUS ( "MaximumAbsoluteError", "RelativeAbsoluteError" ), ),
-
-# 2.2.3. ==> Nombre d'iterations
-
- MaximumIterationsNumber = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = "Nombre maximum d iterations.",
- ang = "Maximum number of iterations."
- ),
-
-# 2.2.4. ==> Erreur maximum absolue
-
- MaximumAbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Distance maximum absolue entre 2 iterations successifs.",
- ang = "Absolute maximum distance between 2 successive iterates."
- ),
-
-# 2.2.5. ==> Erreur maximum relative
-
- RelativeAbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Distance maximum relative entre 2 iterations successifs.",
- ang = "Relative maximum distance between 2 successive iterates."
- ),
-
-# 2.2.6. ==> Ecart de contrainte absolu
-
- MaximumConstraintError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Valeur maximum absolue de la fonction \
- moins la valeur du niveau.",
- ang = "Maximum absolute value of the constraint function \
- minus the level value."
- ),
-
-# 2.2.7. ==> Ecart de residu absolu
-
- MaximumResidualError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Maximum orthogonality error.",
- ang = "Maximum orthogonality error."
- ),
-
- ), # Fin BLOC Reliability
-
-#=====
-# 3. Pour la probabilite
-# seuil par simulation :
-# algorithme choisi
-#=====
-
- Simulation = BLOC ( condition = " Analysis in ( 'Simulation', ) ",
-
-# 3.1. ==> L'algorithme
-
- Algorithm = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "MonteCarlo", "LHS", "DirectionalSampling" ),
- fr = "Algorithme de simulation",
- ang = "Simulation algorithm"
- ),
-
-# 3.1.2. ==> Nombre d...
-
- BlockSize = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- defaut = 1,
- fr = "Nombre maximum ...",
- ang = "Maximum number of ..."
- ),
-
-# 3.2.3. ==> ... maximum ...
-
- MaximumCoefficientOfVariation = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " maximum ...",
- ang = "Absolute maximum ...."
- ),
-
-# 3.2.4. ==> Maximum d'iterations
-
- MaximumOuterSamplingType = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "UserDefined",
- into = ( "Wilks", "UserDefined" ),
- fr = "Mode definition du maximum d iterations",
- ang = "Maximum iterations number"
- ),
-
- Wilks = BLOC ( condition = " MaximumOuterSamplingType in ( 'Wilks', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.0,
- val_max = 1.0,
- fr = "Ordre du quantile.",
- ang = "Order of the quantile."
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.0,
- val_max = 1.0,
- fr = "Confiance ...",
- ang = "Confidence ..."
- ),
-
- I = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 0,
- defaut = 0,
- fr = " ...",
- ang = "Rank ..."
- ),
-
- ), # Fin BLOC Wilks
-
- UserDefined = BLOC ( condition = " MaximumOuterSamplingType in ( 'UserDefined', ) ",
-
- MaximumOuterSampling = SIMP ( statut = "o",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = "Maximum d iterations externes.",
- ang = "Maximum outer Sampling value."
- ),
-
- ), # Fin BLOC UserDefined
-
-# 3.2.6. ==> Root strategy
-
- DirectionalSampling = BLOC ( condition = " Algorithm in ( 'DirectionalSampling', ) ",
-
- RootStrategyImplementation = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "SafeAndSlow",
- into = ( "RiskyAndFast", "MediumSafe", "SafeAndSlow" ),
- fr = "RootStrategyImplementation.",
- ang = "RootStrategyImplementation."
- ),
-
- SolverImplementation = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "Bisection",
- into = ( "Bisection", "Brent", "Secant" ),
- fr = "SolverImplementation.",
- ang = "SolverImplementation."
- ),
-
- SolverImplementationg = BLOC ( condition = " SolverImplementation in ( 'Bisection', 'Brent', 'Secant' ) ",
-
- regles = ( ENSEMBLE ( 'AbsoluteError', 'RelativeError', 'maximumFunctionEvaluation' ), ),
-
- AbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " Absolute error ...",
- ang = "Absolute error ..."
- ),
-
- RelativeError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " Relative error ...",
- ang = "Relative error ..."
- ),
-
- MaximumFunctionEvaluation = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = " maximum Function Evaluation ...",
- ang = "maximum Function Evaluation ..."
- ),
-
- ), # Fin BLOC SolverImplementationg
-
- ), # Fin BLOC DirectionalSampling
-
-# 3.2.7. ==> Impression des intervalles de confiance
-
- ConfidenceIntervalProbability = SIMP ( statut = "f",
- typ = 'R',
- max = '**',
- val_min = 0.,
- val_max = 1.,
- fr = "Liste des intervalles de confiance voulus",
- ang = "Confidence intervals"
- ),
-
- ), # Fin BLOC Simulation
-
-#=====
-# 4. Pour la probabilite evenement
-#=====
-
- Event = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
-
- Threshold = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Le seuil de defaillance.",
- ang = "Failure threshold."
- ),
-
- ComparisonOperator = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ),
- fr = "Que faut-il ne pas depasser : un maximum ou un minimum.",
- ang = "What is the failure threshold : maximum or minimum."
- ),
-
- ), # Fin BLOC Event
-
-
- RandomGenerator = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
-
- SeedToBeSet = SIMP ( statut = "o",
- typ = 'TXM',
- into = ( 'yes', 'no' ),
- defaut = 'no',
- max = 1,
- fr = "La racine du generateur aleatoire doit-elle etre positionnee ?",
- ang = "Does the random generator seed need to be set ?"
- ),
-
- SeedSettings = BLOC ( condition = " SeedToBeSet in ( 'yes', ) ",
-
- RandomGeneratorSeed = SIMP ( statut = "o",
- typ = "I",
- max = 1,
- fr = "Racine du generateur aleatoire",
- ang = "Random generator seed"
- ),
-
- ), # Fin BLOC SeedSettings
-
- ), # Fin BLOC RandomGenerator
-
-
-#====
-# 5. Definition des parametres
-#====
-
- Variables = FACT ( statut = "o",
- min = 1,
- max = "**",
-
-# 5.1. ==> Nom de la variable
-
- Name = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Nom de la variable, identique au nom dans le solver.",
- ang = "Name of the variable, identical to the name in solver."
- ),
-
- Type = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "in", "out", ),
- defaut = "in",
- fr = "variable d'entree ou de sortie du solver",
- ang = "Input or Output variable",
- ),
-
- Unit = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Unite",
- ang = "Unit",
- ),
-
- Comment = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Commentaire",
- ang = "Comment",
- ),
-
- Regexp = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Expression reguliere",
- ang = "Regular expression",
- ),
-
- Format = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Format d'ecriture",
- ang = "Format",
- ),
-
-# 5.2. ==> Variable d'entree
-# 5.2.1. ==> Loi de distribution
-
- InputVariable = BLOC ( condition = " Type in ( 'in', ) ",
-
- MarginalDistribution = SIMP ( statut = "o",
- typ = ( loi, ),
- max = 1,
- fr = "Choix de la loi marginale",
- ang = "1D marginal distribution."
- ),
-
-# 5.2.2. ==> Parametres de calcul
-
-# 5.2.2.1. ==> Quand on cherche le point de conception, on peut preferer le depart de l'algorithme.
-# Si on ne le fait pas, le programme prendra la valeur mediane.
-
- PhysicalStartingPoint = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- fr = "Point de demarrage de l'algorithme iteratif",
- ang = "Initial point for iterative process."
- ),
-
-# 5.2.2.2. ==> Mode d'obtention du gradient par rapport au parametre
-
- Gradient = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- into = ( "OUI", "NON" ),
- defaut = "NON",
- fr = "ASTER calcule directement le gradient.",
- ang = "ASTER computes the gradient for this parameter."
- ),
-
- GradientProvided = BLOC ( condition = " GRADIENT in ( 'NON', ) ",
-
- Increment = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- fr = "Increment dans la direction.",
- ang = "Direction increment."
- ),
- ), # Fin BLOC GradientProvided
-
- ), # Fin BLOC InputVariable
-
- ), # Fin FACT Variables
-
-#====
-# 6. La fonction
-#====
-
-
- Solver = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- #into = ( "Code_Aster", "Code_Saturne", "User_defined" ),
- fr = "Nom du solveur de calcul",
- ang = "Solver name"
- ),
-
- WrapperPath = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "chemin d acces au wrapper",
- ang = "wrapper library path"
- ),
-
- FunctionName = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Nom de la fonction dans le wrapper",
- ang = "Function's name in wrapper"
- ),
-
- GradientName = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du gradient dans le wrapper",
- ang = "gradient's name in wrapper"
- ),
-
- HessianName = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du hessian dans le wrapper",
- ang = "hessian's name in wrapper"
- ),
-
- WrapCouplingMode = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "static-link", "dynamic-link", "fork", ),
- fr = "mode de couplage du solver",
- ang = "Solver coupling mode"
- ),
-
- DTDDirectory = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "repertoire de la DTD",
- ang = "DTD directory"
- ),
-
- Fork = BLOC ( condition = " WrapCouplingMode in ( 'fork', ) ",
-
- Command = SIMP ( statut = "o",
- max = 1,
- typ = "TXM",
- fr = "Chemin du solver",
- ang = "solver path"
- ),
- ), # Fin BLOC Fork
-
- State = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- into = ( "shared", "specific" ),
- fr = "partage de l etat interne entre les fonctions",
- ang = "internal state sharing"
- ),
-
- InDataTransfer = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
- fr = "mode de transfert des donnees d entree",
- ang = "input transfering mode"
- ),
-
- OutDataTransfer = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
- fr = "mode de transfert des donnees de sortie",
- ang = "output transfering mode"
- ),
-
-
-
-#====
-# 7. Informations sur les fichiers d'echange
-#====
-
- Files = FACT ( statut = "f",
- min = 1,
- max = "**",
-
- Id = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Identificateur du fichier",
- ang = "File id"
- ),
-
- Type = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "in", "out", ),
- fr = "Fichier d entree ou de sortie du solveur ?",
- ang = "Input or Output file ?"
- ),
-
- Name = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du fichier",
- ang = "file name"
- ),
-
- Path = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "chemin du fichier",
- ang = "path file "
- ),
-
- Subst = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "liste de variables",
- ang = "list"
- ),
-
- ), # Fin FACT Files
-
-); # Fin PROC STUDY
-
-Result = PROC ( nom = "RESULT",
- op = None,
- docu = "",
- fr = "Liste des resultats a produire",
- ang = "List of results to write out",
-
- GeneralizedReliabilityIndex = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "yes", "no" ),
- defaut = "no",
- max = 1,
- fr = "Index de fiabilite generalise",
- ang = "Generalized reliability index"
- ),
-
-); # Fin PROC Result
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-# --------------------------------------------------
-# debut entete
-# --------------------------------------------------
-
-import Accas
-from Accas import *
-
-class loi ( ASSD ) : pass
-
-
-#CONTEXT.debug = 1
-JdC = JDC_CATA ( code = 'OPENTURNS',
- execmodul = None,
- regles = ( AU_MOINS_UN ( 'STUDY' ), ),
- ) # Fin JDC_CATA
-
-# --------------------------------------------------
-# fin entete
-# --------------------------------------------------
-
-# 3. Version d OPENTURNS ?
-
-#===========================================================
-
-
-#================================
-# 1. Definition des LOIS
-#================================
-
-# Nota : les variables de type OPER doivent etre en majuscules !
-DISTRIBUTION = OPER ( nom = "DISTRIBUTION",
- sd_prod = loi,
- op = 68,
- fr = "Definitions des lois marginales utilisees par les variables d'entree",
-
-
-#====
-# 2. Type de la loi de distribution
-#====
-
- Kind = SIMP ( statut = "o", typ = "TXM",
- into = ( "Beta",
- "Exponential",
- "Gamma",
- "Geometric",
- "Gumbel",
- "Histogram",
- "Logistic",
- "LogNormal",
- "MultiNomial",
- "Normal",
- "TruncatedNormal",
- "Poisson",
- "Student",
- "Triangular",
- "Uniform",
- "UserDefined",
- "Weibull",
- ),
- fr = "Choix du type de la loi marginale",
- ang = "1D marginal distribution." ),
-
-#====
-# 3. Definition des parametres selon le type de la loi
-#====
-
-# 3.1. ==> Loi beta
-
- BETA = BLOC ( condition = " Kind in ( 'Beta', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "RT", "MuSigma" ),
- defaut = "RT",
- fr = "Parametrage de la loi beta",
- ang = "Beta distribution parameter set"
- ),
-
- RT_Parameters = BLOC ( condition = " Settings in ( 'RT', ) ",
-
- R = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre R de la loi",
- ang = "R parameter"
- ),
-
- # T > R
- T = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre T de la loi | T > R",
- ang = "T parameter | T > R"
- ),
-
- ), # Fin BLOC RT_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre A de la loi",
- ang = "A parameter"
- ),
-
- # B > A
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre B de la loi | B > A",
- ang = "B parameter | B > A"
- ),
-
- ), # Fin BLOC BETA
-
-# 3.2. ==> Loi exponentielle
-
- EXPONENTIAL = BLOC ( condition = " Kind in ( 'Exponential', ) ",
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC EXPONENTIAL
-
-# 3.3. ==> Loi gamma
-
- GAMMA = BLOC ( condition = " Kind in ( 'Gamma', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "KLambda", "MuSigma" ),
- defaut = "KLambda",
- fr = "Parametrage de la loi gamma",
- ang = "Gamma distribution parameter set"
- ),
-
- KLambda_Parameters = BLOC ( condition = " Settings in ( 'KLambda', ) ",
-
- K = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre K de la loi | K > 0",
- ang = "K parameter | K > 0"
- ),
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda de la loi | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- ), # Fin BLOC KLambda_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- defaut = 0.0,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- defaut = 1.0,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
-
- ), # Fin BLOC GAMMA
-
-# 3.5. ==> Loi geometrique
-
- GEOMETRIC = BLOC ( condition = " Kind in ( 'Geometric', ) ",
-
- P = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- val_max = 1.,
- fr = "Parametre P | 0 < P < 1",
- ang = "P parameter | 0 < P < 1"
- ),
-
- ), # Fin BLOC GEOMETRIC
-
-# 3.6. ==> Loi gumbel
-
- GUMBEL = BLOC ( condition = " Kind in ( 'Gumbel', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "AlphaBeta", "MuSigma" ),
- defaut = "AlphaBeta",
- fr = "Parametrage de la loi gumbel",
- ang = "Gumbel distribution parameter set"
- ),
-
- AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Alpha de la loi | Alpha > 0",
- ang = "Alpha parameter | Alpha > 0"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Beta de la loi",
- ang = "Beta parameter"
- ),
-
- ), # Fin BLOC AlphaBeta_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- ), # Fin BLOC GUMBEL
-
-# 3.7. ==> Loi histogramme
-
- HISTOGRAM = BLOC ( condition = " Kind in ( 'Histogram', ) ",
-
- Sup = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la distribution",
- ang = "Upper bound"
- ),
-
- # Il faut definir une collection de couples ( x,p )
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC HISTOGRAM
-
-# 3.8. ==> Loi lognormale
-
- LOGNORMAL = BLOC ( condition = " Kind in ( 'LogNormal', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "MuSigmaLog", "MuSigma", "MuSigmaOverMu" ),
- defaut = "MuSigmaLog",
- fr = "Parametrage de la loi lognormale",
- ang = "Lognormal distribution parameter set"
- ),
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi | Mu > Gamma",
- ang = "Mu parameter | Mu > Gamma"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- MuSigmaOverMu_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaOverMu,', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi | Mu > Gamma",
- ang = "Mu parameter | Mu > Gamma"
- ),
-
- SigmaOverMu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre SigmaOverMu de la loi | SigmaOverMu > 0",
- ang = "SigmaOverMu parameter | SigmaOverMu > 0"
- ),
-
- ), # Fin BLOC MuSigmaOverMu_Parameters
-
- MuSigmaLog_Parameters = BLOC ( condition = " Settings in ( 'MuSigmaLog', ) ",
-
- MuLog = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu log de la loi",
- ang = "Mu log parameter"
- ),
-
- SigmaLog = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma log de la loi | SigmaLog > 0",
- ang = "Sigma log parameter | SigmaLog > 0"
- ),
-
- ), # Fin BLOC MuSigmaLog_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC LOGNORMAL
-
-# 3.9. ==> Loi logistique
-
- LOGISTIC = BLOC ( condition = " Kind in ( 'Logistic', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Alpha de la loi",
- ang = "Alpha parameter"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Beta de la loi | Beta > = 0",
- ang = "Beta parameter | Beta > = 0"
- ),
-
- ), # Fin BLOC LOGISTIC
-
-# 3.10. ==> Loi multinomiale
-
- MULTINOMIAL = BLOC ( condition = " Kind in ( 'MultiNomial', ) ",
-
- N = SIMP ( statut = "o",
- typ = "E",
- max = 1,
- fr = "Dimension de la loi",
- ang = "DISTRIBUTION dimension"
- ),
-
- # Il faut un vecteur P de taille N
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC MULTINOMIAL
-
-# 3.11. ==> Loi normale
-
- NORMAL = BLOC ( condition = " Kind in ( 'Normal', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC NORMAL
-
-# 3.12. ==> Loi Poisson
-
- POISSON = BLOC ( condition = " Kind in ( 'Poisson', ) ",
-
- Lambda = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Lambda de la loi | Lambda > 0",
- ang = "Lambda parameter | Lambda > 0"
- ),
-
- ), # Fin BLOC POISSON
-
-# 3.13. ==> Loi student
-
- STUDENT = BLOC ( condition = " Kind in ( 'Student', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Nu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 2.,
- fr = "Parametre Nu de la loi | V > = 2",
- ang = "Nu parameter | V > = 2"
- ),
-
- ), # Fin BLOC STUDENT
-
-# 3.14. ==> Loi triangulaire
-
- TRIANGULAR = BLOC ( condition = " Kind in ( 'Triangular', ) ",
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = M < = B",
- ang = "Lower bound | A < = M < = B"
- ),
-
- M = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Mode de la loi | A < = M < = B",
- ang = "Mode | A < = M < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = M < = B",
- ang = "Upper bound | A < = M < = B"
- ),
-
- ), # Fin BLOC TRIANGULAR
-
-# 3.15. ==> Loi normale tronquee
-
- TRUNCATEDNORMAL = BLOC ( condition = " Kind in ( 'TruncatedNormal', ) ",
-
- MuN = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- SigmaN = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre SigmaN de la loi | SigmaN > 0",
- ang = "SigmaN parameter | SigmaN> 0"
- ),
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = B",
- ang = "Lower bound | A < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = B",
- ang = "Upper bound | A < = B"
- ),
-
- ), # Fin BLOC TRUNCATEDNORMAL
-
-# 3.16. ==> uniforme
-
- UNIFORM = BLOC ( condition = " Kind in ( 'Uniform', ) ",
-
- A = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne inferieure de la loi | A < = B",
- ang = "Lower bound | A < = B"
- ),
-
- B = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Borne superieure de la loi | A < = B",
- ang = "Upper bound | A < = B"
- ),
-
- ), # Fin BLOC UNIFORM
-
-# 3.17. ==> Loi definie par l'utilisateur
-
- USERDEFINED = BLOC ( condition = " Kind in ( 'UserDefined', ) ",
-
- # Il faut definir une collection de couples ( x,p )
- Values = SIMP ( statut = 'o',
- typ = 'R',
- max = '**'
- ),
-
- ), # Fin BLOC USERDEFINED
-
-# 3.18. ==> Weibull
-
- WEIBULL = BLOC ( condition = " Kind in ( 'Weibull', ) ",
-
- Settings = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "AlphaBeta", "MuSigma" ),
- defaut = "AlphaBeta",
- fr = "Parametrage de la loi weibull",
- ang = "Weibull distribution parameter set"
- ),
-
- AlphaBeta_Parameters = BLOC ( condition = " Settings in ( 'AlphaBeta', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Alpha de la loi | Alpha > 0",
- ang = "Alpha parameter | Alpha > 0"
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Beta de la loi | Beta > 0",
- ang = "Beta parameter | Beta > 0"
- ),
-
- ), # Fin BLOC AlphaBeta_Parameters
-
-
- MuSigma_Parameters = BLOC ( condition = " Settings in ( 'MuSigma', ) ",
-
- Mu = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Mu de la loi",
- ang = "Mu parameter"
- ),
-
- Sigma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.,
- fr = "Parametre Sigma de la loi | Sigma > 0",
- ang = "Sigma parameter | Sigma > 0"
- ),
-
- ), # Fin BLOC MuSigma_Parameters
-
- Gamma = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Parametre Gamma",
- ang = "Gamma parameter"
- ),
-
- ), # Fin BLOC WEIBULL
-
-); # Fin OPER DISTRIBUTION
-
-#================================
-# 2. Definition du cas d'etude
-#================================
-# Nota : les variables de type PROC doivent etre en majuscules !
-STUDY = PROC ( nom = "STUDY",
- op = None,
- docu = "",
- fr = "Mise en donnee pour le fichier de configuration de OPENTURNS.",
- ang = "Writes the configuration file for OPENTURNS.",
-
-
-#=====
-# 1. Le Type d'Analyse
-#=====
-
- Analysis = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "Reliability", "Simulation", "QuadraticCumul" ),
- fr = "Type d'Analyse",
- ang = "Analysis",
- ),
-
-#=====
-# 2. Pour la probabilite
-# algorithme et mode choisis
-#=====
-
- Reliability = BLOC ( condition = " Analysis in ( 'Reliability', ) ",
-
-# 2.1. ==> L'algorithme
-
- Algorithm = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "FORM", "SORM" ),
- fr = "Algorithme de fiabilite",
- ang = "Reliability algorithm"
- ),
-
-# 2.2. ==> La methode
-# 2.2.1. ==> La methode
-
- Method = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "Cobyla", "AbdoRackwitz" ),
- fr = "Methode d'optimisation.",
- ang = "Optimisation method."
- ),
-
-# 2.2.2. ==> Regles
-
- regles = ( EXCLUS ( "MaximumAbsoluteError", "RelativeAbsoluteError" ), ),
-
-# 2.2.3. ==> Nombre d'iterations
-
- MaximumIterationsNumber = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = "Nombre maximum d iterations.",
- ang = "Maximum number of iterations."
- ),
-
-# 2.2.4. ==> Erreur maximum absolue
-
- MaximumAbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Distance maximum absolue entre 2 iterations successifs.",
- ang = "Absolute maximum distance between 2 successive iterates."
- ),
-
-# 2.2.5. ==> Erreur maximum relative
-
- RelativeAbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Distance maximum relative entre 2 iterations successifs.",
- ang = "Relative maximum distance between 2 successive iterates."
- ),
-
-# 2.2.6. ==> Ecart de contrainte absolu
-
- MaximumConstraintError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Valeur maximum absolue de la fonction \
- moins la valeur du niveau.",
- ang = "Maximum absolute value of the constraint function \
- minus the level value."
- ),
-
-# 2.2.7. ==> Ecart de residu absolu
-
- MaximumResidualError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = "Maximum orthogonality error.",
- ang = "Maximum orthogonality error."
- ),
-
- ), # Fin BLOC Reliability
-
-#=====
-# 3. Pour la probabilite
-# seuil par simulation :
-# algorithme choisi
-#=====
-
- Simulation = BLOC ( condition = " Analysis in ( 'Simulation', ) ",
-
-# 3.1. ==> L'algorithme
-
- Algorithm = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "MonteCarlo", "LHS", "DirectionalSampling" ),
- fr = "Algorithme de simulation",
- ang = "Simulation algorithm"
- ),
-
-# 3.1.2. ==> Nombre d...
-
- BlockSize = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- defaut = 1,
- fr = "Nombre maximum ...",
- ang = "Maximum number of ..."
- ),
-
-# 3.2.3. ==> ... maximum ...
-
- MaximumCoefficientOfVariation = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " maximum ...",
- ang = "Absolute maximum ...."
- ),
-
-# 3.2.4. ==> Maximum d'iterations
-
- MaximumOuterSamplingType = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "UserDefined",
- into = ( "Wilks", "UserDefined" ),
- fr = "Mode definition du maximum d iterations",
- ang = "Maximum iterations number"
- ),
-
- Wilks = BLOC ( condition = " MaximumOuterSamplingType in ( 'Wilks', ) ",
-
- Alpha = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.0,
- val_max = 1.0,
- fr = "Ordre du quantile.",
- ang = "Order of the quantile."
- ),
-
- Beta = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- val_min = 0.0,
- val_max = 1.0,
- fr = "Confiance ...",
- ang = "Confidence ..."
- ),
-
- I = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 0,
- defaut = 0,
- fr = " ...",
- ang = "Rank ..."
- ),
-
- ), # Fin BLOC Wilks
-
- UserDefined = BLOC ( condition = " MaximumOuterSamplingType in ( 'UserDefined', ) ",
-
- MaximumOuterSampling = SIMP ( statut = "o",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = "Maximum d iterations externes.",
- ang = "Maximum outer Sampling value."
- ),
-
- ), # Fin BLOC UserDefined
-
-# 3.2.6. ==> Root strategy
-
- DirectionalSampling = BLOC ( condition = " Algorithm in ( 'DirectionalSampling', ) ",
-
- RootStrategyImplementation = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "SafeAndSlow",
- into = ( "RiskyAndFast", "MediumSafe", "SafeAndSlow" ),
- fr = "RootStrategyImplementation.",
- ang = "RootStrategyImplementation."
- ),
-
- SolverImplementation = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- defaut = "Bisection",
- into = ( "Bisection", "Brent", "Secant" ),
- fr = "SolverImplementation.",
- ang = "SolverImplementation."
- ),
-
- SolverImplementationg = BLOC ( condition = " SolverImplementation in ( 'Bisection', 'Brent', 'Secant' ) ",
-
- regles = ( ENSEMBLE ( 'AbsoluteError', 'RelativeError', 'maximumFunctionEvaluation' ), ),
-
- AbsoluteError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " Absolute error ...",
- ang = "Absolute error ..."
- ),
-
- RelativeError = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- val_min = 0.0,
- fr = " Relative error ...",
- ang = "Relative error ..."
- ),
-
- MaximumFunctionEvaluation = SIMP ( statut = "f",
- typ = "I",
- max = 1,
- val_min = 1,
- fr = " maximum Function Evaluation ...",
- ang = "maximum Function Evaluation ..."
- ),
-
- ), # Fin BLOC SolverImplementationg
-
- ), # Fin BLOC DirectionalSampling
-
-# 3.2.7. ==> Impression des intervalles de confiance
-
- ConfidenceIntervalProbability = SIMP ( statut = "f",
- typ = 'R',
- max = '**',
- val_min = 0.,
- val_max = 1.,
- fr = "Liste des intervalles de confiance voulus",
- ang = "Confidence intervals"
- ),
-
- ), # Fin BLOC Simulation
-
-#=====
-# 4. Pour la probabilite evenement
-#=====
-
- Event = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
-
- Threshold = SIMP ( statut = "o",
- typ = "R",
- max = 1,
- fr = "Le seuil de defaillance.",
- ang = "Failure threshold."
- ),
-
- ComparisonOperator = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "Less", "LessOrEqual", "Equal", "GreaterOrEqual", "Greater" ),
- fr = "Que faut-il ne pas depasser : un maximum ou un minimum.",
- ang = "What is the failure threshold : maximum or minimum."
- ),
-
- ), # Fin BLOC Event
-
-
- RandomGenerator = BLOC ( condition = " Analysis in ( 'Reliability', 'Simulation' ) ",
-
- SeedToBeSet = SIMP ( statut = "o",
- typ = 'TXM',
- into = ( 'yes', 'no' ),
- defaut = 'no',
- max = 1,
- fr = "La racine du generateur aleatoire doit-elle etre positionnee ?",
- ang = "Does the random generator seed need to be set ?"
- ),
-
- SeedSettings = BLOC ( condition = " SeedToBeSet in ( 'yes', ) ",
-
- RandomGeneratorSeed = SIMP ( statut = "o",
- typ = "I",
- max = 1,
- fr = "Racine du generateur aleatoire",
- ang = "Random generator seed"
- ),
-
- ), # Fin BLOC SeedSettings
-
- ), # Fin BLOC RandomGenerator
-
-
-#====
-# 5. Definition des parametres
-#====
-
- Variables = FACT ( statut = "o",
- min = 1,
- max = "**",
-
-# 5.1. ==> Nom de la variable
-
- Name = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Nom de la variable, identique au nom dans le solver.",
- ang = "Name of the variable, identical to the name in solver."
- ),
-
- Type = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "in", "out", ),
- defaut = "in",
- fr = "variable d'entree ou de sortie du solver",
- ang = "Input or Output variable",
- ),
-
- Unit = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Unite",
- ang = "Unit",
- ),
-
- Comment = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Commentaire",
- ang = "Comment",
- ),
-
- Regexp = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Expression reguliere",
- ang = "Regular expression",
- ),
-
- Format = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Format d'ecriture",
- ang = "Format",
- ),
-
-# 5.2. ==> Variable d'entree
-# 5.2.1. ==> Loi de distribution
-
- InputVariable = BLOC ( condition = " Type in ( 'in', ) ",
-
- MarginalDistribution = SIMP ( statut = "o",
- typ = ( loi, ),
- max = 1,
- fr = "Choix de la loi marginale",
- ang = "1D marginal distribution."
- ),
-
-# 5.2.2. ==> Parametres de calcul
-
-# 5.2.2.1. ==> Quand on cherche le point de conception, on peut preferer le depart de l'algorithme.
-# Si on ne le fait pas, le programme prendra la valeur mediane.
-
- PhysicalStartingPoint = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- fr = "Point de demarrage de l'algorithme iteratif",
- ang = "Initial point for iterative process."
- ),
-
-# 5.2.2.2. ==> Mode d'obtention du gradient par rapport au parametre
-
- Gradient = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- into = ( "OUI", "NON" ),
- defaut = "NON",
- fr = "ASTER calcule directement le gradient.",
- ang = "ASTER computes the gradient for this parameter."
- ),
-
- GradientProvided = BLOC ( condition = " GRADIENT in ( 'NON', ) ",
-
- Increment = SIMP ( statut = "f",
- typ = "R",
- max = 1,
- fr = "Increment dans la direction.",
- ang = "Direction increment."
- ),
- ), # Fin BLOC GradientProvided
-
- ), # Fin BLOC InputVariable
-
- ), # Fin FACT Variables
-
-#====
-# 6. La fonction
-#====
-
-
- Solver = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- #into = ( "Code_Aster", "Code_Saturne", "User_defined" ),
- fr = "Nom du solveur de calcul",
- ang = "Solver name"
- ),
-
- WrapperPath = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "chemin d acces au wrapper",
- ang = "wrapper library path"
- ),
-
- FunctionName = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Nom de la fonction dans le wrapper",
- ang = "Function's name in wrapper"
- ),
-
- GradientName = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du gradient dans le wrapper",
- ang = "gradient's name in wrapper"
- ),
-
- HessianName = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du hessian dans le wrapper",
- ang = "hessian's name in wrapper"
- ),
-
- WrapCouplingMode = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "static-link", "dynamic-link", "fork", ),
- fr = "mode de couplage du solver",
- ang = "Solver coupling mode"
- ),
-
- DTDDirectory = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "repertoire de la DTD",
- ang = "DTD directory"
- ),
-
- Fork = BLOC ( condition = " WrapCouplingMode in ( 'fork', ) ",
-
- Command = SIMP ( statut = "o",
- max = 1,
- typ = "TXM",
- fr = "Chemin du solver",
- ang = "solver path"
- ),
- ), # Fin BLOC Fork
-
- State = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- into = ( "shared", "specific" ),
- fr = "partage de l etat interne entre les fonctions",
- ang = "internal state sharing"
- ),
-
- InDataTransfer = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
- fr = "mode de transfert des donnees d entree",
- ang = "input transfering mode"
- ),
-
- OutDataTransfer = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "files", "pipe", "arguments", "socket", "CORBA", ),
- fr = "mode de transfert des donnees de sortie",
- ang = "output transfering mode"
- ),
-
-
-
-#====
-# 7. Informations sur les fichiers d'echange
-#====
-
- Files = FACT ( statut = "f",
- min = 1,
- max = "**",
-
- Id = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "Identificateur du fichier",
- ang = "File id"
- ),
-
- Type = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- into = ( "in", "out", ),
- fr = "Fichier d entree ou de sortie du solveur ?",
- ang = "Input or Output file ?"
- ),
-
- Name = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "Nom du fichier",
- ang = "file name"
- ),
-
- Path = SIMP ( statut = "o",
- typ = "TXM",
- max = 1,
- fr = "chemin du fichier",
- ang = "path file "
- ),
-
- Subst = SIMP ( statut = "f",
- typ = "TXM",
- max = 1,
- fr = "liste de variables",
- ang = "list"
- ),
-
- ), # Fin FACT Files
-
-); # Fin PROC STUDY
-
-Result = PROC ( nom = "RESULT",
- op = None,
- docu = "",
- fr = "Liste des resultats a produire",
- ang = "List of results to write out",
-
- GeneralizedReliabilityIndex = SIMP ( statut = "o",
- typ = "TXM",
- into = ( "yes", "no" ),
- defaut = "no",
- max = 1,
- fr = "Index de fiabilite generalise",
- ang = "Generalized reliability index"
- ),
-
-); # Fin PROC Result
-
+++ /dev/null
-import os
-
-import prefs
-
-rep_cata = prefs.REPINI
-
-# Acces a la documentation
-path_doc = os.path.join(rep_cata,'Doc')
-exec_acrobat = "/usr/bin/xpdf"
-
-# Utilisateur/Developpeur
-isdeveloppeur = "NON"
-path_cata_dev = "/tmp/cata"
-
-# Repertoire temporaire
-rep_travail = "/tmp"
-
-# Repertoire initial
-initialdir=os.curdir
-
-DTDDirectory="/local/openturns/Logiciels/OpenTURNS/install/share/openturns/wrappers/"
-
-# Choix des catalogues
-rep_mat=" "
-
-catalogues = (
-# ('OPENTURNS','v0',os.path.join(rep_cata,'Open_Cata_V0.py'),'openturns'),
- ('OPENTURNS','v1',os.path.join(rep_cata,'Open_Cata_V1.py'),'openturns'),
- ('OPENTURNS','IDM v7',os.path.join(rep_cata,'Open_Cata_IDM_V7.py'),'openturns'),
-# ('OPENTURNS','vg',os.path.join(rep_cata,'Open_Cata_gn.py'),'openturns'),
- )
-
+++ /dev/null
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-"""
- Ce module sert a lancer EFICAS configure pour Code_Aster
-"""
-# Modules Python
-import sys
-
-# Modules Eficas
-import prefs
-prefs.code="OPENTURNS"
-
-sys.path[:0]=[prefs.INSTALLDIR]
-
-import InterfaceTK
-from InterfaceTK import eficas_go
-
-if len(sys.argv) > 1 :
- # on veut ouvrir un fichier directement au lancement d'Eficas
- eficas_go.lance_eficas(code='OPENTURNS',fichier = sys.argv[1])
-else:
- # on veut ouvrir Eficas 'vide'
- eficas_go.lance_eficas(code='OPENTURNS')
+++ /dev/null
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-import os, sys
-
-# REPINI sert à localiser le fichier editeur.ini
-# Obligatoire
-REPINI=os.path.dirname(os.path.abspath(__file__))
-
-# INSTALLDIR sert à localiser l'installation d'Eficas
-# Obligatoire
-INSTALLDIR=os.path.join(REPINI,'..')
-
-# CODE_PATH sert à localiser Noyau et Validation éventuellement
-# non contenus dans la distribution EFICAS
-# Par défaut on utilise les modules de INSTALLDIR
-# Peut valoir None (defaut)
-CODE_PATH = None
-code = "OPENTURNS"
-
-# lang indique la langue utilisée pour les chaines d'aide : fr ou ang
-lang='fr'
-
-# Codage des strings qui accepte les accents (en remplacement de 'ascii')
-encoding='iso-8859-1'
-
-EditeurDir=INSTALLDIR+"/Editeur"
-sys.path[:0]=[INSTALLDIR]
-
-ICONDIR=os.path.join(INSTALLDIR,'Editeur','icons')
-
-# Preference
-if os.name == 'nt':
- userprefs = os.sep.join( [ os.environ['HOMEDRIVE'], os.environ['HOMEPATH'], 'Eficas_install', 'prefs.py' ])
-else :
- userprefs=os.path.expanduser("~/Eficas_install/prefs.py")
-
-if os.path.isfile(userprefs):
- try:
- execfile(userprefs)
- except:
- pass
-
-
-#-------------------------------------------------------------------
-# Partie pour TK
-#-------------------------------------------------------------------
-
-labels= ('Fichier','Edition','Jeu de commandes',)
-
-appli_composants=['readercata','bureau', 'options', ]
-
-menu_defs={ 'bureau': [
- ('Fichier',[
- ('Nouveau','newJDC','<Control-n>'),
- ('Ouvrir','openJDC','<Control-o>'),
- ('Enregistrer','saveJDC','<Control-e>'),
- ('Enregistrer sous','saveasJDC','<Control-s>'),
- None,
- ('Fermer','closeJDC','<Control-f>'),
- ('Quitter','exitEFICAS','<Control-q>'),
- ]
- ),
- ('Edition',[
- ('Copier','copy','<Control-c>'),
- ('Couper','cut','<Control-x>'),
- ('Coller','paste','<Control-v>'),
- ]
- ),
- ('Jeu de commandes',[
- ('Rapport de validation','visuCRJDC','<Control-r>'),
- ('Fichier à plat','visu_a_plat','<Control-p>'),
- ]
- ),
- ]
- }
-
+++ /dev/null
-# -*- coding: utf-8 -*-
-#@ MODIF properties Accas DATE 10/10/2002 AUTEUR gcbhhhh M.ADMINISTRATEUR
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# RESPONSABLE D6BHHHH J-P.LEFEBVRE
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-# ======================================================================
-# IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR
-# DE LA VERSION DU CODE_ASTER ASSOCIE
-#----------------------------------------------------------------------
-version = "7.1.0"
-date = "23/04/2003"
+++ /dev/null
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
-#
-#
-# ======================================================================
-
-"""
- Ce module sert à lancer EFICAS configuré pour Openturns
-"""
-# Modules Python
-
-# Modules Eficas
-import prefs
-prefs.code="OPENTURNS"
-from InterfaceQT import eficas_go
-
-eficas_go.lance_eficas(code=prefs.code)
+++ /dev/null
-# -*- coding: utf-8 -*-
-"""
- Ce module sert à construire les distributions d'EFICAS pour Openturns
- en fonction du tag CVS courant
- Les distributions sont :
- - un tar.gz pour UNIX ne contenant pas mxTextTools
- L'utilisation de ce module est la suivante :
- 1- Se mettre dans un répertoire de travail
- 2- Configurer son environnement pour utiliser le référentiel CVS EFICAS
- 3- Exporter les sources d'EficasV1 par la commande :
- cvs export -r TAG -d Eficas_export EficasV1
- ou TAG est le tag CVS de la version que l'on veut distribuer (par exemple V1_1p1)
- 5- Aller dans le répertoire Eficas_export
- 6- Executer le script sdist.py
- python sdist.py
- Ce qui a pour effet de creer un repertoire dist contenant la distribution
- et de la copier dans le répertoire indiqué par dir_download s'il est accessible
-
-"""
-import os,shutil,glob,sys
-import types
-
-nom_distrib="QTEficasOpenturns_V1_0"
-path_distrib=os.path.join("dist",nom_distrib)
-path_TextTools="/home/eficas/pkg/mxTools/egenix2.0.2pourWindows/mx/TextTools"
-dir_download= "/home/eficas/WWW/telechargement/eficas"
-
-def main():
- if os.path.isdir('dist'):shutil.rmtree('dist')
-
- copyfiles('.',path_distrib,['LICENSE.TERMS','INSTALL','NEWS'])
-
- copyfiles('../Editeur',os.path.join(path_distrib,'Editeur'),['*.py','faqs.txt'])
- copyfiles('../InterfaceTK',os.path.join(path_distrib,'InterfaceTK'),['*.py','faqs.txt'])
- copyfiles('../InterfaceQT',os.path.join(path_distrib,'InterfaceQT'),['*.py','faqs.txt'])
- copyfiles('../Ui',os.path.join(path_distrib,'Ui'),['*.ui','makefile'])
- copyfiles('../Openturns',os.path.join(path_distrib,'Openturns'),['*.py','*.ini'])
- copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
- copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
- copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
- copyfiles('../Accas',os.path.join(path_distrib,'Accas'),['*.py'])
- copyfiles('../Accas',os.path.join(path_distrib,'Noyau'),['*.py'])
- copyfiles('../Accas',os.path.join(path_distrib,'Validation'),['*.py'])
- # AIDE
- copyfiles('../AIDE',os.path.join(path_distrib,'AIDE'),['*.py'])
- copyfiles('../AIDE/fichiers',os.path.join(path_distrib,'AIDE','fichiers'),['*'])
- copyfiles('.',os.path.join(path_distrib,'AIDE','fichiers'),['INSTALL','NEWS'])
- copyfiles('../Editeur',os.path.join(path_distrib,'AIDE','fichiers'),['faqs.txt'])
- # ______________________
-
- copyfiles('../convert',os.path.join(path_distrib,'convert'),['*.py'])
- copyfiles('../convert/Parserv5',os.path.join(path_distrib,'convert','Parserv5'),['*.py'])
- copyfiles('../generator',os.path.join(path_distrib,'generator'),['*.py'])
- copyfiles('../Editeur/icons',os.path.join(path_distrib,'Editeur','icons'),['*.gif'])
- copyfiles('../Editeur/icons',os.path.join(path_distrib,'Editeur','icons'),['*.png'])
- copyfiles('../Editeur/Patrons/',os.path.join(path_distrib,'Editeur','Patrons'),['*.com*'])
- copyfiles('../Editeur/Patrons/OPENTURNS',os.path.join(path_distrib,'Editeur','Patrons','OPENTURNS'),['*.com*'])
-
- copyfiles('../Noyau',os.path.join(path_distrib,'Noyau'),['*.py'])
- copyfiles('../Validation',os.path.join(path_distrib,'Validation'),['*.py'])
-
-
- tarball= maketarball('dist',nom_distrib,nom_distrib)
- try:
- shutil.copy(tarball,dir_download)
- except:
- print "Repertoire de download inconnu : ",dir_download
-
-
-
-def make_dir(dir_cible):
- if type(dir_cible) is not types.StringType:
- raise "make_dir : dir_cible doit etre une string (%s)" % `dir_cible`
- head,tail=os.path.split(dir_cible)
- tails=[tail]
- while head and tail and not os.path.isdir(head):
- head,tail=os.path.split(head)
- tails.insert(0, tail)
-
- for d in tails:
- head = os.path.join(head, d)
- if not os.path.isdir(head):os.mkdir(head)
-
-
-def copyfiles(dir_origin,dir_cible,listfiles):
- if not os.path.isdir(dir_cible):make_dir(dir_cible)
- for glob_files in listfiles:
- for file in glob.glob(os.path.join(dir_origin,glob_files)):
- shutil.copy(file,dir_cible)
-
-
-def maketarball(dir_trav,dir_cible,nom_tar):
- prev=os.getcwd()
- print prev
- os.chdir(dir_trav)
- os.system("tar -cf "+nom_tar+".tar "+dir_cible)
- os.system("gzip -f9 "+nom_tar+".tar ")
- os.chdir(prev)
- return os.path.join(dir_trav,nom_tar+".tar.gz")
-
-
-main()
-
+++ /dev/null
-# Necessaire pour compatibilite avec Aster
