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. Le mode de lancement est le suivant :
48 ScriptAster --rep_calc=rep_calc --num=nro --mesh_file=mesh_file [-dump] [-h|-help] [-v] [-v_max] options
50 Arguments obligatoires :
51 --rep_calc=rep_calc : le repertoire du calcul.
52 --num=nro : le numero du calcul, depuis 0.
53 --mesh_file=mesh_file : le fichier contenant le maillage sur lequel on veut calculer.
55 Options supplementaires, selon les cas :
56 . Pour un cas transitoire :
57 Les numeros des instants varient de 0 a N. On fournit le numero ou l'instant ; le jeu de commandes fait le tri entre les deux options.
58 --opt1=inst_deb : le numero ou l'instant initial ; si absent, on prend 0.
59 --opt2=inst_fin : le numero ou l'instant final ; si absent, on va jusqu'au bout du transitoire.
61 --opt1=nro_couche : le numero de la couche ; si absent, on prend 1.
62 --opt2=nro_adap : le nombre d'adaptations deja realisees pour la couche ; si absent, on prend 0.
63 . Pour les autres cas :
64 Aucune option supplementaire.
66 Arguments optionnels :
68 --wait=attente : temps d'attente en secondes entre deux examens de l'etat d'un calcul batch ; si absent, on prend 10.
70 -dump : produit le fichier dump du fichier med de resultats ; par defaut, pas de dump.
72 -h|-help : produit l'aide, quels que soient les autres arguments
73 -v : mode verbeux simple
74 -v_max : mode verbeux intensif
77 ./ScriptAster.py --rep_calc=`pwd` --num=0 --mesh_file=maill.00.med -dump
78 ./ScriptAster.py --rep_calc=/scratch/D68518/HOMARD_SVN/trunk/training/tet_aster_ther --num=2 --mesh_file=/scratch/D68518/Salome/Adapt/resu/maill.02.med
84 # 0.1. ==> Les constantes de la machine
86 info_gene = os.uname()
89 machine = info_gene[1]
95 if os.environ.has_key("LOGNAME") :
96 user = os.environ ["LOGNAME"]
102 # 0.3. ==> Le lancement d'Aster
108 # Attente en secondes entre deux controles du job
111 # 0.4. ==> Information
113 affiche_aide_globale = 0
121 #========================= Debut de la fonction ==================================
123 def __init__ ( self, liste_arg ) :
126 Le constructeur de la classe Script
129 # 1. Decodage des arguments
133 self.mesh_file = None
138 for argu in liste_arg :
141 l_aux = argu.split("=")
146 if l_aux[0] == "--rep_calc" :
147 self.rep_calc = l_aux[1]
148 elif l_aux[0] == "--num" :
149 self.numero = int(l_aux[1])
150 elif l_aux[0] == "--mesh_file" :
151 self.mesh_file = l_aux[1]
152 elif l_aux[0] == "--opt1" :
154 elif l_aux[0] == "--opt2" :
156 elif l_aux[0] == "--wait" :
157 self.attente = l_aux[1]
158 elif l_aux[0] == "--version" :
159 self.version = l_aux[1]
162 if saux in ( "-H", "-HELP" ) :
163 self.affiche_aide_globale = 1
166 elif saux in ( "-V_MAX", "-VMAX" ) :
169 elif saux == "-DUMP" :
172 # 2. Les paramètres de base
175 self.nomfic_export = None
178 if self.verbose_max :
179 nom_fonction = __name__ + "/__init__"
180 print "\nDans " + nom_fonction + ","
181 print ". rep_calc :", self.rep_calc
182 print ". numero :", self.numero
183 print ". mesh_file :", self.mesh_file
184 print ". opt1 :", self.opt1
185 print ". opt2 :", self.opt2
186 print ". attente :", self.attente
188 #========================= Fin de la fonction ===================================
190 #========================= Debut de la fonction ==================================
192 def compute ( self ) :
195 Lancement d'un calcul
198 nom_fonction = __name__ + "/compute"
199 blabla = "\nDans " + nom_fonction + ","
208 # 1. Preparation du calcul
210 #print "\n==== self.prepa_calcul () ===="
211 erreur, message_erreur = self.prepa_calcul ()
217 #print "\n==== self.calcul () ===="
218 erreur, message_erreur, fic_caract, fic_caract_2 = self.calcul ()
219 #print "erreur en sortie de self.calcul :", erreur
225 #print "\n==== calcul_aster_attente.calcul (",fic_caract,") ===="
226 erreur, message_erreur = self.calcul_aster_attente (fic_caract)
229 os.remove(fic_caract)
230 os.remove(fic_caract_2)
232 # 4. Gestion du resultat
234 #print "\n==== self.post_aster (dico_resu) ===="
235 erreur, message_erreur, dico_resu = self.post_aster (dico_resu)
242 #print "\n==== self.dump_resultat() ===="
243 erreur, message_erreur = self.dump_resultat ()
249 if self.verbose_max :
251 print ". erreur :", erreur
253 return erreur, message_erreur, dico_resu
255 #========================= Fin de la fonction ===================================
257 #========================= Debut de la fonction ==================================
259 def prepa_calcul ( self ) :
262 Preparation d'un calcul
265 messages_erreur = { 0 : None }
267 nom_fonction = __name__ + "/prepa_calcul"
268 blabla = "\nDans " + nom_fonction + ","
273 if self.verbose_max :
275 print ". numero :", self.numero
276 print ". mesh_file :", self.mesh_file
277 print ". rep_calc :", self.rep_calc
281 # 1. Controles des arguments
283 erreur, message_erreur = self.controle_argument()
287 # 2. Modification du fichier export
289 erreur, message_erreur = self.modif_export()
293 # 3. Modifications du fichier de commandes
294 # 3.1. Pour un cas transitoire
296 if self.nomcas in liste_cas_tr :
297 erreur, message_erreur = self.modif_cas_transitoire()
301 # 3.2. Pour l'excavation
303 elif self.nomcas[:6] == "couche" :
304 erreur, message_erreur = self.modif_cas_excavation()
310 if self.verbose_max :
311 print blabla, "a la fin"
312 print ". erreur :", erreur
314 return erreur, message_erreur
316 #========================= Fin de la fonction ===================================
318 #========================= Debut de la fonction ==================================
320 def controle_argument ( self ) :
323 Controle les arguments et stockage de quelques informations
326 messages_erreur = { 0 : None,
327 -1 : "Quel repertoire de calcul ?",
328 -2 : "Quel fichier de maillage ?",
329 -3 : "Ce repertoire est inconnu.",
330 -4 : "Ce fichier est inconnu.",
331 -5 : "Quel temps d'attente ?",
332 -6 : "Quel numero de calcul ?",
333 -7 : "Numeros de pas de temps invalides.",
334 -8 : "Numero de couche invalide.",
335 -9 : "Numero d'adaptation invalide." }
337 nom_fonction = __name__ + "/controle_argument"
338 blabla = "\nDans " + nom_fonction + ","
343 if self.verbose_max :
345 print ". rep_calc :", self.rep_calc
346 print ". mesh_file :", self.mesh_file
347 print ". numero :", self.numero
348 print ". attente :", self.attente
349 print ". opt1 :", self.opt1
350 print ". opt2 :", self.opt2
354 # 1. Les repertoire et fichier
356 if self.rep_calc == None :
358 elif self.mesh_file == None :
361 self.message_info += "Relancer avec -h pour avoir le mode d'emploi."
364 if os.environ.has_key("HOME") :
365 HOME = os.environ ["HOME"]
367 HOME = "/local/home/salome"
369 if ( self.rep_calc[:1] == "~" ) :
370 self.rep_calc = os.path.join(HOME, self.rep_calc[2:])
371 if not os.path.isdir(self.rep_calc) :
372 self.message_info += "Repertoire " + self.rep_calc
376 aux = os.path.join(os.getcwd(),self.rep_calc)
377 self.rep_calc = os.path.normpath(aux)
379 if ( self.mesh_file[:1] == "~" ) :
380 self.mesh_file = os.path.join(HOME, self.mesh_file[2:])
381 if not os.path.isfile(self.mesh_file) :
382 self.message_info += "Fichier " + self.mesh_file
386 aux = os.path.join(os.getcwd(),self.mesh_file)
387 self.mesh_file = os.path.normpath(aux)
389 # 2. On en deduit le cas
391 self.nomcas = os.path.basename(self.rep_calc)
392 if self.verbose_max :
393 print ". Cas :", self.nomcas
395 # 3. Le temps d'attente
399 iaux = int(self.attente)
405 # 4. Le numero du calcul
407 if self.numero == None :
410 # 5. Options speciales pour les cas transitoires et pour l'excavation
412 if ( self.nomcas in liste_cas_tr ) or ( self.nomcas[:6] == "couche" ) :
414 if self.opt1 == None :
415 self.opt1 = opt1_defaut[self.nomcas]
417 if self.opt2 == None :
418 self.opt2 = opt2_defaut[self.nomcas]
420 # 5.1. Pour un cas transitoire
422 if self.nomcas in liste_cas_tr :
427 iaux1 = int(self.opt1)
429 daux1 = float(self.opt1)
434 iaux2 = int(self.opt2)
436 daux2 = float(self.opt2)
438 if ( ( daux1 == None ) and ( daux2 == None ) ) :
439 #print "iaux1, iaux2 =", iaux1, iaux2
442 elif ( ( iaux1 == None ) and ( iaux2 == None ) ) :
443 #print "daux1, daux2 =", daux1, daux2
450 self.message_info += "opt1 = " + self.opt1
451 self.message_info += "\nopt2 = " + self.opt2
453 # 5.2. Pour l'excavation
455 elif self.nomcas[:6] == "couche" :
459 iaux1 = int(self.opt1)
463 if ( ( iaux1 < 1 ) or ( iaux1 > 20 ) ) :
464 #print "iaux1 =", iaux1
469 iaux2 = int(self.opt2)
474 #print "iaux1 =", iaux1
478 self.message_info += "nro_mail = " + self.numero
479 self.message_info += "\nopt1 = " + self.opt1
480 self.message_info += "\nopt2 = " + self.opt2
483 self.nro_couche = iaux1
484 self.nro_adap = iaux2
489 message_erreur = messages_erreur[erreur]
491 if self.verbose_max :
492 print ". rep_calc :", self.rep_calc
493 print ". mesh_file :", self.mesh_file
495 return erreur, message_erreur
497 #========================= Fin de la fonction ===================================
499 #========================= Debut de la fonction ==================================
501 def modif_export ( self ) :
504 Modification du fichier export et reperage de quelques informations
507 messages_erreur = { 0 : None }
509 nom_fonction = __name__ + "/modif_export"
510 blabla = "\nDans " + nom_fonction + ","
515 if self.verbose_max :
517 print ". numero :", self.numero
518 print ". mesh_file :", self.mesh_file
522 # 1. Lecture du fichier export original
524 nomfic_export = os.path.join(self.rep_calc, "calcul.ref.export")
525 fic = open (nomfic_export, "r")
526 les_lignes = fic.readlines()
529 # 2. Ouverture du nouveau fichier export
532 if self.nomcas[:6] == "couche" :
533 nomfic += ".%02d" % self.nro_couche
534 nomfic += ".%03d.export" % self.numero
535 self.nomfic_export = os.path.join(self.rep_calc, nomfic)
536 fic = open (self.nomfic_export, "w")
538 # 3. Exploration des lignes
540 for ligne in les_lignes :
542 # 3.1. Pas de modification, a priori
547 # 3.2. Decodage des composants de la ligne pour un fichier
549 if ligne[0:2] == "F " :
557 if ( ":" in nomfic_0 ) :
558 laux1 = nomfic_0.split(":")
559 saux = laux1[0] + ":"
562 # 3.2.1. Si c'est le fichier de commandes, mise a jour du nom du repertoire
564 if typfic == "comm" :
566 nomfic_l_0 = os.path.basename(nomfic_0)
567 nomfic = os.path.join(self.rep_calc, nomfic_l_0)
569 # 3.2.2. Si ce n'est pas le fichier de commandes, mise a jour du nom
573 # 3.2.2.1. Le fichier de maillage est celui passe en argument
575 if typfic == "mmed" :
576 nomfic = self.mesh_file
578 # 3.2.2.2. Pour les autres fichiers, on recupère le nom initial
581 nomfic_l_0 = os.path.basename(nomfic_0)
582 laux1 = nomfic_l_0.split(".")
584 # 3.2.2.2.1. Base des noms de fichiers si excavation
586 if laux1[0] == "couche_n" :
587 saux0 = "couche_%02d" % self.nro_couche
591 # 3.2.2.2.2. Indicage des fichiers
596 saux1 = "%02d" % self.numero
598 saux1 = "%03d" % self.numero
600 saux1 = "%04d" % self.numero
602 saux1 = "%d" % self.numero
603 nomfic_l = saux0 + "." + saux1 + "." + laux1[2]
605 nomfic_l = saux0 + "." + laux1[1]
607 nomfic_l_1 = os.path.dirname(nomfic_0)
608 nomfic = os.path.join(nomfic_l_1, nomfic_l)
610 ligne_bis = laux[0] + " " + laux[1] + " " + saux
611 ligne_bis += nomfic + " "
612 ligne_bis += laux[3] + " " + laux[4] + "\n"
614 # 3.2.2.3. On detruit preventivement les fichiers des resultats
616 if self.nomcas[:6] != "couche" :
618 if os.path.isfile(nomfic) :
621 # 3.2.3. Memorisation des noms
623 self.dico[typfic] = nomfic
625 # 3.3. Decodage des composants de la ligne pour la base
627 elif ligne[0:2] == "R " :
634 # 3.3.1. Si c'est le fichier de la base, on recupere le nom initial, en ajustant l'indice
636 if typfic in ( "base", "bhdf" ) :
639 if ( ":" in nomfic_0 ) :
640 laux1 = nomfic_0.split(":")
641 saux = laux1[0] + ":"
643 nomfic_l_0 = os.path.basename(nomfic_0)
644 laux1 = nomfic_l_0.split(".")
648 saux1 = "%02d" % self.numero
650 saux1 = "%03d" % self.numero
652 saux1 = "%04d" % self.numero
654 saux1 = "%d" % self.numero
655 nomfic_l = laux1[0] + "." + saux1 + "." + laux1[2]
656 elif len(laux1) >= 2 :
657 if laux1[0] == "couche_nm1" :
658 saux0 = "couche_%02d" % (self.nro_couche-1)
659 elif laux1[0] == "couche_n" :
660 saux0 = "couche_%02d" % self.nro_couche
663 nomfic_l = saux0 + "." + laux1[1]
665 nomfic_l = nomfic_l_0
666 nomfic_l_1 = os.path.dirname(nomfic_0)
667 nomfic = os.path.join(nomfic_l_1, nomfic_l)
669 ligne_bis = laux[0] + " " + laux[1] + " " + saux
670 ligne_bis += nomfic + " "
671 ligne_bis += laux[3] + " " + laux[4] + "\n"
673 # 3.4. Decodage des composants de la ligne pour un parametre
675 elif ligne[0:2] == "P " :
679 if ( len(laux) == 3 ) :
681 if laux[1] in ( "username" ) :
683 elif laux[1] in ( "uclient" ) :
685 elif laux[1] in ( "aster_root" ) :
686 self.aster_root = aux
687 elif laux[1] in ( "serveur" ) :
689 elif laux[1] in ( "mclient" ) :
691 #elif laux[1] in ( "display" ) :
692 #aux = self.machine+":0.0"
693 elif laux[1] in ( "nomjob" ) :
695 elif laux[1] in ( "mode" ) :
697 ligne_bis = laux[0] + " " + laux[1] + " " + aux + "\n"
699 # 3.5. Ecriture de la ligne
708 message_erreur = messages_erreur[erreur]
710 if self.verbose_max :
711 print ". mclient ", self.mclient
712 print ". uclient ", self.uclient
713 print ". serveur ", self.serveur
714 print ". username ", self.username
715 print ". aster_root ", self.aster_root
716 print ". nomjob ", self.nomjob
717 print ". mode ", self.mode
719 return erreur, message_erreur
721 #========================= Fin de la fonction ===================================
723 #========================= Debut de la fonction ==================================
725 def modif_cas_transitoire ( self ) :
728 Modification du fichier de commandes lie au cas transitoire
731 messages_erreur = { 0 : None,
732 2 : "Mot_cle inconnu dans les commandes." }
734 nom_fonction = __name__ + "/modif_cas_transitoire"
735 blabla = "\nDans " + nom_fonction + ","
740 if self.verbose_max :
742 print ". opt1 :", self.opt1
743 print ". opt2 :", self.opt2
747 # 1. Lecture du fichier de commandes
749 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
750 fic = open (nomfic, "r")
751 les_lignes = fic.readlines()
754 # 2. Ouverture du nouveau fichier de commandes
756 fic = open (nomfic, "w")
758 # 3. Exploration des lignes
760 # 3.0. Reperage de la zone a modifier
764 for ligne in les_lignes :
766 if self.verbose_max :
767 print "ligne =", ligne[:-1]
769 # 3.1. Pas de modification, a priori
773 # 3.2. Reperage de la zone a modifier
775 if ( "A PERSONNALISER - DEBUT" in ligne ) :
777 elif ( "A PERSONNALISER - FIN" in ligne ) :
782 #print "A_modifier =", A_modifier
785 #print "ligne =", ligne[:-1]
786 for iaux in range(2) :
788 mot_cle_ref = "NUME_INST_"
791 mot_cle_ref = "INST_"
793 #print "mot_cle_ref =", mot_cle_ref
795 if ligne[0:lg_mot_cle] == mot_cle_ref :
797 if ligne[lg_mot_cle:lg_mot_cle+4] == "INIT" :
799 motcle = ligne[0:lg_mot_cle+4]
800 elif ligne[lg_mot_cle:lg_mot_cle+3] == "FIN" :
802 motcle = ligne[0:lg_mot_cle+3]
804 self.message_info += ligne
808 ligne_bis = motcle + " = " + str(aux) +"\n"
813 # 3.4. Ecriture de la ligne
821 # 4. Gestion des erreurs
824 message_erreur = messages_erreur[erreur]
826 return erreur, message_erreur
828 #========================= Fin de la fonction ===================================
830 #========================= Debut de la fonction ==================================
832 def modif_cas_excavation ( self ) :
835 Modification du fichier de commandes lie au cas de l'excavation
838 messages_erreur = { 0 : None }
840 nom_fonction = __name__ + "/modif_cas_excavation"
841 blabla = "\nDans " + nom_fonction + ","
846 if self.verbose_max :
848 print ". numero :", self.numero
849 print ". nro_couche :", self.nro_couche
850 print ". nro_adap :", self.nro_adap
854 # 1. Lecture du fichier de commandes
856 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
857 fic = open (nomfic, "r")
858 les_lignes = fic.readlines()
861 # 2. Ouverture du nouveau fichier de commandes
863 fic = open (nomfic, "w")
865 # 3. Exploration des lignes
867 # 3.0. Reperage de la zone a modifier
871 for ligne in les_lignes :
873 if self.verbose_max :
874 print "ligne =", ligne[:-1]
876 # 3.1. Pas de modification, a priori
880 # 3.2. Reperage de la zone a modifier
882 if ( "A PERSONNALISER - DEBUT" in ligne ) :
884 elif ( "A PERSONNALISER - FIN" in ligne ) :
889 #print "A_modifier =", A_modifier
892 #print "ligne =", ligne[:-1]
893 for iaux in range(3) :
895 mot_cle_ref = "nro_mail"
899 mot_cle_ref = "nro_couche"
901 aux = self.nro_couche
903 mot_cle_ref = "nro_adap"
906 #print "mot_cle_ref =", mot_cle_ref
908 if ligne[0:lg_mot_cle] == mot_cle_ref :
909 #print "==> aux =", aux, type(aux)
910 ligne_bis = mot_cle_ref + " = " + str(aux) +"\n"
912 # 3.4. Ecriture de la ligne
920 # 4. Gestion des erreurs
923 message_erreur = messages_erreur[erreur]
925 return erreur, message_erreur
927 #========================= Fin de la fonction ===================================
929 #========================= Debut de la fonction ==================================
931 def calcul ( self ) :
934 Lancement d'un calcul
937 messages_erreur = { 0 : None }
939 nom_fonction = __name__ + "/calcul"
940 blabla = "\nDans " + nom_fonction + ","
945 if self.verbose_max :
946 print ". mclient ", self.mclient
947 print ". serveur ", self.serveur
949 # 1. Copie du fichier export sur le serveur de calcul
951 if ( self.mclient != self.serveur ) :
953 nomfic_export_dist = self.nomjob + ".export"
954 commande = "scp " + self.nomfic_export + " " + self.username + "@" + self.serveur + ":" + nomfic_export_dist
955 if self.verbose_max :
956 print "Copie du fichier export vers", self.serveur, ":"
958 erreur = os.system(commande)
960 # 2. Commande du lancement
962 commande_base = os.path.join(self.aster_root, "bin", "as_run")
964 if self.mode == "batch" :
965 commande_base += "--serv "
966 commande_base += self.username + "@" + self.serveur + ":"
967 #if self.verbose_max :
970 fic_caract = tempfile.mktemp()
971 fic_caract_2 = tempfile.mktemp()
974 # 3.1. Commande finale
976 if ( self.mclient == self.serveur ) :
977 commande = commande_base
978 commande += commande_base + self.nomfic_export
980 commande = "ssh " + self.username + "@" + self.serveur
981 commande += " \"" + commande_base + nomfic_export_dist + "\""
982 commande += " 1>" + fic_caract
983 commande += " 2>" + fic_caract_2
984 if self.verbose_max :
985 print "Lancement sur", self.serveur, ":"
988 # 3.2. Lancement vrai
990 erreur = os.system(commande)
992 messages_erreur[erreur] = "erreur de calcul numero %d" % erreur
994 self.message_info += "resultat dans le fichier :\n"
996 self.message_info += self.dico["rmed"]+"\n"
998 if self.verbose_max :
1000 print ". erreur :", erreur
1001 print ". self.mode :", self.mode
1002 print ". fic_caract :", fic_caract
1005 message_erreur = messages_erreur[erreur]
1007 return erreur, message_erreur, fic_caract, fic_caract_2
1009 #========================= Fin de la fonction ===================================
1011 #========================= Debut de la fonction ==================================
1013 def calcul_aster_attente ( self, fic_caract ) :
1016 Bilan du calcul Aster
1017 fic_caract : fichier caracteristique du job
1020 nom_fonction = __name__ + "/calcul_aster_attente"
1021 blabla = "\nDans " + nom_fonction + ","
1024 message_erreur = " "
1026 if self.verbose_max :
1027 print ". fic_caract :", fic_caract
1028 print ". nomjob :", self.nomjob
1029 print ". rep_calc :", self.rep_calc
1030 print ". mode :", self.mode
1031 print ". attente :", self.attente
1033 if ( self.mode != "interactif" ) :
1035 # 1. Recuperation du numero de job
1037 fic = open (fic_caract, "r")
1038 les_lignes = fic.readlines()
1041 for ligne in les_lignes :
1043 if ( len(ligne)>0 ) :
1045 if "JOBID" in ligne :
1047 laux = ligne.split()
1048 laux1 = laux[0].split("=")
1051 elif "num_job" in ligne :
1053 laux = ligne.split("num_job")
1054 laux1 = laux[1].split()
1058 print ". numjob :", numjob
1060 # 2. Commande de l'examen de l'etat du job,
1062 fic_etat = os.path.join(self.rep_calc, self.nomjob+".etat")
1063 fic_etat_2 = tempfile.mktemp()
1064 commande_base = os.path.join(self.aster_root, "bin", "as_run")
1065 commande_base += " --actu " + numjob + " " + self.nomjob + " " + self.mode
1066 if self.verbose_max :
1067 print "commande_base =", commande_base
1068 if ( self.mclient == self.serveur ) :
1069 commande = commande_base
1071 commande = "ssh " + self.username + "@" + self.serveur
1072 commande += " \"" + commande_base + "\""
1073 commande += " 1>" + fic_etat
1074 commande += " 2>" + fic_etat_2
1075 if self.verbose_max :
1076 print "Examen sur", self.serveur, ":"
1079 # 3. Examen de l'etat du job, jusqu'a la fin
1084 if encore % 4 == 0 :
1085 aux = ((encore-1)*self.attente) / 60
1086 print "..", aux, "mn"
1089 time.sleep(self.attente)
1090 erreur = os.system(commande)
1095 elif os.path.isfile(fic_etat) :
1096 fic = open (fic_etat, "r")
1097 les_lignes = fic.readlines()
1099 if len(les_lignes) > 0 :
1100 if len(les_lignes[0]) > 0 :
1101 laux = les_lignes[0].split()
1102 laux1 = laux[0].split("=")
1104 laux1 = laux[1].split("=")
1106 if self.verbose_max :
1108 if etat in ( "RUN", "PEND" ) :
1111 if etat != "ENDED" :
1112 self.message_info += "Etat du job : " + etat
1115 if diag[:3] in ( "<S>", "<F>" ) :
1118 self.message_info = "Diagnostic du job : " + diag + "\n"
1129 os.remove(fic_etat_2)
1131 if self.verbose_max :
1133 print ". erreur :", erreur
1136 message_erreur = "Erreur dans le calcul"
1138 return erreur, message_erreur
1140 #========================= Fin de la fonction ===================================
1142 #========================= Debut de la fonction ==================================
1144 def post_aster ( self, dico_resu_init ) :
1147 Affichage de resultats selon les cas
1150 messages_erreur = { 0 : None,
1151 1 : "Ce fichier est inconnu." }
1153 nom_fonction = __name__ + "/post_aster"
1154 blabla = "\nDans " + nom_fonction + ","
1157 message_erreur = " "
1160 for cle in dico_resu_init.keys() :
1161 dico_resu[cle] = dico_resu_init[cle]
1165 # 1. Exploration du fichier resu
1167 # 1.1. Recuperation du contenu
1169 nomfic = self.dico["resu"]
1172 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1175 self.message_info += info[:-1]
1179 info = info.replace(chaine, " ")
1180 laux = info[:-1].split()
1183 aux = aux.replace("D", "E")
1184 dico_resu[chaine] = float(aux)
1186 # 2. Exploration du fichier mess
1187 # 2.1. Que chercher ?
1189 for chaine in ( "INSTANT", "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1191 # 2.2. Recuperation du contenu
1193 nomfic = self.dico["mess"]
1194 if chaine == "INSTANT" :
1198 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1201 self.message_info += info[:-1]
1205 if chaine == "INSTANT" :
1206 l_aux = info[:-1].split()
1208 for iaux in range(lg_aux) :
1209 if ( "ORDRE" in l_aux[iaux] ) :
1210 if l_aux[iaux+1] == ":" :
1214 ordre = int(l_aux[jaux])
1215 dico_resu["ORDRE"] = ordre
1216 dico_resu["PAS_DE_TEMPS"] = ordre
1217 elif chaine in ( "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1218 l_aux = info[:-1].split(chaine)
1219 dico_resu[chaine] = int(l_aux[1])
1224 # 3. Fichier de resultats au format med
1226 dico_resu["FileName"] = self.dico["rmed"]
1232 print ". erreur :", erreur
1233 print ". dico_resu :", dico_resu
1236 message_erreur = messages_erreur[erreur]
1238 return erreur, message_erreur, dico_resu
1240 #========================= Fin de la fonction ===================================
1242 #========================= Debut de la fonction ==================================
1244 def post_aster_1 ( self, nomfic, chaine, nuocc ) :
1248 nomfic = nom du fichier a decoder
1249 chaine = chaine a chercher
1250 nuocc = numero de l'occurence a chercher, 0 si toutes
1253 messages_erreur = { 0 : None,
1254 1 : "Ce fichier est inconnu." }
1256 nom_fonction = __name__ + "/post_aster_1"
1257 blabla = "\nDans " + nom_fonction + " :"
1258 if self.verbose_max :
1259 print blabla, "chaine =", chaine, ", nuocc =", nuocc
1262 message_erreur = " "
1267 # 1. Lecture du fichier
1269 if not os.path.isfile(nomfic) :
1270 self.message_info += "\nFichier "+nomfic+"\n"
1273 fic = open (nomfic, "r")
1274 les_lignes = fic.readlines()
1277 # 2. Exploration des lignes
1278 # 2.1. On recupere tout
1282 for ligne in les_lignes :
1289 self.message_info += "\n"
1291 for ligne in les_lignes :
1292 if chaine in ligne :
1294 if ( ( nuocc == 0 ) or ( iaux == nuocc ) ) :
1299 if self.verbose_max :
1301 print ". erreur :", erreur
1304 message_erreur = messages_erreur[erreur]
1306 return erreur, message_erreur, info
1308 #========================= Fin de la fonction ===================================
1310 #========================= Debut de la fonction ==================================
1312 def dump_resultat ( self ) :
1315 Dump du resultat du calcul
1318 messages_erreur = { 0 : None }
1320 nom_fonction = __name__ + "/dump_resultat"
1321 blabla = "\nDans " + nom_fonction + ","
1324 message_erreur = " "
1328 nomfic_donn = os.path.join(self.rep_calc, "donn")
1329 fic = open (nomfic_donn, "w")
1330 fic.write("1\n1\n1\n")
1332 fic_dump = self.dico["rmed"]+".dump"
1333 commande = "mdump " + self.dico["rmed"] + "<" + nomfic_donn + ">" + fic_dump
1335 erreur = os.system(commande)
1337 messages_erreur[erreur] = "Erreur de dump numero %d" % erreur
1339 self.message_info += "\nDump dans le fichier :\n"
1340 self.message_info += fic_dump+"\n"
1342 if self.verbose_max :
1344 print ". erreur :", erreur
1347 message_erreur = messages_erreur[erreur]
1349 return erreur, message_erreur
1351 #========================= Fin de la fonction ===================================
1354 if __name__ == "__main__" :
1356 #print "Arguments a l'entree de", sys.argv[0], ":", sys.argv[1:], "\n"
1358 Script_A = Script(sys.argv[1:])
1360 if Script_A.affiche_aide_globale :
1361 Script_A.message_info = Script_A.__doc__
1363 message_erreur_m = ""
1366 erreur_m, message_erreur_m, dico_resu_m = Script_A.compute ()
1368 sys.stdout.write(Script_A.message_info+"\n")
1369 sys.stderr.write(message_erreur_m+"\n")