doc/files/yacs_script.py

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