# -*- coding: iso-8859-1 -*-
#
#-------------------------------------------------------------------------------
# Code_Saturne version 1.3
# ------------------------
#
#
# This file is part of the Code_Saturne User Interface, element of the
# Code_Saturne CFD tool.
#
# Copyright (C) 1998-2007 EDF S.A., France
#
# contact: saturne-support@edf.fr
#
# The Code_Saturne User Interface is free software; you can redistribute it
# and/or modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2 of
# the License, or (at your option) any later version.
#
# The Code_Saturne User Interface is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty
# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with the Code_Saturne Kernel; if not, write to the
# Free Software Foundation, Inc.,
# 51 Franklin St, Fifth Floor,
# Boston, MA 02110-1301 USA
#
#-------------------------------------------------------------------------------
"""
Start/Restart batch analysis
"""
#-------------------------------------------------------------------------------
# Library modules import
#-------------------------------------------------------------------------------
import os, sys
import string, types
import Tix
from Tkconstants import *
import tkFileDialog, tkMessageBox
#-------------------------------------------------------------------------------
# Application modules import
#-------------------------------------------------------------------------------
from Base.Common import *
import Base.Toolbox as Tool
import Base.Dialog as Dialog
import Base.TkPage as TkPage
from BatchRunningModel import BatchRunningModel
#-------------------------------------------------------------------------------
# Popup window class: Validator Class
#-------------------------------------------------------------------------------
class AsciiValidator(TkPage.DataValidator2):
"""
"""
def isAscii(self, entry, var):
"""
This method verify that value is an ascii string
"""
try:
toto = str(var)
return 1
except:
return self.error(entry)
return 0
#-------------------------------------------------------------------------------
# Popup window class: Data and results user files
#-------------------------------------------------------------------------------
class UserFilesDialog(Dialog.Dialog):
"""
All dirty stuff is done by the Dialog module
"""
def setListbox(self, num, list):
"""
Add data and results files input in entries in the good list.
"""
# 1) Which key is it ?
#
if num == 0:
key = 'data'
elif num == 1:
key = 'results'
else:
self.e[num].delete(0,END)
return
for item in list:
# 2) Verify that the input is not allready in the Listbox
#
if item in self.result[key]:
t = PageText()
tkMessageBox.showwarning (t.WARNING, t.MSG_ALLREADY)
self.e[num].delete(0,END)
else:
# 3) Update element
#
## self.result[key] = self.result[key] + (str(item))
self.result[key].append(str(item))
# 4) Update Listbox, clean entry
#
self.l[num].listbox.insert(END, item)
self.e[num].delete(0,END)
def getFilesName(self, num, var, event=None):
"""
Add data and results users files input in entries in the good list.
"""
list = string.split(var.get())
if not list: return
# Verify for User data files if they exist in self.case[data_path]
#
if num == 0:
for item in list:
if file not in os.listdir(self.default['data_path']):
self.e[num].bell()
self.e[num].selection_range(0,END)
self.e[num].config(selectbackground='red')
t = PageText()
tt = t.ERR_DATA_FILE + self.default['data_path'] \
+ '\n\n' + item + '\n\n' + t.MSG_IDENTITY
tkMessageBox.showwarning(t.WARNING, tt)
self.setListbox(num, list)
def searchUserFiles(self, event=None):
"""
Add data users files input in entries in the good list.
"""
file_name = ""
tk_fopen = tkFileDialog.askopenfilename
dir=os.getcwd()
if os.path.isdir(dir + "/../DATA"): dir = dir + "/../DATA"
file_name = tk_fopen (title="Search user data files.",
initialdir=dir,
filetypes=[("User data files", "*"),
("All files", "*")])
if file_name:
file = os.path.basename(file_name)
list = string.split(file)
if not list: return
num = 0
self.setListbox(num, list)
def killSelection(self, num, event=None):
"""
Delete the selection from the listbox (one by one).
"""
# 1) Is there something to delete ?
#
item = self.l[num].listbox.curselection()
if not item: return
# 2) Delete item from listbox
#
index = int(item[0])
self.l[num].listbox.delete(index)
# 3) Delete item from self.result
#
if num == 0:
del self.result['data'][index]
elif num == 1:
del self.result['results'][index]
def body(self, master):
"""
Processors number and list selection.
"""
# Main initialization
#
t = PageText()
# Variables declaration
#
self.data = Tix.StringVar()
self.resu = Tix.StringVar()
# Results from window initialization
#
self.result = {}
self.result['data'] = []
self.result['results'] = []
# Popup window layout
#
self.imgs = Tix.PhotoImage(file=PIC_PATH+'skull.gif')
self.imgc = Tix.PhotoImage(file=PIC_PATH+'cardfile.gif')
# Display the two listbox
#
f = [0]*2
g = [0]*2
h = [0]*2
self.l = [0]*2
self.e = [0]*2
b = [0]*2
for (num, txt1, txt2, var) in \
[(0, t.USER_DATA_LIST, t.USER_DATA_NEW, self.data),
(1, t.USER_RESU_LIST, t.USER_RESU_NEW, self.resu)]:
f[num] = Tix.LabelFrame(master, label=txt1, bd=2)
f[num].label.config(font=fT)
f[num].pack(side=TOP, expand=YES, padx=10, pady=2)
w1 = f[num].frame
self.l[num] = Tix.ScrolledListBox(w1, scrollbar='auto', width=200, height=60)
self.l[num].pack(side=TOP, expand=YES, padx=4, pady=10)
self.l[num].vsb.config(width=10, bd=1)
self.l[num].hsb.config(width=10, bd=1)
g[num] = Tix.Frame(w1, relief=FLAT)
g[num].pack(side=TOP, fill=BOTH)
w2 = g[num]
h[num] = Tix.Label(w2, text=txt2)
h[num].grid(row=0, column=0, padx=4, sticky=W)
self.e[num] = Tix.Entry(w2, width=20, textvariable=var)
self.e[num].bind("<Return>", TkPage.Callback(self.getFilesName,num,var))
self.e[num].grid(row=1, column=0, padx=4)
self.e[num].delete(0,END)
# Kill buttons
#
b[num] = Tix.Button(w2, image=self.imgs, command=TkPage.Callback(self.killSelection,num))
b[num].grid(row=1, column=1, padx=2, pady=1)
#self.balloon.bind_widget(b[num], balloonmsg=t.DELETE)
# Kill buttons
#
if num == 0:
b1 = Tix.Button(w2, image=self.imgc, command=self.searchUserFiles)
b1.grid(row=0, column=1, padx=2, pady=1)
#self.balloon.bind_widget(b1, statusmsg=t.DELETE)
# Previous values
#
for (i,s) in [(0,'data'), (1,'results')]:
try:
if self.default[s]:
self.setListbox(i, self.default[s])
except: pass
def validate(self):
"""
Verify if data and results users files input exit in the good directory.
"""
num = 0
s = ""
for item in self.result['data']:
file = self.default['data_path'] +'/'+ item
if not os.path.isfile(file):
s = s + item + '\n'
if s:
self.e[num].bell()
t = PageText()
s = '\n\n' + s + '\n'
tt = t.ERR_DATA_FILE + self.default['data_path'] +s+ t.MSG_IDENTITY
tkMessageBox.showwarning(t.WARNING, tt)
return 1
def sequence(self):
"""
Bind the dialog window with only 'Echap'
(delete sequence 'Return', because of the Tix.Control.entry).
"""
self.bind("<Escape>", self.cancel)
#-------------------------------------------------------------------------------
# Popup window class: Cluster job management
#-------------------------------------------------------------------------------
class PBSJobManagementDialog(Dialog.Dialog):
"""
All dirty stuff is done by Dialog module
"""
def jobName(self, entry, event=None):
"""
Delete Blank in the job name
"""
v = string.join(string.split(self.job_name.get()),'_')
self.job_name.set(v)
entry.selection_range(0,END)
entry.config(selectbackground='green')
def getValue(self, entry, var, step=None, event=None):
"""
Incremente, decremente and colorize the input argument entry
"""
if step:
v= var.get()
var.set(v+step)
entry.config(selectbackground='green')
entry.selection_range(0,END)
def body(self, master):
"""
Processors number and list selection.
"""
# Main initialization
#
t = PageText()
# Variables declaration
#
self.job_name = Tix.StringVar()
self.cluster_node = Tix.IntVar()
self.cluster_ppn = Tix.IntVar()
self.h_cput = Tix.IntVar()
self.m_cput = Tix.IntVar()
self.s_cput = Tix.IntVar()
self.job_mem = Tix.IntVar()
# Popup window layout
#
lf = Tix.LabelFrame(master, bd=2, label=t.JOB, relief=FLAT)
lf.label.config(font=fT)
lf.pack(side=TOP, expand=YES, padx=5, pady=5)
f = lf.frame
f1 = Tix.Frame(f,bd=2, relief=FLAT)
f1.pack(side=TOP, anchor=W)
le = Tix.LabelEntry(f1, bd=2, label=t.JOB_NAME)
le.entry.config(width=20, textvariable = self.job_name)
le.entry.bind('<Return>', TkPage.Callback(self.jobName, le.entry))
le.grid(row=0, column=0, sticky=W, padx=5, pady=10)
f2 = Tix.Frame(f, bd=2, relief=FLAT)
f2.pack(side=TOP, anchor=W)
e1=[0]*2
M=[16,2]
for (num, var, tt) in [(0, self.cluster_node, t.CL_NODES),
(1, self.cluster_ppn, t.CL_PPN) ]:
e1[num] = Tix.Control(f2, label=tt, bd=2,
value='1', min=1, max=M[num],
integer=1, selectmode='normal',
variable=var)
e1[num].entry.config(width=3)
e1[num].entry.bind('<Return>',TkPage.Callback(self.getValue, e1[num].entry, var, 0))
e1[num].decr.bind('<Button-1>',TkPage.Callback(self.getValue, e1[num].entry, var, -1))
e1[num].incr.bind('<Button-1>',TkPage.Callback(self.getValue, e1[num].entry, var, 1))
e1[num].grid(row=0, column=num, padx=5, pady=10, sticky=W)
f3 = Tix.Frame(f, relief=FLAT)
f3.pack(side=TOP, anchor=W)
l2 = Tix.Label(f3, text=t.CPU_TIME)
l2.grid(row=0, column=0, padx=5, pady=10, sticky=W)
e2=[0]*3
M=[999,59,59]
for (num, c, var, tt) in [(0, 1, self.h_cput, " h "),
(1, 3, self.m_cput, " mn ") ,
(2, 5, self.s_cput, " s ") ]:
e2[num] = Tix.Control(f3,
label=tt, bd=2,
value='0', min=0, max=M[num],
integer=1, selectmode='normal',
variable=var)
e2[num].entry.config(width=3)
e2[num].entry.bind('<Return>',TkPage.Callback(self.getValue, e2[num].entry, var, 0))
e2[num].decr.bind('<Button-1>',TkPage.Callback(self.getValue, e2[num].entry, var, -1))
e2[num].incr.bind('<Button-1>',TkPage.Callback(self.getValue, e2[num].entry, var, 1))
e2[num].grid(row=0, column=c, padx=2, pady=10, sticky=W)
f4 = Tix.Frame(f, relief=FLAT)
f4.pack(side=TOP, anchor=W)
S = 10
e3 = Tix.Control(f4, label=t.JOB_MEM, bd=2,
value='100', min=1, max=9999999, step=S,
integer=1, selectmode='normal',
variable=self.job_mem)
e3.entry.config(width=10)
e3.entry.bind('<Return>',TkPage.Callback(self.getValue, e3.entry, self.job_mem, 0))
e3.decr.bind('<Button-1>',TkPage.Callback(self.getValue, e3.entry, self.job_mem, -S))
e3.incr.bind('<Button-1>',TkPage.Callback(self.getValue, e3.entry, self.job_mem, S))
e3.grid(row=0, column=0, padx=5, pady=10, sticky=W)
# Previous values
#
try:
self.job_name.set(self.default['job_name'])
self.cluster_node.set(self.default['PBS_node'])
self.cluster_ppn.set(self.default['PBS_ppn'])
self.job_mem.set(self.default['PBS_mem'])
L = string.split(self.default['PBS_cput'], ":")
self.h_cput.set(L[0])
self.m_cput.set(L[1])
self.s_cput.set(L[2])
except:
pass
def apply(self):
"""
What to do when user clicks on 'OK'.
"""
self.result = {}
self.result['job_name'] = self.job_name.get()
self.result['PBS_node'] = self.cluster_node.get()
self.result['PBS_ppn'] = self.cluster_ppn.get()
self.result['PBS_cput'] = str(self.h_cput.get()) + ":" \
+ str(self.m_cput.get()) + ":" \
+ str(self.s_cput.get())
self.result['PBS_mem'] = self.job_mem.get()
def sequence(self):
"""
Bind the dialog window with only 'Echap'
(delete sequence 'Return', because of the Tix.Control.entry).
"""
self.bind("<Escape>", self.cancel)
#-------------------------------------------------------------------------------
# Popup window class: Cluster job management
#-------------------------------------------------------------------------------
class LSFJobManagementDialog(Dialog.Dialog):
"""
All dirty stuff is done by the Dialog module
"""
def jobName(self, entry, event=None):
"""
Delete blank in the job name
"""
v = string.join(string.split(self.job_name.get()),'_')
self.job_name.set(v)
entry.selection_range(0,END)
entry.config(selectbackground='green')
def getValue(self, entry, var, step=None, event=None):
"""
Incremente, decremente and colorize the input argument entry
"""
if step:
v= var.get()
var.set(v+step)
entry.config(selectbackground='green')
entry.selection_range(0,END)
def body(self, master):
"""
Processors number and list selection.
"""
# Main initialization
#
t = PageText()
# Variables declaration
#
self.job_name = Tix.StringVar()
self.cput = Tix.IntVar()
self.cpuT = Tix.IntVar()
self.job_mem = Tix.IntVar()
# Popup window layout
#
lf = Tix.LabelFrame(master, bd=2, label=t.JOB, relief=FLAT)
lf.label.config(font=fT)
lf.pack(side=TOP, expand=YES, padx=5, pady=5)
f = lf.frame
f1 = Tix.Frame(f, bd=2, relief=FLAT)
f1.pack(side=TOP, anchor=W)
le = Tix.LabelEntry(f1, bd=2, label=t.JOB_NAME)
le.entry.config(width=20, textvariable = self.job_name)
le.entry.bind('<Return>', TkPage.Callback(self.jobName,le.entry))
le.grid(row=0, column=0, sticky=W, padx=5, pady=10)
f2 = Tix.Frame(f, bd=2, relief=FLAT)
f2.pack(side=TOP, anchor=W)
e1=[0]*3
M=[999999,3600,999999]
S=[100,10,10]
for (num, var, tt) in [(0, self.cput, t.CPU_TIME2) ,
(1, self.cpuT, t.CPU_TIME_SUP),
(2, self.job_mem, t.JOB_MEM) ]:
e1[num] = Tix.Control(f2, label=tt, bd=2,
value='1', min=1, max=M[num], step=S[num],
integer=1, selectmode='normal',
variable=var)
e1[num].entry.config(width=10)
e1[num].entry.bind('<Return>',TkPage.Callback(self.getValue, e1[num].entry, var, 0))
e1[num].decr.bind('<Button-1>',TkPage.Callback(self.getValue, e1[num].entry, var, -S[num]))
e1[num].incr.bind('<Button-1>',TkPage.Callback(self.getValue, e1[num].entry, var, S[num]))
e1[num].grid(row=num, column=0, padx=5, pady=10, sticky=W)
# Previous values
#
try:
self.job_name.set(self.default['job_name'])
self.cput.set(self.default['NQS_cput'])
self.cpuT.set(self.default['NQS_cpuT']-self.default['NQS_cput'])
self.job_mem.set(self.default['NQS_mem'])
except:
pass
def apply(self):
"""
What to do when user clicks on 'OK'.
"""
self.result = {}
self.result['job_name'] = self.job_name.get()
self.result['NQS_cput'] = self.cput.get()
self.result['NQS_cpuT'] = self.cpuT.get()
self.result['NQS_mem'] = self.job_mem.get()
def sequence(self):
"""
Bind the dialog window with only 'Echap'
(delete sequence 'Return', because of the Tix.Control.entry).
"""
self.bind("<Escape>", self.cancel)
#-------------------------------------------------------------------------------
# Popup advanced options
#-------------------------------------------------------------------------------
class AdvancedOptionsDialog(Dialog.Dialog):
"""
"""
def getOptions(self, num, var, tt, event=None):
"""
Input advanced options.
"""
self.check.begin(self.eopt[num])
if not self.check.isAscii(self.eopt[num],var.get()): var.set('')
def getModeExe(self, event=None):
"""
Input execution mode option.
"""
self.mode_exe.get()
def setOptimisation(self, event=None):
"""
Put optimisation option.
"""
self.optimise.set(self.default['OPTIMISATION'])
if self.default['OPTIMISATION'] == '': self.optimise.set('none')
def getOptimisation(self, event=None):
"""
Input advanced options.
"""
self.opt = ''
self.opt = self.optimise.get()
if self.optimise.get() == 'none': self.opt = ''
return self.opt
def setArgCsVerif(self):
"""
Put ARG_CS_VERIF option from "lance" file.
"""
if self.default['ARG_CS_VERIF'] == '': self.arg_cs_verif.set('standard')
if self.default['ARG_CS_VERIF'] == '0': self.arg_cs_verif.set('mesh_quality')
if self.default['ARG_CS_VERIF'] == '1': self.arg_cs_verif.set('imrgra0')
if self.default['ARG_CS_VERIF'] == '2': self.arg_cs_verif.set('imrgra1')
if self.default['ARG_CS_VERIF'] == '3': self.arg_cs_verif.set('imrgra2')
if self.default['ARG_CS_VERIF'] == '4': self.arg_cs_verif.set('imrgra3')
if self.default['ARG_CS_VERIF'] == '5': self.arg_cs_verif.set('imrgra4')
def getArgCsVerif(self, event=None):
"""
Input ARG_CS_VERIF option.
"""
self.val_verif =''
arg_verif = self.arg_cs_verif.get()
if arg_verif == 'standard': self.val_verif = ''
if arg_verif == 'mesh_quality': self.val_verif = "0"
if arg_verif == 'imrgra0': self.val_verif = "1"
if arg_verif == 'imrgra1': self.val_verif = "2"
if arg_verif == 'imrgra2': self.val_verif = "3"
if arg_verif == 'imrgra3': self.val_verif = "4"
if arg_verif == 'imrgra4': self.val_verif = "5"
return self.val_verif
def setArgCsOutput(self):
"""
Put ARG_CS_OUTPUT options from "lancer" file.
"""
self.val_output = self.default['ARG_CS_OUTPUT']
if self.default['ARG_CS_OUTPUT'] == '':
self.arg_cs_out1.set('listing')
self.arg_cs_out2.set('shunte')
else:
list = self.default['ARG_CS_OUTPUT'].split()
l1 = 0
l2 = 0
for n in range(len(list)):
if list[n] == '--log':
l1 = 1
if list[n+1] == '0': self.arg_cs_out1.set('standard')
if list[n+1] == '1': self.arg_cs_out1.set('listing')
if list[n] == '--logp':
l2 = 1
if list[n+1] == '0': self.arg_cs_out2.set('standard')
if list[n+1] == '1': self.arg_cs_out2.set('listing')
if list[n+1] == '-1': self.arg_cs_out2.set('shunte')
if l1 == 0: self.arg_cs_out1.set('listing')
if l2 == 0: self.arg_cs_out2.set('shunte')
def getArgCsOutput(self, event=None):
"""
Input ARG_CS_OUTPUT options.
"""
self.val_output =''
out1 = ''
out2 = ''
arg_out1 = self.arg_cs_out1.get()
arg_out2 = self.arg_cs_out2.get()
if arg_out1 == 'listing': out1 = ''
if arg_out1 == 'standard': out1 = '--log 0'
if arg_out2 == 'shunte': out2 = ''
if arg_out2 == 'standard': out2 = '--logp 0'
if arg_out2 == 'listing': out2 = '--logp 1'
self.val_output = out1 + ' ' + out2
def searchDir(self, event=None):
"""
Choice temporary directory for batch
"""
t = PageText()
self.dir_name =''
path_case = os.getcwd()
self.dir_name = Dialog.dirselect(self.master,
stbar=self.stbar,
title=t.SELECT_DIR,
default=path_case)
if self.dir_name:
self.exe_name.set(self.dir_name)
## self._scrollHandler(self.edir, "moveto", 1)
self._scrollHandler(self.eopt[0], "moveto", 1)
else:
self.exe_name.set('')
return self.dir_name
def searchFile(self, event=None):
"""
Choice temporary directory for batch
"""
t = PageText()
file_name = ""
tk_fopen = tkFileDialog.askopenfilename
file_name = tk_fopen(title=t.NEW_FILE,
initialdir=os.getcwd(),
filetypes=[("All files","*")])
if file_name:
if not self.valgrind.get():
new = file_name + " --tool=memcheck"
else:
new = ""
for i in string.split(self.valgrind.get()):
if i == string.split(self.valgrind.get())[0]:
i = file_name
new = new + i + ' '
self.valgrind.set(new)
def body(self,master):
"""
Creation of popup window's widgets
"""
t = PageText()
self.mode_exe = Tix.StringVar()
self.optimise = Tix.StringVar()
self.valgrind = Tix.StringVar()
self.list_lib_sat = Tix.StringVar()
self.opt_lib_ext = Tix.StringVar()
self.arg_cs_output = Tix.StringVar()
self.arg_cs_out1 = Tix.StringVar()
self.arg_cs_out2 = Tix.StringVar()
self.arg_cs_verif = Tix.StringVar()
self.exe_name = Tix.StringVar()
self.check = AsciiValidator()
# Options OPTIMISATION, VALGRIND, LISTE_LIB_SAT, et OPTION_LIB_EXT
w = Tix.Frame(master, relief=FLAT)
w.pack(side=TOP, fill=X, padx=10, pady=10)
lab=[0]*6
self.eopt=[0]*6
for (num, var, tt) in [(0, self.exe_name , t.EXE_NAME ),
(1, self.mode_exe , t.MODE_EXEC),
(2, self.optimise , 'OPTIMISATION'),
(3, self.valgrind , 'VALGRIND'),
(4, self.list_lib_sat , t.LISTE_LIB_SAT),
(5, self.opt_lib_ext , t.OPTION_LIB_EXT)]:
lab[num] = Tix.Label(w, text=tt)
lab[num].grid(row=num, column=0, padx=10, pady=5, sticky=W)
if num >= 3:
self.eopt[num] = Tix.Entry(w, bd=2, width=40, textvariable=var)
self.eopt[num].grid(row=num, column=1, padx=5, pady=10, sticky=W)
self.eopt[num].event_add("<<Event1>>", "<Return>", "<Leave>", "<FocusOut>")
self.eopt[num].bind("<<Event1>>", TkPage.Callback(self.getOptions, num, var, tt))
if num == 0:
self.eopt[num] = Tix.Entry(w, bd=1, width=40, textvariable=self.exe_name)
self.eopt[num].grid(row=0, column=1, padx=10, pady=10, sticky=W)
self.eopt[num].event_add("<<E>>", "<Return>", "<Leave>", "<FocusOut>")
# Search directory in list
self.img_dir = Tix.PhotoImage(file=PIC_PATH+'search1.gif')
bdir = Tix.Button(w, image=self.img_dir, command=self.searchDir)
bdir.grid(row=0, column=2, padx=3)
self.balloon.bind_widget(bdir, balloonmsg=t.MSG_CASE_DIR)
if num == 1:
self.eopt[num] = Tix.OptionMenu(w)
self.eopt[num].menubutton.config(width=36, height=0, bd=2, relief=RAISED)
self.eopt[num].grid(row=num, column=1, padx=0, pady=10)
self.eopt[num].add_command('complet', label=t.COMPLET)
self.eopt[num].add_command('pre-traitement', label=t.PRETRAIT)
self.eopt[num].add_command('calcul', label=t.CALCUL)
self.eopt[num].config(variable=var,command=self.getModeExe)
if num == 2:
self.eopt[num] = Tix.OptionMenu(w)
self.eopt[num].menubutton.config(width=36, height=0, bd=2, relief=RAISED)
self.eopt[num].grid(row=num, column=1, padx=0, pady=10)
self.eopt[num].add_command('none', label=t.NONE)
self.eopt[num].add_command('LO', label='low option (LO)')
self.eopt[num].add_command('DBG', label='-g compilation debug option (DBG)')
self.eopt[num].add_command('EF', label='Electric Fence (EF)')
self.eopt[num].add_command('PROF', label='profiling (PROF)')
self.eopt[num].config(variable=var, command=self.getOptimisation)
if num == 3:
bopt = Tix.Button(w, image=self.img_dir, command=self.searchFile)
bopt.grid(row=num, column=2, padx=3)
self.balloon.bind_widget(bopt, balloonmsg=t.MSG_CASE_FILE)
#for ARG_CS_VERIF
larg_verif = Tix.Label(w, text=t.ARG_CS_VERIF)
larg_verif.grid(row=6, column=0, padx=10, pady=5, sticky=W)
self.arg_verif = Tix.OptionMenu(w)
self.arg_verif.menubutton.config(width=36, height=0, bd=2, relief=RAISED)
self.arg_verif.grid(row=6, column=1, padx=0, pady=0)
self.arg_verif.add_command('standard', label=t.JOB_STD)
self.arg_verif.add_command('mesh_quality', label=t.QUALITY_MESH)
self.arg_verif.add_command('imrgra0', label=t.IMRGRA0)
self.arg_verif.add_command('imrgra1', label=t.IMRGRA1)
self.arg_verif.add_command('imrgra2', label=t.IMRGRA2)
self.arg_verif.add_command('imrgra3', label=t.IMRGRA3)
self.arg_verif.add_command('imrgra4', label=t.IMRGRA4)
self.arg_verif.config(variable=self.arg_cs_verif,command=self.getArgCsVerif)
#for ARG_CS_OUTPUT
warg_out = Tix.LabelFrame(master, bd=2, label=t.ARG_CS_OUTPUT, relief=FLAT)
warg_out.label.config(font=fT)
warg_out.pack(side=TOP, fill=X, padx=10, pady=10)
larg_out1 = Tix.Label(warg_out.frame, text=t.ARG_CS_OUT1)
larg_out1.grid(row=0, column=0, padx=10, pady=10, sticky=W)
self.arg_out1 = Tix.OptionMenu(warg_out.frame)
self.arg_out1.menubutton.config(width=25, height=0, bd=2, relief=RAISED)
self.arg_out1.grid(row=0, column=1, padx=0, pady=10)
self.arg_out1.add_command('standard', label=t.STANDARD)
self.arg_out1.add_command('listing', label=t.LISTING)
self.arg_out1.config(variable=self.arg_cs_out1,command=self.getArgCsOutput)
larg_out2 = Tix.Label(warg_out.frame, text=t.ARG_CS_OUT2)
larg_out2.grid(row=1, column=0, padx=10, pady=10, sticky=W)
self.arg_out2 = Tix.OptionMenu(warg_out.frame)
self.arg_out2.menubutton.config(width=25, height=0, bd=2, relief=RAISED)
self.arg_out2.grid(row=1, column=1, padx=0, pady=10)
self.arg_out2.add_command('shunte', label=t.SHUNTE)
self.arg_out2.add_command('standard', label=t.STANDARD)
self.arg_out2.add_command('listing', label=t.LISTING)
self.arg_out2.config(variable=self.arg_cs_out2,command=self.getArgCsOutput)
# Previous values
#
self.mode_exe.set(self.default['MODE_EXEC'])
self.setOptimisation()
self.valgrind.set(self.default['VALGRIND'])
self.list_lib_sat.set(self.default['LISTE_LIB_SAT'])
self.opt_lib_ext.set(self.default['OPTION_LIB_EXT'])
self.setArgCsVerif()
self.setArgCsOutput()
self.exe_name.set(self.default['CS_TMP_PREFIX'])
self.dir_name = self.default['CS_TMP_PREFIX']
self.eopt[0].config(state=DISABLED, bg='white')
def apply(self):
"""
What to do when user clicks on 'OK'.
"""
self.result = {}
self.result['MODE_EXEC'] = self.mode_exe.get()
self.result['OPTIMISATION'] = self.opt
self.result['VALGRIND'] = self.valgrind.get()
self.result['LISTE_LIB_SAT'] = self.list_lib_sat.get()
self.result['OPTION_LIB_EXT']= self.opt_lib_ext.get()
self.result['ARG_CS_OUTPUT'] = self.val_output
self.result['ARG_CS_VERIF'] = self.val_verif
self.result['CS_TMP_PREFIX'] = self.dir_name
def sequence(self):
"""
Bind the dialog window with only 'Echap'
(delete sequence 'Return', because of the Tix.Control.entry).
"""
self.bind("<Escape>", self.cancel)
#-------------------------------------------------------------------------------
# Main class : BatchRunning
#-------------------------------------------------------------------------------
class BatchRunning(TkPage.Page):
"""
This class is devoted to the Computer selection.
When a new computer is selected, The old data frame is deleted and
a new apropriate frame is open.
If the batch script file name is known, informations are display
in the apropiate widget.
"""
def _tkControlVariables(self):
"""
Tkinter variables declaration.
"""
self.computer = Tix.StringVar()
self.IAsize = Tix.IntVar()
self.RAsize = Tix.IntVar()
self.num_cpu = Tix.IntVar()
def _pageControl(self):
"""
"""
# Computers list
#
t = PageText()
self.computerList = [(0, 'station', t.WORKSTATION),
(1, 'cluster', t.CLUSTER) ]
if not self.case['batchScript']:
self.case['batchScript'] = {'station': "" ,
'cluster': "" }
if not self.case['backupBatchScript']:
self.case['backupBatchScript'] = {'station': "no" ,
'cluster': "no" }
def getBatchScriptFileDefaultValues(self):
"""
Extract informations from the batch script file.
"""
self.stbar.busy()
dico = self.mdl.dicoValues
for (valword, var) in [(dico['LONGIA'], self.IAsize),
(dico['LONGRA'], self.RAsize),
(dico['NOMBRE_DE_PROCESSEURS'], self.num_cpu)]:
var.set(valword)
self.stbar.idle()
def verifyBoundariesDefinitions(self, param):
"""
Check if boundaries definitions are in xml file param.
"""
self.stbar.busy()
t = PageText()
from DefineBoundaryRegions import DefBCModel
refList, groupList = DefBCModel(self.case).getLists()
del DefBCModel
if refList or groupList:
pass
else:
if self.case['no_boundary_conditions'] == 0:
Dialog.Warning(self.master, title=t.WARNING, text=t.MSG_NOCL)
self.case['no_boundary_conditions'] = 1
self.stbar.idle()
def getSize(self, num, var, event=None):
"""
Check the validity of 'LONGIA' and 'LONGRA' input.
"""
self.stbar.busy()
if self.check2.isPositive(self.e1[num], var):
if num:
self.mdl.dicoValues['LONGRA'] = self.RAsize.get()
self.mdl.updateBatchScriptFile('LONGRA')
else:
self.mdl.dicoValues['LONGIA'] = self.IAsize.get()
self.mdl.updateBatchScriptFile('LONGIA')
self.stbar.idle()
def getParallelComputing(self, entry, step=None, event=None):
"""
Incremente, decremente and colorize the input argument entry
"""
if step:
v= self.num_cpu.get()
self.num_cpu.set(v+step)
self.mdl.dicoValues['NOMBRE_DE_PROCESSEURS'] = self.num_cpu.get()
self.mdl.updateBatchScriptFile('NOMBRE_DE_PROCESSEURS')
entry.config(selectbackground='green')
entry.selection_range(0,END)
def pbsJobManagement(self, event=None):
"""
Get PBS card informations.
"""
t = PageText()
self.stbar.busy()
default = {}
default['job_name'] = self.mdl.dicoValues['PBS_JOB_NAME']
default['PBS_node'] = self.mdl.dicoValues['PBS_nodes']
default['PBS_ppn'] = self.mdl.dicoValues['PBS_ppn']
default['PBS_cput'] = self.mdl.dicoValues['PBS_walltime']
default['PBS_mem'] = self.mdl.dicoValues['PBS_mem']
dialog = PBSJobManagementDialog(self.myPage, title=t.CLUSTER, default=default)
self.mdl.dicoValues['PBS_JOB_NAME'] = dialog.result['job_name']
self.mdl.dicoValues['PBS_nodes'] = dialog.result['PBS_node']
self.mdl.dicoValues['PBS_ppn'] = dialog.result['PBS_ppn']
self.mdl.dicoValues['PBS_walltime'] = dialog.result['PBS_cput']
self.mdl.dicoValues['PBS_mem'] = dialog.result['PBS_mem']
self.mdl.updateBatchScriptFile()
self.stbar.idle()
def lsfJobManagement(self, event=None):
"""
Get NQS card informations
"""
pass
## t = PageText()
## self.stbar.busy()
##
## default = {}
## default['job_name'] = self.mdl.dicoValues['PBS_JOB_NAME']
## default['NQS_cput'] =
## default['NQS_cpuT'] =
## default['NQS_mem'] =
## dialog = LSFJobManagementDialog(self.myPage, title=t.CATHY, default=default)
##
## self.job_name = dialog.result['job_name']
## self.NQS_cpult = dialog.result['NQS_cput']
## self.NQS_cpulT = dialog.result['NQS_cpuT'] + dialog.result['NQS_cput']
## self.job_memory = dialog.result['NQS_mem']
##
## self.mdl.updateBatchScriptFile()
##
## self.stbar.idle()
##
def getUserFiles(self, event=None):
"""
Input 'FICHIERS_DONNEES_UTILISATEUR' and 'FICHIERS_RESULTATS_UTILISATEUR'
"""
t = PageText()
self.stbar.busy()
default = {}
default['data_path'] = ""
default['data_path'] = self.case['data_path']
default['data'] = string.split(self.mdl.dicoValues['FICHIERS_DONNEES_UTILISATEUR'])
default['results'] = string.split(self.mdl.dicoValues['FICHIERS_RESULTATS_UTILISATEUR'])
dialog = UserFilesDialog(self.myPage, title=t.USER_FILES, default=default)
self.mdl.dicoValues['FICHIERS_DONNEES_UTILISATEUR'] = string.join(dialog.result['data'])
self.mdl.dicoValues['FICHIERS_RESULTATS_UTILISATEUR'] = string.join(dialog.result['results'])
self.mdl.updateBatchScriptFile('FICHIERS_DONNEES_UTILISATEUR')
self.mdl.updateBatchScriptFile('FICHIERS_RESULTATS_UTILISATEUR')
self.stbar.idle()
def getAdvancedOptions(self, event=None):
"""
Ask one popup for advanced specifications
"""
t=PageText()
self.stbar.busy()
default = {}
for option in ['MODE_EXEC',
'OPTIMISATION',
'VALGRIND',
'LISTE_LIB_SAT',
'OPTION_LIB_EXT',
'ARG_CS_OUTPUT',
'ARG_CS_VERIF',
'CS_TMP_PREFIX']:
default[option] = self.mdl.dicoValues[option]
dialog = AdvancedOptionsDialog(self.master, title=t.OPTIONS,
stbar=self.stbar, default=default)
for option in ['MODE_EXEC',
'OPTIMISATION',
'VALGRIND',
'LISTE_LIB_SAT',
'OPTION_LIB_EXT',
'ARG_CS_OUTPUT',
'ARG_CS_VERIF',
'CS_TMP_PREFIX']:
self.mdl.dicoValues[option] = dialog.result[option]
self.mdl.updateBatchScriptFile(option)
self.stbar.idle()
def batchRunning(self, event=None):
"""
Launch Code_Saturne batch running.
"""
t = PageText()
self.stbar.busy()
# Test 1: is the file saved?
#
if self.case['new'] == "yes" or Tool.GuiParam.saved == "no":
Dialog.ShowInfo (self.master, title=t.WARNING, text=t.CASE_NOT_SAVED)
self.stbar.idle()
return
# FIXME: self.case["saved"] = "no" for all set method in model classes
self.case.xmlSaveDocument()
self.mdl.dicoValues['PARAM'] = os.path.basename(self.case['xmlfile'])
self.mdl.updateBatchScriptFile('PARAM')
# Test 2: have we a mesh?
#
if not Tool.GuiParam.matisse :
node_ecs = self.case.xmlGetNode('solution_domain')
if not node_ecs.xmlGetNode('meshes_list'):
if not node_ecs.xmlGetNode('meshes_list').xmlGetNodeList('mesh'):
Dialog.ShowInfo (self.master, title=t.WARNING, text=t.MSG_NOMESH)
self.stbar.idle()
return
# Test 3: have we a trouble with the mesh generation?
#
if Tool.GuiParam.matisse :
import Pages.Matisse as Matisse
if not Matisse.MatisseMeshRunning(self.case).ok :
Dialog.Warning(self.master, title=t.WARNING, text= t.MESHW)
return
# Command line
#
key = self.case['computer']
script = self.case['scripts_path'] + "/" + self.case['batchScript'][key]
batch1 = self.case['scripts_path'] + "/" + "batch"
batch2 = batch1 + '~'
## self.mdl.updateBatchScriptFile()
# Verify if boundaries definitions exist
#
if not Tool.GuiParam.matisse:
param = os.path.basename(self.case['xmlfile'])
if param:
self.verifyBoundariesDefinitions(param)
if key == 'station':
try:
os.rename(batch1, batch2)
except:
pass
cmd = 'nice nohup ' + script + ' | tee ' + batch1 + ' &'
elif key == 'cluster':
#cmd = 'qsub ' + script + ' ' + self.case['batchScript'][key] + ' &'
cmd = 'qsub ' + script
elif key == 'cathy':
cmd = 'sub ca cs ' + script + ' ' + self.case['batchScript'][key] + ' &'
os.system(cmd)
self.stbar.idle()
def displayBatchScriptInfo(self):
"""
Layout of the second part of this page.
"""
self.stbar.busy()
t = PageText()
self.lf2.pack(side=TOP, fill=X, padx=10, pady=5)
self.f3.pack_forget()
self.f3_2.pack_forget()
self.f3p.pack_forget()
self.sepo.pack_forget()
self.fopt.pack_forget()
self.sep2.pack_forget()
self.f5.pack_forget()
self.l3[0].grid_forget()
self.l3[1].grid_forget()
self.lsb.grid_forget()
self.sb.grid_forget()
self.b1[0].grid_forget()
self.b1[1].grid_forget()
if hasattr(self, 'mdl'):
del self.mdl
self.mdl = BatchRunningModel(self.case)
self.mdl.readBatchScriptFile()
self.nameFile1.grid(row=0, column=2, sticky=E)
name = self.case['batchScript'][self.computer.get()]
self.nameFile1.config(text = name, font=fB)
if self.case['computer'] == "station":
if Tool.GuiParam.matisse :
self.f3p.pack(side=TOP, padx=64, anchor=W)
else:
self.f3.pack(side=TOP, padx=72, anchor=W)
self.f3p.pack(side=TOP, padx=64, anchor=W)
self.lsb.grid(row=0, column=0, padx=0, pady=2, sticky=W)
self.sb.grid(row=0, column=1, padx=26, pady=1, sticky=W)
else:
for (i, comput, txt, imag, msg, cmd) in \
[(0, "cluster", t.JOB, 'cluster.gif', t.CLUSTER_INFO, self.pbsJobManagement),
(1, "ccrt", t.JOB, 'cathy.gif' , t.CLUSTER_INFO, self.lsfJobManagement)]:
self.f3_2.pack(side=TOP, padx=66, anchor=W)
self.f3p.pack(side=TOP, padx=66, anchor=W)
self.l3[i].grid(row=0, column=0, padx=10, pady=2, sticky=W)
self.b1[i].grid(row=0, column=1, padx=66, pady=1, sticky=W)
self.sepo.pack(side=TOP, fill=X, pady=10)
self.fopt.pack(side=TOP, padx=66, anchor=W)
self.sep2.pack(side=TOP, fill=X, pady=10)
self.f5.pack(side=TOP, fill=X, padx=10, pady=0)
self.getBatchScriptFileDefaultValues()
self.mdl.updateBatchScriptFile()
self.stbar.idle()
def getBatchAnalysis(self, event=None):
"""
1) Look if the batch script file name is allready known
for the current computer
2) Display the apropriate frame for the selected computer
"""
self.stbar.busy()
self.lf2.pack_forget()
key = self.computer.get()
self.case['computer'] = key
self.lab.config(state=NORMAL)
if self.case['batchScript'].has_key(key) and self.case['batchScript'][key]:
self.displayBatchScriptInfo()
else:
self.nameFile1.grid_forget()
self.stbar.idle()
def searchBatchScriptFile(self, event=None):
"""
Open a FileDialog in order to search the batch script file
in the system file.
"""
t = PageText()
self.stbar.busy()
self.stbar.set(t.MSG_LAUNCHER + self.case['scripts_path'] +")")
file_name = ""
tk_fopen = tkFileDialog.askopenfilename
if self.case['scripts_path'] and os.path.isdir(self.case['scripts_path']):
dir = self.case['scripts_path']
else:
dir = os.getcwd()
file_name = tk_fopen (title=t.LAUNCHER_SELECT,
initialdir=dir,
filetypes=[("All files","*")])
if file_name:
launcher = os.path.basename(file_name)
if self.case['scripts_path'] == os.path.dirname(file_name):
key = self.computer.get()
if self.case['batchScript'].has_key(key):
self.case['batchScript'][key] = launcher
else:
print "Warning: searchBatchScriptFile\n Error with key:", key
self.displayBatchScriptInfo()
else:
t = PageText()
tkMessageBox.showwarning(t.WARNING, t.MSG_SCRIPTS + t.MSG_IDENTITY)
self.stbar.clear()
self.stbar.force_idle()
def _createWidgets(self):
"""
Create the Page layout.
"""
#### Beginning of the page #####
####
t = PageText()
# -1) Mother frame for layout
#
self.lf1 = Tix.LabelFrame(self.myPage, bd=2,
label=t.ARCH_SELECT, relief=FLAT)
self.lf1.label.config(font=fT)
self.lf1.pack(side=TOP, fill=X, padx=10, pady=5)
# 0) Plateform selection between Workstation/Cluster/CaThy
#
#self.r = [0]*3
self.l = [0]*3
f0 = Tix.Frame(self.lf1.frame, relief=FLAT)
f0.pack(side=TOP, fill=X, padx=10, pady=10)
self.b = Tix.OptionMenu(f0)
self.b.menubutton.config(width=28, bd=2, relief=RAISED)
self.b.grid(row=0, column=0, padx=15, pady=5)
self.balloon.bind_widget(self.b, statusmsg=t.MSG_MACHIN,
balloonmsg=t.KEYWORD+'ARCH')
self.b.add_command('station', label=t.WORKSTATION)
self.b.add_command('cluster', label=t.CLUSTER)
self.b.add_command('ccrt', label=t.CCRT, state=DISABLED)
self.b.config(variable=self.computer,command=self.getBatchAnalysis)
# 1) separator
#
Tix.Frame(self.lf1.frame, height=2, bd=2, relief=SUNKEN).pack(side=TOP, fill=X)
# 1) label
#
f1 = Tix.Frame(self.lf1.frame, relief=FLAT)
f1.pack(side=TOP, fill=X)
self.lab = Tix.Label(f1, text=t.LAUNCHER)
self.lab.grid(row=0, column=0, sticky=W, padx=10, pady=10)
self.balloon.bind_widget(self.lab,
statusmsg=t.MSG_LAUNCHER + self.case['scripts_path'] +")")
# 2) Search button
#
self.imgsf = Tix.PhotoImage(file=PIC_PATH+'search1.gif')
self.bsf = Tix.Button(f1, image=self.imgsf,
command=self.searchBatchScriptFile)
self.bsf.grid(row=0, column=1, sticky=E, padx=10, pady=10)
self.balloon.bind_widget(self.bsf, balloonmsg=t.LAUNCHER_SELECT)
# 2.1) File name
#
self.nameFile1 = Tix.Label(f1)
#### Follwing of the page for reading of parameters #####
#### for Batch Analysis
#
# 0) Mother frame for layout
#
self.lf2 = Tix.LabelFrame(self.myPage, bd=2, label=t.BATCH_TITLE, relief=FLAT)
self.lf2.label.config(font=fT)
self.lf2.pack(side=TOP, fill=X, padx=10, pady=10)
self.f2 = Tix.Frame(self.lf2.frame, relief=FLAT)
#self.f2.pack(side=TOP, anchor=W, pady=5)
self.f2.pack(side=TOP, fill=X, pady=5)
# 1) Integer and Float array size
#
l1=[0]*2
self.e1=[0]*2
for (num, var, tt) in [(0, self.IAsize, t.LONGIA),
(1, self.RAsize, t.LONGRA)]:
l1 = Tix.Label(self.f2, text=tt)
l1.grid(row=num, column=0, padx=10, pady=2, sticky=W)
self.e1[num] = Tix.Entry(self.f2, bd=2, width=15, textvariable=var)
self.e1[num].grid(row=num, column=1, padx=5, pady=2, sticky=W)
self.e1[num].event_add("<<Event1>>", "<Return>", "<Leave>", "<FocusOut>")
self.e1[num].bind("<<Event1>>", TkPage.Callback(self.getSize, num, var))
# 2) Parallel computing
#
self.f3 = Tix.Frame(self.lf2.frame, relief=FLAT)
self.f3.pack(side=TOP, anchor=W)
self.f3_2 = Tix.Frame(self.lf2.frame, relief=FLAT)
self.f3_2.pack(side=BOTTOM, anchor=W)
self.lsb = Tix.Label(self.f3, text=t.NUM_OF_CPU)
self.lsb.grid(row=0, column=0, padx=10, pady=2, sticky=W)
self.sb = Tix.Control(self.f3, bd=2,
value='1', min=1, max=32,
integer=1, selectmode='normal',
variable=self.num_cpu)
self.sb.entry.config(width=3)
self.sb.entry.bind('<Return>',TkPage.Callback(self.getParallelComputing, self.sb.entry, 0))
self.sb.decr.bind('<Button-1>',TkPage.Callback(self.getParallelComputing, self.sb.entry, -1))
self.sb.incr.bind('<Button-1>',TkPage.Callback(self.getParallelComputing, self.sb.entry, 1))
self.sb.grid(row=0, column=1, columnspan=2, padx=10, pady=10, sticky=W)
self.l3 = [0]*2
self.img1 = [0]*2
self.b1 = [0]*2
for (i, comput, txt, imag, msg, cmd) in \
[(0, "cluster", t.JOB, 'cluster.gif', t.CLUSTER_INFO, self.pbsJobManagement),
(1, "ccrt", t.JOB, 'cathy.gif', t.CLUSTER_INFO, self.lsfJobManagement)]:
self.l3[i] = Tix.Label(self.f3_2, text=txt)
self.l3[i].grid(row=0, column=0, padx=0, pady=2, sticky=W)
self.img1[i] = Tix.PhotoImage(file=PIC_PATH+imag)
self.b1[i] = Tix.Button(self.f3_2, image=self.img1[i], command=cmd)
self.b1[i].grid(row=0, column=1, padx=55, pady=1, sticky=W)
self.balloon.bind_widget(self.b1[i], balloonmsg=msg)
# 3) User files
#
self.f3p = Tix.Frame(self.lf2.frame, relief=FLAT)
self.f3p.pack(side=TOP, anchor=W)
l4 = Tix.Label(self.f3p, text=t.USER_FILES)
l4.grid(row=1, column=0, padx=10, pady=2, sticky=W)
self.img2 = Tix.PhotoImage(file=PIC_PATH+'chimie.gif')
self.b2 = Tix.Button(self.f3p, image=self.img2, command=self.getUserFiles)
self.b2.grid(row=1, column=1, padx=50, pady=1, sticky=W)
self.balloon.bind_widget(self.b2, balloonmsg=t.USER_FILES_INFO)
# 4) separator
#
self.sepo = Tix.Frame(self.lf2.frame, height=2, bd=2, relief=SUNKEN)
self.sepo.pack(side=TOP, fill=X)
# Advanced options
#
self.fopt = Tix.Frame(self.lf2.frame, relief=FLAT)
self.fopt.pack(side=TOP, fill = X, padx=10)
self.lop = Tix.Label(self.fopt, text=t.OPTIONS)
self.lop.grid(row=0, column=0, padx=10, sticky=W)
self.imsop = Tix.PhotoImage(file=PIC_PATH+'graduate.gif')
sop = Tix.Button(self.fopt, image=self.imsop,
command=self.getAdvancedOptions)
sop.grid(row=0, column=1, padx=50, sticky=E)
#self.balloon.bind_widget(sop, balloonmsg=t.POPUP)
# 5) separator
#
self.sep2 = Tix.Frame(self.lf2.frame, height=2, bd=2, relief=SUNKEN)
self.sep2.pack(side=TOP, fill=X)
# 6) Batch script update and Code_Saturne batch running
#
self.f5 = Tix.Frame(self.lf2.frame, relief=FLAT, bd=3)
self.f5.pack(side=TOP, fill=X, padx=10, pady=0)
self.b5 = Tix.Button(self.f5, text=t.BUTTON_EXE,
width=15, fg="red", font=fB,
highlightbackground="black")
self.b5.grid(row=0, column=0, padx=10, pady=10)
self.balloon.bind_widget(self.b5, statusmsg=t.SAVE_AND_EXE)
self.b5.config(command=self.batchRunning)
def _initializeWidgets(self):
"""
Extract resquested informations from the self.case.
This informations are used to initialize the widgets.
"""
# the selected computer is stored in self.case['computer']
#
#print "dans initiialis...",self.case['batchScript']
#if self.case['batchScript']:
# if self.case['batchScript'][self.case['computer']] == "":
# self.lf2.pack_forget()
# self.f2.pack_forget()
# self.f3.pack_forget()
# self.f3p.pack_forget()
if self.case['computer'] == "":
self.b.config(value='station')
self.case['computer'] = 'station'
else:
for (i,tx1,tx2) in self.computerList:
if self.case['computer'] == tx1:
self.b.config(value=tx1)
#-------------------------------------------------------------------------------
# Text and messages for this page
#-------------------------------------------------------------------------------
class PageText:
"""
Storage of all texts and messages for this page.
"""
def __init__(self):
# 1) Texts
#
if Tool.GuiParam.lang == 'fr':
self.ARCH_SELECT = "Sélection de la plateforme"
self.ARG_CS_OUTPUT = "Gestion des redirections des "\
"sorties (ARG_CS_OUTPUT)"
self.ARG_CS_OUT1 = "redirection pour calcul monoprocesseur ou pour le\n"\
"processeur de rang 0 d'un calcul parallèle (--log)"
self.ARG_CS_OUT2 = "redirection pour les processeurs de rang 1 à N-1 \n"\
"d'un calcul en parallèle sur N processeurs (--logp)"
self.ARG_CS_VERIF = "Tests élémentaires du maillage\n"\
"(ARG_CS_VERIF)"
self.BATCH_TITLE = "Exécution en arrière-plan"
self.BLANC = " "
self.BUTTON_EXE = "Exécution\nde\nCode_Saturne"
self.CALCUL = "Calcul seul"
self.CATHY = "CaThy"
self.CATHY_INFO = "Informations pour la carte NQS"
self.CCRT = "Gestion carte LSF (ccrt CEA)"
self.CLUSTER = "Gestion carte PBS (Cluster) "
self.CLUSTER_INFO = "Informations pour la carte PBS"
self.CL_NODES = "Nombre de noeuds"
self.COMPLET = "Calcul complet"
self.CL_PPN = "CPU par noeuds"
self.CPU_LIST = "Liste des processeurs"
self.CPU_TIME = "Temps de calcul :"
self.CPU_TIME2 = "Temps de calcul (s)"
self.CPU_TIME_SUP = "Temps pour le transfert des fichiers (s)"
self.DATA = "Données"
self.DELETE = "Effacer la sélection"
self.ERROR = "Erreur"
self.EXE_NAME = "Préfix du répertoire temporaire\n"\
" d'exécution (CS_TMP_PREFIX)"
self.IMRGRA0 = "Test du gradient en IMRGRA=0"
self.IMRGRA1 = "Test du gradient en IMRGRA=1"
self.IMRGRA2 = "Test du gradient en IMRGRA=2"
self.IMRGRA3 = "Test du gradient en IMRGRA=3"
self.IMRGRA4 = "Test du gradient en IMRGRA=4"
self.JOB = "Gestion du job "
self.JOB_NAME = "Nom du job"
self.JOB_MEM = "Mémoire (Mb)"
self.JOB_STD = "Pas de test"
self.KEYWORD = "Mot clé Code_Saturne : "
self.LAUNCHER = "Sélectionner le script de lancement"
self.LAUNCHER_SELECT = "Recherche du script de lancement"
self.LISTE_LIB_SAT = "Liste des bibliothèques internes pour\n"\
"édition de liens (LISTE_LIB_SAT)"
self.LISTING = "vers listing_n<N>"
self.LONGIA = "Taille du tableau d'entiers"
self.LONGRA = "Taille du tableau des réels"
self.MODE_EXEC = "Mode d'exécution (MODE_EXEC)"
self.NONE = "Pas d'option"
self.NEW_FILE = "Sélection du fichier d'exécution de VALGRIND"
self.NUM_OF_CPU = "Nombre de processeurs"
self.OPTIONS = "Options avancées"
self.OPTION_LIB_EXT = "Liste des bibliothèques externes pour\n"\
"édition de liens (OPTION_LIB_EXT)"
self.PARALL = "Calcul parallèle"
self.PARALL_INFO = "Nombre et liste des processeurs"
self.PATH_UNKNOWN1 = "Les répertoires suivants n'ont "\
"pas pu être renseignés :\n\n"
self.PRETRAIT = "Pré traitement"
self.QUALITY_MESH = "Critères de qualité du maillage"
self.RESU = "Résultats"
self.SAVE_AND_EXE = "Attention : enregistre automatiquement le cas courant"\
" avant d'exécuter Code_Saturne"
self.SCRIPTS = "Scripts d'exécution"
self.SELECT_DIR = "Sélectionnez un répertoire"
self.SHUNTE = "pas de sortie"
self.STANDARD = "vers sortie standard"
self.USER_DATA_LIST = "Sélection des fichiers de données"
self.USER_DATA_NEW = "Nouveaux fichiers :"
self.USER_FILES = "Fichiers utilisateur"
self.USER_FILES_INFO = "Sélection des fichiers de données\n "\
"et nom des fichiers de résultats"
self.USER_RESU_LIST = "Sélection des fichiers de résultats"
self.USER_RESU_NEW = "Nouveaux fichiers :"
self.USER_SRC = "Sous-programmes utilisateur"
self.WARNING = "Attention"
self.WORKSTATION = "Station de travail"
else:
self.ARCH_SELECT = "Computer Selection"
self.ARG_CS_OUTPUT = "Outputs redirections management (ARG_CS_OUTPUT)"
self.ARG_CS_OUT1 = "redirection for single processor job or for\n"\
"processor rank 0 of multi-processors job (--log)"
self.ARG_CS_OUT2 = "redirection for processors from rank 1 to N-1\n"\
"of multi-processors job (--logp)"
self.ARG_CS_VERIF = "Elementary tests of the mesh\n"\
"(ARG_CS_VERIF)"
self.BATCH_TITLE = "Prepare batch analysis"
self.BLANC = " "
self.BUTTON_EXE = "Code_Saturne\nbatch\nrunning"
self.CALCUL = "Only calculation"
self.CATHY = "CaThy"
self.CATHY_INFO = "NQS card informations"
self.CCRT = "management of chart LSF (CEA ccrt)"
self.CLUSTER = "management of chart PBS (Cluster)"
self.CLUSTER_INFO = "PBS card informations"
self.CL_NODES = "Nodes number"
self.CL_PPN = "CPU per node"
self.COMPLET = "Full job"
self.CPU_LIST = "Processors list"
self.CPU_TIME = "CPU time:"
self.CPU_TIME2 = "CPU time (s)"
self.CPU_TIME_SUP = "Time for file transfert (s)"
self.DATA = "Data"
self.DELETE = "Delete selection"
self.ERROR = "Error"
self.EXE_NAME = "Prefix of temporary directory of \n"\
" execution (CS_TMP_PREFIX)"
self.IMRGRA0 = "Test of the gradient in IMRGRA=0"
self.IMRGRA1 = "Test of the gradient in IMRGRA=1"
self.IMRGRA2 = "Test of the gradient in IMRGRA=2"
self.IMRGRA3 = "Test of the gradient in IMRGRA=3"
self.IMRGRA4 = "Test of the gradient in IMRGRA=4"
self.JOB = "Job management"
self.JOB_NAME = "Name of the job"
self.JOB_MEM = "Memory (Mb)"
self.JOB_STD = "Off"
self.KEYWORD = "Code_Saturne key word: "
self.LAUNCHER = "Select the batch script file"
self.LAUNCHER_SELECT = "Search the batch script"
self.LISTE_LIB_SAT = "List of internal libraries\n"\
"for link (LISTE_LIB_SAT)"
self.LISTING = "towards listing_n<N>"
self.LONGIA = "Integer array size "
self.LONGRA = "Float array size "
self.MODE_EXEC = "Execution mode (MODE_EXEC)"
self.NONE = "None"
self.NEW_FILE = "Select file for use VALGRIND option"
self.NUM_OF_CPU = "Number of processors "
self.OPTIONS = "Advanced options"
self.OPTION_LIB_EXT = "List of external libraries\n"\
"for link (OPTION_LIB_EXT)"
self.PARALL = "Parallel computing"
self.PARALL_INFO = "Number and list of processors"
self.PATH_UNKNOWN1 = "The following paths could not be given:\n\n"
self.PRETRAIT = "Without calculation"
self.QUALITY_MESH = "Quality criteria of the mesh"
self.RESU = "Results"
self.SAVE_AND_EXE = "Warning : save the current file automatically"\
" before Code_Saturne batch running"
self.SCRIPTS = "Run Scripts"
self.SELECT_DIR = "Select directory"
self.SHUNTE = "no output"
self.STANDARD = "towards standard output"
self.USER_DATA_LIST = "User data files selection"
self.USER_DATA_NEW = "New data files:"
self.USER_FILES = "User files "
self.USER_FILES_INFO = "Data files selection and\n "\
"results files name"
self.USER_RESU_LIST = "User results files selection"
self.USER_RESU_NEW = "New results files:"
self.USER_SRC = "User Subroutines"
self.WARNING = "Warning"
self.WORKSTATION = "Workstation"
# 2) Messages
#
if Tool.GuiParam.lang == 'fr':
self.MESHW = "Problème dans la génération du maillage. \n "\
"Voir le compte rendu d'execution 'listsim'"
self.CASE_NOT_SAVED= "Le cas courant doit être enregistré avant "\
"de pouvoir lancer l'exécution de Code_Saturne."
self.ERR_DATA_FILE = "Les fichiers de données utilisateur suivants "\
"ne sont pas dans le répertoire : \n\n"
self.MSG_ALLREADY = "Cette entrée est déjà enregistée " \
"dans la liste."
self.MSG_BLANK = "Donner un nom sans blanc ou accent"
self.MSG_CASE_DIR = "Sélectionner le répertoire temporaire d'exécution du cas"
self.MSG_CASE_FILE = "Sélectionner le fichier d'exécution de VALGRIND"
self.MSG_IDENTITY = "Vérifier l'existence et l'emplacement des fichiers, "\
"ainsi que la rubrique 'Identité et chemins'.\n\n"
self.MSG_LAUNCHER = "Le script de lancement est recherché dans "
self.MSG_MACHIN = "Sélectionner la machine sur laquelle le calcul "\
"sera éxécuté"
self.MSG_SCRIPTS = "Le nouveau fichier de script n'est pas dans "\
"le répertoire des fichiers de scripts indiqué "\
"dans la rubrique 'Identité et chemins'.\n\n"
self.MSG_NOMESH = "Vous devez sélectionner un maillage.\n\n"
self.MSG_NOCL = "Vous n'avez pas définis de conditions aux limites.\n\n"
else:
self.MESHW = "Mesh generation error. \n See the file 'listsim'"
self.CASE_NOT_SAVED= "The current case must be saved before "\
"Code_Saturne batch running."
self.ERR_DATA_FILE = "The following data files are not in the directory:\n\n"
self.MSG_ALLREADY = "This input is allready uploaded in the list."
self.MSG_BLANK = "Please, give a name without blank or accent"
self.MSG_CASE_DIR = "Select the batch temporary directory of the case"
self.MSG_CASE_FILE = "Select file for option VALGRIND"
self.MSG_IDENTITY = "Verify existence and location of these files, "\
"and the 'Identity and Pathes' rubric"
self.MSG_LAUNCHER = "The batch script file name is searched in "
self.MSG_MACHIN = "Select the calculator of running of calculation "
self.MSG_SCRIPTS = "The new batch script file is not in scripts "\
"directory given in the 'Identity and paths' "\
"rubric.\n\n"
self.MSG_NOMESH = "You have to select a mesh.\n\n"
self.MSG_NOCL = "No boundary definition declared.\n\n"
#-------------------------------------------------------------------------------
# End
#-------------------------------------------------------------------------------
syntax highlighted by Code2HTML, v. 0.9.1