# -*- 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("<>", "", "", "") self.e1.bind("<>", 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("<>", "", "", "") self.e1.bind("<>", 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("<>", "", "", "") self.e2.bind("<>", 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("<>", "", "", "") self.e3.bind("<>", 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 = ''\ ''\ ''\ ''\ ''\ ''\ ''\ ''\ '' 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 = ''\ ''\ '1.1'\ ''\ ''\ ''\ ''\ ''\ '' 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 #-------------------------------------------------------------------------------