Aster/Cata/cataSTA74/Macro/macr_fiabilite_ops.py

   1 #@ MODIF macr_fiabilite_ops Macro  DATE 14/09/2004   AUTEUR MCOURTOI M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2004  EDF R&D                  WWW.CODE-ASTER.ORG
   6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   9 # (AT YOUR OPTION) ANY LATER VERSION.
  10 #
  11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  15 #
  16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  19 # ======================================================================
  20
  21
  22 # RESPONSABLE GNICOLAS G.NICOLAS
  23 #
  24 def macr_fiabilite_ops(self, INFO,
  25                        LOGICIEL, VERSION,
  26                        UNITE_ESCL, MESS_ASTER,
  27                        SEUIL, SEUIL_TYPE,
  28                        VARIABLE,
  29                        **args ) :
  30 #
  31 #    args est le dictionnaire des arguments optionnels
  32 #    args.keys() est la liste des mots-clés
  33 #    args.keys()[0] est la premiere valeur de cette liste
  34 #    args.keys()[1:] est la liste des valeurs suivantes dans cette liste
  35 #    args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
  36 ###  print args
  37 ###  print args.keys()
  38 ###  if len (args.keys())>0 : print args.keys()[0]
  39 #
  40   """ Macro-commande réalisant le pilotage du logiciel de fiabilite. """
  41 #
  42 # On charge les modules nécessaires
  43   from Accas import _F
  44   from Macro import fiabilite_mefisto
  45   import aster
  46   import os
  47   import string
  48   import sys
  49   import Numeric
  50 #
  51 #____________________________________________________________________
  52 #
  53 # 1. Préalables
  54 #____________________________________________________________________
  55 #
  56 # 1.1 ==> La macro compte pour 1 dans l'exécution des commandes
  57 #
  58   self.set_icmd(1)
  59 #
  60 # 1.2 ==> On importe les définitions des commandes Aster utilisées
  61 #         dans la macro
  62 #
  63   EXEC_LOGICIEL  = self.get_cmd("EXEC_LOGICIEL")
  64   DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
  65 #
  66 # 1.3 ==> Le nom du programme de fiabilite à lancer
  67 #
  68   repertoire_outils = aster.repout()
  69   fiabilite      = repertoire_outils + "fiabilite"
  70 #
  71 # 1.4 ==> Initialisations
  72 #
  73   erreur = 0
  74   erreur_partiel = [0]
  75   Rep_Calc_ASTER = os.getcwd()
  76   Nom_Exec_ASTER = sys.executable
  77 #
  78   messages_erreur = { 0 : "Tout va bien",
  79                       1 : "Impossible de créer le répertoire de travail pour le logiciel de fiabilité.",
  80                       2 : "Probleme d'ouverture du fichier.",
  81                      10 : "Erreur dans le choix du logiciel de fiabilité.",
  82                      11 : "Erreur dans la création des données pour le logiciel de fiabilité.",
  83                     100 : "Erreur." }
  84 #
  85   while not erreur :
  86 #
  87 #____________________________________________________________________
  88 #
  89 # 2. Répertoires et fichiers
  90 #____________________________________________________________________
  91 #
  92 # 2.1. ==> Création du répertoire pour l'exécution du logiciel de fiabilité
  93 #
  94     Nom_Rep_local = "tmp_fiabilite"
  95     Rep_Calc_LOGICIEL_local = os.path.join(".",Nom_Rep_local)
  96     Rep_Calc_LOGICIEL_global = os.path.join(Rep_Calc_ASTER,Nom_Rep_local)
  97 #
  98     try :
  99       os.mkdir(Rep_Calc_LOGICIEL_global)
 100     except os.error,erreur_partiel :
 101       self.cr.warn("Code d'erreur de mkdir : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
 102       self.cr.fatal("Impossible de créer le répertoire de travail pour le logiciel de fiabilité : "+Rep_Calc_LOGICIEL_global)
 103       erreur = erreur + 1
 104       break
 105 #
 106 # 2.2. ==> On crée un fichier annexe pour transmettre des données à la procédure
 107 #          de lancement des calculs ASTER par le LOGICIEL.
 108 #          Ce fichier est créé dans le répertoire d'exécution du logiciel de fiabilité.
 109 #          On fait ainsi car les arguments passés ont du mal à transiter via l'exécutable.
 110 #          On stocke :
 111 #          1. Le niveau d'information
 112 #          2. L'unité logique associée au jeu de commandes déterministes
 113 #          3. La gestion des sorties ASTER
 114 #          4. Le nom de l'exécutable ASTER
 115 #          5. Le type de seuil du problème (maximum ou minimum)
 116 #
 117     fic_Info_ASTER = os.path.join(Rep_Calc_LOGICIEL_global,"InfoExecASTER")
 118     try :
 119       f_execAster = open(fic_Info_ASTER, "w")
 120     except os.error,erreur_partiel :
 121       self.cr.warn("Fichier : "+fic_Info_ASTER)
 122       self.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
 123       erreur = 2
 124       break
 125 #
 126     f_execAster.write(str(INFO)+"\n")
 127     f_execAster.write(str(UNITE_ESCL)+"\n")
 128     f_execAster.write(str(MESS_ASTER)+"\n")
 129     f_execAster.write(str(Nom_Exec_ASTER)+"\n")
 130     f_execAster.write(str(SEUIL_TYPE))
 131     f_execAster.close()
 132     fichier = open (fic_Info_ASTER,"r")
 133 #
 134     if INFO >= 2 :
 135       print "\nContenu du fichier " + fic_Info_ASTER," :"
 136       les_lignes = fichier.readlines()
 137       fichier.close()
 138       print les_lignes, "\n"
 139 #
 140 #____________________________________________________________________
 141 #
 142 # 3. Les variables par defaut
 143 #____________________________________________________________________
 144 #
 145 # 3.1. ==> Dictionnaire des valeurs physiques et liées à la loi
 146 #
 147     valeurs_lois = { }
 148 #
 149     for m in VARIABLE :
 150 #
 151       v_moy_physique = None
 152       v_moy_loi = None
 153       v_min_loi = None
 154       v_max_loi = None
 155       sigma_loi = None
 156 #
 157 # 3.1.1. ==> loi uniforme : transfert des min et max
 158 #            on définit une moyennne comme étant la médiane des extremes.
 159 #
 160       if m["LOI"] == "UNIFORME" :
 161         v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] )
 162         v_min_loi = m["VALE_MIN"]
 163         v_max_loi = m["VALE_MAX"]
 164 #
 165 # 3.1.2. ==> loi normale : transfert des moyennne et écart-type.
 166 #
 167       elif m["LOI"] == "NORMALE" :
 168         v_moy_loi = m["VALE_MOY"]
 169         v_moy_physique = v_moy_loi
 170         sigma_loi = m["ECART_TYPE"]
 171 #
 172 # 3.1.3. ==> loi lognormale : identité du min, conversion pour le reste
 173 #
 174       elif m["LOI"] == "LOGNORMALE" :
 175         v_min_loi = m["VALE_MIN"]
 176         if m["VALE_MOY_PHY"] is None :
 177           v_moy_loi = m["VALE_MOY"]
 178           sigma_loi = m["ECART_TYPE"]
 179           aux = Numeric.exp(0.5*sigma_loi*sigma_loi+v_moy_loi)
 180           v_moy_physique = v_min_loi + aux
 181         else :
 182           v_moy_physique = m["VALE_MOY_PHY"]
 183           aux = m["ECART_TYPE_PHY"]/(m["VALE_MOY_PHY"]-m["VALE_MIN"])
 184           aux1 = 1. + aux*aux
 185           aux2 = Numeric.sqrt(aux1)
 186           v_moy_loi = Numeric.log((m["VALE_MOY_PHY"]-m["VALE_MIN"])/aux2)
 187           aux2 = Numeric.log(aux1)
 188           sigma_loi = Numeric.sqrt(aux2)
 189 #
 190 # 3.1.4. ==> loi normale tronquée : transfert des moyenne, mini/maxi et écart-type
 191 #            on définit une moyennne comme étant la médiane des extremes.
 192 #
 193       else :
 194         v_moy_loi = m["VALE_MOY"]
 195         v_min_loi = m["VALE_MIN"]
 196         v_max_loi = m["VALE_MAX"]
 197         sigma_loi = m["ECART_TYPE"]
 198         v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] )
 199 #
 200       d = { }
 201       d["v_moy_physique"] = v_moy_physique
 202       d["v_moy_loi"] = v_moy_loi
 203       d["v_min_loi"] = v_min_loi
 204       d["v_max_loi"] = v_max_loi
 205       d["sigma_loi"] = sigma_loi
 206       valeurs_lois[m] = d
 207 #
 208 #____________________________________________________________________
 209 #
 210 # 4. Création des fichiers pour le logiciel de fiabilite
 211 #____________________________________________________________________
 212 #
 213     if ( LOGICIEL == "MEFISTO" ) :
 214 #
 215 # 4.1. ==> MEFISTO
 216 #
 217       erreur = fiabilite_mefisto.fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global,
 218                                                      INFO, VERSION,
 219                                                      SEUIL, SEUIL_TYPE,
 220                                                      VARIABLE,
 221                                                      valeurs_lois,
 222                                                      **args )
 223 #
 224 # 4.2. ==> Erreur si autre logiciel
 225 #
 226     else :
 227 #
 228      self.cr.warn("Logiciel de fiabilité : "+LOGICIEL)
 229      erreur = 10
 230 #
 231 # 4.3. ==> Arret en cas d'erreur
 232 #
 233     if erreur :
 234       break
 235 #
 236 #____________________________________________________________________
 237 #
 238 # 5. Ecriture de la commande d"exécution du logiciel de fiabilité
 239 #
 240 #   Remarque : dans la donnée de la version du logiciel de fiabilité, il faut remplacer
 241 #              le _ de la donnée par un ., qui
 242 #              est interdit dans la syntaxe du langage de commandes ASTER
 243 #   Remarque : il faut remplacer le N majuscule de la donnee par
 244 #              un n minuscule, qui est interdit dans la syntaxe du langage
 245 #              de commandes ASTER
 246 #____________________________________________________________________
 247 #
 248 #
 249     VERSION=string.replace(VERSION,"_",".")
 250     VERSION=string.replace(VERSION,"N","n")
 251 #
 252     EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_LOGICIEL_global), # nom du repertoire
 253                                 _F(NOM_PARA=LOGICIEL),             # nom du logiciel de fiabilité
 254                                 _F(NOM_PARA=VERSION),         # version du logiciel de fiabilité
 255                                ),
 256                     LOGICIEL = fiabilite
 257                    )
 258 #
 259 #--------------------------------------------------------------------
 260 # 6. C'est fini !
 261 #--------------------------------------------------------------------
 262 #
 263     break
 264 #
 265 # 6.1. ==> Arret en cas d'erreur
 266 #
 267   if erreur :
 268     if not messages_erreur.has_key(erreur) :
 269       erreur = 100
 270     self.cr.fatal(messages_erreur[erreur])
 271 #
 272 # 6.2. ==> Si tout va bien, on crée une liste de réels pour le retour
 273 #          A terme, il serait intéressant d'y mettre les résultats
 274 #          de l'analyse fiabiliste. Pour le moment, on se contente de
 275 #          mettre une valeur nulle qui permet de faire un test dans
 276 #          les commandes appelantes.
 277 #
 278   aux = [float(erreur)]
 279 #
 280   self.DeclareOut("nomres",self.sd)
 281   nomres = DEFI_LIST_REEL( VALE = aux , INFO = 1 )
 282 #
 283   return
 284 #
 285 ##########################  Fin de la fonction##################################
 286 #
 287 ##########################   Auto-test##################################
 288 #
 289 if __name__ == "__main__" :
 290 #
 291   import os
 292   import sys
 293   import tempfile
 294 #
 295   Rep_Calc_LOGICIEL_global = tempfile.mktemp()
 296   os.mkdir(Rep_Calc_LOGICIEL_global)
 297 #
 298   classe = None
 299   INFO = 2
 300   LOGICIEL = "MEFISTO"
 301   VERSION = "V3_2"
 302   UNITE_ESCL = 38
 303   MESS_ASTER = "DERNIER"
 304   SEUIL = 1789.
 305   SEUIL_TYPE = "MAXIMUM"
 306   VARIABLE = []
 307   args = {}
 308 #
 309   lr8 = macr_fiabilite_ops(classe, INFO,
 310                        LOGICIEL, VERSION,
 311                        UNITE_ESCL, MESS_ASTER,
 312                        SEUIL, SEUIL_TYPE,
 313                        VARIABLE,
 314                        **args )
 315 ###  print "lr8 = ", lr8
 316   Liste = os.listdir(Rep_Calc_LOGICIEL_global)
 317 #
 318   for nomfic in Liste :
 319     fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic)
 320     os.chmod  (fic_total,0755)
 321     os.remove (fic_total)
 322   os.rmdir (Rep_Calc_LOGICIEL_global)
 323 #
 324   sys.exit("blabla")