Aster/Cata/cataSTA74/Macro/fiabilite_mefisto.py

   1 #@ MODIF fiabilite_mefisto 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 fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global,
  25                         INFO, VERSION,
  26                         SEUIL, SEUIL_TYPE,
  27                         VARIABLE,
  28                         valeurs_lois,
  29                         **args ) :
  30 #
  31 #    valeurs_lois est un dictionnaire indexé sur les variables.
  32 #    Chaque case, valeurs_lois[m], est un dictionnaire contenant :
  33 #    d["v_moy_physique"] = valeur moyenne physique
  34 #    d["v_moy_loi"] = valeur moyenne de la loi
  35 #    d["v_min_loi"] = valeur minimale de la loi
  36 #    d["v_max_loi"] = valeur maximale de la loi
  37 #    d["sigma_loi"] = ecart type de la loi
  38 #
  39 #    args est le dictionnaire des arguments optionnels
  40 #    args.keys() est la liste des mots-clés
  41 #    args.keys()[0] est la premiere valeur de cette liste
  42 #    args.keys()[1:] est la liste des valeurs suivantes dans cette liste
  43 #    args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
  44 #
  45   """ Ecriture des données spécifiques à MEFISTO. """
  46 #
  47   from Macro import fiabilite_fichier
  48   import os
  49   import string
  50 #
  51 #____________________________________________________________________
  52 #
  53 # 1. Préalables
  54 #____________________________________________________________________
  55 #
  56 #
  57   messages_erreur = { 0 : "Tout va bien",
  58                       1 : "Fichier inconnu.",
  59                       2 : "Problème d'ouverture de fichier.",
  60                      10 : "Problème d'ouverture de fichier.",
  61                      11 : "Problème de fermeture de fichier.",
  62                      20 : "Problème d'impression de fichier.",
  63                      50 : "Donnée inacceptable.",
  64                     100 : "Erreur." }
  65 #
  66   trad_oui_non = { "OUI" : 1,
  67                    "NON" : 0 }
  68 #
  69   erreur = 0
  70 #
  71   while not erreur :
  72 #
  73 #____________________________________________________________________
  74 #
  75 # 2. Les fichiers pour le logiciel de fiabilité
  76 #    Ils sont créés dans le répertoire d'exécution du logiciel de fiabilité, avec leurs noms officiels
  77 #____________________________________________________________________
  78 #
  79 #
  80     fic_dataMenu  = "dataMenu"
  81     fic_dataStoch = "dataStoch"
  82     fic_dataNum   = "dataNum"
  83     fic_dataGrad  = "dataGrad"
  84 #
  85 #____________________________________________________________________
  86 #
  87 # 3. Construction du fichier 'dataMenu'
  88 #____________________________________________________________________
  89 #
  90 # 3.1 ==> Ouverture du fichier
  91 #
  92     f_menu = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataMenu, INFO )
  93     erreur = f_menu.Ouvre_Fichier ( "w" )
  94     if erreur :
  95       break
  96 #
  97 # 3.2 ==> Ecriture des données nécessaires
  98 #
  99     f_menu.Ecrit_Titre ("MENU DU PROGRAMME MEFISTO")
 100     f_menu.Ecrit_Titre ("1 <=> OUI et 0 <=> NON (entiers)")
 101 #
 102     f_menu.Ecrit_Titre ("Recherche du point de conception")
 103     aux = trad_oui_non[args["RECH_PT_CONCEPT"]]
 104     f_menu.Ecrit_Valeurs (aux)
 105 #
 106     f_menu.Ecrit_Titre ("First Order Reliability Analyses")
 107     aux = trad_oui_non[args["METHODE_FORM"]]
 108     f_menu.Ecrit_Valeurs (aux)
 109 #
 110     f_menu.Ecrit_Titre ("Second Order Reliability Analyses")
 111     aux = trad_oui_non[args["METHODE_SORM"]]
 112     f_menu.Ecrit_Valeurs (aux)
 113 #
 114     f_menu.Ecrit_Titre ("Importance Sampling Analyses")
 115     aux = trad_oui_non[args["TIRAGE_IMPORTANCE"]]
 116     f_menu.Ecrit_Valeurs (aux)
 117 #
 118     f_menu.Ecrit_Titre ("Optimality Test (1) : Hessian Test")
 119     aux = trad_oui_non[args["T_HESSIEN"]]
 120     f_menu.Ecrit_Valeurs (aux)
 121 #
 122     f_menu.Ecrit_Titre ("Optimality Test (2) : Sphere Test")
 123     aux = trad_oui_non[args["T_SPHERE"]]
 124     f_menu.Ecrit_Valeurs (aux)
 125 #
 126     f_menu.Ecrit_Titre ("Optimality Test (3) : Strong Max Test")
 127     aux = trad_oui_non[args["T_MAXIMUM_FORT"]]
 128     f_menu.Ecrit_Valeurs (aux)
 129 #
 130     f_menu.Ecrit_Titre ("Experiment Plan")
 131     aux = trad_oui_non[args["PLAN_EXPERIENCE"]]
 132     f_menu.Ecrit_Valeurs (aux)
 133 #
 134     f_menu.Ecrit_Titre ("Polynomial Taylor Approximation (order 2)")
 135     aux = trad_oui_non[args["POLYNOME_TAYLOR"]]
 136     f_menu.Ecrit_Valeurs (aux)
 137 #
 138 # 3.3 ==> Fermeture du fichier
 139 #
 140     erreur = f_menu.Ferme_Fichier ( )
 141     if erreur :
 142       break
 143 #
 144     if INFO >= 2 :
 145       erreur = f_menu.Imprime_Fichier ( )
 146       if erreur :
 147         break
 148 #
 149 #____________________________________________________________________
 150 #
 151 # 4. Construction du fichier "dataStoch"
 152 #____________________________________________________________________
 153 #
 154 # 4.1 ==> Ouverture du fichier
 155 #
 156     f_stoch = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataStoch, INFO )
 157     erreur = f_stoch.Ouvre_Fichier ( "w" )
 158     if erreur :
 159       break
 160 #
 161 # 4.2 ==> Nombre d'occurence de VARIABLE
 162 #
 163     nb_occu_variable = len(VARIABLE)
 164 #
 165 # 4.3 ==> Ecriture des données nécessaires
 166 #
 167     f_stoch.Ecrit_Titre ("Code name")
 168     aux=string.replace(VERSION,"_",".")
 169     aux=string.replace(aux,"N","n")
 170     aux=string.replace(aux,"V","v")
 171     f_stoch.Ecrit_Valeurs ( "aster_" + aux )
 172 #
 173     aux = [ "Gradients evaluated by the code" ]
 174     aux.append("1 : Au moins 1 ; 0 : aucun")
 175     f_stoch.Ecrit_Titre (aux)
 176     gradient = 0
 177     for m in VARIABLE :
 178       if m["GRADIENT"] == "OUI" : gradient = 1
 179     f_stoch.Ecrit_Valeurs (gradient)
 180 #
 181     f_stoch.Ecrit_Titre ("Variates number")
 182     f_stoch.Ecrit_Valeurs ( nb_occu_variable )
 183 #
 184     aux = [ "Stochastic Variates" ]
 185     aux.append("1: Uniforme (min, max)")
 186     aux.append("2: Normal (mean, std dev)")
 187     aux.append("3: LogNormal (mean, std dev, min)")
 188     aux.append("4: Normal Truncated (mean, std dev, min, max)")
 189     f_stoch.Ecrit_Titre (aux)
 190 #
 191     for m in VARIABLE :
 192 #
 193       d = valeurs_lois[m]
 194       if m["LOI"] == "UNIFORME" :
 195         f_stoch.Ecrit_Valeurs ( [ m["NOM"],  1 , d["v_min_loi"] , d["v_max_loi"] ] )
 196       elif m["LOI"] == "NORMALE" :
 197         f_stoch.Ecrit_Valeurs ( [ m["NOM"],  2 , d["v_moy_loi"] , d["sigma_loi"] ] )
 198       elif m["LOI"] == "LOGNORMALE" :
 199         f_stoch.Ecrit_Valeurs ( [ m["NOM"],  3 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] ] )
 200       elif m["LOI"] == "NORMALE_TRONQUEE" :
 201         f_stoch.Ecrit_Valeurs ( [ m["NOM"],  4 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] , d["v_max_loi"] ] )
 202       else :
 203         erreur = 50
 204 #
 205     if erreur :
 206       break
 207 #
 208     f_stoch.Ecrit_Titre ("Initial Points")
 209     for m in VARIABLE :
 210       if m["POINT_INI"] is None :
 211         aux = valeurs_lois[m]["v_moy_physique"]
 212       else :
 213         aux = m["POINT_INI"]
 214       f_stoch.Ecrit_Valeurs ( aux )
 215 #
 216     f_stoch.Ecrit_Titre ("Reference Points")
 217     for m in VARIABLE :
 218       if m["POINT_REF"] is None :
 219         aux = valeurs_lois[m]["v_moy_physique"]
 220       else :
 221         aux = m["POINT_REF"]
 222       f_stoch.Ecrit_Valeurs ( aux )
 223 #
 224     f_stoch.Ecrit_Titre ("Design Points")
 225     for m in VARIABLE :
 226       if args["RECH_PT_CONCEPT"] == "OUI" :
 227         aux = 1792.
 228       elif m["POINT_CONCEPT"] is None :
 229         aux = valeurs_lois[m]["v_moy_physique"]
 230       else :
 231         aux = m["POINT_CONCEPT"]
 232       f_stoch.Ecrit_Valeurs ( aux )
 233 #
 234     f_stoch.Ecrit_Titre ("Correlation matrix fictive")
 235     for m in range(nb_occu_variable) :
 236       aux = [ ]
 237       for n in range(nb_occu_variable) :
 238         aux.append(args["MATRICE"][n + m*nb_occu_variable])
 239       f_stoch.Ecrit_Valeurs ( aux )
 240 #
 241     f_stoch.Ecrit_Titre ("Parameter threshold value")
 242     if SEUIL_TYPE == "MAXIMUM" :
 243       aux = SEUIL
 244     else :
 245       aux = -SEUIL
 246     f_stoch.Ecrit_Valeurs ( aux )
 247 #
 248 # 4.4 ==> Fermeture du fichier
 249 #
 250     erreur = f_stoch.Ferme_Fichier ( )
 251     if erreur :
 252       break
 253 #
 254     if INFO >= 2 :
 255       erreur = f_stoch.Imprime_Fichier ( )
 256       if erreur :
 257         break
 258 #
 259 #____________________________________________________________________
 260 #
 261 # 5. Construction du fichier 'dataNum'
 262 #____________________________________________________________________
 263 #
 264 # 5.1 ==> Ouverture du fichier
 265 #
 266     f_num = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataNum, INFO )
 267     erreur = f_num.Ouvre_Fichier ( "w" )
 268     if erreur :
 269       break
 270 #
 271 # 5.2 ==> Ecriture des données nécessaires
 272 #
 273     f_num.Ecrit_Titre ("Parameters : EpsU, EpsG, Tau, Omega, iterMax")
 274     if args["RECH_PT_CONCEPT"] == "OUI" :
 275       f_num.Ecrit_Valeurs (args["EPSILON_U"])
 276       f_num.Ecrit_Valeurs (args["EPSILON_G"])
 277       f_num.Ecrit_Valeurs (args["TAU"])
 278       f_num.Ecrit_Valeurs (args["OMEGA"])
 279       f_num.Ecrit_Valeurs (args["ITER_MAX"])
 280     else :
 281       aux = 0.1848
 282       for k in range(5) :
 283         f_num.Ecrit_Valeurs (aux)
 284 #
 285     f_num.Ecrit_Titre ("Parameters : hgrad, hhess")
 286     f_num.Ecrit_Valeurs (args["HGRAD"])
 287     f_num.Ecrit_Valeurs (args["HHESS"])
 288 #
 289     aux = [ "Parameter Optimality Test(sphere)" ]
 290     aux.append("1: Parametric Method (Point Number in each direction)")
 291     aux.append("2: Gaussian Method (Total Point Number)")
 292     aux.append("3: Rejection Method (Total Point Number)")
 293     f_num.Ecrit_Titre (aux)
 294 #
 295     if args["T_SPHERE"] == "OUI" :
 296 #
 297       if args["METHODE_TEST"] == "PARAMETRIQUE" :
 298         aux1 = 1
 299       elif args["METHODE_TEST"] == "GAUSSIENNE" :
 300         aux1 = 2
 301       elif args["METHODE_TEST"] == "REJECTION" :
 302         aux1 = 3
 303       else :
 304         self.cr.warn("METHODE DE TEST : "+args["METHODE_TEST"])
 305         erreur = 50
 306         break
 307 #
 308       aux2 = args["NB_POINT"]
 309 #
 310     else :
 311 #
 312 #     remarque : il faut mettre une valeur plausible en aux1, sinon plantage violent ...
 313       aux1 = 1
 314       aux2 = 1789
 315 #
 316     f_num.Ecrit_Valeurs ( [ aux1 , aux2 ] )
 317 #
 318     aux = [ "Parameters : alpha, beta" ]
 319     aux.append("alpha: common net")
 320     aux.append("beta: extreme net")
 321     f_num.Ecrit_Titre (aux)
 322     if args["PLAN_EXPERIENCE"] == "OUI" :
 323       aux1 = args["ALPHA"]
 324       aux2 = args["BETA"]
 325     else :
 326       aux1 = 1789.0
 327       aux2 = 1789.0
 328     f_num.Ecrit_Valeurs ( aux1 )
 329     f_num.Ecrit_Valeurs ( aux2 )
 330 #
 331     f_num.Ecrit_Titre ("Parameters Strong Max Test : cosLim, dProb")
 332     if args["T_MAXIMUM_FORT"] == "OUI" :
 333       aux1 = args["COS_LIM"]
 334       aux2 = args["DPROB"]
 335     else :
 336       aux1 = 0.1789
 337       aux2 = 0.1789
 338     f_num.Ecrit_Valeurs ( aux1 )
 339     f_num.Ecrit_Valeurs ( aux2 )
 340 #
 341     f_num.Ecrit_Titre ("Parameter Importance Samplings : Simulation Number")
 342     if args["TIRAGE_IMPORTANCE"] == "OUI" :
 343       aux = args["NB_SIMULATION"]
 344     else :
 345       aux = 1945
 346     f_num.Ecrit_Valeurs ( aux )
 347 #
 348 # 5.3 ==> Fermeture du fichier
 349 #
 350     erreur = f_num.Ferme_Fichier ( )
 351     if erreur :
 352       break
 353 #
 354     if INFO >= 2 :
 355       erreur = f_num.Imprime_Fichier ( )
 356       if erreur :
 357         break
 358 #
 359 #____________________________________________________________________
 360 #
 361 # 6. Construction du fichier 'dataGrad'
 362 #____________________________________________________________________
 363 #
 364 # 6.1 ==> Création du fichier
 365 #
 366     f_grad = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataGrad, INFO )
 367     erreur = f_grad.Ouvre_Fichier ( "w" )
 368     if erreur :
 369       break
 370 #
 371 # 6.2 ==> Ecriture des données nécessaires
 372 #
 373     f_grad.Ecrit_Titre ("Commentaires")
 374 #
 375     for m in VARIABLE :
 376       f_grad.Ecrit_Commentaires (m["NOM"])
 377       if m["GRADIENT"] == "OUI" :
 378         gradient = 1
 379         increment = 0.0
 380       else :
 381         gradient = 0
 382         increment = m["INCREMENT"]
 383       aux = [gradient,increment]
 384       f_grad.Ecrit_Valeurs (aux)
 385 #
 386 # 6.3 ==> Fermeture du fichier
 387 #
 388     erreur = f_grad.Ferme_Fichier ( )
 389     if erreur :
 390       break
 391 #
 392     if INFO >= 2 :
 393       erreur = f_grad.Imprime_Fichier ( )
 394       if erreur :
 395         break
 396 #
 397 #____________________________________________________________________
 398 #
 399 # 7. C'est fini !
 400 #____________________________________________________________________
 401 #
 402     break
 403 #
 404   if erreur :
 405     if not messages_erreur.has_key(erreur) :
 406       erreur = 100
 407     self.cr.warn(messages_erreur[erreur])
 408     erreur = 11
 409 #
 410   return erreur
 411 #
 412 ##########################  Fin de la fonction##################################
 413 #
 414 ##########################   Auto-test##################################
 415 #
 416 if __name__ == "__main__" :
 417 #
 418   import os
 419   import sys
 420   import tempfile
 421 #
 422   Rep_Calc_LOGICIEL_global = tempfile.mktemp()
 423   os.mkdir(Rep_Calc_LOGICIEL_global)
 424 #
 425   INFO = 2
 426   VERSION = "V3_2"
 427   SEUIL = 1789.
 428   SEUIL_TYPE = "MAXIMUM"
 429   VARIABLE = []
 430   args = {}
 431   valeurs = {}
 432 #
 433   erreur = fiabilite_mefisto ( None, Rep_Calc_LOGICIEL_global,
 434                         INFO, VERSION,
 435                         SEUIL, SEUIL_TYPE,
 436                         VARIABLE,
 437                         valeurs,
 438                         **args )
 439 ###  print "Erreur = ", erreur
 440   Liste = os.listdir(Rep_Calc_LOGICIEL_global)
 441 #
 442   for nomfic in Liste :
 443     fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic)
 444     os.chmod  (fic_total,0755)
 445     os.remove (fic_total)
 446   os.rmdir (Rep_Calc_LOGICIEL_global)
 447 #
 448   sys.exit("blabla")