2 # -*- coding: utf-8 -*-
3 # Copyright (C) 2013-2023 CEA, EDF
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.
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.
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
19 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 Lancement d'un calcul ASTER
25 __revision__ = "V5.11"
32 # ==== Debut de personnalisation ====
34 # opt1_defaut, opt2_defaut : les valeurs par defaut de ces options, selon les cas
38 # ==== Fin de personnalisation ====
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.
48 Le mode de lancement est le suivant :
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]
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.
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.
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.
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.
77 -h|-help : produit l'aide, quels que soient les autres arguments
78 -v : mode verbeux simple
79 -v_max : mode verbeux intensif
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
90 # 0.1. ==> Les constantes de la machine
92 info_gene = os.uname()
95 machine = info_gene[1]
101 if "LOGNAME" in os.environ :
102 user = os.environ ["LOGNAME"]
108 # 0.3. ==> Le lancement d'Aster
114 # Attente en secondes entre deux controles du job
117 # 0.4. ==> Information
119 affiche_aide_globale = 0
127 #========================= Debut de la fonction ==================================
129 def __init__ ( self, liste_arg ) :
132 Le constructeur de la classe Script
135 # 1. Decodage des arguments
139 self.mesh_file = None
145 for argu in liste_arg :
148 l_aux = argu.split("=")
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" :
161 elif l_aux[0] == "--opt1" :
163 elif l_aux[0] == "--opt2" :
165 elif l_aux[0] == "--wait" :
166 self.attente = l_aux[1]
167 elif l_aux[0] == "--version" :
168 self.version = l_aux[1]
171 if saux in ( "-H", "-HELP" ) :
172 self.affiche_aide_globale = 1
175 elif saux in ( "-V_MAX", "-VMAX" ) :
178 elif saux == "-DUMP" :
181 # 2. Les paramètres de base
184 self.nomfic_export = None
186 self.numero_str = None
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)
198 #========================= Fin de la fonction ===================================
200 #========================= Debut de la fonction ==================================
202 def compute ( self ) :
205 Lancement d'un calcul
208 nom_fonction = __name__ + "/compute"
209 blabla = "\nDans " + nom_fonction + ","
218 # 1. Preparation du calcul
220 #print "\n==== self.prepa_calcul () ===="
221 erreur, message_erreur = self.prepa_calcul ()
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
235 #print "\n==== calcul_aster_attente.calcul (",fic_caract,") ===="
236 erreur, message_erreur = self.calcul_aster_attente (fic_caract)
239 os.remove(fic_caract)
240 os.remove(fic_caract_2)
242 # 4. Gestion du resultat
244 #print "\n==== self.post_aster (dico_resu) ===="
245 erreur, message_erreur, dico_resu = self.post_aster (dico_resu)
252 #print "\n==== self.dump_resultat() ===="
253 erreur, message_erreur = self.dump_resultat ()
259 if self.verbose_max :
261 print(". erreur :", erreur)
263 return erreur, message_erreur, dico_resu
265 #========================= Fin de la fonction ===================================
267 #========================= Debut de la fonction ==================================
269 def prepa_calcul ( self ) :
272 Preparation d'un calcul
275 nom_fonction = __name__ + "/prepa_calcul"
276 blabla = "\nDans " + nom_fonction + ","
281 if self.verbose_max :
283 print(". rep_calc :", self.rep_calc)
284 print(". mesh_file :", self.mesh_file)
285 print(". tr :", self.tr)
289 # 1. Controles des arguments
291 erreur, message_erreur = self.controle_argument()
295 # 2. Modification du fichier export
297 erreur, message_erreur = self.modif_export()
301 # 3. Modifications du fichier de commandes
302 # 3.1. Pour un cas transitoire
305 erreur, message_erreur = self.modif_cas_transitoire()
309 # 3.2. Pour l'excavation
311 elif self.nomcas[:6] == "couche" :
312 erreur, message_erreur = self.modif_cas_excavation()
318 if self.verbose_max :
319 print(blabla, "a la fin")
320 print(". erreur :", erreur)
322 return erreur, message_erreur
324 #========================= Fin de la fonction ===================================
326 #========================= Debut de la fonction ==================================
328 def controle_argument ( self ) :
331 Controle les arguments et stockage de quelques informations
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." }
345 nom_fonction = __name__ + "/controle_argument"
346 blabla = "\nDans " + nom_fonction + ","
351 if self.verbose_max :
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)
363 # 1. Les repertoire et fichier
364 # 1.1. Il y a bien eu une donnee
366 if self.rep_calc == None :
368 elif self.mesh_file == None :
371 self.message_info += "Relancer avec -h pour avoir le mode d'emploi."
374 # 1.2. Le repertoire de calcul
376 self.rep_calc = os.path.expanduser(self.rep_calc)
377 if not os.path.isdir(self.rep_calc) :
378 self.message_info += "Repertoire " + self.rep_calc
382 aux = os.path.join(os.getcwd(), self.rep_calc)
383 self.rep_calc = os.path.normpath(aux)
389 fic = os.path.expanduser(fic)
390 if not os.path.isfile(fic) :
391 aux = os.path.join(self.rep_calc, fic)
392 if not os.path.isfile(aux) :
393 self.message_info += "Fichier : " + fic
397 fic = os.path.normpath(aux)
398 aux = os.path.join(os.getcwd(), fic)
400 self.mesh_file = os.path.normpath(aux)
402 # 2. On en deduit le cas
404 self.nomcas = os.path.basename(self.rep_calc)
405 if self.verbose_max :
406 print(". Cas :", self.nomcas)
408 # 3. Le temps d'attente
412 iaux = int(self.attente)
418 # 4. Le numero du calcul
420 if self.numero == None :
423 if ( self.numero < 100 ) :
424 self.numero_str = "%02d" % self.numero
425 elif ( self.numero < 1000 ) :
426 self.numero_str = "%03d" % self.numero
427 elif ( self.numero < 10000 ) :
428 self.numero_str = "%04d" % self.numero
430 self.numero_str = "%d" % self.numero
432 # 5. Options speciales pour les cas transitoires et pour l'excavation
434 if ( self.tr or ( self.nomcas[:6] == "couche" ) ) :
436 if self.opt1 == None :
437 self.opt1 = opt1_defaut[self.nomcas]
438 #print ". opt1 defaut :", self.opt1
440 if self.opt2 == None :
441 self.opt2 = opt2_defaut[self.nomcas]
442 #print ". opt2 defaut :", self.opt2
444 # 5.1. Pour un cas transitoire
451 iaux1 = int(self.opt1)
453 daux1 = float(self.opt1)
460 iaux2 = int(self.opt2)
462 daux2 = float(self.opt2)
464 if ( ( daux1 == None ) or ( daux2 == None ) ) :
465 #print "------------ ( daux1 == None ) or ( daux2 == None ) ------------"
466 #print "iaux1, iaux2 =", iaux1, iaux2
469 elif ( ( iaux1 == None ) or ( iaux2 == None ) ) :
470 #print "------------ ( iaux1 == None ) or ( iaux2 == None ) ------------"
471 #print "daux1, daux2 =", daux1, daux2
478 self.message_info += "opt1 = " + self.opt1
479 self.message_info += "\nopt2 = " + self.opt2
481 # 5.2. Pour l'excavation
483 elif self.nomcas[:6] == "couche" :
487 iaux1 = int(self.opt1)
491 if ( ( iaux1 < 1 ) or ( iaux1 > 20 ) ) :
492 #print "iaux1 =", iaux1
497 iaux2 = int(self.opt2)
502 #print "iaux1 =", iaux1
506 self.message_info += "nro_mail = " + self.numero
507 self.message_info += "\nopt1 = " + self.opt1
508 self.message_info += "\nopt2 = " + self.opt2
511 self.nro_couche = iaux1
512 self.nro_adap = iaux2
517 message_erreur = messages_erreur[erreur]
519 if self.verbose_max :
520 print(". rep_calc :", self.rep_calc)
521 print(". mesh_file :", self.mesh_file)
522 print(". opt1 :", self.opt1)
523 print(". opt2 :", self.opt2)
525 return erreur, message_erreur
527 #========================= Fin de la fonction ===================================
529 #========================= Debut de la fonction ==================================
531 def modif_export ( self ) :
534 Modification du fichier export et reperage de quelques informations
537 messages_erreur = { 0 : None }
539 nom_fonction = __name__ + "/modif_export"
540 blabla = "\nDans " + nom_fonction + ","
545 if self.verbose_max :
547 print(". numero :", self.numero)
548 print(". mesh_file :", self.mesh_file)
552 # 1. Lecture du fichier export original
554 fic_export_ref = os.path.join(self.rep_calc, "calcul.ref.export")
555 fic = open (fic_export_ref, "r")
556 les_lignes = fic.readlines()
559 # 2. Ouverture du nouveau fichier export
562 if self.nomcas[:6] == "couche" :
563 nomfic += ".%02d" % self.nro_couche
564 nomfic += "." + self.numero_str + ".export"
565 self.nomfic_export = os.path.join(self.rep_calc, nomfic)
566 if self.verbose_max :
567 print(". nouveau fic_export :", self.nomfic_export)
568 fic = open (self.nomfic_export, "w")
570 # 3. Exploration des lignes
572 for ligne in les_lignes :
574 # 3.1. Pas de modification, a priori
579 # 3.2. Decodage des composants de la ligne pour un fichier
581 if ligne[0:2] == "F " :
592 if ( ":" in nomfic_0 ) :
593 laux1 = nomfic_0.split(":")
594 saux = laux1[0] + ":"
597 # 3.2.1. Si c'est le fichier de commandes, mise a jour du nom du repertoire
599 if ( typfic == "comm" ) :
601 if self.verbose_max :
602 print(". Commandes : mise a jour du nom du repertoire")
604 nomfic_l_0 = os.path.basename(nomfic_0)
605 nomfic = os.path.join(self.rep_calc, nomfic_l_0)
607 # 3.2.2. Si c'est un fichier de resultats ou le fichier de maillage, mise a jour du nom
609 elif ( ( statut == "R" ) or ( typfic == "mmed" ) ) :
610 if self.verbose_max :
611 print(". Mise a jour du nom")
614 # 3.2.2.1. Le fichier de maillage est celui passe en argument
616 if typfic == "mmed" :
617 nomfic = self.mesh_file
619 # 3.2.2.2. Pour les autres fichiers, on recupère le nom initial
622 nomfic_l_0 = os.path.basename(nomfic_0)
623 laux1 = nomfic_l_0.split(".")
624 #print "laux1 =", laux1
626 # 3.2.2.2.1. Base des noms de fichiers si excavation
628 if laux1[0] == "couche_n" :
629 saux0 = "couche_%02d" % self.nro_couche
631 iaux = len(laux1[-1]) + 1
632 saux0 = nomfic_l_0[:-iaux]
633 #print "saux0 =", saux0
635 # 3.2.2.2.2. Indicage des fichiers
637 nomfic_l = saux0 + "." + self.numero_str + "." + laux1[-1]
638 nomfic_l_1 = os.path.dirname(nomfic_0)
639 nomfic = os.path.join(nomfic_l_1, nomfic_l)
640 #print " ==> ", nomfic
643 ligne_bis = laux[0] + " " + laux[1] + " " + saux
644 ligne_bis += nomfic + " "
645 ligne_bis += laux[3] + " " + laux[4] + "\n"
647 # 3.2.2.3. On detruit preventivement les fichiers des resultats
649 if ( statut == "R" ) :
650 if ( self.nomcas[:6] != "couche" ) :
651 if os.path.isfile(nomfic) :
654 # 3.2.3. Memorisation des noms
656 self.dico[typfic] = nomfic
658 # 3.3. Decodage des composants de la ligne pour la base
660 elif ligne[0:2] == "R " :
667 # 3.3.1. Si c'est le fichier de la base, on recupere le nom initial, en ajustant l'indice
669 if typfic in ( "base", "bhdf" ) :
672 if ( ":" in nomfic_0 ) :
673 laux1 = nomfic_0.split(":")
674 saux = laux1[0] + ":"
676 nomfic_l_0 = os.path.basename(nomfic_0)
677 laux1 = nomfic_l_0.split(".")
679 nomfic_l = laux1[0] + "." + self.numero_str + "." + laux1[2]
680 elif len(laux1) >= 2 :
681 if laux1[0] == "couche_nm1" :
682 saux0 = "couche_%02d" % (self.nro_couche-1)
683 elif laux1[0] == "couche_n" :
684 saux0 = "couche_%02d" % self.nro_couche
687 nomfic_l = saux0 + "." + laux1[1]
689 nomfic_l = nomfic_l_0
690 nomfic_l_1 = os.path.dirname(nomfic_0)
691 nomfic = os.path.join(nomfic_l_1, nomfic_l)
693 ligne_bis = laux[0] + " " + laux[1] + " " + saux
694 ligne_bis += nomfic + " "
695 ligne_bis += laux[3] + " " + laux[4] + "\n"
697 # 3.4. Decodage des composants de la ligne pour un parametre
699 elif ligne[0:2] == "P " :
703 if ( len(laux) == 3 ) :
705 if laux[1] in ( "username" ) :
707 elif laux[1] in ( "uclient" ) :
709 elif laux[1] in ( "aster_root" ) :
710 self.aster_root = aux
711 elif laux[1] in ( "serveur" ) :
713 elif laux[1] in ( "mclient" ) :
715 #elif laux[1] in ( "display" ) :
716 #aux = self.machine+":0.0"
717 elif laux[1] in ( "nomjob" ) :
719 elif laux[1] in ( "mode" ) :
721 ligne_bis = laux[0] + " " + laux[1] + " " + aux + "\n"
723 # 3.5. Ecriture de la ligne
732 message_erreur = messages_erreur[erreur]
734 if self.verbose_max :
735 print(". mclient ", self.mclient)
736 print(". uclient ", self.uclient)
737 print(". serveur ", self.serveur)
738 print(". username ", self.username)
739 print(". aster_root ", self.aster_root)
740 print(". nomjob ", self.nomjob)
741 print(". mode ", self.mode)
743 return erreur, message_erreur
745 #========================= Fin de la fonction ===================================
747 #========================= Debut de la fonction ==================================
749 def modif_cas_transitoire ( self ) :
752 Modification du fichier de commandes lie au cas transitoire
755 messages_erreur = { 0 : None,
756 2 : "Mot_cle inconnu dans les commandes." }
758 nom_fonction = __name__ + "/modif_cas_transitoire"
759 blabla = "\nDans " + nom_fonction + ","
764 if self.verbose_max :
766 print(". opt1 :", self.opt1)
767 print(". opt2 :", self.opt2)
771 # 1. Lecture du fichier de commandes
773 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
774 fic = open (nomfic, "r")
775 les_lignes = fic.readlines()
778 # 2. Ouverture du nouveau fichier de commandes
780 fic = open (nomfic, "w")
782 # 3. Exploration des lignes
784 # 3.0. Reperage de la zone a modifier
788 for ligne in les_lignes :
790 if self.verbose_max :
791 print("ligne =", ligne[:-1])
793 # 3.1. Pas de modification, a priori
797 # 3.2. Reperage de la zone a modifier
799 if ( "A PERSONNALISER - DEBUT" in ligne ) :
801 elif ( "A PERSONNALISER - FIN" in ligne ) :
806 #print "A_modifier =", A_modifier
809 #print "ligne =", ligne[:-1]
810 for iaux in range(2) :
812 mot_cle_ref = "NUME_INST_"
815 mot_cle_ref = "INST_"
817 #print "mot_cle_ref =", mot_cle_ref
819 if ligne[0:lg_mot_cle] == mot_cle_ref :
821 if ligne[lg_mot_cle:lg_mot_cle+4] == "INIT" :
823 motcle = ligne[0:lg_mot_cle+4]
824 elif ligne[lg_mot_cle:lg_mot_cle+3] == "FIN" :
826 motcle = ligne[0:lg_mot_cle+3]
828 self.message_info += ligne
832 ligne_bis = motcle + " = " + str(aux) +"\n"
837 # 3.4. Ecriture de la ligne
845 # 4. Gestion des erreurs
848 message_erreur = messages_erreur[erreur]
850 return erreur, message_erreur
852 #========================= Fin de la fonction ===================================
854 #========================= Debut de la fonction ==================================
856 def modif_cas_excavation ( self ) :
859 Modification du fichier de commandes lie au cas de l'excavation
862 messages_erreur = { 0 : None }
864 nom_fonction = __name__ + "/modif_cas_excavation"
865 blabla = "\nDans " + nom_fonction + ","
870 if self.verbose_max :
872 print(". numero :", self.numero)
873 print(". nro_couche :", self.nro_couche)
874 print(". nro_adap :", self.nro_adap)
878 # 1. Lecture du fichier de commandes
880 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
881 fic = open (nomfic, "r")
882 les_lignes = fic.readlines()
885 # 2. Ouverture du nouveau fichier de commandes
887 fic = open (nomfic, "w")
889 # 3. Exploration des lignes
891 # 3.0. Reperage de la zone a modifier
895 for ligne in les_lignes :
897 if self.verbose_max :
898 print("ligne =", ligne[:-1])
900 # 3.1. Pas de modification, a priori
904 # 3.2. Reperage de la zone a modifier
906 if ( "A PERSONNALISER - DEBUT" in ligne ) :
908 elif ( "A PERSONNALISER - FIN" in ligne ) :
913 #print "A_modifier =", A_modifier
916 #print "ligne =", ligne[:-1]
917 for iaux in range(3) :
919 mot_cle_ref = "nro_mail"
923 mot_cle_ref = "nro_couche"
925 aux = self.nro_couche
927 mot_cle_ref = "nro_adap"
930 #print "mot_cle_ref =", mot_cle_ref
932 if ligne[0:lg_mot_cle] == mot_cle_ref :
933 #print "==> aux =", aux, type(aux)
934 ligne_bis = mot_cle_ref + " = " + str(aux) +"\n"
936 # 3.4. Ecriture de la ligne
944 # 4. Gestion des erreurs
947 message_erreur = messages_erreur[erreur]
949 return erreur, message_erreur
951 #========================= Fin de la fonction ===================================
953 #========================= Debut de la fonction ==================================
955 def calcul ( self ) :
958 Lancement d'un calcul
961 messages_erreur = { 0 : None }
963 nom_fonction = __name__ + "/calcul"
964 blabla = "\nDans " + nom_fonction + ","
969 if self.verbose_max :
970 print(". mclient ", self.mclient)
971 print(". serveur ", self.serveur)
973 # 1. Copie du fichier export sur le serveur de calcul
975 if ( self.mclient != self.serveur ) :
977 nomfic_export_dist = self.nomjob + ".export"
978 commande = "scp " + self.nomfic_export + " " + self.username + "@" + self.serveur + ":" + nomfic_export_dist
979 if self.verbose_max :
980 print("Copie du fichier export vers", self.serveur, ":")
982 erreur = os.system(commande)
984 # 2. Commande du lancement
986 commande_base = os.path.join(self.aster_root, "bin", "as_run")
988 if self.mode == "batch" :
989 commande_base += "--serv "
990 commande_base += self.username + "@" + self.serveur + ":"
991 #if self.verbose_max :
994 t_aux = tempfile.mkstemp()
995 fic_caract = t_aux[1]
996 t_aux = tempfile.mkstemp()
997 fic_caract_2 = t_aux[1]
1000 # 3.1. Commande finale
1002 if ( self.mclient == self.serveur ) :
1003 commande = commande_base
1004 commande += commande_base + self.nomfic_export
1006 commande = "ssh " + self.username + "@" + self.serveur
1007 commande += " \"" + commande_base + nomfic_export_dist + "\""
1008 commande += " 1>" + fic_caract
1009 commande += " 2>" + fic_caract_2
1010 if self.verbose_max :
1011 print("Lancement sur", self.serveur, ":")
1014 # 3.2. Lancement vrai
1016 erreur = os.system(commande)
1018 messages_erreur[erreur] = "erreur de calcul numero %d" % erreur
1020 self.message_info += "resultat dans le fichier :\n"
1022 self.message_info += self.dico["rmed"]+"\n"
1024 if self.verbose_max :
1026 print(". erreur :", erreur)
1027 print(". self.mode :", self.mode)
1028 print(". fic_caract :", fic_caract)
1031 message_erreur = messages_erreur[erreur]
1033 return erreur, message_erreur, fic_caract, fic_caract_2
1035 #========================= Fin de la fonction ===================================
1037 #========================= Debut de la fonction ==================================
1039 def calcul_aster_attente ( self, fic_caract ) :
1042 Bilan du calcul Aster
1043 fic_caract : fichier caracteristique du job
1046 nom_fonction = __name__ + "/calcul_aster_attente"
1047 blabla = "\nDans " + nom_fonction + ","
1050 message_erreur = " "
1052 if self.verbose_max :
1053 print(". fic_caract :", fic_caract)
1054 print(". nomjob :", self.nomjob)
1055 print(". rep_calc :", self.rep_calc)
1056 print(". mode :", self.mode)
1057 print(". attente :", self.attente)
1059 if ( self.mode != "interactif" ) :
1061 # 1. Recuperation du numero de job
1063 fic = open (fic_caract, "r")
1064 les_lignes = fic.readlines()
1067 for ligne in les_lignes :
1069 if ( len(ligne)>0 ) :
1071 if "JOBID" in ligne :
1073 laux = ligne.split()
1074 laux1 = laux[0].split("=")
1077 elif "num_job" in ligne :
1079 laux = ligne.split("num_job")
1080 laux1 = laux[1].split()
1084 print(". numjob :", numjob)
1086 # 2. Commande de l'examen de l'etat du job,
1088 fic_etat = os.path.join(self.rep_calc, self.nomjob+".etat")
1089 t_aux = tempfile.mkstemp()
1090 fic_etat_2 = t_aux[1]
1091 commande_base = os.path.join(self.aster_root, "bin", "as_run")
1092 commande_base += " --actu " + numjob + " " + self.nomjob + " " + self.mode
1093 if self.verbose_max :
1094 print("commande_base =", commande_base)
1095 if ( self.mclient == self.serveur ) :
1096 commande = commande_base
1098 commande = "ssh " + self.username + "@" + self.serveur
1099 commande += " \"" + commande_base + "\""
1100 commande += " 1>" + fic_etat
1101 commande += " 2>" + fic_etat_2
1102 if self.verbose_max :
1103 print("Examen sur", self.serveur, ":")
1106 # 3. Examen de l'etat du job, jusqu'a la fin
1111 if encore % 4 == 0 :
1112 aux = ((encore-1)*self.attente) / 60
1113 print("..", aux, "mn")
1116 time.sleep(self.attente)
1117 erreur = os.system(commande)
1122 elif os.path.isfile(fic_etat) :
1123 fic = open (fic_etat, "r")
1124 les_lignes = fic.readlines()
1126 if len(les_lignes) > 0 :
1127 if len(les_lignes[0]) > 0 :
1128 laux = les_lignes[0].split()
1129 laux1 = laux[0].split("=")
1131 laux1 = laux[1].split("=")
1133 if self.verbose_max :
1135 if etat in ( "RUN", "PEND" ) :
1138 if etat != "ENDED" :
1139 self.message_info += "Etat du job : " + etat
1142 if diag[:3] in ( "<S>", "<F>" ) :
1145 self.message_info = "Diagnostic du job : " + diag + "\n"
1156 os.remove(fic_etat_2)
1158 if self.verbose_max :
1160 print(". erreur :", erreur)
1163 message_erreur = "Erreur dans le calcul"
1165 return erreur, message_erreur
1167 #========================= Fin de la fonction ===================================
1169 #========================= Debut de la fonction ==================================
1171 def post_aster ( self, dico_resu_init ) :
1174 Affichage de resultats selon les cas
1177 messages_erreur = { 0 : None,
1178 1 : "Ce fichier est inconnu." }
1180 nom_fonction = __name__ + "/post_aster"
1181 blabla = "\nDans " + nom_fonction + ","
1184 message_erreur = " "
1187 dico_resu.update(dico_resu_init)
1191 # 1. Exploration du fichier resu
1193 # 1.1. Recuperation du contenu
1195 nomfic = self.dico["resu"]
1198 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1204 if ( erreur == 0 ) :
1205 self.message_info += info[:-1]
1206 info = info.replace(chaine, " ")
1207 laux = info[:-1].split()
1210 aux = aux.replace("D", "E")
1211 dico_resu[chaine] = float(aux)
1214 message_erreur = " "
1216 # 2. Exploration du fichier mess
1217 # 2.1. Que chercher ?
1219 for chaine in ( "INSTANT", "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1221 # 2.2. Recuperation du contenu
1223 nomfic = self.dico["mess"]
1224 if chaine == "INSTANT" :
1228 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1234 if ( erreur == 0 ) :
1235 self.message_info += info[:-1]
1236 if chaine == "INSTANT" :
1237 l_aux = info[:-1].split()
1239 for iaux in range(lg_aux) :
1240 if ( "ORDRE" in l_aux[iaux] ) :
1241 if l_aux[iaux+1] == ":" :
1245 ordre = int(l_aux[jaux])
1246 dico_resu["ORDRE"] = ordre
1247 dico_resu["PAS_DE_TEMPS"] = ordre
1248 elif chaine in ( "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1249 l_aux = info[:-1].split(chaine)
1250 dico_resu[chaine] = int(l_aux[1])
1253 message_erreur = " "
1258 # 3. Fichier de resultats au format med
1260 dico_resu["FileName"] = self.dico["rmed"]
1266 print(". erreur :", erreur)
1267 print(". dico_resu :", dico_resu)
1270 message_erreur = messages_erreur[erreur]
1272 return erreur, message_erreur, dico_resu
1274 #========================= Fin de la fonction ===================================
1276 #========================= Debut de la fonction ==================================
1278 def post_aster_1 ( self, nomfic, chaine, nuocc ) :
1282 nomfic = nom du fichier a decoder
1283 chaine = chaine a chercher
1284 nuocc = numero de l'occurence a chercher, 0 si toutes
1286 codret = 0 : tout va bien
1287 1 : le fichier de resultats est absent
1288 -1 : la chaine est absente
1289 message_erreur = "" : tout va bien
1291 info = la ou les lignes recherchees
1294 messages_erreur = { 0 : None,
1295 -1 : "La chaine est absente.",
1296 1 : "Ce fichier est inconnu." }
1298 nom_fonction = __name__ + "/post_aster_1"
1299 blabla = "\nDans " + nom_fonction + " :"
1300 if self.verbose_max :
1301 print(blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc)
1305 message_erreur = " "
1310 # 1. Lecture du fichier
1312 if not os.path.isfile(nomfic) :
1313 self.message_info += "\nFichier "+nomfic+"\n"
1316 fic = open (nomfic, "r")
1317 les_lignes = fic.readlines()
1320 # 2. Exploration des lignes
1321 # 2.1. On recupere tout
1325 for ligne in les_lignes :
1333 for ligne in les_lignes :
1334 if chaine in ligne :
1336 if ( ( nuocc == 0 ) or ( iaux == nuocc ) ) :
1339 self.message_info += "\n"
1347 if ( self.verbose_max or ( erreur>0 ) ) :
1348 print(blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc)
1349 print(". erreur =", erreur)
1352 message_erreur = messages_erreur[erreur]
1354 return erreur, message_erreur, info
1356 #========================= Fin de la fonction ===================================
1358 #========================= Debut de la fonction ==================================
1360 def dump_resultat ( self ) :
1363 Dump du resultat du calcul
1366 messages_erreur = { 0 : None }
1368 nom_fonction = __name__ + "/dump_resultat"
1369 blabla = "\nDans " + nom_fonction + ","
1372 message_erreur = " "
1376 nomfic_donn = os.path.join(self.rep_calc, "donn")
1377 fic = open (nomfic_donn, "w")
1378 fic.write("1\n1\n1\n")
1380 fic_dump = self.dico["rmed"]+".dump"
1381 commande = "mdump " + self.dico["rmed"] + "<" + nomfic_donn + ">" + fic_dump
1383 erreur = os.system(commande)
1385 messages_erreur[erreur] = "Erreur de dump numero %d" % erreur
1387 self.message_info += "\nDump dans le fichier :\n"
1388 self.message_info += fic_dump+"\n"
1390 if self.verbose_max :
1392 print(". erreur :", erreur)
1394 os.remove(nomfic_donn)
1397 message_erreur = messages_erreur[erreur]
1399 return erreur, message_erreur
1401 #========================= Fin de la fonction ===================================
1404 if __name__ == "__main__" :
1406 #print "Arguments a l'entree de", sys.argv[0], ":", sys.argv[1:], "\n"
1408 Script_A = Script(sys.argv[1:])
1410 if Script_A.affiche_aide_globale :
1411 Script_A.message_info = Script_A.__doc__
1413 message_erreur_m = ""
1416 erreur_m, message_erreur_m, dico_resu_m = Script_A.compute ()
1418 sys.stdout.write(Script_A.message_info+"\n")
1419 sys.stderr.write(message_erreur_m+"\n")