Aster/Cata/cataSTA7/Macro/recal.py

   1 #@ MODIF recal Macro  DATE 05/07/2006   AUTEUR CIBHHPD L.SALMONA
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2002  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
  23
  24 import string
  25 import copy
  26 import Numeric
  27 import types
  28 import Gnuplot
  29 import Cata
  30 from Cata.cata import INCLUDE,DETRUIRE
  31 from Accas import _F
  32 from Utilitai.extract import EXTRACT
  33
  34 import os
  35
  36
  37 #_____________________________________________
  38 #
  39 # DIVERS UTILITAIRES POUR LA MACRO
  40 #_____________________________________________
  41
  42
  43 # Transforme les donneés entrées par l'utilsateur en tableau Numeric
  44 def transforme_list_Num(parametres,res_exp):
  45    dim_para = len(parametres)  #donne le nb de parametres
  46    val_para = Numeric.zeros(dim_para,Numeric.Float)
  47    borne_inf = Numeric.zeros(dim_para,Numeric.Float)
  48    borne_sup = Numeric.zeros(dim_para,Numeric.Float)
  49    para = []
  50    for i in range(dim_para):
  51       para.append(parametres[i][0])
  52       val_para[i] = parametres[i][1]
  53       borne_inf[i] = parametres[i][2]
  54       borne_sup[i] = parametres[i][3]
  55    return para,val_para,borne_inf,borne_sup
  56
  57 def mes_concepts(list_concepts=[],base=None):
  58   # Fonction qui liste les concepts créés
  59    for e in base.etapes:
  60       if e.nom in ('INCLUDE','MACR_RECAL',) :
  61         list_concepts=list(mes_concepts(list_concepts=list_concepts,base=e))
  62       elif (e.sd != None) and (e.parent.nom=='INCLUDE') :
  63         nom_concept=e.sd.get_name()
  64         if not(nom_concept in list_concepts):
  65           list_concepts.append( nom_concept )
  66    return tuple(list_concepts)
  67
  68
  69 def detr_concepts(self):
  70      liste_concepts=mes_concepts(base=self.parent)
  71      for e in liste_concepts:
  72         nom = string.strip(e)
  73         DETRUIRE( CONCEPT =self.g_context['_F'](NOM = nom),INFO=1)
  74         if self.jdc.g_context.has_key(nom) : del self.jdc.g_context[nom]
  75      del(liste_concepts)
  76
  77
  78 def calcul_F(self,UL,para,val,reponses):
  79       fic = open('fort.'+str(UL),'r')
  80       #On stocke le contenu de fort.UL dans la variable fichier qui est un string
  81       fichier=fic.read()
  82       #On stocke le contenu initial de fort.UL dans la variable fichiersauv
  83       fichiersauv=copy.copy(fichier)
  84       fic.close()
  85
  86       #Fichier_Resu est une liste ou l'on va stocker le fichier modifié
  87       #idée générale :on délimite des 'blocs' dans fichier
  88       #on modifie ou non ces blocs suivant les besoins
  89       #on ajoute ces blocs dans la liste Fichier_Resu
  90       Fichier_Resu=[]
  91
  92       try:
  93          #cherche l'indice de DEBUT()
  94          index_deb=string.index(fichier,'DEBUT(')
  95          while( fichier[index_deb]!='\n'):
  96             index_deb=index_deb+1
  97          #on restreind fichier en enlevant 'DEBUT();'
  98          fichier = fichier[index_deb+1:]
  99       except :
 100          #on va dans l'except si on a modifié le fichier au moins une fois
 101          pass
 102
 103       try:
 104          #cherche l'indice de FIN()
 105          index_fin = string.index(fichier,'FIN(')
 106          #on restreind fichier en enlevant 'FIN();'
 107          fichier = fichier[:index_fin]
 108       except : pass
 109       #--------------------------------------------------------------------------------
 110       #on cherche à délimiter le bloc des parametres dans le fichier
 111       #Tout d'abord on cherche les indices  d'apparition des paras dans le fichier
 112       #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise
 113       #avec le meme ordre de son fichier de commande
 114       index_para = Numeric.zeros(len(para))
 115       for i in range(len(para)):
 116          index_para[i] = string.index(fichier,para[i])
 117       #On range les indices par ordre croissant afin de déterminer
 118       #les indice_max et indice_min
 119       index_para = Numeric.sort(index_para)
 120       index_first_para = index_para[0]
 121       index_last_para = index_para[len(index_para)-1]
 122
 123
 124       #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation
 125       bloc_inter ='\n'
 126       for i in range(len(para)-1):
 127          j = index_para[i]
 128          k = index_para[i+1]
 129          while(fichier[j]!= '\n'):
 130             j=j+1
 131          bloc_inter=bloc_inter + fichier[j:k] + '\n'
 132
 133       #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para
 134       i = index_last_para
 135       while(fichier[i] != '\n'):
 136          i = i + 1
 137       index_last_para  = i
 138       #on délimite les blocs suivants:
 139       pre_bloc = fichier[:index_first_para]       #fichier avant premier parametre
 140       post_bloc = fichier[ index_last_para+ 1:]    #fichier après dernier parametre
 141
 142       #on ajoute dans L tous ce qui est avant le premier paramètre
 143       Fichier_Resu.append(pre_bloc)
 144       Fichier_Resu.append('\n')
 145       #On ajoute la nouvelle valeur des parametres
 146       dim_para=len(para)
 147       for j in range(dim_para):
 148          Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n')
 149       #On ajoute à Fichier_Resu tous ce qui est entre les parametres
 150       Fichier_Resu.append(bloc_inter)
 151
 152       Fichier_Resu.append(post_bloc)
 153       #--------------------------------------------------------------------------------
 154       #on va ajouter la fonction EXTRACT
 155       #et on stocke les réponses calculées dans la liste Lrep
 156       #qui va etre retournée par la fonction calcul_F
 157       self.g_context['Lrep'] = []
 158       Fichier_Resu.append('Lrep=[]'+'\n')
 159       for i in range(len(reponses)):
 160          Fichier_Resu.append('_F_ = EXTRACT('+str(reponses[i][0])+','+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n')
 161          Fichier_Resu.append('Lrep.append(_F_)'+'\n')
 162
 163       #ouverture du fichier fort.3 et mise a jour de celui ci
 164       x=open('fort.'+str(UL),'w')
 165       x.writelines('from Accas import _F \nfrom Cata.cata import * \n')
 166       x.writelines(Fichier_Resu)
 167       x.close()
 168       del(Fichier_Resu)
 169       del(pre_bloc)
 170       del(post_bloc)
 171       del(fichier)
 172
 173       INCLUDE(UNITE = UL)
 174       detr_concepts(self)
 175       # on remet le fichier dans son etat initial
 176       x=open('fort.'+str(UL),'w')
 177       x.writelines(fichiersauv)
 178       x.close()
 179       return self.g_context['Lrep']
 180
 181 #_____________________________________________
 182 #
 183 # IMPRESSIONS GRAPHIQUES
 184 #_____________________________________________
 185
 186 def graphique(L_F,res_exp,reponses,iter,UL_out,interactif):
 187    graphe=[]
 188    impr=Gnuplot.Gnuplot()
 189    Gnuplot.GnuplotOpts.prefer_inline_data=1
 190    impr('set data style linespoints')
 191    impr('set grid')
 192    impr('set pointsize 2.')
 193    impr('set terminal postscript color')
 194    impr('set output "fort.'+str(UL_out)+'"')
 195    for i in range(len(L_F)):
 196          if interactif:
 197             graphe.append(Gnuplot.Gnuplot(persist=0))
 198             graphe[i]('set data style linespoints')
 199             graphe[i]('set grid')
 200             graphe[i]('set pointsize 2.')
 201             graphe[i].xlabel(reponses[i][1])
 202             graphe[i].ylabel(reponses[i][2])
 203             graphe[i].title(reponses[i][0]+'  Iteration '+str(iter))
 204             graphe[i].plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
 205             graphe[i]('pause 5')
 206 #
 207          impr.xlabel(reponses[i][1])
 208          impr.ylabel(reponses[i][2])
 209          impr.title(reponses[i][0]+'  Iteration '+str(iter))
 210          impr.plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
 211
 212
 213 #_____________________________________________
 214 #
 215 # CONTROLE DES ENTREES UTILISATEUR
 216 #_____________________________________________
 217
 218 def erreur_de_type(code_erreur,X):
 219    #code_erreur ==0 --> X est une liste
 220    #code erreur ==1 --> X est un char
 221    #code erreur ==2 --> X est un float
 222    #test est un boolean (test = 0 défaut et 1 si un test if est verifier
 223    txt=""
 224    if(code_erreur == 0 ):
 225       if type(X) is not types.ListType:
 226          txt="\nCette entrée: " +str(X)+" n'est pas une liste valide"
 227    if(code_erreur == 1 ):
 228       if type(X) is not types.StringType:
 229          txt="\nCette entrée: " +str(X)+" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python"
 230    if(code_erreur == 2 ):
 231       if type(X) is not types.FloatType:
 232          txt="\nCette entrée:  " +str(X)+" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python"
 233    return txt
 234
 235
 236 def erreur_dimension(PARAMETRES,REPONSES):
 237 #On verifie que la dimension de chaque sous_liste de parametre est 4
 238 #et que la dimension de chaque sous_liste de REPONSES est 3
 239    txt=""
 240    for i in range(len(PARAMETRES)):
 241       if (len(PARAMETRES[i]) != 4):
 242          txt=txt + "\nLa sous-liste de la variable paramètre numéro " + str(i+1)+" n'est pas de longueur 4"
 243    for i in range(len(REPONSES)):
 244       if (len(REPONSES[i]) != 3):
 245          txt=txt + "\nLa sous-liste de la variable réponse numéro " + str(i+1)+" n'est pas de longueur 3"
 246    return txt
 247
 248
 249 def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP):
 250    # X et Y sont deux arguments qui doivent avoir la meme dimension
 251    # pour éviter l'arret du programme
 252    txt=""
 253    if( len(REPONSES) != len(RESU_EXP)):
 254       txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux"
 255    return txt
 256
 257 def verif_RESU_EXP(RESU_EXP):
 258    # RESU_EXP doit etre une liste de tableaux Numeric de taille Nx2
 259    # pour éviter l'arret du programme
 260    txt=""
 261    for index,resu in enumerate(RESU_EXP):
 262       if (isinstance(resu,Numeric.ArrayType)):
 263          if (len(Numeric.shape(resu)) != 2):
 264             txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."
 265          else:
 266             if (Numeric.shape(resu)[1] != 2):
 267                txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."
 268       else:
 269          txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau Numeric."
 270    return txt
 271
 272 def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
 273    # POIDS et Y sont deux arguments qui doivent avoir la meme dimension
 274    # pour éviter l'arret du programme
 275    txt=""
 276    if( len(POIDS) != len(RESU_EXP)):
 277       txt="\nVous avez entré " +str(len(POIDS))+ " poids et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de poids que de résultats expérimentaux"
 278    return txt
 279
 280
 281 def verif_fichier(UL,PARAMETRES,REPONSES):
 282 #On verifie les occurences des noms des PARAMETRES et REPONSES
 283 #dans le fichier de commande ASTER
 284    txt=""
 285    fichier = open('fort.'+str(UL),'r')
 286    fic=fichier.read()
 287    for i in range(len(PARAMETRES)):
 288       if((string.find(fic,PARAMETRES[i][0])==-1) or ((string.find(fic,PARAMETRES[i][0]+'=')==-1) and (string.find(fic,PARAMETRES[i][0]+' ')==-1))):
 289          txt=txt + "\nLe paramètre "+PARAMETRES[i][0]+" que vous avez entré pour la phase d'optimisation n'a pas été trouvé dans votre fichier de commandes ASTER"
 290    for i in range(len(REPONSES)):
 291       if((string.find(fic,REPONSES[i][0])==-1) or ((string.find(fic,REPONSES[i][0]+'=')==-1) and (string.find(fic,REPONSES[i][0]+' ')==-1))):
 292          txt=txt + "\nLa réponse  "+REPONSES[i][0]+" que vous avez entrée pour la phase d'optimisation n'a pas été trouvée dans votre fichier de commandes ASTER"
 293    return txt
 294
 295
 296 def verif_valeurs_des_PARAMETRES(PARAMETRES):
 297 #On verifie que pour chaque PARAMETRES de l'optimisation
 298 # les valeurs entrées par l'utilisateur sont telles que :
 299 #              val_inf<val_sup
 300 #              val_init appartient à [borne_inf, borne_sup]
 301 #              val_init!=0
 302 #              borne_sup!=0
 303 #              borne_inf!=0
 304    txt=""
 305    #verification des bornes
 306    for i in range(len(PARAMETRES)):
 307       if( PARAMETRES[i][2] >PARAMETRES[i][3]):
 308          txt=txt + "\nLa borne inférieure "+str(PARAMETRES[i][2])+" de  "+PARAMETRES[i][0]+ "est plus grande que sa borne supérieure"+str(PARAMETRES[i][3])
 309    #verification de l'encadrement de val_init
 310    for i in range(len(PARAMETRES)):
 311       if( (PARAMETRES[i][1] < PARAMETRES[i][2]) or (PARAMETRES[i][1] > PARAMETRES[i][3])):
 312          txt=txt + "\nLa valeur initiale "+str(PARAMETRES[i][1])+" de "+PARAMETRES[i][0]+ " n'est pas dans l'intervalle [borne_inf,born_inf]=["+str(PARAMETRES[i][2])+" , "+str(PARAMETRES[i][3])+"]"
 313    #verification que val_init !=0
 314    for  i in range(len(PARAMETRES)):
 315       if (PARAMETRES[i][1] == 0. ):
 316          txt=txt + "\nProblème de valeurs initiales pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur initiale nulle mais un ordre de grandeur."
 317    #verification que borne_sup !=0
 318    for  i in range(len(PARAMETRES)):
 319       if (PARAMETRES[i][3] == 0. ):
 320          txt=txt + "\nProblème de borne supérieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
 321    #verification que borne_inf !=0
 322    for  i in range(len(PARAMETRES)):
 323       if (PARAMETRES[i][2] == 0. ):
 324          txt=txt + "\nProblème de borne inférieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
 325    return txt
 326
 327
 328 def verif_UNITE(GRAPHIQUE,UNITE_RESU):
 329    # On vérifie que les unités de résultat et
 330    # de graphique sont différentes
 331    txt=""
 332    GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
 333    if (GRAPHE_UL_OUT==UNITE_RESU):
 334        txt=txt + "\nLes unités logiques des fichiers de résultats graphiques et de résultats d'optimisation sont les memes."
 335    return txt
 336
 337
 338
 339 def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU):
 340    #Cette methode va utiliser les methodes de cette classe declarée ci_dessus
 341    #test  est un boolean: test=0 -> pas d'erreur
 342    #                      test=1 -> erreur détectée
 343
 344    texte=""
 345    #On vérifie d'abord si PARAMETRES, REPONSES, RESU_EXP sont bien des listes au sens python
 346    #test de PARAMETRES
 347    texte = texte + erreur_de_type(0,PARAMETRES)
 348    #test de REPONSES
 349    texte = texte + erreur_de_type(0,REPONSES)
 350    #test de RESU_EXP
 351    texte = texte + erreur_de_type(0,RESU_EXP)
 352
 353    #On vérifie si chaque sous liste de PARAMETRES, REPONSES,  possède le type adéquat
 354    #test des sous_listes de PARAMETRES
 355    for i in range(len(PARAMETRES)):
 356       texte = texte +  erreur_de_type(0,PARAMETRES[i])
 357    #test des sous_listes de REPONSES
 358    for i in range(len(REPONSES)):
 359       texte = texte + erreur_de_type(0,REPONSES[i])
 360
 361    #On verifie si la dimension de chaque sous-liste de : PARAMETRES, REPONSES
 362    #il faut que:la dimension d'une sous-liste de PARAMETRES = 4
 363    #et   que    la dimension d'une sous liste de REPONSES   = 3
 364    texte = texte + erreur_dimension(PARAMETRES,REPONSES)
 365
 366    #on verifie le type et la dimension des résultats expérimentaux
 367    texte = texte + verif_RESU_EXP(RESU_EXP)
 368    #on verifie que l'on a autant de réponses que de résultats expérimentaux
 369    texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP)
 370    #on verifie que l'on a autant de poids que de résultats expérimentaux
 371    texte = texte + compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP)
 372
 373    #on verifie les types des arguments de chaque sous liste de PARAMETRES et REPONSES
 374       #verification du type stringet type float des arguments de PARAMETRES
 375    for i in range(len(PARAMETRES)):
 376       texte = texte + erreur_de_type(1,PARAMETRES[i][0])
 377       for k in [1,2,3]:
 378          texte = texte + erreur_de_type(2,PARAMETRES[i][k])
 379
 380    #verification du type string pour les arguments  de REPONSES
 381    for i in range(len(REPONSES)):
 382       for j in range(len(REPONSES[i])):
 383          texte = texte + erreur_de_type(1,REPONSES[i][j])
 384
 385    #verification du fichier de commndes ASTER
 386    texte = texte + verif_fichier(UL,PARAMETRES,REPONSES)
 387
 388    #verifiaction des valeurs des PARAMETRES entrées par l'utilisteur
 389    texte = texte + verif_valeurs_des_PARAMETRES(PARAMETRES)
 390
 391    #verifiaction des unités logiques renseignées par l'utilisateur
 392    texte = texte + verif_UNITE(GRAPHIQUE,UNITE_RESU)
 393
 394    return texte
 395
 396