# -*- 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 scalars boundaries model data management.
This module contains the following classes and function:
- ScalarsBoundariesModel
- ScalarBC
- ScalarsBoundariesView
- PageText
- ScalarsBoundariesTestCase
"""
#-------------------------------------------------------------------------------
# Library modules import
#-------------------------------------------------------------------------------
import sys, unittest
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
#-------------------------------------------------------------------------------
# Scalar Boundaries model class
#-------------------------------------------------------------------------------
class ScalarsBoundariesModel(TkPage.Page):
"""
"""
def __init__(self, case):
"""
Constructor
"""
self.case = case
self.radiative = self.case.xmlInitNode('radiative_transfer')
self.thermal = self.case.xmlInitNode('thermal_scalar')
self.node_add_scalar = self.case.xmlInitNode('additional_scalars')
self.node_bc = self.case.xmlInitNode('boundary_conditions')
self.node_def = self.node_bc.xmlInitNode('boundary_definition')
def defaultValues(self, event=None):
"""
default values
"""
return '0'
def mGetThermalModel(self):
from ThermalScalar import ThermalScalarModel
model = ThermalScalarModel(self.case).getThermalScalar()
if model != "off" :
label, u = ThermalScalarModel(self.case).getThermalScalarLabel()
else:
label = ""
del ThermalScalarModel
return model, label
def mGetThermalNode(self, type, label):
thermal, lab = self.mGetThermalModel()
node = self.node_bc.xmlGetChildNode(type, label=label)
node_th = node.xmlGetNodeList('scalar', name=thermal, type='thermal')
return node_th
# TODO: a revoir avec Model de DefineUserScalar
def mGetAddScalarList(self, type, label):
list = []
node = self.node_bc.xmlGetChildNode(type, label=label)
list = node.xmlGetNodeList('scalar', type='user')
return list
def mGetList(self, type, label, str):
list = []
node = self.node_bc.xmlGetChildNode(type, label=label)
list = node.xmlGetNodeList('scalar',type=str)
return list
def mGetNodeBound(self, label):
return self.node_def.xmlGetNodeList(type, label=label)
def mGetRef(self, type, label):
from BoundConditions import BoundaryConditionsModel
valref = BoundaryConditionsModel(self.case).getRef(type, label)
del BoundaryConditionsModel
return valref
def mGetBoundDefList(self, type):
return self.node_def.xmlGetNodeList(type)
#def mGetBoundCondList(self, type, label):
def mGetBoundCondList(self):
return self.node_bc.xmlGetNodeList(type, label)
def mGetListBC(self, node, type, label):
return node.xmlGetNodeList(type, label=label)
def mAddWallChildBC(self, label):
node = self.node_bc.xmlInitChildNode('wall', label=label)
thermal, lab = self.mGetThermalModel()
from DefineBoundaryRegions import DefBCModel
if thermal != 'off': DefBCModel(self.case).setCondTherm(node, 'neumann', thermal, lab, 0.0)
DefBCModel(self.case).setCondScalar(node, 'neumann', 0.0)
del DefBCModel
def mSetDataType(self, node, string, value):
node.xmlSetData(string, value)
def mGetStringNode(self, node, string):
if not node.xmlGetString(string):
self.mSetDataType(node, string, self.defaultValues())
return node.xmlGetString(string)
def mGetChoice(self, node):
return node['choice']
def mSetChoice(self, node, string):
node['choice'] = string
#-------------------------------------------------------------------------------
# ScalarBC class
#-------------------------------------------------------------------------------
class Scalar_BC:
"""
"""
def __init__(self, case, master, check, stbar, node, typeFace, labelBR, color):
"""
"""
self.master = master
self.case = case
self.check = check
self.stbar = stbar
self.typeFace = typeFace
self.balloon = Tix.Balloon(self.master,
statusbar=self.stbar.label,
bd=1, bg='black')
self.balloon.message.config(bg=wm['background'])
self.node = node
self.labelBR = labelBR
#self.nodeBR = self.node.xmlInitNodeList(self.typeFace,label=labelBR)[0]
self.SB = ScalarsBoundariesModel(self.case)
t = PageText()
self.dicoLabelName = {}
self.label = Tix.StringVar()
self.typeCL = Tix.StringVar()
self.value = Tix.DoubleVar()
self.coeff = Tix.DoubleVar()
self.label = self.node['label']
fbc = Tix.Frame(self.master, relief=FLAT)
fbc.pack(side=TOP)
self.lab = Tix.Label(fbc, width=11, text=self.label, fg=color)
self.lab.config(font = fL, bd=2, relief=GROOVE)
self.balloon.bind_widget(self.lab, statusmsg=t.LABEL_SCA,
balloonmsg=t.KEYWORD+"NOMVAR")
self.otype = Tix.OptionMenu(fbc, options='menubutton.width 45')
self.otype.menubutton.config(bd=2, width=8, relief=RAISED)
self.otype.add_command('dirichlet', label=t.DIRICHLET)
self.otype.add_command('neumann', label=t.NEUMANN)
self.otype.add_command('exchCoeff', label=t.COEFF)
self.otype.config(variable=self.typeCL, command=self.getTypeCL)
# self.balloon.bind_widget(but, statusmsg=t.MSG_LISTING,
# balloonmsg=t.KEYWORD+"ILISVR")
self.eValue = Tix.Entry(fbc, width=8, textvariable=self.value)
self.eValue.event_add("<<Event1>>", "<Return>", "<Leave>", "<FocusOut>")
self.eValue.bind("<<Event1>>", self.getValue)
# self.balloon.bind_widget(self.eValue, statusmsg=t.VALUE,
# balloonmsg=t.KEYWORD+"IHISVR")
self.eCoeff = Tix.Entry(fbc, width=8, textvariable=self.coeff)
self.eCoeff.event_add("<<Event2>>", "<Return>", "<Leave>", "<FocusOut>")
self.eCoeff.bind("<<Event2>>", self.getCoeff)
# self.balloon.bind_widget(self.eCoeff, statusmsg=t.EXCH_COEFF,
# balloonmsg=t.KEYWORD+"IHISVR")
self.replace = Tix.Label(fbc, width=9)
if self.typeFace == 'wall':
self.lab.grid (row=0, column=0, padx=4, pady=2, sticky=W)
self.otype.grid (row=0, column=1, padx=4, pady=2, sticky=W)
self.eValue.grid (row=0, column=2, padx=4, pady=2, sticky=W)
elif self.typeFace in [ 'inlet', 'outlet']:
self.lab.grid (row=0, column=0, padx=2, pady=2, sticky=W)
self.otype.grid (row=0, column=1, padx=2, pady=2, sticky=W)
self.eValue.grid (row=0, column=2, padx=2, pady=2, sticky=W)
if self.typeFace == 'inlet':
self.otype.config(state=DISABLED)
if self.typeFace == 'outlet':
self.otype.disable('exchCoeff')
self.replace.grid_forget()
else: pass
# if self.nodeBR:
if self.node:
# Initialization
diriValue = self.SB.mGetStringNode(self.node, 'dirichlet')
if self.typeFace == 'wall':
neumValue = self.SB.mGetStringNode(self.node, 'neumann')
exchValue = self.SB.mGetStringNode(self.node, 'exchange_coefficient')
if self.typeFace == 'outlet':
neumValue = self.SB.mGetStringNode(self.node, 'neumann')
if self.typeFace == 'wall':
self.type = 'neumann'
if self.typeFace == 'outlet':
self.type = 'neumann'
else:
self.type = 'dirichlet'
choice = self.SB.mGetChoice(self.node)
if choice == 'dirichlet':
self.value.set(diriValue)
self.type = 'dirichlet'
self.eCoeff.config(state=DISABLED)
self.eCoeff.grid_forget()
if self.typeFace == 'wall':
self.replace.grid(row=0, column=3, padx=4, pady=2, sticky=W)
else:
self.replace.grid_forget()
elif choice == 'neumann':
self.value.set(neumValue)
self.type = 'neumann'
if self.typeFace == 'wall':
self.eCoeff.grid_forget()
self.replace.grid(row=0, column=3, padx=4, pady=2, sticky=W)
if self.typeFace == 'outlet':
self.otype.disable('exchCoeff')
elif choice == 'exchange_coefficient':
self.value.set(neumValue)
if self.typeFace == 'wall':
self.replace.grid_forget()
self.eCoeff.grid (row=0, column=3, padx=4, pady=2, sticky=W)
self.coeff.set(exchValue)
self.type = 'exchCoeff'
self.typeCL.set(self.type)
def getTypeCL(self, event=None):
tt = self.typeCL.get()
if tt == 'dirichlet':
self.SB.mSetChoice(self.node, 'dirichlet')
value = self.SB.mGetStringNode(self.node, 'dirichlet')
self.value.set(value)
if self.typeFace == 'wall':
self.eCoeff.grid_forget()
self.replace.grid(row=0, column=3, padx=4, pady=2, sticky=W)
elif tt == 'neumann':
self.SB.mSetChoice(self.node, 'neumann')
value = self.SB.mGetStringNode(self.node, 'neumann')
self.value.set(value)
self.eCoeff.grid_forget()
self.replace.grid(row=0, column=3, padx=4, pady=2, sticky=W)
elif tt == 'exchCoeff':
self.replace.grid_forget()
self.eCoeff.grid (row=0, column=3, padx=4, pady=2, sticky=W)
self.SB.mSetChoice(self.node, 'exchange_coefficient')
value = self.SB.mGetStringNode(self.node, 'neumann')
self.value.set(value)
coef = self.SB.mGetStringNode(self.node, 'exchange_coefficient')
self.coeff.set(coef)
def getValue(self, event=None):
self.stbar.busy()
tt = self.typeCL.get()
if self.check.hasType(self.eValue, self.value):
value = self.value.get()
if not value: value = '0'
if tt == 'dirichlet': self.SB.mSetDataType(self.node, 'dirichlet',value)
if tt in ['neumann','exchCoeff']:
self.SB.mSetDataType(self.node, 'neumann',value)
self.stbar.idle()
return self.value.get()
self.stbar.idle()
def getCoeff(self, event=None):
self.stbar.busy()
if self.check.hasType(self.eCoeff, self.coeff):
coeff = self.coeff.get()
if not coeff: coeff = '0'
if self.typeCL.get() == 'exchCoeff':
self.SB.mSetDataType(self.node, 'exchange_coefficient',coeff)
self.stbar.idle()
return self.coeff.get()
self.stbar.idle()
#-------------------------------------------------------------------------------
# Main class
#-------------------------------------------------------------------------------
class ScalarsBoundariesView(TkPage.Page):
"""
Class to open all Scalars (thermal, user and model) Boundary Conditions Page.
Warning: turbulence variables (k, epsilon, Rij) are not considered
like scalars.
"""
def _tkControlVariables(self):
"""
Tkinter variables declaration.
"""
self.valref = Tix.StringVar()
def _pageControl(self):
"""
Xml node declaration and supplementary default value settings.
"""
t = PageText()
self.SB = ScalarsBoundariesModel(self.case)
# Definition of boundaries and scalar types
#
self.typeList = {'wall': t.WALL ,
'inlet': t.INLET ,
'outlet': t.OUTLET }
# Definition of color
#
self.typeColor = {'wall': "blue" ,
'inlet': "red" ,
'outlet': "purple" }
# Initialize variables concerning the display of the Hlist1
#
self.mousePointedEntry1 = None
self.selectedEntry1 = None
self.currentEntry1 = None
self.entriesNumber1 = 0
def selectHList(self, entry=None):
"""
Browsecmd:
Every single Clik on the Button1 of the mouse send TWO signal to the GUI
the first one when man push the button, and the second one when the
button gets back.
Command:
Every double-Click and Return send only ONE signal to the GUI.
"""
self.selectedEntry1 = self.mousePointedEntry1
self.mousePointedEntry1 = entry
if (self.selectedEntry1 == self.mousePointedEntry1
and self.currentEntry1 != self.mousePointedEntry1):
if entry == None:
msg = "There is an error in the use of the HList1.\n"\
"The selectionned entry is:" + entry + "\n" \
"The application will finish."
tkMessageBox.showerror('SELECTED LIST ERROR', msg)
sys.exit(EXIT_FAILURE)
t = PageText()
self.currentEntry1 = entry
# Here we must call the tk function directly without passing in
# Tix.py, because of a bug in tix8.1 in the Hlist.item_cget function
#
h = self.h1.hlist
label = h.tk.call(h, 'item', 'cget', entry, 0, '-text')
type = h.tk.call(h, 'item', 'cget', entry, 1, '-text')
for key in self.typeList.keys():
if self.typeList[key] == type:
type = key
self.h1.hlist.config(selectbackground=self.typeColor[key])
self.s1.pack_forget()
self.f2.pack_forget()
self.s2.pack_forget()
self.f3.pack_forget()
self.f4.pack_forget()
try: self.f31.destroy()
except: pass
try: self.f41.destroy()
except: pass
valref = self.SB.mGetRef(type, label)
self.valref.set(valref)
self._createWidgetsFac(type, label)
def _make_style(self):
"""
Define beautyfull style in order to display columns in the List.
"""
self.style={}
self.style['header'] = Tix.DisplayStyle(Tix.TEXT,
fg='black',
refwindow=self.lf.frame,
anchor=CENTER,
padx=5, pady=2,
font=fB)
for type in self.typeList.keys():
self.style[type+'b'] = Tix.DisplayStyle(Tix.TEXT,
refwindow=self.lf.frame,
padx=5,
fg=self.typeColor[type],
selectforeground='#fefefe',
font=fB)
self.style[type] = Tix.DisplayStyle(Tix.TEXT,
refwindow=self.lf.frame,
padx=5,
anchor=CENTER,
fg=self.typeColor[type],
selectforeground='#fefefe',
font=fN)
def getLambda(self, event=None):
self.check.begin(self.e1)
if self.check2.hasType(self.e1, self.lamb):
return self.lamb.get()
def getEpsilon(self, event=None):
if self.check2.hasType(self.e2, self.epsil):
return self.epsil.get()
def getEpaiss(self, event=None):
if self.check2.hasType(self.e3, self.epais):
return self.epais.get()
def _createHlist(self):
"""
Create the Hlist for the boundary Regions.
"""
t = PageText()
# Put a simple hierachy into the HList (two levels). Use colors and
# separator widgets (frames) to make the list look fancy
#
self.h1 = Tix.ScrolledHList(self.f1,
options='hlist.columns 3 hlist.header 1' )
self.h1.config(scrollbar="auto +y")
self.h1.hlist.config(browsecmd=self.selectHList,
command=self.selectHList,
bg=wm['hlistbackground'])
self.h1.hsb.config(width=10, bd=1)
self.h1.vsb.config(width=10, bd=1)
self.h1.pack(padx=10, pady=10, side=TOP)
self.f5.pack(side=TOP)
# First some styles for the headers
#
self._make_style()
# Create the headers
#
self.h1.hlist.header_create(0, itemtype=Tix.TEXT, text=t.LABEL,
style=self.style['header'])
self.h1.hlist.header_create(1, itemtype=Tix.TEXT, text=t.TYPE,
style=self.style['header'])
# Notice that we use 3 columns in the hlist widget. This way when the user
# expands the windows wide, the right side of the header doesn't look
# chopped off. The following line ensures that the 3 column header is
# not shown unless the hlist window is wider than its contents.
#
self.h1.hlist.column_width(2,0)
# Let configure the appearance of the HList subwidget
#
self.h1.hlist.config(separator='.', width=25, height=11, drawbranch=0, indent=10)
# Let configure the width of the columns
#
self.h1.hlist.column_width(0, chars=16)
self.h1.hlist.column_width(1, chars=9)
def addInHlist(self, type, label):
"""
Create the item list associated with the new boundary definition.
"""
self.stbar.busy()
for key in self.typeList.keys():
if self.typeList[key] == type: type = key
self.entriesNumber = self.entriesNumber + 1
name = 'entry' + repr(self.entriesNumber)
self.h1.hlist.add(name, itemtype=Tix.TEXT,
text=label,
style=self.style[type+'b'])
self.h1.hlist.item_create(name, 1, itemtype=Tix.TEXT,
text=self.typeList[type],
style=self.style[type])
self.stbar.idle()
def _createWidgetsFac(self, typeFac, label_BR):
"""
Create the Page layout.
"""
t = PageText()
self.scal_BC = self.SB.mGetAddScalarList(typeFac, label_BR)
self.scalTh_BC = self.SB.mGetThermalNode(typeFac, label_BR)
self.scalMod_BC = self.SB.mGetList(typeFac, label_BR, 'model')
if self.scal_BC or self.scalTh_BC or self.scalMod_BC:
self.s2.pack(side=TOP, fill=X, pady=10)
if typeFac == 'wall':
self.f3.pack(side=TOP, fill=X, pady=5)
self.f31 = Tix.ScrolledWindow(self.lf.frame, relief=FLAT, height=190)
self.f31.pack(side=TOP, fill=Y)
if 1:
if self.SB.radiative['model'] == "off" or \
self.SB.thermal['model'] == "off":
self.s1.pack_forget()
self.f2.pack_forget()
else:
self.s1.pack(side=LEFT, fill=Y, pady=10)
self.f2.pack(side=LEFT)
elif typeFac in [ 'inlet', 'outlet']:
self.f4.pack(side=TOP, fill=X, pady=5)
self.f41 = Tix.ScrolledWindow(self.lf.frame, relief=FLAT, height=190)
self.f41.pack(side=TOP, fill=Y)
for scalar, color in [(self.scalTh_BC, 'brown'),
(self.scalMod_BC, 'darkgreen'),
(self.scal_BC, 'darkblue')]:
for node in scalar:
if typeFac == 'wall':
w = self.f31.window
elif typeFac in [ 'inlet', 'outlet']:
w = self.f41.window
Scalar_BC(self.case, w, self.check2, self.stbar,
node, typeFac, label_BR, color)
def _createWidgets(self):
"""
Create the Page layout.
"""
t = PageText()
self.lf = Tix.LabelFrame(self.myPage, bd=2, label=t.SCALARS_BOUNDARIES, relief=FLAT)
self.lf.label.config(font=fT)
self.lf.pack(side=TOP, fill=X, padx=6, pady=6)
f0 = Tix.Frame(self.lf.frame, relief=SUNKEN)
f0.pack(side=TOP, anchor=W)
self.f1 = Tix.Frame(f0, relief=SUNKEN)
self.f1.pack(side=LEFT, padx=10)
self.s1 = Tix.Frame(f0, width=2, bd=2, relief=SUNKEN)
self.s1.pack(side=LEFT, fill=Y, pady=10)
self.f2 = Tix.Frame(f0, relief=FLAT)
self.f2.pack(side=LEFT)
self.s2 = Tix.Frame(self.lf.frame, height=2, bd=2, relief=SUNKEN)
self.f5 = Tix.Frame(self.f1, relief=FLAT)
Tix.Label(self.f5, text=t.REF).grid(row=0,column=0,padx=3)
self.ref = Tix.Entry(self.f5, width=25, relief=GROOVE,bd=2,
bg='lightblue', textvariable=self.valref)
self.ref.grid(row=1, column=0, sticky=E)
scroll = Tix.Scrollbar(self.f5, orient=HORIZONTAL, width=10, bd=2,
command=TkPage.Callback(self._scrollHandler, self.ref))
scroll.grid(row=2, column=0, sticky=E+W)
self.ref['xscrollcommand'] = scroll.set
self.ref.config(state=DISABLED)
self.f3 = Tix.Frame(self.lf.frame, relief=FLAT)
self.f4 = Tix.Frame(self.lf.frame, relief=FLAT)
l1 = Tix.Label(self.f3, text=t.NAME, width=12, bd=1, relief=GROOVE)
l2 = Tix.Label(self.f3, text=t.TYPE, width=10, bd=1, relief=GROOVE)
l3 = Tix.Label(self.f3, text=t.VALUE, width=8, bd=1, relief=GROOVE)
l4 = Tix.Label(self.f3, text=t.COEFF1, width=9, bd=1, relief=GROOVE)
l1.grid (row=0, column=0, ipadx=8, ipady=9)
l2.grid (row=0, column=1, ipadx=10, ipady=9)
l3.grid (row=0, column=2, ipadx=8, ipady=9)
l4.grid (row=0, column=3, ipadx=4, ipady=2)
l1 = Tix.Label(self.f4, text=t.NAME, width=10, bd=1, relief=GROOVE)
l2 = Tix.Label(self.f4, text=t.TYPE, width=10, bd=1, relief=GROOVE)
l3 = Tix.Label(self.f4, text=t.VALUE, width=7, bd=1, relief=GROOVE)
l1.grid (row=0, column=0, ipadx=15, ipady=9)
l2.grid (row=0, column=1, ipadx=12, ipady=9)
l3.grid (row=0, column=2, ipadx=10, ipady=9)
self._createHlist()
def _initializeWidgets(self):
"""
Extract resquested informations from XML document.
This informations are used to initialize the widgets.
For this page default values of all widgets are necessary
included in the XML file.
"""
boundList = []
self.entriesNumber = 0
for type in self.typeList.keys():
for node in self.SB.mGetBoundDefList(type):
label = node['label']
if (label,type) not in boundList:
boundList.append((label,type))
self.addInHlist(type, label)
if type == 'wall':
self.SB.mAddWallChildBC(label)
#-------------------------------------------------------------------------------
# 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.BOUNDARY_REGIONS = "Zones de frontière"
self.INLET = "entrée"
self.OUTLET = "sortie"
self.LABEL = "Étiquette"
self.LABEL_SCA = "Nom du scalaire"
self.NUM = "n°"
self.OFF = "non"
self.ON = "oui"
self.SCALARS = "Scalaires"
self.SCALARS_BOUNDARIES = "Conditions aux limites des scalaires"
self.SYMMETRY = "symétrie"
self.TYPE = "Type"
self.UNDEFINED = "indéfini"
self.WALL = "paroi"
self.NAME = "Nom du Scalaire"
self.REF = "Référence(s)"
self.TYPE = "Type"
self.VALUE = "Valeur"
self.COEFF1 = "Coefficient\nd'échange"
self.COEFF = "Coeff. éch."
self.DIRICHLET = "Dirichlet"
self.NEUMANN = "Neumann"
self.KEYWORD = "Mot clé Code_Saturne: "
else:
self.BOUNDARY_REGIONS = "Boundary regions"
self.INLET = "inlet"
self.OUTLET = "outlet"
self.LABEL = "Label"
self.LABEL_SCA = "Scalar name"
self.NUM = " # "
self.OFF = "off"
self.ON = "on"
self.SCALARS = "Scalars"
self.SCALARS_BOUNDARIES = "Scalars boundaries"
self.SYMMETRY = "symmetry"
self.TYPE = "Type"
self.UNDEFINED = "undefined"
self.WALL = "wall"
self.NAME = "Scalar Name"
self.REF = "Referency(ies)"
self.TYPE = "Type"
self.VALUE = "Value"
self.COEFF1 = "Exchange\nCoefficient"
self.COEFF = "Exch. Coeff"
self.DIRICHLET = "Dirichlet"
self.NEUMANN = "Neumann"
self.KEYWORD = "Code_Saturne keyword: "
# 2) Messages
#
if Tool.GuiParam.lang == 'fr':
self.MSG_SYMMETRY = "Aucune information\nutilisateur\nn'est nécessaire"
self.MSG_UNDEFINED = "Intervention utilisateur obligatoire\n"\
"dans le sous-programe USCLIM"
else:
self.MSG_SYMMETRY = "No user input is required"
self.MSG_UNDEFINED = "User-coding is required "\
"in the subroutine USCLIM"
#-------------------------------------------------------------------------------
# TurbulenceModel test case
#-------------------------------------------------------------------------------
class ScalarBoundariesTestCase(unittest.TestCase):
"""
"""
def setUp(self):
"""
This method is executed before all "check" methods.
"""
from Base.XMLengine import Case, XMLDocument
from Base.XMLinitialize import XMLinit
Tool.GuiParam.lang = 'en'
self.case = Case(None)
XMLinit(self.case)
self.doc = XMLDocument()
def tearDown(self):
"""
This method is executed after all "check" methods.
"""
del self.case
del self.doc
def checkScalarBoundariesInstantiation(self):
"""
Check whether the ScalarBoundariesModel class could be instantiated
"""
model = None
model = ScalarsBoundariesModel(self.case)
assert model != None, 'Could not instantiate ScalarBoundariesModel'
def suite():
testSuite = unittest.makeSuite(ScalarBoundariesTestCase, "check")
return testSuite
def runTest():
runner = unittest.TextTestRunner()
runner.run(suite())
#-------------------------------------------------------------------------------
# End
#-------------------------------------------------------------------------------
syntax highlighted by Code2HTML, v. 0.9.1