2 # -*- coding: utf-8 -*-
3 # Copyright (C) 2013-2016 CEA/DEN, EDF R&D
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 if "HOME" in os.environ :
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 t_aux = tempfile.mkstemp()
1002 fic_caract = t_aux[1]
1003 t_aux = tempfile.mkstemp()
1004 fic_caract_2 = t_aux[1]
1007 # 3.1. Commande finale
1009 if ( self.mclient == self.serveur ) :
1010 commande = commande_base
1011 commande += commande_base + self.nomfic_export
1013 commande = "ssh " + self.username + "@" + self.serveur
1014 commande += " \"" + commande_base + nomfic_export_dist + "\""
1015 commande += " 1>" + fic_caract
1016 commande += " 2>" + fic_caract_2
1017 if self.verbose_max :
1018 print("Lancement sur", self.serveur, ":")
1021 # 3.2. Lancement vrai
1023 erreur = os.system(commande)
1025 messages_erreur[erreur] = "erreur de calcul numero %d" % erreur
1027 self.message_info += "resultat dans le fichier :\n"
1029 self.message_info += self.dico["rmed"]+"\n"
1031 if self.verbose_max :
1033 print(". erreur :", erreur)
1034 print(". self.mode :", self.mode)
1035 print(". fic_caract :", fic_caract)
1038 message_erreur = messages_erreur[erreur]
1040 return erreur, message_erreur, fic_caract, fic_caract_2
1042 #========================= Fin de la fonction ===================================
1044 #========================= Debut de la fonction ==================================
1046 def calcul_aster_attente ( self, fic_caract ) :
1049 Bilan du calcul Aster
1050 fic_caract : fichier caracteristique du job
1053 nom_fonction = __name__ + "/calcul_aster_attente"
1054 blabla = "\nDans " + nom_fonction + ","
1057 message_erreur = " "
1059 if self.verbose_max :
1060 print(". fic_caract :", fic_caract)
1061 print(". nomjob :", self.nomjob)
1062 print(". rep_calc :", self.rep_calc)
1063 print(". mode :", self.mode)
1064 print(". attente :", self.attente)
1066 if ( self.mode != "interactif" ) :
1068 # 1. Recuperation du numero de job
1070 fic = open (fic_caract, "r")
1071 les_lignes = fic.readlines()
1074 for ligne in les_lignes :
1076 if ( len(ligne)>0 ) :
1078 if "JOBID" in ligne :
1080 laux = ligne.split()
1081 laux1 = laux[0].split("=")
1084 elif "num_job" in ligne :
1086 laux = ligne.split("num_job")
1087 laux1 = laux[1].split()
1091 print(". numjob :", numjob)
1093 # 2. Commande de l'examen de l'etat du job,
1095 fic_etat = os.path.join(self.rep_calc, self.nomjob+".etat")
1096 t_aux = tempfile.mkstemp()
1097 fic_etat_2 = t_aux[1]
1098 commande_base = os.path.join(self.aster_root, "bin", "as_run")
1099 commande_base += " --actu " + numjob + " " + self.nomjob + " " + self.mode
1100 if self.verbose_max :
1101 print("commande_base =", commande_base)
1102 if ( self.mclient == self.serveur ) :
1103 commande = commande_base
1105 commande = "ssh " + self.username + "@" + self.serveur
1106 commande += " \"" + commande_base + "\""
1107 commande += " 1>" + fic_etat
1108 commande += " 2>" + fic_etat_2
1109 if self.verbose_max :
1110 print("Examen sur", self.serveur, ":")
1113 # 3. Examen de l'etat du job, jusqu'a la fin
1118 if encore % 4 == 0 :
1119 aux = ((encore-1)*self.attente) / 60
1120 print("..", aux, "mn")
1123 time.sleep(self.attente)
1124 erreur = os.system(commande)
1129 elif os.path.isfile(fic_etat) :
1130 fic = open (fic_etat, "r")
1131 les_lignes = fic.readlines()
1133 if len(les_lignes) > 0 :
1134 if len(les_lignes[0]) > 0 :
1135 laux = les_lignes[0].split()
1136 laux1 = laux[0].split("=")
1138 laux1 = laux[1].split("=")
1140 if self.verbose_max :
1142 if etat in ( "RUN", "PEND" ) :
1145 if etat != "ENDED" :
1146 self.message_info += "Etat du job : " + etat
1149 if diag[:3] in ( "<S>", "<F>" ) :
1152 self.message_info = "Diagnostic du job : " + diag + "\n"
1163 os.remove(fic_etat_2)
1165 if self.verbose_max :
1167 print(". erreur :", erreur)
1170 message_erreur = "Erreur dans le calcul"
1172 return erreur, message_erreur
1174 #========================= Fin de la fonction ===================================
1176 #========================= Debut de la fonction ==================================
1178 def post_aster ( self, dico_resu_init ) :
1181 Affichage de resultats selon les cas
1184 messages_erreur = { 0 : None,
1185 1 : "Ce fichier est inconnu." }
1187 nom_fonction = __name__ + "/post_aster"
1188 blabla = "\nDans " + nom_fonction + ","
1191 message_erreur = " "
1194 dico_resu.update(dico_resu_init)
1198 # 1. Exploration du fichier resu
1200 # 1.1. Recuperation du contenu
1202 nomfic = self.dico["resu"]
1205 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1211 if ( erreur == 0 ) :
1212 self.message_info += info[:-1]
1213 info = info.replace(chaine, " ")
1214 laux = info[:-1].split()
1217 aux = aux.replace("D", "E")
1218 dico_resu[chaine] = float(aux)
1221 message_erreur = " "
1223 # 2. Exploration du fichier mess
1224 # 2.1. Que chercher ?
1226 for chaine in ( "INSTANT", "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1228 # 2.2. Recuperation du contenu
1230 nomfic = self.dico["mess"]
1231 if chaine == "INSTANT" :
1235 erreur, message_erreur, info = self.post_aster_1 ( nomfic, chaine, nuocc )
1241 if ( erreur == 0 ) :
1242 self.message_info += info[:-1]
1243 if chaine == "INSTANT" :
1244 l_aux = info[:-1].split()
1246 for iaux in range(lg_aux) :
1247 if ( "ORDRE" in l_aux[iaux] ) :
1248 if l_aux[iaux+1] == ":" :
1252 ordre = int(l_aux[jaux])
1253 dico_resu["ORDRE"] = ordre
1254 dico_resu["PAS_DE_TEMPS"] = ordre
1255 elif chaine in ( "NOMBRE DE NOEUDS", "NOMBRE DE MAILLES" ) :
1256 l_aux = info[:-1].split(chaine)
1257 dico_resu[chaine] = int(l_aux[1])
1260 message_erreur = " "
1265 # 3. Fichier de resultats au format med
1267 dico_resu["FileName"] = self.dico["rmed"]
1273 print(". erreur :", erreur)
1274 print(". dico_resu :", dico_resu)
1277 message_erreur = messages_erreur[erreur]
1279 return erreur, message_erreur, dico_resu
1281 #========================= Fin de la fonction ===================================
1283 #========================= Debut de la fonction ==================================
1285 def post_aster_1 ( self, nomfic, chaine, nuocc ) :
1289 nomfic = nom du fichier a decoder
1290 chaine = chaine a chercher
1291 nuocc = numero de l'occurence a chercher, 0 si toutes
1293 codret = 0 : tout va bien
1294 1 : le fichier de resultats est absent
1295 -1 : la chaine est absente
1296 message_erreur = "" : tout va bien
1298 info = la ou les lignes recherchees
1301 messages_erreur = { 0 : None,
1302 -1 : "La chaine est absente.",
1303 1 : "Ce fichier est inconnu." }
1305 nom_fonction = __name__ + "/post_aster_1"
1306 blabla = "\nDans " + nom_fonction + " :"
1307 if self.verbose_max :
1308 print(blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc)
1312 message_erreur = " "
1317 # 1. Lecture du fichier
1319 if not os.path.isfile(nomfic) :
1320 self.message_info += "\nFichier "+nomfic+"\n"
1323 fic = open (nomfic, "r")
1324 les_lignes = fic.readlines()
1327 # 2. Exploration des lignes
1328 # 2.1. On recupere tout
1332 for ligne in les_lignes :
1340 for ligne in les_lignes :
1341 if chaine in ligne :
1343 if ( ( nuocc == 0 ) or ( iaux == nuocc ) ) :
1346 self.message_info += "\n"
1354 if ( self.verbose_max or ( erreur>0 ) ) :
1355 print(blabla, "nomfic =", nomfic, "chaine =", chaine, ", nuocc =", nuocc)
1356 print(". erreur =", erreur)
1359 message_erreur = messages_erreur[erreur]
1361 return erreur, message_erreur, info
1363 #========================= Fin de la fonction ===================================
1365 #========================= Debut de la fonction ==================================
1367 def dump_resultat ( self ) :
1370 Dump du resultat du calcul
1373 messages_erreur = { 0 : None }
1375 nom_fonction = __name__ + "/dump_resultat"
1376 blabla = "\nDans " + nom_fonction + ","
1379 message_erreur = " "
1383 nomfic_donn = os.path.join(self.rep_calc, "donn")
1384 fic = open (nomfic_donn, "w")
1385 fic.write("1\n1\n1\n")
1387 fic_dump = self.dico["rmed"]+".dump"
1388 commande = "mdump " + self.dico["rmed"] + "<" + nomfic_donn + ">" + fic_dump
1390 erreur = os.system(commande)
1392 messages_erreur[erreur] = "Erreur de dump numero %d" % erreur
1394 self.message_info += "\nDump dans le fichier :\n"
1395 self.message_info += fic_dump+"\n"
1397 if self.verbose_max :
1399 print(". erreur :", erreur)
1401 os.remove(nomfic_donn)
1404 message_erreur = messages_erreur[erreur]
1406 return erreur, message_erreur
1408 #========================= Fin de la fonction ===================================
1411 if __name__ == "__main__" :
1413 #print "Arguments a l'entree de", sys.argv[0], ":", sys.argv[1:], "\n"
1415 Script_A = Script(sys.argv[1:])
1417 if Script_A.affiche_aide_globale :
1418 Script_A.message_info = Script_A.__doc__
1420 message_erreur_m = ""
1423 erreur_m, message_erreur_m, dico_resu_m = Script_A.compute ()
1425 sys.stdout.write(Script_A.message_info+"\n")
1426 sys.stderr.write(message_erreur_m+"\n")