2013-06-14 06:44:34 +00:00
|
|
|
#!/usr/bin/env python
|
|
|
|
# -*- encoding: utf-8 -*-
|
2013-07-10 16:36:07 +00:00
|
|
|
import os
|
|
|
|
import sys
|
2013-06-14 06:44:34 +00:00
|
|
|
import re
|
|
|
|
import signal
|
|
|
|
|
|
|
|
from PyQt4.QtCore import *
|
|
|
|
from PyQt4.QtGui import *
|
2014-02-25 13:55:29 +00:00
|
|
|
import matplotlib
|
2013-06-14 06:44:34 +00:00
|
|
|
|
2014-04-07 11:41:39 +00:00
|
|
|
from mathlib import fit_anneal, fit_lbfgsb, fit_odr_cmplx, FunctionRegister, FitRoutine
|
2013-07-12 14:11:29 +00:00
|
|
|
|
2014-02-25 13:55:29 +00:00
|
|
|
matplotlib.use('agg')
|
|
|
|
|
|
|
|
|
|
|
|
from matplotlib import pyplot
|
|
|
|
from matplotlib.colors import hex2color
|
2013-07-17 11:00:24 +00:00
|
|
|
#matplotlib.rc_file("default.mplrc")
|
2013-06-14 06:44:34 +00:00
|
|
|
|
|
|
|
import numpy as N
|
|
|
|
|
|
|
|
import QDSMain
|
|
|
|
|
2014-04-03 18:56:50 +00:00
|
|
|
from data import Data, Conductivity, Peak, PowerComplex, Static, YAFF
|
2014-02-25 13:55:29 +00:00
|
|
|
import pyqtgraph as pg
|
2013-06-14 06:44:34 +00:00
|
|
|
|
2014-02-25 13:55:29 +00:00
|
|
|
#import yaff
|
2013-06-14 06:44:34 +00:00
|
|
|
|
2014-04-03 18:56:50 +00:00
|
|
|
from CustomWidgets import ParameterWidget, YaffWidget
|
2014-03-19 18:48:15 +00:00
|
|
|
|
2014-03-18 18:48:39 +00:00
|
|
|
USE_CROSSH=False
|
2013-06-14 06:44:34 +00:00
|
|
|
|
|
|
|
class AppWindow(QMainWindow):
|
|
|
|
def __init__(self, parent=None):
|
|
|
|
super(AppWindow, self).__init__(parent)
|
|
|
|
self.ui = QDSMain.Ui_MainWindow()
|
|
|
|
self.ui.setupUi(self)
|
|
|
|
|
2014-03-19 21:02:26 +00:00
|
|
|
actions = {
|
|
|
|
self.ui.actionAdd_Peak:self.addPeak,
|
|
|
|
self.ui.actionAdd_Cond:self.addCond,
|
2014-03-19 23:35:07 +00:00
|
|
|
self.ui.actionAdd_PowerLaw:self.addPowerComplex,
|
2014-03-20 16:22:33 +00:00
|
|
|
self.ui.actionAdd_Eps_Infty:self.addEpsInfty,
|
|
|
|
self.ui.actionYAFF:self.addYaff,
|
2014-03-19 21:02:26 +00:00
|
|
|
}
|
2014-03-20 14:15:40 +00:00
|
|
|
|
2014-03-19 21:02:26 +00:00
|
|
|
self.myActionGroup = QActionGroup(self)
|
|
|
|
for a in actions.keys(): self.myActionGroup.addAction(a)
|
|
|
|
|
|
|
|
self.function_registry = FunctionRegister()
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
self.peakId = 0
|
2013-07-10 16:36:07 +00:00
|
|
|
|
2014-03-19 18:48:15 +00:00
|
|
|
self.parameterWidget = ParameterWidget()
|
|
|
|
self.ui.dockWidget_3.setWidget(self.parameterWidget)
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
## menubar
|
|
|
|
fileMenu = self.menuBar().addMenu("File")
|
2013-07-10 16:36:07 +00:00
|
|
|
openFile = QAction("&Open", self)
|
2013-06-14 06:44:34 +00:00
|
|
|
openFile.setShortcut(QKeySequence.Open)
|
|
|
|
openFile.triggered.connect(self.openFile)
|
|
|
|
fileMenu.addAction(openFile)
|
2014-02-25 13:55:29 +00:00
|
|
|
|
|
|
|
saveFile = QAction("&Save Fit Result", self)
|
|
|
|
saveFile.setShortcut(QKeySequence.Save)
|
|
|
|
saveFile.triggered.connect(self.saveFitResult)
|
|
|
|
fileMenu.addAction(saveFile)
|
|
|
|
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
# fitting methods
|
2013-07-10 16:36:07 +00:00
|
|
|
fitMenu = self.menuBar().addMenu("Standard Fits")
|
2013-06-14 06:44:34 +00:00
|
|
|
# lm
|
2013-07-10 16:36:07 +00:00
|
|
|
fit_lmAction = QAction("&Levenberg-Marquardt", self)
|
|
|
|
fit_lmAction.setShortcut(QKeySequence("Ctrl+F"))
|
2013-06-14 06:44:34 +00:00
|
|
|
fitMenu.addAction(fit_lmAction)
|
|
|
|
# lbfgsb
|
2013-07-10 16:36:07 +00:00
|
|
|
fit_lbfgsbAction = QAction("&L-BFGS-B", self)
|
2013-06-14 06:44:34 +00:00
|
|
|
fitMenu.addAction(fit_lbfgsbAction)
|
|
|
|
# Simulated Annealing
|
2013-07-10 16:36:07 +00:00
|
|
|
fit_annealAction = QAction("&Simulated Annealing", self)
|
2013-06-14 06:44:34 +00:00
|
|
|
fitMenu.addAction(fit_annealAction)
|
2013-07-10 16:36:07 +00:00
|
|
|
# YAFF
|
|
|
|
yaffMenu = self.menuBar().addMenu("YAFF")
|
|
|
|
start_yaff = QAction("&Startparam.", self)
|
|
|
|
yaffMenu.addAction(start_yaff)
|
|
|
|
fit_yaff = QAction("&Fit", self)
|
|
|
|
yaffMenu.addAction(fit_yaff)
|
2013-06-14 06:44:34 +00:00
|
|
|
|
2014-04-07 11:41:39 +00:00
|
|
|
self._fit_thread = QThread()
|
|
|
|
# self._fit_method = FitRoutine()
|
|
|
|
# self._fit_method.moveToThread(self._fit_thread)
|
|
|
|
# self._fit_method.finished.connect(self._fit_thread.quit)
|
|
|
|
|
|
|
|
# self._fit_queue = QEventLoop()
|
|
|
|
# self._fit_timer = QTimer()
|
|
|
|
# self._fit_timer.setSingleShot(True)
|
|
|
|
# self._fit_timer.timeout.connect(self._fit_queue.quit)
|
|
|
|
# self._fit_method.finished.connect(self._fit_queue.quit)
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
self.signalMapper = QSignalMapper(self)
|
|
|
|
for i, fit_action in enumerate([fit_lmAction, fit_lbfgsbAction, fit_annealAction
|
2013-07-10 16:36:07 +00:00
|
|
|
]):
|
|
|
|
self.signalMapper.setMapping(fit_action, i)
|
2013-06-14 06:44:34 +00:00
|
|
|
fit_action.triggered.connect(self.signalMapper.map)
|
|
|
|
self.signalMapper.mapped.connect(self.fitData)
|
|
|
|
|
|
|
|
# save fitted values
|
|
|
|
|
2014-02-25 13:55:29 +00:00
|
|
|
#self.ui.actionSave_FitResult.triggered.connect(self.saveFitResult)# replaced by menu
|
|
|
|
|
|
|
|
self.data = Data()
|
|
|
|
|
2014-03-19 23:47:19 +00:00
|
|
|
self.fit_boundary = pg.LinearRegionItem(brush=QColor(0,127,254,15))
|
2014-03-20 13:30:19 +00:00
|
|
|
|
|
|
|
self.ui.pgPlotWidget_imag.addItem(self.data.data_curve_imag)
|
|
|
|
self.ui.pgPlotWidget_real.addItem(self.data.data_curve_real)
|
|
|
|
self.ui.pgPlotWidget_imag.addItem(self.data.fitted_curve_imag)
|
|
|
|
self.ui.pgPlotWidget_real.addItem(self.data.fitted_curve_real)
|
2014-03-18 18:48:39 +00:00
|
|
|
|
|
|
|
# cross hair
|
|
|
|
if USE_CROSSH:
|
|
|
|
#self.poslabel = pg.LabelItem(justify='right')
|
|
|
|
self.horizontalLine = pg.InfiniteLine(angle=0)
|
|
|
|
self.verticalLine = pg.InfiniteLine(angle=90)
|
|
|
|
|
2014-03-20 13:30:19 +00:00
|
|
|
#self.ui.pgPlotWidget_imag.plotItem.addItem(self.poslabel)
|
|
|
|
self.ui.pgPlotWidget_imag.addItem(self.horizontalLine)
|
|
|
|
self.ui.pgPlotWidget_imag.addItem(self.verticalLine)
|
|
|
|
|
|
|
|
self.ui.pgPlotWidget_imag.addItem(self.fit_boundary)
|
|
|
|
|
|
|
|
for pltwidgt in (self.ui.pgPlotWidget_real, self.ui.pgPlotWidget_imag):
|
|
|
|
pltwidgt.setLogMode(x=True, y=True)
|
|
|
|
pltwidgt.showGrid(x=True, y=True)
|
|
|
|
pltwidgt.disableAutoRange()
|
2014-03-20 14:15:40 +00:00
|
|
|
pltwidgt.setLabel("bottom", "Frequency", units="Hz")
|
2014-03-18 18:48:39 +00:00
|
|
|
|
2014-03-20 13:30:19 +00:00
|
|
|
self.ui.pgPlotWidget_imag.setLabel("left", "(I) Dielectric loss", units="Debye")
|
|
|
|
self.ui.pgPlotWidget_real.setLabel("left", "(R) Dielectric loss", units="Debye")
|
2014-03-18 18:48:39 +00:00
|
|
|
|
2014-03-20 13:30:19 +00:00
|
|
|
sc_real = self.ui.pgPlotWidget_real.scene()
|
|
|
|
sc_real.sigMouseClicked.connect(self.mousePress)
|
|
|
|
sc_real.sigMouseMoved.connect(self.updateCrosshair)
|
|
|
|
|
|
|
|
sc_imag = self.ui.pgPlotWidget_imag.scene()
|
|
|
|
sc_imag.sigMouseClicked.connect(self.mousePress)
|
|
|
|
sc_imag.sigMouseMoved.connect(self.updateCrosshair)
|
2014-03-18 18:48:39 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def updateCrosshair(self,evt):
|
2014-03-20 13:30:19 +00:00
|
|
|
|
|
|
|
vb_real = self.ui.pgPlotWidget_real.getPlotItem().vb
|
|
|
|
vb_imag = self.ui.pgPlotWidget_imag.getPlotItem().vb
|
|
|
|
|
|
|
|
if self.ui.pgPlotWidget_imag.underMouse():
|
|
|
|
pos = vb_imag.mapSceneToView(evt)
|
|
|
|
elif self.ui.pgPlotWidget_real.underMouse():
|
|
|
|
pos = vb_real.mapSceneToView(evt)
|
|
|
|
else:
|
2014-03-20 14:15:40 +00:00
|
|
|
pos = QPointF(0.0, 0.0)
|
2014-03-20 13:30:19 +00:00
|
|
|
|
2014-03-18 18:48:39 +00:00
|
|
|
self.last_pos = pos
|
2014-03-20 13:30:19 +00:00
|
|
|
|
2014-03-18 18:48:39 +00:00
|
|
|
if USE_CROSSH:
|
|
|
|
self.horizontalLine.setBounds([self.data.frequency.min(), self.data.frequency.max()])
|
|
|
|
self.horizontalLine.setPos(pos.y())
|
|
|
|
self.verticalLine.setPos(pos.x())
|
|
|
|
#self.poslabel.setText("<span style='font-size: 12pt'>f=%0.1f Hz <span style='color: red'>e=%0.1f</span>"\
|
|
|
|
# % (pos.x(),pos.y()))
|
|
|
|
|
|
|
|
def mousePress(self, evt):
|
|
|
|
data_pos = self.last_pos
|
2014-03-19 23:35:07 +00:00
|
|
|
|
2014-03-20 13:30:19 +00:00
|
|
|
mouse_in_imag = self.ui.pgPlotWidget_imag.underMouse()
|
|
|
|
mouse_in_real = self.ui.pgPlotWidget_real.underMouse()
|
|
|
|
|
|
|
|
msgBox = QMessageBox()
|
|
|
|
|
2014-03-19 21:02:26 +00:00
|
|
|
if self.ui.actionAdd_Peak.isChecked():
|
2014-03-20 13:30:19 +00:00
|
|
|
if mouse_in_imag:
|
|
|
|
self.addPeak(data_pos)
|
|
|
|
self.ui.actionAdd_Peak.setChecked(False)
|
|
|
|
else:
|
|
|
|
msgBox.setText("Click in imaginary part")
|
|
|
|
msgBox.exec_()
|
2014-03-19 23:35:07 +00:00
|
|
|
|
2014-03-19 21:02:26 +00:00
|
|
|
if self.ui.actionAdd_Cond.isChecked():
|
2014-03-20 13:30:19 +00:00
|
|
|
if mouse_in_imag:
|
|
|
|
self.addCond(data_pos)
|
|
|
|
self.ui.actionAdd_Cond.setChecked(False)
|
|
|
|
else:
|
|
|
|
msgBox.setText("Click in imaginary part")
|
|
|
|
msgBox.exec_()
|
|
|
|
|
2014-04-03 18:56:50 +00:00
|
|
|
if self.ui.actionYAFF.isChecked():
|
|
|
|
if mouse_in_imag:
|
|
|
|
self.addYaff(data_pos)
|
|
|
|
self.ui.actionYAFF.setChecked(False)
|
|
|
|
else:
|
|
|
|
msgBox.setText("Click in imaginary part")
|
|
|
|
msgBox.exec_()
|
|
|
|
|
|
|
|
|
2014-03-19 23:35:07 +00:00
|
|
|
|
2014-03-19 21:02:26 +00:00
|
|
|
if self.ui.actionAdd_PowerLaw.isChecked():
|
2014-03-20 13:30:19 +00:00
|
|
|
if mouse_in_imag:
|
|
|
|
self.addPowerComplex(data_pos)
|
|
|
|
self.ui.actionAdd_PowerLaw.setChecked(False)
|
|
|
|
else:
|
|
|
|
msgBox.setText("Click in imaginary part")
|
|
|
|
msgBox.exec_()
|
2014-03-19 21:02:26 +00:00
|
|
|
|
2014-03-19 23:35:07 +00:00
|
|
|
if self.ui.actionAdd_Eps_Infty.isChecked():
|
2014-03-20 13:30:19 +00:00
|
|
|
if mouse_in_real:
|
|
|
|
self.addEpsInfty(data_pos)
|
|
|
|
self.ui.actionAdd_Eps_Infty.setChecked(False)
|
|
|
|
else:
|
|
|
|
msgBox.setText("Click in real part")
|
|
|
|
msgBox.exec_()
|
2014-03-19 23:35:07 +00:00
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
|
2013-07-17 11:00:24 +00:00
|
|
|
def saveFitResult(self):
|
2013-07-10 16:36:07 +00:00
|
|
|
"""
|
|
|
|
Saving fit parameters to fitresults.log
|
|
|
|
including temperature
|
|
|
|
"""
|
2014-02-25 13:55:29 +00:00
|
|
|
self.saveFitFigure()
|
2013-06-14 06:44:34 +00:00
|
|
|
if not os.path.exists("fitresults.log"):
|
2013-07-10 16:36:07 +00:00
|
|
|
f = open("fitresults.log", "w")
|
2013-06-14 06:44:34 +00:00
|
|
|
else:
|
2013-07-10 16:36:07 +00:00
|
|
|
f = open("fitresults.log", "a")
|
2013-07-17 11:00:24 +00:00
|
|
|
# write header
|
2014-03-05 15:59:35 +00:00
|
|
|
f.write("#%7s"%('T'))
|
|
|
|
parfmt = "%8.2f" # T formatting
|
2013-07-17 11:00:24 +00:00
|
|
|
# if self.Conductivity != None: pass# always true
|
2014-03-05 15:59:35 +00:00
|
|
|
f.write("%9s%9s%9s " % ("e_s", "sig", "pow_sig"))
|
|
|
|
parfmt += "%9.3g%9.3g%9.2f " # conductivity formatting
|
2013-07-17 11:00:24 +00:00
|
|
|
for i, pb in enumerate(self.peakBoxes):
|
|
|
|
enum_peak = ("e_inf_%i" % i, "tau_%i" % i, "alpha_%i" % i, "beta_%i" % i)
|
2014-03-05 15:59:35 +00:00
|
|
|
f.write("%9s%9s%9s%9s " % enum_peak)
|
|
|
|
print enum_peak
|
|
|
|
parfmt += "%9.3g%9.3g%9.2f%9.2f" # peak formatting
|
|
|
|
f.write("fit_xlow fit_xhigh") # TODO: store limits
|
|
|
|
parfmt += "%9.3g%9.3g"
|
2013-07-17 11:00:24 +00:00
|
|
|
f.write('\n')
|
|
|
|
f.flush()
|
|
|
|
#f.write("%3.2f "%(self.data.meta["T"]))
|
2013-06-14 06:44:34 +00:00
|
|
|
pars = list(self.fitresult)
|
2013-07-10 16:36:07 +00:00
|
|
|
pars.insert(0, self.data.meta["T"])
|
2014-03-05 15:59:35 +00:00
|
|
|
pars.append(self.data.fit_limits[0])
|
|
|
|
pars.append(self.data.fit_limits[1])
|
2013-07-17 11:00:24 +00:00
|
|
|
N.savetxt(f, N.array([pars, ]), fmt=parfmt, delimiter=" ")
|
2013-06-14 06:44:34 +00:00
|
|
|
f.close()
|
|
|
|
|
2014-02-25 13:55:29 +00:00
|
|
|
def saveFitFigure(self):
|
2014-03-05 15:59:35 +00:00
|
|
|
fig = pyplot.figure(figsize=(3.54, 2.75))
|
2014-02-25 13:55:29 +00:00
|
|
|
font = {'family' : 'sans serif',
|
|
|
|
'weight' : 'normal',
|
2014-03-05 15:59:35 +00:00
|
|
|
'size' : 8}
|
2014-02-25 13:55:29 +00:00
|
|
|
|
|
|
|
matplotlib.rc('font', **font)
|
2014-03-05 15:59:35 +00:00
|
|
|
|
|
|
|
pyplot.loglog(self.data.frequency, self.data.epsilon.imag, 'bo', markersize=3, label="Data")
|
|
|
|
pyplot.loglog(self.data.frequency, self.data.epsilon_fit, 'r-', lw=1, label="Fit")
|
2014-02-25 13:55:29 +00:00
|
|
|
|
|
|
|
for i,peak in enumerate(self.peakBoxes):
|
|
|
|
f,eps = peak.get_data()
|
|
|
|
color = hex2color(str(peak.get_color().name()))
|
2014-03-05 15:59:35 +00:00
|
|
|
pyplot.loglog(f,eps, ls="--", color=color , lw=0.75, label="Peak %i"%i)
|
2014-02-25 13:55:29 +00:00
|
|
|
|
|
|
|
if self.Conductivity != None:
|
2014-03-19 21:02:26 +00:00
|
|
|
f,eps = self.Conductivity.get_data()
|
2014-02-25 13:55:29 +00:00
|
|
|
color = hex2color(str(self.Conductivity.get_color().name()))
|
2014-03-05 15:59:35 +00:00
|
|
|
pyplot.loglog(f,eps, ls="-.", color=color, lw=0.75, label="Cond.")
|
2014-02-25 13:55:29 +00:00
|
|
|
f,eps = self.Conductivity.get_epsilon_static()
|
2014-03-05 15:59:35 +00:00
|
|
|
pyplot.loglog(f,eps, ls=":", color=color, lw=0.75, label=r'$\epsilon_0$')
|
2014-02-25 13:55:29 +00:00
|
|
|
|
2014-03-05 15:59:35 +00:00
|
|
|
for i in (0,1): pyplot.axvline(x=self.data.fit_limits[i], color='g', ls="--")
|
|
|
|
pyplot.legend(title = "T=%.1f K"%(self.data.meta["T"]))
|
2014-02-25 13:55:29 +00:00
|
|
|
pyplot.grid()
|
|
|
|
pyplot.xlabel('f/Hz')
|
|
|
|
pyplot.ylabel('eps"')
|
2014-03-05 15:59:35 +00:00
|
|
|
pyplot.savefig(os.path.splitext(self.filepath)[0]+".png")
|
2014-02-25 13:55:29 +00:00
|
|
|
fig.clear()
|
|
|
|
|
2013-07-10 16:36:07 +00:00
|
|
|
|
2014-03-20 16:22:33 +00:00
|
|
|
def addYaff(self, pos):
|
|
|
|
|
2014-04-03 18:56:50 +00:00
|
|
|
_yaff = YAFF(plt_real=self.ui.pgPlotWidget_real,
|
|
|
|
plt_imag=self.ui.pgPlotWidget_imag,
|
|
|
|
limits=self.data.fit_limits)
|
2014-03-20 16:22:33 +00:00
|
|
|
_yaff.changedData.connect(self.updatePlot)
|
|
|
|
_yaff.removeObj.connect(self.delParamterObject)
|
2014-04-03 18:56:50 +00:00
|
|
|
gg_y = 10**pos.y()
|
|
|
|
gg_x = 10**pos.x()*2*N.pi
|
2014-04-07 11:41:39 +00:00
|
|
|
yaff_par = [ gg_y, gg_x , 20.0, 1.0, 0.5, gg_x/100, 1.0, 1.0]
|
2014-04-03 18:56:50 +00:00
|
|
|
_yaff.setParameter(beta=yaff_par)
|
2014-03-20 16:22:33 +00:00
|
|
|
self.parameterWidget.add(_yaff.widget)
|
|
|
|
self.function_registry.register_function(_yaff)
|
|
|
|
self.updatePlot()
|
|
|
|
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
def addCond(self, pos):
|
2014-03-20 13:30:19 +00:00
|
|
|
_conductivity = Conductivity(plt_real=self.ui.pgPlotWidget_real,
|
|
|
|
plt_imag=self.ui.pgPlotWidget_imag,
|
|
|
|
limits=self.data.fit_limits)
|
2014-03-19 23:35:07 +00:00
|
|
|
_conductivity.changedData.connect(self.updatePlot)
|
|
|
|
_conductivity.removeObj.connect(self.delParamterObject)
|
|
|
|
|
2014-04-03 18:56:50 +00:00
|
|
|
cond_par = [0.0, 10**(pos.y() + pos.x())*2*N.pi , 1.0]
|
2014-03-19 23:35:07 +00:00
|
|
|
_conductivity.setParameter(beta=cond_par)
|
|
|
|
|
2014-03-20 14:15:40 +00:00
|
|
|
self.parameterWidget.add(_conductivity.widget)
|
2014-03-19 23:35:07 +00:00
|
|
|
self.function_registry.register_function(_conductivity)
|
2014-03-19 21:02:26 +00:00
|
|
|
self.updatePlot()
|
|
|
|
|
2014-03-20 13:30:19 +00:00
|
|
|
|
|
|
|
def addPowerComplex(self, pos):
|
|
|
|
_power_complex = PowerComplex(plt_imag=self.ui.pgPlotWidget_imag,
|
|
|
|
plt_real=self.ui.pgPlotWidget_real,
|
|
|
|
limits=self.data.fit_limits)
|
|
|
|
_power_complex.changedData.connect(self.updatePlot)
|
|
|
|
_power_complex.removeObj.connect(self.delParamterObject)
|
|
|
|
|
|
|
|
cond_par = [10**(pos.y() + pos.x())*2*N.pi , 1.0]
|
|
|
|
_power_complex.setParameter(beta=cond_par)
|
|
|
|
|
2014-03-20 14:15:40 +00:00
|
|
|
self.parameterWidget.add(_power_complex.widget)
|
2014-03-20 13:30:19 +00:00
|
|
|
self.function_registry.register_function(_power_complex)
|
|
|
|
self.updatePlot()
|
|
|
|
|
2014-03-19 23:35:07 +00:00
|
|
|
def addEpsInfty(self, pos):
|
2014-03-20 13:30:19 +00:00
|
|
|
_eps_infty = Static(plt_imag=self.ui.pgPlotWidget_imag,
|
|
|
|
plt_real=self.ui.pgPlotWidget_real,
|
|
|
|
limits=self.data.fit_limits)
|
2014-03-19 23:35:07 +00:00
|
|
|
_eps_infty.changedData.connect(self.updatePlot)
|
|
|
|
_eps_infty.removeObj.connect(self.delParamterObject)
|
|
|
|
|
|
|
|
cond_par = [10**pos.y()]
|
|
|
|
_eps_infty.setParameter(beta=cond_par)
|
2014-03-19 21:02:26 +00:00
|
|
|
|
2014-03-20 14:15:40 +00:00
|
|
|
self.parameterWidget.add(_eps_infty.widget)
|
2014-03-19 23:35:07 +00:00
|
|
|
self.function_registry.register_function(_eps_infty)
|
|
|
|
self.updatePlot()
|
|
|
|
|
|
|
|
def delParamterObject(self, obj):
|
|
|
|
print "unregister",obj
|
|
|
|
self.function_registry.unregister_function(obj)
|
2013-06-14 06:44:34 +00:00
|
|
|
self.updatePlot()
|
|
|
|
|
|
|
|
def addPeak(self, pos):
|
2014-03-20 13:30:19 +00:00
|
|
|
id_list = [ key.id_num for key in
|
|
|
|
self.function_registry.get_registered_functions().keys()
|
|
|
|
if key.id_string == 'hn']
|
2014-03-19 18:48:15 +00:00
|
|
|
|
|
|
|
self.peakId = 1
|
|
|
|
while self.peakId in id_list:
|
|
|
|
self.peakId += 1
|
|
|
|
|
2014-03-20 14:15:40 +00:00
|
|
|
_peak = Peak(id_num=self.peakId,
|
|
|
|
plt_real=self.ui.pgPlotWidget_real,
|
|
|
|
plt_imag=self.ui.pgPlotWidget_imag,
|
2014-03-20 13:30:19 +00:00
|
|
|
limits=self.data.fit_limits)
|
2014-03-20 14:15:40 +00:00
|
|
|
|
2014-03-19 23:35:07 +00:00
|
|
|
_peak.changedData.connect(self.updatePlot)
|
|
|
|
_peak.removeObj.connect(self.delParamterObject)
|
2014-03-19 21:02:26 +00:00
|
|
|
|
2014-03-19 18:48:15 +00:00
|
|
|
new_peak = [2*10**pos.y(), 1 / (2*N.pi*10**pos.x()), 1, 1]
|
2014-03-19 23:35:07 +00:00
|
|
|
_peak.setParameter(beta = new_peak)
|
2014-03-19 18:48:15 +00:00
|
|
|
|
2014-03-19 23:35:07 +00:00
|
|
|
self.function_registry.register_function(_peak)
|
2014-03-20 14:15:40 +00:00
|
|
|
self.parameterWidget.add(_peak.widget)
|
2014-03-19 23:35:07 +00:00
|
|
|
|
|
|
|
self.updatePlot()
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
def delPeak(self):
|
2013-07-10 16:36:07 +00:00
|
|
|
for i, peak in enumerate(self.peakBoxes.keys()):
|
2013-06-14 06:44:34 +00:00
|
|
|
if peak.widget.isHidden():
|
2014-03-20 13:30:19 +00:00
|
|
|
self.ui.pgPlotWidget_imag.removeItem(peak.mpl_line)
|
2014-03-19 18:48:15 +00:00
|
|
|
self.parameterWidget.vlayout.removeWidget(peak.widget)
|
2014-03-19 21:02:26 +00:00
|
|
|
self.function_registry.unregister_function(peak)
|
|
|
|
|
2014-03-19 18:48:15 +00:00
|
|
|
self.peakBoxes.pop(peak)
|
|
|
|
self.parameterWidget.vlayout.update()
|
2013-06-14 06:44:34 +00:00
|
|
|
self.updatePlot()
|
|
|
|
|
2014-04-07 11:41:39 +00:00
|
|
|
def test(self):
|
|
|
|
print "test"
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
def fitData(self, method):
|
2014-03-19 18:48:15 +00:00
|
|
|
fit_methods = [fit_odr_cmplx, fit_lbfgsb, fit_anneal]
|
2014-03-19 23:35:07 +00:00
|
|
|
|
2014-03-19 18:48:15 +00:00
|
|
|
# build function list
|
2014-03-19 23:35:07 +00:00
|
|
|
p0,funcs,fixed_params = [],[],[]
|
|
|
|
for fcn in self.function_registry.get_registered_functions():
|
|
|
|
p0.extend(fcn.getParameter())
|
|
|
|
funcs.append(fcn.id_string)
|
|
|
|
fixed_params.extend(fcn.getFixed())
|
|
|
|
_freq, _fit = self.data.get_data()
|
|
|
|
|
2014-04-07 11:41:39 +00:00
|
|
|
# Prepare
|
|
|
|
|
|
|
|
# self._fit_thread = QThread()
|
|
|
|
self._fit_method = FitRoutine()
|
|
|
|
self._fit_method.moveToThread(self._fit_thread)
|
|
|
|
self._fit_method.finished_fit.connect(self._fit_thread.quit)
|
|
|
|
|
|
|
|
self._fit_method.fit_odr_cmplx(_freq, _fit, p0, fixed_params, funcs)
|
|
|
|
|
|
|
|
self._fit_thread.started.connect(self.test)
|
|
|
|
|
|
|
|
self._fit_thread.started.connect(self._fit_method.fit)
|
|
|
|
|
|
|
|
|
|
|
|
self._fit_thread.start()
|
|
|
|
#self._fit_thread.wait()
|
|
|
|
|
|
|
|
#self._fit_method.moveToThread(self._fit_thread)
|
|
|
|
#self._fit_thread.start()
|
|
|
|
|
|
|
|
#fit_methods[method](_freq, _fit, p0, fixed_params, funcs)
|
|
|
|
# Run
|
|
|
|
|
|
|
|
#el = QEventLoop()
|
|
|
|
#self._fit_thread.finished.connect(el.quit)
|
|
|
|
#self._fit_method.fit()
|
|
|
|
import time
|
|
|
|
time.sleep(1)
|
|
|
|
# while True:
|
|
|
|
# time.sleep(0.5)
|
|
|
|
# print "waiting..."
|
|
|
|
# if self._fit_thread.isRunning():
|
|
|
|
# pass
|
|
|
|
# else:
|
|
|
|
odr_result = self._fit_method.result()
|
|
|
|
# break
|
|
|
|
|
2014-03-19 18:48:15 +00:00
|
|
|
print "Set fit data"
|
2014-03-19 23:35:07 +00:00
|
|
|
self.data.set_fit(odr_result.beta, funcs)
|
|
|
|
self.ui.statusbar.showMessage(" ".join(odr_result.stopreason))
|
|
|
|
result = odr_result.beta
|
2014-04-07 11:41:39 +00:00
|
|
|
i = 0
|
2014-03-19 23:35:07 +00:00
|
|
|
for fcn in self.function_registry.get_registered_functions():
|
|
|
|
num_p = len(fcn.getParameter())
|
|
|
|
beta = odr_result.beta[i:num_p+i]
|
|
|
|
sd_beta = odr_result.sd_beta[i:num_p+i]
|
|
|
|
fcn.setParameter(beta, sd_beta)
|
|
|
|
i += num_p
|
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
self.updatePlot()
|
2013-07-10 16:36:07 +00:00
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
def openFile(self):
|
2014-03-18 18:48:39 +00:00
|
|
|
#path = unicode(QFileDialog.getOpenFileName(self, "Open file"))
|
|
|
|
path = "MCM42PG0_199.96K.dat"
|
2014-03-05 15:59:35 +00:00
|
|
|
self.filepath=path
|
2014-03-18 18:48:39 +00:00
|
|
|
# TODO analyize file (LF,MF, HF) and act accordingly
|
2013-06-14 06:44:34 +00:00
|
|
|
data = N.loadtxt(path, skiprows=4)
|
2014-02-25 13:55:29 +00:00
|
|
|
self.setWindowTitle(os.path.basename(path))
|
2013-06-14 06:44:34 +00:00
|
|
|
numpat = re.compile('\d+\.\d+')
|
|
|
|
try:
|
2013-07-10 16:36:07 +00:00
|
|
|
Temp = None
|
2013-06-14 06:44:34 +00:00
|
|
|
for line in open(path).readlines():
|
|
|
|
if re.search("Fixed", line) or re.search("Temp", line):
|
2013-07-10 16:36:07 +00:00
|
|
|
print "Found line with Fixed or Temp"
|
2013-06-14 06:44:34 +00:00
|
|
|
Temp = float(re.search(numpat, line).group())
|
2013-07-10 16:36:07 +00:00
|
|
|
print "Temperature found in file:", Temp
|
2013-06-14 06:44:34 +00:00
|
|
|
break
|
2013-07-10 16:36:07 +00:00
|
|
|
if Temp == None: raise ValueError
|
2013-06-14 06:44:34 +00:00
|
|
|
except:
|
2013-07-10 16:36:07 +00:00
|
|
|
Temp = QInputDialog.getDouble(self, "No temperature found in data set", "Temperature/K:", value=0.00)[0]
|
|
|
|
# mask the data to values > 0 (loglog plot)
|
|
|
|
mask = (data[:, 1] > 0) & (data[:, 2] > 0) #& (data[:,2]>1e-3) & (data[:,0] > 1e-2)
|
|
|
|
_freq = data[mask, 0]
|
|
|
|
_die_stor = data[mask, 1]
|
|
|
|
_die_loss = data[mask, 2]
|
2014-02-25 13:55:29 +00:00
|
|
|
self.data.set_data(_freq, _die_stor, _die_loss)
|
2013-07-10 16:36:07 +00:00
|
|
|
self.data.meta["T"] = Temp
|
2014-02-25 13:55:29 +00:00
|
|
|
self.fit_boundary.setRegion([N.log10(_freq.min()), N.log10(_freq.max())])
|
2014-03-20 13:30:19 +00:00
|
|
|
self.ui.pgPlotWidget_imag.enableAutoRange()
|
|
|
|
self.ui.pgPlotWidget_real.enableAutoRange()
|
2013-06-14 06:44:34 +00:00
|
|
|
self.updatePlot()
|
2014-03-20 13:30:19 +00:00
|
|
|
self.ui.pgPlotWidget_imag.disableAutoRange()
|
|
|
|
self.ui.pgPlotWidget_real.disableAutoRange()
|
2013-06-14 06:44:34 +00:00
|
|
|
|
2014-02-25 13:55:29 +00:00
|
|
|
|
2013-06-14 06:44:34 +00:00
|
|
|
def updatePlot(self):
|
2014-03-20 14:15:40 +00:00
|
|
|
log10fmin, log10fmax = self.fit_boundary.getRegion()
|
|
|
|
self.data.set_fit_xlimits(10**log10fmin, 10**log10fmax)
|
2014-03-19 23:35:07 +00:00
|
|
|
p0,funcs = [],[]
|
|
|
|
for fcn in self.function_registry.get_registered_functions():
|
|
|
|
p0.extend(fcn.getParameter())
|
|
|
|
funcs.append(fcn.id_string)
|
2014-04-03 18:56:50 +00:00
|
|
|
# calculate parametrized curve
|
2014-03-05 17:30:00 +00:00
|
|
|
self.data.set_fit(p0, funcs)
|
2014-03-18 18:48:39 +00:00
|
|
|
|
|
|
|
# replot data and fit, TODO: replot only if data changed
|
2014-03-05 17:30:00 +00:00
|
|
|
self.data.data_curve_real.setData(self.data.frequency, self.data.epsilon.real)
|
2014-03-18 18:48:39 +00:00
|
|
|
self.data.data_curve_imag.setData(self.data.frequency, self.data.epsilon.imag)
|
2014-03-19 23:35:07 +00:00
|
|
|
|
|
|
|
if len(funcs)> 0:
|
2014-03-20 14:15:40 +00:00
|
|
|
self.data.fitted_curve_real.setData(self.data.frequency_fit, self.data.epsilon_fit.real)
|
|
|
|
self.data.fitted_curve_imag.setData(self.data.frequency_fit, self.data.epsilon_fit.imag)
|
2014-02-25 13:55:29 +00:00
|
|
|
|
2014-03-20 13:30:19 +00:00
|
|
|
else:
|
|
|
|
self.data.fitted_curve_real.setData([N.nan],[N.nan])
|
|
|
|
self.data.fitted_curve_imag.setData([N.nan],[N.nan])
|
2014-03-20 14:15:40 +00:00
|
|
|
|
2014-02-25 13:55:29 +00:00
|
|
|
def sigint_handler(*args):
|
|
|
|
"""Handler for the SIGINT signal (CTRL + C).
|
|
|
|
"""
|
|
|
|
sys.stderr.write('\r')
|
|
|
|
if QMessageBox.question(None, '', "Are you sure you want to quit?",
|
|
|
|
QMessageBox.Yes | QMessageBox.No,
|
2014-03-18 18:48:39 +00:00
|
|
|
QMessageBox.Yes) == QMessageBox.Yes:
|
2014-02-25 13:55:29 +00:00
|
|
|
QApplication.quit()
|
2013-06-14 06:44:34 +00:00
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
signal.signal(signal.SIGINT, sigint_handler)
|
|
|
|
app = QApplication(sys.argv)
|
|
|
|
timer = QTimer()
|
|
|
|
timer.start(1000) # Check every second for Strg-c on Cmd line
|
|
|
|
timer.timeout.connect(lambda: None)
|
|
|
|
main = AppWindow()
|
|
|
|
main.showMaximized()
|
|
|
|
main.raise_()
|
|
|
|
sys.exit(app.exec_())
|