# -*- 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 module defines the differents possible outputs : listings, for ensights
chronologic and historic files .... captors .... used variables ...
This module defines the following classes:
- NumericalParamEquatModel
- Scheme
- Solveur
- NumericalParamEquatView
"""
#-------------------------------------------------------------------------------
# Library modules import
#-------------------------------------------------------------------------------
import string
from xml.dom.minidom import parse
import Tix, unittest
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
import Base.XMLmodel as XMLmodel
#-------------------------------------------------------------------------------
# NumericalParamEquat model class
#-------------------------------------------------------------------------------
class NumericalParamEquatModel:
"""
"""
def __init__(self, case):
"""
initialization of nodes lists
"""
self.case = case
self.node_models = self.case.xmlGetNode('thermophysical_models')
self.node_vitpre = self.node_models.xmlGetNode('velocity_pressure')
self.node_varVP = self.node_vitpre.xmlGetNodeList('variable')
self.var = []
model = XMLmodel.XMLmodel(self.case)
for part in [(self.node_varVP, 'black'),
(model.getTurbVariable(), 'black'),
(model.getThermalScalar(), 'brown'),
(model.getPuCoalScalars(), 'blue' ),
(model.getAdditionalScalar(), 'darkblue')]:
self.var.append(part)
# nodes creation for all scalars and variables
# Mis en commentaire par NP
## for node in self.var:
## for node1 in node[0]:
## if not self.mIsPressure(node1):
## for tt in ['max_iter_number', 'solveur_precision',
## 'blending_factor', 'order_scheme',
## 'slope_test', 'flux_reconstruction']:
## node1.xmlInitNode(tt)
## # if scalar
## if self.mGetType(node1):
## node1.xmlInitNodeList('time_step_factor')
#turb variables list
self.varturb = []
for node in model.getTurbVariable():
self.varturb.append(node['name'])
def defaultValues(self, name=""):
"""
default values
"""
self.default = {}
self.default['time_step_factor'] = 1.0
self.default['max_iter_number'] = 10000
self.default['solveur_precision'] = 1e-8
self.default['slope_test'] = 'on'
self.default['flux_reconstruction'] = 'on'
if name in self.varturb:
self.default['order_scheme'] = 'upwind'
self.default['blending_factor'] = 0.
else:
self.default['order_scheme'] = 'centered'
self.default['blending_factor'] = 1.
return self.default
def mGetType(self, node):
if node['type'] in ['user', 'thermal']:
return 1
else:
return 0
def mIsPressure(self, node):
if node['name'] == 'pressure':
return 1
else:
return 0
def mGetName(self, node):
return node['name']
def mGetScheme(self, node):
if self.mIsPressure(node):
# FIXME: return nothing ?
return
else:
name = self.mGetName(node)
if not node.xmlGetNode('order_scheme'):
value = self.defaultValues(name)['order_scheme']
else:
value = node.xmlGetNode('order_scheme')['choice']
return value
def mGetBlendingFactor(self, node):
if self.mIsPressure(node):
return
else:
name = self.mGetName(node)
if not node.xmlGetNode('blending_factor'):
value = self.defaultValues(name)['blending_factor']
else:
value = node.xmlGetDouble('blending_factor')
return value
def mGetStatusSlopeTest(self, node):
if self.mIsPressure(node):
return
else:
## value = node.xmlGetNode('slope_test')['status']
## if not value:
## value = self.defaultValues()['slope_test']
## self.mSetSlopeTest(node, value)
## return value
name = self.mGetName(node)
if not node.xmlGetNode('slope_test'):
value = self.defaultValues(name)['slope_test']
else:
value = node.xmlGetNode('slope_test')['status']
return value
def mGetStatusFluxR(self, node):
if self.mIsPressure(node):
return
else:
## value = node.xmlGetNode('flux_reconstruction')['status']
## if not value:
## value = self.defaultValues()['flux_reconstruction']
## self.mSetFluxR(node, value)
## return value
name = self.mGetName(node)
if not node.xmlGetNode('flux_reconstruction'):
value = self.defaultValues(name)['flux_reconstruction']
else:
value = node.xmlGetNode('flux_reconstruction')['status']
return value
def mSetBlendingFactor(self, node, value):
## node.xmlSetData('blending_factor', value)
if node.xmlGetNode('order_scheme'):
if node.xmlGetNode('order_scheme')['choice'] == 'upwind' or \
node.xmlGetNode('order_scheme')['choice'] == 'centered':
node.xmlRemoveChild('blending_factor')
else:
node.xmlSetData('blending_factor', value)
else:
name = self.mGetName(node)
if value != self.defaultValues(name)['blending_factor']:
node.xmlSetData('blending_factor', value)
def mSetScheme(self, node, value):
tt = node.xmlGetNode('order_scheme')
## if not tt:
## tt = node.xmlInitNode('order_scheme')
## tt['order_scheme'] = self.defaultValues()['order_scheme']
## if value == 'upwind':
## node.xmlRemoveChild('order_scheme')
## else:
## tt['choice']=value
name = self.mGetName(node)
if tt:
if value == self.defaultValues(name)['order_scheme']:
node.xmlRemoveChild('order_scheme')
node.xmlRemoveChild('blending_factor')
else:
tt['choice']=value
else:
if value != self.defaultValues(name)['order_scheme']:
tt = node.xmlInitNode('order_scheme')
tt['choice']=value
def mSetSlopeTest(self, node, value):
## tt = node.xmlGetNode('slope_test')
## tt['status']=value
tt = node.xmlGetNode('slope_test')
if value == self.defaultValues()['slope_test']:
node.xmlRemoveChild('slope_test')
else:
if not tt: tt = node.xmlInitNode('slope_test')
tt['status']=value
def mSetFluxR(self, node, value):
## tt = node.xmlGetNode('flux_reconstruction')
## tt['status']=value
tt = node.xmlGetNode('flux_reconstruction')
if tt:
if value == self.defaultValues()['flux_reconstruction']:
node.xmlRemoveChild('flux_reconstruction')
else:
tt['status']=value
else:
if value != self.defaultValues()['flux_reconstruction']:
node.xmlInitNode('flux_reconstruction', status=value)
def mSetMaxIterNumber(self, node, value):
## node.xmlSetData('max_iter_number', value)
if value != self.defaultValues()['max_iter_number']:
node.xmlSetData('max_iter_number', value)
else:
if node: node.xmlRemoveChild('max_iter_number')
def mSetSolveurPrecision(self, node, value):
## node.xmlSetData('solveur_precision', value)
if value != self.defaultValues()['solveur_precision']:
node.xmlSetData('solveur_precision', value)
else:
if node: node.xmlRemoveChild('solveur_precision')
def mGetMaxIterNumber(self, node):
if self.mIsPressure(node):
return
else:
## value, name = node.xmlGetDouble('max_iter_number'), self.mGetName(node)
## if not value:
## value = self.defaultValues(name)['max_iter_number']
## self.mSetMaxIterNumber(node, value)
## return int(value)
if not node.xmlGetNode('max_iter_number'):
value = self.defaultValues()['max_iter_number']
else:
value = node.xmlGetDouble('max_iter_number')
return int(value)
def mGetSolveurPrecision(self, node):
if self.mIsPressure(node):
return
else:
## value, name = node.xmlGetDouble('solveur_precision'), \
## self.mGetName(node)
#### if not value:
## value = self.defaultValues(name)['solveur_precision']
## self.mSetSolveurPrecision(node, value)
## return value
name = self.mGetName(node)
if not node.xmlGetNode('solveur_precision'):
value = self.defaultValues()['solveur_precision']
else:
value = node.xmlGetDouble('solveur_precision')
return value
def mGetTimeStepFactor(self, node):
if self.mIsPressure(node) or not self.mGetType(node):
return
else:
## value, name = node.xmlGetDouble('time_step_factor'),\
## self.mGetName(node)
## if not value:
## value = self.defaultValues(name)['time_step_factor']
## self.mSetTimeStepFactor(node, value)
## return value
name = self.mGetName(node)
if not node.xmlGetNode('time_step_factor'):
value = self.defaultValues()['time_step_factor']
else:
value = node.xmlGetDouble('time_step_factor')
return value
def mSetTimeStepFactor(self, node, value):
## node.xmlSetData('time_step_factor', value)
if value != self.defaultValues()['time_step_factor']:
node.xmlSetData('time_step_factor', value)
else:
if node: node.xmlRemoveChild('time_step_factor')
#-------------------------------------------------------------------------------
# Scheme class
#-------------------------------------------------------------------------------
class Scheme:
"""
"""
def __init__(self, case, master, check, stbar, node, color, NPE):
"""
"""
self.master = master
self.case = case
self.check = check
self.stbar = stbar
self.node = node
self.color = color
self.balloon = Tix.Balloon(self.master, statusbar=self.stbar.label, bd=1, bg='black')
self.balloon.message.config(bg=wm['background'])
# self.NPE = NumericalParamEquatModel(self.case)
self.NPE = NPE
self.label = Tix.StringVar()
self.blencv = Tix.DoubleVar()
self.ischcv = Tix.StringVar()
self.isstpc = Tix.StringVar()
self.ircflu = Tix.StringVar()
self._createWidgets()
def _createWidgets(self):
"""
"""
t = PageText()
f1 = Tix.Frame(self.master)
f1.pack(side=TOP, fill=X)
lab = Tix.Label(f1, width=10, text=self.node['label'], fg=self.color)
self.o1 = Tix.OptionMenu(f1)
self.o1.menubutton.config(bd=2, width=6, relief=RAISED)
self.o1.add_command('upwind', label=t.UPWIND)
self.o1.add_command('centered', label=t.CENTERED)
self.o1.add_command('solu', label=t.SOLU)
self.o1.config(variable=self.ischcv, command=self.setISCHCV)
self.balloon.bind_widget(self.o1, balloonmsg=t.KEYWORD+"ISCHCV")
self.e1 = Tix.Entry(f1, width=5, textvariable=self.blencv)
self.e1.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e1.bind("<<Event>>", self.setBLENCV)
self.balloon.bind_widget(self.e1, balloonmsg=t.KEYWORD+"BLENCV")
self.b1 = Tix.Checkbutton(f1, width=8, onvalue="on", offvalue="off",
variable=self.isstpc, command=self.setISSTPC)
self.balloon.bind_widget(self.b1, balloonmsg=t.KEYWORD+"ISSTPC")
self.b2 = Tix.Checkbutton(f1, width=8, onvalue="on", offvalue="off",
variable=self.ircflu, command=self.setIRCFLU)
self.balloon.bind_widget(self.b2, balloonmsg=t.KEYWORD+"IRCFLU")
lab.grid(row=0,column=0, pady=2)
self.o1.grid(row=0, column=1)
self.e1.grid(row=0, column=2, padx=30, sticky=E)
self.b1.grid(row=0, column=3)
self.b2.grid(row=0, column=4)
# initial values
# on initialise BLENCV avant ISCHCV
# (modif possible de BLENCV en fonction de ISCHCV)
self.blencv.set(self.NPE.mGetBlendingFactor(self.node))
self.ischcv.set(self.NPE.mGetScheme(self.node))
self.isstpc.set(self.NPE.mGetStatusSlopeTest(self.node))
self.ircflu.set(self.NPE.mGetStatusFluxR(self.node))
# test for BLENCV
if self.ischcv.get() == "upwind":
self.blencv.set(0)
self.setBLENCV()
self.e1.config(state=DISABLED)
def setISCHCV(self, event=None):
self.b2.config(state=NORMAL)
if self.ischcv.get() == "upwind":
self.e1.config(state=DISABLED, fg='grey')
self.blencv.set(0.0)
else:
self.e1.config(state=NORMAL, fg = wm['foreground'])
if self.ischcv.get() == "centered":
if self.blencv.get() != 1: self.blencv.set(1.0)
if self.ischcv.get() == "solu":
self.ircflu.set('on')
self.setIRCFLU()
self.b2.config(state=DISABLED)
self.NPE.mSetScheme(self.node, self.ischcv.get())
self.NPE.mSetBlendingFactor(self.node, self.blencv.get())
def setBLENCV(self, event=None):
if self.ischcv.get() != "upwind":
self.stbar.busy()
if self.check.isBetween(self.e1, self.blencv, 1e-20, 1.):
self.NPE.mSetBlendingFactor(self.node, self.blencv.get())
self.stbar.idle()
def setISSTPC(self, event=None):
self.NPE.mSetSlopeTest(self.node, self.isstpc.get())
def setIRCFLU(self, event=None):
self.NPE.mSetFluxR(self.node, self.ircflu.get())
#-------------------------------------------------------------------------------
# Scheme class
#-------------------------------------------------------------------------------
class Solveur:
"""
"""
def __init__(self, case, master, check, stbar, node, color, NPE):
"""
"""
self.master = master
self.case = case
self.check = check
self.stbar = stbar
self.node = node
self.color = color
self.balloon = Tix.Balloon(self.master, statusbar=self.stbar.label, bd=1, bg='black')
self.balloon.message.config(bg=wm['background'])
# self.NPE = NumericalParamEquatModel(self.case)
self.NPE = NPE
self.label = Tix.StringVar()
self.nitmax = Tix.IntVar()
self.epsilo = Tix.DoubleVar()
self.cdtvar = Tix.DoubleVar()
self._createWidgets()
def _createWidgets(self):
"""
"""
t = PageText()
f1 = Tix.Frame(self.master)
f1.pack(fill=X, padx=20)
f2 = Tix.Frame(f1, width=50)
lab = Tix.Label(f2, width=10, text=self.node['label'], fg=self.color)
self.e1 = Tix.Entry(f2, width=8, textvariable=self.nitmax)
self.e1.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e1.bind("<<Event>>", self.setNITMAX)
self.balloon.bind_widget(self.e1, balloonmsg=t.KEYWORD+"NITMAX")
self.e2 = Tix.Entry(f2, width=8, textvariable=self.epsilo)
self.e2.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e2.bind("<<Event>>", self.setEPSILO)
self.balloon.bind_widget(self.e2, balloonmsg=t.KEYWORD+"EPSILO")
f3 = Tix.Frame(f1)
self.e3 = Tix.Entry(f3, width=5, textvariable=self.cdtvar)
self.e3.event_add("<<Event>>", "<Return>", "<Leave>", "<FocusOut>")
self.e3.bind("<<Event>>", self.setCDTVAR)
self.balloon.bind_widget(self.e3, balloonmsg=t.KEYWORD+"CDTVAR")
f2.pack(side=LEFT)
f3.pack(side=LEFT)
lab.grid(row=0,column=0, pady=2)
self.e1.grid(row=0, column=2, padx=25, pady=2)
self.e2.grid(row=0, column=3, padx=25, pady=2)
if self.NPE.mGetType(self.node):
self.e3.grid(row=0, column=1, padx=27, pady=2)
self.nitmax.set(self.NPE.mGetMaxIterNumber(self.node))
self.epsilo.set(self.NPE.mGetSolveurPrecision(self.node))
self.cdtvar.set(self.NPE.mGetTimeStepFactor(self.node))
def setNITMAX(self, event=None):
if self.check.isBetween(self.e1, self.nitmax, 1, 100000):
self.NPE.mSetMaxIterNumber(self.node, self.nitmax.get())
def setEPSILO(self, event=None):
if self.check.isBetween(self.e2, self.epsilo, 1e-10, 1e-3):
self.NPE.mSetSolveurPrecision(self.node, self.epsilo.get())
def setCDTVAR(self, event=None):
if self.check.isSPositive(self.e3, self.cdtvar):
self.NPE.mSetTimeStepFactor(self.node, self.cdtvar.get())
#-------------------------------------------------------------------------------
# Main class
#-------------------------------------------------------------------------------
class NumericalParamEquatView(TkPage.Page):
"""
Class to open Turbulence Page.
"""
def _pageControl(self):
"""
Xml node declaration and supplementary default value settings.
"""
self.NPE = NumericalParamEquatModel(self.case)
def _tkControlVariables(self):
"""
Tkinter variables declaration.
"""
self.ivisse = Tix.IntVar()
self.relaxp = Tix.IntVar()
self.ipucou = Tix.IntVar()
self.extrag = Tix.IntVar()
self.ircflu = Tix.IntVar()
self.iconv = Tix.IntVar()
self.istat = Tix.IntVar()
self.idiff = Tix.IntVar()
def _createWidgets(self):
"""
Create the Page layout.
"""
t = PageText()
# NoteBook and tabs layout
#
nb = Tix.NoteBook(self.myPage)
nb.pack(expand=1, side=TOP, fill=BOTH)
nb.nbframe.config(background=self.bg, backpagecolor=self.bg)
nb.nbframe.config(focuscolor=self.bg, inactivebackground=wm['inactivebackground'])
nb.nbframe.config(relief=RAISED)
nb.nbframe.config(font=fT, tabpadx='10', tabpady='2')
nb.add('page1', anchor='center', label=t.SCHEME)
nb.add('page2', anchor='center', label=t.SOLVEUR)
########################################################
# NoteBook Page 1 - Scheme
########################################################
w1 = Tix.Frame(nb.page1, relief=FLAT)
w1.pack(side=TOP, fill=X, pady = 10)
l11 = Tix.Label(w1, text=t.NAME, bd=1, width=11, height=2, relief=GROOVE)
l12 = Tix.Label(w1, text=t.ORDER, bd=1, width=10, height=2, relief=GROOVE)
l13 = Tix.Label(w1, text=t.BLENDING, bd=1, width=16, height=2, relief=GROOVE)
l14 = Tix.Label(w1, text=t.SLOPE, bd=1, width=10, height=2, relief=GROOVE)
l15 = Tix.Label(w1, text=t.FLUXREC, bd=1, width=14, height=2, relief=GROOVE)
l11.grid (row=0, column=0)
l12.grid (row=0, column=1)
l13.grid (row=0, column=2)
l14.grid (row=0, column=3)
l15.grid (row=0, column=4)
self.w11 = Tix.ScrolledWindow(nb.page1)
self.w11.pack(fill=X)
########################################################
# NoteBook Page 2 - Solveur
########################################################
w2 = Tix.Frame(nb.page2, relief=FLAT)
w2.pack(side=TOP, pady = 10)
l21 = Tix.Label(w2, text=t.NAME, bd=1, width=11, height=2, relief=GROOVE)
l22 = Tix.Label(w2, text=t.MAXITER, bd=1, width=15, height=2, relief=GROOVE)
l23 = Tix.Label(w2, text=t.SOLVPREC, bd=1, width=14, height=2, relief=GROOVE)
l24 = Tix.Label(w2, text=t.TIMEFACTOR, bd=1, width=16, height=2, relief=GROOVE)
l21.grid (row=0, column=0)
l22.grid (row=0, column=1)
l23.grid (row=0, column=2)
l24.grid (row=0, column=3)
self.w21 = Tix.ScrolledWindow(nb.page2)
self.w21.pack(fill=X)
def _initializeWidgets(self):
"""
"""
t = PageText()
for node in self.NPE.var:
for node1 in node[0]:
if not self.NPE.mIsPressure(node1):
Scheme(self.case, self.w11.window, self.check2, self.stbar,
node1, node[1], self.NPE)
Solveur(self.case, self.w21.window, self.check2, self.stbar,
node1, node[1], self.NPE)
#-------------------------------------------------------------------------------
# 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.KEYWORD = "Mot clé Code_Saturne: "
self.SOLVEUR = "SOLVEUR"
self.SCHEME = "SCHEMA"
self.NAME = "Nom"
self.BLENDING = "Proportion schéma\nconvectif ordre 2"
self.ORDER = "Schéma"
self.UPWIND = "Upwind"
self.CENTERED = "Centré"
self.SOLU = "SOLU"
self.SLOPE = "Test\nde pente"
self.FLUXREC = "Reconstruction\ndes flux"
self.TIMEFACTOR = "Facteur\nmultiplicatif du pdt"
self.MAXITER = "Nombre max\nd'itérations"
self.SOLVPREC = "Précision\ndu solveur"
else:
self.KEYWORD = "Code_Saturne key word: "
self.SOLVEUR = "SOLVEUR"
self.SCHEME = "SCHEME"
self.NAME = "Name"
self.BLENDING = "Blending\nFactor"
self.ORDER = "Scheme"
self.UPWIND = "Upwind"
self.CENTERED = "Centered"
self.SOLU = "SOLU"
self.SLOPE = "Slope\nTest"
self.FLUXREC = "Flux\nReconstruction"
self.TIMEFACTOR = "Time Step\nFactor"
self.MAXITER = "Maximum\nIteration Number"
self.SOLVPREC = "Solveur\nPrecision"
# 2) Messages
#
if Tool.GuiParam.lang == 'fr':
pass
else:
pass
#-------------------------------------------------------------------------------
# NumericalParamEquat test case
#-------------------------------------------------------------------------------
class NumericalParamEquatTestCase(unittest.TestCase):
"""
"""
def setUp(self):
"""
This method is executed before all "check" methods.
"""
from Base.XMLengine import Case
from Base.XMLinitialize import XMLinit
Tool.GuiParam.lang = 'en'
self.case = Case(None)
XMLinit(self.case)
def tearDown(self):
"""
This method is executed after all "check" methods.
"""
del self.case
def checkNumericalParamEquatInstantiation(self):
"""
Check whether the NumericalParamEquatModel class could be instantiated
"""
model = None
model = NumericalParamEquatModel(self.case)
assert model != None, 'Could not instantiate NumericalParamEquatModel'
def checkGetScheme(self):
"""
Check whether the NumericalParamEquatModel class could get scheme
"""
model = None
model = NumericalParamEquatModel(self.case)
resu = model.mGetScheme(model.var[0][0][1])
test = 'centered'
assert resu == test, 'Could not get Scheme'
def checkGetBlendingFactor(self):
"""
Check whether the NumericalParamEquatModel class could get blending factor
"""
model = None
model = NumericalParamEquatModel(self.case)
resu = model.mGetBlendingFactor(model.var[0][0][1])
print "resu ===",resu
test = 1.0
assert resu == test, 'Could not get blending factor'
def checkgetStatusSlopeTest(self):
"""
Check whether the NumericalParamEquatModel class could get slope test
"""
model = None
model = NumericalParamEquatModel(self.case)
resu = model.mGetStatusSlopeTest(model.var[0][0][1])
test = 'on'
assert resu == test, 'Could not get slope test'
def checkgetStatusFluxR(self):
"""
Check whether the NumericalParamEquatModel class could get flux reconstruction
"""
model = None
model = NumericalParamEquatModel(self.case)
resu = model.mGetStatusFluxR(model.var[0][0][1])
test = 'on'
assert resu == test, 'Could not get flux reconstruction'
def checksetFluxR(self):
"""
Check whether the NumericalParamEquatModel class could set flux reconstruction
"""
model = None
model = NumericalParamEquatModel(self.case)
for nn in range(len(model.var[0][0])):
resu = model.var[0][0][nn]
if resu['name'] == 'pressure':
model.mSetFluxR(resu,'off')
res = model.node_vitpre.toString()
test = '<velocity_pressure>'\
'<variable label="Pressure" name="pressure">'\
'<flux_reconstruction status="off"/>'\
'</variable>'\
'<variable label="VelocitU" name="velocity_U"/>'\
'<variable label="VelocitV" name="velocity_V"/>'\
'<variable label="VelocitW" name="velocity_W"/>'\
'<property label="total_pressure" name="total_pressure"/>'\
'</velocity_pressure>'
assert res == test, 'Could not set flux reconstruction'
def checksetTimeStepFactor(self):
"""
Check whether the NumericalParamEquatModel class could set time step factor
"""
model = None
model = NumericalParamEquatModel(self.case)
for nn in range(len(model.var[0][0])):
resu = model.var[0][0][nn]
if resu['name'] == 'pressure':
model.mSetTimeStepFactor(resu,1.1)
res = model.node_vitpre.toString()
test = '<velocity_pressure>'\
'<variable label="Pressure" name="pressure">'\
'<time_step_factor>1.1</time_step_factor>'\
'</variable>'\
'<variable label="VelocitU" name="velocity_U"/>'\
'<variable label="VelocitV" name="velocity_V"/>'\
'<variable label="VelocitW" name="velocity_W"/>'\
'<property label="total_pressure" name="total_pressure"/>'\
'</velocity_pressure>'
assert res == test, 'Could not set time step factor'
def suite():
testSuite = unittest.makeSuite(NumericalParamEquatTestCase, "check")
return testSuite
def runTest():
runner = unittest.TextTestRunner()
runner.run(suite())
#-------------------------------------------------------------------------------
# End
#-------------------------------------------------------------------------------
syntax highlighted by Code2HTML, v. 0.9.1