Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py

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