Aster/Cata/cataSTA9/Macro/reca_calcul_aster.py

   1 #@ MODIF reca_calcul_aster Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE
   2 # -*- coding: iso-8859-1 -*-
   3 # RESPONSABLE ASSIRE A.ASSIRE
   4 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   5 # ======================================================================
   6 # COPYRIGHT (C) 1991 - 2006  EDF R&D                  WWW.CODE-ASTER.ORG
   7 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   8 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   9 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
  10 # (AT YOUR OPTION) ANY LATER VERSION.
  11 #
  12 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  13 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  14 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  15 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  16 #
  17 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  18 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  19 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  20 # ======================================================================
  21
  22 # mode_include = False
  23 # __follow_output = False
  24 # table_sensibilite = False
  25 __commandes_aster__ = False
  26
  27 debug = False
  28
  29 import copy, Numeric, types, os, sys, pprint, math
  30 from glob import glob
  31 from externe_mess import UTMESS
  32
  33 from Utilitai.System import ExecCommand
  34
  35 # Nom de la routine
  36 nompro = 'MACR_RECAL'
  37
  38
  39 # ------------------------------------------------------------------------------
  40
  41 class PARAMETRES:
  42
  43   def __init__(self, METHODE, UNITE_RESU, INFO=1, fich_output='./REPE_OUT/output_esclave.txt', mode_include=False, follow_output=False, table_sensibilite=False, memjeveux_esclave=None, PARA_DIFF_FINI=1.E-3, ITER_MAXI=10, ITER_FONC_MAXI=100):
  44
  45     self.METHODE        = METHODE
  46     self.UNITE_RESU     = UNITE_RESU
  47     self.INFO           = INFO
  48     self.fich_output    = fich_output
  49     self.PARA_DIFF_FINI = PARA_DIFF_FINI
  50     self.ITER_FONC_MAXI = ITER_FONC_MAXI
  51     self.ITER_MAXI      = ITER_MAXI,
  52
  53     try:
  54       import Cata, aster
  55       from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE
  56       from Accas import _F
  57     except:
  58       mode_include = False
  59
  60     if not mode_include:
  61       try:
  62         from Macro.lire_table_ops import lecture_table
  63         mode_aster = True
  64       except:
  65         try:
  66           sys.path.append( './Python/Macro' )
  67           from Macro.lire_table_ops import lecture_table
  68           mode_aster = False
  69         except:
  70           UTMESS('F','MACR_RECAL',"Probleme : impossible d'importer le module de lecture des tables!")
  71     self.mode_include      = mode_include
  72     self.follow_output     = follow_output
  73     self.mode_aster        = mode_aster
  74     self.memjeveux_esclave = memjeveux_esclave
  75     self.table_sensibilite = table_sensibilite
  76
  77     self.vector_output     = False
  78     self.error_output      = False
  79
  80
  81 # ------------------------------------------------------------------------------
  82
  83 class CALCUL_ASTER:
  84
  85   def __init__(self, PARAMETRES, UL, para, reponses, LIST_SENSI=[], LIST_DERIV=[]):
  86
  87     self.UL                    = UL
  88     self.para                  = para
  89     self.reponses              = reponses
  90     self.LIST_SENSI            = LIST_SENSI
  91     self.LIST_DERIV            = LIST_DERIV
  92
  93     self.METHODE               = PARAMETRES.METHODE
  94     self.UNITE_RESU            = PARAMETRES.UNITE_RESU
  95     self.INFO                  = PARAMETRES.INFO
  96     self.fich_output           = PARAMETRES.fich_output
  97     self.mode_include          = PARAMETRES.mode_include
  98     self.follow_output         = PARAMETRES.follow_output
  99     self.table_sensibilite     = PARAMETRES.table_sensibilite
 100     self.mode_aster            = PARAMETRES.mode_aster
 101     self.memjeveux_esclave     = PARAMETRES.memjeveux_esclave
 102     self.PARA_DIFF_FINI        = PARAMETRES.PARA_DIFF_FINI
 103     self.ITER_FONC_MAXI        = PARAMETRES.ITER_FONC_MAXI
 104     self.vector_output         = PARAMETRES.vector_output
 105     self.error_output          = PARAMETRES.vector_output
 106
 107     self.UNITE_GRAPHIQUE       = None
 108     self.new_export            = 'tmp_export'
 109     self.nom_fichier_mess_fils = None
 110     self.nom_fichier_resu_fils = None
 111
 112     self.fichier_esclave       = None
 113
 114     self.evaluation_fonction   = 0
 115
 116     self.L_J_init              = None
 117     self.val                   = None
 118     self.L                     = None
 119     self.L_deriv_sensible      = None
 120
 121
 122
 123   # ------------------------------------------------------------------------------
 124
 125   def Lancement_Commande(self, cmd):
 126
 127           if self.INFO>=1: UTMESS('I','MACR_RECAL',"Lancement de la commande : " + cmd)
 128
 129           fich_output       = self.fich_output
 130           follow_output     = self.follow_output
 131
 132           # Lancement d'Aster avec le deuxieme export
 133           iret, txt_output = ExecCommand(cmd, follow_output=self.follow_output,verbose=False)
 134
 135           if fich_output:
 136              # Recuperation du .mess 'fils'
 137              f=open(fich_output, 'w')
 138              f.write( txt_output )
 139              f.close()
 140
 141           if self.INFO>=1: UTMESS('I','MACR_RECAL',"Fin du lancement de la commande : " + cmd)
 142
 143           diag = self.Recuperation_Diagnostic(txt_output)
 144
 145           return
 146
 147
 148   # ------------------------------------------------------------------------------
 149
 150   def Recuperation_Diagnostic(self, output):
 151
 152     txt = '--- DIAGNOSTIC JOB :'
 153     diag = None
 154     for ligne in output.splitlines():
 155       if ligne.find(txt) > -1:
 156         diag = ligne.split(txt)[-1].strip()
 157         break
 158
 159     if self.INFO>=1: UTMESS('I','MACR_RECAL',"Diagnostic du calcul esclave : " + diag)
 160
 161     if diag in ['OK', 'NOOK_TEST_RESU', '<A>_ALARM', '<F>_COPY_ERROR']: return True
 162     else:
 163       UTMESS('F','MACR_RECAL',"Le fichier esclave ne s'est pas terminé correctement.")
 164
 165
 166   # ------------------------------------------------------------------------------
 167
 168   def Remplace_fichier_esclave(self, val_in): pass
 169
 170
 171   # ------------------------------------------------------------------------------
 172
 173   def calcul_Aster(self, val, INFO=0):
 174
 175         self.val   = val
 176         UL         = self.UL
 177         para       = self.para
 178         reponses   = self.reponses
 179         UNITE_RESU = self.UNITE_RESU
 180         LIST_SENSI = self.LIST_SENSI
 181         LIST_DERIV = self.LIST_DERIV
 182
 183         mode_include      = self.mode_include
 184         follow_output     = self.follow_output
 185         table_sensibilite = self.table_sensibilite
 186
 187         if self.evaluation_fonction > self.ITER_FONC_MAXI:
 188            UTMESS('F', nompro, "Le nombre d'evaluation de la fonctionnelle depasse le critere ITER_FONC_MAXI.")
 189         self.evaluation_fonction += 1
 190
 191
 192         if not mode_include:
 193
 194           # Creation du repertoire temporaire pour l'execution de l'esclave
 195           tmp_macr_recal = self.Creation_Temporaire_Esclave()
 196
 197           # Creation du fichier .export de l'esclave
 198           self.Creation_Fichier_Export_Esclave(tmp_macr_recal)
 199
 200         # Fichier esclave a modifier (si methode EXTERNE alors on prend directement le fichier esclave, sinon c'est le fort.UL dans le repertoire d'execution
 201         try:
 202            if self.METHODE=='EXTERNE':
 203               fic = open(self.fichier_esclave,'r')
 204            else:
 205               fic = open('fort.'+str(UL),'r')
 206
 207            # On stocke le contenu de fort.UL dans la variable fichier qui est une string
 208            fichier=fic.read()
 209            # On stocke le contenu initial de fort.UL dans la variable fichiersauv
 210            fichiersauv=copy.copy(fichier)
 211            fic.close()
 212         except:
 213            UTMESS('F', nompro, "Impossible de relire le fichier esclave : \n " + str(self.fichier_esclave))
 214
 215         # chemin vers as_run
 216         if os.environ.has_key('ASTER_ROOT'):
 217            as_run = os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'bin', 'as_run')
 218         elif os.path.isfile(aster.repout() + os.sep + 'as_run'):
 219            as_run = aster.repout() + os.sep + 'as_run'
 220         else:
 221            as_run = 'as_run'
 222            if INFO>=1: UTMESS('A', nompro, "Variable d'environnement ASTER_ROOT absente, " \
 223                                "on essaiera avec 'as_run' dans le $PATH.")
 224
 225         if __commandes_aster__:
 226           try:
 227             from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE
 228           except:
 229             message = "Erreur"
 230             UTMESS('F', nompro, message)
 231
 232         # Utilisation du module Python de LIRE_TABLE
 233         if self.mode_aster:
 234           from Macro.lire_table_ops import lecture_table
 235         else:
 236           try:
 237             sys.path.append( './Python/Macro' )
 238             from lire_table_ops import lecture_table
 239           except:
 240             UTMESS('F','MACR_RECAL',"Probleme : impossible d'importer le module de lecture des tables!")
 241
 242         txt = []
 243         for i in para:
 244           txt.append( "\t\t\t%s : %s" % (i, val[para.index(i)]) )
 245         if INFO>=1: UTMESS('I','MACR_RECAL',"Calcul de F avec les parametres:\n%s" % '\n'.join(txt))
 246
 247
 248   # MARCHE PAS !!
 249 #         # Quelques verifications/modifications sur le fichier esclave, pour blindage
 250 #         fichiernew=[]
 251 #         for ligne in fichier.split('\n'):
 252 #            # DEBUT et FIN (on retire les espaces entre le mot-clé et la premiere parenthese)
 253 #            for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]:
 254 #               if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1:
 255 #                  index_deb1 = ligne.index(txt1)
 256 #                  ligne1 = ligne[ index_deb1+len(txt1):]
 257 #                  if ligne.find( txt1 )!=-1:
 258 #
 259 #
 260 #            for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]:
 261 #               if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1:
 262 #                  index_deb1 = ligne.index(txt1)
 263 #                  index_fin1 = index_deb1 + len(txt1)
 264 #                  index_deb2 = ligne.index(txt2)
 265 #                  index_fin2 = index_deb1 + len(txt2)
 266 #                  ligne = ligne[:index_fin1]+ligne[index_deb2:]
 267 #               # on retire les parametes en commentaires
 268 #               for txt in para:
 269 #                  if ligne.find(txt)!=-1:
 270 #                    if ligne.replace(' ', '')[0] == '#': ligne = ''
 271 #            fichiernew.append(ligne)
 272 #         fichier = '\n'.join(fichiernew)
 273
 274
 275
 276         # On supprime tous les commentaires du fichier esclave
 277         fichiernew=[]
 278         for ligne in fichier.split('\n'):
 279            if ligne.strip() != '':
 280               if ligne.replace(' ', '')[0] == '#': ligne = ''
 281               fichiernew.append(ligne)
 282         fichier = '\n'.join(fichiernew)
 283
 284
 285         #Fichier_Resu est une liste ou l'on va stocker le fichier modifié
 286         #idée générale :on délimite des 'blocs' dans fichier
 287         #on modifie ou non ces blocs suivant les besoins
 288         #on ajoute ces blocs dans la liste Fichier_Resu
 289         Fichier_Resu=[]
 290
 291         # Dans le cas du mode INCLUDE on enleve le mot-clé DEBUT
 292         if mode_include:
 293           try:
 294              #cherche l'indice de DEBUT()
 295              index_deb=fichier.index('DEBUT(')
 296              while( fichier[index_deb]!='\n'):
 297                 index_deb=index_deb+1
 298              #on restreint fichier en enlevant 'DEBUT();'
 299              fichier = fichier[index_deb+1:]
 300           except:
 301              #on va dans l'except si on a modifié le fichier au moins une fois
 302              pass
 303
 304 #         print 60*'o'
 305 #         print fichier
 306 #         print 60*'o'
 307
 308         # On enleve le mot-clé FIN()
 309         try:
 310            #cherche l'indice de FIN()
 311            index_fin = fichier.index('FIN(')
 312            #on restreint fichier en enlevant 'FIN();'
 313            fichier = fichier[:index_fin]
 314         except : pass
 315
 316 #         print 60*'o'
 317 #         print fichier
 318 #         print 60*'o'
 319
 320         #--------------------------------------------------------------------------------
 321         #on cherche à délimiter le bloc des parametres dans le fichier
 322         #Tout d'abord on cherche les indices d'apparition des paras dans le fichier
 323         #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise
 324         #avec le meme ordre que son fichier de commande
 325         index_para = Numeric.zeros(len(para))
 326         for i in range(len(para)):
 327            index_para[i] = fichier.index(para[i])
 328
 329         #On range les indices par ordre croissant afin de déterminer
 330         #les indice_max et indice_min
 331         index_para = Numeric.sort(index_para)
 332         index_first_para = index_para[0]
 333         index_last_para = index_para[len(index_para)-1]
 334
 335
 336         #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation
 337         bloc_inter ='\n'
 338         for i in range(len(para)-1):
 339            j = index_para[i]
 340            k = index_para[i+1]
 341            while(fichier[j]!= '\n'):
 342               j=j+1
 343            bloc_inter=bloc_inter + fichier[j:k] + '\n'
 344
 345         #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para
 346         i = index_last_para
 347         while(fichier[i] != '\n'):
 348            i = i + 1
 349         index_last_para  = i
 350         #on délimite les blocs suivants:
 351         pre_bloc = fichier[:index_first_para]        #fichier avant premier parametre
 352         post_bloc = fichier[ index_last_para+ 1:]    #fichier après dernier parametre
 353
 354         #on ajoute dans L tous ce qui est avant le premier paramètre
 355         Fichier_Resu.append(pre_bloc)
 356         Fichier_Resu.append('\n')
 357
 358         # Liste des parametres utilisant la SENSIBILITE
 359         liste_sensibilite = []
 360         if len(LIST_SENSI)>0:
 361           for i in LIST_SENSI:
 362             liste_sensibilite.append( i )
 363
 364         #On ajoute la nouvelle valeur des parametres
 365         dim_para=len(para)
 366         for j in range(dim_para):
 367            if not para[j] in liste_sensibilite:
 368              Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n')
 369            else:
 370              Fichier_Resu.append(para[j]+'=DEFI_PARA_SENSI(VALE='+str(val[j]) + ',);' + '\n')
 371
 372
 373         #On ajoute à Fichier_Resu tous ce qui est entre les parametres
 374         Fichier_Resu.append(bloc_inter)
 375
 376         Fichier_Resu.append(post_bloc)
 377
 378         #--------------------------------------------------------------------------------
 379         #on va ajouter la fonction d'extraction du numarray de la table par la méthode Array
 380         #et on stocke les réponses calculées dans la liste Lrep
 381         #qui va etre retournée par la fonction calcul_Aster
 382         if mode_include:
 383           self.g_context['Lrep'] = []
 384           Fichier_Resu.append('Lrep=[]'+'\n')
 385           for i in range(len(reponses)):
 386              Fichier_Resu.append('t'+str(reponses[i][0])+'='+str(reponses[i][0])+'.EXTR_TABLE()'+'\n')
 387              Fichier_Resu.append('F = '+'t'+str(reponses[i][0])+'.Array('+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n')
 388              Fichier_Resu.append('Lrep.append(F)'+'\n')
 389
 390         #ouverture du fichier fort.3 et mise a jour de celui ci
 391         x=open('fort.'+str(UL),'w')
 392         if mode_include:
 393           x.writelines('from Accas import _F \nfrom Cata.cata import * \n')
 394         x.writelines(Fichier_Resu)
 395         x.close()
 396
 397         del(pre_bloc)
 398         del(post_bloc)
 399         del(fichier)
 400
 401         # ----------------------------------------------------------------------------------
 402         # Execution d'une deuxieme instance d'Aster
 403
 404         if not mode_include:
 405
 406           # Ajout des commandes d'impression des tables Resultats et Derivees à la fin du fichier esclave
 407           Fichier_Resu = []
 408           num_ul = '99'
 409
 410           # Tables correspondant aux Resultats
 411           for i in range(len(reponses)):
 412              _ul = str(int(100+i))
 413
 414              try:    os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul )
 415              except: pass
 416
 417              Fichier_Resu.append("\n# Recuperation de la table : " + str(reponses[i][0]) + "\n")
 418              Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n")
 419              Fichier_Resu.append("IMPR_TABLE(TABLE="+str(reponses[i][0])+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
 420              Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n")
 421
 422           # Tables correspondant aux Derivees
 423           if len(LIST_SENSI)>0:
 424               i = 0
 425               for _para in LIST_SENSI:
 426                   _lst_tbl  = LIST_DERIV[_para][0]
 427                   for _lst_tbl in LIST_DERIV[_para]:
 428                      i += 1
 429                      _tbl = _lst_tbl[0]
 430
 431                      _ul = str(int(100+len(reponses)+i))
 432                      try:    os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul )
 433                      except: pass
 434
 435                      Fichier_Resu.append("\n# Recuperation de la table derivee : " + _tbl + " (parametre " + _para + ")\n")
 436                      Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n")
 437                      if table_sensibilite:
 438                        Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", SENSIBILITE="+_para+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
 439                      else:
 440                        Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
 441                      Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n")
 442
 443           # Ecriture du "nouveau" fichier .comm
 444           x=open('fort.'+str(UL),'a')
 445           x.write( '\n'.join(Fichier_Resu) )
 446           x.write('\nFIN();\n')
 447           x.close()
 448
 449 #          os.system("cat %s" % self.new_export)
 450
 451           # Lancement du calcul Aster esclave
 452           cmd = '%s %s' % (as_run, self.new_export)
 453           self.Lancement_Commande(cmd)
 454
 455           # Recuperation du .mess et du .resu 'fils'
 456           if self.METHODE != 'EXTERNE':
 457              if self.nom_fichier_mess_fils:
 458                  cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_mess_fils + ' ./REPE_OUT/'
 459                  os.system( cmd )
 460              if self.nom_fichier_resu_fils:
 461                  cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_resu_fils + ' ./REPE_OUT/'
 462                  os.system( cmd )
 463
 464           if __commandes_aster__:
 465               # Unite logique libre
 466               _tbul_libre=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
 467               _ul_libre=_tbul_libre['UNITE_LIBRE',1]
 468
 469
 470           # ------------------------------------------------------
 471           # Recuperation des tableaux resultats
 472           Lrep=[]
 473           _TB = [None]*len(reponses)
 474           for i in range(len(reponses)):
 475
 476             if __commandes_aster__:
 477
 478                 # Version par des commandes Aster
 479                 # -------
 480
 481
 482                 DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i)), );
 483                 try:
 484                   _TB[i]=LIRE_TABLE(UNITE=_ul_libre,
 485                                     FORMAT='ASTER',
 486                                     NUME_TABLE=1,
 487                                     SEPARATEUR=' ',);
 488                   DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,);
 489                   tREPONSE=_TB[i].EXTR_TABLE()
 490
 491                   F = tREPONSE.Array( str(reponses[i][1]), str(reponses[i][2]) )
 492                   Lrep.append(F)
 493                 except:
 494                   message = "Impossible de recuperer les resultats de calcul esclave!"
 495                   UTMESS('F', nompro, message)
 496
 497             else:
 498
 499                 # Version par utilisation directe du python de lire_table
 500                 # -------
 501
 502                 # Chemin vers le fichier contenant la table
 503                 _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i))
 504
 505                 try:
 506                    file=open(_fic_table,'r')
 507                    texte=file.read()
 508                    file.close()
 509                 except Exception, err:
 510                    ier=1
 511                    message = """Impossible de recuperer les resultats de calcul esclave (lecture des tables)!
 512 Le calcul esclave n'a pas du se terminer correctement (ajouter un repertoire dans ASTK en Resultat avec
 513 le type repe et voir l'output du fichier esclave dans ce repertoire.
 514 Message:
 515 """
 516                    message += str(err)
 517                    UTMESS('F', nompro, message)
 518
 519                 try:
 520                    table_lue = lecture_table(texte, 1, ' ')
 521                    list_para = table_lue.para
 522                    tab_lue   = table_lue.values()
 523                 except Exception, err:
 524                    ier=1
 525                    message = "Impossible de recuperer les resultats de calcul esclave (lecture des tables)!\nMessage:\n" + str(err)
 526                 else:
 527                    ier=0
 528
 529                 if ier!=0 :
 530                    UTMESS('F', nompro, message)
 531
 532                 try:
 533                     nb_val = len(tab_lue[ list_para[0] ])
 534                     F = Numeric.zeros((nb_val,2), Numeric.Float)
 535                     for k in range(nb_val):
 536 #                       F[k][0] = tab_lue[ list_para[0] ][1][k]
 537 #                       F[k][1] = tab_lue[ list_para[1] ][1][k]
 538                       F[k][0] = tab_lue[ str(reponses[i][1]) ][k]
 539                       F[k][1] = tab_lue[ str(reponses[i][2]) ][k]
 540                     Lrep.append(F)
 541                 except Exception, err:
 542                     message = "Impossible de recuperer les resultats de calcul esclave (recuperation des tables)!\nMessage:\n" + str(err)
 543                     UTMESS('F', nompro, message)
 544
 545
 546           # ------------------------------------------------------
 547           # Recuperation des tableaux des derivees (SENSIBILITE)
 548           L_deriv={}
 549           if len(LIST_SENSI)>0:
 550               _lon = 0
 551               for _para in LIST_SENSI:
 552                   _lon += len(LIST_DERIV[_para])
 553               _TBD = [None]*_lon
 554
 555               i = 0
 556               for _para in LIST_SENSI:
 557
 558                   L_deriv[_para] = []
 559                   _lst_tbl  = LIST_DERIV[_para][0]
 560
 561                   for _lst_tbl in LIST_DERIV[_para]:
 562                       j = LIST_DERIV[_para].index(_lst_tbl)
 563                       _tbl = _lst_tbl[0]
 564
 565                       if __commandes_aster__:
 566
 567                           # Version par des commandes Aster
 568                           # -------
 569
 570                           DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i)),);
 571                           _TBD[i]=LIRE_TABLE(UNITE=_ul_libre,
 572                                            FORMAT='ASTER',
 573                                            NUME_TABLE=1,
 574                                            SEPARATEUR=' ',);
 575                           DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,);
 576                           tREPONSE=_TBD[i].EXTR_TABLE()
 577                           DF = tREPONSE.Array( str(LIST_DERIV[_para][j][1]), str(LIST_DERIV[_para][j][2]) )
 578                           L_deriv[_para].append(DF)
 579                           i+=1
 580
 581                       else:
 582
 583                           # Version par utilisation directe du python de lire_table
 584                           # -------
 585
 586                           # Chemin vers le fichier contenant la table
 587                           _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i))
 588
 589                           try:
 590                              file=open(_fic_table,'r')
 591                              texte=file.read()
 592                              file.close()
 593                           except Exception, err:
 594                              message = """Impossible de recuperer les resultats de calcul esclave (lecture des tables)!
 595 Le calcul esclave n'a pas du se terminer correctement (ajouter un repertoire en Resultat avec
 596 le type repe et voir l'output du fichier esclave dans ce repertoire.
 597 Message:
 598 """
 599                              message += str(err)
 600                              UTMESS('F', nompro, message)
 601
 602                           try:
 603                              table_lue = lecture_table(texte, 1, ' ')
 604                              list_para = table_lue.para
 605                              tab_lue   = table_lue.values()
 606                           except Exception, err:
 607                              ier=1
 608                              message = "Impossible de recuperer les resultats de calcul esclave (lecture des tables)!\nMessage:\n" + str(err)
 609                           else:
 610                              ier=0
 611
 612                           if ier!=0 :
 613                              UTMESS('F', nompro, message)
 614
 615                           try:
 616                               nb_val = len(tab_lue[ list_para[0] ])
 617                               DF = Numeric.zeros((nb_val,2), Numeric.Float)
 618                               for k in range(nb_val):
 619 #                                 DF[k][0] = tab_lue[ list_para[0] ][1][k]
 620 #                                 DF[k][1] = tab_lue[ list_para[1] ][1][k]
 621                                 DF[k][0] = tab_lue[ str(LIST_DERIV[_para][j][1]) ][k]
 622                                 DF[k][1] = tab_lue[ str(LIST_DERIV[_para][j][2]) ][k]
 623                               L_deriv[_para].append(DF)
 624                               i+=1
 625                           except Exception, err:
 626                              message = "Impossible de recuperer les resultats de calcul esclave (recuperation des tables)!\nMessage:\n" + str(err)
 627                              UTMESS('F', nompro, message)
 628
 629
 630           # Nettoyage du export
 631           try:    os.remove(self.new_export)
 632           except: pass
 633
 634           # Nettoyage du repertoire temporaire
 635           if self.METHODE == 'EXTERNE': listdir =  ['REPE_TABLE', 'base', 'REPE_IN']
 636           else:                         listdir =  ['.', 'REPE_TABLE', 'base', 'REPE_OUT', 'REPE_IN']
 637           for dir in listdir:
 638             try:
 639               for fic in os.listdir(tmp_macr_recal+os.sep+dir):
 640                 try:    os.remove(tmp_macr_recal+os.sep+dir+os.sep+fic)
 641                 except: pass
 642             except: pass
 643
 644
 645
 646         # ----------------------------------------------------------------------------------
 647         # Ou bien on inclue le fichier Esclave
 648
 649         elif mode_include:
 650
 651           if debug: os.system('cp fort.'+str(UL)+' REPE_OUT/')
 652
 653           INCLUDE(UNITE = UL)
 654
 655           Lrep = self.g_context['Lrep']
 656           L_deriv = None
 657
 658           # Destruction des concepts Aster
 659           reca_utilitaires.detr_concepts(self)
 660
 661
 662         # ----------------------------------------------------------------------------------
 663         # Ou alors probleme ?
 664         else: sys.exit(1)
 665
 666
 667         del(Fichier_Resu)
 668
 669         # on remet le fichier dans son etat initial
 670         x=open('fort.'+str(UL),'w')
 671         x.writelines(fichiersauv)
 672         x.close()
 673
 674         return Lrep, L_deriv
 675
 676
 677
 678   # ------------------------------------------------------------------------------
 679
 680   def calcul_FG(self, val):
 681
 682      self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
 683      self.L_J, self.erreur = self.Simul.multi_interpole(self.L, self.reponses)
 684      if not self.L_J_init: self.L_J_init = copy.copy(self.L_J)
 685      self.J = self.Simul.norme_J(self.L_J_init, self.L_J, self.UNITE_RESU)
 686
 687      # Calcul des derivees
 688      self.A_nodim = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI)
 689
 690      self.A = self.Dim.adim_sensi( copy.copy(self.A_nodim) )
 691 #     self.residu = self.reca_algo.test_convergence(self.gradient_init, self.erreur, self.A, Numeric.zeros(len(self.gradient_init),Numeric.Float) )
 692      self.residu = 0.
 693
 694      if self.vector_output:
 695         return self.erreur, self.residu, self.A_nodim, self.A
 696      else:
 697         # norme de l'erreur
 698         self.norme = Numeric.dot(self.erreur, self.erreur)**0.5
 699
 700         self.norme_A_nodim = Numeric.zeros( (1,len(self.para)), Numeric.Float )
 701         self.norme_A       = Numeric.zeros( (1,len(self.para)), Numeric.Float )
 702         for c in range(len(self.A[0,:])):
 703            norme_A_nodim = 0
 704            norme_A        = 0
 705            for l in range(len(self.A[:,0])):
 706               norme_A_nodim += self.A_nodim[l,c] * self.A_nodim[l,c]
 707               norme_A       += self.A[l,c] * self.A[l,c]
 708            self.norme_A_nodim[0,c] = math.sqrt( norme_A_nodim )
 709            self.norme_A[0,c] = math.sqrt( norme_A )
 710
 711         return self.norme, self.residu, self.norme_A_nodim, self.norme_A
 712
 713
 714   # ------------------------------------------------------------------------------
 715
 716   def calcul_F(self, val):
 717
 718      self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
 719      L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses)
 720      if not self.L_J_init: self.L_J_init = copy.copy(L_J)
 721      J = self.Simul.norme_J(self.L_J_init, L_J, self.UNITE_RESU)
 722
 723      # norme de l'erreur
 724      norme = Numeric.sum( [x**2 for x in erreur] )
 725
 726      if debug:
 727         print 'erreur=', erreur
 728         print "norme de l'erreur=", norme
 729         print "norme de J (fonctionnelle)=", str(J)
 730
 731      if self.INFO>=1:
 732         txt = "Informations de convergence :"
 733         txt += '\n=======================================================\n'
 734         if self.evaluation_fonction >1: txt += "\n   Nombre d'evaluation de la fonction =  "  + str(self.evaluation_fonction)
 735         txt += "\n=> Fonctionnelle     = "+str(J)
 736
 737      if self.vector_output:
 738         if self.INFO>=1:
 739            txt += "\n=> Norme de l'erreur = " + str(norme)
 740            txt += '\n=======================================================\n'
 741            UTMESS('I','MACR_RECAL',txt)
 742         return erreur
 743      else:
 744         if self.INFO>=1:
 745            txt += "\n=> Erreur           = " + str(norme)
 746            txt += '\n=======================================================\n'
 747            UTMESS('I','MACR_RECAL',txt)
 748         return norme
 749
 750
 751
 752   # ------------------------------------------------------------------------------
 753
 754   def calcul_G(self, val):
 755
 756      # Si le calcul Aster est deja effectue pour val on ne le refait pas
 757      if (self.val == val) and self.L and self.L_deriv_sensible: pass
 758      else:
 759         self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
 760      A = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI)
 761      A = self.Dim.adim_sensi(A)
 762      L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses)
 763      grad = Numeric.dot(Numeric.transpose(A),erreur)
 764      if debug: print 'grad=', grad
 765      return grad
 766
 767
 768   # ------------------------------------------------------------------------------
 769
 770   def Creation_Temporaire_Esclave(self):
 771      """
 772         Creation du repertoire temporaire d'execution du calcul esclace
 773      """
 774
 775      # Creation du repertoire temporaire
 776      tmp_macr_recal = os.getcwd() + os.sep + 'tmp_macr_recal'
 777      try:    os.mkdir(tmp_macr_recal)
 778      except: pass
 779      if not os.path.exists(tmp_macr_recal): UTMESS('F','MACR_RECAL',"Probleme : Impossible de creer le repertoire temporaire : " + tmp_macr_recal)
 780      try:    os.mkdir(tmp_macr_recal + os.sep + 'REPE_TABLE')
 781      except: pass
 782      if not os.path.exists(tmp_macr_recal + os.sep + 'REPE_TABLE'): UTMESS('F','MACR_RECAL',"Probleme : Impossible de creer le repertoire temporaire : " + tmp_macr_recal + os.sep + 'REPE_TABLE')
 783
 784      return tmp_macr_recal
 785
 786
 787   # ------------------------------------------------------------------------------
 788
 789   def Creation_Fichier_Export_Esclave(self, tmp_macr_recal):
 790      """
 791         Creation du fichier .export pour le calcul esclave
 792      """
 793
 794      from as_profil import ASTER_PROFIL
 795
 796      # Recuperation du fichier .export
 797      list_export = glob('*.export')
 798
 799      if len(list_export) == 0: UTMESS('F','MACR_RECAL',"Probleme : il n'y a pas de fichier .export dans le repertoire de travail!")
 800      elif len(list_export) >1: UTMESS('F','MACR_RECAL',"Probleme : il y a plus d'un fichier .export dans le repertoire de travail!")
 801
 802      # On modifie le profil
 803      prof = ASTER_PROFIL(list_export[0])
 804
 805      # xterm
 806      if prof.param.has_key('xterm'):
 807         del prof.param['xterm']
 808      # memjeveux
 809      prof.args['memjeveux'] = self.memjeveux_esclave
 810
 811      # fichier/répertoire
 812      for lab in ('data', 'resu'):
 813        l_fr = getattr(prof, lab)
 814        l_tmp = l_fr[:]
 815
 816        for dico in l_tmp:
 817
 818          # répertoires
 819          if dico['isrep']:
 820
 821            # base non prise en compte
 822            if dico['type'] in ('base', 'bhdf'):
 823              l_fr.remove(dico)
 824
 825            if lab == 'resu':
 826              dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
 827
 828          # fichiers
 829          else:
 830
 831            # Nom du fichier .mess (pour recuperation dans REPE_OUT)
 832            if dico['ul'] == '6':
 833              self.nom_fichier_mess_fils = os.path.basename(dico['path'])
 834 #             self.nom_fichier_mess_fils = os.path.join(os.getcwd(), 'fort.%d' % self.UL)
 835
 836            # Nom du fichier .resu (pour recuperation dans REPE_OUT)
 837            if dico['ul'] == '8':
 838              self.nom_fichier_resu_fils = os.path.basename(dico['path'])
 839
 840            # Ancien .comm non pris en compte
 841            # Fichier d'unite logique UNITE_RESU (rapport de MACR_RECAL) non pris en compte
 842            if dico['type'] == 'comm' or (dico['ul'] == str(self.UNITE_RESU) and lab == 'resu'):
 843              l_fr.remove(dico)
 844
 845            # Fichier d'unite logique UL devient le nouveau .comm
 846            elif dico['ul'] == str(self.UL):
 847              self.fichier_esclave = dico['path']
 848              dico['type'] = 'comm'
 849              dico['ul']   = '1'
 850              dico['path'] = os.path.join(os.getcwd(), 'fort.%d' % self.UL)
 851
 852            # Tous les autres fichiers en Resultat
 853            elif lab == 'resu':
 854               if self.UNITE_GRAPHIQUE and dico['ul'] == str(self.UNITE_GRAPHIQUE): l_fr.remove(dico)
 855               else:
 856                  dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
 857
 858            # Tous les autres fichiers en Donnees
 859            elif lab == 'data':
 860               if dico['type'] not in ('exec', 'ele'):
 861                  if dico['ul']   != '0':   # Traite le cas des sources python sourchargees
 862                     if self.METHODE !='EXTERNE':
 863                        dico['path'] = os.path.join(os.getcwd(), 'fort.%s' % dico['ul'])
 864
 865            # sinon on garde la ligne telle quelle
 866        setattr(prof, lab, l_fr)
 867
 868      # Ecriture du nouveau fichier export
 869      prof.WriteExportTo(self.new_export)
 870
 871      if debug: os.system('cp ' + self.new_export + ' /tmp')
 872
 873   # --FIN CLASSE  ----------------------------------------------------------------------------
 874
 875
 876