# -*- 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
#
#-------------------------------------------------------------------------------
"""
This page is devoted to the time step management.
This module contains the following classes and function:
- TimeStepModel
- TimeStepView
"""
#-------------------------------------------------------------------------------
# Library modules import
#-------------------------------------------------------------------------------
import Tix
from Tkconstants import *
#-------------------------------------------------------------------------------
# Application modules import
#-------------------------------------------------------------------------------
from Base.Common import *
import Base.Toolbox as Tool
import Base.Dialog as Dialog
import Base.TkPage as TkPage
from Base.XMLvariables import Variables
#-------------------------------------------------------------------------------
# Time Step Model class
#-------------------------------------------------------------------------------
class TimeStepModel:
"""
Class to open the Time Step Page.
"""
def __init__(self, case):
"""
Constructor.
"""
self.case =case
self.node_models = self.case.xmlGetNode('thermophysical_models')
self.node_turb = self.node_models.xmlInitChildNode('turbulence')
self.node_control = self.case.xmlGetNode('analysis_control')
self.node_time = self.node_control.xmlInitNode('time_parameters')
Variables(self.case).setNewProperty(self.node_time, 'courant_number')
Variables(self.case).setNewProperty(self.node_time, 'fourier_number')
def defaultValues(self):
"""
Return in a dictionnary which contains default values
"""
default = {}
default['iterations'] = 10
default['time_passing'] = 0
default['time_step_ref'] = 0.1
default['max_courant_num'] = 1.0
default['max_fourier_num'] = 10.0
default['time_step_min'] = 0.1*default['time_step_ref']
default['time_step_max'] = 1000.0*default['time_step_ref']
default['time_step_var'] = 0.1
default['thermal_time_step'] = 'off'
default['zero_time_step'] = 'off'
return default
def getTimePassing(self):
"""
Get value of time_passing for node "time_parameters"
"""
tag = 'time_passing'
v = self.node_time.xmlGetInt(tag)
if v == None:
v = self.defaultValues()[tag]
self.setTimePassing(v)
from Turbulence import TurbulenceModel
model = TurbulenceModel(self.case).getTurbulenceModel()
del TurbulenceModel
if model in ('LES_Smagorinsky', 'LES_dynamique'):
v = 0
self.setTimePassing(v)
return v
def setTimePassing(self, val):
"""
Get value of time_passing for node "time_parameters"
"""
self.node_time.xmlSetData('time_passing', val)
if val in (1,2):
Variables(self.case).setNewProperty(self.node_time,
'local_time_step')
def getTimeStep(self):
"""
Get value of time_step_reference for node "time_parameters"
"""
tag = 'time_step_ref'
v = self.node_time.xmlGetDouble(tag)
if v == None:
v = self.defaultValues()[tag]
self.setTimeStep(v)
return v
def setTimeStep(self, val):
"""
Get value of time_step_reference for node "time_parameters"
"""
self.node_time.xmlSetData('time_step_ref', val)
def getIterationsNumber(self):
"""
Get number of iterations for node "time_parameters"
"""
tag = 'iterations'
v = self.node_time.xmlGetInt(tag)
if v == None:
v = self.defaultValues()[tag]
self.setIterationsNumber(v)
return v
def setIterationsNumber(self, val):
"""
Put number of iterations for node "time_parameters"
"""
self.node_time.xmlSetData('iterations', val)
def getMaxCourant(self):
"""
Return the max courant number allowed
"""
tag = 'max_courant_num'
return self.getOptions(tag)
def setMaxCourant(self, val):
"""
Input the max courant number allowed
"""
self.setOptions('max_courant_num', val)
def getMaxFourier(self):
"""
Return the max fourier number allowed
"""
tag = 'max_fourier_num'
return self.getOptions(tag)
def setMaxFourier(self, val):
"""
Input the max fourier number allowed
"""
self.setOptions('max_fourier_num', val)
def getTimeStepMin(self):
"""
Return the minimal time step
"""
tag = 'time_step_min'
return self.getOptions(tag)
def setTimeStepMin(self, val):
"""
Input the minimal time step
"""
self.setOptions('time_step_min', val)
def getTimeStepMax(self):
"""
Return the maximal time step
"""
tag = 'time_step_max'
return self.getOptions(tag)
def setTimeStepMax(self, val):
"""
Input the maximal time step
"""
self.setOptions('time_step_max', val)
def getTimeStepVariation(self):
"""
Return the maximal variation of time step between two iteration
"""
tag = 'time_step_var'
return self.getOptions(tag)
def setTimeStepVariation(self, val):
"""
Input the maximal variation of time step between two iteration
"""
self.setOptions('time_step_var', val)
def getOptions(self, tag):
"""
Get options for node "time_parameters"
"""
v = self.node_time.xmlGetChildDouble(tag)
if v == None:
v = self.defaultValues()[tag]
self.setOptions(tag, v)
return v
def setOptions(self, tag, val):
"""
Put options for node "time_parameters"
"""
self.node_time.xmlSetData(tag, val)
def getThermalTimeStep(self):
"""
Get status of thermal_time_step for node "time_parameters"
"""
s = ""
node = self.node_time.xmlGetChildNode('thermal_time_step', 'status')
if not node or not node['status']:
s = self.defaultValues()['thermal_time_step']
self.setThermalTimeStep(s)
else:
s = node['status']
return s
def setThermalTimeStep(self, status):
"""
Put status of thermal_time_step for node "time_parameters"
"""
node = self.node_time.xmlInitChildNode('thermal_time_step', 'status')
node['status'] = status
def getZeroTimeStep(self):
"""
Get status of zero_time_step for node "time_parameters"
"""
s = ""
node = self.node_time.xmlGetNode('zero_time_step', 'status')
if not node or not node['status']:
s = self.defaultValues()['zero_time_step']
self.setZeroTimeStep(s)
else:
s = node['status']
return s
def setZeroTimeStep(self, status):
"""
Get status of zero_time_step for node "time_parameters"
"""
node = self.node_time.xmlInitChildNode('zero_time_step', 'status')
if node: node['status'] = status
def RemoveThermalTimeStepNode(self):
"""
Remove Thermal time step node for node "time_parameters"
"""
self.node_time.xmlRemoveChild('thermal_time_step')
def RemoveLocalTimeStepNode(self):
"""
Remove Thermal time step node for node "time_parameters"
"""
self.node_time.xmlRemoveChild('property', name='local_time_step')
def RemoveTimeNode(self, node):
"""
Remove Thermal time step node for node "time_parameters"
"""
self.node_time.xmlRemoveChild(node)
#-------------------------------------------------------------------------------
# Time Step Model class for Matisse
#-------------------------------------------------------------------------------
class TimeStepMatisseModel(TimeStepModel):
def __init__(self, case):
"""
Constructor.
"""
TimeStepModel.__init__(self, case)
self.node_matisse = self.case.root().xmlInitChildNode('matisse')
self.node_compute = self.node_matisse.xmlInitChildNode('compute')
self.node_phymodel = self.node_compute.xmlInitChildNode('physical_model')
def defaultValues(self):
"""
Return in a dictionnary which contains default values
"""
default = TimeStepModel.defaultValues(self)
default['dtdtmx'] = 1.0
return default
def setDtdtmx(self, val):
"""
set value of Dtdtmx for node "dtdtmx"
"""
self.node_phymodel.xmlSetData('dtdtmx', val)
def getDtdtmx(self):
"""
Get value of Dtdtmx for node "dtdtmx"
"""
val = self.node_phymodel.xmlGetDouble('dtdtmx')
if not val :
self.node_phymodel.xmlInitChildNode('dtdtmx')
val = self.defaultValues()['dtdtmx']
self.setDtdtmx(val)
return val
#-------------------------------------------------------------------------------
# Time Step View class
#-------------------------------------------------------------------------------
class TimeStepView(TkPage.Page):
"""
Class to open the Time Step Page.
"""
def _tkControlVariables(self):
"""
Tkinter variables declaration.
"""
self.time_passing = Tix.IntVar()
self.iteration = Tix.IntVar()
self.time_step = Tix.DoubleVar()
self.courant_max = Tix.DoubleVar()
self.fourier_max = Tix.DoubleVar()
self.time_step_min = Tix.DoubleVar()
self.time_step_max = Tix.DoubleVar()
self.time_step_var = Tix.DoubleVar()
self.thermal_time_step = Tix.StringVar()
self.zero_time_step = Tix.StringVar()
def _pageControl(self):
"""
Xml node declaration and supplementary default value settings.
"""
self.mdl = TimeStepModel(self.case)
self.tagList= ['max_courant_num',
'max_fourier_num',
'time_step_min',
'time_step_max',
'time_step_var']
self._iteration = 0
def getTimePassing(self, event=None):
"""
Input IDTVAR.
"""
self.stbar.busy()
idtvar = self.time_passing.get()
self.mdl.setTimePassing(idtvar)
if idtvar in (1, 2):
self.w5.pack_forget()
self.s2.pack_forget()
self.w6.pack_forget()
self.w3.pack(side=TOP, fill=X, pady=10)
self.s1.pack(side=TOP, fill=X)
if self.thermalCase():
self.w5.pack(side=TOP, fill=X, pady=10)
self.s2.pack(side=TOP, fill=X)
self.w6.pack(side=TOP, fill=X, pady=10)
for i, var in [(0, self.courant_max ),
(1, self.fourier_max ),
(2, self.time_step_min),
(3, self.time_step_max),
(4, self.time_step_var)]:
self.getTimeOption(i, var)
else:
self.w3.pack_forget()
self.s1.pack_forget()
self.mdl.RemoveLocalTimeStepNode()
for node in self.tagList:
self.mdl.RemoveTimeNode(node)
self.stbar.idle()
def getTimeStep(self, event=None):
"""
Input DTREF.
"""
self.stbar.busy()
if self.check2.isSPositive(self.e1, self.time_step):
self.mdl.setTimeStep(self.time_step.get())
self.stbar.idle()
def getIter(self, entry, step=0, event=None):
"""
Input NTMABS.
"""
self.stbar.busy()
if self.check2.isSPositive(self.e2, self.iteration):
self.mdl.setIterationsNumber(self.iteration.get())
self.stbar.idle()
def getTimeOption(self, num, var, event=None):
"""
Input COUMAX / FOUMAX / DTMIN / DTMAX / VARRDT.
"""
self.stbar.busy()
if num == 2:
if self.check2.isPositive(self.e[num], var):
self.mdl.setOptions(self.tagList[num], var.get())
elif self.check2.isSPositive(self.e[num], var):
self.mdl.setOptions(self.tagList[num], var.get())
self.stbar.idle()
def thermalCase(self):
"""
Is the current case a thermal case ?
"""
# FIXME: TimeStep: remplacer FluidCharacteristics par XMLmodel avec method appropiée
thermal_case = 0
from FluidCharacteristics import FluidCharacteristicsModel
n_joul, n_thermo, n_gas, n_coal = FluidCharacteristicsModel(self.case).getThermoPhysicalModel()
del FluidCharacteristicsModel
if n_joul != 'off' or n_thermo != 'off' or n_gas != 'off' or n_coal != 'off':
thermal_case = 1
return thermal_case
def getThermalTimeStep(self, event=None):
"""
Input IPTLRO.
"""
self.stbar.busy()
self.mdl.setThermalTimeStep(self.thermal_time_step.get())
self.stbar.idle()
def getZeroTimeStep(self, event=None):
"""
Input INPDT0.
"""
self.stbar.busy()
self.mdl.setZeroTimeStep(self.zero_time_step.get())
self.stbar.idle()
def _createWidgets(self):
"""
Make widgets and the time step management layout.
"""
t = PageText()
lf = Tix.LabelFrame(self.myPage, bd=2, label=t.TIME_TITLE, relief=FLAT)
lf.label.config(font=fT)
lf.pack(side=TOP, fill=X, padx=10, pady=10)
w1 = Tix.Frame(lf.frame, relief=FLAT)
w1.pack(side=TOP, fill=X, pady=10)
# Separator
#
Tix.Frame(lf.frame, height=2, bd=2, relief=SUNKEN).pack(side=TOP, fill=X)
w2 = Tix.Frame(lf.frame, relief=FLAT)
w2.pack(side=TOP, fill=X, pady=10)
# Separator
#
Tix.Frame(lf.frame, height=2, bd=2, relief=SUNKEN).pack(side=TOP, fill=X)
self.w3 = Tix.Frame(lf.frame, relief=FLAT)
self.w3.pack(side=TOP, fill=X, pady=10)
# Separator
#
self.s1 = Tix.Frame(lf.frame, height=2, bd=2, relief=SUNKEN)
self.s1.pack(side=TOP, fill=X)
self.w5 = Tix.Frame(lf.frame, relief=FLAT)
self.w5.pack(side=TOP, fill=X, pady=10)
# Separator
#
self.s2 = Tix.Frame(lf.frame, height=2, bd=2, relief=SUNKEN)
self.s2.pack(side=TOP, fill=X)
self.w6 = Tix.Frame(lf.frame, relief=FLAT)
self.w6.pack(side=TOP, fill=X, pady=10)
# IDTVAR
#
Tix.Label(w1, text=t.TIME_STEP_TYPE, bd=2, relief=FLAT) \
.grid(row=0, column=0, columnspan=2, pady=5, sticky=W)
self.r = [0]*3
self.h = [0]*3
for i, t1 in [(0, t.TIMETYPE0),
(1, t.TIMETYPE1),
(2, t.TIMETYPE2)]:
self.r[i] = Tix.Radiobutton(w1, value=i, variable=self.time_passing,
command=self.getTimePassing)
self.r[i].grid(row=1+i, column=0, sticky=E)
self.h[i] = Tix.Label(w1, text=t1)
self.balloon.bind_widget(self.h[i], balloonmsg=t.KEYWORD+"IDTVAR",
statusmsg=t.MSG_IDTVAR)
self.h[i].grid(row=1+i, column=1, padx=3, pady=2, sticky=W)
# DTREF
#
l1 = Tix.Label(w2, text=t.TIME_STEP)
self.balloon.bind_widget(l1, balloonmsg=t.KEYWORD+"DTREF",
statusmsg=t.MSG_DTREF)
l1.grid(row=0, column=0, padx=3, pady=2, sticky=W)
f1 = Tix.Frame(w2, relief=FLAT)
f1.grid(row=0, column=1, padx=4, pady=2, sticky=W)
self.e1 = Tix.Entry(f1, bd=2, width=8, textvariable=self.time_step)
self.e1.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e1.bind("<<Event>>", self.getTimeStep)
self.e1.pack(padx=0, pady=2, side=LEFT)
Tix.Label(f1, text='s', relief=FLAT).pack(padx=5, pady=2, side=LEFT)
# NTMABS (recontruction of a new Control widget)
#
l2 = Tix.Label(w2, text=t.ITERATION, relief=FLAT)
self.balloon.bind_widget(l2, balloonmsg=t.KEYWORD+"NTMABS",
statusmsg=t.MSG_NTMABS)
l2.grid(row=1, column=0, padx=3, pady=2, sticky=W)
f2 = Tix.Frame(w2, relief=FLAT)
f2.grid(row=1, column=1, padx=4, pady=2, sticky=W)
self.e2 = Tix.Entry(f2, bd=2, width=8, textvariable=self.iteration)
self.e2.pack(padx=0, pady=2, side=LEFT)
self.e2.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e2.bind('<<Event>>', self.getIter)
# COUMAX / FOUMAX / DTMIN / DTMAX / VARRDT
#
l = [0]*5
self.e = [0]*5
for i, t1, key, var in [(0, t.COUMAX, "COUMAX", self.courant_max ),
(1, t.FOUMAX, "FOUMAX", self.fourier_max ),
(2, t.DTMIN, "DTMIN", self.time_step_min),
(3, t.DTMAX, "DTMAX", self.time_step_max),
(4, t.VARRDT, "VARRDT", self.time_step_var)]:
l[i] = Tix.Label(self.w3, text=t1)
self.balloon.bind_widget(l[i], balloonmsg=t.KEYWORD+key,
statusmsg=t.MSG_COUFOU)
l[i].grid(row=i, column=0, padx=3, pady=2, sticky=E)
self.e[i] = Tix.Entry(self.w3, bd=2, width=10, textvariable=var)
self.e[i].event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e[i].bind ("<<Event>>", TkPage.Callback(self.getTimeOption, i, var))
self.e[i].grid(row=i, column=1, padx=0, pady=5, sticky=W)
Tix.Label(self.w3, text='s', relief=FLAT).grid(row=2, column=2, padx=5)
Tix.Label(self.w3, text='s', relief=FLAT).grid(row=3, column=2, padx=5)
# IPTLRO
#
h5 = Tix.Label(self.w5, text=t.THERMAL_TIME)
self.balloon.bind_widget(h5, balloonmsg=t.KEYWORD+"IPTLRO")
h5.grid(row=0, column=0, padx=15, sticky=W)
self.c2 = Tix.Checkbutton(self.w5, onvalue='on', offvalue='off',
variable=self.thermal_time_step,
command=self.getThermalTimeStep)
self.c2.grid(row=0, column=1, sticky=E)
# INPDT0
#
h6 = Tix.Label(self.w6, text=t.TIME_ZERO)
self.balloon.bind_widget(h6, balloonmsg=t.KEYWORD+"INPDT0")
h6.grid(row=0, column=0, padx=15, sticky=W)
self.c1 = Tix.Checkbutton(self.w6, onvalue='on', offvalue='off',
variable=self.zero_time_step,
command=self.getZeroTimeStep)
self.c1.grid(row=0, column=1, sticky=E)
def _initializeWidgets(self):
"""
Extract resquested informations from XML document.
This informations are used to initialize the widgets.
"""
# IDTVAR
#
idtvar = self.mdl.getTimePassing()
self.time_passing.set(idtvar)
self.r[idtvar].select()
if idtvar in (1, 2):
self.w5.pack_forget()
self.s2.pack_forget()
self.w6.pack_forget()
self.w3.pack(side=TOP, fill=X, pady=10)
self.s1.pack(side=TOP, fill=X)
if self.thermalCase():
self.w5.pack(side=TOP, fill=X, pady=10)
self.s2.pack(side=TOP, fill=X)
self.w6.pack(side=TOP, fill=X, pady=10)
else:
self.w3.pack_forget()
self.s1.pack_forget()
from Turbulence import TurbulenceModel
model = TurbulenceModel(self.case).getTurbulenceModel()
del TurbulenceModel
if model in ('LES_Smagorinsky', 'LES_dynamique'):
for i in range(0,3):
self.r[i].config(state=DISABLED)
self.h[i].config(state=DISABLED)
# DTREF (insert in the xml doc if it deosn't exist)
#
dtref = self.mdl.getTimeStep()
self.time_step.set(dtref)
# NTMABS (insert in the xml doc if it deosn't exist)
# (warning it's not an Entry widget but a Control widget)
#
ntmabs = self.mdl.getIterationsNumber()
self.iteration.set(ntmabs)
# COUMAX / FOUMAX / DTMIN / DTMAX / VARRDT
#
for i, var in [(0, self.courant_max ),
(1, self.fourier_max ),
(2, self.time_step_min),
(3, self.time_step_max),
(4, self.time_step_var)]:
option = self.mdl.getOptions(self.tagList[i])
var.set(option)
# IPTLRO
#
if self.thermalCase():
status1 = self.mdl.getThermalTimeStep()
if status1 == 'on':
self.c2.select()
else:
self.c2.deselect()
else:
self.mdl.RemoveThermalTimeStepNode()
self.w5.pack_forget()
self.s2.pack_forget()
# INPDT0
#
status2 = self.mdl.getZeroTimeStep()
if status2 == 'on':
self.c1.select()
else:
self.c1.deselect()
#-------------------------------------------------------------------------------
# Time Step View class for Matisse
#-------------------------------------------------------------------------------
class TimeStepMatisseView(TkPage.Page):
"""
Class to open the Time Step Page.
"""
def _tkControlVariables(self):
"""
Tkinter variables declaration.
"""
self.iteration = Tix.IntVar()
self.dtdtmx = Tix.DoubleVar()
self.zero_time_step = Tix.StringVar()
def _pageControl(self):
"""
Xml node declaration and supplementary default value settings.
"""
self.mdl = TimeStepMatisseModel(self.case)
self._iteration = 0
def getIter(self, entry, step=0, event=None):
"""
Input NTMABS.
"""
self.stbar.busy()
if self.check2.isSPositive(self.e2, self.iteration):
self.mdl.setIterationsNumber(self.iteration.get())
self.stbar.idle()
def getDtdtmx(self, entry, step=0, event=None):
"""
Input NTMABS.
"""
self.stbar.busy()
if self.check2.isSPositive(self.e3, self.dtdtmx):
self.mdl.setDtdtmx(self.dtdtmx.get())
self.stbar.idle()
def getZeroTimeStep(self, event=None):
"""
Input INPDT0.
"""
self.stbar.busy()
self.mdl.setZeroTimeStep(self.zero_time_step.get())
self.stbar.idle()
def _createWidgets(self):
"""
Make widgets and the time step management layout.
"""
t = PageText()
lf = Tix.LabelFrame(self.myPage, bd=2, label=t.TIME_TITLE, relief=FLAT)
lf.label.config(font=fT)
lf.pack(side=TOP, fill=X, padx=10, pady=10)
w2 = Tix.Frame(lf.frame, relief=FLAT)
w2.pack(side=TOP, fill=X, pady=10)
# Separator
#
Tix.Frame(lf.frame, height=2, bd=2, relief=SUNKEN).pack(side=TOP, fill=X)
self.w6 = Tix.Frame(lf.frame, relief=FLAT)
self.w6.pack(side=TOP, fill=X, pady=10)
# NTMABS
#
l2 = Tix.Label(w2, text=t.ITERATION, relief=FLAT)
self.balloon.bind_widget(l2, balloonmsg=t.KEYWORD+"NTMABS",
statusmsg=t.MSG_NTMABS)
l2.grid(row=1, column=0, padx=3, pady=2, sticky=W)
f2 = Tix.Frame(w2, relief=FLAT)
f2.grid(row=1, column=1, padx=4, pady=2, sticky=W)
self.e2 = Tix.Entry(f2, bd=2, width=8, textvariable=self.iteration)
self.e2.pack(padx=0, pady=2, side=LEFT)
self.e2.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e2.bind('<<Event>>', self.getIter)
# dtdtmx
#
l3 = Tix.Label(w2, text=t.DTDTMX, relief=FLAT)
l3.grid(row=2, column=0, padx=3, pady=2, sticky=W)
f3 = Tix.Frame(w2, relief=FLAT)
f3.grid(row=2, column=1, padx=4, pady=2, sticky=W)
self.e3 = Tix.Entry(f3, bd=2, width=8, textvariable=self.dtdtmx)
self.e3.pack(padx=0, pady=2, side=LEFT)
self.e3.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e3.bind('<<Event>>', self.getDtdtmx)
# INPDT0
#
h6 = Tix.Label(self.w6, text=t.TIME_ZERO)
self.balloon.bind_widget(h6, balloonmsg=t.KEYWORD+"INPDT0")
h6.grid(row=0, column=0, padx=15, sticky=W)
self.c1 = Tix.Checkbutton(self.w6, onvalue='on', offvalue='off',
variable=self.zero_time_step,
command=self.getZeroTimeStep)
self.c1.grid(row=0, column=1, sticky=E)
def _initializeWidgets(self):
"""
Extract resquested informations from XML document.
This informations are used to initialize the widgets.
"""
ntmabs = self.mdl.getIterationsNumber()
self.iteration.set(ntmabs)
dtdtmx = self.mdl.getDtdtmx()
self.dtdtmx.set(dtdtmx)
status = self.mdl.getZeroTimeStep()
if status == 'on':
self.c1.select()
else:
self.c1.deselect()
#-------------------------------------------------------------------------------
# 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.COUMAX = "Nombre de Courant maximal :"
self.DTMAX = "Pas de temps maximal :"
self.DTMIN = "Pas de temps minimal :"
self.FOUMAX = "Nombre de Fourier maximal :"
self.ITERATION = "Nombre de pas de temps (suites comprises) :"
self.KEYWORD = "Mot clé Code_Saturne : "
self.NO = "non"
self.THERMAL_TIME = "Limitation du pas de temps par \nle pas de temps thermique local"
self.TIME_STEP = "Pas de temps de référence :"
self.TIME_STEP_TYPE = "Options du pas de temps : "
self.TIME_TITLE = "Gestion du pas de temps"
self.TIMETYPE0 = "Uniforme et constant"
self.TIMETYPE1 = "Variable en temps et uniforme en espace"
self.TIMETYPE2 = "Variable en espace et en temps"
self.TIME_ZERO = "Option zéro pas de temps"
self.VARRDT = "Variation maximale du pas de temps :"
self.YES = "oui"
self.DTDTMX = "Delta de température max par pas de temps"
else:
self.COUMAX = "Maximal Courant number:"
self.DTMAX = "Maximal time step:"
self.DTMIN = "Minimal time step:"
self.FOUMAX = "Maximal Fourier number:"
self.ITERATION = "Number of iterations (restart included):"
self.KEYWORD = "Code_Saturne key word: "
self.NO = "off"
self.THERMAL_TIME = "Time step limitation with \nthe local thermal time step"
self.TIME_STEP = "Reference time step:"
self.TIME_STEP_TYPE = "Time step options:"
self.TIME_TITLE = "Set time step"
self.TIMETYPE0 = "Uniform and constant"
self.TIMETYPE1 = "Variable in time and uniform in space"
self.TIMETYPE2 = "Variable in time and in space"
self.TIME_ZERO = "Option zero time step"
self.VARRDT = "Time step maximal variation:"
self.YES = "on"
self.DTDTMX = "max temperature gradient / time step"
# 2) Messages
#
if Tool.GuiParam.lang == 'fr':
self.MSG_IDTVAR = "A l'ordre 2 en temps, le pas de temps doit être "\
"uniforme et constant."
self.MSG_IPTLRO = "Utile si pas de temps variable et si thermique"
self.MSG_DTREF = ""
self.MSG_COUFOU = "Entrée accessible si le pas de temps est "\
"variable."
self.MSG_NTMABS = "Nombre de pas de temps absolu de la "\
"simulation, suites incluses."
else:
self.MSG_IDTVAR = "At order 2 in time, the time step must be uniform "\
"and constant."
self.MSG_IPTLRO = "Usefull with variable time step and thermal case."
self.MSG_DTREF = ""
self.MSG_COUFOU = "Accessible entry if the time step is variable."
self.MSG_NTMABS = "Absolute time step number of the "\
"simulation, restarts included."
#-------------------------------------------------------------------------------
# End
#-------------------------------------------------------------------------------
syntax highlighted by Code2HTML, v. 0.9.1