2 # -*- coding: iso-8859-1 -*-
3 # Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
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
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 os.environ.has_key("LOGNAME") :
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 if os.environ.has_key("HOME") :
377 HOME = os.environ ["HOME"]
379 HOME = "/local/home/salome"
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
388 aux = os.path.join(os.getcwd(), self.rep_calc)
389 self.rep_calc = os.path.normpath(aux)
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
404 fic = os.path.normpath(aux)
405 aux = os.path.join(os.getcwd(), fic)
407 self.mesh_file = os.path.normpath(aux)
409 # 2. On en deduit le cas
411 self.nomcas = os.path.basename(self.rep_calc)
412 if self.verbose_max :
413 print ". Cas :", self.nomcas
415 # 3. Le temps d'attente
419 iaux = int(self.attente)
425 # 4. Le numero du calcul
427 if self.numero == None :
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
437 self.numero_str = "%d" % self.numero
439 # 5. Options speciales pour les cas transitoires et pour l'excavation
441 if ( self.tr or ( self.nomcas[:6] == "couche" ) ) :
443 if self.opt1 == None :
444 self.opt1 = opt1_defaut[self.nomcas]
445 #print ". opt1 defaut :", self.opt1
447 if self.opt2 == None :
448 self.opt2 = opt2_defaut[self.nomcas]
449 #print ". opt2 defaut :", self.opt2
451 # 5.1. Pour un cas transitoire
458 iaux1 = int(self.opt1)
460 daux1 = float(self.opt1)
467 iaux2 = int(self.opt2)
469 daux2 = float(self.opt2)
471 if ( ( daux1 == None ) or ( daux2 == None ) ) :
472 #print "------------ ( daux1 == None ) or ( daux2 == None ) ------------"
473 #print "iaux1, iaux2 =", iaux1, iaux2
476 elif ( ( iaux1 == None ) or ( iaux2 == None ) ) :
477 #print "------------ ( iaux1 == None ) or ( iaux2 == None ) ------------"
478 #print "daux1, daux2 =", daux1, daux2
485 self.message_info += "opt1 = " + self.opt1
486 self.message_info += "\nopt2 = " + self.opt2
488 # 5.2. Pour l'excavation
490 elif self.nomcas[:6] == "couche" :
494 iaux1 = int(self.opt1)
498 if ( ( iaux1 < 1 ) or ( iaux1 > 20 ) ) :
499 #print "iaux1 =", iaux1
504 iaux2 = int(self.opt2)
509 #print "iaux1 =", iaux1
513 self.message_info += "nro_mail = " + self.numero
514 self.message_info += "\nopt1 = " + self.opt1
515 self.message_info += "\nopt2 = " + self.opt2
518 self.nro_couche = iaux1
519 self.nro_adap = iaux2
524 message_erreur = messages_erreur[erreur]
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
532 return erreur, message_erreur
534 #========================= Fin de la fonction ===================================
536 #========================= Debut de la fonction ==================================
538 def modif_export ( self ) :
541 Modification du fichier export et reperage de quelques informations
544 messages_erreur = { 0 : None }
546 nom_fonction = __name__ + "/modif_export"
547 blabla = "\nDans " + nom_fonction + ","
552 if self.verbose_max :
554 print ". numero :", self.numero
555 print ". mesh_file :", self.mesh_file
559 # 1. Lecture du fichier export original
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()
566 # 2. Ouverture du nouveau fichier export
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")
577 # 3. Exploration des lignes
579 for ligne in les_lignes :
581 # 3.1. Pas de modification, a priori
586 # 3.2. Decodage des composants de la ligne pour un fichier
588 if ligne[0:2] == "F " :
599 if ( ":" in nomfic_0 ) :
600 laux1 = nomfic_0.split(":")
601 saux = laux1[0] + ":"
604 # 3.2.1. Si c'est le fichier de commandes, mise a jour du nom du repertoire
606 if ( typfic == "comm" ) :
608 if self.verbose_max :
609 print ". Commandes : mise a jour du nom du repertoire"
611 nomfic_l_0 = os.path.basename(nomfic_0)
612 nomfic = os.path.join(self.rep_calc, nomfic_l_0)
614 # 3.2.2. Si c'est un fichier de resultats ou le fichier de maillage, mise a jour du nom
616 elif ( ( statut == "R" ) or ( typfic == "mmed" ) ) :
617 if self.verbose_max :
618 print ". Mise a jour du nom"
621 # 3.2.2.1. Le fichier de maillage est celui passe en argument
623 if typfic == "mmed" :
624 nomfic = self.mesh_file
626 # 3.2.2.2. Pour les autres fichiers, on recupère le nom initial
629 nomfic_l_0 = os.path.basename(nomfic_0)
630 laux1 = nomfic_l_0.split(".")
631 #print "laux1 =", laux1
633 # 3.2.2.2.1. Base des noms de fichiers si excavation
635 if laux1[0] == "couche_n" :
636 saux0 = "couche_%02d" % self.nro_couche
638 iaux = len(laux1[-1]) + 1
639 saux0 = nomfic_l_0[:-iaux]
640 #print "saux0 =", saux0
642 # 3.2.2.2.2. Indicage des fichiers
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
650 ligne_bis = laux[0] + " " + laux[1] + " " + saux
651 ligne_bis += nomfic + " "
652 ligne_bis += laux[3] + " " + laux[4] + "\n"
654 # 3.2.2.3. On detruit preventivement les fichiers des resultats
656 if ( statut == "R" ) :
657 if ( self.nomcas[:6] != "couche" ) :
658 if os.path.isfile(nomfic) :
661 # 3.2.3. Memorisation des noms
663 self.dico[typfic] = nomfic
665 # 3.3. Decodage des composants de la ligne pour la base
667 elif ligne[0:2] == "R " :
674 # 3.3.1. Si c'est le fichier de la base, on recupere le nom initial, en ajustant l'indice
676 if typfic in ( "base", "bhdf" ) :
679 if ( ":" in nomfic_0 ) :
680 laux1 = nomfic_0.split(":")
681 saux = laux1[0] + ":"
683 nomfic_l_0 = os.path.basename(nomfic_0)
684 laux1 = nomfic_l_0.split(".")
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
694 nomfic_l = saux0 + "." + laux1[1]
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)
700 ligne_bis = laux[0] + " " + laux[1] + " " + saux
701 ligne_bis += nomfic + " "
702 ligne_bis += laux[3] + " " + laux[4] + "\n"
704 # 3.4. Decodage des composants de la ligne pour un parametre
706 elif ligne[0:2] == "P " :
710 if ( len(laux) == 3 ) :
712 if laux[1] in ( "username" ) :
714 elif laux[1] in ( "uclient" ) :
716 elif laux[1] in ( "aster_root" ) :
717 self.aster_root = aux
718 elif laux[1] in ( "serveur" ) :
720 elif laux[1] in ( "mclient" ) :
722 #elif laux[1] in ( "display" ) :
723 #aux = self.machine+":0.0"
724 elif laux[1] in ( "nomjob" ) :
726 elif laux[1] in ( "mode" ) :
728 ligne_bis = laux[0] + " " + laux[1] + " " + aux + "\n"
730 # 3.5. Ecriture de la ligne
739 message_erreur = messages_erreur[erreur]
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
750 return erreur, message_erreur
752 #========================= Fin de la fonction ===================================
754 #========================= Debut de la fonction ==================================
756 def modif_cas_transitoire ( self ) :
759 Modification du fichier de commandes lie au cas transitoire
762 messages_erreur = { 0 : None,
763 2 : "Mot_cle inconnu dans les commandes." }
765 nom_fonction = __name__ + "/modif_cas_transitoire"
766 blabla = "\nDans " + nom_fonction + ","
771 if self.verbose_max :
773 print ". opt1 :", self.opt1
774 print ". opt2 :", self.opt2
778 # 1. Lecture du fichier de commandes
780 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
781 fic = open (nomfic, "r")
782 les_lignes = fic.readlines()
785 # 2. Ouverture du nouveau fichier de commandes
787 fic = open (nomfic, "w")
789 # 3. Exploration des lignes
791 # 3.0. Reperage de la zone a modifier
795 for ligne in les_lignes :
797 if self.verbose_max :
798 print "ligne =", ligne[:-1]
800 # 3.1. Pas de modification, a priori
804 # 3.2. Reperage de la zone a modifier
806 if ( "A PERSONNALISER - DEBUT" in ligne ) :
808 elif ( "A PERSONNALISER - FIN" in ligne ) :
813 #print "A_modifier =", A_modifier
816 #print "ligne =", ligne[:-1]
817 for iaux in range(2) :
819 mot_cle_ref = "NUME_INST_"
822 mot_cle_ref = "INST_"
824 #print "mot_cle_ref =", mot_cle_ref
826 if ligne[0:lg_mot_cle] == mot_cle_ref :
828 if ligne[lg_mot_cle:lg_mot_cle+4] == "INIT" :
830 motcle = ligne[0:lg_mot_cle+4]
831 elif ligne[lg_mot_cle:lg_mot_cle+3] == "FIN" :
833 motcle = ligne[0:lg_mot_cle+3]
835 self.message_info += ligne
839 ligne_bis = motcle + " = " + str(aux) +"\n"
844 # 3.4. Ecriture de la ligne
852 # 4. Gestion des erreurs
855 message_erreur = messages_erreur[erreur]
857 return erreur, message_erreur
859 #========================= Fin de la fonction ===================================
861 #========================= Debut de la fonction ==================================
863 def modif_cas_excavation ( self ) :
866 Modification du fichier de commandes lie au cas de l'excavation
869 messages_erreur = { 0 : None }
871 nom_fonction = __name__ + "/modif_cas_excavation"
872 blabla = "\nDans " + nom_fonction + ","
877 if self.verbose_max :
879 print ". numero :", self.numero
880 print ". nro_couche :", self.nro_couche
881 print ". nro_adap :", self.nro_adap
885 # 1. Lecture du fichier de commandes
887 nomfic = os.path.join(self.rep_calc, self.dico["comm"])
888 fic = open (nomfic, "r")
889 les_lignes = fic.readlines()
892 # 2. Ouverture du nouveau fichier de commandes
894 fic = open (nomfic, "w")
896 # 3. Exploration des lignes
898 # 3.0. Reperage de la zone a modifier
902 for ligne in les_lignes :
904 if self.verbose_max :
905 print "ligne =", ligne[:-1]
907 # 3.1. Pas de modification, a priori
911 # 3.2. Reperage de la zone a modifier
913 if ( "A PERSONNALISER - DEBUT" in ligne ) :
915 elif ( "A PERSONNALISER - FIN" in ligne ) :
920 #print "A_modifier =", A_modifier
923 #print "ligne =", ligne[:-1]
924 for iaux in range(3) :
926 mot_cle_ref = "nro_mail"
930 mot_cle_ref = "nro_couche"
932 aux = self.nro_couche
934 mot_cle_ref = "nro_adap"
937 #print "mot_cle_ref =", mot_cle_ref
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"
943 # 3.4. Ecriture de la ligne
951 # 4. Gestion des erreurs
954 message_erreur = messages_erreur[erreur]
956 return erreur, message_erreur
958 #========================= Fin de la fonction ===================================
960 #========================= Debut de la fonction ==================================
962 def calcul ( self ) :
965 Lancement d'un calcul
968 messages_erreur = { 0 : None }
970 nom_fonction = __name__ + "/calcul"
971 blabla = "\nDans " + nom_fonction + ","
976 if self.verbose_max :
977 print ". mclient ", self.mclient
978 print ". serveur ", self.serveur
980 # 1. Copie du fichier export sur le serveur de calcul
982 if ( self.mclient != self.serveur ) :
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, ":"
989 erreur = os.system(commande)
991 # 2. Commande du lancement
993 commande_base = os.path.join(self.aster_root, "bin", "as_run")
995 if self.mode == "batch" :
996 commande_base += "--serv "
997 commande_base += self.username + "@" + self.serveur + ":"
998 #if self.verbose_max :
1001 fic_caract = tempfile.mktemp()
1002 fic_caract_2 = tempfile.mktemp()
1005 # 3.1. Commande finale
1007 if ( self.mclient == self.serveur ) :
1008 commande = commande_base
1009 commande += commande_base + self.nomfic_export
1011 commande = "ssh " + self.username + "@" + self.serveur
1012 commande += " \"" + commande_base + nomfic_export_dist + "\""
1013 commande += " 1>" + fic_caract
1014 commande += " 2>" + fic_caract_2
1015 if self.verbose_max :
1016 print "Lancement sur", self.serveur, ":"
1019 # 3.2. Lancement vrai
1021 erreur = os.system(commande)
1023 messages_erreur[erreur] = "erreur de calcul numero %d" % erreur
1025 self.message_info += "resultat dans le fichier :\n"
1027 self.message_info += self.dico["rmed"]+"\n"
1029 if self.verbose_max :
1031 print ". erreur :", erreur
1032 print ". self.mode :", self.mode
1033 print ". fic_caract :", fic_caract
1036 message_erreur = messages_erreur[erreur]
1038 return erreur, message_erreur, fic_caract, fic_caract_2
1040 #========================= Fin de la fonction ===================================
1042 #========================= Debut de la fonction ==================================
1044 def calcul_aster_attente ( self, fic_caract ) :
1047 Bilan du calcul Aster
1048 fic_caract : fichier caracteristique du job
1051 nom_fonction = __name__ + "/calcul_aster_attente"
1052 blabla = "\nDans " + nom_fonction + ","
1055 message_erreur = " "
1057 if self.verbose_max :
1058 print ". fic_caract :", fic_caract
1059 print ". nomjob :", self.nomjob
1060 print ". rep_calc :", self.rep_calc
1061 print ". mode :", self.mode
1062 print ". attente :", self.attente
1064 if ( self.mode != "interactif" ) :
1066 # 1. Recuperation du numero de job
1068 fic = open (fic_caract, "r")
1069 les_lignes = fic.readlines()
1072 for ligne in les_lignes :
1074 if ( len(ligne)>0 ) :
1076 if "JOBID" in ligne :
1078 laux = ligne.split()
1079 laux1 = laux[0].split("=")
1082 elif "num_job" in ligne :
1084 laux = ligne.split("num_job")
1085 laux1 = laux[1].split()
1089 print ". numjob :", numjob
1091 # 2. Commande de l'examen de l'etat du job,
1093 fic_etat = os.path.join(self.rep_calc, self.nomjob+".etat")
1094 fic_etat_2 = tempfile.mktemp()
1095 commande_base = os.path.join(self.aster_root, "bin", "as_run")
1096 commande_base += " --actu " + numjob + " " + self.nomjob + " " + self.mode
1097 if self.verbose_max :
1098 print "commande_base =", commande_base
1099 if ( self.mclient == self.serveur ) :
1100 commande = commande_base
1102 commande = "ssh " + self.username + "@" + self.serveur
1103 commande += " \"" + commande_base + "\""
1104 commande += " 1>" + fic_etat
1105 commande += " 2>" + fic_etat_2
1106 if self.verbose_max :
1107 print "Examen sur", self.serveur, ":"
1110 # 3. Examen de l'etat du job, jusqu'a la fin
1115 if encore % 4 == 0 :
1116 aux = ((encore-1)*self.attente) / 60
1117 print "..", aux, "mn"
1120 time.sleep(self.attente)
1121 erreur = os.system(commande)
1126 elif os.path.isfile(fic_etat) :
1127 fic = open (fic_etat, "r")
1128 les_lignes = fic.readlines()
1130 if len(les_lignes) > 0 :
1131 if len(les_lignes[0]) > 0 :
1132 laux = les_lignes[0].split()
1133 laux1 = laux[0].split("=")
1135 laux1 = laux[1].split("=")
1137 if self.verbose_max :
1139 if etat in ( "RUN", "PEND" ) :
1142 if etat != "ENDED" :
1143 self.message_info += "Etat du job : " + etat
1146 if diag[:3] in ( "<S>", "<F>" ) :
1149 self.message_info = "Diagnostic du job : " + diag + "\n"
1160 os.remove(fic_etat_2)
1162 if self.verbose_max :
1164 print ". erreur :", erreur
1167 message_erreur = "Erreur dans le calcul"
1169 return erreur, message_erreur
1171 #========================= Fin de la fonction ===================================
1173 #========================= Debut de la fonction ==================================
1175 def post_aster ( self, dico_resu_init ) :
1178 Affichage de resultats selon les cas
1181 messages_erreur = { 0 : None,
1182 1 : "Ce fichier est inconnu." }
1184 nom_fonction = __name__ + "/post_aster"
1185 blabla = "\nDans " + nom_fonction + ","
1188 message_erreur = " "
1191 for cle in dico_resu_init.keys() :
1192 dico_resu[cle] = dico_resu_init[cle]
1196 # 1. Exploration du fichier resu
1198 # 1.1. Recuperation du contenu
1200 nomfic = self.dico["resu"]
1203 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1209 if ( erreur == 0 ) :
1210 self.message_info += info[:-1]
1211 info = info.replace(chaine, " ")
1212 laux = info[:-1].split()
1215 aux = aux.replace("D", "E")
1216 dico_resu[chaine] = float(aux)
1219 message_erreur = " "
1221 # 2. Exploration du fichier mess
1222 # 2.1. Que chercher ?
1224 for chaine in ( "INSTANT", "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1226 # 2.2. Recuperation du contenu
1228 nomfic = self.dico["mess"]
1229 if chaine == "INSTANT" :
1233 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1239 if ( erreur == 0 ) :
1240 self.message_info += info[:-1]
1241 if chaine == "INSTANT" :
1242 l_aux = info[:-1].split()
1244 for iaux in range(lg_aux) :
1245 if ( "ORDRE" in l_aux[iaux] ) :
1246 if l_aux[iaux+1] == ":" :
1250 ordre = int(l_aux[jaux])
1251 dico_resu["ORDRE"] = ordre
1252 dico_resu["PAS_DE_TEMPS"] = ordre
1253 elif chaine in ( "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1254 l_aux = info[:-1].split(chaine)
1255 dico_resu[chaine] = int(l_aux[1])
1258 message_erreur = " "
1263 # 3. Fichier de resultats au format med
1265 dico_resu["FileName"] = self.dico["rmed"]
1271 print ". erreur :", erreur
1272 print ". dico_resu :", dico_resu
1275 message_erreur = messages_erreur[erreur]
1277 return erreur, message_erreur, dico_resu
1279 #========================= Fin de la fonction ===================================
1281 #========================= Debut de la fonction ==================================
1283 def post_aster_1 ( self, nomfic, chaine, nuocc ) :
1287 nomfic = nom du fichier a decoder
1288 chaine = chaine a chercher
1289 nuocc = numero de l'occurence a chercher, 0 si toutes
1291 codret = 0 : tout va bien
1292 1 : le fichier de resultats est absent
1293 -1 : la chaine est absente
1294 message_erreur = "" : tout va bien
1296 info = la ou les lignes recherchees
1299 messages_erreur = { 0 : None,
1300 -1 : "La chaine est absente.",
1301 1 : "Ce fichier est inconnu." }
1303 nom_fonction = __name__ + "/post_aster_1"
1304 blabla = "\nDans " + nom_fonction + " :"
1305 if self.verbose_max :
1306 print blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc
1310 message_erreur = " "
1315 # 1. Lecture du fichier
1317 if not os.path.isfile(nomfic) :
1318 self.message_info += "\nFichier "+nomfic+"\n"
1321 fic = open (nomfic, "r")
1322 les_lignes = fic.readlines()
1325 # 2. Exploration des lignes
1326 # 2.1. On recupere tout
1330 for ligne in les_lignes :
1338 for ligne in les_lignes :
1339 if chaine in ligne :
1341 if ( ( nuocc == 0 ) or ( iaux == nuocc ) ) :
1344 self.message_info += "\n"
1352 if ( self.verbose_max or ( erreur>0 ) ) :
1353 print blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc
1354 print ". erreur =", erreur
1357 message_erreur = messages_erreur[erreur]
1359 return erreur, message_erreur, info
1361 #========================= Fin de la fonction ===================================
1363 #========================= Debut de la fonction ==================================
1365 def dump_resultat ( self ) :
1368 Dump du resultat du calcul
1371 messages_erreur = { 0 : None }
1373 nom_fonction = __name__ + "/dump_resultat"
1374 blabla = "\nDans " + nom_fonction + ","
1377 message_erreur = " "
1381 nomfic_donn = os.path.join(self.rep_calc, "donn")
1382 fic = open (nomfic_donn, "w")
1383 fic.write("1\n1\n1\n")
1385 fic_dump = self.dico["rmed"]+".dump"
1386 commande = "mdump " + self.dico["rmed"] + "<" + nomfic_donn + ">" + fic_dump
1388 erreur = os.system(commande)
1390 messages_erreur[erreur] = "Erreur de dump numero %d" % erreur
1392 self.message_info += "\nDump dans le fichier :\n"
1393 self.message_info += fic_dump+"\n"
1395 if self.verbose_max :
1397 print ". erreur :", erreur
1399 os.remove(nomfic_donn)
1402 message_erreur = messages_erreur[erreur]
1404 return erreur, message_erreur
1406 #========================= Fin de la fonction ===================================
1409 if __name__ == "__main__" :
1411 #print "Arguments a l'entree de", sys.argv[0], ":", sys.argv[1:], "\n"
1413 Script_A = Script(sys.argv[1:])
1415 if Script_A.affiche_aide_globale :
1416 Script_A.message_info = Script_A.__doc__
1418 message_erreur_m = ""
1421 erreur_m, message_erreur_m, dico_resu_m = Script_A.compute ()
1423 sys.stdout.write(Script_A.message_info+"\n")
1424 sys.stderr.write(message_erreur_m+"\n")