# -*- 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 'Additional user's scalars' page. This module defines the following classes: - MultiSelect - DefineUserScalarsModel - DefineUserScalarsView - PageText """ #------------------------------------------------------------------------------- # Library modules import #------------------------------------------------------------------------------- import string import Tix import 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 from Base.XMLvariables import Variables from Base.XMLvariables import Model from Base.XMLmodel import XMLmodel from DefineBoundaryRegions import DefBCModel #------------------------------------------------------------------------------- # Multi-selection string #------------------------------------------------------------------------------- MULTISEL = "*****" #------------------------------------------------------------------------------- # Hlist multi-selection class #------------------------------------------------------------------------------- class MultiSelect: """ This class is design in order to manage the storage of the selected items in the Hlist. """ def __init__(self, case, Hlist, nodeScalar): """ Constructor """ self.case = case self.Hlist = Hlist self.nodeScalar = nodeScalar def _initList(self): """ For each mouse selection we reinitialize all lists. """ self.labelL = [] self.initL = [] self.variL = [] self.miniL = [] self.maxiL = [] self.mdl = DefineUserScalarsModel(self.case) def scalarInfo(self, entry): """ Return info from the argument 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 # t = PageText() h = self.Hlist label = h.tk.call(h, 'item', 'cget', entry, 0, '-text') init = h.tk.call(h, 'item', 'cget', entry, 1, '-text') vari = h.tk.call(h, 'item', 'cget', entry, 2, '-text') if vari == "--": vari = t.NO_VARIANCE return label, float(init), vari def setItems(self, entriesL): """ Store values when a new selection is done. """ self._initList() for entry in entriesL: label, init, vari = self.scalarInfo(entry) self.labelL.append(label) self.initL.append(init) self.variL.append(vari) list = self.mdl.getUserScalarsNodeList() for scalar in list: if self.mdl.mgetLabelScalar(scalar) == label: mini, maxi = self.mdl.mgetMinMaxValue(scalar) self.miniL.append(mini) self.maxiL.append(maxi) def getItems(self): """ Return all the lists. """ return self.labelL, self.initL, self.variL, self.miniL, self.maxiL def widgetText(self): """ Find the right texts for the widget layout. """ label, init, vari = self.labelL[0], self.initL[0], self.variL[0] mini, maxi = self.miniL[0], self.maxiL[0] for i in self.labelL: if label != i: label = MULTISEL for i in self.initL: if init != i: init = MULTISEL for i in self.variL: if vari != i: vari = MULTISEL for i in self.miniL: if not i: i = 0 if mini != i: mini = MULTISEL for i in self.maxiL: if not i: i = 1.0e+12 if maxi != i: maxi = MULTISEL if init != MULTISEL: init = "%g" % (init) if mini != MULTISEL: mini = "%g" % (mini) if maxi != MULTISEL: maxi = "%g" % (maxi) return label, init, vari, mini, maxi #------------------------------------------------------------------------------- # Define User Scalars model class #------------------------------------------------------------------------------- class DefineUserScalarsModel(Variables, Model): """ """ def __init__(self, case): """ Constructor """ self.case = case # TODO: the InitZoneView class ! zone_label = "1" self.zone = zone_label self.node_th_sca = self.case.xmlGetNode('thermal_scalar') self.node_user_sca = self.case.xmlGetNode('additional_scalars') self.node_bc = self.case.xmlGetNode('boundary_conditions') self.dicoCoeff = {} def defaultValues(self): """Return the default values""" pass def getScalarList(self): """Return the User scalar label list (thermal scalar included)""" list = [] model = self.node_th_sca['model'] if model != 'off': list.append(self.node_th_sca.xmlGetNodeList('scalar', name=model)['label']) for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): list.append(n['label']) return list def getUserScalarList(self): """Return the User scalar label list (without thermal scalar)""" list = [] for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): list.append(n['label']) return list def setNewUserScalar(self, scalar_label): """Input a new additional_scalar with label scalar_label""" Variables(self.case).setNewUserScalar(self.node_user_sca, scalar_label) def deleteUserScalar(self, scalar_label): """Delete an additional_scalar node with label scalar_label""" for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n.xmlRemoveNode() def setScalarInitialValue(self, scalar_label, zone, initial_value): """ Put initial value for an additional_scalar with label scalar_label and zone zone """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n.xmlInitChildNode('initial_value', zone=zone) n.xmlSetData('initial_value', initial_value) def getScalarInitialValue(self, scalar_label, zone): """ Get initial value from an additional_scalar with label scalar_label and zone zone """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_init = n.xmlGetChildNode('initial_value', zone=zone) if n_init: val = n.xmlGetDouble('initial_value') return val def setScalarMinValue(self, scalar_label, min_value): """Put minimal value for an additional_scalar with label scalar_label""" for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: ## n_min = n.xmlInitChildNode('min_value') ## n_min.xmlSetData(min_value) n.xmlSetData('min_value', min_value) def getScalarMinValue(self, scalar_label): """Get minimal value from an additional_scalar with label scalar_label""" for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_min = n.xmlGetChildNode('min_value') if n_min: min_val = n.xmlGetDouble('min_value') return min_val def setScalarMaxValue(self, scalar_label, max_value): """Put maximal value for an additional_scalar with label scalar_label""" for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n.xmlSetData('max_value', max_value) def getScalarMaxValue(self, scalar_label): """Get maximal value from an additional_scalar with label scalar_label""" for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_max = n.xmlGetChildNode('max_value') if n_max: max_val = n.xmlGetDouble('max_value') return max_val def setScalarVariance(self, scalar_label, variance_label): """Put variance of an additional_scalar with label scalar_label""" for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n.xmlSetData('variance',variance_label) def getScalarVariance(self, scalar_label): """Get variance of an additional_scalar with label scalar_label""" for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_var = n.xmlGetChildNode('variance') if n_var: var = n.xmlGetString('variance') return var def setScalarDiffusivity(self, scalar_label, diffusivity_label, initial_value): """ Put initial value of property "diffusivity" for an additional_scalar with label scalar_label """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_dif = n.xmlInitChildNode('property', label=diffusivity_label) n_dif.xmlSetData('initial_value',initial_value) def getScalarDiffusivityLabel(self, scalar_label): """ Get label of diffusivity's property for an additional_scalar with label scalar_label """ lab_diff = '' for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_diff = n.xmlGetChildNode('property') if n_diff: lab_diff = n_diff['label'] return lab_diff def setScalarDiffusivityLabel(self, scalar_label, diffusivity_label): """ Put label of diffusivity's property for an additional_scalar with label scalar_label """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_dif = n.xmlInitChildNode('property') n_dif['label'] = diffusivity_label def getScalarDiffusivityInitialValue(self, scalar_label): """ Get initial value of diffusivity's property for an additional_scalar with label scalar_label """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_diff = n.xmlGetChildNode('property') if n_diff: diffu = n.xmlGetDouble('initial_value') return diffu def setScalarDiffusivityInitialValue(self, scalar_label, initial_value): """ Set initial value of diffusivity's property for an additional_scalar with label scalar_label """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_diff = n.xmlInitChildNode('property') n_diff.xmlSetData('initial_value', initial_value) def getScalarDiffusivityChoice(self, scalar_label): """ Get choice of diffusivity's property for an additional_scalar with label scalar_label """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_diff = n.xmlGetChildNode('property') if n_diff: choice = n_diff['choice'] return choice def setScalarDiffusivityChoice(self, scalar_label, choice): """ Set choice of diffusivity's property for an additional_scalar with label scalar_label """ for n in self.node_user_sca.xmlGetNodeList('scalar', type='user'): if n['label'] == scalar_label: n_diff = n.xmlGetChildNode('property') if n_diff : n_diff['choice'] = choice else: n.xmlInitChildNode('property', choice=choice) def getUserScalarsNodeList(self): """ Get list of scalar'nodes """ return self.node_user_sca.xmlGetChildNodeList('scalar') def mgetLabelScalar(self, node): """ Input the new label in scalar's node """ return node['label'] def mgetMinMaxValue(self, node): """ Get min and max scalar'nodes """ mini = node.xmlGetChildDouble('min_value') maxi = node.xmlGetChildDouble('max_value') return mini, maxi def mgetLabInitVariScalar(self, scalar): """ Get label, initial value and variancy of the scalar """ label = scalar['label'] init = scalar.xmlGetChildDouble('initial_value', zone=self.zone) vari = scalar.xmlGetChildString('variance') if not vari : node_diff = scalar.xmlGetNode('property', 'label') self.dicoCoeff[label] = node_diff['label'] return label, init, vari def mgetNewScalar(self, node, tag, name): """ Add new scalar in node 'self.node_user_sca' or 'self.node_bc' in XML doc. """ # for new scalar newChild = Variables(self.case).setNewUserScalar(node, name) # for boundary conditions for node in self.node_bc.xmlGetChildNodeList('inlet'): DefBCModel(self.case).setCondScalar(node, 'dirichlet', '0.0') for node in self.node_bc.xmlGetChildNodeList('outlet'): DefBCModel(self.case).setCondScalar(node, 'neumann', '0.0') return newChild def addDiffusivityProperty(self, node, coeff): """ """ n = Variables(self.case).setNewFluidProperty(node, 'diffusion_coefficient', coeff) n.xmlSetData('initial_value', self.getMolecularViscosity()) def getMolecularViscosity(self): """ """ coeff = 1.0 node0 = self.case.xmlInitNode('physical_properties') node1 = node0.xmlGetNode('fluid_properties') if node1: node2 = node1.xmlGetNode('property', name='molecular_viscosity') if node2: coeff = node2.xmlGetChildDouble('initial_value') return coeff def mReplaceScalar(self, node, init, vari, mini, maxi, nameCoeff): """ Replace the old values by new ones into the XML doc """ t = PageText() node.xmlInitChildNode('initial_value', zone=self.zone) node.xmlSetData('initial_value', init) if vari != t.NO_VARIANCE: node.xmlSetData('variance', vari) node.xmlRemoveChild('property') node.xmlRemoveChild('min_value') node.xmlRemoveChild('max_value') else: node.xmlRemoveChild('variance') node.xmlSetData('min_value', mini) node.xmlSetData('max_value', maxi) if nameCoeff: self.addDiffusivityProperty(node, nameCoeff) def mputNewLabelintoBoundCondScalar(self, old_label, new_label): """ Replace the old label by new ones into boundary conditions for scaar in the XML doc """ for nature in ('inlet','outlet','wall'): for node in self.node_bc.xmlGetChildNodeList(nature): for n in node.xmlGetChildNodeList('scalar', type='user'): if n['label'] == old_label: n['label'] = new_label def mSetScalar(self, label, nameCoeff, init, vari, mini, maxi): """ Add the new values to the XML doc """ newChild = self.mgetNewScalar(self.node_user_sca, 'label', label) self.mReplaceScalar(newChild, init, vari, mini, maxi, nameCoeff) for node in self.node_bc.xmlGetChildNodeList('inlet'): DefBCModel(self.case).setCondScalar(node, 'dirichlet', '0.0') for node in self.node_bc.xmlGetChildNodeList('outlet'): DefBCModel(self.case).setCondScalar(node, 'neumann', '0.0') def msetLabelScalar(self, node, label): """ Inpur the new label in scalar's node """ node['label'] = label def mverifVariance(self, label): """ """ vari = 0 for node in self.node_user_sca.xmlGetNodeList('scalar', 'label'): if node['label'] == label: if node.xmlGetString('variance'): vari = 1 return vari def msetNewLabelintoVariance(self, old_label, new_label): """ Put the new label if scalr with new label has one variancy """ label_dico = "" for node in self.node_user_sca.xmlGetNodeList('scalar'): if node.xmlGetString('variance') == old_label: node.xmlSetData('variance', new_label) label_dico = node['label'] return label_dico def mputDeleteIntoScalarVariance(self, label): """ Put "delete" in node variance of scalar named label It will be destroyed after """ lab_vari="" list = self.node_user_sca.xmlGetNodeList('scalar') for node in list: variance = node.xmlGetString('variance') if variance == label: node['type'] = 'todelete' lab_vari = node['label'] #self.mputDeleteIntoScalar(node['label']) return lab_vari def mputDeleteIntoScalar(self, label): """ Put "delete" in node scalar named label It will be destroyed after """ # Normally there is only one node in nodeList and in nodeListBC # list = self.node_user_sca.xmlGetNodeList('scalar', label=label) for node in list: node['type'] = 'todelete' def mDeleteBoundaryScalar(self, label): """ Put "delete" in node scalar named label It will be destroyed after """ for nature in ('inlet','outlet','wall'): for node in self.node_bc.xmlGetChildNodeList(nature): for n in node.xmlGetChildNodeList('scalar', type='user'): if n['label'] == label: n.xmlRemoveNode() def mcancelNode(self): """ Cancel node in xml file """ nodeList1 = self.node_user_sca.xmlGetNodeList('scalar', type='todelete') for node in nodeList1: node.xmlRemoveNode() #------------------------------------------------------------------------------- # Main class #------------------------------------------------------------------------------- class DefineUserScalarsView(TkPage.Page): """ Class to open Define User Scalars Page. """ def _dependsPages(self, name): """ Construction of the list of dependencies Pages. """ # self.case[name]['depends'] = ['scalar/prosca', # 'bounda/scalar'] self.case[name]['depends'] = ['scalar/prosca'] def _pageControl(self): """ Default value settings. """ # Class attribute 'self.currentEntry' represents the selected entries # in the Hlist with information allready displayed in the widgets. # In the other side, 'self.selectedEntry' contents the last selected entries # from the Hlist to be displayed (but not yet). If 'self.currentEntry' and # 'self.selectedEntry' are different so the 'self.selectedEntry' becomes # the 'self.currentEntry'. # self.selectedEntry = None self.currentEntry = None self.entriesNumber = 0 self.dicolabel = {} self.mdl = DefineUserScalarsModel(self.case) def _make_style(self): """ Define beautiful style in order to display columns in the Hlist. """ self.style={} self.style['header'] = Tix.DisplayStyle(Tix.TEXT, refwindow=self.lf1, anchor=CENTER, padx=5, pady=2, font=fB) self.style['style'+'b'] = Tix.DisplayStyle(Tix.TEXT, refwindow=self.lf1, padx=5, selectforeground='#fefefe', font=fB) self.style['styleV'+'b'] = Tix.DisplayStyle(Tix.TEXT, refwindow=self.lf1, padx=5, fg='brown', font=fB) self.style['style'] = Tix.DisplayStyle(Tix.TEXT, refwindow=self.lf1, padx=5, anchor=CENTER, selectforeground='#fefefe', font=fN) self.style['styleV'] = Tix.DisplayStyle(Tix.TEXT, refwindow=self.lf1, padx=5, anchor=CENTER, fg='brown', font=fN) def _tkControlVariables(self): """ Tkinter variables declaration. Note: 'self.init', 'self.mini' and 'self.maxi' are StringVar() and not a DoubleVar() because of the 'MULTISEL' contents possibility. """ self.label = Tix.StringVar() self.init = Tix.StringVar() self.vari = Tix.StringVar() self.mini = Tix.StringVar() self.maxi = Tix.StringVar() def getLabel(self, event=None): """ Return the label of the scalar. If there is no user label, we propose one. Space is forbidden in the scalar label. """ t = PageText() if self.mdl.dicoCoeff: i = 1 while (("Dv"+str(i)) in self.mdl.dicoCoeff.values()) \ or (("scalar"+str(i)) in self.mdl.dicoCoeff.keys()): i = i + 1 num = str(i) else: num = str(1) if not self.label.get(): self.label.set("scalar" + num) diffCoeff = "Dscal" + num if len(self.label.get()) > 8: self.stbar.set(t.MSG_LABEL) self.label.set(string.join(string.split(self.label.get()), '_')[:8]) self.mdl.dicoCoeff[self.label.get()] = diffCoeff return self.label.get(), diffCoeff def getVari(self, event=None): """ Return the variance value from the ComboBox. """ t = PageText() self.e4.config(state=NORMAL) self.e5.config(state=NORMAL) self.l4.config(state=NORMAL) self.l5.config(state=NORMAL) if self.vari.get() == "": self.vari.set(t.NO_VARIANCE) elif self.vari.get() != t.NO_VARIANCE: self.mini.set('0.0') self.maxi.set(SPGRAND) self.e4.config(state=DISABLED) self.e5.config(state=DISABLED) self.l4.config(state=DISABLED) self.l5.config(state=DISABLED) return self.vari.get() def isFloat(self, entry, var): """ Verify if the 'entry' contents a float. If not, signal an error and return None. """ try: double = float(var.get()) except: self.check2.error(entry) double = None return double def string2float(self, entry, var): """ If the StringVar() 'var' associated to the 'entry', is not a 'MULTISEL', convert it to a float. """ self.check2.begin(entry) # Several selections in Hlist # if self.currentEntry and len(self.currentEntry) > 1: if var.get() != MULTISEL: double = self.isFloat(entry, var) else: double = MULTISEL # Only one selection in Hlist # else: double = self.isFloat(entry, var) return double def getInit(self, event=None): """ Return the initialization value, which can be 1) a float, if all selections have the same initialization value, 2) a 'MULTISEL' string if all selections have not the same initialization value, 3) 'None' if there is an error. """ if not self.init.get(): self.init.set('0.0') return self.string2float(self.e2, self.init) def getMini(self, event=None): """ Return the min value, which can be 1) a float, if all selections have the same min value, 2) a 'MULTISEL' string if all selections have not the same min value, 3) 'None' if there is an error. """ if not self.mini.get(): self.mini.set(SMGRAND) return self.string2float(self.e4, self.mini) def getMaxi(self, event=None): """ Return the min value, which can be 1) a float, if all selections have the same max value, 2) a 'MULTISEL' string if all selections have not the same max value, 3) 'None' if there is an error. """ if not self.maxi.get(): self.maxi.set(SPGRAND) return self.string2float(self.e5, self.maxi) def insertHlist(self, label, init, vari): """ Create the item Hlist associated with the new boundary definition and update the listBox """ self.stbar.busy() t = PageText() self.entriesNumber = self.entriesNumber + 1 scal_num = 'item' + str(self.entriesNumber) self.dicolabel[label] = scal_num if vari == t.NO_VARIANCE: vari = "--" # If the scalar is a variance, it is displayed with a specific color. # if vari != "--": self.h.hlist.add(scal_num, itemtype=Tix.TEXT, text=label, style=self.style['styleV'+'b']) self.h.hlist.item_create(scal_num, 1, itemtype=Tix.TEXT, text="%g"%(init), style=self.style['styleV']) self.h.hlist.item_create(scal_num, 2, itemtype=Tix.TEXT, text=vari, style=self.style['styleV']) else: self.h.hlist.add(scal_num, itemtype=Tix.TEXT, text=label, style=self.style['style'+'b']) self.h.hlist.item_create(scal_num, 1, itemtype=Tix.TEXT, text="%g"%(init), style=self.style['style']) self.h.hlist.item_create(scal_num, 2, itemtype=Tix.TEXT, text=vari, style=self.style['style']) self.e3.insert(END, label) self.stbar.idle() def replaceHlist(self, item, label, init, vari): """ Update the 'item' into the Hlist. """ self.stbar.busy() t = PageText() self.dicolabel[label] = item if vari == t.NO_VARIANCE: vari = "--" # If the scalar is a variance, it is displayed with a specific color. # if vari != "--": self.h.hlist.item_configure(item, 0, itemtype=Tix.TEXT, text=label, style=self.style['styleV'+'b']) self.h.hlist.item_configure(item, 1, itemtype=Tix.TEXT, text="%g"%(init), style=self.style['styleV']) self.h.hlist.item_configure(item, 2, itemtype=Tix.TEXT, text=vari, style=self.style['styleV']) else: self.h.hlist.item_configure(item, 0, itemtype=Tix.TEXT, text=label, style=self.style['style'+'b']) self.h.hlist.item_configure(item, 1, itemtype=Tix.TEXT, text="%g"%(init), style=self.style['style']) self.h.hlist.item_configure(item, 2, itemtype=Tix.TEXT, text=vari, style=self.style['style']) self.stbar.idle() def eraseEntries(self, event=None): """ Delete all caracters in the entries. """ t = PageText() self.e1.config(state=NORMAL) self.e1.delete(0, END) self.e2.delete(0, END) self.vari.set(t.NO_VARIANCE) self.e4.delete(0, END) self.e5.delete(0, END) def checkInitMinMax(self, name, init, mini, maxi): """ Verify the coherence between init, mini and maxi """ OK = 1 if mini > maxi: t = PageText() Dialog.ShowInfo(self.master, title=t.INFO, text=t.MSG_CLIPPING+name) elif init < mini or init > maxi: t = PageText() Dialog.ShowInfo(self.master, title=t.WARNING, text=t.MSG_INIT+name) OK = 0 return OK def createHlist(self,event=None): """ Upload contents of the definition widget when the "Create" button is pushed. """ self.stbar.busy() t = PageText() # Get back data from entries # label, nameCoeff = self.getLabel() vari = self.getVari() init = self.getInit() if init != None: mini = self.getMini() if init != None and mini != None: maxi = self.getMaxi() # Verify if everything is OK # if not self.mdl.mverifVariance(vari) : if label not in self.e3.slistbox.listbox.get(0,END) and \ label != MULTISEL and init != None and \ mini != None and maxi != None: if self.checkInitMinMax(label, init, mini, maxi): # Update the Hlist and the XML doc with the new data # self.insertHlist(label, init, vari) self.mdl.mSetScalar(label, nameCoeff, init, vari, mini, maxi) else: self.stbar.set(t.MSG_VARIANCE) self.eraseEntries() self.currentEntry = None self.selectHlist() self.stbar.idle() def setEditedValueHlist(self, node, entry, old_label, old_init, old_vari, old_mini, old_maxi): """ Checking consistency of values and interpreting complexe entry for reference if necessary. """ t = PageText() # Get back data from entries # new_label, diffCoeff = self.getLabel() new_vari = self.getVari() new_init = self.getInit() if new_init != None: new_mini = self.getMini() if new_init != None and new_mini != None: new_maxi = self.getMaxi() # Verify if everything is OK # if not self.mdl.mverifVariance(new_vari) : if (new_label == old_label or new_label not in self.e3.slistbox.listbox.get(0,END) ) and \ new_vari != old_label and new_init != None and \ new_mini != None and new_maxi != None: if new_init == MULTISEL: new_init = old_init if new_mini == MULTISEL: new_mini = old_mini if new_maxi == MULTISEL: new_maxi = old_maxi if new_label == MULTISEL: new_label = old_label if new_vari == MULTISEL: new_vari = old_vari if self.checkInitMinMax(old_label, new_init, new_mini, new_maxi): # Update the Hlist and the XML doc with the new data # del self.dicolabel[old_label] self.replaceHlist(entry, new_label, new_init, new_vari) self.mdl.mReplaceScalar(node, new_init, new_vari, new_mini, new_maxi, diffCoeff) # What to do if the label has changed? # if new_label != MULTISEL and new_label != old_label: # Input the new label of the scalar in 'self.node_user_sca' # self.mdl.msetLabelScalar(node, new_label) # If the scalar with the new label has a variance # label_dico = self.mdl.msetNewLabelintoVariance(old_label, new_label) if label_dico: item = self.dicolabel[label_dico] self.h.hlist.item_configure(item, 2, itemtype=Tix.TEXT, text=new_label, style=self.style['styleV']) # Update the listbox # list = self.e3.slistbox.listbox.get(0,END) for index in range(len(list)): if list[index] == old_label: self.e3.slistbox.listbox.delete(index) self.e3.insert(index, new_label) # Input the new label of the scalar in 'self.node_bc' # self.mdl.mputNewLabelintoBoundCondScalar(old_label, new_label) else: self.stbar.set(t.MSG_VARIANCE) self.stbar.idle() def editHlist(self, event=None): """ Modify previous selected entries. A new node is created with the new specifications and the previous ChildNodes are cloned in order to taking into account the user's boundary conditions if they exist. """ if not self.currentEntry: return self.stbar.busy() label, init, vari, mini, maxi = self.select.getItems() # Search of the nodes to modify # for i in range(len(self.currentEntry)): entry = self.currentEntry[i] list = self.mdl.getUserScalarsNodeList() for node in list: # Modify the node's properties one by one # #labl, init, vari = self.mdl.mgetLabInitVariScalar(node) #if node['label'] == label[i]: if self.mdl.mgetLabelScalar(node) == label[i]: self.setEditedValueHlist(node, entry, label[i], init[i], vari[i], mini[i], maxi[i]) self.selectHlist() self.stbar.idle() def cancelScalar(self, label): """ Just delete the current selected entries from the Hlist and of course from the XML file. """ # If the scalar has a variance, it will be destroyed too # lab_vari = self.mdl.mputDeleteIntoScalarVariance(label) if lab_vari: self.cancelScalar(lab_vari) # Normaly there is only one node in nodeList and in nodeListBC # self.mdl.mputDeleteIntoScalar(label) self.mdl.mDeleteBoundaryScalar(label) # Delete the scalar from the listbox # list = self.e3.slistbox.listbox.get(0,END) for index in range(len(list)): if list[index] == label: self.e3.slistbox.listbox.delete(index) # Delete boundary region from the Hlist # self.h.hlist.delete_entry(self.dicolabel[label]) self.entriesNumber = self.entriesNumber + 1 del self.dicolabel[label] del self.mdl.dicoCoeff[label] def cancelHlist(self, event=None): """ Just delete the current selected entries from the Hlist and of course from the XML file. """ if not self.currentEntry: return self.stbar.busy() for entry in self.currentEntry: try: label, init, vari = self.select.scalarInfo(entry) self.cancelScalar(label) except :pass self.mdl.mcancelNode() self.eraseEntries() self.currentEntry = None self.selectHlist() self.stbar.idle() 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.selectedEntry = self.h.hlist.info_selection() if not self.selectedEntry: self.l1.config(state=NORMAL) self.l3.config(state=NORMAL) self.e1.config(state=NORMAL) self.e3.config(state=NORMAL) self.e4.config(state=NORMAL) self.e5.config(state=NORMAL) self.l4.config(state=NORMAL) self.l5.config(state=NORMAL) elif self.currentEntry != self.selectedEntry: self.currentEntry = self.selectedEntry self.select.setItems(self.currentEntry) label, init, vari, mini, maxi = self.select.widgetText() self.e1.delete(0,END) self.e1.insert(0,label) self.e1.icursor(END) self.e2.delete(0,END) self.e2.insert(0,init) self.e2.icursor(END) self.vari.set(vari) self.e4.delete(0,END) self.e4.insert(0,mini) self.e4.icursor(END) self.e5.delete(0,END) self.e5.insert(0,maxi) self.e5.icursor(END) if len(self.currentEntry) > 1: self.l1.config(state=DISABLED) self.l3.config(state=DISABLED) self.e1.config(state=DISABLED) self.e3.config(state=DISABLED) else: self.l1.config(state=NORMAL) self.l3.config(state=NORMAL) self.e1.config(state=NORMAL) self.e3.config(state=NORMAL) self.label.set(label) def reloadHlist(self): """ Destroy the contents of the Hlist, and reload the scalar data from the XMLdoc. """ t = PageText() self.entriesNumber = 0 self.dicolabel = {} self.e3.slistbox.listbox.delete(0,END) self.e3.insert(0, t.NO_VARIANCE) self.h.hlist.delete_all() list = self.mdl.getUserScalarsNodeList() for scalar in list: label, init, vari = self.mdl.mgetLabInitVariScalar(scalar) if vari in ("", "no variance", "no_variance"): vari = t.NO_VARIANCE self.insertHlist(label, init, vari) def selectHlistAll(self): """ Fonction for the Popup Menu. Select everything in the Hlist. """ self.reloadHlist() try: first = 'item' + repr(1) last = 'item' + repr(self.entriesNumber) self.h.hlist.selection_set(first, last) self.currentEntry = None self.selectHlist() except: pass def cancelSelection(self): """ Fonction for the Popup Menu. Blank the selection. """ self.h.hlist.selection_clear() self.eraseEntries() self.currentEntry = None self.selectHlist() def _createWidgets(self): """ Page layout """ t = PageText() self.lf1 = Tix.LabelFrame(self.myPage, bd=2, label=t.TITLE, relief=FLAT) self.lf1.label.config(font=fT) self.lf1.pack(side=TOP, fill=X, padx=10, pady=10) # Put a simple hierarchy into the Hlist (two levels). # self.h = Tix.ScrolledHList(self.lf1.frame, options= 'hlist.columns 4 hlist.header 1' ) self.h.config(scrollbar="auto +x +y") self.h.hlist.config(selectmode='extended', browsecmd=self.selectHlist, bg=wm['hlistbackground']) self.h.hsb.config(width=10, bd=1) self.h.vsb.config(width=10, bd=1) self.h.pack(padx=10, pady=10, side=TOP) self.balloon.bind_widget(self.h.hlist, statusmsg=t.MSG_HLIST) # Create the headers # self._make_style() self.h.hlist.header_create(0, itemtype=Tix.TEXT, text=t.NAME, style=self.style['header']) self.h.hlist.header_create(1, itemtype=Tix.TEXT, text=t.INITIAL, style=self.style['header']) self.h.hlist.header_create(2, itemtype=Tix.TEXT, text=t.VARIANCE, style=self.style['header']) # Notice that we use 4 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 4 column header is # not shown unless the Hlist window is wider than its contents. # self.h.hlist.column_width(col=3, width=0) # Let configure the appearance of the Hlist subwidget # self.h.hlist.config(separator='.', width=39, height=11, drawbranch=0, indent=10) # width of the columns # self.h.hlist.column_width(col=0, chars=13) self.h.hlist.column_width(col=1, chars=13) self.h.hlist.column_width(col=2, chars=13) # Create the mouse selection instance # self.select = MultiSelect(self.case, self.h.hlist, self.mdl.node_user_sca) # Popup Menu of Tree # pm = Tix.PopupMenu(self.h.hlist, title=t.POPUP, state=NORMAL) pm.bind_widget(self.h.hlist) pm.menu.add_separator() pm.menu.add_command(label=t.SELECT_ALL, command=self.selectHlistAll) pm.menu.add_command(label=t.UNSELECT, command=self.cancelSelection) pm.menu.m1 = Tix.Menu(pm.menu) ## pm.menu.add_separator() ## pm.menu.m2 = Tix.Menu(pm.menu) ## pm.menu.add_cascade(label=t.OPTION, menu=pm.menu.m2) ## pm.menu.m2.add_command(label=t.BGCOLOR) # Separator # s = Tix.Frame(self.lf1.frame, height=2, bd=2, relief=SUNKEN) s.pack(side=TOP, fill=X) f1 = Tix.Frame(self.lf1.frame, relief=FLAT) f1.pack(side=TOP, fill=X) self.l1 = Tix.Label(f1, text=t.NAME) self.l2 = Tix.Label(f1, text=t.INITIAL) self.l3 = Tix.Label(f1, text=t.VARIANCE) self.l4 = Tix.Label(f1, text=t.MIN) self.l5 = Tix.Label(f1, text=t.MAX) self.l1.grid(row=0, column=0, padx=3, pady=2, sticky=E) self.l2.grid(row=1, column=0, padx=3, pady=2, sticky=E) self.l3.grid(row=2, column=0, padx=3, pady=2, sticky=E) self.l4.grid(row=3, column=0, padx=3, pady=2, sticky=E) self.l5.grid(row=4, column=0, padx=3, pady=2, sticky=E) self.balloon.bind_widget(self.l4, balloonmsg=t.KEYWORD+'SCAMIN') self.balloon.bind_widget(self.l5, balloonmsg=t.KEYWORD+'SCAMAX') self.e3 = Tix.ComboBox(f1, editable=0, bd=2, listwidth=50, selectmode="", variable=self.vari) self.e3.entry.config(width=15, bg=wm['textbackground']) self.e3.slistbox.config(height=100, scrollbar="auto") self.e3.slistbox.vsb.config(width=10, bd=1) self.e3.slistbox.hsb.config(width=10, bd=1) ## self.e3.event_add("<>", "", "") ## self.e3.bind("<>", self.getVari) self.e1 = Tix.Entry(f1, bd=2, width=15, textvariable=self.label) self.e2 = Tix.Entry(f1, bd=2, width=15, textvariable=self.init) self.e4 = Tix.Entry(f1, bd=2, width=10, textvariable=self.mini) self.e5 = Tix.Entry(f1, bd=2, width=10, textvariable=self.maxi) self.e1.grid(row=0, column=1, padx=5, pady=2, sticky=W) self.e2.grid(row=1, column=1, padx=5, pady=2, sticky=W) self.e3.grid(row=2, column=1, pady=2, sticky=W) self.e4.grid(row=3, column=1, padx=5, pady=2, sticky=W) self.e5.grid(row=4, column=1, padx=5, pady=10, sticky=W) self.balloon.bind_widget(self.e4, balloonmsg=t.KEYWORD+'SCAMIN') self.balloon.bind_widget(self.e5, balloonmsg=t.KEYWORD+'SCAMAX') box1 = Tix.ButtonBox(f1, orientation=VERTICAL, relief=FLAT) box1.add('create', text=t.CREATE, command=self.createHlist) box1.add('modify', text=t.MODIFY, command=self.editHlist) box1.add('erase', text=t.ERASE, command=self.cancelHlist) box1.grid(row=0, column=2, rowspan=4, padx=15, pady=0, sticky=W) self.e3.config(bg=wm['textbackground'], command=self.getVari) def _initializeWidgets(self): """ Get XML previous value. """ t = PageText() self.reloadHlist() self.cancelSelection() self.vari.set(t.NO_VARIANCE) # on rajoute le scalaire thermique dans la liste des variances label = XMLmodel(self.case).getThermalScalarLabel() if label: self.e3.insert(0, 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.CREATE = "Créer" self.DEFINITION = "DÉFINITION\nINITIALISATION" self.ERASE = "Effacer" self.INITIAL = "Valeur\ninitiale" self.MAX = "Valeur\nmaximale" self.MIN = "Valeur\nminimale" self.MODIFY = "Modifier" self.NAME = "Nom" self.NO_VARIANCE = "pas de variance" self.POPUP = "Menu popup" self.SELECT_ALL = "Tout sélectionner" self.TITLE = "Définition des scalaires et Initialisation" self.UNSELECT = "Désélectionner" self.VARIANCE = "Variance" self.INFO = "Information" self.WARNING = "Attention" self.KEYWORD = "Mot clé Code_Saturne : " else: self.CREATE = "Create" self.DEFINITION = "DEFINITION\nINITIALIZATION" self.ERASE = "Erase" self.INITIAL = "Initial\nvalue" self.MAX = "Maximal\nvalue" self.MIN = "Minimal\nvalue" self.MODIFY = "Modify" self.NAME = "Name" self.NO_VARIANCE = "no variance" self.POPUP = "Menu popup" self.SELECT_ALL = "Select all" self.TITLE = "User Scalar Definition and Initialization" self.UNSELECT = "Unselect" self.VARIANCE = "Variance" self.INFO = "Information" self.WARNING = "Warning" self.KEYWORD = "Code_Saturne key word: " # 2) Messages # if Tool.GuiParam.lang == 'fr': self.MSG_HLIST = "Cliquer le bouton droit pour " \ "le menu contextuel." self.MSG_CLIPPING = "La valeur minimale est supérieure à la valeur "\ "maximale. Il n'y aura donc pas de clipping "\ "pour le scalaire :\n\n" self.MSG_INIT = "La valeur initial doit être comprise entre les "\ "valeurs minimale et maximale du scalaire :\n\n" self.MSG_LABEL = "Le nom du scalaire est coupé à 8 caractères" self.MSG_VARIANCE = "Un scalaire ne peut pas être la variance d'une variance" else: self.MSG_HLIST = "Click right button for popup menu." self.MSG_CLIPPING = "The minimal value is greater than the maximal "\ "value. Therefore there will be no clipping for the "\ "scalar named:\n\n" self.MSG_INIT = "The initial value must be set between the "\ "minimal and the maximal value of the scalar "\ "named:\n\n" self.MSG_LABEL = "Only 8 characters are kept for Scalar name" self.MSG_VARIANCE = "Scalar can't be variance of another variance" #------------------------------------------------------------------------------- # DefineUsersScalars test case #------------------------------------------------------------------------------- class UserScalarTestCase(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 def checkDefineUserScalarsModelInstantiation(self): """Check whether the DefineUserScalarsModel class could be instantiated.""" model = None model = DefineUserScalarsModel(self.case) assert model != None, 'Could not instantiate DefineUserScalarsModel' def checkSetNewUserScalar(self): """Check whether the DefineUserScalarsModel class could be set new scalar.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') truc = model.node_user_sca.toString() doc = ''\ ''\ '' assert doc == truc, 'Could not set a new scalar' def checkGetScalarList(self): """Check whether the DefineUserScalarsModel class could be get list.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setNewUserScalar('tutu') list = model.getScalarList() assert list == ['toto', 'titi', 'tutu'], 'Could not get list' def checkGetUserScalarList(self): """Check whether the DefineUserScalarsModel class could be get user list.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setNewUserScalar('tutu') list = model.getUserScalarList() assert list == ['toto', 'titi', 'tutu'], 'Could not get user scalar list' def checkDeleteUserScalar(self): """Check whether the DefineUserScalarsModel class could be delete one scalar from user list.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setNewUserScalar('tutu') model.deleteUserScalar('titi') list = model.getUserScalarList() assert list == ['toto', 'tutu'], 'Could not delete user scalar list' def checkSetScalarInitialValue(self): """Check whether the DefineUserScalarsModel class could be set initial value.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setScalarInitialValue('toto', '1', 0.05) truc = model.node_user_sca.toString() doc = ''\ ''\ '0.05'\ ''\ '' assert doc == truc, 'Could not set initial value to user scalar' def checkGetScalarInitialValue(self): """Check whether the DefineUserScalarsModel class could be get initial value.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setScalarInitialValue('toto', '1', '0.05') value = model.getScalarInitialValue('toto','1') assert value == 0.05,'Could not get initial value to user scalar' def checkSetScalarMinMaxValue(self): """Check whether the DefineUserScalarsModel class could be set min and max value.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setScalarInitialValue('toto', '1', 0.05) model.setScalarMinValue('toto',0.01) model.setScalarMaxValue('toto',100.) truc = model.node_user_sca.toString() doc = ''\ ''\ '0.05'\ '0.01'\ '100'\ ''\ ''\ '' assert doc == truc,'Could not set min ansd max value to user scalar' def checkGetScalarMinMaxValue(self): """Check whether the DefineUserScalarsModel class could be get min and max value.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setScalarInitialValue('toto', '1', 0.05) model.setScalarMinValue('toto',0.01) model.setScalarMaxValue('toto',100.) truc = model.node_user_sca.toString() doc = ''\ ''\ '0.05'\ '0.01'\ '100'\ ''\ ''\ '' min = model.getScalarMinValue('toto') max = model.getScalarMaxValue('toto') assert min == 0.01,'Could not get min value to user scalar' assert max == 100.,'Could not get max value to user scalar' def checkSetScalarVariance(self): """Check whether the DefineUserScalarsModel class could be set variance.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setScalarVariance('toto', 'titi') truc = model.node_user_sca.toString() doc = ''\ ''\ 'titi'\ ''\ ''\ '' assert doc == truc,'Could not set variance to user scalar' def checkGetScalarVariance(self): """Check whether the DefineUserScalarsModel class could be get variance.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setScalarVariance('toto', 'titi') vari = model.getScalarVariance('toto') assert vari == 'titi','Could not get variance to user scalar' def checkSetandGetScalarDiffusivityLabel(self): """Check whether the DefineUserScalarsModel class could be get label of diffusivity.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setScalarDiffusivity('toto', 'diffu_toto', 0.005) label = model.getScalarDiffusivityLabel('toto') assert label == 'diffu_toto',"Could not set label of user scalar's property" def checkSetandGetScalarDiffusivityInitialValue(self): """Check whether the DefineUserScalarsModel class could be set diffusivity'initial value.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setScalarDiffusivity('toto', 'diffu_toto', 0.005) model.setScalarDiffusivityInitialValue('toto', 0.045) truc = model.node_user_sca.toString() doc =''\ ''\ ''\ '0.045'\ ''\ ''\ ''\ '' assert doc == truc,"Could not set initial value of user scalar's property" val = model.getScalarDiffusivityInitialValue('toto') assert val == 0.045,"Could not get initial value of user scalar's property" def checkSetandGetScalarDiffusivityChoice(self): """Check whether the DefineUserScalarsModel class could be set diffusivity's choice.""" model = DefineUserScalarsModel(self.case) model.setNewUserScalar('toto') model.setNewUserScalar('titi') model.setScalarDiffusivity('toto', 'diffu_toto', 0.005) model.setScalarDiffusivityChoice('toto', 'constant') truc = model.node_user_sca.toString() doc = ''\ ''\ ''\ '0.005'\ ''\ ''\ ''\ '' assert doc==truc,"Could not set choice of user scalar's property" ch = model.getScalarDiffusivityChoice('toto') assert ch == "constant","Could not get choice of user scalar's property" def suite(): """unittest function""" testSuite = unittest.makeSuite(UserScalarTestCase, "check") return testSuite def runTest(): """unittest function""" print "XMLengineTestCase to be completed..." runner = unittest.TextTestRunner() runner.run(suite()) #------------------------------------------------------------------------------- # End DefineUsersScalars #-------------------------------------------------------------------------------