Aster/Cata/cataSTA10/Macro/fiabilite_mefisto.py

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