2 # -*- coding: iso-8859-1 -*-
4 Lancement d'un calcul ASTER
13 # ==== Debut de personnalisation ====
15 # opt1_defaut, opt2_defaut : les valeurs par defaut de ces options, selon les cas
18 # liste_cas_tr : liste des cas transitoires
22 opt1_defaut["couche"] = str(nro_couche)
24 opt2_defaut["couche"] = str(nro_adap)
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"
30 liste_cas_tr.append("ssnp142d")
31 opt1_defaut["ssnp142d"] = "0.0"
32 opt2_defaut["ssnp142d"] = "4.0"
34 liste_cas_tr.append("Riete")
35 opt1_defaut["Riete"] = "0.0"
36 opt2_defaut["Riete"] = "8.0"
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 --num=nro --mesh_file=mesh_file [-dump] [-h|-help] [-v] [-v_max] options
52 Arguments obligatoires :
53 --rep_calc=rep_calc : le repertoire du calcul.
54 --num=nro : le numero du calcul, depuis 0.
55 --mesh_file=mesh_file : le fichier contenant le maillage sur lequel on veut calculer. Le nom est absolu ou relatif par rapport au repertoire de calcul.
57 Options supplementaires, selon les cas :
58 . Pour un cas transitoire :
59 Les numeros des instants varient de 0 a N. On fournit le numero ou l'instant ; le jeu de commandes fait le tri entre les deux options.
60 --opt1=inst_deb : le numero ou l'instant initial ; si absent, on prend 0.
61 --opt2=inst_fin : le numero ou l'instant final ; si absent, on va jusqu'au bout du transitoire.
63 --opt1=nro_couche : le numero de la couche ; si absent, on prend 1.
64 --opt2=nro_adap : le nombre d'adaptations deja realisees pour la couche ; si absent, on prend 0.
65 . Pour les autres cas :
66 Aucune option supplementaire.
68 Arguments optionnels :
70 --wait=wait : temps d'attente en secondes entre deux examens de l'etat d'un calcul batch ; si absent, on prend 10.
72 -dump : produit le fichier dump du fichier med de resultats ; par defaut, pas de dump.
74 -h|-help : produit l'aide, quels que soient les autres arguments
75 -v : mode verbeux simple
76 -v_max : mode verbeux intensif
79 ./ScriptAster.py --rep_calc=`pwd` --num=0 --mesh_file=maill.00.med -dump
80 ./ScriptAster.py --rep_calc=/scratch/D68518/HOMARD_SVN/trunk/training/tet_aster_ther --num=2 --mesh_file=/scratch/D68518/Salome/Adapt/resu/maill.02.med
86 # 0.1. ==> Les constantes de la machine
88 info_gene = os.uname()
91 machine = info_gene[1]
97 if os.environ.has_key("LOGNAME") :
98 user = os.environ ["LOGNAME"]
104 # 0.3. ==> Le lancement d'Aster
110 # Attente en secondes entre deux controles du job
113 # 0.4. ==> Information
115 affiche_aide_globale = 0
123 #========================= Debut de la fonction ==================================
125 def __init__ ( self, liste_arg ) :
128 Le constructeur de la classe Script
131 # 1. Decodage des arguments
135 self.mesh_file = None
140 for argu in liste_arg :
143 l_aux = argu.split("=")
148 if l_aux[0] == "--rep_calc" :
149 self.rep_calc = l_aux[1]
150 elif l_aux[0] == "--num" :
151 self.numero = int(l_aux[1])
152 elif l_aux[0] == "--mesh_file" :
153 self.mesh_file = l_aux[1]
154 elif l_aux[0] == "--opt1" :
156 elif l_aux[0] == "--opt2" :
158 elif l_aux[0] == "--wait" :
159 self.attente = l_aux[1]
160 elif l_aux[0] == "--version" :
161 self.version = l_aux[1]
164 if saux in ( "-H", "-HELP" ) :
165 self.affiche_aide_globale = 1
168 elif saux in ( "-V_MAX", "-VMAX" ) :
171 elif saux == "-DUMP" :
174 # 2. Les paramètres de base
177 self.nomfic_export = None
180 if self.verbose_max :
181 nom_fonction = __name__ + "/__init__"
182 print "\nDans " + nom_fonction + ","
183 print ". rep_calc :", self.rep_calc
184 print ". numero :", self.numero
185 print ". mesh_file :", self.mesh_file
186 print ". opt1 :", self.opt1
187 print ". opt2 :", self.opt2
188 print ". attente :", self.attente
190 #========================= Fin de la fonction ===================================
192 #========================= Debut de la fonction ==================================
194 def compute ( self ) :
197 Lancement d'un calcul
200 nom_fonction = __name__ + "/compute"
201 blabla = "\nDans " + nom_fonction + ","
210 # 1. Preparation du calcul
212 #print "\n==== self.prepa_calcul () ===="
213 erreur, message_erreur = self.prepa_calcul ()
219 #print "\n==== self.calcul () ===="
220 erreur, message_erreur, fic_caract, fic_caract_2 = self.calcul ()
221 #print "erreur en sortie de self.calcul :", erreur
227 #print "\n==== calcul_aster_attente.calcul (",fic_caract,") ===="
228 erreur, message_erreur = self.calcul_aster_attente (fic_caract)
231 os.remove(fic_caract)
232 os.remove(fic_caract_2)
234 # 4. Gestion du resultat
236 #print "\n==== self.post_aster (dico_resu) ===="
237 erreur, message_erreur, dico_resu = self.post_aster (dico_resu)
244 #print "\n==== self.dump_resultat() ===="
245 erreur, message_erreur = self.dump_resultat ()
251 if self.verbose_max :
253 print ". erreur :", erreur
255 return erreur, message_erreur, dico_resu
257 #========================= Fin de la fonction ===================================
259 #========================= Debut de la fonction ==================================
261 def prepa_calcul ( self ) :
264 Preparation d'un calcul
267 messages_erreur = { 0 : None }
269 nom_fonction = __name__ + "/prepa_calcul"
270 blabla = "\nDans " + nom_fonction + ","
275 if self.verbose_max :
277 print ". numero :", self.numero
278 print ". mesh_file :", self.mesh_file
279 print ". rep_calc :", self.rep_calc
283 # 1. Controles des arguments
285 erreur, message_erreur = self.controle_argument()
289 # 2. Modification du fichier export
291 erreur, message_erreur = self.modif_export()
295 # 3. Modifications du fichier de commandes
296 # 3.1. Pour un cas transitoire
298 if self.nomcas in liste_cas_tr :
299 erreur, message_erreur = self.modif_cas_transitoire()
303 # 3.2. Pour l'excavation
305 elif self.nomcas[:6] == "couche" :
306 erreur, message_erreur = self.modif_cas_excavation()
312 if self.verbose_max :
313 print blabla, "a la fin"
314 print ". erreur :", erreur
316 return erreur, message_erreur
318 #========================= Fin de la fonction ===================================
320 #========================= Debut de la fonction ==================================
322 def controle_argument ( self ) :
325 Controle les arguments et stockage de quelques informations
328 messages_erreur = { 0 : None,
329 -1 : "Quel repertoire de calcul ?",
330 -2 : "Quel fichier de maillage ?",
331 -3 : "Ce repertoire est inconnu.",
332 -4 : "Ce fichier est inconnu.",
333 -5 : "Quel temps d'attente ?",
334 -6 : "Quel numero de calcul ?",
335 -7 : "Numeros de pas de temps invalides.",
336 -8 : "Numero de couche invalide.",
337 -9 : "Numero d'adaptation invalide." }
339 nom_fonction = __name__ + "/controle_argument"
340 blabla = "\nDans " + nom_fonction + ","
345 if self.verbose_max :
347 print ". rep_calc :", self.rep_calc
348 print ". mesh_file :", self.mesh_file
349 print ". numero :", self.numero
350 print ". attente :", self.attente
351 print ". opt1 :", self.opt1
352 print ". opt2 :", self.opt2
356 # 1. Les repertoire et fichier
358 if self.rep_calc == None :
360 elif self.mesh_file == None :
363 self.message_info += "Relancer avec -h pour avoir le mode d'emploi."
366 if os.environ.has_key("HOME") :
367 HOME = os.environ ["HOME"]
369 HOME = "/local/home/salome"
371 if ( self.rep_calc[:1] == "~" ) :
372 self.rep_calc = os.path.join(HOME, self.rep_calc[2:])
373 if not os.path.isdir(self.rep_calc) :
374 self.message_info += "Repertoire " + self.rep_calc
378 aux = os.path.join(os.getcwd(),self.rep_calc)
379 self.rep_calc = os.path.normpath(aux)
381 if ( self.mesh_file[:1] == "~" ) :
382 self.mesh_file = os.path.join(HOME, self.mesh_file[2:])
383 if not os.path.isfile(self.mesh_file) :
384 aux = os.path.join(self.rep_calc, self.mesh_file)
385 if not os.path.isfile(aux) :
386 self.message_info += "Fichier " + self.mesh_file
390 self.mesh_file = os.path.normpath(aux)
391 aux = os.path.join(os.getcwd(),self.mesh_file)
392 self.mesh_file = os.path.normpath(aux)
394 # 2. On en deduit le cas
396 self.nomcas = os.path.basename(self.rep_calc)
397 if self.verbose_max :
398 print ". Cas :", self.nomcas
400 # 3. Le temps d'attente
404 iaux = int(self.attente)
410 # 4. Le numero du calcul
412 if self.numero == None :
415 # 5. Options speciales pour les cas transitoires et pour l'excavation
417 if ( self.nomcas in liste_cas_tr ) or ( self.nomcas[:6] == "couche" ) :
419 if self.opt1 == None :
420 self.opt1 = opt1_defaut[self.nomcas]
422 if self.opt2 == None :
423 self.opt2 = opt2_defaut[self.nomcas]
425 # 5.1. Pour un cas transitoire
427 if self.nomcas in liste_cas_tr :
432 iaux1 = int(self.opt1)
434 daux1 = float(self.opt1)
439 iaux2 = int(self.opt2)
441 daux2 = float(self.opt2)
443 if ( ( daux1 == None ) and ( daux2 == None ) ) :
444 #print "iaux1, iaux2 =", iaux1, iaux2
447 elif ( ( iaux1 == None ) and ( iaux2 == None ) ) :
448 #print "daux1, daux2 =", daux1, daux2
455 self.message_info += "opt1 = " + self.opt1
456 self.message_info += "\nopt2 = " + self.opt2
458 # 5.2. Pour l'excavation
460 elif self.nomcas[:6] == "couche" :
464 iaux1 = int(self.opt1)
468 if ( ( iaux1 < 1 ) or ( iaux1 > 20 ) ) :
469 #print "iaux1 =", iaux1
474 iaux2 = int(self.opt2)
479 #print "iaux1 =", iaux1
483 self.message_info += "nro_mail = " + self.numero
484 self.message_info += "\nopt1 = " + self.opt1
485 self.message_info += "\nopt2 = " + self.opt2
488 self.nro_couche = iaux1
489 self.nro_adap = iaux2
494 message_erreur = messages_erreur[erreur]
496 if self.verbose_max :
497 print ". rep_calc :", self.rep_calc
498 print ". mesh_file :", self.mesh_file
500 return erreur, message_erreur
502 #========================= Fin de la fonction ===================================
504 #========================= Debut de la fonction ==================================
506 def modif_export ( self ) :
509 Modification du fichier export et reperage de quelques informations
512 messages_erreur = { 0 : None }
514 nom_fonction = __name__ + "/modif_export"
515 blabla = "\nDans " + nom_fonction + ","
520 if self.verbose_max :
522 print ". numero :", self.numero
523 print ". mesh_file :", self.mesh_file
527 # 1. Lecture du fichier export original
529 nomfic_export = os.path.join(self.rep_calc, "calcul.ref.export")
530 fic = open (nomfic_export, "r")
531 les_lignes = fic.readlines()
534 # 2. Ouverture du nouveau fichier export
537 if self.nomcas[:6] == "couche" :
538 nomfic += ".%02d" % self.nro_couche
539 nomfic += ".%03d.export" % self.numero
540 self.nomfic_export = os.path.join(self.rep_calc, nomfic)
541 fic = open (self.nomfic_export, "w")
543 # 3. Exploration des lignes
545 for ligne in les_lignes :
547 # 3.1. Pas de modification, a priori
552 # 3.2. Decodage des composants de la ligne pour un fichier
554 if ligne[0:2] == "F " :
562 if ( ":" in nomfic_0 ) :
563 laux1 = nomfic_0.split(":")
564 saux = laux1[0] + ":"
567 # 3.2.1. Si c'est le fichier de commandes, mise a jour du nom du repertoire
569 if typfic == "comm" :
571 nomfic_l_0 = os.path.basename(nomfic_0)
572 nomfic = os.path.join(self.rep_calc, nomfic_l_0)
574 # 3.2.2. Si ce n'est pas le fichier de commandes, mise a jour du nom
578 # 3.2.2.1. Le fichier de maillage est celui passe en argument
580 if typfic == "mmed" :
581 nomfic = self.mesh_file
583 # 3.2.2.2. Pour les autres fichiers, on recupère le nom initial
586 nomfic_l_0 = os.path.basename(nomfic_0)
587 laux1 = nomfic_l_0.split(".")
589 # 3.2.2.2.1. Base des noms de fichiers si excavation
591 if laux1[0] == "couche_n" :
592 saux0 = "couche_%02d" % self.nro_couche
596 # 3.2.2.2.2. Indicage des fichiers
601 saux1 = "%02d" % self.numero
603 saux1 = "%03d" % self.numero
605 saux1 = "%04d" % self.numero
607 saux1 = "%d" % self.numero
608 nomfic_l = saux0 + "." + saux1 + "." + laux1[2]
610 nomfic_l = saux0 + "." + laux1[1]
612 nomfic_l_1 = os.path.dirname(nomfic_0)
613 nomfic = os.path.join(nomfic_l_1, nomfic_l)
615 ligne_bis = laux[0] + " " + laux[1] + " " + saux
616 ligne_bis += nomfic + " "
617 ligne_bis += laux[3] + " " + laux[4] + "\n"
619 # 3.2.2.3. On detruit preventivement les fichiers des resultats
621 if self.nomcas[:6] != "couche" :
623 if os.path.isfile(nomfic) :
626 # 3.2.3. Memorisation des noms
628 self.dico[typfic] = nomfic
630 # 3.3. Decodage des composants de la ligne pour la base
632 elif ligne[0:2] == "R " :
639 # 3.3.1. Si c'est le fichier de la base, on recupere le nom initial, en ajustant l'indice
641 if typfic in ( "base", "bhdf" ) :
644 if ( ":" in nomfic_0 ) :
645 laux1 = nomfic_0.split(":")
646 saux = laux1[0] + ":"
648 nomfic_l_0 = os.path.basename(nomfic_0)
649 laux1 = nomfic_l_0.split(".")
653 saux1 = "%02d" % self.numero
655 saux1 = "%03d" % self.numero
657 saux1 = "%04d" % self.numero
659 saux1 = "%d" % self.numero
660 nomfic_l = laux1[0] + "." + saux1 + "." + laux1[2]
661 elif len(laux1) >= 2 :
662 if laux1[0] == "couche_nm1" :
663 saux0 = "couche_%02d" % (self.nro_couche-1)
664 elif laux1[0] == "couche_n" :
665 saux0 = "couche_%02d" % self.nro_couche
668 nomfic_l = saux0 + "." + laux1[1]
670 nomfic_l = nomfic_l_0
671 nomfic_l_1 = os.path.dirname(nomfic_0)
672 nomfic = os.path.join(nomfic_l_1, nomfic_l)
674 ligne_bis = laux[0] + " " + laux[1] + " " + saux
675 ligne_bis += nomfic + " "
676 ligne_bis += laux[3] + " " + laux[4] + "\n"
678 # 3.4. Decodage des composants de la ligne pour un parametre
680 elif ligne[0:2] == "P " :
684 if ( len(laux) == 3 ) :
686 if laux[1] in ( "username" ) :
688 elif laux[1] in ( "uclient" ) :
690 elif laux[1] in ( "aster_root" ) :
691 self.aster_root = aux
692 elif laux[1] in ( "serveur" ) :
694 elif laux[1] in ( "mclient" ) :
696 #elif laux[1] in ( "display" ) :
697 #aux = self.machine+":0.0"
698 elif laux[1] in ( "nomjob" ) :
700 elif laux[1] in ( "mode" ) :
702 ligne_bis = laux[0] + " " + laux[1] + " " + aux + "\n"
704 # 3.5. Ecriture de la ligne
713 message_erreur = messages_erreur[erreur]
715 if self.verbose_max :
716 print ". mclient ", self.mclient
717 print ". uclient ", self.uclient
718 print ". serveur ", self.serveur
719 print ". username ", self.username
720 print ". aster_root ", self.aster_root
721 print ". nomjob ", self.nomjob
722 print ". mode ", self.mode
724 return erreur, message_erreur
726 #========================= Fin de la fonction ===================================
728 #========================= Debut de la fonction ==================================
730 def modif_cas_transitoire ( self ) :
733 Modification du fichier de commandes lie au cas transitoire
736 messages_erreur = { 0 : None,
737 2 : "Mot_cle inconnu dans les commandes." }
739 nom_fonction = __name__ + "/modif_cas_transitoire"
740 blabla = "\nDans " + nom_fonction + ","
745 if self.verbose_max :
747 print ". opt1 :", self.opt1
748 print ". opt2 :", self.opt2
752 # 1. Lecture du fichier de commandes
754 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
755 fic = open (nomfic, "r")
756 les_lignes = fic.readlines()
759 # 2. Ouverture du nouveau fichier de commandes
761 fic = open (nomfic, "w")
763 # 3. Exploration des lignes
765 # 3.0. Reperage de la zone a modifier
769 for ligne in les_lignes :
771 if self.verbose_max :
772 print "ligne =", ligne[:-1]
774 # 3.1. Pas de modification, a priori
778 # 3.2. Reperage de la zone a modifier
780 if ( "A PERSONNALISER - DEBUT" in ligne ) :
782 elif ( "A PERSONNALISER - FIN" in ligne ) :
787 #print "A_modifier =", A_modifier
790 #print "ligne =", ligne[:-1]
791 for iaux in range(2) :
793 mot_cle_ref = "NUME_INST_"
796 mot_cle_ref = "INST_"
798 #print "mot_cle_ref =", mot_cle_ref
800 if ligne[0:lg_mot_cle] == mot_cle_ref :
802 if ligne[lg_mot_cle:lg_mot_cle+4] == "INIT" :
804 motcle = ligne[0:lg_mot_cle+4]
805 elif ligne[lg_mot_cle:lg_mot_cle+3] == "FIN" :
807 motcle = ligne[0:lg_mot_cle+3]
809 self.message_info += ligne
813 ligne_bis = motcle + " = " + str(aux) +"\n"
818 # 3.4. Ecriture de la ligne
826 # 4. Gestion des erreurs
829 message_erreur = messages_erreur[erreur]
831 return erreur, message_erreur
833 #========================= Fin de la fonction ===================================
835 #========================= Debut de la fonction ==================================
837 def modif_cas_excavation ( self ) :
840 Modification du fichier de commandes lie au cas de l'excavation
843 messages_erreur = { 0 : None }
845 nom_fonction = __name__ + "/modif_cas_excavation"
846 blabla = "\nDans " + nom_fonction + ","
851 if self.verbose_max :
853 print ". numero :", self.numero
854 print ". nro_couche :", self.nro_couche
855 print ". nro_adap :", self.nro_adap
859 # 1. Lecture du fichier de commandes
861 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
862 fic = open (nomfic, "r")
863 les_lignes = fic.readlines()
866 # 2. Ouverture du nouveau fichier de commandes
868 fic = open (nomfic, "w")
870 # 3. Exploration des lignes
872 # 3.0. Reperage de la zone a modifier
876 for ligne in les_lignes :
878 if self.verbose_max :
879 print "ligne =", ligne[:-1]
881 # 3.1. Pas de modification, a priori
885 # 3.2. Reperage de la zone a modifier
887 if ( "A PERSONNALISER - DEBUT" in ligne ) :
889 elif ( "A PERSONNALISER - FIN" in ligne ) :
894 #print "A_modifier =", A_modifier
897 #print "ligne =", ligne[:-1]
898 for iaux in range(3) :
900 mot_cle_ref = "nro_mail"
904 mot_cle_ref = "nro_couche"
906 aux = self.nro_couche
908 mot_cle_ref = "nro_adap"
911 #print "mot_cle_ref =", mot_cle_ref
913 if ligne[0:lg_mot_cle] == mot_cle_ref :
914 #print "==> aux =", aux, type(aux)
915 ligne_bis = mot_cle_ref + " = " + str(aux) +"\n"
917 # 3.4. Ecriture de la ligne
925 # 4. Gestion des erreurs
928 message_erreur = messages_erreur[erreur]
930 return erreur, message_erreur
932 #========================= Fin de la fonction ===================================
934 #========================= Debut de la fonction ==================================
936 def calcul ( self ) :
939 Lancement d'un calcul
942 messages_erreur = { 0 : None }
944 nom_fonction = __name__ + "/calcul"
945 blabla = "\nDans " + nom_fonction + ","
950 if self.verbose_max :
951 print ". mclient ", self.mclient
952 print ". serveur ", self.serveur
954 # 1. Copie du fichier export sur le serveur de calcul
956 if ( self.mclient != self.serveur ) :
958 nomfic_export_dist = self.nomjob + ".export"
959 commande = "scp " + self.nomfic_export + " " + self.username + "@" + self.serveur + ":" + nomfic_export_dist
960 if self.verbose_max :
961 print "Copie du fichier export vers", self.serveur, ":"
963 erreur = os.system(commande)
965 # 2. Commande du lancement
967 commande_base = os.path.join(self.aster_root, "bin", "as_run")
969 if self.mode == "batch" :
970 commande_base += "--serv "
971 commande_base += self.username + "@" + self.serveur + ":"
972 #if self.verbose_max :
975 fic_caract = tempfile.mktemp()
976 fic_caract_2 = tempfile.mktemp()
979 # 3.1. Commande finale
981 if ( self.mclient == self.serveur ) :
982 commande = commande_base
983 commande += commande_base + self.nomfic_export
985 commande = "ssh " + self.username + "@" + self.serveur
986 commande += " \"" + commande_base + nomfic_export_dist + "\""
987 commande += " 1>" + fic_caract
988 commande += " 2>" + fic_caract_2
989 if self.verbose_max :
990 print "Lancement sur", self.serveur, ":"
993 # 3.2. Lancement vrai
995 erreur = os.system(commande)
997 messages_erreur[erreur] = "erreur de calcul numero %d" % erreur
999 self.message_info += "resultat dans le fichier :\n"
1001 self.message_info += self.dico["rmed"]+"\n"
1003 if self.verbose_max :
1005 print ". erreur :", erreur
1006 print ". self.mode :", self.mode
1007 print ". fic_caract :", fic_caract
1010 message_erreur = messages_erreur[erreur]
1012 return erreur, message_erreur, fic_caract, fic_caract_2
1014 #========================= Fin de la fonction ===================================
1016 #========================= Debut de la fonction ==================================
1018 def calcul_aster_attente ( self, fic_caract ) :
1021 Bilan du calcul Aster
1022 fic_caract : fichier caracteristique du job
1025 nom_fonction = __name__ + "/calcul_aster_attente"
1026 blabla = "\nDans " + nom_fonction + ","
1029 message_erreur = " "
1031 if self.verbose_max :
1032 print ". fic_caract :", fic_caract
1033 print ". nomjob :", self.nomjob
1034 print ". rep_calc :", self.rep_calc
1035 print ". mode :", self.mode
1036 print ". attente :", self.attente
1038 if ( self.mode != "interactif" ) :
1040 # 1. Recuperation du numero de job
1042 fic = open (fic_caract, "r")
1043 les_lignes = fic.readlines()
1046 for ligne in les_lignes :
1048 if ( len(ligne)>0 ) :
1050 if "JOBID" in ligne :
1052 laux = ligne.split()
1053 laux1 = laux[0].split("=")
1056 elif "num_job" in ligne :
1058 laux = ligne.split("num_job")
1059 laux1 = laux[1].split()
1063 print ". numjob :", numjob
1065 # 2. Commande de l'examen de l'etat du job,
1067 fic_etat = os.path.join(self.rep_calc, self.nomjob+".etat")
1068 fic_etat_2 = tempfile.mktemp()
1069 commande_base = os.path.join(self.aster_root, "bin", "as_run")
1070 commande_base += " --actu " + numjob + " " + self.nomjob + " " + self.mode
1071 if self.verbose_max :
1072 print "commande_base =", commande_base
1073 if ( self.mclient == self.serveur ) :
1074 commande = commande_base
1076 commande = "ssh " + self.username + "@" + self.serveur
1077 commande += " \"" + commande_base + "\""
1078 commande += " 1>" + fic_etat
1079 commande += " 2>" + fic_etat_2
1080 if self.verbose_max :
1081 print "Examen sur", self.serveur, ":"
1084 # 3. Examen de l'etat du job, jusqu'a la fin
1089 if encore % 4 == 0 :
1090 aux = ((encore-1)*self.attente) / 60
1091 print "..", aux, "mn"
1094 time.sleep(self.attente)
1095 erreur = os.system(commande)
1100 elif os.path.isfile(fic_etat) :
1101 fic = open (fic_etat, "r")
1102 les_lignes = fic.readlines()
1104 if len(les_lignes) > 0 :
1105 if len(les_lignes[0]) > 0 :
1106 laux = les_lignes[0].split()
1107 laux1 = laux[0].split("=")
1109 laux1 = laux[1].split("=")
1111 if self.verbose_max :
1113 if etat in ( "RUN", "PEND" ) :
1116 if etat != "ENDED" :
1117 self.message_info += "Etat du job : " + etat
1120 if diag[:3] in ( "<S>", "<F>" ) :
1123 self.message_info = "Diagnostic du job : " + diag + "\n"
1134 os.remove(fic_etat_2)
1136 if self.verbose_max :
1138 print ". erreur :", erreur
1141 message_erreur = "Erreur dans le calcul"
1143 return erreur, message_erreur
1145 #========================= Fin de la fonction ===================================
1147 #========================= Debut de la fonction ==================================
1149 def post_aster ( self, dico_resu_init ) :
1152 Affichage de resultats selon les cas
1155 messages_erreur = { 0 : None,
1156 1 : "Ce fichier est inconnu." }
1158 nom_fonction = __name__ + "/post_aster"
1159 blabla = "\nDans " + nom_fonction + ","
1162 message_erreur = " "
1165 for cle in dico_resu_init.keys() :
1166 dico_resu[cle] = dico_resu_init[cle]
1170 # 1. Exploration du fichier resu
1172 # 1.1. Recuperation du contenu
1174 nomfic = self.dico["resu"]
1177 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1183 if ( erreur == 0 ) :
1184 self.message_info += info[:-1]
1185 info = info.replace(chaine, " ")
1186 laux = info[:-1].split()
1189 aux = aux.replace("D", "E")
1190 dico_resu[chaine] = float(aux)
1193 message_erreur = " "
1195 # 2. Exploration du fichier mess
1196 # 2.1. Que chercher ?
1198 for chaine in ( "INSTANT", "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1200 # 2.2. Recuperation du contenu
1202 nomfic = self.dico["mess"]
1203 if chaine == "INSTANT" :
1207 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1213 if ( erreur == 0 ) :
1214 self.message_info += info[:-1]
1215 if chaine == "INSTANT" :
1216 l_aux = info[:-1].split()
1218 for iaux in range(lg_aux) :
1219 if ( "ORDRE" in l_aux[iaux] ) :
1220 if l_aux[iaux+1] == ":" :
1224 ordre = int(l_aux[jaux])
1225 dico_resu["ORDRE"] = ordre
1226 dico_resu["PAS_DE_TEMPS"] = ordre
1227 elif chaine in ( "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1228 l_aux = info[:-1].split(chaine)
1229 dico_resu[chaine] = int(l_aux[1])
1232 message_erreur = " "
1237 # 3. Fichier de resultats au format med
1239 dico_resu["FileName"] = self.dico["rmed"]
1245 print ". erreur :", erreur
1246 print ". dico_resu :", dico_resu
1249 message_erreur = messages_erreur[erreur]
1251 return erreur, message_erreur, dico_resu
1253 #========================= Fin de la fonction ===================================
1255 #========================= Debut de la fonction ==================================
1257 def post_aster_1 ( self, nomfic, chaine, nuocc ) :
1261 nomfic = nom du fichier a decoder
1262 chaine = chaine a chercher
1263 nuocc = numero de l'occurence a chercher, 0 si toutes
1265 codret = 0 : tout va bien
1266 1 : le fichier de resultats est absent
1267 -1 : la chaine est absente
1268 message_erreur = "" : tout va bien
1270 info = la ou les lignes recherchees
1273 messages_erreur = { 0 : None,
1274 -1 : "La chaine est absente.",
1275 1 : "Ce fichier est inconnu." }
1277 nom_fonction = __name__ + "/post_aster_1"
1278 blabla = "\nDans " + nom_fonction + " :"
1279 if self.verbose_max :
1280 print blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc
1284 message_erreur = " "
1289 # 1. Lecture du fichier
1291 if not os.path.isfile(nomfic) :
1292 self.message_info += "\nFichier "+nomfic+"\n"
1295 fic = open (nomfic, "r")
1296 les_lignes = fic.readlines()
1299 # 2. Exploration des lignes
1300 # 2.1. On recupere tout
1304 for ligne in les_lignes :
1312 for ligne in les_lignes :
1313 if chaine in ligne :
1315 if ( ( nuocc == 0 ) or ( iaux == nuocc ) ) :
1318 self.message_info += "\n"
1326 if ( self.verbose_max or ( erreur>0 ) ) :
1327 print blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc
1328 print ". erreur =", erreur
1331 message_erreur = messages_erreur[erreur]
1333 return erreur, message_erreur, info
1335 #========================= Fin de la fonction ===================================
1337 #========================= Debut de la fonction ==================================
1339 def dump_resultat ( self ) :
1342 Dump du resultat du calcul
1345 messages_erreur = { 0 : None }
1347 nom_fonction = __name__ + "/dump_resultat"
1348 blabla = "\nDans " + nom_fonction + ","
1351 message_erreur = " "
1355 nomfic_donn = os.path.join(self.rep_calc, "donn")
1356 fic = open (nomfic_donn, "w")
1357 fic.write("1\n1\n1\n")
1359 fic_dump = self.dico["rmed"]+".dump"
1360 commande = "mdump " + self.dico["rmed"] + "<" + nomfic_donn + ">" + fic_dump
1362 erreur = os.system(commande)
1364 messages_erreur[erreur] = "Erreur de dump numero %d" % erreur
1366 self.message_info += "\nDump dans le fichier :\n"
1367 self.message_info += fic_dump+"\n"
1369 if self.verbose_max :
1371 print ". erreur :", erreur
1373 os.remove(nomfic_donn)
1376 message_erreur = messages_erreur[erreur]
1378 return erreur, message_erreur
1380 #========================= Fin de la fonction ===================================
1383 if __name__ == "__main__" :
1385 #print "Arguments a l'entree de", sys.argv[0], ":", sys.argv[1:], "\n"
1387 Script_A = Script(sys.argv[1:])
1389 if Script_A.affiche_aide_globale :
1390 Script_A.message_info = Script_A.__doc__
1392 message_erreur_m = ""
1395 erreur_m, message_erreur_m, dico_resu_m = Script_A.compute ()
1397 sys.stdout.write(Script_A.message_info+"\n")
1398 sys.stderr.write(message_erreur_m+"\n")