doc/files/yacs_script.py

   1 #!/usr/bin/env python
   2 # -*- coding: iso-8859-1 -*-
   3 """
   4 Lancement d'un calcul ASTER
   5 """
   6 __revision__ = "V5.4"
   7 #
   8 import sys
   9 import os
  10 import tempfile
  11 import time
  12 #
  13 # ==== Debut de personnalisation ====
  14 #
  15 # opt1_defaut, opt2_defaut : les valeurs par defaut de ces options, selon les cas
  16 opt1_defaut = {}
  17 opt2_defaut = {}
  18 # liste_cas_tr : liste des cas transitoires
  19 liste_cas_tr = []
  20 #
  21 nro_couche = 1
  22 opt1_defaut["couche"] = str(nro_couche)
  23 nro_adap = 0
  24 opt2_defaut["couche"] = str(nro_adap)
  25 #
  26 liste_cas_tr.append("tet_aster_ther_tr")
  27 opt1_defaut["tet_aster_ther_tr"] = "0"
  28 opt2_defaut["tet_aster_ther_tr"] = "25"
  29 #
  30 liste_cas_tr.append("ssnp142d")
  31 opt1_defaut["ssnp142d"] = "0.0"
  32 opt2_defaut["ssnp142d"] = "4.0"
  33 #
  34 liste_cas_tr.append("Riete")
  35 opt1_defaut["Riete"] = "0.0"
  36 opt2_defaut["Riete"] = "8.0"
  37 #
  38 # ==== Fin de personnalisation ====
  39 #
  40 class Script :
  41 #
  42   """
  43 Mode d'emploi :
  44 ---------------
  45
  46 Cette procedure lance un calcul Aster. Avant de lancer ce script, il faut avoir cree un repertoire pour le calcul. Dans ce repertoire, on aura mis le fichier de commandes sous le nom 'calcul.comm'. Apres un premier calcul, lance traditionnellement, on aura copie le fichier '*export' sous le nom 'calcul.ref.export' dans ce repertoire.
  47
  48 Le mode de lancement est le suivant :
  49
  50 ScriptAster --rep_calc=rep_calc --num=nro --mesh_file=mesh_file [-dump] [-h|-help] [-v] [-v_max] options
  51
  52 Arguments obligatoires :
  53 --rep_calc=rep_calc : le repertoire du calcul.
  54 --num=nro : le numero du calcul, depuis 0.
  55 --mesh_file=mesh_file : le fichier contenant le maillage sur lequel on veut calculer. Le nom est absolu ou relatif par rapport au repertoire de calcul.
  56
  57 Options supplementaires, selon les cas :
  58 . Pour un cas transitoire :
  59 Les numeros des instants varient de 0 a N. On fournit le numero ou l'instant ; le jeu de commandes fait le tri entre les deux options.
  60 --opt1=inst_deb : le numero ou l'instant initial ; si absent, on prend 0.
  61 --opt2=inst_fin : le numero ou l'instant final ; si absent, on va jusqu'au bout du transitoire.
  62 . Pour l'excavation :
  63 --opt1=nro_couche : le numero de la couche ; si absent, on prend 1.
  64 --opt2=nro_adap : le nombre d'adaptations deja realisees pour la couche ; si absent, on prend 0.
  65 . Pour les autres cas :
  66 Aucune option supplementaire.
  67
  68 Arguments optionnels :
  69
  70 --wait=wait : temps d'attente en secondes entre deux examens de l'etat d'un calcul batch ; si absent, on prend 10.
  71
  72 -dump : produit le fichier dump du fichier med de resultats ; par defaut, pas de dump.
  73
  74 -h|-help : produit l'aide, quels que soient les autres arguments
  75 -v : mode verbeux simple
  76 -v_max : mode verbeux intensif
  77
  78 Exemple :
  79 ./ScriptAster.py --rep_calc=`pwd` --num=0 --mesh_file=maill.00.med -dump
  80 ./ScriptAster.py --rep_calc=/scratch/D68518/HOMARD_SVN/trunk/training/tet_aster_ther --num=2 --mesh_file=/scratch/D68518/Salome/Adapt/resu/maill.02.med
  81   """
  82 #
  83 #====
  84 # 0. Les defauts
  85 #====
  86 # 0.1. ==> Les constantes de la machine
  87 #
  88   info_gene = os.uname()
  89   #print info_gene
  90 #
  91   machine = info_gene[1]
  92   serveur = machine
  93   mclient = machine
  94 #
  95 # 0.2. ==> Le user
  96 #
  97   if os.environ.has_key("LOGNAME") :
  98     user = os.environ ["LOGNAME"]
  99   else :
 100     user = "salome"
 101   username = user
 102   uclient = user
 103 #
 104 # 0.3. ==> Le lancement d'Aster
 105 #
 106   aster_root = None
 107 #
 108   nomjob = None
 109   mode = None
 110 # Attente en secondes entre deux controles du job
 111   attente = "10"
 112 #
 113 # 0.4. ==> Information
 114 #
 115   affiche_aide_globale = 0
 116   verbose = 0
 117   verbose_max = 0
 118   dump = 0
 119 #
 120   message_info = "\n"
 121 #
 122 #
 123 #========================= Debut de la fonction ==================================
 124 #
 125   def __init__ ( self, liste_arg ) :
 126 #
 127     """
 128 Le constructeur de la classe Script
 129     """
 130 #
 131 # 1. Decodage des arguments
 132 #
 133     self.rep_calc = None
 134     self.num = None
 135     self.mesh_file = None
 136     self.opt1 = None
 137     self.opt2 = None
 138     self.version = None
 139 #
 140     for argu in liste_arg :
 141 #
 142       #print argu
 143       l_aux = argu.split("=")
 144       #print l_aux
 145       if len(l_aux) == 2 :
 146         #print l_aux[0]
 147         #print l_aux[1]
 148         if l_aux[0] == "--rep_calc" :
 149           self.rep_calc = l_aux[1]
 150         elif l_aux[0] == "--num" :
 151           self.numero = int(l_aux[1])
 152         elif l_aux[0] == "--mesh_file" :
 153           self.mesh_file = l_aux[1]
 154         elif l_aux[0] == "--opt1" :
 155           self.opt1 = l_aux[1]
 156         elif l_aux[0] == "--opt2" :
 157           self.opt2 = l_aux[1]
 158         elif l_aux[0] == "--wait" :
 159           self.attente = l_aux[1]
 160         elif l_aux[0] == "--version" :
 161           self.version = l_aux[1]
 162       else :
 163         saux = argu.upper()
 164         if saux in ( "-H", "-HELP" ) :
 165           self.affiche_aide_globale = 1
 166         elif saux == "-V" :
 167           self.verbose = 1
 168         elif saux in ( "-V_MAX", "-VMAX" ) :
 169           self.verbose = 1
 170           self.verbose_max = 1
 171         elif saux == "-DUMP" :
 172           self.dump = 1
 173 #
 174 # 2. Les paramètres de base
 175 #
 176     self.dico = {}
 177     self.nomfic_export = None
 178     self.nomcas = ""
 179 #
 180     if self.verbose_max :
 181       nom_fonction = __name__ + "/__init__"
 182       print "\nDans " + nom_fonction + ","
 183       print ". rep_calc  :", self.rep_calc
 184       print ". numero    :", self.numero
 185       print ". mesh_file :", self.mesh_file
 186       print ". opt1      :", self.opt1
 187       print ". opt2      :", self.opt2
 188       print ". attente   :", self.attente
 189 #
 190 #=========================  Fin de la fonction ===================================
 191 #
 192 #========================= Debut de la fonction ==================================
 193 #
 194   def compute ( self ) :
 195 #
 196     """
 197 Lancement d'un calcul
 198     """
 199 #
 200     nom_fonction = __name__ + "/compute"
 201     blabla = "\nDans " + nom_fonction + ","
 202 #
 203     erreur = 0
 204     message_erreur = " "
 205 #
 206     dico_resu = {}
 207 #
 208     while not erreur :
 209 #
 210 # 1. Preparation du calcul
 211 #
 212       #print "\n==== self.prepa_calcul () ===="
 213       erreur, message_erreur = self.prepa_calcul ()
 214       if erreur :
 215         break
 216 #
 217 # 2. Calcul
 218 #
 219       #print "\n==== self.calcul () ===="
 220       erreur, message_erreur, fic_caract, fic_caract_2 = self.calcul ()
 221       #print "erreur en sortie de self.calcul :", erreur
 222       if erreur :
 223         break
 224 #
 225 # 3. Attente
 226 #
 227       #print "\n==== calcul_aster_attente.calcul (",fic_caract,") ===="
 228       erreur, message_erreur = self.calcul_aster_attente (fic_caract)
 229       if erreur :
 230         break
 231       os.remove(fic_caract)
 232       os.remove(fic_caract_2)
 233 #
 234 # 4. Gestion du resultat
 235 #
 236       #print "\n==== self.post_aster (dico_resu) ===="
 237       erreur, message_erreur, dico_resu = self.post_aster (dico_resu)
 238       if erreur :
 239         break
 240 #
 241 # 5. Dump eventuel
 242 #
 243       if self.dump :
 244         #print "\n==== self.dump_resultat() ===="
 245         erreur, message_erreur = self.dump_resultat ()
 246         if erreur :
 247           break
 248 #
 249       break
 250 #
 251     if self.verbose_max :
 252       print blabla
 253       print ". erreur :", erreur
 254 #
 255     return erreur, message_erreur, dico_resu
 256 #
 257 #=========================  Fin de la fonction ===================================
 258 #
 259 #========================= Debut de la fonction ==================================
 260 #
 261   def prepa_calcul ( self ) :
 262 #
 263     """
 264 Preparation d'un calcul
 265     """
 266 #
 267     messages_erreur = { 0 : None }
 268 #
 269     nom_fonction = __name__ + "/prepa_calcul"
 270     blabla = "\nDans " + nom_fonction + ","
 271 #
 272     erreur = 0
 273     message_erreur = " "
 274 #
 275     if self.verbose_max :
 276       print blabla
 277       print ". numero    :", self.numero
 278       print ". mesh_file :", self.mesh_file
 279       print ". rep_calc  :", self.rep_calc
 280 #
 281     while not erreur :
 282 #
 283 # 1. Controles des arguments
 284 #
 285       erreur, message_erreur = self.controle_argument()
 286       if erreur :
 287         break
 288 #
 289 # 2. Modification du fichier export
 290 #
 291       erreur, message_erreur = self.modif_export()
 292       if erreur :
 293         break
 294 #
 295 # 3. Modifications du fichier de commandes
 296 # 3.1. Pour un cas transitoire
 297 #
 298       if self.nomcas in liste_cas_tr :
 299         erreur, message_erreur = self.modif_cas_transitoire()
 300         if erreur :
 301           break
 302 #
 303 # 3.2. Pour l'excavation
 304 #
 305       elif self.nomcas[:6] == "couche" :
 306         erreur, message_erreur = self.modif_cas_excavation()
 307         if erreur :
 308           break
 309 #
 310       break
 311 #
 312     if self.verbose_max :
 313       print blabla, "a la fin"
 314       print ". erreur :", erreur
 315 #
 316     return erreur, message_erreur
 317 #
 318 #=========================  Fin de la fonction ===================================
 319 #
 320 #========================= Debut de la fonction ==================================
 321 #
 322   def controle_argument ( self ) :
 323 #
 324     """
 325 Controle les arguments et stockage de quelques informations
 326     """
 327 #
 328     messages_erreur = { 0 : None,
 329                        -1 : "Quel repertoire de calcul ?",
 330                        -2 : "Quel fichier de maillage ?",
 331                        -3 : "Ce repertoire est inconnu.",
 332                        -4 : "Ce fichier est inconnu.",
 333                        -5 : "Quel temps d'attente ?",
 334                        -6 : "Quel numero de calcul ?",
 335                        -7 : "Numeros de pas de temps invalides.",
 336                        -8 : "Numero de couche invalide.",
 337                        -9 : "Numero d'adaptation invalide." }
 338 #
 339     nom_fonction = __name__ + "/controle_argument"
 340     blabla = "\nDans " + nom_fonction + ","
 341 #
 342     erreur = 0
 343     message_erreur = " "
 344 #
 345     if self.verbose_max :
 346       print blabla
 347       print ". rep_calc  :", self.rep_calc
 348       print ". mesh_file :", self.mesh_file
 349       print ". numero    :", self.numero
 350       print ". attente   :", self.attente
 351       print ". opt1      :", self.opt1
 352       print ". opt2      :", self.opt2
 353 #
 354     while not erreur :
 355 #
 356 # 1. Les repertoire et fichier
 357 #
 358       if self.rep_calc == None :
 359         erreur = -1
 360       elif self.mesh_file == None :
 361         erreur = -2
 362       if erreur < 0 :
 363         self.message_info += "Relancer avec -h pour avoir le mode d'emploi."
 364         break
 365 #
 366       if os.environ.has_key("HOME") :
 367         HOME = os.environ ["HOME"]
 368       else :
 369         HOME = "/local/home/salome"
 370 #
 371       if ( self.rep_calc[:1] == "~" ) :
 372         self.rep_calc = os.path.join(HOME, self.rep_calc[2:])
 373       if not os.path.isdir(self.rep_calc) :
 374         self.message_info += "Repertoire " + self.rep_calc
 375         erreur = -3
 376         break
 377       else :
 378         aux = os.path.join(os.getcwd(),self.rep_calc)
 379         self.rep_calc = os.path.normpath(aux)
 380 #
 381       if ( self.mesh_file[:1] == "~" ) :
 382         self.mesh_file = os.path.join(HOME, self.mesh_file[2:])
 383       if not os.path.isfile(self.mesh_file) :
 384         aux = os.path.join(self.rep_calc, self.mesh_file)
 385         if not os.path.isfile(aux) :
 386           self.message_info += "Fichier " + self.mesh_file
 387           erreur = -4
 388           break
 389         else :
 390           self.mesh_file = os.path.normpath(aux)
 391       aux = os.path.join(os.getcwd(),self.mesh_file)
 392       self.mesh_file = os.path.normpath(aux)
 393 #
 394 # 2. On en deduit le cas
 395 #
 396       self.nomcas = os.path.basename(self.rep_calc)
 397       if self.verbose_max :
 398         print ". Cas :", self.nomcas
 399 #
 400 # 3. Le temps d'attente
 401 #
 402       iaux = None
 403       try :
 404         iaux = int(self.attente)
 405       except :
 406         erreur = -5
 407         break
 408       self.attente = iaux
 409 #
 410 # 4. Le numero du calcul
 411 #
 412       if self.numero == None :
 413         erreur = -6
 414 #
 415 # 5. Options speciales pour les cas transitoires et pour l'excavation
 416 #
 417       if ( self.nomcas in liste_cas_tr ) or ( self.nomcas[:6] == "couche" ) :
 418 #
 419         if self.opt1 == None :
 420           self.opt1 = opt1_defaut[self.nomcas]
 421 #
 422         if self.opt2 == None :
 423           self.opt2 = opt2_defaut[self.nomcas]
 424 #
 425 # 5.1. Pour un cas transitoire
 426 #
 427       if self.nomcas in liste_cas_tr :
 428 #
 429         iaux1 = None
 430         daux1 = None
 431         try :
 432           iaux1 = int(self.opt1)
 433         except :
 434           daux1 = float(self.opt1)
 435 #
 436         iaux2 = None
 437         daux2 = None
 438         try :
 439           iaux2 = int(self.opt2)
 440         except :
 441           daux2 = float(self.opt2)
 442 #
 443         if ( ( daux1 == None ) and  ( daux2 == None ) ) :
 444           #print "iaux1, iaux2 =", iaux1, iaux2
 445           if iaux2 < iaux1 :
 446             erreur = -7
 447         elif ( ( iaux1 == None ) and  ( iaux2 == None ) ) :
 448           #print "daux1, daux2 =", daux1, daux2
 449           if daux2 < daux1 :
 450             erreur = -7
 451         else :
 452           erreur = -7
 453 #
 454         if erreur :
 455           self.message_info += "opt1 = " + self.opt1
 456           self.message_info += "\nopt2 = " + self.opt2
 457 #
 458 # 5.2. Pour l'excavation
 459 #
 460       elif self.nomcas[:6] == "couche" :
 461 #
 462         iaux1 = None
 463         try :
 464           iaux1 = int(self.opt1)
 465         except :
 466           erreur = -8
 467 #
 468         if ( ( iaux1 < 1 ) or ( iaux1 > 20 ) ) :
 469           #print "iaux1 =", iaux1
 470           erreur = -8
 471 #
 472         iaux2 = None
 473         try :
 474           iaux2 = int(self.opt2)
 475         except :
 476           erreur = -9
 477 #
 478         if ( iaux2 < 0 ) :
 479           #print "iaux1 =", iaux1
 480           erreur = -9
 481 #
 482         if erreur :
 483           self.message_info += "nro_mail = " + self.numero
 484           self.message_info += "\nopt1 = " + self.opt1
 485           self.message_info += "\nopt2 = " + self.opt2
 486           break
 487 #
 488         self.nro_couche = iaux1
 489         self.nro_adap = iaux2
 490 #
 491       break
 492 #
 493     if erreur :
 494       message_erreur = messages_erreur[erreur]
 495 #
 496     if self.verbose_max :
 497       print ". rep_calc  :", self.rep_calc
 498       print ". mesh_file :", self.mesh_file
 499 #
 500     return erreur, message_erreur
 501 #
 502 #=========================  Fin de la fonction ===================================
 503 #
 504 #========================= Debut de la fonction ==================================
 505 #
 506   def modif_export ( self ) :
 507 #
 508     """
 509 Modification du fichier export et reperage de quelques informations
 510     """
 511 #
 512     messages_erreur = { 0 : None }
 513 #
 514     nom_fonction = __name__ + "/modif_export"
 515     blabla = "\nDans " + nom_fonction + ","
 516 #
 517     erreur = 0
 518     message_erreur = " "
 519 #
 520     if self.verbose_max :
 521       print blabla
 522       print ". numero    :", self.numero
 523       print ". mesh_file :", self.mesh_file
 524 #
 525     while not erreur :
 526 #
 527 # 1. Lecture du fichier export original
 528 #
 529       nomfic_export = os.path.join(self.rep_calc, "calcul.ref.export")
 530       fic = open (nomfic_export, "r")
 531       les_lignes = fic.readlines()
 532       fic.close()
 533 #
 534 # 2. Ouverture du nouveau fichier export
 535 #
 536       nomfic = "calcul"
 537       if self.nomcas[:6] == "couche" :
 538         nomfic += ".%02d" % self.nro_couche
 539       nomfic += ".%03d.export" % self.numero
 540       self.nomfic_export = os.path.join(self.rep_calc, nomfic)
 541       fic = open (self.nomfic_export, "w")
 542 #
 543 # 3. Exploration des lignes
 544 #
 545       for ligne in les_lignes :
 546 #
 547 # 3.1. Pas de modification, a priori
 548 #
 549         ligne_bis = ligne
 550         saux = ""
 551 #
 552 # 3.2. Decodage des composants de la ligne pour un fichier
 553 #
 554         if ligne[0:2] == "F " :
 555 #
 556           laux = ligne.split()
 557           #print laux
 558           typfic = laux[1]
 559           #print typfic
 560 #
 561           nomfic_0 = laux[2]
 562           if ( ":" in nomfic_0 ) :
 563             laux1 = nomfic_0.split(":")
 564             saux = laux1[0] + ":"
 565             nomfic_0 = laux1[1]
 566 #
 567 # 3.2.1. Si c'est le fichier de commandes, mise a jour du nom du repertoire
 568 #
 569           if typfic == "comm" :
 570 #
 571             nomfic_l_0 = os.path.basename(nomfic_0)
 572             nomfic = os.path.join(self.rep_calc, nomfic_l_0)
 573 #
 574 # 3.2.2. Si ce n'est pas le fichier de commandes, mise a jour du nom
 575 #
 576           else :
 577 #
 578 # 3.2.2.1. Le fichier de maillage est celui passe en argument
 579 #
 580             if typfic == "mmed" :
 581               nomfic = self.mesh_file
 582 #
 583 # 3.2.2.2. Pour les autres fichiers, on recupère le nom initial
 584 #
 585             else :
 586               nomfic_l_0 = os.path.basename(nomfic_0)
 587               laux1 = nomfic_l_0.split(".")
 588 #
 589 # 3.2.2.2.1. Base des noms de fichiers si excavation
 590 #
 591               if laux1[0] == "couche_n" :
 592                 saux0 = "couche_%02d" % self.nro_couche
 593               else :
 594                 saux0 = laux1[0]
 595 #
 596 # 3.2.2.2.2. Indicage des fichiers
 597 #
 598               if len(laux1) >= 3 :
 599                 iaux = len(laux1[1])
 600                 if iaux == 2 :
 601                   saux1 = "%02d" % self.numero
 602                 elif iaux == 3 :
 603                   saux1 = "%03d" % self.numero
 604                 elif iaux == 4 :
 605                   saux1 = "%04d" % self.numero
 606                 else :
 607                   saux1 = "%d" % self.numero
 608                 nomfic_l = saux0 + "." + saux1 + "." + laux1[2]
 609               else :
 610                 nomfic_l = saux0 + "." + laux1[1]
 611 #
 612               nomfic_l_1 = os.path.dirname(nomfic_0)
 613               nomfic = os.path.join(nomfic_l_1, nomfic_l)
 614 #
 615           ligne_bis  = laux[0] + " " + laux[1] + " " + saux
 616           ligne_bis += nomfic + " "
 617           ligne_bis += laux[3] + " " + laux[4] + "\n"
 618 #
 619 # 3.2.2.3. On detruit preventivement les fichiers des resultats
 620 #
 621           if self.nomcas[:6] != "couche" :
 622             if laux[3] == "R" :
 623               if os.path.isfile(nomfic) :
 624                 os.remove(nomfic)
 625 #
 626 # 3.2.3. Memorisation des noms
 627 #
 628           self.dico[typfic] = nomfic
 629 #
 630 # 3.3. Decodage des composants de la ligne pour la base
 631 #
 632         elif ligne[0:2] == "R " :
 633 #
 634           laux = ligne.split()
 635           #print laux
 636           typfic = laux[1]
 637           #print typfic
 638 #
 639 # 3.3.1. Si c'est le fichier de la base, on recupere le nom initial, en ajustant l'indice
 640 #
 641           if typfic in ( "base", "bhdf" ) :
 642 #
 643             nomfic_0 = laux[2]
 644             if ( ":" in nomfic_0 ) :
 645               laux1 = nomfic_0.split(":")
 646               saux = laux1[0] + ":"
 647               nomfic_0 = laux1[1]
 648             nomfic_l_0 = os.path.basename(nomfic_0)
 649             laux1 = nomfic_l_0.split(".")
 650             if len(laux1) >= 3 :
 651               iaux = len(laux1[1])
 652               if iaux == 2 :
 653                 saux1 = "%02d" % self.numero
 654               elif iaux == 3 :
 655                 saux1 = "%03d" % self.numero
 656               elif iaux == 4 :
 657                 saux1 = "%04d" % self.numero
 658               else :
 659                 saux1 = "%d" % self.numero
 660               nomfic_l = laux1[0] + "." + saux1 + "." + laux1[2]
 661             elif len(laux1) >= 2 :
 662               if laux1[0] == "couche_nm1" :
 663                 saux0 = "couche_%02d" % (self.nro_couche-1)
 664               elif laux1[0] == "couche_n" :
 665                 saux0 = "couche_%02d" % self.nro_couche
 666               else :
 667                 saux0 = laux1[0]
 668               nomfic_l = saux0 + "." + laux1[1]
 669             else :
 670               nomfic_l = nomfic_l_0
 671             nomfic_l_1 = os.path.dirname(nomfic_0)
 672             nomfic = os.path.join(nomfic_l_1, nomfic_l)
 673 #
 674             ligne_bis  = laux[0] + " " + laux[1] + " " + saux
 675             ligne_bis += nomfic + " "
 676             ligne_bis += laux[3] + " " + laux[4] + "\n"
 677 #
 678 # 3.4. Decodage des composants de la ligne pour un parametre
 679 #
 680         elif ligne[0:2] == "P " :
 681 #
 682           laux = ligne.split()
 683           #print laux
 684           if ( len(laux) == 3 ) :
 685             aux = laux[2]
 686             if laux[1] in ( "username" ) :
 687               self.username = aux
 688             elif laux[1] in ( "uclient" ) :
 689               self.uclient = aux
 690             elif laux[1] in ( "aster_root" ) :
 691               self.aster_root = aux
 692             elif laux[1] in ( "serveur" ) :
 693               self.serveur = aux
 694             elif laux[1] in ( "mclient" ) :
 695               self.mclient = aux
 696             #elif laux[1] in ( "display" ) :
 697               #aux = self.machine+":0.0"
 698             elif laux[1] in ( "nomjob" ) :
 699               self.nomjob = aux
 700             elif laux[1] in ( "mode" ) :
 701               self.mode = aux
 702             ligne_bis  = laux[0] + " " + laux[1] + " " + aux  + "\n"
 703 #
 704 # 3.5. Ecriture de la ligne
 705 #
 706         fic.write(ligne_bis)
 707 #
 708       fic.close()
 709 #
 710       break
 711 #
 712     if erreur :
 713       message_erreur = messages_erreur[erreur]
 714 #
 715     if self.verbose_max :
 716       print ". mclient    ", self.mclient
 717       print ". uclient    ", self.uclient
 718       print ". serveur    ", self.serveur
 719       print ". username   ", self.username
 720       print ". aster_root ", self.aster_root
 721       print ". nomjob     ", self.nomjob
 722       print ". mode       ", self.mode
 723 #
 724     return erreur, message_erreur
 725 #
 726 #=========================  Fin de la fonction ===================================
 727 #
 728 #========================= Debut de la fonction ==================================
 729 #
 730   def modif_cas_transitoire ( self ) :
 731 #
 732     """
 733 Modification du fichier de commandes lie au cas transitoire
 734     """
 735 #
 736     messages_erreur = { 0 : None,
 737                         2 : "Mot_cle inconnu dans les commandes." }
 738 #
 739     nom_fonction = __name__ + "/modif_cas_transitoire"
 740     blabla = "\nDans " + nom_fonction + ","
 741 #
 742     erreur = 0
 743     message_erreur = " "
 744 #
 745     if self.verbose_max :
 746       print blabla
 747       print ". opt1 :", self.opt1
 748       print ". opt2 :", self.opt2
 749 #
 750     while not erreur :
 751 #
 752 # 1. Lecture du fichier de commandes
 753 #
 754       nomfic = os.path.join(self.rep_calc, self.dico["comm"])
 755       fic = open (nomfic, "r")
 756       les_lignes = fic.readlines()
 757       fic.close()
 758 #
 759 # 2. Ouverture du nouveau fichier de commandes
 760 #
 761       fic = open (nomfic, "w")
 762 #
 763 # 3. Exploration des lignes
 764 #
 765 # 3.0. Reperage de la zone a modifier
 766 #
 767       A_modifier = 0
 768 #
 769       for ligne in les_lignes :
 770 #
 771         if self.verbose_max :
 772           print "ligne =", ligne[:-1]
 773 #
 774 # 3.1. Pas de modification, a priori
 775 #
 776         ligne_bis = ligne
 777 #
 778 # 3.2. Reperage de la zone a modifier
 779 #
 780         if ( "A PERSONNALISER - DEBUT" in ligne ) :
 781           A_modifier = 1
 782         elif ( "A PERSONNALISER - FIN" in ligne ) :
 783           A_modifier = 0
 784 #
 785 # 3.3. Modification
 786 #
 787         #print "A_modifier =", A_modifier
 788         if A_modifier :
 789 #
 790           #print "ligne =", ligne[:-1]
 791           for iaux in range(2) :
 792             if iaux == 0 :
 793               mot_cle_ref = "NUME_INST_"
 794               lg_mot_cle = 10
 795             else :
 796               mot_cle_ref = "INST_"
 797               lg_mot_cle = 5
 798             #print "mot_cle_ref =", mot_cle_ref
 799 #
 800             if ligne[0:lg_mot_cle] == mot_cle_ref :
 801 #
 802               if ligne[lg_mot_cle:lg_mot_cle+4] == "INIT" :
 803                 aux = self.opt1
 804                 motcle = ligne[0:lg_mot_cle+4]
 805               elif ligne[lg_mot_cle:lg_mot_cle+3] == "FIN" :
 806                 aux = self.opt2
 807                 motcle = ligne[0:lg_mot_cle+3]
 808               else :
 809                 self.message_info += ligne
 810                 erreur = 2
 811                 break
 812 #
 813               ligne_bis = motcle + " = " + str(aux) +"\n"
 814 #
 815           if erreur :
 816             break
 817 #
 818 # 3.4. Ecriture de la ligne
 819 #
 820         fic.write(ligne_bis)
 821 #
 822       fic.close()
 823 #
 824       break
 825 #
 826 # 4. Gestion des erreurs
 827 #
 828     if erreur :
 829       message_erreur = messages_erreur[erreur]
 830 #
 831     return erreur, message_erreur
 832 #
 833 #=========================  Fin de la fonction ===================================
 834 #
 835 #========================= Debut de la fonction ==================================
 836 #
 837   def modif_cas_excavation ( self ) :
 838 #
 839     """
 840 Modification du fichier de commandes lie au cas de l'excavation
 841     """
 842 #
 843     messages_erreur = { 0 : None }
 844 #
 845     nom_fonction = __name__ + "/modif_cas_excavation"
 846     blabla = "\nDans " + nom_fonction + ","
 847 #
 848     erreur = 0
 849     message_erreur = " "
 850 #
 851     if self.verbose_max :
 852       print blabla
 853       print ". numero     :", self.numero
 854       print ". nro_couche :", self.nro_couche
 855       print ". nro_adap   :", self.nro_adap
 856 #
 857     while not erreur :
 858 #
 859 # 1. Lecture du fichier de commandes
 860 #
 861       nomfic = os.path.join(self.rep_calc, self.dico["comm"])
 862       fic = open (nomfic, "r")
 863       les_lignes = fic.readlines()
 864       fic.close()
 865 #
 866 # 2. Ouverture du nouveau fichier de commandes
 867 #
 868       fic = open (nomfic, "w")
 869 #
 870 # 3. Exploration des lignes
 871 #
 872 # 3.0. Reperage de la zone a modifier
 873 #
 874       A_modifier = 0
 875 #
 876       for ligne in les_lignes :
 877 #
 878         if self.verbose_max :
 879           print "ligne =", ligne[:-1]
 880 #
 881 # 3.1. Pas de modification, a priori
 882 #
 883         ligne_bis = ligne
 884 #
 885 # 3.2. Reperage de la zone a modifier
 886 #
 887         if ( "A PERSONNALISER - DEBUT" in ligne ) :
 888           A_modifier = 1
 889         elif ( "A PERSONNALISER - FIN" in ligne ) :
 890           A_modifier = 0
 891 #
 892 # 3.3. Modification
 893 #
 894         #print "A_modifier =", A_modifier
 895         if A_modifier :
 896 #
 897           #print "ligne =", ligne[:-1]
 898           for iaux in range(3) :
 899             if iaux == 0 :
 900               mot_cle_ref = "nro_mail"
 901               lg_mot_cle = 8
 902               aux = self.numero
 903             elif iaux == 1 :
 904               mot_cle_ref = "nro_couche"
 905               lg_mot_cle = 10
 906               aux = self.nro_couche
 907             elif iaux == 2 :
 908               mot_cle_ref = "nro_adap"
 909               lg_mot_cle = 8
 910               aux = self.nro_adap
 911             #print "mot_cle_ref =", mot_cle_ref
 912 #
 913             if ligne[0:lg_mot_cle] == mot_cle_ref :
 914               #print "==> aux =", aux, type(aux)
 915               ligne_bis = mot_cle_ref + " = " + str(aux) +"\n"
 916 #
 917 # 3.4. Ecriture de la ligne
 918 #
 919         fic.write(ligne_bis)
 920 #
 921       fic.close()
 922 #
 923       break
 924 #
 925 # 4. Gestion des erreurs
 926 #
 927     if erreur :
 928       message_erreur = messages_erreur[erreur]
 929 #
 930     return erreur, message_erreur
 931 #
 932 #=========================  Fin de la fonction ===================================
 933 #
 934 #========================= Debut de la fonction ==================================
 935 #
 936   def calcul ( self ) :
 937 #
 938     """
 939 Lancement d'un calcul
 940     """
 941 #
 942     messages_erreur = { 0 : None }
 943 #
 944     nom_fonction = __name__ + "/calcul"
 945     blabla = "\nDans " + nom_fonction + ","
 946 #
 947     erreur = 0
 948     message_erreur = " "
 949 #
 950     if self.verbose_max :
 951       print ". mclient    ", self.mclient
 952       print ". serveur    ", self.serveur
 953 #
 954 # 1. Copie du fichier export sur le serveur de calcul
 955 #
 956     if ( self.mclient != self.serveur ) :
 957 #
 958       nomfic_export_dist = self.nomjob + ".export"
 959       commande = "scp " + self.nomfic_export + " " + self.username + "@" + self.serveur + ":" + nomfic_export_dist
 960       if self.verbose_max :
 961         print "Copie du fichier export vers", self.serveur, ":"
 962         print commande
 963       erreur = os.system(commande)
 964 #
 965 # 2. Commande du lancement
 966 #
 967     commande_base  = os.path.join(self.aster_root, "bin", "as_run")
 968     commande_base += " "
 969     if self.mode == "batch" :
 970       commande_base += "--serv "
 971     commande_base += self.username + "@" + self.serveur + ":"
 972     #if self.verbose_max :
 973       #print commande_base
 974 #
 975     fic_caract   = tempfile.mktemp()
 976     fic_caract_2 = tempfile.mktemp()
 977 #
 978 # 3. Lancement
 979 # 3.1. Commande finale
 980 #
 981     if ( self.mclient == self.serveur ) :
 982       commande  = commande_base
 983       commande += commande_base + self.nomfic_export
 984     else :
 985       commande  = "ssh " + self.username + "@" + self.serveur
 986       commande += " \"" + commande_base + nomfic_export_dist + "\""
 987     commande += " 1>" + fic_caract
 988     commande += " 2>" + fic_caract_2
 989     if self.verbose_max :
 990       print "Lancement sur", self.serveur, ":"
 991       print commande
 992 #
 993 # 3.2. Lancement vrai
 994 #
 995     erreur = os.system(commande)
 996     if erreur :
 997       messages_erreur[erreur] = "erreur de calcul numero %d" % erreur
 998     else :
 999       self.message_info += "resultat dans le fichier :\n"
