Aster/Cata/cataSTA76/Macro/macr_adap_mail_ops.py

   1 #@ MODIF macr_adap_mail_ops Macro  DATE 05/10/2004   AUTEUR CIBHHLV L.VIVAN
   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 def macr_adap_mail_ops ( self,
  23                          INFO, VERSION_HOMARD, LANGUE,
  24                          NOMBRE, QUALITE, CONNEXITE, TAILLE, INTERPENETRATION,
  25                          NON_SIMPLEXE, MAILLAGE_FRONTIERE,
  26                          **args):
  27   """
  28      Ecriture des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
  29      Remarque : on ne mentionne explicitement que les mots-clés communs aux
  30                 deux macros. Les autres sont dans le dictionnaire args
  31   """
  32 #
  33 #  1. args est le dictionnaire des arguments
  34 #     args.keys() est la liste des mots-clés
  35 #     args.keys()[0] est la premiere valeur de cette liste
  36 #     args.keys()[1:] est la liste des valeurs suivantes dans cette liste
  37 #     args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante.
  38 #
  39 ###  print args
  40 ###  print args.keys()
  41 ###  if len (args.keys())>0 : print args.keys()[0]
  42 ###  print args["MAILLAGE"]
  43 #
  44 #  2. Les caractéristiques d'un passage sont conservées dans un dictionnaire. Il y a autant de
  45 #     dictionnaires que de sollicitations pour une série d'adaptation. L'ensemble de ces dictionnaires
  46 #     est conservé dans la liste Liste_Passages. Cette liste est nécessairement globale pour pouvoir
  47 #     la retrouver à chaque nouveau passage.
  48 #     Description du dictionnaire de passages :
  49 #        dico["Maillage_0"]             = o ; string ; nom du concept du maillage initial de la série d'adaptation
  50 #        dico["Maillage_NP1"]           = o ; string ; nom du concept du dernier maillage adapté
  51 #        dico["Rep_Calc_HOMARD_global"] = o ; string ; Nom global du répertoire de calcul pour HOMARD
  52 #        dico["Rep_Calc_HOMARD_local"]  = o ; string ; Nom local du répertoire de calcul pour HOMARD
  53 #                                                      depuis le répertoire de calcul pour ASTER
  54 #        dico["niter"]                  = o ; entier ; numéro d'itération
  55 #
  56 #  3. Les caractéristiques d'un maillage sont conservées dans un dictionnaire. Il y a autant de
  57 #     dictionnaires que de maillages manipulés. L'ensemble de ces dictionnaires est conservé
  58 #     dans la liste Liste_Maillages.
  59 #     Description du dictionnaire de maillages :
  60 #        dico["Type_Maillage"] = o ; string ; "MAILLAGE_N", "MAILLAGE_NP1" ou "MAILLAGE_FRONTIERE"
  61 #        dico["Nom_ASTER"]     = o ; concept ASTER associé
  62 #        dico["Action"]        = o ; string ; "A_ecrire" ou "A_lire"
  63 #        dico["NOM_MED"]       = o ; string ; Nom MED du maillage
  64 #
  65 #  4. Les caractéristiques d'un champ sont conservées dans un dictionnaire. Il y a autant de
  66 #     dictionnaires que de champs manipulés. L'ensemble de ces dictionnaires est conservé
  67 #     dans la liste Liste_Champs.
  68 #     Description du dictionnaire de champs :
  69 #        dico["Type_Champ"]   = o ; string ; "INDICATEUR" ou "CHAMP"
  70 #        dico["RESULTAT"]     = o ; concept ASTER du résutat associé
  71 #        dico["NOM_CHAM"]     = o ; string ; Nom ASTER du champ
  72 #        dico["COMPOSANTE"]   = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
  73 #        dico["NUME_ORDRE"]   = f ; entier ; Numéro d'ordre du champ
  74 #        dico["INST"]         = f ; entier ; Instant du champ
  75 #        dico["PRECISION"]    = f ; entier ; Précision sur l'instant du champ
  76 #        dico["CRITERE"]      = f ; entier ; Critère de précision sur l'instant du champ
  77 #        dico["CHAM_MAJ"]     = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage
  78 #        dico["NOM_MED"]      = o ; string ; Nom MED du champ
  79 #
  80   from Accas import _F
  81   import aster
  82   import string
  83   import types
  84   import os
  85 #
  86   global Liste_Passages
  87 #
  88 #--------------------------------------------------------------------
  89 # 1. Préalables
  90 #--------------------------------------------------------------------
  91 #
  92 # 1.1. ==> La macro compte pour 1 dans la numerotation des commandes
  93 #
  94   self.set_icmd(1)
  95 #
  96 # 1.2. ==> Numéro du passage dans cette macro
  97 #
  98   try :
  99     self.jdc.indice_macro_homard = self.jdc.indice_macro_homard + 1
 100   except :
 101     self.jdc.indice_macro_homard = 1
 102     Liste_Passages = []
 103   Numero_Passage_Fonction = self.jdc.indice_macro_homard
 104 ###  print "Numero_Passage_Fonction = ",Numero_Passage_Fonction
 105 #
 106 # 1.3. ==> On importe les definitions des commandes a utiliser dans la macro
 107 #
 108   DEFI_FICHIER    = self.get_cmd("DEFI_FICHIER")
 109   IMPR_RESU       = self.get_cmd("IMPR_RESU")
 110   EXEC_LOGICIEL   = self.get_cmd("EXEC_LOGICIEL")
 111   IMPR_FICO_HOMA  = self.get_cmd("IMPR_FICO_HOMA")
 112   LIRE_MAILLAGE   = self.get_cmd("LIRE_MAILLAGE")
 113   LIRE_CHAMP      = self.get_cmd("LIRE_CHAMP")
 114   DETRUIRE        = self.get_cmd('DETRUIRE')
 115 #
 116 # 1.4. ==> Le nom du programme HOMARD à lancer
 117 #
 118   repertoire_outils = aster.repout()
 119   homard            = repertoire_outils + "homard"
 120 #
 121 # 1.5. ==> Initialisations
 122 #
 123   codret = 0
 124   codret_partiel = [0]
 125   Rep_Calc_ASTER = os.getcwd()
 126 #
 127   Liste_Maillages = []
 128   Liste_Champs    = []
 129   dico_indi = {}
 130 #
 131   ADAPTATION = None
 132   MAJ_CHAM = None
 133 #
 134   unite = 71
 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     modhom = "ADAP"
 144 #
 145     ADAPTATION = args["ADAPTATION"]
 146     if args.has_key("MAJ_CHAM") :
 147       MAJ_CHAM = args["MAJ_CHAM"]
 148 #
 149 # 2.1.1. ==> Les concepts "maillage"
 150 #
 151     for mot_cle in ["MAILLAGE_N","MAILLAGE_NP1"] :
 152       dico = {}
 153       dico["Type_Maillage"] = mot_cle
 154       dico["Nom_ASTER"]     = ADAPTATION[mot_cle]
 155       if ( mot_cle == "MAILLAGE_N" ) :
 156         dico["Action"] = "A_ecrire"
 157       else :
 158         dico["Action"] = "A_lire"
 159       Liste_Maillages.append(dico)
 160 #
 161 # 2.1.2. ==> L'éventuel indicateur d'erreur
 162 #
 163     if ADAPTATION["LIBRE"] != None :
 164       dico = {}
 165       dico["Type_Champ"] = "INDICATEUR"
 166       dico["RESULTAT"]   = ADAPTATION["RESULTAT_N"]
 167       dico["NOM_CHAM"]   = ADAPTATION["INDICATEUR"]
 168       dico["COMPOSANTE"] = ADAPTATION["NOM_CMP_INDICA"]
 169       if ( ADAPTATION["NUME_ORDRE"] != None ) :
 170         dico["NUME_ORDRE"] = ADAPTATION["NUME_ORDRE"]
 171       if ( ADAPTATION["INST"] != None ) :
 172         dico["INST"] = ADAPTATION["INST"]
 173         for cle in [ "PRECISION", "CRITERE" ] :
 174           if ( ADAPTATION[cle] != None ) :
 175             dico[cle] = ADAPTATION[cle]
 176       dico["NOM_MED"] = aster.mdnoch ( dico["RESULTAT"].nom , dico["NOM_CHAM"] )
 177       Liste_Champs.append(dico)
 178       dico_indi = dico
 179 ###      print dico
 180 #
 181 # 2.1.3. ==> Les champs à mettre à jour
 182 #
 183     if ( MAJ_CHAM != None ) :
 184 #
 185       for maj_cham in MAJ_CHAM :
 186 ###        print maj_cham
 187 #
 188         dico = {}
 189         dico["Type_Champ"] = "CHAMP"
 190         for cle in [ "CHAM_MAJ", "TYPE_CHAM", "RESULTAT", "NOM_CHAM" ] :
 191           dico[cle] = maj_cham[cle]
 192         if ( maj_cham["NUME_ORDRE"] != None ) :
 193           dico["NUME_ORDRE"] = maj_cham["NUME_ORDRE"]
 194         elif ( maj_cham["INST"] != None ) :
 195           dico["INST"] = maj_cham["INST"]
 196           for cle in [ "PRECISION", "CRITERE" ] :
 197             if ( maj_cham[cle] != None ) :
 198               dico[cle] = maj_cham[cle]
 199         dico["NOM_MED"] = aster.mdnoch ( dico["RESULTAT"].nom , dico["NOM_CHAM"] )
 200 #
 201 ###        print dico
 202         Liste_Champs.append(dico)
 203 #
 204 # 2.2. ==> Données de pilotage de l'information
 205 #
 206   else :
 207 #
 208     modhom = "INFO"
 209 #
 210     dico = {}
 211     dico["Type_Maillage"] = "MAILLAGE_N"
 212     dico["Nom_ASTER"]     = args["MAILLAGE"]
 213     dico["Action"]        = "A_ecrire"
 214     Liste_Maillages.append(dico)
 215 #
 216 # 2.3. ==> Suivi de frontière
 217 #
 218   if ( MAILLAGE_FRONTIERE != None ) :
 219 #
 220     dico = {}
 221     dico["Type_Maillage"] = "MAILLAGE_FRONTIERE"
 222     dico["Nom_ASTER"]     = MAILLAGE_FRONTIERE
 223     dico["Action"]        = "A_ecrire"
 224     Liste_Maillages.append(dico)
 225 #
 226 #--------------------------------------------------------------------
 227 # 3. Préparation du lancement des commandes
 228 #--------------------------------------------------------------------
 229 #
 230 # 3.1. ==> . Elaboration des noms MED des concepts de maillage
 231 #          . Memorisation des noms ASTER du maillage en entrée et en sortie (sous forme string)
 232 #          On crée une nouvelle liste des dictionnaires décrivant les maillages
 233 #          et à la fin on écrase l'ancienne liste par cette nouvelle.
 234 #
 235   L = []
 236   for dico in Liste_Maillages :
 237     dico["NOM_MED"] = aster.mdnoma(dico["Nom_ASTER"].nom)
 238     L.append(dico)
 239     if ( dico["Type_Maillage"] == "MAILLAGE_N" ) :
 240       Nom_Concept_Maillage_N = dico["Nom_ASTER"].nom
 241     elif ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) :
 242       Nom_Concept_Maillage_NP1 = dico["Nom_ASTER"].nom
 243   Liste_Maillages = L
 244 #
 245 # 3.2. ==> Recherche du numéro d'itération et du répertoire de travail
 246 #
 247 # 3.2.1. ==> Par défaut :
 248 #            . le numéro d'itération est nul
 249 #            . le nom du répertoire de lancement de HOMARD est construit sur le nom
 250 #              du maillage en entrée et le numéro de passage dans la fonction
 251 #
 252   niter = 0
 253   Nom_Rep_local = Nom_Concept_Maillage_N + "_" + modhom + "_" + str(Numero_Passage_Fonction)
 254   Rep_Calc_HOMARD_local = os.path.join(".",Nom_Rep_local)
 255   Rep_Calc_HOMARD_global = os.path.join(Rep_Calc_ASTER,Nom_Rep_local)
 256 ###  print "Rep_Calc_HOMARD_local  = ", Rep_Calc_HOMARD_local
 257 ###  print "Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
 258 #
 259 # 3.2.2. ==> En adaptation :
 260 #
 261   if ( modhom == "ADAP" ) :
 262 #
 263 # 3.2.2.1. ==> On recherche si dans les passages déjà effectués, il en existe un
 264 #              dont le maillage d'arrivée était l'actuel maillage d'entrée. Si c'est
 265 #              le cas, cela veut dire que l'adaptation en cours est la suite d'une
 266 #              précédente. On doit donc utiliser le meme répertoire. Le numéro
 267 #              d'itération est celui de l'adaptation précédente augmenté de 1.
 268 #
 269     for dico in Liste_Passages :
 270       if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
 271         niter   = dico["niter"] + 1
 272         Rep_Calc_HOMARD_local  = dico["Rep_Calc_HOMARD_local"]
 273         Rep_Calc_HOMARD_global = dico["Rep_Calc_HOMARD_global"]
 274 #
 275 # 3.2.2.2. ==> Memorisation de ce passage
 276 #
 277 # 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure
 278 #
 279     if ( niter == 0 ) :
 280       dico = {}
 281       dico["Maillage_0"]   = Nom_Concept_Maillage_N
 282       dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
 283       dico["Rep_Calc_HOMARD_local"]  = Rep_Calc_HOMARD_local
 284       dico["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global
 285       dico["niter"]        = niter
 286       Liste_Passages.append(dico)
 287 #
 288 # 3.2.2.2.2. ==> Modification du cas en cours
 289 #
 290     else :
 291       L = []
 292       for dico in Liste_Passages :
 293         if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) :
 294           dico["Maillage_NP1"] = Nom_Concept_Maillage_NP1
 295           dico["niter"]        = niter
 296         L.append(dico)
 297       Liste_Passages = L
 298 #
 299 ###  print "niter = ", niter, ", Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global
 300 #
 301 #--------------------------------------------------------------------
 302 # 4. Ecriture des commandes
 303 #--------------------------------------------------------------------
 304 #
 305 # 4.1. ==> Création du répertoire pour homard
 306 #          attention : on ne fait cette creation qu'une seule fois par cas
 307 #                      d'adaptation ou d'information
 308 #
 309   if ( niter == 0 ) :
 310 #
 311     try :
 312       os.mkdir(Rep_Calc_HOMARD_global)
 313     except os.error,codret_partiel :
 314       self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
 315       self.cr.fatal("<F> <MACR_ADAP_MAIL> Impossible de créer le répertoire de travail pour HOMARD : "+Rep_Calc_HOMARD_global)
 316       codret = codret + 1
 317 #
 318 # 4.2. ==> Ecriture des commandes de creation des donnees MED
 319 #
 320 #  On doit écrire : le maillage,
 321 #                   le champ d'indicateur d'erreur
 322 #                   les champs à convertir
 323 #  Remarque : on met tout dans le meme fichier
 324 #
 325 #  Chacune de ces écritures est optionnelle selon le contexte.
 326 #
 327   if ( INFO > 1 ) : infomail = "OUI"
 328   else :            infomail = "NON"
 329 #
 330 # 4.2.1. ==> Noms des fichiers d'ASTER vers HOMARD et éventuellement de HOMARD vers ASTER
 331 #            Remarque : aujourd'hui, les écritures ou les lectures au format MED se font obligatoirement sur
 332 #                       un fichier de nom fort.n, placé dans le répertoire de calcul
 333 #                       Dans le fichier de configuration, on donne comme nom MAILL.(niter).MED en entrée et
 334 #                       MAILL.(niter+1).MED en sortie (cf. adhc00)
 335 #                       Tant que les E/S MED n'ont pas évolué, on fait un lien pour assurer la cohérence.
 336 #
 337 # 4.2.1.1. ==> D'ASTER vers HOMARD
 338 #
 339   Unite_Fichier_ASTER_vers_HOMARD = 1787 + 2*Numero_Passage_Fonction
 340   Fichier_ASTER_vers_HOMARD = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_ASTER_vers_HOMARD))
 341   Fichier_HOMARD_Entree = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter)+".MED")
 342 ###  print "Fichier_ASTER_vers_HOMARD = ",Fichier_ASTER_vers_HOMARD
 343 ###  print "Fichier_HOMARD_Entree = ",Fichier_HOMARD_Entree
 344   try :
 345     os.symlink(Fichier_ASTER_vers_HOMARD,Fichier_HOMARD_Entree)
 346   except os.error,codret_partiel :
 347     self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
 348     self.cr.fatal("<F> <MACR_ADAP_MAIL> Probleme au lien entre " + Fichier_ASTER_vers_HOMARD + " et " + Fichier_HOMARD_Entree)
 349     codret = codret + 1
 350 #
 351 # 4.2.1.2. ==> De HOMARD vers ASTER
 352 #
 353   if ( modhom == "ADAP" ) :
 354     Unite_Fichier_HOMARD_vers_ASTER = Unite_Fichier_ASTER_vers_HOMARD + 1
 355     Fichier_HOMARD_vers_ASTER = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_HOMARD_vers_ASTER))
 356     Fichier_HOMARD_Sortie = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter+1)+".MED")
 357 ###    print "Fichier_HOMARD_vers_ASTER = ",Fichier_HOMARD_vers_ASTER
 358 ###    print "Fichier_HOMARD_Sortie = ",Fichier_HOMARD_Sortie
 359     try :
 360       os.symlink(Fichier_HOMARD_vers_ASTER,Fichier_HOMARD_Sortie)
 361     except os.error,codret_partiel :
 362       self.cr.warn("Code d'erreur de symlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
 363       self.cr.fatal("<F> <MACR_ADAP_MAIL> Probleme au lien entre " + Fichier_HOMARD_vers_ASTER + " et " + Fichier_HOMARD_Sortie)
 364       codret = codret + 1
 365 #
 366 # 4.2.2. La définition du fichier de ASTER vers HOMARD
 367 #
 368   DEFI_FICHIER ( ACTION= "ASSOCIER",
 369                  UNITE = Unite_Fichier_ASTER_vers_HOMARD,
 370                  TYPE = "LIBRE",
 371                  INFO = INFO )
 372 #
 373 # 4.2.3. Le(s) maillage(s)
 374 # Le maillage de calcul et l'éventuel maillage de la frontiere sont écrits
 375 # dans le meme fichier MED
 376 # En fait, on pourrait s'en passer au dela de la 1ère itération
 377 # car HOMARD a mémorisé. Mais dès que l'on écrit un champ,
 378 # les conventions MED imposent la présence du maillage dans le fichier.
 379 # Donc on va toujours écrire.
 380 #
 381   for dico in Liste_Maillages :
 382     if ( dico["Action"] == "A_ecrire" ) :
 383       motscsi={}
 384       motscsi["MAILLAGE"] = dico["Nom_ASTER"]
 385       motscfa={}
 386       motscfa["RESU"]=_F( INFO_MAILLAGE=infomail,
 387                           **motscsi )
 388 #
 389       IMPR_RESU ( INFO = INFO,
 390                   FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD,
 391                   **motscfa )
 392 #
 393 # 4.2.4. Le(s) champ(s)
 394 #        Attention : il se peut que l'on demande la mise à jour du champ qui a servi comme
 395 #                    indicateur d'erreur. Si c'est le cas, il ne faut pas demander son
 396 #                    impression sinon il y a plantage d'IMPR_RESU qui ne sait pas substituer
 397 #                    deux champs. D'ailleurs, c'est plus économique ainsi !
 398 #        Remarque : pour l'adaptation, on ne demande a priori qu'une composante du champ d'indicateur.
 399 #                   s'il y a demande de mise à jour, toutes les composantes sont concernées. Il faut
 400 #                   donc dans ce cas imprimer le champ total.
 401 #        dico["Type_Champ"]   = o ; string ; "INDICATEUR" ou "CHAMP"
 402 #        dico["RESULTAT"]     = o ; concept ASTER du résutat associé
 403 #        dico["NOM_CHAM"]     = o ; string ; Nom ASTER du champ
 404 #        dico["COMPOSANTE"]   = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur)
 405 #        dico["NUME_ORDRE"]   = f ; entier ; Numéro d'ordre du champ
 406 #        dico["INST"]         = f ; entier ; Instant du champ
 407 #        dico["PRECISION"]    = f ; entier ; Précision sur l'instant du champ
 408 #        dico["CRITERE"]      = f ; entier ; Critère de précision sur l'instant du champ
 409 #        dico["CHAM_MAJ"]     = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage
 410 #        dico["NOM_MED"]      = o ; string ; Nom MED du champ
 411 #
 412 # 4.2.4.1. Recherche d'un doublon éventuel sur le champ d'indicateur d'erreur
 413 #
 414   if len(dico_indi) > 0 :
 415     imprime_indic = 0
 416   else :
 417     imprime_indic = 1
 418 #
 419   Liste_Champs_imprime = []
 420   for dico in Liste_Champs :
 421 #   Pour un champ à mettre à jour, on a toujours impression
 422     if ( dico["Type_Champ"] == "CHAMP" ) :
 423       Liste_Champs_imprime.append(dico)
 424 #     Si le champ d'indicateur n'a pas été repéré comme champ à mettre à jour :
 425       if not imprime_indic :
 426 #       Est-ce le meme champ ?
 427         ok = 1
 428         for cle in [ "RESULTAT", "NOM_CHAM" ] :
 429           if ( dico_indi[cle] != dico[cle] ) :
 430             ok = 0
 431             break
 432 #       Si oui, est-ce au meme moment ? (remarque : si rien n'est désigné, c'est qu'il n'y a qu'un
 433 #       seul instant ... donc c'est le meme ! En revanche, on ne sait pas comparer une donnée
 434 #       en numéro d'ordre et une donnée en instant. On croise les doigts.)
 435         if ok :
 436           for cle in [ "NUME_ORDRE", "INST" ] :
 437             if dico.has_key(cle) :
 438               if ( dico[cle] != None ) :
 439                 if dico_indi.has_key(cle) :
 440                   if ( dico_indi[cle] != dico[cle] ) :
 441                     ok = 0
 442                     break
 443         if ok : imprime_indic = 1
 444 #   Si le champ d'indicateur n'a pas été repéré comme champ à mettre à jour, il faut
 445 #   l'inclure dans les champs à imprimer
 446   if not imprime_indic : Liste_Champs_imprime.append(dico_indi)
 447 #
 448 # 4.2.4.2. Impressions après le filtrage précédent
 449 #
 450   for dico in Liste_Champs_imprime :
 451     motscsi={}
 452     for cle in [ "RESULTAT", "NOM_CHAM", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
 453       if dico.has_key(cle) :
 454         if ( dico[cle] != None ) :
 455           motscsi[cle] = dico[cle]
 456     if dico.has_key("COMPOSANTE") :
 457       motscsi["NOM_CMP"] = dico["COMPOSANTE"]
 458     motscfa={}
 459     motscfa["RESU"]=_F( INFO_MAILLAGE=infomail,
 460                         **motscsi
 461                       )
 462 #
 463     IMPR_RESU ( INFO = INFO,
 464                 FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD,
 465                 **motscfa )
 466 #
 467 # 4.3. ==> Ecriture de la commande d'écriture des fichiers de données pour HOMARD
 468 #
 469   motscfa={}
 470 #
 471 # 4.3.1. ==> Le traitement
 472 #
 473   motscsi={}
 474 #
 475 # 4.3.1.1. ==> Le type de traitement
 476 #
 477   if ( modhom == "ADAP" ) :
 478     if ( ADAPTATION["UNIFORME"] != None ) :
 479       motscsi["UNIFORME"] = ADAPTATION["UNIFORME"]
 480     else :
 481       motscsi["ADAPTATION"] = ADAPTATION["LIBRE"]
 482   else :
 483     motscsi["INFORMATION"] = "OUI"
 484 #
 485 # 4.3.1.2. ==> Les noms med des maillages
 486 #
 487   for dico in Liste_Maillages :
 488 ###    print "Nom MED de " + dico["Type_Maillage"] + " = " + dico["NOM_MED"]
 489     motscsi[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"]
 490 #
 491 # 4.3.1.3. ==> Les caracteristiques de l'éventuel indicateur d'erreur
 492 #
 493   for dico in Liste_Champs :
 494     if ( dico["Type_Champ"] == "INDICATEUR" ) :
 495       Liste_aux = [ "NOM_MED", "COMPOSANTE" ]
 496       if dico.has_key("NUME_ORDRE") :
 497         Liste_aux.append("NUME_ORDRE")
 498       else :
 499         for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] :
 500           Liste_aux.append(cle)
 501       for cle in Liste_aux :
 502         if dico.has_key(cle) :
 503           if ( dico[cle] != None ) :
 504             motscsi[cle] = dico[cle]
 505 #
 506 # 4.3.1.4. ==> Les critères de raffinement et les niveaux extremes
 507 #
 508   if ( modhom == "ADAP" ) :
 509     Liste_aux = [ ]
 510     if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "RAFFINEMENT" ) :
 511       Liste_aux.append("CRIT_RAFF_ABS")
 512       Liste_aux.append("CRIT_RAFF_REL")
 513       Liste_aux.append("CRIT_RAFF_PE")
 514     if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "DERAFFINEMENT" ) :
 515       Liste_aux.append("CRIT_DERA_ABS")
 516       Liste_aux.append("CRIT_DERA_REL")
 517       Liste_aux.append("CRIT_DERA_PE")
 518     niveau = 0
 519     if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "RAFFINEMENT" or ADAPTATION["UNIFORME"] == "RAFFINEMENT" ) :
 520       Liste_aux.append("NIVE_MAX")
 521       niveau = niveau + 1
 522     if ( ADAPTATION["LIBRE"] == "RAFF_DERA" or ADAPTATION["LIBRE"] == "DERAFFINEMENT" or ADAPTATION["UNIFORME"] == "DERAFFINEMENT" ) :
 523       Liste_aux.append("NIVE_MIN")
 524       niveau = niveau + 2
 525     for mot_cle in Liste_aux :
 526       if ( ADAPTATION[mot_cle] != None ) :
 527         motscsi[mot_cle] = ADAPTATION[mot_cle]
 528 #
 529     if ( niveau == 2 ) :
 530       if ( ADAPTATION["NIVE_MIN"] > ADAPTATION["NIVE_MAX"] ) :
 531         self.cr.fatal("<F> <MACR_ADAP_MAIL> Le niveau minimum doit etre inferieur au niveau maximum.")
 532         codret = codret + 1
 533 #
 534 # 4.3.1.5. ==> Numéro d'itération
 535 #
 536   if ( modhom == "ADAP" ) :
 537     motscsi["NITER"] = niter
 538 #
 539 # 4.3.1.6. ==> Suivi de la frontiere
 540 #
 541   if args.has_key("GROUP_MA") :
 542     if ( args["GROUP_MA"] != None ) :
 543       motscsi["GROUP_MA"] = args["GROUP_MA"]
 544 #
 545 # 4.3.1.7. ==> Bilan
 546 #
 547   motscfa["TRAITEMENT"] = _F(**motscsi)
 548 #
 549 # 4.3.2. ==> L'analyse
 550 #
 551   motscsi={}
 552   if ( NOMBRE != None )           : motscsi["NOMBRE" ]           = NOMBRE
 553   if ( QUALITE != None )          : motscsi["QUALITE" ]          = QUALITE
 554   if ( CONNEXITE != None )        : motscsi["CONNEXITE" ]        = CONNEXITE
 555   if ( TAILLE != None )           : motscsi["TAILLE" ]           = TAILLE
 556   if ( INTERPENETRATION != None ) : motscsi["INTERPENETRATION" ] = INTERPENETRATION
 557 #
 558   motscfa["ANALYSE"] = _F(**motscsi)
 559 #
 560 # 4.3.3. ==> La mise à jour de champs
 561 #
 562   prem = 1
 563   for dico in Liste_Champs :
 564     motscsi={}
 565     if ( dico["Type_Champ"] == "CHAMP" ) :
 566       Liste_aux = [ "NOM_MED", "COMPOSANTE" ]
 567       if dico.has_key("NUME_ORDRE") :
 568         Liste_aux.append("NUME_ORDRE")
 569       else :
 570         for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] :
 571           Liste_aux.append(cle)
 572       for cle in Liste_aux :
 573         if dico.has_key(cle) :
 574           if ( dico[cle] != None ) :
 575             motscsi[cle] = dico[cle]
 576 ###      print motscsi
 577       if prem :
 578         motscfa["MAJ_CHAM"] = [_F(**motscsi),]
 579         prem = 0
 580       else :
 581         motscfa["MAJ_CHAM"].append(_F(**motscsi))
 582 #
 583 # 4.3.4. ==> La commande
 584 #
 585 # 4.3.4.1. ==> Les fichiers annexes
 586 #
 587   dico = {}
 588 #
 589   Nom_Fichier_Configuration = "HOMARD.Configuration"
 590   Fichier_Configuration = os.path.join(Rep_Calc_HOMARD_local,Nom_Fichier_Configuration)
 591   dico[Fichier_Configuration] = ("HOMARD_CONFIG","UNITE_CONF",unite)
 592 #
 593   if ( modhom != "ADAP" ) :
 594     unite = unite + 1
 595     Nom_Fichier_Donnees = "HOMARD.Donnees"
 596     Fichier_Donnees = os.path.join(Rep_Calc_HOMARD_local,Nom_Fichier_Donnees)
 597 #                             1234567890123456
 598     dico[Fichier_Donnees] = ("HOMARD_DONN","UNITE_DONN",unite)
 599 #
 600 # 4.3.4.2. ==> L'ouverture de ces fichiers
 601 #
 602   for fic in dico.keys() :
 603     DEFI_FICHIER ( ACTION= "ASSOCIER", FICHIER = fic, UNITE = dico[fic][2],
 604                    TYPE = "ASCII", ACCES = "NEW", INFO = INFO )
 605     motscfa[dico[fic][1]] = dico[fic][2]
 606 #
 607 # 4.3.4.3. ==> Ecriture
 608 #
 609 ###  print motscfa
 610   IMPR_FICO_HOMA ( INFO=INFO, LANGUE = LANGUE, NON_SIMPLEXE = NON_SIMPLEXE, **motscfa )
 611 #
 612 ###  for fic in dico.keys() :
 613 ###    print "\nContenu de ", fic
 614 ###    fichier = open (fic,"r")
 615 ###    les_lignes = fichier.readlines()
 616 ###    fichier.close()
 617 ###    for ligne in les_lignes :
 618 ###      print ligne[:-1]
 619 #
 620 # 4.3.4.4. ==> La fermeture des fichiers locaux
 621 #              Remarque : il faut le faire ici pour que le gestionnaire de DEFI_FICHIER soit à jour
 622 #              Remarque : aujourd'hui on est obligé de passer par le numéro d'unité logique
 623 #
 624   for fic in dico.keys() :
 625     DEFI_FICHIER ( ACTION= "LIBERER", UNITE = dico[fic][2], INFO = INFO )
 626 #
 627 # 4.4. ==> Ecriture de la commande d'exécution de homard
 628 #    Remarque : dans la donnée de la version de HOMARD, il faut remplacer
 629 #               le _ de la donnee par un ., qui
 630 #               est interdit dans la syntaxe du langage de commandes ASTER
 631 #    Remarque : il faut remplacer le N majuscule de la donnee par
 632 #               un n minuscule, qui est interdit dans la syntaxe du langage
 633 #               de commandes ASTER
 634 #    Remarque : pour le nommage des fichiers d'échange entre ASTER et HOMARD, on utilise
 635 #               la convention implicite du fort.n des entrees/sorties au format MED
 636 #
 637   VERSION_HOMARD=string.replace(VERSION_HOMARD,"_",".")
 638   VERSION_HOMARD=string.replace(VERSION_HOMARD,"N","n")
 639   if ( VERSION_HOMARD[-6:]=="_PERSO" ):
 640 #    motscsi["ARGUMENT"]=_F("TYPEXE"="-PERSO")
 641     VERSION_HOMARD=VERSION_HOMARD[:-6]
 642 #
 643   if ( modhom == "ADAP" ) :
 644     Nom_Fichier_Donnees = "0"
 645 #
 646   EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_HOMARD_global), # nom du repertoire
 647                               _F(NOM_PARA=VERSION_HOMARD),  # version de homard
 648                               _F(NOM_PARA=str(INFO)),       # niveau d information
 649                               _F(NOM_PARA=Nom_Fichier_Donnees), # fichier de données HOMARD
 650                              ),
 651                   LOGICIEL = homard
 652                 )
 653 #
 654 # 4.5. ==> Ecriture de la commande de lecture des resultats med
 655 #          Remarque :
 656 #          La fonction self.DeclareOut(a,b) focntionne ainsi :
 657 #          a est une chaine de caracteres
 658 #          b est la variable déclarée dans la commande
 659 #          le but est de associer le contenu de b à la variable locale qui sera désignée par a
 660 #          Exemple :
 661 #          self.DeclareOut("maillage_np1",ADAPTATION["MAILLAGE_NP1"])
 662 #          ==> la variable maillage_np1 est identifiée à l'argument "MAILLAGE_NP1" du mot-clé ADAPTATION
 663 #
 664   if ( modhom == "ADAP" ) :
 665 #
 666 # 4.5.1. ==> Le maillage
 667 #
 668     self.DeclareOut("maillage_np1",ADAPTATION["MAILLAGE_NP1"])
 669     for dico in Liste_Maillages :
 670       if ( dico["Action"] == "A_lire" ) :
 671         maillage_np1 = LIRE_MAILLAGE ( UNITE = Unite_Fichier_HOMARD_vers_ASTER,
 672                                        FORMAT = "MED",
 673                                        NOM_MED = dico["NOM_MED"],
 674                                        VERI_MAIL = _F(VERIF="NON"), INFO_MED = INFO, INFO = INFO )
 675 #
 676 # 4.5.2. ==> Les champs
 677 #
 678     for dico in Liste_Champs :
 679       if ( dico["Type_Champ"] == "CHAMP" ) :
 680 ###        print dico
 681         self.DeclareOut("champ_maj",dico["CHAM_MAJ"])
 682         motscsi={}
 683         for cle in [ "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
 684           if dico.has_key(cle) :
 685             if ( dico[cle] != None ) :
 686               motscsi[cle] = dico[cle]
 687         if dico.has_key("NUME_ORDRE") :
 688           motscsi["NUME_PT"] = dico["NUME_ORDRE"]
 689         champ_maj = LIRE_CHAMP ( UNITE = Unite_Fichier_HOMARD_vers_ASTER, FORMAT = "MED",
 690                                  MAILLAGE = maillage_np1,
 691                                  NOM_MED = dico["NOM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"],
 692                                  INFO = INFO, **motscsi )
 693 #
 694 #--------------------------------------------------------------------
 695 # 5. Menage des fichiers MED et HOMARD devenus inutiles
 696 #--------------------------------------------------------------------
 697 #
 698   fic = os.path.join(Rep_Calc_HOMARD_global,"MAILL."+str(niter)+".HOM")
 699   Liste_aux = [ Fichier_ASTER_vers_HOMARD, Fichier_HOMARD_Entree, fic ]
 700   if ( modhom == "ADAP" ) :
 701     Liste_aux.append(Fichier_HOMARD_vers_ASTER)
 702     Liste_aux.append(Fichier_HOMARD_Sortie)
 703 #
 704   for fic in Liste_aux :
 705     if ( INFO > 1 ) : print "Destruction du fichier ", fic
 706     if os.path.islink(fic) :
 707       try :
 708         os.unlink(fic)
 709       except os.error,codret_partiel :
 710         self.cr.warn("Code d'erreur de unlink : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
 711         self.cr.warn("Impossible d'enlever le lien sur le fichier : "+fic)
 712         codret = codret + 1
 713     if os.path.isfile(fic) :
 714       try :
 715         os.remove(fic)
 716       except os.error,codret_partiel :
 717         self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1])
 718         self.cr.warn("Impossible de détruire le fichier : "+fic)
 719         codret = codret + 1
 720 ###  print os.listdir(Rep_Calc_ASTER)
 721 ###  print os.listdir(Rep_Calc_HOMARD_global)
 722 #
 723 #--------------------------------------------------------------------
 724 # 6. C'est fini !
 725 #--------------------------------------------------------------------
 726 #
 727   return codret