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