1000       #print self.dico
1001       self.message_info += self.dico["rmed"]+"\n"
1002 #
1003     if self.verbose_max :
1004       print blabla
1005       print ". erreur     :", erreur
1006       print ". self.mode  :", self.mode
1007       print ". fic_caract :", fic_caract
1008 #
1009     if erreur :
1010       message_erreur = messages_erreur[erreur]
1011 #
1012     return erreur, message_erreur, fic_caract, fic_caract_2
1013 #
1014 #=========================  Fin de la fonction ===================================
1015 #
1016 #========================= Debut de la fonction ==================================
1017 #
1018   def calcul_aster_attente ( self, fic_caract ) :
1019 #
1020     """
1021 Bilan du calcul Aster
1022 fic_caract : fichier caracteristique du job
1023     """
1024 #
1025     nom_fonction = __name__ + "/calcul_aster_attente"
1026     blabla = "\nDans " + nom_fonction + ","
1027 #
1028     erreur = 0
1029     message_erreur = " "
1030 #
1031     if self.verbose_max :
1032       print ". fic_caract :", fic_caract
1033       print ". nomjob     :", self.nomjob
1034       print ". rep_calc   :", self.rep_calc
1035       print ". mode       :", self.mode
1036       print ". attente    :", self.attente
1037 #
1038     if ( self.mode != "interactif" ) :
1039 #
1040 # 1. Recuperation du numero de job
1041 #
1042       fic = open (fic_caract, "r")
1043       les_lignes = fic.readlines()
1044       fic.close()
1045   #
1046       for ligne in les_lignes :
1047         #print ligne
1048         if ( len(ligne)>0 ) :
1049           # en batch :
1050           if "JOBID" in ligne :
1051             #print ligne
1052             laux = ligne.split()
1053             laux1 = laux[0].split("=")
1054             numjob = laux1[1]
1055           # en interactif :
1056           elif "num_job" in ligne :
1057             #print ligne
1058             laux = ligne.split("num_job")
1059             laux1 = laux[1].split()
1060             numjob = laux1[0]
1061   #
1062       if self.verbose :
1063         print ". numjob :", numjob
1064 #
1065 # 2. Commande de l'examen de l'etat du job,
1066 #
1067       fic_etat = os.path.join(self.rep_calc, self.nomjob+".etat")
1068       fic_etat_2 = tempfile.mktemp()
1069       commande_base  = os.path.join(self.aster_root, "bin", "as_run")
1070       commande_base += " --actu " + numjob + " " + self.nomjob + " " + self.mode
1071       if self.verbose_max :
1072         print "commande_base =", commande_base
1073       if ( self.mclient == self.serveur ) :
1074         commande  = commande_base
1075       else :
1076         commande  = "ssh " + self.username + "@" + self.serveur
1077         commande += " \"" + commande_base + "\""
1078       commande += " 1>" + fic_etat
1079       commande += " 2>" + fic_etat_2
1080       if self.verbose_max :
1081         print "Examen sur", self.serveur, ":"
1082         print commande
1083 #
1084 # 3. Examen de l'etat du job, jusqu'a la fin
1085 #
1086       encore = 1
1087       while encore :
1088   #
1089         if encore % 4 == 0 :
1090           aux = ((encore-1)*self.attente) / 60
1091           print "..", aux, "mn"
1092           #print diag
1093   #
1094         time.sleep(self.attente)
1095         erreur = os.system(commande)
1096   #
1097         if erreur :
1098           erreur = -1
1099           break
1100         elif os.path.isfile(fic_etat) :
1101           fic = open (fic_etat, "r")
1102           les_lignes = fic.readlines()
1103           fic.close()
1104           if len(les_lignes) > 0 :
1105             if len(les_lignes[0]) > 0 :
1106               laux = les_lignes[0].split()
1107               laux1 = laux[0].split("=")
1108               etat = laux1[1]
1109               laux1 = laux[1].split("=")
1110               diag = laux1[1]
1111               if self.verbose_max :
1112                 print etat, diag
1113               if etat in ( "RUN", "PEND" ) :
1114                 encore += 1
1115               else :
1116                 if etat != "ENDED" :
1117                   self.message_info += "Etat du job : " + etat
1118                   erreur = -2
1119                 else :
1120                   if diag[:3] in ( "<S>", "<F>" ) :
1121                     erreur = -3
1122                 if erreur :
1123                   self.message_info = "Diagnostic du job : " + diag + "\n"
1124                 encore = 0
1125                 break
1126             else :
1127               encore += 1
1128           else :
1129             encore += 1
1130         else :
1131           erreur = -4
1132           break
1133 #
1134       os.remove(fic_etat_2)
1135 #
1136     if self.verbose_max :
1137       print blabla
1138       print ". erreur :", erreur
1139 #
1140     if erreur :
1141       message_erreur = "Erreur dans le calcul"
1142 #
1143     return erreur, message_erreur
1144 #
1145 #=========================  Fin de la fonction ===================================
1146 #
1147 #========================= Debut de la fonction ==================================
1148 #
1149   def post_aster ( self, dico_resu_init ) :
1150 #
1151     """
1152 Affichage de resultats selon les cas
1153     """
1154 #
1155     messages_erreur = { 0 : None,
1156                         1 : "Ce fichier est inconnu." }
1157 #
1158     nom_fonction = __name__ + "/post_aster"
1159     blabla = "\nDans " + nom_fonction + ","
1160 #
1161     erreur = 0
1162     message_erreur = " "
1163 #
1164     dico_resu = {}
1165     for cle in dico_resu_init.keys() :
1166       dico_resu[cle] = dico_resu_init[cle]
1167 #
1168     while not erreur :
1169 #
1170 # 1. Exploration du fichier resu
1171 #
1172 # 1.1. Recuperation du contenu
1173 #
1174       nomfic = self.dico["resu"]
1175       chaine = "V_TEST"
1176       nuocc = 1
1177       erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1178       if ( erreur > 0 ) :
1179         break
1180       self.message_info += info[:-1]
1181 #
1182 # 1.2. Details
1183 #
1184       if ( erreur == 0 ) :
1185         info = info.replace(chaine, " ")
1186         laux = info[:-1].split()
1187         aux = laux[0]
1188         if ( "D" in aux ) :
1189           aux = aux.replace("D", "E")
1190         dico_resu[chaine] = float(aux)
1191       else :
1192         erreur = 0
1193 #
1194 # 2. Exploration du fichier mess
1195 # 2.1. Que chercher ?
1196 #
1197       for chaine in ( "INSTANT", "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1198 #
1199 # 2.2. Recuperation du contenu
1200 #
1201         nomfic = self.dico["mess"]
1202         if chaine == "INSTANT" :
1203           nuocc = 0
1204         else :
1205           nuocc = 1
1206         erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1207         if ( erreur > 0 ) :
1208           break
1209         self.message_info += info[:-1]
1210 #
1211 # 2.3. Details
1212 #
1213         if ( erreur == 0 ) :
1214           if chaine == "INSTANT" :
1215             l_aux = info[:-1].split()
1216             lg_aux = len(l_aux)
1217             for iaux in range(lg_aux) :
1218               if ( "ORDRE" in l_aux[iaux] ) :
1219                 if l_aux[iaux+1] == ":" :
1220                   jaux = iaux+2
1221                 else :
1222                   jaux = iaux+1
1223                 ordre = int(l_aux[jaux])
1224                 dico_resu["ORDRE"] = ordre
1225                 dico_resu["PAS_DE_TEMPS"] = ordre
1226           elif chaine in ( "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1227             l_aux = info[:-1].split(chaine)
1228             dico_resu[chaine] = int(l_aux[1])
1229         else :
1230           erreur = 0
1231 #
1232       if erreur :
1233         break
1234 #
1235 # 3. Fichier de resultats au format med
1236 #
1237       dico_resu["FileName"] = self.dico["rmed"]
1238 #
1239       break
1240 #
1241     if self.verbose :
1242       print blabla
1243       print ". erreur :", erreur
1244       print ". dico_resu :", dico_resu
1245 #
1246     if erreur :
1247       message_erreur = messages_erreur[erreur]
1248 #
1249     return erreur, message_erreur, dico_resu
1250 #
1251 #=========================  Fin de la fonction ===================================
1252 #
1253 #========================= Debut de la fonction ==================================
1254 #
1255   def post_aster_1 ( self, nomfic, chaine, nuocc ) :
1256 #
1257     """
1258 Decodage de fichier
1259 nomfic = nom du fichier a decoder
1260 chaine = chaine a chercher
1261 nuocc = numero de l'occurence a chercher, 0 si toutes
1262 Retour :
1263 codret = 0 : tout va bien
1264          1 : le fichier de resultats est absent
1265         -1 : la chaine est absente
1266 message_erreur = "" : tout va bien
1267                != "" si probleme
1268 info = la ou les lignes recherchees
1269     """
1270 #
1271     messages_erreur = { 0 : None,
1272                        -1 : "La chaine est absente.",
1273                         1 : "Ce fichier est inconnu." }
1274 #
1275     nom_fonction = __name__ + "/post_aster_1"
1276     blabla = "\nDans " + nom_fonction + " :"
1277     if self.verbose_max :
1278       print blabla, "chaine =", chaine, ", nuocc =", nuocc
1279 #
1280     erreur = -1
1281     message_erreur = " "
1282     info = ""
1283 #
1284     while not erreur :
1285 #
1286 # 1. Lecture du fichier
1287 #
1288       if not os.path.isfile(nomfic) :
1289         self.message_info += "\nFichier "+nomfic+"\n"
1290         erreur = 1
1291         break
1292       fic = open (nomfic, "r")
1293       les_lignes = fic.readlines()
1294       fic.close()
1295 #
1296 # 2. Exploration des lignes
1297 # 2.1. On recupere tout
1298 #
1299       if chaine == None :
1300 #
1301         for ligne in les_lignes :
1302           info += ligne
1303 #
1304 # 2.2. On cible
1305 #
1306       else :
1307 #
1308         self.message_info += "\n"
1309         iaux = 0
1310         for ligne in les_lignes :
1311           if chaine in ligne :
1312             iaux += 1
1313             if ( ( nuocc == 0 ) or ( iaux == nuocc ) ) :
1314               info += ligne
1315               erreur = 0
1316 #
1317       break
1318 #
1319     if ( self.verbose_max or ( erreur>0 ) ) :
1320       print blabla, "chaine =", chaine, ", nuocc =", nuocc
1321       print ". erreur =", erreur
1322 #
1323     if erreur :
1324       message_erreur = messages_erreur[erreur]
1325 #
1326     return erreur, message_erreur, info
1327 #
1328 #=========================  Fin de la fonction ===================================
1329 #
1330 #========================= Debut de la fonction ==================================
1331 #
1332   def dump_resultat ( self ) :
1333 #
1334     """
1335 Dump du resultat du calcul
1336     """
1337 #
1338     messages_erreur = { 0 : None }
1339 #
1340     nom_fonction = __name__ + "/dump_resultat"
1341     blabla = "\nDans " + nom_fonction + ","
1342 #
1343     erreur = 0
1344     message_erreur = " "
1345 #
1346 # 1. Lancement
1347 #
1348     nomfic_donn = os.path.join(self.rep_calc, "donn")
1349     fic = open (nomfic_donn, "w")
1350     fic.write("1\n1\n1\n")
1351     fic.close()
1352     fic_dump = self.dico["rmed"]+".dump"
1353     commande = "mdump " + self.dico["rmed"] + "<" + nomfic_donn + ">" + fic_dump
1354     #print commande
1355     erreur = os.system(commande)
1356     if erreur :
1357       messages_erreur[erreur] = "Erreur de dump numero %d" % erreur
1358     else :
1359       self.message_info += "\nDump dans le fichier :\n"
1360       self.message_info += fic_dump+"\n"
1361 #
1362     if self.verbose_max :
1363       print blabla
1364       print ". erreur :", erreur
1365 #
1366     os.remove(nomfic_donn)
1367 #
1368     if erreur :
1369       message_erreur = messages_erreur[erreur]
1370 #
1371     return erreur, message_erreur
1372 #
1373 #=========================  Fin de la fonction ===================================
1374 #
1375 #
1376 if __name__ == "__main__" :
1377 #
1378   #print "Arguments a l'entree de",  sys.argv[0], ":", sys.argv[1:], "\n"
1379 #
1380   Script_A = Script(sys.argv[1:])
1381 #
1382   if Script_A.affiche_aide_globale :
1383     Script_A.message_info = Script_A.__doc__
1384     erreur_m = 0
1385     message_erreur_m = ""
1386   else :
1387     dico_resu_m = {}
1388     erreur_m, message_erreur_m, dico_resu_m = Script_A.compute ()
1389 #
1390   sys.stdout.write(Script_A.message_info+"\n")
1391   sys.stderr.write(message_erreur_m+"\n")
1392   sys.exit(erreur_m)