Aster/Cata/cataSTA9/Macro/macr_adap_mail_ops.py

   1 #@ MODIF macr_adap_mail_ops Macro  DATE 24/11/2008   AUTEUR GNICOLAS G.NICOLAS
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2003  EDF R&D                  WWW.CODE-ASTER.ORG
   6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   9 # (AT YOUR OPTION) ANY LATER VERSION.
  10 #
  11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  15 #
  16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  19 # ======================================================================
  20 # RESPONSABLE GNICOLAS G.NICOLAS
  21 #
  22 """
  23 Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
  24 """
  25 __revision__ = "V1.2"
  26 #
  27 def macr_adap_mail_ops ( self,
  28                          INFO, VERSION_HOMARD, MAILLAGE_FRONTIERE,
  29                          **args):
  30   """
  31      Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
  32   """
  33 #
  34 #  1. args est le dictionnaire des arguments
  35 #     args.keys() est la liste des mots-cles
  36 #     args.keys()[0] est la premiere valeur de cette liste
  37 #     args.keys()[1:] est la liste des valeurs suivantes dans cette liste
  38 #     args.keys(mot_cle) represente le contenu de la variable mot_cle dans la macro appelante.
  39 #
  40 ###  print args
  41 ###  print args.keys()
  42 ###  if len (args.keys())>0 : print args.keys()[0]
  43 ###  print args["MAILLAGE"]
  44 #
  45 #  2. Les caracteristiques d'un passage sont conservees dans un dictionnaire. Il y a autant de
  46 #     dictionnaires que de sollicitations pour une serie d'adaptation. L'ensemble de ces dictionnaires
  47 #     est conserve dans la liste Liste_Passages. Cette liste est necessairement globale pour pouvoir
  48 #     la retrouver e chaque nouveau passage.
  49 #     Description du dictionnaire de passages :
  50 #        dico["Maillage_0"]             = o ; string ; nom du concept du maillage initial de la serie d'adaptation
  51 #        dico["Maillage_NP1"]           = o ; string ; nom du concept du dernier maillage adapte
  52 #        dico["Rep_Calc_HOMARD_global"] = o ; string ; Nom global du repertoire de calcul pour HOMARD
  53 #        dico["Rep_Calc_HOMARD_local"]  = o ; string ; Nom local du repertoire de calcul pour HOMARD
  54 #                                                      depuis le repertoire de calcul pour ASTER
  55 #        dico["niter"]                  = o ; entier ; numero d'iteration
  56 #
  57 #  3. Les caracteristiques d'un maillage sont conservees dans un dictionnaire. Il y a autant de
  58 #     dictionnaires que de maillages manipules. L'ensemble de ces dictionnaires est conserve
  59 #     dans la liste liste_maillages.
  60 #     Description du dictionnaire de maillages :
  61 #        dico["Type_Maillage"] = o ; string ; "MAILLAGE_N", "MAILLAGE_NP1", "MAILLAGE_NP1_ANNEXE" ou "MAILLAGE_FRONTIERE"
  62 #        dico["Nom_ASTER"]     = o ; concept ASTER associe
  63 #        dico["Action"]        = o ; string ; "A_ecrire" ou "A_lire"
  64 #        dico["NOM_MED"]       = o ; string ; Nom MED du maillage
  65 #
  66 #  4. Les caracteristiques d'un champ sont conservees dans un dictionnaire. Il y a autant de
  67 #     dictionnaires que de champs manipules. L'ensemble de ces dictionnaires est conserve
  68 #     dans la liste liste_champs.
  69 #     Description du dictionnaire de champs :
  70 #        dico["Type_Champ"]   = o ; string ; "INDICATEUR" ou "CHAMP_MAJ"
  71 #        dico["RESULTAT"]     = f ; concept ASTER du resutat associe
  72 #        dico["NOM_CHAM"]     = f ; string ; Nom ASTER du champ
  73 #        dico["CHAM_GD"]      = f ; concept ASTER du champ de grandeur associee
  74 #        dico["COMPOSANTE"]   = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
  75 #        dico["NUME_ORDRE"]   = f ; entier ; Numero d'ordre du champ
  76 #        dico["INST"]         = f ; entier ; Instant du champ
  77 #        dico["PRECISION"]    = f ; entier ; Precision sur l'instant du champ
  78 #        dico["CRITERE"]      = f ; entier ; Critere de precision sur l'instant du champ
  79 #        dico["CHAM_MAJ"]     = f ; string ; Nom ASTER du champ interpole sur le nouveau maillage
  80 #        dico["NOM_MED"]      = o ; string ; Nom MED du champ
  81 #        dico["SENSIBILITE"]  = f ; string ; Nom du parametre sensible associe
  82 #
  83 #  5. Signification de INFO
  84 #     INFO = 1 : aucun message
  85 #     INFO = 2 : les messages des commandes annexes (DEFI_FICHIER, IMPR_RESU, LIRE_MAILLAGE, LIRE_CHAMP)
  86 #     INFO = 3 : aucun message pour les commandes annexes
  87 #                1er niveau de message pour l'execution de HOMARD
  88 #     INFO = 4 : aucun message pour les commandes annexes
  89 #                2nd niveau de message pour l'execution de HOMARD
  90 #
  91   from Accas import _F
  92   from Macro import creation_donnees_homard
  93   from Utilitai.Utmess     import UTMESS, MasquerAlarme, RetablirAlarme
  94   import aster
  95   import string
  96   import os
  97   import shutil
  98 #
  99   global Liste_Passages
 100 #
 101 #====================================================================
 102 # 1. Prealables
 103 #====================================================================
 104 #
 105 # 1.1. ==> La macro compte pour 1 dans la numerotation des commandes
 106 #
 107   self.set_icmd(1)
 108 #
 109 # 1.2. ==> Numero du passage dans cette macro
 110 #
 111   try :
 112     self.jdc.indice_macro_homard = self.jdc.indice_macro_homard + 1
 113   except :
 114     self.jdc.indice_macro_homard = 1
 115     Liste_Passages = []
 116   numero_passage_fonction = self.jdc.indice_macro_homard
 117 ###  print "numero_passage_fonction = ",numero_passage_fonction
 118 #
 119 # 1.3. ==> On importe les definitions des commandes a utiliser dans la macro
 120 #
 121   DEFI_FICHIER    = self.get_cmd("DEFI_FICHIER")
 122   IMPR_RESU       = self.get_cmd("IMPR_RESU")
 123   EXEC_LOGICIEL   = self.get_cmd("EXEC_LOGICIEL")
 124   LIRE_MAILLAGE   = self.get_cmd("LIRE_MAILLAGE")
 125   LIRE_CHAMP      = self.get_cmd("LIRE_CHAMP")
 126 #
 127 # 1.4. ==> Le nom du programme HOMARD e lancer
 128 #
 129   repertoire_outils = aster.repout()
 130   homard            = repertoire_outils + "homard"
 131 #
 132 # 1.5. ==> Initialisations
 133 #
 134   codret_partiel = [0]
 135   Rep_Calc_ASTER = os.getcwd()
 136 #
 137   liste_maillages = []
 138   liste_champs    = []
 139   liste_zones     = []
 140   dico_indi = {}
 141 #
 142   LISTE_ADAPTATION_LIBRE = ("RAFF_DERA" , "RAFFINEMENT" , "DERAFFINEMENT")
 143 #
 144   if ( INFO == 2 ) :
 145     infomail = "OUI"
 146     infocomm = 2
 147   else :
 148     infomail = "NON"
 149     infocomm = 1
 150 #
 151 #====================================================================
 152 # 2. Decodage des arguments de la macro-commande
 153 #====================================================================
 154 # 2.1. ==> Donnees de pilotage de l'adaptation
 155 #
 156   if ( self.nom == "MACR_ADAP_MAIL" ) :
 157 #
 158     mode_homard = "ADAP"
 159 #
 160 # 2.1.1. ==> Les concepts "maillage"
 161 #
 162 #gn    print "\n.. Debut de 2.1.1"
 163 #    for mot_cle in ["MAILLAGE_N" , "MAILLAGE_NP1"] :
 164     for mot_cle in ["MAILLAGE_N" , "MAILLAGE_NP1" , "MAILLAGE_NP1_ANNEXE"] :
 165 #gn      print "\nmot_cle = ",mot_cle
 166       dico = {}
 167       dico["Type_Maillage"] = mot_cle
 168       if ( args[mot_cle] != None ) :
 169 #gn        print "==> args[",mot_cle,"] = ",args[mot_cle]
 170         dico["Nom_ASTER"] = args[mot_cle]
 171         if ( mot_cle == "MAILLAGE_N" ) :
 172           dico["Action"] = "A_ecrire"
 173         else :
 174           dico["Action"] = "A_lire"
 175       else :
 176         dico["Action"] = "Rien"
 177 #gn      print "dico = ",dico
 178       liste_maillages.append(dico)
 179 #
 180 # 2.1.2. ==> L'eventuel indicateur d'erreur
 181 #
 182 #gn    print "\n.. Debut de 2.1.2"
 183 #gn    print "args = ", args
 184     if args["ADAPTATION"] in LISTE_ADAPTATION_LIBRE :
 185       dico = {}
 186       dico["Type_Champ"] = "INDICATEUR"
 187       if ( args["RESULTAT_N"] != None ) :
 188         lresu = 1
 189         dico["RESULTAT"]   = args["RESULTAT_N"]
 190         noresu = dico["RESULTAT"].nom
 191         dico["NOM_CHAM"]   = args["INDICATEUR"]
 192         nomsym = dico["NOM_CHAM"]
 193         if ( args["NUME_ORDRE"] != None ) :
 194           dico["NUME_ORDRE"] = args["NUME_ORDRE"]
 195         if ( args["INST"] != None ) :
 196           dico["INST"] = args["INST"]
 197           for cle in [ "PRECISION", "CRITERE" ] :
 198             if ( args[cle] != None ) :
 199               dico[cle] = args[cle]
 200         if ( args["SENSIBILITE"] != None ) :
 201           dico["SENSIBILITE"] = args["SENSIBILITE"]
 202       else :
 203         lresu = 0
 204         dico["CHAM_GD"] = args["CHAM_GD"]
 205         noresu = dico["CHAM_GD"].nom
 206         nomsym = " "
 207 #gn      print "dico = ", dico
 208 #
 209       if dico.has_key("SENSIBILITE") :
 210         nopase = dico["SENSIBILITE"].nom
 211       else :
 212         nopase = " "
 213 #gn      print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
 214       dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase )
 215 #gn      print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"]
 216       dico["COMPOSANTE"] = args["NOM_CMP_INDICA"]
 217       liste_champs.append(dico)
 218       dico_indi = dico
 219 ###      print dico
 220 #
 221 # 2.1.3. ==> Les champs e mettre e jour
 222 #
 223 #gn     print "\n.. Debut de 2.1.3."
 224 #
 225     if args.has_key("MAJ_CHAM") :
 226 #
 227       if args["MAJ_CHAM"] is None :
 228         les_champs = []
 229       else :
 230         les_champs = args["MAJ_CHAM"]
 231 #
 232       for maj_cham in les_champs :
 233 #gn        print maj_cham
 234 #gn        print type(maj_cham)
 235 #
 236         dico = {}
 237         dico["Type_Champ"] = "CHAMP_MAJ"
 238         liste_aux = [ "CHAM_MAJ", "TYPE_CHAM" ]
 239         if ( maj_cham["RESULTAT"] != None ) :
 240           lresu = 1
 241           liste_aux.append("RESULTAT")
 242           liste_aux.append("NOM_CHAM")
 243           if ( maj_cham["NUME_ORDRE"] != None ) :
 244             dico["NUME_ORDRE"] = maj_cham["NUME_ORDRE"]
 245           elif ( maj_cham["INST"] != None ) :
 246             dico["INST"] = maj_cham["INST"]
 247             for cle in [ "PRECISION", "CRITERE" ] :
 248               if ( maj_cham[cle] != None ) :
 249                 dico[cle] = maj_cham[cle]
 250           noresu = maj_cham["RESULTAT"].nom
 251           nomsym = maj_cham["NOM_CHAM"]
 252           if ( maj_cham["SENSIBILITE"] != None ) :
 253             dico["SENSIBILITE"] = maj_cham["SENSIBILITE"]
 254         else :
 255           lresu = 0
 256           liste_aux.append("CHAM_GD")
 257           noresu = maj_cham["CHAM_GD"].nom
 258           nomsym = " "
 259         for cle in liste_aux :
 260           dico[cle] = maj_cham[cle]
 261 #gn        print "dico = ", dico
 262 #
 263         if dico.has_key("SENSIBILITE") :
 264           nopase = dico["SENSIBILITE"].nom
 265         else :
 266           nopase = " "
 267 #gn        print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
 268         dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase )
 269 #gn        print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"]
 270 #
 271 ###        print dico
 272         liste_champs.append(dico)
 273 #
 274 # 2.1.4. ==> Les zones de raffinement
 275 #
 276 ###    print "\n.. Debut de 2.1.4."
 277 #
 278     if args.has_key("ZONE") :
 279 #
 280       if args["ZONE"] is not None :
 281         les_zones = args["ZONE"]
 282 #
 283       for zone in les_zones :
 284 ###        print zone
 285 ###        print type(zone)
 286         dico = {}
 287         for aux in ['X_MINI', 'X_MAXI', 'Y_MINI', 'Y_MAXI', 'Z_MINI', 'Z_MAXI', 'X_CENTRE', 'Y_CENTRE', 'Z_CENTRE', 'RAYON'] :
 288           if ( zone[aux] != None ) :
 289             dico[aux] = zone[aux]
 290 ###        print dico
 291         liste_zones.append(dico)
 292 #
 293 ###    print liste_zones
 294 #
 295 # 2.2. ==> Donnees de pilotage de l'information
 296 #
 297   else :
 298 #
 299     mode_homard = "INFO"
 300 #
 301     dico = {}
 302     dico["Type_Maillage"] = "MAILLAGE_N"
 303     dico["Nom_ASTER"]     = args["MAILLAGE"]
 304     dico["Action"]        = "A_ecrire"
 305     liste_maillages.append(dico)
 306 #
 307 # 2.3. ==> Suivi de frontiere
 308 #
 309 #gn   print "\n.. Debut de 2.3."
 310 #
 311   if ( MAILLAGE_FRONTIERE != None ) :
 312 #
 313     dico = {}
 314     dico["Type_Maillage"] = "MAILLAGE_FRONTIERE"
 315     dico["Nom_ASTER"]     = MAILLAGE_FRONTIERE
 316     dico["Action"]        = "A_ecrire"
 317     liste_maillages.append(dico)
 318 #
 319 # 2.4. ==> Le numero de version de HOMARD
 320 #    Remarque : dans la donnee de la version de HOMARD, il faut remplacer
 321 #               le _ de la donnee par un ., qui est interdit dans la
 322 #               syntaxe du langage de commandes ASTER
 323 #    Remarque : il faut remplacer le N majuscule de la donnee par
 324 #               un n minuscule, qui est interdit dans la syntaxe du langage
 325 #               de commandes ASTER
 326 #
 327 #gn  print "\n.. Debut de 2.4. avec VERSION_HOMARD = ", VERSION_HOMARD
 328   VERSION_HOMARD = string.replace(VERSION_HOMARD,"_" , ".")
 329   VERSION_HOMARD = string.replace(VERSION_HOMARD,"N" , "n")
 330 #
 331   if ( VERSION_HOMARD[-6:]==".PERSO" ):
 332     VERSION_HOMARD = VERSION_HOMARD[:-6]
 333     version_perso = 1
 334   else :
 335     version_perso = 0
 336 #gn  print ".... VERSION_HOMARD = ", VERSION_HOMARD
 337 #gn  print ".... version_perso  = ", version_perso
 338 #
 339 #====================================================================
 340 # 3. Preparation du lancement des commandes
 341 #====================================================================
 342 #
 343 # 3.1. ==> . Elaboration des noms MED des concepts de maillage
 344 #          . Memorisation des noms ASTER du maillage en entree et en sortie (sous forme string)
 345 #
 346 #          On cree une nouvelle liste des dictionnaires decrivant les maillages
 347 #          et e la fin on ecrase l'ancienne liste par cette nouvelle.
 348 #
 349 #gn  print "\n.. Debut de 3.1."
 350 #
 351   Nom_Concept_Maillage_NP1_ANNEXE = None
 352   l_aux = []
 353   for dico in liste_maillages :
 354 #gn    print "\ndico avant = ",dico
 355     if ( dico["Action"] != "Rien" ) :
 356       dico["NOM_MED"] = aster.mdnoma(dico["Nom_ASTER"].nom)
 357       l_aux.append(dico)
 358       if ( dico["Type_Maillage"] == "MAILLAGE_N" ) :
 359         Nom_Concept_Maillage_N = dico["Nom_ASTER"].nom
 360       elif ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) :
 361         Nom_Concept_Maillage_NP1 = dico["Nom_ASTER"].nom
 362       elif ( dico["Type_Maillage"] == "MAILLAGE_NP1_ANNEXE" ) :
 363         Nom_Concept_Maillage_NP1_ANNEXE = dico["Nom_ASTER"].nom
 364 #gn    print "\ndico apres = ",dico
 365   liste_maillages = l_aux
 366 #
 367 # 3.2. ==> Recherche du numero d'iteration et du repertoire de travail
 368 #
 369 # 3.2.1. ==> Par defaut :
 370 #            . le numero d'iteration est nul
 371 #            . le nom du repertoire de lancement de HOMARD est construit sur le nom
 372 #              du maillage en entree et le numero de passage dans la fonction
 373 #
 374 #gn  print "\.. Debut de 3.2.1."
 375 #
 376   niter = 0
 377   Nom_Rep_local = Nom_Concept_Maillage_N + "_" + mode_homard + "_" + str(numero_passage_fonction)
 378   Rep_Calc_HOMARD_local = os.path.join(".", Nom_Rep_local)
 379   Rep_Calc_HOMARD_global = os.path.join(Rep_Calc_ASTER, Nom_Rep_local)
 380 ###  print "Rep_Calc_HOMARD_local  = ", Rep_Calc_HOMARD_local
 381 ###  print "Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
 382 #
 383 # 3.2.2. ==> En adaptation : il faut repartir du repertoire de l'iteration precedente
 384 #
 385 #gn  print "\.. Debut de 3.2.2."
 386 #
 387   if ( mode_homard == "ADAP" ) :
 388 #
 389 # 3.2.2.1. ==> On recherche si dans les passages deje effectues, il en existe un
 390 #              dont le maillage d'arrivee etait l'actuel maillage d'entree. Si c'est
 391 #              le cas, cela veut dire que l'adaptation en cours est la suite d'une
 392 #              precedente. On doit donc utiliser le meme repertoire. Le numero
 393 #              d'iteration est celui de l'adaptation precedente augmente de 1.
 394 #
 395 #gn     print "\.. Debut de 3.2.2.1."
 396 #
 397     for dico in Liste_Passages :
 398       if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
 399         niter   = dico["niter"] + 1
 400         Rep_Calc_HOMARD_local  = dico["Rep_Calc_HOMARD_local"]
 401         Rep_Calc_HOMARD_global = dico["Rep_Calc_HOMARD_global"]
 402 #
 403 # 3.2.2.2. ==> Memorisation de ce passage
 404 #
 405 #gn     print "\.. Debut de 3.2.2.2."
 406 #
 407 # 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure
 408 #
 409     if ( niter == 0 ) :
 410       dico = {}
 411       dico["Maillage_0"]   = Nom_Concept_Maillage_N
 412       dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
 413       dico["Maillage_NP1_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE
 414       dico["Rep_Calc_HOMARD_local"]  = Rep_Calc_HOMARD_local
 415       dico["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global
 416       dico["niter"]        = niter
 417       Liste_Passages.append(dico)
 418 #
 419 # 3.2.2.2.2. ==> Modification du cas en cours
 420 #
 421     else :
 422       l_aux = []
 423       for dico in Liste_Passages :
 424         if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
 425           dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
 426           dico["Maillage_NP1_ANNEXE"] = Nom_Concept_Maillage_NP1_ANNEXE
 427           dico["niter"]        = niter
 428         l_aux.append(dico)
 429       Liste_Passages = l_aux
 430 #
 431 ###  print "niter = ", niter, ", Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
 432 #
 433 # 3.2.3. Creation du repertoire pour homard
 434 #        attention : on ne fait cette creation qu'une seule fois par cas
 435 #                    d'adaptation ou d'information
 436 #
 437 #gn  print "\.. Debut de 3.2.3."
 438 #
 439   if ( niter == 0 ) :
 440 #
 441     try :
 442       os.mkdir(Rep_Calc_HOMARD_global)
 443     except os.error,codret_partiel :
 444       self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
 445       UTMESS("F",'HOMARD0_4',valk=Rep_Calc_HOMARD_global)
 446 #
 447 #====================================================================
 448 # 4. Ecriture des commandes de creation des donnees MED
 449 #====================================================================
 450 #
 451 #gn  print "\.. Debut de 4."
 452 #
 453 #  On doit ecrire : le maillage,
 454 #                   le champ d'indicateur d'erreur
 455 #                   les champs e convertir
 456 #  Remarque : on met tout dans le meme fichier
 457 #
 458 #  Chacune de ces ecritures est optionnelle selon le contexte.
 459 #
 460 # 4.1. ==> Noms des fichiers d'ASTER vers HOMARD et eventuellement de HOMARD vers ASTER
 461 #          Remarque : aujourd'hui, les ecritures ou les lectures au format MED se font obligatoirement sur
 462 #                     un fichier de nom fort.n, place dans le repertoire de calcul
 463 ##
 464 # 4.1.1. ==> D'ASTER vers HOMARD
 465 #
 466   unite_fichier_aster_vers_homard = 1787 + 2*numero_passage_fonction
 467   fichier_aster_vers_homard = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_aster_vers_homard))
 468 ###  print "fichier_aster_vers_homard = ",fichier_aster_vers_homard
 469 #
 470 # 4.1.2. ==> De HOMARD vers ASTER
 471 #
 472   if ( mode_homard == "ADAP" ) :
 473     unite_fichier_homard_vers_aster = unite_fichier_aster_vers_homard + 1
 474     fichier_homard_vers_aster = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_homard_vers_aster))
 475 ###    print "fichier_homard_vers_aster = ",fichier_homard_vers_aster
 476 #
 477 # 4.2. La definition du fichier de ASTER vers HOMARD
 478 #
 479   DEFI_FICHIER ( ACTION= "ASSOCIER",
 480                  UNITE = unite_fichier_aster_vers_homard,
 481                  TYPE = "LIBRE",
 482                  INFO = infocomm )
 483 #
 484 # 4.3. Le(s) maillage(s)
 485 # Le maillage de calcul et l'eventuel maillage de la frontiere sont ecrits
 486 # dans le meme fichier MED
 487 # En fait, on pourrait s'en passer au dela de la 1ere iteration
 488 # car HOMARD a memorise. Mais des que l'on ecrit un champ,
 489 # les conventions MED imposent la presence du maillage dans le fichier.
 490 # Donc on va toujours ecrire.
 491 #
 492   for dico in liste_maillages :
 493     if ( dico["Action"] == "A_ecrire" ) :
 494       motscsi = {}
 495       motscsi["MAILLAGE"] = dico["Nom_ASTER"]
 496       motscfa = {}
 497       motscfa["RESU"] = _F( INFO_MAILLAGE=infomail,
 498                           **motscsi )
 499 #
 500       IMPR_RESU ( INFO = infocomm,
 501                   FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard,
 502                   **motscfa )
 503 #
 504 # 4.4. Le(s) champ(s)
 505 #        Attention : il se peut que l'on demande la mise e jour du champ qui a servi comme
 506 #                    indicateur d'erreur. Si c'est le cas, il ne faut pas demander son
 507 #                    impression sinon il y a plantage d'IMPR_RESU qui ne sait pas substituer
 508 #                    deux champs. D'ailleurs, c'est plus economique ainsi !
 509 #        Remarque : pour l'adaptation, on ne demande a priori qu'une composante du champ d'indicateur.
 510 #                   s'il y a demande de mise e jour, toutes les composantes sont concernees. Il faut
 511 #                   donc dans ce cas imprimer le champ total.
 512 #        dico["Type_Champ"]   = o ; string ; "INDICATEUR" ou "CHAMP_MAJ"
 513 #        dico["RESULTAT"]     = f ; concept ASTER du resutat associe
 514 #        dico["NOM_CHAM"]     = f ; string ; Nom ASTER du champ
 515 #        dico["CHAM_GD"]      = f ; concept ASTER du champ de grandeur associee
 516 #        dico["COMPOSANTE"]   = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
 517 #        dico["NUME_ORDRE"]   = f ; entier ; Numero d'ordre du champ
 518 #        dico["INST"]         = f ; entier ; Instant du champ
 519 #        dico["PRECISION"]    = f ; entier ; Precision sur l'instant du champ
 520 #        dico["CRITERE"]      = f ; entier ; Critere de precision sur l'instant du champ
 521 #        dico["CHAM_MAJ"]     = f ; string ; Nom ASTER du champ interpole sur le nouveau maillage
 522 #        dico["NOM_MED"]      = o ; string ; Nom MED du champ
 523 #        dico["SENSIBILITE"]  = f ; string ; Nom du parametre sensible associe
 524 #
 525 # 4.4.1. Recherche d'un doublon eventuel sur le champ d'indicateur d'erreur
 526 #
 527 #gn  print "dico_indi = ",dico_indi
 528   if len(dico_indi) > 0 :
 529     indic_est_deja_imprime = 0
 530     if dico_indi.has_key("RESULTAT") :
 531       liste_aux = [ "RESULTAT", "NOM_CHAM" ]
 532     else :
 533       liste_aux = [ "CHAM_GD" ]
 534   else :
 535     indic_est_deja_imprime = 1
 536     liste_aux = [ ]
 537 #gn  print ".. Au debut de la boucle, liste_aux = ",liste_aux
 538 #gn  print ".. Au debut de la boucle, indic_est_deja_imprime = ",indic_est_deja_imprime
 539 #
 540   liste_champs_imprime = []
 541   for dico in liste_champs :
 542 ###    print "\n.... dico = ",dico
 543 #   Pour un champ e mettre e jour, on a toujours impression
 544     if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
 545       liste_champs_imprime.append(dico)
 546 #     Si le champ d'indicateur n'a toujours pas ete repere comme champ e mettre e jour :
 547       if not indic_est_deja_imprime :
 548 #       Est-ce le meme champ ?
 549         on_a_le_champ = 1
 550         for cle in liste_aux :
 551           if ( dico.has_key(cle) ) :
 552 ###            print "...... dico_indi[cle] = ",dico_indi[cle]
 553 ###            print "...... dico[cle]      = ",dico[cle]
 554             if ( dico_indi[cle] != dico[cle] ) :
 555               on_a_le_champ = 0
 556               break
 557           else :
 558             on_a_le_champ = 0
 559             break
 560 #       Si oui, est-ce un champ sensible ou non ?
 561         if on_a_le_champ :
 562           cle = "SENSIBILITE"
 563           if dico.has_key(cle) :
 564             if ( dico[cle] != None ) :
 565               if dico_indi.has_key(cle) :
 566                 if ( dico_indi[cle] != dico[cle] ) :
 567                   on_a_le_champ = 0
 568                   break
 569               else :
 570                 on_a_le_champ = 0
 571                 break
 572 #       Si oui, est-ce au meme moment ? (remarque : si rien n'est designe, c'est qu'il n'y a qu'un
 573 #       seul instant ... donc c'est le meme ! En revanche, on ne sait pas comparer une donnee
 574 #       en numero d'ordre et une donnee en instant. On croise les doigts.)
 575         if on_a_le_champ :
 576           for cle in [ "NUME_ORDRE", "INST" ] :
 577             if dico.has_key(cle) :
 578               if ( dico[cle] != None ) :
 579                 if dico_indi.has_key(cle) :
 580                   if ( dico_indi[cle] != dico[cle] ) :
 581                     on_a_le_champ = 0
 582                     break
 583         if on_a_le_champ :
 584           indic_est_deja_imprime = 1
 585 ###  print "\n\nFin de la boucle .. indic_est_deja_imprime = ",indic_est_deja_imprime
 586 #   Si le champ d'indicateur n'a pas ete repere comme champ e mettre e jour, il faut
 587 #   l'inclure dans les champs e imprimer
 588   if not indic_est_deja_imprime :
 589     liste_champs_imprime.append(dico_indi)
 590 #
 591 # 4.4.2. Impressions apres le filtrage precedent
 592 #gn  print "\n.... Debut de 4.2.4.2."
 593 #
 594   for dico in liste_champs_imprime :
 595     motscsi = {}
 596     for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
 597       if dico.has_key(cle) :
 598         if ( dico[cle] != None ) :
 599           motscsi[cle] = dico[cle]
 600     if dico.has_key("COMPOSANTE") :
 601       motscsi["NOM_CMP"] = dico["COMPOSANTE"]
 602     if dico.has_key("SENSIBILITE") :
 603       motscsi["SENSIBILITE"] = dico["SENSIBILITE"]
 604     motscfa = {}
 605     motscfa["RESU"] = _F( INFO_MAILLAGE=infomail,
 606                         **motscsi
 607                       )
 608 #gn    print ".. motscfa = ",motscfa
 609 #
 610     IMPR_RESU ( INFO = infocomm,
 611                 FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard,
 612                 **motscfa )
 613 #
 614 #====================================================================
 615 # 5. ==> Creation des fichiers de donnees pour HOMARD
 616 #====================================================================
 617 #
 618 #gn  print "\.. Debut de 5."
 619 #
 620   dico_configuration = {}
 621 #
 622 # 5.1. ==> Les generalites
 623 #
 624   dico_configuration["INFO"] = INFO
 625 #
 626   dico_configuration["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global
 627   dico_configuration["VERSION_HOMARD"] = VERSION_HOMARD
 628   dico_configuration["version_perso"] = version_perso
 629 #
 630   dico_configuration["niter"] = niter
 631   dico_configuration["Fichier_ASTER_vers_HOMARD"] = fichier_aster_vers_homard
 632   if ( mode_homard == "ADAP" ) :
 633     dico_configuration["Fichier_HOMARD_vers_ASTER"] = fichier_homard_vers_aster
 634 #
 635 # 5.2. ==> Les noms med des maillages
 636 #
 637   for dico in liste_maillages :
 638 #gn    print "Nom MED de " + dico["Type_Maillage"] + " = " + dico["NOM_MED"]
 639     dico_configuration[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"]
 640 #gn  print dico_configuration
 641 #
 642 # 5.3. ==> Les caracteristiques de l'eventuel indicateur d'erreur
 643 #
 644   for dico in liste_champs :
 645     dico_aux = {}
 646     if ( dico["Type_Champ"] == "INDICATEUR" ) :
 647       liste_aux = [ "NOM_MED", "COMPOSANTE" ]
 648       if dico.has_key("NUME_ORDRE") :
 649         liste_aux.append("NUME_ORDRE")
 650       for cle in liste_aux :
 651         if ( dico[cle] != None ) :
 652           dico_aux[cle] = dico[cle]
 653       dico_configuration["Indicateur"] = dico_aux
 654 #gn  if dico_configuration.has_key("Indicateur") :
 655 #gn    print "dico_configuration[Indicateur] = ", dico_configuration["Indicateur"]
 656 #
 657 # 5.4. ==> Les eventuelles zones de raffinement
 658 #
 659   prem = 1
 660   for dico in liste_zones :
 661     if prem :
 662       l_aux = [dico]
 663       prem = 0
 664     else :
 665       l_aux = dico_configuration["Zones"]
 666       l_aux.append(dico)
 667     dico_configuration["Zones"] = l_aux
 668 ###  if dico_configuration.has_key("Zones") :
 669 ###    print "dico_configuration[Zones] = ", dico_configuration["Zones"]
 670 #
 671 # 5.5. ==> La mise e jour de champs
 672 #
 673   prem = 1
 674   for dico in liste_champs :
 675     dico_aux = {}
 676     if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
 677       liste_aux = [ "NOM_MED", "COMPOSANTE" ]
 678       if dico.has_key("NUME_ORDRE") :
 679         liste_aux.append("NUME_ORDRE")
 680       else :
 681         for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] :
 682           liste_aux.append(cle)
 683       for cle in liste_aux :
 684         if dico.has_key(cle) :
 685           if ( dico[cle] != None ) :
 686             dico_aux[cle] = dico[cle]
 687 #gn      print dico_aux
 688       if prem :
 689         l_aux = [dico_aux]
 690         prem = 0
 691       else :
 692         l_aux = dico_configuration["Champs"]
 693         l_aux.append(dico_aux)
 694       dico_configuration["Champs"] = l_aux
 695 #gn  if dico_configuration.has_key("Champs") :
 696 #gn   print "dico_configuration[Champs] = ", dico_configuration["Champs"]
 697 #
 698 # 5.6. ==> Appel de la fonction de creation
 699 #
 700   donnees_homard = creation_donnees_homard.creation_donnees_homard ( self.nom, args, dico_configuration )
 701   if ( INFO >= 4 ) :
 702     donnees_homard.quel_mode ( )
 703   fic_homard_niter, fic_homard_niterp1 = donnees_homard.creation_configuration ( )
 704   donnees_homard.ecrire_fichier_configuration ( )
 705   if ( mode_homard == "INFO" ) :
 706     Nom_Fichier_Donnees = donnees_homard.ecrire_fichier_donnees ( )
 707   else :
 708     Nom_Fichier_Donnees = "0"
 709 #
 710 # 5.7. ==> Impression eventuelle des fichiers crees
 711 #
 712 #gn  print "Repertoire ",Rep_Calc_HOMARD_global
 713 #gn  os.system("ls -la "+Rep_Calc_HOMARD_global)
 714   if ( INFO >= 4 ) :
 715     l_aux = ["HOMARD.Donnees" , "HOMARD.Configuration"]
 716   else :
 717     l_aux = [ ]
 718   for nomfic in l_aux :
 719     fic = os.path.join(Rep_Calc_HOMARD_global, nomfic)
 720     if os.path.isfile (fic) :
 721       print "\n\n=============================================================="
 722       print "Contenu de", nomfic
 723       fichier = open (fic,"r")
 724       les_lignes = fichier.readlines()
 725       fichier.close()
 726       for ligne in les_lignes :
 727         print ligne[:-1]
 728       print "==============================================================\n"
 729 #gn  if ( mode_homard == "ADAP" ) :
 730 #gn    if args.has_key("MAJ_CHAM") :
 731 #gn      if args["MAJ_CHAM"] is not None :
 732 #gn        import time
 733 #gn        time.sleep(3600)
 734 #
 735 #====================================================================
 736 # 6. Ecriture de la commande d'execution de homard
 737 #====================================================================
 738 #
 739 #
 740 #gn  print "\.. Debut de 6."
 741 #gn  os.system("cp " + Rep_Calc_HOMARD_global + "/../fort.17* $HOME/aster")
 742 #gn  os.system("cp " + Rep_Calc_HOMARD_global + "/HOMARD.Configuration $HOME/aster/HOMARD.Configuration"+str(niter))
 743 #gn  fichier_aster_vers_homard_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_aster_vers_homard))
 744 #gn  shutil.copyfile(fichier_aster_vers_homard, fichier_aster_vers_homard_2)
 745 #
 746   iaux = INFO
 747   EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_HOMARD_global, # nom du repertoire
 748                               VERSION_HOMARD,         # version de homard
 749                               str(iaux),              # niveau d information
 750                               Nom_Fichier_Donnees,    # fichier de donnees HOMARD
 751                               str(version_perso),     # version personnelle de homard ?
 752                              ),
 753                   LOGICIEL = homard,
 754                   INFO     = INFO,
 755                 )
 756 #gn  import time
 757 #gn  time.sleep(3600)
 758 #
 759 #gn  if ( mode_homard == "ADAP" ) :
 760 #gn    fichier_homard_vers_aster_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster))
 761 #gn    shutil.copyfile(fichier_homard_vers_aster, fichier_homard_vers_aster_2)
 762 #gn    fichier_homard_vers_aster_2_1 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".1")
 763 #gn    os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_1+"</tmp/donn1")
 764 #gn    fichier_homard_vers_aster_2_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".2")
 765 #gn    os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_2+"</tmp/donn2")
 766 #
 767 #====================================================================
 768 # 7. ==> Ecriture de la commande de lecture des resultats med
 769 #        Remarque :
 770 #        La fonction self.DeclareOut(a,b) fonctionne ainsi :
 771 #        a est une chaine de caracteres
 772 #        b est la variable declaree dans la commande
 773 #        le but est de associer le contenu de b e la variable locale qui sera designee par a
 774 #        Exemple :
 775 #        self.DeclareOut("maillage_a_lire",args["MAILLAGE_NP1"])
 776 #        ==> la variable maillage_a_lire est identifiee e l'argument "MAILLAGE_NP1"
 777 #====================================================================
 778 #
 779   if ( mode_homard == "ADAP" ) :
 780 #
 781 # 7.1. ==> Le maillage
 782 #          On inhibe l'alarme MODELISA5_49 qui apparait car on fait VERIF=NON
 783 #
 784 #gn    print "args = ",args
 785     for dico in liste_maillages :
 786 #gn      print dico
 787       if ( dico["Action"] == "A_lire" ) :
 788 #
 789         MasquerAlarme('MODELISA5_49')
 790 #
 791         self.DeclareOut("maillage_a_lire", dico["Nom_ASTER"])
 792         maillage_a_lire = LIRE_MAILLAGE ( UNITE = unite_fichier_homard_vers_aster,
 793                                        FORMAT = "MED",
 794                                        NOM_MED = dico["NOM_MED"],
 795                                        VERI_MAIL = _F(VERIF="NON"), INFO_MED = infocomm, INFO = infocomm )
 796 #
 797         RetablirAlarme('MODELISA5_49')
 798 #
 799 #gn        print "MAILLAGE = ",maillage_a_lire
 800 #gn        print "NOM_MED = ",dico["NOM_MED"]
 801         if ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) :
 802           maillage_np1 = maillage_a_lire
 803           maillage_np1_nom_med = dico["NOM_MED"]
 804 #
 805 # 7.2. ==> Les champs
 806 #gn    import time
 807 #gn    time.sleep(3600)
 808 #
 809     for dico in liste_champs :
 810       if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
 811 #gn        print dico
 812         self.DeclareOut("champ_maj", dico["CHAM_MAJ"])
 813         motscsi = {}
 814         for cle in [ "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
 815           if dico.has_key(cle) :
 816             if ( dico[cle] != None ) :
 817               motscsi[cle] = dico[cle]
 818         if dico.has_key("NUME_ORDRE") :
 819           motscsi["NUME_PT"] = dico["NUME_ORDRE"]
 820 #gn        print "MAILLAGE = ",maillage_np1
 821 #gn        print "NOM_MAIL_MED = ",maillage_np1_nom_med
 822 #gn        print "NOM_MED = ",dico["NOM_MED"]
 823 #gn        print "TYPE_CHAM =", dico["TYPE_CHAM"]
 824         champ_maj = LIRE_CHAMP ( UNITE = unite_fichier_homard_vers_aster, FORMAT = "MED",
 825                                  MAILLAGE = maillage_np1, NOM_MAIL_MED=maillage_np1_nom_med,
 826                                  NOM_MED = dico["NOM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"],
 827                                  INFO = infocomm, **motscsi )
 828 #
 829 #====================================================================
 830 # 8. Menage des fichiers devenus inutiles
 831 #    On doit imperativement garder le dernier fichier homard produit
 832 #    En mode d'information, on garde egalement les fichiers textes
 833 #====================================================================
 834 #
 835   liste_aux = [fichier_aster_vers_homard]
 836   liste_aux_bis = os.listdir(Rep_Calc_HOMARD_global)
 837   for fic in liste_aux_bis :
 838     fic_total = os.path.join(Rep_Calc_HOMARD_global, fic)
 839     liste_aux.append(fic_total)
 840   liste_aux_bis = []
 841   if ( mode_homard == "ADAP" ) :
 842     liste_aux.append(fichier_homard_vers_aster)
 843     fic = os.path.join(Rep_Calc_HOMARD_global, fic_homard_niterp1)
 844     liste_aux_bis.append(fic)
 845 #gn  os.system("cp " + Rep_Calc_HOMARD_global + "/* $HOME/aster")
 846 #
 847   for fic in liste_aux :
 848     if fic not in liste_aux_bis :
 849       if ( INFO >= 3 ) :
 850         print "Destruction du fichier ", fic
 851       if os.path.isfile(fic) :
 852         try :
 853           os.remove(fic)
 854         except os.error,codret_partiel :
 855           self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
 856           UTMESS("F",'HOMARD0_5',valk=fic)
 857 #gn  print "Repertoire ",Rep_Calc_HOMARD_global
 858 #gn  os.system("ls -la "+Rep_Calc_HOMARD_global)
 859 #gn  print "Repertoire ",Rep_Calc_ASTER
 860 #gn  os.system("ls -la "+Rep_Calc_ASTER)
 861 #gn  print os.listdir(Rep_Calc_HOMARD_global)
 862 #
 863 #====================================================================
 864 #  C'est fini !
 865 #====================================================================
 866 #
 867 ###  if ( mode_homard == "ADAP" and niter == 3 ) :
 868 ###  if ( niter == 2 ) :
 869 ###    import time
 870 ###    time.sleep(3600)
 871 #
 872   return