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