Markus Rosenstihl
9ce80f13b5
* fitresults are stored in a better format * started gracedriver to sva data in grace file
258 lines
7.9 KiB
Python
258 lines
7.9 KiB
Python
# -*- encoding: utf8 -*-
|
|
|
|
from PyQt4.QtCore import QObject, Qt, pyqtSignal, pyqtSlot
|
|
from PyQt4.QtGui import QColor
|
|
import numpy as np
|
|
import pyqtgraph as pg
|
|
import ContainerWidgets
|
|
import libyaff
|
|
from BDSMathlib import Functions, id_to_color
|
|
|
|
__author__ = 'markusro'
|
|
|
|
|
|
class BaseObject(QObject):
|
|
changedData = pyqtSignal()
|
|
removeObj = pyqtSignal(QObject)
|
|
|
|
def __init__(self, plt_real=None, plt_imag=None, limits=None):
|
|
super(BaseObject, self).__init__()
|
|
|
|
myPen = pg.mkPen( style=Qt.DotLine,
|
|
width=2.5)
|
|
|
|
self.data_curve_real = pg.PlotDataItem(x=np.array([np.nan]),y=np.array([np.nan]), pen=myPen)
|
|
self.plt_real = plt_real
|
|
self.plt_real.addItem(self.data_curve_real)
|
|
|
|
self.data_curve_imag = pg.PlotDataItem(x=np.array([np.nan]),y=np.array([np.nan]), pen=myPen)
|
|
self.plt_imag = plt_imag
|
|
self.plt_imag.addItem(self.data_curve_imag)
|
|
|
|
self.limits = limits
|
|
|
|
# private varaibles
|
|
#self.functions = Functions()
|
|
|
|
self._color = QColor("white")
|
|
self._id_label = None
|
|
self._id_string = None
|
|
self._widget = None
|
|
self._frequency = np.logspace(np.log10(limits[0]), np.log10(limits[1]), 256)
|
|
self._data = None
|
|
self._func = None
|
|
self._beta = None
|
|
self._sd_beta = None
|
|
self._selector_mask = None
|
|
self._param_number = 0
|
|
self._abort = False
|
|
|
|
@pyqtSlot(bool)
|
|
def abort(self, abort=False):
|
|
self._abort = abort
|
|
|
|
@property
|
|
def param_number(self):
|
|
return self._param_number
|
|
|
|
@param_number.setter
|
|
def param_number(self, num):
|
|
self._param_number = num
|
|
|
|
@property
|
|
def id_string(self):
|
|
return self._id_string
|
|
|
|
@id_string.setter
|
|
def id_string(self, id):
|
|
#self._func = self.functions.get_function(id)
|
|
self._id_string = id
|
|
|
|
|
|
@property
|
|
def id_label(self):
|
|
return self._id_label
|
|
|
|
@id_label.setter
|
|
def id_label(self, id):
|
|
#self._func = self.functions.get_function(id)
|
|
self._func = self.function
|
|
self._id_label = id
|
|
|
|
@property
|
|
def color(self):
|
|
return self._color
|
|
|
|
@color.setter
|
|
def color(self, c):
|
|
self._color = c
|
|
self.data_curve_real.setPen(c)
|
|
self.data_curve_imag.setPen(c)
|
|
|
|
@property
|
|
def widget(self):
|
|
return self._widget
|
|
|
|
@widget.setter
|
|
def widget(self, wdgt):
|
|
self._widget = wdgt
|
|
self._widget.changedTable.connect(self.updateData) # TODO better to use self.setParameter
|
|
self.removeObj.connect(self._widget.deleteLater)
|
|
self._widget.removeMe.connect(self.removeMe)
|
|
|
|
def getParameter(self):
|
|
p = self.widget.getTable() # TODO ugly ... should return self._beta etc ...?
|
|
return p
|
|
|
|
def getFixed(self):
|
|
p = self.widget.fixedParameter()
|
|
return p
|
|
|
|
def setParameter(self, beta, sd_beta=None):
|
|
self._beta = beta
|
|
self._sd_beta = sd_beta
|
|
self.widget.updateTable(beta, sd_beta)
|
|
self.updateData()
|
|
|
|
def get_data(self):
|
|
return self._frequency, self._data
|
|
|
|
def removeMe(self):
|
|
self.plt_imag.removeItem(self.data_curve_imag)
|
|
self.plt_real.removeItem(self.data_curve_real)
|
|
self.removeObj.emit(self)
|
|
self.changedData.emit()
|
|
|
|
def updateData(self):
|
|
self._data = self._func(self.getParameter(), self._frequency)
|
|
self.data_curve_real.setData(x=self._frequency, y=self._data[0])
|
|
self.data_curve_imag.setData(x=self._frequency, y=self._data[1])
|
|
self.changedData.emit()
|
|
|
|
def resampleData(self, x):
|
|
data = self._func(self.getParameter(), x)
|
|
return np.array([x,data[0],data[1]]).T
|
|
|
|
|
|
def clearData(self):
|
|
self.data_curve_real.setData(x=[np.nan], y=[np.nan])
|
|
self.data_curve_imag.setData(x=[np.nan], y=[np.nan])
|
|
|
|
def function(self,p,x):
|
|
if self._abort: raise StopIteration
|
|
#raise NotImplementedError, "This needs to be implemented in your subclass"
|
|
|
|
|
|
class Conductivity(BaseObject):
|
|
def __init__( self, plt_imag=None, plt_real=None, limits=None ):
|
|
super(Conductivity, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
|
|
self.widget = ContainerWidgets.ConductivityWidget()
|
|
self.color = QColor("blue")
|
|
self.id_label = "Cond."
|
|
self.id_string = "cond"
|
|
|
|
self.param_number = 3
|
|
|
|
def function(self, p, x ):
|
|
om = 2*np.pi*x
|
|
sgma, isgma, n = p
|
|
cond = sgma/(om**n) + isgma/(1j*om**n) # Jonscher (Universal Dielectric Response: e",e' prop sigma/omega**n
|
|
cplx = np.array([cond.real, -cond.imag])
|
|
return cplx
|
|
|
|
|
|
class PowerComplex(BaseObject):
|
|
def __init__( self, plt_real=None, plt_imag=None, limits=None ):
|
|
super(PowerComplex, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
|
|
self.widget = ContainerWidgets.PowerLawWidget()
|
|
self.color = QColor("#ff44c4")
|
|
self.id_label = 'Power Law'
|
|
self.id_string = "pwr"
|
|
self.param_number = 2
|
|
|
|
def function( self, p, x ):
|
|
BaseObject.function(self,p,x)
|
|
om = 2*np.pi*x
|
|
sgma,n = p
|
|
power = sgma/(om*1j)**n
|
|
cplx = np.array([power.real, -power.imag])
|
|
return cplx
|
|
|
|
|
|
class Static(BaseObject):
|
|
def __init__( self, plt_real=None, plt_imag=None, limits=None ):
|
|
super(Static, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
|
|
self.widget = ContainerWidgets.StaticWidget()
|
|
self.color = QColor('#FF0F13')
|
|
self.id_label = u'ε(∞)'
|
|
self.id_string = "eps_infty"
|
|
self.param_number = 1
|
|
|
|
def function( self, p, x ):
|
|
BaseObject.function(self,p,x)
|
|
|
|
eps_inf = p[0]
|
|
static = np.ones( (2,x.size) )*eps_inf
|
|
static[1,:] *= 0 # set imag part zero
|
|
return static
|
|
|
|
|
|
class Peak(BaseObject):
|
|
def __init__( self, id_num=None, plt_real=None, plt_imag=None, limits=None ):
|
|
super(Peak, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
|
|
self.widget = ContainerWidgets.PeakWidget()
|
|
self.widget.setId(id_num)
|
|
self.color = id_to_color(id_num)
|
|
self.widget.setColor(self.color)
|
|
self.id_num = id_num
|
|
self.id_label = "Hav-Neg"
|
|
self.id_string = "hn"
|
|
self.param_number = 4
|
|
|
|
def function( self, p, x ):
|
|
BaseObject.function(self,p,x)
|
|
eps,t,a,b = p
|
|
om = 2*np.pi*x
|
|
hn = eps/(1+(1j*om*t)**a)**b
|
|
cplx = np.array([hn.real, -hn.imag])
|
|
return cplx
|
|
|
|
|
|
class YAFF(BaseObject):
|
|
def __init__( self, plt_real=None, plt_imag=None, limits=None ):
|
|
super(YAFF, self).__init__(plt_real=plt_real, plt_imag=plt_imag, limits=limits)
|
|
self.widget = ContainerWidgets.YaffWidget()
|
|
self.widget.on_model_changed.connect(self.change_model)
|
|
self.widget.configuration_changed.connect(self.change_configuration)
|
|
self.color = QColor(32, 120, 29, int(255*0.82))
|
|
self._libyaff = libyaff.Yaff(self.widget.getYaffType())
|
|
self.id_label = self._libyaff.label
|
|
self.id_string = "yaff"
|
|
self._param_number = self._libyaff.params
|
|
self._selector_mask = self.widget.selector_mask
|
|
|
|
@property
|
|
def param_number(self):
|
|
return self._param_number
|
|
|
|
@param_number.setter
|
|
def param_number(self, num=None):
|
|
self._param_number = self._libyaff.params
|
|
|
|
def change_configuration(self, t_list, tau_list):
|
|
self._libyaff.dist_tau = tau_list
|
|
self._libyaff.time_points = t_list
|
|
self.updateData()
|
|
|
|
def change_model(self):
|
|
self._libyaff = libyaff.Yaff(self.widget.getYaffType())
|
|
self._selector_mask = self.widget.selector_mask
|
|
self.id_label = self._libyaff.label
|
|
self.param_number = self._libyaff.params
|
|
self.updateData()
|
|
|
|
def function( self, p, x ):
|
|
BaseObject.function(self,p,x)
|
|
ya = self._libyaff.loss( p, x)
|
|
cplx = np.array([ya.imag, ya.real])
|
|
return cplx |