def updateFileTable(self):
self.fileTable.setRowCount(0)
self.fileTable.setRowCount(len(self.files))
for row, f in enumerate(self.files):
gh.setTableItem(self.fileTable, row, 0, text=f[0], editable=False)
gh.setTableItem(self.fileTable, row, 1, text=f[1], editable=False)
self.fileTable.resizeColumnsToContents()
def rowSwap(self, row1, row2):
table = self.ruleTable
row1Items = [
table.takeItem(row1, 0),
table.cellWidget(row1, 1),
table.takeItem(row1, 2)
]
row2Items = [
table.takeItem(row2, 0),
table.cellWidget(row2, 1),
table.takeItem(row2, 2)
]
table.setItem(row1, 0, row2Items[0])
table.setItem(row2, 0, row1Items[0])
table.setItem(row1, 2, row2Items[2])
table.setItem(row2, 2, row1Items[2])
r1ct = row1Items[1].currentText()
r2ct = row2Items[1].currentText()
r1it = [row1Items[1].itemText(i) \
for i in range(row1Items[1].count())]
r2it = [row2Items[1].itemText(i) \
for i in range(row2Items[1].count())]
#assigning new widgets will delete old
gh.setTableItem(table, row1, 1, r2ct, pullDown=r2it)
gh.setTableItem(table, row2, 1, r1ct, pullDown=r1it)
def setSolver(self, name):
'''
Set the current solver
name: the name of the solver to make active
'''
slvr = self.methods[name].opt()
self.methodDescriptionBox.setHtml(slvr.methodDescription)
opts = slvr.options
ovals = self.dat.optProblem.solverOptions.get(name, None)
if ovals:
opts.loadValues(ovals)
self.solverOptionTable.clearContents()
self.solverOptionTable.setRowCount(len(opts))
row = 0
table = self.solverOptionTable
for i, opt in enumerate(opts.order):
gh.setTableItem(
table,
i,
0,
opt,
editable=False)
gh.setTableItem(
table,
i,
2,
opts[opt].desc,
editable=False)
if opts[opt].dtype == bool:
# If the option is bool type use a check box
gh.setTableItem(
table,
i,
1,
'',
check = opts[opt].value,
jsonEnc = False,
bgColor = QColor(235, 255, 235))
elif len(opts[opt].validValues) > 0:
# if is a list type use a combo box
gh.setTableItem(
table,
i,
1,
opts[opt].value,
jsonEnc = True,
pullDown = opts[opt].validValues,
bgColor = QColor(235, 255, 235))
else:
# Otherwise you just have to type
gh.setTableItem(
table,
i,
1,
opts[opt].value,
jsonEnc = True,
bgColor = QColor(235, 255, 235))
table.resizeColumnsToContents()
def _add_input(self):
row = self.inputs_table.rowCount()
self.inputs_table.setRowCount(row + 1)
for i in range(8):
if i == 2:
gh.setTableItem(self.inputs_table, row, i, "double",
pullDown=["double", "int", "string"])
else:
gh.setTableItem(self.inputs_table, row, i, "")
def createOptionsTables(self):
"""
Get the options for all the surrogate method plugins and
make oftion tables for them. These go into a stack
widget that switches when you change the tool selection
"""
self.optTable = {}
for tool in self.tools:
pg = self.dat.surrogateMethods.plugins[tool].surrogateMethod(self.dat)
self.optTable[tool] = QTableWidget(self)
self.settingsStack.addWidget(self.optTable[tool])
self.optTable[tool].setColumnCount(3)
self.optTable[tool].setHorizontalHeaderLabels(
["Setting Name", "Value", "Description"]
)
self.optTable[tool].setRowCount(len(pg.options.order))
for i, opt in enumerate(pg.options.order):
gh.setTableItem(self.optTable[tool], i, 0, opt, editable=False)
gh.setTableItem(
self.optTable[tool], i, 2, pg.options[opt].desc, editable=False
)
pg.options[opt].dtype
if pg.options[opt].dtype == bool:
# If the option is bool type use a check box
gh.setTableItem(
self.optTable[tool],
i,
1,
"",
check=pg.options[opt].value,
jsonEnc=False,
bgColor=QColor(235, 255, 235),
)
elif len(pg.options[opt].validValues) > 0:
# if is a list type use a combo box
gh.setTableItem(
self.optTable[tool],
i,
1,
pg.options[opt].default,
jsonEnc=True,
pullDown=pg.options[opt].validValues,
bgColor=QColor(235, 255, 235),
)
else:
# Otherwise you just have to type
gh.setTableItem(
self.optTable[tool],
i,
1,
pg.options[opt].value,
jsonEnc=True,
bgColor=QColor(235, 255, 235),
)
self.optTable[tool].resizeColumnsToContents()
self.settingsStack.setCurrentIndex(0)
def addG(self):
'''
Add a new inequality constraint
'''
self.gTable.setRowCount(self.gTable.rowCount() + 1)
gh.setTableItem(self.gTable,
self.gTable.rowCount() - 1,
self.icCols["Form"],
"Linear",
pullDown=self.penForms)
def __init__(self, varNames, parent=None):
super(optSampleGenDialog, self).__init__(parent=parent)
self.setupUi(self)
self.varNames = varNames
self.okayButton.clicked.connect(self.accept)
self.cancelButton.clicked.connect(self.reject)
self.FileButton.clicked.connect(self.fileBrowse)
self.ffactTable.setRowCount(len(varNames))
self.sampleType = self.SAMPLE_FULL_FACT
self.sampleSettings = {}
for row, var in enumerate(varNames):
gh.setTableItem(self.ffactTable, row, 0, var)
def updateSettingsTable(self):
"""
This table contains node/model options. Sinter simulation
options, turbine options, plugin options...
"""
table = self.simSettingsTable
table.clearContents()
opts = self.node.options
table.setRowCount(len(opts))
for row, opt in enumerate(opts.order):
if opts[opt].disable:
table.hideRow(row)
gh.setTableItem(table, row, 0, opt, editable=False)
gh.setTableItem(table, row, 2, opts[opt].desc)
# set the value column use a checkbox for bool options
# and if there is a list of valid values use a combo box.
if opts[opt].dtype == bool:
# If the option is bool type use a check box
gh.setTableItem(
table,
row,
1,
"",
check=opts[opt].value,
jsonEnc=False,
bgColor=QColor(235, 255, 235),
)
elif len(opts[opt].validValues) > 0:
# if is a list type use a combo box
gh.setTableItem(
table,
row,
1,
opts[opt].value,
jsonEnc=True,
pullDown=opts[opt].validValues,
bgColor=QColor(235, 255, 235),
)
else:
# Otherwise you just have to type
gh.setTableItem(
table,
row,
1,
opts[opt].value,
jsonEnc=True,
bgColor=QColor(235, 255, 235),
)
table.resizeColumnsToContents()
def addTurbineConf(self):
# Browse for a file
fileNames, filtr = QFileDialog.getOpenFileNames(
self, "Additional Files", "",
"Config files (*.cfg);;Text Files (*.txt);;All Files (*)")
if fileNames:
tbl = self.tableWidget
tc = self.dat.flowsheet.turbConfig
for fn in fileNames:
i = tbl.rowCount()
tbl.setRowCount(tbl.rowCount() + 1)
gh.setTableItem(tbl,
i,
0,
tc.readConfigPeek(fn),
editable=False)
gh.setTableItem(tbl, i, 1, fn, editable=False)
def addConnection(self, fv="", tv=""):
"""
Add a new row to the connection table, if fv and/or tv are supplied
and fv and tv are valid variable names, initally create the row with
the specified connection.
Args
fv (str): Input or output var in from node, "" for user selection
tv (str): Input var in to node, "" for user selection later
Returns:
None
"""
n1 = self.fromBox.currentText()
n2 = self.toBox.currentText()
_log.debug("Adding connection from {}.{} to {}.{}".format(n1, fv, n2, tv))
# Add row
self.connectTable.setRowCount(self.connectTable.rowCount() + 1)
# get variable names, can connect in and out vars in n1 to in vars in n2
vars1in = sorted(self.dat.flowsheet.nodes[n1].inVars.keys())
vars1out = sorted(self.dat.flowsheet.nodes[n1].outVars.keys())
vars2 = sorted(self.dat.flowsheet.nodes[n2].inVars.keys())
# Fill in the pull down boxes
row = self.connectTable.rowCount() - 1
gh.setTableItem(self.connectTable, row, 0, fv, pullDown=vars1out + vars1in)
# Put a seperator between output and input vars in from vars
self.connectTable.cellWidget(row, 0).insertSeparator(len(vars1out))
gh.setTableItem(self.connectTable, row, 1, tv, pullDown=vars2)
gh.setTableItem( # This is the active checkbox
self.connectTable, row, 2, "", check=True, editable=False
)
# make columns wide enough to see what's goning on
self.connectTable.resizeColumnsToContents()
def _add_blank_input_file(self):
row = self.input_files_table.rowCount()
self.input_files_table.setRowCount(row + 1)
gh.setTableItem(self.input_files_table, row, 0, "")
gh.setTableItem(self.input_files_table, row, 1, "")
gh.setTableItem(self.input_files_table,
row,
2,
"sha1",
pullDown=["sha1"])
def addConnection(self, fv ="", tv=""):
self.connectTable.setRowCount( self.connectTable.rowCount() + 1 )
vars1in = sorted(self.dat.flowsheet.nodes[ self.fromBox.currentText() ].inVars.keys())
vars1out = sorted(self.dat.flowsheet.nodes[ self.fromBox.currentText() ].outVars.keys())
vars2 = sorted(self.dat.flowsheet.nodes[ self.toBox.currentText() ] .inVars.keys())
i = self.connectTable.rowCount() - 1
gh.setTableItem( self.connectTable, i, 0, fv, pullDown = vars1out + vars1in )
self.connectTable.cellWidget( i, 0 ).insertSeparator( len(vars1out) )
gh.setTableItem( self.connectTable, i, 1, tv, pullDown = vars2 )
gh.setTableItem( self.connectTable, i, 2, "", check = True, editable = False )
self.connectTable.resizeColumnsToContents()
def addOp(self, op=None):
r = self.dat.flowsheet.results
if op is not None:
op = self.copDictRev[op]
else:
op = "AND"
table = self.ruleTable
row = table.rowCount()
table.setRowCount(row + 1)
bg = QColor(200, 200, 200)
gh.setTableItem(table, row, 0, "", bgColor=bg, editable=False)
gh.setTableItem(table, row, 2, "", bgColor=bg, editable=False)
gh.setTableItem(table, row, 1, op, pullDown=self.copList)
def _add_input_file(self):
dialog = QFileDialog(self, 'Model File', directory=os.getcwd())
if dialog.exec_() == QDialog.Accepted:
res = dialog.selectedFiles()[0]
file = os.path.relpath(res)
row = self.input_files_table.rowCount()
self.input_files_table.setRowCount(row + 1)
gh.setTableItem(self.input_files_table, row, 0, file)
with open(file, "rb") as fp:
h = hashlib.sha1(fp.read()).hexdigest()
gh.setTableItem(self.input_files_table, row, 1, h)
gh.setTableItem(self.input_files_table, row, 2, "sha1",
pullDown=["sha1"])
self.input_files_table.resizeColumnsToContents()
def addRule(self, rule=None):
r = self.dat.flowsheet.results
if rule:
term1 = json.dumps(rule.term1)
term2 = json.dumps(rule.term2)
op = self.ropDictRev[rule.op]
else:
term1 = "err"
term2 = "0"
op = "="
table = self.ruleTable
row = table.rowCount()
table.setRowCount(row + 1)
gh.setTableItem(table, row, 0, term1, editable=True)
gh.setTableItem(table, row, 2, term2, editable=True)
gh.setTableItem(table, row, 1, op, pullDown=self.ropList)
def updateConnections(self):
'''
Update the connection table from the currently selected edge.
'''
self.connectTable.clearContents()
vars1in = sorted(self.dat.flowsheet.nodes[ self.fromBox.currentText() ].inVars.keys())
vars1out = sorted(self.dat.flowsheet.nodes[ self.fromBox.currentText() ].outVars.keys())
vars2 = sorted(self.dat.flowsheet.nodes[ self.toBox.currentText() ] .inVars.keys())
if self.edge.start == self.fromBox.currentText() and self.edge.end == self.toBox.currentText():
self.connectTable.setRowCount( len(self.edge.con) )
for i in range( len(self.edge.con) ):
gh.setTableItem( self.connectTable, i, 0, self.edge.con[i].fromName, pullDown = vars1out + vars1in )
self.connectTable.cellWidget( i, 0 ).insertSeparator( len(vars1out) )
gh.setTableItem( self.connectTable, i, 1, self.edge.con[i].toName, pullDown = vars2 )
gh.setTableItem( self.connectTable, i, 2, "", check = self.edge.con[i].active, editable = False )
else:
self.connectTable.setRowCount( 0 )
self.connectTable.resizeColumnsToContents()
def refreshContents(self):
'''
Update the contents of the surrogate for to reflect the
current state of the foqus session.
'''
self.ivGeneralButton1.hide()
self.ivGeneralButton2.hide()
self.ovGeneralButton1.hide()
self.ovGeneralButton2.hide()
self.dataBrowser.refreshContents()
inputNames = self.dat.flowsheet.input.compoundNames()
self.dat.flowsheet.markConnectedInputs()
delList = []
for i in range(len(inputNames)):
if self.dat.flowsheet.input.get(inputNames[i]).con == True:
delList.append(inputNames[i])
for n in delList:
inputNames.remove(n)
outputNames = self.dat.flowsheet.output.compoundNames()
if self.dat.surrogateCurrent is not None:
i = self.toolSelectBox.findText(self.dat.surrogateCurrent)
if i >= 0:
self.blockapply = True
self.toolSelectBox.setCurrentIndex(i)
self.blockapply = False
tool = self.toolSelectBox.currentText()
if tool == '':
return
pg = self.dat.surrogateMethods.plugins[tool].\
surrogateMethod(self.dat)
pg.loadFromSession()
pg.updateOptions()
for i, btn in enumerate(pg.inputVarButtons):
# this is because I am beeing lazy there are two
# preexisting buttons
if i == 0:
self.ivGeneralButton1.setText(btn[0])
self.ivGeneralButton1.show()
elif i == 1:
self.ivGeneralButton2.setText(btn[0])
self.ivGeneralButton2.show()
for i, btn in enumerate(pg.outputVarButtons):
if i == 0:
self.ovGeneralButton1.setText(btn[0])
self.ovGeneralButton1.show()
elif i == 1:
self.ovGeneralButton2.setText(btn[0])
self.ovGeneralButton2.show()
for i in range(self.optTable[tool].rowCount()):
oname = gh.getCellText(self.optTable[tool], i, 0)
if oname in pg.options:
if pg.options[oname].dtype == bool:
gh.setCellChecked(self.optTable[tool], i, 1,
pg.options[oname].value)
elif len(pg.options[oname].validValues) > 0:
gh.cellPulldownSetItemsJSON(self.optTable[tool], i, 1,
pg.options[oname].validValues)
gh.cellPulldownSetJSON(self.optTable[tool], i, 1,
pg.options[oname].value)
else:
gh.setCellJSON(self.optTable[tool], i, 1,
pg.options[oname].value)
self.inputTable.setRowCount(0)
self.inputTable.setColumnCount(3 + len(pg.inputCols))
for i, item in enumerate(pg.inputCols):
gh.setColHeaderIntem(self.inputTable, i + 3, item[0])
self.outputTable.setRowCount(0)
self.outputTable.setColumnCount(1 + len(pg.outputCols))
for i, item in enumerate(pg.outputCols):
gh.setColHeaderIntem(self.outputTable, i + 1, item[0])
self.inputTable.setRowCount(len(inputNames))
self.outputTable.setRowCount(len(outputNames))
self.inputCols = gh.colIndexes(self.inputTable)
self.outputCols = gh.colIndexes(self.outputTable)
for i in range(len(inputNames)):
var = self.dat.flowsheet.input.get(inputNames[i])
gh.setTableItem(self.inputTable,
row=i,
col=self.inputCols['Name'],
text=inputNames[i],
check=inputNames[i] in pg.input,
editable=False)
gh.setTableItem(self.inputTable,
row=i,
col=self.inputCols['Max'],
text=var.max,
jsonEnc=True)
gh.setTableItem(self.inputTable,
row=i,
col=self.inputCols['Min'],
text=var.min,
jsonEnc=True)
for item in pg.inputCols:
val = pg.getInputVarOption(item[0], inputNames[i])
gh.setTableItem(self.inputTable,
row=i,
col=self.inputCols[item[0]],
text=val,
jsonEnc=True)
for i in range(len(outputNames)):
var = self.dat.flowsheet.output.get(outputNames[i])
gh.setTableItem(self.outputTable,
row=i,
col=self.outputCols['Name'],
text=outputNames[i],
check=outputNames[i] in pg.output,
editable=False)
for item in pg.outputCols:
val = pg.getOutputVarOption(item[0], outputNames[i])
gh.setTableItem(self.outputTable,
row=i,
col=self.outputCols[item[0]],
text=val,
jsonEnc=True)
self.inputTable.resizeColumnsToContents()
self.outputTable.resizeColumnsToContents()
def updateInputVariables(self):
'''
Update the input variables table from the node contents
'''
table = self.inputVarTable
vars = self.node.inVars
table.clearContents()
table.setRowCount(len(vars))
row = 0
for name in sorted(vars.keys(), key=lambda s: s.lower()):
var = vars[name]
if var.con == 1:
bgColor = QColor(255, 255, 200)
elif var.con ==2:
bgColor = QColor(255, 220, 230)
else:
bgColor = QColor(255, 255, 255)
gh.setTableItem(table, row, self.ivCols["Name"], name,
bgColor=bgColor, editable=False)
gh.setTableItem(table, row,
self.ivCols["Value"],
var.value,
jsonEnc = True,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Default"],
var.default,
jsonEnc = True,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Min"],
var.min,
jsonEnc = True,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Max"],
var.max,
jsonEnc = True,
bgColor = bgColor)
gh.setTableItem(table,
row, self.ivCols["Tags"],
var.tags,
jsonEnc = True,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Unit"],
var.unit,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Type"],
pullDown= ["float", "int", "str"],
text=var.typeStr(),
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Description"],
var.desc,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Distribution"],
Distribution.getFullName(var.dist.type),
pullDown=Distribution.fullNames,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Param 1"],
var.dist.firstParamValue,
jsonEnc = True,
bgColor = bgColor)
gh.setTableItem(table, row,
self.ivCols["Param 2"],
var.dist.secondParamValue,
jsonEnc = True,
bgColor = bgColor)
row += 1
table.resizeColumnsToContents()
self.inputVarTable.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.inputVarTable.setSelectionBehavior(
QAbstractItemView.SelectRows)
def updateOutputVariables(self):
'''
Update the output variables table from the node contents
'''
table = self.outputVarTable
vars = self.node.outVars
table.clearContents()
table.setRowCount(len(vars))
row = 0
for name in sorted(vars.keys(), key = lambda s: s.lower()):
var = vars[name]
gh.setTableItem(table, row,
self.ovCols["Name"],
name, editable=False)
gh.setTableItem(table, row,
self.ovCols["Value"],
var.value,
jsonEnc = True)
gh.setTableItem(table, row,
self.ovCols["Unit"],
var.unit)
gh.setTableItem(table, row,
self.ovCols["Type"],
pullDown= ["float", "int", "str"],
text=var.typeStr())
gh.setTableItem(table, row,
self.ovCols["Description"],
var.desc)
gh.setTableItem(table, row,
self.ovCols["Tags"],
var.tags,
jsonEnc = True)
row += 1
table.resizeColumnsToContents()
self.outputVarTable.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.outputVarTable.setSelectionBehavior(
QAbstractItemView.SelectRows)
def updateTurbineTable(self):
tc = self.dat.flowsheet.turbConfig
localFile = self.dat.foqusSettings.turbConfig
remoteFile = self.dat.foqusSettings.turbConfigCluster
localAddress = tc.readConfigPeek(localFile)
remoteAddress = tc.readConfigPeek(remoteFile)
if self.multiRadio.isChecked():
self.addConfigButton.setEnabled(True)
self.removeConfigButton.setEnabled(True)
else:
self.addConfigButton.setEnabled(False)
self.removeConfigButton.setEnabled(False)
if self.currentRadio.isChecked():
self.tableWidget.clearContents()
self.tableWidget.setRowCount(1)
gh.setTableItem(self.tableWidget, 0, 0, tc.address, editable=False)
gh.setTableItem(self.tableWidget, 0, 1, tc.path, editable=False)
self.tableWidget.resizeColumnsToContents()
elif self.remoteRadio.isChecked():
self.tableWidget.clearContents()
self.tableWidget.setRowCount(1)
gh.setTableItem(self.tableWidget,
0,
0,
remoteAddress,
editable=False)
gh.setTableItem(self.tableWidget, 0, 1, remoteFile, editable=False)
self.tableWidget.resizeColumnsToContents()
elif self.localRadio.isChecked():
self.tableWidget.clearContents()
self.tableWidget.setRowCount(1)
gh.setTableItem(self.tableWidget,
0,
0,
localAddress,
editable=False)
gh.setTableItem(self.tableWidget, 0, 1, localFile, editable=False)
self.tableWidget.resizeColumnsToContents()
elif self.lrRadio.isChecked():
self.tableWidget.clearContents()
self.tableWidget.setRowCount(2)
gh.setTableItem(self.tableWidget,
0,
0,
localAddress,
editable=False)
gh.setTableItem(self.tableWidget, 0, 1, localFile, editable=False)
gh.setTableItem(self.tableWidget,
1,
0,
remoteAddress,
editable=False)
gh.setTableItem(self.tableWidget, 1, 1, remoteFile, editable=False)
self.tableWidget.resizeColumnsToContents()
elif self.multiRadio.isChecked():
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
def refreshContents(self):
'''
'''
self.dat.flowsheet.generateGlobalVariables()
prob = self.dat.optProblem
x = self.dat.flowsheet.x
# Set up problem selection combo box
o = self.dat.optProblem
# Setup optimization solver selection box
self.solverBox.blockSignals(True)
self.solverBox.clear()
self.solverBox.addItems(self.osolvers)
if self.osolvers: #at least on solver available
indx = self.solverBox.findText(o.solver)
if indx == -1:
indx = 0
self.solverBox.setCurrentIndex(indx)
self.lastSolver = self.solverBox.currentText()
self.setSolver(self.lastSolver)
self.solverBox.blockSignals(False)
else: #if no solvers are available
pass
# put data into variable table
row = 0
self.varForm.clearContents()
self.varForm.setRowCount(0)
table = self.varForm
for vkey in x:
#only list inputs that are not set by other variables
if not x[vkey].con:
self.varForm.setRowCount(self.varForm.rowCount() + 1)
scale = x[vkey].scaling
gh.setTableItem(
table,
row,
self.vtCols["Variable"],
vkey)
gh.setTableItem(
table,
row,
self.vtCols["Type"],
"Fixed",
pullDown = ["Fixed", "Decision", "Sample"])
if vkey in prob.v:
gh.cellPulldownSetText(table, row,
self.vtCols["Type"], "Decision")
elif vkey in prob.vs:
gh.cellPulldownSetText(table, row,
self.vtCols["Type"], "Sample")
table.cellWidget(row, self.vtCols["Type"])\
.currentIndexChanged.connect(self.scaleHelper)
gh.setTableItem(
table,
row,
self.vtCols["Scale"],
x[vkey].scaling,
pullDown=self.scalingOpts)
gh.setTableItem(
table,
row,
self.vtCols["Min"],
x[vkey].min,
jsonEnc=True)
gh.setTableItem(
table,
row,
self.vtCols["Max"],
x[vkey].max,
jsonEnc=True)
gh.setTableItem(
table,
row,
self.vtCols["Value"],
x[vkey].value,
jsonEnc=True)
row += 1
self.scaleHelper()
table.resizeColumnsToContents()
if not o:
self.fTable.setRowCount(0)
self.gTable.setRowCount(0)
return
# put data in objective function table
self.fTable.setRowCount( len(o.obj) )
row = 0
table = self.fTable
for f in o.obj:
gh.setTableItem(
table,
row,
self.ofCols["Expression"],
f.pycode)
gh.setTableItem(
table,
row,
self.ofCols["Penalty Scale"],
f.penScale,
jsonEnc=True)
gh.setTableItem(
table,
row,
self.ofCols["Value for Failure"],
f.fail,
jsonEnc=True)
row += 1
table.resizeColumnsToContents()
# put data in inequality constraint table
self.gTable.setRowCount(len(o.g))
row = 0
table = self.gTable
for f in o.g:
gh.setTableItem(
table,
row,
self.icCols["Expression"],
f.pycode)
gh.setTableItem(
table,
row,
self.icCols["Penalty Factor"],
f.penalty,
jsonEnc=True)
gh.setTableItem(
table,
row,
self.icCols["Form"],
f.penForm,
pullDown=self.penForms)
row += 1
table.resizeColumnsToContents()
# Get objective type
if prob.objtype == prob.OBJ_TYPE_EVAL:
self.objTypeCombo.setCurrentIndex(0)
elif prob.objtype == prob.OBJ_TYPE_CUST:
self.objTypeCombo.setCurrentIndex(1)
# Get custom code
self.customCodeEdit.setPlainText(prob.custpy)
self.updateSampleVarsTable()
