def on_arbBtn_clicked(self):
dlg = QDialog(self)
loadUi(dlg, 'change.ui')
with SettingGroup('main') as settings:
dlg.xEdit.setText(settings.value('changex', 'x'))
dlg.yEdit.setText(settings.value('changey', 'y'))
dlg.dyEdit.setText(settings.value('changedy', 'dy'))
if dlg.exec_() != QDialog.Accepted:
return
settings.setValue('changex', dlg.xEdit.text())
settings.setValue('changey', dlg.yEdit.text())
settings.setValue('changedy', dlg.dyEdit.text())
xfml = dlg.xEdit.text()
yfml = dlg.yEdit.text()
dyfml = dlg.dyEdit.text()
new_x = []
new_y = []
new_dy = []
ns = {}
for dpoint in zip(self.data.x, self.data.y_raw, self.data.dy_raw):
ns.update(x=dpoint[0], y=dpoint[1], dy=dpoint[2])
new_x.append(eval(xfml, ns))
new_y.append(eval(yfml, ns))
new_dy.append(eval(dyfml, ns))
self.data.x[:] = new_x
self.data.y_raw[:] = new_y
self.data.dy_raw[:] = new_dy
self.data.y = self.data.y_raw / self.data.norm
self.data.dy = self.data.dy_raw / self.data.norm
self.replotRequest.emit(None)
session.set_dirty()
def on_subtractBtn_clicked(self):
from ufit.gui.scanitem import ScanDataItem
dlg = QDialog(self)
loadUi(dlg, 'subtract.ui')
data2obj = dlg.setList.populate(ScanDataItem)
if dlg.exec_() != QDialog.Accepted:
return
witems = dlg.setList.selectedItems()
if not witems:
return
try:
prec = float(dlg.precisionEdit.text())
except ValueError:
QMessageBox.warning(self, 'Error',
'Please enter a valid precision.')
return
new_data = self.data.subtract(data2obj[witems[0].type()].data, prec,
dlg.destructBox.isChecked())
if not dlg.destructBox.isChecked():
new_model = self.model.copy()
from ufit.gui.scanitem import ScanDataItem
session.add_item(ScanDataItem(new_data, new_model),
self.item.group)
else:
self.replotRequest.emit(None)
session.set_dirty()
def _update_settings(self):
"""Update settings from controls."""
s = self.item.settings
old_title = s.title
title = s.title = self.titleBox.text()
if title != old_title:
self.item.update_htmldesc()
xaxis = str(self.xaxisBox.currentText())
yaxis = str(self.yaxisBox.currentText())
if xaxis != s.xaxis or yaxis != s.yaxis:
# new axes selected => discard limits on replot
self.mapdata = None
if xaxis == yaxis:
QMessageBox.warning(self, 'Error', 'Please select distinct X '
'and Y axes.')
return
s.xaxis = xaxis
s.yaxis = yaxis
s.interp = self.stepBox.value()
s.zmin = maybe_float(self.zminEdit.text(), -1e300)
s.zmax = maybe_float(self.zmaxEdit.text(), 1e300)
s.yscale = maybe_float(self.scaleEdit.text(), 1.0)
s.usemask = self.usemaskBox.isChecked()
s.dots = self.dotsBox.isChecked()
s.contour = self.contourBox.isChecked()
s.logz = self.logBox.isChecked()
s.gauss2d = self.fitBox.isChecked()
session.set_dirty()
def callback():
self.model.apply_pick(self._pick_values)
for p in self.model.params:
ctls = self.param_controls[p]
if not p.expr:
ctls[1].setText('%.5g' % p.value)
session.set_dirty()
self.do_plot()
def on_shiftBtn_clicked(self):
try:
const = float(self.shiftConstEdit.text())
except ValueError:
return
self.data.x += const
self.replotRequest.emit(None)
session.set_dirty()
def on_monscaleBtn_clicked(self):
try:
const = int(self.monscaleEdit.text())
except ValueError:
return
self.data.rescale(const)
self.replotRequest.emit(None)
session.set_dirty()
def on_addBtn_clicked(self):
try:
const = float(self.addConstEdit.text())
except ValueError:
return
self.data.y += const
self.data.y_raw += const * self.data.norm
self.replotRequest.emit(None)
session.set_dirty()
def on_scaleXBtn_clicked(self):
try:
const = float(self.scaleXConstEdit.text())
except ValueError:
return
for data in self.datas:
data.x *= const
self.replotRequest.emit(None)
session.set_dirty()
def logz_callback(self):
ax = self.canvas.figure.gca()
self.canvas.logz = not self.canvas.logz
session.set_dirty()
self._actions['logz_callback'].setChecked(self.canvas.logz)
for im in ax.get_images():
if self.canvas.logz:
im.set_norm(LogNorm())
else:
im.set_norm(None)
self.canvas.draw()
def on_mulBtn_clicked(self):
try:
const = float(self.scaleConstEdit.text())
except ValueError:
return
self.data.y *= const
self.data.y_raw *= const
self.data.dy *= const
self.data.dy_raw *= const
self.replotRequest.emit(None)
session.set_dirty()
def on_limitsBtn_clicked(self):
try:
limitmin = float(self.limitminEdit.text())
except ValueError:
limitmin = None
try:
limitmax = float(self.limitmaxEdit.text())
except ValueError:
limitmax = None
self.data.fitmin, self.data.fitmax = limitmin, limitmax
self.replotRequest.emit(None)
session.set_dirty()
def update_from_controls(self):
for p, ctls in iteritems(self.param_controls):
_, val, _, fx, expr, pmin, pmax, delta = ctls
p.value = float(val.text()) if val.text() else 0
if fx.checkState() == Qt.Checked:
p.expr = str(val.text())
else:
p.expr = str(expr.currentText())
p.pmin = float(pmin.text()) if pmin.text() else None
p.pmax = float(pmax.text()) if pmax.text() else None
p.delta = float(delta.text()) if delta.text() else 0
self.update_enables()
session.set_dirty()
def on_monscaleBtn_clicked(self):
try:
const = int(self.monscaleEdit.text())
except ValueError:
return
for data in self.datas:
data.nscale = const
data.norm = data.norm_raw / const
data.y = data.y_raw / data.norm
data.dy = sqrt(data.y_raw) / data.norm
data.yaxis = data.ycol + ' / %s %s' % (const, data.ncol)
self.replotRequest.emit(None)
session.set_dirty()
def on_tbl_itemChanged(self, item):
if self._updating:
return
try:
new_value = eval(str(item.text()))
except Exception:
QMessageBox.error(self, 'Error',
'The new value is not a valid expression.')
return
else:
key = str(self.tbl.item(item.row(), 0).text())
self.data.meta[key] = new_value
self.replotRequest.emit(None)
session.set_dirty()
def on_rebinBtn_clicked(self):
try:
binsize = float(self.precisionEdit.text())
except ValueError:
QMessageBox.warning(self, 'Error', 'Enter a valid precision.')
return
new_array, new_meta = rebin(self.data._data, binsize, self.data.meta)
self.data.__init__(new_meta,
new_array,
self.data.xcol,
self.data.ycol,
self.data.ncol,
self.data.nscale,
name=self.data.name,
sources=self.data.sources)
self.replotRequest.emit(None)
session.set_dirty()
def do_fit(self):
if self.picking:
QMessageBox.information(self, 'Fitting',
'Please finish the picking operation first.')
return
self.update_from_controls()
self.statusLabel.setText('Working...')
self.statusLabel.repaint()
QApplication.processEvents()
try:
res = self.model.fit(self.data, **self.fit_kws)
except Exception as e:
self.logger.exception('Error during fit')
self.statusLabel.setText('Error during fit: %s' % e)
return
self.on_modelFitted(self.item, res)
self.replotRequest.emit(True)
session.set_dirty()
def restore_from_params(self, other_params):
for p in self.model.params:
if p.name not in other_params:
continue
p0 = other_params[p.name]
ctls = self.param_controls[p]
ctls[1].setText('%.5g' % p0.value)
ctls[2].setText(u'± %.5g' % p0.error)
ctls[3].setChecked(False)
if p0.expr and is_float(p0.expr):
ctls[1].setText(p0.expr)
ctls[3].setChecked(True)
ctls[4].lineEdit().setText('')
else:
ctls[4].lineEdit().setText(p0.expr or '')
ctls[5].setText(p0.pmin is not None and '%.5g' % p0.pmin or '')
ctls[6].setText(p0.pmax is not None and '%.5g' % p0.pmax or '')
ctls[7].setText(p0.delta and '%.5g' % p0.delta or '')
session.set_dirty()
self.do_plot()
def on_badResetBtn_clicked(self):
self.data.reset_mask()
self.replotRequest.emit(None)
session.set_dirty()
def on_nameBtn_clicked(self):
self.data.name = str(self.nameEdit.text())
session.set_dirty()
self.replotRequest.emit(None)
def on_titleBtn_clicked(self):
self.data.meta.title = str(self.titleEdit.text())
self.titleChanged.emit()
session.set_dirty()
self.replotRequest.emit(None)
def on_textBox_textChanged(self):
if self._editing:
session.set_dirty()
def on_itemTree_collapsed(self, index):
index.internalPointer().expanded = False
session.set_dirty()
def change_model(self, model, keep_param_values=True):
self.model = model
self.newModel.emit(model, keep_param_values)
session.set_dirty()
def removeBadPoints(self, points):
"""'Remove' bad data points (just mask them out)."""
for point in points:
self.data.mask[self.data.x == point] = False
self.replotRequest.emit(None)
session.set_dirty()
def on_itemTree_expanded(self, index):
index.internalPointer().expanded = True
session.set_dirty()
