more cleanup

data/Container.py

@@ -0,0 +1,127 @@
+# -*- encoding: utf8 -*-
+
+from math import libyaff
+
+from PyQt4.QtGui import QColor
+import numpy as np
+
+from math.BDSMathlib import id_to_color
+from data.container_base import BaseObject
+from gui import ContainerWidgets
+
+
+__author__ = 'markusro'
+
+
+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

data/container_base.py

@@ -0,0 +1,143 @@
+from PyQt4.QtCore import QObject, pyqtSignal, Qt, pyqtSlot
+from PyQt4.QtGui import QColor
+import numpy as np
+import pyqtgraph as pg
+
+__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._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
+
+    def set_limits(self, limits):
+        self.limits = limits
+        self.updateData()
+
+    @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
+        print c
+        self.data_curve_real.setPen(color=c, style=Qt.DotLine, width=2.5)
+        self.data_curve_imag.setPen(color=c, style=Qt.DotLine, width=2.5)
+
+    @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._frequency = np.logspace(np.log10(self.limits[0]), np.log10(self.limits[1]), 256)
+        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"