1 #@ MODIF recal Macro DATE 11/07/2005 AUTEUR PABHHHH N.TARDIEU
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.
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.
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 # ======================================================================
30 from Cata.cata import INCLUDE,DETRUIRE
32 from Utilitai.extract import EXTRACT
37 #_____________________________________________
39 # DIVERS UTILITAIRES POUR LA MACRO
40 #_____________________________________________
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)
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
57 def mes_concepts(list_concepts=[],base=None):
58 # Fonction qui liste les concepts créés
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)
69 def detr_concepts(self):
70 liste_concepts=mes_concepts(base=self.parent)
71 for e in liste_concepts:
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]
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
82 #On stocke le contenu initial de fort.UL dans la variable fichiersauv
83 fichiersauv=copy.copy(fichier)
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
93 #cherche l'indice de DEBUT()
94 index_deb=string.index(fichier,'DEBUT(')
95 while( fichier[index_deb]!='\n'):
97 #on restreind fichier en enlevant 'DEBUT();'
98 fichier = fichier[index_deb+1:]
100 #on va dans l'except si on a modifié le fichier au moins une fois
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]
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]
124 #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation
126 for i in range(len(para)-1):
129 while(fichier[j]!= '\n'):
131 bloc_inter=bloc_inter + fichier[j:k] + '\n'
133 #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para
135 while(fichier[i] != '\n'):
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
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
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)
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')
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)
175 # on remet le fichier dans son etat initial
176 x=open('fort.'+str(UL),'w')
177 x.writelines(fichiersauv)
179 return self.g_context['Lrep']
181 #_____________________________________________
183 # IMPRESSIONS GRAPHIQUES
184 #_____________________________________________
186 def graphique(L_F,res_exp,reponses,iter,UL_out,interactif):
188 impr=Gnuplot.Gnuplot()
189 Gnuplot.GnuplotOpts.prefer_inline_data=1
190 impr('set data style linespoints')
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)):
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'))
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'))
213 #_____________________________________________
215 # CONTROLE DES ENTREES UTILISATEUR
216 #_____________________________________________
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
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"
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
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"
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
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"
257 def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
258 # POIDS et Y sont deux arguments qui doivent avoir la meme dimension
259 # pour éviter l'arret du programme
261 if( len(POIDS) != len(RESU_EXP)):
262 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"
266 def verif_fichier(UL,PARAMETRES,REPONSES):
267 #On verifie les occurences des noms des PARAMETRES et REPONSES
268 #dans le fichier de commande ASTER
270 fichier = open('fort.'+str(UL),'r')
272 for i in range(len(PARAMETRES)):
273 if((string.find(fic,PARAMETRES[i][0])==-1) or ((string.find(fic,PARAMETRES[i][0]+'=')==-1) and (string.find(fic,PARAMETRES[i][0]+' ')==-1))):
274 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"
275 for i in range(len(REPONSES)):
276 if((string.find(fic,REPONSES[i][0])==-1) or ((string.find(fic,REPONSES[i][0]+'=')==-1) and (string.find(fic,REPONSES[i][0]+' ')==-1))):
277 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"
281 def verif_valeurs_des_PARAMETRES(PARAMETRES):
282 #On verifie que pour chaque PARAMETRES de l'optimisation
283 # les valeurs entrées par l'utilisateur sont telles que :
285 # val_init appartient à [borne_inf, borne_sup]
290 #verification des bornes
291 for i in range(len(PARAMETRES)):
292 if( PARAMETRES[i][2] >PARAMETRES[i][3]):
293 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])
294 #verification de l'encadrement de val_init
295 for i in range(len(PARAMETRES)):
296 if( (PARAMETRES[i][1] < PARAMETRES[i][2]) or (PARAMETRES[i][1] > PARAMETRES[i][3])):
297 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])+"]"
298 #verification que val_init !=0
299 for i in range(len(PARAMETRES)):
300 if (PARAMETRES[i][1] == 0. ):
301 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."
302 #verification que borne_sup !=0
303 for i in range(len(PARAMETRES)):
304 if (PARAMETRES[i][3] == 0. ):
305 txt=txt + "\nProblème de borne supérieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
306 #verification que borne_inf !=0
307 for i in range(len(PARAMETRES)):
308 if (PARAMETRES[i][2] == 0. ):
309 txt=txt + "\nProblème de borne inférieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
313 def verif_UNITE(GRAPHIQUE,UNITE_RESU):
314 # On vérifie que les unités de résultat et
315 # de graphique sont différentes
317 GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
318 if (GRAPHE_UL_OUT==UNITE_RESU):
319 txt=txt + "\nLes unités logiques des fichiers de résultats graphiques et de résultats d'optimisation sont les memes."
324 def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU):
325 #Cette methode va utiliser les methodes de cette classe declarée ci_dessus
326 #test est un boolean: test=0 -> pas d'erreur
327 # test=1 -> erreur détectée
330 #On vérifie d'abord si PARAMETRES, REPONSES, RESU_EXP sont bien des listes au sens python
332 texte = texte + erreur_de_type(0,PARAMETRES)
334 texte = texte + erreur_de_type(0,REPONSES)
336 texte = texte + erreur_de_type(0,RESU_EXP)
338 #On vérifie si chaque sous liste de PARAMETRES, REPONSES, possède le type adéquat
339 #test des sous_listes de PARAMETRES
340 for i in range(len(PARAMETRES)):
341 texte = texte + erreur_de_type(0,PARAMETRES[i])
342 #test des sous_listes de REPONSES
343 for i in range(len(REPONSES)):
344 texte = texte + erreur_de_type(0,REPONSES[i])
346 #On verifie si la dimension de chaque sous-liste de : PARAMETRES, REPONSES
347 #il faut que:la dimension d'une sous-liste de PARAMETRES = 4
348 #et que la dimension d'une sous liste de REPONSES = 3
349 texte = texte + erreur_dimension(PARAMETRES,REPONSES)
351 #on verifie que l'on a autant de réponses que de résultats expérimentaux
352 texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP)
353 #on verifie que l'on a autant de poids que de résultats expérimentaux
354 texte = texte + compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP)
356 #on verifie les types des arguments de chaque sous liste de PARAMETRES et REPONSES
357 #verification du type stringet type float des arguments de PARAMETRES
358 for i in range(len(PARAMETRES)):
359 texte = texte + erreur_de_type(1,PARAMETRES[i][0])
361 texte = texte + erreur_de_type(2,PARAMETRES[i][k])
363 #verification du type string pour les arguments de REPONSES
364 for i in range(len(REPONSES)):
365 for j in range(len(REPONSES[i])):
366 texte = texte + erreur_de_type(1,REPONSES[i][j])
368 #verification du fichier de commndes ASTER
369 texte = texte + verif_fichier(UL,PARAMETRES,REPONSES)
371 #verifiaction des valeurs des PARAMETRES entrées par l'utilisteur
372 texte = texte + verif_valeurs_des_PARAMETRES(PARAMETRES)
374 #verifiaction des unités logiques renseignées par l'utilisateur
375 texte = texte + verif_UNITE(GRAPHIQUE,UNITE_RESU)