Aster/Cata/cataSTA9/Macro/macr_adap_mail_ops.py

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